OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-6.8/] [bfd/] [i386linux.c] - Blame information for rev 294

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 24 jeremybenn
/* BFD back-end for linux flavored i386 a.out binaries.
2
   Copyright 1992, 1993, 1994, 1995, 1996, 1997, 1999, 2001, 2002, 2003,
3 225 jeremybenn
   2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
4 24 jeremybenn
 
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 TARGET_PAGE_SIZE        4096
23
#define ZMAGIC_DISK_BLOCK_SIZE 1024
24
#define SEGMENT_SIZE TARGET_PAGE_SIZE
25
#define TEXT_START_ADDR 0x0
26
#define N_SHARED_LIB(x) 0
27
 
28
#define MACHTYPE_OK(mtype) ((mtype) == M_386 || (mtype) == M_UNKNOWN)
29
 
30
#include "sysdep.h"
31
#include "bfd.h"
32
#include "libbfd.h"
33
#include "aout/aout64.h"
34
#include "aout/stab_gnu.h"
35
#include "aout/ar.h"
36
#include "libaout.h"           /* BFD a.out internal data structures */
37
 
38
#define DEFAULT_ARCH bfd_arch_i386
39
 
40
/* Do not "beautify" the CONCAT* macro args.  Traditional C will not
41
   remove whitespace added here, and thus will fail to concatenate
42
   the tokens.  */
43
#define MY(OP) CONCAT2 (i386linux_,OP)
44
#define TARGETNAME "a.out-i386-linux"
45
 
46
extern const bfd_target MY(vec);
47
 
48
/* We always generate QMAGIC files in preference to ZMAGIC files.  It
49
   would be possible to make this a linker option, if that ever
50
   becomes important.  */
51
 
52
static void MY_final_link_callback
53
  PARAMS ((bfd *, file_ptr *, file_ptr *, file_ptr *));
54
static bfd_boolean i386linux_bfd_final_link
55
  PARAMS ((bfd *, struct bfd_link_info *));
56
static bfd_boolean i386linux_write_object_contents PARAMS ((bfd *));
57
 
58
static bfd_boolean
59
i386linux_bfd_final_link (abfd, info)
60
     bfd *abfd;
61
     struct bfd_link_info *info;
62
{
63
  obj_aout_subformat (abfd) = q_magic_format;
64
  return NAME(aout,final_link) (abfd, info, MY_final_link_callback);
65
}
66
 
67
#define MY_bfd_final_link i386linux_bfd_final_link
68
 
69
/* Set the machine type correctly.  */
70
 
71
static bfd_boolean
72
i386linux_write_object_contents (abfd)
73
     bfd *abfd;
74
{
75
  struct external_exec exec_bytes;
76
  struct internal_exec *execp = exec_hdr (abfd);
77
 
78
  N_SET_MACHTYPE (*execp, M_386);
79
 
80
  obj_reloc_entry_size (abfd) = RELOC_STD_SIZE;
81
 
82
  WRITE_HEADERS(abfd, execp);
83
 
84
  return TRUE;
85
}
86
 
87
#define MY_write_object_contents i386linux_write_object_contents
88
 
89
/* Code to link against Linux a.out shared libraries.  */
90
 
91
/* See if a symbol name is a reference to the global offset table.  */
92
 
93
#ifndef GOT_REF_PREFIX
94
#define GOT_REF_PREFIX  "__GOT_"
95
#endif
96
 
97
#define IS_GOT_SYM(name)   (CONST_STRNEQ (name, GOT_REF_PREFIX))
98
 
99
/* See if a symbol name is a reference to the procedure linkage table.  */
100
 
101
#ifndef PLT_REF_PREFIX
102
#define PLT_REF_PREFIX  "__PLT_"
103
#endif
104
 
105
#define IS_PLT_SYM(name)  (CONST_STRNEQ (name, PLT_REF_PREFIX))
106
 
107
/* This string is used to generate specialized error messages.  */
108
 
109
#ifndef NEEDS_SHRLIB
110
#define NEEDS_SHRLIB "__NEEDS_SHRLIB_"
111
#endif
112
 
113
/* This special symbol is a set vector that contains a list of
114
   pointers to fixup tables.  It will be present in any dynamically
115
   linked file.  The linker generated fixup table should also be added
116
   to the list, and it should always appear in the second slot (the
117
   first one is a dummy with a magic number that is defined in
118
   crt0.o).  */
119
 
120
#ifndef SHARABLE_CONFLICTS
121
#define SHARABLE_CONFLICTS "__SHARABLE_CONFLICTS__"
122
#endif
123
 
124
/* We keep a list of fixups.  The terminology is a bit strange, but
125
   each fixup contains two 32 bit numbers.  A regular fixup contains
126
   an address and a pointer, and at runtime we should store the
127
   address at the location pointed to by the pointer.  A builtin fixup
128
   contains two pointers, and we should read the address using one
129
   pointer and store it at the location pointed to by the other
130
   pointer.  Builtin fixups come into play when we have duplicate
131
   __GOT__ symbols for the same variable.  The builtin fixup will copy
132
   the GOT pointer from one over into the other.  */
133
 
134
struct fixup
135
{
136
  struct fixup *next;
137
  struct linux_link_hash_entry *h;
138
  bfd_vma value;
139
 
140
  /* Nonzero if this is a jump instruction that needs to be fixed,
141
     zero if this is just a pointer */
142
  char jump;
143
 
144
  char builtin;
145
};
146
 
147
/* We don't need a special hash table entry structure, but we do need
148
   to keep some information between linker passes, so we use a special
149
   hash table.  */
150
 
151
struct linux_link_hash_entry
152
{
153
  struct aout_link_hash_entry root;
154
};
155
 
156
struct linux_link_hash_table
157
{
158
  struct aout_link_hash_table root;
159
 
160
  /* First dynamic object found in link.  */
161
  bfd *dynobj;
162
 
163
  /* Number of fixups.  */
164
  size_t fixup_count;
165
 
166
  /* Number of builtin fixups.  */
167
  size_t local_builtins;
168
 
169
  /* List of fixups.  */
170
  struct fixup *fixup_list;
171
};
172
 
173
static struct bfd_hash_entry *linux_link_hash_newfunc
174
  PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
175
static struct bfd_link_hash_table *linux_link_hash_table_create
176
  PARAMS ((bfd *));
177
static struct fixup *new_fixup
178
  PARAMS ((struct bfd_link_info *, struct linux_link_hash_entry *,
179
           bfd_vma, int));
180
static bfd_boolean linux_link_create_dynamic_sections
181
  PARAMS ((bfd *, struct bfd_link_info *));
182
static bfd_boolean linux_add_one_symbol
183
  PARAMS ((struct bfd_link_info *, bfd *, const char *, flagword, asection *,
184
           bfd_vma, const char *, bfd_boolean, bfd_boolean,
185
           struct bfd_link_hash_entry **));
186
static bfd_boolean linux_tally_symbols
187
  PARAMS ((struct linux_link_hash_entry *, PTR));
188
static bfd_boolean linux_finish_dynamic_link
189
  PARAMS ((bfd *, struct bfd_link_info *));
190
 
191
/* Routine to create an entry in an Linux link hash table.  */
192
 
193
static struct bfd_hash_entry *
194
linux_link_hash_newfunc (entry, table, string)
195
     struct bfd_hash_entry *entry;
196
     struct bfd_hash_table *table;
197
     const char *string;
198
{
199
  struct linux_link_hash_entry *ret = (struct linux_link_hash_entry *) entry;
200
 
201
  /* Allocate the structure if it has not already been allocated by a
202
     subclass.  */
203
  if (ret == (struct linux_link_hash_entry *) NULL)
204
    ret = ((struct linux_link_hash_entry *)
205
           bfd_hash_allocate (table, sizeof (struct linux_link_hash_entry)));
206
  if (ret == NULL)
207
    return (struct bfd_hash_entry *) ret;
208
 
209
  /* Call the allocation method of the superclass.  */
210
  ret = ((struct linux_link_hash_entry *)
211
         NAME(aout,link_hash_newfunc) ((struct bfd_hash_entry *) ret,
212
                                       table, string));
213
  if (ret != NULL)
214
    {
215
      /* Set local fields; there aren't any.  */
216
    }
217
 
218
  return (struct bfd_hash_entry *) ret;
219
}
220
 
221
/* Create a Linux link hash table.  */
222
 
223
static struct bfd_link_hash_table *
224
linux_link_hash_table_create (abfd)
225
     bfd *abfd;
226
{
227
  struct linux_link_hash_table *ret;
228
  bfd_size_type amt = sizeof (struct linux_link_hash_table);
229
 
230
  ret = (struct linux_link_hash_table *) bfd_alloc (abfd, amt);
231
  if (ret == (struct linux_link_hash_table *) NULL)
232
    return (struct bfd_link_hash_table *) NULL;
233
  if (!NAME(aout,link_hash_table_init) (&ret->root, abfd,
234
                                        linux_link_hash_newfunc,
235
                                        sizeof (struct linux_link_hash_entry)))
236
    {
237
      free (ret);
238
      return (struct bfd_link_hash_table *) NULL;
239
    }
240
 
241
  ret->dynobj = NULL;
242
  ret->fixup_count = 0;
243
  ret->local_builtins = 0;
244
  ret->fixup_list = NULL;
245
 
246
  return &ret->root.root;
247
}
248
 
249
/* Look up an entry in a Linux link hash table.  */
250
 
251
#define linux_link_hash_lookup(table, string, create, copy, follow) \
252
  ((struct linux_link_hash_entry *) \
253
   aout_link_hash_lookup (&(table)->root, (string), (create), (copy),\
254
                          (follow)))
255
 
256
/* Traverse a Linux link hash table.  */
257
 
258
#define linux_link_hash_traverse(table, func, info)                     \
259
  (aout_link_hash_traverse                                              \
260
   (&(table)->root,                                                     \
261
    (bfd_boolean (*) PARAMS ((struct aout_link_hash_entry *, PTR))) (func), \
262
    (info)))
263
 
264
/* Get the Linux link hash table from the info structure.  This is
265
   just a cast.  */
266
 
267
#define linux_hash_table(p) ((struct linux_link_hash_table *) ((p)->hash))
268
 
269
/* Store the information for a new fixup.  */
270
 
271
static struct fixup *
272
new_fixup (info, h, value, builtin)
273
     struct bfd_link_info *info;
274
     struct linux_link_hash_entry *h;
275
     bfd_vma value;
276
     int builtin;
277
{
278
  struct fixup *f;
279
 
280
  f = (struct fixup *) bfd_hash_allocate (&info->hash->table,
281
                                          sizeof (struct fixup));
282
  if (f == NULL)
283
    return f;
284
  f->next = linux_hash_table (info)->fixup_list;
285
  linux_hash_table (info)->fixup_list = f;
286
  f->h = h;
287
  f->value = value;
288
  f->builtin = builtin;
289
  f->jump = 0;
290
  ++linux_hash_table (info)->fixup_count;
291
  return f;
292
}
293
 
294
/* We come here once we realize that we are going to link to a shared
295
   library.  We need to create a special section that contains the
296
   fixup table, and we ultimately need to add a pointer to this into
297
   the set vector for SHARABLE_CONFLICTS.  At this point we do not
298
   know the size of the section, but that's OK - we just need to
299
   create it for now.  */
300
 
301
static bfd_boolean
302
linux_link_create_dynamic_sections (abfd, info)
303
     bfd *abfd;
304
     struct bfd_link_info *info ATTRIBUTE_UNUSED;
305
{
306
  flagword flags;
307
  register asection *s;
308
 
309
  /* Note that we set the SEC_IN_MEMORY flag.  */
310
  flags = SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY;
311
 
312
  /* We choose to use the name ".linux-dynamic" for the fixup table.
313
     Why not? */
314
  s = bfd_make_section_with_flags (abfd, ".linux-dynamic", flags);
315
  if (s == NULL
316
      || ! bfd_set_section_alignment (abfd, s, 2))
317
    return FALSE;
318
  s->size = 0;
319
  s->contents = 0;
320
 
321
  return TRUE;
322
}
323
 
324
/* Function to add a single symbol to the linker hash table.  This is
325
   a wrapper around _bfd_generic_link_add_one_symbol which handles the
326
   tweaking needed for dynamic linking support.  */
327
 
328
static bfd_boolean
329
linux_add_one_symbol (info, abfd, name, flags, section, value, string,
330
                      copy, collect, hashp)
331
     struct bfd_link_info *info;
332
     bfd *abfd;
333
     const char *name;
334
     flagword flags;
335
     asection *section;
336
     bfd_vma value;
337
     const char *string;
338
     bfd_boolean copy;
339
     bfd_boolean collect;
340
     struct bfd_link_hash_entry **hashp;
341
{
342
  struct linux_link_hash_entry *h;
343
  bfd_boolean insert;
344
 
345
  /* Look up and see if we already have this symbol in the hash table.
346
     If we do, and the defining entry is from a shared library, we
347
     need to create the dynamic sections.
348
 
349
     FIXME: What if abfd->xvec != info->output_bfd->xvec?  We may
350
     want to be able to link Linux a.out and ELF objects together,
351
     but serious confusion is possible.  */
352
 
353
  insert = FALSE;
354
 
355
  if (! info->relocatable
356
      && linux_hash_table (info)->dynobj == NULL
357
      && strcmp (name, SHARABLE_CONFLICTS) == 0
358
      && (flags & BSF_CONSTRUCTOR) != 0
359
      && abfd->xvec == info->output_bfd->xvec)
360
    {
361
      if (! linux_link_create_dynamic_sections (abfd, info))
362
        return FALSE;
363
      linux_hash_table (info)->dynobj = abfd;
364
      insert = TRUE;
365
    }
366
 
367
  if (bfd_is_abs_section (section)
368
      && abfd->xvec == info->output_bfd->xvec)
369
    {
370
      h = linux_link_hash_lookup (linux_hash_table (info), name, FALSE,
371
                                  FALSE, FALSE);
372
      if (h != NULL
373
          && (h->root.root.type == bfd_link_hash_defined
374
              || h->root.root.type == bfd_link_hash_defweak))
375
        {
376
          struct fixup *f;
377
 
378
          if (hashp != NULL)
379
            *hashp = (struct bfd_link_hash_entry *) h;
380
 
381
          f = new_fixup (info, h, value, ! IS_PLT_SYM (name));
382
          if (f == NULL)
383
            return FALSE;
384
          f->jump = IS_PLT_SYM (name);
385
 
386
          return TRUE;
387
        }
388
    }
389
 
390
  /* Do the usual procedure for adding a symbol.  */
391
  if (! _bfd_generic_link_add_one_symbol (info, abfd, name, flags, section,
392
                                          value, string, copy, collect,
393
                                          hashp))
394
    return FALSE;
395
 
396
  /* Insert a pointer to our table in the set vector.  The dynamic
397
     linker requires this information */
398
  if (insert)
399
    {
400
      asection *s;
401
 
402
      /* Here we do our special thing to add the pointer to the
403
         dynamic section in the SHARABLE_CONFLICTS set vector.  */
404
      s = bfd_get_section_by_name (linux_hash_table (info)->dynobj,
405
                                   ".linux-dynamic");
406
      BFD_ASSERT (s != NULL);
407
 
408
      if (! (_bfd_generic_link_add_one_symbol
409
             (info, linux_hash_table (info)->dynobj, SHARABLE_CONFLICTS,
410
              BSF_GLOBAL | BSF_CONSTRUCTOR, s, (bfd_vma) 0, NULL,
411
              FALSE, FALSE, NULL)))
412
        return FALSE;
413
    }
414
 
415
  return TRUE;
416
}
417
 
418
/* We will crawl the hash table and come here for every global symbol.
419
   We will examine each entry and see if there are indications that we
420
   need to add a fixup.  There are two possible cases - one is where
421
   you have duplicate definitions of PLT or GOT symbols - these will
422
   have already been caught and added as "builtin" fixups.  If we find
423
   that the corresponding non PLT/GOT symbol is also present, we
424
   convert it to a regular fixup instead.
425
 
426
   This function is called via linux_link_hash_traverse.  */
427
 
428
static bfd_boolean
429
linux_tally_symbols (h, data)
430
     struct linux_link_hash_entry *h;
431
     PTR data;
432
{
433
  struct bfd_link_info *info = (struct bfd_link_info *) data;
434
  struct fixup *f, *f1;
435
  int is_plt;
436
  struct linux_link_hash_entry *h1, *h2;
437
  bfd_boolean exists;
438
 
439
  if (h->root.root.type == bfd_link_hash_warning)
440
    h = (struct linux_link_hash_entry *) h->root.root.u.i.link;
441
 
442
  if (h->root.root.type == bfd_link_hash_undefined
443
      && CONST_STRNEQ (h->root.root.root.string, NEEDS_SHRLIB))
444
    {
445
      const char *name;
446
      char *p;
447
      char *alloc = NULL;
448
 
449
      name = h->root.root.root.string + sizeof NEEDS_SHRLIB - 1;
450
      p = strrchr (name, '_');
451
      if (p != NULL)
452
        alloc = (char *) bfd_malloc ((bfd_size_type) strlen (name) + 1);
453
 
454
      if (p == NULL || alloc == NULL)
455
        (*_bfd_error_handler) (_("Output file requires shared library `%s'\n"),
456
                               name);
457
      else
458
        {
459
          strcpy (alloc, name);
460
          p = strrchr (alloc, '_');
461
          *p++ = '\0';
462
          (*_bfd_error_handler)
463
            (_("Output file requires shared library `%s.so.%s'\n"),
464
             alloc, p);
465
          free (alloc);
466
        }
467
 
468
      abort ();
469
    }
470
 
471
  /* If this symbol is not a PLT/GOT, we do not even need to look at it */
472
  is_plt = IS_PLT_SYM (h->root.root.root.string);
473
 
474
  if (is_plt || IS_GOT_SYM (h->root.root.root.string))
475
    {
476
      /* Look up this symbol twice.  Once just as a regular lookup,
477
         and then again following all of the indirect links until we
478
         reach a real symbol.  */
479
      h1 = linux_link_hash_lookup (linux_hash_table (info),
480
                                   (h->root.root.root.string
481
                                    + sizeof PLT_REF_PREFIX - 1),
482
                                   FALSE, FALSE, TRUE);
483
      /* h2 does not follow indirect symbols. */
484
      h2 = linux_link_hash_lookup (linux_hash_table (info),
485
                                   (h->root.root.root.string
486
                                    + sizeof PLT_REF_PREFIX - 1),
487
                                   FALSE, FALSE, FALSE);
488
 
489
      /* The real symbol must exist but if it is also an ABS symbol,
490
         there is no need to have a fixup.  This is because they both
491
         came from the same library.  If on the other hand, we had to
492
         use an indirect symbol to get to the real symbol, we add the
493
         fixup anyway, since there are cases where these symbols come
494
         from different shared libraries */
495
      if (h1 != NULL
496
          && (((h1->root.root.type == bfd_link_hash_defined
497
                || h1->root.root.type == bfd_link_hash_defweak)
498
               && ! bfd_is_abs_section (h1->root.root.u.def.section))
499
              || h2->root.root.type == bfd_link_hash_indirect))
500
        {
501
          /* See if there is a "builtin" fixup already present
502
             involving this symbol.  If so, convert it to a regular
503
             fixup.  In the end, this relaxes some of the requirements
504
             about the order of performing fixups.  */
505
          exists = FALSE;
506
          for (f1 = linux_hash_table (info)->fixup_list;
507
               f1 != NULL;
508
               f1 = f1->next)
509
            {
510
              if ((f1->h != h && f1->h != h1)
511
                  || (! f1->builtin && ! f1->jump))
512
                continue;
513
              if (f1->h == h1)
514
                exists = TRUE;
515
              if (! exists
516
                  && bfd_is_abs_section (h->root.root.u.def.section))
517
                {
518
                  f = new_fixup (info, h1, f1->h->root.root.u.def.value, 0);
519
                  f->jump = is_plt;
520
                }
521
              f1->h = h1;
522
              f1->jump = is_plt;
523
              f1->builtin = 0;
524
              exists = TRUE;
525
            }
526
          if (! exists
527
              && bfd_is_abs_section (h->root.root.u.def.section))
528
            {
529
              f = new_fixup (info, h1, h->root.root.u.def.value, 0);
530
              if (f == NULL)
531
                {
532
                  /* FIXME: No way to return error.  */
533
                  abort ();
534
                }
535
              f->jump = is_plt;
536
            }
537
        }
538
 
539
      /* Quick and dirty way of stripping these symbols from the
540
         symtab. */
541
      if (bfd_is_abs_section (h->root.root.u.def.section))
542
        h->root.written = TRUE;
543
    }
544
 
545
  return TRUE;
546
}
547
 
548
/* This is called to set the size of the .linux-dynamic section is.
549
   It is called by the Linux linker emulation before_allocation
550
   routine.  We have finished reading all of the input files, and now
551
   we just scan the hash tables to find out how many additional fixups
552
   are required.  */
553
 
554
bfd_boolean
555
bfd_i386linux_size_dynamic_sections (output_bfd, info)
556
     bfd *output_bfd;
557
     struct bfd_link_info *info;
558
{
559
  struct fixup *f;
560
  asection *s;
561
 
562
  if (output_bfd->xvec != &MY(vec))
563
    return TRUE;
564
 
565
  /* First find the fixups... */
566
  linux_link_hash_traverse (linux_hash_table (info),
567
                            linux_tally_symbols,
568
                            (PTR) info);
569
 
570
  /* If there are builtin fixups, leave room for a marker.  This is
571
     used by the dynamic linker so that it knows that all that follow
572
     are builtin fixups instead of regular fixups.  */
573
  for (f = linux_hash_table (info)->fixup_list; f != NULL; f = f->next)
574
    {
575
      if (f->builtin)
576
        {
577
          ++linux_hash_table (info)->fixup_count;
578
          ++linux_hash_table (info)->local_builtins;
579
          break;
580
        }
581
    }
582
 
583
  if (linux_hash_table (info)->dynobj == NULL)
584
    {
585
      if (linux_hash_table (info)->fixup_count > 0)
586
        abort ();
587
      return TRUE;
588
    }
589
 
590
  /* Allocate memory for our fixup table.  We will fill it in later.  */
591
  s = bfd_get_section_by_name (linux_hash_table (info)->dynobj,
592
                               ".linux-dynamic");
593
  if (s != NULL)
594
    {
595
      s->size = linux_hash_table (info)->fixup_count + 1;
596
      s->size *= 8;
597
      s->contents = (bfd_byte *) bfd_zalloc (output_bfd, s->size);
598
      if (s->contents == NULL)
599
        return FALSE;
600
    }
601
 
602
  return TRUE;
603
}
604
 
605
/* We come here once we are ready to actually write the fixup table to
606
   the output file.  Scan the fixup tables and so forth and generate
607
   the stuff we need.  */
608
 
609
static bfd_boolean
610
linux_finish_dynamic_link (output_bfd, info)
611
     bfd *output_bfd;
612
     struct bfd_link_info *info;
613
{
614
  asection *s, *os, *is;
615
  bfd_byte *fixup_table;
616
  struct linux_link_hash_entry *h;
617
  struct fixup *f;
618
  unsigned int new_addr;
619
  int section_offset;
620
  unsigned int fixups_written;
621
 
622
  if (linux_hash_table (info)->dynobj == NULL)
623
    return TRUE;
624
 
625
  s = bfd_get_section_by_name (linux_hash_table (info)->dynobj,
626
                               ".linux-dynamic");
627
  BFD_ASSERT (s != NULL);
628
  os = s->output_section;
629
  fixups_written = 0;
630
 
631
#ifdef LINUX_LINK_DEBUG
632
  printf ("Fixup table file offset: %x  VMA: %x\n",
633
          os->filepos + s->output_offset,
634
          os->vma + s->output_offset);
635
#endif
636
 
637
  fixup_table = s->contents;
638
  bfd_put_32 (output_bfd,
639
              (bfd_vma) linux_hash_table (info)->fixup_count, fixup_table);
640
  fixup_table += 4;
641
 
642
  /* Fill in fixup table.  */
643
  for (f = linux_hash_table (info)->fixup_list; f != NULL; f = f->next)
644
    {
645
      if (f->builtin)
646
        continue;
647
 
648
      if (f->h->root.root.type != bfd_link_hash_defined
649
          && f->h->root.root.type != bfd_link_hash_defweak)
650
        {
651
          (*_bfd_error_handler)
652
            (_("Symbol %s not defined for fixups\n"),
653
             f->h->root.root.root.string);
654
          continue;
655
        }
656
 
657
      is = f->h->root.root.u.def.section;
658
      section_offset = is->output_section->vma + is->output_offset;
659
      new_addr = f->h->root.root.u.def.value + section_offset;
660
 
661
#ifdef LINUX_LINK_DEBUG
662
      printf ("Fixup(%d) %s: %x %x\n",f->jump, f->h->root.root.string,
663
              new_addr, f->value);
664
#endif
665
 
666
      if (f->jump)
667
        {
668
          /* Relative address */
669
          new_addr = new_addr - (f->value + 5);
670
          bfd_put_32 (output_bfd, (bfd_vma) new_addr, fixup_table);
671
          fixup_table += 4;
672
          bfd_put_32 (output_bfd, f->value + 1, fixup_table);
673
          fixup_table += 4;
674
        }
675
      else
676
        {
677
          bfd_put_32 (output_bfd, (bfd_vma) new_addr, fixup_table);
678
          fixup_table += 4;
679
          bfd_put_32 (output_bfd, f->value, fixup_table);
680
          fixup_table += 4;
681
        }
682
      ++fixups_written;
683
    }
684
 
685
  if (linux_hash_table (info)->local_builtins != 0)
686
    {
687
      /* Special marker so we know to switch to the other type of fixup */
688
      bfd_put_32 (output_bfd, (bfd_vma) 0, fixup_table);
689
      fixup_table += 4;
690
      bfd_put_32 (output_bfd, (bfd_vma) 0, fixup_table);
691
      fixup_table += 4;
692
      ++fixups_written;
693
      for (f = linux_hash_table (info)->fixup_list; f != NULL; f = f->next)
694
        {
695
          if (! f->builtin)
696
            continue;
697
 
698
          if (f->h->root.root.type != bfd_link_hash_defined
699
              && f->h->root.root.type != bfd_link_hash_defweak)
700
            {
701
              (*_bfd_error_handler)
702
                (_("Symbol %s not defined for fixups\n"),
703
                 f->h->root.root.root.string);
704
              continue;
705
            }
706
 
707
          is = f->h->root.root.u.def.section;
708
          section_offset = is->output_section->vma + is->output_offset;
709
          new_addr = f->h->root.root.u.def.value + section_offset;
710
 
711
#ifdef LINUX_LINK_DEBUG
712
          printf ("Fixup(B) %s: %x %x\n", f->h->root.root.string,
713
                  new_addr, f->value);
714
#endif
715
 
716
          bfd_put_32 (output_bfd, (bfd_vma) new_addr, fixup_table);
717
          fixup_table += 4;
718
          bfd_put_32 (output_bfd, f->value, fixup_table);
719
          fixup_table += 4;
720
          ++fixups_written;
721
        }
722
  }
723
 
724
  if (linux_hash_table (info)->fixup_count != fixups_written)
725
    {
726
      (*_bfd_error_handler) (_("Warning: fixup count mismatch\n"));
727
      while (linux_hash_table (info)->fixup_count > fixups_written)
728
        {
729
          bfd_put_32 (output_bfd, (bfd_vma) 0, fixup_table);
730
          fixup_table += 4;
731
          bfd_put_32 (output_bfd, (bfd_vma) 0, fixup_table);
732
          fixup_table += 4;
733
          ++fixups_written;
734
        }
735
    }
736
 
737
  h = linux_link_hash_lookup (linux_hash_table (info),
738
                              "__BUILTIN_FIXUPS__",
739
                              FALSE, FALSE, FALSE);
740
 
741
  if (h != NULL
742
      && (h->root.root.type == bfd_link_hash_defined
743
          || h->root.root.type == bfd_link_hash_defweak))
744
    {
745
      is = h->root.root.u.def.section;
746
      section_offset = is->output_section->vma + is->output_offset;
747
      new_addr = h->root.root.u.def.value + section_offset;
748
 
749
#ifdef LINUX_LINK_DEBUG
750
      printf ("Builtin fixup table at %x\n", new_addr);
751
#endif
752
 
753
      bfd_put_32 (output_bfd, (bfd_vma) new_addr, fixup_table);
754
    }
755
  else
756
    bfd_put_32 (output_bfd, (bfd_vma) 0, fixup_table);
757
 
758
  if (bfd_seek (output_bfd, (file_ptr) (os->filepos + s->output_offset),
759
                SEEK_SET) != 0)
760
    return FALSE;
761
 
762
  if (bfd_bwrite ((PTR) s->contents, s->size, output_bfd) != s->size)
763
    return FALSE;
764
 
765
  return TRUE;
766
}
767
 
768
#define MY_bfd_link_hash_table_create linux_link_hash_table_create
769
#define MY_add_one_symbol linux_add_one_symbol
770
#define MY_finish_dynamic_link linux_finish_dynamic_link
771
 
772
#define MY_zmagic_contiguous 1
773
 
774
#include "aout-target.h"

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.