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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-stable/] [binutils-2.20.1/] [bfd/] [pdp11.c] - Blame information for rev 816

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

Line No. Rev Author Line
1 205 julius
/* BFD back-end for PDP-11 a.out binaries.
2
   Copyright 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2009
3
   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
 
23
/* BFD backend for PDP-11, running 2.11BSD in particular.
24
 
25
   This file was hacked up by looking hard at the existing vaxnetbsd
26
   back end and the header files in 2.11BSD.
27
 
28
   TODO
29
   * support for V7 file formats
30
   * support for overlay object files (see 2.11 a.out(5))
31
   * support for old and very old archives
32
   (see 2.11 ar(5), historical section)
33
 
34
   Search for TODO to find other areas needing more work.  */
35
 
36
#define BYTES_IN_WORD   2
37
#define BYTES_IN_LONG   4
38
#define ARCH_SIZE       16
39
#undef TARGET_IS_BIG_ENDIAN_P
40
 
41
#define TARGET_PAGE_SIZE        1024
42
#define SEGMENT__SIZE   TARGET_PAGE_SIZE
43
 
44
#define DEFAULT_ARCH    bfd_arch_pdp11
45
#define DEFAULT_MID     M_PDP11
46
 
47
/* Do not "beautify" the CONCAT* macro args.  Traditional C will not
48
   remove whitespace added here, and thus will fail to concatenate
49
   the tokens.  */
50
#define MY(OP) CONCAT2 (pdp11_aout_,OP)
51
 
52
/* This needs to start with a.out so GDB knows it is an a.out variant.  */
53
#define TARGETNAME "a.out-pdp11"
54
 
55
/* This is the normal load address for executables.  */
56
#define TEXT_START_ADDR         0
57
 
58
/* The header is not included in the text segment.  */
59
#define N_HEADER_IN_TEXT(x)     0
60
 
61
/* There are no shared libraries.  */
62
#define N_SHARED_LIB(x)         0
63
 
64
/* There is no flags field.  */
65
#define N_FLAGS(exec)           0
66
 
67
#define N_SET_FLAGS(exec, flags) do { } while (0)
68
#define N_BADMAG(x) (N_MAGIC(x) != OMAGIC       \
69
                     && N_MAGIC(x) != NMAGIC    \
70
                     && N_MAGIC(x) != ZMAGIC)
71
 
72
#include "sysdep.h"
73
#include "bfd.h"
74
 
75
#define external_exec pdp11_external_exec
76
struct pdp11_external_exec
77
{
78
  bfd_byte e_info[2];           /* Magic number.  */
79
  bfd_byte e_text[2];           /* Length of text section in bytes.  */
80
  bfd_byte e_data[2];           /* Length of data section in bytes.  */
81
  bfd_byte e_bss[2];            /* Length of bss area in bytes.  */
82
  bfd_byte e_syms[2];           /* Length of symbol table in bytes.  */
83
  bfd_byte e_entry[2];          /* Start address.  */
84
  bfd_byte e_unused[2];         /* Not used.  */
85
  bfd_byte e_flag[2];           /* Relocation info stripped.  */
86
  bfd_byte e_relocatable;       /* Ugly hack.  */
87
};
88
 
89
#define EXEC_BYTES_SIZE (8 * 2)
90
 
91
#define A_MAGIC1        OMAGIC
92
#define OMAGIC          0407    /* ...object file or impure executable.  */
93
#define A_MAGIC2        NMAGIC
94
#define NMAGIC          0410    /* Pure executable.  */
95
#define ZMAGIC          0413    /* Demand-paged executable.  */
96
#define A_MAGIC3        0411    /* Separated I&D.  */
97
#define A_MAGIC4        0405    /* Overlay.  */
98
#define A_MAGIC5        0430    /* Auto-overlay (nonseparate).  */
99
#define A_MAGIC6        0431    /* Auto-overlay (separate).  */
100
#define QMAGIC          0
101
#define BMAGIC          0
102
 
103
#define A_FLAG_RELOC_STRIPPED   0x0001
104
 
105
#define external_nlist pdp11_external_nlist
106
struct pdp11_external_nlist
107
{
108
  bfd_byte e_unused[2];         /* Unused.  */
109
  bfd_byte e_strx[2];           /* Index into string table of name.  */
110
  bfd_byte e_type[1];           /* Type of symbol.  */
111
  bfd_byte e_ovly[1];           /* Overlay number.  */
112
  bfd_byte e_value[2];          /* Value of symbol.  */
113
};
114
 
115
#define EXTERNAL_NLIST_SIZE     8
116
 
117
#define N_TXTOFF(x)     (EXEC_BYTES_SIZE)
118
#define N_DATOFF(x)     (N_TXTOFF(x) + (x).a_text)
119
#define N_TRELOFF(x)    (N_DATOFF(x) + (x).a_data)
120
#define N_DRELOFF(x)    (N_TRELOFF(x) + (x).a_trsize)
121
#define N_SYMOFF(x)     (N_DRELOFF(x) + (x).a_drsize)
122
#define N_STROFF(x)     (N_SYMOFF(x) + (x).a_syms)
123
 
124
#define WRITE_HEADERS(abfd, execp) pdp11_aout_write_headers (abfd, execp)
125
 
126
#include "libbfd.h"
127
#include "libaout.h"
128
 
129
#define SWAP_MAGIC(ext) bfd_getl16 (ext)
130
 
131
#define MY_entry_is_text_address 1
132
 
133
#define MY_write_object_contents MY(write_object_contents)
134
static bfd_boolean MY(write_object_contents) (bfd *);
135
#define MY_text_includes_header 1
136
 
137
#define MY_BFD_TARGET
138
 
139
#include "aout-target.h"
140
 
141
/* Start of modified aoutx.h.  */
142
#define KEEPIT udata.i
143
 
144
#include <string.h>             /* For strchr and friends.  */
145
#include "bfd.h"
146
#include "sysdep.h"
147
#include "safe-ctype.h"
148
#include "bfdlink.h"
149
 
150
#include "libaout.h"
151
#include "aout/aout64.h"
152
#include "aout/stab_gnu.h"
153
#include "aout/ar.h"
154
 
155
#undef N_TYPE
156
#undef N_UNDF
157
#undef N_ABS
158
#undef N_TEXT
159
#undef N_DATA
160
#undef N_BSS
161
#undef N_REG
162
#undef N_FN
163
#undef N_EXT
164
#define N_TYPE          0x1f    /* Type mask.  */
165
#define N_UNDF          0x00    /* Undefined.  */
166
#define N_ABS           0x01    /* Absolute.  */
167
#define N_TEXT          0x02    /* Text segment.  */
168
#define N_DATA          0x03    /* Data segment.  */
169
#define N_BSS           0x04    /* Bss segment.  */
170
#define N_REG           0x14    /* Register symbol.  */
171
#define N_FN            0x1f    /* File name.  */
172
#define N_EXT           0x20    /* External flag.  */
173
 
174
#define RELOC_SIZE 2
175
 
176
#define RELFLG          0x0001  /* PC-relative flag.  */
177
#define RTYPE           0x000e  /* Type mask.  */
178
#define RIDXMASK        0xfff0  /* Index mask.  */
179
 
180
#define RABS            0x00    /* Absolute.  */
181
#define RTEXT           0x02    /* Text.  */
182
#define RDATA           0x04    /* Data.  */
183
#define RBSS            0x06    /* Bss.  */
184
#define REXT            0x08    /* External.  */
185
 
186
#define RINDEX(x)       (((x) & 0xfff0) >> 4)
187
 
188
#ifndef MY_final_link_relocate
189
#define MY_final_link_relocate _bfd_final_link_relocate
190
#endif
191
 
192
#ifndef MY_relocate_contents
193
#define MY_relocate_contents _bfd_relocate_contents
194
#endif
195
 
196
/* A hash table used for header files with N_BINCL entries.  */
197
 
198
struct aout_link_includes_table
199
{
200
  struct bfd_hash_table root;
201
};
202
 
203
/* A linked list of totals that we have found for a particular header
204
   file.  */
205
 
206
struct aout_link_includes_totals
207
{
208
  struct aout_link_includes_totals *next;
209
  bfd_vma total;
210
};
211
 
212
/* An entry in the header file hash table.  */
213
 
214
struct aout_link_includes_entry
215
{
216
  struct bfd_hash_entry root;
217
  /* List of totals we have found for this file.  */
218
  struct aout_link_includes_totals *totals;
219
};
220
 
221
/* During the final link step we need to pass around a bunch of
222
   information, so we do it in an instance of this structure.  */
223
 
224
struct aout_final_link_info
225
{
226
  /* General link information.  */
227
  struct bfd_link_info *info;
228
  /* Output bfd.  */
229
  bfd *output_bfd;
230
  /* Reloc file positions.  */
231
  file_ptr treloff, dreloff;
232
  /* File position of symbols.  */
233
  file_ptr symoff;
234
  /* String table.  */
235
  struct bfd_strtab_hash *strtab;
236
  /* Header file hash table.  */
237
  struct aout_link_includes_table includes;
238
  /* A buffer large enough to hold the contents of any section.  */
239
  bfd_byte *contents;
240
  /* A buffer large enough to hold the relocs of any section.  */
241
  void * relocs;
242
  /* A buffer large enough to hold the symbol map of any input BFD.  */
243
  int *symbol_map;
244
  /* A buffer large enough to hold output symbols of any input BFD.  */
245
  struct external_nlist *output_syms;
246
};
247
 
248
reloc_howto_type howto_table_pdp11[] =
249
{
250
  /* type              rs size bsz  pcrel bitpos ovrf                     sf name     part_inpl readmask  setmask    pcdone */
251
HOWTO( 0,               0,  1,  16,  FALSE, 0, complain_overflow_signed,0,"16",     TRUE, 0x0000ffff,0x0000ffff, FALSE),
252
HOWTO( 1,              0,  1,  16,  TRUE,  0, complain_overflow_signed,0,"DISP16", TRUE, 0x0000ffff,0x0000ffff, FALSE),
253
};
254
 
255
#define TABLE_SIZE(TABLE)       (sizeof(TABLE)/sizeof(TABLE[0]))
256
 
257
 
258
static bfd_boolean aout_link_check_archive_element (bfd *, struct bfd_link_info *, bfd_boolean *);
259
static bfd_boolean aout_link_add_object_symbols    (bfd *, struct bfd_link_info *);
260
static bfd_boolean aout_link_add_symbols           (bfd *, struct bfd_link_info *);
261
static bfd_boolean aout_link_write_symbols         (struct aout_final_link_info *, bfd *);
262
 
263
 
264
reloc_howto_type *
265
NAME (aout, reloc_type_lookup) (bfd * abfd ATTRIBUTE_UNUSED,
266
                                bfd_reloc_code_real_type code)
267
{
268
  switch (code)
269
    {
270
    case BFD_RELOC_16:
271
      return &howto_table_pdp11[0];
272
    case BFD_RELOC_16_PCREL:
273
      return &howto_table_pdp11[1];
274
    default:
275
      return NULL;
276
    }
277
}
278
 
279
reloc_howto_type *
280
NAME (aout, reloc_name_lookup) (bfd *abfd ATTRIBUTE_UNUSED,
281
                                      const char *r_name)
282
{
283
  unsigned int i;
284
 
285
  for (i = 0;
286
       i < sizeof (howto_table_pdp11) / sizeof (howto_table_pdp11[0]);
287
       i++)
288
    if (howto_table_pdp11[i].name != NULL
289
        && strcasecmp (howto_table_pdp11[i].name, r_name) == 0)
290
      return &howto_table_pdp11[i];
291
 
292
  return NULL;
293
}
294
 
295
static int
296
pdp11_aout_write_headers (bfd *abfd, struct internal_exec *execp)
297
{
298
  struct external_exec exec_bytes;
299
  bfd_size_type text_size;
300
  file_ptr text_end;
301
 
302
  if (adata(abfd).magic == undecided_magic)
303
    NAME (aout, adjust_sizes_and_vmas) (abfd, &text_size, &text_end);
304
 
305
  execp->a_syms = bfd_get_symcount (abfd) * EXTERNAL_NLIST_SIZE;
306
  execp->a_entry = bfd_get_start_address (abfd);
307
 
308
  if (obj_textsec (abfd)->reloc_count > 0
309
      || obj_datasec (abfd)->reloc_count > 0)
310
    {
311
      execp->a_trsize = execp->a_text;
312
      execp->a_drsize = execp->a_data;
313
    }
314
  else
315
    {
316
      execp->a_trsize = 0;
317
      execp->a_drsize = 0;
318
    }
319
 
320
  NAME (aout, swap_exec_header_out) (abfd, execp, & exec_bytes);
321
 
322
  if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET) != 0)
323
    return FALSE;
324
 
325
  if (bfd_bwrite ((void *) &exec_bytes, (bfd_size_type) EXEC_BYTES_SIZE, abfd)
326
      != EXEC_BYTES_SIZE)
327
    return FALSE;
328
 
329
  /* Now write out reloc info, followed by syms and strings.  */
330
  if (bfd_get_outsymbols (abfd) != NULL
331
      && bfd_get_symcount (abfd) != 0)
332
    {
333
      if (bfd_seek (abfd, (file_ptr) (N_SYMOFF(*execp)), SEEK_SET) != 0)
334
        return FALSE;
335
 
336
      if (! NAME (aout, write_syms) (abfd))
337
        return FALSE;
338
    }
339
 
340
  if (obj_textsec (abfd)->reloc_count > 0
341
      || obj_datasec (abfd)->reloc_count > 0)
342
    {
343
      if (bfd_seek (abfd, (file_ptr) (N_TRELOFF(*execp)), SEEK_SET) != 0
344
          || !NAME (aout, squirt_out_relocs) (abfd, obj_textsec (abfd))
345
          || bfd_seek (abfd, (file_ptr) (N_DRELOFF(*execp)), SEEK_SET) != 0
346
          || !NAME (aout, squirt_out_relocs) (abfd, obj_datasec (abfd)))
347
        return FALSE;
348
    }
349
 
350
  return TRUE;
351
}
352
 
353
/* Write an object file.
354
   Section contents have already been written.  We write the
355
   file header, symbols, and relocation.  */
356
 
357
static bfd_boolean
358
MY(write_object_contents) (bfd *abfd)
359
{
360
  struct internal_exec *execp = exec_hdr (abfd);
361
 
362
  /* We must make certain that the magic number has been set.  This
363
     will normally have been done by set_section_contents, but only if
364
     there actually are some section contents.  */
365
  if (! abfd->output_has_begun)
366
    {
367
      bfd_size_type text_size;
368
      file_ptr text_end;
369
 
370
      NAME (aout, adjust_sizes_and_vmas) (abfd, &text_size, &text_end);
371
    }
372
 
373
  obj_reloc_entry_size (abfd) = RELOC_SIZE;
374
 
375
  return WRITE_HEADERS (abfd, execp);
376
}
377
 
378
/* Swap the information in an executable header @var{raw_bytes} taken
379
   from a raw byte stream memory image into the internal exec header
380
   structure "execp".  */
381
 
382
#ifndef NAME_swap_exec_header_in
383
void
384
NAME (aout, swap_exec_header_in) (bfd *abfd,
385
                                  struct external_exec *bytes,
386
                                  struct internal_exec *execp)
387
{
388
  /* The internal_exec structure has some fields that are unused in this
389
     configuration (IE for i960), so ensure that all such uninitialized
390
     fields are zero'd out.  There are places where two of these structs
391
     are memcmp'd, and thus the contents do matter.  */
392
  memset ((void *) execp, 0, sizeof (struct internal_exec));
393
  /* Now fill in fields in the execp, from the bytes in the raw data.  */
394
  execp->a_info   = GET_MAGIC (abfd, bytes->e_info);
395
  execp->a_text   = GET_WORD (abfd, bytes->e_text);
396
  execp->a_data   = GET_WORD (abfd, bytes->e_data);
397
  execp->a_bss    = GET_WORD (abfd, bytes->e_bss);
398
  execp->a_syms   = GET_WORD (abfd, bytes->e_syms);
399
  execp->a_entry  = GET_WORD (abfd, bytes->e_entry);
400
 
401
  if (GET_WORD (abfd, bytes->e_flag) & A_FLAG_RELOC_STRIPPED)
402
    {
403
      execp->a_trsize = 0;
404
      execp->a_drsize = 0;
405
    }
406
  else
407
    {
408
      execp->a_trsize = execp->a_text;
409
      execp->a_drsize = execp->a_data;
410
    }
411
}
412
#define NAME_swap_exec_header_in NAME (aout, swap_exec_header_in)
413
#endif
414
 
415
/*  Swap the information in an internal exec header structure
416
    "execp" into the buffer "bytes" ready for writing to disk.  */
417
void
418
NAME (aout, swap_exec_header_out) (bfd *abfd,
419
                                   struct internal_exec *execp,
420
                                   struct external_exec *bytes)
421
{
422
  /* Now fill in fields in the raw data, from the fields in the exec struct.  */
423
  PUT_MAGIC (abfd, execp->a_info,               bytes->e_info);
424
  PUT_WORD (abfd, execp->a_text,                bytes->e_text);
425
  PUT_WORD (abfd, execp->a_data,                bytes->e_data);
426
  PUT_WORD (abfd, execp->a_bss,                 bytes->e_bss);
427
  PUT_WORD (abfd, execp->a_syms,                bytes->e_syms);
428
  PUT_WORD (abfd, execp->a_entry,               bytes->e_entry);
429
  PUT_WORD (abfd, 0,                             bytes->e_unused);
430
 
431
  if ((execp->a_trsize == 0 || execp->a_text == 0)
432
      && (execp->a_drsize == 0 || execp->a_data == 0))
433
    PUT_WORD (abfd, A_FLAG_RELOC_STRIPPED, bytes->e_flag);
434
  else if (execp->a_trsize == execp->a_text
435
           && execp->a_drsize == execp->a_data)
436
    PUT_WORD (abfd, 0, bytes->e_flag);
437
  else
438
    {
439
      /* TODO: print a proper warning message.  */
440
      fprintf (stderr, "BFD:%s:%d: internal error\n", __FILE__, __LINE__);
441
      PUT_WORD (abfd, 0,                 bytes->e_flag);
442
    }
443
}
444
 
445
/* Make all the section for an a.out file.  */
446
 
447
bfd_boolean
448
NAME (aout, make_sections) (bfd *abfd)
449
{
450
  if (obj_textsec (abfd) == NULL && bfd_make_section (abfd, ".text") == NULL)
451
    return FALSE;
452
  if (obj_datasec (abfd) == NULL && bfd_make_section (abfd, ".data") == NULL)
453
    return FALSE;
454
  if (obj_bsssec (abfd) == NULL  && bfd_make_section (abfd, ".bss") == NULL)
455
    return FALSE;
456
  return TRUE;
457
}
458
 
459
/* Some a.out variant thinks that the file open in ABFD
460
   checking is an a.out file.  Do some more checking, and set up
461
   for access if it really is.  Call back to the calling
462
   environment's "finish up" function just before returning, to
463
   handle any last-minute setup.  */
464
 
465
const bfd_target *
466
NAME (aout, some_aout_object_p) (bfd *abfd,
467
                                 struct internal_exec *execp,
468
                                 const bfd_target *(*callback_to_real_object_p) (bfd *))
469
{
470
  struct aout_data_struct *rawptr, *oldrawptr;
471
  const bfd_target *result;
472
  bfd_size_type amt = sizeof (struct aout_data_struct);
473
 
474
  rawptr = bfd_zalloc (abfd, amt);
475
  if (rawptr == NULL)
476
    return 0;
477
 
478
  oldrawptr = abfd->tdata.aout_data;
479
  abfd->tdata.aout_data = rawptr;
480
 
481
  /* Copy the contents of the old tdata struct.
482
     In particular, we want the subformat, since for hpux it was set in
483
     hp300hpux.c:swap_exec_header_in and will be used in
484
     hp300hpux.c:callback.  */
485
  if (oldrawptr != NULL)
486
    *abfd->tdata.aout_data = *oldrawptr;
487
 
488
  abfd->tdata.aout_data->a.hdr = &rawptr->e;
489
  *(abfd->tdata.aout_data->a.hdr) = *execp;     /* Copy in the internal_exec struct.  */
490
  execp = abfd->tdata.aout_data->a.hdr;
491
 
492
  /* Set the file flags.  */
493
  abfd->flags = BFD_NO_FLAGS;
494
  if (execp->a_drsize || execp->a_trsize)
495
    abfd->flags |= HAS_RELOC;
496
  /* Setting of EXEC_P has been deferred to the bottom of this function.  */
497
  if (execp->a_syms)
498
    abfd->flags |= HAS_LINENO | HAS_DEBUG | HAS_SYMS | HAS_LOCALS;
499
  if (N_DYNAMIC(*execp))
500
    abfd->flags |= DYNAMIC;
501
 
502
  if (N_MAGIC (*execp) == ZMAGIC)
503
    {
504
      abfd->flags |= D_PAGED | WP_TEXT;
505
      adata (abfd).magic = z_magic;
506
    }
507
  else if (N_MAGIC (*execp) == NMAGIC)
508
    {
509
      abfd->flags |= WP_TEXT;
510
      adata (abfd).magic = n_magic;
511
    }
512
  else if (N_MAGIC (*execp) == OMAGIC)
513
    adata (abfd).magic = o_magic;
514
  else
515
    {
516
      /* Should have been checked with N_BADMAG before this routine
517
         was called.  */
518
      abort ();
519
    }
520
 
521
  bfd_get_start_address (abfd) = execp->a_entry;
522
 
523
  obj_aout_symbols (abfd) = NULL;
524
  bfd_get_symcount (abfd) = execp->a_syms / sizeof (struct external_nlist);
525
 
526
  /* The default relocation entry size is that of traditional V7 Unix.  */
527
  obj_reloc_entry_size (abfd) = RELOC_SIZE;
528
 
529
  /* The default symbol entry size is that of traditional Unix.  */
530
  obj_symbol_entry_size (abfd) = EXTERNAL_NLIST_SIZE;
531
 
532
#ifdef USE_MMAP
533
  bfd_init_window (&obj_aout_sym_window (abfd));
534
  bfd_init_window (&obj_aout_string_window (abfd));
535
#endif
536
 
537
  obj_aout_external_syms (abfd) = NULL;
538
  obj_aout_external_strings (abfd) = NULL;
539
  obj_aout_sym_hashes (abfd) = NULL;
540
 
541
  if (! NAME (aout, make_sections) (abfd))
542
    return NULL;
543
 
544
  obj_datasec (abfd)->size = execp->a_data;
545
  obj_bsssec (abfd)->size = execp->a_bss;
546
 
547
  obj_textsec (abfd)->flags =
548
    (execp->a_trsize != 0
549
     ? (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS | SEC_RELOC)
550
     : (SEC_ALLOC | SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS));
551
  obj_datasec (abfd)->flags =
552
    (execp->a_drsize != 0
553
     ? (SEC_ALLOC | SEC_LOAD | SEC_DATA | SEC_HAS_CONTENTS | SEC_RELOC)
554
     : (SEC_ALLOC | SEC_LOAD | SEC_DATA | SEC_HAS_CONTENTS));
555
  obj_bsssec (abfd)->flags = SEC_ALLOC;
556
 
557
#ifdef THIS_IS_ONLY_DOCUMENTATION
558
  /* The common code can't fill in these things because they depend
559
     on either the start address of the text segment, the rounding
560
     up of virtual addresses between segments, or the starting file
561
     position of the text segment -- all of which varies among different
562
     versions of a.out.  */
563
 
564
  /* Call back to the format-dependent code to fill in the rest of the
565
     fields and do any further cleanup.  Things that should be filled
566
     in by the callback:  */
567
  struct exec *execp = exec_hdr (abfd);
568
 
569
  obj_textsec (abfd)->size = N_TXTSIZE(*execp);
570
  /* Data and bss are already filled in since they're so standard.  */
571
 
572
  /* The virtual memory addresses of the sections.  */
573
  obj_textsec (abfd)->vma = N_TXTADDR(*execp);
574
  obj_datasec (abfd)->vma = N_DATADDR(*execp);
575
  obj_bsssec  (abfd)->vma = N_BSSADDR(*execp);
576
 
577
  /* The file offsets of the sections.  */
578
  obj_textsec (abfd)->filepos = N_TXTOFF(*execp);
579
  obj_datasec (abfd)->filepos = N_DATOFF(*execp);
580
 
581
  /* The file offsets of the relocation info.  */
582
  obj_textsec (abfd)->rel_filepos = N_TRELOFF(*execp);
583
  obj_datasec (abfd)->rel_filepos = N_DRELOFF(*execp);
584
 
585
  /* The file offsets of the string table and symbol table.  */
586
  obj_str_filepos (abfd) = N_STROFF (*execp);
587
  obj_sym_filepos (abfd) = N_SYMOFF (*execp);
588
 
589
  /* Determine the architecture and machine type of the object file.  */
590
  abfd->obj_arch = bfd_arch_obscure;
591
 
592
  adata(abfd)->page_size = TARGET_PAGE_SIZE;
593
  adata(abfd)->segment_size = SEGMENT_SIZE;
594
  adata(abfd)->exec_bytes_size = EXEC_BYTES_SIZE;
595
 
596
  return abfd->xvec;
597
 
598
  /* The architecture is encoded in various ways in various a.out variants,
599
     or is not encoded at all in some of them.  The relocation size depends
600
     on the architecture and the a.out variant.  Finally, the return value
601
     is the bfd_target vector in use.  If an error occurs, return zero and
602
     set bfd_error to the appropriate error code.
603
 
604
     Formats such as b.out, which have additional fields in the a.out
605
     header, should cope with them in this callback as well.  */
606
#endif  /* DOCUMENTATION */
607
 
608
  result = (*callback_to_real_object_p)(abfd);
609
 
610
  /* Now that the segment addresses have been worked out, take a better
611
     guess at whether the file is executable.  If the entry point
612
     is within the text segment, assume it is.  (This makes files
613
     executable even if their entry point address is 0, as long as
614
     their text starts at zero.).
615
 
616
     This test had to be changed to deal with systems where the text segment
617
     runs at a different location than the default.  The problem is that the
618
     entry address can appear to be outside the text segment, thus causing an
619
     erroneous conclusion that the file isn't executable.
620
 
621
     To fix this, we now accept any non-zero entry point as an indication of
622
     executability.  This will work most of the time, since only the linker
623
     sets the entry point, and that is likely to be non-zero for most systems. */
624
 
625
  if (execp->a_entry != 0
626
      || (execp->a_entry >= obj_textsec(abfd)->vma
627
          && execp->a_entry < obj_textsec(abfd)->vma + obj_textsec(abfd)->size))
628
    abfd->flags |= EXEC_P;
629
#ifdef STAT_FOR_EXEC
630
  else
631
    {
632
      struct stat stat_buf;
633
 
634
      /* The original heuristic doesn't work in some important cases.
635
        The a.out file has no information about the text start
636
        address.  For files (like kernels) linked to non-standard
637
        addresses (ld -Ttext nnn) the entry point may not be between
638
        the default text start (obj_textsec(abfd)->vma) and
639
        (obj_textsec(abfd)->vma) + text size.  This is not just a mach
640
        issue.  Many kernels are loaded at non standard addresses.  */
641
      if (abfd->iostream != NULL
642
          && (abfd->flags & BFD_IN_MEMORY) == 0
643
          && (fstat(fileno((FILE *) (abfd->iostream)), &stat_buf) == 0)
644
          && ((stat_buf.st_mode & 0111) != 0))
645
        abfd->flags |= EXEC_P;
646
    }
647
#endif /* STAT_FOR_EXEC */
648
 
649
  if (!result)
650
    {
651
      free (rawptr);
652
      abfd->tdata.aout_data = oldrawptr;
653
    }
654
  return result;
655
}
656
 
657
/* Initialize ABFD for use with a.out files.  */
658
 
659
bfd_boolean
660
NAME (aout, mkobject) (bfd *abfd)
661
{
662
  struct aout_data_struct  *rawptr;
663
  bfd_size_type amt = sizeof (struct aout_data_struct);
664
 
665
  bfd_set_error (bfd_error_system_call);
666
 
667
  /* Use an intermediate variable for clarity.  */
668
  rawptr = bfd_zalloc (abfd, amt);
669
 
670
  if (rawptr == NULL)
671
    return FALSE;
672
 
673
  abfd->tdata.aout_data = rawptr;
674
  exec_hdr (abfd) = &(rawptr->e);
675
 
676
  obj_textsec (abfd) = NULL;
677
  obj_datasec (abfd) = NULL;
678
  obj_bsssec (abfd)  = NULL;
679
 
680
  return TRUE;
681
}
682
 
683
/* Keep track of machine architecture and machine type for
684
   a.out's. Return the <<machine_type>> for a particular
685
   architecture and machine, or <<M_UNKNOWN>> if that exact architecture
686
   and machine can't be represented in a.out format.
687
 
688
   If the architecture is understood, machine type 0 (default)
689
   is always understood.  */
690
 
691
enum machine_type
692
NAME (aout, machine_type) (enum bfd_architecture arch,
693
                           unsigned long machine,
694
                           bfd_boolean *unknown)
695
{
696
  enum machine_type arch_flags;
697
 
698
  arch_flags = M_UNKNOWN;
699
  *unknown = TRUE;
700
 
701
  switch (arch)
702
    {
703
    case bfd_arch_sparc:
704
      if (machine == 0
705
          || machine == bfd_mach_sparc
706
          || machine == bfd_mach_sparc_sparclite
707
          || machine == bfd_mach_sparc_v9)
708
        arch_flags = M_SPARC;
709
      else if (machine == bfd_mach_sparc_sparclet)
710
        arch_flags = M_SPARCLET;
711
      break;
712
 
713
    case bfd_arch_m68k:
714
      switch (machine)
715
        {
716
        case 0:                arch_flags = M_68010; break;
717
        case bfd_mach_m68000: arch_flags = M_UNKNOWN; *unknown = FALSE; break;
718
        case bfd_mach_m68010: arch_flags = M_68010; break;
719
        case bfd_mach_m68020: arch_flags = M_68020; break;
720
        default:              arch_flags = M_UNKNOWN; break;
721
        }
722
      break;
723
 
724
    case bfd_arch_i386:
725
      if (machine == 0
726
          || machine == bfd_mach_i386_i386
727
          || machine == bfd_mach_i386_i386_intel_syntax)
728
        arch_flags = M_386;
729
      break;
730
 
731
    case bfd_arch_arm:
732
      if (machine == 0)  arch_flags = M_ARM;
733
      break;
734
 
735
    case bfd_arch_mips:
736
      switch (machine)
737
        {
738
        case 0:
739
        case 2000:
740
        case bfd_mach_mips3000:
741
          arch_flags = M_MIPS1;
742
          break;
743
        case bfd_mach_mips4000: /* MIPS3 */
744
        case bfd_mach_mips4400:
745
        case bfd_mach_mips8000: /* MIPS4 */
746
        case bfd_mach_mips6000: /* Real MIPS2: */
747
          arch_flags = M_MIPS2;
748
          break;
749
        default:
750
          arch_flags = M_UNKNOWN;
751
          break;
752
        }
753
      break;
754
 
755
    case bfd_arch_ns32k:
756
      switch (machine)
757
        {
758
        case 0:                  arch_flags = M_NS32532; break;
759
        case 32032:             arch_flags = M_NS32032; break;
760
        case 32532:             arch_flags = M_NS32532; break;
761
        default:                arch_flags = M_UNKNOWN; break;
762
        }
763
      break;
764
 
765
    case bfd_arch_pdp11:
766
      /* TODO: arch_flags = M_PDP11; */
767
      *unknown = FALSE;
768
      break;
769
 
770
    case bfd_arch_vax:
771
      *unknown = FALSE;
772
      break;
773
 
774
    default:
775
      arch_flags = M_UNKNOWN;
776
    }
777
 
778
  if (arch_flags != M_UNKNOWN)
779
    *unknown = FALSE;
780
 
781
  return arch_flags;
782
}
783
 
784
/* Set the architecture and the machine of the ABFD to the
785
   values ARCH and MACHINE.  Verify that @ABFD's format
786
   can support the architecture required.  */
787
 
788
bfd_boolean
789
NAME (aout, set_arch_mach) (bfd *abfd,
790
                            enum bfd_architecture arch,
791
                            unsigned long machine)
792
{
793
  if (! bfd_default_set_arch_mach (abfd, arch, machine))
794
    return FALSE;
795
 
796
  if (arch != bfd_arch_unknown)
797
    {
798
      bfd_boolean unknown;
799
 
800
      NAME (aout, machine_type) (arch, machine, &unknown);
801
      if (unknown)
802
        return FALSE;
803
    }
804
 
805
  obj_reloc_entry_size (abfd) = RELOC_SIZE;
806
 
807
  return (*aout_backend_info(abfd)->set_sizes) (abfd);
808
}
809
 
810
static void
811
adjust_o_magic (bfd *abfd, struct internal_exec *execp)
812
{
813
  file_ptr pos = adata (abfd).exec_bytes_size;
814
  bfd_vma vma = 0;
815
  int pad = 0;
816
 
817
  /* Text.  */
818
  obj_textsec (abfd)->filepos = pos;
819
  if (! obj_textsec (abfd)->user_set_vma)
820
    obj_textsec (abfd)->vma = vma;
821
  else
822
    vma = obj_textsec (abfd)->vma;
823
 
824
  pos += obj_textsec (abfd)->size;
825
  vma += obj_textsec (abfd)->size;
826
 
827
  /* Data.  */
828
  if (!obj_datasec (abfd)->user_set_vma)
829
    {
830
      obj_textsec (abfd)->size += pad;
831
      pos += pad;
832
      vma += pad;
833
      obj_datasec (abfd)->vma = vma;
834
    }
835
  else
836
    vma = obj_datasec (abfd)->vma;
837
  obj_datasec (abfd)->filepos = pos;
838
  pos += obj_datasec (abfd)->size;
839
  vma += obj_datasec (abfd)->size;
840
 
841
  /* BSS.  */
842
  if (! obj_bsssec (abfd)->user_set_vma)
843
    {
844
      obj_datasec (abfd)->size += pad;
845
      pos += pad;
846
      vma += pad;
847
      obj_bsssec (abfd)->vma = vma;
848
    }
849
  else
850
    {
851
      /* The VMA of the .bss section is set by the VMA of the
852
         .data section plus the size of the .data section.  We may
853
         need to add padding bytes to make this true.  */
854
      pad = obj_bsssec (abfd)->vma - vma;
855
      if (pad > 0)
856
        {
857
          obj_datasec (abfd)->size += pad;
858
          pos += pad;
859
        }
860
    }
861
  obj_bsssec (abfd)->filepos = pos;
862
 
863
  /* Fix up the exec header.  */
864
  execp->a_text = obj_textsec (abfd)->size;
865
  execp->a_data = obj_datasec (abfd)->size;
866
  execp->a_bss  = obj_bsssec (abfd)->size;
867
  N_SET_MAGIC (*execp, OMAGIC);
868
}
869
 
870
static void
871
adjust_z_magic (bfd *abfd, struct internal_exec *execp)
872
{
873
  bfd_size_type data_pad, text_pad;
874
  file_ptr text_end;
875
  const struct aout_backend_data *abdp;
876
  int ztih;                     /* Nonzero if text includes exec header.  */
877
 
878
  abdp = aout_backend_info (abfd);
879
 
880
  /* Text.  */
881
  ztih = (abdp != NULL
882
          && (abdp->text_includes_header
883
              || obj_aout_subformat (abfd) == q_magic_format));
884
  obj_textsec(abfd)->filepos = (ztih
885
                                ? adata(abfd).exec_bytes_size
886
                                : adata(abfd).zmagic_disk_block_size);
887
  if (! obj_textsec(abfd)->user_set_vma)
888
    {
889
      /* ?? Do we really need to check for relocs here?  */
890
      obj_textsec(abfd)->vma = ((abfd->flags & HAS_RELOC)
891
                                ? 0
892
                                : (ztih
893
                                   ? (abdp->default_text_vma
894
                                      + adata (abfd).exec_bytes_size)
895
                                   : abdp->default_text_vma));
896
      text_pad = 0;
897
    }
898
  else
899
    {
900
      /* The .text section is being loaded at an unusual address.  We
901
         may need to pad it such that the .data section starts at a page
902
         boundary.  */
903
      if (ztih)
904
        text_pad = ((obj_textsec (abfd)->filepos - obj_textsec (abfd)->vma)
905
                    & (adata (abfd).page_size - 1));
906
      else
907
        text_pad = ((- obj_textsec (abfd)->vma)
908
                    & (adata (abfd).page_size - 1));
909
    }
910
 
911
  /* Find start of data.  */
912
  if (ztih)
913
    {
914
      text_end = obj_textsec (abfd)->filepos + obj_textsec (abfd)->size;
915
      text_pad += BFD_ALIGN (text_end, adata (abfd).page_size) - text_end;
916
    }
917
  else
918
    {
919
      /* Note that if page_size == zmagic_disk_block_size, then
920
         filepos == page_size, and this case is the same as the ztih
921
         case.  */
922
      text_end = obj_textsec (abfd)->size;
923
      text_pad += BFD_ALIGN (text_end, adata (abfd).page_size) - text_end;
924
      text_end += obj_textsec (abfd)->filepos;
925
    }
926
 
927
  obj_textsec (abfd)->size += text_pad;
928
  text_end += text_pad;
929
 
930
  /* Data.  */
931
  if (!obj_datasec(abfd)->user_set_vma)
932
    {
933
      bfd_vma vma;
934
      vma = obj_textsec(abfd)->vma + obj_textsec(abfd)->size;
935
      obj_datasec(abfd)->vma = BFD_ALIGN (vma, adata(abfd).segment_size);
936
    }
937
  if (abdp && abdp->zmagic_mapped_contiguous)
938
    {
939
      text_pad = (obj_datasec(abfd)->vma
940
                  - obj_textsec(abfd)->vma
941
                  - obj_textsec(abfd)->size);
942
      obj_textsec(abfd)->size += text_pad;
943
    }
944
  obj_datasec (abfd)->filepos = (obj_textsec (abfd)->filepos
945
                                + obj_textsec (abfd)->size);
946
 
947
  /* Fix up exec header while we're at it.  */
948
  execp->a_text = obj_textsec(abfd)->size;
949
  if (ztih && (!abdp || (abdp && !abdp->exec_header_not_counted)))
950
    execp->a_text += adata(abfd).exec_bytes_size;
951
  N_SET_MAGIC (*execp, ZMAGIC);
952
 
953
  /* Spec says data section should be rounded up to page boundary.  */
954
  obj_datasec(abfd)->size
955
    = align_power (obj_datasec(abfd)->size,
956
                   obj_bsssec(abfd)->alignment_power);
957
  execp->a_data = BFD_ALIGN (obj_datasec(abfd)->size,
958
                             adata(abfd).page_size);
959
  data_pad = execp->a_data - obj_datasec(abfd)->size;
960
 
961
  /* BSS.  */
962
  if (!obj_bsssec(abfd)->user_set_vma)
963
    obj_bsssec(abfd)->vma = (obj_datasec(abfd)->vma
964
                             + obj_datasec(abfd)->size);
965
  /* If the BSS immediately follows the data section and extra space
966
     in the page is left after the data section, fudge data
967
     in the header so that the bss section looks smaller by that
968
     amount.  We'll start the bss section there, and lie to the OS.
969
     (Note that a linker script, as well as the above assignment,
970
     could have explicitly set the BSS vma to immediately follow
971
     the data section.)  */
972
  if (align_power (obj_bsssec(abfd)->vma, obj_bsssec(abfd)->alignment_power)
973
      == obj_datasec(abfd)->vma + obj_datasec(abfd)->size)
974
    execp->a_bss = (data_pad > obj_bsssec(abfd)->size) ? 0 :
975
      obj_bsssec(abfd)->size - data_pad;
976
  else
977
    execp->a_bss = obj_bsssec(abfd)->size;
978
}
979
 
980
static void
981
adjust_n_magic (bfd *abfd, struct internal_exec *execp)
982
{
983
  file_ptr pos = adata(abfd).exec_bytes_size;
984
  bfd_vma vma = 0;
985
  int pad;
986
 
987
  /* Text.  */
988
  obj_textsec(abfd)->filepos = pos;
989
  if (!obj_textsec(abfd)->user_set_vma)
990
    obj_textsec(abfd)->vma = vma;
991
  else
992
    vma = obj_textsec(abfd)->vma;
993
  pos += obj_textsec(abfd)->size;
994
  vma += obj_textsec(abfd)->size;
995
 
996
  /* Data.  */
997
  obj_datasec(abfd)->filepos = pos;
998
  if (!obj_datasec(abfd)->user_set_vma)
999
    obj_datasec(abfd)->vma = BFD_ALIGN (vma, adata(abfd).segment_size);
1000
  vma = obj_datasec(abfd)->vma;
1001
 
1002
  /* Since BSS follows data immediately, see if it needs alignment.  */
1003
  vma += obj_datasec(abfd)->size;
1004
  pad = align_power (vma, obj_bsssec(abfd)->alignment_power) - vma;
1005
  obj_datasec(abfd)->size += pad;
1006
  pos += obj_datasec(abfd)->size;
1007
 
1008
  /* BSS.  */
1009
  if (!obj_bsssec(abfd)->user_set_vma)
1010
    obj_bsssec(abfd)->vma = vma;
1011
  else
1012
    vma = obj_bsssec(abfd)->vma;
1013
 
1014
  /* Fix up exec header.  */
1015
  execp->a_text = obj_textsec(abfd)->size;
1016
  execp->a_data = obj_datasec(abfd)->size;
1017
  execp->a_bss = obj_bsssec(abfd)->size;
1018
  N_SET_MAGIC (*execp, NMAGIC);
1019
}
1020
 
1021
bfd_boolean
1022
NAME (aout, adjust_sizes_and_vmas) (bfd *abfd,
1023
                                    bfd_size_type *text_size,
1024
                                    file_ptr * text_end ATTRIBUTE_UNUSED)
1025
{
1026
  struct internal_exec *execp = exec_hdr (abfd);
1027
 
1028
  if (! NAME (aout, make_sections) (abfd))
1029
    return FALSE;
1030
 
1031
  if (adata(abfd).magic != undecided_magic)
1032
    return TRUE;
1033
 
1034
  obj_textsec(abfd)->size =
1035
    align_power(obj_textsec(abfd)->size,
1036
                obj_textsec(abfd)->alignment_power);
1037
 
1038
  *text_size = obj_textsec (abfd)->size;
1039
  /* Rule (heuristic) for when to pad to a new page.  Note that there
1040
     are (at least) two ways demand-paged (ZMAGIC) files have been
1041
     handled.  Most Berkeley-based systems start the text segment at
1042
     (TARGET_PAGE_SIZE).  However, newer versions of SUNOS start the text
1043
     segment right after the exec header; the latter is counted in the
1044
     text segment size, and is paged in by the kernel with the rest of
1045
     the text. */
1046
 
1047
  /* This perhaps isn't the right way to do this, but made it simpler for me
1048
     to understand enough to implement it.  Better would probably be to go
1049
     right from BFD flags to alignment/positioning characteristics.  But the
1050
     old code was sloppy enough about handling the flags, and had enough
1051
     other magic, that it was a little hard for me to understand.  I think
1052
     I understand it better now, but I haven't time to do the cleanup this
1053
     minute.  */
1054
 
1055
  if (abfd->flags & WP_TEXT)
1056
    adata(abfd).magic = n_magic;
1057
  else
1058
    adata(abfd).magic = o_magic;
1059
 
1060
#ifdef BFD_AOUT_DEBUG /* requires gcc2 */
1061
#if __GNUC__ >= 2
1062
  fprintf (stderr, "%s text=<%x,%x,%x> data=<%x,%x,%x> bss=<%x,%x,%x>\n",
1063
           ({ char *str;
1064
              switch (adata(abfd).magic) {
1065
              case n_magic: str = "NMAGIC"; break;
1066
              case o_magic: str = "OMAGIC"; break;
1067
              case z_magic: str = "ZMAGIC"; break;
1068
              default: abort ();
1069
              }
1070
              str;
1071
            }),
1072
           obj_textsec(abfd)->vma, obj_textsec(abfd)->size,
1073
                obj_textsec(abfd)->alignment_power,
1074
           obj_datasec(abfd)->vma, obj_datasec(abfd)->size,
1075
                obj_datasec(abfd)->alignment_power,
1076
           obj_bsssec(abfd)->vma, obj_bsssec(abfd)->size,
1077
                obj_bsssec(abfd)->alignment_power);
1078
#endif
1079
#endif
1080
 
1081
  switch (adata(abfd).magic)
1082
    {
1083
    case o_magic:
1084
      adjust_o_magic (abfd, execp);
1085
      break;
1086
    case z_magic:
1087
      adjust_z_magic (abfd, execp);
1088
      break;
1089
    case n_magic:
1090
      adjust_n_magic (abfd, execp);
1091
      break;
1092
    default:
1093
      abort ();
1094
    }
1095
 
1096
#ifdef BFD_AOUT_DEBUG
1097
  fprintf (stderr, "       text=<%x,%x,%x> data=<%x,%x,%x> bss=<%x,%x>\n",
1098
           obj_textsec(abfd)->vma, obj_textsec(abfd)->size,
1099
                obj_textsec(abfd)->filepos,
1100
           obj_datasec(abfd)->vma, obj_datasec(abfd)->size,
1101
                obj_datasec(abfd)->filepos,
1102
           obj_bsssec(abfd)->vma, obj_bsssec(abfd)->size);
1103
#endif
1104
 
1105
  return TRUE;
1106
}
1107
 
1108
/* Called by the BFD in response to a bfd_make_section request.  */
1109
 
1110
bfd_boolean
1111
NAME (aout, new_section_hook) (bfd *abfd, asection *newsect)
1112
{
1113
  /* Align to double at least.  */
1114
  newsect->alignment_power = bfd_get_arch_info(abfd)->section_align_power;
1115
 
1116
  if (bfd_get_format (abfd) == bfd_object)
1117
    {
1118
      if (obj_textsec (abfd) == NULL
1119
          && !strcmp (newsect->name, ".text"))
1120
        {
1121
          obj_textsec(abfd)= newsect;
1122
          newsect->target_index = N_TEXT;
1123
        }
1124
      else if (obj_datasec (abfd) == NULL
1125
               && !strcmp (newsect->name, ".data"))
1126
        {
1127
          obj_datasec (abfd) = newsect;
1128
          newsect->target_index = N_DATA;
1129
        }
1130
      else if (obj_bsssec (abfd) == NULL
1131
               && !strcmp (newsect->name, ".bss"))
1132
        {
1133
          obj_bsssec (abfd) = newsect;
1134
          newsect->target_index = N_BSS;
1135
        }
1136
    }
1137
 
1138
  /* We allow more than three sections internally.  */
1139
  return _bfd_generic_new_section_hook (abfd, newsect);
1140
}
1141
 
1142
bfd_boolean
1143
NAME (aout, set_section_contents) (bfd *abfd,
1144
                                   sec_ptr section,
1145
                                   const void * location,
1146
                                   file_ptr offset,
1147
                                   bfd_size_type count)
1148
{
1149
  file_ptr text_end;
1150
  bfd_size_type text_size;
1151
 
1152
  if (! abfd->output_has_begun)
1153
    {
1154
      if (! NAME (aout, adjust_sizes_and_vmas) (abfd, & text_size, & text_end))
1155
        return FALSE;
1156
    }
1157
 
1158
  if (section == obj_bsssec (abfd))
1159
    {
1160
      bfd_set_error (bfd_error_no_contents);
1161
      return FALSE;
1162
    }
1163
 
1164
  if (section != obj_textsec (abfd)
1165
      && section != obj_datasec (abfd))
1166
    {
1167
      (*_bfd_error_handler)
1168
        ("%s: can not represent section `%s' in a.out object file format",
1169
         bfd_get_filename (abfd), bfd_get_section_name (abfd, section));
1170
      bfd_set_error (bfd_error_nonrepresentable_section);
1171
      return FALSE;
1172
    }
1173
 
1174
  if (count != 0)
1175
    {
1176
      if (bfd_seek (abfd, section->filepos + offset, SEEK_SET) != 0
1177
          || bfd_bwrite (location, count, abfd) != count)
1178
        return FALSE;
1179
    }
1180
 
1181
  return TRUE;
1182
}
1183
 
1184
/* Read the external symbols from an a.out file.  */
1185
 
1186
static bfd_boolean
1187
aout_get_external_symbols (bfd *abfd)
1188
{
1189
  if (obj_aout_external_syms (abfd) == NULL)
1190
    {
1191
      bfd_size_type count;
1192
      struct external_nlist *syms;
1193
 
1194
      count = exec_hdr (abfd)->a_syms / EXTERNAL_NLIST_SIZE;
1195
 
1196
#ifdef USE_MMAP
1197
      if (! bfd_get_file_window (abfd, obj_sym_filepos (abfd),
1198
                                 exec_hdr (abfd)->a_syms,
1199
                                 &obj_aout_sym_window (abfd), TRUE))
1200
        return FALSE;
1201
      syms = (struct external_nlist *) obj_aout_sym_window (abfd).data;
1202
#else
1203
      /* We allocate using malloc to make the values easy to free
1204
         later on.  If we put them on the objalloc it might not be
1205
         possible to free them.  */
1206
      syms = bfd_malloc (count * EXTERNAL_NLIST_SIZE);
1207
      if (syms == NULL && count != 0)
1208
        return FALSE;
1209
 
1210
      if (bfd_seek (abfd, obj_sym_filepos (abfd), SEEK_SET) != 0
1211
          || (bfd_bread (syms, exec_hdr (abfd)->a_syms, abfd)
1212
              != exec_hdr (abfd)->a_syms))
1213
        {
1214
          free (syms);
1215
          return FALSE;
1216
        }
1217
#endif
1218
 
1219
      obj_aout_external_syms (abfd) = syms;
1220
      obj_aout_external_sym_count (abfd) = count;
1221
    }
1222
 
1223
  if (obj_aout_external_strings (abfd) == NULL
1224
      && exec_hdr (abfd)->a_syms != 0)
1225
    {
1226
      unsigned char string_chars[BYTES_IN_LONG];
1227
      bfd_size_type stringsize;
1228
      char *strings;
1229
 
1230
      /* Get the size of the strings.  */
1231
      if (bfd_seek (abfd, obj_str_filepos (abfd), SEEK_SET) != 0
1232
          || (bfd_bread ((void *) string_chars, (bfd_size_type) BYTES_IN_LONG,
1233
                        abfd) != BYTES_IN_LONG))
1234
        return FALSE;
1235
      stringsize = H_GET_32 (abfd, string_chars);
1236
 
1237
#ifdef USE_MMAP
1238
      if (! bfd_get_file_window (abfd, obj_str_filepos (abfd), stringsize,
1239
                                 &obj_aout_string_window (abfd), TRUE))
1240
        return FALSE;
1241
      strings = (char *) obj_aout_string_window (abfd).data;
1242
#else
1243
      strings = bfd_malloc (stringsize + 1);
1244
      if (strings == NULL)
1245
        return FALSE;
1246
 
1247
      /* Skip space for the string count in the buffer for convenience
1248
         when using indexes.  */
1249
      if (bfd_bread (strings + 4, stringsize - 4, abfd) != stringsize - 4)
1250
        {
1251
          free (strings);
1252
          return FALSE;
1253
        }
1254
#endif
1255
      /* Ensure that a zero index yields an empty string.  */
1256
      strings[0] = '\0';
1257
 
1258
      strings[stringsize - 1] = 0;
1259
 
1260
      obj_aout_external_strings (abfd) = strings;
1261
      obj_aout_external_string_size (abfd) = stringsize;
1262
    }
1263
 
1264
  return TRUE;
1265
}
1266
 
1267
/* Translate an a.out symbol into a BFD symbol.  The desc, other, type
1268
   and symbol->value fields of CACHE_PTR will be set from the a.out
1269
   nlist structure.  This function is responsible for setting
1270
   symbol->flags and symbol->section, and adjusting symbol->value.  */
1271
 
1272
static bfd_boolean
1273
translate_from_native_sym_flags (bfd *abfd,
1274
                                 aout_symbol_type *cache_ptr)
1275
{
1276
  flagword visible;
1277
 
1278
  if (cache_ptr->type == N_FN)
1279
    {
1280
      asection *sec;
1281
 
1282
      /* This is a debugging symbol.  */
1283
      cache_ptr->symbol.flags = BSF_DEBUGGING;
1284
 
1285
      /* Work out the symbol section.  */
1286
      switch (cache_ptr->type & N_TYPE)
1287
        {
1288
        case N_TEXT:
1289
        case N_FN:
1290
          sec = obj_textsec (abfd);
1291
          break;
1292
        case N_DATA:
1293
          sec = obj_datasec (abfd);
1294
          break;
1295
        case N_BSS:
1296
          sec = obj_bsssec (abfd);
1297
          break;
1298
        default:
1299
        case N_ABS:
1300
          sec = bfd_abs_section_ptr;
1301
          break;
1302
        }
1303
 
1304
      cache_ptr->symbol.section = sec;
1305
      cache_ptr->symbol.value -= sec->vma;
1306
 
1307
      return TRUE;
1308
    }
1309
 
1310
  /* Get the default visibility.  This does not apply to all types, so
1311
     we just hold it in a local variable to use if wanted.  */
1312
  if ((cache_ptr->type & N_EXT) == 0)
1313
    visible = BSF_LOCAL;
1314
  else
1315
    visible = BSF_GLOBAL;
1316
 
1317
  switch (cache_ptr->type)
1318
    {
1319
    default:
1320
    case N_ABS: case N_ABS | N_EXT:
1321
      cache_ptr->symbol.section = bfd_abs_section_ptr;
1322
      cache_ptr->symbol.flags = visible;
1323
      break;
1324
 
1325
    case N_UNDF | N_EXT:
1326
      if (cache_ptr->symbol.value != 0)
1327
        {
1328
          /* This is a common symbol.  */
1329
          cache_ptr->symbol.flags = BSF_GLOBAL;
1330
          cache_ptr->symbol.section = bfd_com_section_ptr;
1331
        }
1332
      else
1333
        {
1334
          cache_ptr->symbol.flags = 0;
1335
          cache_ptr->symbol.section = bfd_und_section_ptr;
1336
        }
1337
      break;
1338
 
1339
    case N_TEXT: case N_TEXT | N_EXT:
1340
      cache_ptr->symbol.section = obj_textsec (abfd);
1341
      cache_ptr->symbol.value -= cache_ptr->symbol.section->vma;
1342
      cache_ptr->symbol.flags = visible;
1343
      break;
1344
 
1345
    case N_DATA: case N_DATA | N_EXT:
1346
      cache_ptr->symbol.section = obj_datasec (abfd);
1347
      cache_ptr->symbol.value -= cache_ptr->symbol.section->vma;
1348
      cache_ptr->symbol.flags = visible;
1349
      break;
1350
 
1351
    case N_BSS: case N_BSS | N_EXT:
1352
      cache_ptr->symbol.section = obj_bsssec (abfd);
1353
      cache_ptr->symbol.value -= cache_ptr->symbol.section->vma;
1354
      cache_ptr->symbol.flags = visible;
1355
      break;
1356
    }
1357
 
1358
  return TRUE;
1359
}
1360
 
1361
/* Set the fields of SYM_POINTER according to CACHE_PTR.  */
1362
 
1363
static bfd_boolean
1364
translate_to_native_sym_flags (bfd *abfd,
1365
                               asymbol *cache_ptr,
1366
                               struct external_nlist *sym_pointer)
1367
{
1368
  bfd_vma value = cache_ptr->value;
1369
  asection *sec;
1370
  bfd_vma off;
1371
 
1372
  /* Mask out any existing type bits in case copying from one section
1373
     to another.  */
1374
  sym_pointer->e_type[0] &= ~N_TYPE;
1375
 
1376
  sec = bfd_get_section (cache_ptr);
1377
  off = 0;
1378
 
1379
  if (sec == NULL)
1380
    {
1381
      /* This case occurs, e.g., for the *DEBUG* section of a COFF
1382
         file.  */
1383
      (*_bfd_error_handler)
1384
        ("%B: can not represent section for symbol `%s' in a.out object file format",
1385
         abfd, cache_ptr->name != NULL ? cache_ptr->name : "*unknown*");
1386
      bfd_set_error (bfd_error_nonrepresentable_section);
1387
      return FALSE;
1388
    }
1389
 
1390
  if (sec->output_section != NULL)
1391
    {
1392
      off = sec->output_offset;
1393
      sec = sec->output_section;
1394
    }
1395
 
1396
  if (bfd_is_abs_section (sec))
1397
    sym_pointer->e_type[0] |= N_ABS;
1398
  else if (sec == obj_textsec (abfd))
1399
    sym_pointer->e_type[0] |= N_TEXT;
1400
  else if (sec == obj_datasec (abfd))
1401
    sym_pointer->e_type[0] |= N_DATA;
1402
  else if (sec == obj_bsssec (abfd))
1403
    sym_pointer->e_type[0] |= N_BSS;
1404
  else if (bfd_is_und_section (sec))
1405
    sym_pointer->e_type[0] = N_UNDF | N_EXT;
1406
  else if (bfd_is_com_section (sec))
1407
    sym_pointer->e_type[0] = N_UNDF | N_EXT;
1408
  else
1409
    {
1410
      (*_bfd_error_handler)
1411
        ("%B: can not represent section `%A' in a.out object file format",
1412
         abfd, sec);
1413
      bfd_set_error (bfd_error_nonrepresentable_section);
1414
      return FALSE;
1415
    }
1416
 
1417
  /* Turn the symbol from section relative to absolute again */
1418
  value += sec->vma + off;
1419
 
1420
  if ((cache_ptr->flags & BSF_DEBUGGING) != 0)
1421
    sym_pointer->e_type[0] = ((aout_symbol_type *) cache_ptr)->type;
1422
  else if ((cache_ptr->flags & BSF_GLOBAL) != 0)
1423
    sym_pointer->e_type[0] |= N_EXT;
1424
 
1425
  PUT_WORD(abfd, value, sym_pointer->e_value);
1426
 
1427
  return TRUE;
1428
}
1429
 
1430
/* Native-level interface to symbols. */
1431
 
1432
asymbol *
1433
NAME (aout, make_empty_symbol) (bfd *abfd)
1434
{
1435
  bfd_size_type amt = sizeof (aout_symbol_type);
1436
  aout_symbol_type *new_symbol_type = bfd_zalloc (abfd, amt);
1437
 
1438
  if (!new_symbol_type)
1439
    return NULL;
1440
  new_symbol_type->symbol.the_bfd = abfd;
1441
 
1442
  return &new_symbol_type->symbol;
1443
}
1444
 
1445
/* Translate a set of internal symbols into external symbols.  */
1446
 
1447
bfd_boolean
1448
NAME (aout, translate_symbol_table) (bfd *abfd,
1449
                                     aout_symbol_type *in,
1450
                                     struct external_nlist *ext,
1451
                                     bfd_size_type count,
1452
                                     char *str,
1453
                                     bfd_size_type strsize,
1454
                                     bfd_boolean dynamic)
1455
{
1456
  struct external_nlist *ext_end;
1457
 
1458
  ext_end = ext + count;
1459
  for (; ext < ext_end; ext++, in++)
1460
    {
1461
      bfd_vma x;
1462
 
1463
      x = GET_WORD (abfd, ext->e_strx);
1464
      in->symbol.the_bfd = abfd;
1465
 
1466
      /* For the normal symbols, the zero index points at the number
1467
         of bytes in the string table but is to be interpreted as the
1468
         null string.  For the dynamic symbols, the number of bytes in
1469
         the string table is stored in the __DYNAMIC structure and the
1470
         zero index points at an actual string.  */
1471
      if (x == 0 && ! dynamic)
1472
        in->symbol.name = "";
1473
      else if (x < strsize)
1474
        in->symbol.name = str + x;
1475
      else
1476
        return FALSE;
1477
 
1478
      in->symbol.value = GET_SWORD (abfd,  ext->e_value);
1479
      /* TODO: is 0 a safe value here?  */
1480
      in->desc = 0;
1481
      in->other = 0;
1482
      in->type = H_GET_8 (abfd,  ext->e_type);
1483
      in->symbol.udata.p = NULL;
1484
 
1485
      if (! translate_from_native_sym_flags (abfd, in))
1486
        return FALSE;
1487
 
1488
      if (dynamic)
1489
        in->symbol.flags |= BSF_DYNAMIC;
1490
    }
1491
 
1492
  return TRUE;
1493
}
1494
 
1495
/* We read the symbols into a buffer, which is discarded when this
1496
   function exits.  We read the strings into a buffer large enough to
1497
   hold them all plus all the cached symbol entries.  */
1498
 
1499
bfd_boolean
1500
NAME (aout, slurp_symbol_table) (bfd *abfd)
1501
{
1502
  struct external_nlist *old_external_syms;
1503
  aout_symbol_type *cached;
1504
  bfd_size_type cached_size;
1505
 
1506
  /* If there's no work to be done, don't do any.  */
1507
  if (obj_aout_symbols (abfd) != NULL)
1508
    return TRUE;
1509
 
1510
  old_external_syms = obj_aout_external_syms (abfd);
1511
 
1512
  if (! aout_get_external_symbols (abfd))
1513
    return FALSE;
1514
 
1515
  cached_size = obj_aout_external_sym_count (abfd);
1516
  cached_size *= sizeof (aout_symbol_type);
1517
  cached = bfd_zmalloc (cached_size);
1518
  if (cached == NULL && cached_size != 0)
1519
    return FALSE;
1520
 
1521
  /* Convert from external symbol information to internal.  */
1522
  if (! (NAME (aout, translate_symbol_table)
1523
         (abfd, cached,
1524
          obj_aout_external_syms (abfd),
1525
          obj_aout_external_sym_count (abfd),
1526
          obj_aout_external_strings (abfd),
1527
          obj_aout_external_string_size (abfd),
1528
          FALSE)))
1529
    {
1530
      free (cached);
1531
      return FALSE;
1532
    }
1533
 
1534
  bfd_get_symcount (abfd) = obj_aout_external_sym_count (abfd);
1535
 
1536
  obj_aout_symbols (abfd) = cached;
1537
 
1538
  /* It is very likely that anybody who calls this function will not
1539
     want the external symbol information, so if it was allocated
1540
     because of our call to aout_get_external_symbols, we free it up
1541
     right away to save space.  */
1542
  if (old_external_syms == NULL
1543
      && obj_aout_external_syms (abfd) != NULL)
1544
    {
1545
#ifdef USE_MMAP
1546
      bfd_free_window (&obj_aout_sym_window (abfd));
1547
#else
1548
      free (obj_aout_external_syms (abfd));
1549
#endif
1550
      obj_aout_external_syms (abfd) = NULL;
1551
    }
1552
 
1553
  return TRUE;
1554
}
1555
 
1556
/* We use a hash table when writing out symbols so that we only write
1557
   out a particular string once.  This helps particularly when the
1558
   linker writes out stabs debugging entries, because each different
1559
   contributing object file tends to have many duplicate stabs
1560
   strings.
1561
 
1562
   This hash table code breaks dbx on SunOS 4.1.3, so we don't do it
1563
   if BFD_TRADITIONAL_FORMAT is set.  */
1564
 
1565
/* Get the index of a string in a strtab, adding it if it is not
1566
   already present.  */
1567
 
1568
static INLINE bfd_size_type
1569
add_to_stringtab (bfd *abfd,
1570
                  struct bfd_strtab_hash *tab,
1571
                  const char *str,
1572
                  bfd_boolean copy)
1573
{
1574
  bfd_boolean hash;
1575
  bfd_size_type index;
1576
 
1577
  /* An index of 0 always means the empty string.  */
1578
  if (str == 0 || *str == '\0')
1579
    return 0;
1580
 
1581
  /* Don't hash if BFD_TRADITIONAL_FORMAT is set, because SunOS dbx
1582
     doesn't understand a hashed string table.  */
1583
  hash = TRUE;
1584
  if ((abfd->flags & BFD_TRADITIONAL_FORMAT) != 0)
1585
    hash = FALSE;
1586
 
1587
  index = _bfd_stringtab_add (tab, str, hash, copy);
1588
 
1589
  if (index != (bfd_size_type) -1)
1590
    /* Add BYTES_IN_LONG to the return value to account for the
1591
       space taken up by the string table size.  */
1592
    index += BYTES_IN_LONG;
1593
 
1594
  return index;
1595
}
1596
 
1597
/* Write out a strtab.  ABFD is already at the right location in the
1598
   file.  */
1599
 
1600
static bfd_boolean
1601
emit_stringtab (bfd *abfd, struct bfd_strtab_hash *tab)
1602
{
1603
  bfd_byte buffer[BYTES_IN_LONG];
1604
 
1605
  /* The string table starts with the size.  */
1606
  H_PUT_32 (abfd, _bfd_stringtab_size (tab) + BYTES_IN_LONG, buffer);
1607
  if (bfd_bwrite ((void *) buffer, (bfd_size_type) BYTES_IN_LONG, abfd)
1608
      != BYTES_IN_LONG)
1609
    return FALSE;
1610
 
1611
  return _bfd_stringtab_emit (abfd, tab);
1612
}
1613
 
1614
bfd_boolean
1615
NAME (aout, write_syms) (bfd *abfd)
1616
{
1617
  unsigned int count ;
1618
  asymbol **generic = bfd_get_outsymbols (abfd);
1619
  struct bfd_strtab_hash *strtab;
1620
 
1621
  strtab = _bfd_stringtab_init ();
1622
  if (strtab == NULL)
1623
    return FALSE;
1624
 
1625
  for (count = 0; count < bfd_get_symcount (abfd); count++)
1626
    {
1627
      asymbol *g = generic[count];
1628
      bfd_size_type indx;
1629
      struct external_nlist nsp;
1630
 
1631
      PUT_WORD (abfd, 0, nsp.e_unused);
1632
 
1633
      indx = add_to_stringtab (abfd, strtab, g->name, FALSE);
1634
      if (indx == (bfd_size_type) -1)
1635
        goto error_return;
1636
      PUT_WORD (abfd, indx, nsp.e_strx);
1637
 
1638
      if (bfd_asymbol_flavour(g) == abfd->xvec->flavour)
1639
        H_PUT_8 (abfd, aout_symbol(g)->type,  nsp.e_type);
1640
      else
1641
        H_PUT_8 (abfd, 0, nsp.e_type);
1642
 
1643
      if (! translate_to_native_sym_flags (abfd, g, &nsp))
1644
        goto error_return;
1645
 
1646
      H_PUT_8 (abfd, 0, nsp.e_ovly);
1647
 
1648
      if (bfd_bwrite ((void *)&nsp, (bfd_size_type) EXTERNAL_NLIST_SIZE, abfd)
1649
          != EXTERNAL_NLIST_SIZE)
1650
        goto error_return;
1651
 
1652
      /* NB: `KEEPIT' currently overlays `udata.p', so set this only
1653
         here, at the end.  */
1654
      g->KEEPIT = count;
1655
    }
1656
 
1657
  if (! emit_stringtab (abfd, strtab))
1658
    goto error_return;
1659
 
1660
  _bfd_stringtab_free (strtab);
1661
 
1662
  return TRUE;
1663
 
1664
error_return:
1665
  _bfd_stringtab_free (strtab);
1666
  return FALSE;
1667
}
1668
 
1669
 
1670
long
1671
NAME (aout, canonicalize_symtab) (bfd *abfd, asymbol **location)
1672
{
1673
  unsigned int counter = 0;
1674
  aout_symbol_type *symbase;
1675
 
1676
  if (!NAME (aout, slurp_symbol_table) (abfd))
1677
    return -1;
1678
 
1679
  for (symbase = obj_aout_symbols (abfd); counter++ < bfd_get_symcount (abfd);)
1680
    *(location++) = (asymbol *)(symbase++);
1681
  *location++ =0;
1682
  return bfd_get_symcount (abfd);
1683
}
1684
 
1685
 
1686
/* Output extended relocation information to a file in target byte order.  */
1687
 
1688
static void
1689
pdp11_aout_swap_reloc_out (bfd *abfd, arelent *g, bfd_byte *natptr)
1690
{
1691
  int r_index;
1692
  int r_pcrel;
1693
  int reloc_entry;
1694
  int r_type;
1695
  asymbol *sym = *(g->sym_ptr_ptr);
1696
  asection *output_section = sym->section->output_section;
1697
 
1698
  if (g->addend != 0)
1699
    fprintf (stderr, "BFD: can't do this reloc addend stuff\n");
1700
 
1701
  r_pcrel = g->howto->pc_relative;
1702
 
1703
  if (bfd_is_abs_section (output_section))
1704
    r_type = RABS;
1705
  else if (output_section == obj_textsec (abfd))
1706
    r_type = RTEXT;
1707
  else if (output_section == obj_datasec (abfd))
1708
    r_type = RDATA;
1709
  else if (output_section == obj_bsssec (abfd))
1710
    r_type = RBSS;
1711
  else if (bfd_is_und_section (output_section))
1712
    r_type = REXT;
1713
  else if (bfd_is_com_section (output_section))
1714
    r_type = REXT;
1715
  else
1716
    r_type = -1;
1717
 
1718
  BFD_ASSERT (r_type != -1);
1719
 
1720
  if (r_type == RABS)
1721
    r_index = 0;
1722
  else
1723
    r_index = (*(g->sym_ptr_ptr))->KEEPIT;
1724
 
1725
  reloc_entry = r_index << 4 | r_type | r_pcrel;
1726
 
1727
  PUT_WORD (abfd, reloc_entry, natptr);
1728
}
1729
 
1730
/* BFD deals internally with all things based from the section they're
1731
   in. so, something in 10 bytes into a text section  with a base of
1732
   50 would have a symbol (.text+10) and know .text vma was 50.
1733
 
1734
   Aout keeps all it's symbols based from zero, so the symbol would
1735
   contain 60. This macro subs the base of each section from the value
1736
   to give the true offset from the section */
1737
 
1738
 
1739
#define MOVE_ADDRESS(ad)                                                \
1740
  if (r_extern)                                                         \
1741
    {                                                                   \
1742
      /* Undefined symbol.  */                                          \
1743
      cache_ptr->sym_ptr_ptr = symbols + r_index;                       \
1744
      cache_ptr->addend = ad;                                           \
1745
    }                                                                   \
1746
  else                                                                  \
1747
    {                                                                   \
1748
      /* Defined, section relative. replace symbol with pointer to      \
1749
         symbol which points to section.  */                            \
1750
      switch (r_index)                                                  \
1751
        {                                                               \
1752
        case N_TEXT:                                                    \
1753
        case N_TEXT | N_EXT:                                            \
1754
          cache_ptr->sym_ptr_ptr  = obj_textsec (abfd)->symbol_ptr_ptr; \
1755
          cache_ptr->addend = ad  - su->textsec->vma;                   \
1756
          break;                                                        \
1757
        case N_DATA:                                                    \
1758
        case N_DATA | N_EXT:                                            \
1759
          cache_ptr->sym_ptr_ptr  = obj_datasec (abfd)->symbol_ptr_ptr; \
1760
          cache_ptr->addend = ad - su->datasec->vma;                    \
1761
          break;                                                        \
1762
        case N_BSS:                                                     \
1763
        case N_BSS | N_EXT:                                             \
1764
          cache_ptr->sym_ptr_ptr  = obj_bsssec (abfd)->symbol_ptr_ptr;  \
1765
          cache_ptr->addend = ad - su->bsssec->vma;                     \
1766
          break;                                                        \
1767
        default:                                                        \
1768
        case N_ABS:                                                     \
1769
        case N_ABS | N_EXT:                                             \
1770
          cache_ptr->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr; \
1771
          cache_ptr->addend = ad;                                       \
1772
          break;                                                        \
1773
        }                                                               \
1774
    }
1775
 
1776
static void
1777
pdp11_aout_swap_reloc_in (bfd *          abfd,
1778
                          bfd_byte *     bytes,
1779
                          arelent *      cache_ptr,
1780
                          bfd_size_type  offset,
1781
                          asymbol **     symbols,
1782
                          bfd_size_type  symcount)
1783
{
1784
  struct aoutdata *su = &(abfd->tdata.aout_data->a);
1785
  unsigned int r_index;
1786
  int reloc_entry;
1787
  int r_extern;
1788
  int r_pcrel;
1789
 
1790
  reloc_entry = GET_WORD (abfd, (void *) bytes);
1791
 
1792
  r_pcrel = reloc_entry & RELFLG;
1793
 
1794
  cache_ptr->address = offset;
1795
  cache_ptr->howto = howto_table_pdp11 + (r_pcrel ? 1 : 0);
1796
 
1797
  if ((reloc_entry & RTYPE) == RABS)
1798
    r_index = N_ABS;
1799
  else
1800
    r_index = RINDEX (reloc_entry);
1801
 
1802
  /* r_extern reflects whether the symbol the reloc is against is
1803
     local or global.  */
1804
  r_extern = (reloc_entry & RTYPE) == REXT;
1805
 
1806
  if (r_extern && r_index > symcount)
1807
    {
1808
      /* We could arrange to return an error, but it might be useful
1809
         to see the file even if it is bad.  */
1810
      r_extern = 0;
1811
      r_index = N_ABS;
1812
    }
1813
 
1814
  MOVE_ADDRESS(0);
1815
}
1816
 
1817
/* Read and swap the relocs for a section.  */
1818
 
1819
bfd_boolean
1820
NAME (aout, slurp_reloc_table) (bfd *abfd, sec_ptr asect, asymbol **symbols)
1821
{
1822
  bfd_byte *rptr;
1823
  bfd_size_type count;
1824
  bfd_size_type reloc_size;
1825
  void * relocs;
1826
  arelent *reloc_cache;
1827
  size_t each_size;
1828
  unsigned int counter = 0;
1829
  arelent *cache_ptr;
1830
 
1831
  if (asect->relocation)
1832
    return TRUE;
1833
 
1834
  if (asect->flags & SEC_CONSTRUCTOR)
1835
    return TRUE;
1836
 
1837
  if (asect == obj_datasec (abfd))
1838
    reloc_size = exec_hdr(abfd)->a_drsize;
1839
  else if (asect == obj_textsec (abfd))
1840
    reloc_size = exec_hdr(abfd)->a_trsize;
1841
  else if (asect == obj_bsssec (abfd))
1842
    reloc_size = 0;
1843
  else
1844
    {
1845
      bfd_set_error (bfd_error_invalid_operation);
1846
      return FALSE;
1847
    }
1848
 
1849
  if (bfd_seek (abfd, asect->rel_filepos, SEEK_SET) != 0)
1850
    return FALSE;
1851
 
1852
  each_size = obj_reloc_entry_size (abfd);
1853
 
1854
  relocs = bfd_malloc (reloc_size);
1855
  if (relocs == NULL && reloc_size != 0)
1856
    return FALSE;
1857
 
1858
  if (bfd_bread (relocs, reloc_size, abfd) != reloc_size)
1859
    {
1860
      free (relocs);
1861
      return FALSE;
1862
    }
1863
 
1864
  count = reloc_size / each_size;
1865
 
1866
  /* Count the number of NON-ZERO relocs, this is the count we want.  */
1867
  {
1868
    unsigned int real_count = 0;
1869
 
1870
    for (counter = 0; counter < count; counter++)
1871
      {
1872
        int x;
1873
 
1874
        x = GET_WORD (abfd, (char *) relocs + each_size * counter);
1875
        if (x != 0)
1876
          real_count++;
1877
      }
1878
 
1879
    count = real_count;
1880
  }
1881
 
1882
  reloc_cache = bfd_zmalloc (count * sizeof (arelent));
1883
  if (reloc_cache == NULL && count != 0)
1884
    return FALSE;
1885
 
1886
  cache_ptr = reloc_cache;
1887
 
1888
  rptr = relocs;
1889
  for (counter = 0;
1890
       counter < count;
1891
       counter++, rptr += RELOC_SIZE, cache_ptr++)
1892
    {
1893
      while (GET_WORD (abfd, (void *) rptr) == 0)
1894
        {
1895
          rptr += RELOC_SIZE;
1896
          if ((char *) rptr >= (char *) relocs + reloc_size)
1897
            goto done;
1898
        }
1899
 
1900
      pdp11_aout_swap_reloc_in (abfd, rptr, cache_ptr,
1901
                                (bfd_size_type) ((char *) rptr - (char *) relocs),
1902
                                symbols,
1903
                                (bfd_size_type) bfd_get_symcount (abfd));
1904
    }
1905
 done:
1906
  /* Just in case, if rptr >= relocs + reloc_size should happen
1907
     too early.  */
1908
  BFD_ASSERT (counter == count);
1909
 
1910
  free (relocs);
1911
 
1912
  asect->relocation = reloc_cache;
1913
  asect->reloc_count = cache_ptr - reloc_cache;
1914
 
1915
  return TRUE;
1916
}
1917
 
1918
/* Write out a relocation section into an object file.  */
1919
 
1920
bfd_boolean
1921
NAME (aout, squirt_out_relocs) (bfd *abfd, asection *section)
1922
{
1923
  arelent **generic;
1924
  unsigned char *native;
1925
  unsigned int count = section->reloc_count;
1926
  bfd_size_type natsize;
1927
 
1928
  natsize = section->size;
1929
  native = bfd_zalloc (abfd, natsize);
1930
  if (!native)
1931
    return FALSE;
1932
 
1933
  generic = section->orelocation;
1934
  if (generic != NULL)
1935
    {
1936
      while (count > 0)
1937
        {
1938
          bfd_byte *r;
1939
 
1940
          r = native + (*generic)->address;
1941
          pdp11_aout_swap_reloc_out (abfd, *generic, r);
1942
          count--;
1943
          generic++;
1944
        }
1945
    }
1946
 
1947
  if (bfd_bwrite ((void *) native, natsize, abfd) != natsize)
1948
    {
1949
      bfd_release (abfd, native);
1950
      return FALSE;
1951
    }
1952
 
1953
  bfd_release (abfd, native);
1954
  return TRUE;
1955
}
1956
 
1957
/* This is stupid.  This function should be a boolean predicate.  */
1958
 
1959
long
1960
NAME (aout, canonicalize_reloc) (bfd *abfd,
1961
                                 sec_ptr section,
1962
                                 arelent **relptr,
1963
                                 asymbol **symbols)
1964
{
1965
  arelent *tblptr = section->relocation;
1966
  unsigned int count;
1967
 
1968
  if (section == obj_bsssec (abfd))
1969
    {
1970
      *relptr = NULL;
1971
      return 0;
1972
    }
1973
 
1974
  if (!(tblptr || NAME (aout, slurp_reloc_table)(abfd, section, symbols)))
1975
    return -1;
1976
 
1977
  if (section->flags & SEC_CONSTRUCTOR)
1978
    {
1979
      arelent_chain *chain = section->constructor_chain;
1980
 
1981
      for (count = 0; count < section->reloc_count; count ++)
1982
        {
1983
          *relptr ++ = &chain->relent;
1984
          chain = chain->next;
1985
        }
1986
    }
1987
  else
1988
    {
1989
      tblptr = section->relocation;
1990
 
1991
      for (count = 0; count++ < section->reloc_count;)
1992
        *relptr++ = tblptr++;
1993
    }
1994
 
1995
  *relptr = 0;
1996
 
1997
  return section->reloc_count;
1998
}
1999
 
2000
long
2001
NAME (aout, get_reloc_upper_bound) (bfd *abfd, sec_ptr asect)
2002
{
2003
  if (bfd_get_format (abfd) != bfd_object)
2004
    {
2005
      bfd_set_error (bfd_error_invalid_operation);
2006
      return -1;
2007
    }
2008
 
2009
  if (asect->flags & SEC_CONSTRUCTOR)
2010
    return (sizeof (arelent *) * (asect->reloc_count + 1));
2011
 
2012
  if (asect == obj_datasec (abfd))
2013
    return (sizeof (arelent *)
2014
            * ((exec_hdr (abfd)->a_drsize / obj_reloc_entry_size (abfd))
2015
               + 1));
2016
 
2017
  if (asect == obj_textsec (abfd))
2018
    return (sizeof (arelent *)
2019
            * ((exec_hdr (abfd)->a_trsize / obj_reloc_entry_size (abfd))
2020
               + 1));
2021
 
2022
  /* TODO: why are there two if statements for obj_bsssec()? */
2023
 
2024
  if (asect == obj_bsssec (abfd))
2025
    return sizeof (arelent *);
2026
 
2027
  if (asect == obj_bsssec (abfd))
2028
    return 0;
2029
 
2030
  bfd_set_error (bfd_error_invalid_operation);
2031
  return -1;
2032
}
2033
 
2034
 
2035
long
2036
NAME (aout, get_symtab_upper_bound) (bfd *abfd)
2037
{
2038
  if (!NAME (aout, slurp_symbol_table) (abfd))
2039
    return -1;
2040
 
2041
  return (bfd_get_symcount (abfd) + 1) * (sizeof (aout_symbol_type *));
2042
}
2043
 
2044
alent *
2045
NAME (aout, get_lineno) (bfd * abfd ATTRIBUTE_UNUSED,
2046
                         asymbol * symbol ATTRIBUTE_UNUSED)
2047
{
2048
  return NULL;
2049
}
2050
 
2051
void
2052
NAME (aout, get_symbol_info) (bfd * abfd ATTRIBUTE_UNUSED,
2053
                              asymbol *symbol,
2054
                              symbol_info *ret)
2055
{
2056
  bfd_symbol_info (symbol, ret);
2057
 
2058
  if (ret->type == '?')
2059
    {
2060
      int type_code = aout_symbol(symbol)->type & 0xff;
2061
      const char *stab_name = bfd_get_stab_name (type_code);
2062
      static char buf[10];
2063
 
2064
      if (stab_name == NULL)
2065
        {
2066
          sprintf(buf, "(%d)", type_code);
2067
          stab_name = buf;
2068
        }
2069
      ret->type = '-';
2070
      ret->stab_type  = type_code;
2071
      ret->stab_other = (unsigned) (aout_symbol(symbol)->other & 0xff);
2072
      ret->stab_desc  = (unsigned) (aout_symbol(symbol)->desc & 0xffff);
2073
      ret->stab_name  = stab_name;
2074
    }
2075
}
2076
 
2077
void
2078
NAME (aout, print_symbol) (bfd * abfd,
2079
                           void * afile,
2080
                           asymbol *symbol,
2081
                           bfd_print_symbol_type how)
2082
{
2083
  FILE *file = (FILE *) afile;
2084
 
2085
  switch (how)
2086
    {
2087
    case bfd_print_symbol_name:
2088
      if (symbol->name)
2089
        fprintf(file,"%s", symbol->name);
2090
      break;
2091
    case bfd_print_symbol_more:
2092
      fprintf(file,"%4x %2x %2x",
2093
              (unsigned) (aout_symbol (symbol)->desc & 0xffff),
2094
              (unsigned) (aout_symbol (symbol)->other & 0xff),
2095
              (unsigned) (aout_symbol (symbol)->type));
2096
      break;
2097
    case bfd_print_symbol_all:
2098
      {
2099
        const char *section_name = symbol->section->name;
2100
 
2101
        bfd_print_symbol_vandf (abfd, (void *) file, symbol);
2102
 
2103
        fprintf (file," %-5s %04x %02x %02x",
2104
                 section_name,
2105
                 (unsigned) (aout_symbol (symbol)->desc & 0xffff),
2106
                 (unsigned) (aout_symbol (symbol)->other & 0xff),
2107
                 (unsigned) (aout_symbol (symbol)->type  & 0xff));
2108
        if (symbol->name)
2109
          fprintf(file," %s", symbol->name);
2110
      }
2111
      break;
2112
    }
2113
}
2114
 
2115
/* If we don't have to allocate more than 1MB to hold the generic
2116
   symbols, we use the generic minisymbol method: it's faster, since
2117
   it only translates the symbols once, not multiple times.  */
2118
#define MINISYM_THRESHOLD (1000000 / sizeof (asymbol))
2119
 
2120
/* Read minisymbols.  For minisymbols, we use the unmodified a.out
2121
   symbols.  The minisymbol_to_symbol function translates these into
2122
   BFD asymbol structures.  */
2123
 
2124
long
2125
NAME (aout, read_minisymbols) (bfd *abfd,
2126
                               bfd_boolean dynamic,
2127
                               void * *minisymsp,
2128
                               unsigned int *sizep)
2129
{
2130
  if (dynamic)
2131
    /* We could handle the dynamic symbols here as well, but it's
2132
       easier to hand them off.  */
2133
    return _bfd_generic_read_minisymbols (abfd, dynamic, minisymsp, sizep);
2134
 
2135
  if (! aout_get_external_symbols (abfd))
2136
    return -1;
2137
 
2138
  if (obj_aout_external_sym_count (abfd) < MINISYM_THRESHOLD)
2139
    return _bfd_generic_read_minisymbols (abfd, dynamic, minisymsp, sizep);
2140
 
2141
  *minisymsp = (void *) obj_aout_external_syms (abfd);
2142
 
2143
  /* By passing the external symbols back from this routine, we are
2144
     giving up control over the memory block.  Clear
2145
     obj_aout_external_syms, so that we do not try to free it
2146
     ourselves.  */
2147
  obj_aout_external_syms (abfd) = NULL;
2148
 
2149
  *sizep = EXTERNAL_NLIST_SIZE;
2150
  return obj_aout_external_sym_count (abfd);
2151
}
2152
 
2153
/* Convert a minisymbol to a BFD asymbol.  A minisymbol is just an
2154
   unmodified a.out symbol.  The SYM argument is a structure returned
2155
   by bfd_make_empty_symbol, which we fill in here.  */
2156
 
2157
asymbol *
2158
NAME (aout, minisymbol_to_symbol) (bfd *abfd,
2159
                                   bfd_boolean dynamic,
2160
                                   const void * minisym,
2161
                                   asymbol *sym)
2162
{
2163
  if (dynamic
2164
      || obj_aout_external_sym_count (abfd) < MINISYM_THRESHOLD)
2165
    return _bfd_generic_minisymbol_to_symbol (abfd, dynamic, minisym, sym);
2166
 
2167
  memset (sym, 0, sizeof (aout_symbol_type));
2168
 
2169
  /* We call translate_symbol_table to translate a single symbol.  */
2170
  if (! (NAME (aout, translate_symbol_table)
2171
         (abfd,
2172
          (aout_symbol_type *) sym,
2173
          (struct external_nlist *) minisym,
2174
          (bfd_size_type) 1,
2175
          obj_aout_external_strings (abfd),
2176
          obj_aout_external_string_size (abfd),
2177
          FALSE)))
2178
    return NULL;
2179
 
2180
  return sym;
2181
}
2182
 
2183
/* Provided a BFD, a section and an offset into the section, calculate
2184
   and return the name of the source file and the line nearest to the
2185
   wanted location.  */
2186
 
2187
bfd_boolean
2188
NAME (aout, find_nearest_line) (bfd *abfd,
2189
                                asection *section,
2190
                                asymbol **symbols,
2191
                                bfd_vma offset,
2192
                                const char **filename_ptr,
2193
                                const char **functionname_ptr,
2194
                                unsigned int *line_ptr)
2195
{
2196
  /* Run down the file looking for the filename, function and linenumber.  */
2197
  asymbol **p;
2198
  const char *directory_name = NULL;
2199
  const char *main_file_name = NULL;
2200
  const char *current_file_name = NULL;
2201
  const char *line_file_name = NULL; /* Value of current_file_name at line number.  */
2202
  bfd_vma low_line_vma = 0;
2203
  bfd_vma low_func_vma = 0;
2204
  asymbol *func = 0;
2205
  size_t filelen, funclen;
2206
  char *buf;
2207
 
2208
  *filename_ptr = abfd->filename;
2209
  *functionname_ptr = 0;
2210
  *line_ptr = 0;
2211
 
2212
  if (symbols != NULL)
2213
    {
2214
      for (p = symbols; *p; p++)
2215
        {
2216
          aout_symbol_type  *q = (aout_symbol_type *)(*p);
2217
        next:
2218
          switch (q->type)
2219
            {
2220
            case N_TEXT:
2221
              /* If this looks like a file name symbol, and it comes after
2222
                 the line number we have found so far, but before the
2223
                 offset, then we have probably not found the right line
2224
                 number.  */
2225
              if (q->symbol.value <= offset
2226
                  && ((q->symbol.value > low_line_vma
2227
                       && (line_file_name != NULL
2228
                           || *line_ptr != 0))
2229
                      || (q->symbol.value > low_func_vma
2230
                          && func != NULL)))
2231
                {
2232
                  const char * symname;
2233
 
2234
                  symname = q->symbol.name;
2235
                  if (strcmp (symname + strlen (symname) - 2, ".o") == 0)
2236
                    {
2237
                      if (q->symbol.value > low_line_vma)
2238
                        {
2239
                          *line_ptr = 0;
2240
                          line_file_name = NULL;
2241
                        }
2242
                      if (q->symbol.value > low_func_vma)
2243
                        func = NULL;
2244
                    }
2245
                }
2246
              break;
2247
 
2248
            case N_SO:
2249
              /* If this symbol is less than the offset, but greater than
2250
                 the line number we have found so far, then we have not
2251
                 found the right line number.  */
2252
              if (q->symbol.value <= offset)
2253
                {
2254
                  if (q->symbol.value > low_line_vma)
2255
                    {
2256
                      *line_ptr = 0;
2257
                      line_file_name = NULL;
2258
                    }
2259
                  if (q->symbol.value > low_func_vma)
2260
                    func = NULL;
2261
                }
2262
 
2263
              main_file_name = current_file_name = q->symbol.name;
2264
              /* Look ahead to next symbol to check if that too is an N_SO.  */
2265
              p++;
2266
              if (*p == NULL)
2267
                break;
2268
              q = (aout_symbol_type *)(*p);
2269
              if (q->type != (int) N_SO)
2270
                goto next;
2271
 
2272
              /* Found a second N_SO  First is directory; second is filename.  */
2273
              directory_name = current_file_name;
2274
              main_file_name = current_file_name = q->symbol.name;
2275
              if (obj_textsec(abfd) != section)
2276
                goto done;
2277
              break;
2278
            case N_SOL:
2279
              current_file_name = q->symbol.name;
2280
              break;
2281
 
2282
            case N_SLINE:
2283
            case N_DSLINE:
2284
            case N_BSLINE:
2285
              /* We'll keep this if it resolves nearer than the one we have
2286
                 already.  */
2287
              if (q->symbol.value >= low_line_vma
2288
                  && q->symbol.value <= offset)
2289
                {
2290
                  *line_ptr = q->desc;
2291
                  low_line_vma = q->symbol.value;
2292
                  line_file_name = current_file_name;
2293
                }
2294
              break;
2295
 
2296
            case N_FUN:
2297
              {
2298
                /* We'll keep this if it is nearer than the one we have already.  */
2299
                if (q->symbol.value >= low_func_vma &&
2300
                    q->symbol.value <= offset)
2301
                  {
2302
                    low_func_vma = q->symbol.value;
2303
                    func = (asymbol *) q;
2304
                  }
2305
                else if (q->symbol.value > offset)
2306
                  goto done;
2307
              }
2308
              break;
2309
            }
2310
        }
2311
    }
2312
 
2313
 done:
2314
  if (*line_ptr != 0)
2315
    main_file_name = line_file_name;
2316
 
2317
  if (main_file_name == NULL
2318
      || main_file_name[0] == '/'
2319
      || directory_name == NULL)
2320
    filelen = 0;
2321
  else
2322
    filelen = strlen (directory_name) + strlen (main_file_name);
2323
  if (func == NULL)
2324
    funclen = 0;
2325
  else
2326
    funclen = strlen (bfd_asymbol_name (func));
2327
 
2328
  if (adata (abfd).line_buf != NULL)
2329
    free (adata (abfd).line_buf);
2330
  if (filelen + funclen == 0)
2331
    adata (abfd).line_buf = buf = NULL;
2332
  else
2333
    {
2334
      buf = bfd_malloc ((bfd_size_type) filelen + funclen + 3);
2335
      adata (abfd).line_buf = buf;
2336
      if (buf == NULL)
2337
        return FALSE;
2338
    }
2339
 
2340
  if (main_file_name != NULL)
2341
    {
2342
      if (main_file_name[0] == '/' || directory_name == NULL)
2343
        *filename_ptr = main_file_name;
2344
      else
2345
        {
2346
          sprintf (buf, "%s%s", directory_name, main_file_name);
2347
          *filename_ptr = buf;
2348
          buf += filelen + 1;
2349
        }
2350
    }
2351
 
2352
  if (func)
2353
    {
2354
      const char *function = func->name;
2355
      char *colon;
2356
 
2357
      /* The caller expects a symbol name.  We actually have a
2358
         function name, without the leading underscore.  Put the
2359
         underscore back in, so that the caller gets a symbol name.  */
2360
      if (bfd_get_symbol_leading_char (abfd) == '\0')
2361
        strcpy (buf, function);
2362
      else
2363
        {
2364
          buf[0] = bfd_get_symbol_leading_char (abfd);
2365
          strcpy (buf + 1, function);
2366
        }
2367
 
2368
      /* Have to remove : stuff.  */
2369
      colon = strchr (buf, ':');
2370
      if (colon != NULL)
2371
        *colon = '\0';
2372
      *functionname_ptr = buf;
2373
    }
2374
 
2375
  return TRUE;
2376
}
2377
 
2378
int
2379
NAME (aout, sizeof_headers) (bfd *abfd,
2380
                             struct bfd_link_info *info ATTRIBUTE_UNUSED)
2381
{
2382
  return adata (abfd).exec_bytes_size;
2383
}
2384
 
2385
/* Free all information we have cached for this BFD.  We can always
2386
   read it again later if we need it.  */
2387
 
2388
bfd_boolean
2389
NAME (aout, bfd_free_cached_info) (bfd *abfd)
2390
{
2391
  asection *o;
2392
 
2393
  if (bfd_get_format (abfd) != bfd_object)
2394
    return TRUE;
2395
 
2396
#define BFCI_FREE(x) if (x != NULL) { free (x); x = NULL; }
2397
  BFCI_FREE (obj_aout_symbols (abfd));
2398
 
2399
#ifdef USE_MMAP
2400
  obj_aout_external_syms (abfd) = 0;
2401
  bfd_free_window (&obj_aout_sym_window (abfd));
2402
  bfd_free_window (&obj_aout_string_window (abfd));
2403
  obj_aout_external_strings (abfd) = 0;
2404
#else
2405
  BFCI_FREE (obj_aout_external_syms (abfd));
2406
  BFCI_FREE (obj_aout_external_strings (abfd));
2407
#endif
2408
  for (o = abfd->sections; o != NULL; o = o->next)
2409
    BFCI_FREE (o->relocation);
2410
#undef BFCI_FREE
2411
 
2412
  return TRUE;
2413
}
2414
 
2415
/* Routine to create an entry in an a.out link hash table.  */
2416
 
2417
struct bfd_hash_entry *
2418
NAME (aout, link_hash_newfunc) (struct bfd_hash_entry *entry,
2419
                                struct bfd_hash_table *table,
2420
                                const char *string)
2421
{
2422
  struct aout_link_hash_entry *ret = (struct aout_link_hash_entry *) entry;
2423
 
2424
  /* Allocate the structure if it has not already been allocated by a
2425
     subclass.  */
2426
  if (ret == NULL)
2427
    ret = bfd_hash_allocate (table, sizeof (* ret));
2428
  if (ret == NULL)
2429
    return NULL;
2430
 
2431
  /* Call the allocation method of the superclass.  */
2432
  ret = (struct aout_link_hash_entry *)
2433
         _bfd_link_hash_newfunc ((struct bfd_hash_entry *) ret, table, string);
2434
  if (ret)
2435
    {
2436
      /* Set local fields.  */
2437
      ret->written = FALSE;
2438
      ret->indx = -1;
2439
    }
2440
 
2441
  return (struct bfd_hash_entry *) ret;
2442
}
2443
 
2444
/* Initialize an a.out link hash table.  */
2445
 
2446
bfd_boolean
2447
NAME (aout, link_hash_table_init) (struct aout_link_hash_table *table,
2448
                                   bfd *abfd,
2449
                                   struct bfd_hash_entry *(*newfunc) (struct bfd_hash_entry *,
2450
                                                                     struct bfd_hash_table *,
2451
                                                                     const char *),
2452
                                   unsigned int entsize)
2453
{
2454
  return _bfd_link_hash_table_init (&table->root, abfd, newfunc, entsize);
2455
}
2456
 
2457
/* Create an a.out link hash table.  */
2458
 
2459
struct bfd_link_hash_table *
2460
NAME (aout, link_hash_table_create) (bfd *abfd)
2461
{
2462
  struct aout_link_hash_table *ret;
2463
  bfd_size_type amt = sizeof (struct aout_link_hash_table);
2464
 
2465
  ret = bfd_alloc (abfd, amt);
2466
  if (ret == NULL)
2467
    return NULL;
2468
  if (! NAME (aout, link_hash_table_init) (ret, abfd,
2469
                                           NAME (aout, link_hash_newfunc),
2470
                                           sizeof (struct aout_link_hash_entry)))
2471
    {
2472
      free (ret);
2473
      return NULL;
2474
    }
2475
  return &ret->root;
2476
}
2477
 
2478
/* Free up the internal symbols read from an a.out file.  */
2479
 
2480
static bfd_boolean
2481
aout_link_free_symbols (bfd *abfd)
2482
{
2483
  if (obj_aout_external_syms (abfd) != NULL)
2484
    {
2485
#ifdef USE_MMAP
2486
      bfd_free_window (&obj_aout_sym_window (abfd));
2487
#else
2488
      free ((void *) obj_aout_external_syms (abfd));
2489
#endif
2490
      obj_aout_external_syms (abfd) = NULL;
2491
    }
2492
 
2493
  if (obj_aout_external_strings (abfd) != NULL)
2494
    {
2495
#ifdef USE_MMAP
2496
      bfd_free_window (&obj_aout_string_window (abfd));
2497
#else
2498
      free ((void *) obj_aout_external_strings (abfd));
2499
#endif
2500
      obj_aout_external_strings (abfd) = NULL;
2501
    }
2502
  return TRUE;
2503
}
2504
 
2505
/* Given an a.out BFD, add symbols to the global hash table as
2506
   appropriate.  */
2507
 
2508
bfd_boolean
2509
NAME (aout, link_add_symbols) (bfd *abfd, struct bfd_link_info *info)
2510
{
2511
  switch (bfd_get_format (abfd))
2512
    {
2513
    case bfd_object:
2514
      return aout_link_add_object_symbols (abfd, info);
2515
    case bfd_archive:
2516
      return _bfd_generic_link_add_archive_symbols
2517
        (abfd, info, aout_link_check_archive_element);
2518
    default:
2519
      bfd_set_error (bfd_error_wrong_format);
2520
      return FALSE;
2521
    }
2522
}
2523
 
2524
/* Add symbols from an a.out object file.  */
2525
 
2526
static bfd_boolean
2527
aout_link_add_object_symbols (bfd *abfd, struct bfd_link_info *info)
2528
{
2529
  if (! aout_get_external_symbols (abfd))
2530
    return FALSE;
2531
  if (! aout_link_add_symbols (abfd, info))
2532
    return FALSE;
2533
  if (! info->keep_memory)
2534
    {
2535
      if (! aout_link_free_symbols (abfd))
2536
        return FALSE;
2537
    }
2538
  return TRUE;
2539
}
2540
 
2541
/* Look through the internal symbols to see if this object file should
2542
   be included in the link.  We should include this object file if it
2543
   defines any symbols which are currently undefined.  If this object
2544
   file defines a common symbol, then we may adjust the size of the
2545
   known symbol but we do not include the object file in the link
2546
   (unless there is some other reason to include it).  */
2547
 
2548
static bfd_boolean
2549
aout_link_check_ar_symbols (bfd *abfd,
2550
                            struct bfd_link_info *info,
2551
                            bfd_boolean *pneeded)
2552
{
2553
  struct external_nlist *p;
2554
  struct external_nlist *pend;
2555
  char *strings;
2556
 
2557
  *pneeded = FALSE;
2558
 
2559
  /* Look through all the symbols.  */
2560
  p = obj_aout_external_syms (abfd);
2561
  pend = p + obj_aout_external_sym_count (abfd);
2562
  strings = obj_aout_external_strings (abfd);
2563
  for (; p < pend; p++)
2564
    {
2565
      int type = H_GET_8 (abfd, p->e_type);
2566
      const char *name;
2567
      struct bfd_link_hash_entry *h;
2568
 
2569
      /* Ignore symbols that are not externally visible.  This is an
2570
         optimization only, as we check the type more thoroughly
2571
         below.  */
2572
      if ((type & N_EXT) == 0
2573
          || type == N_FN)
2574
        continue;
2575
 
2576
      name = strings + GET_WORD (abfd, p->e_strx);
2577
      h = bfd_link_hash_lookup (info->hash, name, FALSE, FALSE, TRUE);
2578
 
2579
      /* We are only interested in symbols that are currently
2580
         undefined or common.  */
2581
      if (h == NULL
2582
          || (h->type != bfd_link_hash_undefined
2583
              && h->type != bfd_link_hash_common))
2584
        continue;
2585
 
2586
      if (type == (N_TEXT | N_EXT)
2587
          || type == (N_DATA | N_EXT)
2588
          || type == (N_BSS | N_EXT)
2589
          || type == (N_ABS | N_EXT))
2590
        {
2591
          /* This object file defines this symbol.  We must link it
2592
             in.  This is true regardless of whether the current
2593
             definition of the symbol is undefined or common.  If the
2594
             current definition is common, we have a case in which we
2595
             have already seen an object file including
2596
                 int a;
2597
             and this object file from the archive includes
2598
                 int a = 5;
2599
             In such a case we must include this object file.
2600
 
2601
             FIXME: The SunOS 4.1.3 linker will pull in the archive
2602
             element if the symbol is defined in the .data section,
2603
             but not if it is defined in the .text section.  That
2604
             seems a bit crazy to me, and I haven't implemented it.
2605
             However, it might be correct.  */
2606
          if (! (*info->callbacks->add_archive_element) (info, abfd, name))
2607
            return FALSE;
2608
          *pneeded = TRUE;
2609
          return TRUE;
2610
        }
2611
 
2612
      if (type == (N_UNDF | N_EXT))
2613
        {
2614
          bfd_vma value;
2615
 
2616
          value = GET_WORD (abfd, p->e_value);
2617
          if (value != 0)
2618
            {
2619
              /* This symbol is common in the object from the archive
2620
                 file.  */
2621
              if (h->type == bfd_link_hash_undefined)
2622
                {
2623
                  bfd *symbfd;
2624
                  unsigned int power;
2625
 
2626
                  symbfd = h->u.undef.abfd;
2627
                  if (symbfd == NULL)
2628
                    {
2629
                      /* This symbol was created as undefined from
2630
                         outside BFD.  We assume that we should link
2631
                         in the object file.  This is done for the -u
2632
                         option in the linker.  */
2633
                      if (! (*info->callbacks->add_archive_element)
2634
                          (info, abfd, name))
2635
                        return FALSE;
2636
                      *pneeded = TRUE;
2637
                      return TRUE;
2638
                    }
2639
                  /* Turn the current link symbol into a common
2640
                     symbol.  It is already on the undefs list.  */
2641
                  h->type = bfd_link_hash_common;
2642
                  h->u.c.p = bfd_hash_allocate (&info->hash->table,
2643
                                                sizeof (struct bfd_link_hash_common_entry));
2644
                  if (h->u.c.p == NULL)
2645
                    return FALSE;
2646
 
2647
                  h->u.c.size = value;
2648
 
2649
                  /* FIXME: This isn't quite right.  The maximum
2650
                     alignment of a common symbol should be set by the
2651
                     architecture of the output file, not of the input
2652
                     file.  */
2653
                  power = bfd_log2 (value);
2654
                  if (power > bfd_get_arch_info (abfd)->section_align_power)
2655
                    power = bfd_get_arch_info (abfd)->section_align_power;
2656
                  h->u.c.p->alignment_power = power;
2657
 
2658
                  h->u.c.p->section = bfd_make_section_old_way (symbfd,
2659
                                                                "COMMON");
2660
                }
2661
              else
2662
                {
2663
                  /* Adjust the size of the common symbol if
2664
                     necessary.  */
2665
                  if (value > h->u.c.size)
2666
                    h->u.c.size = value;
2667
                }
2668
            }
2669
        }
2670
    }
2671
 
2672
  /* We do not need this object file.  */
2673
  return TRUE;
2674
}
2675
 
2676
/* Check a single archive element to see if we need to include it in
2677
   the link.  *PNEEDED is set according to whether this element is
2678
   needed in the link or not.  This is called from
2679
   _bfd_generic_link_add_archive_symbols.  */
2680
 
2681
static bfd_boolean
2682
aout_link_check_archive_element (bfd *abfd,
2683
                                 struct bfd_link_info *info,
2684
                                 bfd_boolean *pneeded)
2685
{
2686
  if (! aout_get_external_symbols (abfd))
2687
    return FALSE;
2688
 
2689
  if (! aout_link_check_ar_symbols (abfd, info, pneeded))
2690
    return FALSE;
2691
 
2692
  if (*pneeded)
2693
    {
2694
      if (! aout_link_add_symbols (abfd, info))
2695
        return FALSE;
2696
    }
2697
 
2698
  if (! info->keep_memory || ! *pneeded)
2699
    {
2700
      if (! aout_link_free_symbols (abfd))
2701
        return FALSE;
2702
    }
2703
 
2704
  return TRUE;
2705
}
2706
 
2707
/* Add all symbols from an object file to the hash table.  */
2708
 
2709
static bfd_boolean
2710
aout_link_add_symbols (bfd *abfd, struct bfd_link_info *info)
2711
{
2712
  bfd_boolean (*add_one_symbol)
2713
    (struct bfd_link_info *, bfd *, const char *, flagword, asection *,
2714
     bfd_vma, const char *, bfd_boolean, bfd_boolean,
2715
     struct bfd_link_hash_entry **);
2716
  struct external_nlist *syms;
2717
  bfd_size_type sym_count;
2718
  char *strings;
2719
  bfd_boolean copy;
2720
  struct aout_link_hash_entry **sym_hash;
2721
  struct external_nlist *p;
2722
  struct external_nlist *pend;
2723
 
2724
  syms = obj_aout_external_syms (abfd);
2725
  sym_count = obj_aout_external_sym_count (abfd);
2726
  strings = obj_aout_external_strings (abfd);
2727
  if (info->keep_memory)
2728
    copy = FALSE;
2729
  else
2730
    copy = TRUE;
2731
 
2732
  if (aout_backend_info (abfd)->add_dynamic_symbols != NULL)
2733
    {
2734
      if (! ((*aout_backend_info (abfd)->add_dynamic_symbols)
2735
             (abfd, info, &syms, &sym_count, &strings)))
2736
        return FALSE;
2737
    }
2738
 
2739
  /* We keep a list of the linker hash table entries that correspond
2740
     to particular symbols.  We could just look them up in the hash
2741
     table, but keeping the list is more efficient.  Perhaps this
2742
     should be conditional on info->keep_memory.  */
2743
  sym_hash = bfd_alloc (abfd,
2744
                        sym_count * sizeof (struct aout_link_hash_entry *));
2745
  if (sym_hash == NULL && sym_count != 0)
2746
    return FALSE;
2747
  obj_aout_sym_hashes (abfd) = sym_hash;
2748
 
2749
  add_one_symbol = aout_backend_info (abfd)->add_one_symbol;
2750
  if (add_one_symbol == NULL)
2751
    add_one_symbol = _bfd_generic_link_add_one_symbol;
2752
 
2753
  p = syms;
2754
  pend = p + sym_count;
2755
  for (; p < pend; p++, sym_hash++)
2756
    {
2757
      int type;
2758
      const char *name;
2759
      bfd_vma value;
2760
      asection *section;
2761
      flagword flags;
2762
      const char *string;
2763
 
2764
      *sym_hash = NULL;
2765
 
2766
      type = H_GET_8 (abfd, p->e_type);
2767
 
2768
      name = strings + GET_WORD (abfd, p->e_strx);
2769
      value = GET_WORD (abfd, p->e_value);
2770
      flags = BSF_GLOBAL;
2771
      string = NULL;
2772
      switch (type)
2773
        {
2774
        default:
2775
          abort ();
2776
 
2777
        case N_UNDF:
2778
        case N_ABS:
2779
        case N_TEXT:
2780
        case N_DATA:
2781
        case N_BSS:
2782
        case N_REG:
2783
        case N_FN:
2784
          /* Ignore symbols that are not externally visible.  */
2785
          continue;
2786
 
2787
        case N_UNDF | N_EXT:
2788
          if (value == 0)
2789
            {
2790
              section = bfd_und_section_ptr;
2791
              flags = 0;
2792
            }
2793
          else
2794
            section = bfd_com_section_ptr;
2795
          break;
2796
        case N_ABS | N_EXT:
2797
          section = bfd_abs_section_ptr;
2798
          break;
2799
        case N_TEXT | N_EXT:
2800
          section = obj_textsec (abfd);
2801
          value -= bfd_get_section_vma (abfd, section);
2802
          break;
2803
        case N_DATA | N_EXT:
2804
          /* Treat N_SETV symbols as N_DATA symbol; see comment in
2805
             translate_from_native_sym_flags.  */
2806
          section = obj_datasec (abfd);
2807
          value -= bfd_get_section_vma (abfd, section);
2808
          break;
2809
        case N_BSS | N_EXT:
2810
          section = obj_bsssec (abfd);
2811
          value -= bfd_get_section_vma (abfd, section);
2812
          break;
2813
        }
2814
 
2815
      if (! ((*add_one_symbol)
2816
             (info, abfd, name, flags, section, value, string, copy, FALSE,
2817
              (struct bfd_link_hash_entry **) sym_hash)))
2818
        return FALSE;
2819
 
2820
      /* Restrict the maximum alignment of a common symbol based on
2821
         the architecture, since a.out has no way to represent
2822
         alignment requirements of a section in a .o file.  FIXME:
2823
         This isn't quite right: it should use the architecture of the
2824
         output file, not the input files.  */
2825
      if ((*sym_hash)->root.type == bfd_link_hash_common
2826
          && ((*sym_hash)->root.u.c.p->alignment_power >
2827
              bfd_get_arch_info (abfd)->section_align_power))
2828
        (*sym_hash)->root.u.c.p->alignment_power =
2829
          bfd_get_arch_info (abfd)->section_align_power;
2830
 
2831
      /* If this is a set symbol, and we are not building sets, then
2832
         it is possible for the hash entry to not have been set.  In
2833
         such a case, treat the symbol as not globally defined.  */
2834
      if ((*sym_hash)->root.type == bfd_link_hash_new)
2835
        {
2836
          BFD_ASSERT ((flags & BSF_CONSTRUCTOR) != 0);
2837
          *sym_hash = NULL;
2838
        }
2839
    }
2840
 
2841
  return TRUE;
2842
}
2843
 
2844
/* Look up an entry in an the header file hash table.  */
2845
 
2846
#define aout_link_includes_lookup(table, string, create, copy) \
2847
  ((struct aout_link_includes_entry *) \
2848
   bfd_hash_lookup (&(table)->root, (string), (create), (copy)))
2849
 
2850
/* The function to create a new entry in the header file hash table.  */
2851
 
2852
static struct bfd_hash_entry *
2853
aout_link_includes_newfunc (struct bfd_hash_entry *entry,
2854
                            struct bfd_hash_table *table,
2855
                            const char *string)
2856
{
2857
  struct aout_link_includes_entry * ret =
2858
    (struct aout_link_includes_entry *) entry;
2859
 
2860
  /* Allocate the structure if it has not already been allocated by a
2861
     subclass.  */
2862
  if (ret == NULL)
2863
    ret = bfd_hash_allocate (table,
2864
                             sizeof (struct aout_link_includes_entry));
2865
  if (ret == NULL)
2866
    return NULL;
2867
 
2868
  /* Call the allocation method of the superclass.  */
2869
  ret = ((struct aout_link_includes_entry *)
2870
         bfd_hash_newfunc ((struct bfd_hash_entry *) ret, table, string));
2871
  if (ret)
2872
    /* Set local fields.  */
2873
    ret->totals = NULL;
2874
 
2875
  return (struct bfd_hash_entry *) ret;
2876
}
2877
 
2878
static bfd_boolean
2879
aout_link_write_other_symbol (struct aout_link_hash_entry *h, void * data)
2880
{
2881
  struct aout_final_link_info *finfo = (struct aout_final_link_info *) data;
2882
  bfd *output_bfd;
2883
  int type;
2884
  bfd_vma val;
2885
  struct external_nlist outsym;
2886
  bfd_size_type indx;
2887
  bfd_size_type amt;
2888
 
2889
  if (h->root.type == bfd_link_hash_warning)
2890
    {
2891
      h = (struct aout_link_hash_entry *) h->root.u.i.link;
2892
      if (h->root.type == bfd_link_hash_new)
2893
        return TRUE;
2894
    }
2895
 
2896
  output_bfd = finfo->output_bfd;
2897
 
2898
  if (aout_backend_info (output_bfd)->write_dynamic_symbol != NULL)
2899
    {
2900
      if (! ((*aout_backend_info (output_bfd)->write_dynamic_symbol)
2901
             (output_bfd, finfo->info, h)))
2902
        {
2903
          /* FIXME: No way to handle errors.  */
2904
          abort ();
2905
        }
2906
    }
2907
 
2908
  if (h->written)
2909
    return TRUE;
2910
 
2911
  h->written = TRUE;
2912
 
2913
  /* An indx of -2 means the symbol must be written.  */
2914
  if (h->indx != -2
2915
      && (finfo->info->strip == strip_all
2916
          || (finfo->info->strip == strip_some
2917
              && bfd_hash_lookup (finfo->info->keep_hash, h->root.root.string,
2918
                                  FALSE, FALSE) == NULL)))
2919
    return TRUE;
2920
 
2921
  switch (h->root.type)
2922
    {
2923
    default:
2924
      abort ();
2925
      /* Avoid variable not initialized warnings.  */
2926
      return TRUE;
2927
    case bfd_link_hash_new:
2928
      /* This can happen for set symbols when sets are not being
2929
         built.  */
2930
      return TRUE;
2931
    case bfd_link_hash_undefined:
2932
      type = N_UNDF | N_EXT;
2933
      val = 0;
2934
      break;
2935
    case bfd_link_hash_defined:
2936
    case bfd_link_hash_defweak:
2937
      {
2938
        asection *sec;
2939
 
2940
        sec = h->root.u.def.section->output_section;
2941
        BFD_ASSERT (bfd_is_abs_section (sec)
2942
                    || sec->owner == output_bfd);
2943
        if (sec == obj_textsec (output_bfd))
2944
          type = h->root.type == bfd_link_hash_defined ? N_TEXT : N_WEAKT;
2945
        else if (sec == obj_datasec (output_bfd))
2946
          type = h->root.type == bfd_link_hash_defined ? N_DATA : N_WEAKD;
2947
        else if (sec == obj_bsssec (output_bfd))
2948
          type = h->root.type == bfd_link_hash_defined ? N_BSS : N_WEAKB;
2949
        else
2950
          type = h->root.type == bfd_link_hash_defined ? N_ABS : N_WEAKA;
2951
        type |= N_EXT;
2952
        val = (h->root.u.def.value
2953
               + sec->vma
2954
               + h->root.u.def.section->output_offset);
2955
      }
2956
      break;
2957
    case bfd_link_hash_common:
2958
      type = N_UNDF | N_EXT;
2959
      val = h->root.u.c.size;
2960
      break;
2961
    case bfd_link_hash_undefweak:
2962
      type = N_WEAKU;
2963
      val = 0;
2964
    case bfd_link_hash_indirect:
2965
    case bfd_link_hash_warning:
2966
      /* FIXME: Ignore these for now.  The circumstances under which
2967
         they should be written out are not clear to me.  */
2968
      return TRUE;
2969
    }
2970
 
2971
  H_PUT_8 (output_bfd, type, outsym.e_type);
2972
  indx = add_to_stringtab (output_bfd, finfo->strtab, h->root.root.string,
2973
                           FALSE);
2974
  if (indx == (bfd_size_type) -1)
2975
    /* FIXME: No way to handle errors.  */
2976
    abort ();
2977
 
2978
  PUT_WORD (output_bfd, indx, outsym.e_strx);
2979
  PUT_WORD (output_bfd, val, outsym.e_value);
2980
 
2981
  amt = EXTERNAL_NLIST_SIZE;
2982
  if (bfd_seek (output_bfd, finfo->symoff, SEEK_SET) != 0
2983
      || bfd_bwrite ((void *) &outsym, amt, output_bfd) != amt)
2984
    /* FIXME: No way to handle errors.  */
2985
    abort ();
2986
 
2987
  finfo->symoff += amt;
2988
  h->indx = obj_aout_external_sym_count (output_bfd);
2989
  ++obj_aout_external_sym_count (output_bfd);
2990
 
2991
  return TRUE;
2992
}
2993
 
2994
/* Handle a link order which is supposed to generate a reloc.  */
2995
 
2996
static bfd_boolean
2997
aout_link_reloc_link_order (struct aout_final_link_info *finfo,
2998
                            asection *o,
2999
                            struct bfd_link_order *p)
3000
{
3001
  struct bfd_link_order_reloc *pr;
3002
  int r_index;
3003
  int r_extern;
3004
  reloc_howto_type *howto;
3005
  file_ptr *reloff_ptr;
3006
  struct reloc_std_external srel;
3007
  void * rel_ptr;
3008
  bfd_size_type rel_size;
3009
 
3010
  pr = p->u.reloc.p;
3011
 
3012
  if (p->type == bfd_section_reloc_link_order)
3013
    {
3014
      r_extern = 0;
3015
      if (bfd_is_abs_section (pr->u.section))
3016
        r_index = N_ABS | N_EXT;
3017
      else
3018
        {
3019
          BFD_ASSERT (pr->u.section->owner == finfo->output_bfd);
3020
          r_index = pr->u.section->target_index;
3021
        }
3022
    }
3023
  else
3024
    {
3025
      struct aout_link_hash_entry *h;
3026
 
3027
      BFD_ASSERT (p->type == bfd_symbol_reloc_link_order);
3028
      r_extern = 1;
3029
      h = ((struct aout_link_hash_entry *)
3030
           bfd_wrapped_link_hash_lookup (finfo->output_bfd, finfo->info,
3031
                                         pr->u.name, FALSE, FALSE, TRUE));
3032
      if (h != NULL
3033
          && h->indx >= 0)
3034
        r_index = h->indx;
3035
      else if (h != NULL)
3036
        {
3037
          /* We decided to strip this symbol, but it turns out that we
3038
             can't.  Note that we lose the other and desc information
3039
             here.  I don't think that will ever matter for a global
3040
             symbol.  */
3041
          h->indx = -2;
3042
          h->written = FALSE;
3043
          if (! aout_link_write_other_symbol (h, (void *) finfo))
3044
            return FALSE;
3045
          r_index = h->indx;
3046
        }
3047
      else
3048
        {
3049
          if (! ((*finfo->info->callbacks->unattached_reloc)
3050
                 (finfo->info, pr->u.name, NULL, NULL, (bfd_vma) 0)))
3051
            return FALSE;
3052
          r_index = 0;
3053
        }
3054
    }
3055
 
3056
  howto = bfd_reloc_type_lookup (finfo->output_bfd, pr->reloc);
3057
  if (howto == 0)
3058
    {
3059
      bfd_set_error (bfd_error_bad_value);
3060
      return FALSE;
3061
    }
3062
 
3063
  if (o == obj_textsec (finfo->output_bfd))
3064
    reloff_ptr = &finfo->treloff;
3065
  else if (o == obj_datasec (finfo->output_bfd))
3066
    reloff_ptr = &finfo->dreloff;
3067
  else
3068
    abort ();
3069
 
3070
#ifdef MY_put_reloc
3071
  MY_put_reloc(finfo->output_bfd, r_extern, r_index, p->offset, howto,
3072
               &srel);
3073
#else
3074
  {
3075
    int r_pcrel;
3076
    int r_baserel;
3077
    int r_jmptable;
3078
    int r_relative;
3079
    int r_length;
3080
 
3081
    fprintf (stderr, "TODO: line %d in bfd/pdp11.c\n", __LINE__);
3082
 
3083
    r_pcrel = howto->pc_relative;
3084
    r_baserel = (howto->type & 8) != 0;
3085
    r_jmptable = (howto->type & 16) != 0;
3086
    r_relative = (howto->type & 32) != 0;
3087
    r_length = howto->size;
3088
 
3089
    PUT_WORD (finfo->output_bfd, p->offset, srel.r_address);
3090
    if (bfd_header_big_endian (finfo->output_bfd))
3091
      {
3092
        srel.r_index[0] = r_index >> 16;
3093
        srel.r_index[1] = r_index >> 8;
3094
        srel.r_index[2] = r_index;
3095
        srel.r_type[0] =
3096
          ((r_extern ?     RELOC_STD_BITS_EXTERN_BIG : 0)
3097
           | (r_pcrel ?    RELOC_STD_BITS_PCREL_BIG : 0)
3098
           | (r_baserel ?  RELOC_STD_BITS_BASEREL_BIG : 0)
3099
           | (r_jmptable ? RELOC_STD_BITS_JMPTABLE_BIG : 0)
3100
           | (r_relative ? RELOC_STD_BITS_RELATIVE_BIG : 0)
3101
           | (r_length <<  RELOC_STD_BITS_LENGTH_SH_BIG));
3102
      }
3103
    else
3104
      {
3105
        srel.r_index[2] = r_index >> 16;
3106
        srel.r_index[1] = r_index >> 8;
3107
        srel.r_index[0] = r_index;
3108
        srel.r_type[0] =
3109
          ((r_extern ?     RELOC_STD_BITS_EXTERN_LITTLE : 0)
3110
           | (r_pcrel ?    RELOC_STD_BITS_PCREL_LITTLE : 0)
3111
           | (r_baserel ?  RELOC_STD_BITS_BASEREL_LITTLE : 0)
3112
           | (r_jmptable ? RELOC_STD_BITS_JMPTABLE_LITTLE : 0)
3113
           | (r_relative ? RELOC_STD_BITS_RELATIVE_LITTLE : 0)
3114
           | (r_length <<  RELOC_STD_BITS_LENGTH_SH_LITTLE));
3115
      }
3116
  }
3117
#endif
3118
  rel_ptr = (void *) &srel;
3119
 
3120
  /* We have to write the addend into the object file, since
3121
     standard a.out relocs are in place.  It would be more
3122
     reliable if we had the current contents of the file here,
3123
     rather than assuming zeroes, but we can't read the file since
3124
     it was opened using bfd_openw.  */
3125
  if (pr->addend != 0)
3126
    {
3127
      bfd_size_type size;
3128
      bfd_reloc_status_type r;
3129
      bfd_byte *buf;
3130
      bfd_boolean ok;
3131
 
3132
      size = bfd_get_reloc_size (howto);
3133
      buf = bfd_zmalloc (size);
3134
      if (buf == NULL)
3135
        return FALSE;
3136
      r = MY_relocate_contents (howto, finfo->output_bfd,
3137
                                pr->addend, buf);
3138
      switch (r)
3139
        {
3140
        case bfd_reloc_ok:
3141
          break;
3142
        default:
3143
        case bfd_reloc_outofrange:
3144
          abort ();
3145
        case bfd_reloc_overflow:
3146
          if (! ((*finfo->info->callbacks->reloc_overflow)
3147
                 (finfo->info, NULL,
3148
                  (p->type == bfd_section_reloc_link_order
3149
                   ? bfd_section_name (finfo->output_bfd,
3150
                                       pr->u.section)
3151
                   : pr->u.name),
3152
                  howto->name, pr->addend, NULL,
3153
                  (asection *) NULL, (bfd_vma) 0)))
3154
            {
3155
              free (buf);
3156
              return FALSE;
3157
            }
3158
          break;
3159
        }
3160
      ok = bfd_set_section_contents (finfo->output_bfd, o,
3161
                                     (void *) buf,
3162
                                     (file_ptr) p->offset,
3163
                                     size);
3164
      free (buf);
3165
      if (! ok)
3166
        return FALSE;
3167
    }
3168
 
3169
  rel_size = obj_reloc_entry_size (finfo->output_bfd);
3170
  if (bfd_seek (finfo->output_bfd, *reloff_ptr, SEEK_SET) != 0
3171
      || bfd_bwrite (rel_ptr, rel_size, finfo->output_bfd) != rel_size)
3172
    return FALSE;
3173
 
3174
  *reloff_ptr += rel_size;
3175
 
3176
  /* Assert that the relocs have not run into the symbols, and that n
3177
     the text relocs have not run into the data relocs.  */
3178
  BFD_ASSERT (*reloff_ptr <= obj_sym_filepos (finfo->output_bfd)
3179
              && (reloff_ptr != &finfo->treloff
3180
                  || (*reloff_ptr
3181
                      <= obj_datasec (finfo->output_bfd)->rel_filepos)));
3182
 
3183
  return TRUE;
3184
}
3185
 
3186
/* Get the section corresponding to a reloc index.  */
3187
 
3188
static inline asection *
3189
aout_reloc_type_to_section (bfd *abfd, int type)
3190
{
3191
  switch (type)
3192
    {
3193
    case RTEXT: return obj_textsec (abfd);
3194
    case RDATA: return obj_datasec (abfd);
3195
    case RBSS:  return obj_bsssec (abfd);
3196
    case RABS:  return bfd_abs_section_ptr;
3197
    case REXT:  return bfd_und_section_ptr;
3198
    default:    abort ();
3199
    }
3200
}
3201
 
3202
static bfd_boolean
3203
pdp11_aout_link_input_section (struct aout_final_link_info *finfo,
3204
                               bfd *input_bfd,
3205
                               asection *input_section,
3206
                               bfd_byte *relocs,
3207
                               bfd_size_type rel_size,
3208
                               bfd_byte *contents)
3209
{
3210
  bfd_boolean (*check_dynamic_reloc)
3211
    (struct bfd_link_info *, bfd *, asection *,
3212
     struct aout_link_hash_entry *, void *, bfd_byte *, bfd_boolean *,
3213
     bfd_vma *);
3214
  bfd *output_bfd;
3215
  bfd_boolean relocatable;
3216
  struct external_nlist *syms;
3217
  char *strings;
3218
  struct aout_link_hash_entry **sym_hashes;
3219
  int *symbol_map;
3220
  bfd_size_type reloc_count;
3221
  bfd_byte *rel;
3222
  bfd_byte *rel_end;
3223
 
3224
  output_bfd = finfo->output_bfd;
3225
  check_dynamic_reloc = aout_backend_info (output_bfd)->check_dynamic_reloc;
3226
 
3227
  BFD_ASSERT (obj_reloc_entry_size (input_bfd) == RELOC_SIZE);
3228
  BFD_ASSERT (input_bfd->xvec->header_byteorder
3229
              == output_bfd->xvec->header_byteorder);
3230
 
3231
  relocatable = finfo->info->relocatable;
3232
  syms = obj_aout_external_syms (input_bfd);
3233
  strings = obj_aout_external_strings (input_bfd);
3234
  sym_hashes = obj_aout_sym_hashes (input_bfd);
3235
  symbol_map = finfo->symbol_map;
3236
 
3237
  reloc_count = rel_size / RELOC_SIZE;
3238
  rel = relocs;
3239
  rel_end = rel + rel_size;
3240
  for (; rel < rel_end; rel += RELOC_SIZE)
3241
    {
3242
      bfd_vma r_addr;
3243
      int r_index;
3244
      int r_type;
3245
      int r_pcrel;
3246
      int r_extern;
3247
      reloc_howto_type *howto;
3248
      struct aout_link_hash_entry *h = NULL;
3249
      bfd_vma relocation;
3250
      bfd_reloc_status_type r;
3251
      int reloc_entry;
3252
 
3253
      reloc_entry = GET_WORD (input_bfd, (void *) rel);
3254
      if (reloc_entry == 0)
3255
        continue;
3256
 
3257
      {
3258
        unsigned int howto_idx;
3259
 
3260
        r_index = (reloc_entry & RIDXMASK) >> 4;
3261
        r_type = reloc_entry & RTYPE;
3262
        r_pcrel = reloc_entry & RELFLG;
3263
        r_addr = (char *) rel - (char *) relocs;
3264
 
3265
        r_extern = (r_type == REXT);
3266
 
3267
        howto_idx = r_pcrel;
3268
        BFD_ASSERT (howto_idx < TABLE_SIZE (howto_table_pdp11));
3269
        howto = howto_table_pdp11 + howto_idx;
3270
      }
3271
 
3272
      if (relocatable)
3273
        {
3274
          /* We are generating a relocatable output file, and must
3275
             modify the reloc accordingly.  */
3276
          if (r_extern)
3277
            {
3278
              /* If we know the symbol this relocation is against,
3279
                 convert it into a relocation against a section.  This
3280
                 is what the native linker does.  */
3281
              h = sym_hashes[r_index];
3282
              if (h != NULL
3283
                  && (h->root.type == bfd_link_hash_defined
3284
                      || h->root.type == bfd_link_hash_defweak))
3285
                {
3286
                  asection *output_section;
3287
 
3288
                  /* Compute a new r_index.  */
3289
                  output_section = h->root.u.def.section->output_section;
3290
                  if (output_section == obj_textsec (output_bfd))
3291
                    r_type = N_TEXT;
3292
                  else if (output_section == obj_datasec (output_bfd))
3293
                    r_type = N_DATA;
3294
                  else if (output_section == obj_bsssec (output_bfd))
3295
                    r_type = N_BSS;
3296
                  else
3297
                    r_type = N_ABS;
3298
 
3299
                  /* Add the symbol value and the section VMA to the
3300
                     addend stored in the contents.  */
3301
                  relocation = (h->root.u.def.value
3302
                                + output_section->vma
3303
                                + h->root.u.def.section->output_offset);
3304
                }
3305
              else
3306
                {
3307
                  /* We must change r_index according to the symbol
3308
                     map.  */
3309
                  r_index = symbol_map[r_index];
3310
 
3311
                  if (r_index == -1)
3312
                    {
3313
                      if (h != NULL)
3314
                        {
3315
                          /* We decided to strip this symbol, but it
3316
                             turns out that we can't.  Note that we
3317
                             lose the other and desc information here.
3318
                             I don't think that will ever matter for a
3319
                             global symbol.  */
3320
                          if (h->indx < 0)
3321
                            {
3322
                              h->indx = -2;
3323
                              h->written = FALSE;
3324
                              if (! aout_link_write_other_symbol (h,
3325
                                                                  (void *) finfo))
3326
                                return FALSE;
3327
                            }
3328
                          r_index = h->indx;
3329
                        }
3330
                      else
3331
                        {
3332
                          const char *name;
3333
 
3334
                          name = strings + GET_WORD (input_bfd,
3335
                                                     syms[r_index].e_strx);
3336
                          if (! ((*finfo->info->callbacks->unattached_reloc)
3337
                                 (finfo->info, name, input_bfd, input_section,
3338
                                  r_addr)))
3339
                            return FALSE;
3340
                          r_index = 0;
3341
                        }
3342
                    }
3343
 
3344
                  relocation = 0;
3345
                }
3346
 
3347
              /* Write out the new r_index value.  */
3348
              reloc_entry = GET_WORD (input_bfd, rel);
3349
              reloc_entry &= RIDXMASK;
3350
              reloc_entry |= r_index << 4;
3351
              PUT_WORD (input_bfd, reloc_entry, rel);
3352
            }
3353
          else
3354
            {
3355
              asection *section;
3356
 
3357
              /* This is a relocation against a section.  We must
3358
                 adjust by the amount that the section moved.  */
3359
              section = aout_reloc_type_to_section (input_bfd, r_type);
3360
              relocation = (section->output_section->vma
3361
                            + section->output_offset
3362
                            - section->vma);
3363
            }
3364
 
3365
          /* Change the address of the relocation.  */
3366
          fprintf (stderr, "TODO: change the address of the relocation\n");
3367
 
3368
          /* Adjust a PC relative relocation by removing the reference
3369
             to the original address in the section and including the
3370
             reference to the new address.  */
3371
          if (r_pcrel)
3372
            relocation -= (input_section->output_section->vma
3373
                           + input_section->output_offset
3374
                           - input_section->vma);
3375
 
3376
#ifdef MY_relocatable_reloc
3377
          MY_relocatable_reloc (howto, output_bfd, rel, relocation, r_addr);
3378
#endif
3379
 
3380
          if (relocation == 0)
3381
            r = bfd_reloc_ok;
3382
          else
3383
            r = MY_relocate_contents (howto,
3384
                                      input_bfd, relocation,
3385
                                      contents + r_addr);
3386
        }
3387
      else
3388
        {
3389
          bfd_boolean hundef;
3390
 
3391
          /* We are generating an executable, and must do a full
3392
             relocation.  */
3393
          hundef = FALSE;
3394
          if (r_extern)
3395
            {
3396
              h = sym_hashes[r_index];
3397
 
3398
              if (h != NULL
3399
                  && (h->root.type == bfd_link_hash_defined
3400
                      || h->root.type == bfd_link_hash_defweak))
3401
                {
3402
                  relocation = (h->root.u.def.value
3403
                                + h->root.u.def.section->output_section->vma
3404
                                + h->root.u.def.section->output_offset);
3405
                }
3406
              else if (h != NULL
3407
                       && h->root.type == bfd_link_hash_undefweak)
3408
                relocation = 0;
3409
              else
3410
                {
3411
                  hundef = TRUE;
3412
                  relocation = 0;
3413
                }
3414
            }
3415
          else
3416
            {
3417
              asection *section;
3418
 
3419
              section = aout_reloc_type_to_section (input_bfd, r_type);
3420
              relocation = (section->output_section->vma
3421
                            + section->output_offset
3422
                            - section->vma);
3423
              if (r_pcrel)
3424
                relocation += input_section->vma;
3425
            }
3426
 
3427
          if (check_dynamic_reloc != NULL)
3428
            {
3429
              bfd_boolean skip;
3430
 
3431
              if (! ((*check_dynamic_reloc)
3432
                     (finfo->info, input_bfd, input_section, h,
3433
                      (void *) rel, contents, &skip, &relocation)))
3434
                return FALSE;
3435
              if (skip)
3436
                continue;
3437
            }
3438
 
3439
          /* Now warn if a global symbol is undefined.  We could not
3440
             do this earlier, because check_dynamic_reloc might want
3441
             to skip this reloc.  */
3442
          if (hundef && ! finfo->info->shared)
3443
            {
3444
              const char *name;
3445
 
3446
              if (h != NULL)
3447
                name = h->root.root.string;
3448
              else
3449
                name = strings + GET_WORD (input_bfd, syms[r_index].e_strx);
3450
              if (! ((*finfo->info->callbacks->undefined_symbol)
3451
                     (finfo->info, name, input_bfd, input_section,
3452
                      r_addr, TRUE)))
3453
                return FALSE;
3454
            }
3455
 
3456
          r = MY_final_link_relocate (howto,
3457
                                      input_bfd, input_section,
3458
                                      contents, r_addr, relocation,
3459
                                      (bfd_vma) 0);
3460
        }
3461
 
3462
      if (r != bfd_reloc_ok)
3463
        {
3464
          switch (r)
3465
            {
3466
            default:
3467
            case bfd_reloc_outofrange:
3468
              abort ();
3469
            case bfd_reloc_overflow:
3470
              {
3471
                const char *name;
3472
 
3473
                if (h != NULL)
3474
                  name = NULL;
3475
                else if (r_extern)
3476
                  name = strings + GET_WORD (input_bfd,
3477
                                             syms[r_index].e_strx);
3478
                else
3479
                  {
3480
                    asection *s;
3481
 
3482
                    s = aout_reloc_type_to_section (input_bfd, r_type);
3483
                    name = bfd_section_name (input_bfd, s);
3484
                  }
3485
                if (! ((*finfo->info->callbacks->reloc_overflow)
3486
                       (finfo->info, (h ? &h->root : NULL), name,
3487
                        howto->name, (bfd_vma) 0, input_bfd,
3488
                        input_section, r_addr)))
3489
                  return FALSE;
3490
              }
3491
              break;
3492
            }
3493
        }
3494
    }
3495
 
3496
  return TRUE;
3497
}
3498
 
3499
/* Link an a.out section into the output file.  */
3500
 
3501
static bfd_boolean
3502
aout_link_input_section (struct aout_final_link_info *finfo,
3503
                         bfd *input_bfd,
3504
                         asection *input_section,
3505
                         file_ptr *reloff_ptr,
3506
                         bfd_size_type rel_size)
3507
{
3508
  bfd_size_type input_size;
3509
  void * relocs;
3510
 
3511
  /* Get the section contents.  */
3512
  input_size = input_section->size;
3513
  if (! bfd_get_section_contents (input_bfd, input_section,
3514
                                  (void *) finfo->contents,
3515
                                  (file_ptr) 0, input_size))
3516
    return FALSE;
3517
 
3518
  /* Read in the relocs if we haven't already done it.  */
3519
  if (aout_section_data (input_section) != NULL
3520
      && aout_section_data (input_section)->relocs != NULL)
3521
    relocs = aout_section_data (input_section)->relocs;
3522
  else
3523
    {
3524
      relocs = finfo->relocs;
3525
      if (rel_size > 0)
3526
        {
3527
          if (bfd_seek (input_bfd, input_section->rel_filepos, SEEK_SET) != 0
3528
              || bfd_bread (relocs, rel_size, input_bfd) != rel_size)
3529
            return FALSE;
3530
        }
3531
    }
3532
 
3533
  /* Relocate the section contents.  */
3534
  if (! pdp11_aout_link_input_section (finfo, input_bfd, input_section,
3535
                                       (bfd_byte *) relocs,
3536
                                       rel_size, finfo->contents))
3537
    return FALSE;
3538
 
3539
  /* Write out the section contents.  */
3540
  if (! bfd_set_section_contents (finfo->output_bfd,
3541
                                  input_section->output_section,
3542
                                  (void *) finfo->contents,
3543
                                  (file_ptr) input_section->output_offset,
3544
                                  input_size))
3545
    return FALSE;
3546
 
3547
  /* If we are producing relocatable output, the relocs were
3548
     modified, and we now write them out.  */
3549
  if (finfo->info->relocatable && rel_size > 0)
3550
    {
3551
      if (bfd_seek (finfo->output_bfd, *reloff_ptr, SEEK_SET) != 0)
3552
        return FALSE;
3553
      if (bfd_bwrite (relocs, rel_size, finfo->output_bfd) != rel_size)
3554
        return FALSE;
3555
      *reloff_ptr += rel_size;
3556
 
3557
      /* Assert that the relocs have not run into the symbols, and
3558
         that if these are the text relocs they have not run into the
3559
         data relocs.  */
3560
      BFD_ASSERT (*reloff_ptr <= obj_sym_filepos (finfo->output_bfd)
3561
                  && (reloff_ptr != &finfo->treloff
3562
                      || (*reloff_ptr
3563
                          <= obj_datasec (finfo->output_bfd)->rel_filepos)));
3564
    }
3565
 
3566
  return TRUE;
3567
}
3568
 
3569
/* Link an a.out input BFD into the output file.  */
3570
 
3571
static bfd_boolean
3572
aout_link_input_bfd (struct aout_final_link_info *finfo, bfd *input_bfd)
3573
{
3574
  bfd_size_type sym_count;
3575
 
3576
  BFD_ASSERT (bfd_get_format (input_bfd) == bfd_object);
3577
 
3578
  /* If this is a dynamic object, it may need special handling.  */
3579
  if ((input_bfd->flags & DYNAMIC) != 0
3580
      && aout_backend_info (input_bfd)->link_dynamic_object != NULL)
3581
    return ((*aout_backend_info (input_bfd)->link_dynamic_object)
3582
            (finfo->info, input_bfd));
3583
 
3584
  /* Get the symbols.  We probably have them already, unless
3585
     finfo->info->keep_memory is FALSE.  */
3586
  if (! aout_get_external_symbols (input_bfd))
3587
    return FALSE;
3588
 
3589
  sym_count = obj_aout_external_sym_count (input_bfd);
3590
 
3591
  /* Write out the symbols and get a map of the new indices.  The map
3592
     is placed into finfo->symbol_map.  */
3593
  if (! aout_link_write_symbols (finfo, input_bfd))
3594
    return FALSE;
3595
 
3596
  /* Relocate and write out the sections.  These functions use the
3597
     symbol map created by aout_link_write_symbols.  The linker_mark
3598
     field will be set if these sections are to be included in the
3599
     link, which will normally be the case.  */
3600
  if (obj_textsec (input_bfd)->linker_mark)
3601
    {
3602
      if (! aout_link_input_section (finfo, input_bfd,
3603
                                     obj_textsec (input_bfd),
3604
                                     &finfo->treloff,
3605
                                     exec_hdr (input_bfd)->a_trsize))
3606
        return FALSE;
3607
    }
3608
  if (obj_datasec (input_bfd)->linker_mark)
3609
    {
3610
      if (! aout_link_input_section (finfo, input_bfd,
3611
                                     obj_datasec (input_bfd),
3612
                                     &finfo->dreloff,
3613
                                     exec_hdr (input_bfd)->a_drsize))
3614
        return FALSE;
3615
    }
3616
 
3617
  /* If we are not keeping memory, we don't need the symbols any
3618
     longer.  We still need them if we are keeping memory, because the
3619
     strings in the hash table point into them.  */
3620
  if (! finfo->info->keep_memory)
3621
    {
3622
      if (! aout_link_free_symbols (input_bfd))
3623
        return FALSE;
3624
    }
3625
 
3626
  return TRUE;
3627
}
3628
 
3629
/* Do the final link step.  This is called on the output BFD.  The
3630
   INFO structure should point to a list of BFDs linked through the
3631
   link_next field which can be used to find each BFD which takes part
3632
   in the output.  Also, each section in ABFD should point to a list
3633
   of bfd_link_order structures which list all the input sections for
3634
   the output section.  */
3635
 
3636
bfd_boolean
3637
NAME (aout, final_link) (bfd *abfd,
3638
                         struct bfd_link_info *info,
3639
                         void (*callback) (bfd *, file_ptr *, file_ptr *, file_ptr *))
3640
{
3641
  struct aout_final_link_info aout_info;
3642
  bfd_boolean includes_hash_initialized = FALSE;
3643
  bfd *sub;
3644
  bfd_size_type trsize, drsize;
3645
  bfd_size_type max_contents_size;
3646
  bfd_size_type max_relocs_size;
3647
  bfd_size_type max_sym_count;
3648
  bfd_size_type text_size;
3649
  file_ptr text_end;
3650
  struct bfd_link_order *p;
3651
  asection *o;
3652
  bfd_boolean have_link_order_relocs;
3653
 
3654
  if (info->shared)
3655
    abfd->flags |= DYNAMIC;
3656
 
3657
  aout_info.info = info;
3658
  aout_info.output_bfd = abfd;
3659
  aout_info.contents = NULL;
3660
  aout_info.relocs = NULL;
3661
  aout_info.symbol_map = NULL;
3662
  aout_info.output_syms = NULL;
3663
 
3664
  if (!bfd_hash_table_init_n (&aout_info.includes.root,
3665
                              aout_link_includes_newfunc,
3666
                              sizeof (struct aout_link_includes_entry),
3667
                              251))
3668
    goto error_return;
3669
  includes_hash_initialized = TRUE;
3670
 
3671
  /* Figure out the largest section size.  Also, if generating
3672
     relocatable output, count the relocs.  */
3673
  trsize = 0;
3674
  drsize = 0;
3675
  max_contents_size = 0;
3676
  max_relocs_size = 0;
3677
  max_sym_count = 0;
3678
  for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
3679
    {
3680
      size_t sz;
3681
 
3682
      if (info->relocatable)
3683
        {
3684
          if (bfd_get_flavour (sub) == bfd_target_aout_flavour)
3685
            {
3686
              trsize += exec_hdr (sub)->a_trsize;
3687
              drsize += exec_hdr (sub)->a_drsize;
3688
            }
3689
          else
3690
            {
3691
              /* FIXME: We need to identify the .text and .data sections
3692
                 and call get_reloc_upper_bound and canonicalize_reloc to
3693
                 work out the number of relocs needed, and then multiply
3694
                 by the reloc size.  */
3695
              (*_bfd_error_handler)
3696
                ("%s: relocatable link from %s to %s not supported",
3697
                 bfd_get_filename (abfd),
3698
                 sub->xvec->name, abfd->xvec->name);
3699
              bfd_set_error (bfd_error_invalid_operation);
3700
              goto error_return;
3701
            }
3702
        }
3703
 
3704
      if (bfd_get_flavour (sub) == bfd_target_aout_flavour)
3705
        {
3706
          sz = obj_textsec (sub)->size;
3707
          if (sz > max_contents_size)
3708
            max_contents_size = sz;
3709
          sz = obj_datasec (sub)->size;
3710
          if (sz > max_contents_size)
3711
            max_contents_size = sz;
3712
 
3713
          sz = exec_hdr (sub)->a_trsize;
3714
          if (sz > max_relocs_size)
3715
            max_relocs_size = sz;
3716
          sz = exec_hdr (sub)->a_drsize;
3717
          if (sz > max_relocs_size)
3718
            max_relocs_size = sz;
3719
 
3720
          sz = obj_aout_external_sym_count (sub);
3721
          if (sz > max_sym_count)
3722
            max_sym_count = sz;
3723
        }
3724
    }
3725
 
3726
  if (info->relocatable)
3727
    {
3728
      if (obj_textsec (abfd) != NULL)
3729
        trsize += (_bfd_count_link_order_relocs (obj_textsec (abfd)
3730
                                                 ->map_head.link_order)
3731
                   * obj_reloc_entry_size (abfd));
3732
      if (obj_datasec (abfd) != NULL)
3733
        drsize += (_bfd_count_link_order_relocs (obj_datasec (abfd)
3734
                                                 ->map_head.link_order)
3735
                   * obj_reloc_entry_size (abfd));
3736
    }
3737
 
3738
  exec_hdr (abfd)->a_trsize = trsize;
3739
  exec_hdr (abfd)->a_drsize = drsize;
3740
  exec_hdr (abfd)->a_entry = bfd_get_start_address (abfd);
3741
 
3742
  /* Adjust the section sizes and vmas according to the magic number.
3743
     This sets a_text, a_data and a_bss in the exec_hdr and sets the
3744
     filepos for each section.  */
3745
  if (! NAME (aout, adjust_sizes_and_vmas) (abfd, &text_size, &text_end))
3746
    goto error_return;
3747
 
3748
  /* The relocation and symbol file positions differ among a.out
3749
     targets.  We are passed a callback routine from the backend
3750
     specific code to handle this.
3751
     FIXME: At this point we do not know how much space the symbol
3752
     table will require.  This will not work for any (nonstandard)
3753
     a.out target that needs to know the symbol table size before it
3754
     can compute the relocation file positions.  This may or may not
3755
     be the case for the hp300hpux target, for example.  */
3756
  (*callback) (abfd, &aout_info.treloff, &aout_info.dreloff,
3757
               &aout_info.symoff);
3758
  obj_textsec (abfd)->rel_filepos = aout_info.treloff;
3759
  obj_datasec (abfd)->rel_filepos = aout_info.dreloff;
3760
  obj_sym_filepos (abfd) = aout_info.symoff;
3761
 
3762
  /* We keep a count of the symbols as we output them.  */
3763
  obj_aout_external_sym_count (abfd) = 0;
3764
 
3765
  /* We accumulate the string table as we write out the symbols.  */
3766
  aout_info.strtab = _bfd_stringtab_init ();
3767
  if (aout_info.strtab == NULL)
3768
    goto error_return;
3769
 
3770
  /* Allocate buffers to hold section contents and relocs.  */
3771
  aout_info.contents = bfd_malloc (max_contents_size);
3772
  aout_info.relocs = bfd_malloc (max_relocs_size);
3773
  aout_info.symbol_map = bfd_malloc (max_sym_count * sizeof (int *));
3774
  aout_info.output_syms = bfd_malloc ((max_sym_count + 1)
3775
                                      * sizeof (struct external_nlist));
3776
  if ((aout_info.contents == NULL && max_contents_size != 0)
3777
      || (aout_info.relocs == NULL && max_relocs_size != 0)
3778
      || (aout_info.symbol_map == NULL && max_sym_count != 0)
3779
      || aout_info.output_syms == NULL)
3780
    goto error_return;
3781
 
3782
  /* If we have a symbol named __DYNAMIC, force it out now.  This is
3783
     required by SunOS.  Doing this here rather than in sunos.c is a
3784
     hack, but it's easier than exporting everything which would be
3785
     needed.  */
3786
  {
3787
    struct aout_link_hash_entry *h;
3788
 
3789
    h = aout_link_hash_lookup (aout_hash_table (info), "__DYNAMIC",
3790
                               FALSE, FALSE, FALSE);
3791
    if (h != NULL)
3792
      aout_link_write_other_symbol (h, &aout_info);
3793
  }
3794
 
3795
  /* The most time efficient way to do the link would be to read all
3796
     the input object files into memory and then sort out the
3797
     information into the output file.  Unfortunately, that will
3798
     probably use too much memory.  Another method would be to step
3799
     through everything that composes the text section and write it
3800
     out, and then everything that composes the data section and write
3801
     it out, and then write out the relocs, and then write out the
3802
     symbols.  Unfortunately, that requires reading stuff from each
3803
     input file several times, and we will not be able to keep all the
3804
     input files open simultaneously, and reopening them will be slow.
3805
 
3806
     What we do is basically process one input file at a time.  We do
3807
     everything we need to do with an input file once--copy over the
3808
     section contents, handle the relocation information, and write
3809
     out the symbols--and then we throw away the information we read
3810
     from it.  This approach requires a lot of lseeks of the output
3811
     file, which is unfortunate but still faster than reopening a lot
3812
     of files.
3813
 
3814
     We use the output_has_begun field of the input BFDs to see
3815
     whether we have already handled it.  */
3816
  for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
3817
    sub->output_has_begun = FALSE;
3818
 
3819
  /* Mark all sections which are to be included in the link.  This
3820
     will normally be every section.  We need to do this so that we
3821
     can identify any sections which the linker has decided to not
3822
     include.  */
3823
  for (o = abfd->sections; o != NULL; o = o->next)
3824
    {
3825
      for (p = o->map_head.link_order; p != NULL; p = p->next)
3826
        if (p->type == bfd_indirect_link_order)
3827
          p->u.indirect.section->linker_mark = TRUE;
3828
    }
3829
 
3830
  have_link_order_relocs = FALSE;
3831
  for (o = abfd->sections; o != NULL; o = o->next)
3832
    {
3833
      for (p = o->map_head.link_order;
3834
           p != NULL;
3835
           p = p->next)
3836
        {
3837
          if (p->type == bfd_indirect_link_order
3838
              && (bfd_get_flavour (p->u.indirect.section->owner)
3839
                  == bfd_target_aout_flavour))
3840
            {
3841
              bfd *input_bfd;
3842
 
3843
              input_bfd = p->u.indirect.section->owner;
3844
              if (! input_bfd->output_has_begun)
3845
                {
3846
                  if (! aout_link_input_bfd (&aout_info, input_bfd))
3847
                    goto error_return;
3848
                  input_bfd->output_has_begun = TRUE;
3849
                }
3850
            }
3851
          else if (p->type == bfd_section_reloc_link_order
3852
                   || p->type == bfd_symbol_reloc_link_order)
3853
            /* These are handled below.  */
3854
            have_link_order_relocs = TRUE;
3855
          else
3856
            {
3857
              if (! _bfd_default_link_order (abfd, info, o, p))
3858
                goto error_return;
3859
            }
3860
        }
3861
    }
3862
 
3863
  /* Write out any symbols that we have not already written out.  */
3864
  aout_link_hash_traverse (aout_hash_table (info),
3865
                           aout_link_write_other_symbol,
3866
                           (void *) &aout_info);
3867
 
3868
  /* Now handle any relocs we were asked to create by the linker.
3869
     These did not come from any input file.  We must do these after
3870
     we have written out all the symbols, so that we know the symbol
3871
     indices to use.  */
3872
  if (have_link_order_relocs)
3873
    {
3874
      for (o = abfd->sections; o != NULL; o = o->next)
3875
        {
3876
          for (p = o->map_head.link_order;
3877
               p != NULL;
3878
               p = p->next)
3879
            {
3880
              if (p->type == bfd_section_reloc_link_order
3881
                  || p->type == bfd_symbol_reloc_link_order)
3882
                {
3883
                  if (! aout_link_reloc_link_order (&aout_info, o, p))
3884
                    goto error_return;
3885
                }
3886
            }
3887
        }
3888
    }
3889
 
3890
  if (aout_info.contents != NULL)
3891
    {
3892
      free (aout_info.contents);
3893
      aout_info.contents = NULL;
3894
    }
3895
  if (aout_info.relocs != NULL)
3896
    {
3897
      free (aout_info.relocs);
3898
      aout_info.relocs = NULL;
3899
    }
3900
  if (aout_info.symbol_map != NULL)
3901
    {
3902
      free (aout_info.symbol_map);
3903
      aout_info.symbol_map = NULL;
3904
    }
3905
  if (aout_info.output_syms != NULL)
3906
    {
3907
      free (aout_info.output_syms);
3908
      aout_info.output_syms = NULL;
3909
    }
3910
  if (includes_hash_initialized)
3911
    {
3912
      bfd_hash_table_free (&aout_info.includes.root);
3913
      includes_hash_initialized = FALSE;
3914
    }
3915
 
3916
  /* Finish up any dynamic linking we may be doing.  */
3917
  if (aout_backend_info (abfd)->finish_dynamic_link != NULL)
3918
    {
3919
      if (! (*aout_backend_info (abfd)->finish_dynamic_link) (abfd, info))
3920
        goto error_return;
3921
    }
3922
 
3923
  /* Update the header information.  */
3924
  abfd->symcount = obj_aout_external_sym_count (abfd);
3925
  exec_hdr (abfd)->a_syms = abfd->symcount * EXTERNAL_NLIST_SIZE;
3926
  obj_str_filepos (abfd) = obj_sym_filepos (abfd) + exec_hdr (abfd)->a_syms;
3927
  obj_textsec (abfd)->reloc_count =
3928
    exec_hdr (abfd)->a_trsize / obj_reloc_entry_size (abfd);
3929
  obj_datasec (abfd)->reloc_count =
3930
    exec_hdr (abfd)->a_drsize / obj_reloc_entry_size (abfd);
3931
 
3932
  /* Write out the string table, unless there are no symbols.  */
3933
  if (abfd->symcount > 0)
3934
    {
3935
      if (bfd_seek (abfd, obj_str_filepos (abfd), SEEK_SET) != 0
3936
          || ! emit_stringtab (abfd, aout_info.strtab))
3937
        goto error_return;
3938
    }
3939
  else if (obj_textsec (abfd)->reloc_count == 0
3940
           && obj_datasec (abfd)->reloc_count == 0)
3941
    {
3942
      bfd_byte b;
3943
 
3944
      b = 0;
3945
      if (bfd_seek (abfd,
3946
                    (file_ptr) (obj_datasec (abfd)->filepos
3947
                                + exec_hdr (abfd)->a_data
3948
                                - 1),
3949
                    SEEK_SET) != 0
3950
          || bfd_bwrite (&b, (bfd_size_type) 1, abfd) != 1)
3951
        goto error_return;
3952
    }
3953
 
3954
  return TRUE;
3955
 
3956
 error_return:
3957
  if (aout_info.contents != NULL)
3958
    free (aout_info.contents);
3959
  if (aout_info.relocs != NULL)
3960
    free (aout_info.relocs);
3961
  if (aout_info.symbol_map != NULL)
3962
    free (aout_info.symbol_map);
3963
  if (aout_info.output_syms != NULL)
3964
    free (aout_info.output_syms);
3965
  if (includes_hash_initialized)
3966
    bfd_hash_table_free (&aout_info.includes.root);
3967
  return FALSE;
3968
}
3969
 
3970
/* Adjust and write out the symbols for an a.out file.  Set the new
3971
   symbol indices into a symbol_map.  */
3972
 
3973
static bfd_boolean
3974
aout_link_write_symbols (struct aout_final_link_info *finfo, bfd *input_bfd)
3975
{
3976
  bfd *output_bfd;
3977
  bfd_size_type sym_count;
3978
  char *strings;
3979
  enum bfd_link_strip strip;
3980
  enum bfd_link_discard discard;
3981
  struct external_nlist *outsym;
3982
  bfd_size_type strtab_index;
3983
  struct external_nlist *sym;
3984
  struct external_nlist *sym_end;
3985
  struct aout_link_hash_entry **sym_hash;
3986
  int *symbol_map;
3987
  bfd_boolean pass;
3988
  bfd_boolean skip_next;
3989
 
3990
  output_bfd = finfo->output_bfd;
3991
  sym_count = obj_aout_external_sym_count (input_bfd);
3992
  strings = obj_aout_external_strings (input_bfd);
3993
  strip = finfo->info->strip;
3994
  discard = finfo->info->discard;
3995
  outsym = finfo->output_syms;
3996
 
3997
  /* First write out a symbol for this object file, unless we are
3998
     discarding such symbols.  */
3999
  if (strip != strip_all
4000
      && (strip != strip_some
4001
          || bfd_hash_lookup (finfo->info->keep_hash, input_bfd->filename,
4002
                              FALSE, FALSE) != NULL)
4003
      && discard != discard_all)
4004
    {
4005
      H_PUT_8 (output_bfd, N_TEXT, outsym->e_type);
4006
      strtab_index = add_to_stringtab (output_bfd, finfo->strtab,
4007
                                       input_bfd->filename, FALSE);
4008
      if (strtab_index == (bfd_size_type) -1)
4009
        return FALSE;
4010
      PUT_WORD (output_bfd, strtab_index, outsym->e_strx);
4011
      PUT_WORD (output_bfd,
4012
                (bfd_get_section_vma (output_bfd,
4013
                                      obj_textsec (input_bfd)->output_section)
4014
                 + obj_textsec (input_bfd)->output_offset),
4015
                outsym->e_value);
4016
      ++obj_aout_external_sym_count (output_bfd);
4017
      ++outsym;
4018
    }
4019
 
4020
  pass = FALSE;
4021
  skip_next = FALSE;
4022
  sym = obj_aout_external_syms (input_bfd);
4023
  sym_end = sym + sym_count;
4024
  sym_hash = obj_aout_sym_hashes (input_bfd);
4025
  symbol_map = finfo->symbol_map;
4026
  memset (symbol_map, 0, (size_t) sym_count * sizeof *symbol_map);
4027
  for (; sym < sym_end; sym++, sym_hash++, symbol_map++)
4028
    {
4029
      const char *name;
4030
      int type;
4031
      struct aout_link_hash_entry *h;
4032
      bfd_boolean skip;
4033
      asection *symsec;
4034
      bfd_vma val = 0;
4035
      bfd_boolean copy;
4036
 
4037
      /* We set *symbol_map to 0 above for all symbols.  If it has
4038
         already been set to -1 for this symbol, it means that we are
4039
         discarding it because it appears in a duplicate header file.
4040
         See the N_BINCL code below.  */
4041
      if (*symbol_map == -1)
4042
        continue;
4043
 
4044
      /* Initialize *symbol_map to -1, which means that the symbol was
4045
         not copied into the output file.  We will change it later if
4046
         we do copy the symbol over.  */
4047
      *symbol_map = -1;
4048
 
4049
      type = H_GET_8 (input_bfd, sym->e_type);
4050
      name = strings + GET_WORD (input_bfd, sym->e_strx);
4051
 
4052
      h = NULL;
4053
 
4054
      if (pass)
4055
        {
4056
          /* Pass this symbol through.  It is the target of an
4057
             indirect or warning symbol.  */
4058
          val = GET_WORD (input_bfd, sym->e_value);
4059
          pass = FALSE;
4060
        }
4061
      else if (skip_next)
4062
        {
4063
          /* Skip this symbol, which is the target of an indirect
4064
             symbol that we have changed to no longer be an indirect
4065
             symbol.  */
4066
          skip_next = FALSE;
4067
          continue;
4068
        }
4069
      else
4070
        {
4071
          struct aout_link_hash_entry *hresolve;
4072
 
4073
          /* We have saved the hash table entry for this symbol, if
4074
             there is one.  Note that we could just look it up again
4075
             in the hash table, provided we first check that it is an
4076
             external symbol. */
4077
          h = *sym_hash;
4078
 
4079
          /* Use the name from the hash table, in case the symbol was
4080
             wrapped.  */
4081
          if (h != NULL)
4082
            name = h->root.root.string;
4083
 
4084
          /* If this is an indirect or warning symbol, then change
4085
             hresolve to the base symbol.  We also change *sym_hash so
4086
             that the relocation routines relocate against the real
4087
             symbol.  */
4088
          hresolve = h;
4089
          if (h != NULL
4090
              && (h->root.type == bfd_link_hash_indirect
4091
                  || h->root.type == bfd_link_hash_warning))
4092
            {
4093
              hresolve = (struct aout_link_hash_entry *) h->root.u.i.link;
4094
              while (hresolve->root.type == bfd_link_hash_indirect
4095
                     || hresolve->root.type == bfd_link_hash_warning)
4096
                hresolve = ((struct aout_link_hash_entry *)
4097
                            hresolve->root.u.i.link);
4098
              *sym_hash = hresolve;
4099
            }
4100
 
4101
          /* If the symbol has already been written out, skip it.  */
4102
          if (h != NULL
4103
              && h->root.type != bfd_link_hash_warning
4104
              && h->written)
4105
            {
4106
              if ((type & N_TYPE) == N_INDR
4107
                  || type == N_WARNING)
4108
                skip_next = TRUE;
4109
              *symbol_map = h->indx;
4110
              continue;
4111
            }
4112
 
4113
          /* See if we are stripping this symbol.  */
4114
          skip = FALSE;
4115
          switch (strip)
4116
            {
4117
            case strip_none:
4118
              break;
4119
            case strip_debugger:
4120
              if ((type & N_STAB) != 0)
4121
                skip = TRUE;
4122
              break;
4123
            case strip_some:
4124
              if (bfd_hash_lookup (finfo->info->keep_hash, name, FALSE, FALSE)
4125
                  == NULL)
4126
                skip = TRUE;
4127
              break;
4128
            case strip_all:
4129
              skip = TRUE;
4130
              break;
4131
            }
4132
          if (skip)
4133
            {
4134
              if (h != NULL)
4135
                h->written = TRUE;
4136
              continue;
4137
            }
4138
 
4139
          /* Get the value of the symbol.  */
4140
          if ((type & N_TYPE) == N_TEXT
4141
              || type == N_WEAKT)
4142
            symsec = obj_textsec (input_bfd);
4143
          else if ((type & N_TYPE) == N_DATA
4144
                   || type == N_WEAKD)
4145
            symsec = obj_datasec (input_bfd);
4146
          else if ((type & N_TYPE) == N_BSS
4147
                   || type == N_WEAKB)
4148
            symsec = obj_bsssec (input_bfd);
4149
          else if ((type & N_TYPE) == N_ABS
4150
                   || type == N_WEAKA)
4151
            symsec = bfd_abs_section_ptr;
4152
          else if (((type & N_TYPE) == N_INDR
4153
                    && (hresolve == NULL
4154
                        || (hresolve->root.type != bfd_link_hash_defined
4155
                            && hresolve->root.type != bfd_link_hash_defweak
4156
                            && hresolve->root.type != bfd_link_hash_common)))
4157
                   || type == N_WARNING)
4158
            {
4159
              /* Pass the next symbol through unchanged.  The
4160
                 condition above for indirect symbols is so that if
4161
                 the indirect symbol was defined, we output it with
4162
                 the correct definition so the debugger will
4163
                 understand it.  */
4164
              pass = TRUE;
4165
              val = GET_WORD (input_bfd, sym->e_value);
4166
              symsec = NULL;
4167
            }
4168
          else if ((type & N_STAB) != 0)
4169
            {
4170
              val = GET_WORD (input_bfd, sym->e_value);
4171
              symsec = NULL;
4172
            }
4173
          else
4174
            {
4175
              /* If we get here with an indirect symbol, it means that
4176
                 we are outputting it with a real definition.  In such
4177
                 a case we do not want to output the next symbol,
4178
                 which is the target of the indirection.  */
4179
              if ((type & N_TYPE) == N_INDR)
4180
                skip_next = TRUE;
4181
 
4182
              symsec = NULL;
4183
 
4184
              /* We need to get the value from the hash table.  We use
4185
                 hresolve so that if we have defined an indirect
4186
                 symbol we output the final definition.  */
4187
              if (h == NULL)
4188
                {
4189
                  switch (type & N_TYPE)
4190
                    {
4191
                    case N_SETT:
4192
                      symsec = obj_textsec (input_bfd);
4193
                      break;
4194
                    case N_SETD:
4195
                      symsec = obj_datasec (input_bfd);
4196
                      break;
4197
                    case N_SETB:
4198
                      symsec = obj_bsssec (input_bfd);
4199
                      break;
4200
                    case N_SETA:
4201
                      symsec = bfd_abs_section_ptr;
4202
                      break;
4203
                    default:
4204
                      val = 0;
4205
                      break;
4206
                    }
4207
                }
4208
              else if (hresolve->root.type == bfd_link_hash_defined
4209
                       || hresolve->root.type == bfd_link_hash_defweak)
4210
                {
4211
                  asection *input_section;
4212
                  asection *output_section;
4213
 
4214
                  /* This case usually means a common symbol which was
4215
                     turned into a defined symbol.  */
4216
                  input_section = hresolve->root.u.def.section;
4217
                  output_section = input_section->output_section;
4218
                  BFD_ASSERT (bfd_is_abs_section (output_section)
4219
                              || output_section->owner == output_bfd);
4220
                  val = (hresolve->root.u.def.value
4221
                         + bfd_get_section_vma (output_bfd, output_section)
4222
                         + input_section->output_offset);
4223
 
4224
                  /* Get the correct type based on the section.  If
4225
                     this is a constructed set, force it to be
4226
                     globally visible.  */
4227
                  if (type == N_SETT
4228
                      || type == N_SETD
4229
                      || type == N_SETB
4230
                      || type == N_SETA)
4231
                    type |= N_EXT;
4232
 
4233
                  type &=~ N_TYPE;
4234
 
4235
                  if (output_section == obj_textsec (output_bfd))
4236
                    type |= (hresolve->root.type == bfd_link_hash_defined
4237
                             ? N_TEXT
4238
                             : N_WEAKT);
4239
                  else if (output_section == obj_datasec (output_bfd))
4240
                    type |= (hresolve->root.type == bfd_link_hash_defined
4241
                             ? N_DATA
4242
                             : N_WEAKD);
4243
                  else if (output_section == obj_bsssec (output_bfd))
4244
                    type |= (hresolve->root.type == bfd_link_hash_defined
4245
                             ? N_BSS
4246
                             : N_WEAKB);
4247
                  else
4248
                    type |= (hresolve->root.type == bfd_link_hash_defined
4249
                             ? N_ABS
4250
                             : N_WEAKA);
4251
                }
4252
              else if (hresolve->root.type == bfd_link_hash_common)
4253
                val = hresolve->root.u.c.size;
4254
              else if (hresolve->root.type == bfd_link_hash_undefweak)
4255
                {
4256
                  val = 0;
4257
                  type = N_WEAKU;
4258
                }
4259
              else
4260
                val = 0;
4261
            }
4262
          if (symsec != NULL)
4263
            val = (symsec->output_section->vma
4264
                   + symsec->output_offset
4265
                   + (GET_WORD (input_bfd, sym->e_value)
4266
                      - symsec->vma));
4267
 
4268
          /* If this is a global symbol set the written flag, and if
4269
             it is a local symbol see if we should discard it.  */
4270
          if (h != NULL)
4271
            {
4272
              h->written = TRUE;
4273
              h->indx = obj_aout_external_sym_count (output_bfd);
4274
            }
4275
          else if ((type & N_TYPE) != N_SETT
4276
                   && (type & N_TYPE) != N_SETD
4277
                   && (type & N_TYPE) != N_SETB
4278
                   && (type & N_TYPE) != N_SETA)
4279
            {
4280
              switch (discard)
4281
                {
4282
                case discard_none:
4283
                case discard_sec_merge:
4284
                  break;
4285
                case discard_l:
4286
                  if ((type & N_STAB) == 0
4287
                      && bfd_is_local_label_name (input_bfd, name))
4288
                    skip = TRUE;
4289
                  break;
4290
                case discard_all:
4291
                  skip = TRUE;
4292
                  break;
4293
                }
4294
              if (skip)
4295
                {
4296
                  pass = FALSE;
4297
                  continue;
4298
                }
4299
            }
4300
 
4301
          /* An N_BINCL symbol indicates the start of the stabs
4302
             entries for a header file.  We need to scan ahead to the
4303
             next N_EINCL symbol, ignoring nesting, adding up all the
4304
             characters in the symbol names, not including the file
4305
             numbers in types (the first number after an open
4306
             parenthesis).  */
4307
          if (type == N_BINCL)
4308
            {
4309
              struct external_nlist *incl_sym;
4310
              int nest;
4311
              struct aout_link_includes_entry *incl_entry;
4312
              struct aout_link_includes_totals *t;
4313
 
4314
              val = 0;
4315
              nest = 0;
4316
              for (incl_sym = sym + 1; incl_sym < sym_end; incl_sym++)
4317
                {
4318
                  int incl_type;
4319
 
4320
                  incl_type = H_GET_8 (input_bfd, incl_sym->e_type);
4321
                  if (incl_type == N_EINCL)
4322
                    {
4323
                      if (nest == 0)
4324
                        break;
4325
                      --nest;
4326
                    }
4327
                  else if (incl_type == N_BINCL)
4328
                    ++nest;
4329
                  else if (nest == 0)
4330
                    {
4331
                      const char *s;
4332
 
4333
                      s = strings + GET_WORD (input_bfd, incl_sym->e_strx);
4334
                      for (; *s != '\0'; s++)
4335
                        {
4336
                          val += *s;
4337
                          if (*s == '(')
4338
                            {
4339
                              /* Skip the file number.  */
4340
                              ++s;
4341
                              while (ISDIGIT (*s))
4342
                                ++s;
4343
                              --s;
4344
                            }
4345
                        }
4346
                    }
4347
                }
4348
 
4349
              /* If we have already included a header file with the
4350
                 same value, then replace this one with an N_EXCL
4351
                 symbol.  */
4352
              copy = ! finfo->info->keep_memory;
4353
              incl_entry = aout_link_includes_lookup (&finfo->includes,
4354
                                                      name, TRUE, copy);
4355
              if (incl_entry == NULL)
4356
                return FALSE;
4357
              for (t = incl_entry->totals; t != NULL; t = t->next)
4358
                if (t->total == val)
4359
                  break;
4360
              if (t == NULL)
4361
                {
4362
                  /* This is the first time we have seen this header
4363
                     file with this set of stabs strings.  */
4364
                  t = bfd_hash_allocate (&finfo->includes.root,
4365
                                         sizeof *t);
4366
                  if (t == NULL)
4367
                    return FALSE;
4368
                  t->total = val;
4369
                  t->next = incl_entry->totals;
4370
                  incl_entry->totals = t;
4371
                }
4372
              else
4373
                {
4374
                  int *incl_map;
4375
 
4376
                  /* This is a duplicate header file.  We must change
4377
                     it to be an N_EXCL entry, and mark all the
4378
                     included symbols to prevent outputting them.  */
4379
                  type = N_EXCL;
4380
 
4381
                  nest = 0;
4382
                  for (incl_sym = sym + 1, incl_map = symbol_map + 1;
4383
                       incl_sym < sym_end;
4384
                       incl_sym++, incl_map++)
4385
                    {
4386
                      int incl_type;
4387
 
4388
                      incl_type = H_GET_8 (input_bfd, incl_sym->e_type);
4389
                      if (incl_type == N_EINCL)
4390
                        {
4391
                          if (nest == 0)
4392
                            {
4393
                              *incl_map = -1;
4394
                              break;
4395
                            }
4396
                          --nest;
4397
                        }
4398
                      else if (incl_type == N_BINCL)
4399
                        ++nest;
4400
                      else if (nest == 0)
4401
                        *incl_map = -1;
4402
                    }
4403
                }
4404
            }
4405
        }
4406
 
4407
      /* Copy this symbol into the list of symbols we are going to
4408
         write out.  */
4409
      H_PUT_8 (output_bfd, type, outsym->e_type);
4410
      copy = FALSE;
4411
      if (! finfo->info->keep_memory)
4412
        {
4413
          /* name points into a string table which we are going to
4414
             free.  If there is a hash table entry, use that string.
4415
             Otherwise, copy name into memory.  */
4416
          if (h != NULL)
4417
            name = h->root.root.string;
4418
          else
4419
            copy = TRUE;
4420
        }
4421
      strtab_index = add_to_stringtab (output_bfd, finfo->strtab,
4422
                                       name, copy);
4423
      if (strtab_index == (bfd_size_type) -1)
4424
        return FALSE;
4425
      PUT_WORD (output_bfd, strtab_index, outsym->e_strx);
4426
      PUT_WORD (output_bfd, val, outsym->e_value);
4427
      *symbol_map = obj_aout_external_sym_count (output_bfd);
4428
      ++obj_aout_external_sym_count (output_bfd);
4429
      ++outsym;
4430
    }
4431
 
4432
  /* Write out the output symbols we have just constructed.  */
4433
  if (outsym > finfo->output_syms)
4434
    {
4435
      bfd_size_type size;
4436
 
4437
      if (bfd_seek (output_bfd, finfo->symoff, SEEK_SET) != 0)
4438
        return FALSE;
4439
      size = outsym - finfo->output_syms;
4440
      size *= EXTERNAL_NLIST_SIZE;
4441
      if (bfd_bwrite ((void *) finfo->output_syms, size, output_bfd) != size)
4442
        return FALSE;
4443
      finfo->symoff += size;
4444
    }
4445
 
4446
  return TRUE;
4447
}
4448
 
4449
/* Write out a symbol that was not associated with an a.out input
4450
   object.  */
4451
 
4452
static bfd_vma
4453
bfd_getp32 (const void *p)
4454
{
4455
  const bfd_byte *addr = p;
4456
  unsigned long v;
4457
 
4458
  v = (unsigned long) addr[1] << 24;
4459
  v |= (unsigned long) addr[0] << 16;
4460
  v |= (unsigned long) addr[3] << 8;
4461
  v |= (unsigned long) addr[2];
4462
  return v;
4463
}
4464
 
4465
#define COERCE32(x) (((bfd_signed_vma) (x) ^ 0x80000000) - 0x80000000)
4466
 
4467
static bfd_signed_vma
4468
bfd_getp_signed_32 (const void *p)
4469
{
4470
  const bfd_byte *addr = p;
4471
  unsigned long v;
4472
 
4473
  v = (unsigned long) addr[1] << 24;
4474
  v |= (unsigned long) addr[0] << 16;
4475
  v |= (unsigned long) addr[3] << 8;
4476
  v |= (unsigned long) addr[2];
4477
  return COERCE32 (v);
4478
}
4479
 
4480
static void
4481
bfd_putp32 (bfd_vma data, void *p)
4482
{
4483
  bfd_byte *addr = p;
4484
 
4485
  addr[0] = (data >> 16) & 0xff;
4486
  addr[1] = (data >> 24) & 0xff;
4487
  addr[2] = (data >> 0) & 0xff;
4488
  addr[3] = (data >> 8) & 0xff;
4489
}
4490
 
4491
const bfd_target MY (vec) =
4492
{
4493
  TARGETNAME,                   /* Name.  */
4494
  bfd_target_aout_flavour,
4495
  BFD_ENDIAN_LITTLE,            /* Target byte order (little).  */
4496
  BFD_ENDIAN_LITTLE,            /* Target headers byte order (little).  */
4497
  (HAS_RELOC | EXEC_P |         /* Object flags.  */
4498
   HAS_LINENO | HAS_DEBUG |
4499
   HAS_SYMS | HAS_LOCALS | WP_TEXT),
4500
  (SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD | SEC_RELOC | SEC_CODE | SEC_DATA),
4501
  MY_symbol_leading_char,
4502
  AR_PAD_CHAR,                  /* AR_pad_char.  */
4503
  15,                           /* AR_max_namelen.  */
4504
  bfd_getl64, bfd_getl_signed_64, bfd_putl64,
4505
     bfd_getp32, bfd_getp_signed_32, bfd_putp32,
4506
     bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* Data.  */
4507
  bfd_getl64, bfd_getl_signed_64, bfd_putl64,
4508
     bfd_getp32, bfd_getp_signed_32, bfd_putp32,
4509
     bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* Headers.  */
4510
    {_bfd_dummy_target, MY_object_p,            /* bfd_check_format.  */
4511
       bfd_generic_archive_p, MY_core_file_p},
4512
    {bfd_false, MY_mkobject,                    /* bfd_set_format.  */
4513
       _bfd_generic_mkarchive, bfd_false},
4514
    {bfd_false, MY_write_object_contents,       /* bfd_write_contents.  */
4515
       _bfd_write_archive_contents, bfd_false},
4516
 
4517
     BFD_JUMP_TABLE_GENERIC (MY),
4518
     BFD_JUMP_TABLE_COPY (MY),
4519
     BFD_JUMP_TABLE_CORE (MY),
4520
     BFD_JUMP_TABLE_ARCHIVE (MY),
4521
     BFD_JUMP_TABLE_SYMBOLS (MY),
4522
     BFD_JUMP_TABLE_RELOCS (MY),
4523
     BFD_JUMP_TABLE_WRITE (MY),
4524
     BFD_JUMP_TABLE_LINK (MY),
4525
     BFD_JUMP_TABLE_DYNAMIC (MY),
4526
 
4527
  /* Alternative_target.  */
4528
  NULL,
4529
 
4530
  (void *) MY_backend_data
4531
};

powered by: WebSVN 2.1.0

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