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