OpenCores
URL https://opencores.org/ocsvn/openrisc_2011-10-31/openrisc_2011-10-31/trunk

Subversion Repositories openrisc_2011-10-31

[/] [openrisc/] [trunk/] [gnu-src/] [binutils-2.20.1/] [bfd/] [vms.c] - Blame information for rev 205

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.