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

Subversion Repositories openrisc_me

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

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

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