bfd/elf32-mep.c

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