?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
rename files
[binutils/dougsmingw.git] / bfd / vms.c
blob176705e10ec12310695933ae511c69c73d17126c
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 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_new_section_hook (bfd *abfd, asection *section);
54 static bfd_boolean vms_get_section_contents
55 (bfd *abfd, asection *section, PTR x1, file_ptr x2, bfd_size_type x3);
56 static long vms_get_symtab_upper_bound (bfd *abfd);
57 static long vms_canonicalize_symtab (bfd *abfd, asymbol **symbols);
58 static void vms_print_symbol (bfd *abfd, PTR file, asymbol *symbol,
59 bfd_print_symbol_type how);
60 static void vms_get_symbol_info (bfd *abfd, asymbol *symbol, symbol_info *ret);
61 static bfd_boolean vms_bfd_is_local_label_name (bfd *abfd, const char *);
62 static bfd_boolean vms_find_nearest_line
63 (bfd *abfd, asection *section, asymbol **symbols, bfd_vma offset,
64 const char **file, const char **func, unsigned int *line);
65 static void alloc_reloc_stream (bfd *abfd, asection *section,
66 void *alloc_error);
67 static bfd_boolean vms_slurp_reloc_table (bfd *abfd, asection *section,
68 asymbol **symbols);
69 static long vms_get_reloc_upper_bound (bfd *abfd, asection *sect);
70 static long vms_canonicalize_reloc (bfd *abfd, asection *srcsec,
71 arelent **location, asymbol **symbols);
72 static const struct reloc_howto_struct *vms_bfd_reloc_type_lookup
73 (bfd *abfd, bfd_reloc_code_real_type code);
74 static bfd_boolean vms_set_arch_mach
75 (bfd *abfd, enum bfd_architecture arch, unsigned long mach);
76 static bfd_boolean vms_set_section_contents
77 (bfd *abfd, asection *section, const PTR location, file_ptr offset,
78 bfd_size_type count);
79
80 #define vms_bfd_is_target_special_symbol ((bfd_boolean (*) (bfd *, asymbol *)) bfd_false)
81 #define vms_make_empty_symbol _bfd_generic_make_empty_symbol
82 #define vms_bfd_link_just_syms _bfd_generic_link_just_syms
83 #define vms_bfd_copy_link_hash_symbol_type \
84 _bfd_generic_copy_link_hash_symbol_type
85 #define vms_bfd_is_group_section bfd_generic_is_group_section
86 #define vms_bfd_discard_group bfd_generic_discard_group
87 #define vms_section_already_linked _bfd_generic_section_already_linked
88 #define vms_bfd_define_common_symbol bfd_generic_define_common_symbol
89 #define vms_bfd_copy_private_header_data _bfd_generic_bfd_copy_private_header_data
90 #define vms_get_synthetic_symtab _bfd_nodynamic_get_synthetic_symtab
91
92 #define vms_bfd_copy_private_bfd_data _bfd_generic_bfd_copy_private_bfd_data
93 #define vms_bfd_free_cached_info _bfd_generic_bfd_free_cached_info
94 #define vms_bfd_copy_private_section_data _bfd_generic_bfd_copy_private_section_data
95 #define vms_bfd_copy_private_symbol_data _bfd_generic_bfd_copy_private_symbol_data
96 #define vms_bfd_set_private_flags _bfd_generic_bfd_set_private_flags
97 #define vms_bfd_merge_private_bfd_data _bfd_generic_bfd_merge_private_bfd_data
98 #define vms_get_section_contents_in_window _bfd_generic_get_section_contents_in_window
99 #define vms_read_minisymbols _bfd_generic_read_minisymbols
100 #define vms_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
101 #define vms_get_lineno _bfd_nosymbols_get_lineno
102 #define vms_find_inliner_info _bfd_nosymbols_find_inliner_info
103 #define vms_bfd_make_debug_symbol _bfd_nosymbols_bfd_make_debug_symbol
104 \f
105 #ifdef VMS_DEBUG
106 /* Cause debug info to be emitted for the structure. */
107 struct vms_private_data_struct _vms_private_data_struct_dummy;
108 struct vms_section_data_struct _vms_section_data_struct_dummy;
109 #endif
110
111 extern const bfd_target vms_vax_vec;
112 extern const bfd_target vms_alpha_vec;
113
114 /* Initialize private data */
115 static bfd_boolean
116 vms_initialize (bfd * abfd)
117 {
118 bfd_size_type amt;
119
120 bfd_set_start_address (abfd, (bfd_vma) -1);
121
122 amt = sizeof (struct vms_private_data_struct);
123 abfd->tdata.any = bfd_zalloc (abfd, amt);
124 if (abfd->tdata.any == NULL)
125 return FALSE;
126
127 if (bfd_get_flavour (abfd) == bfd_target_ovax_flavour)
128 PRIV (is_vax) = TRUE;
129
130 PRIV (file_format) = FF_UNKNOWN;
131
132 amt = sizeof (struct stack_struct) * STACKSIZE;
133 PRIV (stack) = bfd_alloc (abfd, amt);
134 if (PRIV (stack) == NULL)
135 goto error_ret1;
136
137 amt = sizeof (struct bfd_hash_table);
138 PRIV (vms_symbol_table) = bfd_alloc (abfd, amt);
139 if (PRIV (vms_symbol_table) == NULL)
140 goto error_ret1;
141
142 if (!bfd_hash_table_init (PRIV (vms_symbol_table), _bfd_vms_hash_newfunc,
143 sizeof (vms_symbol_entry)))
144 goto error_ret1;
145
146 amt = MAX_OUTREC_SIZE;
147 PRIV (output_buf) = bfd_alloc (abfd, amt);
148 if (PRIV (output_buf) == NULL)
149 goto error_ret2;
150
151 PRIV (length_pos) = 2;
152
153 return TRUE;
154
155 error_ret2:
156 bfd_hash_table_free (PRIV (vms_symbol_table));
157 error_ret1:
158 bfd_release (abfd, abfd->tdata.any);
159 abfd->tdata.any = NULL;
160 return FALSE;
161 }
162
163 struct pair
164 {
165 unsigned int section_count;
166 asection **sections;
167 };
168
169 /* Fill symbol->section with section pointer.
170
171 symbol->section is filled with the section index for defined symbols
172 during reading the GSD/EGSD section. But we need the pointer to the
173 bfd section later.
174
175 It has the correct value for referenced (undefined section) symbols.
176
177 Called from bfd_hash_traverse in vms_fixup_sections. */
178
179 static bfd_boolean
180 fill_section_ptr (struct bfd_hash_entry *entry, void *sections)
181 {
182 asymbol *sym = ((vms_symbol_entry *)entry)->symbol;
183 struct pair *data = (struct pair *)sections;
184 unsigned long sec = (unsigned long)sym->section;
185
186 vms_debug2 ((6, "fill_section_ptr: sym %p, sec %lu\n", sym, sec));
187
188 if (sec < data->section_count)
189 {
190 sym->section = data->sections[sec];
191
192 if (strcmp (sym->name, sym->section->name) == 0)
193 sym->flags |= BSF_SECTION_SYM;
194 }
195 else if (sec == (unsigned long)-1)
196 sym->section = &bfd_und_section;
197
198 return TRUE;
199 }
200
201 /* Fixup section pointers in symbols. */
202 static bfd_boolean
203 vms_fixup_sections (bfd * abfd)
204 {
205 struct pair data;
206
207 if (PRIV (fixup_done))
208 return TRUE;
209
210 data.section_count = PRIV (section_count);
211 data.sections = PRIV (sections);
212 bfd_hash_traverse (PRIV (vms_symbol_table), fill_section_ptr, &data);
213
214 PRIV (fixup_done) = TRUE;
215 return TRUE;
216 }
217
218 /* Slurp an ordered set of VMS object records. */
219 int
220 _bfd_vms_slurp_object_records (bfd * abfd)
221 {
222 int err, new_type, type = -1;
223
224 do
225 {
226 vms_debug2 ((7, "reading at %08lx\n", bfd_tell (abfd)));
227
228 new_type = _bfd_vms_get_object_record (abfd);
229 if (new_type < 0)
230 {
231 vms_debug2 ((2, "next_record failed\n"));
232 return -1;
233 }
234
235 if (type == EOBJ_S_C_EGSD && new_type != EOBJ_S_C_EGSD)
236 {
237 if (! vms_fixup_sections (abfd))
238 {
239 vms_debug2 ((2, "vms_fixup_sections failed\n"));
240 return -1;
241 }
242 }
243
244 type = new_type;
245
246 switch (type)
247 {
248 case OBJ_S_C_HDR:
249 case EOBJ_S_C_EMH:
250 err = _bfd_vms_slurp_hdr (abfd, type);
251 break;
252 case OBJ_S_C_EOM:
253 case OBJ_S_C_EOMW:
254 case EOBJ_S_C_EEOM:
255 err = _bfd_vms_slurp_eom (abfd, type);
256 break;
257 case OBJ_S_C_GSD:
258 case EOBJ_S_C_EGSD:
259 err = _bfd_vms_slurp_gsd (abfd, type);
260 break;
261 case OBJ_S_C_TIR:
262 case EOBJ_S_C_ETIR:
263 err = _bfd_vms_slurp_tir (abfd, type);
264 break;
265 case OBJ_S_C_DBG:
266 case EOBJ_S_C_EDBG:
267 err = _bfd_vms_slurp_dbg (abfd, type);
268 PRIV (dst_ptr_end) = PRIV (image_ptr);
269 break;
270 case OBJ_S_C_TBT:
271 case EOBJ_S_C_ETBT:
272 err = _bfd_vms_slurp_tbt (abfd, type);
273 PRIV (dst_ptr_end) = PRIV (image_ptr);
274 break;
275 case OBJ_S_C_LNK:
276 err = _bfd_vms_slurp_lnk (abfd, type);
277 break;
278 default:
279 err = -1;
280 }
281 if (err != 0)
282 {
283 vms_debug2 ((2, "slurp type %d failed with %d\n", type, err));
284 return err;
285 }
286 }
287 while (type != EOBJ_S_C_EEOM && type != OBJ_S_C_EOM && type != OBJ_S_C_EOMW);
288
289 return 0;
290 }
291
292 /* Slurp a VMS module and return an error status. */
293
294 static int
295 vms_slurp_module (bfd *abfd)
296 {
297 int type, err;
298
299 if (PRIV (is_vax))
300 type = PRIV (vms_rec)[0];
301 else
302 type = bfd_getl16 (PRIV (vms_rec));
303
304 err = _bfd_vms_slurp_hdr (abfd, type);
305 if (err != 0)
306 {
307 bfd_set_error (bfd_error_wrong_format);
308 return err;
309 }
310
311 return _bfd_vms_slurp_object_records (abfd);
312 }
313
314 /* Slurp a VMS image and return an error status. */
315
316 static int
317 vms_slurp_image (bfd *abfd)
318 {
319 unsigned int isd_offset, ihs_offset;
320 int err;
321
322 err = _bfd_vms_slurp_ihd (abfd, &isd_offset, &ihs_offset);
323 if (err != 0)
324 {
325 bfd_set_error (bfd_error_wrong_format);
326 return err;
327 }
328
329 err = _bfd_vms_slurp_isd (abfd, isd_offset);
330 if (err != 0)
331 {
332 bfd_set_error (bfd_error_wrong_format);
333 return err;
334 }
335
336 return _bfd_vms_slurp_ihs (abfd, ihs_offset);
337 }
338
339 /* Check the format for a file being read.
340 Return a (bfd_target *) if it's an object file or zero if not. */
341
342 static const struct bfd_target *
343 vms_object_p (bfd *abfd)
344 {
345 const struct bfd_target *target_vector;
346 const bfd_arch_info_type *arch;
347 PTR tdata_save = abfd->tdata.any;
348 bfd_vma saddr_save = bfd_get_start_address (abfd);
349 int err = 0;
350
351 vms_debug2 ((1, "vms_object_p(%p)\n", abfd));
352
353 if (!vms_initialize (abfd))
354 goto error_ret;
355
356 if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET))
357 goto err_wrong_format;
358
359 switch (_bfd_vms_get_first_record (abfd))
360 {
361 case FT_UNKNOWN:
362 default:
363 err = -1;
364 break;
365
366 case FT_MODULE:
367 err = vms_slurp_module (abfd);
368 break;
369
370 case FT_IMAGE:
371 err = vms_slurp_image (abfd);
372 break;
373 }
374
375 if (err != 0)
376 goto err_wrong_format;
377
378 if (PRIV (is_vax))
379 {
380 if (! vms_fixup_sections (abfd))
381 {
382 vms_debug2 ((2, "vms_fixup_sections failed\n"));
383 goto err_wrong_format;
384 }
385
386 target_vector = &vms_vax_vec;
387 arch = bfd_scan_arch ("vax");
388
389 vms_debug2 ((2, "arch is vax\n"));
390 }
391 else
392 {
393 /* Set arch_info to alpha. */
394 target_vector = &vms_alpha_vec;
395 arch = bfd_scan_arch ("alpha");
396 vms_debug2 ((2, "arch is alpha\n"));
397 }
398
399 abfd->arch_info = arch;
400 return target_vector;
401
402 err_wrong_format:
403 bfd_set_error (bfd_error_wrong_format);
404
405 error_ret:
406 if (abfd->tdata.any != tdata_save && abfd->tdata.any != NULL)
407 bfd_release (abfd, abfd->tdata.any);
408 abfd->tdata.any = tdata_save;
409 bfd_set_start_address (abfd, saddr_save);
410 return NULL;
411 }
412
413 /* Set the format of a file being written. */
414
415 static bfd_boolean
416 vms_mkobject (bfd * abfd)
417 {
418 const bfd_arch_info_type *arch;
419
420 vms_debug2 ((1, "vms_mkobject (%p)\n", abfd));
421
422 if (!vms_initialize (abfd))
423 return FALSE;
424
425 if (PRIV (is_vax))
426 arch = bfd_scan_arch ("vax");
427 else
428 arch = bfd_scan_arch ("alpha");
429
430 if (arch == 0)
431 {
432 bfd_set_error(bfd_error_wrong_format);
433 return FALSE;
434 }
435
436 abfd->arch_info = arch;
437 return TRUE;
438 }
439
440 /* Write cached information into a file being written, at bfd_close. */
441
442 static bfd_boolean
443 vms_write_object_contents (bfd * abfd)
444 {
445 vms_debug2 ((1, "vms_write_object_contents (%p)\n", abfd));
446
447 if (abfd->section_count > 0) /* we have sections */
448 {
449 if (PRIV (is_vax))
450 {
451 if (_bfd_vms_write_hdr (abfd, OBJ_S_C_HDR) != 0)
452 return FALSE;
453 if (_bfd_vms_write_gsd (abfd, OBJ_S_C_GSD) != 0)
454 return FALSE;
455 if (_bfd_vms_write_tir (abfd, OBJ_S_C_TIR) != 0)
456 return FALSE;
457 if (_bfd_vms_write_tbt (abfd, OBJ_S_C_TBT) != 0)
458 return FALSE;
459 if (_bfd_vms_write_dbg (abfd, OBJ_S_C_DBG) != 0)
460 return FALSE;
461 if (abfd->section_count > 255)
462 {
463 if (_bfd_vms_write_eom (abfd, OBJ_S_C_EOMW) != 0)
464 return FALSE;
465 }
466 else
467 {
468 if (_bfd_vms_write_eom (abfd, OBJ_S_C_EOM) != 0)
469 return FALSE;
470 }
471 }
472 else
473 {
474 if (_bfd_vms_write_hdr (abfd, EOBJ_S_C_EMH) != 0)
475 return FALSE;
476 if (_bfd_vms_write_gsd (abfd, EOBJ_S_C_EGSD) != 0)
477 return FALSE;
478 if (_bfd_vms_write_tir (abfd, EOBJ_S_C_ETIR) != 0)
479 return FALSE;
480 if (_bfd_vms_write_tbt (abfd, EOBJ_S_C_ETBT) != 0)
481 return FALSE;
482 if (_bfd_vms_write_dbg (abfd, EOBJ_S_C_EDBG) != 0)
483 return FALSE;
484 if (_bfd_vms_write_eom (abfd, EOBJ_S_C_EEOM) != 0)
485 return FALSE;
486 }
487 }
488 return TRUE;
489 }
490
491 /* 4.1, generic. */
492
493 /* Free the reloc buffer for the specified section. */
494
495 static void
496 free_reloc_stream (bfd *abfd ATTRIBUTE_UNUSED, asection *section,
497 void *data ATTRIBUTE_UNUSED)
498 {
499 if (vms_section_data (section)->reloc_stream)
500 free (vms_section_data (section)->reloc_stream);
501 }
502
503 #ifdef VMS
504 /* Convert the file to variable record length format. This is done
505 using undocumented system call sys$modify().
506 Pure VMS version. */
507
508 static void
509 vms_convert_to_var (char *vms_filename)
510 {
511 struct FAB fab = cc$rms_fab;
512
513 fab.fab$l_fna = vms_filename;
514 fab.fab$b_fns = strlen (vms_filename);
515 fab.fab$b_fac = FAB$M_PUT;
516 fab.fab$l_fop = FAB$M_ESC;
517 fab.fab$l_ctx = RME$C_SETRFM;
518
519 sys$open (&fab);
520
521 fab.fab$b_rfm = FAB$C_VAR;
522
523 sys$modify (&fab);
524 sys$close (&fab);
525 }
526
527 static int
528 vms_convert_to_var_1 (char *filename, int type)
529 {
530 if (type != DECC$K_FILE)
531 return FALSE;
532 vms_convert_to_var (filename);
533 return TRUE;
534 }
535
536 /* Convert the file to variable record length format. This is done
537 using undocumented system call sys$modify().
538 Unix filename version. */
539
540 static int
541 vms_convert_to_var_unix_filename (const char *unix_filename)
542 {
543 if (decc$to_vms (unix_filename, &vms_convert_to_var_1, 0, 1) != 1)
544 return FALSE;
545 return TRUE;
546 }
547 #endif /* VMS */
548
549 /* Called when the BFD is being closed to do any necessary cleanup. */
550
551 static bfd_boolean
552 vms_close_and_cleanup (bfd * abfd)
553 {
554 vms_debug2 ((1, "vms_close_and_cleanup (%p)\n", abfd));
555
556 if (abfd == NULL || abfd->tdata.any == NULL)
557 return TRUE;
558
559 if (PRIV (vms_buf) != NULL)
560 free (PRIV (vms_buf));
561
562 if (PRIV (sections) != NULL)
563 free (PRIV (sections));
564
565 if (PRIV (vms_symbol_table))
566 bfd_hash_table_free (PRIV (vms_symbol_table));
567
568 bfd_map_over_sections (abfd, free_reloc_stream, NULL);
569
570 bfd_release (abfd, abfd->tdata.any);
571 abfd->tdata.any = NULL;
572
573 #ifdef VMS
574 if (abfd->direction == write_direction)
575 {
576 /* Last step on VMS is to convert the file to variable record length
577 format. */
578 if (bfd_cache_close (abfd) != TRUE)
579 return FALSE;
580 if (vms_convert_to_var_unix_filename (abfd->filename) != TRUE)
581 return FALSE;
582 }
583 #endif
584
585 return TRUE;
586 }
587
588 /* Called when a new section is created. */
589
590 static bfd_boolean
591 vms_new_section_hook (bfd * abfd, asection *section)
592 {
593 bfd_size_type amt;
594
595 /* Count hasn't been incremented yet. */
596 unsigned int section_count = abfd->section_count + 1;
597
598 vms_debug2 ((1, "vms_new_section_hook (%p, [%d]%s), count %d\n",
599 abfd, section->index, section->name, section_count));
600
601 bfd_set_section_alignment (abfd, section, 0);
602
603 if (section_count > PRIV (section_count))
604 {
605 amt = section_count;
606 amt *= sizeof (asection *);
607 PRIV (sections) = bfd_realloc_or_free (PRIV (sections), amt);
608 if (PRIV (sections) == NULL)
609 return FALSE;
610 PRIV (section_count) = section_count;
611 }
612
613 vms_debug2 ((6, "section_count: %d\n", PRIV (section_count)));
614
615 PRIV (sections)[section->index] = section;
616
617 vms_debug2 ((7, "%d: %s\n", section->index, section->name));
618
619 amt = sizeof (struct vms_section_data_struct);
620 section->used_by_bfd = (PTR) bfd_zalloc (abfd, amt);
621 if (section->used_by_bfd == NULL)
622 return FALSE;
623
624 return _bfd_generic_new_section_hook (abfd, section);
625 }
626
627 /* Read the contents of a section.
628 buf points to a buffer of buf_size bytes to be filled with
629 section data (starting at offset into section) */
630
631 static bfd_boolean
632 vms_get_section_contents (bfd * abfd ATTRIBUTE_UNUSED,
633 asection *section ATTRIBUTE_UNUSED,
634 void * buf ATTRIBUTE_UNUSED,
635 file_ptr offset ATTRIBUTE_UNUSED,
636 bfd_size_type buf_size ATTRIBUTE_UNUSED)
637 {
638 bfd_size_type size = section->size;
639
640 vms_debug2 ((1, "vms_get_section_contents (%p, %s, %p, off %ld, size %d)\n",
641 abfd, section->name, buf, offset, (int)buf_size));
642
643 if (section->contents)
644 abort ();
645
646 section->contents = (unsigned char *) bfd_malloc (size);
647
648 if (section->contents == NULL)
649 {
650 bfd_set_error (bfd_error_no_memory);
651 return FALSE;
652 }
653
654 if (bfd_seek (abfd, section->filepos, SEEK_SET))
655 {
656 bfd_set_error (bfd_error_file_truncated);
657 return FALSE;
658 }
659
660 if (bfd_bread (section->contents, size, abfd) != size)
661 {
662 bfd_set_error (bfd_error_file_truncated);
663 return FALSE;
664 }
665
666 section->flags |= SEC_IN_MEMORY;
667
668 if (buf)
669 memcpy (buf, section->contents + offset, (size_t) buf_size);
670
671 return TRUE;
672 }
673
674 /* Part 4.5, symbols. */
675
676 /* Return the number of bytes required to store a vector of pointers
677 to asymbols for all the symbols in the BFD abfd, including a
678 terminal NULL pointer. If there are no symbols in the BFD,
679 then return 0. If an error occurs, return -1. */
680
681 static long
682 vms_get_symtab_upper_bound (bfd * abfd)
683 {
684 vms_debug2 ((1, "vms_get_symtab_upper_bound (%p), %d symbols\n",
685 abfd, PRIV (gsd_sym_count)));
686
687 return (PRIV (gsd_sym_count) + 1) * sizeof (asymbol *);
688 }
689
690 /* Copy symbols from hash table to symbol vector
691
692 called from bfd_hash_traverse in vms_canonicalize_symtab
693 init counter to 0 if entry == 0. */
694
695 static bfd_boolean
696 copy_symbols (struct bfd_hash_entry *entry, void * arg)
697 {
698 bfd * abfd = (bfd *) arg;
699
700 if (entry == NULL) /* Init counter. */
701 PRIV (symnum) = 0;
702 else /* Fill vector, inc counter. */
703 PRIV (symcache)[PRIV (symnum)++] = ((vms_symbol_entry *)entry)->symbol;
704
705 return TRUE;
706 }
707
708 /* Read the symbols from the BFD abfd, and fills in the vector
709 location with pointers to the symbols and a trailing NULL.
710
711 Return number of symbols read. */
712
713 static long
714 vms_canonicalize_symtab (bfd * abfd, asymbol **symbols)
715 {
716 vms_debug2 ((1, "vms_canonicalize_symtab (%p, <ret>)\n", abfd));
717
718 /* Init counter. */
719 copy_symbols (NULL, abfd);
720
721 /* Traverse table and fill symbols vector. */
722 PRIV (symcache) = symbols;
723 bfd_hash_traverse (PRIV (vms_symbol_table), copy_symbols, abfd);
724
725 symbols[PRIV (gsd_sym_count)] = NULL;
726
727 return PRIV (gsd_sym_count);
728 }
729
730 /* Print symbol to file according to how. how is one of
731 bfd_print_symbol_name just print the name
732 bfd_print_symbol_more print more (???)
733 bfd_print_symbol_all print all we know, which is not much right now :-). */
734
735 static void
736 vms_print_symbol (bfd * abfd,
737 void * file,
738 asymbol *symbol,
739 bfd_print_symbol_type how)
740 {
741 vms_debug2 ((1, "vms_print_symbol (%p, %p, %p, %d)\n",
742 abfd, file, symbol, how));
743
744 switch (how)
745 {
746 case bfd_print_symbol_name:
747 case bfd_print_symbol_more:
748 fprintf ((FILE *)file," %s", symbol->name);
749 break;
750
751 case bfd_print_symbol_all:
752 {
753 const char *section_name = symbol->section->name;
754
755 bfd_print_symbol_vandf (abfd, file, symbol);
756
757 fprintf ((FILE *) file," %-8s %s", section_name, symbol->name);
758 }
759 break;
760 }
761 }
762
763 /* Return information about symbol in ret.
764
765 fill type, value and name
766 type:
767 A absolute
768 B bss segment symbol
769 C common symbol
770 D data segment symbol
771 f filename
772 t a static function symbol
773 T text segment symbol
774 U undefined
775 - debug. */
776
777 static void
778 vms_get_symbol_info (bfd * abfd ATTRIBUTE_UNUSED,
779 asymbol *symbol,
780 symbol_info *ret)
781 {
782 asection *sec;
783
784 vms_debug2 ((1, "vms_get_symbol_info (%p, %p, %p)\n", abfd, symbol, ret));
785
786 sec = symbol->section;
787
788 if (ret == NULL)
789 return;
790
791 if (sec == 0)
792 ret->type = 'U';
793 else if (bfd_is_com_section (sec))
794 ret->type = 'C';
795 else if (bfd_is_abs_section (sec))
796 ret->type = 'A';
797 else if (bfd_is_und_section (sec))
798 ret->type = 'U';
799 else if (bfd_is_ind_section (sec))
800 ret->type = 'I';
801 else if (bfd_get_section_flags (abfd, sec) & SEC_CODE)
802 ret->type = 'T';
803 else if (bfd_get_section_flags (abfd, sec) & SEC_DATA)
804 ret->type = 'D';
805 else if (bfd_get_section_flags (abfd, sec) & SEC_ALLOC)
806 ret->type = 'B';
807 else
808 ret->type = '-';
809
810 if (ret->type != 'U')
811 ret->value = symbol->value + symbol->section->vma;
812 else
813 ret->value = 0;
814 ret->name = symbol->name;
815 }
816
817 /* Return TRUE if the given symbol sym in the BFD abfd is
818 a compiler generated local label, else return FALSE. */
819
820 static bfd_boolean
821 vms_bfd_is_local_label_name (bfd * abfd ATTRIBUTE_UNUSED,
822 const char *name)
823 {
824 vms_debug2 ((1, "vms_bfd_is_local_label_name (%p, %s)\n", abfd, name));
825 return name[0] == '$';
826 }
827
828 /* Provided a BFD, a section and an offset into the section, calculate and
829 return the name of the source file and the line nearest to the wanted
830 location. */
831
832 static bfd_boolean
833 vms_find_nearest_line (bfd * abfd ATTRIBUTE_UNUSED,
834 asection *section ATTRIBUTE_UNUSED,
835 asymbol **symbols ATTRIBUTE_UNUSED,
836 bfd_vma offset ATTRIBUTE_UNUSED,
837 const char **file ATTRIBUTE_UNUSED,
838 const char **func ATTRIBUTE_UNUSED,
839 unsigned int *line ATTRIBUTE_UNUSED)
840 {
841 vms_debug2 ((1, "vms_find_nearest_line (%p, %s, %p, %ld, ...)\n",
842 abfd, section->name, symbols, (long int)offset));
843 return _bfd_vms_find_nearest_dst_line (abfd, section, symbols, offset, file, func, line);
844 }
845
846 /* Part 4.6, relocations. */
847
848 /* Allocate the reloc buffer for the specified section. */
849
850 static void
851 alloc_reloc_stream (bfd *abfd ATTRIBUTE_UNUSED, asection *section,
852 void *alloc_error)
853 {
854 unsigned char *ptr;
855
856 /* If there were no relocations, there is nothing to do. */
857 if (section->reloc_count == 0)
858 return;
859
860 ptr = bfd_malloc (vms_section_data (section)->reloc_size);
861 if (ptr == NULL)
862 {
863 *(bfd_boolean *)alloc_error = TRUE;
864 return;
865 }
866
867 vms_section_data (section)->reloc_stream = ptr;
868 }
869
870 /* Read in the relocs for the specified section and internalize them.
871
872 The implementation is loosely based on the SOM code and made up
873 of 3 distinct phases:
874
875 1. When the VMS object is opened and parsed, the number and the size
876 of the relocations are computed for all sections. This makes it
877 possible to know upfront both which sections have no relocs and
878 the size of the reloc buffers for the other sections, at virtually
879 no cost for consumers that don't care about relocs at all.
880
881 2. When vms_slurp_reloc_table is invoked for the first time on a section
882 with relocs, the object is traversed and all the reloc information
883 is saved in per-section reloc buffers. It would be very inefficient
884 to scan the whole file on each invocation, so we slurp for all the
885 sections at once.
886
887 3. On subsequent invocations of vms_slurp_reloc_table, the relocs for the
888 specified section are fetched from the buffer, decoded and internalized.
889 The buffer is then freed since the internalized relocs are attached to
890 the section, turning additional invocations of vms_slurp_reloc_table
891 on the same section into no-ops.
892
893 Since VMS objects have very few sections, it could be profitable to merge
894 phase #2 and phase #3, i.e. to decode and internalize the relocs for all
895 the sections at once. The current implementation is more elegant. */
896
897 static bfd_boolean
898 vms_slurp_reloc_table (bfd *abfd, asection *section, asymbol **symbols)
899 {
900 arelent *internal_relocs;
901 bfd_size_type amt;
902 int err;
903
904 /* If there were no relocations, there is nothing to do. */
905 if (section->reloc_count == 0)
906 return TRUE;
907
908 /* Return saved information about the relocations if it is available. */
909 if (section->relocation != NULL)
910 return TRUE;
911
912 /* If the relocation stream has not been slurped, do it now. */
913 if (vms_section_data (section)->reloc_stream == NULL)
914 {
915 bfd_boolean alloc_error = FALSE;
916 int type;
917
918 /* Size the reloc buffer for each section. */
919 bfd_map_over_sections (abfd, alloc_reloc_stream, &alloc_error);
920 if (alloc_error)
921 return FALSE;
922
923 if (bfd_seek (abfd, 0, SEEK_SET) != 0)
924 return FALSE;
925
926 /* Reset section pointer. */
927 PRIV (image_section) = NULL;
928
929 do
930 {
931 type = _bfd_vms_get_object_record (abfd);
932 if (type != EOBJ_S_C_ETIR
933 && type != EOBJ_S_C_EDBG
934 && type != EOBJ_S_C_ETBT)
935 continue;
936 err = _bfd_vms_slurp_relocs (abfd);
937 if (err != 0)
938 {
939 vms_debug2 ((2, "slurp relocs failed with %d\n", err));
940 return FALSE;
941 }
942 }
943 while (type != EOBJ_S_C_EEOM);
944 }
945
946 amt = section->reloc_count * sizeof (arelent);
947 internal_relocs = (arelent *) bfd_zalloc (abfd, amt);
948 if (internal_relocs == NULL)
949 return FALSE;
950
951 /* Decode and internalize the relocations. */
952 err = _bfd_vms_decode_relocs (abfd, internal_relocs, section, symbols);
953 if (err != 0)
954 {
955 vms_debug2 ((2, "decode relocs failed with %d\n", err));
956 return FALSE;
957 }
958
959 /* We're done with the external relocations. Free them. */
960 free (vms_section_data (section)->reloc_stream);
961 vms_section_data (section)->reloc_stream = NULL;
962
963 /* Save our results and return success. */
964 section->relocation = internal_relocs;
965 return TRUE;
966 }
967
968 /* Return the number of bytes required to store the relocation
969 information associated with the given section. */
970
971 static long
972 vms_get_reloc_upper_bound (bfd *abfd ATTRIBUTE_UNUSED, asection *section)
973 {
974 return (section->reloc_count + 1) * sizeof (arelent *);
975 }
976
977 /* Convert relocations from VMS (external) form into BFD internal
978 form. Return the number of relocations. */
979
980 static long
981 vms_canonicalize_reloc (bfd *abfd, asection *section, arelent **relptr,
982 asymbol **symbols)
983 {
984 arelent *tblptr;
985 int count;
986
987 if (! vms_slurp_reloc_table (abfd, section, symbols))
988 return -1;
989
990 count = section->reloc_count;
991 tblptr = section->relocation;
992
993 while (count--)
994 *relptr++ = tblptr++;
995
996 *relptr = (arelent *) NULL;
997 return section->reloc_count;
998 }
999 \f
1000 /* This is just copied from ecoff-alpha, needs to be fixed probably. */
1001
1002 /* How to process the various reloc types. */
1003
1004 static bfd_reloc_status_type
1005 reloc_nil (bfd * abfd ATTRIBUTE_UNUSED,
1006 arelent *reloc ATTRIBUTE_UNUSED,
1007 asymbol *sym ATTRIBUTE_UNUSED,
1008 void * data ATTRIBUTE_UNUSED,
1009 asection *sec ATTRIBUTE_UNUSED,
1010 bfd *output_bfd ATTRIBUTE_UNUSED,
1011 char **error_message ATTRIBUTE_UNUSED)
1012 {
1013 #if VMS_DEBUG
1014 vms_debug (1, "reloc_nil (abfd %p, output_bfd %p)\n", abfd, output_bfd);
1015 vms_debug (2, "In section %s, symbol %s\n",
1016 sec->name, sym->name);
1017 vms_debug (2, "reloc sym %s, addr %08lx, addend %08lx, reloc is a %s\n",
1018 reloc->sym_ptr_ptr[0]->name,
1019 (unsigned long)reloc->address,
1020 (unsigned long)reloc->addend, reloc->howto->name);
1021 vms_debug (2, "data at %p\n", data);
1022 /* _bfd_hexdump (2, data, bfd_get_reloc_size (reloc->howto), 0); */
1023 #endif
1024
1025 return bfd_reloc_ok;
1026 }
1027
1028 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value
1029 from smaller values. Start with zero, widen, *then* decrement. */
1030 #define MINUS_ONE (((bfd_vma)0) - 1)
1031
1032 static reloc_howto_type alpha_howto_table[] =
1033 {
1034 HOWTO (ALPHA_R_IGNORE, /* Type. */
1035 0, /* Rightshift. */
1036 0, /* Size (0 = byte, 1 = short, 2 = long). */
1037 8, /* Bitsize. */
1038 TRUE, /* PC relative. */
1039 0, /* Bitpos. */
1040 complain_overflow_dont,/* Complain_on_overflow. */
1041 reloc_nil, /* Special_function. */
1042 "IGNORE", /* Name. */
1043 TRUE, /* Partial_inplace. */
1044 0, /* Source mask */
1045 0, /* Dest mask. */
1046 TRUE), /* PC rel offset. */
1047
1048 /* A 64 bit reference to a symbol. */
1049 HOWTO (ALPHA_R_REFQUAD, /* Type. */
1050 0, /* Rightshift. */
1051 4, /* Size (0 = byte, 1 = short, 2 = long). */
1052 64, /* Bitsize. */
1053 FALSE, /* PC relative. */
1054 0, /* Bitpos. */
1055 complain_overflow_bitfield, /* Complain_on_overflow. */
1056 reloc_nil, /* Special_function. */
1057 "REFQUAD", /* Name. */
1058 TRUE, /* Partial_inplace. */
1059 MINUS_ONE, /* Source mask. */
1060 MINUS_ONE, /* Dest mask. */
1061 FALSE), /* PC rel offset. */
1062
1063 /* A 21 bit branch. The native assembler generates these for
1064 branches within the text segment, and also fills in the PC
1065 relative offset in the instruction. */
1066 HOWTO (ALPHA_R_BRADDR, /* Type. */
1067 2, /* Rightshift. */
1068 2, /* Size (0 = byte, 1 = short, 2 = long). */
1069 21, /* Bitsize. */
1070 TRUE, /* PC relative. */
1071 0, /* Bitpos. */
1072 complain_overflow_signed, /* Complain_on_overflow. */
1073 reloc_nil, /* Special_function. */
1074 "BRADDR", /* Name. */
1075 TRUE, /* Partial_inplace. */
1076 0x1fffff, /* Source mask. */
1077 0x1fffff, /* Dest mask. */
1078 FALSE), /* PC rel offset. */
1079
1080 /* A hint for a jump to a register. */
1081 HOWTO (ALPHA_R_HINT, /* Type. */
1082 2, /* Rightshift. */
1083 1, /* Size (0 = byte, 1 = short, 2 = long). */
1084 14, /* Bitsize. */
1085 TRUE, /* PC relative. */
1086 0, /* Bitpos. */
1087 complain_overflow_dont,/* Complain_on_overflow. */
1088 reloc_nil, /* Special_function. */
1089 "HINT", /* Name. */
1090 TRUE, /* Partial_inplace. */
1091 0x3fff, /* Source mask. */
1092 0x3fff, /* Dest mask. */
1093 FALSE), /* PC rel offset. */
1094
1095 /* 16 bit PC relative offset. */
1096 HOWTO (ALPHA_R_SREL16, /* Type. */
1097 0, /* Rightshift. */
1098 1, /* Size (0 = byte, 1 = short, 2 = long). */
1099 16, /* Bitsize. */
1100 TRUE, /* PC relative. */
1101 0, /* Bitpos. */
1102 complain_overflow_signed, /* Complain_on_overflow. */
1103 reloc_nil, /* Special_function. */
1104 "SREL16", /* Name. */
1105 TRUE, /* Partial_inplace. */
1106 0xffff, /* Source mask. */
1107 0xffff, /* Dest mask. */
1108 FALSE), /* PC rel offset. */
1109
1110 /* 32 bit PC relative offset. */
1111 HOWTO (ALPHA_R_SREL32, /* Type. */
1112 0, /* Rightshift. */
1113 2, /* Size (0 = byte, 1 = short, 2 = long). */
1114 32, /* Bitsize. */
1115 TRUE, /* PC relative. */
1116 0, /* Bitpos. */
1117 complain_overflow_signed, /* Complain_on_overflow. */
1118 reloc_nil, /* Special_function. */
1119 "SREL32", /* Name. */
1120 TRUE, /* Partial_inplace. */
1121 0xffffffff, /* Source mask. */
1122 0xffffffff, /* Dest mask. */
1123 FALSE), /* PC rel offset. */
1124
1125 /* A 64 bit PC relative offset. */
1126 HOWTO (ALPHA_R_SREL64, /* Type. */
1127 0, /* Rightshift. */
1128 4, /* Size (0 = byte, 1 = short, 2 = long). */
1129 64, /* Bitsize. */
1130 TRUE, /* PC relative. */
1131 0, /* Bitpos. */
1132 complain_overflow_signed, /* Complain_on_overflow. */
1133 reloc_nil, /* Special_function. */
1134 "SREL64", /* Name. */
1135 TRUE, /* Partial_inplace. */
1136 MINUS_ONE, /* Source mask. */
1137 MINUS_ONE, /* Dest mask. */
1138 FALSE), /* PC rel offset. */
1139
1140 /* Push a value on the reloc evaluation stack. */
1141 HOWTO (ALPHA_R_OP_PUSH, /* Type. */
1142 0, /* Rightshift. */
1143 0, /* Size (0 = byte, 1 = short, 2 = long). */
1144 0, /* Bitsize. */
1145 FALSE, /* PC relative. */
1146 0, /* Bitpos. */
1147 complain_overflow_dont,/* Complain_on_overflow. */
1148 reloc_nil, /* Special_function. */
1149 "OP_PUSH", /* Name. */
1150 FALSE, /* Partial_inplace. */
1151 0, /* Source mask. */
1152 0, /* Dest mask. */
1153 FALSE), /* PC rel offset. */
1154
1155 /* Store the value from the stack at the given address. Store it in
1156 a bitfield of size r_size starting at bit position r_offset. */
1157 HOWTO (ALPHA_R_OP_STORE, /* Type. */
1158 0, /* Rightshift. */
1159 4, /* Size (0 = byte, 1 = short, 2 = long). */
1160 64, /* Bitsize. */
1161 FALSE, /* PC relative. */
1162 0, /* Bitpos. */
1163 complain_overflow_dont,/* Complain_on_overflow. */
1164 reloc_nil, /* Special_function. */
1165 "OP_STORE", /* Name. */
1166 FALSE, /* Partial_inplace. */
1167 0, /* Source mask. */
1168 MINUS_ONE, /* Dest mask. */
1169 FALSE), /* PC rel offset. */
1170
1171 /* Subtract the reloc address from the value on the top of the
1172 relocation stack. */
1173 HOWTO (ALPHA_R_OP_PSUB, /* Type. */
1174 0, /* Rightshift. */
1175 0, /* Size (0 = byte, 1 = short, 2 = long). */
1176 0, /* Bitsize. */
1177 FALSE, /* PC relative. */
1178 0, /* Bitpos. */
1179 complain_overflow_dont,/* Complain_on_overflow. */
1180 reloc_nil, /* Special_function. */
1181 "OP_PSUB", /* Name. */
1182 FALSE, /* Partial_inplace. */
1183 0, /* Source mask. */
1184 0, /* Dest mask. */
1185 FALSE), /* PC rel offset. */
1186
1187 /* Shift the value on the top of the relocation stack right by the
1188 given value. */
1189 HOWTO (ALPHA_R_OP_PRSHIFT, /* Type. */
1190 0, /* Rightshift. */
1191 0, /* Size (0 = byte, 1 = short, 2 = long). */
1192 0, /* Bitsize. */
1193 FALSE, /* PC relative. */
1194 0, /* Bitpos. */
1195 complain_overflow_dont,/* Complain_on_overflow. */
1196 reloc_nil, /* Special_function. */
1197 "OP_PRSHIFT", /* Name. */
1198 FALSE, /* Partial_inplace. */
1199 0, /* Source mask. */
1200 0, /* Dest mask. */
1201 FALSE), /* PC rel offset. */
1202
1203 /* Hack. Linkage is done by linker. */
1204 HOWTO (ALPHA_R_LINKAGE, /* Type. */
1205 0, /* Rightshift. */
1206 8, /* Size (0 = byte, 1 = short, 2 = long). */
1207 256, /* Bitsize. */
1208 FALSE, /* PC relative. */
1209 0, /* Bitpos. */
1210 complain_overflow_dont,/* Complain_on_overflow. */
1211 reloc_nil, /* Special_function. */
1212 "LINKAGE", /* Name. */
1213 FALSE, /* Partial_inplace. */
1214 0, /* Source mask. */
1215 0, /* Dest mask. */
1216 FALSE), /* PC rel offset. */
1217
1218 /* A 32 bit reference to a symbol. */
1219 HOWTO (ALPHA_R_REFLONG, /* Type. */
1220 0, /* Rightshift. */
1221 2, /* Size (0 = byte, 1 = short, 2 = long). */
1222 32, /* Bitsize. */
1223 FALSE, /* PC relative. */
1224 0, /* Bitpos. */
1225 complain_overflow_bitfield, /* Complain_on_overflow. */
1226 reloc_nil, /* Special_function. */
1227 "REFLONG", /* Name. */
1228 TRUE, /* Partial_inplace. */
1229 0xffffffff, /* Source mask. */
1230 0xffffffff, /* Dest mask. */
1231 FALSE), /* PC rel offset. */
1232
1233 /* A 64 bit reference to a procedure, written as 32 bit value. */
1234 HOWTO (ALPHA_R_CODEADDR, /* Type. */
1235 0, /* Rightshift. */
1236 4, /* Size (0 = byte, 1 = short, 2 = long). */
1237 64, /* Bitsize. */
1238 FALSE, /* PC relative. */
1239 0, /* Bitpos. */
1240 complain_overflow_signed,/* Complain_on_overflow. */
1241 reloc_nil, /* Special_function. */
1242 "CODEADDR", /* Name. */
1243 FALSE, /* Partial_inplace. */
1244 0xffffffff, /* Source mask. */
1245 0xffffffff, /* Dest mask. */
1246 FALSE), /* PC rel offset. */
1247
1248 HOWTO (ALPHA_R_NOP, /* Type. */
1249 0, /* Rightshift. */
1250 3, /* Size (0 = byte, 1 = short, 2 = long). */
1251 0, /* Bitsize. */
1252 /* The following value must match that of ALPHA_R_BSR/ALPHA_R_BOH
1253 because the calculations for the 3 relocations are the same.
1254 See B.4.5.2 of the OpenVMS Linker Utility Manual. */
1255 TRUE, /* PC relative. */
1256 0, /* Bitpos. */
1257 complain_overflow_dont,/* Complain_on_overflow. */
1258 reloc_nil, /* Special_function. */
1259 "NOP", /* Name. */
1260 FALSE, /* Partial_inplace. */
1261 0xffffffff, /* Source mask. */
1262 0xffffffff, /* Dest mask. */
1263 FALSE), /* PC rel offset. */
1264
1265 HOWTO (ALPHA_R_BSR, /* Type. */
1266 0, /* Rightshift. */
1267 3, /* Size (0 = byte, 1 = short, 2 = long). */
1268 0, /* Bitsize. */
1269 TRUE, /* PC relative. */
1270 0, /* Bitpos. */
1271 complain_overflow_dont,/* Complain_on_overflow. */
1272 reloc_nil, /* Special_function. */
1273 "BSR", /* Name. */
1274 FALSE, /* Partial_inplace. */
1275 0xffffffff, /* Source mask. */
1276 0xffffffff, /* Dest mask. */
1277 FALSE), /* PC rel offset. */
1278
1279 HOWTO (ALPHA_R_LDA, /* Type. */
1280 0, /* Rightshift. */
1281 3, /* Size (0 = byte, 1 = short, 2 = long). */
1282 0, /* Bitsize. */
1283 FALSE, /* PC relative. */
1284 0, /* Bitpos. */
1285 complain_overflow_dont,/* Complain_on_overflow. */
1286 reloc_nil, /* Special_function. */
1287 "LDA", /* Name. */
1288 FALSE, /* Partial_inplace. */
1289 0xffffffff, /* Source mask. */
1290 0xffffffff, /* Dest mask. */
1291 FALSE), /* PC rel offset. */
1292
1293 HOWTO (ALPHA_R_BOH, /* Type. */
1294 0, /* Rightshift. */
1295 3, /* Size (0 = byte, 1 = short, 2 = long, 3 = nil). */
1296 0, /* Bitsize. */
1297 TRUE, /* PC relative. */
1298 0, /* Bitpos. */
1299 complain_overflow_dont,/* Complain_on_overflow. */
1300 reloc_nil, /* Special_function. */
1301 "BOH", /* Name. */
1302 FALSE, /* Partial_inplace. */
1303 0xffffffff, /* Source mask. */
1304 0xffffffff, /* Dest mask. */
1305 FALSE), /* PC rel offset. */
1306 };
1307
1308 /* Return a pointer to a howto structure which, when invoked, will perform
1309 the relocation code on data from the architecture noted. */
1310
1311 static const struct reloc_howto_struct *
1312 vms_bfd_reloc_type_lookup (bfd * abfd ATTRIBUTE_UNUSED,
1313 bfd_reloc_code_real_type code)
1314 {
1315 int alpha_type;
1316
1317 vms_debug2 ((1, "vms_bfd_reloc_type_lookup (%p, %d)\t", abfd, code));
1318
1319 switch (code)
1320 {
1321 case BFD_RELOC_16: alpha_type = ALPHA_R_SREL16; break;
1322 case BFD_RELOC_32: alpha_type = ALPHA_R_REFLONG; break;
1323 case BFD_RELOC_64: alpha_type = ALPHA_R_REFQUAD; break;
1324 case BFD_RELOC_CTOR: alpha_type = ALPHA_R_REFQUAD; break;
1325 case BFD_RELOC_23_PCREL_S2: alpha_type = ALPHA_R_BRADDR; break;
1326 case BFD_RELOC_ALPHA_HINT: alpha_type = ALPHA_R_HINT; break;
1327 case BFD_RELOC_16_PCREL: alpha_type = ALPHA_R_SREL16; break;
1328 case BFD_RELOC_32_PCREL: alpha_type = ALPHA_R_SREL32; break;
1329 case BFD_RELOC_64_PCREL: alpha_type = ALPHA_R_SREL64; break;
1330 case BFD_RELOC_ALPHA_LINKAGE: alpha_type = ALPHA_R_LINKAGE; break;
1331 case BFD_RELOC_ALPHA_CODEADDR: alpha_type = ALPHA_R_CODEADDR; break;
1332 case BFD_RELOC_ALPHA_NOP: alpha_type = ALPHA_R_NOP; break;
1333 case BFD_RELOC_ALPHA_BSR: alpha_type = ALPHA_R_BSR; break;
1334 case BFD_RELOC_ALPHA_LDA: alpha_type = ALPHA_R_LDA; break;
1335 case BFD_RELOC_ALPHA_BOH: alpha_type = ALPHA_R_BOH; break;
1336 default:
1337 (*_bfd_error_handler) ("reloc (%d) is *UNKNOWN*", code);
1338 return NULL;
1339 }
1340 vms_debug2 ((2, "reloc is %s\n", alpha_howto_table[alpha_type].name));
1341 return & alpha_howto_table[alpha_type];
1342 }
1343
1344 static reloc_howto_type *
1345 vms_bfd_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
1346 const char *r_name)
1347 {
1348 unsigned int i;
1349
1350 for (i = 0;
1351 i < sizeof (alpha_howto_table) / sizeof (alpha_howto_table[0]);
1352 i++)
1353 if (alpha_howto_table[i].name != NULL
1354 && strcasecmp (alpha_howto_table[i].name, r_name) == 0)
1355 return &alpha_howto_table[i];
1356
1357 return NULL;
1358 }
1359
1360 /* Part 4.7, writing an object file. */
1361
1362 /* Set the architecture and machine type in BFD abfd to arch and mach.
1363 Find the correct pointer to a structure and insert it into the arch_info
1364 pointer. */
1365
1366 static bfd_boolean
1367 vms_set_arch_mach (bfd * abfd,
1368 enum bfd_architecture arch ATTRIBUTE_UNUSED,
1369 unsigned long mach ATTRIBUTE_UNUSED)
1370 {
1371 vms_debug2 ((1, "vms_set_arch_mach (%p, %d, %ld)\n", abfd, arch, mach));
1372
1373 if (arch != bfd_arch_alpha
1374 && arch != bfd_arch_vax
1375 && arch != bfd_arch_unknown)
1376 return FALSE;
1377
1378 return bfd_default_set_arch_mach (abfd, arch, mach);
1379 }
1380
1381 /* Sets the contents of the section section in BFD abfd to the data starting
1382 in memory at LOCATION. The data is written to the output section starting
1383 at offset offset for count bytes.
1384
1385 Normally TRUE is returned, else FALSE. Possible error returns are:
1386 o bfd_error_no_contents - The output section does not have the
1387 SEC_HAS_CONTENTS attribute, so nothing can be written to it.
1388 o and some more too */
1389
1390 static bfd_boolean
1391 vms_set_section_contents (bfd * abfd,
1392 asection *section,
1393 const void * location,
1394 file_ptr offset,
1395 bfd_size_type count)
1396 {
1397 #if VMS_DEBUG
1398 vms_debug (1, "vms_set_section_contents (%p, sec %s, loc %p, off %ld, count %d)\n",
1399 abfd, section->name, location, (long int)offset, (int)count);
1400 vms_debug (2, "size %d\n", (int) section->size);
1401 #endif
1402 if (count == (bfd_size_type)0)
1403 return TRUE;
1404
1405 if (section->contents == NULL)
1406 section->contents = bfd_alloc (abfd, section->size);
1407 if (section->contents == NULL)
1408 return FALSE;
1409
1410 memcpy (section->contents + offset, location, (size_t) count);
1411 return TRUE;
1412 }
1413
1414 static bfd_boolean
1415 vms_bfd_print_private_bfd_data (bfd *abfd, void *ptr)
1416 {
1417 FILE *file = (FILE *)ptr;
1418
1419 fprintf (file, _("structure level: %d\n"), PRIV(hdr_data.hdr_b_strlvl));
1420 fprintf (file, _("module name : %s\n"), PRIV(hdr_data.hdr_t_name));
1421 fprintf (file, _("module version : %s\n"), PRIV(hdr_data.hdr_t_version));
1422 fprintf (file, _("module date : %s\n"), PRIV(hdr_data.hdr_t_date));
1423 fprintf (file, _("language name : %s\n"), PRIV(hdr_data.hdr_c_lnm));
1424 fprintf (file, _("source files : %s\n"), PRIV(hdr_data.hdr_c_src));
1425 fprintf (file, _("title : %s\n"), PRIV(hdr_data.hdr_c_ttl));
1426
1427 return TRUE;
1428 }
1429 \f
1430 const bfd_target vms_alpha_vec =
1431 {
1432 "vms-alpha", /* Name. */
1433 bfd_target_evax_flavour,
1434 BFD_ENDIAN_LITTLE, /* Data byte order is little. */
1435 BFD_ENDIAN_LITTLE, /* Header byte order is little. */
1436
1437 (HAS_RELOC | EXEC_P | HAS_LINENO | HAS_DEBUG | HAS_SYMS | HAS_LOCALS
1438 | WP_TEXT | D_PAGED), /* Object flags. */
1439 (SEC_ALLOC | SEC_LOAD | SEC_RELOC
1440 | SEC_READONLY | SEC_CODE | SEC_DATA
1441 | SEC_HAS_CONTENTS | SEC_IN_MEMORY), /* Sect flags. */
1442 0, /* symbol_leading_char. */
1443 ' ', /* ar_pad_char. */
1444 15, /* ar_max_namelen. */
1445 bfd_getl64, bfd_getl_signed_64, bfd_putl64,
1446 bfd_getl32, bfd_getl_signed_32, bfd_putl32,
1447 bfd_getl16, bfd_getl_signed_16, bfd_putl16,
1448 bfd_getl64, bfd_getl_signed_64, bfd_putl64,
1449 bfd_getl32, bfd_getl_signed_32, bfd_putl32,
1450 bfd_getl16, bfd_getl_signed_16, bfd_putl16,
1451
1452 {_bfd_dummy_target, vms_object_p, /* bfd_check_format. */
1453 _bfd_dummy_target, _bfd_dummy_target},
1454 {bfd_false, vms_mkobject, /* bfd_set_format. */
1455 bfd_false, bfd_false},
1456 {bfd_false, vms_write_object_contents, /* bfd_write_contents. */
1457 bfd_false, bfd_false},
1458
1459 BFD_JUMP_TABLE_GENERIC (vms),
1460 BFD_JUMP_TABLE_COPY (vms),
1461 BFD_JUMP_TABLE_CORE (_bfd_nocore),
1462 BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive),
1463 BFD_JUMP_TABLE_SYMBOLS (vms),
1464 BFD_JUMP_TABLE_RELOCS (vms),
1465 BFD_JUMP_TABLE_WRITE (vms),
1466 BFD_JUMP_TABLE_LINK (_bfd_nolink),
1467 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
1468
1469 NULL,
1470
1471 (PTR) 0
1472 };
1473
1474 const bfd_target vms_vax_vec =
1475 {
1476 "vms-vax", /* Name. */
1477 bfd_target_ovax_flavour,
1478 BFD_ENDIAN_LITTLE, /* Data byte order is little. */
1479 BFD_ENDIAN_LITTLE, /* Header byte order is little. */
1480
1481 (HAS_RELOC | HAS_SYMS /* Object flags. */
1482 | WP_TEXT | D_PAGED
1483 | HAS_LINENO | HAS_DEBUG | HAS_LOCALS),
1484
1485 (SEC_ALLOC | SEC_LOAD | SEC_RELOC
1486 | SEC_READONLY | SEC_CODE | SEC_DATA
1487 | SEC_HAS_CONTENTS | SEC_IN_MEMORY), /* Sect flags. */
1488 0, /* symbol_leading_char */
1489 ' ', /* ar_pad_char */
1490 15, /* ar_max_namelen */
1491 bfd_getl64, bfd_getl_signed_64, bfd_putl64,
1492 bfd_getl32, bfd_getl_signed_32, bfd_putl32,
1493 bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* Data. */
1494 bfd_getl64, bfd_getl_signed_64, bfd_putl64,
1495 bfd_getl32, bfd_getl_signed_32, bfd_putl32,
1496 bfd_getl16, bfd_getl_signed_16, bfd_putl16, /* Hdrs. */
1497
1498 {_bfd_dummy_target, vms_object_p, /* bfd_check_format. */
1499 _bfd_dummy_target, _bfd_dummy_target},
1500 {bfd_false, vms_mkobject, /* bfd_set_format. */
1501 bfd_false, bfd_false},
1502 {bfd_false, vms_write_object_contents, /* bfd_write_contents. */
1503 bfd_false, bfd_false},
1504
1505 BFD_JUMP_TABLE_GENERIC (vms),
1506 BFD_JUMP_TABLE_COPY (vms),
1507 BFD_JUMP_TABLE_CORE (_bfd_nocore),
1508 BFD_JUMP_TABLE_ARCHIVE (_bfd_noarchive),
1509 BFD_JUMP_TABLE_SYMBOLS (vms),
1510 BFD_JUMP_TABLE_RELOCS (vms),
1511 BFD_JUMP_TABLE_WRITE (vms),
1512 BFD_JUMP_TABLE_LINK (_bfd_nolink),
1513 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
1514
1515 NULL,
1516
1517 (PTR) 0
1518 };
Patches to binutils for mingw-w64