Upload Tizen:Base source
[external/binutils.git] / bfd / i386lynx.c
1 /* BFD back-end for i386 a.out binaries under LynxOS.
2    Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1999, 2001, 2002,
3    2003, 2005, 2007, 2009, 2010 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 #define TEXT_START_ADDR 0
23 #define TARGET_PAGE_SIZE 4096
24 #define SEGMENT_SIZE TARGET_PAGE_SIZE
25 #define DEFAULT_ARCH bfd_arch_i386
26
27 /* Do not "beautify" the CONCAT* macro args.  Traditional C will not
28    remove whitespace added here, and thus will fail to concatenate
29    the tokens.  */
30 #define MY(OP) CONCAT2 (i386lynx_aout_,OP)
31 #define TARGETNAME "a.out-i386-lynx"
32
33 #include "sysdep.h"
34 #include "bfd.h"
35 #include "libbfd.h"
36
37 #ifndef WRITE_HEADERS
38 #define WRITE_HEADERS(abfd, execp)                                            \
39       {                                                                       \
40         bfd_size_type text_size; /* dummy vars */                             \
41         file_ptr text_end;                                                    \
42         if (adata(abfd).magic == undecided_magic)                             \
43           NAME(aout,adjust_sizes_and_vmas) (abfd, &text_size, &text_end);     \
44                                                                               \
45         execp->a_syms = bfd_get_symcount (abfd) * EXTERNAL_NLIST_SIZE;        \
46         execp->a_entry = bfd_get_start_address (abfd);                        \
47                                                                               \
48         execp->a_trsize = ((obj_textsec (abfd)->reloc_count) *                \
49                            obj_reloc_entry_size (abfd));                      \
50         execp->a_drsize = ((obj_datasec (abfd)->reloc_count) *                \
51                            obj_reloc_entry_size (abfd));                      \
52         NAME(aout,swap_exec_header_out) (abfd, execp, &exec_bytes);           \
53                                                                               \
54         if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0                      \
55             || bfd_bwrite ((PTR) &exec_bytes, (bfd_size_type) EXEC_BYTES_SIZE, \
56                           abfd) != EXEC_BYTES_SIZE)                           \
57           return FALSE;                                                       \
58         /* Now write out reloc info, followed by syms and strings */          \
59                                                                               \
60         if (bfd_get_symcount (abfd) != 0)                                     \
61             {                                                                 \
62               if (bfd_seek (abfd, (file_ptr) (N_SYMOFF(*execp)), SEEK_SET)    \
63                   != 0)                                                       \
64                 return FALSE;                                                 \
65                                                                               \
66               if (! NAME(aout,write_syms) (abfd)) return FALSE;               \
67                                                                               \
68               if (bfd_seek (abfd, (file_ptr) (N_TRELOFF(*execp)), SEEK_SET)   \
69                   != 0)                                                       \
70                 return FALSE;                                                 \
71                                                                               \
72               if (!NAME(lynx,squirt_out_relocs) (abfd, obj_textsec (abfd)))   \
73                 return FALSE;                                                 \
74               if (bfd_seek (abfd, (file_ptr) (N_DRELOFF(*execp)), SEEK_SET)   \
75                   != 0)                                                       \
76                 return 0;                                                     \
77                                                                               \
78               if (!NAME(lynx,squirt_out_relocs) (abfd, obj_datasec (abfd)))   \
79                 return FALSE;                                                 \
80             }                                                                 \
81       }
82 #endif
83
84 #include "libaout.h"
85 #include "aout/aout64.h"
86
87 void NAME (lynx,swap_std_reloc_out)
88   PARAMS ((bfd *, arelent *, struct reloc_std_external *));
89 void NAME (lynx,swap_ext_reloc_out)
90   PARAMS ((bfd *, arelent *, struct reloc_ext_external *));
91 void NAME (lynx,swap_ext_reloc_in)
92   PARAMS ((bfd *, struct reloc_ext_external *, arelent *, asymbol **,
93            bfd_size_type));
94 void NAME (lynx,swap_std_reloc_in)
95   PARAMS ((bfd *, struct reloc_std_external *, arelent *, asymbol **,
96            bfd_size_type));
97 bfd_boolean NAME (lynx,slurp_reloc_table)
98   PARAMS ((bfd *, sec_ptr, asymbol **));
99 bfd_boolean NAME (lynx,squirt_out_relocs)
100   PARAMS ((bfd *, asection *));
101 long NAME (lynx,canonicalize_reloc)
102   PARAMS ((bfd *, sec_ptr, arelent **, asymbol **));
103
104 #ifdef LYNX_CORE
105
106 char *lynx_core_file_failing_command ();
107 int lynx_core_file_failing_signal ();
108 bfd_boolean lynx_core_file_matches_executable_p ();
109 const bfd_target *lynx_core_file_p ();
110
111 #define MY_core_file_failing_command lynx_core_file_failing_command
112 #define MY_core_file_failing_signal lynx_core_file_failing_signal
113 #define MY_core_file_matches_executable_p lynx_core_file_matches_executable_p
114 #define MY_core_file_p lynx_core_file_p
115
116 #endif /* LYNX_CORE */
117 \f
118
119 #define KEEPIT udata.i
120
121 extern reloc_howto_type aout_32_ext_howto_table[];
122 extern reloc_howto_type aout_32_std_howto_table[];
123
124 /* Standard reloc stuff */
125 /* Output standard relocation information to a file in target byte order. */
126
127 void
128 NAME(lynx,swap_std_reloc_out) (abfd, g, natptr)
129      bfd *abfd;
130      arelent *g;
131      struct reloc_std_external *natptr;
132 {
133   int r_index;
134   asymbol *sym = *(g->sym_ptr_ptr);
135   int r_extern;
136   unsigned int r_length;
137   int r_pcrel;
138   int r_baserel, r_jmptable, r_relative;
139   asection *output_section = sym->section->output_section;
140
141   PUT_WORD (abfd, g->address, natptr->r_address);
142
143   r_length = g->howto->size;    /* Size as a power of two */
144   r_pcrel = (int) g->howto->pc_relative;        /* Relative to PC? */
145   /* r_baserel, r_jmptable, r_relative???  FIXME-soon */
146   r_baserel = 0;
147   r_jmptable = 0;
148   r_relative = 0;
149
150   /* name was clobbered by aout_write_syms to be symbol index */
151
152   /* If this relocation is relative to a symbol then set the
153      r_index to the symbols index, and the r_extern bit.
154
155      Absolute symbols can come in in two ways, either as an offset
156      from the abs section, or as a symbol which has an abs value.
157      check for that here
158   */
159
160
161   if (bfd_is_com_section (output_section)
162       || bfd_is_abs_section (output_section)
163       || bfd_is_und_section (output_section))
164     {
165       if (bfd_abs_section_ptr->symbol == sym)
166         {
167           /* Whoops, looked like an abs symbol, but is really an offset
168              from the abs section */
169           r_index = 0;
170           r_extern = 0;
171         }
172       else
173         {
174           /* Fill in symbol */
175           r_extern = 1;
176           r_index = (*g->sym_ptr_ptr)->KEEPIT;
177         }
178     }
179   else
180     {
181       /* Just an ordinary section */
182       r_extern = 0;
183       r_index = output_section->target_index;
184     }
185
186   /* now the fun stuff */
187   if (bfd_header_big_endian (abfd))
188     {
189       natptr->r_index[0] = r_index >> 16;
190       natptr->r_index[1] = r_index >> 8;
191       natptr->r_index[2] = r_index;
192       natptr->r_type[0] =
193         (r_extern ? RELOC_STD_BITS_EXTERN_BIG : 0)
194         | (r_pcrel ? RELOC_STD_BITS_PCREL_BIG : 0)
195         | (r_baserel ? RELOC_STD_BITS_BASEREL_BIG : 0)
196         | (r_jmptable ? RELOC_STD_BITS_JMPTABLE_BIG : 0)
197         | (r_relative ? RELOC_STD_BITS_RELATIVE_BIG : 0)
198         | (r_length << RELOC_STD_BITS_LENGTH_SH_BIG);
199     }
200   else
201     {
202       natptr->r_index[2] = r_index >> 16;
203       natptr->r_index[1] = r_index >> 8;
204       natptr->r_index[0] = r_index;
205       natptr->r_type[0] =
206         (r_extern ? RELOC_STD_BITS_EXTERN_LITTLE : 0)
207         | (r_pcrel ? RELOC_STD_BITS_PCREL_LITTLE : 0)
208         | (r_baserel ? RELOC_STD_BITS_BASEREL_LITTLE : 0)
209         | (r_jmptable ? RELOC_STD_BITS_JMPTABLE_LITTLE : 0)
210         | (r_relative ? RELOC_STD_BITS_RELATIVE_LITTLE : 0)
211         | (r_length << RELOC_STD_BITS_LENGTH_SH_LITTLE);
212     }
213 }
214
215
216 /* Extended stuff */
217 /* Output extended relocation information to a file in target byte order. */
218
219 void
220 NAME(lynx,swap_ext_reloc_out) (abfd, g, natptr)
221      bfd *abfd;
222      arelent *g;
223      register struct reloc_ext_external *natptr;
224 {
225   int r_index;
226   int r_extern;
227   unsigned int r_type;
228   unsigned int r_addend;
229   asymbol *sym = *(g->sym_ptr_ptr);
230   asection *output_section = sym->section->output_section;
231
232   PUT_WORD (abfd, g->address, natptr->r_address);
233
234   r_type = (unsigned int) g->howto->type;
235
236   r_addend = g->addend + (*(g->sym_ptr_ptr))->section->output_section->vma;
237
238
239   /* If this relocation is relative to a symbol then set the
240      r_index to the symbols index, and the r_extern bit.
241
242      Absolute symbols can come in in two ways, either as an offset
243      from the abs section, or as a symbol which has an abs value.
244      check for that here
245      */
246
247   if (bfd_is_com_section (output_section)
248       || bfd_is_abs_section (output_section)
249       || bfd_is_und_section (output_section))
250     {
251       if (bfd_abs_section_ptr->symbol == sym)
252         {
253           /* Whoops, looked like an abs symbol, but is really an offset
254          from the abs section */
255           r_index = 0;
256           r_extern = 0;
257         }
258       else
259         {
260           r_extern = 1;
261           r_index = (*g->sym_ptr_ptr)->KEEPIT;
262         }
263     }
264   else
265     {
266       /* Just an ordinary section */
267       r_extern = 0;
268       r_index = output_section->target_index;
269     }
270
271
272   /* now the fun stuff */
273   if (bfd_header_big_endian (abfd))
274     {
275       natptr->r_index[0] = r_index >> 16;
276       natptr->r_index[1] = r_index >> 8;
277       natptr->r_index[2] = r_index;
278       natptr->r_type[0] =
279         (r_extern ? RELOC_EXT_BITS_EXTERN_BIG : 0)
280         | (r_type << RELOC_EXT_BITS_TYPE_SH_BIG);
281     }
282   else
283     {
284       natptr->r_index[2] = r_index >> 16;
285       natptr->r_index[1] = r_index >> 8;
286       natptr->r_index[0] = r_index;
287       natptr->r_type[0] =
288         (r_extern ? RELOC_EXT_BITS_EXTERN_LITTLE : 0)
289         | (r_type << RELOC_EXT_BITS_TYPE_SH_LITTLE);
290     }
291
292   PUT_WORD (abfd, r_addend, natptr->r_addend);
293 }
294
295 /* BFD deals internally with all things based from the section they're
296    in. so, something in 10 bytes into a text section  with a base of
297    50 would have a symbol (.text+10) and know .text vma was 50.
298
299    Aout keeps all it's symbols based from zero, so the symbol would
300    contain 60. This macro subs the base of each section from the value
301    to give the true offset from the section */
302
303
304 #define MOVE_ADDRESS(ad)                                                \
305   if (r_extern) {                                                       \
306    /* undefined symbol */                                               \
307      cache_ptr->sym_ptr_ptr = symbols + r_index;                        \
308      cache_ptr->addend = ad;                                            \
309      } else {                                                           \
310     /* defined, section relative. replace symbol with pointer to        \
311        symbol which points to section  */                               \
312     switch (r_index) {                                                  \
313     case N_TEXT:                                                        \
314     case N_TEXT | N_EXT:                                                \
315       cache_ptr->sym_ptr_ptr  = obj_textsec(abfd)->symbol_ptr_ptr;      \
316       cache_ptr->addend = ad  - su->textsec->vma;                       \
317       break;                                                            \
318     case N_DATA:                                                        \
319     case N_DATA | N_EXT:                                                \
320       cache_ptr->sym_ptr_ptr  = obj_datasec(abfd)->symbol_ptr_ptr;      \
321       cache_ptr->addend = ad - su->datasec->vma;                        \
322       break;                                                            \
323     case N_BSS:                                                         \
324     case N_BSS | N_EXT:                                                 \
325       cache_ptr->sym_ptr_ptr  = obj_bsssec(abfd)->symbol_ptr_ptr;       \
326       cache_ptr->addend = ad - su->bsssec->vma;                         \
327       break;                                                            \
328     default:                                                            \
329     case N_ABS:                                                         \
330     case N_ABS | N_EXT:                                                 \
331      cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr;      \
332       cache_ptr->addend = ad;                                           \
333       break;                                                            \
334     }                                                                   \
335   }                                                                     \
336
337 void
338 NAME(lynx,swap_ext_reloc_in) (abfd, bytes, cache_ptr, symbols, symcount)
339      bfd *abfd;
340      struct reloc_ext_external *bytes;
341      arelent *cache_ptr;
342      asymbol **symbols;
343      bfd_size_type symcount ATTRIBUTE_UNUSED;
344 {
345   int r_index;
346   int r_extern;
347   unsigned int r_type;
348   struct aoutdata *su = &(abfd->tdata.aout_data->a);
349
350   cache_ptr->address = (GET_SWORD (abfd, bytes->r_address));
351
352   r_index = bytes->r_index[1];
353   r_extern = (0 != (bytes->r_index[0] & RELOC_EXT_BITS_EXTERN_BIG));
354   r_type = (bytes->r_index[0] & RELOC_EXT_BITS_TYPE_BIG)
355     >> RELOC_EXT_BITS_TYPE_SH_BIG;
356
357   cache_ptr->howto = aout_32_ext_howto_table + r_type;
358   MOVE_ADDRESS (GET_SWORD (abfd, bytes->r_addend));
359 }
360
361 void
362 NAME(lynx,swap_std_reloc_in) (abfd, bytes, cache_ptr, symbols, symcount)
363      bfd *abfd;
364      struct reloc_std_external *bytes;
365      arelent *cache_ptr;
366      asymbol **symbols;
367      bfd_size_type symcount ATTRIBUTE_UNUSED;
368 {
369   int r_index;
370   int r_extern;
371   unsigned int r_length;
372   int r_pcrel;
373   struct aoutdata *su = &(abfd->tdata.aout_data->a);
374
375   cache_ptr->address = H_GET_32 (abfd, bytes->r_address);
376
377   r_index = bytes->r_index[1];
378   r_extern = (0 != (bytes->r_index[0] & RELOC_STD_BITS_EXTERN_BIG));
379   r_pcrel = (0 != (bytes->r_index[0] & RELOC_STD_BITS_PCREL_BIG));
380   r_length = (bytes->r_index[0] & RELOC_STD_BITS_LENGTH_BIG)
381     >> RELOC_STD_BITS_LENGTH_SH_BIG;
382
383   cache_ptr->howto = aout_32_std_howto_table + r_length + 4 * r_pcrel;
384   /* FIXME-soon:  Roll baserel, jmptable, relative bits into howto setting */
385
386   MOVE_ADDRESS (0);
387 }
388
389 /* Reloc hackery */
390
391 bfd_boolean
392 NAME(lynx,slurp_reloc_table) (abfd, asect, symbols)
393      bfd *abfd;
394      sec_ptr asect;
395      asymbol **symbols;
396 {
397   bfd_size_type count;
398   bfd_size_type reloc_size;
399   PTR relocs;
400   arelent *reloc_cache;
401   size_t each_size;
402
403   if (asect->relocation)
404     return TRUE;
405
406   if (asect->flags & SEC_CONSTRUCTOR)
407     return TRUE;
408
409   if (asect == obj_datasec (abfd))
410     {
411       reloc_size = exec_hdr (abfd)->a_drsize;
412       goto doit;
413     }
414
415   if (asect == obj_textsec (abfd))
416     {
417       reloc_size = exec_hdr (abfd)->a_trsize;
418       goto doit;
419     }
420
421   bfd_set_error (bfd_error_invalid_operation);
422   return FALSE;
423
424 doit:
425   if (bfd_seek (abfd, asect->rel_filepos, SEEK_SET) != 0)
426     return FALSE;
427   each_size = obj_reloc_entry_size (abfd);
428
429   count = reloc_size / each_size;
430
431
432   reloc_cache = (arelent *) bfd_zmalloc (count * sizeof (arelent));
433   if (!reloc_cache && count != 0)
434     return FALSE;
435
436   relocs = (PTR) bfd_alloc (abfd, reloc_size);
437   if (!relocs && reloc_size != 0)
438     {
439       free (reloc_cache);
440       return FALSE;
441     }
442
443   if (bfd_bread (relocs, reloc_size, abfd) != reloc_size)
444     {
445       bfd_release (abfd, relocs);
446       free (reloc_cache);
447       return FALSE;
448     }
449
450   if (each_size == RELOC_EXT_SIZE)
451     {
452       register struct reloc_ext_external *rptr = (struct reloc_ext_external *) relocs;
453       unsigned int counter = 0;
454       arelent *cache_ptr = reloc_cache;
455
456       for (; counter < count; counter++, rptr++, cache_ptr++)
457         {
458           NAME(lynx,swap_ext_reloc_in) (abfd, rptr, cache_ptr, symbols,
459                                         (bfd_size_type) bfd_get_symcount (abfd));
460         }
461     }
462   else
463     {
464       register struct reloc_std_external *rptr = (struct reloc_std_external *) relocs;
465       unsigned int counter = 0;
466       arelent *cache_ptr = reloc_cache;
467
468       for (; counter < count; counter++, rptr++, cache_ptr++)
469         {
470           NAME(lynx,swap_std_reloc_in) (abfd, rptr, cache_ptr, symbols,
471                                         (bfd_size_type) bfd_get_symcount (abfd));
472         }
473
474     }
475
476   bfd_release (abfd, relocs);
477   asect->relocation = reloc_cache;
478   asect->reloc_count = count;
479   return TRUE;
480 }
481
482
483
484 /* Write out a relocation section into an object file.  */
485
486 bfd_boolean
487 NAME(lynx,squirt_out_relocs) (abfd, section)
488      bfd *abfd;
489      asection *section;
490 {
491   arelent **generic;
492   unsigned char *native, *natptr;
493   size_t each_size;
494
495   unsigned int count = section->reloc_count;
496   bfd_size_type natsize;
497
498   if (count == 0)
499     return TRUE;
500
501   each_size = obj_reloc_entry_size (abfd);
502   natsize = count;
503   natsize *= each_size;
504   native = (unsigned char *) bfd_zalloc (abfd, natsize);
505   if (!native)
506     return FALSE;
507
508   generic = section->orelocation;
509
510   if (each_size == RELOC_EXT_SIZE)
511     {
512       for (natptr = native;
513            count != 0;
514            --count, natptr += each_size, ++generic)
515         NAME(lynx,swap_ext_reloc_out) (abfd, *generic, (struct reloc_ext_external *) natptr);
516     }
517   else
518     {
519       for (natptr = native;
520            count != 0;
521            --count, natptr += each_size, ++generic)
522         NAME(lynx,swap_std_reloc_out) (abfd, *generic, (struct reloc_std_external *) natptr);
523     }
524
525   if (bfd_bwrite ((PTR) native, natsize, abfd) != natsize)
526     {
527       bfd_release (abfd, native);
528       return FALSE;
529     }
530   bfd_release (abfd, native);
531
532   return TRUE;
533 }
534
535 /* This is stupid.  This function should be a boolean predicate */
536 long
537 NAME(lynx,canonicalize_reloc) (abfd, section, relptr, symbols)
538      bfd *abfd;
539      sec_ptr section;
540      arelent **relptr;
541      asymbol **symbols;
542 {
543   arelent *tblptr = section->relocation;
544   unsigned int count;
545
546   if (!(tblptr || NAME(lynx,slurp_reloc_table) (abfd, section, symbols)))
547     return -1;
548
549   if (section->flags & SEC_CONSTRUCTOR)
550     {
551       arelent_chain *chain = section->constructor_chain;
552       for (count = 0; count < section->reloc_count; count++)
553         {
554           *relptr++ = &chain->relent;
555           chain = chain->next;
556         }
557     }
558   else
559     {
560       tblptr = section->relocation;
561
562       for (count = 0; count++ < section->reloc_count;)
563         {
564           *relptr++ = tblptr++;
565         }
566     }
567   *relptr = 0;
568
569   return section->reloc_count;
570 }
571
572 #define MY_canonicalize_reloc NAME(lynx,canonicalize_reloc)
573
574 #include "aout-target.h"