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