Commit | Line | Data |
---|---|---|
252b5132 RH |
1 | /* vms.c -- BFD back-end for VAX (openVMS/VAX) and |
2 | EVAX (openVMS/Alpha) files. | |
3 | Copyright 1996, 1997, 1998 Free Software Foundation, Inc. | |
4 | ||
5 | Written by Klaus K"ampf (kkaempf@rmi.de) | |
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 2 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ | |
20 | ||
21 | #include "bfd.h" | |
22 | #include "sysdep.h" | |
23 | #include "bfdlink.h" | |
24 | #include "libbfd.h" | |
25 | ||
26 | #include "vms.h" | |
27 | ||
28 | static boolean vms_initialize PARAMS ((bfd *)); | |
29 | static int priv_section_count; | |
30 | static boolean fill_section_ptr PARAMS ((struct bfd_hash_entry *, PTR)); | |
31 | static boolean vms_fixup_sections PARAMS ((bfd *)); | |
32 | static boolean copy_symbols PARAMS ((struct bfd_hash_entry *, PTR)); | |
33 | static bfd_reloc_status_type reloc_nil | |
34 | PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **)); | |
35 | static const struct bfd_target *vms_object_p PARAMS ((bfd *abfd)); | |
36 | static const struct bfd_target *vms_archive_p PARAMS ((bfd *abfd)); | |
37 | static boolean vms_mkobject PARAMS ((bfd *abfd)); | |
38 | static boolean vms_write_object_contents PARAMS ((bfd *abfd)); | |
39 | static boolean vms_close_and_cleanup PARAMS ((bfd *abfd)); | |
40 | static boolean vms_bfd_free_cached_info PARAMS ((bfd *abfd)); | |
41 | static boolean vms_new_section_hook PARAMS ((bfd *abfd, asection *section)); | |
42 | static boolean vms_get_section_contents | |
43 | PARAMS ((bfd *abfd, asection *section, PTR x1, file_ptr x2, | |
44 | bfd_size_type x3)); | |
45 | static boolean vms_get_section_contents_in_window | |
46 | PARAMS ((bfd *abfd, asection *section, bfd_window *w, file_ptr offset, | |
47 | bfd_size_type count)); | |
48 | static boolean vms_bfd_copy_private_bfd_data PARAMS ((bfd *src, bfd *dest)); | |
49 | static boolean vms_bfd_copy_private_section_data | |
50 | PARAMS ((bfd *srcbfd, asection *srcsec, bfd *dstbfd, asection *dstsec)); | |
51 | static boolean vms_bfd_copy_private_symbol_data | |
52 | PARAMS ((bfd *ibfd, asymbol *isym, bfd *obfd, asymbol *osym)); | |
53 | static boolean vms_bfd_print_private_bfd_data | |
54 | PARAMS ((bfd *abfd, void *file)); | |
55 | static char *vms_core_file_failing_command PARAMS ((bfd *abfd)); | |
56 | static int vms_core_file_failing_signal PARAMS ((bfd *abfd)); | |
57 | static boolean vms_core_file_matches_executable_p | |
58 | PARAMS ((bfd *abfd, bfd *bbfd)); | |
59 | static boolean vms_slurp_armap PARAMS ((bfd *abfd)); | |
60 | static boolean vms_slurp_extended_name_table PARAMS ((bfd *abfd)); | |
61 | static boolean vms_construct_extended_name_table | |
62 | PARAMS ((bfd *abfd, char **tabloc, bfd_size_type *tablen, | |
63 | const char **name)); | |
64 | static void vms_truncate_arname | |
65 | PARAMS ((bfd *abfd, CONST char *pathname, char *arhdr)); | |
66 | static boolean vms_write_armap | |
67 | PARAMS ((bfd *arch, unsigned int elength, struct orl *map, | |
68 | unsigned int orl_count, int stridx)); | |
69 | static PTR vms_read_ar_hdr PARAMS ((bfd *abfd)); | |
70 | static bfd *vms_get_elt_at_index PARAMS ((bfd *abfd, symindex index)); | |
71 | static bfd *vms_openr_next_archived_file PARAMS ((bfd *arch, bfd *prev)); | |
72 | static boolean vms_update_armap_timestamp PARAMS ((bfd *abfd)); | |
73 | static int vms_generic_stat_arch_elt PARAMS ((bfd *abfd, struct stat *stat)); | |
74 | static long vms_get_symtab_upper_bound PARAMS ((bfd *abfd)); | |
75 | static long vms_get_symtab PARAMS ((bfd *abfd, asymbol **symbols)); | |
76 | static void vms_print_symbol | |
77 | PARAMS ((bfd *abfd, PTR file, asymbol *symbol, bfd_print_symbol_type how)); | |
78 | static void vms_get_symbol_info | |
79 | PARAMS ((bfd *abfd, asymbol *symbol, symbol_info *ret)); | |
80 | static boolean vms_bfd_is_local_label_name PARAMS ((bfd *abfd, const char *)); | |
81 | static alent *vms_get_lineno PARAMS ((bfd *abfd, asymbol *symbol)); | |
82 | static boolean vms_find_nearest_line | |
83 | PARAMS ((bfd *abfd, asection *section, asymbol **symbols, bfd_vma offset, | |
84 | const char **file, const char **func, unsigned int *line)); | |
85 | static asymbol *vms_bfd_make_debug_symbol | |
86 | PARAMS ((bfd *abfd, void *ptr, unsigned long size)); | |
87 | static long vms_read_minisymbols | |
88 | PARAMS ((bfd *abfd, boolean dynamic, PTR *minisymsp, unsigned int *sizep)); | |
89 | static asymbol *vms_minisymbol_to_symbol | |
90 | PARAMS ((bfd *abfd, boolean dynamic, const PTR minisym, asymbol *sym)); | |
91 | static long vms_get_reloc_upper_bound PARAMS ((bfd *abfd, asection *sect)); | |
92 | static long vms_canonicalize_reloc | |
93 | PARAMS ((bfd *abfd, asection *srcsec, arelent **location, | |
94 | asymbol **symbols)); | |
95 | static const struct reloc_howto_struct *vms_bfd_reloc_type_lookup | |
96 | PARAMS ((bfd *abfd, bfd_reloc_code_real_type code)); | |
97 | static boolean vms_set_arch_mach | |
98 | PARAMS ((bfd *abfd, enum bfd_architecture arch, unsigned long mach)); | |
99 | static boolean vms_set_section_contents | |
100 | PARAMS ((bfd *abfd, asection *section, PTR location, file_ptr offset, | |
101 | bfd_size_type count)); | |
102 | static int vms_sizeof_headers PARAMS ((bfd *abfd, boolean reloc)); | |
103 | static bfd_byte *vms_bfd_get_relocated_section_contents | |
104 | PARAMS ((bfd *abfd, struct bfd_link_info *link_info, | |
105 | struct bfd_link_order *link_order, bfd_byte *data, | |
106 | boolean relocateable, asymbol **symbols)); | |
107 | static boolean vms_bfd_relax_section | |
108 | PARAMS ((bfd *abfd, asection *section, struct bfd_link_info *link_info, | |
109 | boolean *again)); | |
110 | static boolean vms_bfd_gc_sections | |
111 | PARAMS ((bfd *abfd, struct bfd_link_info *link_info)); | |
112 | static struct bfd_link_hash_table *vms_bfd_link_hash_table_create | |
113 | PARAMS ((bfd *abfd)); | |
114 | static boolean vms_bfd_link_add_symbols | |
115 | PARAMS ((bfd *abfd, struct bfd_link_info *link_info)); | |
116 | static boolean vms_bfd_final_link | |
117 | PARAMS ((bfd *abfd, struct bfd_link_info *link_info)); | |
118 | static boolean vms_bfd_link_split_section | |
119 | PARAMS ((bfd *abfd, asection *section)); | |
120 | static long vms_get_dynamic_symtab_upper_bound PARAMS ((bfd *abfd)); | |
121 | static long vms_canonicalize_dynamic_symtab | |
122 | PARAMS ((bfd *abfd, asymbol **symbols)); | |
123 | static long vms_get_dynamic_reloc_upper_bound PARAMS ((bfd *abfd)); | |
124 | static long vms_canonicalize_dynamic_reloc | |
125 | PARAMS ((bfd *abfd, arelent **arel, asymbol **symbols)); | |
126 | static boolean vms_bfd_merge_private_bfd_data PARAMS ((bfd *ibfd, bfd *obfd)); | |
127 | static boolean vms_bfd_set_private_flags PARAMS ((bfd *abfd, flagword flags)); | |
128 | ||
129 | #define vms_make_empty_symbol _bfd_vms_make_empty_symbol | |
130 | \f | |
131 | /*===========================================================================*/ | |
132 | ||
133 | const bfd_target vms_alpha_vec = | |
134 | { | |
135 | ||
136 | "vms-alpha", /* name */ | |
137 | bfd_target_evax_flavour, | |
138 | false, /* data byte order is little */ | |
139 | false, /* header byte order is little */ | |
140 | ||
141 | (HAS_RELOC | HAS_SYMS | |
142 | | WP_TEXT | D_PAGED), /* object flags */ | |
143 | (SEC_ALLOC | SEC_LOAD | SEC_RELOC | |
144 | | SEC_READONLY | SEC_CODE | SEC_DATA | |
145 | | SEC_HAS_CONTENTS | SEC_IN_MEMORY), /* sect flags */ | |
146 | 0, /* symbol_leading_char */ | |
147 | ' ', /* ar_pad_char */ | |
148 | 15, /* ar_max_namelen */ | |
149 | bfd_getl64, bfd_getl_signed_64, bfd_putl64, | |
150 | bfd_getl32, bfd_getl_signed_32, bfd_putl32, | |
151 | bfd_getl16, bfd_getl_signed_16, bfd_putl16, | |
152 | bfd_getl64, bfd_getl_signed_64, bfd_putl64, | |
153 | bfd_getl32, bfd_getl_signed_32, bfd_putl32, | |
154 | bfd_getl16, bfd_getl_signed_16, bfd_putl16, | |
155 | ||
156 | {_bfd_dummy_target, vms_object_p, /* bfd_check_format */ | |
157 | vms_archive_p, _bfd_dummy_target}, | |
158 | {bfd_false, vms_mkobject, /* bfd_set_format */ | |
159 | _bfd_generic_mkarchive, bfd_false}, | |
160 | {bfd_false, vms_write_object_contents, /* bfd_write_contents */ | |
161 | _bfd_write_archive_contents, bfd_false}, | |
162 | ||
163 | BFD_JUMP_TABLE_GENERIC (vms), | |
164 | BFD_JUMP_TABLE_COPY (vms), | |
165 | BFD_JUMP_TABLE_CORE (vms), | |
166 | BFD_JUMP_TABLE_ARCHIVE (vms), | |
167 | BFD_JUMP_TABLE_SYMBOLS (vms), | |
168 | BFD_JUMP_TABLE_RELOCS (vms), | |
169 | BFD_JUMP_TABLE_WRITE (vms), | |
170 | BFD_JUMP_TABLE_LINK (vms), | |
171 | BFD_JUMP_TABLE_DYNAMIC (vms), | |
172 | ||
173 | (PTR) 0 | |
174 | }; | |
175 | ||
176 | const bfd_target vms_vax_vec = | |
177 | { | |
178 | ||
179 | "vms-vax", /* name */ | |
180 | bfd_target_ovax_flavour, | |
181 | false, /* data byte order is little */ | |
182 | false, /* header byte order is little */ | |
183 | ||
184 | (HAS_RELOC | HAS_SYMS /* object flags */ | |
185 | | WP_TEXT | D_PAGED | |
186 | | HAS_LINENO | HAS_DEBUG | HAS_LOCALS), | |
187 | ||
188 | (SEC_ALLOC | SEC_LOAD | SEC_RELOC | |
189 | | SEC_READONLY | SEC_CODE | SEC_DATA | |
190 | | SEC_HAS_CONTENTS | SEC_IN_MEMORY), /* sect flags */ | |
191 | 0, /* symbol_leading_char */ | |
192 | ' ', /* ar_pad_char */ | |
193 | 15, /* ar_max_namelen */ | |
194 | bfd_getl64, bfd_getl_signed_64, bfd_putl64, | |
195 | bfd_getl32, bfd_getl_signed_32, bfd_putl32, | |
196 | bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* data */ | |
197 | bfd_getl64, bfd_getl_signed_64, bfd_putl64, | |
198 | bfd_getl32, bfd_getl_signed_32, bfd_putl32, | |
199 | bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* hdrs */ | |
200 | ||
201 | {_bfd_dummy_target, vms_object_p, /* bfd_check_format */ | |
202 | vms_archive_p, _bfd_dummy_target}, | |
203 | {bfd_false, vms_mkobject, /* bfd_set_format */ | |
204 | _bfd_generic_mkarchive, bfd_false}, | |
205 | {bfd_false, vms_write_object_contents, /* bfd_write_contents */ | |
206 | _bfd_write_archive_contents, bfd_false}, | |
207 | ||
208 | BFD_JUMP_TABLE_GENERIC (vms), | |
209 | BFD_JUMP_TABLE_COPY (vms), | |
210 | BFD_JUMP_TABLE_CORE (vms), | |
211 | BFD_JUMP_TABLE_ARCHIVE (vms), | |
212 | BFD_JUMP_TABLE_SYMBOLS (vms), | |
213 | BFD_JUMP_TABLE_RELOCS (vms), | |
214 | BFD_JUMP_TABLE_WRITE (vms), | |
215 | BFD_JUMP_TABLE_LINK (vms), | |
216 | BFD_JUMP_TABLE_DYNAMIC (vms), | |
217 | ||
218 | (PTR) 0 | |
219 | }; | |
220 | \f | |
221 | /*===========================================================================*/ | |
222 | ||
223 | /* Initialize private data */ | |
224 | ||
225 | static boolean | |
226 | vms_initialize (abfd) | |
227 | bfd *abfd; | |
228 | { | |
229 | int i; | |
230 | ||
231 | if (abfd->tdata.any != 0) | |
232 | return true; | |
233 | ||
234 | bfd_set_start_address (abfd, (bfd_vma)-1); | |
235 | ||
236 | abfd->tdata.any = ((struct vms_private_data_struct*) | |
237 | bfd_malloc (sizeof (struct vms_private_data_struct))); | |
238 | if (abfd->tdata.any == 0) | |
239 | return false; | |
240 | ||
241 | #ifdef __ALPHA | |
242 | PRIV(is_vax) = 0; | |
243 | #else | |
244 | PRIV(is_vax) = 1; | |
245 | #endif | |
246 | PRIV(vms_buf) = 0; | |
247 | PRIV(buf_size) = 0; | |
248 | PRIV(rec_length) = 0; | |
249 | PRIV(file_format) = FF_UNKNOWN; | |
250 | PRIV(fixup_done) = false; | |
251 | PRIV(sections) = NULL; | |
252 | ||
253 | PRIV(stack) = ((struct stack_struct *) | |
254 | bfd_malloc (sizeof (struct stack_struct) * STACKSIZE)); | |
255 | if (PRIV(stack) == 0) | |
256 | { | |
257 | vms_init_no_mem1: | |
258 | free (abfd->tdata.any); | |
259 | abfd->tdata.any = 0; | |
260 | return false; | |
261 | } | |
262 | PRIV(stackptr) = 0; | |
263 | ||
264 | PRIV(vms_symbol_table) = ((struct bfd_hash_table *) | |
265 | bfd_malloc (sizeof (struct bfd_hash_table))); | |
266 | if (PRIV(vms_symbol_table) == 0) | |
267 | { | |
268 | vms_init_no_mem2: | |
269 | free (PRIV(stack)); | |
270 | PRIV(stack) = 0; | |
271 | goto vms_init_no_mem1; | |
272 | } | |
273 | ||
274 | if (!bfd_hash_table_init (PRIV(vms_symbol_table), _bfd_vms_hash_newfunc)) | |
275 | return false; | |
276 | ||
277 | PRIV(location_stack) = ((struct location_struct *) | |
278 | bfd_malloc (sizeof (struct location_struct) | |
279 | * LOCATION_SAVE_SIZE)); | |
280 | if (PRIV(location_stack) == 0) | |
281 | { | |
282 | vms_init_no_mem3: | |
283 | free (PRIV(vms_symbol_table)); | |
284 | PRIV(vms_symbol_table) = 0; | |
285 | goto vms_init_no_mem2; | |
286 | } | |
287 | ||
288 | for (i = 0; i < VMS_SECTION_COUNT; i++) | |
289 | PRIV(vms_section_table)[i] = NULL; | |
290 | ||
291 | PRIV(output_buf) = (unsigned char *) malloc (MAX_OUTREC_SIZE); | |
292 | if (PRIV(output_buf) == 0) | |
293 | { | |
294 | free (PRIV(location_stack)); | |
295 | PRIV(location_stack) = 0; | |
296 | goto vms_init_no_mem3; | |
297 | } | |
298 | PRIV(push_level) = 0; | |
299 | PRIV(pushed_size) = 0; | |
300 | PRIV(length_pos) = 2; | |
301 | PRIV(output_size) = 0; | |
302 | PRIV(output_alignment) = 1; | |
303 | ||
304 | return true; | |
305 | } | |
306 | ||
307 | ||
308 | /* Fill symbol->section with section ptr | |
309 | symbol->section is filled with the section index for defined symbols | |
310 | during reading the GSD/EGSD section. But we need the pointer to the | |
311 | bfd section later. | |
312 | ||
313 | It has the correct value for referenced (undefined section) symbols | |
314 | ||
315 | called from bfd_hash_traverse in vms_fixup_sections */ | |
316 | ||
317 | static boolean | |
318 | fill_section_ptr (entry, sections) | |
319 | struct bfd_hash_entry *entry; | |
320 | PTR sections; | |
321 | { | |
322 | asection *sec; | |
323 | asymbol *sym; | |
324 | ||
325 | sym = ((vms_symbol_entry *)entry)->symbol; | |
326 | sec = sym->section; | |
327 | ||
328 | #if VMS_DEBUG | |
329 | vms_debug (6, "fill_section_ptr: sym %p, sec %p\n", sym, sec); | |
330 | #endif | |
331 | ||
332 | /* fill forward references (these contain section number, not section ptr). */ | |
333 | ||
334 | if ((int)sec < priv_section_count) | |
335 | { | |
336 | sec = ((vms_symbol_entry *)entry)->symbol->section = | |
337 | ((asection **)sections)[(int)sec]; | |
338 | } | |
339 | ||
340 | if (strcmp (sym->name, sec->name) == 0) | |
341 | sym->flags |= BSF_SECTION_SYM; | |
342 | ||
343 | return true; | |
344 | } | |
345 | ||
346 | ||
347 | /* Fixup sections | |
348 | set up all pointers and arrays, counters and sizes are fixed now | |
349 | ||
350 | we build a private sections vector for easy access since sections | |
351 | are always referenced by an index number. | |
352 | ||
353 | alloc PRIV(sections) according to abfd->section_count | |
354 | copy abfd->sections to PRIV(sections) */ | |
355 | ||
356 | static boolean | |
357 | vms_fixup_sections (abfd) | |
358 | bfd *abfd; | |
359 | { | |
360 | asection *s; | |
361 | ||
362 | if (PRIV(fixup_done)) | |
363 | return true; | |
364 | ||
365 | /* | |
366 | * traverse symbol table and fill in all section pointers | |
367 | */ | |
368 | ||
369 | /* can't provide section count as argument to fill_section_ptr(). */ | |
370 | priv_section_count = PRIV(section_count); | |
371 | bfd_hash_traverse (PRIV(vms_symbol_table), fill_section_ptr, | |
372 | (PTR)(PRIV(sections))); | |
373 | ||
374 | PRIV(fixup_done) = true; | |
375 | ||
376 | return true; | |
377 | } | |
378 | ||
379 | /*===========================================================================*/ | |
380 | ||
381 | /* Check the format for a file being read. | |
382 | Return a (bfd_target *) if it's an object file or zero if not. */ | |
383 | ||
384 | static const struct bfd_target * | |
385 | vms_object_p (abfd) | |
386 | bfd *abfd; | |
387 | { | |
388 | int err = 0; | |
389 | int prev_type; | |
390 | const struct bfd_target *target_vector = 0; | |
391 | const bfd_arch_info_type *arch = 0; | |
392 | ||
393 | #if VMS_DEBUG | |
394 | vms_debug (1, "vms_object_p(%p)\n", abfd); | |
395 | #endif | |
396 | ||
397 | if (!vms_initialize (abfd)) | |
398 | { | |
399 | fprintf (stderr, "vms_initialize () failed !!\n"); | |
400 | return 0; | |
401 | } | |
402 | ||
403 | if (bfd_seek (abfd, 0L, SEEK_SET)) | |
404 | { | |
405 | bfd_set_error (bfd_error_file_truncated); | |
406 | return 0; | |
407 | } | |
408 | ||
409 | prev_type = -1; | |
410 | ||
411 | do | |
412 | { | |
413 | #if VMS_DEBUG | |
414 | vms_debug (7, "reading at %08lx\n", bfd_tell(abfd)); | |
415 | #endif | |
416 | if (_bfd_vms_next_record (abfd) < 0) | |
417 | { | |
418 | #if VMS_DEBUG | |
419 | vms_debug (2, "next_record failed\n"); | |
420 | #endif | |
421 | bfd_set_error (bfd_error_wrong_format); | |
422 | return 0; | |
423 | } | |
424 | ||
425 | if ((prev_type == EOBJ_S_C_EGSD) | |
426 | && (PRIV(rec_type) != EOBJ_S_C_EGSD)) | |
427 | { | |
428 | if (vms_fixup_sections (abfd) == false) | |
429 | { | |
430 | #if VMS_DEBUG | |
431 | vms_debug (2, "vms_fixup_sections failed\n"); | |
432 | #endif | |
433 | bfd_set_error (bfd_error_wrong_format); | |
434 | return 0; | |
435 | } | |
436 | } | |
437 | ||
438 | prev_type = PRIV(rec_type); | |
439 | ||
440 | if (target_vector == 0) | |
441 | { | |
442 | if (prev_type <= OBJ_S_C_MAXRECTYP) | |
443 | target_vector = &vms_vax_vec; | |
444 | else | |
445 | target_vector = &vms_alpha_vec; | |
446 | } | |
447 | ||
448 | switch (prev_type) | |
449 | { | |
450 | case OBJ_S_C_HDR: | |
451 | case EOBJ_S_C_EMH: | |
452 | err = _bfd_vms_slurp_hdr (abfd, prev_type); | |
453 | break; | |
454 | case OBJ_S_C_EOM: | |
455 | case OBJ_S_C_EOMW: | |
456 | case EOBJ_S_C_EEOM: | |
457 | err = _bfd_vms_slurp_eom (abfd, prev_type); | |
458 | break; | |
459 | case OBJ_S_C_GSD: | |
460 | case EOBJ_S_C_EGSD: | |
461 | err = _bfd_vms_slurp_gsd (abfd, prev_type); | |
462 | break; | |
463 | case OBJ_S_C_TIR: | |
464 | case EOBJ_S_C_ETIR: | |
465 | err = _bfd_vms_slurp_tir (abfd, prev_type); | |
466 | break; | |
467 | case OBJ_S_C_DBG: | |
468 | case EOBJ_S_C_EDBG: | |
469 | err = _bfd_vms_slurp_dbg (abfd, prev_type); | |
470 | break; | |
471 | case OBJ_S_C_TBT: | |
472 | case EOBJ_S_C_ETBT: | |
473 | err = _bfd_vms_slurp_tbt (abfd, prev_type); | |
474 | break; | |
475 | case OBJ_S_C_LNK: | |
476 | err = _bfd_vms_slurp_lnk (abfd, prev_type); | |
477 | break; | |
478 | default: | |
479 | err = -1; | |
480 | } | |
481 | if (err != 0) | |
482 | { | |
483 | #if VMS_DEBUG | |
484 | vms_debug (2, "slurp type %d failed with %d\n", prev_type, err); | |
485 | #endif | |
486 | bfd_set_error (bfd_error_wrong_format); | |
487 | return 0; | |
488 | } | |
489 | } | |
490 | while ((prev_type != EOBJ_S_C_EEOM) && (prev_type != OBJ_S_C_EOM) && (prev_type != OBJ_S_C_EOMW)); | |
491 | ||
492 | if (target_vector == &vms_vax_vec) | |
493 | { | |
494 | if (vms_fixup_sections (abfd) == false) | |
495 | { | |
496 | #if VMS_DEBUG | |
497 | vms_debug (2, "vms_fixup_sections failed\n"); | |
498 | #endif | |
499 | bfd_set_error (bfd_error_wrong_format); | |
500 | return 0; | |
501 | } | |
502 | ||
503 | /* set arch_info to vax */ | |
504 | ||
505 | arch = bfd_scan_arch ("vax"); | |
506 | PRIV (is_vax) = 1; | |
507 | #if VMS_DEBUG | |
508 | vms_debug (2, "arch is vax\n"); | |
509 | #endif | |
510 | } | |
511 | else if (target_vector == &vms_alpha_vec) | |
512 | { | |
513 | /* set arch_info to alpha */ | |
514 | ||
515 | arch = bfd_scan_arch ("alpha"); | |
516 | PRIV (is_vax) = 0; | |
517 | #if VMS_DEBUG | |
518 | vms_debug (2, "arch is alpha\n"); | |
519 | #endif | |
520 | } | |
521 | ||
522 | if (arch == 0) | |
523 | { | |
524 | #if VMS_DEBUG | |
525 | vms_debug (2, "arch not found\n"); | |
526 | #endif | |
527 | bfd_set_error (bfd_error_wrong_format); | |
528 | return 0; | |
529 | } | |
530 | abfd->arch_info = arch; | |
531 | ||
532 | return target_vector; | |
533 | } | |
534 | ||
535 | ||
536 | /* Check the format for a file being read. | |
537 | Return a (bfd_target *) if it's an archive file or zero. */ | |
538 | ||
539 | static const struct bfd_target * | |
540 | vms_archive_p (abfd) | |
541 | bfd *abfd; | |
542 | { | |
543 | #if VMS_DEBUG | |
544 | vms_debug (1, "vms_archive_p(%p)\n", abfd); | |
545 | #endif | |
546 | ||
547 | return 0; | |
548 | } | |
549 | ||
550 | ||
551 | /* Set the format of a file being written. */ | |
552 | ||
553 | static boolean | |
554 | vms_mkobject (abfd) | |
555 | bfd *abfd; | |
556 | { | |
557 | #if VMS_DEBUG | |
558 | vms_debug (1, "vms_mkobject(%p)\n", abfd); | |
559 | #endif | |
560 | ||
561 | if (!vms_initialize (abfd)) | |
562 | { | |
563 | fprintf (stderr, "vms_initialize () failed !!\n"); | |
564 | return 0; | |
565 | } | |
566 | ||
567 | { | |
568 | #ifdef __VAX | |
569 | const bfd_arch_info_type *arch = bfd_scan_arch ("vax"); | |
570 | #else | |
571 | const bfd_arch_info_type *arch = bfd_scan_arch ("alpha"); | |
572 | #endif | |
573 | if (arch == 0) | |
574 | { | |
575 | bfd_set_error(bfd_error_wrong_format); | |
576 | return 0; | |
577 | } | |
578 | abfd->arch_info = arch; | |
579 | } | |
580 | ||
581 | return true; | |
582 | } | |
583 | ||
584 | ||
585 | /* Write cached information into a file being written, at bfd_close. */ | |
586 | ||
587 | static boolean | |
588 | vms_write_object_contents (abfd) | |
589 | bfd *abfd; | |
590 | { | |
591 | #if VMS_DEBUG | |
592 | vms_debug (1, "vms_write_object_contents(%p)\n", abfd); | |
593 | #endif | |
594 | ||
595 | if (abfd->section_count > 0) /* we have sections */ | |
596 | { | |
597 | if (PRIV(is_vax)) | |
598 | { | |
599 | if (_bfd_vms_write_hdr (abfd, OBJ_S_C_HDR) != 0) | |
600 | return false; | |
601 | if (_bfd_vms_write_gsd (abfd, OBJ_S_C_GSD) != 0) | |
602 | return false; | |
603 | if (_bfd_vms_write_tir (abfd, OBJ_S_C_TIR) != 0) | |
604 | return false; | |
605 | if (_bfd_vms_write_tbt (abfd, OBJ_S_C_TBT) != 0) | |
606 | return false; | |
607 | if (_bfd_vms_write_dbg (abfd, OBJ_S_C_DBG) != 0) | |
608 | return false; | |
609 | if (abfd->section_count > 255) | |
610 | { | |
611 | if (_bfd_vms_write_eom (abfd, OBJ_S_C_EOMW) != 0) | |
612 | return false; | |
613 | } | |
614 | else | |
615 | { | |
616 | if (_bfd_vms_write_eom (abfd, OBJ_S_C_EOM) != 0) | |
617 | return false; | |
618 | } | |
619 | } | |
620 | else | |
621 | { | |
622 | if (_bfd_vms_write_hdr (abfd, EOBJ_S_C_EMH) != 0) | |
623 | return false; | |
624 | if (_bfd_vms_write_gsd (abfd, EOBJ_S_C_EGSD) != 0) | |
625 | return false; | |
626 | if (_bfd_vms_write_tir (abfd, EOBJ_S_C_ETIR) != 0) | |
627 | return false; | |
628 | if (_bfd_vms_write_tbt (abfd, EOBJ_S_C_ETBT) != 0) | |
629 | return false; | |
630 | if (_bfd_vms_write_dbg (abfd, EOBJ_S_C_EDBG) != 0) | |
631 | return false; | |
632 | if (_bfd_vms_write_eom (abfd, EOBJ_S_C_EEOM) != 0) | |
633 | return false; | |
634 | } | |
635 | } | |
636 | return true; | |
637 | } | |
638 | ||
639 | /*-- 4.1, generic -----------------------------------------------------------*/ | |
640 | ||
641 | /* Called when the BFD is being closed to do any necessary cleanup. */ | |
642 | ||
643 | static boolean | |
644 | vms_close_and_cleanup (abfd) | |
645 | bfd *abfd; | |
646 | { | |
647 | asection *sec; | |
648 | vms_section *es, *es1; | |
649 | vms_reloc *er, *er1; | |
650 | int i; | |
651 | ||
652 | #if VMS_DEBUG | |
653 | vms_debug (1, "vms_close_and_cleanup(%p)\n", abfd); | |
654 | #endif | |
655 | if (abfd == 0) | |
656 | return true; | |
657 | ||
658 | if (PRIV(vms_buf) != NULL) | |
659 | { | |
660 | free (PRIV(vms_buf)); | |
661 | PRIV(vms_buf) = NULL; | |
662 | } | |
663 | PRIV(buf_size) = 0; | |
664 | ||
665 | if (PRIV(output_buf) != 0) | |
666 | { | |
667 | free (PRIV(output_buf)); | |
668 | PRIV(output_buf) = 0; | |
669 | } | |
670 | ||
671 | sec = abfd->sections; | |
672 | while (sec != NULL) | |
673 | { | |
674 | if (sec->contents) | |
675 | free (sec->contents); | |
676 | sec = sec->next; | |
677 | } | |
678 | ||
679 | if (PRIV(sections) != NULL) | |
680 | { | |
681 | free (PRIV(sections)); | |
682 | PRIV(sections) = NULL; | |
683 | } | |
684 | ||
685 | if (PRIV(vms_symbol_table)) | |
686 | { | |
687 | bfd_hash_table_free (PRIV(vms_symbol_table)); | |
688 | PRIV(vms_symbol_table) = 0; | |
689 | } | |
690 | ||
691 | if (PRIV(stack)) | |
692 | { | |
693 | free (PRIV(stack)); | |
694 | PRIV(stack) = 0; | |
695 | } | |
696 | ||
697 | if (PRIV(location_stack)) | |
698 | { | |
699 | free (PRIV(location_stack)); | |
700 | PRIV(location_stack) = 0; | |
701 | } | |
702 | ||
703 | for (i = 0; i < VMS_SECTION_COUNT; i++) | |
704 | { | |
705 | es = PRIV(vms_section_table)[i]; | |
706 | while (es != NULL) | |
707 | { | |
708 | es1 = es->next; | |
709 | free (es); | |
710 | es = es1; | |
711 | } | |
712 | PRIV(vms_section_table)[i] = NULL; | |
713 | } | |
714 | ||
715 | free (abfd->tdata.any); | |
716 | abfd->tdata.any = NULL; | |
717 | ||
718 | return true; | |
719 | } | |
720 | ||
721 | ||
722 | /* Ask the BFD to free all cached information. */ | |
723 | static boolean | |
724 | vms_bfd_free_cached_info (abfd) | |
725 | bfd *abfd; | |
726 | { | |
727 | #if VMS_DEBUG | |
728 | vms_debug (1, "vms_bfd_free_cached_info(%p)\n", abfd); | |
729 | #endif | |
730 | return true; | |
731 | } | |
732 | ||
733 | ||
734 | /* Called when a new section is created. */ | |
735 | ||
736 | static boolean | |
737 | vms_new_section_hook (abfd, section) | |
738 | bfd *abfd; | |
739 | asection *section; | |
740 | { | |
741 | #if VMS_DEBUG | |
742 | vms_debug (1, "vms_new_section_hook (%p, [%d]%s), count %d\n", abfd, section->index, section->name, abfd->section_count); | |
743 | #endif | |
744 | bfd_set_section_alignment(abfd, section, 4); | |
745 | ||
746 | if (abfd->section_count > PRIV(section_count)) | |
747 | { | |
748 | PRIV(sections) = ((asection **) | |
749 | bfd_realloc (PRIV(sections), abfd->section_count * sizeof (asection *))); | |
750 | if (PRIV(sections) == 0) | |
751 | return false; | |
752 | PRIV(section_count) = abfd->section_count; | |
753 | } | |
754 | #if VMS_DEBUG | |
755 | vms_debug (6, "section_count: %d\n", PRIV(section_count)); | |
756 | #endif | |
757 | PRIV(sections)[section->index] = section; | |
758 | #if VMS_DEBUG | |
759 | vms_debug (7, "%d: %s\n", section->index, section->name); | |
760 | #endif | |
761 | ||
762 | return true; | |
763 | } | |
764 | ||
765 | ||
766 | /* Read the contents of a section. | |
767 | buf points to a buffer of buf_size bytes to be filled with | |
768 | section data (starting at offset into section) */ | |
769 | ||
770 | static boolean | |
771 | vms_get_section_contents (abfd, section, buf, offset, buf_size) | |
772 | bfd *abfd; | |
773 | asection *section; | |
774 | PTR buf; | |
775 | file_ptr offset; | |
776 | bfd_size_type buf_size; | |
777 | { | |
778 | #if VMS_DEBUG | |
779 | vms_debug (1, "vms_get_section_contents(%p, %s, %p, off %ld, size %d)\n", | |
780 | abfd, section->name, buf, offset, (int)buf_size); | |
781 | #endif | |
782 | ||
783 | /* shouldn't be called, since all sections are IN_MEMORY */ | |
784 | ||
785 | return false; | |
786 | } | |
787 | ||
788 | /* Read the contents of a section. | |
789 | buf points to a buffer of buf_size bytes to be filled with | |
790 | section data (starting at offset into section) */ | |
791 | ||
792 | static boolean | |
793 | vms_get_section_contents_in_window (abfd, section, w, offset, count) | |
794 | bfd *abfd; | |
795 | asection *section; | |
796 | bfd_window *w; | |
797 | file_ptr offset; | |
798 | bfd_size_type count; | |
799 | { | |
800 | #if VMS_DEBUG | |
801 | vms_debug (1, "vms_get_section_contents_in_window(%p, %s, %p, off %ld, count %d)\n", | |
802 | abfd, section->name, w, offset, (int)count); | |
803 | #endif | |
804 | ||
805 | /* shouldn't be called, since all sections are IN_MEMORY */ | |
806 | ||
807 | return false; | |
808 | } | |
809 | ||
810 | /*-- Part 4.2, copy private data --------------------------------------------*/ | |
811 | ||
812 | /* Called to copy BFD general private data from one object file | |
813 | to another. */ | |
814 | ||
815 | static boolean | |
816 | vms_bfd_copy_private_bfd_data (src, dest) | |
817 | bfd *src; | |
818 | bfd *dest; | |
819 | { | |
820 | #if VMS_DEBUG | |
821 | vms_debug (1, "vms_bfd_copy_private_bfd_data(%p, %p)\n", src, dest); | |
822 | #endif | |
823 | return true; | |
824 | } | |
825 | ||
826 | ||
827 | /* Merge private BFD information from the BFD @var{ibfd} to the | |
828 | the output file BFD @var{obfd} when linking. Return <<true>> | |
829 | on success, <<false>> on error. Possible error returns are: | |
830 | ||
831 | o <<bfd_error_no_memory>> - | |
832 | Not enough memory exists to create private data for @var{obfd}. */ | |
833 | ||
834 | static boolean | |
835 | vms_bfd_merge_private_bfd_data (ibfd, obfd) | |
836 | bfd *ibfd; | |
837 | bfd *obfd; | |
838 | { | |
839 | #if VMS_DEBUG | |
840 | vms_debug (1,"vms_bfd_merge_private_bfd_data(%p, %p)\n", ibfd, obfd); | |
841 | #endif | |
842 | return true; | |
843 | } | |
844 | ||
845 | ||
846 | /* Set private BFD flag information in the BFD @var{abfd}. | |
847 | Return <<true>> on success, <<false>> on error. Possible error | |
848 | returns are: | |
849 | ||
850 | o <<bfd_error_no_memory>> - | |
851 | Not enough memory exists to create private data for @var{obfd}. */ | |
852 | ||
853 | static boolean | |
854 | vms_bfd_set_private_flags (abfd, flags) | |
855 | bfd *abfd; | |
856 | flagword flags; | |
857 | { | |
858 | #if VMS_DEBUG | |
859 | vms_debug (1,"vms_bfd_set_private_flags(%p, %lx)\n", abfd, (long)flags); | |
860 | #endif | |
861 | return true; | |
862 | } | |
863 | ||
864 | ||
865 | /* Called to copy BFD private section data from one object file | |
866 | to another. */ | |
867 | ||
868 | static boolean | |
869 | vms_bfd_copy_private_section_data (srcbfd, srcsec, dstbfd, dstsec) | |
870 | bfd *srcbfd; | |
871 | asection *srcsec; | |
872 | bfd *dstbfd; | |
873 | asection *dstsec; | |
874 | { | |
875 | #if VMS_DEBUG | |
876 | vms_debug (1, "vms_bfd_copy_private_section_data(%p, %s, %p, %s)\n", | |
877 | srcbfd, srcsec->name, dstbfd, dstsec->name); | |
878 | #endif | |
879 | return true; | |
880 | } | |
881 | ||
882 | /* Called to copy BFD private symbol data from one object file | |
883 | to another. */ | |
884 | ||
885 | static boolean | |
886 | vms_bfd_copy_private_symbol_data (ibfd, isym, obfd, osym) | |
887 | bfd *ibfd; | |
888 | asymbol *isym; | |
889 | bfd *obfd; | |
890 | asymbol *osym; | |
891 | { | |
892 | #if VMS_DEBUG | |
893 | vms_debug (1, "vms_bfd_copy_private_symbol_data(%p, %s, %p, %s)\n", | |
894 | ibfd, isym->name, obfd, osym->name); | |
895 | #endif | |
896 | return true; | |
897 | } | |
898 | ||
899 | /*-- Part 4.3, core file ----------------------------------------------------*/ | |
900 | ||
901 | /* Return a read-only string explaining which program was running | |
902 | when it failed and produced the core file abfd. */ | |
903 | ||
904 | static char * | |
905 | vms_core_file_failing_command (abfd) | |
906 | bfd *abfd; | |
907 | { | |
908 | #if VMS_DEBUG | |
909 | vms_debug (1, "vms_core_file_failing_command(%p)\n", abfd); | |
910 | #endif | |
911 | return 0; | |
912 | } | |
913 | ||
914 | ||
915 | /* Returns the signal number which caused the core dump which | |
916 | generated the file the BFD abfd is attached to. */ | |
917 | ||
918 | static int | |
919 | vms_core_file_failing_signal (abfd) | |
920 | bfd *abfd; | |
921 | { | |
922 | #if VMS_DEBUG | |
923 | vms_debug (1, "vms_core_file_failing_signal(%p)\n", abfd); | |
924 | #endif | |
925 | return 0; | |
926 | } | |
927 | ||
928 | ||
929 | /* Return true if the core file attached to core_bfd was generated | |
930 | by a run of the executable file attached to exec_bfd, false otherwise. */ | |
931 | ||
932 | static boolean | |
933 | vms_core_file_matches_executable_p (abfd, bbfd) | |
934 | bfd *abfd; | |
935 | bfd *bbfd; | |
936 | { | |
937 | #if VMS_DEBUG | |
938 | vms_debug (1, "vms_core_file_matches_executable_p(%p, %p)\n", abfd, bbfd); | |
939 | #endif | |
940 | return false; | |
941 | } | |
942 | ||
943 | /*-- Part 4.4, archive ------------------------------------------------------*/ | |
944 | ||
945 | /* ??? do something with an archive map. | |
946 | Return false on error, true otherwise. */ | |
947 | ||
948 | static boolean | |
949 | vms_slurp_armap (abfd) | |
950 | bfd *abfd; | |
951 | { | |
952 | #if VMS_DEBUG | |
953 | vms_debug (1, "vms_slurp_armap(%p)\n", abfd); | |
954 | #endif | |
955 | return false; | |
956 | } | |
957 | ||
958 | ||
959 | /* ??? do something with an extended name table. | |
960 | Return false on error, true otherwise. */ | |
961 | ||
962 | static boolean | |
963 | vms_slurp_extended_name_table (abfd) | |
964 | bfd *abfd; | |
965 | { | |
966 | #if VMS_DEBUG | |
967 | vms_debug (1, "vms_slurp_extended_name_table(%p)\n", abfd); | |
968 | #endif | |
969 | return false; | |
970 | } | |
971 | ||
972 | ||
973 | /* ??? do something with an extended name table. | |
974 | Return false on error, true otherwise. */ | |
975 | ||
976 | static boolean | |
977 | vms_construct_extended_name_table (abfd, tabloc, tablen, name) | |
978 | bfd *abfd; | |
979 | char **tabloc; | |
980 | bfd_size_type *tablen; | |
981 | const char **name; | |
982 | { | |
983 | #if VMS_DEBUG | |
984 | vms_debug (1, "vms_construct_extended_name_table(%p)\n", abfd); | |
985 | #endif | |
986 | return false; | |
987 | } | |
988 | ||
989 | ||
990 | /* Truncate the name of an archive to match system-dependent restrictions */ | |
991 | ||
992 | static void | |
993 | vms_truncate_arname (abfd, pathname, arhdr) | |
994 | bfd *abfd; | |
995 | CONST char *pathname; | |
996 | char *arhdr; | |
997 | { | |
998 | #if VMS_DEBUG | |
999 | vms_debug (1, "vms_truncate_arname(%p, %s, %s)\n", abfd, pathname, arhdr); | |
1000 | #endif | |
1001 | return; | |
1002 | } | |
1003 | ||
1004 | ||
1005 | /* ??? write archive map */ | |
1006 | ||
1007 | static boolean | |
1008 | vms_write_armap (arch, elength, map, orl_count, stridx) | |
1009 | bfd *arch; | |
1010 | unsigned int elength; | |
1011 | struct orl *map; | |
1012 | unsigned int orl_count; | |
1013 | int stridx; | |
1014 | { | |
1015 | #if VMS_DEBUG | |
1016 | vms_debug (1, "vms_write_armap(%p, %d, %p, %d %d)\n", | |
1017 | arch, elength, map, orl_count, stridx); | |
1018 | #endif | |
1019 | return true; | |
1020 | } | |
1021 | ||
1022 | /* Read archive header ??? */ | |
1023 | ||
1024 | static PTR | |
1025 | vms_read_ar_hdr (abfd) | |
1026 | bfd * abfd; | |
1027 | { | |
1028 | #if VMS_DEBUG | |
1029 | vms_debug (1, "vms_read_ar_hdr(%p)\n", abfd); | |
1030 | #endif | |
1031 | return (PTR)0; | |
1032 | } | |
1033 | ||
1034 | ||
1035 | /* Provided a BFD, @var{archive}, containing an archive and NULL, open | |
1036 | an input BFD on the first contained element and returns that. | |
1037 | Subsequent calls should pass the archive and the previous return value | |
1038 | to return a created BFD to the next contained element. | |
1039 | NULL is returned when there are no more. */ | |
1040 | ||
1041 | static bfd * | |
1042 | vms_openr_next_archived_file (arch, prev) | |
1043 | bfd *arch; | |
1044 | bfd *prev; | |
1045 | { | |
1046 | #if VMS_DEBUG | |
1047 | vms_debug (1, "vms_openr_next_archived_file(%p, %p)\n", arch, prev); | |
1048 | #endif | |
1049 | return false; | |
1050 | } | |
1051 | ||
1052 | ||
1053 | /* Return the BFD which is referenced by the symbol in ABFD indexed by | |
1054 | INDEX. INDEX should have been returned by bfd_get_next_mapent. */ | |
1055 | ||
1056 | static bfd * | |
1057 | vms_get_elt_at_index (abfd, index) | |
1058 | bfd *abfd; | |
1059 | symindex index; | |
1060 | { | |
1061 | #if VMS_DEBUG | |
1062 | vms_debug (1, "vms_get_elt_at_index(%p, %p)\n", abfd, index); | |
1063 | #endif | |
1064 | return _bfd_generic_get_elt_at_index(abfd, index); | |
1065 | } | |
1066 | ||
1067 | ||
1068 | /* ??? | |
1069 | -> bfd_generic_stat_arch_elt */ | |
1070 | ||
1071 | static int | |
1072 | vms_generic_stat_arch_elt (abfd, stat) | |
1073 | bfd *abfd; | |
1074 | struct stat *stat; | |
1075 | { | |
1076 | #if VMS_DEBUG | |
1077 | vms_debug (1, "vms_generic_stat_arch_elt(%p, %p)\n", abfd, stat); | |
1078 | #endif | |
1079 | return bfd_generic_stat_arch_elt(abfd, stat); | |
1080 | } | |
1081 | ||
1082 | ||
1083 | /* This is a new function in bfd 2.5 */ | |
1084 | ||
1085 | static boolean | |
1086 | vms_update_armap_timestamp (abfd) | |
1087 | bfd *abfd; | |
1088 | { | |
1089 | #if VMS_DEBUG | |
1090 | vms_debug (1, "vms_update_armap_timestamp(%p)\n", abfd); | |
1091 | #endif | |
1092 | return true; | |
1093 | } | |
1094 | ||
1095 | /*-- Part 4.5, symbols --------------------------------------------------------*/ | |
1096 | ||
1097 | /* Return the number of bytes required to store a vector of pointers | |
1098 | to asymbols for all the symbols in the BFD abfd, including a | |
1099 | terminal NULL pointer. If there are no symbols in the BFD, | |
1100 | then return 0. If an error occurs, return -1. */ | |
1101 | ||
1102 | static long | |
1103 | vms_get_symtab_upper_bound (abfd) | |
1104 | bfd *abfd; | |
1105 | { | |
1106 | #if VMS_DEBUG | |
1107 | vms_debug (1, "vms_get_symtab_upper_bound(%p), %d symbols\n", abfd, PRIV(gsd_sym_count)); | |
1108 | #endif | |
1109 | return (PRIV(gsd_sym_count)+1) * sizeof(asymbol *); | |
1110 | } | |
1111 | ||
1112 | ||
1113 | /* Copy symbols from hash table to symbol vector | |
1114 | ||
1115 | called from bfd_hash_traverse in vms_get_symtab | |
1116 | init counter to 0 if entry == 0 */ | |
1117 | ||
1118 | static boolean | |
1119 | copy_symbols (entry, arg) | |
1120 | struct bfd_hash_entry *entry; | |
1121 | PTR arg; | |
1122 | { | |
1123 | bfd *abfd = (bfd *) arg; | |
1124 | ||
1125 | if (entry == NULL) /* init counter */ | |
1126 | PRIV(symnum) = 0; | |
1127 | else /* fill vector, inc counter */ | |
1128 | PRIV(symcache)[PRIV(symnum)++] = ((vms_symbol_entry *)entry)->symbol; | |
1129 | ||
1130 | return true; | |
1131 | } | |
1132 | ||
1133 | ||
1134 | /* Read the symbols from the BFD abfd, and fills in the vector | |
1135 | location with pointers to the symbols and a trailing NULL. | |
1136 | ||
1137 | return # of symbols read */ | |
1138 | ||
1139 | static long | |
1140 | vms_get_symtab (abfd, symbols) | |
1141 | bfd *abfd; | |
1142 | asymbol **symbols; | |
1143 | { | |
1144 | #if VMS_DEBUG | |
1145 | vms_debug (1, "vms_get_symtab(%p, <ret>)\n", abfd); | |
1146 | #endif | |
1147 | ||
1148 | /* init counter */ | |
1149 | (void)copy_symbols((struct bfd_hash_entry *)0, abfd); | |
1150 | ||
1151 | /* traverse table and fill symbols vector */ | |
1152 | ||
1153 | PRIV(symcache) = symbols; | |
1154 | bfd_hash_traverse(PRIV(vms_symbol_table), copy_symbols, (PTR)abfd); | |
1155 | ||
1156 | symbols[PRIV(gsd_sym_count)] = NULL; | |
1157 | ||
1158 | return PRIV(gsd_sym_count); | |
1159 | } | |
1160 | ||
1161 | ||
1162 | /* Create a new asymbol structure for the BFD abfd and return a pointer | |
1163 | to it. | |
1164 | This routine is necessary because each back end has private information | |
1165 | surrounding the asymbol. Building your own asymbol and pointing to it | |
1166 | will not create the private information, and will cause problems later on. */ | |
1167 | ||
1168 | asymbol * | |
1169 | _bfd_vms_make_empty_symbol (abfd) | |
1170 | bfd *abfd; | |
1171 | { | |
1172 | asymbol *symbol = (asymbol *)bfd_zalloc(abfd, sizeof(asymbol)); | |
1173 | ||
1174 | #if VMS_DEBUG | |
1175 | vms_debug (1, "_bfd_vms_make_empty_symbol(%p)\n", abfd); | |
1176 | #endif | |
1177 | ||
1178 | if (symbol == 0) | |
1179 | { | |
1180 | bfd_set_error (bfd_error_no_memory); | |
1181 | return 0; | |
1182 | } | |
1183 | symbol->the_bfd = abfd; | |
1184 | ||
1185 | return symbol; | |
1186 | } | |
1187 | ||
1188 | ||
1189 | /* Print symbol to file according to how. how is one of | |
1190 | bfd_print_symbol_name just print the name | |
1191 | bfd_print_symbol_more print more (???) | |
1192 | bfd_print_symbol_all print all we know, which is not much right now :-) */ | |
1193 | ||
1194 | static void | |
1195 | vms_print_symbol (abfd, file, symbol, how) | |
1196 | bfd *abfd; | |
1197 | PTR file; | |
1198 | asymbol *symbol; | |
1199 | bfd_print_symbol_type how; | |
1200 | { | |
1201 | #if VMS_DEBUG | |
1202 | vms_debug (1, "vms_print_symbol(%p, %p, %p, %d)\n", abfd, file, symbol, how); | |
1203 | #endif | |
1204 | ||
1205 | switch (how) | |
1206 | { | |
1207 | case bfd_print_symbol_name: | |
1208 | case bfd_print_symbol_more: | |
1209 | fprintf((FILE *)file," %s", symbol->name); | |
1210 | break; | |
1211 | ||
1212 | break; | |
1213 | ||
1214 | case bfd_print_symbol_all: | |
1215 | { | |
1216 | CONST char *section_name = symbol->section->name; | |
1217 | ||
1218 | bfd_print_symbol_vandf((PTR)file,symbol); | |
1219 | ||
1220 | fprintf((FILE *)file," %-8s %s", section_name, symbol->name); | |
1221 | } | |
1222 | break; | |
1223 | } | |
1224 | return; | |
1225 | } | |
1226 | ||
1227 | ||
1228 | /* Return information about symbol in ret. | |
1229 | ||
1230 | fill type, value and name | |
1231 | type: | |
1232 | A absolute | |
1233 | B bss segment symbol | |
1234 | C common symbol | |
1235 | D data segment symbol | |
1236 | f filename | |
1237 | t a static function symbol | |
1238 | T text segment symbol | |
1239 | U undefined | |
1240 | - debug */ | |
1241 | ||
1242 | static void | |
1243 | vms_get_symbol_info (abfd, symbol, ret) | |
1244 | bfd *abfd; | |
1245 | asymbol *symbol; | |
1246 | symbol_info *ret; | |
1247 | { | |
1248 | asection *sec; | |
1249 | ||
1250 | #if VMS_DEBUG | |
1251 | vms_debug (1, "vms_get_symbol_info(%p, %p, %p)\n", abfd, symbol, ret); | |
1252 | #endif | |
1253 | ||
1254 | sec = symbol->section; | |
1255 | ||
1256 | if (ret == 0) | |
1257 | return; | |
1258 | ||
1259 | if (bfd_is_com_section (sec)) | |
1260 | ret->type = 'C'; | |
1261 | else if (bfd_is_abs_section (sec)) | |
1262 | ret->type = 'A'; | |
1263 | else if (bfd_is_und_section (sec)) | |
1264 | ret->type = 'U'; | |
1265 | else if (bfd_is_ind_section (sec)) | |
1266 | ret->type = 'I'; | |
1267 | else if (bfd_get_section_flags (abfd, sec) & SEC_CODE) | |
1268 | ret->type = 'T'; | |
1269 | else if (bfd_get_section_flags (abfd, sec) & SEC_DATA) | |
1270 | ret->type = 'D'; | |
1271 | else if (bfd_get_section_flags (abfd, sec) & SEC_ALLOC) | |
1272 | ret->type = 'B'; | |
1273 | else | |
1274 | ret->type = '-'; | |
1275 | ||
1276 | if (ret->type != 'U') | |
1277 | ret->value = symbol->value + symbol->section->vma; | |
1278 | else | |
1279 | ret->value = 0; | |
1280 | ret->name = symbol->name; | |
1281 | ||
1282 | return; | |
1283 | } | |
1284 | ||
1285 | ||
1286 | /* Return true if the given symbol sym in the BFD abfd is | |
1287 | a compiler generated local label, else return false. */ | |
1288 | ||
1289 | static boolean | |
1290 | vms_bfd_is_local_label_name (abfd, name) | |
1291 | bfd *abfd; | |
1292 | const char *name; | |
1293 | { | |
1294 | #if VMS_DEBUG | |
1295 | vms_debug (1, "vms_bfd_is_local_label_name(%p, %s)\n", abfd, name); | |
1296 | #endif | |
1297 | return name[0] == '$'; | |
1298 | } | |
1299 | ||
1300 | ||
1301 | /* Get source line number for symbol */ | |
1302 | ||
1303 | static alent * | |
1304 | vms_get_lineno (abfd, symbol) | |
1305 | bfd *abfd; | |
1306 | asymbol *symbol; | |
1307 | { | |
1308 | #if VMS_DEBUG | |
1309 | vms_debug (1, "vms_get_lineno(%p, %p)\n", abfd, symbol); | |
1310 | #endif | |
1311 | return 0; | |
1312 | } | |
1313 | ||
1314 | ||
1315 | /* Provided a BFD, a section and an offset into the section, calculate and | |
1316 | return the name of the source file and the line nearest to the wanted | |
1317 | location. */ | |
1318 | ||
1319 | static boolean | |
1320 | vms_find_nearest_line (abfd, section, symbols, offset, file, func, line) | |
1321 | bfd *abfd; | |
1322 | asection *section; | |
1323 | asymbol **symbols; | |
1324 | bfd_vma offset; | |
1325 | CONST char **file; | |
1326 | CONST char **func; | |
1327 | unsigned int *line; | |
1328 | { | |
1329 | #if VMS_DEBUG | |
1330 | vms_debug (1, "vms_find_nearest_line(%p, %s, %p, %ld, <ret>, <ret>, <ret>)\n", | |
1331 | abfd, section->name, symbols, (long int)offset); | |
1332 | #endif | |
1333 | return false; | |
1334 | } | |
1335 | ||
1336 | ||
1337 | /* Back-door to allow format-aware applications to create debug symbols | |
1338 | while using BFD for everything else. Currently used by the assembler | |
1339 | when creating COFF files. */ | |
1340 | ||
1341 | static asymbol * | |
1342 | vms_bfd_make_debug_symbol (abfd, ptr, size) | |
1343 | bfd *abfd; | |
1344 | void *ptr; | |
1345 | unsigned long size; | |
1346 | { | |
1347 | #if VMS_DEBUG | |
1348 | vms_debug (1, "vms_bfd_make_debug_symbol(%p, %p, %ld)\n", abfd, ptr, size); | |
1349 | #endif | |
1350 | return 0; | |
1351 | } | |
1352 | ||
1353 | ||
1354 | /* Read minisymbols. For minisymbols, we use the unmodified a.out | |
1355 | symbols. The minisymbol_to_symbol function translates these into | |
1356 | BFD asymbol structures. */ | |
1357 | ||
1358 | static long | |
1359 | vms_read_minisymbols (abfd, dynamic, minisymsp, sizep) | |
1360 | bfd *abfd; | |
1361 | boolean dynamic; | |
1362 | PTR *minisymsp; | |
1363 | unsigned int *sizep; | |
1364 | { | |
1365 | #if VMS_DEBUG | |
1366 | vms_debug (1, "vms_read_minisymbols(%p, %d, %p, %d)\n", abfd, dynamic, minisymsp, *sizep); | |
1367 | #endif | |
1368 | return _bfd_generic_read_minisymbols (abfd, dynamic, minisymsp, sizep); | |
1369 | } | |
1370 | ||
1371 | /* Convert a minisymbol to a BFD asymbol. A minisymbol is just an | |
1372 | unmodified a.out symbol. The SYM argument is a structure returned | |
1373 | by bfd_make_empty_symbol, which we fill in here. */ | |
1374 | ||
1375 | static asymbol * | |
1376 | vms_minisymbol_to_symbol (abfd, dynamic, minisym, sym) | |
1377 | bfd *abfd; | |
1378 | boolean dynamic; | |
1379 | const PTR minisym; | |
1380 | asymbol *sym; | |
1381 | { | |
1382 | #if VMS_DEBUG | |
1383 | vms_debug (1, "vms_minisymbol_to_symbol(%p, %d, %p, %p)\n", abfd, dynamic, minisym, sym); | |
1384 | #endif | |
1385 | return _bfd_generic_minisymbol_to_symbol (abfd, dynamic, minisym, sym); | |
1386 | } | |
1387 | ||
1388 | /*-- Part 4.6, relocations --------------------------------------------------*/ | |
1389 | ||
1390 | /* Return the number of bytes required to store the relocation information | |
1391 | associated with section sect attached to bfd abfd. | |
1392 | If an error occurs, return -1. */ | |
1393 | ||
1394 | static long | |
1395 | vms_get_reloc_upper_bound (abfd, section) | |
1396 | bfd *abfd; | |
1397 | asection *section; | |
1398 | { | |
1399 | #if VMS_DEBUG | |
1400 | vms_debug (1, "vms_get_reloc_upper_bound(%p, %s)\n", abfd, section->name); | |
1401 | #endif | |
1402 | return -1L; | |
1403 | } | |
1404 | ||
1405 | ||
1406 | /* Call the back end associated with the open BFD abfd and translate the | |
1407 | external form of the relocation information attached to sec into the | |
1408 | internal canonical form. Place the table into memory at loc, which has | |
1409 | been preallocated, usually by a call to bfd_get_reloc_upper_bound. | |
1410 | Returns the number of relocs, or -1 on error. */ | |
1411 | ||
1412 | static long | |
1413 | vms_canonicalize_reloc (abfd, section, location, symbols) | |
1414 | bfd *abfd; | |
1415 | asection *section; | |
1416 | arelent **location; | |
1417 | asymbol **symbols; | |
1418 | { | |
1419 | #if VMS_DEBUG | |
1420 | vms_debug (1, "vms_canonicalize_reloc(%p, %s, <ret>, <ret>)\n", abfd, section->name); | |
1421 | #endif | |
1422 | return false; | |
1423 | } | |
1424 | ||
1425 | /*---------------------------------------------------------------------------*/ | |
1426 | /* this is just copied from ecoff-alpha, needs to be fixed probably */ | |
1427 | ||
1428 | /* How to process the various reloc types. */ | |
1429 | ||
1430 | static bfd_reloc_status_type | |
1431 | reloc_nil (abfd, reloc, sym, data, sec, output_bfd, error_message) | |
1432 | bfd *abfd; | |
1433 | arelent *reloc; | |
1434 | asymbol *sym; | |
1435 | PTR data; | |
1436 | asection *sec; | |
1437 | bfd *output_bfd; | |
1438 | char **error_message; | |
1439 | { | |
1440 | #if VMS_DEBUG | |
1441 | vms_debug (1, "reloc_nil(abfd %p, output_bfd %p)\n", abfd, output_bfd); | |
1442 | vms_debug (2, "In section %s, symbol %s\n", | |
1443 | sec->name, sym->name); | |
1444 | vms_debug (2, "reloc sym %s, addr %08lx, addend %08lx, reloc is a %s\n", | |
1445 | reloc->sym_ptr_ptr[0]->name, | |
1446 | (unsigned long)reloc->address, | |
1447 | (unsigned long)reloc->addend, reloc->howto->name); | |
1448 | vms_debug (2, "data at %p\n", data); | |
1449 | /* _bfd_hexdump (2, data, bfd_get_reloc_size(reloc->howto),0); */ | |
1450 | #endif | |
1451 | ||
1452 | return bfd_reloc_ok; | |
1453 | } | |
1454 | ||
1455 | /* In case we're on a 32-bit machine, construct a 64-bit "-1" value | |
1456 | from smaller values. Start with zero, widen, *then* decrement. */ | |
1457 | #define MINUS_ONE (((bfd_vma)0) - 1) | |
1458 | ||
1459 | static reloc_howto_type alpha_howto_table[] = | |
1460 | { | |
1461 | HOWTO (ALPHA_R_IGNORE, /* type */ | |
1462 | 0, /* rightshift */ | |
1463 | 0, /* size (0 = byte, 1 = short, 2 = long) */ | |
1464 | 8, /* bitsize */ | |
1465 | true, /* pc_relative */ | |
1466 | 0, /* bitpos */ | |
1467 | complain_overflow_dont, /* complain_on_overflow */ | |
1468 | reloc_nil, /* special_function */ | |
1469 | "IGNORE", /* name */ | |
1470 | true, /* partial_inplace */ | |
1471 | 0, /* src_mask */ | |
1472 | 0, /* dst_mask */ | |
1473 | true), /* pcrel_offset */ | |
1474 | ||
1475 | /* A 64 bit reference to a symbol. */ | |
1476 | HOWTO (ALPHA_R_REFQUAD, /* type */ | |
1477 | 0, /* rightshift */ | |
1478 | 4, /* size (0 = byte, 1 = short, 2 = long) */ | |
1479 | 64, /* bitsize */ | |
1480 | false, /* pc_relative */ | |
1481 | 0, /* bitpos */ | |
1482 | complain_overflow_bitfield, /* complain_on_overflow */ | |
1483 | reloc_nil, /* special_function */ | |
1484 | "REFQUAD", /* name */ | |
1485 | true, /* partial_inplace */ | |
1486 | MINUS_ONE, /* src_mask */ | |
1487 | MINUS_ONE, /* dst_mask */ | |
1488 | false), /* pcrel_offset */ | |
1489 | ||
1490 | /* A 21 bit branch. The native assembler generates these for | |
1491 | branches within the text segment, and also fills in the PC | |
1492 | relative offset in the instruction. */ | |
1493 | HOWTO (ALPHA_R_BRADDR, /* type */ | |
1494 | 2, /* rightshift */ | |
1495 | 2, /* size (0 = byte, 1 = short, 2 = long) */ | |
1496 | 21, /* bitsize */ | |
1497 | true, /* pc_relative */ | |
1498 | 0, /* bitpos */ | |
1499 | complain_overflow_signed, /* complain_on_overflow */ | |
1500 | reloc_nil, /* special_function */ | |
1501 | "BRADDR", /* name */ | |
1502 | true, /* partial_inplace */ | |
1503 | 0x1fffff, /* src_mask */ | |
1504 | 0x1fffff, /* dst_mask */ | |
1505 | false), /* pcrel_offset */ | |
1506 | ||
1507 | /* A hint for a jump to a register. */ | |
1508 | HOWTO (ALPHA_R_HINT, /* type */ | |
1509 | 2, /* rightshift */ | |
1510 | 1, /* size (0 = byte, 1 = short, 2 = long) */ | |
1511 | 14, /* bitsize */ | |
1512 | true, /* pc_relative */ | |
1513 | 0, /* bitpos */ | |
1514 | complain_overflow_dont, /* complain_on_overflow */ | |
1515 | reloc_nil, /* special_function */ | |
1516 | "HINT", /* name */ | |
1517 | true, /* partial_inplace */ | |
1518 | 0x3fff, /* src_mask */ | |
1519 | 0x3fff, /* dst_mask */ | |
1520 | false), /* pcrel_offset */ | |
1521 | ||
1522 | /* 16 bit PC relative offset. */ | |
1523 | HOWTO (ALPHA_R_SREL16, /* type */ | |
1524 | 0, /* rightshift */ | |
1525 | 1, /* size (0 = byte, 1 = short, 2 = long) */ | |
1526 | 16, /* bitsize */ | |
1527 | true, /* pc_relative */ | |
1528 | 0, /* bitpos */ | |
1529 | complain_overflow_signed, /* complain_on_overflow */ | |
1530 | reloc_nil, /* special_function */ | |
1531 | "SREL16", /* name */ | |
1532 | true, /* partial_inplace */ | |
1533 | 0xffff, /* src_mask */ | |
1534 | 0xffff, /* dst_mask */ | |
1535 | false), /* pcrel_offset */ | |
1536 | ||
1537 | /* 32 bit PC relative offset. */ | |
1538 | HOWTO (ALPHA_R_SREL32, /* type */ | |
1539 | 0, /* rightshift */ | |
1540 | 2, /* size (0 = byte, 1 = short, 2 = long) */ | |
1541 | 32, /* bitsize */ | |
1542 | true, /* pc_relative */ | |
1543 | 0, /* bitpos */ | |
1544 | complain_overflow_signed, /* complain_on_overflow */ | |
1545 | reloc_nil, /* special_function */ | |
1546 | "SREL32", /* name */ | |
1547 | true, /* partial_inplace */ | |
1548 | 0xffffffff, /* src_mask */ | |
1549 | 0xffffffff, /* dst_mask */ | |
1550 | false), /* pcrel_offset */ | |
1551 | ||
1552 | /* A 64 bit PC relative offset. */ | |
1553 | HOWTO (ALPHA_R_SREL64, /* type */ | |
1554 | 0, /* rightshift */ | |
1555 | 4, /* size (0 = byte, 1 = short, 2 = long) */ | |
1556 | 64, /* bitsize */ | |
1557 | true, /* pc_relative */ | |
1558 | 0, /* bitpos */ | |
1559 | complain_overflow_signed, /* complain_on_overflow */ | |
1560 | reloc_nil, /* special_function */ | |
1561 | "SREL64", /* name */ | |
1562 | true, /* partial_inplace */ | |
1563 | MINUS_ONE, /* src_mask */ | |
1564 | MINUS_ONE, /* dst_mask */ | |
1565 | false), /* pcrel_offset */ | |
1566 | ||
1567 | /* Push a value on the reloc evaluation stack. */ | |
1568 | HOWTO (ALPHA_R_OP_PUSH, /* type */ | |
1569 | 0, /* rightshift */ | |
1570 | 0, /* size (0 = byte, 1 = short, 2 = long) */ | |
1571 | 0, /* bitsize */ | |
1572 | false, /* pc_relative */ | |
1573 | 0, /* bitpos */ | |
1574 | complain_overflow_dont, /* complain_on_overflow */ | |
1575 | reloc_nil, /* special_function */ | |
1576 | "OP_PUSH", /* name */ | |
1577 | false, /* partial_inplace */ | |
1578 | 0, /* src_mask */ | |
1579 | 0, /* dst_mask */ | |
1580 | false), /* pcrel_offset */ | |
1581 | ||
1582 | /* Store the value from the stack at the given address. Store it in | |
1583 | a bitfield of size r_size starting at bit position r_offset. */ | |
1584 | HOWTO (ALPHA_R_OP_STORE, /* type */ | |
1585 | 0, /* rightshift */ | |
1586 | 4, /* size (0 = byte, 1 = short, 2 = long) */ | |
1587 | 64, /* bitsize */ | |
1588 | false, /* pc_relative */ | |
1589 | 0, /* bitpos */ | |
1590 | complain_overflow_dont, /* complain_on_overflow */ | |
1591 | reloc_nil, /* special_function */ | |
1592 | "OP_STORE", /* name */ | |
1593 | false, /* partial_inplace */ | |
1594 | 0, /* src_mask */ | |
1595 | MINUS_ONE, /* dst_mask */ | |
1596 | false), /* pcrel_offset */ | |
1597 | ||
1598 | /* Subtract the reloc address from the value on the top of the | |
1599 | relocation stack. */ | |
1600 | HOWTO (ALPHA_R_OP_PSUB, /* type */ | |
1601 | 0, /* rightshift */ | |
1602 | 0, /* size (0 = byte, 1 = short, 2 = long) */ | |
1603 | 0, /* bitsize */ | |
1604 | false, /* pc_relative */ | |
1605 | 0, /* bitpos */ | |
1606 | complain_overflow_dont, /* complain_on_overflow */ | |
1607 | reloc_nil, /* special_function */ | |
1608 | "OP_PSUB", /* name */ | |
1609 | false, /* partial_inplace */ | |
1610 | 0, /* src_mask */ | |
1611 | 0, /* dst_mask */ | |
1612 | false), /* pcrel_offset */ | |
1613 | ||
1614 | /* Shift the value on the top of the relocation stack right by the | |
1615 | given value. */ | |
1616 | HOWTO (ALPHA_R_OP_PRSHIFT, /* type */ | |
1617 | 0, /* rightshift */ | |
1618 | 0, /* size (0 = byte, 1 = short, 2 = long) */ | |
1619 | 0, /* bitsize */ | |
1620 | false, /* pc_relative */ | |
1621 | 0, /* bitpos */ | |
1622 | complain_overflow_dont, /* complain_on_overflow */ | |
1623 | reloc_nil, /* special_function */ | |
1624 | "OP_PRSHIFT", /* name */ | |
1625 | false, /* partial_inplace */ | |
1626 | 0, /* src_mask */ | |
1627 | 0, /* dst_mask */ | |
1628 | false), /* pcrel_offset */ | |
1629 | ||
1630 | /* Hack. Linkage is done by linker. */ | |
1631 | HOWTO (ALPHA_R_LINKAGE, /* type */ | |
1632 | 0, /* rightshift */ | |
1633 | 8, /* size (0 = byte, 1 = short, 2 = long) */ | |
1634 | 256, /* bitsize */ | |
1635 | false, /* pc_relative */ | |
1636 | 0, /* bitpos */ | |
1637 | complain_overflow_dont, /* complain_on_overflow */ | |
1638 | reloc_nil, /* special_function */ | |
1639 | "LINKAGE", /* name */ | |
1640 | false, /* partial_inplace */ | |
1641 | 0, /* src_mask */ | |
1642 | 0, /* dst_mask */ | |
1643 | false), /* pcrel_offset */ | |
1644 | ||
1645 | /* A 32 bit reference to a symbol. */ | |
1646 | HOWTO (ALPHA_R_REFLONG, /* type */ | |
1647 | 0, /* rightshift */ | |
1648 | 2, /* size (0 = byte, 1 = short, 2 = long) */ | |
1649 | 32, /* bitsize */ | |
1650 | false, /* pc_relative */ | |
1651 | 0, /* bitpos */ | |
1652 | complain_overflow_bitfield, /* complain_on_overflow */ | |
1653 | reloc_nil, /* special_function */ | |
1654 | "REFLONG", /* name */ | |
1655 | true, /* partial_inplace */ | |
1656 | 0xffffffff, /* src_mask */ | |
1657 | 0xffffffff, /* dst_mask */ | |
1658 | false), /* pcrel_offset */ | |
1659 | ||
1660 | /* A 64 bit reference to a procedure, written as 32 bit value. */ | |
1661 | HOWTO (ALPHA_R_CODEADDR, /* type */ | |
1662 | 0, /* rightshift */ | |
1663 | 4, /* size (0 = byte, 1 = short, 2 = long) */ | |
1664 | 64, /* bitsize */ | |
1665 | false, /* pc_relative */ | |
1666 | 0, /* bitpos */ | |
1667 | complain_overflow_signed,/* complain_on_overflow */ | |
1668 | reloc_nil, /* special_function */ | |
1669 | "CODEADDR", /* name */ | |
1670 | false, /* partial_inplace */ | |
1671 | 0xffffffff, /* src_mask */ | |
1672 | 0xffffffff, /* dst_mask */ | |
1673 | false), /* pcrel_offset */ | |
1674 | ||
1675 | }; | |
1676 | ||
1677 | /* Return a pointer to a howto structure which, when invoked, will perform | |
1678 | the relocation code on data from the architecture noted. */ | |
1679 | ||
1680 | static const struct reloc_howto_struct * | |
1681 | vms_bfd_reloc_type_lookup (abfd, code) | |
1682 | bfd *abfd; | |
1683 | bfd_reloc_code_real_type code; | |
1684 | { | |
1685 | int alpha_type; | |
1686 | ||
1687 | #if VMS_DEBUG | |
1688 | vms_debug (1, "vms_bfd_reloc_type_lookup(%p, %d)\t", abfd, code); | |
1689 | #endif | |
1690 | ||
1691 | switch (code) | |
1692 | { | |
1693 | case BFD_RELOC_16: alpha_type = ALPHA_R_SREL16; break; | |
1694 | case BFD_RELOC_32: alpha_type = ALPHA_R_REFLONG; break; | |
1695 | case BFD_RELOC_64: alpha_type = ALPHA_R_REFQUAD; break; | |
1696 | case BFD_RELOC_CTOR: alpha_type = ALPHA_R_REFQUAD; break; | |
1697 | case BFD_RELOC_23_PCREL_S2: alpha_type = ALPHA_R_BRADDR; break; | |
1698 | case BFD_RELOC_ALPHA_HINT: alpha_type = ALPHA_R_HINT; break; | |
1699 | case BFD_RELOC_16_PCREL: alpha_type = ALPHA_R_SREL16; break; | |
1700 | case BFD_RELOC_32_PCREL: alpha_type = ALPHA_R_SREL32; break; | |
1701 | case BFD_RELOC_64_PCREL: alpha_type = ALPHA_R_SREL64; break; | |
1702 | case BFD_RELOC_ALPHA_LINKAGE: alpha_type = ALPHA_R_LINKAGE; break; | |
1703 | case BFD_RELOC_ALPHA_CODEADDR: alpha_type = ALPHA_R_CODEADDR; break; | |
1704 | default: | |
1705 | (*_bfd_error_handler) ("reloc (%d) is *UNKNOWN*", code); | |
1706 | return (const struct reloc_howto_struct *) NULL; | |
1707 | } | |
1708 | #if VMS_DEBUG | |
1709 | vms_debug (2, "reloc is %s\n", alpha_howto_table[alpha_type].name); | |
1710 | #endif | |
1711 | return &alpha_howto_table[alpha_type]; | |
1712 | } | |
1713 | ||
1714 | ||
1715 | /*-- Part 4.7, writing an object file ---------------------------------------*/ | |
1716 | ||
1717 | /* Set the architecture and machine type in BFD abfd to arch and mach. | |
1718 | Find the correct pointer to a structure and insert it into the arch_info | |
1719 | pointer. */ | |
1720 | ||
1721 | static boolean | |
1722 | vms_set_arch_mach (abfd, arch, mach) | |
1723 | bfd *abfd; | |
1724 | enum bfd_architecture arch; | |
1725 | unsigned long mach; | |
1726 | { | |
1727 | #if VMS_DEBUG | |
1728 | vms_debug (1, "vms_set_arch_mach(%p, %d, %ld)\n", abfd, arch, mach); | |
1729 | #endif | |
1730 | abfd->arch_info = bfd_scan_arch("alpha"); | |
1731 | ||
1732 | return true; | |
1733 | } | |
1734 | ||
1735 | ||
1736 | /* Sets the contents of the section section in BFD abfd to the data starting | |
1737 | in memory at data. The data is written to the output section starting at | |
1738 | offset offset for count bytes. | |
1739 | ||
1740 | Normally true is returned, else false. Possible error returns are: | |
1741 | o bfd_error_no_contents - The output section does not have the | |
1742 | SEC_HAS_CONTENTS attribute, so nothing can be written to it. | |
1743 | o and some more too */ | |
1744 | ||
1745 | static boolean | |
1746 | vms_set_section_contents (abfd, section, location, offset, count) | |
1747 | bfd *abfd; | |
1748 | asection *section; | |
1749 | PTR location; | |
1750 | file_ptr offset; | |
1751 | bfd_size_type count; | |
1752 | { | |
1753 | #if VMS_DEBUG | |
1754 | vms_debug (1, "vms_set_section_contents(%p, sec %s, loc %p, off %ld, count %d)\n", | |
1755 | abfd, section->name, location, (long int)offset, (int)count); | |
1756 | vms_debug (2, "secraw %d, seccooked %d\n", (int)section->_raw_size, (int)section->_cooked_size); | |
1757 | #endif | |
1758 | return _bfd_save_vms_section(abfd, section, location, offset, count); | |
1759 | } | |
1760 | ||
1761 | ||
1762 | /*-- Part 4.8, linker -------------------------------------------------------*/ | |
1763 | ||
1764 | /* Get the size of the section headers. */ | |
1765 | ||
1766 | static int | |
1767 | vms_sizeof_headers (abfd, reloc) | |
1768 | bfd *abfd; | |
1769 | boolean reloc; | |
1770 | { | |
1771 | #if VMS_DEBUG | |
1772 | vms_debug (1, "vms_sizeof_headers(%p, %s)\n", abfd, (reloc)?"True":"False"); | |
1773 | #endif | |
1774 | return 0; | |
1775 | } | |
1776 | ||
1777 | ||
1778 | /* Provides default handling of relocation effort for back ends | |
1779 | which can't be bothered to do it efficiently. */ | |
1780 | ||
1781 | static bfd_byte * | |
1782 | vms_bfd_get_relocated_section_contents (abfd, link_info, link_order, data, | |
1783 | relocateable, symbols) | |
1784 | bfd *abfd; | |
1785 | struct bfd_link_info *link_info; | |
1786 | struct bfd_link_order *link_order; | |
1787 | bfd_byte *data; | |
1788 | boolean relocateable; | |
1789 | asymbol **symbols; | |
1790 | { | |
1791 | #if VMS_DEBUG | |
1792 | vms_debug (1, "vms_bfd_get_relocated_section_contents(%p, %p, %p, %p, %s, %p)\n", | |
1793 | abfd, link_info, link_order, data, (relocateable)?"True":"False", symbols); | |
1794 | #endif | |
1795 | return 0; | |
1796 | } | |
1797 | ||
1798 | ||
1799 | /* ??? */ | |
1800 | ||
1801 | static boolean | |
1802 | vms_bfd_relax_section (abfd, section, link_info, again) | |
1803 | bfd *abfd; | |
1804 | asection *section; | |
1805 | struct bfd_link_info *link_info; | |
1806 | boolean *again; | |
1807 | { | |
1808 | #if VMS_DEBUG | |
1809 | vms_debug (1, "vms_bfd_relax_section(%p, %s, %p, <ret>)\n", | |
1810 | abfd, section->name, link_info); | |
1811 | #endif | |
1812 | return true; | |
1813 | } | |
1814 | ||
1815 | static boolean | |
1816 | vms_bfd_gc_sections (abfd, link_info) | |
1817 | bfd *abfd; | |
1818 | struct bfd_link_info *link_info; | |
1819 | { | |
1820 | #if VMS_DEBUG | |
1821 | vms_debug (1, "vms_bfd_gc_sections(%p, %p)\n", abfd, link_info); | |
1822 | #endif | |
1823 | return true; | |
1824 | } | |
1825 | ||
1826 | ||
1827 | /* Create a hash table for the linker. Different backends store | |
1828 | different information in this table. */ | |
1829 | ||
1830 | static struct bfd_link_hash_table * | |
1831 | vms_bfd_link_hash_table_create (abfd) | |
1832 | bfd *abfd; | |
1833 | { | |
1834 | #if VMS_DEBUG | |
1835 | vms_debug (1, "vms_bfd_link_hash_table_create(%p)\n", abfd); | |
1836 | #endif | |
1837 | return 0; | |
1838 | } | |
1839 | ||
1840 | ||
1841 | /* Add symbols from this object file into the hash table. */ | |
1842 | ||
1843 | static boolean | |
1844 | vms_bfd_link_add_symbols (abfd, link_info) | |
1845 | bfd *abfd; | |
1846 | struct bfd_link_info *link_info; | |
1847 | { | |
1848 | #if VMS_DEBUG | |
1849 | vms_debug (1, "vms_bfd_link_add_symbols(%p, %p)\n", abfd, link_info); | |
1850 | #endif | |
1851 | return false; | |
1852 | } | |
1853 | ||
1854 | ||
1855 | /* Do a link based on the link_order structures attached to each | |
1856 | section of the BFD. */ | |
1857 | ||
1858 | static boolean | |
1859 | vms_bfd_final_link (abfd, link_info) | |
1860 | bfd *abfd; | |
1861 | struct bfd_link_info *link_info; | |
1862 | { | |
1863 | #if VMS_DEBUG | |
1864 | vms_debug (1, "vms_bfd_final_link(%p, %p)\n", abfd, link_info); | |
1865 | #endif | |
1866 | return true; | |
1867 | } | |
1868 | ||
1869 | /* Should this section be split up into smaller pieces during linking. */ | |
1870 | ||
1871 | static boolean | |
1872 | vms_bfd_link_split_section (abfd, section) | |
1873 | bfd *abfd; | |
1874 | asection *section; | |
1875 | { | |
1876 | #if VMS_DEBUG | |
1877 | vms_debug (1, "vms_bfd_link_split_section(%p, %s)\n", abfd, section->name); | |
1878 | #endif | |
1879 | return false; | |
1880 | } | |
1881 | ||
1882 | /*-- Part 4.9, dynamic symbols and relocations ------------------------------*/ | |
1883 | ||
1884 | /* Get the amount of memory required to hold the dynamic symbols. */ | |
1885 | ||
1886 | static long | |
1887 | vms_get_dynamic_symtab_upper_bound (abfd) | |
1888 | bfd *abfd; | |
1889 | { | |
1890 | #if VMS_DEBUG | |
1891 | vms_debug (1, "vms_get_dynamic_symtab_upper_bound(%p)\n", abfd); | |
1892 | #endif | |
1893 | return 0; | |
1894 | } | |
1895 | ||
1896 | static boolean | |
1897 | vms_bfd_print_private_bfd_data (abfd, file) | |
1898 | bfd *abfd; | |
1899 | void *file; | |
1900 | { | |
1901 | #if VMS_DEBUG | |
1902 | vms_debug (1, "vms_bfd_print_private_bfd_data(%p)\n", abfd); | |
1903 | #endif | |
1904 | return 0; | |
1905 | } | |
1906 | ||
1907 | ||
1908 | /* Read in the dynamic symbols. */ | |
1909 | ||
1910 | static long | |
1911 | vms_canonicalize_dynamic_symtab (abfd, symbols) | |
1912 | bfd *abfd; | |
1913 | asymbol **symbols; | |
1914 | { | |
1915 | #if VMS_DEBUG | |
1916 | vms_debug (1, "vms_canonicalize_dynamic_symtab(%p, <ret>)\n", abfd); | |
1917 | #endif | |
1918 | return 0L; | |
1919 | } | |
1920 | ||
1921 | ||
1922 | /* Get the amount of memory required to hold the dynamic relocs. */ | |
1923 | ||
1924 | static long | |
1925 | vms_get_dynamic_reloc_upper_bound (abfd) | |
1926 | bfd *abfd; | |
1927 | { | |
1928 | #if VMS_DEBUG | |
1929 | vms_debug (1, "vms_get_dynamic_reloc_upper_bound(%p)\n", abfd); | |
1930 | #endif | |
1931 | return 0L; | |
1932 | } | |
1933 | ||
1934 | ||
1935 | /* Read in the dynamic relocs. */ | |
1936 | ||
1937 | static long | |
1938 | vms_canonicalize_dynamic_reloc (abfd, arel, symbols) | |
1939 | bfd *abfd; | |
1940 | arelent **arel; | |
1941 | asymbol **symbols; | |
1942 | { | |
1943 | #if VMS_DEBUG | |
1944 | vms_debug (1, "vms_canonicalize_dynamic_reloc(%p)\n", abfd); | |
1945 | #endif | |
1946 | return 0L; | |
1947 | } |