bfd/elf32-mep.c

   1 /* MeP-specific support for 32-bit ELF.
   2    Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006
   3    Free Software Foundation, Inc.
   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 2 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, MA 02110-1301, USA.  */
  20
  21 #include "bfd.h"
  22 #include "sysdep.h"
  23 #include "libbfd.h"
  24 #include "elf-bfd.h"
  25 #include "elf/mep.h"
  26 #include "libiberty.h"
  27
  28 /* Forward declarations.  */
  29
  30 /* Private relocation functions.  */
  31 \f
  32 #define MEPREL(type, size, bits, right, left, pcrel, overflow, mask) \
  33   {(unsigned)type, right, size, bits, pcrel, left, overflow, mep_reloc, #type, FALSE, 0, mask, 0 }
  34
  35 #define N complain_overflow_dont
  36 #define S complain_overflow_signed
  37 #define U complain_overflow_unsigned
  38
  39 static bfd_reloc_status_type mep_reloc (bfd *, arelent *, struct bfd_symbol *,
  40                                         void *, asection *, bfd *, char **);
  41
  42 static reloc_howto_type mep_elf_howto_table [] =
  43 {
  44   /* type, size, bits, leftshift, rightshift, pcrel, OD/OS/OU, mask.  */
  45   MEPREL (R_MEP_NONE,     0,  0, 0, 0, 0, N, 0),
  46   MEPREL (R_RELC,         0,  0, 0, 0, 0, N, 0),
  47   /* MEPRELOC:HOWTO */
  48     /* This section generated from bfd/mep-relocs.pl from include/elf/mep.h.  */
  49   MEPREL (R_MEP_8,        0,  8, 0, 0, 0, U, 0xff),
  50   MEPREL (R_MEP_16,       1, 16, 0, 0, 0, U, 0xffff),
  51   MEPREL (R_MEP_32,       2, 32, 0, 0, 0, U, 0xffffffff),
  52   MEPREL (R_MEP_PCREL8A2, 1,  8, 1, 1, 1, S, 0x00fe),
  53   MEPREL (R_MEP_PCREL12A2,1, 12, 1, 1, 1, S, 0x0ffe),
  54   MEPREL (R_MEP_PCREL17A2,2, 17, 0, 1, 1, S, 0x0000ffff),
  55   MEPREL (R_MEP_PCREL24A2,2, 24, 0, 1, 1, S, 0x07f0ffff),
  56   MEPREL (R_MEP_PCABS24A2,2, 24, 0, 1, 0, U, 0x07f0ffff),
  57   MEPREL (R_MEP_LOW16,    2, 16, 0, 0, 0, N, 0x0000ffff),
  58   MEPREL (R_MEP_HI16U,    2, 32, 0,16, 0, N, 0x0000ffff),
  59   MEPREL (R_MEP_HI16S,    2, 32, 0,16, 0, N, 0x0000ffff),
  60   MEPREL (R_MEP_GPREL,    2, 16, 0, 0, 0, S, 0x0000ffff),
  61   MEPREL (R_MEP_TPREL,    2, 16, 0, 0, 0, S, 0x0000ffff),
  62   MEPREL (R_MEP_TPREL7,   1,  7, 0, 0, 0, U, 0x007f),
  63   MEPREL (R_MEP_TPREL7A2, 1,  7, 1, 1, 0, U, 0x007e),
  64   MEPREL (R_MEP_TPREL7A4, 1,  7, 2, 2, 0, U, 0x007c),
  65   MEPREL (R_MEP_UIMM24,   2, 24, 0, 0, 0, U, 0x00ffffff),
  66   MEPREL (R_MEP_ADDR24A4, 2, 24, 0, 2, 0, U, 0x00fcffff),
  67   MEPREL (R_MEP_GNU_VTINHERIT,1,  0,16,32, 0, N, 0x0000),
  68   MEPREL (R_MEP_GNU_VTENTRY,1,  0,16,32, 0, N, 0x0000),
  69   /* MEPRELOC:END */
  70 };
  71
  72 #define VALID_MEP_RELOC(N) ((N) >= 0 \
  73   && (N) < ARRAY_SIZE (mep_elf_howto_table)
  74
  75 #undef N
  76 #undef S
  77 #undef U
  78
  79 static bfd_reloc_status_type
  80 mep_reloc
  81     (bfd *               abfd ATTRIBUTE_UNUSED,
  82      arelent *           reloc_entry ATTRIBUTE_UNUSED,
  83      struct bfd_symbol * symbol ATTRIBUTE_UNUSED,
  84      void *              data ATTRIBUTE_UNUSED,
  85      asection *          input_section ATTRIBUTE_UNUSED,
  86      bfd *               output_bfd ATTRIBUTE_UNUSED,
  87      char **             error_message ATTRIBUTE_UNUSED)
  88 {
  89   return bfd_reloc_ok;
  90 }
  91
  92 \f
  93
  94 #define BFD_RELOC_MEP_NONE BFD_RELOC_NONE
  95 #if defined (__STDC__) || defined (ALMOST_STDC) || defined (HAVE_STRINGIZE)
  96 #define MAP(n) case BFD_RELOC_MEP_##n: type = R_MEP_##n; break
  97 #else
  98 #define MAP(n) case BFD_RELOC_MEP_/**/n: type = R_MEP_/**/n; break
  99 #endif
 100
 101 static reloc_howto_type *
 102 mep_reloc_type_lookup
 103     (bfd * abfd ATTRIBUTE_UNUSED,
 104      bfd_reloc_code_real_type code)
 105 {
 106   unsigned int type = 0;
 107
 108   switch (code)
 109     {
 110     MAP(NONE);
 111     case BFD_RELOC_8:
 112       type = R_MEP_8;
 113       break;
 114     case BFD_RELOC_16:
 115       type = R_MEP_16;
 116       break;
 117     case BFD_RELOC_32:
 118       type = R_MEP_32;
 119       break;
 120     case BFD_RELOC_VTABLE_ENTRY:
 121       type = R_MEP_GNU_VTENTRY;
 122       break;
 123     case BFD_RELOC_VTABLE_INHERIT:
 124       type = R_MEP_GNU_VTINHERIT;
 125       break;
 126     case BFD_RELOC_RELC:
 127       type = R_RELC;
 128       break;
 129
 130     /* MEPRELOC:MAP */
 131     /* This section generated from bfd/mep-relocs.pl from include/elf/mep.h.  */
 132     MAP(8);
 133     MAP(16);
 134     MAP(32);
 135     MAP(PCREL8A2);
 136     MAP(PCREL12A2);
 137     MAP(PCREL17A2);
 138     MAP(PCREL24A2);
 139     MAP(PCABS24A2);
 140     MAP(LOW16);
 141     MAP(HI16U);
 142     MAP(HI16S);
 143     MAP(GPREL);
 144     MAP(TPREL);
 145     MAP(TPREL7);
 146     MAP(TPREL7A2);
 147     MAP(TPREL7A4);
 148     MAP(UIMM24);
 149     MAP(ADDR24A4);
 150     MAP(GNU_VTINHERIT);
 151     MAP(GNU_VTENTRY);
 152     /* MEPRELOC:END */
 153
 154     default:
 155       /* Pacify gcc -Wall.  */
 156       fprintf (stderr, "mep: no reloc for code %d\n", code);
 157       return NULL;
 158     }
 159
 160   if (mep_elf_howto_table[type].type != type)
 161     {
 162       fprintf (stderr, "MeP: howto %d has type %d\n", type, mep_elf_howto_table[type].type);
 163       abort ();
 164     }
 165
 166   return mep_elf_howto_table + type;
 167 }
 168
 169 #undef MAP
 170
 171 \f
 172 /* Perform a single relocation.  */
 173
 174 static struct bfd_link_info *mep_info;
 175 static int warn_tp = 0, warn_sda = 0;
 176
 177 static bfd_vma
 178 mep_lookup_global
 179     (char *    name,
 180      bfd_vma   ofs,
 181      bfd_vma * cache,
 182      int *     warn)
 183 {
 184   struct bfd_link_hash_entry *h;
 185
 186   if (*cache || *warn)
 187     return *cache;
 188
 189   h = bfd_link_hash_lookup (mep_info->hash, name, FALSE, FALSE, TRUE);
 190   if (h == 0 || h->type != bfd_link_hash_defined)
 191     {
 192       *warn = ofs + 1;
 193       return 0;
 194     }
 195   *cache = (h->u.def.value
 196           + h->u.def.section->output_section->vma
 197           + h->u.def.section->output_offset);
 198   return *cache;
 199 }
 200
 201 static bfd_vma
 202 mep_tpoff_base (bfd_vma ofs)
 203 {
 204   static bfd_vma cache = 0;
 205   return mep_lookup_global ("__tpbase", ofs, &cache, &warn_tp);
 206 }
 207
 208 static bfd_vma
 209 mep_sdaoff_base (bfd_vma ofs)
 210 {
 211   static bfd_vma cache = 0;
 212   return mep_lookup_global ("__sdabase", ofs, &cache, &warn_sda);
 213 }
 214
 215 static bfd_reloc_status_type
 216 mep_final_link_relocate
 217     (reloc_howto_type *  howto,
 218      bfd *               input_bfd,
 219      asection *          input_section,
 220      bfd_byte *          contents,
 221      Elf_Internal_Rela * rel,
 222      bfd_vma             relocation)
 223 {
 224   unsigned long u;
 225   long s;
 226   unsigned char *byte;
 227   bfd_vma pc;
 228   bfd_reloc_status_type r = bfd_reloc_ok;
 229   int e2, e4;
 230
 231   if (bfd_big_endian (input_bfd))
 232     {
 233       e2 = 0;
 234       e4 = 0;
 235     }
 236   else
 237     {
 238       e2 = 1;
 239       e4 = 3;
 240     }
 241
 242   pc = (input_section->output_section->vma
 243         + input_section->output_offset
 244         + rel->r_offset);
 245
 246   s = relocation + rel->r_addend;
 247
 248   byte = (unsigned char *)contents + rel->r_offset;
 249
 250   if (howto->type == R_MEP_PCREL24A2
 251       && s == 0
 252       && pc >= 0x800000)
 253     {
 254       /* This is an unreachable branch to an undefined weak function.
 255          Silently ignore it, since the opcode can't do that but should
 256          never be executed anyway.  */
 257       return bfd_reloc_ok;
 258     }
 259
 260   if (howto->pc_relative)
 261     s -= pc;
 262
 263   u = (unsigned long) s;
 264
 265   switch (howto->type)
 266     {
 267     /* MEPRELOC:APPLY */
 268     /* This section generated from bfd/mep-relocs.pl from include/elf/mep.h.  */
 269     case R_MEP_8: /* 76543210 */
 270       if (u > 255) r = bfd_reloc_overflow;
 271       byte[0] = (u & 0xff);
 272       break;
 273     case R_MEP_16: /* fedcba9876543210 */
 274       if (u > 65535) r = bfd_reloc_overflow;
 275       byte[0^e2] = ((u >> 8) & 0xff);
 276       byte[1^e2] = (u & 0xff);
 277       break;
 278     case R_MEP_32: /* vutsrqponmlkjihgfedcba9876543210 */
 279       byte[0^e4] = ((u >> 24) & 0xff);
 280       byte[1^e4] = ((u >> 16) & 0xff);
 281       byte[2^e4] = ((u >> 8) & 0xff);
 282       byte[3^e4] = (u & 0xff);
 283       break;
 284     case R_MEP_PCREL8A2: /* --------7654321- */
 285       if (-128 > s || s > 127) r = bfd_reloc_overflow;
 286       byte[1^e2] = (byte[1^e2] & 0x01) | (s & 0xfe);
 287       break;
 288     case R_MEP_PCREL12A2: /* ----ba987654321- */
 289       if (-2048 > s || s > 2047) r = bfd_reloc_overflow;
 290       byte[0^e2] = (byte[0^e2] & 0xf0) | ((s >> 8) & 0x0f);
 291       byte[1^e2] = (byte[1^e2] & 0x01) | (s & 0xfe);
 292       break;
 293     case R_MEP_PCREL17A2: /* ----------------gfedcba987654321 */
 294       if (-65536 > s || s > 65535) r = bfd_reloc_overflow;
 295       byte[2^e2] = ((s >> 9) & 0xff);
 296       byte[3^e2] = ((s >> 1) & 0xff);
 297       break;
 298     case R_MEP_PCREL24A2: /* -----7654321----nmlkjihgfedcba98 */
 299       if (-8388608 > s || s > 8388607) r = bfd_reloc_overflow;
 300       byte[0^e2] = (byte[0^e2] & 0xf8) | ((s >> 5) & 0x07);
 301       byte[1^e2] = (byte[1^e2] & 0x0f) | ((s << 3) & 0xf0);
 302       byte[2^e2] = ((s >> 16) & 0xff);
 303       byte[3^e2] = ((s >> 8) & 0xff);
 304       break;
 305     case R_MEP_PCABS24A2: /* -----7654321----nmlkjihgfedcba98 */
 306       if (u > 16777215) r = bfd_reloc_overflow;
 307       byte[0^e2] = (byte[0^e2] & 0xf8) | ((u >> 5) & 0x07);
 308       byte[1^e2] = (byte[1^e2] & 0x0f) | ((u << 3) & 0xf0);
 309       byte[2^e2] = ((u >> 16) & 0xff);
 310       byte[3^e2] = ((u >> 8) & 0xff);
 311       break;
 312     case R_MEP_LOW16: /* ----------------fedcba9876543210 */
 313       byte[2^e2] = ((u >> 8) & 0xff);
 314       byte[3^e2] = (u & 0xff);
 315       break;
 316     case R_MEP_HI16U: /* ----------------vutsrqponmlkjihg */
 317       byte[2^e2] = ((u >> 24) & 0xff);
 318       byte[3^e2] = ((u >> 16) & 0xff);
 319       break;
 320     case R_MEP_HI16S: /* ----------------vutsrqponmlkjihg */
 321       byte[2^e2] = ((s >> 24) & 0xff);
 322       byte[3^e2] = ((s >> 16) & 0xff);
 323       break;
 324     case R_MEP_GPREL: /* ----------------fedcba9876543210 */
 325       s -= mep_sdaoff_base(rel->r_offset);
 326       if (-32768 > s || s > 32767) r = bfd_reloc_overflow;
 327       byte[2^e2] = ((s >> 8) & 0xff);
 328       byte[3^e2] = (s & 0xff);
 329       break;
 330     case R_MEP_TPREL: /* ----------------fedcba9876543210 */
 331       s -= mep_tpoff_base(rel->r_offset);
 332       if (-32768 > s || s > 32767) r = bfd_reloc_overflow;
 333       byte[2^e2] = ((s >> 8) & 0xff);
 334       byte[3^e2] = (s & 0xff);
 335       break;
 336     case R_MEP_TPREL7: /* ---------6543210 */
 337       u -= mep_tpoff_base(rel->r_offset);
 338       if (u > 127) r = bfd_reloc_overflow;
 339       byte[1^e2] = (byte[1^e2] & 0x80) | (u & 0x7f);
 340       break;
 341     case R_MEP_TPREL7A2: /* ---------654321- */
 342       u -= mep_tpoff_base(rel->r_offset);
 343       if (u > 127) r = bfd_reloc_overflow;
 344       byte[1^e2] = (byte[1^e2] & 0x81) | (u & 0x7e);
 345       break;
 346     case R_MEP_TPREL7A4: /* ---------65432-- */
 347       u -= mep_tpoff_base(rel->r_offset);
 348       if (u > 127) r = bfd_reloc_overflow;
 349       byte[1^e2] = (byte[1^e2] & 0x83) | (u & 0x7c);
 350       break;
 351     case R_MEP_UIMM24: /* --------76543210nmlkjihgfedcba98 */
 352       if (u > 16777215) r = bfd_reloc_overflow;
 353       byte[1^e2] = (u & 0xff);
 354       byte[2^e2] = ((u >> 16) & 0xff);
 355       byte[3^e2] = ((u >> 8) & 0xff);
 356       break;
 357     case R_MEP_ADDR24A4: /* --------765432--nmlkjihgfedcba98 */
 358       if (u > 16777215) r = bfd_reloc_overflow;
 359       byte[1^e2] = (byte[1^e2] & 0x03) | (u & 0xfc);
 360       byte[2^e2] = ((u >> 16) & 0xff);
 361       byte[3^e2] = ((u >> 8) & 0xff);
 362       break;
 363     case R_MEP_GNU_VTINHERIT: /* ---------------- */
 364       break;
 365     case R_MEP_GNU_VTENTRY: /* ---------------- */
 366       break;
 367     /* MEPRELOC:END */
 368     default:
 369       abort ();
 370     }
 371
 372   return r;
 373 }
 374 \f
 375 /* Set the howto pointer for a MEP ELF reloc.  */
 376
 377 static void
 378 mep_info_to_howto_rela
 379     (bfd *               abfd ATTRIBUTE_UNUSED,
 380      arelent *           cache_ptr,
 381      Elf_Internal_Rela * dst)
 382 {
 383   unsigned int r_type;
 384
 385   r_type = ELF32_R_TYPE (dst->r_info);
 386   cache_ptr->howto = & mep_elf_howto_table [r_type];
 387 }
 388
 389 /* Look through the relocs for a section during the first phase.
 390    Since we don't do .gots or .plts, we just need to consider the
 391    virtual table relocs for gc.  */
 392
 393 static bfd_boolean
 394 mep_elf_check_relocs
 395     (bfd *                     abfd,
 396      struct bfd_link_info *    info,
 397      asection *                sec,
 398      const Elf_Internal_Rela * relocs)
 399 {
 400   Elf_Internal_Shdr *           symtab_hdr;
 401   struct elf_link_hash_entry ** sym_hashes;
 402   struct elf_link_hash_entry ** sym_hashes_end;
 403   const Elf_Internal_Rela *     rel;
 404   const Elf_Internal_Rela *     rel_end;
 405
 406   if (info->relocatable)
 407     return TRUE;
 408
 409   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
 410   sym_hashes = elf_sym_hashes (abfd);
 411   sym_hashes_end = sym_hashes + symtab_hdr->sh_size / sizeof (Elf32_External_Sym);
 412   if (!elf_bad_symtab (abfd))
 413     sym_hashes_end -= symtab_hdr->sh_info;
 414
 415   rel_end = relocs + sec->reloc_count;
 416   for (rel = relocs; rel < rel_end; rel++)
 417     {
 418       struct elf_link_hash_entry *h;
 419       unsigned long r_symndx;
 420
 421       r_symndx = ELF32_R_SYM (rel->r_info);
 422       if (r_symndx < symtab_hdr->sh_info)
 423         h = NULL;
 424       else
 425         h = sym_hashes[r_symndx - symtab_hdr->sh_info];
 426     }
 427   return TRUE;
 428 }
 429
 430 \f
 431 /* Relocate a MEP ELF section.
 432    There is some attempt to make this function usable for many architectures,
 433    both USE_REL and USE_RELA ['twould be nice if such a critter existed],
 434    if only to serve as a learning tool.
 435
 436    The RELOCATE_SECTION function is called by the new ELF backend linker
 437    to handle the relocations for a section.
 438
 439    The relocs are always passed as Rela structures; if the section
 440    actually uses Rel structures, the r_addend field will always be
 441    zero.
 442
 443    This function is responsible for adjusting the section contents as
 444    necessary, and (if using Rela relocs and generating a relocatable
 445    output file) adjusting the reloc addend as necessary.
 446
 447    This function does not have to worry about setting the reloc
 448    address or the reloc symbol index.
 449
 450    LOCAL_SYMS is a pointer to the swapped in local symbols.
 451
 452    LOCAL_SECTIONS is an array giving the section in the input file
 453    corresponding to the st_shndx field of each local symbol.
 454
 455    The global hash table entry for the global symbols can be found
 456    via elf_sym_hashes (input_bfd).
 457
 458    When generating relocatable output, this function must handle
 459    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
 460    going to be the section symbol corresponding to the output
 461    section, which means that the addend must be adjusted
 462    accordingly.  */
 463
 464 static bfd_boolean
 465 mep_elf_relocate_section
 466     (bfd *                   output_bfd ATTRIBUTE_UNUSED,
 467      struct bfd_link_info *  info,
 468      bfd *                   input_bfd,
 469      asection *              input_section,
 470      bfd_byte *              contents,
 471      Elf_Internal_Rela *     relocs,
 472      Elf_Internal_Sym *      local_syms,
 473      asection **             local_sections)
 474 {
 475   Elf_Internal_Shdr *           symtab_hdr;
 476   struct elf_link_hash_entry ** sym_hashes;
 477   Elf_Internal_Rela *           rel;
 478   Elf_Internal_Rela *           relend;
 479
 480   symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
 481   sym_hashes = elf_sym_hashes (input_bfd);
 482   relend     = relocs + input_section->reloc_count;
 483
 484   mep_info = info;
 485
 486   for (rel = relocs; rel < relend; rel ++)
 487     {
 488       reloc_howto_type *           howto;
 489       unsigned long                r_symndx;
 490       Elf_Internal_Sym *           sym;
 491       asection *                   sec;
 492       struct elf_link_hash_entry * h;
 493       bfd_vma                      relocation;
 494       bfd_reloc_status_type        r;
 495       const char *                 name = NULL;
 496       int                          r_type;
 497
 498       r_type = ELF32_R_TYPE (rel->r_info);
 499
 500       r_symndx = ELF32_R_SYM (rel->r_info);
 501
 502       if (info->relocatable)
 503         {
 504           /* This is a relocatable link.  We don't have to change
 505              anything, unless the reloc is against a section symbol,
 506              in which case we have to adjust according to where the
 507              section symbol winds up in the output section.  */
 508           if (r_symndx < symtab_hdr->sh_info)
 509             {
 510               sym = local_syms + r_symndx;
 511
 512               if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
 513                 {
 514                   sec = local_sections [r_symndx];
 515                   rel->r_addend += sec->output_offset + sym->st_value;
 516                 }
 517             }
 518
 519           continue;
 520         }
 521
 522       /* Is this a complex relocation?  */
 523       if (ELF32_R_TYPE (rel->r_info) == R_RELC)
 524         {
 525           bfd_elf_perform_complex_relocation (output_bfd, info,
 526                                               input_bfd, input_section, contents,
 527                                               rel, local_syms, local_sections);
 528           continue;
 529         }
 530
 531       /* This is a final link.  */
 532       howto  = mep_elf_howto_table + ELF32_R_TYPE (rel->r_info);
 533       h      = NULL;
 534       sym    = NULL;
 535       sec    = NULL;
 536
 537       if (r_symndx < symtab_hdr->sh_info)
 538         {
 539           sym = local_syms + r_symndx;
 540           sec = local_sections [r_symndx];
 541           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
 542
 543           name = bfd_elf_string_from_elf_section
 544             (input_bfd, symtab_hdr->sh_link, sym->st_name);
 545           name = (name == NULL) ? bfd_section_name (input_bfd, sec) : name;
 546 #if 0
 547           fprintf (stderr, "local: sec: %s, sym: %s (%d), value: %x + %x + %x addend %x\n",
 548                    sec->name, name, sym->st_name,
 549                    sec->output_section->vma, sec->output_offset,
 550                    sym->st_value, rel->r_addend);
 551 #endif
 552         }
 553       else
 554         {
 555           h = sym_hashes [r_symndx];
 556
 557           while (h->root.type == bfd_link_hash_indirect
 558                  || h->root.type == bfd_link_hash_warning)
 559             h = (struct elf_link_hash_entry *) h->root.u.i.link;
 560
 561           name = h->root.root.string;
 562
 563           if (h->root.type == bfd_link_hash_defined
 564               || h->root.type == bfd_link_hash_defweak)
 565             {
 566               sec = h->root.u.def.section;
 567               relocation = (h->root.u.def.value
 568                             + sec->output_section->vma
 569                             + sec->output_offset);
 570 #if 0
 571               fprintf (stderr,
 572                        "defined: sec: %s, name: %s, value: %x + %x + %x gives: %x\n",
 573                        sec->name, name, h->root.u.def.value,
 574                        sec->output_section->vma, sec->output_offset, relocation);
 575 #endif
 576             }
 577           else if (h->root.type == bfd_link_hash_undefweak)
 578             {
 579 #if 0
 580               fprintf (stderr, "undefined: sec: %s, name: %s\n",
 581                        sec->name, name);
 582 #endif
 583               relocation = 0;
 584             }
 585           else
 586             {
 587               if (! ((*info->callbacks->undefined_symbol)
 588                      (info, h->root.root.string, input_bfd,
 589                       input_section, rel->r_offset,
 590                       (!info->shared && info->unresolved_syms_in_objects == RM_GENERATE_ERROR))))
 591                 return FALSE;
 592 #if 0
 593               fprintf (stderr, "unknown: name: %s\n", name);
 594 #endif
 595               relocation = 0;
 596             }
 597         }
 598
 599       switch (r_type)
 600         {
 601         default:
 602           r = mep_final_link_relocate (howto, input_bfd, input_section,
 603                                          contents, rel, relocation);
 604           break;
 605         }
 606
 607       if (r != bfd_reloc_ok)
 608         {
 609           const char * msg = (const char *) NULL;
 610
 611           switch (r)
 612             {
 613             case bfd_reloc_overflow:
 614               r = info->callbacks->reloc_overflow
 615                 (info, (h ? &h->root : NULL), name, howto->name, (bfd_vma) 0,
 616                  input_bfd, input_section, rel->r_offset);
 617               break;
 618
 619             case bfd_reloc_undefined:
 620               r = info->callbacks->undefined_symbol
 621                 (info, name, input_bfd, input_section, rel->r_offset, TRUE);
 622               break;
 623
 624             case bfd_reloc_outofrange:
 625               msg = _("internal error: out of range error");
 626               break;
 627
 628             case bfd_reloc_notsupported:
 629               msg = _("internal error: unsupported relocation error");
 630               break;
 631
 632             case bfd_reloc_dangerous:
 633               msg = _("internal error: dangerous relocation");
 634               break;
 635
 636             default:
 637               msg = _("internal error: unknown error");
 638               break;
 639             }
 640
 641           if (msg)
 642             r = info->callbacks->warning
 643               (info, msg, name, input_bfd, input_section, rel->r_offset);
 644
 645           if (! r)
 646             return FALSE;
 647         }
 648     }
 649
 650   if (warn_tp)
 651     info->callbacks->undefined_symbol
 652       (info, "__tpbase", input_bfd, input_section, warn_tp-1, TRUE);
 653   if (warn_sda)
 654     info->callbacks->undefined_symbol
 655       (info, "__sdabase", input_bfd, input_section, warn_sda-1, TRUE);
 656   if (warn_sda || warn_tp)
 657     return FALSE;
 658
 659   return TRUE;
 660 }
 661 \f
 662
 663 /* Update the got entry reference counts for the section being
 664    removed.  */
 665
 666 static bfd_boolean
 667 mep_elf_gc_sweep_hook
 668     (bfd *                     abfd ATTRIBUTE_UNUSED,
 669      struct bfd_link_info *    info ATTRIBUTE_UNUSED,
 670      asection *                sec ATTRIBUTE_UNUSED,
 671      const Elf_Internal_Rela * relocs ATTRIBUTE_UNUSED)
 672 {
 673   return TRUE;
 674 }
 675
 676 /* Return the section that should be marked against GC for a given
 677    relocation.  */
 678
 679 static asection *
 680 mep_elf_gc_mark_hook
 681     (asection *                   sec,
 682      struct bfd_link_info *       info ATTRIBUTE_UNUSED,
 683      Elf_Internal_Rela *          rel,
 684      struct elf_link_hash_entry * h,
 685      Elf_Internal_Sym *           sym)
 686 {
 687   if (h != NULL)
 688     {
 689       switch (ELF32_R_TYPE (rel->r_info))
 690         {
 691         default:
 692           switch (h->root.type)
 693             {
 694             case bfd_link_hash_defined:
 695             case bfd_link_hash_defweak:
 696               return h->root.u.def.section;
 697
 698             case bfd_link_hash_common:
 699               return h->root.u.c.p->section;
 700
 701             default:
 702               break;
 703             }
 704         }
 705     }
 706   else
 707     {
 708       if (!(elf_bad_symtab (sec->owner)
 709             && ELF_ST_BIND (sym->st_info) != STB_LOCAL)
 710           && ! ((sym->st_shndx <= 0 || sym->st_shndx >= SHN_LORESERVE)
 711                 && sym->st_shndx != SHN_COMMON))
 712         return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
 713     }
 714
 715   return NULL;
 716 }
 717
 718 \f
 719 /* Function to set the ELF flag bits.  */
 720
 721 static bfd_boolean
 722 mep_elf_set_private_flags (bfd *    abfd,
 723                            flagword flags)
 724 {
 725   elf_elfheader (abfd)->e_flags = flags;
 726   elf_flags_init (abfd) = TRUE;
 727   return TRUE;
 728 }
 729
 730 static bfd_boolean
 731 mep_elf_copy_private_bfd_data (bfd * ibfd, bfd * obfd)
 732 {
 733   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
 734       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
 735     return TRUE;
 736
 737   elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
 738   elf_flags_init (obfd) = TRUE;
 739   return TRUE;
 740 }
 741
 742 /* Merge backend specific data from an object file to the output
 743    object file when linking.  */
 744
 745 static bfd_boolean
 746 mep_elf_merge_private_bfd_data (bfd * ibfd, bfd * obfd)
 747 {
 748   static bfd *last_ibfd = 0;
 749   flagword old_flags, new_flags;
 750   flagword old_partial, new_partial;
 751
 752   /* Check if we have the same endianess.  */
 753   if (_bfd_generic_verify_endian_match (ibfd, obfd) == FALSE)
 754     return FALSE;
 755
 756   new_flags = elf_elfheader (ibfd)->e_flags;
 757   old_flags = elf_elfheader (obfd)->e_flags;
 758
 759 #ifdef DEBUG
 760   _bfd_error_handler ("%B: old_flags = 0x%.8lx, new_flags = 0x%.8lx, init = %s",
 761                       ibfd, old_flags, new_flags, elf_flags_init (obfd) ? "yes" : "no");
 762 #endif
 763
 764     /* First call, no flags set.  */
 765     if (!elf_flags_init (obfd))
 766     {
 767       elf_flags_init (obfd) = TRUE;
 768       old_flags = new_flags;
 769     }
 770   else if ((new_flags | old_flags) & EF_MEP_LIBRARY)
 771     {
 772       /* Non-library flags trump library flags.  The choice doesn't really
 773          matter if both OLD_FLAGS and NEW_FLAGS have EF_MEP_LIBRARY set.  */
 774       if (old_flags & EF_MEP_LIBRARY)
 775         old_flags = new_flags;
 776     }
 777   else
 778     {
 779       /* Make sure they're for the same mach.  Allow upgrade from the "mep"
 780          mach.  */
 781       new_partial = (new_flags & EF_MEP_CPU_MASK);
 782       old_partial = (old_flags & EF_MEP_CPU_MASK);
 783       if (new_partial == old_partial)
 784         ;
 785       else if (new_partial == EF_MEP_CPU_MEP)
 786         ;
 787       else if (old_partial == EF_MEP_CPU_MEP)
 788         old_flags = (old_flags & ~EF_MEP_CPU_MASK) | new_partial;
 789       else
 790         {
 791           _bfd_error_handler (_("%B and %B are for different cores"), last_ibfd, ibfd);
 792           bfd_set_error (bfd_error_invalid_target);
 793           return FALSE;
 794         }
 795
 796       /* Make sure they're for the same me_module.  Allow basic config to
 797          mix with any other.  */
 798       new_partial = (new_flags & EF_MEP_INDEX_MASK);
 799       old_partial = (old_flags & EF_MEP_INDEX_MASK);
 800       if (new_partial == old_partial)
 801         ;
 802       else if (new_partial == 0)
 803         ;
 804       else if (old_partial == 0)
 805         old_flags = (old_flags & ~EF_MEP_INDEX_MASK) | new_partial;
 806       else
 807         {
 808           _bfd_error_handler (_("%B and %B are for different configurations"), last_ibfd, ibfd);
 809           bfd_set_error (bfd_error_invalid_target);
 810           return FALSE;
 811         }
 812     }
 813
 814   elf_elfheader (obfd)->e_flags = old_flags;
 815   last_ibfd = ibfd;
 816   return TRUE;
 817 }
 818
 819 /* This will be edited by the MeP configration tool.  */
 820 static const char * config_names[] =
 821 {
 822   "basic"
 823   /* start-mepcfgtool */
 824   ,"simple"
 825   ,"fmax"
 826   /* end-mepcfgtool */
 827 };
 828
 829 static const char * core_names[] =
 830 {
 831   "MeP", "MeP-c2", "MeP-c3", "MeP-h1"
 832 };
 833
 834 static bfd_boolean
 835 mep_elf_print_private_bfd_data (bfd * abfd, void * ptr)
 836 {
 837   FILE *   file = (FILE *) ptr;
 838   flagword flags, partial_flags;
 839
 840   BFD_ASSERT (abfd != NULL && ptr != NULL);
 841
 842   /* Print normal ELF private data.  */
 843   _bfd_elf_print_private_bfd_data (abfd, ptr);
 844
 845   flags = elf_elfheader (abfd)->e_flags;
 846   fprintf (file, _("private flags = 0x%lx"), (long)flags);
 847
 848   partial_flags = (flags & EF_MEP_CPU_MASK) >> 24;
 849   if (partial_flags < ARRAY_SIZE (core_names))
 850     fprintf (file, "  core: %s", core_names[(long)partial_flags]);
 851
 852   partial_flags = flags & EF_MEP_INDEX_MASK;
 853   if (partial_flags < ARRAY_SIZE (config_names))
 854     fprintf (file, "  me_module: %s", config_names[(long)partial_flags]);
 855
 856   fputc ('\n', file);
 857
 858   return TRUE;
 859 }
 860
 861 /* Return the machine subcode from the ELF e_flags header.  */
 862
 863 static int
 864 elf32_mep_machine (bfd * abfd)
 865 {
 866   switch (elf_elfheader (abfd)->e_flags & EF_MEP_CPU_MASK)
 867     {
 868     default: break;
 869     case EF_MEP_CPU_C2: return bfd_mach_mep;
 870     case EF_MEP_CPU_C3: return bfd_mach_mep;
 871     case EF_MEP_CPU_C4: return bfd_mach_mep;
 872     case EF_MEP_CPU_H1: return bfd_mach_mep_h1;
 873     }
 874
 875   return bfd_mach_mep;
 876 }
 877
 878 static bfd_boolean
 879 mep_elf_object_p (bfd * abfd)
 880 {
 881   /* Irix 5 and 6 is broken.  Object file symbol tables are not always
 882      sorted correctly such that local symbols preceed global symbols,
 883      and the sh_info field in the symbol table is not always right.  */
 884   /* This is needed for the RELC support code.  */
 885   elf_bad_symtab (abfd) = TRUE;
 886   bfd_default_set_arch_mach (abfd, bfd_arch_mep, elf32_mep_machine (abfd));
 887   return TRUE;
 888 }
 889
 890 static bfd_boolean
 891 mep_elf_section_flags (flagword * flags, const Elf_Internal_Shdr * hdr)
 892 {
 893   if (hdr->sh_flags & SHF_MEP_VLIW)
 894     * flags |= SEC_MEP_VLIW;
 895   return TRUE;
 896 }
 897
 898 static bfd_boolean
 899 mep_elf_fake_sections (bfd *               abfd ATTRIBUTE_UNUSED,
 900                        Elf_Internal_Shdr * hdr,
 901                        asection *          sec)
 902 {
 903   if (sec->flags & SEC_MEP_VLIW)
 904     hdr->sh_flags |= SHF_MEP_VLIW;
 905   return TRUE;
 906 }
 907
 908 \f
 909 #define ELF_ARCH                bfd_arch_mep
 910 #define ELF_MACHINE_CODE        EM_CYGNUS_MEP
 911 #define ELF_MAXPAGESIZE         0x1000
 912
 913 #define TARGET_BIG_SYM          bfd_elf32_mep_vec
 914 #define TARGET_BIG_NAME         "elf32-mep"
 915
 916 #define TARGET_LITTLE_SYM       bfd_elf32_mep_little_vec
 917 #define TARGET_LITTLE_NAME      "elf32-mep-little"
 918
 919 #define elf_info_to_howto_rel                   NULL
 920 #define elf_info_to_howto                       mep_info_to_howto_rela
 921 #define elf_backend_relocate_section            mep_elf_relocate_section
 922 #define elf_backend_gc_mark_hook                mep_elf_gc_mark_hook
 923 #define elf_backend_gc_sweep_hook               mep_elf_gc_sweep_hook
 924 #define elf_backend_check_relocs                mep_elf_check_relocs
 925 #define elf_backend_object_p                    mep_elf_object_p
 926 #define elf_backend_section_flags               mep_elf_section_flags
 927 #define elf_backend_fake_sections               mep_elf_fake_sections
 928
 929 #define elf_backend_can_gc_sections             1
 930
 931 #define bfd_elf32_bfd_reloc_type_lookup         mep_reloc_type_lookup
 932 #define bfd_elf32_bfd_set_private_flags         mep_elf_set_private_flags
 933 #define bfd_elf32_bfd_copy_private_bfd_data     mep_elf_copy_private_bfd_data
 934 #define bfd_elf32_bfd_merge_private_bfd_data    mep_elf_merge_private_bfd_data
 935 #define bfd_elf32_bfd_print_private_bfd_data    mep_elf_print_private_bfd_data
 936
 937 /* We use only the RELA entries.  */
 938 #define USE_RELA
 939
 940 #include "elf32-target.h"