bfd/elf32-mt.c

   1 /* Morpho Technologies MT specific support for 32-bit ELF
   2    Copyright 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2011, 2012
   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., 59 Temple Place - Suite 330, Boston,
  20    MA 02111-1307, USA.  */
  21
  22 #include "sysdep.h"
  23 #include "bfd.h"
  24 #include "libbfd.h"
  25 #include "elf-bfd.h"
  26 #include "elf/mt.h"
  27
  28 /* Prototypes.  */
  29 static reloc_howto_type * mt_reloc_type_lookup
  30   (bfd *, bfd_reloc_code_real_type);
  31
  32 static void mt_info_to_howto_rela
  33   (bfd *, arelent *, Elf_Internal_Rela *);
  34
  35 static bfd_reloc_status_type mt_elf_relocate_hi16
  36   (bfd *, Elf_Internal_Rela *, bfd_byte *, bfd_vma);
  37
  38 static bfd_reloc_status_type mt_final_link_relocate
  39   (reloc_howto_type *, bfd *, asection *, bfd_byte *,
  40    Elf_Internal_Rela *, bfd_vma);
  41
  42 static bfd_boolean mt_elf_relocate_section
  43   (bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
  44    Elf_Internal_Rela *, Elf_Internal_Sym *, asection **);
  45
  46 /* Relocation tables.  */
  47 static reloc_howto_type mt_elf_howto_table [] =
  48 {
  49   /* This reloc does nothing.  */
  50   HOWTO (R_MT_NONE,           /* type */
  51           0,                      /* rightshift */
  52           2,                      /* size (0 = byte, 1 = short, 2 = long) */
  53           32,                     /* bitsize */
  54           FALSE,                  /* pc_relative */
  55           0,                      /* bitpos */
  56           complain_overflow_dont, /* complain_on_overflow */
  57           bfd_elf_generic_reloc,  /* special_function */
  58           "R_MT_NONE",          /* name */
  59           FALSE,                  /* partial_inplace */
  60           0 ,                     /* src_mask */
  61           0,                      /* dst_mask */
  62           FALSE),                 /* pcrel_offset */
  63
  64   /* A 16 bit absolute relocation.  */
  65   HOWTO (R_MT_16,             /* type */
  66           0,                      /* rightshift */
  67           2,                      /* size (0 = byte, 1 = short, 2 = long) */
  68           16,                     /* bitsize */
  69           FALSE,                  /* pc_relative */
  70           0,                      /* bitpos */
  71           complain_overflow_dont, /* complain_on_overflow */
  72           bfd_elf_generic_reloc,  /* special_function */
  73           "R_MT_16",            /* name */
  74           FALSE,                  /* partial_inplace */
  75           0 ,                     /* src_mask */
  76           0xffff,                 /* dst_mask */
  77           FALSE),                 /* pcrel_offset */
  78
  79   /* A 32 bit absolute relocation.  */
  80   HOWTO (R_MT_32,             /* type */
  81           0,                      /* rightshift */
  82           2,                      /* size (0 = byte, 1 = short, 2 = long) */
  83           32,                     /* bitsize */
  84           FALSE,                  /* pc_relative */
  85           0,                      /* bitpos */
  86           complain_overflow_dont, /* complain_on_overflow */
  87           bfd_elf_generic_reloc,  /* special_function */
  88           "R_MT_32",            /* name */
  89           FALSE,                  /* partial_inplace */
  90           0 ,                     /* src_mask */
  91           0xffffffff,             /* dst_mask */
  92           FALSE),                 /* pcrel_offset */
  93
  94   /* A 32 bit pc-relative relocation.  */
  95   HOWTO (R_MT_32_PCREL,       /* type */
  96           0,                      /* rightshift */
  97           2,                      /* size (0 = byte, 1 = short, 2 = long) */
  98           32,                     /* bitsize */
  99           TRUE,                   /* pc_relative */
 100           0,                      /* bitpos */
 101           complain_overflow_dont, /* complain_on_overflow */
 102           bfd_elf_generic_reloc,  /* special_function */
 103           "R_MT_32_PCREL",    /* name */
 104           FALSE,                  /* partial_inplace */
 105           0 ,                     /* src_mask */
 106           0xffffffff,             /* dst_mask */
 107           TRUE),                  /* pcrel_offset */
 108
 109   /* A 16 bit pc-relative relocation.  */
 110   HOWTO (R_MT_PC16,           /* type */
 111           0,                      /* rightshift */
 112           2,                      /* size (0 = byte, 1 = short, 2 = long) */
 113           16,                     /* bitsize */
 114           TRUE,                   /* pc_relative */
 115           0,                      /* bitpos */
 116           complain_overflow_signed, /* complain_on_overflow */
 117           bfd_elf_generic_reloc,  /* special_function */
 118           "R_MT_PC16",          /* name */
 119           FALSE,                  /* partial_inplace */
 120           0,                      /* src_mask */
 121           0xffff,                 /* dst_mask */
 122           TRUE),                  /* pcrel_offset */
 123
 124   /* high 16 bits of symbol value.  */
 125   HOWTO (R_MT_HI16,          /* type */
 126          0,                     /* rightshift */
 127          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 128          16,                    /* bitsize */
 129          FALSE,                 /* pc_relative */
 130          0,                     /* bitpos */
 131          complain_overflow_dont, /* complain_on_overflow */
 132          bfd_elf_generic_reloc, /* special_function */
 133          "R_MT_HI16",        /* name */
 134          FALSE,                  /* partial_inplace */
 135          0xffff0000,            /* src_mask */
 136          0xffff0000,            /* dst_mask */
 137          FALSE),                /* pcrel_offset */
 138
 139   /* Low 16 bits of symbol value.  */
 140   HOWTO (R_MT_LO16,          /* type */
 141          0,                     /* rightshift */
 142          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 143          16,                    /* bitsize */
 144          FALSE,                 /* pc_relative */
 145          0,                     /* bitpos */
 146          complain_overflow_dont, /* complain_on_overflow */
 147          bfd_elf_generic_reloc, /* special_function */
 148          "R_MT_LO16",        /* name */
 149          FALSE,                  /* partial_inplace */
 150          0xffff,                /* src_mask */
 151          0xffff,                /* dst_mask */
 152          FALSE),                /* pcrel_offset */
 153 };
 154
 155 /* Map BFD reloc types to MT ELF reloc types.  */
 156
 157 static reloc_howto_type *
 158 mt_reloc_type_lookup
 159     (bfd *                    abfd ATTRIBUTE_UNUSED,
 160      bfd_reloc_code_real_type code)
 161 {
 162   /* Note that the mt_elf_howto_table is indxed by the R_
 163      constants.  Thus, the order that the howto records appear in the
 164      table *must* match the order of the relocation types defined in
 165      include/elf/mt.h.  */
 166
 167   switch (code)
 168     {
 169     case BFD_RELOC_NONE:
 170       return &mt_elf_howto_table[ (int) R_MT_NONE];
 171     case BFD_RELOC_16:
 172       return &mt_elf_howto_table[ (int) R_MT_16];
 173     case BFD_RELOC_32:
 174       return &mt_elf_howto_table[ (int) R_MT_32];
 175     case BFD_RELOC_32_PCREL:
 176       return &mt_elf_howto_table[ (int) R_MT_32_PCREL];
 177     case BFD_RELOC_16_PCREL:
 178       return &mt_elf_howto_table[ (int) R_MT_PC16];
 179     case BFD_RELOC_HI16:
 180       return &mt_elf_howto_table[ (int) R_MT_HI16];
 181     case BFD_RELOC_LO16:
 182       return &mt_elf_howto_table[ (int) R_MT_LO16];
 183
 184     default:
 185       /* Pacify gcc -Wall.  */
 186       return NULL;
 187     }
 188   return NULL;
 189 }
 190
 191 static reloc_howto_type *
 192 mt_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
 193                       const char *r_name)
 194 {
 195   unsigned int i;
 196
 197   for (i = 0;
 198        i < sizeof (mt_elf_howto_table) / sizeof (mt_elf_howto_table[0]);
 199        i++)
 200     if (mt_elf_howto_table[i].name != NULL
 201         && strcasecmp (mt_elf_howto_table[i].name, r_name) == 0)
 202       return &mt_elf_howto_table[i];
 203
 204   return NULL;
 205 }
 206
 207 bfd_reloc_status_type
 208 mt_elf_relocate_hi16
 209     (bfd *               input_bfd,
 210      Elf_Internal_Rela * relhi,
 211      bfd_byte *          contents,
 212      bfd_vma             value)
 213 {
 214   bfd_vma insn;
 215
 216   insn = bfd_get_32 (input_bfd, contents + relhi->r_offset);
 217
 218   value += relhi->r_addend;
 219   value >>= 16;
 220   insn = ((insn & ~0xFFFF) | value);
 221
 222   bfd_put_32 (input_bfd, insn, contents + relhi->r_offset);
 223   return bfd_reloc_ok;
 224 }
 225 \f
 226 /* XXX: The following code is the result of a cut&paste.  This unfortunate
 227    practice is very widespread in the various target back-end files.  */
 228
 229 /* Set the howto pointer for a MT ELF reloc.  */
 230
 231 static void
 232 mt_info_to_howto_rela
 233     (bfd *               abfd ATTRIBUTE_UNUSED,
 234      arelent *           cache_ptr,
 235      Elf_Internal_Rela * dst)
 236 {
 237   unsigned int r_type;
 238
 239   r_type = ELF32_R_TYPE (dst->r_info);
 240   cache_ptr->howto = & mt_elf_howto_table [r_type];
 241 }
 242
 243 /* Perform a single relocation.  By default we use the standard BFD
 244    routines.  */
 245
 246 static bfd_reloc_status_type
 247 mt_final_link_relocate
 248     (reloc_howto_type *  howto,
 249      bfd *               input_bfd,
 250      asection *          input_section,
 251      bfd_byte *          contents,
 252      Elf_Internal_Rela * rel,
 253      bfd_vma             relocation)
 254 {
 255   return _bfd_final_link_relocate (howto, input_bfd, input_section,
 256                                    contents, rel->r_offset,
 257                                    relocation, rel->r_addend);
 258 }
 259
 260 /* Relocate a MT ELF section.
 261    There is some attempt to make this function usable for many architectures,
 262    both USE_REL and USE_RELA ['twould be nice if such a critter existed],
 263    if only to serve as a learning tool.
 264
 265    The RELOCATE_SECTION function is called by the new ELF backend linker
 266    to handle the relocations for a section.
 267
 268    The relocs are always passed as Rela structures; if the section
 269    actually uses Rel structures, the r_addend field will always be
 270    zero.
 271
 272    This function is responsible for adjusting the section contents as
 273    necessary, and (if using Rela relocs and generating a relocatable
 274    output file) adjusting the reloc addend as necessary.
 275
 276    This function does not have to worry about setting the reloc
 277    address or the reloc symbol index.
 278
 279    LOCAL_SYMS is a pointer to the swapped in local symbols.
 280
 281    LOCAL_SECTIONS is an array giving the section in the input file
 282    corresponding to the st_shndx field of each local symbol.
 283
 284    The global hash table entry for the global symbols can be found
 285    via elf_sym_hashes (input_bfd).
 286
 287    When generating relocatable output, this function must handle
 288    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
 289    going to be the section symbol corresponding to the output
 290    section, which means that the addend must be adjusted
 291    accordingly.  */
 292
 293 static bfd_boolean
 294 mt_elf_relocate_section
 295     (bfd *                   output_bfd ATTRIBUTE_UNUSED,
 296      struct bfd_link_info *  info,
 297      bfd *                   input_bfd,
 298      asection *              input_section,
 299      bfd_byte *              contents,
 300      Elf_Internal_Rela *     relocs,
 301      Elf_Internal_Sym *      local_syms,
 302      asection **             local_sections)
 303 {
 304   Elf_Internal_Shdr *           symtab_hdr;
 305   struct elf_link_hash_entry ** sym_hashes;
 306   Elf_Internal_Rela *           rel;
 307   Elf_Internal_Rela *           relend;
 308
 309   symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
 310   sym_hashes = elf_sym_hashes (input_bfd);
 311   relend     = relocs + input_section->reloc_count;
 312
 313   for (rel = relocs; rel < relend; rel ++)
 314     {
 315       reloc_howto_type *           howto;
 316       unsigned long                r_symndx;
 317       Elf_Internal_Sym *           sym;
 318       asection *                   sec;
 319       struct elf_link_hash_entry * h;
 320       bfd_vma                      relocation;
 321       bfd_reloc_status_type        r;
 322       const char *                 name = NULL;
 323       int                          r_type;
 324
 325       r_type = ELF32_R_TYPE (rel->r_info);
 326
 327       r_symndx = ELF32_R_SYM (rel->r_info);
 328
 329       howto  = mt_elf_howto_table + ELF32_R_TYPE (rel->r_info);
 330       h      = NULL;
 331       sym    = NULL;
 332       sec    = NULL;
 333
 334       if (r_symndx < symtab_hdr->sh_info)
 335         {
 336           sym = local_syms + r_symndx;
 337           sec = local_sections [r_symndx];
 338           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
 339
 340           name = bfd_elf_string_from_elf_section
 341             (input_bfd, symtab_hdr->sh_link, sym->st_name);
 342           name = (name == NULL) ? bfd_section_name (input_bfd, sec) : name;
 343         }
 344       else
 345         {
 346           bfd_boolean unresolved_reloc;
 347           bfd_boolean warned;
 348
 349           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
 350                                    r_symndx, symtab_hdr, sym_hashes,
 351                                    h, sec, relocation,
 352                                    unresolved_reloc, warned);
 353
 354           name = h->root.root.string;
 355         }
 356
 357       if (sec != NULL && discarded_section (sec))
 358         RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
 359                                          rel, 1, relend, howto, 0, contents);
 360
 361       if (info->relocatable)
 362         continue;
 363
 364       /* Finally, the sole MT-specific part.  */
 365       switch (r_type)
 366         {
 367         case R_MT_HI16:
 368           r = mt_elf_relocate_hi16 (input_bfd, rel, contents, relocation);
 369           break;
 370         default:
 371           r = mt_final_link_relocate (howto, input_bfd, input_section,
 372                                           contents, rel, relocation);
 373           break;
 374         }
 375
 376
 377       if (r != bfd_reloc_ok)
 378         {
 379           const char * msg = (const char *) NULL;
 380
 381           switch (r)
 382             {
 383             case bfd_reloc_overflow:
 384               r = info->callbacks->reloc_overflow
 385                 (info, (h ? &h->root : NULL), name, howto->name, (bfd_vma) 0,
 386                  input_bfd, input_section, rel->r_offset);
 387               break;
 388
 389             case bfd_reloc_undefined:
 390               r = info->callbacks->undefined_symbol
 391                 (info, name, input_bfd, input_section, rel->r_offset, TRUE);
 392               break;
 393
 394             case bfd_reloc_outofrange:
 395               msg = _("internal error: out of range error");
 396               break;
 397
 398             case bfd_reloc_dangerous:
 399               msg = _("internal error: dangerous relocation");
 400               break;
 401
 402             default:
 403               msg = _("internal error: unknown error");
 404               break;
 405             }
 406
 407           if (msg)
 408             r = info->callbacks->warning
 409               (info, msg, name, input_bfd, input_section, rel->r_offset);
 410
 411           if (! r)
 412             return FALSE;
 413         }
 414     }
 415
 416   return TRUE;
 417 }
 418
 419 /* Look through the relocs for a section during the first phase.
 420    Since we don't do .gots or .plts, we just need to consider the
 421    virtual table relocs for gc.  */
 422
 423 static bfd_boolean
 424 mt_elf_check_relocs
 425     (bfd *                     abfd,
 426      struct bfd_link_info *    info,
 427      asection *                sec,
 428      const Elf_Internal_Rela * relocs)
 429 {
 430   Elf_Internal_Shdr *           symtab_hdr;
 431   struct elf_link_hash_entry ** sym_hashes;
 432   const Elf_Internal_Rela *     rel;
 433   const Elf_Internal_Rela *     rel_end;
 434
 435   if (info->relocatable)
 436     return TRUE;
 437
 438   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
 439   sym_hashes = elf_sym_hashes (abfd);
 440
 441   rel_end = relocs + sec->reloc_count;
 442   for (rel = relocs; rel < rel_end; rel++)
 443     {
 444       struct elf_link_hash_entry *h;
 445       unsigned long r_symndx;
 446
 447       r_symndx = ELF32_R_SYM (rel->r_info);
 448       if (r_symndx < symtab_hdr->sh_info)
 449         h = NULL;
 450       else
 451         {
 452           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
 453           while (h->root.type == bfd_link_hash_indirect
 454                  || h->root.type == bfd_link_hash_warning)
 455             h = (struct elf_link_hash_entry *) h->root.u.i.link;
 456
 457           /* PR15323, ref flags aren't set for references in the same
 458              object.  */
 459           h->root.non_ir_ref = 1;
 460         }
 461     }
 462
 463   return TRUE;
 464 }
 465
 466 /* Return the MACH for an e_flags value.  */
 467
 468 static int
 469 elf32_mt_machine (bfd *abfd)
 470 {
 471   switch (elf_elfheader (abfd)->e_flags & EF_MT_CPU_MASK)
 472     {
 473     case EF_MT_CPU_MRISC:       return bfd_mach_ms1;
 474     case EF_MT_CPU_MRISC2:      return bfd_mach_mrisc2;
 475     case EF_MT_CPU_MS2:         return bfd_mach_ms2;
 476     }
 477
 478   return bfd_mach_ms1;
 479 }
 480
 481 static bfd_boolean
 482 mt_elf_object_p (bfd * abfd)
 483 {
 484   bfd_default_set_arch_mach (abfd, bfd_arch_mt, elf32_mt_machine (abfd));
 485
 486   return TRUE;
 487 }
 488
 489 /* Function to set the ELF flag bits.  */
 490
 491 static bfd_boolean
 492 mt_elf_set_private_flags (bfd *    abfd,
 493                            flagword flags)
 494 {
 495   elf_elfheader (abfd)->e_flags = flags;
 496   elf_flags_init (abfd) = TRUE;
 497   return TRUE;
 498 }
 499
 500 static bfd_boolean
 501 mt_elf_copy_private_bfd_data (bfd * ibfd, bfd * obfd)
 502 {
 503   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
 504       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
 505     return TRUE;
 506
 507   BFD_ASSERT (!elf_flags_init (obfd)
 508               || elf_elfheader (obfd)->e_flags == elf_elfheader (ibfd)->e_flags);
 509
 510   elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
 511   elf_flags_init (obfd) = TRUE;
 512
 513   /* Copy object attributes.  */
 514   _bfd_elf_copy_obj_attributes (ibfd, obfd);
 515
 516   return TRUE;
 517 }
 518
 519 /* Merge backend specific data from an object file to the output
 520    object file when linking.  */
 521
 522 static bfd_boolean
 523 mt_elf_merge_private_bfd_data (bfd * ibfd, bfd * obfd)
 524 {
 525   flagword     old_flags, new_flags;
 526   bfd_boolean  ok = TRUE;
 527
 528   /* Check if we have the same endianness.  */
 529   if (_bfd_generic_verify_endian_match (ibfd, obfd) == FALSE)
 530     return FALSE;
 531
 532   /* If they're not both mt, then merging is meaningless, so just
 533      don't do it.  */
 534   if (strcmp (ibfd->arch_info->arch_name, "mt") != 0)
 535     return TRUE;
 536   if (strcmp (obfd->arch_info->arch_name, "mt") != 0)
 537     return TRUE;
 538
 539   new_flags = elf_elfheader (ibfd)->e_flags;
 540   old_flags = elf_elfheader (obfd)->e_flags;
 541
 542 #ifdef DEBUG
 543   _bfd_error_handler ("%B: old_flags = 0x%.8lx, new_flags = 0x%.8lx, init = %s",
 544                       ibfd, old_flags, new_flags, elf_flags_init (obfd) ? "yes" : "no");
 545 #endif
 546
 547   if (!elf_flags_init (obfd))
 548     {
 549       old_flags = new_flags;
 550       elf_flags_init (obfd) = TRUE;
 551     }
 552   else if ((new_flags & EF_MT_CPU_MASK) != (old_flags & EF_MT_CPU_MASK))
 553     {
 554       /* CPU has changed.  This is invalid, because MRISC, MRISC2 and
 555          MS2 are not subsets of each other.   */
 556       ok = FALSE;
 557     }
 558
 559   if (ok)
 560     {
 561       obfd->arch_info = ibfd->arch_info;
 562       elf_elfheader (obfd)->e_flags = old_flags;
 563     }
 564
 565   return ok;
 566 }
 567
 568 static bfd_boolean
 569 mt_elf_print_private_bfd_data (bfd * abfd, void * ptr)
 570 {
 571   FILE *   file = (FILE *) ptr;
 572   flagword flags;
 573
 574   BFD_ASSERT (abfd != NULL && ptr != NULL);
 575
 576   /* Print normal ELF private data.  */
 577   _bfd_elf_print_private_bfd_data (abfd, ptr);
 578
 579   flags = elf_elfheader (abfd)->e_flags;
 580   fprintf (file, _("private flags = 0x%lx:"), (unsigned long) flags);
 581
 582   switch (flags & EF_MT_CPU_MASK)
 583     {
 584     default:
 585     case EF_MT_CPU_MRISC:   fprintf (file, " ms1-16-002");      break;
 586     case EF_MT_CPU_MRISC2:  fprintf (file, " ms1-16-003");      break;
 587     case EF_MT_CPU_MS2:     fprintf (file, " ms2");     break;
 588     }
 589
 590   fputc ('\n', file);
 591
 592   return TRUE;
 593 }
 594
 595 \f
 596 #define TARGET_BIG_SYM   bfd_elf32_mt_vec
 597 #define TARGET_BIG_NAME  "elf32-mt"
 598
 599 #define ELF_ARCH         bfd_arch_mt
 600 #define ELF_MACHINE_CODE EM_MT
 601 #define ELF_MAXPAGESIZE  1 /* No pages on the MT.  */
 602
 603 #define elf_info_to_howto_rel                   NULL
 604 #define elf_info_to_howto                       mt_info_to_howto_rela
 605
 606 #define elf_backend_relocate_section            mt_elf_relocate_section
 607
 608 #define bfd_elf32_bfd_reloc_type_lookup         mt_reloc_type_lookup
 609 #define bfd_elf32_bfd_reloc_name_lookup   mt_reloc_name_lookup
 610
 611 #define elf_backend_check_relocs                mt_elf_check_relocs
 612 #define elf_backend_object_p                    mt_elf_object_p
 613 #define elf_backend_rela_normal                 1
 614
 615 #define elf_backend_can_gc_sections             1
 616
 617 #define bfd_elf32_bfd_set_private_flags         mt_elf_set_private_flags
 618 #define bfd_elf32_bfd_copy_private_bfd_data     mt_elf_copy_private_bfd_data
 619 #define bfd_elf32_bfd_merge_private_bfd_data    mt_elf_merge_private_bfd_data
 620 #define bfd_elf32_bfd_print_private_bfd_data    mt_elf_print_private_bfd_data
 621
 622 #include "elf32-target.h"