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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gdb-6.8/] [bfd/] [sparclinux.c] - Blame information for rev 827

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 sparc a.out binaries.
2
   Copyright 1992, 1993, 1994, 1995, 1996, 1997, 1999, 2000, 2001, 2002,
3 225 jeremybenn
   2003, 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_SPARC || (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_sparc
39
/* Do not "beautify" the CONCAT* macro args.  Traditional C will not
40
   remove whitespace added here, and thus will fail to concatenate
41
   the tokens.  */
42
#define MY(OP) CONCAT2 (sparclinux_,OP)
43
#define TARGETNAME "a.out-sparc-linux"
44
 
45
extern const bfd_target MY(vec);
46
 
47
/* We always generate QMAGIC files in preference to ZMAGIC files.  It
48
   would be possible to make this a linker option, if that ever
49
   becomes important.  */
50
 
51
static void MY_final_link_callback
52
  PARAMS ((bfd *, file_ptr *, file_ptr *, file_ptr *));
53
 
54
static bfd_boolean sparclinux_bfd_final_link
55
  PARAMS ((bfd *abfd, struct bfd_link_info *info));
56
 
57
static bfd_boolean
58
sparclinux_bfd_final_link (abfd, info)
59
     bfd *abfd;
60
     struct bfd_link_info *info;
61
{
62
  obj_aout_subformat (abfd) = q_magic_format;
63
  return NAME(aout,final_link) (abfd, info, MY_final_link_callback);
64
}
65
 
66
#define MY_bfd_final_link sparclinux_bfd_final_link
67
 
68
/* Set the machine type correctly.  */
69
 
70
static bfd_boolean sparclinux_write_object_contents PARAMS ((bfd *abfd));
71
 
72
static bfd_boolean
73
sparclinux_write_object_contents (abfd)
74
     bfd *abfd;
75
{
76
  struct external_exec exec_bytes;
77
  struct internal_exec *execp = exec_hdr (abfd);
78
 
79
  N_SET_MACHTYPE (*execp, M_SPARC);
80
 
81
  obj_reloc_entry_size (abfd) = RELOC_STD_SIZE;
82
 
83
  WRITE_HEADERS(abfd, execp);
84
 
85
  return TRUE;
86
}
87
 
88
#define MY_write_object_contents sparclinux_write_object_contents
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_malloc (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 (struct linux_link_hash_entry *h, void * data)
430
{
431
  struct bfd_link_info *info = (struct bfd_link_info *) data;
432
  struct fixup *f, *f1;
433
  int is_plt;
434
  struct linux_link_hash_entry *h1, *h2;
435
  bfd_boolean exists;
436
 
437
  if (h->root.root.type == bfd_link_hash_warning)
438
    h = (struct linux_link_hash_entry *) h->root.root.u.i.link;
439
 
440
  if (h->root.root.type == bfd_link_hash_undefined
441
      && CONST_STRNEQ (h->root.root.root.string, NEEDS_SHRLIB))
442
    {
443
      const char *name;
444
      char *p;
445
      char *alloc = NULL;
446
 
447
      name = h->root.root.root.string + sizeof NEEDS_SHRLIB - 1;
448
      p = strrchr (name, '_');
449
      if (p != NULL)
450
        alloc = (char *) bfd_malloc ((bfd_size_type) strlen (name) + 1);
451
 
452
      if (p == NULL || alloc == NULL)
453
        (*_bfd_error_handler) (_("Output file requires shared library `%s'\n"),
454
                               name);
455
      else
456
        {
457
          strcpy (alloc, name);
458
          p = strrchr (alloc, '_');
459
          *p++ = '\0';
460
          (*_bfd_error_handler)
461
            (_("Output file requires shared library `%s.so.%s'\n"),
462
             alloc, p);
463
          free (alloc);
464
        }
465
 
466
      abort ();
467
    }
468
 
469
  /* If this symbol is not a PLT/GOT, we do not even need to look at
470
     it.  */
471
  is_plt = IS_PLT_SYM (h->root.root.root.string);
472
 
473
  if (is_plt || IS_GOT_SYM (h->root.root.root.string))
474
    {
475
      /* Look up this symbol twice.  Once just as a regular lookup,
476
         and then again following all of the indirect links until we
477
         reach a real symbol.  */
478
      h1 = linux_link_hash_lookup (linux_hash_table (info),
479
                                   (h->root.root.root.string
480
                                    + sizeof PLT_REF_PREFIX - 1),
481
                                   FALSE, FALSE, TRUE);
482
      /* h2 does not follow indirect symbols.  */
483
      h2 = linux_link_hash_lookup (linux_hash_table (info),
484
                                   (h->root.root.root.string
485
                                    + sizeof PLT_REF_PREFIX - 1),
486
                                   FALSE, FALSE, FALSE);
487
 
488
      /* The real symbol must exist but if it is also an ABS symbol,
489
         there is no need to have a fixup.  This is because they both
490
         came from the same library.  If on the other hand, we had to
491
         use an indirect symbol to get to the real symbol, we add the
492
         fixup anyway, since there are cases where these symbols come
493
         from different shared libraries */
494
      if (h1 != NULL
495
          && (((h1->root.root.type == bfd_link_hash_defined
496
                || h1->root.root.type == bfd_link_hash_defweak)
497
               && ! bfd_is_abs_section (h1->root.root.u.def.section))
498
              || h2->root.root.type == bfd_link_hash_indirect))
499
        {
500
          /* See if there is a "builtin" fixup already present
501
             involving this symbol.  If so, convert it to a regular
502
             fixup.  In the end, this relaxes some of the requirements
503
             about the order of performing fixups.  */
504
          exists = FALSE;
505
          for (f1 = linux_hash_table (info)->fixup_list;
506
               f1 != NULL;
507
               f1 = f1->next)
508
            {
509
              if ((f1->h != h && f1->h != h1)
510
                  || (! f1->builtin && ! f1->jump))
511
                continue;
512
              if (f1->h == h1)
513
                exists = TRUE;
514
              if (! exists
515
                  && bfd_is_abs_section (h->root.root.u.def.section))
516
                {
517
                  f = new_fixup (info, h1, f1->h->root.root.u.def.value, 0);
518
                  f->jump = is_plt;
519
                }
520
              f1->h = h1;
521
              f1->jump = is_plt;
522
              f1->builtin = 0;
523
              exists = TRUE;
524
            }
525
          if (! exists
526
              && bfd_is_abs_section (h->root.root.u.def.section))
527
            {
528
              f = new_fixup (info, h1, h->root.root.u.def.value, 0);
529
              if (f == NULL)
530
                {
531
                  /* FIXME: No way to return error.  */
532
                  abort ();
533
                }
534
              f->jump = is_plt;
535
            }
536
        }
537
 
538
      /* Quick and dirty way of stripping these symbols from the
539
         symtab.  */
540
      if (bfd_is_abs_section (h->root.root.u.def.section))
541
        h->root.written = TRUE;
542
    }
543
 
544
  return TRUE;
545
}
546
 
547
/* This is called to set the size of the .linux-dynamic section is.
548
   It is called by the Linux linker emulation before_allocation
549
   routine.  We have finished reading all of the input files, and now
550
   we just scan the hash tables to find out how many additional fixups
551
   are required.  */
552
 
553
bfd_boolean
554
bfd_sparclinux_size_dynamic_sections (output_bfd, info)
555
     bfd *output_bfd;
556
     struct bfd_link_info *info;
557
{
558
  struct fixup *f;
559
  asection *s;
560
 
561
  if (output_bfd->xvec != &MY(vec))
562
    return TRUE;
563
 
564
  /* First find the fixups...  */
565
  linux_link_hash_traverse (linux_hash_table (info),
566
                            linux_tally_symbols,
567
                            (PTR) info);
568
 
569
  /* If there are builtin fixups, leave room for a marker.  This is
570
     used by the dynamic linker so that it knows that all that follow
571
     are builtin fixups instead of regular fixups.  */
572
  for (f = linux_hash_table (info)->fixup_list; f != NULL; f = f->next)
573
    {
574
      if (f->builtin)
575
        {
576
          ++linux_hash_table (info)->fixup_count;
577
          ++linux_hash_table (info)->local_builtins;
578
          break;
579
        }
580
    }
581
 
582
  if (linux_hash_table (info)->dynobj == NULL)
583
    {
584
      if (linux_hash_table (info)->fixup_count > 0)
585
        abort ();
586
      return TRUE;
587
    }
588
 
589
  /* Allocate memory for our fixup table.  We will fill it in later.  */
590
  s = bfd_get_section_by_name (linux_hash_table (info)->dynobj,
591
                               ".linux-dynamic");
592
  if (s != NULL)
593
    {
594
      s->size = linux_hash_table (info)->fixup_count + 1;
595
      s->size *= 8;
596
      s->contents = (bfd_byte *) bfd_zalloc (output_bfd, s->size);
597
      if (s->contents == NULL)
598
        return FALSE;
599
    }
600
 
601
  return TRUE;
602
}
603
 
604
/* We come here once we are ready to actually write the fixup table to
605
   the output file.  Scan the fixup tables and so forth and generate
606
   the stuff we need.  */
607
 
608
static bfd_boolean
609
linux_finish_dynamic_link (output_bfd, info)
610
     bfd *output_bfd;
611
     struct bfd_link_info *info;
612
{
613
  asection *s, *os, *is;
614
  bfd_byte *fixup_table;
615
  struct linux_link_hash_entry *h;
616
  struct fixup *f;
617
  unsigned int new_addr;
618
  int section_offset;
619
  unsigned int fixups_written;
620
 
621
  if (linux_hash_table (info)->dynobj == NULL)
622
    return TRUE;
623
 
624
  s = bfd_get_section_by_name (linux_hash_table (info)->dynobj,
625
                               ".linux-dynamic");
626
  BFD_ASSERT (s != NULL);
627
  os = s->output_section;
628
  fixups_written = 0;
629
 
630
#ifdef LINUX_LINK_DEBUG
631
  printf ("Fixup table file offset: %x  VMA: %x\n",
632
          os->filepos + s->output_offset,
633
          os->vma + s->output_offset);
634
#endif
635
 
636
  fixup_table = s->contents;
637
  bfd_put_32 (output_bfd,
638
              (bfd_vma) linux_hash_table (info)->fixup_count, fixup_table);
639
  fixup_table += 4;
640
 
641
  /* Fill in fixup table.  */
642
  for (f = linux_hash_table (info)->fixup_list; f != NULL; f = f->next)
643
    {
644
      if (f->builtin)
645
        continue;
646
 
647
      if (f->h->root.root.type != bfd_link_hash_defined
648
          && f->h->root.root.type != bfd_link_hash_defweak)
649
        {
650
          (*_bfd_error_handler)
651
            (_("Symbol %s not defined for fixups\n"),
652
             f->h->root.root.root.string);
653
          continue;
654
        }
655
 
656
      is = f->h->root.root.u.def.section;
657
      section_offset = is->output_section->vma + is->output_offset;
658
      new_addr = f->h->root.root.u.def.value + section_offset;
659
 
660
#ifdef LINUX_LINK_DEBUG
661
      printf ("Fixup(%d) %s: %x %x\n",f->jump, f->h->root.root.string,
662
              new_addr, f->value);
663
#endif
664
 
665
      if (f->jump)
666
        {
667
          /* Relative address */
668
          new_addr = new_addr - (f->value + 5);
669
          bfd_put_32 (output_bfd, (bfd_vma) new_addr, fixup_table);
670
          fixup_table += 4;
671
          bfd_put_32 (output_bfd, f->value + 1, fixup_table);
672
          fixup_table += 4;
673
        }
674
      else
675
        {
676
          bfd_put_32 (output_bfd, (bfd_vma) new_addr, fixup_table);
677
          fixup_table += 4;
678
          bfd_put_32 (output_bfd, f->value, fixup_table);
679
          fixup_table += 4;
680
        }
681
      ++fixups_written;
682
    }
683
 
684
  if (linux_hash_table (info)->local_builtins != 0)
685
    {
686
      /* Special marker so we know to switch to the other type of fixup */
687
      bfd_put_32 (output_bfd, (bfd_vma) 0, fixup_table);
688
      fixup_table += 4;
689
      bfd_put_32 (output_bfd, (bfd_vma) 0, fixup_table);
690
      fixup_table += 4;
691
      ++fixups_written;
692
      for (f = linux_hash_table (info)->fixup_list; f != NULL; f = f->next)
693
        {
694
          if (! f->builtin)
695
            continue;
696
 
697
          if (f->h->root.root.type != bfd_link_hash_defined
698
              && f->h->root.root.type != bfd_link_hash_defweak)
699
            {
700
              (*_bfd_error_handler)
701
                (_("Symbol %s not defined for fixups\n"),
702
                 f->h->root.root.root.string);
703
              continue;
704
            }
705
 
706
          is = f->h->root.root.u.def.section;
707
          section_offset = is->output_section->vma + is->output_offset;
708
          new_addr = f->h->root.root.u.def.value + section_offset;
709
 
710
#ifdef LINUX_LINK_DEBUG
711
          printf ("Fixup(B) %s: %x %x\n", f->h->root.root.string,
712
                  new_addr, f->value);
713
#endif
714
 
715
          bfd_put_32 (output_bfd, (bfd_vma) new_addr, fixup_table);
716
          fixup_table += 4;
717
          bfd_put_32 (output_bfd, f->value, fixup_table);
718
          fixup_table += 4;
719
          ++fixups_written;
720
        }
721
    }
722
 
723
  if (linux_hash_table (info)->fixup_count != fixups_written)
724
    {
725
      (*_bfd_error_handler) (_("Warning: fixup count mismatch\n"));
726
      while (linux_hash_table (info)->fixup_count > fixups_written)
727
        {
728
          bfd_put_32 (output_bfd, (bfd_vma) 0, fixup_table);
729
          fixup_table += 4;
730
          bfd_put_32 (output_bfd, (bfd_vma) 0, fixup_table);
731
          fixup_table += 4;
732
          ++fixups_written;
733
        }
734
    }
735
 
736
  h = linux_link_hash_lookup (linux_hash_table (info),
737
                              "__BUILTIN_FIXUPS__",
738
                              FALSE, FALSE, FALSE);
739
 
740
  if (h != NULL
741
      && (h->root.root.type == bfd_link_hash_defined
742
          || h->root.root.type == bfd_link_hash_defweak))
743
    {
744
      is = h->root.root.u.def.section;
745
      section_offset = is->output_section->vma + is->output_offset;
746
      new_addr = h->root.root.u.def.value + section_offset;
747
 
748
#ifdef LINUX_LINK_DEBUG
749
      printf ("Builtin fixup table at %x\n", new_addr);
750
#endif
751
 
752
      bfd_put_32 (output_bfd, (bfd_vma) new_addr, fixup_table);
753
    }
754
  else
755
    bfd_put_32 (output_bfd, (bfd_vma) 0, fixup_table);
756
 
757
  if (bfd_seek (output_bfd, (file_ptr) (os->filepos + s->output_offset),
758
                SEEK_SET) != 0)
759
    return FALSE;
760
 
761
  if (bfd_bwrite ((PTR) s->contents, s->size, output_bfd) != s->size)
762
    return FALSE;
763
 
764
  return TRUE;
765
}
766
 
767
#define MY_bfd_link_hash_table_create linux_link_hash_table_create
768
#define MY_add_one_symbol linux_add_one_symbol
769
#define MY_finish_dynamic_link linux_finish_dynamic_link
770
 
771
#define MY_zmagic_contiguous 1
772
 
773
#include "aout-target.h"

powered by: WebSVN 2.1.0

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