bfd/elf32-mep.c

   1 /* MeP-specific support for 32-bit ELF.
   2    Copyright (C) 2001-2019 Free Software Foundation, Inc.
   3
   4    This file is part of BFD, the Binary File Descriptor library.
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 3 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, write to the Free Software
  18    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
  19    MA 02110-1301, USA.  */
  20
  21 #include "sysdep.h"
  22 #include "bfd.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   HOWTO (type, right, size, bits, pcrel, left, overflow, bfd_elf_generic_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 reloc_howto_type mep_elf_howto_table [] =
  40 {
  41   /* type, size, bits, leftshift, rightshift, pcrel, OD/OS/OU, mask.  */
  42   MEPREL (R_MEP_NONE,     3,  0, 0, 0, 0, N, 0),
  43   MEPREL (R_RELC,         0,  0, 0, 0, 0, N, 0),
  44   /* MEPRELOC:HOWTO */
  45     /* This section generated from bfd/mep-relocs.pl from include/elf/mep.h.  */
  46   MEPREL (R_MEP_8,        0,  8, 0, 0, 0, U, 0xff),
  47   MEPREL (R_MEP_16,       1, 16, 0, 0, 0, U, 0xffff),
  48   MEPREL (R_MEP_32,       2, 32, 0, 0, 0, U, 0xffffffff),
  49   MEPREL (R_MEP_PCREL8A2, 1,  8, 1, 1, 1, S, 0x00fe),
  50   MEPREL (R_MEP_PCREL12A2,1, 12, 1, 1, 1, S, 0x0ffe),
  51   MEPREL (R_MEP_PCREL17A2,2, 17, 0, 1, 1, S, 0x0000ffff),
  52   MEPREL (R_MEP_PCREL24A2,2, 24, 0, 1, 1, S, 0x07f0ffff),
  53   MEPREL (R_MEP_PCABS24A2,2, 24, 0, 1, 0, U, 0x07f0ffff),
  54   MEPREL (R_MEP_LOW16,    2, 16, 0, 0, 0, N, 0x0000ffff),
  55   MEPREL (R_MEP_HI16U,    2, 32, 0,16, 0, N, 0x0000ffff),
  56   MEPREL (R_MEP_HI16S,    2, 32, 0,16, 0, N, 0x0000ffff),
  57   MEPREL (R_MEP_GPREL,    2, 16, 0, 0, 0, S, 0x0000ffff),
  58   MEPREL (R_MEP_TPREL,    2, 16, 0, 0, 0, S, 0x0000ffff),
  59   MEPREL (R_MEP_TPREL7,   1,  7, 0, 0, 0, U, 0x007f),
  60   MEPREL (R_MEP_TPREL7A2, 1,  7, 1, 1, 0, U, 0x007e),
  61   MEPREL (R_MEP_TPREL7A4, 1,  7, 2, 2, 0, U, 0x007c),
  62   MEPREL (R_MEP_UIMM24,   2, 24, 0, 0, 0, U, 0x00ffffff),
  63   MEPREL (R_MEP_ADDR24A4, 2, 24, 0, 2, 0, U, 0x00fcffff),
  64   MEPREL (R_MEP_GNU_VTINHERIT,1,  0,16,32, 0, N, 0x0000),
  65   MEPREL (R_MEP_GNU_VTENTRY,1,  0,16,32, 0, N, 0x0000),
  66   /* MEPRELOC:END */
  67 };
  68
  69 #define VALID_MEP_RELOC(N) ((N) >= 0 \
  70   && (N) < ARRAY_SIZE (mep_elf_howto_table)
  71
  72 #undef N
  73 #undef S
  74 #undef U
  75 \f
  76
  77 #define BFD_RELOC_MEP_NONE BFD_RELOC_NONE
  78 #if defined (__STDC__) || defined (ALMOST_STDC) || defined (HAVE_STRINGIZE)
  79 #define MAP(n) case BFD_RELOC_MEP_##n: type = R_MEP_##n; break
  80 #else
  81 #define MAP(n) case BFD_RELOC_MEP_/**/n: type = R_MEP_/**/n; break
  82 #endif
  83
  84 static reloc_howto_type *
  85 mep_reloc_type_lookup
  86     (bfd * abfd ATTRIBUTE_UNUSED,
  87      bfd_reloc_code_real_type code)
  88 {
  89   unsigned int type = 0;
  90
  91   switch (code)
  92     {
  93     MAP(NONE);
  94     case BFD_RELOC_8:
  95       type = R_MEP_8;
  96       break;
  97     case BFD_RELOC_16:
  98       type = R_MEP_16;
  99       break;
 100     case BFD_RELOC_32:
 101       type = R_MEP_32;
 102       break;
 103     case BFD_RELOC_VTABLE_ENTRY:
 104       type = R_MEP_GNU_VTENTRY;
 105       break;
 106     case BFD_RELOC_VTABLE_INHERIT:
 107       type = R_MEP_GNU_VTINHERIT;
 108       break;
 109     case BFD_RELOC_RELC:
 110       type = R_RELC;
 111       break;
 112
 113     /* MEPRELOC:MAP */
 114     /* This section generated from bfd/mep-relocs.pl from include/elf/mep.h.  */
 115     MAP(8);
 116     MAP(16);
 117     MAP(32);
 118     MAP(PCREL8A2);
 119     MAP(PCREL12A2);
 120     MAP(PCREL17A2);
 121     MAP(PCREL24A2);
 122     MAP(PCABS24A2);
 123     MAP(LOW16);
 124     MAP(HI16U);
 125     MAP(HI16S);
 126     MAP(GPREL);
 127     MAP(TPREL);
 128     MAP(TPREL7);
 129     MAP(TPREL7A2);
 130     MAP(TPREL7A4);
 131     MAP(UIMM24);
 132     MAP(ADDR24A4);
 133     MAP(GNU_VTINHERIT);
 134     MAP(GNU_VTENTRY);
 135     /* MEPRELOC:END */
 136
 137     default:
 138       /* Pacify gcc -Wall.  */
 139       _bfd_error_handler (_("mep: no reloc for code %d"), code);
 140       return NULL;
 141     }
 142
 143   if (mep_elf_howto_table[type].type != type)
 144     {
 145       /* xgettext:c-format */
 146       _bfd_error_handler (_("MeP: howto %d has type %d"),
 147                           type, mep_elf_howto_table[type].type);
 148       abort ();
 149     }
 150
 151   return mep_elf_howto_table + type;
 152 }
 153
 154 #undef MAP
 155
 156 static reloc_howto_type *
 157 mep_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED, const char *r_name)
 158 {
 159   unsigned int i;
 160
 161   for (i = 0;
 162        i < sizeof (mep_elf_howto_table) / sizeof (mep_elf_howto_table[0]);
 163        i++)
 164     if (mep_elf_howto_table[i].name != NULL
 165         && strcasecmp (mep_elf_howto_table[i].name, r_name) == 0)
 166       return &mep_elf_howto_table[i];
 167
 168   return NULL;
 169 }
 170 \f
 171 /* Perform a single relocation.  */
 172
 173 static struct bfd_link_info *mep_info;
 174 static int warn_tp = 0, warn_sda = 0;
 175
 176 static bfd_vma
 177 mep_lookup_global
 178     (char *    name,
 179      bfd_vma   ofs,
 180      bfd_vma * cache,
 181      int *     warn)
 182 {
 183   struct bfd_link_hash_entry *h;
 184
 185   if (*cache || *warn)
 186     return *cache;
 187
 188   h = bfd_link_hash_lookup (mep_info->hash, name, FALSE, FALSE, TRUE);
 189   if (h == 0 || h->type != bfd_link_hash_defined)
 190     {
 191       *warn = ofs + 1;
 192       return 0;
 193     }
 194   *cache = (h->u.def.value
 195           + h->u.def.section->output_section->vma
 196           + h->u.def.section->output_offset);
 197   return *cache;
 198 }
 199
 200 static bfd_vma
 201 mep_tpoff_base (bfd_vma ofs)
 202 {
 203   static bfd_vma cache = 0;
 204   return mep_lookup_global ("__tpbase", ofs, &cache, &warn_tp);
 205 }
 206
 207 static bfd_vma
 208 mep_sdaoff_base (bfd_vma ofs)
 209 {
 210   static bfd_vma cache = 0;
 211   return mep_lookup_global ("__sdabase", ofs, &cache, &warn_sda);
 212 }
 213
 214 static bfd_reloc_status_type
 215 mep_final_link_relocate
 216     (reloc_howto_type *  howto,
 217      bfd *               input_bfd,
 218      asection *          input_section,
 219      bfd_byte *          contents,
 220      Elf_Internal_Rela * rel,
 221      bfd_vma             relocation)
 222 {
 223   unsigned long u;
 224   long s;
 225   unsigned char *byte;
 226   bfd_vma pc;
 227   bfd_reloc_status_type r = bfd_reloc_ok;
 228   int e2, e4;
 229
 230   if (bfd_big_endian (input_bfd))
 231     {
 232       e2 = 0;
 233       e4 = 0;
 234     }
 235   else
 236     {
 237       e2 = 1;
 238       e4 = 3;
 239     }
 240
 241   pc = (input_section->output_section->vma
 242         + input_section->output_offset
 243         + rel->r_offset);
 244
 245   s = relocation + rel->r_addend;
 246
 247   byte = (unsigned char *)contents + rel->r_offset;
 248
 249   if (howto->type == R_MEP_PCREL24A2
 250       && s == 0
 251       && pc >= 0x800000)
 252     {
 253       /* This is an unreachable branch to an undefined weak function.
 254          Silently ignore it, since the opcode can't do that but should
 255          never be executed anyway.  */
 256       return bfd_reloc_ok;
 257     }
 258
 259   if (howto->pc_relative)
 260     s -= pc;
 261
 262   u = (unsigned long) s;
 263
 264   switch (howto->type)
 265     {
 266     /* MEPRELOC:APPLY */
 267     /* This section generated from bfd/mep-relocs.pl from include/elf/mep.h.  */
 268     case R_MEP_8: /* 76543210 */
 269       if (u > 255) r = bfd_reloc_overflow;
 270       byte[0] = (u & 0xff);
 271       break;
 272     case R_MEP_16: /* fedcba9876543210 */
 273       if (u > 65535) r = bfd_reloc_overflow;
 274       byte[0^e2] = ((u >> 8) & 0xff);
 275       byte[1^e2] = (u & 0xff);
 276       break;
 277     case R_MEP_32: /* vutsrqponmlkjihgfedcba9876543210 */
 278       byte[0^e4] = ((u >> 24) & 0xff);
 279       byte[1^e4] = ((u >> 16) & 0xff);
 280       byte[2^e4] = ((u >> 8) & 0xff);
 281       byte[3^e4] = (u & 0xff);
 282       break;
 283     case R_MEP_PCREL8A2: /* --------7654321- */
 284       if (-128 > s || s > 127) r = bfd_reloc_overflow;
 285       byte[1^e2] = (byte[1^e2] & 0x01) | (s & 0xfe);
 286       break;
 287     case R_MEP_PCREL12A2: /* ----ba987654321- */
 288       if (-2048 > s || s > 2047) r = bfd_reloc_overflow;
 289       byte[0^e2] = (byte[0^e2] & 0xf0) | ((s >> 8) & 0x0f);
 290       byte[1^e2] = (byte[1^e2] & 0x01) | (s & 0xfe);
 291       break;
 292     case R_MEP_PCREL17A2: /* ----------------gfedcba987654321 */
 293       if (-65536 > s || s > 65535) r = bfd_reloc_overflow;
 294       byte[2^e2] = ((s >> 9) & 0xff);
 295       byte[3^e2] = ((s >> 1) & 0xff);
 296       break;
 297     case R_MEP_PCREL24A2: /* -----7654321----nmlkjihgfedcba98 */
 298       if (-8388608 > s || s > 8388607) r = bfd_reloc_overflow;
 299       byte[0^e2] = (byte[0^e2] & 0xf8) | ((s >> 5) & 0x07);
 300       byte[1^e2] = (byte[1^e2] & 0x0f) | ((s << 3) & 0xf0);
 301       byte[2^e2] = ((s >> 16) & 0xff);
 302       byte[3^e2] = ((s >> 8) & 0xff);
 303       break;
 304     case R_MEP_PCABS24A2: /* -----7654321----nmlkjihgfedcba98 */
 305       if (u > 16777215) r = bfd_reloc_overflow;
 306       byte[0^e2] = (byte[0^e2] & 0xf8) | ((u >> 5) & 0x07);
 307       byte[1^e2] = (byte[1^e2] & 0x0f) | ((u << 3) & 0xf0);
 308       byte[2^e2] = ((u >> 16) & 0xff);
 309       byte[3^e2] = ((u >> 8) & 0xff);
 310       break;
 311     case R_MEP_LOW16: /* ----------------fedcba9876543210 */
 312       byte[2^e2] = ((u >> 8) & 0xff);
 313       byte[3^e2] = (u & 0xff);
 314       break;
 315     case R_MEP_HI16U: /* ----------------vutsrqponmlkjihg */
 316       byte[2^e2] = ((u >> 24) & 0xff);
 317       byte[3^e2] = ((u >> 16) & 0xff);
 318       break;
 319     case R_MEP_HI16S: /* ----------------vutsrqponmlkjihg */
 320       if (s & 0x8000)
 321         s += 0x10000;
 322       byte[2^e2] = ((s >> 24) & 0xff);
 323       byte[3^e2] = ((s >> 16) & 0xff);
 324       break;
 325     case R_MEP_GPREL: /* ----------------fedcba9876543210 */
 326       s -= mep_sdaoff_base(rel->r_offset);
 327       if (-32768 > s || s > 32767) r = bfd_reloc_overflow;
 328       byte[2^e2] = ((s >> 8) & 0xff);
 329       byte[3^e2] = (s & 0xff);
 330       break;
 331     case R_MEP_TPREL: /* ----------------fedcba9876543210 */
 332       s -= mep_tpoff_base(rel->r_offset);
 333       if (-32768 > s || s > 32767) r = bfd_reloc_overflow;
 334       byte[2^e2] = ((s >> 8) & 0xff);
 335       byte[3^e2] = (s & 0xff);
 336       break;
 337     case R_MEP_TPREL7: /* ---------6543210 */
 338       u -= mep_tpoff_base(rel->r_offset);
 339       if (u > 127) r = bfd_reloc_overflow;
 340       byte[1^e2] = (byte[1^e2] & 0x80) | (u & 0x7f);
 341       break;
 342     case R_MEP_TPREL7A2: /* ---------654321- */
 343       u -= mep_tpoff_base(rel->r_offset);
 344       if (u > 127) r = bfd_reloc_overflow;
 345       byte[1^e2] = (byte[1^e2] & 0x81) | (u & 0x7e);
 346       break;
 347     case R_MEP_TPREL7A4: /* ---------65432-- */
 348       u -= mep_tpoff_base(rel->r_offset);
 349       if (u > 127) r = bfd_reloc_overflow;
 350       byte[1^e2] = (byte[1^e2] & 0x83) | (u & 0x7c);
 351       break;
 352     case R_MEP_UIMM24: /* --------76543210nmlkjihgfedcba98 */
 353       if (u > 16777215) r = bfd_reloc_overflow;
 354       byte[1^e2] = (u & 0xff);
 355       byte[2^e2] = ((u >> 16) & 0xff);
 356       byte[3^e2] = ((u >> 8) & 0xff);
 357       break;
 358     case R_MEP_ADDR24A4: /* --------765432--nmlkjihgfedcba98 */
 359       if (u > 16777215) r = bfd_reloc_overflow;
 360       byte[1^e2] = (byte[1^e2] & 0x03) | (u & 0xfc);
 361       byte[2^e2] = ((u >> 16) & 0xff);
 362       byte[3^e2] = ((u >> 8) & 0xff);
 363       break;
 364     case R_MEP_GNU_VTINHERIT: /* ---------------- */
 365       break;
 366     case R_MEP_GNU_VTENTRY: /* ---------------- */
 367       break;
 368     /* MEPRELOC:END */
 369     default:
 370       abort ();
 371     }
 372
 373   return r;
 374 }
 375 \f
 376 /* Set the howto pointer for a MEP ELF reloc.  */
 377
 378 static bfd_boolean
 379 mep_info_to_howto_rela (bfd *               abfd,
 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   if (r_type >= R_MEP_max)
 387     {
 388       /* xgettext:c-format */
 389       _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
 390                           abfd, r_type);
 391       bfd_set_error (bfd_error_bad_value);
 392       return FALSE;
 393     }
 394   cache_ptr->howto = & mep_elf_howto_table [r_type];
 395   return TRUE;
 396 }
 397 \f
 398 /* Relocate a MEP ELF section.
 399    There is some attempt to make this function usable for many architectures,
 400    both USE_REL and USE_RELA ['twould be nice if such a critter existed],
 401    if only to serve as a learning tool.
 402
 403    The RELOCATE_SECTION function is called by the new ELF backend linker
 404    to handle the relocations for a section.
 405
 406    The relocs are always passed as Rela structures; if the section
 407    actually uses Rel structures, the r_addend field will always be
 408    zero.
 409
 410    This function is responsible for adjusting the section contents as
 411    necessary, and (if using Rela relocs and generating a relocatable
 412    output file) adjusting the reloc addend as necessary.
 413
 414    This function does not have to worry about setting the reloc
 415    address or the reloc symbol index.
 416
 417    LOCAL_SYMS is a pointer to the swapped in local symbols.
 418
 419    LOCAL_SECTIONS is an array giving the section in the input file
 420    corresponding to the st_shndx field of each local symbol.
 421
 422    The global hash table entry for the global symbols can be found
 423    via elf_sym_hashes (input_bfd).
 424
 425    When generating relocatable output, this function must handle
 426    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
 427    going to be the section symbol corresponding to the output
 428    section, which means that the addend must be adjusted
 429    accordingly.  */
 430
 431 static bfd_boolean
 432 mep_elf_relocate_section
 433     (bfd *                   output_bfd ATTRIBUTE_UNUSED,
 434      struct bfd_link_info *  info,
 435      bfd *                   input_bfd,
 436      asection *              input_section,
 437      bfd_byte *              contents,
 438      Elf_Internal_Rela *     relocs,
 439      Elf_Internal_Sym *      local_syms,
 440      asection **             local_sections)
 441 {
 442   Elf_Internal_Shdr *           symtab_hdr;
 443   struct elf_link_hash_entry ** sym_hashes;
 444   Elf_Internal_Rela *           rel;
 445   Elf_Internal_Rela *           relend;
 446
 447   symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
 448   sym_hashes = elf_sym_hashes (input_bfd);
 449   relend     = relocs + input_section->reloc_count;
 450
 451   mep_info = info;
 452
 453   for (rel = relocs; rel < relend; rel ++)
 454     {
 455       reloc_howto_type *           howto;
 456       unsigned long                r_symndx;
 457       Elf_Internal_Sym *           sym;
 458       asection *                   sec;
 459       struct elf_link_hash_entry * h;
 460       bfd_vma                      relocation;
 461       bfd_reloc_status_type        r;
 462       const char *                 name = NULL;
 463       int                          r_type;
 464
 465       r_type = ELF32_R_TYPE (rel->r_info);
 466       r_symndx = ELF32_R_SYM (rel->r_info);
 467       howto  = mep_elf_howto_table + ELF32_R_TYPE (rel->r_info);
 468       h      = NULL;
 469       sym    = NULL;
 470       sec    = NULL;
 471
 472       if (r_symndx < symtab_hdr->sh_info)
 473         {
 474           sym = local_syms + r_symndx;
 475           sec = local_sections [r_symndx];
 476           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
 477
 478           name = bfd_elf_string_from_elf_section
 479             (input_bfd, symtab_hdr->sh_link, sym->st_name);
 480           name = (name == NULL) ? bfd_section_name (input_bfd, sec) : name;
 481         }
 482       else
 483         {
 484           bfd_boolean warned, unresolved_reloc, ignored;
 485
 486           RELOC_FOR_GLOBAL_SYMBOL(info, input_bfd, input_section, rel,
 487                                   r_symndx, symtab_hdr, sym_hashes,
 488                                   h, sec, relocation,
 489                                   unresolved_reloc, warned, ignored);
 490
 491           name = h->root.root.string;
 492         }
 493
 494       if (sec != NULL && discarded_section (sec))
 495         RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
 496                                          rel, 1, relend, howto, 0, contents);
 497
 498       if (bfd_link_relocatable (info))
 499         continue;
 500
 501       if (r_type == R_RELC)
 502         r = bfd_elf_perform_complex_relocation (input_bfd, input_section,
 503                                                 contents, rel, relocation);
 504       else
 505         r = mep_final_link_relocate (howto, input_bfd, input_section,
 506                                      contents, rel, relocation);
 507
 508       if (r != bfd_reloc_ok)
 509         {
 510           const char * msg = (const char *) NULL;
 511
 512           switch (r)
 513             {
 514             case bfd_reloc_overflow:
 515               (*info->callbacks->reloc_overflow)
 516                 (info, (h ? &h->root : NULL), name, howto->name, (bfd_vma) 0,
 517                  input_bfd, input_section, rel->r_offset);
 518               break;
 519
 520             case bfd_reloc_undefined:
 521               (*info->callbacks->undefined_symbol)
 522                 (info, name, input_bfd, input_section, rel->r_offset, TRUE);
 523               break;
 524
 525             case bfd_reloc_outofrange:
 526               msg = _("internal error: out of range error");
 527               break;
 528
 529             case bfd_reloc_notsupported:
 530               msg = _("internal error: unsupported relocation error");
 531               break;
 532
 533             case bfd_reloc_dangerous:
 534               msg = _("internal error: dangerous relocation");
 535               break;
 536
 537             default:
 538               msg = _("internal error: unknown error");
 539               break;
 540             }
 541
 542           if (msg)
 543             (*info->callbacks->warning) (info, msg, name, input_bfd,
 544                                          input_section, rel->r_offset);
 545         }
 546     }
 547
 548   if (warn_tp)
 549     info->callbacks->undefined_symbol
 550       (info, "__tpbase", input_bfd, input_section, warn_tp-1, TRUE);
 551   if (warn_sda)
 552     info->callbacks->undefined_symbol
 553       (info, "__sdabase", input_bfd, input_section, warn_sda-1, TRUE);
 554   if (warn_sda || warn_tp)
 555     return FALSE;
 556
 557   return TRUE;
 558 }
 559 \f
 560 /* Function to set the ELF flag bits.  */
 561
 562 static bfd_boolean
 563 mep_elf_set_private_flags (bfd *    abfd,
 564                            flagword flags)
 565 {
 566   elf_elfheader (abfd)->e_flags = flags;
 567   elf_flags_init (abfd) = TRUE;
 568   return TRUE;
 569 }
 570
 571 /* Merge backend specific data from an object file to the output
 572    object file when linking.  */
 573
 574 static bfd_boolean
 575 mep_elf_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
 576 {
 577   bfd *obfd = info->output_bfd;
 578   static bfd *last_ibfd = 0;
 579   flagword old_flags, new_flags;
 580   flagword old_partial, new_partial;
 581
 582   /* Check if we have the same endianness.  */
 583   if (!_bfd_generic_verify_endian_match (ibfd, info))
 584     return FALSE;
 585
 586   new_flags = elf_elfheader (ibfd)->e_flags;
 587   old_flags = elf_elfheader (obfd)->e_flags;
 588
 589 #ifdef DEBUG
 590   _bfd_error_handler ("%pB: old_flags = 0x%.8x, new_flags = 0x%.8x, init = %s",
 591                       ibfd, old_flags, new_flags, elf_flags_init (obfd) ? "yes" : "no");
 592 #endif
 593
 594     /* First call, no flags set.  */
 595     if (!elf_flags_init (obfd))
 596     {
 597       elf_flags_init (obfd) = TRUE;
 598       old_flags = new_flags;
 599     }
 600   else if ((new_flags | old_flags) & EF_MEP_LIBRARY)
 601     {
 602       /* Non-library flags trump library flags.  The choice doesn't really
 603          matter if both OLD_FLAGS and NEW_FLAGS have EF_MEP_LIBRARY set.  */
 604       if (old_flags & EF_MEP_LIBRARY)
 605         old_flags = new_flags;
 606     }
 607   else
 608     {
 609       /* Make sure they're for the same mach.  Allow upgrade from the "mep"
 610          mach.  */
 611       new_partial = (new_flags & EF_MEP_CPU_MASK);
 612       old_partial = (old_flags & EF_MEP_CPU_MASK);
 613       if (new_partial == old_partial)
 614         ;
 615       else if (new_partial == EF_MEP_CPU_MEP)
 616         ;
 617       else if (old_partial == EF_MEP_CPU_MEP)
 618         old_flags = (old_flags & ~EF_MEP_CPU_MASK) | new_partial;
 619       else
 620         {
 621           /* xgettext:c-format */
 622           _bfd_error_handler (_("%pB and %pB are for different cores"),
 623                               last_ibfd, ibfd);
 624           bfd_set_error (bfd_error_invalid_target);
 625           return FALSE;
 626         }
 627
 628       /* Make sure they're for the same me_module.  Allow basic config to
 629          mix with any other.  */
 630       new_partial = (new_flags & EF_MEP_INDEX_MASK);
 631       old_partial = (old_flags & EF_MEP_INDEX_MASK);
 632       if (new_partial == old_partial)
 633         ;
 634       else if (new_partial == 0)
 635         ;
 636       else if (old_partial == 0)
 637         old_flags = (old_flags & ~EF_MEP_INDEX_MASK) | new_partial;
 638       else
 639         {
 640           /* xgettext:c-format */
 641           _bfd_error_handler (_("%pB and %pB are for different configurations"),
 642                               last_ibfd, ibfd);
 643           bfd_set_error (bfd_error_invalid_target);
 644           return FALSE;
 645         }
 646     }
 647
 648   elf_elfheader (obfd)->e_flags = old_flags;
 649   last_ibfd = ibfd;
 650   return TRUE;
 651 }
 652
 653 /* This will be edited by the MeP configration tool.  */
 654 static const char * config_names[] =
 655 {
 656   "basic"
 657   /* start-mepcfgtool */
 658   ,"default"
 659   /* end-mepcfgtool */
 660 };
 661
 662 static const char * core_names[] =
 663 {
 664   "MeP", "MeP-c2", "MeP-c3", "MeP-h1"
 665 };
 666
 667 static bfd_boolean
 668 mep_elf_print_private_bfd_data (bfd * abfd, void * ptr)
 669 {
 670   FILE *   file = (FILE *) ptr;
 671   flagword flags, partial_flags;
 672
 673   BFD_ASSERT (abfd != NULL && ptr != NULL);
 674
 675   /* Print normal ELF private data.  */
 676   _bfd_elf_print_private_bfd_data (abfd, ptr);
 677
 678   flags = elf_elfheader (abfd)->e_flags;
 679   fprintf (file, _("private flags = 0x%lx"), (unsigned long) flags);
 680
 681   partial_flags = (flags & EF_MEP_CPU_MASK) >> 24;
 682   if (partial_flags < ARRAY_SIZE (core_names))
 683     fprintf (file, "  core: %s", core_names[(long)partial_flags]);
 684
 685   partial_flags = flags & EF_MEP_INDEX_MASK;
 686   if (partial_flags < ARRAY_SIZE (config_names))
 687     fprintf (file, "  me_module: %s", config_names[(long)partial_flags]);
 688
 689   fputc ('\n', file);
 690
 691   return TRUE;
 692 }
 693
 694 /* Return the machine subcode from the ELF e_flags header.  */
 695
 696 static int
 697 elf32_mep_machine (bfd * abfd)
 698 {
 699   switch (elf_elfheader (abfd)->e_flags & EF_MEP_CPU_MASK)
 700     {
 701     default: break;
 702     case EF_MEP_CPU_C2: return bfd_mach_mep;
 703     case EF_MEP_CPU_C3: return bfd_mach_mep;
 704     case EF_MEP_CPU_C4: return bfd_mach_mep;
 705     case EF_MEP_CPU_C5: return bfd_mach_mep_c5;
 706     case EF_MEP_CPU_H1: return bfd_mach_mep_h1;
 707     }
 708
 709   return bfd_mach_mep;
 710 }
 711
 712 static bfd_boolean
 713 mep_elf_object_p (bfd * abfd)
 714 {
 715   bfd_default_set_arch_mach (abfd, bfd_arch_mep, elf32_mep_machine (abfd));
 716   return TRUE;
 717 }
 718
 719 static bfd_boolean
 720 mep_elf_section_flags (flagword * flags, const Elf_Internal_Shdr * hdr)
 721 {
 722   if (hdr->sh_flags & SHF_MEP_VLIW)
 723     * flags |= SEC_MEP_VLIW;
 724   return TRUE;
 725 }
 726
 727 static bfd_boolean
 728 mep_elf_fake_sections (bfd *               abfd ATTRIBUTE_UNUSED,
 729                        Elf_Internal_Shdr * hdr,
 730                        asection *          sec)
 731 {
 732   if (sec->flags & SEC_MEP_VLIW)
 733     hdr->sh_flags |= SHF_MEP_VLIW;
 734   return TRUE;
 735 }
 736
 737 \f
 738 #define ELF_ARCH                bfd_arch_mep
 739 #define ELF_MACHINE_CODE        EM_CYGNUS_MEP
 740 #define ELF_MAXPAGESIZE         0x1000
 741
 742 #define TARGET_BIG_SYM          mep_elf32_vec
 743 #define TARGET_BIG_NAME         "elf32-mep"
 744
 745 #define TARGET_LITTLE_SYM       mep_elf32_le_vec
 746 #define TARGET_LITTLE_NAME      "elf32-mep-little"
 747
 748 #define elf_info_to_howto_rel                   NULL
 749 #define elf_info_to_howto                       mep_info_to_howto_rela
 750 #define elf_backend_relocate_section            mep_elf_relocate_section
 751 #define elf_backend_object_p                    mep_elf_object_p
 752 #define elf_backend_section_flags               mep_elf_section_flags
 753 #define elf_backend_fake_sections               mep_elf_fake_sections
 754
 755 #define bfd_elf32_bfd_reloc_type_lookup         mep_reloc_type_lookup
 756 #define bfd_elf32_bfd_reloc_name_lookup         mep_reloc_name_lookup
 757 #define bfd_elf32_bfd_set_private_flags         mep_elf_set_private_flags
 758 #define bfd_elf32_bfd_merge_private_bfd_data    mep_elf_merge_private_bfd_data
 759 #define bfd_elf32_bfd_print_private_bfd_data    mep_elf_print_private_bfd_data
 760
 761 #define elf_backend_rela_normal                 1
 762
 763 #include "elf32-target.h"