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