1 /* evax-alpha.c -- BFD back-end for ALPHA EVAX (openVMS/Alpha) files.
2 Copyright 1996, 1997 Free Software Foundation, Inc.
3 Written by Klaus K"ampf (kkaempf@progis.de)
4 of proGIS Softwareentwicklung, Aachen, Germany
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
30 static boolean evax_initialize
PARAMS ((bfd
*));
31 static boolean fill_section_ptr
PARAMS ((struct bfd_hash_entry
*, PTR
));
32 static boolean evax_fixup_sections
PARAMS ((bfd
*));
33 static boolean copy_symbols
PARAMS ((struct bfd_hash_entry
*, PTR
));
34 static bfd_reloc_status_type reloc_nil
35 PARAMS ((bfd
*, arelent
*, asymbol
*, PTR
, asection
*, bfd
*, char **));
36 static const struct bfd_target
*evax_object_p
PARAMS ((bfd
*abfd
));
37 static const struct bfd_target
*evax_archive_p
PARAMS ((bfd
*abfd
));
38 static boolean evax_mkobject
PARAMS ((bfd
*abfd
));
39 static boolean evax_write_object_contents
PARAMS ((bfd
*abfd
));
40 static boolean evax_close_and_cleanup
PARAMS ((bfd
*abfd
));
41 static boolean evax_bfd_free_cached_info
PARAMS ((bfd
*abfd
));
42 static boolean evax_new_section_hook
PARAMS ((bfd
*abfd
, asection
*section
));
43 static boolean evax_get_section_contents
44 PARAMS ((bfd
*abfd
, asection
*section
, PTR x1
, file_ptr x2
,
46 static boolean evax_get_section_contents_in_window
47 PARAMS ((bfd
*abfd
, asection
*section
, bfd_window
*w
, file_ptr offset
,
48 bfd_size_type count
));
49 static boolean evax_bfd_copy_private_bfd_data
PARAMS ((bfd
*src
, bfd
*dest
));
50 static boolean evax_bfd_copy_private_section_data
51 PARAMS ((bfd
*srcbfd
, asection
*srcsec
, bfd
*dstbfd
, asection
*dstsec
));
52 static boolean evax_bfd_copy_private_symbol_data
53 PARAMS ((bfd
*ibfd
, asymbol
*isym
, bfd
*obfd
, asymbol
*osym
));
54 static boolean evax_bfd_print_private_bfd_data
55 PARAMS ((bfd
*abfd
, void *file
));
56 static char *evax_core_file_failing_command
PARAMS ((bfd
*abfd
));
57 static int evax_core_file_failing_signal
PARAMS ((bfd
*abfd
));
58 static boolean evax_core_file_matches_executable_p
59 PARAMS ((bfd
*abfd
, bfd
*bbfd
));
60 static boolean evax_slurp_armap
PARAMS ((bfd
*abfd
));
61 static boolean evax_slurp_extended_name_table
PARAMS ((bfd
*abfd
));
62 static boolean evax_construct_extended_name_table
63 PARAMS ((bfd
*abfd
, char **tabloc
, bfd_size_type
*tablen
,
65 static void evax_truncate_arname
66 PARAMS ((bfd
*abfd
, CONST
char *pathname
, char *arhdr
));
67 static boolean evax_write_armap
68 PARAMS ((bfd
*arch
, unsigned int elength
, struct orl
*map
,
69 unsigned int orl_count
, int stridx
));
70 static PTR evax_read_ar_hdr
PARAMS ((bfd
*abfd
));
71 static bfd
*evax_get_elt_at_index
PARAMS ((bfd
*abfd
, symindex index
));
72 static bfd
*evax_openr_next_archived_file
PARAMS ((bfd
*arch
, bfd
*prev
));
73 static boolean evax_update_armap_timestamp
PARAMS ((bfd
*abfd
));
74 static int evax_generic_stat_arch_elt
PARAMS ((bfd
*abfd
, struct stat
*stat
));
75 static long evax_get_symtab_upper_bound
PARAMS ((bfd
*abfd
));
76 static long evax_get_symtab
PARAMS ((bfd
*abfd
, asymbol
**symbols
));
77 static void evax_print_symbol
78 PARAMS ((bfd
*abfd
, PTR file
, asymbol
*symbol
, bfd_print_symbol_type how
));
79 static void evax_get_symbol_info
80 PARAMS ((bfd
*abfd
, asymbol
*symbol
, symbol_info
*ret
));
81 static boolean evax_bfd_is_local_label_name
PARAMS ((bfd
*abfd
, const char *));
82 static alent
*evax_get_lineno
PARAMS ((bfd
*abfd
, asymbol
*symbol
));
83 static boolean evax_find_nearest_line
84 PARAMS ((bfd
*abfd
, asection
*section
, asymbol
**symbols
, bfd_vma offset
,
85 const char **file
, const char **func
, unsigned int *line
));
86 static asymbol
*evax_bfd_make_debug_symbol
87 PARAMS ((bfd
*abfd
, void *ptr
, unsigned long size
));
88 static long evax_read_minisymbols
89 PARAMS ((bfd
*abfd
, boolean dynamic
, PTR
*minisymsp
, unsigned int *sizep
));
90 static asymbol
*evax_minisymbol_to_symbol
91 PARAMS ((bfd
*abfd
, boolean dynamic
, const PTR minisym
, asymbol
*sym
));
92 static long evax_get_reloc_upper_bound
PARAMS ((bfd
*abfd
, asection
*sect
));
93 static long evax_canonicalize_reloc
94 PARAMS ((bfd
*abfd
, asection
*srcsec
, arelent
**location
,
96 static const struct reloc_howto_struct
*evax_bfd_reloc_type_lookup
97 PARAMS ((bfd
*abfd
, bfd_reloc_code_real_type code
));
98 static boolean evax_set_arch_mach
99 PARAMS ((bfd
*abfd
, enum bfd_architecture arch
, unsigned long mach
));
100 static boolean evax_set_section_contents
101 PARAMS ((bfd
*abfd
, asection
*section
, PTR location
, file_ptr offset
,
102 bfd_size_type count
));
103 static int evax_sizeof_headers
PARAMS ((bfd
*abfd
, boolean reloc
));
104 static bfd_byte
*evax_bfd_get_relocated_section_contents
105 PARAMS ((bfd
*abfd
, struct bfd_link_info
*link_info
,
106 struct bfd_link_order
*link_order
, bfd_byte
*data
,
107 boolean relocateable
, asymbol
**symbols
));
108 static boolean evax_bfd_relax_section
109 PARAMS ((bfd
*abfd
, asection
*section
, struct bfd_link_info
*link_info
,
111 static struct bfd_link_hash_table
*evax_bfd_link_hash_table_create
112 PARAMS ((bfd
*abfd
));
113 static boolean evax_bfd_link_add_symbols
114 PARAMS ((bfd
*abfd
, struct bfd_link_info
*link_info
));
115 static boolean evax_bfd_final_link
116 PARAMS ((bfd
*abfd
, struct bfd_link_info
*link_info
));
117 static boolean evax_bfd_link_split_section
118 PARAMS ((bfd
*abfd
, asection
*section
));
119 static long evax_get_dynamic_symtab_upper_bound
PARAMS ((bfd
*abfd
));
120 static long evax_canonicalize_dynamic_symtab
121 PARAMS ((bfd
*abfd
, asymbol
**symbols
));
122 static long evax_get_dynamic_reloc_upper_bound
PARAMS ((bfd
*abfd
));
123 static long evax_canonicalize_dynamic_reloc
124 PARAMS ((bfd
*abfd
, arelent
**arel
, asymbol
**symbols
));
125 static boolean evax_bfd_merge_private_bfd_data
PARAMS ((bfd
*ibfd
, bfd
*obfd
));
126 static boolean evax_bfd_set_private_flags
PARAMS ((bfd
*abfd
, flagword flags
));
128 #define evax_make_empty_symbol _bfd_evax_make_empty_symbol
130 /*===========================================================================*/
132 const bfd_target evax_alpha_vec
=
135 "evax-alpha", /* name */
136 bfd_target_evax_flavour
,
137 false, /* data byte order is little */
138 false, /* header byte order is little */
140 (HAS_RELOC
| HAS_SYMS
141 | WP_TEXT
| D_PAGED
), /* object flags */
142 (SEC_ALLOC
| SEC_LOAD
| SEC_RELOC
143 | SEC_READONLY
| SEC_CODE
| SEC_DATA
144 | SEC_HAS_CONTENTS
| SEC_IN_MEMORY
), /* sect flags */
145 0, /* symbol_leading_char */
146 ' ', /* ar_pad_char */
147 15, /* ar_max_namelen */
148 bfd_getl64
, bfd_getl_signed_64
, bfd_putl64
,
149 bfd_getl32
, bfd_getl_signed_32
, bfd_putl32
,
150 bfd_getl16
, bfd_getl_signed_16
, bfd_putl16
,
151 bfd_getl64
, bfd_getl_signed_64
, bfd_putl64
,
152 bfd_getl32
, bfd_getl_signed_32
, bfd_putl32
,
153 bfd_getl16
, bfd_getl_signed_16
, bfd_putl16
,
155 {_bfd_dummy_target
, evax_object_p
, /* bfd_check_format */
156 evax_archive_p
, _bfd_dummy_target
},
157 {bfd_false
, evax_mkobject
, /* bfd_set_format */
158 _bfd_generic_mkarchive
, bfd_false
},
159 {bfd_false
, evax_write_object_contents
, /* bfd_write_contents */
160 _bfd_write_archive_contents
, bfd_false
},
162 BFD_JUMP_TABLE_GENERIC (evax
),
163 BFD_JUMP_TABLE_COPY (evax
),
164 BFD_JUMP_TABLE_CORE (evax
),
165 BFD_JUMP_TABLE_ARCHIVE (evax
),
166 BFD_JUMP_TABLE_SYMBOLS (evax
),
167 BFD_JUMP_TABLE_RELOCS (evax
),
168 BFD_JUMP_TABLE_WRITE (evax
),
169 BFD_JUMP_TABLE_LINK (evax
),
170 BFD_JUMP_TABLE_DYNAMIC (evax
),
176 /*===========================================================================*/
178 /* Initialize private data */
181 evax_initialize (abfd
)
186 if (abfd
->tdata
.any
!= 0)
189 bfd_set_start_address (abfd
, (bfd_vma
)-1);
191 abfd
->tdata
.any
= ((struct evax_private_data_struct
*)
192 bfd_malloc (sizeof (struct evax_private_data_struct
)));
193 if (abfd
->tdata
.any
== 0)
197 PRIV(rec_length
) = 0;
198 PRIV(file_format
) = FF_UNKNOWN
;
199 PRIV(fixup_done
) = false;
200 PRIV(sections
) = NULL
;
202 PRIV(stack
) = ((struct stack_struct
*)
203 bfd_malloc (sizeof (struct stack_struct
) * STACKSIZE
));
204 if (PRIV(stack
) == 0)
207 free (abfd
->tdata
.any
);
213 PRIV(evax_symbol_table
) = ((struct bfd_hash_table
*)
214 bfd_malloc (sizeof (struct bfd_hash_table
)));
215 if (PRIV(evax_symbol_table
) == 0)
220 goto evax_init_no_mem1
;
223 if (!bfd_hash_table_init (PRIV(evax_symbol_table
), _bfd_evax_hash_newfunc
))
226 PRIV(location_stack
) = ((struct location_struct
*)
227 bfd_malloc (sizeof (struct location_struct
)
228 * LOCATION_SAVE_SIZE
));
229 if (PRIV(location_stack
) == 0)
232 free (PRIV(evax_symbol_table
));
233 PRIV(evax_symbol_table
) = 0;
234 goto evax_init_no_mem2
;
237 for (i
= 0; i
< EVAX_SECTION_COUNT
; i
++)
238 PRIV(evax_section_table
)[i
] = NULL
;
240 PRIV(output_buf
) = (unsigned char *) malloc (MAX_OUTREC_SIZE
);
241 if (PRIV(output_buf
) == 0)
243 free (PRIV(location_stack
));
244 PRIV(location_stack
) = 0;
245 goto evax_init_no_mem3
;
247 PRIV(push_level
) = 0;
248 PRIV(pushed_size
) = 0;
249 PRIV(length_pos
) = 2;
250 PRIV(output_size
) = 0;
251 PRIV(output_alignment
) = 1;
257 /* Fill symbol->section with section ptr
258 symbol->section is filled with the section index for defined symbols
259 during reading the EGSD section. But we need the pointer to the
262 It has the correct value for referenced (undefined section) symbols
264 called from bfd_hash_traverse in evax_fixup_sections */
267 fill_section_ptr (entry
, sections
)
268 struct bfd_hash_entry
*entry
;
274 sym
= ((evax_symbol_entry
*)entry
)->symbol
;
277 if (!bfd_is_und_section (sec
))
279 sec
= ((evax_symbol_entry
*)entry
)->symbol
->section
=
280 ((asection
**)sections
)[(int)sec
];
283 if (strcmp (sym
->name
, sec
->name
) == 0)
284 sym
->flags
|= BSF_SECTION_SYM
;
291 set up all pointers and arrays, counters and sizes are fixed now
293 we build a private sections vector for easy access since sections
294 are always referenced by an index number.
296 alloc PRIV(sections) according to abfd->section_count
297 copy abfd->sections to PRIV(sections) */
300 evax_fixup_sections (abfd
)
305 if (PRIV(fixup_done
))
308 PRIV(sections
) = ((asection
**)
309 bfd_malloc (abfd
->section_count
* sizeof (asection
*)));
310 if (PRIV(sections
) == 0)
312 PRIV(egsd_sec_count
) = abfd
->section_count
;
316 PRIV(sections
)[s
->index
] = s
;
321 * traverse symbol table and fill in all section pointers
324 bfd_hash_traverse (PRIV(evax_symbol_table
), fill_section_ptr
,
325 (PTR
)(PRIV(sections
)));
327 PRIV(fixup_done
) = true;
332 /*===========================================================================*/
334 /* Check the format for a file being read.
335 Return a (bfd_target *) if it's an object file or zero if not. */
337 static const struct bfd_target
*
344 evax_debug (1, "evax_object_p(%p)\n", abfd
);
346 if (bfd_seek (abfd
, 0L, SEEK_SET
))
348 bfd_set_error (bfd_error_file_truncated
);
357 evax_debug (3, "reading at %08lx\n", bfd_tell(abfd
));
359 if (_bfd_evax_next_record (abfd
) < 0)
362 evax_debug (2, "next_record failed\n");
364 bfd_set_error (bfd_error_wrong_format
);
368 if ((prev_type
== EOBJ_S_C_EGSD
) && (PRIV(rec_type
) != EOBJ_S_C_EGSD
))
370 if (evax_fixup_sections (abfd
) == false)
373 evax_debug (2, "evax_fixup_sections failed\n");
375 bfd_set_error (bfd_error_wrong_format
);
380 prev_type
= PRIV(rec_type
);
382 switch (PRIV(rec_type
))
385 err
= _bfd_evax_slurp_emh (abfd
);
388 err
= _bfd_evax_slurp_eeom (abfd
);
391 err
= _bfd_evax_slurp_egsd (abfd
);
394 err
= _bfd_evax_slurp_etir (abfd
);
397 err
= _bfd_evax_slurp_edbg (abfd
);
400 err
= _bfd_evax_slurp_etbt (abfd
);
408 evax_debug (2, "slurp type %d failed with %d\n", PRIV(rec_type
), err
);
410 bfd_set_error (bfd_error_wrong_format
);
414 while (prev_type
!= EOBJ_S_C_EEOM
);
416 /* set arch_info to alpha */
419 const bfd_arch_info_type
*arch
= bfd_scan_arch ("alpha");
423 evax_debug (2, "arch not found\n");
425 bfd_set_error (bfd_error_wrong_format
);
428 abfd
->arch_info
= arch
;
431 return &evax_alpha_vec
;
435 /* Check the format for a file being read.
436 Return a (bfd_target *) if it's an archive file or zero. */
438 static const struct bfd_target
*
439 evax_archive_p (abfd
)
443 evax_debug (1, "evax_archive_p(%p)\n", abfd
);
446 if (!evax_initialize (abfd
))
453 /* Set the format of a file being written. */
460 evax_debug (1, "evax_mkobject(%p)\n", abfd
);
463 if (!evax_initialize (abfd
))
467 const bfd_arch_info_type
*arch
= bfd_scan_arch ("alpha");
470 bfd_set_error(bfd_error_wrong_format
);
473 abfd
->arch_info
= arch
;
480 /* Write cached information into a file being written, at bfd_close. */
483 evax_write_object_contents (abfd
)
487 evax_debug (1, "evax_write_object_contents(%p)\n", abfd
);
490 if (abfd
->section_count
> 0) /* we have sections */
492 if (_bfd_evax_write_emh (abfd
) != 0)
494 if (_bfd_evax_write_egsd (abfd
) != 0)
496 if (_bfd_evax_write_etir (abfd
) != 0)
498 if (_bfd_evax_write_etbt (abfd
) != 0)
500 if (_bfd_evax_write_eeom (abfd
) != 0)
506 /*-- 4.1, generic -----------------------------------------------------------*/
508 /* Called when the BFD is being closed to do any necessary cleanup. */
511 evax_close_and_cleanup (abfd
)
515 evax_section
*es
, *es1
;
516 evax_reloc
*er
, *er1
;
520 evax_debug (1, "evax_close_and_cleanup(%p)\n", abfd
);
525 if (PRIV(evax_buf
) != NULL
)
527 free (PRIV(evax_buf
));
528 PRIV(evax_buf
) = NULL
;
532 if (PRIV(output_buf
) != 0)
534 free (PRIV(output_buf
));
535 PRIV(output_buf
) = 0;
538 sec
= abfd
->sections
;
542 free (sec
->contents
);
546 if (PRIV(sections
) != NULL
)
548 free (PRIV(sections
));
549 PRIV(sections
) = NULL
;
552 if (PRIV(evax_symbol_table
))
554 bfd_hash_table_free (PRIV(evax_symbol_table
));
555 PRIV(evax_symbol_table
) = 0;
564 if (PRIV(location_stack
))
566 free (PRIV(location_stack
));
567 PRIV(location_stack
) = 0;
570 for (i
= 0; i
< EVAX_SECTION_COUNT
; i
++)
572 es
= PRIV(evax_section_table
)[i
];
579 PRIV(evax_section_table
)[i
] = NULL
;
582 free (abfd
->tdata
.any
);
583 abfd
->tdata
.any
= NULL
;
589 /* Ask the BFD to free all cached information. */
591 evax_bfd_free_cached_info (abfd
)
595 evax_debug (1, "evax_bfd_free_cached_info(%p)\n", abfd
);
601 /* Called when a new section is created. */
604 evax_new_section_hook (abfd
, section
)
609 evax_debug (1, "evax_new_section_hook(%p, %s)\n", abfd
, section
->name
);
611 bfd_set_section_alignment(abfd
, section
, 4);
616 /* Read the contents of a section.
617 buf points to a buffer of buf_size bytes to be filled with
618 section data (starting at offset into section) */
621 evax_get_section_contents (abfd
, section
, buf
, offset
, buf_size
)
626 bfd_size_type buf_size
;
629 evax_debug (1, "evax_get_section_contents(%p, %s, %p, off %ld, size %d)\n",
630 abfd
, section
->name
, buf
, offset
, (int)buf_size
);
633 /* shouldn't be called, since all sections are IN_MEMORY */
638 /* Read the contents of a section.
639 buf points to a buffer of buf_size bytes to be filled with
640 section data (starting at offset into section) */
643 evax_get_section_contents_in_window (abfd
, section
, w
, offset
, count
)
651 evax_debug (1, "evax_get_section_contents_in_window(%p, %s, %p, off %ld, count %d)\n",
652 abfd
, section
->name
, w
, offset
, (int)count
);
655 /* shouldn't be called, since all sections are IN_MEMORY */
660 /*-- Part 4.2, copy private data --------------------------------------------*/
662 /* Called to copy BFD general private data from one object file
666 evax_bfd_copy_private_bfd_data (src
, dest
)
671 evax_debug (1, "evax_bfd_copy_private_bfd_data(%p, %p)\n", src
, dest
);
677 /* Merge private BFD information from the BFD @var{ibfd} to the
678 the output file BFD @var{obfd} when linking. Return <<true>>
679 on success, <<false>> on error. Possible error returns are:
681 o <<bfd_error_no_memory>> -
682 Not enough memory exists to create private data for @var{obfd}. */
685 evax_bfd_merge_private_bfd_data (ibfd
, obfd
)
690 evax_debug (1,"evax_bfd_merge_private_bfd_data(%p, %p)\n", ibfd
, obfd
);
696 /* Set private BFD flag information in the BFD @var{abfd}.
697 Return <<true>> on success, <<false>> on error. Possible error
700 o <<bfd_error_no_memory>> -
701 Not enough memory exists to create private data for @var{obfd}. */
704 evax_bfd_set_private_flags (abfd
, flags
)
709 evax_debug (1,"evax_bfd_set_private_flags(%p, %lx)\n", abfd
, (long)flags
);
715 /* Called to copy BFD private section data from one object file
719 evax_bfd_copy_private_section_data (srcbfd
, srcsec
, dstbfd
, dstsec
)
726 evax_debug (1, "evax_bfd_copy_private_section_data(%p, %s, %p, %s)\n",
727 srcbfd
, srcsec
->name
, dstbfd
, dstsec
->name
);
732 /* Called to copy BFD private symbol data from one object file
736 evax_bfd_copy_private_symbol_data (ibfd
, isym
, obfd
, osym
)
743 evax_debug (1, "evax_bfd_copy_private_symbol_data(%p, %s, %p, %s)\n",
744 ibfd
, isym
->name
, obfd
, osym
->name
);
749 /*-- Part 4.3, core file ----------------------------------------------------*/
751 /* Return a read-only string explaining which program was running
752 when it failed and produced the core file abfd. */
755 evax_core_file_failing_command (abfd
)
759 evax_debug (1, "evax_core_file_failing_command(%p)\n", abfd
);
765 /* Returns the signal number which caused the core dump which
766 generated the file the BFD abfd is attached to. */
769 evax_core_file_failing_signal (abfd
)
773 evax_debug (1, "evax_core_file_failing_signal(%p)\n", abfd
);
779 /* Return true if the core file attached to core_bfd was generated
780 by a run of the executable file attached to exec_bfd, false otherwise. */
783 evax_core_file_matches_executable_p (abfd
, bbfd
)
788 evax_debug (1, "evax_core_file_matches_executable_p(%p, %p)\n", abfd
, bbfd
);
793 /*-- Part 4.4, archive ------------------------------------------------------*/
795 /* ??? do something with an archive map.
796 Return false on error, true otherwise. */
799 evax_slurp_armap (abfd
)
803 evax_debug (1, "evax_slurp_armap(%p)\n", abfd
);
809 /* ??? do something with an extended name table.
810 Return false on error, true otherwise. */
813 evax_slurp_extended_name_table (abfd
)
817 evax_debug (1, "evax_slurp_extended_name_table(%p)\n", abfd
);
823 /* ??? do something with an extended name table.
824 Return false on error, true otherwise. */
827 evax_construct_extended_name_table (abfd
, tabloc
, tablen
, name
)
830 bfd_size_type
*tablen
;
834 evax_debug (1, "evax_construct_extended_name_table(%p)\n", abfd
);
840 /* Truncate the name of an archive to match system-dependent restrictions */
843 evax_truncate_arname (abfd
, pathname
, arhdr
)
845 CONST
char *pathname
;
849 evax_debug (1, "evax_truncate_arname(%p, %s, %s)\n", abfd
, pathname
, arhdr
);
855 /* ??? write archive map */
858 evax_write_armap (arch
, elength
, map
, orl_count
, stridx
)
860 unsigned int elength
;
862 unsigned int orl_count
;
866 evax_debug (1, "evax_write_armap(%p, %d, %p, %d %d)\n",
867 arch
, elength
, map
, orl_count
, stridx
);
872 /* Read archive header ??? */
875 evax_read_ar_hdr (abfd
)
879 evax_debug (1, "evax_read_ar_hdr(%p)\n", abfd
);
885 /* Provided a BFD, @var{archive}, containing an archive and NULL, open
886 an input BFD on the first contained element and returns that.
887 Subsequent calls should pass the archive and the previous return value
888 to return a created BFD to the next contained element.
889 NULL is returned when there are no more. */
892 evax_openr_next_archived_file (arch
, prev
)
897 evax_debug (1, "evax_openr_next_archived_file(%p, %p)\n", arch
, prev
);
903 /* Return the BFD which is referenced by the symbol in ABFD indexed by
904 INDEX. INDEX should have been returned by bfd_get_next_mapent. */
907 evax_get_elt_at_index (abfd
, index
)
912 evax_debug (1, "evax_get_elt_at_index(%p, %p)\n", abfd
, index
);
914 return _bfd_generic_get_elt_at_index(abfd
, index
);
919 -> bfd_generic_stat_arch_elt */
922 evax_generic_stat_arch_elt (abfd
, stat
)
927 evax_debug (1, "evax_generic_stat_arch_elt(%p, %p)\n", abfd
, stat
);
929 return bfd_generic_stat_arch_elt(abfd
, stat
);
933 /* This is a new function in bfd 2.5 */
936 evax_update_armap_timestamp (abfd
)
940 evax_debug (1, "evax_update_armap_timestamp(%p)\n", abfd
);
945 /*-- Part 4.5, symbols --------------------------------------------------------*/
947 /* Return the number of bytes required to store a vector of pointers
948 to asymbols for all the symbols in the BFD abfd, including a
949 terminal NULL pointer. If there are no symbols in the BFD,
950 then return 0. If an error occurs, return -1. */
953 evax_get_symtab_upper_bound (abfd
)
957 evax_debug (1, "evax_get_symtab_upper_bound(%p), %d symbols\n", abfd
, PRIV(egsd_sym_count
));
959 return (PRIV(egsd_sym_count
)+1) * sizeof(asymbol
*);
963 /* Copy symbols from hash table to symbol vector
965 called from bfd_hash_traverse in evax_get_symtab
966 init counter to 0 if entry == 0 */
969 copy_symbols (entry
, arg
)
970 struct bfd_hash_entry
*entry
;
973 bfd
*abfd
= (bfd
*) arg
;
975 if (entry
== NULL
) /* init counter */
977 else /* fill vector, inc counter */
978 PRIV(symcache
)[PRIV(symnum
)++] = ((evax_symbol_entry
*)entry
)->symbol
;
984 /* Read the symbols from the BFD abfd, and fills in the vector
985 location with pointers to the symbols and a trailing NULL.
987 return # of symbols read */
990 evax_get_symtab (abfd
, symbols
)
995 evax_debug (1, "evax_get_symtab(%p, <ret>)\n", abfd
);
999 (void)copy_symbols((struct bfd_hash_entry
*)0, abfd
);
1001 /* traverse table and fill symbols vector */
1003 PRIV(symcache
) = symbols
;
1004 bfd_hash_traverse(PRIV(evax_symbol_table
), copy_symbols
, (PTR
)abfd
);
1006 symbols
[PRIV(egsd_sym_count
)] = NULL
;
1008 return PRIV(egsd_sym_count
);
1012 /* Create a new asymbol structure for the BFD abfd and return a pointer
1014 This routine is necessary because each back end has private information
1015 surrounding the asymbol. Building your own asymbol and pointing to it
1016 will not create the private information, and will cause problems later on. */
1019 _bfd_evax_make_empty_symbol (abfd
)
1022 asymbol
*symbol
= (asymbol
*)bfd_zalloc(abfd
, sizeof(asymbol
));
1025 evax_debug (1, "_bfd_evax_make_empty_symbol(%p)\n", abfd
);
1030 bfd_set_error (bfd_error_no_memory
);
1033 symbol
->the_bfd
= abfd
;
1039 /* Print symbol to file according to how. how is one of
1040 bfd_print_symbol_name just print the name
1041 bfd_print_symbol_more print more (???)
1042 bfd_print_symbol_all print all we know, which is not much right now :-) */
1045 evax_print_symbol (abfd
, file
, symbol
, how
)
1049 bfd_print_symbol_type how
;
1052 evax_debug (1, "evax_print_symbol(%p, %p, %p, %d)\n", abfd
, file
, symbol
, how
);
1057 case bfd_print_symbol_name
:
1058 case bfd_print_symbol_more
:
1059 fprintf((FILE *)file
," %s", symbol
->name
);
1064 case bfd_print_symbol_all
:
1066 CONST
char *section_name
= symbol
->section
->name
;
1068 bfd_print_symbol_vandf((PTR
)file
,symbol
);
1070 fprintf((FILE *)file
," %-8s %s", section_name
, symbol
->name
);
1078 /* Return information about symbol in ret.
1080 fill type, value and name
1083 B bss segment symbol
1085 D data segment symbol
1087 t a static function symbol
1088 T text segment symbol
1093 evax_get_symbol_info (abfd
, symbol
, ret
)
1101 evax_debug (1, "evax_get_symbol_info(%p, %p, <ret>)\n", abfd
, symbol
);
1104 sec
= symbol
->section
;
1106 if (bfd_is_com_section (sec
))
1108 else if (bfd_is_abs_section (sec
))
1110 else if (bfd_is_und_section (sec
))
1112 else if (bfd_is_ind_section (sec
))
1114 else if (bfd_get_section_flags (abfd
, sec
) & SEC_CODE
)
1116 else if (bfd_get_section_flags (abfd
, sec
) & SEC_DATA
)
1118 else if (bfd_get_section_flags (abfd
, sec
) & SEC_ALLOC
)
1123 if (ret
->type
!= 'U')
1124 ret
->value
= symbol
->value
+ symbol
->section
->vma
;
1127 ret
->name
= symbol
->name
;
1133 /* Return true if the given symbol sym in the BFD abfd is
1134 a compiler generated local label, else return false. */
1137 evax_bfd_is_local_label_name (abfd
, name
)
1142 evax_debug (1, "evax_bfd_is_local_label_name(%p, %s)\n", abfd
, name
);
1144 return name
[0] == '$';
1148 /* Get source line number for symbol */
1151 evax_get_lineno (abfd
, symbol
)
1156 evax_debug (1, "evax_get_lineno(%p, %p)\n", abfd
, symbol
);
1162 /* Provided a BFD, a section and an offset into the section, calculate and
1163 return the name of the source file and the line nearest to the wanted
1167 evax_find_nearest_line (abfd
, section
, symbols
, offset
, file
, func
, line
)
1177 evax_debug (1, "evax_find_nearest_line(%p, %s, %p, %ld, <ret>, <ret>, <ret>)\n",
1178 abfd
, section
->name
, symbols
, (long int)offset
);
1184 /* Back-door to allow format-aware applications to create debug symbols
1185 while using BFD for everything else. Currently used by the assembler
1186 when creating COFF files. */
1189 evax_bfd_make_debug_symbol (abfd
, ptr
, size
)
1195 evax_debug (1, "evax_bfd_make_debug_symbol(%p, %p, %ld)\n", abfd
, ptr
, size
);
1201 /* Read minisymbols. For minisymbols, we use the unmodified a.out
1202 symbols. The minisymbol_to_symbol function translates these into
1203 BFD asymbol structures. */
1206 evax_read_minisymbols (abfd
, dynamic
, minisymsp
, sizep
)
1210 unsigned int *sizep
;
1213 evax_debug (1, "evax_read_minisymbols(%p, %d, %p, %d)\n", abfd
, dynamic
, minisymsp
, *sizep
);
1215 return _bfd_generic_read_minisymbols (abfd
, dynamic
, minisymsp
, sizep
);
1218 /* Convert a minisymbol to a BFD asymbol. A minisymbol is just an
1219 unmodified a.out symbol. The SYM argument is a structure returned
1220 by bfd_make_empty_symbol, which we fill in here. */
1223 evax_minisymbol_to_symbol (abfd
, dynamic
, minisym
, sym
)
1230 evax_debug (1, "evax_minisymbol_to_symbol(%p, %d, %p, %p)\n", abfd
, dynamic
, minisym
, sym
);
1232 return _bfd_generic_minisymbol_to_symbol (abfd
, dynamic
, minisym
, sym
);
1235 /*-- Part 4.6, relocations --------------------------------------------------*/
1237 /* Return the number of bytes required to store the relocation information
1238 associated with section sect attached to bfd abfd.
1239 If an error occurs, return -1. */
1242 evax_get_reloc_upper_bound (abfd
, section
)
1247 evax_debug (1, "evax_get_reloc_upper_bound(%p, %s)\n", abfd
, section
->name
);
1253 /* Call the back end associated with the open BFD abfd and translate the
1254 external form of the relocation information attached to sec into the
1255 internal canonical form. Place the table into memory at loc, which has
1256 been preallocated, usually by a call to bfd_get_reloc_upper_bound.
1257 Returns the number of relocs, or -1 on error. */
1260 evax_canonicalize_reloc (abfd
, section
, location
, symbols
)
1267 evax_debug (1, "evax_canonicalize_reloc(%p, %s, <ret>, <ret>)\n", abfd
, section
->name
);
1272 /*---------------------------------------------------------------------------*/
1273 /* this is just copied from ecoff-alpha, needs to be fixed probably */
1275 /* How to process the various reloc types. */
1277 static bfd_reloc_status_type
1278 reloc_nil (abfd
, reloc
, sym
, data
, sec
, output_bfd
, error_message
)
1285 char **error_message
;
1288 evax_debug (1, "reloc_nil(abfd %p, output_bfd %p)\n", abfd
, output_bfd
);
1289 evax_debug (2, "In section %s, symbol %s\n",
1290 sec
->name
, sym
->name
);
1291 evax_debug (2, "reloc sym %s, addr %08lx, addend %08lx, reloc is a %s\n",
1292 reloc
->sym_ptr_ptr
[0]->name
,
1293 (unsigned long)reloc
->address
,
1294 (unsigned long)reloc
->addend
, reloc
->howto
->name
);
1295 evax_debug (2, "data at %p\n", data
);
1296 /* _bfd_hexdump (2, data, bfd_get_reloc_size(reloc->howto),0); */
1299 return bfd_reloc_ok
;
1302 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value
1303 from smaller values. Start with zero, widen, *then* decrement. */
1304 #define MINUS_ONE (((bfd_vma)0) - 1)
1306 static reloc_howto_type alpha_howto_table
[] =
1308 HOWTO (ALPHA_R_IGNORE
, /* type */
1310 0, /* size (0 = byte, 1 = short, 2 = long) */
1312 true, /* pc_relative */
1314 complain_overflow_dont
, /* complain_on_overflow */
1315 reloc_nil
, /* special_function */
1316 "IGNORE", /* name */
1317 true, /* partial_inplace */
1320 true), /* pcrel_offset */
1322 /* A 64 bit reference to a symbol. */
1323 HOWTO (ALPHA_R_REFQUAD
, /* type */
1325 4, /* size (0 = byte, 1 = short, 2 = long) */
1327 false, /* pc_relative */
1329 complain_overflow_bitfield
, /* complain_on_overflow */
1330 reloc_nil
, /* special_function */
1331 "REFQUAD", /* name */
1332 true, /* partial_inplace */
1333 MINUS_ONE
, /* src_mask */
1334 MINUS_ONE
, /* dst_mask */
1335 false), /* pcrel_offset */
1337 /* A 21 bit branch. The native assembler generates these for
1338 branches within the text segment, and also fills in the PC
1339 relative offset in the instruction. */
1340 HOWTO (ALPHA_R_BRADDR
, /* type */
1342 2, /* size (0 = byte, 1 = short, 2 = long) */
1344 true, /* pc_relative */
1346 complain_overflow_signed
, /* complain_on_overflow */
1347 reloc_nil
, /* special_function */
1348 "BRADDR", /* name */
1349 true, /* partial_inplace */
1350 0x1fffff, /* src_mask */
1351 0x1fffff, /* dst_mask */
1352 false), /* pcrel_offset */
1354 /* A hint for a jump to a register. */
1355 HOWTO (ALPHA_R_HINT
, /* type */
1357 1, /* size (0 = byte, 1 = short, 2 = long) */
1359 true, /* pc_relative */
1361 complain_overflow_dont
, /* complain_on_overflow */
1362 reloc_nil
, /* special_function */
1364 true, /* partial_inplace */
1365 0x3fff, /* src_mask */
1366 0x3fff, /* dst_mask */
1367 false), /* pcrel_offset */
1369 /* 16 bit PC relative offset. */
1370 HOWTO (ALPHA_R_SREL16
, /* type */
1372 1, /* size (0 = byte, 1 = short, 2 = long) */
1374 true, /* pc_relative */
1376 complain_overflow_signed
, /* complain_on_overflow */
1377 reloc_nil
, /* special_function */
1378 "SREL16", /* name */
1379 true, /* partial_inplace */
1380 0xffff, /* src_mask */
1381 0xffff, /* dst_mask */
1382 false), /* pcrel_offset */
1384 /* 32 bit PC relative offset. */
1385 HOWTO (ALPHA_R_SREL32
, /* type */
1387 2, /* size (0 = byte, 1 = short, 2 = long) */
1389 true, /* pc_relative */
1391 complain_overflow_signed
, /* complain_on_overflow */
1392 reloc_nil
, /* special_function */
1393 "SREL32", /* name */
1394 true, /* partial_inplace */
1395 0xffffffff, /* src_mask */
1396 0xffffffff, /* dst_mask */
1397 false), /* pcrel_offset */
1399 /* A 64 bit PC relative offset. */
1400 HOWTO (ALPHA_R_SREL64
, /* type */
1402 4, /* size (0 = byte, 1 = short, 2 = long) */
1404 true, /* pc_relative */
1406 complain_overflow_signed
, /* complain_on_overflow */
1407 reloc_nil
, /* special_function */
1408 "SREL64", /* name */
1409 true, /* partial_inplace */
1410 MINUS_ONE
, /* src_mask */
1411 MINUS_ONE
, /* dst_mask */
1412 false), /* pcrel_offset */
1414 /* Push a value on the reloc evaluation stack. */
1415 HOWTO (ALPHA_R_OP_PUSH
, /* type */
1417 0, /* size (0 = byte, 1 = short, 2 = long) */
1419 false, /* pc_relative */
1421 complain_overflow_dont
, /* complain_on_overflow */
1422 reloc_nil
, /* special_function */
1423 "OP_PUSH", /* name */
1424 false, /* partial_inplace */
1427 false), /* pcrel_offset */
1429 /* Store the value from the stack at the given address. Store it in
1430 a bitfield of size r_size starting at bit position r_offset. */
1431 HOWTO (ALPHA_R_OP_STORE
, /* type */
1433 4, /* size (0 = byte, 1 = short, 2 = long) */
1435 false, /* pc_relative */
1437 complain_overflow_dont
, /* complain_on_overflow */
1438 reloc_nil
, /* special_function */
1439 "OP_STORE", /* name */
1440 false, /* partial_inplace */
1442 MINUS_ONE
, /* dst_mask */
1443 false), /* pcrel_offset */
1445 /* Subtract the reloc address from the value on the top of the
1446 relocation stack. */
1447 HOWTO (ALPHA_R_OP_PSUB
, /* type */
1449 0, /* size (0 = byte, 1 = short, 2 = long) */
1451 false, /* pc_relative */
1453 complain_overflow_dont
, /* complain_on_overflow */
1454 reloc_nil
, /* special_function */
1455 "OP_PSUB", /* name */
1456 false, /* partial_inplace */
1459 false), /* pcrel_offset */
1461 /* Shift the value on the top of the relocation stack right by the
1463 HOWTO (ALPHA_R_OP_PRSHIFT
, /* type */
1465 0, /* size (0 = byte, 1 = short, 2 = long) */
1467 false, /* pc_relative */
1469 complain_overflow_dont
, /* complain_on_overflow */
1470 reloc_nil
, /* special_function */
1471 "OP_PRSHIFT", /* name */
1472 false, /* partial_inplace */
1475 false), /* pcrel_offset */
1477 /* Hack. Linkage is done by linker. */
1478 HOWTO (ALPHA_R_LINKAGE
, /* type */
1480 8, /* size (0 = byte, 1 = short, 2 = long) */
1482 false, /* pc_relative */
1484 complain_overflow_dont
, /* complain_on_overflow */
1485 reloc_nil
, /* special_function */
1486 "LINKAGE", /* name */
1487 false, /* partial_inplace */
1490 false), /* pcrel_offset */
1492 /* A 32 bit reference to a symbol. */
1493 HOWTO (ALPHA_R_REFLONG
, /* type */
1495 2, /* size (0 = byte, 1 = short, 2 = long) */
1497 false, /* pc_relative */
1499 complain_overflow_bitfield
, /* complain_on_overflow */
1500 reloc_nil
, /* special_function */
1501 "REFLONG", /* name */
1502 true, /* partial_inplace */
1503 0xffffffff, /* src_mask */
1504 0xffffffff, /* dst_mask */
1505 false), /* pcrel_offset */
1507 /* A 64 bit reference to a procedure, written as 32 bit value. */
1508 HOWTO (ALPHA_R_CODEADDR
, /* type */
1510 4, /* size (0 = byte, 1 = short, 2 = long) */
1512 false, /* pc_relative */
1514 complain_overflow_signed
,/* complain_on_overflow */
1515 reloc_nil
, /* special_function */
1516 "CODEADDR", /* name */
1517 false, /* partial_inplace */
1518 0xffffffff, /* src_mask */
1519 0xffffffff, /* dst_mask */
1520 false), /* pcrel_offset */
1524 /* Return a pointer to a howto structure which, when invoked, will perform
1525 the relocation code on data from the architecture noted. */
1527 static const struct reloc_howto_struct
*
1528 evax_bfd_reloc_type_lookup (abfd
, code
)
1530 bfd_reloc_code_real_type code
;
1535 evax_debug (1, "evax_bfd_reloc_type_lookup(%p, %d)\t", abfd
, code
);
1540 case BFD_RELOC_16
: alpha_type
= ALPHA_R_SREL16
; break;
1541 case BFD_RELOC_32
: alpha_type
= ALPHA_R_REFLONG
; break;
1542 case BFD_RELOC_64
: alpha_type
= ALPHA_R_REFQUAD
; break;
1543 case BFD_RELOC_CTOR
: alpha_type
= ALPHA_R_REFQUAD
; break;
1544 case BFD_RELOC_23_PCREL_S2
: alpha_type
= ALPHA_R_BRADDR
; break;
1545 case BFD_RELOC_ALPHA_HINT
: alpha_type
= ALPHA_R_HINT
; break;
1546 case BFD_RELOC_16_PCREL
: alpha_type
= ALPHA_R_SREL16
; break;
1547 case BFD_RELOC_32_PCREL
: alpha_type
= ALPHA_R_SREL32
; break;
1548 case BFD_RELOC_64_PCREL
: alpha_type
= ALPHA_R_SREL64
; break;
1549 case BFD_RELOC_ALPHA_LINKAGE
: alpha_type
= ALPHA_R_LINKAGE
; break;
1550 case BFD_RELOC_ALPHA_CODEADDR
: alpha_type
= ALPHA_R_CODEADDR
; break;
1552 (*_bfd_error_handler
) ("reloc (%d) is *UNKNOWN*", code
);
1553 return (const struct reloc_howto_struct
*) NULL
;
1556 evax_debug (2, "reloc is %s\n", alpha_howto_table
[alpha_type
].name
);
1558 return &alpha_howto_table
[alpha_type
];
1562 /*-- Part 4.7, writing an object file ---------------------------------------*/
1564 /* Set the architecture and machine type in BFD abfd to arch and mach.
1565 Find the correct pointer to a structure and insert it into the arch_info
1569 evax_set_arch_mach (abfd
, arch
, mach
)
1571 enum bfd_architecture arch
;
1575 evax_debug (1, "evax_set_arch_mach(%p, %d, %ld)\n", abfd
, arch
, mach
);
1577 abfd
->arch_info
= bfd_scan_arch("alpha");
1583 /* Sets the contents of the section section in BFD abfd to the data starting
1584 in memory at data. The data is written to the output section starting at
1585 offset offset for count bytes.
1587 Normally true is returned, else false. Possible error returns are:
1588 o bfd_error_no_contents - The output section does not have the
1589 SEC_HAS_CONTENTS attribute, so nothing can be written to it.
1590 o and some more too */
1593 evax_set_section_contents (abfd
, section
, location
, offset
, count
)
1598 bfd_size_type count
;
1601 evax_debug (1, "evax_set_section_contents(%p, sec %s, loc %p, off %ld, count %d)\n",
1602 abfd
, section
->name
, location
, (long int)offset
, (int)count
);
1603 evax_debug (2, "secraw %d, seccooked %d\n", (int)section
->_raw_size
, (int)section
->_cooked_size
);
1605 return _bfd_save_evax_section(abfd
, section
, location
, offset
, count
);
1609 /*-- Part 4.8, linker -------------------------------------------------------*/
1611 /* Get the size of the section headers. */
1614 evax_sizeof_headers (abfd
, reloc
)
1619 evax_debug (1, "evax_sizeof_headers(%p, %s)\n", abfd
, (reloc
)?"True":"False");
1625 /* Provides default handling of relocation effort for back ends
1626 which can't be bothered to do it efficiently. */
1629 evax_bfd_get_relocated_section_contents (abfd
, link_info
, link_order
, data
,
1630 relocateable
, symbols
)
1632 struct bfd_link_info
*link_info
;
1633 struct bfd_link_order
*link_order
;
1635 boolean relocateable
;
1639 evax_debug (1, "evax_bfd_get_relocated_section_contents(%p, %p, %p, %p, %s, %p)\n",
1640 abfd
, link_info
, link_order
, data
, (relocateable
)?"True":"False", symbols
);
1649 evax_bfd_relax_section (abfd
, section
, link_info
, again
)
1652 struct bfd_link_info
*link_info
;
1656 evax_debug (1, "evax_bfd_relax_section(%p, %s, %p, <ret>)\n",
1657 abfd
, section
->name
, link_info
);
1663 /* Create a hash table for the linker. Different backends store
1664 different information in this table. */
1666 static struct bfd_link_hash_table
*
1667 evax_bfd_link_hash_table_create (abfd
)
1671 evax_debug (1, "evax_bfd_link_hash_table_create(%p)\n", abfd
);
1677 /* Add symbols from this object file into the hash table. */
1680 evax_bfd_link_add_symbols (abfd
, link_info
)
1682 struct bfd_link_info
*link_info
;
1685 evax_debug (1, "evax_bfd_link_add_symbols(%p, %p)\n", abfd
, link_info
);
1691 /* Do a link based on the link_order structures attached to each
1692 section of the BFD. */
1695 evax_bfd_final_link (abfd
, link_info
)
1697 struct bfd_link_info
*link_info
;
1700 evax_debug (1, "evax_bfd_final_link(%p, %p)\n", abfd
, link_info
);
1705 /* Should this section be split up into smaller pieces during linking. */
1708 evax_bfd_link_split_section (abfd
, section
)
1713 evax_debug (1, "evax_bfd_link_split_section(%p, %s)\n", abfd
, section
->name
);
1718 /*-- Part 4.9, dynamic symbols and relocations ------------------------------*/
1720 /* Get the amount of memory required to hold the dynamic symbols. */
1723 evax_get_dynamic_symtab_upper_bound (abfd
)
1727 evax_debug (1, "evax_get_dynamic_symtab_upper_bound(%p)\n", abfd
);
1733 evax_bfd_print_private_bfd_data (abfd
, file
)
1738 evax_debug (1, "evax_bfd_print_private_bfd_data(%p)\n", abfd
);
1744 /* Read in the dynamic symbols. */
1747 evax_canonicalize_dynamic_symtab (abfd
, symbols
)
1752 evax_debug (1, "evax_canonicalize_dynamic_symtab(%p, <ret>)\n", abfd
);
1758 /* Get the amount of memory required to hold the dynamic relocs. */
1761 evax_get_dynamic_reloc_upper_bound (abfd
)
1765 evax_debug (1, "evax_get_dynamic_reloc_upper_bound(%p)\n", abfd
);
1771 /* Read in the dynamic relocs. */
1774 evax_canonicalize_dynamic_reloc (abfd
, arel
, symbols
)
1780 evax_debug (1, "evax_canonicalize_dynamic_reloc(%p)\n", abfd
);