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