2005-06-20 H.J. Lu <hongjiu.lu@intel.com>
[external/binutils.git] / bfd / elf32-dlx.c
1 /* DLX specific support for 32-bit ELF
2    Copyright 2002, 2003, 2004, 2005 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 2 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, MA 02110-1301, USA.  */
19
20 #include "bfd.h"
21 #include "sysdep.h"
22 #include "libbfd.h"
23 #include "elf-bfd.h"
24 #include "elf/dlx.h"
25
26 int    set_dlx_skip_hi16_flag PARAMS ((int));
27
28 static bfd_boolean elf32_dlx_check_relocs
29   PARAMS ((bfd *, struct bfd_link_info *, asection *,
30            const Elf_Internal_Rela *));
31 static void elf32_dlx_info_to_howto
32   PARAMS ((bfd *, arelent *, Elf_Internal_Rela *));
33 static void elf32_dlx_info_to_howto_rel
34   PARAMS ((bfd *, arelent *, Elf_Internal_Rela *));
35 static bfd_reloc_status_type elf32_dlx_relocate16
36   PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
37 static bfd_reloc_status_type elf32_dlx_relocate26
38   PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
39 static reloc_howto_type *elf32_dlx_reloc_type_lookup
40   PARAMS ((bfd *, bfd_reloc_code_real_type));
41 static bfd_reloc_status_type _bfd_dlx_elf_hi16_reloc
42   PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
43 static reloc_howto_type * dlx_rtype_to_howto
44   PARAMS ((unsigned int));
45
46
47 #define USE_REL 1
48
49 #define bfd_elf32_bfd_reloc_type_lookup elf32_dlx_reloc_type_lookup
50 #define elf_info_to_howto               elf32_dlx_info_to_howto
51 #define elf_info_to_howto_rel           elf32_dlx_info_to_howto_rel
52 #define elf_backend_check_relocs        elf32_dlx_check_relocs
53
54 static reloc_howto_type dlx_elf_howto_table[]=
55   {
56     /* No relocation.  */
57     HOWTO (R_DLX_NONE,            /* type */
58            0,                     /* rightshift */
59            0,                     /* size (0 = byte, 1 = short, 2 = long) */
60            0,                     /* bitsize */
61            FALSE,                 /* pc_relative */
62            0,                     /* bitpos */
63            complain_overflow_dont,/* complain_on_overflow */
64            bfd_elf_generic_reloc, /* special_function */
65            "R_DLX_NONE",          /* name */
66            FALSE,                 /* partial_inplace */
67            0,                     /* src_mask */
68            0,                     /* dst_mask */
69            FALSE),                /* pcrel_offset */
70
71     /* 8 bit relocation.  */
72     HOWTO (R_DLX_RELOC_8,         /* type */
73            0,                     /* rightshift */
74            0,                     /* size (0 = byte, 1 = short, 2 = long) */
75            8,                     /* bitsize */
76            FALSE,                 /* pc_relative */
77            0,                     /* bitpos */
78            complain_overflow_dont,/* complain_on_overflow */
79            bfd_elf_generic_reloc, /* special_function */
80            "R_DLX_RELOC_8",       /* name */
81            TRUE,                  /* partial_inplace */
82            0xff,                  /* src_mask */
83            0xff,                  /* dst_mask */
84            FALSE),                /* pcrel_offset */
85
86     /* 16 bit relocation.  */
87     HOWTO (R_DLX_RELOC_16,        /* type */
88            0,                     /* rightshift */
89            1,                     /* size (0 = byte, 1 = short, 2 = long) */
90            16,                    /* bitsize */
91            FALSE,                 /* pc_relative */
92            0,                     /* bitpos */
93            complain_overflow_dont,/* complain_on_overflow */
94            bfd_elf_generic_reloc, /* special_function */
95            "R_DLX_RELOC_16",      /* name */
96            TRUE,                  /* partial_inplace */
97            0xffff,                /* src_mask */
98            0xffff,                /* dst_mask */
99            FALSE),                /* pcrel_offset */
100
101     /* 32 bit relocation.  */
102     HOWTO (R_DLX_RELOC_32,        /* type */
103            0,                     /* rightshift */
104            2,                     /* size (0 = byte, 1 = short, 2 = long) */
105            32,                    /* bitsize */
106            FALSE,                 /* pc_relative */
107            0,                     /* bitpos */
108            complain_overflow_dont,/* complain_on_overflow */
109            bfd_elf_generic_reloc, /* special_function */
110            "R_DLX_RELOC_32",      /* name */
111            TRUE,                  /* partial_inplace */
112            0xffffffff,            /* src_mask */
113            0xffffffff,            /* dst_mask */
114            FALSE),                /* pcrel_offset */
115
116     /* GNU extension to record C++ vtable hierarchy */
117     HOWTO (R_DLX_GNU_VTINHERIT,   /* type */
118            0,                     /* rightshift */
119            2,                     /* size (0 = byte, 1 = short, 2 = long) */
120            0,                     /* bitsize */
121            FALSE,                 /* pc_relative */
122            0,                     /* bitpos */
123            complain_overflow_dont,/* complain_on_overflow */
124            NULL,                  /* special_function */
125            "R_DLX_GNU_VTINHERIT", /* name */
126            FALSE,                 /* partial_inplace */
127            0,                     /* src_mask */
128            0,                     /* dst_mask */
129            FALSE),                /* pcrel_offset */
130
131     /* GNU extension to record C++ vtable member usage */
132     HOWTO (R_DLX_GNU_VTENTRY,     /* type */
133            0,                     /* rightshift */
134            2,                     /* size (0 = byte, 1 = short, 2 = long) */
135            0,                     /* bitsize */
136            FALSE,                 /* pc_relative */
137            0,                     /* bitpos */
138            complain_overflow_dont,/* complain_on_overflow */
139            _bfd_elf_rel_vtable_reloc_fn,/* special_function */
140            "R_DLX_GNU_VTENTRY",   /* name */
141            FALSE,                 /* partial_inplace */
142            0,                     /* src_mask */
143            0,                     /* dst_mask */
144            FALSE)                 /* pcrel_offset */
145   };
146
147 /* 16 bit offset for pc-relative branches.  */
148 static reloc_howto_type elf_dlx_gnu_rel16_s2 =
149 HOWTO (R_DLX_RELOC_16_PCREL,  /* type */
150        0,                     /* rightshift */
151        1,                     /* size (0 = byte, 1 = short, 2 = long) */
152        16,                    /* bitsize */
153        TRUE,                  /* pc_relative */
154        0,                     /* bitpos */
155        complain_overflow_signed, /* complain_on_overflow */
156        elf32_dlx_relocate16,  /* special_function */
157        "R_DLX_RELOC_16_PCREL",/* name */
158        TRUE,                  /* partial_inplace */
159        0xffff,                /* src_mask */
160        0xffff,                /* dst_mask */
161        TRUE);                 /* pcrel_offset */
162
163 /* 26 bit offset for pc-relative branches.  */
164 static reloc_howto_type elf_dlx_gnu_rel26_s2 =
165 HOWTO (R_DLX_RELOC_26_PCREL,  /* type */
166        0,                     /* rightshift */
167        2,                     /* size (0 = byte, 1 = short, 2 = long) */
168        26,                    /* bitsize */
169        TRUE,                  /* pc_relative */
170        0,                     /* bitpos */
171        complain_overflow_dont,/* complain_on_overflow */
172        elf32_dlx_relocate26,  /* special_function */
173        "R_DLX_RELOC_26_PCREL",/* name */
174        TRUE,                  /* partial_inplace */
175        0xffff,                /* src_mask */
176        0xffff,                /* dst_mask */
177        TRUE);                 /* pcrel_offset */
178
179 /* High 16 bits of symbol value.  */
180 static reloc_howto_type elf_dlx_reloc_16_hi =
181 HOWTO (R_DLX_RELOC_16_HI,     /* type */
182        16,                    /* rightshift */
183        2,                     /* size (0 = byte, 1 = short, 2 = long) */
184        32,                    /* bitsize */
185        FALSE,                 /* pc_relative */
186        0,                     /* bitpos */
187        complain_overflow_dont, /* complain_on_overflow */
188        _bfd_dlx_elf_hi16_reloc,/* special_function */
189        "R_DLX_RELOC_16_HI",   /* name */
190        TRUE,                  /* partial_inplace */
191        0xFFFF,                /* src_mask */
192        0xffff,                /* dst_mask */
193        FALSE);                /* pcrel_offset */
194
195   /* Low 16 bits of symbol value.  */
196 static reloc_howto_type elf_dlx_reloc_16_lo =
197 HOWTO (R_DLX_RELOC_16_LO,     /* type */
198        0,                     /* rightshift */
199        1,                     /* size (0 = byte, 1 = short, 2 = long) */
200        16,                    /* bitsize */
201        FALSE,                 /* pc_relative */
202        0,                     /* bitpos */
203        complain_overflow_dont,/* complain_on_overflow */
204        bfd_elf_generic_reloc, /* special_function */
205        "R_DLX_RELOC_16_LO",   /* name */
206        TRUE,                  /* partial_inplace */
207        0xffff,                /* src_mask */
208        0xffff,                /* dst_mask */
209        FALSE);                /* pcrel_offset */
210
211
212 /* The gas default behavior is not to preform the %hi modifier so that the
213    GNU assembler can have the lower 16 bits offset placed in the insn, BUT
214    we do like the gas to indicate it is %hi reloc type so when we in the link
215    loader phase we can have the corrected hi16 vale replace the buggous lo16
216    value that was placed there by gas.  */
217
218 static int skip_dlx_elf_hi16_reloc = 0;
219
220 int
221 set_dlx_skip_hi16_flag (flag)
222      int flag;
223 {
224   skip_dlx_elf_hi16_reloc = flag;
225   return flag;
226 }
227
228 static bfd_reloc_status_type
229 _bfd_dlx_elf_hi16_reloc (abfd, reloc_entry, symbol, data,
230                          input_section, output_bfd, error_message)
231      bfd *abfd;
232      arelent *reloc_entry;
233      asymbol *symbol;
234      PTR data;
235      asection *input_section;
236      bfd *output_bfd;
237      char **error_message;
238 {
239   bfd_reloc_status_type ret;
240   bfd_vma relocation;
241
242   /* If the skip flag is set then we simply do the generic relocating, this
243      is more of a hack for dlx gas/gld, so we do not need to do the %hi/%lo
244      fixup like mips gld did.   */
245   if (skip_dlx_elf_hi16_reloc)
246     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
247                           input_section, output_bfd, error_message);
248
249   /* If we're relocating, and this an external symbol, we don't want
250      to change anything.  */
251   if (output_bfd != (bfd *) NULL
252       && (symbol->flags & BSF_SECTION_SYM) == 0
253       && reloc_entry->addend == 0)
254     {
255       reloc_entry->address += input_section->output_offset;
256       return bfd_reloc_ok;
257     }
258
259   ret = bfd_reloc_ok;
260
261   if (bfd_is_und_section (symbol->section)
262       && output_bfd == (bfd *) NULL)
263     ret = bfd_reloc_undefined;
264
265   relocation = (bfd_is_com_section (symbol->section)) ? 0 : symbol->value;
266   relocation += symbol->section->output_section->vma;
267   relocation += symbol->section->output_offset;
268   relocation += reloc_entry->addend;
269   relocation += bfd_get_16 (abfd, (bfd_byte *)data + reloc_entry->address);
270
271   if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
272     return bfd_reloc_outofrange;
273
274   bfd_put_16 (abfd, (short)((relocation >> 16) & 0xFFFF),
275               (bfd_byte *)data + reloc_entry->address);
276
277   return ret;
278 }
279
280 /* ELF relocs are against symbols.  If we are producing relocatable
281    output, and the reloc is against an external symbol, and nothing
282    has given us any additional addend, the resulting reloc will also
283    be against the same symbol.  In such a case, we don't want to
284    change anything about the way the reloc is handled, since it will
285    all be done at final link time.  Rather than put special case code
286    into bfd_perform_relocation, all the reloc types use this howto
287    function.  It just short circuits the reloc if producing
288    relocatable output against an external symbol.  */
289
290 static bfd_reloc_status_type
291 elf32_dlx_relocate16  (abfd, reloc_entry, symbol, data,
292                        input_section, output_bfd, error_message)
293      bfd *abfd;
294      arelent *reloc_entry;
295      asymbol *symbol;
296      PTR data;
297      asection *input_section;
298      bfd *output_bfd;
299      char **error_message ATTRIBUTE_UNUSED;
300 {
301   unsigned long insn, vallo, allignment;
302   int           val;
303
304   /* HACK: I think this first condition is necessary when producing
305      relocatable output.  After the end of HACK, the code is identical
306      to bfd_elf_generic_reloc().  I would _guess_ the first change
307      belongs there rather than here.  martindo 1998-10-23.  */
308
309   if (skip_dlx_elf_hi16_reloc)
310     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
311                                  input_section, output_bfd, error_message);
312
313   /* Check undefined section and undefined symbols  */
314   if (bfd_is_und_section (symbol->section)
315       && output_bfd == (bfd *) NULL)
316     return bfd_reloc_undefined;
317
318   /* Can not support a long jump to sections other then .text   */
319   if (strcmp (input_section->name, symbol->section->output_section->name) != 0)
320     {
321       fprintf (stderr,
322                "BFD Link Error: branch (PC rel16) to section (%s) not supported\n",
323                symbol->section->output_section->name);
324       return bfd_reloc_undefined;
325     }
326
327   insn  = bfd_get_32 (abfd, (bfd_byte *)data + reloc_entry->address);
328   allignment = 1 << (input_section->output_section->alignment_power - 1);
329   vallo = insn & 0x0000FFFF;
330
331   if (vallo & 0x8000)
332     vallo = ~(vallo | 0xFFFF0000) + 1;
333
334   /* vallo points to the vma of next instruction.  */
335   vallo += (((unsigned long)(input_section->output_section->vma +
336                            input_section->output_offset) +
337             allignment) & ~allignment);
338
339   /* val is the displacement (PC relative to next instruction).  */
340   val =  (symbol->section->output_offset +
341           symbol->section->output_section->vma +
342           symbol->value) - vallo;
343
344   if (abs ((int) val) > 0x00007FFF)
345     return bfd_reloc_outofrange;
346
347   insn  = (insn & 0xFFFF0000) | (val & 0x0000FFFF);
348
349   bfd_put_32 (abfd, insn,
350               (bfd_byte *) data + reloc_entry->address);
351
352   return bfd_reloc_ok;
353 }
354
355 static bfd_reloc_status_type
356 elf32_dlx_relocate26  (abfd, reloc_entry, symbol, data,
357                        input_section, output_bfd, error_message)
358      bfd *abfd;
359      arelent *reloc_entry;
360      asymbol *symbol;
361      PTR data;
362      asection *input_section;
363      bfd *output_bfd;
364      char **error_message ATTRIBUTE_UNUSED;
365 {
366   unsigned long insn, vallo, allignment;
367   int           val;
368
369   /* HACK: I think this first condition is necessary when producing
370      relocatable output.  After the end of HACK, the code is identical
371      to bfd_elf_generic_reloc().  I would _guess_ the first change
372      belongs there rather than here.  martindo 1998-10-23.  */
373
374   if (skip_dlx_elf_hi16_reloc)
375     return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
376                                  input_section, output_bfd, error_message);
377
378   /* Check undefined section and undefined symbols.  */
379   if (bfd_is_und_section (symbol->section)
380       && output_bfd == (bfd *) NULL)
381     return bfd_reloc_undefined;
382
383   /* Can not support a long jump to sections other then .text   */
384   if (strcmp (input_section->name, symbol->section->output_section->name) != 0)
385     {
386       fprintf (stderr,
387                "BFD Link Error: jump (PC rel26) to section (%s) not supported\n",
388                symbol->section->output_section->name);
389       return bfd_reloc_undefined;
390     }
391
392   insn  = bfd_get_32 (abfd, (bfd_byte *)data + reloc_entry->address);
393   allignment = 1 << (input_section->output_section->alignment_power - 1);
394   vallo = insn & 0x03FFFFFF;
395
396   if (vallo & 0x03000000)
397     vallo = ~(vallo | 0xFC000000) + 1;
398
399   /* vallo is the vma for the next instruction.  */
400   vallo += (((unsigned long) (input_section->output_section->vma +
401                               input_section->output_offset) +
402              allignment) & ~allignment);
403
404   /* val is the displacement (PC relative to next instruction).  */
405   val = (symbol->section->output_offset +
406          symbol->section->output_section->vma + symbol->value)
407     - vallo;
408
409   if (abs ((int) val) > 0x01FFFFFF)
410     return bfd_reloc_outofrange;
411
412   insn  = (insn & 0xFC000000) | (val & 0x03FFFFFF);
413   bfd_put_32 (abfd, insn,
414               (bfd_byte *) data + reloc_entry->address);
415
416   return bfd_reloc_ok;
417 }
418
419 /* A mapping from BFD reloc types to DLX ELF reloc types.
420    Stolen from elf32-mips.c.
421
422    More about this table - for dlx elf relocation we do not really
423    need this table, if we have a rtype defined in this table will
424    caused tc_gen_relocate confused and die on us, but if we remove
425    this table it will caused more problem, so for now simple solution
426    is to remove those entries which may cause problem.  */
427 struct elf_reloc_map
428 {
429   bfd_reloc_code_real_type bfd_reloc_val;
430   enum elf_dlx_reloc_type elf_reloc_val;
431 };
432
433 static const struct elf_reloc_map dlx_reloc_map[] =
434   {
435     { BFD_RELOC_NONE,           R_DLX_NONE },
436     { BFD_RELOC_16,             R_DLX_RELOC_16 },
437     { BFD_RELOC_32,             R_DLX_RELOC_32 },
438     { BFD_RELOC_DLX_HI16_S,     R_DLX_RELOC_16_HI },
439     { BFD_RELOC_DLX_LO16,       R_DLX_RELOC_16_LO },
440     { BFD_RELOC_VTABLE_INHERIT, R_DLX_GNU_VTINHERIT },
441     { BFD_RELOC_VTABLE_ENTRY,   R_DLX_GNU_VTENTRY }
442   };
443
444
445 /* Look through the relocs for a section during the first phase.
446    Since we don't do .gots or .plts, we just need to consider the
447    virtual table relocs for gc.  */
448
449 static bfd_boolean
450 elf32_dlx_check_relocs (abfd, info, sec, relocs)
451      bfd *abfd;
452      struct bfd_link_info *info;
453      asection *sec;
454      const Elf_Internal_Rela *relocs;
455 {
456   Elf_Internal_Shdr *symtab_hdr;
457   struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
458   const Elf_Internal_Rela *rel;
459   const Elf_Internal_Rela *rel_end;
460
461   if (info->relocatable)
462     return TRUE;
463
464   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
465   sym_hashes = elf_sym_hashes (abfd);
466   sym_hashes_end = sym_hashes + symtab_hdr->sh_size / sizeof (Elf32_External_Sym);
467   if (!elf_bad_symtab (abfd))
468     sym_hashes_end -= symtab_hdr->sh_info;
469
470   rel_end = relocs + sec->reloc_count;
471   for (rel = relocs; rel < rel_end; rel++)
472     {
473       struct elf_link_hash_entry *h;
474       unsigned long r_symndx;
475
476       r_symndx = ELF32_R_SYM (rel->r_info);
477       if (r_symndx < symtab_hdr->sh_info)
478         h = NULL;
479       else
480         {
481           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
482           while (h->root.type == bfd_link_hash_indirect
483                  || h->root.type == bfd_link_hash_warning)
484             h = (struct elf_link_hash_entry *) h->root.u.i.link;
485         }
486
487       switch (ELF32_R_TYPE (rel->r_info))
488         {
489         /* This relocation describes the C++ object vtable hierarchy.
490            Reconstruct it for later use during GC.  */
491         case R_DLX_GNU_VTINHERIT:
492           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
493             return FALSE;
494           break;
495
496         /* This relocation describes which C++ vtable entries are actually
497            used.  Record for later use during GC.  */
498         case R_DLX_GNU_VTENTRY:
499           if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
500             return FALSE;
501           break;
502         }
503     }
504
505   return TRUE;
506 }
507
508 /* Given a BFD reloc type, return a howto structure.  */
509
510 static reloc_howto_type *
511 elf32_dlx_reloc_type_lookup (abfd, code)
512      bfd *abfd ATTRIBUTE_UNUSED;
513      bfd_reloc_code_real_type code;
514 {
515   unsigned int i;
516
517   for (i = 0; i < sizeof (dlx_reloc_map) / sizeof (struct elf_reloc_map); i++)
518     if (dlx_reloc_map[i].bfd_reloc_val == code)
519       return &dlx_elf_howto_table[(int) dlx_reloc_map[i].elf_reloc_val];
520
521   switch (code)
522     {
523     default:
524       bfd_set_error (bfd_error_bad_value);
525       return NULL;
526     case BFD_RELOC_16_PCREL_S2:
527       return &elf_dlx_gnu_rel16_s2;
528     case BFD_RELOC_DLX_JMP26:
529       return &elf_dlx_gnu_rel26_s2;
530     case BFD_RELOC_HI16_S:
531       return &elf_dlx_reloc_16_hi;
532     case BFD_RELOC_LO16:
533       return &elf_dlx_reloc_16_lo;
534     }
535 }
536
537 static reloc_howto_type *
538 dlx_rtype_to_howto (r_type)
539      unsigned int r_type;
540 {
541   switch (r_type)
542     {
543     case R_DLX_RELOC_16_PCREL:
544       return & elf_dlx_gnu_rel16_s2;
545       break;
546     case R_DLX_RELOC_26_PCREL:
547       return & elf_dlx_gnu_rel26_s2;
548       break;
549     case R_DLX_RELOC_16_HI:
550       return & elf_dlx_reloc_16_hi;
551       break;
552     case R_DLX_RELOC_16_LO:
553       return & elf_dlx_reloc_16_lo;
554       break;
555
556     default:
557       BFD_ASSERT (r_type < (unsigned int) R_DLX_max);
558       return & dlx_elf_howto_table[r_type];
559       break;
560     }
561 }
562
563 static void
564 elf32_dlx_info_to_howto (abfd, cache_ptr, dst)
565      bfd * abfd ATTRIBUTE_UNUSED;
566      arelent * cache_ptr ATTRIBUTE_UNUSED;
567      Elf_Internal_Rela * dst ATTRIBUTE_UNUSED;
568 {
569   abort ();
570 }
571
572 static void
573 elf32_dlx_info_to_howto_rel (abfd, cache_ptr, dst)
574      bfd *abfd ATTRIBUTE_UNUSED;
575      arelent *cache_ptr;
576      Elf_Internal_Rela *dst;
577 {
578   unsigned int r_type;
579
580   r_type = ELF32_R_TYPE (dst->r_info);
581   cache_ptr->howto = dlx_rtype_to_howto (r_type);
582   return;
583 }
584
585 #define TARGET_BIG_SYM          bfd_elf32_dlx_big_vec
586 #define TARGET_BIG_NAME         "elf32-dlx"
587 #define ELF_ARCH                bfd_arch_dlx
588 #define ELF_MACHINE_CODE        EM_DLX
589 #define ELF_MAXPAGESIZE         1 /* FIXME: This number is wrong,  It should be the page size in bytes.  */
590
591 #include "elf32-target.h"