projects / deliverable / binutils-gdb.git / blob
? search:


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