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

Subversion Repositories openrisc_me

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

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

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

powered by: WebSVN 2.1.0

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