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