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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-7.1/] [bfd/] [m68klinux.c] - Blame information for rev 227

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 227 jeremybenn
/* BFD back-end for linux flavored m68k a.out binaries.
2
   Copyright 1992, 1993, 1994, 1995, 1996, 1997, 1999, 2000, 2001, 2002,
3
   2003, 2004, 2005, 2006, 2007, 2008, 2009 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 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
 
27
#define MACHTYPE_OK(mtype) ((mtype) == M_68020 || (mtype) == M_UNKNOWN)
28
 
29
#include "sysdep.h"
30
#include "bfd.h"
31
#include "libbfd.h"
32
#include "aout/aout64.h"
33
#include "aout/stab_gnu.h"
34
#include "aout/ar.h"
35
#include "libaout.h"           /* BFD a.out internal data structures */
36
 
37
#define TARGET_IS_BIG_ENDIAN_P
38
#define DEFAULT_ARCH bfd_arch_m68k
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 (m68klinux_,OP)
44
#define TARGETNAME "a.out-m68k-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 m68klinux_bfd_final_link
55
  PARAMS ((bfd *, struct bfd_link_info *));
56
static bfd_boolean m68klinux_write_object_contents PARAMS ((bfd *));
57
 
58
static bfd_boolean
59
m68klinux_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 m68klinux_bfd_final_link
68
 
69
/* Set the machine type correctly.  */
70
 
71
static bfd_boolean
72
m68klinux_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_68020);
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 m68klinux_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_malloc (amt);
231
  if (ret == (struct linux_link_hash_table *) NULL)
232
    {
233
      bfd_set_error (bfd_error_no_memory);
234
      return (struct bfd_link_hash_table *) NULL;
235
    }
236
  if (!NAME(aout,link_hash_table_init) (&ret->root, abfd,
237
                                        linux_link_hash_newfunc,
238
                                        sizeof (struct linux_link_hash_entry)))
239
    {
240
      free (ret);
241
      return (struct bfd_link_hash_table *) NULL;
242
    }
243
 
244
  ret->dynobj = NULL;
245
  ret->fixup_count = 0;
246
  ret->local_builtins = 0;
247
  ret->fixup_list = NULL;
248
 
249
  return &ret->root.root;
250
}
251
 
252
/* Look up an entry in a Linux link hash table.  */
253
 
254
#define linux_link_hash_lookup(table, string, create, copy, follow) \
255
  ((struct linux_link_hash_entry *) \
256
   aout_link_hash_lookup (&(table)->root, (string), (create), (copy),\
257
                          (follow)))
258
 
259
/* Traverse a Linux link hash table.  */
260
 
261
#define linux_link_hash_traverse(table, func, info)                     \
262
  (aout_link_hash_traverse                                              \
263
   (&(table)->root,                                                     \
264
    (bfd_boolean (*) PARAMS ((struct aout_link_hash_entry *, PTR))) (func),     \
265
    (info)))
266
 
267
/* Get the Linux link hash table from the info structure.  This is
268
   just a cast.  */
269
 
270
#define linux_hash_table(p) ((struct linux_link_hash_table *) ((p)->hash))
271
 
272
/* Store the information for a new fixup.  */
273
 
274
static struct fixup *
275
new_fixup (info, h, value, builtin)
276
     struct bfd_link_info *info;
277
     struct linux_link_hash_entry *h;
278
     bfd_vma value;
279
     int builtin;
280
{
281
  struct fixup *f;
282
 
283
  f = (struct fixup *) bfd_hash_allocate (&info->hash->table,
284
                                          sizeof (struct fixup));
285
  if (f == NULL)
286
    return f;
287
  f->next = linux_hash_table (info)->fixup_list;
288
  linux_hash_table (info)->fixup_list = f;
289
  f->h = h;
290
  f->value = value;
291
  f->builtin = builtin;
292
  f->jump = 0;
293
  ++linux_hash_table (info)->fixup_count;
294
  return f;
295
}
296
 
297
/* We come here once we realize that we are going to link to a shared
298
   library.  We need to create a special section that contains the
299
   fixup table, and we ultimately need to add a pointer to this into
300
   the set vector for SHARABLE_CONFLICTS.  At this point we do not
301
   know the size of the section, but that's OK - we just need to
302
   create it for now.  */
303
 
304
static bfd_boolean
305
linux_link_create_dynamic_sections (abfd, info)
306
     bfd *abfd;
307
     struct bfd_link_info *info ATTRIBUTE_UNUSED;
308
{
309
  flagword flags;
310
  register asection *s;
311
 
312
  /* Note that we set the SEC_IN_MEMORY flag.  */
313
  flags = SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY;
314
 
315
  /* We choose to use the name ".linux-dynamic" for the fixup table.
316
     Why not? */
317
  s = bfd_make_section_with_flags (abfd, ".linux-dynamic", flags);
318
  if (s == NULL
319
      || ! bfd_set_section_alignment (abfd, s, 2))
320
    return FALSE;
321
  s->size = 0;
322
  s->contents = 0;
323
 
324
  return TRUE;
325
}
326
 
327
/* Function to add a single symbol to the linker hash table.  This is
328
   a wrapper around _bfd_generic_link_add_one_symbol which handles the
329
   tweaking needed for dynamic linking support.  */
330
 
331
static bfd_boolean
332
linux_add_one_symbol (info, abfd, name, flags, section, value, string,
333
                      copy, collect, hashp)
334
     struct bfd_link_info *info;
335
     bfd *abfd;
336
     const char *name;
337
     flagword flags;
338
     asection *section;
339
     bfd_vma value;
340
     const char *string;
341
     bfd_boolean copy;
342
     bfd_boolean collect;
343
     struct bfd_link_hash_entry **hashp;
344
{
345
  struct linux_link_hash_entry *h;
346
  bfd_boolean insert;
347
 
348
  /* Look up and see if we already have this symbol in the hash table.
349
     If we do, and the defining entry is from a shared library, we
350
     need to create the dynamic sections.
351
 
352
     FIXME: What if abfd->xvec != info->output_bfd->xvec?  We may
353
     want to be able to link Linux a.out and ELF objects together,
354
     but serious confusion is possible.  */
355
 
356
  insert = FALSE;
357
 
358
  if (! info->relocatable
359
      && linux_hash_table (info)->dynobj == NULL
360
      && strcmp (name, SHARABLE_CONFLICTS) == 0
361
      && (flags & BSF_CONSTRUCTOR) != 0
362
      && abfd->xvec == info->output_bfd->xvec)
363
    {
364
      if (! linux_link_create_dynamic_sections (abfd, info))
365
        return FALSE;
366
      linux_hash_table (info)->dynobj = abfd;
367
      insert = TRUE;
368
    }
369
 
370
  if (bfd_is_abs_section (section)
371
      && abfd->xvec == info->output_bfd->xvec)
372
    {
373
      h = linux_link_hash_lookup (linux_hash_table (info), name, FALSE,
374
                                  FALSE, FALSE);
375
      if (h != NULL
376
          && (h->root.root.type == bfd_link_hash_defined
377
              || h->root.root.type == bfd_link_hash_defweak))
378
        {
379
          struct fixup *f;
380
 
381
          if (hashp != NULL)
382
            *hashp = (struct bfd_link_hash_entry *) h;
383
 
384
          f = new_fixup (info, h, value, ! IS_PLT_SYM (name));
385
          if (f == NULL)
386
            return FALSE;
387
          f->jump = IS_PLT_SYM (name);
388
 
389
          return TRUE;
390
        }
391
    }
392
 
393
  /* Do the usual procedure for adding a symbol.  */
394
  if (! _bfd_generic_link_add_one_symbol (info, abfd, name, flags, section,
395
                                          value, string, copy, collect,
396
                                          hashp))
397
    return FALSE;
398
 
399
  /* Insert a pointer to our table in the set vector.  The dynamic
400
     linker requires this information */
401
  if (insert)
402
    {
403
      asection *s;
404
 
405
      /* Here we do our special thing to add the pointer to the
406
         dynamic section in the SHARABLE_CONFLICTS set vector.  */
407
      s = bfd_get_section_by_name (linux_hash_table (info)->dynobj,
408
                                   ".linux-dynamic");
409
      BFD_ASSERT (s != NULL);
410
 
411
      if (! (_bfd_generic_link_add_one_symbol
412
             (info, linux_hash_table (info)->dynobj, SHARABLE_CONFLICTS,
413
              BSF_GLOBAL | BSF_CONSTRUCTOR, s, (bfd_vma) 0, NULL,
414
              FALSE, FALSE, NULL)))
415
        return FALSE;
416
    }
417
 
418
  return TRUE;
419
}
420
 
421
/* We will crawl the hash table and come here for every global symbol.
422
   We will examine each entry and see if there are indications that we
423
   need to add a fixup.  There are two possible cases - one is where
424
   you have duplicate definitions of PLT or GOT symbols - these will
425
   have already been caught and added as "builtin" fixups.  If we find
426
   that the corresponding non PLT/GOT symbol is also present, we
427
   convert it to a regular fixup instead.
428
 
429
   This function is called via linux_link_hash_traverse.  */
430
 
431
static bfd_boolean
432
linux_tally_symbols (h, data)
433
     struct linux_link_hash_entry *h;
434
     PTR data;
435
{
436
  struct bfd_link_info *info = (struct bfd_link_info *) data;
437
  struct fixup *f, *f1;
438
  int is_plt;
439
  struct linux_link_hash_entry *h1, *h2;
440
  bfd_boolean exists;
441
 
442
  if (h->root.root.type == bfd_link_hash_warning)
443
    h = (struct linux_link_hash_entry *) h->root.root.u.i.link;
444
 
445
  if (h->root.root.type == bfd_link_hash_undefined
446
      && CONST_STRNEQ (h->root.root.root.string, NEEDS_SHRLIB))
447
    {
448
      const char *name;
449
      char *p;
450
      char *alloc = NULL;
451
 
452
      name = h->root.root.root.string + sizeof NEEDS_SHRLIB - 1;
453
      p = strrchr (name, '_');
454
      if (p != NULL)
455
        alloc = (char *) bfd_malloc ((bfd_size_type) strlen (name) + 1);
456
 
457
      if (p == NULL || alloc == NULL)
458
        (*_bfd_error_handler) (_("Output file requires shared library `%s'\n"),
459
                               name);
460
      else
461
        {
462
          strcpy (alloc, name);
463
          p = strrchr (alloc, '_');
464
          *p++ = '\0';
465
          (*_bfd_error_handler)
466
            (_("Output file requires shared library `%s.so.%s'\n"),
467
             alloc, p);
468
          free (alloc);
469
        }
470
 
471
      abort ();
472
    }
473
 
474
  /* If this symbol is not a PLT/GOT, we do not even need to look at it */
475
  is_plt = IS_PLT_SYM (h->root.root.root.string);
476
 
477
  if (is_plt || IS_GOT_SYM (h->root.root.root.string))
478
    {
479
      /* Look up this symbol twice.  Once just as a regular lookup,
480
         and then again following all of the indirect links until we
481
         reach a real symbol.  */
482
      h1 = linux_link_hash_lookup (linux_hash_table (info),
483
                                   (h->root.root.root.string
484
                                    + sizeof PLT_REF_PREFIX - 1),
485
                                   FALSE, FALSE, TRUE);
486
      /* h2 does not follow indirect symbols.  */
487
      h2 = linux_link_hash_lookup (linux_hash_table (info),
488
                                   (h->root.root.root.string
489
                                    + sizeof PLT_REF_PREFIX - 1),
490
                                   FALSE, FALSE, FALSE);
491
 
492
      /* The real symbol must exist but if it is also an ABS symbol,
493
         there is no need to have a fixup.  This is because they both
494
         came from the same library.  If on the other hand, we had to
495
         use an indirect symbol to get to the real symbol, we add the
496
         fixup anyway, since there are cases where these symbols come
497
         from different shared libraries */
498
      if (h1 != NULL
499
          && (((h1->root.root.type == bfd_link_hash_defined
500
                || h1->root.root.type == bfd_link_hash_defweak)
501
               && ! bfd_is_abs_section (h1->root.root.u.def.section))
502
              || h2->root.root.type == bfd_link_hash_indirect))
503
        {
504
          /* See if there is a "builtin" fixup already present
505
             involving this symbol.  If so, convert it to a regular
506
             fixup.  In the end, this relaxes some of the requirements
507
             about the order of performing fixups.  */
508
          exists = FALSE;
509
          for (f1 = linux_hash_table (info)->fixup_list;
510
               f1 != NULL;
511
               f1 = f1->next)
512
            {
513
              if ((f1->h != h && f1->h != h1)
514
                  || (! f1->builtin && ! f1->jump))
515
                continue;
516
              if (f1->h == h1)
517
                exists = TRUE;
518
              if (! exists
519
                  && bfd_is_abs_section (h->root.root.u.def.section))
520
                {
521
                  f = new_fixup (info, h1, f1->h->root.root.u.def.value, 0);
522
                  f->jump = is_plt;
523
                }
524
              f1->h = h1;
525
              f1->jump = is_plt;
526
              f1->builtin = 0;
527
              exists = TRUE;
528
            }
529
          if (! exists
530
              && bfd_is_abs_section (h->root.root.u.def.section))
531
            {
532
              f = new_fixup (info, h1, h->root.root.u.def.value, 0);
533
              if (f == NULL)
534
                {
535
                  /* FIXME: No way to return error.  */
536
                  abort ();
537
                }
538
              f->jump = is_plt;
539
            }
540
        }
541
 
542
      /* Quick and dirty way of stripping these symbols from the
543
         symtab.  */
544
      if (bfd_is_abs_section (h->root.root.u.def.section))
545
        h->root.written = TRUE;
546
    }
547
 
548
  return TRUE;
549
}
550
 
551
/* This is called to set the size of the .linux-dynamic section is.
552
   It is called by the Linux linker emulation before_allocation
553
   routine.  We have finished reading all of the input files, and now
554
   we just scan the hash tables to find out how many additional fixups
555
   are required.  */
556
 
557
bfd_boolean
558
bfd_m68klinux_size_dynamic_sections (output_bfd, info)
559
     bfd *output_bfd;
560
     struct bfd_link_info *info;
561
{
562
  struct fixup *f;
563
  asection *s;
564
 
565
  if (output_bfd->xvec != &MY(vec))
566
    return TRUE;
567
 
568
  /* First find the fixups...  */
569
  linux_link_hash_traverse (linux_hash_table (info),
570
                            linux_tally_symbols,
571
                            (PTR) info);
572
 
573
  /* If there are builtin fixups, leave room for a marker.  This is
574
     used by the dynamic linker so that it knows that all that follow
575
     are builtin fixups instead of regular fixups.  */
576
  for (f = linux_hash_table (info)->fixup_list; f != NULL; f = f->next)
577
    {
578
      if (f->builtin)
579
        {
580
          ++linux_hash_table (info)->fixup_count;
581
          ++linux_hash_table (info)->local_builtins;
582
          break;
583
        }
584
    }
585
 
586
  if (linux_hash_table (info)->dynobj == NULL)
587
    {
588
      if (linux_hash_table (info)->fixup_count > 0)
589
        abort ();
590
      return TRUE;
591
    }
592
 
593
  /* Allocate memory for our fixup table.  We will fill it in later.  */
594
  s = bfd_get_section_by_name (linux_hash_table (info)->dynobj,
595
                               ".linux-dynamic");
596
  if (s != NULL)
597
    {
598
      s->size = linux_hash_table (info)->fixup_count + 1;
599
      s->size *= 8;
600
      s->contents = (bfd_byte *) bfd_zalloc (output_bfd, s->size);
601
      if (s->contents == NULL)
602
        {
603
          bfd_set_error (bfd_error_no_memory);
604
          return FALSE;
605
        }
606
    }
607
 
608
  return TRUE;
609
}
610
 
611
/* We come here once we are ready to actually write the fixup table to
612
   the output file.  Scan the fixup tables and so forth and generate
613
   the stuff we need.  */
614
 
615
static bfd_boolean
616
linux_finish_dynamic_link (output_bfd, info)
617
     bfd *output_bfd;
618
     struct bfd_link_info *info;
619
{
620
  asection *s, *os, *is;
621
  bfd_byte *fixup_table;
622
  struct linux_link_hash_entry *h;
623
  struct fixup *f;
624
  unsigned int new_addr;
625
  int section_offset;
626
  unsigned int fixups_written;
627
 
628
  if (linux_hash_table (info)->dynobj == NULL)
629
    return TRUE;
630
 
631
  s = bfd_get_section_by_name (linux_hash_table (info)->dynobj,
632
                               ".linux-dynamic");
633
  BFD_ASSERT (s != NULL);
634
  os = s->output_section;
635
  fixups_written = 0;
636
 
637
#ifdef LINUX_LINK_DEBUG
638
  printf ("Fixup table file offset: %x  VMA: %x\n",
639
          os->filepos + s->output_offset,
640
          os->vma + s->output_offset);
641
#endif
642
 
643
  fixup_table = s->contents;
644
  bfd_put_32 (output_bfd, (bfd_vma) linux_hash_table (info)->fixup_count,
645
              fixup_table);
646
  fixup_table += 4;
647
 
648
  /* Fill in fixup table.  */
649
  for (f = linux_hash_table (info)->fixup_list; f != NULL; f = f->next)
650
    {
651
      if (f->builtin)
652
        continue;
653
 
654
      if (f->h->root.root.type != bfd_link_hash_defined
655
          && f->h->root.root.type != bfd_link_hash_defweak)
656
        {
657
          (*_bfd_error_handler)
658
            (_("Symbol %s not defined for fixups\n"),
659
             f->h->root.root.root.string);
660
          continue;
661
        }
662
 
663
      is = f->h->root.root.u.def.section;
664
      section_offset = is->output_section->vma + is->output_offset;
665
      new_addr = f->h->root.root.u.def.value + section_offset;
666
 
667
#ifdef LINUX_LINK_DEBUG
668
      printf ("Fixup(%d) %s: %x %x\n",f->jump, f->h->root.root.string,
669
              new_addr, f->value);
670
#endif
671
 
672
      if (f->jump)
673
        {
674
          bfd_put_32 (output_bfd, (bfd_vma) new_addr, fixup_table);
675
          fixup_table += 4;
676
          bfd_put_32 (output_bfd, f->value + 2, fixup_table);
677
          fixup_table += 4;
678
        }
679
      else
680
        {
681
          bfd_put_32 (output_bfd, (bfd_vma) new_addr, fixup_table);
682
          fixup_table += 4;
683
          bfd_put_32 (output_bfd, f->value, fixup_table);
684
          fixup_table += 4;
685
        }
686
      ++fixups_written;
687
    }
688
 
689
  if (linux_hash_table (info)->local_builtins != 0)
690
    {
691
      /* Special marker so we know to switch to the other type of fixup */
692
      bfd_put_32 (output_bfd, (bfd_vma) 0, fixup_table);
693
      fixup_table += 4;
694
      bfd_put_32 (output_bfd, (bfd_vma) 0, fixup_table);
695
      fixup_table += 4;
696
      ++fixups_written;
697
      for (f = linux_hash_table (info)->fixup_list; f != NULL; f = f->next)
698
        {
699
          if (! f->builtin)
700
            continue;
701
 
702
          if (f->h->root.root.type != bfd_link_hash_defined
703
              && f->h->root.root.type != bfd_link_hash_defweak)
704
            {
705
              (*_bfd_error_handler)
706
                (_("Symbol %s not defined for fixups\n"),
707
                 f->h->root.root.root.string);
708
              continue;
709
            }
710
 
711
          is = f->h->root.root.u.def.section;
712
          section_offset = is->output_section->vma + is->output_offset;
713
          new_addr = f->h->root.root.u.def.value + section_offset;
714
 
715
#ifdef LINUX_LINK_DEBUG
716
          printf ("Fixup(B) %s: %x %x\n", f->h->root.root.string,
717
                  new_addr, f->value);
718
#endif
719
 
720
          bfd_put_32 (output_bfd, (bfd_vma) new_addr, fixup_table);
721
          fixup_table += 4;
722
          bfd_put_32 (output_bfd, f->value, fixup_table);
723
          fixup_table += 4;
724
          ++fixups_written;
725
        }
726
  }
727
 
728
  if (linux_hash_table (info)->fixup_count != fixups_written)
729
    {
730
      (*_bfd_error_handler) (_("Warning: fixup count mismatch\n"));
731
      while (linux_hash_table (info)->fixup_count > fixups_written)
732
        {
733
          bfd_put_32 (output_bfd, (bfd_vma) 0, fixup_table);
734
          fixup_table += 4;
735
          bfd_put_32 (output_bfd, (bfd_vma) 0, fixup_table);
736
          fixup_table += 4;
737
          ++fixups_written;
738
        }
739
    }
740
 
741
  h = linux_link_hash_lookup (linux_hash_table (info),
742
                              "__BUILTIN_FIXUPS__",
743
                              FALSE, FALSE, FALSE);
744
 
745
  if (h != NULL
746
      && (h->root.root.type == bfd_link_hash_defined
747
          || h->root.root.type == bfd_link_hash_defweak))
748
    {
749
      is = h->root.root.u.def.section;
750
      section_offset = is->output_section->vma + is->output_offset;
751
      new_addr = h->root.root.u.def.value + section_offset;
752
 
753
#ifdef LINUX_LINK_DEBUG
754
      printf ("Builtin fixup table at %x\n", new_addr);
755
#endif
756
 
757
      bfd_put_32 (output_bfd, (bfd_vma) new_addr, fixup_table);
758
    }
759
  else
760
    bfd_put_32 (output_bfd, (bfd_vma) 0, fixup_table);
761
 
762
  if (bfd_seek (output_bfd, (file_ptr) (os->filepos + s->output_offset),
763
                SEEK_SET) != 0)
764
    return FALSE;
765
 
766
  if (bfd_bwrite ((PTR) s->contents, s->size, output_bfd) != s->size)
767
    return FALSE;
768
 
769
  return TRUE;
770
}
771
 
772
#define MY_bfd_link_hash_table_create linux_link_hash_table_create
773
#define MY_add_one_symbol linux_add_one_symbol
774
#define MY_finish_dynamic_link linux_finish_dynamic_link
775
 
776
#define MY_zmagic_contiguous 1
777
 
778
#include "aout-target.h"

powered by: WebSVN 2.1.0

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