[BACK]Return to elf32-metag.c CVS log [TXT][DIR] Up to [cvs.NetBSD.org] / src / external / gpl3 / binutils.old / dist / bfd

Annotation of src/external/gpl3/binutils.old/dist/bfd/elf32-metag.c, Revision 1.1.1.4

1.1       christos    1: /* Meta support for 32-bit ELF
1.1.1.4 ! christos    2:    Copyright (C) 2013-2020 Free Software Foundation, Inc.
1.1       christos    3:    Contributed by Imagination Technologies Ltd.
                      4:
                      5:    This file is part of BFD, the Binary File Descriptor library.
                      6:
                      7:    This program is free software; you can redistribute it and/or modify
                      8:    it under the terms of the GNU General Public License as published by
                      9:    the Free Software Foundation; either version 3 of the License, or
                     10:    (at your option) any later version.
                     11:
                     12:    This program is distributed in the hope that it will be useful,
                     13:    but WITHOUT ANY WARRANTY; without even the implied warranty of
                     14:    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
                     15:    GNU General Public License for more details.
                     16:
                     17:    You should have received a copy of the GNU General Public License
                     18:    along with this program; if not, write to the Free Software
                     19:    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
                     20:    MA 02110-1301, USA.  */
                     21:
                     22: #include "sysdep.h"
                     23: #include "bfd.h"
                     24: #include "libbfd.h"
                     25: #include "elf-bfd.h"
                     26: #include "elf32-metag.h"
                     27: #include "elf/metag.h"
                     28:
                     29: #define GOT_ENTRY_SIZE 4
                     30: #define ELF_DYNAMIC_INTERPRETER "/lib/ld-uClibc.so.0"
                     31:
                     32: /* ABI version:
                     33:     0 - original
                     34:     1 - with GOT offset */
                     35: #define METAG_ELF_ABI_VERSION 1
                     36:
                     37: static const unsigned int plt0_entry[] =
                     38:   {
                     39:     0x02000005, /* MOVT D0Re0, #HI(GOT+4) */
                     40:     0x02000000, /* ADD  D0Re0, D0Re0, #LO(GOT+4) */
                     41:     0xb70001e3, /* SETL [A0StP++], D0Re0, D1Re0 */
                     42:     0xc600012a, /* GETD PC, [D0Re0+#4] */
                     43:     0xa0fffffe  /* NOP */
                     44:   };
                     45:
                     46: static const unsigned int plt0_pic_entry[] =
                     47:   {
                     48:     0x82900001, /* ADDT A0.2, CPC0, #0 */
                     49:     0x82100000, /* ADD  A0.2, A0.2, #0 */
                     50:     0xa3100c20, /* MOV  D0Re0, A0.2 */
                     51:     0xb70001e3, /* SETL [A0StP++], D0Re0, D1Re0 */
                     52:     0xc600012a, /* GETD PC, [D0Re0+#4] */
                     53:   };
                     54:
                     55: static const unsigned int plt_entry[] =
                     56:   {
                     57:     0x82100005, /* MOVT A0.2, #HI(GOT+off) */
                     58:     0x82100000, /* ADD  A0.2, A0.2, #LO(GOT+off) */
                     59:     0xc600806a, /* GETD PC, [A0.2] */
                     60:     0x03000004, /* MOV  D1Re0, #LO(offset) */
                     61:     0xa0000000  /* B    PLT0 */
                     62:   };
                     63:
                     64: static const unsigned int plt_pic_entry[] =
                     65:   {
                     66:     0x82900001, /* ADDT A0.2, CPC0, #HI(GOT+off) */
                     67:     0x82100000, /* ADD  A0.2, A0.2, #LO(GOT+off) */
                     68:     0xc600806a, /* GETD PC, [A0.2] */
                     69:     0x03000004, /* MOV  D1Re0, #LO(offset) */
                     70:     0xa0000000  /* B    PLT0 */
                     71:   };
                     72:
                     73: /* Variable names follow a coding style.
                     74:    Please follow this (Apps Hungarian) style:
                     75:
1.1.1.3   christos   76:    Structure/Variable             Prefix
                     77:    elf_link_hash_table            "etab"
                     78:    elf_link_hash_entry            "eh"
1.1       christos   79:
1.1.1.3   christos   80:    elf_metag_link_hash_table      "htab"
                     81:    elf_metag_link_hash_entry      "hh"
1.1       christos   82:
1.1.1.3   christos   83:    bfd_link_hash_table            "btab"
                     84:    bfd_link_hash_entry            "bh"
1.1       christos   85:
                     86:    bfd_hash_table containing stubs "bstab"
1.1.1.3   christos   87:    elf_metag_stub_hash_entry      "hsh"
1.1       christos   88:
                     89:    Always remember to use GNU Coding Style.  */
                     90:
                     91: #define PLT_ENTRY_SIZE sizeof(plt_entry)
                     92:
                     93: static reloc_howto_type elf_metag_howto_table[] =
                     94: {
                     95:   /* High order 16 bit absolute.  */
                     96:   HOWTO (R_METAG_HIADDR16,     /* type */
                     97:         16,                    /* rightshift */
                     98:         2,                     /* size (0 = byte, 1 = short, 2 = long) */
                     99:         16,                    /* bitsize */
                    100:         FALSE,                 /* pc_relative */
                    101:         3,                     /* bitpos */
                    102:         complain_overflow_dont, /* complain_on_overflow */
                    103:         bfd_elf_generic_reloc, /* special_function */
                    104:         "R_METAG_HIADDR16",    /* name */
                    105:         FALSE,                 /* partial_inplace */
                    106:         0,                     /* src_mask */
                    107:         0x0007fff8,            /* dst_mask */
                    108:         FALSE),                /* pcrel_offset */
                    109:
                    110:   /* Low order 16 bit absolute.  */
                    111:   HOWTO (R_METAG_LOADDR16,     /* type */
                    112:         0,                     /* rightshift */
                    113:         2,                     /* size (0 = byte, 1 = short, 2 = long) */
                    114:         16,                    /* bitsize */
                    115:         FALSE,                 /* pc_relative */
                    116:         3,                     /* bitpos */
                    117:         complain_overflow_dont,/* complain_on_overflow */
                    118:         bfd_elf_generic_reloc, /* special_function */
                    119:         "R_METAG_LOADDR16",    /* name */
                    120:         FALSE,                 /* partial_inplace */
                    121:         0,                     /* src_mask */
                    122:         0x0007fff8,            /* dst_mask */
                    123:         FALSE),                /* pcrel_offset */
                    124:
                    125:   /* 32 bit absolute.  */
                    126:   HOWTO (R_METAG_ADDR32,       /* type */
                    127:         0,                     /* rightshift */
                    128:         2,                     /* size (0 = byte, 1 = short, 2 = long) */
                    129:         32,                    /* bitsize */
                    130:         FALSE,                 /* pc_relative */
                    131:         0,                     /* bitpos */
                    132:         complain_overflow_bitfield, /* complain_on_overflow */
                    133:         bfd_elf_generic_reloc, /* special_function */
                    134:         "R_METAG_ADDR32",      /* name */
                    135:         FALSE,                 /* partial_inplace */
                    136:         0x00000000,            /* src_mask */
                    137:         0xffffffff,            /* dst_mask */
                    138:         FALSE),                /* pcrel_offset */
                    139:
                    140:   /* No relocation.  */
                    141:   HOWTO (R_METAG_NONE,         /* type */
                    142:         0,                     /* rightshift */
                    143:         3,                     /* size (0 = byte, 1 = short, 2 = long) */
                    144:         0,                     /* bitsize */
                    145:         FALSE,                 /* pc_relative */
                    146:         0,                     /* bitpos */
                    147:         complain_overflow_dont, /* complain_on_overflow */
                    148:         bfd_elf_generic_reloc, /* special_function */
                    149:         "R_METAG_NONE",        /* name */
                    150:         FALSE,                 /* partial_inplace */
                    151:         0,                     /* src_mask */
                    152:         0,                     /* dst_mask */
                    153:         FALSE),                /* pcrel_offset */
                    154:
                    155:   /* 19 bit pc relative */
                    156:   HOWTO (R_METAG_RELBRANCH,    /* type */
                    157:         2,                     /* rightshift */
                    158:         2,                     /* size (0 = byte, 1 = short, 2 = long) */
                    159:         19,                    /* bitsize */
                    160:         TRUE,                  /* pc_relative */
                    161:         5,                     /* bitpos */
                    162:         complain_overflow_signed, /* complain_on_overflow */
                    163:         bfd_elf_generic_reloc, /* special_function */
                    164:         "R_METAG_RELBRANCH",   /* name */
                    165:         FALSE,                 /* partial_inplace */
                    166:         0,                     /* src_mask */
                    167:         0x00ffffe0,            /* dst_mask */
                    168:         FALSE),                /* pcrel_offset */
                    169:
                    170:   /* GET/SET offset */
                    171:   HOWTO (R_METAG_GETSETOFF,    /* type */
                    172:         0,                     /* rightshift */
                    173:         1,                     /* size (0 = byte, 1 = short, 2 = long) */
                    174:         12,                    /* bitsize */
                    175:         FALSE,                 /* pc_relative */
                    176:         7,                     /* bitpos */
                    177:         complain_overflow_dont, /* complain_on_overflow */
                    178:         bfd_elf_generic_reloc, /* special_function */
                    179:         "R_METAG_GETSETOFF",   /* name */
                    180:         FALSE,                 /* partial_inplace */
                    181:         0,                     /* src_mask */
                    182:         0,                     /* dst_mask */
                    183:         FALSE),                /* pcrel_offset */
                    184:
                    185:   EMPTY_HOWTO (6),
                    186:   EMPTY_HOWTO (7),
                    187:   EMPTY_HOWTO (8),
                    188:   EMPTY_HOWTO (9),
                    189:   EMPTY_HOWTO (10),
                    190:   EMPTY_HOWTO (11),
                    191:   EMPTY_HOWTO (12),
                    192:   EMPTY_HOWTO (13),
                    193:   EMPTY_HOWTO (14),
                    194:   EMPTY_HOWTO (15),
                    195:   EMPTY_HOWTO (16),
                    196:   EMPTY_HOWTO (17),
                    197:   EMPTY_HOWTO (18),
                    198:   EMPTY_HOWTO (19),
                    199:   EMPTY_HOWTO (20),
                    200:   EMPTY_HOWTO (21),
                    201:   EMPTY_HOWTO (22),
                    202:   EMPTY_HOWTO (23),
                    203:   EMPTY_HOWTO (24),
                    204:   EMPTY_HOWTO (25),
                    205:   EMPTY_HOWTO (26),
                    206:   EMPTY_HOWTO (27),
                    207:   EMPTY_HOWTO (28),
                    208:   EMPTY_HOWTO (29),
                    209:
                    210:   HOWTO (R_METAG_GNU_VTINHERIT, /* type */
                    211:         0,                     /* rightshift */
                    212:         2,                     /* size (0 = byte, 1 = short, 2 = long) */
                    213:         0,                     /* bitsize */
                    214:         FALSE,         /* pc_relative */
                    215:         0,                     /* bitpos */
                    216:         complain_overflow_dont, /* complain_on_overflow */
                    217:         NULL,                  /* special_function */
                    218:         "R_METAG_GNU_VTINHERIT", /* name */
                    219:         FALSE,         /* partial_inplace */
                    220:         0,                     /* src_mask */
                    221:         0,                     /* dst_mask */
                    222:         FALSE),                /* pcrel_offset */
                    223:
                    224:   HOWTO (R_METAG_GNU_VTENTRY,  /* type */
                    225:         0,                     /* rightshift */
                    226:         2,                     /* size (0 = byte, 1 = short, 2 = long) */
                    227:         0,                     /* bitsize */
                    228:         FALSE,                 /* pc_relative */
                    229:         0,                     /* bitpos */
                    230:         complain_overflow_dont, /* complain_on_overflow */
                    231:         _bfd_elf_rel_vtable_reloc_fn, /* special_function */
                    232:         "R_METAG_GNU_VTENTRY",  /* name */
                    233:         FALSE,                 /* partial_inplace */
                    234:         0,                     /* src_mask */
                    235:         0,                     /* dst_mask */
                    236:         FALSE),                /* pcrel_offset */
                    237:
                    238:   /* High order 16 bit GOT offset */
                    239:   HOWTO (R_METAG_HI16_GOTOFF,  /* type */
                    240:         16,                    /* rightshift */
                    241:         2,                     /* size (0 = byte, 1 = short, 2 = long) */
                    242:         16,                    /* bitsize */
                    243:         FALSE,                 /* pc_relative */
                    244:         3,                     /* bitpos */
                    245:         complain_overflow_dont, /* complain_on_overflow */
                    246:         bfd_elf_generic_reloc, /* special_function */
                    247:         "R_METAG_HI16_GOTOFF", /* name */
                    248:         FALSE,                 /* partial_inplace */
                    249:         0,                     /* src_mask */
                    250:         0x0007fff8,            /* dst_mask */
                    251:         FALSE),                /* pcrel_offset */
                    252:
                    253:   /* Low order 16 bit GOT offset */
                    254:   HOWTO (R_METAG_LO16_GOTOFF,  /* type */
                    255:         0,                     /* rightshift */
                    256:         2,                     /* size (0 = byte, 1 = short, 2 = long) */
                    257:         16,                    /* bitsize */
                    258:         FALSE,                 /* pc_relative */
                    259:         3,                     /* bitpos */
                    260:         complain_overflow_dont, /* complain_on_overflow */
                    261:         bfd_elf_generic_reloc, /* special_function */
                    262:         "R_METAG_LO16_GOTOFF", /* name */
                    263:         FALSE,                 /* partial_inplace */
                    264:         0,                     /* src_mask */
                    265:         0x0007fff8,            /* dst_mask */
                    266:         FALSE),                /* pcrel_offset */
                    267:
                    268:   /* GET/SET GOT offset */
                    269:   HOWTO (R_METAG_GETSET_GOTOFF, /* type */
                    270:         0,                     /* rightshift */
                    271:         1,                     /* size (0 = byte, 1 = short, 2 = long) */
                    272:         12,                    /* bitsize */
                    273:         FALSE,                 /* pc_relative */
                    274:         7,                     /* bitpos */
                    275:         complain_overflow_dont, /* complain_on_overflow */
                    276:         bfd_elf_generic_reloc, /* special_function */
                    277:         "R_METAG_GETSET_GOTOFF", /* name */
                    278:         FALSE,                 /* partial_inplace */
                    279:         0,                     /* src_mask */
                    280:         0,                     /* dst_mask */
                    281:         FALSE),                /* pcrel_offset */
                    282:
                    283:   /* GET/SET GOT relative */
                    284:   HOWTO (R_METAG_GETSET_GOT,   /* type */
                    285:         0,                     /* rightshift */
                    286:         1,                     /* size (0 = byte, 1 = short, 2 = long) */
                    287:         12,                    /* bitsize */
                    288:         FALSE,                 /* pc_relative */
                    289:         7,                     /* bitpos */
                    290:         complain_overflow_dont, /* complain_on_overflow */
                    291:         bfd_elf_generic_reloc, /* special_function */
                    292:         "R_METAG_GETSET_GOT",  /* name */
                    293:         FALSE,                 /* partial_inplace */
                    294:         0,                     /* src_mask */
                    295:         0,                     /* dst_mask */
                    296:         FALSE),                /* pcrel_offset */
                    297:
                    298:   /* High order 16 bit GOT reference */
                    299:   HOWTO (R_METAG_HI16_GOTPC,   /* type */
                    300:         16,                    /* rightshift */
                    301:         2,                     /* size (0 = byte, 1 = short, 2 = long) */
                    302:         16,                    /* bitsize */
                    303:         FALSE,                 /* pc_relative */
                    304:         3,                     /* bitpos */
                    305:         complain_overflow_dont, /* complain_on_overflow */
                    306:         bfd_elf_generic_reloc, /* special_function */
                    307:         "R_METAG_HI16_GOTPC",  /* name */
                    308:         FALSE,                 /* partial_inplace */
                    309:         0,                     /* src_mask */
                    310:         0x0007fff8,            /* dst_mask */
                    311:         FALSE),                /* pcrel_offset */
                    312:
                    313:   /* Low order 16 bit GOT reference */
                    314:   HOWTO (R_METAG_LO16_GOTPC,   /* type */
                    315:         0,                     /* rightshift */
                    316:         2,                     /* size (0 = byte, 1 = short, 2 = long) */
                    317:         16,                    /* bitsize */
                    318:         FALSE,                 /* pc_relative */
                    319:         3,                     /* bitpos */
                    320:         complain_overflow_dont, /* complain_on_overflow */
                    321:         bfd_elf_generic_reloc, /* special_function */
                    322:         "R_METAG_LO16_GOTPC",  /* name */
                    323:         FALSE,                 /* partial_inplace */
                    324:         0,                     /* src_mask */
                    325:         0x0007fff8,            /* dst_mask */
                    326:         FALSE),                /* pcrel_offset */
                    327:
                    328:   /* High order 16 bit PLT */
                    329:   HOWTO (R_METAG_HI16_PLT,     /* type */
                    330:         16,                    /* rightshift */
                    331:         2,                     /* size (0 = byte, 1 = short, 2 = long) */
                    332:         16,                    /* bitsize */
                    333:         FALSE,                 /* pc_relative */
                    334:         3,                     /* bitpos */
                    335:         complain_overflow_dont, /* complain_on_overflow */
                    336:         bfd_elf_generic_reloc, /* special_function */
                    337:         "R_METAG_HI16_PLT",    /* name */
                    338:         FALSE,                 /* partial_inplace */
                    339:         0,                     /* src_mask */
                    340:         0x0007fff8,            /* dst_mask */
                    341:         FALSE),                /* pcrel_offset */
                    342:
                    343:   /* Low order 16 bit PLT */
                    344:   HOWTO (R_METAG_LO16_PLT,     /* type */
                    345:         0,                     /* rightshift */
                    346:         2,                     /* size (0 = byte, 1 = short, 2 = long) */
                    347:         16,                    /* bitsize */
                    348:         FALSE,                 /* pc_relative */
                    349:         3,                     /* bitpos */
                    350:         complain_overflow_dont, /* complain_on_overflow */
                    351:         bfd_elf_generic_reloc, /* special_function */
                    352:         "R_METAG_LO16_PLT",    /* name */
                    353:         FALSE,                 /* partial_inplace */
                    354:         0,                     /* src_mask */
                    355:         0xffffffff,            /* dst_mask */
                    356:         FALSE),                /* pcrel_offset */
                    357:
                    358:   HOWTO (R_METAG_RELBRANCH_PLT, /* type */
                    359:         2,                     /* rightshift */
                    360:         2,                     /* size (0 = byte, 1 = short, 2 = long) */
                    361:         19,                    /* bitsize */
                    362:         TRUE,                  /* pc_relative */
                    363:         5,                     /* bitpos */
                    364:         complain_overflow_signed, /* complain_on_overflow */
                    365:         bfd_elf_generic_reloc, /* special_function */
                    366:         "R_METAG_RELBRANCH_PLT", /* name */
                    367:         FALSE,                 /* partial_inplace */
                    368:         0,                     /* src_mask */
                    369:         0x00ffffe0,            /* dst_mask */
                    370:         FALSE),                /* pcrel_offset */
                    371:
                    372:   /* Dummy relocs used by the linker internally.  */
                    373:   HOWTO (R_METAG_GOTOFF,       /* type */
                    374:         0,                     /* rightshift */
                    375:         2,                     /* size (0 = byte, 1 = short, 2 = long) */
                    376:         32,                    /* bitsize */
                    377:         FALSE,                 /* pc_relative */
                    378:         0,                     /* bitpos */
                    379:         complain_overflow_bitfield, /* complain_on_overflow */
                    380:         bfd_elf_generic_reloc, /* special_function */
                    381:         "R_METAG_GOTOFF",      /* name */
                    382:         FALSE,                 /* partial_inplace */
                    383:         0xffffffff,            /* src_mask */
                    384:         0xffffffff,            /* dst_mask */
                    385:         FALSE),                /* pcrel_offset */
                    386:
                    387:   HOWTO (R_METAG_PLT,          /* type */
                    388:         0,                     /* rightshift */
                    389:         2,                     /* size (0 = byte, 1 = short, 2 = long) */
                    390:         32,                    /* bitsize */
                    391:         FALSE,                 /* pc_relative */
                    392:         0,                     /* bitpos */
                    393:         complain_overflow_bitfield, /* complain_on_overflow */
                    394:         bfd_elf_generic_reloc, /* special_function */
                    395:         "R_METAG_GOTOFF",      /* name */
                    396:         FALSE,                 /* partial_inplace */
                    397:         0xffffffff,            /* src_mask */
                    398:         0xffffffff,            /* dst_mask */
                    399:         FALSE),                /* pcrel_offset */
                    400:
                    401:   /* This is used only by the dynamic linker.  The symbol should exist
                    402:      both in the object being run and in some shared library.  The
                    403:      dynamic linker copies the data addressed by the symbol from the
                    404:      shared library into the object, because the object being
                    405:      run has to have the data at some particular address.  */
                    406:   HOWTO (R_METAG_COPY,         /* type */
                    407:         0,                     /* rightshift */
                    408:         2,                     /* size (0 = byte, 1 = short, 2 = long) */
                    409:         32,                    /* bitsize */
                    410:         FALSE,                 /* pc_relative */
                    411:         0,                     /* bitpos */
                    412:         complain_overflow_bitfield, /* complain_on_overflow */
                    413:         bfd_elf_generic_reloc, /* special_function */
                    414:         "R_METAG_COPY",        /* name */
                    415:         FALSE,                 /* partial_inplace */
                    416:         0xffffffff,            /* src_mask */
                    417:         0xffffffff,            /* dst_mask */
                    418:         FALSE),                /* pcrel_offset */
                    419:
                    420:   /* Marks a procedure linkage table entry for a symbol.  */
                    421:   HOWTO (R_METAG_JMP_SLOT,     /* type */
                    422:         0,                     /* rightshift */
                    423:         2,                     /* size (0 = byte, 1 = short, 2 = long) */
                    424:         32,                    /* bitsize */
                    425:         FALSE,                 /* pc_relative */
                    426:         0,                     /* bitpos */
                    427:         complain_overflow_bitfield, /* complain_on_overflow */
                    428:         bfd_elf_generic_reloc, /* special_function */
                    429:         "R_METAG_JMP_SLOT",    /* name */
                    430:         FALSE,                 /* partial_inplace */
                    431:         0xffffffff,            /* src_mask */
                    432:         0xffffffff,            /* dst_mask */
                    433:         FALSE),                /* pcrel_offset */
                    434:
                    435:   /* Used only by the dynamic linker.  When the object is run, this
                    436:      longword is set to the load address of the object, plus the
                    437:      addend.  */
                    438:   HOWTO (R_METAG_RELATIVE,     /* type */
                    439:         0,                     /* rightshift */
                    440:         2,                     /* size (0 = byte, 1 = short, 2 = long) */
                    441:         32,                    /* bitsize */
                    442:         FALSE,                 /* pc_relative */
                    443:         0,                     /* bitpos */
                    444:         complain_overflow_bitfield, /* complain_on_overflow */
                    445:         bfd_elf_generic_reloc, /* special_function */
                    446:         "R_METAG_RELATIVE",    /* name */
                    447:         FALSE,                 /* partial_inplace */
                    448:         0xffffffff,            /* src_mask */
                    449:         0xffffffff,            /* dst_mask */
                    450:         FALSE),                /* pcrel_offset */
                    451:
                    452:   HOWTO (R_METAG_GLOB_DAT,     /* type */
                    453:         0,                     /* rightshift */
                    454:         2,                     /* size (0 = byte, 1 = short, 2 = long) */
                    455:         32,                    /* bitsize */
                    456:         FALSE,                 /* pc_relative */
                    457:         0,                     /* bitpos */
                    458:         complain_overflow_bitfield, /* complain_on_overflow */
                    459:         bfd_elf_generic_reloc, /* special_function */
                    460:         "R_METAG_GLOB_DAT",    /* name */
                    461:         FALSE,                 /* partial_inplace */
                    462:         0xffffffff,            /* src_mask */
                    463:         0xffffffff,            /* dst_mask */
                    464:         FALSE),                /* pcrel_offset */
                    465:
                    466:   HOWTO (R_METAG_TLS_GD,       /* type */
                    467:         0,                     /* rightshift */
                    468:         2,                     /* size (0 = byte, 1 = short, 2 = long) */
                    469:         16,                    /* bitsize */
                    470:         FALSE,                 /* pc_relative */
                    471:         3,                     /* bitpos */
                    472:         complain_overflow_dont, /* complain_on_overflow */
                    473:         bfd_elf_generic_reloc, /* special_function */
                    474:         "R_METAG_TLS_GD",      /* name */
                    475:         FALSE,                 /* partial_inplace */
                    476:         0,                     /* src_mask */
                    477:         0x0007fff8,            /* dst_mask */
                    478:         FALSE),                /* pcrel_offset */
                    479:
                    480:   HOWTO (R_METAG_TLS_LDM,      /* type */
                    481:         0,                     /* rightshift */
                    482:         2,                     /* size (0 = byte, 1 = short, 2 = long) */
                    483:         16,                    /* bitsize */
                    484:         FALSE,                 /* pc_relative */
                    485:         3,                     /* bitpos */
                    486:         complain_overflow_bitfield, /* complain_on_overflow */
                    487:         bfd_elf_generic_reloc, /* special_function */
                    488:         "R_METAG_TLS_LDM",     /* name */
                    489:         FALSE,                 /* partial_inplace */
                    490:         0,                     /* src_mask */
                    491:         0x0007fff8,            /* dst_mask */
                    492:         FALSE),                /* pcrel_offset */
                    493:
                    494:   HOWTO (R_METAG_TLS_LDO_HI16, /* type */
                    495:         16,                    /* rightshift */
                    496:         2,                     /* size (0 = byte, 1 = short, 2 = long) */
                    497:         16,                    /* bitsize */
                    498:         FALSE,                 /* pc_relative */
                    499:         3,                     /* bitpos */
                    500:         complain_overflow_bitfield, /* complain_on_overflow */
                    501:         bfd_elf_generic_reloc, /* special_function */
                    502:         "R_METAG_TLS_LDO_HI16", /* name */
                    503:         FALSE,                 /* partial_inplace */
                    504:         0,                     /* src_mask */
                    505:         0x0007fff8,            /* dst_mask */
                    506:         FALSE),                /* pcrel_offset */
                    507:
                    508:   HOWTO (R_METAG_TLS_LDO_LO16, /* type */
                    509:         0,                     /* rightshift */
                    510:         2,                     /* size (0 = byte, 1 = short, 2 = long) */
                    511:         16,                    /* bitsize */
                    512:         FALSE,                 /* pc_relative */
                    513:         3,                     /* bitpos */
                    514:         complain_overflow_bitfield, /* complain_on_overflow */
                    515:         bfd_elf_generic_reloc, /* special_function */
                    516:         "R_METAG_TLS_LDO_LO16", /* name */
                    517:         FALSE,                 /* partial_inplace */
                    518:         0,                     /* src_mask */
                    519:         0x0007fff8,            /* dst_mask */
                    520:         FALSE),                /* pcrel_offset */
                    521:
                    522:   /* Dummy reloc used by the linker internally.  */
                    523:   HOWTO (R_METAG_TLS_LDO,      /* type */
                    524:         0,                     /* rightshift */
                    525:         2,                     /* size (0 = byte, 1 = short, 2 = long) */
                    526:         16,                    /* bitsize */
                    527:         FALSE,                 /* pc_relative */
                    528:         3,                     /* bitpos */
                    529:         complain_overflow_bitfield, /* complain_on_overflow */
                    530:         bfd_elf_generic_reloc, /* special_function */
                    531:         "R_METAG_TLS_LDO",     /* name */
                    532:         FALSE,                 /* partial_inplace */
                    533:         0,                     /* src_mask */
                    534:         0x0007fff8,            /* dst_mask */
                    535:         FALSE),                /* pcrel_offset */
                    536:
                    537:   HOWTO (R_METAG_TLS_IE,       /* type */
                    538:         2,                     /* rightshift */
                    539:         2,                     /* size (0 = byte, 1 = short, 2 = long) */
                    540:         12,                    /* bitsize */
                    541:         FALSE,                 /* pc_relative */
                    542:         7,                     /* bitpos */
                    543:         complain_overflow_dont, /* complain_on_overflow */
                    544:         bfd_elf_generic_reloc, /* special_function */
                    545:         "R_METAG_TLS_IE",      /* name */
                    546:         FALSE,                 /* partial_inplace */
                    547:         0,                     /* src_mask */
                    548:         0x0007ff80,            /* dst_mask */
                    549:         FALSE),                /* pcrel_offset */
                    550:
                    551:   /* Dummy reloc used by the linker internally.  */
                    552:   HOWTO (R_METAG_TLS_IENONPIC,  /* type */
                    553:         0,                     /* rightshift */
                    554:         2,                     /* size (0 = byte, 1 = short, 2 = long) */
                    555:         16,                    /* bitsize */
                    556:         FALSE,                 /* pc_relative */
                    557:         3,                     /* bitpos */
                    558:         complain_overflow_dont, /* complain_on_overflow */
                    559:         bfd_elf_generic_reloc, /* special_function */
                    560:         "R_METAG_TLS_IENONPIC", /* name */
                    561:         FALSE,                 /* partial_inplace */
                    562:         0,                     /* src_mask */
                    563:         0x0007fff8,            /* dst_mask */
                    564:         FALSE),                /* pcrel_offset */
                    565:
                    566:   HOWTO (R_METAG_TLS_IENONPIC_HI16,/* type */
                    567:         16,                    /* rightshift */
                    568:         2,                     /* size (0 = byte, 1 = short, 2 = long) */
                    569:         16,                    /* bitsize */
                    570:         FALSE,                 /* pc_relative */
                    571:         3,                     /* bitpos */
                    572:         complain_overflow_dont, /* complain_on_overflow */
                    573:         bfd_elf_generic_reloc, /* special_function */
                    574:         "R_METAG_TLS_IENONPIC_HI16", /* name */
                    575:         FALSE,                 /* partial_inplace */
                    576:         0,                     /* src_mask */
                    577:         0x0007fff8,            /* dst_mask */
                    578:         FALSE),                /* pcrel_offset */
                    579:
                    580:   HOWTO (R_METAG_TLS_IENONPIC_LO16,/* type */
                    581:         0,                     /* rightshift */
                    582:         2,                     /* size (0 = byte, 1 = short, 2 = long) */
                    583:         16,                    /* bitsize */
                    584:         FALSE,                 /* pc_relative */
                    585:         3,                     /* bitpos */
                    586:         complain_overflow_dont, /* complain_on_overflow */
                    587:         bfd_elf_generic_reloc, /* special_function */
                    588:         "R_METAG_TLS_IENONPIC_LO16", /* name */
                    589:         FALSE,                 /* partial_inplace */
                    590:         0,                     /* src_mask */
                    591:         0x0007fff8,            /* dst_mask */
                    592:         FALSE),                /* pcrel_offset */
                    593:
                    594:   HOWTO (R_METAG_TLS_TPOFF,    /* type */
                    595:         0,                     /* rightshift */
                    596:         2,                     /* size (0 = byte, 1 = short, 2 = long) */
                    597:         32,                    /* bitsize */
                    598:         FALSE,                 /* pc_relative */
                    599:         0,                     /* bitpos */
                    600:         complain_overflow_bitfield, /* complain_on_overflow */
                    601:         bfd_elf_generic_reloc, /* special_function */
                    602:         "R_METAG_TLS_TPOFF",   /* name */
                    603:         FALSE,                 /* partial_inplace */
                    604:         0,                     /* src_mask */
                    605:         0xffffffff,            /* dst_mask */
                    606:         FALSE),                /* pcrel_offset */
                    607:
                    608:   HOWTO (R_METAG_TLS_DTPMOD,   /* type */
                    609:         0,                     /* rightshift */
                    610:         2,                     /* size (0 = byte, 1 = short, 2 = long) */
                    611:         32,                    /* bitsize */
                    612:         FALSE,                 /* pc_relative */
                    613:         0,                     /* bitpos */
                    614:         complain_overflow_bitfield, /* complain_on_overflow */
                    615:         bfd_elf_generic_reloc, /* special_function */
                    616:         "R_METAG_TLS_DTPMOD",  /* name */
                    617:         FALSE,                 /* partial_inplace */
                    618:         0,                     /* src_mask */
                    619:         0xffffffff,            /* dst_mask */
                    620:         FALSE),                /* pcrel_offset */
                    621:
                    622:   HOWTO (R_METAG_TLS_DTPOFF,   /* type */
                    623:         0,                     /* rightshift */
                    624:         2,                     /* size (0 = byte, 1 = short, 2 = long) */
                    625:         32,                    /* bitsize */
                    626:         FALSE,                 /* pc_relative */
                    627:         0,                     /* bitpos */
                    628:         complain_overflow_bitfield, /* complain_on_overflow */
                    629:         bfd_elf_generic_reloc, /* special_function */
                    630:         "R_METAG_TLS_DTPOFF",  /* name */
                    631:         FALSE,                 /* partial_inplace */
                    632:         0,                     /* src_mask */
                    633:         0xffffffff,            /* dst_mask */
                    634:         FALSE),                /* pcrel_offset */
                    635:
                    636:   /* Dummy reloc used by the linker internally.  */
                    637:   HOWTO (R_METAG_TLS_LE,       /* type */
                    638:         0,                     /* rightshift */
                    639:         2,                     /* size (0 = byte, 1 = short, 2 = long) */
                    640:         32,                    /* bitsize */
                    641:         FALSE,                 /* pc_relative */
                    642:         0,                     /* bitpos */
                    643:         complain_overflow_bitfield, /* complain_on_overflow */
                    644:         bfd_elf_generic_reloc, /* special_function */
                    645:         "R_METAG_TLS_LE",      /* name */
                    646:         FALSE,                 /* partial_inplace */
                    647:         0,                     /* src_mask */
                    648:         0xffffffff,            /* dst_mask */
                    649:         FALSE),                /* pcrel_offset */
                    650:
                    651:   HOWTO (R_METAG_TLS_LE_HI16,  /* type */
                    652:         16,                    /* rightshift */
                    653:         2,                     /* size (0 = byte, 1 = short, 2 = long) */
                    654:         16,                    /* bitsize */
                    655:         FALSE,                 /* pc_relative */
                    656:         3,                     /* bitpos */
                    657:         complain_overflow_dont, /* complain_on_overflow */
                    658:         bfd_elf_generic_reloc, /* special_function */
                    659:         "R_METAG_TLS_LE_HI16", /* name */
                    660:         FALSE,                 /* partial_inplace */
                    661:         0,                     /* src_mask */
                    662:         0x0007fff8,            /* dst_mask */
                    663:         FALSE),                /* pcrel_offset */
                    664:
                    665:   HOWTO (R_METAG_TLS_LE_LO16,  /* type */
                    666:         0,                     /* rightshift */
                    667:         2,                     /* size (0 = byte, 1 = short, 2 = long) */
                    668:         16,                    /* bitsize */
                    669:         FALSE,                 /* pc_relative */
                    670:         3,                     /* bitpos */
                    671:         complain_overflow_dont, /* complain_on_overflow */
                    672:         bfd_elf_generic_reloc, /* special_function */
                    673:         "R_METAG_TLS_LE_LO16", /* name */
                    674:         FALSE,                 /* partial_inplace */
                    675:         0,                     /* src_mask */
                    676:         0x0007fff8,            /* dst_mask */
                    677:         FALSE),                /* pcrel_offset */
                    678:
                    679: };
                    680:
                    681: #define BRANCH_BITS 19
                    682:
                    683: /* The GOT is typically accessed using a [GS]ETD instruction. The size of the
                    684:    immediate offset which can be used in such instructions therefore limits
                    685:    the usable size of the GOT. If the base register for the [GS]ETD (A1LbP)
                    686:    is pointing to the base of the GOT then the size is limited to the maximum
                    687:    11 bits unsigned dword offset, or 2^13 = 0x2000 bytes. However the offset
                    688:    in a [GS]ETD instruction is signed, so by setting the base address register
                    689:    to an offset of that 0x2000 byte maximum unsigned offset from the base of
                    690:    the GOT we can use negative offsets in addition to positive. This
                    691:    effectively doubles the usable GOT size to 0x4000 bytes.  */
                    692: #define GOT_REG_OFFSET 0x2000
                    693:
                    694: struct metag_reloc_map
                    695: {
                    696:   bfd_reloc_code_real_type bfd_reloc_val;
                    697:   unsigned int metag_reloc_val;
                    698: };
                    699:
                    700: static const struct metag_reloc_map metag_reloc_map [] =
                    701:   {
1.1.1.3   christos  702:     { BFD_RELOC_NONE,               R_METAG_NONE },
                    703:     { BFD_RELOC_32,                 R_METAG_ADDR32 },
                    704:     { BFD_RELOC_METAG_HIADDR16,             R_METAG_HIADDR16 },
                    705:     { BFD_RELOC_METAG_LOADDR16,             R_METAG_LOADDR16 },
1.1       christos  706:     { BFD_RELOC_METAG_RELBRANCH,     R_METAG_RELBRANCH },
                    707:     { BFD_RELOC_METAG_GETSETOFF,     R_METAG_GETSETOFF },
1.1.1.3   christos  708:     { BFD_RELOC_VTABLE_INHERIT,             R_METAG_GNU_VTINHERIT },
                    709:     { BFD_RELOC_VTABLE_ENTRY,       R_METAG_GNU_VTENTRY },
                    710:     { BFD_RELOC_METAG_REL8,         R_METAG_REL8 },
                    711:     { BFD_RELOC_METAG_REL16,        R_METAG_REL16 },
1.1       christos  712:     { BFD_RELOC_METAG_HI16_GOTOFF,   R_METAG_HI16_GOTOFF },
                    713:     { BFD_RELOC_METAG_LO16_GOTOFF,   R_METAG_LO16_GOTOFF },
                    714:     { BFD_RELOC_METAG_GETSET_GOTOFF, R_METAG_GETSET_GOTOFF },
                    715:     { BFD_RELOC_METAG_GETSET_GOT,    R_METAG_GETSET_GOT },
                    716:     { BFD_RELOC_METAG_HI16_GOTPC,    R_METAG_HI16_GOTPC },
                    717:     { BFD_RELOC_METAG_LO16_GOTPC,    R_METAG_LO16_GOTPC },
1.1.1.3   christos  718:     { BFD_RELOC_METAG_HI16_PLT,             R_METAG_HI16_PLT },
                    719:     { BFD_RELOC_METAG_LO16_PLT,             R_METAG_LO16_PLT },
1.1       christos  720:     { BFD_RELOC_METAG_RELBRANCH_PLT, R_METAG_RELBRANCH_PLT },
1.1.1.3   christos  721:     { BFD_RELOC_METAG_GOTOFF,       R_METAG_GOTOFF },
                    722:     { BFD_RELOC_METAG_PLT,          R_METAG_PLT },
                    723:     { BFD_RELOC_METAG_COPY,         R_METAG_COPY },
                    724:     { BFD_RELOC_METAG_JMP_SLOT,             R_METAG_JMP_SLOT },
                    725:     { BFD_RELOC_METAG_RELATIVE,             R_METAG_RELATIVE },
                    726:     { BFD_RELOC_METAG_GLOB_DAT,             R_METAG_GLOB_DAT },
                    727:     { BFD_RELOC_METAG_TLS_GD,       R_METAG_TLS_GD },
                    728:     { BFD_RELOC_METAG_TLS_LDM,      R_METAG_TLS_LDM },
1.1       christos  729:     { BFD_RELOC_METAG_TLS_LDO_HI16,  R_METAG_TLS_LDO_HI16 },
                    730:     { BFD_RELOC_METAG_TLS_LDO_LO16,  R_METAG_TLS_LDO_LO16 },
1.1.1.3   christos  731:     { BFD_RELOC_METAG_TLS_LDO,      R_METAG_TLS_LDO },
                    732:     { BFD_RELOC_METAG_TLS_IE,       R_METAG_TLS_IE },
1.1       christos  733:     { BFD_RELOC_METAG_TLS_IENONPIC,  R_METAG_TLS_IENONPIC },
                    734:     { BFD_RELOC_METAG_TLS_IENONPIC_HI16, R_METAG_TLS_IENONPIC_HI16 },
                    735:     { BFD_RELOC_METAG_TLS_IENONPIC_LO16, R_METAG_TLS_IENONPIC_LO16 },
                    736:     { BFD_RELOC_METAG_TLS_TPOFF,     R_METAG_TLS_TPOFF },
                    737:     { BFD_RELOC_METAG_TLS_DTPMOD,    R_METAG_TLS_DTPMOD },
                    738:     { BFD_RELOC_METAG_TLS_DTPOFF,    R_METAG_TLS_DTPOFF },
1.1.1.3   christos  739:     { BFD_RELOC_METAG_TLS_LE,       R_METAG_TLS_LE },
1.1       christos  740:     { BFD_RELOC_METAG_TLS_LE_HI16,   R_METAG_TLS_LE_HI16 },
                    741:     { BFD_RELOC_METAG_TLS_LE_LO16,   R_METAG_TLS_LE_LO16 },
                    742:   };
                    743:
                    744: enum elf_metag_stub_type
                    745: {
                    746:   metag_stub_long_branch,
                    747:   metag_stub_long_branch_shared,
                    748:   metag_stub_none
                    749: };
                    750:
                    751: struct elf_metag_stub_hash_entry
                    752: {
                    753:   /* Base hash table entry structure.  */
                    754:   struct bfd_hash_entry bh_root;
                    755:
                    756:   /* The stub section.  */
                    757:   asection *stub_sec;
                    758:
                    759:   /* Offset within stub_sec of the beginning of this stub.  */
                    760:   bfd_vma stub_offset;
                    761:
                    762:   /* Given the symbol's value and its section we can determine its final
                    763:      value when building the stubs (so the stub knows where to jump.  */
                    764:   bfd_vma target_value;
                    765:   asection *target_section;
                    766:
                    767:   enum elf_metag_stub_type stub_type;
                    768:
                    769:   /* The symbol table entry, if any, that this was derived from.  */
                    770:   struct elf_metag_link_hash_entry *hh;
                    771:
                    772:   /* And the reloc addend that this was derived from.  */
                    773:   bfd_vma addend;
                    774:
                    775:   /* Where this stub is being called from, or, in the case of combined
                    776:      stub sections, the first input section in the group.  */
                    777:   asection *id_sec;
                    778: };
                    779:
                    780: struct elf_metag_link_hash_entry
                    781: {
                    782:   struct elf_link_hash_entry eh;
                    783:
                    784:   /* A pointer to the most recently used stub hash entry against this
                    785:      symbol.  */
                    786:   struct elf_metag_stub_hash_entry *hsh_cache;
                    787:
                    788:   /* Used to count relocations for delayed sizing of relocation
                    789:      sections.  */
1.1.1.3   christos  790:   struct elf_dyn_relocs *dyn_relocs;
1.1       christos  791:
                    792:   enum
                    793:     {
                    794:       GOT_UNKNOWN = 0, GOT_NORMAL = 1, GOT_TLS_IE = 2, GOT_TLS_LDM = 4, GOT_TLS_GD = 8
                    795:     } tls_type;
                    796: };
                    797:
                    798: struct elf_metag_link_hash_table
                    799: {
                    800:   /* The main hash table.  */
                    801:   struct elf_link_hash_table etab;
                    802:
                    803:   /* The stub hash table.  */
                    804:   struct bfd_hash_table bstab;
                    805:
                    806:   /* Linker stub bfd.  */
                    807:   bfd *stub_bfd;
                    808:
                    809:   /* Linker call-backs.  */
                    810:   asection * (*add_stub_section) (const char *, asection *);
                    811:   void (*layout_sections_again) (void);
                    812:
                    813:   /* Array to keep track of which stub sections have been created, and
                    814:      information on stub grouping.  */
                    815:   struct map_stub
                    816:   {
                    817:     /* This is the section to which stubs in the group will be
                    818:        attached.  */
                    819:     asection *link_sec;
                    820:     /* The stub section.  */
                    821:     asection *stub_sec;
                    822:   } *stub_group;
                    823:
                    824:   /* Assorted information used by elf_metag_size_stubs.  */
                    825:   unsigned int bfd_count;
                    826:   unsigned int top_index;
                    827:   asection **input_list;
                    828:   Elf_Internal_Sym **all_local_syms;
                    829:
                    830:   /* Small local sym cache.  */
                    831:   struct sym_cache sym_cache;
                    832:
                    833:   /* Data for LDM relocations.  */
                    834:   union
                    835:   {
                    836:     bfd_signed_vma refcount;
                    837:     bfd_vma offset;
                    838:   } tls_ldm_got;
                    839: };
                    840:
                    841: /* Return the base vma address which should be subtracted from the
                    842:    real address when resolving a dtpoff relocation.  This is PT_TLS
                    843:    segment p_vaddr.  */
                    844: static bfd_vma
                    845: dtpoff_base (struct bfd_link_info *info)
                    846: {
                    847:   /* If tls_sec is NULL, we should have signalled an error already.  */
                    848:   if (elf_hash_table (info)->tls_sec == NULL)
                    849:     return 0;
                    850:   return elf_hash_table (info)->tls_sec->vma;
                    851: }
                    852:
                    853: /* Return the relocation value for R_METAG_TLS_IE */
                    854: static bfd_vma
                    855: tpoff (struct bfd_link_info *info, bfd_vma address)
                    856: {
                    857:   /* If tls_sec is NULL, we should have signalled an error already.  */
                    858:   if (elf_hash_table (info)->tls_sec == NULL)
                    859:     return 0;
                    860:   /* METAG TLS ABI is variant I and static TLS blocks start just after
                    861:      tcbhead structure which has 2 pointer fields.  */
                    862:   return (address - elf_hash_table (info)->tls_sec->vma
                    863:          + align_power ((bfd_vma) 8,
                    864:                         elf_hash_table (info)->tls_sec->alignment_power));
                    865: }
                    866:
1.1.1.3   christos  867: static bfd_boolean
                    868: metag_info_to_howto_rela (bfd *abfd,
1.1       christos  869:                          arelent *cache_ptr,
                    870:                          Elf_Internal_Rela *dst)
                    871: {
                    872:   unsigned int r_type;
                    873:
                    874:   r_type = ELF32_R_TYPE (dst->r_info);
                    875:   if (r_type >= (unsigned int) R_METAG_MAX)
                    876:     {
1.1.1.3   christos  877:       /* xgettext:c-format */
                    878:       _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
                    879:                          abfd, r_type);
                    880:       bfd_set_error (bfd_error_bad_value);
                    881:       return FALSE;
1.1       christos  882:     }
                    883:   cache_ptr->howto = & elf_metag_howto_table [r_type];
1.1.1.3   christos  884:   return TRUE;
1.1       christos  885: }
                    886:
                    887: static reloc_howto_type *
                    888: metag_reloc_type_lookup (bfd * abfd ATTRIBUTE_UNUSED,
                    889:                         bfd_reloc_code_real_type code)
                    890: {
                    891:   unsigned int i;
                    892:
                    893:   for (i = 0; i < sizeof (metag_reloc_map) / sizeof (metag_reloc_map[0]); i++)
                    894:     if (metag_reloc_map [i].bfd_reloc_val == code)
                    895:       return & elf_metag_howto_table [metag_reloc_map[i].metag_reloc_val];
                    896:
                    897:   return NULL;
                    898: }
                    899:
                    900: static reloc_howto_type *
                    901: metag_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
                    902:                         const char *r_name)
                    903: {
                    904:   unsigned int i;
                    905:
                    906:   for (i = 0; i < sizeof (elf_metag_howto_table) / sizeof (elf_metag_howto_table[0]); i++)
                    907:     if (elf_metag_howto_table[i].name != NULL
                    908:        && strcasecmp (elf_metag_howto_table[i].name, r_name) == 0)
                    909:       return &elf_metag_howto_table[i];
                    910:
                    911:   return NULL;
                    912: }
                    913:
                    914: /* Various hash macros and functions.  */
                    915: #define metag_link_hash_table(p) \
                    916:   (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
                    917:   == METAG_ELF_DATA ? ((struct elf_metag_link_hash_table *) ((p)->hash)) : NULL)
                    918:
                    919: #define metag_elf_hash_entry(ent) \
                    920:   ((struct elf_metag_link_hash_entry *)(ent))
                    921:
                    922: #define metag_stub_hash_entry(ent) \
                    923:   ((struct elf_metag_stub_hash_entry *)(ent))
                    924:
                    925: #define metag_stub_hash_lookup(table, string, create, copy) \
                    926:   ((struct elf_metag_stub_hash_entry *) \
                    927:    bfd_hash_lookup ((table), (string), (create), (copy)))
                    928:
                    929: #define metag_elf_local_got_tls_type(abfd) \
                    930:   ((char *)(elf_local_got_offsets (abfd) + (elf_tdata (abfd)->symtab_hdr.sh_info)))
                    931:
                    932: /* Assorted hash table functions.  */
                    933:
                    934: /* Initialize an entry in the stub hash table.  */
                    935:
                    936: static struct bfd_hash_entry *
                    937: stub_hash_newfunc (struct bfd_hash_entry *entry,
                    938:                   struct bfd_hash_table *table,
                    939:                   const char *string)
                    940: {
                    941:   /* Allocate the structure if it has not already been allocated by a
                    942:      subclass.  */
                    943:   if (entry == NULL)
                    944:     {
                    945:       entry = bfd_hash_allocate (table,
                    946:                                 sizeof (struct elf_metag_stub_hash_entry));
                    947:       if (entry == NULL)
                    948:        return entry;
                    949:     }
                    950:
                    951:   /* Call the allocation method of the superclass.  */
                    952:   entry = bfd_hash_newfunc (entry, table, string);
                    953:   if (entry != NULL)
                    954:     {
                    955:       struct elf_metag_stub_hash_entry *hsh;
                    956:
                    957:       /* Initialize the local fields.  */
                    958:       hsh = (struct elf_metag_stub_hash_entry *) entry;
                    959:       hsh->stub_sec = NULL;
                    960:       hsh->stub_offset = 0;
                    961:       hsh->target_value = 0;
                    962:       hsh->target_section = NULL;
                    963:       hsh->stub_type = metag_stub_long_branch;
                    964:       hsh->hh = NULL;
                    965:       hsh->id_sec = NULL;
                    966:     }
                    967:
                    968:   return entry;
                    969: }
                    970:
                    971: /* Initialize an entry in the link hash table.  */
                    972:
                    973: static struct bfd_hash_entry *
                    974: metag_link_hash_newfunc (struct bfd_hash_entry *entry,
                    975:                         struct bfd_hash_table *table,
                    976:                         const char *string)
                    977: {
                    978:   /* Allocate the structure if it has not already been allocated by a
                    979:      subclass.  */
                    980:   if (entry == NULL)
                    981:     {
                    982:       entry = bfd_hash_allocate (table,
                    983:                                 sizeof (struct elf_metag_link_hash_entry));
                    984:       if (entry == NULL)
                    985:        return entry;
                    986:     }
                    987:
                    988:   /* Call the allocation method of the superclass.  */
                    989:   entry = _bfd_elf_link_hash_newfunc (entry, table, string);
                    990:   if (entry != NULL)
                    991:     {
                    992:       struct elf_metag_link_hash_entry *hh;
                    993:
                    994:       /* Initialize the local fields.  */
                    995:       hh = (struct elf_metag_link_hash_entry *) entry;
                    996:       hh->hsh_cache = NULL;
                    997:       hh->dyn_relocs = NULL;
                    998:       hh->tls_type = GOT_UNKNOWN;
                    999:     }
                   1000:
                   1001:   return entry;
                   1002: }
                   1003:
                   1004: /* Free the derived linker hash table.  */
                   1005:
                   1006: static void
                   1007: elf_metag_link_hash_table_free (bfd *obfd)
                   1008: {
                   1009:   struct elf_metag_link_hash_table *htab
                   1010:     = (struct elf_metag_link_hash_table *) obfd->link.hash;
                   1011:
                   1012:   bfd_hash_table_free (&htab->bstab);
                   1013:   _bfd_elf_link_hash_table_free (obfd);
                   1014: }
                   1015:
                   1016: /* Create the derived linker hash table.  The Meta ELF port uses the derived
                   1017:    hash table to keep information specific to the Meta ELF linker (without
                   1018:    using static variables).  */
                   1019:
                   1020: static struct bfd_link_hash_table *
                   1021: elf_metag_link_hash_table_create (bfd *abfd)
                   1022: {
                   1023:   struct elf_metag_link_hash_table *htab;
                   1024:   bfd_size_type amt = sizeof (*htab);
                   1025:
                   1026:   htab = bfd_zmalloc (amt);
                   1027:   if (htab == NULL)
                   1028:     return NULL;
                   1029:
                   1030:   if (!_bfd_elf_link_hash_table_init (&htab->etab, abfd,
                   1031:                                      metag_link_hash_newfunc,
                   1032:                                      sizeof (struct elf_metag_link_hash_entry),
                   1033:                                      METAG_ELF_DATA))
                   1034:     {
                   1035:       free (htab);
                   1036:       return NULL;
                   1037:     }
                   1038:
                   1039:   /* Init the stub hash table too.  */
                   1040:   if (!bfd_hash_table_init (&htab->bstab, stub_hash_newfunc,
                   1041:                            sizeof (struct elf_metag_stub_hash_entry)))
                   1042:     {
                   1043:       _bfd_elf_link_hash_table_free (abfd);
                   1044:       return NULL;
                   1045:     }
                   1046:   htab->etab.root.hash_table_free = elf_metag_link_hash_table_free;
                   1047:
                   1048:   return &htab->etab.root;
                   1049: }
                   1050:
                   1051: /* Section name for stubs is the associated section name plus this
                   1052:    string.  */
                   1053: #define STUB_SUFFIX ".stub"
                   1054:
                   1055: /* Build a name for an entry in the stub hash table.  */
                   1056:
                   1057: static char *
                   1058: metag_stub_name (const asection *input_section,
                   1059:                 const asection *sym_sec,
                   1060:                 const struct elf_metag_link_hash_entry *hh,
                   1061:                 const Elf_Internal_Rela *rel)
                   1062: {
                   1063:   char *stub_name;
                   1064:   bfd_size_type len;
                   1065:
                   1066:   if (hh)
                   1067:     {
                   1068:       len = 8 + 1 + strlen (hh->eh.root.root.string) + 1 + 8 + 1;
                   1069:       stub_name = bfd_malloc (len);
                   1070:       if (stub_name != NULL)
                   1071:        {
                   1072:          sprintf (stub_name, "%08x_%s+%x",
                   1073:                   input_section->id & 0xffffffff,
                   1074:                   hh->eh.root.root.string,
                   1075:                   (int) rel->r_addend & 0xffffffff);
                   1076:        }
                   1077:     }
                   1078:   else
                   1079:     {
                   1080:       len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
                   1081:       stub_name = bfd_malloc (len);
                   1082:       if (stub_name != NULL)
                   1083:        {
                   1084:          sprintf (stub_name, "%08x_%x:%x+%x",
                   1085:                   input_section->id & 0xffffffff,
                   1086:                   sym_sec->id & 0xffffffff,
                   1087:                   (int) ELF32_R_SYM (rel->r_info) & 0xffffffff,
                   1088:                   (int) rel->r_addend & 0xffffffff);
                   1089:        }
                   1090:     }
                   1091:   return stub_name;
                   1092: }
                   1093:
                   1094: /* Look up an entry in the stub hash.  Stub entries are cached because
                   1095:    creating the stub name takes a bit of time.  */
                   1096:
                   1097: static struct elf_metag_stub_hash_entry *
                   1098: metag_get_stub_entry (const asection *input_section,
                   1099:                      const asection *sym_sec,
                   1100:                      struct elf_metag_link_hash_entry *hh,
                   1101:                      const Elf_Internal_Rela *rel,
                   1102:                      struct elf_metag_link_hash_table *htab)
                   1103: {
                   1104:   struct elf_metag_stub_hash_entry *hsh;
                   1105:   const asection *id_sec;
                   1106:
                   1107:   /* If this input section is part of a group of sections sharing one
                   1108:      stub section, then use the id of the first section in the group.
                   1109:      Stub names need to include a section id, as there may well be
                   1110:      more than one stub used to reach say, printf, and we need to
                   1111:      distinguish between them.  */
                   1112:   id_sec = htab->stub_group[input_section->id].link_sec;
                   1113:
                   1114:   if (hh != NULL && hh->hsh_cache != NULL
                   1115:       && hh->hsh_cache->hh == hh
                   1116:       && hh->hsh_cache->id_sec == id_sec)
                   1117:     {
                   1118:       hsh = hh->hsh_cache;
                   1119:     }
                   1120:   else
                   1121:     {
                   1122:       char *stub_name;
                   1123:
                   1124:       stub_name = metag_stub_name (id_sec, sym_sec, hh, rel);
                   1125:       if (stub_name == NULL)
                   1126:        return NULL;
                   1127:
                   1128:       hsh = metag_stub_hash_lookup (&htab->bstab,
                   1129:                                    stub_name, FALSE, FALSE);
                   1130:
                   1131:       if (hh != NULL)
                   1132:        hh->hsh_cache = hsh;
                   1133:
                   1134:       free (stub_name);
                   1135:     }
                   1136:
                   1137:   return hsh;
                   1138: }
                   1139:
                   1140: /* Add a new stub entry to the stub hash.  Not all fields of the new
                   1141:    stub entry are initialised.  */
                   1142:
                   1143: static struct elf_metag_stub_hash_entry *
                   1144: metag_add_stub (const char *stub_name,
                   1145:                asection *section,
                   1146:                struct elf_metag_link_hash_table *htab)
                   1147: {
                   1148:   asection *link_sec;
                   1149:   asection *stub_sec;
                   1150:   struct elf_metag_stub_hash_entry *hsh;
                   1151:
                   1152:   link_sec = htab->stub_group[section->id].link_sec;
                   1153:   stub_sec = htab->stub_group[section->id].stub_sec;
                   1154:   if (stub_sec == NULL)
                   1155:     {
                   1156:       stub_sec = htab->stub_group[link_sec->id].stub_sec;
                   1157:       if (stub_sec == NULL)
                   1158:        {
                   1159:          size_t namelen;
                   1160:          bfd_size_type len;
                   1161:          char *s_name;
                   1162:
                   1163:          namelen = strlen (link_sec->name);
                   1164:          len = namelen + sizeof (STUB_SUFFIX);
                   1165:          s_name = bfd_alloc (htab->stub_bfd, len);
                   1166:          if (s_name == NULL)
                   1167:            return NULL;
                   1168:
                   1169:          memcpy (s_name, link_sec->name, namelen);
                   1170:          memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
                   1171:
                   1172:          stub_sec = (*htab->add_stub_section) (s_name, link_sec);
                   1173:          if (stub_sec == NULL)
                   1174:            return NULL;
                   1175:          htab->stub_group[link_sec->id].stub_sec = stub_sec;
                   1176:        }
                   1177:       htab->stub_group[section->id].stub_sec = stub_sec;
                   1178:     }
                   1179:
                   1180:   /* Enter this entry into the linker stub hash table.  */
                   1181:   hsh = metag_stub_hash_lookup (&htab->bstab, stub_name,
                   1182:                                TRUE, FALSE);
                   1183:   if (hsh == NULL)
                   1184:     {
1.1.1.3   christos 1185:       /* xgettext:c-format */
                   1186:       _bfd_error_handler (_("%pB: cannot create stub entry %s"),
                   1187:                          section->owner, stub_name);
1.1       christos 1188:       return NULL;
                   1189:     }
                   1190:
                   1191:   hsh->stub_sec = stub_sec;
                   1192:   hsh->stub_offset = 0;
                   1193:   hsh->id_sec = link_sec;
                   1194:   return hsh;
                   1195: }
                   1196:
                   1197: /* Check a signed integer value can be represented in the given number
                   1198:    of bits.  */
                   1199:
                   1200: static bfd_boolean
                   1201: within_signed_range (int value, unsigned int bits)
                   1202: {
                   1203:   int min_val = -(1 << (bits - 1));
                   1204:   int max_val = (1 << (bits - 1)) - 1;
                   1205:   return (value <= max_val) && (value >= min_val);
                   1206: }
                   1207:
                   1208: /* Perform a relocation as part of a final link.  */
                   1209:
                   1210: static bfd_reloc_status_type
                   1211: metag_final_link_relocate (reloc_howto_type *howto,
                   1212:                           bfd *input_bfd,
                   1213:                           asection *input_section,
                   1214:                           bfd_byte *contents,
                   1215:                           Elf_Internal_Rela *rel,
                   1216:                           bfd_vma relocation,
                   1217:                           struct elf_metag_link_hash_entry *hh,
                   1218:                           struct elf_metag_link_hash_table *htab,
                   1219:                           asection *sym_sec)
                   1220: {
                   1221:   bfd_reloc_status_type r = bfd_reloc_ok;
                   1222:   bfd_byte *hit_data = contents + rel->r_offset;
                   1223:   int opcode, op_shift, op_extended, l1, l2;
                   1224:   bfd_signed_vma srel, addend = rel->r_addend;
                   1225:   struct elf_metag_stub_hash_entry *hsh = NULL;
                   1226:   bfd_vma location;
                   1227:
                   1228:   /* Find out where we are and where we're going.  */
                   1229:   location = (rel->r_offset +
                   1230:              input_section->output_offset +
                   1231:              input_section->output_section->vma);
                   1232:
                   1233:   switch (howto->type)
                   1234:     {
                   1235:     case R_METAG_RELBRANCH:
                   1236:     case R_METAG_RELBRANCH_PLT:
                   1237:       /* Make it a pc relative offset.  */
                   1238:       relocation -= location;
                   1239:       break;
                   1240:     case R_METAG_TLS_GD:
                   1241:     case R_METAG_TLS_IE:
                   1242:       relocation -= elf_gp (input_section->output_section->owner);
                   1243:       break;
                   1244:     default:
                   1245:       break;
                   1246:     }
                   1247:
                   1248:   switch (howto->type)
                   1249:     {
                   1250:     case R_METAG_RELBRANCH_PLT:
                   1251:     case R_METAG_RELBRANCH:
                   1252:       opcode = bfd_get_32 (input_bfd, hit_data);
                   1253:
                   1254:       srel = (bfd_signed_vma) relocation;
                   1255:       srel += addend;
                   1256:
                   1257:       /* If the branch is out of reach, then redirect the
                   1258:         call to the local stub for this function.  */
                   1259:       if (srel > ((1 << (BRANCH_BITS + 1)) - 1) ||
                   1260:          (srel < - (1 << (BRANCH_BITS + 1))))
                   1261:        {
                   1262:          if (sym_sec == NULL)
                   1263:            break;
                   1264:
                   1265:          hsh = metag_get_stub_entry (input_section, sym_sec,
                   1266:                                      hh, rel, htab);
                   1267:          if (hsh == NULL)
                   1268:            return bfd_reloc_undefined;
                   1269:
                   1270:          /* Munge up the value and addend so that we call the stub
                   1271:             rather than the procedure directly.  */
                   1272:          srel = (hsh->stub_offset
                   1273:                  + hsh->stub_sec->output_offset
                   1274:                  + hsh->stub_sec->output_section->vma);
                   1275:          srel -= location;
                   1276:        }
                   1277:
                   1278:       srel = srel >> 2;
                   1279:
                   1280:       if (!within_signed_range (srel, BRANCH_BITS))
                   1281:        {
                   1282:          if (hh && hh->eh.root.type == bfd_link_hash_undefweak)
                   1283:            srel = 0;
                   1284:          else
                   1285:            return bfd_reloc_overflow;
                   1286:        }
                   1287:
                   1288:       opcode &= ~(0x7ffff << 5);
                   1289:       opcode |= ((srel & 0x7ffff) << 5);
                   1290:
                   1291:       bfd_put_32 (input_bfd, opcode, hit_data);
                   1292:       break;
                   1293:     case R_METAG_GETSETOFF:
                   1294:     case R_METAG_GETSET_GOT:
                   1295:     case R_METAG_GETSET_GOTOFF:
                   1296:       opcode = bfd_get_32 (input_bfd, hit_data);
                   1297:
                   1298:       srel = (bfd_signed_vma) relocation;
                   1299:       srel += addend;
                   1300:
                   1301:       /* Is this a standard or extended GET/SET?  */
                   1302:       if ((opcode & 0xf0000000) == 0xa0000000)
                   1303:        {
                   1304:          /* Extended GET/SET.  */
                   1305:          l1 = opcode & 0x2;
                   1306:          l2 = opcode & 0x4;
                   1307:          op_extended = 1;
                   1308:        }
                   1309:       else
                   1310:        {
                   1311:          /* Standard GET/SET.  */
                   1312:          l1 = opcode & 0x01000000;
                   1313:          l2 = opcode & 0x04000000;
                   1314:          op_extended = 0;
                   1315:        }
                   1316:
                   1317:       /* Calculate the width of the GET/SET and how much we need to
                   1318:         shift the result by.  */
                   1319:       if (l2)
                   1320:        if (l1)
                   1321:          op_shift = 3;
                   1322:        else
                   1323:          op_shift = 2;
                   1324:       else
                   1325:        if (l1)
                   1326:          op_shift = 1;
                   1327:        else
                   1328:          op_shift = 0;
                   1329:
                   1330:       /* GET/SET offsets are scaled by the width of the transfer.  */
                   1331:       srel = srel >> op_shift;
                   1332:
                   1333:       /* Extended GET/SET has signed 12 bits of offset, standard has
                   1334:         signed 6 bits.  */
                   1335:       if (op_extended)
                   1336:        {
                   1337:          if (!within_signed_range (srel, 12))
                   1338:            {
                   1339:              if (hh && hh->eh.root.type == bfd_link_hash_undefweak)
                   1340:                srel = 0;
                   1341:              else
                   1342:                return bfd_reloc_overflow;
                   1343:            }
                   1344:          opcode &= ~(0xfff << 7);
                   1345:          opcode |= ((srel & 0xfff) << 7);
                   1346:        }
                   1347:       else
                   1348:        {
                   1349:          if (!within_signed_range (srel, 5))
                   1350:            {
                   1351:              if (hh && hh->eh.root.type == bfd_link_hash_undefweak)
                   1352:                srel = 0;
                   1353:              else
                   1354:                return bfd_reloc_overflow;
                   1355:            }
                   1356:          opcode &= ~(0x3f << 8);
                   1357:          opcode |= ((srel & 0x3f) << 8);
                   1358:        }
                   1359:
                   1360:       bfd_put_32 (input_bfd, opcode, hit_data);
                   1361:       break;
                   1362:     case R_METAG_TLS_GD:
                   1363:     case R_METAG_TLS_LDM:
                   1364:       opcode = bfd_get_32 (input_bfd, hit_data);
                   1365:
                   1366:       if ((bfd_signed_vma)relocation < 0)
                   1367:        {
                   1368:         /* sign extend immediate */
                   1369:         if ((opcode & 0xf2000001) == 0x02000000)
                   1370:          {
                   1371:            /* ADD De.e,Dx.r,#I16 */
                   1372:            /* set SE bit */
                   1373:            opcode |= (1 << 1);
                   1374:          } else
                   1375:            return bfd_reloc_overflow;
                   1376:        }
                   1377:
                   1378:       bfd_put_32 (input_bfd, opcode, hit_data);
                   1379:
                   1380:       r = _bfd_final_link_relocate (howto, input_bfd, input_section,
                   1381:                                    contents, rel->r_offset,
                   1382:                                    relocation, rel->r_addend);
                   1383:       break;
                   1384:     default:
                   1385:       r = _bfd_final_link_relocate (howto, input_bfd, input_section,
                   1386:                                    contents, rel->r_offset,
                   1387:                                    relocation, rel->r_addend);
                   1388:     }
                   1389:
                   1390:   return r;
                   1391: }
                   1392:
                   1393: /* This is defined because R_METAG_NONE != 0...
                   1394:    See RELOC_AGAINST_DISCARDED_SECTION for details.  */
                   1395: #define METAG_RELOC_AGAINST_DISCARDED_SECTION(info, input_bfd, input_section, \
                   1396:                                              rel, relend, howto, contents) \
                   1397:   {                                                                    \
                   1398:     _bfd_clear_contents (howto, input_bfd, input_section,              \
1.1.1.4 ! christos 1399:                         contents, rel->r_offset);                      \
1.1       christos 1400:                                                                        \
                   1401:     if (bfd_link_relocatable (info)                                    \
                   1402:        && (input_section->flags & SEC_DEBUGGING))                      \
                   1403:       {                                                                        \
                   1404:        /* Only remove relocations in debug sections since other        \
                   1405:           sections may require relocations.  */                        \
                   1406:        Elf_Internal_Shdr *rel_hdr;                                     \
                   1407:                                                                        \
                   1408:        rel_hdr = _bfd_elf_single_rel_hdr (input_section->output_section); \
                   1409:                                                                        \
                   1410:        /* Avoid empty output section.  */                              \
                   1411:        if (rel_hdr->sh_size > rel_hdr->sh_entsize)                     \
                   1412:          {                                                             \
                   1413:            rel_hdr->sh_size -= rel_hdr->sh_entsize;                    \
                   1414:            rel_hdr = _bfd_elf_single_rel_hdr (input_section);          \
                   1415:            rel_hdr->sh_size -= rel_hdr->sh_entsize;                    \
                   1416:                                                                        \
                   1417:            memmove (rel, rel + 1, (relend - rel) * sizeof (*rel));     \
                   1418:                                                                        \
                   1419:            input_section->reloc_count--;                               \
                   1420:            relend--;                                                   \
                   1421:            rel--;                                                      \
                   1422:            continue;                                                   \
                   1423:          }                                                             \
                   1424:       }                                                                        \
                   1425:                                                                        \
                   1426:     rel->r_info = R_METAG_NONE;                                                \
                   1427:     rel->r_addend = 0;                                                 \
                   1428:     continue;                                                          \
                   1429:   }
                   1430:
                   1431: /* Relocate a META ELF section.
                   1432:
                   1433: The RELOCATE_SECTION function is called by the new ELF backend linker
                   1434: to handle the relocations for a section.
                   1435:
                   1436: The relocs are always passed as Rela structures; if the section
                   1437: actually uses Rel structures, the r_addend field will always be
                   1438: zero.
                   1439:
                   1440: This function is responsible for adjusting the section contents as
                   1441: necessary, and (if using Rela relocs and generating a relocatable
                   1442: output file) adjusting the reloc addend as necessary.
                   1443:
                   1444: This function does not have to worry about setting the reloc
                   1445: address or the reloc symbol index.
                   1446:
                   1447: LOCAL_SYMS is a pointer to the swapped in local symbols.
                   1448:
                   1449: LOCAL_SECTIONS is an array giving the section in the input file
                   1450: corresponding to the st_shndx field of each local symbol.
                   1451:
                   1452: The global hash table entry for the global symbols can be found
                   1453: via elf_sym_hashes (input_bfd).
                   1454:
                   1455: When generating relocatable output, this function must handle
                   1456: STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
                   1457: going to be the section symbol corresponding to the output
                   1458: section, which means that the addend must be adjusted
                   1459: accordingly.  */
                   1460:
                   1461: static bfd_boolean
                   1462: elf_metag_relocate_section (bfd *output_bfd,
                   1463:                            struct bfd_link_info *info,
                   1464:                            bfd *input_bfd,
                   1465:                            asection *input_section,
                   1466:                            bfd_byte *contents,
                   1467:                            Elf_Internal_Rela *relocs,
                   1468:                            Elf_Internal_Sym *local_syms,
                   1469:                            asection **local_sections)
                   1470: {
                   1471:   bfd_vma *local_got_offsets;
                   1472:   Elf_Internal_Shdr *symtab_hdr;
                   1473:   struct elf_link_hash_entry **eh_syms;
                   1474:   struct elf_metag_link_hash_table *htab;
                   1475:   Elf_Internal_Rela *rel;
                   1476:   Elf_Internal_Rela *relend;
                   1477:   asection *sreloc;
                   1478:
                   1479:   symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
                   1480:   eh_syms = elf_sym_hashes (input_bfd);
                   1481:   relend = relocs + input_section->reloc_count;
                   1482:
                   1483:   htab = metag_link_hash_table (info);
                   1484:   local_got_offsets = elf_local_got_offsets (input_bfd);
                   1485:
                   1486:   sreloc = NULL;
                   1487:
                   1488:   for (rel = relocs; rel < relend; rel ++)
                   1489:     {
                   1490:       reloc_howto_type *howto;
                   1491:       unsigned long r_symndx;
                   1492:       Elf_Internal_Sym *sym;
                   1493:       asection *sec;
                   1494:       struct elf_metag_link_hash_entry *hh;
                   1495:       bfd_vma relocation;
                   1496:       bfd_reloc_status_type r;
                   1497:       const char *name;
                   1498:       int r_type;
                   1499:
                   1500:       r_type = ELF32_R_TYPE (rel->r_info);
                   1501:
                   1502:       if (r_type == R_METAG_GNU_VTINHERIT
                   1503:          || r_type == R_METAG_GNU_VTENTRY
                   1504:          || r_type == R_METAG_NONE)
                   1505:        continue;
                   1506:
                   1507:       r_symndx = ELF32_R_SYM (rel->r_info);
                   1508:
                   1509:       howto  = elf_metag_howto_table + ELF32_R_TYPE (rel->r_info);
                   1510:       hh     = NULL;
                   1511:       sym    = NULL;
                   1512:       sec    = NULL;
                   1513:
                   1514:       if (r_symndx < symtab_hdr->sh_info)
                   1515:        {
                   1516:          sym = local_syms + r_symndx;
                   1517:          sec = local_sections [r_symndx];
                   1518:          relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
                   1519:
                   1520:          name = bfd_elf_string_from_elf_section
                   1521:            (input_bfd, symtab_hdr->sh_link, sym->st_name);
1.1.1.4 ! christos 1522:          name = name == NULL ? bfd_section_name (sec) : name;
1.1       christos 1523:        }
                   1524:       else
                   1525:        {
                   1526:          struct elf_link_hash_entry *eh;
                   1527:          bfd_boolean unresolved_reloc, warned, ignored;
                   1528:
                   1529:          RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
                   1530:                                   r_symndx, symtab_hdr, eh_syms,
                   1531:                                   eh, sec, relocation,
                   1532:                                   unresolved_reloc, warned, ignored);
                   1533:
                   1534:          name = eh->root.root.string;
                   1535:          hh = (struct elf_metag_link_hash_entry *) eh;
                   1536:        }
                   1537:
                   1538:       if (sec != NULL && discarded_section (sec))
                   1539:          METAG_RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
                   1540:                                                 rel, relend, howto, contents);
                   1541:
                   1542:       if (bfd_link_relocatable (info))
                   1543:        continue;
                   1544:
                   1545:       switch (r_type)
                   1546:        {
                   1547:        case R_METAG_ADDR32:
                   1548:        case R_METAG_RELBRANCH:
                   1549:          if ((input_section->flags & SEC_ALLOC) == 0)
                   1550:            break;
                   1551:
                   1552:          if ((bfd_link_pic (info)
                   1553:               && r_symndx != STN_UNDEF
                   1554:               && (input_section->flags & SEC_ALLOC) != 0
                   1555:               && (r_type != R_METAG_RELBRANCH
                   1556:                   || !SYMBOL_CALLS_LOCAL (info, &hh->eh)))
                   1557:              || (!bfd_link_pic (info)
                   1558:                  && hh != NULL
                   1559:                  && hh->eh.dynindx != -1
                   1560:                  && !hh->eh.non_got_ref
                   1561:                  && ((hh->eh.def_dynamic
                   1562:                       && !hh->eh.def_regular)
                   1563:                      || hh->eh.root.type == bfd_link_hash_undefweak
                   1564:                      || hh->eh.root.type == bfd_link_hash_undefined)))
                   1565:            {
                   1566:              Elf_Internal_Rela outrel;
                   1567:              bfd_boolean skip, relocate;
                   1568:              bfd_byte *loc;
                   1569:
                   1570:              /* When generating a shared object, these relocations
                   1571:                 are copied into the output file to be resolved at run
                   1572:                 time.  */
                   1573:
                   1574:              sreloc = elf_section_data (input_section)->sreloc;
                   1575:              BFD_ASSERT (sreloc != NULL);
                   1576:
                   1577:              skip = FALSE;
                   1578:              relocate = FALSE;
                   1579:
                   1580:              outrel.r_offset = _bfd_elf_section_offset (output_bfd,
                   1581:                                                         info,
                   1582:                                                         input_section,
                   1583:                                                         rel->r_offset);
                   1584:              if (outrel.r_offset == (bfd_vma) -1)
                   1585:                skip = TRUE;
                   1586:              else if (outrel.r_offset == (bfd_vma) -2)
                   1587:                skip = TRUE, relocate = TRUE;
                   1588:              outrel.r_offset += (input_section->output_section->vma
                   1589:                                  + input_section->output_offset);
                   1590:
                   1591:              if (skip)
                   1592:                {
                   1593:                  memset (&outrel, 0, sizeof outrel);
                   1594:                  outrel.r_info = ELF32_R_INFO (0, R_METAG_NONE);
                   1595:                }
                   1596:              else if (r_type == R_METAG_RELBRANCH)
                   1597:                {
                   1598:                  BFD_ASSERT (hh != NULL && hh->eh.dynindx != -1);
                   1599:                  outrel.r_info = ELF32_R_INFO (hh->eh.dynindx, r_type);
                   1600:                  outrel.r_addend = rel->r_addend;
                   1601:                }
                   1602:              else
                   1603:                {
                   1604:                  /* h->dynindx may be -1 if this symbol was marked to
                   1605:                     become local.  */
                   1606:                  if (hh == NULL
                   1607:                      || ((info->symbolic || hh->eh.dynindx == -1)
                   1608:                          && hh->eh.def_regular))
                   1609:                    {
                   1610:                      relocate = TRUE;
                   1611:                      outrel.r_info = ELF32_R_INFO (0, R_METAG_RELATIVE);
                   1612:                      outrel.r_addend = relocation + rel->r_addend;
                   1613:                    }
                   1614:                  else
                   1615:                    {
                   1616:                      BFD_ASSERT (hh->eh.dynindx != -1);
                   1617:                      outrel.r_info = ELF32_R_INFO (hh->eh.dynindx, r_type);
                   1618:                      outrel.r_addend = rel->r_addend;
                   1619:                    }
                   1620:                }
                   1621:
                   1622:              loc = sreloc->contents;
                   1623:              loc += sreloc->reloc_count * sizeof(Elf32_External_Rela);
                   1624:              bfd_elf32_swap_reloca_out (output_bfd, &outrel,loc);
                   1625:              ++sreloc->reloc_count;
                   1626:
                   1627:              /* If this reloc is against an external symbol, we do
                   1628:                 not want to fiddle with the addend.  Otherwise, we
                   1629:                 need to include the symbol value so that it becomes
                   1630:                 an addend for the dynamic reloc.  */
                   1631:              if (! relocate)
                   1632:                continue;
                   1633:            }
                   1634:          break;
                   1635:
                   1636:        case R_METAG_RELBRANCH_PLT:
                   1637:          /* Relocation is to the entry for this symbol in the
                   1638:             procedure linkage table.  */
                   1639:
                   1640:          if (hh == NULL)
                   1641:            break;
                   1642:
                   1643:          if (hh->eh.forced_local)
                   1644:            break;
                   1645:
1.1.1.3   christos 1646:          if (hh->eh.plt.offset == (bfd_vma) -1 || htab->etab.splt == NULL)
1.1       christos 1647:            {
                   1648:              /* We didn't make a PLT entry for this symbol.  This
                   1649:                 happens when statically linking PIC code, or when
                   1650:                 using -Bsymbolic.  */
                   1651:              break;
                   1652:            }
                   1653:
1.1.1.3   christos 1654:          relocation = (htab->etab.splt->output_section->vma
                   1655:                        + htab->etab.splt->output_offset
1.1       christos 1656:                        + hh->eh.plt.offset);
                   1657:          break;
                   1658:        case R_METAG_HI16_GOTPC:
                   1659:        case R_METAG_LO16_GOTPC:
1.1.1.3   christos 1660:          BFD_ASSERT (htab->etab.sgot != NULL);
1.1       christos 1661:
1.1.1.3   christos 1662:          relocation = (htab->etab.sgot->output_section->vma +
                   1663:                        htab->etab.sgot->output_offset);
1.1       christos 1664:          relocation += GOT_REG_OFFSET;
                   1665:          relocation -= (input_section->output_section->vma
                   1666:                         + input_section->output_offset
                   1667:                         + rel->r_offset);
                   1668:          break;
                   1669:        case R_METAG_HI16_GOTOFF:
                   1670:        case R_METAG_LO16_GOTOFF:
                   1671:        case R_METAG_GETSET_GOTOFF:
1.1.1.3   christos 1672:          BFD_ASSERT (htab->etab.sgot != NULL);
1.1       christos 1673:
1.1.1.3   christos 1674:          relocation -= (htab->etab.sgot->output_section->vma +
                   1675:                         htab->etab.sgot->output_offset);
1.1       christos 1676:          relocation -= GOT_REG_OFFSET;
                   1677:          break;
                   1678:        case R_METAG_GETSET_GOT:
                   1679:          {
                   1680:            bfd_vma off;
                   1681:            bfd_boolean do_got = 0;
                   1682:
                   1683:            /* Relocation is to the entry for this symbol in the
                   1684:               global offset table.  */
                   1685:            if (hh != NULL)
                   1686:              {
                   1687:                bfd_boolean dyn;
                   1688:
                   1689:                off = hh->eh.got.offset;
                   1690:                dyn = htab->etab.dynamic_sections_created;
                   1691:                if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
                   1692:                                                       bfd_link_pic (info),
                   1693:                                                       &hh->eh))
                   1694:                  {
                   1695:                    /* If we aren't going to call finish_dynamic_symbol,
                   1696:                       then we need to handle initialisation of the .got
                   1697:                       entry and create needed relocs here.  Since the
                   1698:                       offset must always be a multiple of 4, we use the
                   1699:                       least significant bit to record whether we have
                   1700:                       initialised it already.  */
                   1701:                    if ((off & 1) != 0)
                   1702:                      off &= ~1;
                   1703:                    else
                   1704:                      {
                   1705:                        hh->eh.got.offset |= 1;
                   1706:                        do_got = 1;
                   1707:                      }
                   1708:                  }
                   1709:              }
                   1710:            else
                   1711:              {
                   1712:                /* Local symbol case.  */
                   1713:                if (local_got_offsets == NULL)
                   1714:                  abort ();
                   1715:
                   1716:                off = local_got_offsets[r_symndx];
                   1717:
                   1718:                /* The offset must always be a multiple of 4.  We use
                   1719:                   the least significant bit to record whether we have
                   1720:                   already generated the necessary reloc.  */
                   1721:                if ((off & 1) != 0)
                   1722:                  off &= ~1;
                   1723:                else
                   1724:                  {
                   1725:                    local_got_offsets[r_symndx] |= 1;
                   1726:                    do_got = 1;
                   1727:                  }
                   1728:              }
                   1729:
                   1730:            if (do_got)
                   1731:              {
                   1732:                if (bfd_link_pic (info))
                   1733:                  {
                   1734:                    /* Output a dynamic relocation for this GOT entry.
                   1735:                       In this case it is relative to the base of the
                   1736:                       object because the symbol index is zero.  */
                   1737:                    Elf_Internal_Rela outrel;
                   1738:                    bfd_byte *loc;
1.1.1.3   christos 1739:                    asection *s = htab->etab.srelgot;
1.1       christos 1740:
                   1741:                    outrel.r_offset = (off
1.1.1.3   christos 1742:                                       + htab->etab.sgot->output_offset
                   1743:                                       + htab->etab.sgot->output_section->vma);
1.1       christos 1744:                    outrel.r_info = ELF32_R_INFO (0, R_METAG_RELATIVE);
                   1745:                    outrel.r_addend = relocation;
                   1746:                    loc = s->contents;
                   1747:                    loc += s->reloc_count++ * sizeof (Elf32_External_Rela);
                   1748:                    bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
                   1749:                  }
                   1750:                else
                   1751:                  bfd_put_32 (output_bfd, relocation,
1.1.1.3   christos 1752:                              htab->etab.sgot->contents + off);
1.1       christos 1753:              }
                   1754:
                   1755:            if (off >= (bfd_vma) -2)
                   1756:              abort ();
                   1757:
                   1758:            relocation = off - GOT_REG_OFFSET;
                   1759:          }
                   1760:          break;
                   1761:        case R_METAG_TLS_GD:
                   1762:        case R_METAG_TLS_IE:
                   1763:          {
                   1764:            /* XXXMJF There is room here for optimisations. For example
                   1765:               converting from GD->IE, etc.  */
                   1766:            bfd_vma off;
                   1767:            int indx;
                   1768:            char tls_type;
                   1769:
1.1.1.3   christos 1770:            if (htab->etab.sgot == NULL)
1.1       christos 1771:              abort();
                   1772:
                   1773:            indx = 0;
                   1774:            if (hh != NULL)
                   1775:              {
                   1776:                bfd_boolean dyn;
                   1777:                dyn = htab->etab.dynamic_sections_created;
                   1778:
                   1779:                if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
                   1780:                                                     bfd_link_pic (info),
                   1781:                                                     &hh->eh)
                   1782:                    && (!bfd_link_pic (info)
                   1783:                        || !SYMBOL_REFERENCES_LOCAL (info, &hh->eh)))
                   1784:                  {
                   1785:                    indx = hh->eh.dynindx;
                   1786:                  }
                   1787:                off = hh->eh.got.offset;
                   1788:                tls_type = hh->tls_type;
                   1789:              }
                   1790:            else
                   1791:              {
                   1792:                /* Local symbol case.  */
                   1793:                if (local_got_offsets == NULL)
                   1794:                  abort ();
                   1795:
                   1796:                off = local_got_offsets[r_symndx];
                   1797:                tls_type = metag_elf_local_got_tls_type (input_bfd) [r_symndx];
                   1798:              }
                   1799:
                   1800:            if (tls_type == GOT_UNKNOWN)
1.1.1.3   christos 1801:              abort ();
1.1       christos 1802:
                   1803:            if ((off & 1) != 0)
                   1804:              off &= ~1;
                   1805:            else
                   1806:              {
                   1807:                bfd_boolean need_relocs = FALSE;
                   1808:                Elf_Internal_Rela outrel;
                   1809:                bfd_byte *loc = NULL;
                   1810:                int cur_off = off;
                   1811:
                   1812:                /* The GOT entries have not been initialized yet.  Do it
                   1813:                   now, and emit any relocations.  If both an IE GOT and a
                   1814:                   GD GOT are necessary, we emit the GD first.  */
                   1815:
                   1816:                if ((bfd_link_pic (info) || indx != 0)
                   1817:                    && (hh == NULL
                   1818:                        || ELF_ST_VISIBILITY (hh->eh.other) == STV_DEFAULT
                   1819:                        || hh->eh.root.type != bfd_link_hash_undefweak))
                   1820:                  {
                   1821:                    need_relocs = TRUE;
1.1.1.3   christos 1822:                    loc = htab->etab.srelgot->contents;
1.1       christos 1823:                    /* FIXME (CAO): Should this be reloc_count++ ? */
1.1.1.3   christos 1824:                    loc += htab->etab.srelgot->reloc_count * sizeof (Elf32_External_Rela);
1.1       christos 1825:                  }
                   1826:
                   1827:                if (tls_type & GOT_TLS_GD)
                   1828:                  {
                   1829:                    if (need_relocs)
                   1830:                      {
                   1831:                        outrel.r_offset = (cur_off
1.1.1.3   christos 1832:                                           + htab->etab.sgot->output_section->vma
                   1833:                                           + htab->etab.sgot->output_offset);
1.1       christos 1834:                        outrel.r_info = ELF32_R_INFO (indx, R_METAG_TLS_DTPMOD);
                   1835:                        outrel.r_addend = 0;
1.1.1.3   christos 1836:                        bfd_put_32 (output_bfd, 0, htab->etab.sgot->contents + cur_off);
1.1       christos 1837:
                   1838:                        bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
1.1.1.3   christos 1839:                        htab->etab.srelgot->reloc_count++;
1.1       christos 1840:                        loc += sizeof (Elf32_External_Rela);
                   1841:
                   1842:                        if (indx == 0)
                   1843:                          bfd_put_32 (output_bfd, 0,
1.1.1.3   christos 1844:                                      htab->etab.sgot->contents + cur_off + 4);
1.1       christos 1845:                        else
                   1846:                          {
                   1847:                            bfd_put_32 (output_bfd, 0,
1.1.1.3   christos 1848:                                        htab->etab.sgot->contents + cur_off + 4);
1.1       christos 1849:                            outrel.r_info = ELF32_R_INFO (indx,
                   1850:                                                      R_METAG_TLS_DTPOFF);
                   1851:                            outrel.r_offset += 4;
                   1852:                            bfd_elf32_swap_reloca_out (output_bfd,
                   1853:                                                       &outrel, loc);
1.1.1.3   christos 1854:                            htab->etab.srelgot->reloc_count++;
1.1       christos 1855:                            loc += sizeof (Elf32_External_Rela);
                   1856:                          }
                   1857:                      }
                   1858:                    else
                   1859:                      {
                   1860:                        /* We don't support changing the TLS model.  */
1.1.1.3   christos 1861:                        /* PR 20675 */
                   1862:                        if (bfd_link_pic (info))
                   1863:                          _bfd_error_handler (_("%pB(%pA): multiple TLS models are not supported"),
                   1864:                                              input_bfd, input_section);
                   1865:                        else
                   1866:                          _bfd_error_handler (_("%pB(%pA): shared library symbol %s encountered whilst performing a static link"),
                   1867:                                              input_bfd, input_section, name);
                   1868:                        return FALSE;
1.1       christos 1869:                      }
                   1870:
                   1871:                    cur_off += 8;
                   1872:                  }
                   1873:
                   1874:                if (tls_type & GOT_TLS_IE)
                   1875:                  {
                   1876:                    if (need_relocs)
                   1877:                      {
                   1878:                        outrel.r_offset = (cur_off
1.1.1.3   christos 1879:                                           + htab->etab.sgot->output_section->vma
                   1880:                                           + htab->etab.sgot->output_offset);
1.1       christos 1881:                        outrel.r_info = ELF32_R_INFO (indx, R_METAG_TLS_TPOFF);
                   1882:
                   1883:                        if (indx == 0)
                   1884:                          outrel.r_addend = relocation - dtpoff_base (info);
                   1885:                        else
                   1886:                          outrel.r_addend = 0;
                   1887:
                   1888:                        bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
1.1.1.3   christos 1889:                        htab->etab.srelgot->reloc_count++;
1.1       christos 1890:                        loc += sizeof (Elf32_External_Rela);
                   1891:                      }
                   1892:                    else
                   1893:                      bfd_put_32 (output_bfd, tpoff (info, relocation),
1.1.1.3   christos 1894:                                  htab->etab.sgot->contents + cur_off);
1.1       christos 1895:
                   1896:                    cur_off += 4;
                   1897:                  }
                   1898:
                   1899:                  if (hh != NULL)
                   1900:                    hh->eh.got.offset |= 1;
                   1901:                  else
                   1902:                    local_got_offsets[r_symndx] |= 1;
                   1903:              }
                   1904:
                   1905:            /* Add the base of the GOT to the relocation value.  */
                   1906:            relocation = off - GOT_REG_OFFSET;
                   1907:
                   1908:            break;
                   1909:          }
                   1910:
                   1911:        case R_METAG_TLS_IENONPIC_HI16:
                   1912:        case R_METAG_TLS_IENONPIC_LO16:
                   1913:        case R_METAG_TLS_LE_HI16:
                   1914:        case R_METAG_TLS_LE_LO16:
                   1915:          if (bfd_link_pic (info))
                   1916:            {
1.1.1.3   christos 1917:              _bfd_error_handler
                   1918:                /* xgettext:c-format */
                   1919:                (_("%pB(%pA+%#" PRIx64 "): "
                   1920:                   "%s relocation not permitted in shared object"),
                   1921:                 input_bfd, input_section, (uint64_t) rel->r_offset,
                   1922:                 howto->name);
1.1       christos 1923:              return FALSE;
                   1924:            }
                   1925:          else
                   1926:            relocation = tpoff (info, relocation);
                   1927:          break;
                   1928:        case R_METAG_TLS_LDO_HI16:
                   1929:        case R_METAG_TLS_LDO_LO16:
                   1930:          if (! bfd_link_pic (info))
                   1931:            relocation = tpoff (info, relocation);
                   1932:          else
                   1933:            relocation -= dtpoff_base (info);
                   1934:          break;
                   1935:        case R_METAG_TLS_LDM:
                   1936:          {
                   1937:            bfd_vma off;
                   1938:
1.1.1.3   christos 1939:            if (htab->etab.sgot == NULL)
1.1       christos 1940:              abort();
                   1941:            off = htab->tls_ldm_got.offset;
                   1942:            if (off & 1)
                   1943:              off &= ~1;
                   1944:            else
                   1945:              {
                   1946:                Elf_Internal_Rela outrel;
                   1947:                bfd_byte *loc;
                   1948:
                   1949:                outrel.r_offset = (off
1.1.1.3   christos 1950:                                   + htab->etab.sgot->output_section->vma
                   1951:                                   + htab->etab.sgot->output_offset);
1.1       christos 1952:
                   1953:                outrel.r_addend = 0;
                   1954:                outrel.r_info = ELF32_R_INFO (0, R_METAG_TLS_DTPMOD);
1.1.1.3   christos 1955:                loc = htab->etab.srelgot->contents;
                   1956:                loc += htab->etab.srelgot->reloc_count++ * sizeof (Elf32_External_Rela);
1.1       christos 1957:                bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
                   1958:                htab->tls_ldm_got.offset |= 1;
                   1959:              }
                   1960:
                   1961:            relocation = off - GOT_REG_OFFSET;
                   1962:            break;
                   1963:          }
                   1964:        default:
                   1965:          break;
                   1966:        }
                   1967:
                   1968:       r = metag_final_link_relocate (howto, input_bfd, input_section,
                   1969:                                     contents, rel, relocation, hh, htab,
                   1970:                                     sec);
                   1971:
                   1972:       if (r != bfd_reloc_ok)
                   1973:        {
                   1974:          const char * msg = (const char *) NULL;
                   1975:
                   1976:          switch (r)
                   1977:            {
                   1978:            case bfd_reloc_overflow:
1.1.1.2   christos 1979:              (*info->callbacks->reloc_overflow)
1.1       christos 1980:                (info, (hh ? &hh->eh.root : NULL), name, howto->name,
                   1981:                 (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
                   1982:              break;
                   1983:
                   1984:            case bfd_reloc_undefined:
1.1.1.2   christos 1985:              (*info->callbacks->undefined_symbol)
                   1986:                (info, name, input_bfd, input_section, rel->r_offset, TRUE);
1.1       christos 1987:              break;
                   1988:
                   1989:            case bfd_reloc_outofrange:
                   1990:              msg = _("internal error: out of range error");
                   1991:              break;
                   1992:
                   1993:            case bfd_reloc_notsupported:
                   1994:              msg = _("internal error: unsupported relocation error");
                   1995:              break;
                   1996:
                   1997:            case bfd_reloc_dangerous:
                   1998:              msg = _("internal error: dangerous relocation");
                   1999:              break;
                   2000:
                   2001:            default:
                   2002:              msg = _("internal error: unknown error");
                   2003:              break;
                   2004:            }
                   2005:
                   2006:          if (msg)
1.1.1.2   christos 2007:            (*info->callbacks->warning) (info, msg, name, input_bfd,
                   2008:                                         input_section, rel->r_offset);
1.1       christos 2009:        }
                   2010:     }
                   2011:
                   2012:   return TRUE;
                   2013: }
                   2014:
                   2015: /* Create the .plt and .got sections, and set up our hash table
                   2016:    short-cuts to various dynamic sections.  */
                   2017:
                   2018: static bfd_boolean
                   2019: elf_metag_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
                   2020: {
                   2021:   struct elf_metag_link_hash_table *htab;
                   2022:   struct elf_link_hash_entry *eh;
                   2023:   struct bfd_link_hash_entry *bh;
                   2024:   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
                   2025:
                   2026:   /* Don't try to create the .plt and .got twice.  */
                   2027:   htab = metag_link_hash_table (info);
1.1.1.3   christos 2028:   if (htab->etab.splt != NULL)
1.1       christos 2029:     return TRUE;
                   2030:
                   2031:   /* Call the generic code to do most of the work.  */
                   2032:   if (! _bfd_elf_create_dynamic_sections (abfd, info))
                   2033:     return FALSE;
                   2034:
1.1.1.3   christos 2035:   /* The header goes at the start of the dynamic .got section, which
                   2036:      is placed after the dynamic .got.plt section.  ie. The header is
                   2037:      not necessarily at the start of the output .got section.  */
                   2038:   htab->etab.sgot->size += 12;
1.1       christos 2039:
1.1.1.3   christos 2040:   /* Define the symbol __GLOBAL_OFFSET_TABLE__ on the header.  */
1.1       christos 2041:   bh = NULL;
                   2042:   if (!(_bfd_generic_link_add_one_symbol
1.1.1.3   christos 2043:        (info, abfd, "__GLOBAL_OFFSET_TABLE__", BSF_GLOBAL, htab->etab.sgot,
1.1       christos 2044:         (bfd_vma) 0, NULL, FALSE, bed->collect, &bh)))
                   2045:     return FALSE;
                   2046:   eh = (struct elf_link_hash_entry *) bh;
                   2047:   eh->def_regular = 1;
                   2048:   eh->type = STT_OBJECT;
                   2049:   eh->other = STV_HIDDEN;
                   2050:
                   2051:   if (! bfd_link_executable (info)
                   2052:       && ! bfd_elf_link_record_dynamic_symbol (info, eh))
                   2053:     return FALSE;
                   2054:
1.1.1.3   christos 2055:   htab->etab.hgot = eh;
1.1       christos 2056:
                   2057:   return TRUE;
                   2058: }
                   2059:
                   2060: /* Look through the relocs for a section during the first phase, and
                   2061:    calculate needed space in the global offset table, procedure linkage
                   2062:    table, and dynamic reloc sections.  At this point we haven't
                   2063:    necessarily read all the input files.  */
                   2064:
                   2065: static bfd_boolean
                   2066: elf_metag_check_relocs (bfd *abfd,
                   2067:                        struct bfd_link_info *info,
                   2068:                        asection *sec,
                   2069:                        const Elf_Internal_Rela *relocs)
                   2070: {
                   2071:   Elf_Internal_Shdr *symtab_hdr;
                   2072:   struct elf_link_hash_entry **eh_syms;
                   2073:   const Elf_Internal_Rela *rel;
                   2074:   const Elf_Internal_Rela *rel_end;
                   2075:   struct elf_metag_link_hash_table *htab;
                   2076:   asection *sreloc;
                   2077:   bfd *dynobj;
                   2078:   int tls_type = GOT_UNKNOWN, old_tls_type = GOT_UNKNOWN;
                   2079:
                   2080:   if (bfd_link_relocatable (info))
                   2081:     return TRUE;
                   2082:
                   2083:   htab = metag_link_hash_table (info);
                   2084:   dynobj = htab->etab.dynobj;
                   2085:   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
                   2086:   eh_syms = elf_sym_hashes (abfd);
                   2087:   sreloc = NULL;
                   2088:
                   2089:   if (htab == NULL)
                   2090:     return FALSE;
                   2091:
                   2092:   rel_end = relocs + sec->reloc_count;
                   2093:   for (rel = relocs; rel < rel_end; rel++)
                   2094:     {
                   2095:       int r_type;
                   2096:       struct elf_metag_link_hash_entry *hh;
                   2097:       Elf_Internal_Sym *isym;
                   2098:       unsigned long r_symndx;
                   2099:
                   2100:       r_symndx = ELF32_R_SYM (rel->r_info);
                   2101:       r_type = ELF32_R_TYPE (rel->r_info);
                   2102:       if (r_symndx < symtab_hdr->sh_info)
                   2103:        {
                   2104:          /* A local symbol.  */
                   2105:          isym = bfd_sym_from_r_symndx (&htab->sym_cache,
                   2106:                                        abfd, r_symndx);
                   2107:          if (isym == NULL)
                   2108:            return FALSE;
                   2109:
                   2110:          hh = NULL;
                   2111:        }
                   2112:       else
                   2113:        {
                   2114:          isym = NULL;
                   2115:
                   2116:          hh = (struct elf_metag_link_hash_entry *)
                   2117:            eh_syms[r_symndx - symtab_hdr->sh_info];
                   2118:          while (hh->eh.root.type == bfd_link_hash_indirect
                   2119:                 || hh->eh.root.type == bfd_link_hash_warning)
                   2120:            hh = (struct elf_metag_link_hash_entry *) hh->eh.root.u.i.link;
                   2121:        }
                   2122:
                   2123:       /* Some relocs require a global offset table.  */
1.1.1.3   christos 2124:       if (htab->etab.sgot == NULL)
1.1       christos 2125:        {
                   2126:          switch (r_type)
                   2127:            {
                   2128:            case R_METAG_TLS_GD:
                   2129:            case R_METAG_TLS_LDM:
                   2130:            case R_METAG_TLS_IE:
                   2131:              if (bfd_link_pic (info))
                   2132:                info->flags |= DF_STATIC_TLS;
                   2133:              /* Fall through.  */
                   2134:
                   2135:            case R_METAG_HI16_GOTOFF:
                   2136:            case R_METAG_LO16_GOTOFF:
                   2137:            case R_METAG_GETSET_GOTOFF:
                   2138:            case R_METAG_GETSET_GOT:
                   2139:            case R_METAG_HI16_GOTPC:
                   2140:            case R_METAG_LO16_GOTPC:
                   2141:              if (dynobj == NULL)
                   2142:                htab->etab.dynobj = dynobj = abfd;
                   2143:              if (!elf_metag_create_dynamic_sections (dynobj, info))
                   2144:                return FALSE;
                   2145:              break;
                   2146:
                   2147:            default:
                   2148:              break;
                   2149:            }
                   2150:        }
                   2151:
                   2152:       switch (r_type)
                   2153:        {
                   2154:        case R_METAG_TLS_IE:
                   2155:        case R_METAG_TLS_GD:
                   2156:        case R_METAG_GETSET_GOT:
                   2157:          switch (r_type)
                   2158:            {
                   2159:            default:
                   2160:              tls_type = GOT_NORMAL;
                   2161:              break;
                   2162:            case R_METAG_TLS_IE:
                   2163:              tls_type = GOT_TLS_IE;
                   2164:              break;
                   2165:            case R_METAG_TLS_GD:
                   2166:              tls_type = GOT_TLS_GD;
                   2167:              break;
                   2168:            }
                   2169:
                   2170:          if (hh != NULL)
                   2171:            {
                   2172:              hh->eh.got.refcount += 1;
                   2173:              old_tls_type = hh->tls_type;
                   2174:            }
                   2175:          else
                   2176:            {
                   2177:              bfd_signed_vma *local_got_refcounts;
                   2178:
                   2179:              /* This is a global offset table entry for a local
                   2180:                 symbol.  */
                   2181:              local_got_refcounts = elf_local_got_refcounts (abfd);
                   2182:              if (local_got_refcounts == NULL)
                   2183:                {
                   2184:                  bfd_size_type size;
                   2185:
                   2186:                  size = symtab_hdr->sh_info;
                   2187:                  size *= sizeof (bfd_signed_vma);
                   2188:                  /* Add in space to store the local GOT TLS types.  */
                   2189:                  size += symtab_hdr->sh_info;
                   2190:                  local_got_refcounts = ((bfd_signed_vma *)
                   2191:                                         bfd_zalloc (abfd, size));
                   2192:                  if (local_got_refcounts == NULL)
                   2193:                    return FALSE;
                   2194:                  elf_local_got_refcounts (abfd) = local_got_refcounts;
                   2195:                  memset (metag_elf_local_got_tls_type (abfd),
                   2196:                          GOT_UNKNOWN, symtab_hdr->sh_info);
                   2197:                }
                   2198:              local_got_refcounts[r_symndx] += 1;
                   2199:              old_tls_type = metag_elf_local_got_tls_type (abfd) [r_symndx];
                   2200:            }
                   2201:
                   2202:          if (old_tls_type != tls_type)
                   2203:            {
                   2204:              if (hh != NULL)
                   2205:                {
                   2206:                  hh->tls_type = tls_type;
                   2207:                }
                   2208:              else
                   2209:                {
                   2210:                  metag_elf_local_got_tls_type (abfd) [r_symndx] = tls_type;
                   2211:                }
                   2212:            }
                   2213:
                   2214:          break;
                   2215:
                   2216:        case R_METAG_TLS_LDM:
                   2217:          metag_link_hash_table (info)->tls_ldm_got.refcount += 1;
                   2218:          break;
                   2219:
                   2220:        case R_METAG_RELBRANCH_PLT:
                   2221:          /* This symbol requires a procedure linkage table entry.  We
                   2222:             actually build the entry in adjust_dynamic_symbol,
                   2223:             because this might be a case of linking PIC code without
                   2224:             linking in any dynamic objects, in which case we don't
                   2225:             need to generate a procedure linkage table after all.  */
                   2226:
                   2227:          /* If this is a local symbol, we resolve it directly without
                   2228:             creating a procedure linkage table entry.  */
                   2229:          if (hh == NULL)
                   2230:            continue;
                   2231:
                   2232:          if (hh->eh.forced_local)
                   2233:            break;
                   2234:
                   2235:          hh->eh.needs_plt = 1;
                   2236:          hh->eh.plt.refcount += 1;
                   2237:          break;
                   2238:
                   2239:        case R_METAG_HIADDR16:
                   2240:        case R_METAG_LOADDR16:
                   2241:          /* Let's help debug shared library creation.  These relocs
                   2242:             cannot be used in shared libs.  Don't error out for
                   2243:             sections we don't care about, such as debug sections or
                   2244:             non-constant sections.  */
                   2245:          if (bfd_link_pic (info)
                   2246:              && (sec->flags & SEC_ALLOC) != 0
                   2247:              && (sec->flags & SEC_READONLY) != 0)
                   2248:            {
                   2249:              const char *name;
                   2250:
                   2251:              if (hh)
                   2252:                name = hh->eh.root.root.string;
                   2253:              else
                   2254:                name = bfd_elf_sym_name (abfd, symtab_hdr, isym, NULL);
1.1.1.3   christos 2255:              _bfd_error_handler
                   2256:                /* xgettext:c-format */
                   2257:                (_("%pB: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
1.1       christos 2258:                 abfd, elf_metag_howto_table[r_type].name, name);
                   2259:              bfd_set_error (bfd_error_bad_value);
                   2260:              return FALSE;
                   2261:            }
                   2262:
                   2263:          /* Fall through.  */
                   2264:        case R_METAG_ADDR32:
                   2265:        case R_METAG_RELBRANCH:
                   2266:        case R_METAG_GETSETOFF:
                   2267:          if (hh != NULL && !bfd_link_pic (info))
                   2268:            {
                   2269:              hh->eh.non_got_ref = 1;
                   2270:              hh->eh.plt.refcount += 1;
                   2271:            }
                   2272:
                   2273:          /* If we are creating a shared library, and this is a reloc
                   2274:             against a global symbol, or a non PC relative reloc
                   2275:             against a local symbol, then we need to copy the reloc
                   2276:             into the shared library.  However, if we are linking with
                   2277:             -Bsymbolic, we do not need to copy a reloc against a
                   2278:             global symbol which is defined in an object we are
                   2279:             including in the link (i.e., DEF_REGULAR is set).  At
                   2280:             this point we have not seen all the input files, so it is
                   2281:             possible that DEF_REGULAR is not set now but will be set
                   2282:             later (it is never cleared).  We account for that
                   2283:             possibility below by storing information in the
                   2284:             dyn_relocs field of the hash table entry. A similar
                   2285:             situation occurs when creating shared libraries and symbol
                   2286:             visibility changes render the symbol local.
                   2287:
                   2288:             If on the other hand, we are creating an executable, we
                   2289:             may need to keep relocations for symbols satisfied by a
                   2290:             dynamic library if we manage to avoid copy relocs for the
                   2291:             symbol.  */
                   2292:          if ((bfd_link_pic (info)
                   2293:               && (sec->flags & SEC_ALLOC) != 0
                   2294:               && (r_type != R_METAG_RELBRANCH
                   2295:                   || (hh != NULL
                   2296:                       && (! info->symbolic
                   2297:                           || hh->eh.root.type == bfd_link_hash_defweak
                   2298:                           || !hh->eh.def_regular))))
                   2299:              || (!bfd_link_pic (info)
                   2300:                  && (sec->flags & SEC_ALLOC) != 0
                   2301:                  && hh != NULL
                   2302:                  && (hh->eh.root.type == bfd_link_hash_defweak
                   2303:                      || !hh->eh.def_regular)))
                   2304:            {
1.1.1.3   christos 2305:              struct elf_dyn_relocs *hdh_p;
                   2306:              struct elf_dyn_relocs **hdh_head;
1.1       christos 2307:
                   2308:              if (dynobj == NULL)
                   2309:                htab->etab.dynobj = dynobj = abfd;
                   2310:
                   2311:              /* When creating a shared object, we must copy these
                   2312:                 relocs into the output file.  We create a reloc
                   2313:                 section in dynobj and make room for the reloc.  */
                   2314:              if (sreloc == NULL)
                   2315:                {
                   2316:                  sreloc = _bfd_elf_make_dynamic_reloc_section
                   2317:                    (sec, htab->etab.dynobj, 2, abfd, /*rela?*/ TRUE);
                   2318:
                   2319:                  if (sreloc == NULL)
                   2320:                    {
                   2321:                      bfd_set_error (bfd_error_bad_value);
                   2322:                      return FALSE;
                   2323:                    }
                   2324:
                   2325:                  elf_section_data (sec)->sreloc = sreloc;
                   2326:                }
                   2327:
                   2328:              /* If this is a global symbol, we count the number of
                   2329:                 relocations we need for this symbol.  */
                   2330:              if (hh != NULL)
                   2331:                hdh_head = &((struct elf_metag_link_hash_entry *) hh)->dyn_relocs;
                   2332:              else
                   2333:                {
                   2334:                  /* Track dynamic relocs needed for local syms too.  */
                   2335:                  asection *sr;
                   2336:                  void *vpp;
                   2337:
                   2338:                  sr = bfd_section_from_elf_index (abfd, isym->st_shndx);
                   2339:                  if (sr == NULL)
                   2340:                    sr = sec;
                   2341:
                   2342:                  vpp = &elf_section_data (sr)->local_dynrel;
1.1.1.3   christos 2343:                  hdh_head = (struct elf_dyn_relocs **) vpp;
1.1       christos 2344:                }
                   2345:
                   2346:              hdh_p = *hdh_head;
                   2347:              if (hdh_p == NULL || hdh_p->sec != sec)
                   2348:                {
1.1.1.3   christos 2349:                  hdh_p = ((struct elf_dyn_relocs *)
1.1       christos 2350:                           bfd_alloc (dynobj, sizeof *hdh_p));
                   2351:                  if (hdh_p == NULL)
                   2352:                    return FALSE;
1.1.1.3   christos 2353:                  hdh_p->next = *hdh_head;
1.1       christos 2354:                  *hdh_head = hdh_p;
                   2355:                  hdh_p->sec = sec;
                   2356:                  hdh_p->count = 0;
1.1.1.3   christos 2357:                  hdh_p->pc_count = 0;
1.1       christos 2358:                }
                   2359:
                   2360:              hdh_p->count += 1;
                   2361:              if (ELF32_R_TYPE (rel->r_info) == R_METAG_RELBRANCH)
1.1.1.3   christos 2362:                hdh_p->pc_count += 1;
1.1       christos 2363:            }
                   2364:          break;
                   2365:
                   2366:          /* This relocation describes the C++ object vtable hierarchy.
                   2367:             Reconstruct it for later use during GC.  */
                   2368:        case R_METAG_GNU_VTINHERIT:
                   2369:          if (!bfd_elf_gc_record_vtinherit (abfd, sec, &hh->eh,
                   2370:                                            rel->r_offset))
                   2371:            return FALSE;
                   2372:          break;
                   2373:
                   2374:          /* This relocation describes which C++ vtable entries are actually
                   2375:             used.  Record for later use during GC.  */
                   2376:        case R_METAG_GNU_VTENTRY:
1.1.1.4 ! christos 2377:          if (!bfd_elf_gc_record_vtentry (abfd, sec, &hh->eh, rel->r_addend))
1.1       christos 2378:            return FALSE;
                   2379:          break;
                   2380:        }
                   2381:     }
                   2382:
                   2383:   return TRUE;
                   2384: }
                   2385:
                   2386: /* Copy the extra info we tack onto an elf_link_hash_entry.  */
                   2387:
                   2388: static void
                   2389: elf_metag_copy_indirect_symbol (struct bfd_link_info *info,
                   2390:                                struct elf_link_hash_entry *eh_dir,
                   2391:                                struct elf_link_hash_entry *eh_ind)
                   2392: {
                   2393:   struct elf_metag_link_hash_entry *hh_dir, *hh_ind;
                   2394:
                   2395:   hh_dir = metag_elf_hash_entry (eh_dir);
                   2396:   hh_ind = metag_elf_hash_entry (eh_ind);
                   2397:
                   2398:   if (hh_ind->dyn_relocs != NULL)
                   2399:     {
                   2400:       if (hh_dir->dyn_relocs != NULL)
                   2401:        {
1.1.1.3   christos 2402:          struct elf_dyn_relocs **hdh_pp;
                   2403:          struct elf_dyn_relocs *hdh_p;
1.1       christos 2404:
                   2405:          if (eh_ind->root.type == bfd_link_hash_indirect)
                   2406:            abort ();
                   2407:
                   2408:          /* Add reloc counts against the weak sym to the strong sym
                   2409:             list.  Merge any entries against the same section.  */
                   2410:          for (hdh_pp = &hh_ind->dyn_relocs; (hdh_p = *hdh_pp) != NULL; )
                   2411:            {
1.1.1.3   christos 2412:              struct elf_dyn_relocs *hdh_q;
1.1       christos 2413:
                   2414:              for (hdh_q = hh_dir->dyn_relocs; hdh_q != NULL;
1.1.1.3   christos 2415:                   hdh_q = hdh_q->next)
1.1       christos 2416:                if (hdh_q->sec == hdh_p->sec)
                   2417:                  {
1.1.1.3   christos 2418:                    hdh_q->pc_count += hdh_p->pc_count;
1.1       christos 2419:                    hdh_q->count += hdh_p->count;
1.1.1.3   christos 2420:                    *hdh_pp = hdh_p->next;
1.1       christos 2421:                    break;
                   2422:                  }
                   2423:              if (hdh_q == NULL)
1.1.1.3   christos 2424:                hdh_pp = &hdh_p->next;
1.1       christos 2425:            }
                   2426:          *hdh_pp = hh_dir->dyn_relocs;
                   2427:        }
                   2428:
                   2429:       hh_dir->dyn_relocs = hh_ind->dyn_relocs;
                   2430:       hh_ind->dyn_relocs = NULL;
                   2431:     }
                   2432:
                   2433:   if (eh_ind->root.type == bfd_link_hash_indirect
                   2434:       && eh_dir->got.refcount <= 0)
                   2435:     {
                   2436:       hh_dir->tls_type = hh_ind->tls_type;
                   2437:       hh_ind->tls_type = GOT_UNKNOWN;
                   2438:     }
                   2439:
                   2440:   _bfd_elf_link_hash_copy_indirect (info, eh_dir, eh_ind);
                   2441: }
                   2442:
1.1.1.3   christos 2443: /* Find dynamic relocs for H that apply to read-only sections.  */
                   2444:
                   2445: static asection *
                   2446: readonly_dynrelocs (struct elf_link_hash_entry *h)
                   2447: {
                   2448:   struct elf_dyn_relocs *p;
                   2449:
                   2450:   for (p = metag_elf_hash_entry (h)->dyn_relocs; p != NULL; p = p->next)
                   2451:     {
                   2452:       asection *s = p->sec->output_section;
                   2453:
                   2454:       if (s != NULL && (s->flags & SEC_READONLY) != 0)
                   2455:        return p->sec;
                   2456:     }
                   2457:   return NULL;
                   2458: }
                   2459:
1.1       christos 2460: /* Adjust a symbol defined by a dynamic object and referenced by a
                   2461:    regular object.  The current definition is in some section of the
                   2462:    dynamic object, but we're not including those sections.  We have to
                   2463:    change the definition to something the rest of the link can
                   2464:    understand.  */
                   2465:
                   2466: static bfd_boolean
                   2467: elf_metag_adjust_dynamic_symbol (struct bfd_link_info *info,
                   2468:                                 struct elf_link_hash_entry *eh)
                   2469: {
                   2470:   struct elf_metag_link_hash_table *htab;
1.1.1.3   christos 2471:   asection *s, *srel;
1.1       christos 2472:
                   2473:   /* If this is a function, put it in the procedure linkage table.  We
                   2474:      will fill in the contents of the procedure linkage table later,
                   2475:      when we know the address of the .got section.  */
                   2476:   if (eh->type == STT_FUNC
                   2477:       || eh->needs_plt)
                   2478:     {
                   2479:       if (eh->plt.refcount <= 0
                   2480:          || SYMBOL_CALLS_LOCAL (info, eh)
                   2481:          || (ELF_ST_VISIBILITY (eh->other) != STV_DEFAULT
                   2482:              && eh->root.type == bfd_link_hash_undefweak))
                   2483:        {
                   2484:          /* This case can occur if we saw a PLT reloc in an input
                   2485:             file, but the symbol was never referred to by a dynamic
                   2486:             object.  In such a case, we don't actually need to build
                   2487:             a procedure linkage table, and we can just do a PCREL
                   2488:             reloc instead.  */
                   2489:          eh->plt.offset = (bfd_vma) -1;
                   2490:          eh->needs_plt = 0;
                   2491:        }
                   2492:
                   2493:       return TRUE;
                   2494:     }
                   2495:   else
                   2496:     eh->plt.offset = (bfd_vma) -1;
                   2497:
                   2498:   /* If this is a weak symbol, and there is a real definition, the
                   2499:      processor independent code will have arranged for us to see the
                   2500:      real definition first, and we can just use the same value.  */
1.1.1.3   christos 2501:   if (eh->is_weakalias)
1.1       christos 2502:     {
1.1.1.3   christos 2503:       struct elf_link_hash_entry *def = weakdef (eh);
                   2504:       BFD_ASSERT (def->root.type == bfd_link_hash_defined);
                   2505:       eh->root.u.def.section = def->root.u.def.section;
                   2506:       eh->root.u.def.value = def->root.u.def.value;
                   2507:       eh->non_got_ref = def->non_got_ref;
1.1       christos 2508:       return TRUE;
                   2509:     }
                   2510:
                   2511:   /* This is a reference to a symbol defined by a dynamic object which
                   2512:      is not a function.  */
                   2513:
                   2514:   /* If we are creating a shared library, we must presume that the
                   2515:      only references to the symbol are via the global offset table.
                   2516:      For such cases we need not do anything here; the relocations will
                   2517:      be handled correctly by relocate_section.  */
                   2518:   if (bfd_link_pic (info))
                   2519:     return TRUE;
                   2520:
                   2521:   /* If there are no references to this symbol that do not use the
                   2522:      GOT, we don't need to generate a copy reloc.  */
                   2523:   if (!eh->non_got_ref)
                   2524:     return TRUE;
                   2525:
                   2526:   /* If -z nocopyreloc was given, we won't generate them either.  */
                   2527:   if (info->nocopyreloc)
                   2528:     {
                   2529:       eh->non_got_ref = 0;
                   2530:       return TRUE;
                   2531:     }
                   2532:
1.1.1.3   christos 2533:   /* If we don't find any dynamic relocs in read-only sections, then
1.1       christos 2534:      we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
1.1.1.3   christos 2535:   if (!readonly_dynrelocs (eh))
1.1       christos 2536:     {
                   2537:       eh->non_got_ref = 0;
                   2538:       return TRUE;
                   2539:     }
                   2540:
                   2541:   /* We must allocate the symbol in our .dynbss section, which will
                   2542:      become part of the .bss section of the executable.  There will be
                   2543:      an entry for this symbol in the .dynsym section.  The dynamic
                   2544:      object will contain position independent code, so all references
                   2545:      from the dynamic object to this symbol will go through the global
                   2546:      offset table.  The dynamic linker will use the .dynsym entry to
                   2547:      determine the address it must put in the global offset table, so
                   2548:      both the dynamic object and the regular object will refer to the
                   2549:      same memory location for the variable.  */
                   2550:
                   2551:   htab = metag_link_hash_table (info);
                   2552:
                   2553:   /* We must generate a COPY reloc to tell the dynamic linker to
                   2554:      copy the initial value out of the dynamic object and into the
                   2555:      runtime process image.  */
1.1.1.3   christos 2556:   if ((eh->root.u.def.section->flags & SEC_READONLY) != 0)
                   2557:     {
                   2558:       s = htab->etab.sdynrelro;
                   2559:       srel = htab->etab.sreldynrelro;
                   2560:     }
                   2561:   else
                   2562:     {
                   2563:       s = htab->etab.sdynbss;
                   2564:       srel = htab->etab.srelbss;
                   2565:     }
1.1       christos 2566:   if ((eh->root.u.def.section->flags & SEC_ALLOC) != 0 && eh->size != 0)
                   2567:     {
1.1.1.3   christos 2568:       srel->size += sizeof (Elf32_External_Rela);
1.1       christos 2569:       eh->needs_copy = 1;
                   2570:     }
                   2571:
                   2572:   return _bfd_elf_adjust_dynamic_copy (info, eh, s);
                   2573: }
                   2574:
                   2575: /* Allocate space in .plt, .got and associated reloc sections for
                   2576:    global syms.  */
                   2577:
                   2578: static bfd_boolean
                   2579: allocate_dynrelocs (struct elf_link_hash_entry *eh, void *inf)
                   2580: {
                   2581:   struct bfd_link_info *info;
                   2582:   struct elf_metag_link_hash_table *htab;
                   2583:   struct elf_metag_link_hash_entry *hh;
1.1.1.3   christos 2584:   struct elf_dyn_relocs *hdh_p;
1.1       christos 2585:
                   2586:   if (eh->root.type == bfd_link_hash_indirect)
                   2587:     return TRUE;
                   2588:
                   2589:   if (eh->root.type == bfd_link_hash_warning)
                   2590:     eh = (struct elf_link_hash_entry *) eh->root.u.i.link;
                   2591:
                   2592:   info = inf;
                   2593:   htab = metag_link_hash_table (info);
                   2594:
                   2595:   if (htab->etab.dynamic_sections_created
                   2596:       && eh->plt.refcount > 0)
                   2597:     {
                   2598:       /* Make sure this symbol is output as a dynamic symbol.
                   2599:         Undefined weak syms won't yet be marked as dynamic.  */
                   2600:       if (eh->dynindx == -1
                   2601:          && !eh->forced_local)
                   2602:        {
                   2603:          if (! bfd_elf_link_record_dynamic_symbol (info, eh))
                   2604:            return FALSE;
                   2605:        }
                   2606:
                   2607:       if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info), eh))
                   2608:        {
1.1.1.3   christos 2609:          asection *s = htab->etab.splt;
1.1       christos 2610:
                   2611:          /* If this is the first .plt entry, make room for the special
                   2612:             first entry.  */
                   2613:          if (s->size == 0)
                   2614:            s->size += PLT_ENTRY_SIZE;
                   2615:
                   2616:          eh->plt.offset = s->size;
                   2617:
                   2618:          /* If this symbol is not defined in a regular file, and we are
                   2619:             not generating a shared library, then set the symbol to this
                   2620:             location in the .plt.  This is required to make function
                   2621:             pointers compare as equal between the normal executable and
                   2622:             the shared library.  */
                   2623:          if (! bfd_link_pic (info)
                   2624:              && !eh->def_regular)
                   2625:            {
                   2626:              eh->root.u.def.section = s;
                   2627:              eh->root.u.def.value = eh->plt.offset;
                   2628:            }
                   2629:
                   2630:          /* Make room for this entry.  */
                   2631:          s->size += PLT_ENTRY_SIZE;
                   2632:
                   2633:          /* We also need to make an entry in the .got.plt section, which
                   2634:             will be placed in the .got section by the linker script.  */
1.1.1.3   christos 2635:          htab->etab.sgotplt->size += 4;
1.1       christos 2636:
                   2637:          /* We also need to make an entry in the .rel.plt section.  */
1.1.1.3   christos 2638:          htab->etab.srelplt->size += sizeof (Elf32_External_Rela);
1.1       christos 2639:        }
                   2640:       else
                   2641:        {
                   2642:          eh->plt.offset = (bfd_vma) -1;
                   2643:          eh->needs_plt = 0;
                   2644:        }
                   2645:     }
                   2646:   else
                   2647:     {
                   2648:       eh->plt.offset = (bfd_vma) -1;
                   2649:       eh->needs_plt = 0;
                   2650:     }
                   2651:
                   2652:   if (eh->got.refcount > 0)
                   2653:     {
                   2654:       asection *s;
                   2655:       bfd_boolean dyn;
                   2656:       int tls_type = metag_elf_hash_entry (eh)->tls_type;
                   2657:
                   2658:       /* Make sure this symbol is output as a dynamic symbol.
                   2659:         Undefined weak syms won't yet be marked as dynamic.  */
                   2660:       if (eh->dynindx == -1
                   2661:          && !eh->forced_local)
                   2662:        {
                   2663:          if (! bfd_elf_link_record_dynamic_symbol (info, eh))
                   2664:            return FALSE;
                   2665:        }
                   2666:
1.1.1.3   christos 2667:       s = htab->etab.sgot;
1.1       christos 2668:
                   2669:       eh->got.offset = s->size;
                   2670:       s->size += 4;
                   2671:       /* R_METAG_TLS_GD needs 2 consecutive GOT slots.  */
                   2672:       if (tls_type == GOT_TLS_GD)
                   2673:          s->size += 4;
                   2674:       dyn = htab->etab.dynamic_sections_created;
                   2675:       /* R_METAG_TLS_IE needs one dynamic relocation if dynamic,
                   2676:         R_METAG_TLS_GD needs one if local symbol and two if global.  */
                   2677:       if ((tls_type == GOT_TLS_GD && eh->dynindx == -1)
                   2678:          || (tls_type == GOT_TLS_IE && dyn))
1.1.1.3   christos 2679:        htab->etab.srelgot->size += sizeof (Elf32_External_Rela);
1.1       christos 2680:       else if (tls_type == GOT_TLS_GD)
1.1.1.3   christos 2681:          htab->etab.srelgot->size += 2 * sizeof (Elf32_External_Rela);
1.1       christos 2682:       else if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
                   2683:                                                bfd_link_pic (info),
                   2684:                                                eh))
1.1.1.3   christos 2685:          htab->etab.srelgot->size += sizeof (Elf32_External_Rela);
1.1       christos 2686:     }
                   2687:   else
                   2688:     eh->got.offset = (bfd_vma) -1;
                   2689:
                   2690:   hh = (struct elf_metag_link_hash_entry *) eh;
                   2691:   if (hh->dyn_relocs == NULL)
                   2692:     return TRUE;
                   2693:
                   2694:   /* If this is a -Bsymbolic shared link, then we need to discard all
                   2695:      space allocated for dynamic pc-relative relocs against symbols
                   2696:      defined in a regular object.  For the normal shared case, discard
                   2697:      space for relocs that have become local due to symbol visibility
                   2698:      changes.  */
                   2699:   if (bfd_link_pic (info))
                   2700:     {
                   2701:       if (SYMBOL_CALLS_LOCAL (info, eh))
                   2702:        {
1.1.1.3   christos 2703:          struct elf_dyn_relocs **hdh_pp;
1.1       christos 2704:
                   2705:          for (hdh_pp = &hh->dyn_relocs; (hdh_p = *hdh_pp) != NULL; )
                   2706:            {
1.1.1.3   christos 2707:              hdh_p->count -= hdh_p->pc_count;
                   2708:              hdh_p->pc_count = 0;
1.1       christos 2709:              if (hdh_p->count == 0)
1.1.1.3   christos 2710:                *hdh_pp = hdh_p->next;
1.1       christos 2711:              else
1.1.1.3   christos 2712:                hdh_pp = &hdh_p->next;
1.1       christos 2713:            }
                   2714:        }
                   2715:
                   2716:       /* Also discard relocs on undefined weak syms with non-default
                   2717:         visibility.  */
                   2718:       if (hh->dyn_relocs != NULL
                   2719:          && eh->root.type == bfd_link_hash_undefweak)
                   2720:        {
                   2721:          if (ELF_ST_VISIBILITY (eh->other) != STV_DEFAULT)
                   2722:            hh->dyn_relocs = NULL;
                   2723:
                   2724:          /* Make sure undefined weak symbols are output as a dynamic
                   2725:             symbol in PIEs.  */
                   2726:          else if (eh->dynindx == -1
                   2727:                   && !eh->forced_local)
                   2728:            {
                   2729:              if (! bfd_elf_link_record_dynamic_symbol (info, eh))
                   2730:                return FALSE;
                   2731:            }
                   2732:        }
                   2733:     }
                   2734:   else
                   2735:     {
                   2736:       /* For the non-shared case, discard space for relocs against
                   2737:         symbols which turn out to need copy relocs or are not
                   2738:         dynamic.  */
                   2739:       if (!eh->non_got_ref
                   2740:          && ((eh->def_dynamic
                   2741:               && !eh->def_regular)
                   2742:              || (htab->etab.dynamic_sections_created
                   2743:                  && (eh->root.type == bfd_link_hash_undefweak
                   2744:                      || eh->root.type == bfd_link_hash_undefined))))
                   2745:        {
                   2746:          /* Make sure this symbol is output as a dynamic symbol.
                   2747:             Undefined weak syms won't yet be marked as dynamic.  */
                   2748:          if (eh->dynindx == -1
                   2749:              && !eh->forced_local)
                   2750:            {
                   2751:              if (! bfd_elf_link_record_dynamic_symbol (info, eh))
                   2752:                return FALSE;
                   2753:            }
                   2754:
                   2755:          /* If that succeeded, we know we'll be keeping all the
                   2756:             relocs.  */
                   2757:          if (eh->dynindx != -1)
                   2758:            goto keep;
                   2759:        }
                   2760:
                   2761:       hh->dyn_relocs = NULL;
                   2762:       return TRUE;
                   2763:
                   2764:     keep: ;
                   2765:     }
                   2766:
                   2767:   /* Finally, allocate space.  */
1.1.1.3   christos 2768:   for (hdh_p = hh->dyn_relocs; hdh_p != NULL; hdh_p = hdh_p->next)
1.1       christos 2769:     {
                   2770:       asection *sreloc = elf_section_data (hdh_p->sec)->sreloc;
                   2771:       sreloc->size += hdh_p->count * sizeof (Elf32_External_Rela);
                   2772:     }
                   2773:
                   2774:   return TRUE;
                   2775: }
                   2776:
1.1.1.3   christos 2777: /* Set DF_TEXTREL if we find any dynamic relocs that apply to
                   2778:    read-only sections.  */
1.1       christos 2779:
                   2780: static bfd_boolean
1.1.1.3   christos 2781: maybe_set_textrel (struct elf_link_hash_entry *h, void *info_p)
1.1       christos 2782: {
1.1.1.3   christos 2783:   asection *sec;
1.1       christos 2784:
1.1.1.3   christos 2785:   if (h->root.type == bfd_link_hash_indirect)
                   2786:     return TRUE;
1.1       christos 2787:
1.1.1.3   christos 2788:   sec = readonly_dynrelocs (h);
                   2789:   if (sec != NULL)
1.1       christos 2790:     {
1.1.1.3   christos 2791:       struct bfd_link_info *info = (struct bfd_link_info *) info_p;
1.1       christos 2792:
1.1.1.3   christos 2793:       info->flags |= DF_TEXTREL;
                   2794:       info->callbacks->minfo
                   2795:        (_("%pB: dynamic relocation against `%pT' in read-only section `%pA'\n"),
                   2796:         sec->owner, h->root.root.string, sec);
1.1       christos 2797:
1.1.1.3   christos 2798:       /* Not an error, just cut short the traversal.  */
                   2799:       return FALSE;
1.1       christos 2800:     }
                   2801:   return TRUE;
                   2802: }
                   2803:
                   2804: /* Set the sizes of the dynamic sections.  */
                   2805:
                   2806: static bfd_boolean
                   2807: elf_metag_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
                   2808:                                 struct bfd_link_info *info)
                   2809: {
                   2810:   struct elf_metag_link_hash_table *htab;
                   2811:   bfd *dynobj;
                   2812:   bfd *ibfd;
                   2813:   asection *s;
                   2814:   bfd_boolean relocs;
                   2815:
                   2816:   htab = metag_link_hash_table (info);
                   2817:   dynobj = htab->etab.dynobj;
                   2818:   if (dynobj == NULL)
                   2819:     abort ();
                   2820:
                   2821:   if (htab->etab.dynamic_sections_created)
                   2822:     {
                   2823:       /* Set the contents of the .interp section to the interpreter.  */
                   2824:       if (bfd_link_executable (info) && !info->nointerp)
                   2825:        {
                   2826:          s = bfd_get_linker_section (dynobj, ".interp");
                   2827:          if (s == NULL)
                   2828:            abort ();
                   2829:          s->size = sizeof ELF_DYNAMIC_INTERPRETER;
                   2830:          s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
                   2831:        }
                   2832:     }
                   2833:
                   2834:   /* Set up .got offsets for local syms, and space for local dynamic
                   2835:      relocs.  */
                   2836:   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
                   2837:     {
                   2838:       bfd_signed_vma *local_got;
                   2839:       bfd_signed_vma *end_local_got;
                   2840:       bfd_size_type locsymcount;
                   2841:       Elf_Internal_Shdr *symtab_hdr;
                   2842:       asection *srel;
                   2843:       char *local_tls_type;
                   2844:
                   2845:       if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
                   2846:        continue;
                   2847:
                   2848:       for (s = ibfd->sections; s != NULL; s = s->next)
                   2849:        {
1.1.1.3   christos 2850:          struct elf_dyn_relocs *hdh_p;
1.1       christos 2851:
1.1.1.3   christos 2852:          for (hdh_p = ((struct elf_dyn_relocs *)
1.1       christos 2853:                        elf_section_data (s)->local_dynrel);
                   2854:               hdh_p != NULL;
1.1.1.3   christos 2855:               hdh_p = hdh_p->next)
1.1       christos 2856:            {
                   2857:              if (!bfd_is_abs_section (hdh_p->sec)
                   2858:                  && bfd_is_abs_section (hdh_p->sec->output_section))
                   2859:                {
                   2860:                  /* Input section has been discarded, either because
                   2861:                     it is a copy of a linkonce section or due to
                   2862:                     linker script /DISCARD/, so we'll be discarding
                   2863:                     the relocs too.  */
                   2864:                }
                   2865:              else if (hdh_p->count != 0)
                   2866:                {
                   2867:                  srel = elf_section_data (hdh_p->sec)->sreloc;
                   2868:                  srel->size += hdh_p->count * sizeof (Elf32_External_Rela);
                   2869:                  if ((hdh_p->sec->output_section->flags & SEC_READONLY) != 0)
                   2870:                    info->flags |= DF_TEXTREL;
                   2871:                }
                   2872:            }
                   2873:        }
                   2874:
                   2875:       local_got = elf_local_got_refcounts (ibfd);
                   2876:       if (!local_got)
                   2877:        continue;
                   2878:
                   2879:       symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
                   2880:       locsymcount = symtab_hdr->sh_info;
                   2881:       end_local_got = local_got + locsymcount;
                   2882:       local_tls_type = metag_elf_local_got_tls_type (ibfd);
1.1.1.3   christos 2883:       s = htab->etab.sgot;
                   2884:       srel = htab->etab.srelgot;
1.1       christos 2885:       for (; local_got < end_local_got; ++local_got)
                   2886:        {
                   2887:          if (*local_got > 0)
                   2888:            {
                   2889:              *local_got = s->size;
                   2890:              s->size += GOT_ENTRY_SIZE;
                   2891:              /* R_METAG_TLS_GD relocs need 2 consecutive GOT entries.  */
                   2892:              if (*local_tls_type == GOT_TLS_GD)
                   2893:                s->size += 4;
                   2894:              if (bfd_link_pic (info))
                   2895:                srel->size += sizeof (Elf32_External_Rela);
                   2896:            }
                   2897:          else
                   2898:            *local_got = (bfd_vma) -1;
                   2899:          ++local_tls_type;
                   2900:        }
                   2901:     }
                   2902:
                   2903:   if (htab->tls_ldm_got.refcount > 0)
                   2904:     {
                   2905:       /* Allocate 2 got entries and 1 dynamic reloc for R_METAG_TLS_LDM
                   2906:         reloc.  */
1.1.1.3   christos 2907:       htab->tls_ldm_got.offset = htab->etab.sgot->size;
                   2908:       htab->etab.sgot->size += 8;
                   2909:       htab->etab.srelgot->size += sizeof (Elf32_External_Rela);
1.1       christos 2910:     }
                   2911:   else
                   2912:     htab->tls_ldm_got.offset = -1;
                   2913:
                   2914:   /* Allocate global sym .plt and .got entries, and space for global
                   2915:      sym dynamic relocs.  */
                   2916:   elf_link_hash_traverse (&htab->etab, allocate_dynrelocs, info);
                   2917:
                   2918:   /* We now have determined the sizes of the various dynamic sections.
                   2919:      Allocate memory for them.  */
                   2920:   relocs = FALSE;
                   2921:   for (s = dynobj->sections; s != NULL; s = s->next)
                   2922:     {
                   2923:       bfd_boolean reloc_section = FALSE;
                   2924:
                   2925:       if ((s->flags & SEC_LINKER_CREATED) == 0)
                   2926:        continue;
                   2927:
1.1.1.3   christos 2928:       if (s == htab->etab.splt
                   2929:          || s == htab->etab.sgot
                   2930:          || s == htab->etab.sgotplt
                   2931:          || s == htab->etab.sdynbss
                   2932:          || s == htab->etab.sdynrelro)
1.1       christos 2933:        {
                   2934:          /* Strip this section if we don't need it; see the
                   2935:             comment below.  */
                   2936:        }
1.1.1.4 ! christos 2937:       else if (CONST_STRNEQ (bfd_section_name (s), ".rela"))
1.1       christos 2938:        {
1.1.1.3   christos 2939:          if (s->size != 0 && s != htab->etab.srelplt)
1.1       christos 2940:            relocs = TRUE;
                   2941:
                   2942:          /* We use the reloc_count field as a counter if we need
                   2943:             to copy relocs into the output file.  */
                   2944:          s->reloc_count = 0;
                   2945:          reloc_section = TRUE;
                   2946:        }
                   2947:       else
                   2948:        {
                   2949:          /* It's not one of our sections, so don't allocate space.  */
                   2950:          continue;
                   2951:        }
                   2952:
                   2953:       if (s->size == 0)
                   2954:        {
                   2955:          /* If we don't need this section, strip it from the
                   2956:             output file.  This is mostly to handle .rela.bss and
                   2957:             .rela.plt.  We must create both sections in
                   2958:             create_dynamic_sections, because they must be created
                   2959:             before the linker maps input sections to output
                   2960:             sections.  The linker does that before
                   2961:             adjust_dynamic_symbol is called, and it is that
                   2962:             function which decides whether anything needs to go
                   2963:             into these sections.  */
                   2964:          s->flags |= SEC_EXCLUDE;
                   2965:          continue;
                   2966:        }
                   2967:
                   2968:       if ((s->flags & SEC_HAS_CONTENTS) == 0)
                   2969:        continue;
                   2970:
                   2971:       /* Allocate memory for the section contents.  */
                   2972:       s->contents = bfd_zalloc (dynobj, s->size);
                   2973:       if (s->contents == NULL)
                   2974:        return FALSE;
                   2975:       else if (reloc_section)
                   2976:        {
                   2977:          unsigned char *contents = s->contents;
                   2978:          Elf32_External_Rela reloc;
                   2979:
                   2980:          /* Fill the reloc section with a R_METAG_NONE type reloc.  */
                   2981:          memset(&reloc, 0, sizeof(Elf32_External_Rela));
                   2982:          reloc.r_info[0] = R_METAG_NONE;
                   2983:          for (; contents < (s->contents + s->size);
                   2984:               contents += sizeof(Elf32_External_Rela))
                   2985:            {
                   2986:              memcpy(contents, &reloc, sizeof(Elf32_External_Rela));
                   2987:            }
                   2988:        }
                   2989:     }
                   2990:
                   2991:   if (htab->etab.dynamic_sections_created)
                   2992:     {
                   2993:       /* Add some entries to the .dynamic section.  We fill in the
                   2994:         values later, in elf_metag_finish_dynamic_sections, but we
                   2995:         must add the entries now so that we get the correct size for
                   2996:         the .dynamic section.  The DT_DEBUG entry is filled in by the
                   2997:         dynamic linker and used by the debugger.  */
                   2998: #define add_dynamic_entry(TAG, VAL) \
                   2999:   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
                   3000:
                   3001:       if (!add_dynamic_entry (DT_PLTGOT, 0))
                   3002:        return FALSE;
                   3003:
                   3004:       if (bfd_link_executable (info))
                   3005:        {
                   3006:          if (!add_dynamic_entry (DT_DEBUG, 0))
                   3007:            return FALSE;
                   3008:        }
                   3009:
1.1.1.3   christos 3010:       if (htab->etab.srelplt->size != 0)
1.1       christos 3011:        {
                   3012:          if (!add_dynamic_entry (DT_PLTRELSZ, 0)
                   3013:              || !add_dynamic_entry (DT_PLTREL, DT_RELA)
                   3014:              || !add_dynamic_entry (DT_JMPREL, 0))
                   3015:            return FALSE;
                   3016:        }
                   3017:
                   3018:       if (relocs)
                   3019:        {
                   3020:          if (!add_dynamic_entry (DT_RELA, 0)
                   3021:              || !add_dynamic_entry (DT_RELASZ, 0)
                   3022:              || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
                   3023:            return FALSE;
                   3024:
                   3025:          /* If any dynamic relocs apply to a read-only section,
                   3026:             then we need a DT_TEXTREL entry.  */
                   3027:          if ((info->flags & DF_TEXTREL) == 0)
1.1.1.3   christos 3028:            elf_link_hash_traverse (&htab->etab, maybe_set_textrel, info);
1.1       christos 3029:
                   3030:          if ((info->flags & DF_TEXTREL) != 0)
                   3031:            {
                   3032:              if (!add_dynamic_entry (DT_TEXTREL, 0))
                   3033:                return FALSE;
                   3034:            }
                   3035:        }
                   3036:     }
                   3037: #undef add_dynamic_entry
                   3038:
                   3039:   return TRUE;
                   3040: }
                   3041:
                   3042: /* Finish up dynamic symbol handling.  We set the contents of various
                   3043:    dynamic sections here.  */
                   3044:
                   3045: static bfd_boolean
                   3046: elf_metag_finish_dynamic_symbol (bfd *output_bfd,
                   3047:                                 struct bfd_link_info *info,
                   3048:                                 struct elf_link_hash_entry *eh,
                   3049:                                 Elf_Internal_Sym *sym)
                   3050: {
                   3051:   struct elf_metag_link_hash_table *htab;
                   3052:   Elf_Internal_Rela rel;
                   3053:   bfd_byte *loc;
                   3054:
                   3055:   htab = metag_link_hash_table (info);
                   3056:
                   3057:   if (eh->plt.offset != (bfd_vma) -1)
                   3058:     {
                   3059:       asection *splt;
                   3060:       asection *sgot;
                   3061:       asection *srela;
                   3062:
                   3063:       bfd_vma plt_index;
                   3064:       bfd_vma got_offset;
                   3065:       bfd_vma got_entry;
                   3066:
                   3067:       if (eh->plt.offset & 1)
                   3068:        abort ();
                   3069:
                   3070:       BFD_ASSERT (eh->dynindx != -1);
                   3071:
1.1.1.3   christos 3072:       splt = htab->etab.splt;
                   3073:       sgot = htab->etab.sgotplt;
                   3074:       srela = htab->etab.srelplt;
1.1       christos 3075:       BFD_ASSERT (splt != NULL && sgot != NULL && srela != NULL);
                   3076:
                   3077:       /* Get the index in the procedure linkage table which
                   3078:         corresponds to this symbol.  This is the index of this symbol
                   3079:         in all the symbols for which we are making plt entries.  The
                   3080:         first entry in the procedure linkage table is reserved.  */
                   3081:       plt_index = eh->plt.offset / PLT_ENTRY_SIZE - 1;
                   3082:
                   3083:       /* Get the offset into the .got.plt table of the entry that
                   3084:         corresponds to this function.  */
                   3085:       got_offset = plt_index * GOT_ENTRY_SIZE;
                   3086:
                   3087:       BFD_ASSERT (got_offset < (1 << 16));
                   3088:
                   3089:       got_entry = sgot->output_section->vma
                   3090:        + sgot->output_offset
                   3091:        + got_offset;
                   3092:
                   3093:       BFD_ASSERT (plt_index < (1 << 16));
                   3094:
                   3095:       /* Fill in the entry in the procedure linkage table.  */
                   3096:       if (! bfd_link_pic (info))
                   3097:        {
                   3098:          bfd_put_32 (output_bfd,
                   3099:                      (plt_entry[0]
                   3100:                       | (((got_entry >> 16) & 0xffff) << 3)),
                   3101:                      splt->contents + eh->plt.offset);
                   3102:          bfd_put_32 (output_bfd,
                   3103:                      (plt_entry[1]
                   3104:                       | ((got_entry & 0xffff) << 3)),
                   3105:                      splt->contents + eh->plt.offset + 4);
                   3106:          bfd_put_32 (output_bfd, plt_entry[2],
                   3107:                      splt->contents + eh->plt.offset + 8);
                   3108:          bfd_put_32 (output_bfd,
                   3109:                      (plt_entry[3] | (plt_index << 3)),
                   3110:                      splt->contents + eh->plt.offset + 12);
                   3111:          bfd_put_32 (output_bfd,
                   3112:                      (plt_entry[4]
                   3113:                       | ((((unsigned int) ((- (eh->plt.offset + 16)) >> 2)) & 0x7ffff) << 5)),
                   3114:                      splt->contents + eh->plt.offset + 16);
                   3115:        }
                   3116:       else
                   3117:        {
                   3118:          bfd_vma addr = got_entry - (splt->output_section->vma +
                   3119:                                      splt->output_offset + eh->plt.offset);
                   3120:
                   3121:          bfd_put_32 (output_bfd,
                   3122:                      plt_pic_entry[0] | (((addr >> 16) & 0xffff) << 3),
                   3123:                      splt->contents + eh->plt.offset);
                   3124:          bfd_put_32 (output_bfd,
                   3125:                      plt_pic_entry[1] | ((addr & 0xffff) << 3),
                   3126:                      splt->contents + eh->plt.offset + 4);
                   3127:          bfd_put_32 (output_bfd, plt_pic_entry[2],
                   3128:                      splt->contents + eh->plt.offset + 8);
                   3129:          bfd_put_32 (output_bfd,
                   3130:                      (plt_pic_entry[3] | (plt_index << 3)),
                   3131:                      splt->contents + eh->plt.offset + 12);
                   3132:          bfd_put_32 (output_bfd,
                   3133:                      (plt_pic_entry[4]
                   3134:                       + ((((unsigned int) ((- (eh->plt.offset + 16)) >> 2)) & 0x7ffff) << 5)),
                   3135:                      splt->contents + eh->plt.offset + 16);
                   3136:        }
                   3137:
                   3138:       /* Fill in the entry in the global offset table.  */
                   3139:       bfd_put_32 (output_bfd,
                   3140:                  (splt->output_section->vma
                   3141:                   + splt->output_offset
                   3142:                   + eh->plt.offset
                   3143:                   + 12), /* offset within PLT entry */
                   3144:                  sgot->contents + got_offset);
                   3145:
                   3146:       /* Fill in the entry in the .rela.plt section.  */
                   3147:       rel.r_offset = (sgot->output_section->vma
                   3148:                      + sgot->output_offset
                   3149:                      + got_offset);
                   3150:       rel.r_info = ELF32_R_INFO (eh->dynindx, R_METAG_JMP_SLOT);
                   3151:       rel.r_addend = 0;
1.1.1.3   christos 3152:       loc = htab->etab.srelplt->contents;
1.1       christos 3153:       loc += plt_index * sizeof(Elf32_External_Rela);
                   3154:       bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
                   3155:
                   3156:       if (!eh->def_regular)
                   3157:        {
                   3158:          /* Mark the symbol as undefined, rather than as defined in
                   3159:             the .plt section.  Leave the value alone.  */
                   3160:          sym->st_shndx = SHN_UNDEF;
                   3161:        }
                   3162:     }
                   3163:
                   3164:   if (eh->got.offset != (bfd_vma) -1
                   3165:       && (metag_elf_hash_entry (eh)->tls_type & GOT_TLS_GD) == 0
                   3166:       && (metag_elf_hash_entry (eh)->tls_type & GOT_TLS_IE) == 0)
                   3167:     {
                   3168:       /* This symbol has an entry in the global offset table.  Set it
                   3169:         up.  */
                   3170:
                   3171:       rel.r_offset = ((eh->got.offset &~ (bfd_vma) 1)
1.1.1.3   christos 3172:                      + htab->etab.sgot->output_offset
                   3173:                      + htab->etab.sgot->output_section->vma);
1.1       christos 3174:
                   3175:       /* If this is a -Bsymbolic link and the symbol is defined
                   3176:         locally or was forced to be local because of a version file,
                   3177:         we just want to emit a RELATIVE reloc.  The entry in the
                   3178:         global offset table will already have been initialized in the
                   3179:         relocate_section function.  */
                   3180:       if (bfd_link_pic (info)
                   3181:          && (info->symbolic || eh->dynindx == -1)
                   3182:          && eh->def_regular)
                   3183:        {
                   3184:          rel.r_info = ELF32_R_INFO (0, R_METAG_RELATIVE);
                   3185:          rel.r_addend = (eh->root.u.def.value
                   3186:                          + eh->root.u.def.section->output_offset
                   3187:                          + eh->root.u.def.section->output_section->vma);
                   3188:        }
                   3189:       else
                   3190:        {
                   3191:          if ((eh->got.offset & 1) != 0)
                   3192:            abort ();
1.1.1.3   christos 3193:          bfd_put_32 (output_bfd, 0, htab->etab.sgot->contents + eh->got.offset);
1.1       christos 3194:          rel.r_info = ELF32_R_INFO (eh->dynindx, R_METAG_GLOB_DAT);
                   3195:          rel.r_addend = 0;
                   3196:        }
                   3197:
1.1.1.3   christos 3198:       loc = htab->etab.srelgot->contents;
                   3199:       loc += htab->etab.srelgot->reloc_count++ * sizeof (Elf32_External_Rela);
1.1       christos 3200:       bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
                   3201:     }
                   3202:
                   3203:   if (eh->needs_copy)
                   3204:     {
                   3205:       asection *s;
                   3206:
                   3207:       /* This symbol needs a copy reloc.  Set it up.  */
                   3208:
                   3209:       if (! (eh->dynindx != -1
                   3210:             && (eh->root.type == bfd_link_hash_defined
                   3211:                 || eh->root.type == bfd_link_hash_defweak)))
                   3212:        abort ();
                   3213:
                   3214:       rel.r_offset = (eh->root.u.def.value
                   3215:                      + eh->root.u.def.section->output_offset
                   3216:                      + eh->root.u.def.section->output_section->vma);
                   3217:       rel.r_addend = 0;
                   3218:       rel.r_info = ELF32_R_INFO (eh->dynindx, R_METAG_COPY);
1.1.1.3   christos 3219:       if (eh->root.u.def.section == htab->etab.sdynrelro)
                   3220:        s = htab->etab.sreldynrelro;
                   3221:       else
                   3222:        s = htab->etab.srelbss;
1.1       christos 3223:       loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rela);
                   3224:       bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
                   3225:     }
                   3226:
                   3227:   /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.  */
                   3228:   if (eh->root.root.string[0] == '_'
                   3229:       && (strcmp (eh->root.root.string, "_DYNAMIC") == 0
                   3230:          || eh == htab->etab.hgot))
                   3231:     {
                   3232:       sym->st_shndx = SHN_ABS;
                   3233:     }
                   3234:
                   3235:   return TRUE;
                   3236: }
                   3237:
                   3238: /* Set the Meta ELF ABI version.  */
                   3239:
1.1.1.4 ! christos 3240: static bfd_boolean
        !          3241: elf_metag_init_file_header (bfd *abfd, struct bfd_link_info *link_info)
1.1       christos 3242: {
                   3243:   Elf_Internal_Ehdr * i_ehdrp; /* ELF file header, internal form.  */
                   3244:
1.1.1.4 ! christos 3245:   if (!_bfd_elf_init_file_header (abfd, link_info))
        !          3246:     return FALSE;
        !          3247:
1.1       christos 3248:   i_ehdrp = elf_elfheader (abfd);
                   3249:   i_ehdrp->e_ident[EI_ABIVERSION] = METAG_ELF_ABI_VERSION;
1.1.1.4 ! christos 3250:   return TRUE;
1.1       christos 3251: }
                   3252:
                   3253: /* Used to decide how to sort relocs in an optimal manner for the
                   3254:    dynamic linker, before writing them out.  */
                   3255:
                   3256: static enum elf_reloc_type_class
                   3257: elf_metag_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
                   3258:                            const asection *rel_sec ATTRIBUTE_UNUSED,
                   3259:                            const Elf_Internal_Rela *rela)
                   3260: {
                   3261:   switch ((int) ELF32_R_TYPE (rela->r_info))
                   3262:     {
                   3263:     case R_METAG_RELATIVE:
                   3264:       return reloc_class_relative;
                   3265:     case R_METAG_JMP_SLOT:
                   3266:       return reloc_class_plt;
                   3267:     case R_METAG_COPY:
                   3268:       return reloc_class_copy;
                   3269:     default:
                   3270:       return reloc_class_normal;
                   3271:     }
                   3272: }
                   3273:
                   3274: /* Finish up the dynamic sections.  */
                   3275:
                   3276: static bfd_boolean
                   3277: elf_metag_finish_dynamic_sections (bfd *output_bfd,
                   3278:                                   struct bfd_link_info *info)
                   3279: {
                   3280:   bfd *dynobj;
                   3281:   struct elf_metag_link_hash_table *htab;
                   3282:   asection *sdyn;
                   3283:
                   3284:   htab = metag_link_hash_table (info);
                   3285:   dynobj = htab->etab.dynobj;
                   3286:
                   3287:   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
                   3288:
                   3289:   if (htab->etab.dynamic_sections_created)
                   3290:     {
                   3291:       asection *splt;
                   3292:       Elf32_External_Dyn *dyncon, *dynconend;
                   3293:
                   3294:       if (sdyn == NULL)
                   3295:        abort ();
                   3296:
                   3297:       dyncon = (Elf32_External_Dyn *) sdyn->contents;
                   3298:       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
                   3299:       for (; dyncon < dynconend; dyncon++)
                   3300:        {
                   3301:          Elf_Internal_Dyn dyn;
                   3302:          asection *s;
                   3303:
                   3304:          bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
                   3305:
                   3306:          switch (dyn.d_tag)
                   3307:            {
                   3308:            default:
                   3309:              continue;
                   3310:
                   3311:            case DT_PLTGOT:
1.1.1.3   christos 3312:              s = htab->etab.sgot;
1.1.1.2   christos 3313:              dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
1.1       christos 3314:              bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
                   3315:              break;
                   3316:
                   3317:            case DT_JMPREL:
1.1.1.3   christos 3318:              s = htab->etab.srelplt;
1.1.1.2   christos 3319:              dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
1.1       christos 3320:              bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
                   3321:              break;
                   3322:
                   3323:            case DT_PLTRELSZ:
1.1.1.3   christos 3324:              s = htab->etab.srelplt;
1.1       christos 3325:              dyn.d_un.d_val = s->size;
                   3326:              bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
                   3327:              break;
                   3328:            }
                   3329:
                   3330:        }
                   3331:
                   3332:       /* Fill in the first entry in the procedure linkage table.  */
1.1.1.3   christos 3333:       splt = htab->etab.splt;
1.1       christos 3334:       if (splt && splt->size > 0)
                   3335:        {
                   3336:          unsigned long addr;
                   3337:          /* addr = .got + 4 */
1.1.1.3   christos 3338:          addr = (htab->etab.sgot->output_section->vma
                   3339:                  + htab->etab.sgot->output_offset + 4);
1.1       christos 3340:          if (bfd_link_pic (info))
                   3341:            {
                   3342:              addr -= splt->output_section->vma + splt->output_offset;
                   3343:              bfd_put_32 (output_bfd,
                   3344:                          plt0_pic_entry[0] | (((addr >> 16) & 0xffff) << 3),
                   3345:                          splt->contents);
                   3346:              bfd_put_32 (output_bfd,
                   3347:                          plt0_pic_entry[1] | ((addr & 0xffff) << 3),
                   3348:                          splt->contents + 4);
                   3349:              bfd_put_32 (output_bfd, plt0_pic_entry[2], splt->contents + 8);
                   3350:              bfd_put_32 (output_bfd, plt0_pic_entry[3], splt->contents + 12);
                   3351:              bfd_put_32 (output_bfd, plt0_pic_entry[4], splt->contents + 16);
                   3352:            }
                   3353:          else
                   3354:            {
                   3355:              bfd_put_32 (output_bfd,
                   3356:                          plt0_entry[0] | (((addr >> 16) & 0xffff) << 3),
                   3357:                          splt->contents);
                   3358:              bfd_put_32 (output_bfd,
                   3359:                          plt0_entry[1] | ((addr & 0xffff) << 3),
                   3360:                          splt->contents + 4);
                   3361:              bfd_put_32 (output_bfd, plt0_entry[2], splt->contents + 8);
                   3362:              bfd_put_32 (output_bfd, plt0_entry[3], splt->contents + 12);
                   3363:              bfd_put_32 (output_bfd, plt0_entry[4], splt->contents + 16);
                   3364:            }
                   3365:
                   3366:          elf_section_data (splt->output_section)->this_hdr.sh_entsize =
                   3367:            PLT_ENTRY_SIZE;
                   3368:        }
                   3369:     }
                   3370:
1.1.1.3   christos 3371:   if (htab->etab.sgot != NULL && htab->etab.sgot->size != 0)
1.1       christos 3372:     {
                   3373:       /* Fill in the first entry in the global offset table.
                   3374:         We use it to point to our dynamic section, if we have one.  */
                   3375:       bfd_put_32 (output_bfd,
                   3376:                  sdyn ? sdyn->output_section->vma + sdyn->output_offset : 0,
1.1.1.3   christos 3377:                  htab->etab.sgot->contents);
1.1       christos 3378:
                   3379:       /* The second entry is reserved for use by the dynamic linker.  */
1.1.1.3   christos 3380:       memset (htab->etab.sgot->contents + GOT_ENTRY_SIZE, 0, GOT_ENTRY_SIZE);
1.1       christos 3381:
                   3382:       /* Set .got entry size.  */
1.1.1.3   christos 3383:       elf_section_data (htab->etab.sgot->output_section)
1.1       christos 3384:        ->this_hdr.sh_entsize = GOT_ENTRY_SIZE;
                   3385:     }
                   3386:
                   3387:   return TRUE;
                   3388: }
                   3389:
                   3390: /* Return the section that should be marked against GC for a given
                   3391:    relocation.  */
                   3392:
                   3393: static asection *
                   3394: elf_metag_gc_mark_hook (asection *sec,
                   3395:                        struct bfd_link_info *info,
                   3396:                        Elf_Internal_Rela *rela,
                   3397:                        struct elf_link_hash_entry *hh,
                   3398:                        Elf_Internal_Sym *sym)
                   3399: {
                   3400:   if (hh != NULL)
                   3401:     switch ((unsigned int) ELF32_R_TYPE (rela->r_info))
                   3402:       {
                   3403:       case R_METAG_GNU_VTINHERIT:
                   3404:       case R_METAG_GNU_VTENTRY:
                   3405:        return NULL;
                   3406:       }
                   3407:
                   3408:   return _bfd_elf_gc_mark_hook (sec, info, rela, hh, sym);
                   3409: }
                   3410:
                   3411: /* Determine the type of stub needed, if any, for a call.  */
                   3412:
                   3413: static enum elf_metag_stub_type
                   3414: metag_type_of_stub (asection *input_sec,
                   3415:                    const Elf_Internal_Rela *rel,
                   3416:                    struct elf_metag_link_hash_entry *hh,
                   3417:                    bfd_vma destination,
                   3418:                    struct bfd_link_info *info ATTRIBUTE_UNUSED)
                   3419: {
                   3420:   bfd_vma location;
                   3421:   bfd_vma branch_offset;
                   3422:   bfd_vma max_branch_offset;
                   3423:
                   3424:   if (hh != NULL &&
                   3425:       !(hh->eh.root.type == bfd_link_hash_defined
                   3426:        || hh->eh.root.type == bfd_link_hash_defweak))
                   3427:     return metag_stub_none;
                   3428:
                   3429:   /* Determine where the call point is.  */
                   3430:   location = (input_sec->output_offset
                   3431:              + input_sec->output_section->vma
                   3432:              + rel->r_offset);
                   3433:
                   3434:   branch_offset = destination - location;
                   3435:
                   3436:   /* Determine if a long branch stub is needed.  Meta branch offsets
                   3437:      are signed 19 bits 4 byte aligned.  */
                   3438:   max_branch_offset = (1 << (BRANCH_BITS-1)) << 2;
                   3439:
                   3440:   if (branch_offset + max_branch_offset >= 2*max_branch_offset)
                   3441:     {
                   3442:       if (bfd_link_pic (info))
                   3443:        return metag_stub_long_branch_shared;
                   3444:       else
                   3445:        return metag_stub_long_branch;
                   3446:     }
                   3447:
                   3448:   return metag_stub_none;
                   3449: }
                   3450:
                   3451: #define MOVT_A0_3      0x82180005
                   3452: #define JUMP_A0_3      0xac180003
                   3453:
                   3454: #define MOVT_A1LBP     0x83080005
                   3455: #define ADD_A1LBP      0x83080000
                   3456:
                   3457: #define ADDT_A0_3_CPC  0x82980001
                   3458: #define ADD_A0_3_A0_3  0x82180000
                   3459: #define MOV_PC_A0_3    0xa3180ca0
                   3460:
                   3461: static bfd_boolean
                   3462: metag_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg ATTRIBUTE_UNUSED)
                   3463: {
                   3464:   struct elf_metag_stub_hash_entry *hsh;
                   3465:   asection *stub_sec;
                   3466:   bfd *stub_bfd;
                   3467:   bfd_byte *loc;
                   3468:   bfd_vma sym_value;
                   3469:   int size;
                   3470:
                   3471:   /* Massage our args to the form they really have.  */
                   3472:   hsh = (struct elf_metag_stub_hash_entry *) gen_entry;
                   3473:
                   3474:   stub_sec = hsh->stub_sec;
                   3475:
                   3476:   /* Make a note of the offset within the stubs for this entry.  */
                   3477:   hsh->stub_offset = stub_sec->size;
                   3478:   loc = stub_sec->contents + hsh->stub_offset;
                   3479:
                   3480:   stub_bfd = stub_sec->owner;
                   3481:
                   3482:   switch (hsh->stub_type)
                   3483:     {
                   3484:     case metag_stub_long_branch_shared:
                   3485:       /* A PIC long branch stub is an ADDT and an ADD instruction used to
                   3486:         calculate the jump target using A0.3 as a temporary. Then a MOV
                   3487:         to PC carries out the jump.  */
                   3488:       sym_value = (hsh->target_value
                   3489:                   + hsh->target_section->output_offset
                   3490:                   + hsh->target_section->output_section->vma
                   3491:                   + hsh->addend);
                   3492:
                   3493:       sym_value -= (hsh->stub_offset
                   3494:                    + stub_sec->output_offset
                   3495:                    + stub_sec->output_section->vma);
                   3496:
                   3497:       bfd_put_32 (stub_bfd, ADDT_A0_3_CPC | (((sym_value >> 16) & 0xffff) << 3),
                   3498:                  loc);
                   3499:
                   3500:       bfd_put_32 (stub_bfd, ADD_A0_3_A0_3 | ((sym_value & 0xffff) << 3),
                   3501:                  loc + 4);
                   3502:
                   3503:       bfd_put_32 (stub_bfd, MOV_PC_A0_3, loc + 8);
                   3504:
                   3505:       size = 12;
                   3506:       break;
                   3507:     case metag_stub_long_branch:
                   3508:       /* A standard long branch stub is a MOVT instruction followed by a
                   3509:         JUMP instruction using the A0.3 register as a temporary. This is
                   3510:         the same method used by the LDLK linker (patch.c).  */
                   3511:       sym_value = (hsh->target_value
                   3512:                   + hsh->target_section->output_offset
                   3513:                   + hsh->target_section->output_section->vma
                   3514:                   + hsh->addend);
                   3515:
                   3516:       bfd_put_32 (stub_bfd, MOVT_A0_3 | (((sym_value >> 16) & 0xffff) << 3),
                   3517:                  loc);
                   3518:
                   3519:       bfd_put_32 (stub_bfd, JUMP_A0_3 | ((sym_value & 0xffff) << 3), loc + 4);
                   3520:
                   3521:       size = 8;
                   3522:       break;
                   3523:     default:
                   3524:       BFD_FAIL ();
                   3525:       return FALSE;
                   3526:     }
                   3527:
                   3528:   stub_sec->size += size;
                   3529:   return TRUE;
                   3530: }
                   3531:
                   3532: /* As above, but don't actually build the stub.  Just bump offset so
                   3533:    we know stub section sizes.  */
                   3534:
                   3535: static bfd_boolean
                   3536: metag_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg ATTRIBUTE_UNUSED)
                   3537: {
                   3538:   struct elf_metag_stub_hash_entry *hsh;
                   3539:   int size = 0;
                   3540:
                   3541:   /* Massage our args to the form they really have.  */
                   3542:   hsh = (struct elf_metag_stub_hash_entry *) gen_entry;
                   3543:
                   3544:   if (hsh->stub_type == metag_stub_long_branch)
                   3545:     size = 8;
                   3546:   else if (hsh->stub_type == metag_stub_long_branch_shared)
                   3547:     size = 12;
                   3548:
                   3549:   hsh->stub_sec->size += size;
                   3550:   return TRUE;
                   3551: }
                   3552:
                   3553: /* Set up various things so that we can make a list of input sections
                   3554:    for each output section included in the link.  Returns -1 on error,
                   3555:    0 when no stubs will be needed, and 1 on success.  */
                   3556:
                   3557: int
                   3558: elf_metag_setup_section_lists (bfd *output_bfd, struct bfd_link_info *info)
                   3559: {
                   3560:   bfd *input_bfd;
                   3561:   unsigned int bfd_count;
                   3562:   unsigned int top_id, top_index;
                   3563:   asection *section;
                   3564:   asection **input_list, **list;
                   3565:   bfd_size_type amt;
                   3566:   struct elf_metag_link_hash_table *htab = metag_link_hash_table (info);
                   3567:
                   3568:   /* Count the number of input BFDs and find the top input section id.  */
                   3569:   for (input_bfd = info->input_bfds, bfd_count = 0, top_id = 0;
                   3570:        input_bfd != NULL;
                   3571:        input_bfd = input_bfd->link.next)
                   3572:     {
                   3573:       bfd_count += 1;
                   3574:       for (section = input_bfd->sections;
                   3575:           section != NULL;
                   3576:           section = section->next)
                   3577:        {
                   3578:          if (top_id < section->id)
                   3579:            top_id = section->id;
                   3580:        }
                   3581:     }
                   3582:
                   3583:   htab->bfd_count = bfd_count;
                   3584:
                   3585:   amt = sizeof (struct map_stub) * (top_id + 1);
                   3586:   htab->stub_group = bfd_zmalloc (amt);
                   3587:   if (htab->stub_group == NULL)
                   3588:     return -1;
                   3589:
                   3590:   /* We can't use output_bfd->section_count here to find the top output
                   3591:      section index as some sections may have been removed, and
                   3592:      strip_excluded_output_sections doesn't renumber the indices.  */
                   3593:   for (section = output_bfd->sections, top_index = 0;
                   3594:        section != NULL;
                   3595:        section = section->next)
                   3596:     {
                   3597:       if (top_index < section->index)
                   3598:        top_index = section->index;
                   3599:     }
                   3600:
                   3601:   htab->top_index = top_index;
                   3602:   amt = sizeof (asection *) * (top_index + 1);
                   3603:   input_list = bfd_malloc (amt);
                   3604:   htab->input_list = input_list;
                   3605:   if (input_list == NULL)
                   3606:     return -1;
                   3607:
                   3608:   /* For sections we aren't interested in, mark their entries with a
                   3609:      value we can check later.  */
                   3610:   list = input_list + top_index;
                   3611:   do
                   3612:     *list = bfd_abs_section_ptr;
                   3613:   while (list-- != input_list);
                   3614:
                   3615:   for (section = output_bfd->sections;
                   3616:        section != NULL;
                   3617:        section = section->next)
                   3618:     {
                   3619:       /* FIXME: This is a bit of hack. Currently our .ctors and .dtors
                   3620:        * have PC relative relocs in them but no code flag set.  */
                   3621:       if (((section->flags & SEC_CODE) != 0) ||
                   3622:          strcmp(".ctors", section->name) ||
                   3623:          strcmp(".dtors", section->name))
                   3624:        input_list[section->index] = NULL;
                   3625:     }
                   3626:
                   3627:   return 1;
                   3628: }
                   3629:
                   3630: /* The linker repeatedly calls this function for each input section,
                   3631:    in the order that input sections are linked into output sections.
                   3632:    Build lists of input sections to determine groupings between which
                   3633:    we may insert linker stubs.  */
                   3634:
                   3635: void
                   3636: elf_metag_next_input_section (struct bfd_link_info *info, asection *isec)
                   3637: {
                   3638:   struct elf_metag_link_hash_table *htab = metag_link_hash_table (info);
                   3639:
                   3640:   if (isec->output_section->index <= htab->top_index)
                   3641:     {
                   3642:       asection **list = htab->input_list + isec->output_section->index;
                   3643:       if (*list != bfd_abs_section_ptr)
                   3644:        {
                   3645:          /* Steal the link_sec pointer for our list.  */
                   3646: #define PREV_SEC(sec) (htab->stub_group[(sec)->id].link_sec)
                   3647:          /* This happens to make the list in reverse order,
                   3648:             which is what we want.  */
                   3649:          PREV_SEC (isec) = *list;
                   3650:          *list = isec;
                   3651:        }
                   3652:     }
                   3653: }
                   3654:
                   3655: /* See whether we can group stub sections together.  Grouping stub
                   3656:    sections may result in fewer stubs.  More importantly, we need to
                   3657:    put all .init* and .fini* stubs at the beginning of the .init or
                   3658:    .fini output sections respectively, because glibc splits the
                   3659:    _init and _fini functions into multiple parts.  Putting a stub in
                   3660:    the middle of a function is not a good idea.  */
                   3661:
                   3662: static void
                   3663: group_sections (struct elf_metag_link_hash_table *htab,
                   3664:                bfd_size_type stub_group_size,
                   3665:                bfd_boolean stubs_always_before_branch)
                   3666: {
                   3667:   asection **list = htab->input_list + htab->top_index;
                   3668:   do
                   3669:     {
                   3670:       asection *tail = *list;
                   3671:       if (tail == bfd_abs_section_ptr)
                   3672:        continue;
                   3673:       while (tail != NULL)
                   3674:        {
                   3675:          asection *curr;
                   3676:          asection *prev;
                   3677:          bfd_size_type total;
                   3678:          bfd_boolean big_sec;
                   3679:
                   3680:          curr = tail;
                   3681:          total = tail->size;
                   3682:          big_sec = total >= stub_group_size;
                   3683:
                   3684:          while ((prev = PREV_SEC (curr)) != NULL
                   3685:                 && ((total += curr->output_offset - prev->output_offset)
                   3686:                     < stub_group_size))
                   3687:            curr = prev;
                   3688:
                   3689:          /* OK, the size from the start of CURR to the end is less
                   3690:             than stub_group_size bytes and thus can be handled by one stub
                   3691:             section.  (or the tail section is itself larger than
                   3692:             stub_group_size bytes, in which case we may be toast.)
                   3693:             We should really be keeping track of the total size of
                   3694:             stubs added here, as stubs contribute to the final output
                   3695:             section size.  */
                   3696:          do
                   3697:            {
                   3698:              prev = PREV_SEC (tail);
                   3699:              /* Set up this stub group.  */
                   3700:              htab->stub_group[tail->id].link_sec = curr;
                   3701:            }
                   3702:          while (tail != curr && (tail = prev) != NULL);
                   3703:
                   3704:          /* But wait, there's more!  Input sections up to stub_group_size
                   3705:             bytes before the stub section can be handled by it too.
                   3706:             Don't do this if we have a really large section after the
                   3707:             stubs, as adding more stubs increases the chance that
                   3708:             branches may not reach into the stub section.  */
                   3709:          if (!stubs_always_before_branch && !big_sec)
                   3710:            {
                   3711:              total = 0;
                   3712:              while (prev != NULL
                   3713:                     && ((total += tail->output_offset - prev->output_offset)
                   3714:                         < stub_group_size))
                   3715:                {
                   3716:                  tail = prev;
                   3717:                  prev = PREV_SEC (tail);
                   3718:                  htab->stub_group[tail->id].link_sec = curr;
                   3719:                }
                   3720:            }
                   3721:          tail = prev;
                   3722:        }
                   3723:     }
                   3724:   while (list-- != htab->input_list);
                   3725:   free (htab->input_list);
                   3726: #undef PREV_SEC
                   3727: }
                   3728:
                   3729: /* Read in all local syms for all input bfds.
                   3730:    Returns -1 on error, 0 otherwise.  */
                   3731:
                   3732: static int
                   3733: get_local_syms (bfd *output_bfd ATTRIBUTE_UNUSED, bfd *input_bfd,
                   3734:                struct bfd_link_info *info)
                   3735: {
                   3736:   unsigned int bfd_indx;
                   3737:   Elf_Internal_Sym *local_syms, **all_local_syms;
                   3738:   int stub_changed = 0;
                   3739:   struct elf_metag_link_hash_table *htab = metag_link_hash_table (info);
                   3740:
                   3741:   /* We want to read in symbol extension records only once.  To do this
                   3742:      we need to read in the local symbols in parallel and save them for
                   3743:      later use; so hold pointers to the local symbols in an array.  */
                   3744:   bfd_size_type amt = sizeof (Elf_Internal_Sym *) * htab->bfd_count;
                   3745:   all_local_syms = bfd_zmalloc (amt);
                   3746:   htab->all_local_syms = all_local_syms;
                   3747:   if (all_local_syms == NULL)
                   3748:     return -1;
                   3749:
                   3750:   /* Walk over all the input BFDs, swapping in local symbols.  */
                   3751:   for (bfd_indx = 0;
                   3752:        input_bfd != NULL;
                   3753:        input_bfd = input_bfd->link.next, bfd_indx++)
                   3754:     {
                   3755:       Elf_Internal_Shdr *symtab_hdr;
                   3756:
                   3757:       /* We'll need the symbol table in a second.  */
                   3758:       symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
                   3759:       if (symtab_hdr->sh_info == 0)
                   3760:        continue;
                   3761:
                   3762:       /* We need an array of the local symbols attached to the input bfd.  */
                   3763:       local_syms = (Elf_Internal_Sym *) symtab_hdr->contents;
                   3764:       if (local_syms == NULL)
                   3765:        {
                   3766:          local_syms = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
                   3767:                                             symtab_hdr->sh_info, 0,
                   3768:                                             NULL, NULL, NULL);
                   3769:          /* Cache them for elf_link_input_bfd.  */
                   3770:          symtab_hdr->contents = (unsigned char *) local_syms;
                   3771:        }
                   3772:       if (local_syms == NULL)
                   3773:        return -1;
                   3774:
                   3775:       all_local_syms[bfd_indx] = local_syms;
                   3776:     }
                   3777:
                   3778:   return stub_changed;
                   3779: }
                   3780:
                   3781: /* Determine and set the size of the stub section for a final link.
                   3782:
                   3783: The basic idea here is to examine all the relocations looking for
                   3784: PC-relative calls to a target that is unreachable with a "CALLR"
                   3785: instruction.  */
                   3786:
                   3787: /* See elf32-hppa.c and elf64-ppc.c.  */
                   3788:
                   3789: bfd_boolean
                   3790: elf_metag_size_stubs(bfd *output_bfd, bfd *stub_bfd,
                   3791:                     struct bfd_link_info *info,
                   3792:                     bfd_signed_vma group_size,
                   3793:                     asection * (*add_stub_section) (const char *, asection *),
                   3794:                     void (*layout_sections_again) (void))
                   3795: {
                   3796:   bfd_size_type stub_group_size;
                   3797:   bfd_boolean stubs_always_before_branch;
                   3798:   bfd_boolean stub_changed;
                   3799:   struct elf_metag_link_hash_table *htab = metag_link_hash_table (info);
                   3800:
                   3801:   /* Stash our params away.  */
                   3802:   htab->stub_bfd = stub_bfd;
                   3803:   htab->add_stub_section = add_stub_section;
                   3804:   htab->layout_sections_again = layout_sections_again;
                   3805:   stubs_always_before_branch = group_size < 0;
                   3806:   if (group_size < 0)
                   3807:     stub_group_size = -group_size;
                   3808:   else
                   3809:     stub_group_size = group_size;
                   3810:   if (stub_group_size == 1)
                   3811:     {
                   3812:       /* Default values.  */
                   3813:       /* FIXME: not sure what these values should be */
                   3814:       if (stubs_always_before_branch)
                   3815:        {
                   3816:          stub_group_size = (1 << BRANCH_BITS);
                   3817:        }
                   3818:       else
                   3819:        {
                   3820:          stub_group_size = (1 << BRANCH_BITS);
                   3821:        }
                   3822:     }
                   3823:
                   3824:   group_sections (htab, stub_group_size, stubs_always_before_branch);
                   3825:
                   3826:   switch (get_local_syms (output_bfd, info->input_bfds, info))
                   3827:     {
                   3828:     default:
                   3829:       if (htab->all_local_syms)
                   3830:        goto error_ret_free_local;
                   3831:       return FALSE;
                   3832:
                   3833:     case 0:
                   3834:       stub_changed = FALSE;
                   3835:       break;
                   3836:
                   3837:     case 1:
                   3838:       stub_changed = TRUE;
                   3839:       break;
                   3840:     }
                   3841:
                   3842:   while (1)
                   3843:     {
                   3844:       bfd *input_bfd;
                   3845:       unsigned int bfd_indx;
                   3846:       asection *stub_sec;
                   3847:
                   3848:       for (input_bfd = info->input_bfds, bfd_indx = 0;
                   3849:           input_bfd != NULL;
                   3850:           input_bfd = input_bfd->link.next, bfd_indx++)
                   3851:        {
                   3852:          Elf_Internal_Shdr *symtab_hdr;
                   3853:          asection *section;
                   3854:          Elf_Internal_Sym *local_syms;
                   3855:
                   3856:          /* We'll need the symbol table in a second.  */
                   3857:          symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
                   3858:          if (symtab_hdr->sh_info == 0)
                   3859:            continue;
                   3860:
                   3861:          local_syms = htab->all_local_syms[bfd_indx];
                   3862:
                   3863:          /* Walk over each section attached to the input bfd.  */
                   3864:          for (section = input_bfd->sections;
                   3865:               section != NULL;
                   3866:               section = section->next)
                   3867:            {
                   3868:              Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
                   3869:
                   3870:              /* If there aren't any relocs, then there's nothing more
                   3871:                 to do.  */
                   3872:              if ((section->flags & SEC_RELOC) == 0
                   3873:                  || section->reloc_count == 0)
                   3874:                continue;
                   3875:
                   3876:              /* If this section is a link-once section that will be
                   3877:                 discarded, then don't create any stubs.  */
                   3878:              if (section->output_section == NULL
                   3879:                  || section->output_section->owner != output_bfd)
                   3880:                continue;
                   3881:
                   3882:              /* Get the relocs.  */
                   3883:              internal_relocs
                   3884:                = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
                   3885:                                             info->keep_memory);
                   3886:              if (internal_relocs == NULL)
                   3887:                goto error_ret_free_local;
                   3888:
                   3889:              /* Now examine each relocation.  */
                   3890:              irela = internal_relocs;
                   3891:              irelaend = irela + section->reloc_count;
                   3892:              for (; irela < irelaend; irela++)
                   3893:                {
                   3894:                  unsigned int r_type, r_indx;
                   3895:                  enum elf_metag_stub_type stub_type;
                   3896:                  struct elf_metag_stub_hash_entry *hsh;
                   3897:                  asection *sym_sec;
                   3898:                  bfd_vma sym_value;
                   3899:                  bfd_vma destination;
                   3900:                  struct elf_metag_link_hash_entry *hh;
                   3901:                  char *stub_name;
                   3902:                  const asection *id_sec;
                   3903:
                   3904:                  r_type = ELF32_R_TYPE (irela->r_info);
                   3905:                  r_indx = ELF32_R_SYM (irela->r_info);
                   3906:
                   3907:                  if (r_type >= (unsigned int) R_METAG_MAX)
                   3908:                    {
                   3909:                      bfd_set_error (bfd_error_bad_value);
                   3910:                    error_ret_free_internal:
                   3911:                      if (elf_section_data (section)->relocs == NULL)
                   3912:                        free (internal_relocs);
                   3913:                      goto error_ret_free_local;
                   3914:                    }
                   3915:
                   3916:                  /* Only look for stubs on CALLR and B instructions.  */
                   3917:                  if (!(r_type == (unsigned int) R_METAG_RELBRANCH ||
                   3918:                        r_type == (unsigned int) R_METAG_RELBRANCH_PLT))
                   3919:                    continue;
                   3920:
                   3921:                  /* Now determine the call target, its name, value,
                   3922:                     section.  */
                   3923:                  sym_sec = NULL;
                   3924:                  sym_value = 0;
                   3925:                  destination = 0;
                   3926:                  hh = NULL;
                   3927:                  if (r_indx < symtab_hdr->sh_info)
                   3928:                    {
                   3929:                      /* It's a local symbol.  */
                   3930:                      Elf_Internal_Sym *sym;
                   3931:                      Elf_Internal_Shdr *hdr;
                   3932:                      unsigned int shndx;
                   3933:
                   3934:                      sym = local_syms + r_indx;
                   3935:                      if (ELF_ST_TYPE (sym->st_info) != STT_SECTION)
                   3936:                        sym_value = sym->st_value;
                   3937:                      shndx = sym->st_shndx;
                   3938:                      if (shndx < elf_numsections (input_bfd))
                   3939:                        {
                   3940:                          hdr = elf_elfsections (input_bfd)[shndx];
                   3941:                          sym_sec = hdr->bfd_section;
                   3942:                          destination = (sym_value + irela->r_addend
                   3943:                                         + sym_sec->output_offset
                   3944:                                         + sym_sec->output_section->vma);
                   3945:                        }
                   3946:                    }
                   3947:                  else
                   3948:                    {
                   3949:                      /* It's an external symbol.  */
                   3950:                      int e_indx;
                   3951:
                   3952:                      e_indx = r_indx - symtab_hdr->sh_info;
                   3953:                      hh = ((struct elf_metag_link_hash_entry *)
                   3954:                            elf_sym_hashes (input_bfd)[e_indx]);
                   3955:
                   3956:                      while (hh->eh.root.type == bfd_link_hash_indirect
                   3957:                             || hh->eh.root.type == bfd_link_hash_warning)
                   3958:                        hh = ((struct elf_metag_link_hash_entry *)
                   3959:                              hh->eh.root.u.i.link);
                   3960:
                   3961:                      if (hh->eh.root.type == bfd_link_hash_defined
                   3962:                          || hh->eh.root.type == bfd_link_hash_defweak)
                   3963:                        {
                   3964:                          sym_sec = hh->eh.root.u.def.section;
                   3965:                          sym_value = hh->eh.root.u.def.value;
                   3966:                          if (hh->eh.plt.offset != (bfd_vma) -1
                   3967:                              && hh->eh.dynindx != -1
                   3968:                              && r_type == (unsigned int) R_METAG_RELBRANCH_PLT)
                   3969:                            {
1.1.1.3   christos 3970:                              sym_sec = htab->etab.splt;
1.1       christos 3971:                              sym_value = hh->eh.plt.offset;
                   3972:                            }
                   3973:
                   3974:                          if (sym_sec->output_section != NULL)
                   3975:                            destination = (sym_value + irela->r_addend
                   3976:                                           + sym_sec->output_offset
                   3977:                                           + sym_sec->output_section->vma);
                   3978:                          else
                   3979:                            continue;
                   3980:                        }
                   3981:                      else if (hh->eh.root.type == bfd_link_hash_undefweak)
                   3982:                        {
                   3983:                          if (! bfd_link_pic (info))
                   3984:                            continue;
                   3985:                        }
                   3986:                      else if (hh->eh.root.type == bfd_link_hash_undefined)
                   3987:                        {
                   3988:                          if (! (info->unresolved_syms_in_objects == RM_IGNORE
                   3989:                                 && (ELF_ST_VISIBILITY (hh->eh.other)
                   3990:                                     == STV_DEFAULT)))
                   3991:                            continue;
                   3992:                        }
                   3993:                      else
                   3994:                        {
                   3995:                          bfd_set_error (bfd_error_bad_value);
                   3996:                          goto error_ret_free_internal;
                   3997:                        }
                   3998:                    }
                   3999:
                   4000:                  /* Determine what (if any) linker stub is needed.  */
                   4001:                  stub_type = metag_type_of_stub (section, irela, hh,
                   4002:                                                  destination, info);
                   4003:                  if (stub_type == metag_stub_none)
                   4004:                    continue;
                   4005:
                   4006:                  /* Support for grouping stub sections.  */
                   4007:                  id_sec = htab->stub_group[section->id].link_sec;
                   4008:
                   4009:                  /* Get the name of this stub.  */
                   4010:                  stub_name = metag_stub_name (id_sec, sym_sec, hh, irela);
                   4011:                  if (!stub_name)
                   4012:                    goto error_ret_free_internal;
                   4013:
                   4014:                  hsh = metag_stub_hash_lookup (&htab->bstab,
                   4015:                                                stub_name,
                   4016:                                                FALSE, FALSE);
                   4017:                  if (hsh != NULL)
                   4018:                    {
                   4019:                      /* The proper stub has already been created.  */
                   4020:                      free (stub_name);
                   4021:                      continue;
                   4022:                    }
                   4023:
                   4024:                  hsh = metag_add_stub (stub_name, section, htab);
                   4025:                  if (hsh == NULL)
                   4026:                    {
                   4027:                      free (stub_name);
                   4028:                      goto error_ret_free_internal;
                   4029:                    }
                   4030:                  hsh->target_value = sym_value;
                   4031:                  hsh->target_section = sym_sec;
                   4032:                  hsh->stub_type = stub_type;
                   4033:                  hsh->hh = hh;
                   4034:                  hsh->addend = irela->r_addend;
                   4035:                  stub_changed = TRUE;
                   4036:                }
                   4037:
                   4038:              /* We're done with the internal relocs, free them.  */
                   4039:              if (elf_section_data (section)->relocs == NULL)
                   4040:                free (internal_relocs);
                   4041:            }
                   4042:        }
                   4043:
                   4044:       if (!stub_changed)
                   4045:        break;
                   4046:
                   4047:       /* OK, we've added some stubs.  Find out the new size of the
                   4048:         stub sections.  */
                   4049:       for (stub_sec = htab->stub_bfd->sections;
                   4050:           stub_sec != NULL;
                   4051:           stub_sec = stub_sec->next)
                   4052:        stub_sec->size = 0;
                   4053:
                   4054:       bfd_hash_traverse (&htab->bstab, metag_size_one_stub, htab);
                   4055:
                   4056:       /* Ask the linker to do its stuff.  */
                   4057:       (*htab->layout_sections_again) ();
                   4058:       stub_changed = FALSE;
                   4059:     }
                   4060:
                   4061:   free (htab->all_local_syms);
                   4062:   return TRUE;
                   4063:
                   4064:  error_ret_free_local:
                   4065:   free (htab->all_local_syms);
                   4066:   return FALSE;
                   4067: }
                   4068:
                   4069: /* Build all the stubs associated with the current output file.  The
                   4070:    stubs are kept in a hash table attached to the main linker hash
                   4071:    table.  This function is called via metagelf_finish in the linker.  */
                   4072:
                   4073: bfd_boolean
                   4074: elf_metag_build_stubs (struct bfd_link_info *info)
                   4075: {
                   4076:   asection *stub_sec;
                   4077:   struct bfd_hash_table *table;
                   4078:   struct elf_metag_link_hash_table *htab;
                   4079:
                   4080:   htab = metag_link_hash_table (info);
                   4081:
                   4082:   for (stub_sec = htab->stub_bfd->sections;
                   4083:        stub_sec != NULL;
                   4084:        stub_sec = stub_sec->next)
                   4085:     {
                   4086:       bfd_size_type size;
                   4087:
                   4088:       /* Allocate memory to hold the linker stubs.  */
                   4089:       size = stub_sec->size;
                   4090:       stub_sec->contents = bfd_zalloc (htab->stub_bfd, size);
                   4091:       if (stub_sec->contents == NULL && size != 0)
                   4092:        return FALSE;
                   4093:       stub_sec->size = 0;
                   4094:     }
                   4095:
                   4096:   /* Build the stubs as directed by the stub hash table.  */
                   4097:   table = &htab->bstab;
                   4098:   bfd_hash_traverse (table, metag_build_one_stub, info);
                   4099:
                   4100:   return TRUE;
                   4101: }
                   4102:
                   4103: /* Return TRUE if SYM represents a local label symbol.  */
                   4104:
                   4105: static bfd_boolean
                   4106: elf_metag_is_local_label_name (bfd *abfd ATTRIBUTE_UNUSED, const char *name)
                   4107: {
                   4108:   if (name[0] == '$' && name[1] == 'L')
                   4109:     return 1;
                   4110:   return _bfd_elf_is_local_label_name (abfd, name);
                   4111: }
                   4112:
                   4113: /* Return address for Ith PLT stub in section PLT, for relocation REL
                   4114:    or (bfd_vma) -1 if it should not be included.  */
                   4115:
                   4116: static bfd_vma
                   4117: elf_metag_plt_sym_val (bfd_vma i, const asection *plt,
                   4118:                       const arelent *rel ATTRIBUTE_UNUSED)
                   4119: {
                   4120:   return plt->vma + (i + 1) * PLT_ENTRY_SIZE;
                   4121: }
                   4122:
                   4123: #define ELF_ARCH               bfd_arch_metag
                   4124: #define ELF_TARGET_ID          METAG_ELF_DATA
                   4125: #define ELF_MACHINE_CODE       EM_METAG
                   4126: #define ELF_MINPAGESIZE        0x1000
                   4127: #define ELF_MAXPAGESIZE        0x4000
                   4128: #define ELF_COMMONPAGESIZE     0x1000
                   4129:
                   4130: #define TARGET_LITTLE_SYM      metag_elf32_vec
                   4131: #define TARGET_LITTLE_NAME     "elf32-metag"
                   4132:
                   4133: #define elf_symbol_leading_char '_'
                   4134:
                   4135: #define elf_info_to_howto_rel                  NULL
                   4136: #define elf_info_to_howto                      metag_info_to_howto_rela
                   4137:
                   4138: #define bfd_elf32_bfd_is_local_label_name      elf_metag_is_local_label_name
                   4139: #define bfd_elf32_bfd_link_hash_table_create \
                   4140:        elf_metag_link_hash_table_create
                   4141: #define elf_backend_relocate_section           elf_metag_relocate_section
                   4142: #define elf_backend_gc_mark_hook               elf_metag_gc_mark_hook
                   4143: #define elf_backend_check_relocs               elf_metag_check_relocs
                   4144: #define elf_backend_create_dynamic_sections    elf_metag_create_dynamic_sections
                   4145: #define elf_backend_adjust_dynamic_symbol      elf_metag_adjust_dynamic_symbol
                   4146: #define elf_backend_finish_dynamic_symbol      elf_metag_finish_dynamic_symbol
                   4147: #define elf_backend_finish_dynamic_sections    elf_metag_finish_dynamic_sections
                   4148: #define elf_backend_size_dynamic_sections      elf_metag_size_dynamic_sections
                   4149: #define elf_backend_omit_section_dynsym \
1.1.1.3   christos 4150:        _bfd_elf_omit_section_dynsym_all
1.1.1.4 ! christos 4151: #define elf_backend_init_file_header           elf_metag_init_file_header
1.1       christos 4152: #define elf_backend_reloc_type_class           elf_metag_reloc_type_class
                   4153: #define elf_backend_copy_indirect_symbol       elf_metag_copy_indirect_symbol
                   4154: #define elf_backend_plt_sym_val                elf_metag_plt_sym_val
                   4155:
                   4156: #define elf_backend_can_gc_sections            1
                   4157: #define elf_backend_can_refcount               1
1.1.1.3   christos 4158: #define elf_backend_rela_normal                        1
                   4159: #define elf_backend_want_got_plt               1
1.1       christos 4160: #define elf_backend_want_got_sym               0
                   4161: #define elf_backend_want_plt_sym               0
                   4162: #define elf_backend_plt_readonly               1
1.1.1.3   christos 4163: #define elf_backend_dtrel_excludes_plt         1
                   4164: #define elf_backend_want_dynrelro              1
1.1       christos 4165:
                   4166: #define bfd_elf32_bfd_reloc_type_lookup        metag_reloc_type_lookup
                   4167: #define bfd_elf32_bfd_reloc_name_lookup        metag_reloc_name_lookup
                   4168:
                   4169: #include "elf32-target.h"

CVSweb <webmaster@jp.NetBSD.org>