/* vms.c -- BFD back-end for EVAX (openVMS/Alpha) files.
- Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
- 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
+ Copyright (C) 1996-2017 Free Software Foundation, Inc.
Initial version written by Klaus Kaempf (kkaempf@rmi.de)
Major rewrite by Adacore.
struct module *modules; /* list of all compilation units */
+ /* The DST section. */
asection *dst_section;
unsigned int dst_ptr_offsets_count; /* # of offsets in following array */
struct vms_internal_eisd_map *gbl_eisd_tail;
/* linkage index counter used by conditional store commands */
- int vms_linkage_index;
-
- /* see tc-alpha.c of gas for a description. */
- int flag_hash_long_names; /* -+, hash instead of truncate */
- int flag_show_after_trunc; /* -H, show hashing/truncation */
+ unsigned int vms_linkage_index;
};
#define PRIV2(abfd, name) \
((struct vms_section_data_struct *)sec->used_by_bfd)
/* To be called from the debugger. */
-struct vms_private_data_struct *bfd_vms_get_data (bfd *abfd);
+struct vms_private_data_struct *bfd_vms_get_data (bfd *);
-static int vms_get_remaining_object_record (bfd *abfd, int read_so_far);
+static int vms_get_remaining_object_record (bfd *, unsigned int);
static bfd_boolean _bfd_vms_slurp_object_records (bfd * abfd);
static void alpha_vms_add_fixup_lp (struct bfd_link_info *, bfd *, bfd *);
static void alpha_vms_add_fixup_ca (struct bfd_link_info *, bfd *, bfd *);
static void alpha_vms_add_fixup_qr (struct bfd_link_info *, bfd *, bfd *,
bfd_vma);
-static void alpha_vms_add_lw_reloc (struct bfd_link_info *info);
-static void alpha_vms_add_qw_reloc (struct bfd_link_info *info);
-static void alpha_vms_add_lw_fixup (struct bfd_link_info *, unsigned int,
+static void alpha_vms_add_fixup_lr (struct bfd_link_info *, unsigned int,
bfd_vma);
+static void alpha_vms_add_lw_reloc (struct bfd_link_info *);
+static void alpha_vms_add_qw_reloc (struct bfd_link_info *);
struct vector_type
{
{
struct bfd_link_hash_table root;
- /* Vector of shared libaries. */
+ /* Vector of shared libraries. */
struct vector_type shrlibs;
/* Fixup section. */
asection *section;
flagword bfd_flags;
+ /* PR 17512: file: 3d9e9fe9. */
+ if (offset >= PRIV (recrd.rec_size))
+ return FALSE;
eisd = (struct vms_eisd *)(PRIV (recrd.rec) + offset);
rec_size = bfd_getl32 (eisd->eisdsize);
-
if (rec_size == 0)
break;
return FALSE;
}
- if (_bfd_vms_slurp_object_records (abfd) != TRUE)
+ if (!_bfd_vms_slurp_object_records (abfd))
return FALSE;
abfd->flags |= HAS_SYMS;
Return the size of the record or 0 on failure. */
static int
-vms_get_remaining_object_record (bfd *abfd, int read_so_far)
+vms_get_remaining_object_record (bfd *abfd, unsigned int read_so_far)
{
unsigned int to_read;
/* Extract record size. */
PRIV (recrd.rec_size) = bfd_getl16 (PRIV (recrd.rec) + 2);
- if (PRIV (recrd.rec_size) <= 0)
+ if (PRIV (recrd.rec_size) == 0)
{
bfd_set_error (bfd_error_file_truncated);
return 0;
return 0;
PRIV (recrd.buf_size) = to_read;
}
+ /* PR 17512: file: 025-1974-0.004. */
+ else if (to_read <= read_so_far)
+ return 0;
/* Read the remaining record. */
to_read -= read_so_far;
{
unsigned char *ptr;
unsigned char *vms_rec;
+ unsigned char *end;
int subtype;
vms_rec = PRIV (recrd.rec);
+ /* PR 17512: file: 62736583. */
+ end = PRIV (recrd.buf) + PRIV (recrd.buf_size);
vms_debug2 ((2, "HDR/EMH\n"));
{
case EMH__C_MHD:
/* Module header. */
+ if (vms_rec + 21 >= end)
+ goto fail;
PRIV (hdr_data).hdr_b_strlvl = vms_rec[6];
PRIV (hdr_data).hdr_l_arch1 = bfd_getl32 (vms_rec + 8);
PRIV (hdr_data).hdr_l_arch2 = bfd_getl32 (vms_rec + 12);
PRIV (hdr_data).hdr_l_recsiz = bfd_getl32 (vms_rec + 16);
+ if ((vms_rec + 20 + vms_rec[20] + 1) >= end)
+ goto fail;
PRIV (hdr_data).hdr_t_name = _bfd_vms_save_counted_string (vms_rec + 20);
ptr = vms_rec + 20 + vms_rec[20] + 1;
+ if ((ptr + *ptr + 1) >= end)
+ goto fail;
PRIV (hdr_data).hdr_t_version =_bfd_vms_save_counted_string (ptr);
ptr += *ptr + 1;
+ if (ptr + 17 >= end)
+ goto fail;
PRIV (hdr_data).hdr_t_date = _bfd_vms_save_sized_string (ptr, 17);
break;
case EMH__C_LNM:
+ if (vms_rec + PRIV (recrd.rec_size - 6) > end)
+ goto fail;
PRIV (hdr_data).hdr_c_lnm =
_bfd_vms_save_sized_string (vms_rec, PRIV (recrd.rec_size - 6));
break;
case EMH__C_SRC:
+ if (vms_rec + PRIV (recrd.rec_size - 6) > end)
+ goto fail;
PRIV (hdr_data).hdr_c_src =
_bfd_vms_save_sized_string (vms_rec, PRIV (recrd.rec_size - 6));
break;
case EMH__C_TTL:
+ if (vms_rec + PRIV (recrd.rec_size - 6) > end)
+ goto fail;
PRIV (hdr_data).hdr_c_ttl =
_bfd_vms_save_sized_string (vms_rec, PRIV (recrd.rec_size - 6));
break;
break;
default:
+ fail:
bfd_set_error (bfd_error_wrong_format);
return FALSE;
}
0 },
{ EVAX_CODE_NAME,
EGPS__V_PIC | EGPS__V_REL | EGPS__V_SHR | EGPS__V_EXE,
- SEC_CODE,
+ SEC_CODE | SEC_READONLY,
EGPS__V_PIC | EGPS__V_REL | EGPS__V_SHR | EGPS__V_EXE,
- SEC_CODE | SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD },
+ SEC_CODE | SEC_READONLY | SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD },
{ EVAX_LITERAL_NAME,
EGPS__V_PIC | EGPS__V_REL | EGPS__V_SHR | EGPS__V_RD | EGPS__V_NOMOD,
SEC_DATA | SEC_READONLY,
EGPS__V_PIC | EGPS__V_REL | EGPS__V_SHR | EGPS__V_RD,
- SEC_DATA | SEC_HAS_CONTENTS | SEC_ALLOC | SEC_READONLY | SEC_LOAD },
+ SEC_DATA | SEC_READONLY | SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD },
{ EVAX_LINK_NAME,
EGPS__V_REL | EGPS__V_RD,
SEC_DATA | SEC_READONLY,
EGPS__V_REL | EGPS__V_RD,
- SEC_DATA | SEC_HAS_CONTENTS | SEC_ALLOC | SEC_READONLY | SEC_LOAD },
+ SEC_DATA | SEC_READONLY | SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD },
{ EVAX_DATA_NAME,
EGPS__V_REL | EGPS__V_RD | EGPS__V_WRT | EGPS__V_NOMOD,
SEC_DATA,
EGPS__V_PIC | EGPS__V_REL | EGPS__V_RD,
SEC_DATA | SEC_READONLY,
EGPS__V_PIC | EGPS__V_REL | EGPS__V_RD,
- SEC_DATA | SEC_HAS_CONTENTS | SEC_ALLOC | SEC_READONLY | SEC_LOAD },
+ SEC_DATA | SEC_READONLY | SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD },
{ EVAX_READONLY_NAME,
EGPS__V_PIC | EGPS__V_REL | EGPS__V_SHR | EGPS__V_RD | EGPS__V_NOMOD,
SEC_DATA | SEC_READONLY,
EGPS__V_PIC | EGPS__V_REL | EGPS__V_SHR | EGPS__V_RD,
- SEC_DATA | SEC_HAS_CONTENTS | SEC_ALLOC | SEC_READONLY | SEC_LOAD },
+ SEC_DATA | SEC_READONLY | SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD },
{ EVAX_LOCAL_NAME,
EGPS__V_REL | EGPS__V_RD | EGPS__V_WRT,
SEC_DATA,
EGPS__V_PIC | EGPS__V_OVR,
SEC_DATA | SEC_READONLY,
EGPS__V_PIC | EGPS__V_OVR,
- SEC_DATA | SEC_HAS_CONTENTS | SEC_ALLOC | SEC_READONLY | SEC_LOAD },
+ SEC_DATA | SEC_READONLY | SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD },
{ NULL,
EGPS__V_REL | EGPS__V_RD | EGPS__V_WRT,
SEC_DATA,
EGPS__V_REL | EGPS__V_RD | EGPS__V_WRT,
- SEC_IN_MEMORY | SEC_DATA | SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD }
+ SEC_DATA | SEC_HAS_CONTENTS | SEC_ALLOC | SEC_LOAD }
};
/* Retrieve BFD section flags by name and size. */
_bfd_vms_slurp_egsd (bfd *abfd)
{
int gsd_type, gsd_size;
- asection *section;
unsigned char *vms_rec;
- flagword new_flags, old_flags;
- char *name;
unsigned long base_addr;
- unsigned long align_addr;
vms_debug2 ((2, "EGSD\n"));
switch (gsd_type)
{
case EGSD__C_PSC:
+ /* Program section definition. */
{
- /* Program section definition. */
struct vms_egps *egps = (struct vms_egps *)vms_rec;
+ flagword new_flags, vms_flags;
+ asection *section;
+
+ vms_flags = bfd_getl16 (egps->flags);
- name = _bfd_vms_save_counted_string (&egps->namlng);
- section = bfd_make_section (abfd, name);
- if (!section)
- return FALSE;
-
- old_flags = bfd_getl16 (egps->flags);
- vms_section_data (section)->flags = old_flags;
- vms_section_data (section)->no_flags = 0;
- section->size = bfd_getl32 (egps->alloc);
- new_flags = vms_secflag_by_name (evax_section_flags, name,
- section->size > 0);
- if (!(old_flags & EGPS__V_NOMOD) && section->size > 0)
+ if ((vms_flags & EGPS__V_REL) == 0)
{
- new_flags |= SEC_HAS_CONTENTS;
- if (old_flags & EGPS__V_REL)
- new_flags |= SEC_RELOC;
+ /* Use the global absolute section for all
+ absolute sections. */
+ section = bfd_abs_section_ptr;
}
- if (!bfd_set_section_flags (abfd, section, new_flags))
- return FALSE;
- section->alignment_power = egps->align;
- if ((old_flags & EGPS__V_REL) != 0)
+ else
{
+ char *name;
+ unsigned long align_addr;
+
+ name = _bfd_vms_save_counted_string (&egps->namlng);
+
+ section = bfd_make_section (abfd, name);
+ if (!section)
+ return FALSE;
+
+ section->filepos = 0;
+ section->size = bfd_getl32 (egps->alloc);
+ section->alignment_power = egps->align;
+
+ vms_section_data (section)->flags = vms_flags;
+ vms_section_data (section)->no_flags = 0;
+
+ new_flags = vms_secflag_by_name (evax_section_flags, name,
+ section->size > 0);
+ if (section->size > 0)
+ new_flags |= SEC_LOAD;
+ if (!(vms_flags & EGPS__V_NOMOD) && section->size > 0)
+ {
+ /* Set RELOC and HAS_CONTENTS if the section is not
+ demand-zero and not empty. */
+ new_flags |= SEC_HAS_CONTENTS;
+ if (vms_flags & EGPS__V_REL)
+ new_flags |= SEC_RELOC;
+ }
+ if (vms_flags & EGPS__V_EXE)
+ {
+ /* Set CODE if section is executable. */
+ new_flags |= SEC_CODE;
+ new_flags &= ~SEC_DATA;
+ }
+ if (!bfd_set_section_flags (abfd, section, new_flags))
+ return FALSE;
+
/* Give a non-overlapping vma to non absolute sections. */
align_addr = (1 << section->alignment_power);
if ((base_addr % align_addr) != 0)
section->vma = (bfd_vma)base_addr;
base_addr += section->size;
}
- else
- section->vma = 0;
- section->filepos = 0;
/* Append it to the section array. */
if (PRIV (section_count) >= PRIV (section_max))
PRIV (sections)[PRIV (section_count)] = section;
PRIV (section_count)++;
-
-#if VMS_DEBUG
- vms_debug (4, "EGSD P-section %d (%s, flags %04x) ",
- section->index, name, old_flags);
- vms_debug (4, "%lu bytes at 0x%08lx (mem %p)\n",
- (unsigned long)section->size,
- (unsigned long)section->vma, section->contents);
-#endif
}
break;
int nameoff;
struct vms_symbol_entry *entry;
struct vms_egsy *egsy = (struct vms_egsy *) vms_rec;
+ flagword old_flags;
old_flags = bfd_getl16 (egsy->flags);
if (old_flags & EGSY__V_DEF)
{
struct vms_symbol_entry *entry;
struct vms_egst *egst = (struct vms_egst *)vms_rec;
+ flagword old_flags;
old_flags = bfd_getl16 (egst->header.flags);
case EGSD__C_SYMM:
case EGSD__C_SYMV:
default:
- (*_bfd_error_handler) (_("Unknown EGSD subtype %d"), gsd_type);
+ _bfd_error_handler (_("Unknown EGSD subtype %d"), gsd_type);
bfd_set_error (bfd_error_bad_value);
return FALSE;
}
if (PRIV (stackptr) >= STACKSIZE)
{
bfd_set_error (bfd_error_bad_value);
- (*_bfd_error_handler) (_("Stack overflow (%d) in _bfd_vms_push"), PRIV (stackptr));
+ _bfd_error_handler (_("Stack overflow (%d) in _bfd_vms_push"), PRIV (stackptr));
exit (1);
}
}
if (PRIV (stackptr) == 0)
{
bfd_set_error (bfd_error_bad_value);
- (*_bfd_error_handler) (_("Stack underflow in _bfd_vms_pop"));
+ _bfd_error_handler (_("Stack underflow in _bfd_vms_pop"));
exit (1);
}
PRIV (stackptr)--;
default:
/* These names have not yet been added to this switch statement. */
- (*_bfd_error_handler) (_("unknown ETIR command %d"), cmd);
+ _bfd_error_handler (_("unknown ETIR command %d"), cmd);
}
return NULL;
*vma = 0;
else
{
- if (!(*info->callbacks->undefined_symbol)
- (info, name, abfd, PRIV (image_section), PRIV (image_offset), TRUE))
- abort ();
+ (*info->callbacks->undefined_symbol)
+ (info, name, abfd, PRIV (image_section), PRIV (image_offset), TRUE);
*vma = 0;
}
}
#if VMS_DEBUG
_bfd_vms_debug (4, "etir: %s(%d)\n",
_bfd_vms_etir_name (cmd), cmd);
- _bfd_hexdump (8, ptr, cmd_length - 4, (long) ptr);
+ _bfd_hexdump (8, ptr, cmd_length - 4, 0);
#endif
switch (cmd)
psect = bfd_getl32 (ptr);
if ((unsigned int) psect >= PRIV (section_count))
{
- (*_bfd_error_handler) (_("bad section index in %s"),
- _bfd_vms_etir_name (cmd));
+ _bfd_error_handler (_("bad section index in %s"),
+ _bfd_vms_etir_name (cmd));
bfd_set_error (bfd_error_bad_value);
return FALSE;
}
case ETIR__C_STA_LI:
case ETIR__C_STA_MOD:
case ETIR__C_STA_CKARG:
- (*_bfd_error_handler) (_("unsupported STA cmd %s"),
- _bfd_vms_etir_name (cmd));
+ _bfd_error_handler (_("unsupported STA cmd %s"),
+ _bfd_vms_etir_name (cmd));
return FALSE;
break;
}
else if (rel1 & RELC_SHR_BASE)
{
- alpha_vms_add_lw_fixup (info, rel1 & RELC_MASK, op1);
+ alpha_vms_add_fixup_lr (info, rel1 & RELC_MASK, op1);
rel1 = RELC_NONE;
}
if (rel1 != RELC_NONE)
case ETIR__C_STO_RB:
case ETIR__C_STO_AB:
case ETIR__C_STO_LP_PSB:
- (*_bfd_error_handler) (_("%s: not supported"),
- _bfd_vms_etir_name (cmd));
+ _bfd_error_handler (_("%s: not supported"),
+ _bfd_vms_etir_name (cmd));
return FALSE;
break;
case ETIR__C_STO_HINT_GBL:
case ETIR__C_STO_HINT_PS:
- (*_bfd_error_handler) (_("%s: not implemented"),
- _bfd_vms_etir_name (cmd));
+ _bfd_error_handler (_("%s: not implemented"),
+ _bfd_vms_etir_name (cmd));
return FALSE;
break;
lw psect index
qw offset. */
case ETIR__C_STC_PS:
- (*_bfd_error_handler) (_("%s: not supported"),
- _bfd_vms_etir_name (cmd));
+ _bfd_error_handler (_("%s: not supported"),
+ _bfd_vms_etir_name (cmd));
return FALSE;
break;
/* 214 Store-conditional NOP, BSR or HINT at psect + offset
arg: none. */
case ETIR__C_STC_NBH_PS:
- (*_bfd_error_handler) ("%s: not supported",
- _bfd_vms_etir_name (cmd));
+ _bfd_error_handler (_("%s: not supported"),
+ _bfd_vms_etir_name (cmd));
return FALSE;
break;
if (rel1 != RELC_NONE || rel2 != RELC_NONE)
{
bad_context:
- (*_bfd_error_handler) (_("invalid use of %s with contexts"),
- _bfd_vms_etir_name (cmd));
+ _bfd_error_handler (_("invalid use of %s with contexts"),
+ _bfd_vms_etir_name (cmd));
return FALSE;
}
if ((int)op2 < 0) /* Shift right. */
case ETIR__C_OPR_ROT: /* Rotate. */
case ETIR__C_OPR_REDEF: /* Redefine symbol to current location. */
case ETIR__C_OPR_DFLIT: /* Define a literal. */
- (*_bfd_error_handler) (_("%s: not supported"),
- _bfd_vms_etir_name (cmd));
+ _bfd_error_handler (_("%s: not supported"),
+ _bfd_vms_etir_name (cmd));
return FALSE;
break;
break;
default:
- (*_bfd_error_handler) (_("reserved cmd %d"), cmd);
+ _bfd_error_handler (_("reserved cmd %d"), cmd);
return FALSE;
break;
}
PRIV (eom_data).eom_w_comcod = bfd_getl16 (eeom->comcod);
if (PRIV (eom_data).eom_w_comcod > 1)
{
- (*_bfd_error_handler) (_("Object module NOT error-free !\n"));
+ _bfd_error_handler (_("Object module NOT error-free !\n"));
bfd_set_error (bfd_error_bad_value);
return FALSE;
}
default:
err = FALSE;
}
- if (err != TRUE)
+ if (!err)
{
vms_debug2 ((2, "slurp type %d failed\n", type));
return FALSE;
static const struct bfd_target *
alpha_vms_object_p (bfd *abfd)
{
- PTR tdata_save = abfd->tdata.any;
+ void *tdata_save = abfd->tdata.any;
unsigned int test_len;
unsigned char *buf;
PRIV (recrd.rec) = buf;
if (bfd_bread (buf, test_len, abfd) != test_len)
- {
- bfd_set_error (bfd_error_file_truncated);
- goto error_ret;
- }
+ goto err_wrong_format;
/* Is it an image? */
if ((bfd_getl32 (buf) == EIHD__K_MAJORID)
if (buf == NULL)
{
PRIV (recrd.buf) = NULL;
- bfd_set_error (bfd_error_no_memory);
goto error_ret;
}
PRIV (recrd.buf) = buf;
while (remaining > 0)
{
if (bfd_bread (buf + read_so_far, to_read, abfd) != to_read)
- {
- bfd_set_error (bfd_error_file_truncated);
- goto err_wrong_format;
- }
+ goto err_wrong_format;
read_so_far += to_read;
remaining -= to_read;
/* Reset the record pointer. */
PRIV (recrd.rec) = buf;
+ /* PR 17512: file: 7d7c57c2. */
+ if (PRIV (recrd.rec_size) < sizeof (struct vms_eihd))
+ goto error_ret;
vms_debug2 ((2, "file type is image\n"));
- if (_bfd_vms_slurp_eihd (abfd, &eisd_offset, &eihs_offset) != TRUE)
+ if (!_bfd_vms_slurp_eihd (abfd, &eisd_offset, &eihs_offset))
goto err_wrong_format;
- if (_bfd_vms_slurp_eisd (abfd, eisd_offset) != TRUE)
+ if (!_bfd_vms_slurp_eisd (abfd, eisd_offset))
goto err_wrong_format;
/* EIHS is optional. */
- if (eihs_offset != 0 && _bfd_vms_slurp_eihs (abfd, eihs_offset) != TRUE)
+ if (eihs_offset != 0 && !_bfd_vms_slurp_eihs (abfd, eihs_offset))
goto err_wrong_format;
}
else
vms_debug2 ((2, "file type is module\n"));
type = bfd_getl16 (PRIV (recrd.rec));
- if (type != EOBJ__C_EMH || _bfd_vms_slurp_ehdr (abfd) != TRUE)
+ if (type != EOBJ__C_EMH || !_bfd_vms_slurp_ehdr (abfd))
goto err_wrong_format;
- if (_bfd_vms_slurp_object_records (abfd) != TRUE)
+ if (!_bfd_vms_slurp_object_records (abfd))
goto err_wrong_format;
}
else
_bfd_vms_output_alignment (recwr, 2);
_bfd_vms_output_begin (recwr, EOBJ__C_EEOM);
- _bfd_vms_output_long (recwr, (unsigned long) (PRIV (vms_linkage_index) >> 1));
+ _bfd_vms_output_long (recwr, PRIV (vms_linkage_index + 1) >> 1);
_bfd_vms_output_byte (recwr, 0); /* Completion code. */
_bfd_vms_output_byte (recwr, 0); /* Fill byte. */
return TRUE;
}
-/* This hash routine borrowed from GNU-EMACS, and strengthened
- slightly. ERY. */
-
-static int
-hash_string (const char *ptr)
-{
- const unsigned char *p = (unsigned char *) ptr;
- const unsigned char *end = p + strlen (ptr);
- unsigned char c;
- int hash = 0;
-
- while (p != end)
- {
- c = *p++;
- hash = ((hash << 3) + (hash << 15) + (hash >> 28) + c);
- }
- return hash;
-}
-
-/* Generate a length-hashed VMS symbol name (limited to maxlen chars). */
-
-static char *
-_bfd_vms_length_hash_symbol (bfd *abfd, const char *in, int maxlen)
-{
- unsigned long result;
- int in_len;
- char *new_name;
- const char *old_name;
- int i;
- static char outbuf[EOBJ__C_SYMSIZ + 1];
- char *out = outbuf;
-
-#if VMS_DEBUG
- vms_debug (4, "_bfd_vms_length_hash_symbol \"%s\"\n", in);
-#endif
-
- if (maxlen > EOBJ__C_SYMSIZ)
- maxlen = EOBJ__C_SYMSIZ;
-
- /* Save this for later. */
- new_name = out;
-
- /* We may need to truncate the symbol, save the hash for later. */
- in_len = strlen (in);
-
- result = (in_len > maxlen) ? hash_string (in) : 0;
-
- old_name = in;
-
- /* Do the length checking. */
- if (in_len <= maxlen)
- i = in_len;
- else
- {
- if (PRIV (flag_hash_long_names))
- i = maxlen - 9;
- else
- i = maxlen;
- }
-
- strncpy (out, in, (size_t) i);
- in += i;
- out += i;
-
- if ((in_len > maxlen)
- && PRIV (flag_hash_long_names))
- sprintf (out, "_%08lx", result);
- else
- *out = 0;
-
-#if VMS_DEBUG
- vms_debug (4, "--> [%d]\"%s\"\n", (int)strlen (outbuf), outbuf);
-#endif
-
- if (in_len > maxlen
- && PRIV (flag_hash_long_names)
- && PRIV (flag_show_after_trunc))
- printf (_("Symbol %s replaced by %s\n"), old_name, new_name);
-
- return outbuf;
-}
-
static void
vector_grow1 (struct vector_type *vec, size_t elsz)
{
if (!(sec->flags & SEC_READONLY))
eisd->u.eisd.flags |= EISD__M_WRT | EISD__M_CRF;
- if (!(sec->flags & SEC_LOAD))
+ /* If relocations or fixup will be applied, make this isect writeable. */
+ if (sec->flags & SEC_RELOC)
+ eisd->u.eisd.flags |= EISD__M_WRT | EISD__M_CRF;
+
+ if (!(sec->flags & SEC_HAS_CONTENTS))
{
eisd->u.eisd.flags |= EISD__M_DZRO;
eisd->u.eisd.flags &= ~EISD__M_CRF;
for (i = 0; i < PRIV (gsd_sym_count); i++)
{
struct vms_symbol_entry *sym = PRIV (syms)[i];
- char *hash;
bfd_vma val;
bfd_vma ep;
_bfd_vms_output_quad (recwr, ep);
_bfd_vms_output_quad (recwr, val);
_bfd_vms_output_long (recwr, 0);
- hash = _bfd_vms_length_hash_symbol (abfd, sym->name, EOBJ__C_SYMSIZ);
- _bfd_vms_output_counted (recwr, hash);
+ _bfd_vms_output_counted (recwr, sym->name);
_bfd_vms_output_end_subrec (recwr);
if ((i % 5) == 4)
_bfd_vms_output_end (abfd, recwr);
else if ((*sname == 'l') && (strcmp (sname, "lcomm") == 0))
sname = EVAX_LOCAL_NAME;
}
- else
- sname = _bfd_vms_length_hash_symbol (abfd, sname, EOBJ__C_SECSIZ);
if (bfd_is_com_section (section))
new_flags = (EGPS__V_OVR | EGPS__V_REL | EGPS__V_GBL | EGPS__V_RD
for (symnum = 0; symnum < abfd->symcount; symnum++)
{
- char *hash;
-
symbol = abfd->outsymbols[symnum];
old_flags = symbol->flags;
/* Work-around a missing feature: consider __main as the main entry
point. */
- if (*(symbol->name) == '_')
- {
- if (strcmp (symbol->name, "__main") == 0)
- bfd_set_start_address (abfd, (bfd_vma)symbol->value);
- }
+ if (symbol->name[0] == '_' && strcmp (symbol->name, "__main") == 0)
+ bfd_set_start_address (abfd, (bfd_vma)symbol->value);
/* Only put in the GSD the global and the undefined symbols. */
if (old_flags & BSF_FILE)
_bfd_vms_output_long (recwr, ca_psindx);
_bfd_vms_output_long (recwr, psindx);
}
- hash = _bfd_vms_length_hash_symbol (abfd, symbol->name, EOBJ__C_SYMSIZ);
- _bfd_vms_output_counted (recwr, hash);
+ _bfd_vms_output_counted (recwr, symbol->name);
_bfd_vms_output_end_subrec (recwr);
}
{
asymbol *symbol;
unsigned int symnum;
- int had_case = 0;
- int had_file = 0;
struct vms_rec_wr *recwr = &PRIV (recwr);
vms_debug2 ((2, "vms_write_ehdr (%p)\n", abfd));
if (symbol->flags & BSF_FILE)
{
- if (CONST_STRNEQ ((char *)symbol->name, "<CASE:"))
- {
- PRIV (flag_hash_long_names) = symbol->name[6] - '0';
- PRIV (flag_show_after_trunc) = symbol->name[7] - '0';
-
- if (had_file)
- break;
- had_case = 1;
- continue;
- }
-
_bfd_vms_output_dump (recwr, (unsigned char *) symbol->name,
(int) strlen (symbol->name));
- if (had_case)
- break;
- had_file = 1;
+ break;
}
}
_bfd_vms_output_alignment (recwr, 4);
- PRIV (vms_linkage_index) = 1;
+ PRIV (vms_linkage_index) = 0;
for (section = abfd->sections; section; section = section->next)
{
int pass2_in_progress = 0;
unsigned int irel;
- if (section->reloc_count <= 0)
- (*_bfd_error_handler)
- (_("SEC_RELOC with no relocs in section %s"), section->name);
+ if (section->reloc_count == 0)
+ _bfd_error_handler
+ (_("SEC_RELOC with no relocs in section %A"), section);
#if VMS_DEBUG
else
asection *sec = sym->section;
bfd_boolean defer = defer_reloc_p (rptr);
unsigned int slen;
- char *hash;
if (pass2_in_progress)
{
/* Regular relocs are intertwined with binary data. */
if (curr_addr > addr)
- (*_bfd_error_handler) (_("Size error in section %s"),
- section->name);
+ _bfd_error_handler (_("Size error in section %A"),
+ section);
size = addr - curr_addr;
sto_imm (abfd, section, size, curr_data, curr_addr);
curr_data += size;
{
bfd_vma addend = rptr->addend;
slen = strlen ((char *) sym->name);
- hash = _bfd_vms_length_hash_symbol
- (abfd, sym->name, EOBJ__C_SYMSIZ);
etir_output_check (abfd, section, curr_addr, slen);
if (addend)
{
_bfd_vms_output_begin_subrec (recwr, ETIR__C_STA_GBL);
- _bfd_vms_output_counted (recwr, hash);
+ _bfd_vms_output_counted (recwr, sym->name);
_bfd_vms_output_end_subrec (recwr);
_bfd_vms_output_begin_subrec (recwr, ETIR__C_STA_LW);
_bfd_vms_output_long (recwr, (unsigned long) addend);
{
_bfd_vms_output_begin_subrec
(recwr, ETIR__C_STO_GBL_LW);
- _bfd_vms_output_counted (recwr, hash);
+ _bfd_vms_output_counted (recwr, sym->name);
_bfd_vms_output_end_subrec (recwr);
}
}
{
bfd_vma addend = rptr->addend;
slen = strlen ((char *) sym->name);
- hash = _bfd_vms_length_hash_symbol
- (abfd, sym->name, EOBJ__C_SYMSIZ);
etir_output_check (abfd, section, curr_addr, slen);
if (addend)
{
_bfd_vms_output_begin_subrec (recwr, ETIR__C_STA_GBL);
- _bfd_vms_output_counted (recwr, hash);
+ _bfd_vms_output_counted (recwr, sym->name);
_bfd_vms_output_end_subrec (recwr);
_bfd_vms_output_begin_subrec (recwr, ETIR__C_STA_QW);
_bfd_vms_output_quad (recwr, addend);
else
{
_bfd_vms_output_begin_subrec (recwr, ETIR__C_STO_GBL);
- _bfd_vms_output_counted (recwr, hash);
+ _bfd_vms_output_counted (recwr, sym->name);
_bfd_vms_output_end_subrec (recwr);
}
}
etir_output_check (abfd, section, curr_addr, 64);
_bfd_vms_output_begin_subrec (recwr, ETIR__C_STC_LP_PSB);
_bfd_vms_output_long
- (recwr, (unsigned long) PRIV (vms_linkage_index));
- PRIV (vms_linkage_index) += 2;
- hash = _bfd_vms_length_hash_symbol
- (abfd, sym->name, EOBJ__C_SYMSIZ);
- _bfd_vms_output_counted (recwr, hash);
+ (recwr, (unsigned long) rptr->addend);
+ if (rptr->addend > PRIV (vms_linkage_index))
+ PRIV (vms_linkage_index) = rptr->addend;
+ _bfd_vms_output_counted (recwr, sym->name);
_bfd_vms_output_byte (recwr, 0);
_bfd_vms_output_end_subrec (recwr);
break;
case ALPHA_R_CODEADDR:
slen = strlen ((char *) sym->name);
- hash = _bfd_vms_length_hash_symbol
- (abfd, sym->name, EOBJ__C_SYMSIZ);
etir_output_check (abfd, section, curr_addr, slen);
_bfd_vms_output_begin_subrec (recwr, ETIR__C_STO_CA);
- _bfd_vms_output_counted (recwr, hash);
+ _bfd_vms_output_counted (recwr, sym->name);
_bfd_vms_output_end_subrec (recwr);
break;
_bfd_vms_output_begin_subrec (recwr, ETIR__C_STC_NOP_GBL);
_bfd_vms_output_long (recwr, (unsigned long) udata->lkindex);
_bfd_vms_output_long
- (recwr,
- (unsigned long) udata->enbsym->section->target_index);
+ (recwr, (unsigned long) section->target_index);
_bfd_vms_output_quad (recwr, rptr->address);
_bfd_vms_output_long (recwr, (unsigned long) 0x47ff041f);
_bfd_vms_output_long
- (recwr,
- (unsigned long) udata->enbsym->section->target_index);
+ (recwr, (unsigned long) section->target_index);
_bfd_vms_output_quad (recwr, rptr->addend);
- _bfd_vms_output_counted
- (recwr, _bfd_vms_length_hash_symbol
- (abfd, udata->origname, EOBJ__C_SYMSIZ));
+ _bfd_vms_output_counted (recwr, udata->origname);
_bfd_vms_output_end_subrec (recwr);
break;
case ALPHA_R_BSR:
- (*_bfd_error_handler) (_("Spurious ALPHA_R_BSR reloc"));
+ _bfd_error_handler (_("Spurious ALPHA_R_BSR reloc"));
break;
case ALPHA_R_LDA:
_bfd_vms_output_long
(recwr, (unsigned long) udata->lkindex + 1);
_bfd_vms_output_long
- (recwr,
- (unsigned long) udata->enbsym->section->target_index);
+ (recwr, (unsigned long) section->target_index);
_bfd_vms_output_quad (recwr, rptr->address);
_bfd_vms_output_long (recwr, (unsigned long) 0x237B0000);
_bfd_vms_output_long
(recwr, (unsigned long) udata->bsym->section->target_index);
_bfd_vms_output_quad (recwr, rptr->addend);
- _bfd_vms_output_counted
- (recwr, _bfd_vms_length_hash_symbol
- (abfd, udata->origname, EOBJ__C_SYMSIZ));
+ _bfd_vms_output_counted (recwr, udata->origname);
_bfd_vms_output_end_subrec (recwr);
break;
_bfd_vms_output_begin_subrec (recwr, ETIR__C_STC_BOH_GBL);
_bfd_vms_output_long (recwr, (unsigned long) udata->lkindex);
_bfd_vms_output_long
- (recwr,
- (unsigned long) udata->enbsym->section->target_index);
+ (recwr, (unsigned long) section->target_index);
_bfd_vms_output_quad (recwr, rptr->address);
_bfd_vms_output_long (recwr, (unsigned long) 0xD3400000);
_bfd_vms_output_long
- (recwr,
- (unsigned long) udata->enbsym->section->target_index);
+ (recwr, (unsigned long) section->target_index);
_bfd_vms_output_quad (recwr, rptr->addend);
- _bfd_vms_output_counted
- (recwr, _bfd_vms_length_hash_symbol
- (abfd, udata->origname, EOBJ__C_SYMSIZ));
+ _bfd_vms_output_counted (recwr, udata->origname);
_bfd_vms_output_end_subrec (recwr);
break;
default:
- (*_bfd_error_handler) (_("Unhandled relocation %s"),
- rptr->howto->name);
+ _bfd_error_handler (_("Unhandled relocation %s"),
+ rptr->howto->name);
break;
}
{
/* Output rest of section. */
if (curr_addr > section->size)
- (*_bfd_error_handler) (_("Size error in section %s"),
- section->name);
+ _bfd_error_handler (_("Size error in section %A"), section);
size = section->size - curr_addr;
sto_imm (abfd, section, size, curr_data, curr_addr);
curr_data += size;
{
if (abfd->section_count > 0) /* we have sections */
{
- if (_bfd_vms_write_ehdr (abfd) != TRUE)
+ if (!_bfd_vms_write_ehdr (abfd))
return FALSE;
- if (_bfd_vms_write_egsd (abfd) != TRUE)
+ if (!_bfd_vms_write_egsd (abfd))
return FALSE;
- if (_bfd_vms_write_etir (abfd, EOBJ__C_ETIR) != TRUE)
+ if (!_bfd_vms_write_etir (abfd, EOBJ__C_ETIR))
return FALSE;
- if (_bfd_vms_write_eeom (abfd) != TRUE)
+ if (!_bfd_vms_write_eeom (abfd))
return FALSE;
}
}
break;
default:
- (*_bfd_error_handler) (_("unknown source command %d"),
- cmd);
+ _bfd_error_handler (_("unknown source command %d"),
+ cmd);
cmd_length = 2;
break;
}
break;
case DST__K_SET_LINUM_INCR:
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("DST__K_SET_LINUM_INCR not implemented"));
cmd_length = 2;
break;
case DST__K_SET_LINUM_INCR_W:
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("DST__K_SET_LINUM_INCR_W not implemented"));
cmd_length = 3;
break;
case DST__K_RESET_LINUM_INCR:
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("DST__K_RESET_LINUM_INCR not implemented"));
cmd_length = 1;
break;
case DST__K_BEG_STMT_MODE:
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("DST__K_BEG_STMT_MODE not implemented"));
cmd_length = 1;
break;
case DST__K_END_STMT_MODE:
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("DST__K_END_STMT_MODE not implemented"));
cmd_length = 1;
break;
break;
case DST__K_SET_PC:
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("DST__K_SET_PC not implemented"));
cmd_length = 2;
break;
case DST__K_SET_PC_W:
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("DST__K_SET_PC_W not implemented"));
cmd_length = 3;
break;
case DST__K_SET_PC_L:
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("DST__K_SET_PC_L not implemented"));
cmd_length = 5;
break;
case DST__K_SET_STMTNUM:
- (*_bfd_error_handler)
+ _bfd_error_handler
(_("DST__K_SET_STMTNUM not implemented"));
cmd_length = 2;
break;
}
else
{
- (*_bfd_error_handler) (_("unknown line command %d"),
- cmd);
+ _bfd_error_handler (_("unknown line command %d"), cmd);
cmd_length = 2;
}
break;
/* We don't have a DMT section so this must be an object. Parse
the module right now in order to compute its start address and
end address. */
+ void *dst = PRIV (dst_section)->contents;
+
+ if (dst == NULL)
+ return NULL;
+
module = new_module (abfd);
parse_module (abfd, module, PRIV (dst_section)->contents, -1);
list = module;
location. */
static bfd_boolean
-_bfd_vms_find_nearest_dst_line (bfd *abfd, asection *section,
- asymbol **symbols ATTRIBUTE_UNUSED,
- bfd_vma offset, const char **file,
- const char **func, unsigned int *line)
+_bfd_vms_find_nearest_line (bfd *abfd,
+ asymbol **symbols ATTRIBUTE_UNUSED,
+ asection *section,
+ bfd_vma offset,
+ const char **file,
+ const char **func,
+ unsigned int *line,
+ unsigned int *discriminator)
{
struct module *module;
*file = NULL;
*func = NULL;
*line = 0;
+ if (discriminator)
+ *discriminator = 0;
- if (PRIV (dst_section) == NULL || !(abfd->flags & (EXEC_P | DYNAMIC)))
+ /* We can't do anything if there is no DST (debug symbol table). */
+ if (PRIV (dst_section) == NULL)
return FALSE;
+ /* Create the module list - if not already done. */
if (PRIV (modules) == NULL)
{
PRIV (modules) = build_module_list (abfd);
case ETIR__C_CTL_SETRB:
if (prev_cmd != ETIR__C_STA_PQ)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
+ /* xgettext:c-format */
(_("Unknown reloc %s + %s"), _bfd_vms_etir_name (prev_cmd),
_bfd_vms_etir_name (cmd));
return FALSE;
{
if (prev_cmd != ETIR__C_STA_GBL)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
+ /* xgettext:c-format */
(_("Unknown reloc %s + %s"), _bfd_vms_etir_name (cmd),
_bfd_vms_etir_name (ETIR__C_STA_LW));
return FALSE;
/* ALPHA_R_REFQUAD und_section, step 2 */
if (prev_cmd != -1 && prev_cmd != ETIR__C_STA_GBL)
{
- (*_bfd_error_handler)
+ _bfd_error_handler
+ /* xgettext:c-format */
(_("Unknown reloc %s + %s"), _bfd_vms_etir_name (cmd),
_bfd_vms_etir_name (ETIR__C_STA_QW));
return FALSE;
&& prev_cmd != ETIR__C_STA_LW
&& prev_cmd != ETIR__C_STA_PQ)
{
- (*_bfd_error_handler) (_("Unknown reloc %s + %s"),
- _bfd_vms_etir_name (prev_cmd),
- _bfd_vms_etir_name (ETIR__C_STO_LW));
+ /* xgettext:c-format */
+ _bfd_error_handler (_("Unknown reloc %s + %s"),
+ _bfd_vms_etir_name (prev_cmd),
+ _bfd_vms_etir_name (ETIR__C_STO_LW));
return FALSE;
}
reloc_code = BFD_RELOC_32;
/* ALPHA_R_REFQUAD abs_section, step 2 */
if (prev_cmd != ETIR__C_OPR_ADD && prev_cmd != ETIR__C_STA_QW)
{
- (*_bfd_error_handler) (_("Unknown reloc %s + %s"),
- _bfd_vms_etir_name (prev_cmd),
- _bfd_vms_etir_name (ETIR__C_STO_QW));
+ /* xgettext:c-format */
+ _bfd_error_handler (_("Unknown reloc %s + %s"),
+ _bfd_vms_etir_name (prev_cmd),
+ _bfd_vms_etir_name (ETIR__C_STO_QW));
return FALSE;
}
reloc_code = BFD_RELOC_64;
case ETIR__C_STO_OFF: /* ALPHA_R_REFQUAD others, step 2 */
if (prev_cmd != ETIR__C_STA_PQ)
{
- (*_bfd_error_handler) (_("Unknown reloc %s + %s"),
- _bfd_vms_etir_name (prev_cmd),
- _bfd_vms_etir_name (ETIR__C_STO_OFF));
+ /* xgettext:c-format */
+ _bfd_error_handler (_("Unknown reloc %s + %s"),
+ _bfd_vms_etir_name (prev_cmd),
+ _bfd_vms_etir_name (ETIR__C_STO_OFF));
return FALSE;
}
reloc_code = BFD_RELOC_64;
/* ALPHA_R_REFQUAD und_section, step 3 */
if (prev_cmd != ETIR__C_STA_LW && prev_cmd != ETIR__C_STA_QW)
{
- (*_bfd_error_handler) (_("Unknown reloc %s + %s"),
- _bfd_vms_etir_name (prev_cmd),
- _bfd_vms_etir_name (ETIR__C_OPR_ADD));
+ /* xgettext:c-format */
+ _bfd_error_handler (_("Unknown reloc %s + %s"),
+ _bfd_vms_etir_name (prev_cmd),
+ _bfd_vms_etir_name (ETIR__C_OPR_ADD));
return FALSE;
}
prev_cmd = ETIR__C_OPR_ADD;
continue;
default:
- (*_bfd_error_handler) (_("Unknown reloc %s"),
- _bfd_vms_etir_name (cmd));
+ _bfd_error_handler (_("Unknown reloc %s"),
+ _bfd_vms_etir_name (cmd));
return FALSE;
}
/* Get section to which the relocation applies. */
if (cur_psect < 0 || cur_psect > (int)PRIV (section_count))
{
- (*_bfd_error_handler) (_("Invalid section index in ETIR"));
+ _bfd_error_handler (_("Invalid section index in ETIR"));
return FALSE;
}
+
sec = PRIV (sections)[cur_psect];
+ if (sec == bfd_abs_section_ptr)
+ {
+ _bfd_error_handler (_("Relocation for non-REL psect"));
+ return FALSE;
+ }
+
vms_sec = vms_section_data (sec);
/* Allocate a reloc entry. */
vms_sec->reloc_max = 64;
sec->relocation = bfd_zmalloc
(vms_sec->reloc_max * sizeof (arelent));
- }
+ }
else
{
vms_sec->reloc_max *= 2;
}
if (sym == NULL)
{
- (*_bfd_error_handler) (_("Unknown symbol in command %s"),
- _bfd_vms_etir_name (cmd));
+ _bfd_error_handler (_("Unknown symbol in command %s"),
+ _bfd_vms_etir_name (cmd));
reloc->sym_ptr_ptr = NULL;
}
else
*relptr = (arelent *) NULL;
return section->reloc_count;
}
+
+/* Install a new set of internal relocs. */
+
+#define alpha_vms_set_reloc _bfd_generic_set_reloc
+
\f
/* This is just copied from ecoff-alpha, needs to be fixed probably. */
case BFD_RELOC_ALPHA_LDA: alpha_type = ALPHA_R_LDA; break;
case BFD_RELOC_ALPHA_BOH: alpha_type = ALPHA_R_BOH; break;
default:
- (*_bfd_error_handler) ("reloc (%d) is *UNKNOWN*", code);
+ _bfd_error_handler (_("reloc (%d) is *UNKNOWN*"), code);
return NULL;
}
vms_debug2 ((2, "reloc is %s\n", alpha_howto_table[alpha_type].name));
subtype = (unsigned)bfd_getl16 (emh->subtyp);
+ /* xgettext:c-format */
fprintf (file, _(" EMH %u (len=%u): "), subtype, rec_len);
switch (subtype)
type = (unsigned)bfd_getl16 (e->gsdtyp);
len = (unsigned)bfd_getl16 (e->gsdsiz);
+ /* xgettext:c-format */
fprintf (file, _(" EGSD entry %2u (type: %u, len: %u): "),
n, type, len);
n++;
static void
evax_bfd_print_etir_stc_ir (FILE *file, const unsigned char *buf, int is_ps)
{
+ /* xgettext:c-format */
fprintf (file, _(" linkage index: %u, replacement insn: 0x%08x\n"),
(unsigned)bfd_getl32 (buf),
(unsigned)bfd_getl32 (buf + 16));
+ /* xgettext:c-format */
fprintf (file, _(" psect idx 1: %u, offset 1: 0x%08x %08x\n"),
(unsigned)bfd_getl32 (buf + 4),
(unsigned)bfd_getl32 (buf + 12),
(unsigned)bfd_getl32 (buf + 8));
+ /* xgettext:c-format */
fprintf (file, _(" psect idx 2: %u, offset 2: 0x%08x %08x\n"),
(unsigned)bfd_getl32 (buf + 20),
(unsigned)bfd_getl32 (buf + 28),
(unsigned)bfd_getl32 (buf + 24));
if (is_ps)
+ /* xgettext:c-format */
fprintf (file, _(" psect idx 3: %u, offset 3: 0x%08x %08x\n"),
(unsigned)bfd_getl32 (buf + 32),
(unsigned)bfd_getl32 (buf + 40),
unsigned char *rec, unsigned int rec_len)
{
unsigned int off = sizeof (struct vms_egsd);
- unsigned int sec_len;
+ unsigned int sec_len = 0;
+ /* xgettext:c-format */
fprintf (file, _(" %s (len=%u+%u):\n"), name,
(unsigned)(rec_len - sizeof (struct vms_eobjrec)),
(unsigned)sizeof (struct vms_eobjrec));
size = bfd_getl16 (etir->size);
buf = rec + off + sizeof (struct vms_etir);
+ /* xgettext:c-format */
fprintf (file, _(" (type: %3u, size: 4+%3u): "), type, size - 4);
switch (type)
{
break;
case ETIR__C_STA_PQ:
fprintf (file, _("STA_PQ (stack psect base + offset)\n"));
+ /* xgettext:c-format */
fprintf (file, _(" psect: %u, offset: 0x%08x %08x\n"),
(unsigned)bfd_getl32 (buf + 0),
(unsigned)bfd_getl32 (buf + 8),
case ETIR__C_STC_LP_PSB:
fprintf (file,
_("STC_LP_PSB (store cond linkage pair + signature)\n"));
+ /* xgettext:c-format */
fprintf (file, _(" linkage index: %u, procedure: %.*s\n"),
(unsigned)bfd_getl32 (buf), buf[4], buf + 5);
buf += 4 + 1 + buf[4];
break;
case ETIR__C_STC_GBL:
fprintf (file, _("STC_GBL (store cond global)\n"));
+ /* xgettext:c-format */
fprintf (file, _(" linkage index: %u, global: %.*s\n"),
(unsigned)bfd_getl32 (buf), buf[4], buf + 5);
break;
case ETIR__C_STC_GCA:
fprintf (file, _("STC_GCA (store cond code address)\n"));
+ /* xgettext:c-format */
fprintf (file, _(" linkage index: %u, procedure name: %.*s\n"),
(unsigned)bfd_getl32 (buf), buf[4], buf + 5);
break;
case ETIR__C_STC_PS:
fprintf (file, _("STC_PS (store cond psect + offset)\n"));
fprintf (file,
+ /* xgettext:c-format */
_(" linkage index: %u, psect: %u, offset: 0x%08x %08x\n"),
(unsigned)bfd_getl32 (buf),
(unsigned)bfd_getl32 (buf + 4),
break;
base = bfd_getl32 (rel + 4);
+ /* xgettext:c-format */
fprintf (file, _(" bitcount: %u, base addr: 0x%08x\n"),
count, base);
val = bfd_getl32 (rel);
rel += 4;
+ /* xgettext:c-format */
fprintf (file, _(" bitmap: 0x%08x (count: %u):\n"), val, count);
for (k = 0; k < 32; k++)
count = bfd_getl32 (rel + 0);
if (count == 0)
return;
+ /* xgettext:c-format */
fprintf (file, _(" image %u (%u entries)\n"),
(unsigned)bfd_getl32 (rel + 4), count);
rel += 8;
for (j = 0; j < count; j++)
{
+ /* xgettext:c-format */
fprintf (file, _(" offset: 0x%08x, val: 0x%08x\n"),
(unsigned)bfd_getl32 (rel + 0),
(unsigned)bfd_getl32 (rel + 4));
count = bfd_getl32 (rel + 0);
if (count == 0)
break;
+ /* xgettext:c-format */
fprintf (file, _(" image %u (%u entries), offsets:\n"),
(unsigned)bfd_getl32 (rel + 4), count);
rel += 8;
}
else
{
+ /* xgettext:c-format */
fprintf (file, _("class: %u, dtype: %u, length: %u, pointer: 0x%08x\n"),
bclass, dtype, len, pointer);
switch (bclass)
evax_bfd_get_dsc_name (dsc->dtype));
evax_bfd_print_indent (indent + 1, file);
fprintf (file,
+ /* xgettext:c-format */
_("dimct: %u, aflags: 0x%02x, digits: %u, scale: %u\n"),
dsc->dimct, dsc->aflags, dsc->digits, dsc->scale);
evax_bfd_print_indent (indent + 1, file);
fprintf (file,
+ /* xgettext:c-format */
_("arsize: %u, a0: 0x%08x\n"),
(unsigned)bfd_getl32 (dsc->arsize),
(unsigned)bfd_getl32 (dsc->a0));
for (i = 0; i < dsc->dimct; i++)
{
evax_bfd_print_indent (indent + 2, file);
- fprintf (file, _("[%u]: %u\n"), i + 1,
+ fprintf (file, "[%u]: %u\n", i + 1,
(unsigned)bfd_getl32 (b));
b += 4;
}
for (i = 0; i < dsc->dimct; i++)
{
evax_bfd_print_indent (indent + 2, file);
+ /* xgettext:c-format */
fprintf (file, _("[%u]: Lower: %u, upper: %u\n"), i + 1,
(unsigned)bfd_getl32 (b + 0),
(unsigned)bfd_getl32 (b + 4));
evax_bfd_get_dsc_name (ubs->dtype));
evax_bfd_print_indent (indent + 1, file);
fprintf (file,
+ /* xgettext:c-format */
_("base: %u, pos: %u\n"),
(unsigned)bfd_getl32 (ubs->base),
(unsigned)bfd_getl32 (ubs->pos));
unsigned int len = 5;
evax_bfd_print_indent (indent, file);
+ /* xgettext:c-format */
fprintf (file, _("vflags: 0x%02x, value: 0x%08x "), vflags, value);
buf += 5;
fprintf (file, _("(at bit offset %u)\n"), value);
break;
default:
+ /* xgettext:c-format */
fprintf (file, _("(reg: %u, disp: %u, indir: %u, kind: "),
(vflags & DST__K_REGNUM_MASK) >> DST__K_REGNUM_SHIFT,
vflags & DST__K_DISP ? 1 : 0,
unsigned int len = (unsigned)bfd_getl16 (buf);
evax_bfd_print_indent (indent, file);
- fprintf (file, ("len: %2u, kind: %2u "), len, kind);
+ /* xgettext:c-format */
+ fprintf (file, _("len: %2u, kind: %2u "), len, kind);
buf += 3;
switch (kind)
{
case DST__K_TS_ATOM:
- fprintf (file, ("atomic, type=0x%02x %s\n"),
+ /* xgettext:c-format */
+ fprintf (file, _("atomic, type=0x%02x %s\n"),
buf[0], evax_bfd_get_dsc_name (buf[0]));
break;
case DST__K_TS_IND:
- fprintf (file, ("indirect, defined at 0x%08x\n"),
+ fprintf (file, _("indirect, defined at 0x%08x\n"),
(unsigned)bfd_getl32 (buf));
break;
case DST__K_TS_TPTR:
- fprintf (file, ("typed pointer\n"));
+ fprintf (file, _("typed pointer\n"));
evax_bfd_print_typspec (buf, indent + 1, file);
break;
case DST__K_TS_PTR:
- fprintf (file, ("pointer\n"));
+ fprintf (file, _("pointer\n"));
break;
case DST__K_TS_ARRAY:
{
unsigned int vec_len;
unsigned int i;
- fprintf (file, ("array, dim: %u, bitmap: "), buf[0]);
+ fprintf (file, _("array, dim: %u, bitmap: "), buf[0]);
vec_len = (buf[0] + 1 + 7) / 8;
for (i = 0; i < vec_len; i++)
fprintf (file, " %02x", buf[i + 1]);
fputc ('\n', file);
vs = buf + 1 + vec_len;
evax_bfd_print_indent (indent, file);
- fprintf (file, ("array descriptor:\n"));
+ fprintf (file, _("array descriptor:\n"));
vs += evax_bfd_print_valspec (vs, indent + 1, file);
for (i = 0; i < buf[0] + 1U; i++)
if (buf[1 + i / 8] & (1 << (i % 8)))
{
evax_bfd_print_indent (indent, file);
if (i == 0)
- fprintf (file, ("type spec for element:\n"));
+ fprintf (file, _("type spec for element:\n"));
else
- fprintf (file, ("type spec for subscript %u:\n"), i);
+ fprintf (file, _("type spec for subscript %u:\n"), i);
evax_bfd_print_typspec (vs, indent + 1, file);
vs += bfd_getl16 (vs);
}
}
break;
default:
- fprintf (file, ("*unhandled*\n"));
+ fprintf (file, _("*unhandled*\n"));
}
}
}
len = bfd_getl16 (dsth.length);
type = bfd_getl16 (dsth.type);
+ /* xgettext:c-format */
fprintf (file, _(" type: %3u, len: %3u (at 0x%08x): "),
type, len, off);
if (len == 0)
const char *name = (const char *)buf + sizeof (*dst);
fprintf (file, _("modbeg\n"));
+ /* xgettext:c-format */
fprintf (file, _(" flags: %d, language: %u, "
"major: %u, minor: %u\n"),
dst->flags,
const char *name = (const char *)buf + sizeof (*dst);
fputs (_("rtnbeg\n"), file);
+ /* xgettext:c-format */
fprintf (file, _(" flags: %u, address: 0x%08x, "
"pd-address: 0x%08x\n"),
dst->flags,
{
struct vms_dst_epilog *dst = (void *)buf;
+ /* xgettext:c-format */
fprintf (file, _("epilog: flags: %u, count: %u\n"),
dst->flags, (unsigned)bfd_getl32 (dst->count));
}
struct vms_dst_blkbeg *dst = (void *)buf;
const char *name = (const char *)buf + sizeof (*dst);
+ /* xgettext:c-format */
fprintf (file, _("blkbeg: address: 0x%08x, name: %.*s\n"),
(unsigned)bfd_getl32 (dst->address),
name[0], name + 1);
fprintf (file, _("recbeg: name: %.*s\n"), name[0], name + 1);
evax_bfd_print_valspec (buf, 4, file);
- fprintf (file, (" len: %u bits\n"),
+ fprintf (file, _(" len: %u bits\n"),
(unsigned)bfd_getl32 (name + 1 + name[0]));
}
break;
fprintf (file, _("recend\n"));
break;
case DST__K_ENUMBEG:
+ /* xgettext:c-format */
fprintf (file, _("enumbeg, len: %u, name: %.*s\n"),
buf[0], buf[1], buf + 2);
break;
case DST__K_LABEL:
{
struct vms_dst_label *lab = (void *)buf;
- fprintf (file, ("label, name: %.*s\n"),
+ fprintf (file, _("label, name: %.*s\n"),
lab->name[0], lab->name + 1);
- fprintf (file, (" address: 0x%08x\n"),
+ fprintf (file, _(" address: 0x%08x\n"),
(unsigned)bfd_getl32 (lab->value));
}
break;
fprintf (file, _("discontiguous range (nbr: %u)\n"), cnt);
for (i = 0; i < cnt; i++, rng += 8)
+ /* xgettext:c-format */
fprintf (file, _(" address: 0x%08x, size: %u\n"),
(unsigned)bfd_getl32 (rng),
(unsigned)bfd_getl32 (rng + 4));
fprintf (file, _("delta pc +%-4d"), -cmd);
line++; /* FIXME: curr increment. */
pc += -cmd;
+ /* xgettext:c-format */
fprintf (file, _(" pc: 0x%08x line: %5u\n"),
pc, line);
cmdlen = 1;
struct vms_dst_src_decl_src *src = (void *)(buf + 1);
const char *name;
+ /* xgettext:c-format */
fprintf (file, _(" declfile: len: %u, flags: %u, "
"fileid: %u\n"),
src->length, src->flags,
(unsigned)bfd_getl16 (src->fileid));
+ /* xgettext:c-format */
fprintf (file, _(" rms: cdt: 0x%08x %08x, "
"ebk: 0x%08x, ffb: 0x%04x, "
"rfo: %u\n"),
fprintf (file, _("cannot read EIHD\n"));
return;
}
+ /* xgettext:c-format */
fprintf (file, _("EIHD: (size: %u, nbr blocks: %u)\n"),
(unsigned)bfd_getl32 (eihd.size),
(unsigned)bfd_getl32 (eihd.hdrblkcnt));
+ /* xgettext:c-format */
fprintf (file, _(" majorid: %u, minorid: %u\n"),
(unsigned)bfd_getl32 (eihd.majorid),
(unsigned)bfd_getl32 (eihd.minorid));
name = _("unknown");
break;
}
+ /* xgettext:c-format */
fprintf (file, _(" image type: %u (%s)"), val, name);
val = (unsigned)bfd_getl32 (eihd.subtype);
name = _("unknown");
break;
}
+ /* xgettext:c-format */
fprintf (file, _(", subtype: %u (%s)\n"), val, name);
eisd_off = bfd_getl32 (eihd.isdoff);
eiha_off = bfd_getl32 (eihd.activoff);
eihi_off = bfd_getl32 (eihd.imgidoff);
eihs_off = bfd_getl32 (eihd.symdbgoff);
+ /* xgettext:c-format */
fprintf (file, _(" offsets: isd: %u, activ: %u, symdbg: %u, "
"imgid: %u, patch: %u\n"),
eisd_off, eiha_off, eihs_off, eihi_off,
" version array off: %u\n"),
eihvn_off);
fprintf (file,
+ /* xgettext:c-format */
_(" img I/O count: %u, nbr channels: %u, req pri: %08x%08x\n"),
(unsigned)bfd_getl32 (eihd.imgiocnt),
(unsigned)bfd_getl32 (eihd.iochancnt),
if (val & EIHD__M_EXT_BIND_SECT)
fprintf (file, " EXT_BIND_SECT");
fprintf (file, "\n");
+ /* xgettext:c-format */
fprintf (file, _(" ident: 0x%08x, sysver: 0x%08x, "
"match ctrl: %u, symvect_size: %u\n"),
(unsigned)bfd_getl32 (eihd.ident),
{
eihef_off = bfd_getl32 (eihd.ext_fixup_off);
eihnp_off = bfd_getl32 (eihd.noopt_psect_off);
+ /* xgettext:c-format */
fprintf (file, _(", ext fixup offset: %u, no_opt psect off: %u"),
eihef_off, eihnp_off);
}
fputs (_("*unknown* "), file);
break;
}
- fprintf (file, _(": %u.%u\n"),
+ fprintf (file, ": %u.%u\n",
(unsigned)bfd_getl16 (ver.major),
(unsigned)bfd_getl16 (ver.minor));
}
}
fprintf (file, _("Image activation: (size=%u)\n"),
(unsigned)bfd_getl32 (eiha.size));
+ /* xgettext:c-format */
fprintf (file, _(" First address : 0x%08x 0x%08x\n"),
(unsigned)bfd_getl32 (eiha.tfradr1_h),
(unsigned)bfd_getl32 (eiha.tfradr1));
+ /* xgettext:c-format */
fprintf (file, _(" Second address: 0x%08x 0x%08x\n"),
(unsigned)bfd_getl32 (eiha.tfradr2_h),
(unsigned)bfd_getl32 (eiha.tfradr2));
+ /* xgettext:c-format */
fprintf (file, _(" Third address : 0x%08x 0x%08x\n"),
(unsigned)bfd_getl32 (eiha.tfradr3_h),
(unsigned)bfd_getl32 (eiha.tfradr3));
+ /* xgettext:c-format */
fprintf (file, _(" Fourth address: 0x%08x 0x%08x\n"),
(unsigned)bfd_getl32 (eiha.tfradr4_h),
(unsigned)bfd_getl32 (eiha.tfradr4));
+ /* xgettext:c-format */
fprintf (file, _(" Shared image : 0x%08x 0x%08x\n"),
(unsigned)bfd_getl32 (eiha.inishr_h),
(unsigned)bfd_getl32 (eiha.inishr));
fprintf (file, _("cannot read EIHI\n"));
return;
}
+ /* xgettext:c-format */
fprintf (file, _("Image identification: (major: %u, minor: %u)\n"),
(unsigned)bfd_getl32 (eihi.majorid),
(unsigned)bfd_getl32 (eihi.minorid));
fprintf (file, _("cannot read EIHS\n"));
return;
}
+ /* xgettext:c-format */
fprintf (file, _("Image symbol & debug table: (major: %u, minor: %u)\n"),
(unsigned)bfd_getl32 (eihs.majorid),
(unsigned)bfd_getl32 (eihs.minorid));
dst_vbn = bfd_getl32 (eihs.dstvbn);
dst_size = bfd_getl32 (eihs.dstsize);
+ /* xgettext:c-format */
fprintf (file, _(" debug symbol table : vbn: %u, size: %u (0x%x)\n"),
dst_vbn, dst_size, dst_size);
gst_vbn = bfd_getl32 (eihs.gstvbn);
gst_size = bfd_getl32 (eihs.gstsize);
+ /* xgettext:c-format */
fprintf (file, _(" global symbol table: vbn: %u, records: %u\n"),
gst_vbn, gst_size);
dmt_vbn = bfd_getl32 (eihs.dmtvbn);
dmt_size = bfd_getl32 (eihs.dmtsize);
+ /* xgettext:c-format */
fprintf (file, _(" debug module table : vbn: %u, size: %u\n"),
dmt_vbn, dmt_size);
}
/* Next block. */
eisd_off = (eisd_off + VMS_BLOCK_SIZE) & ~(VMS_BLOCK_SIZE - 1);
}
+ /* xgettext:c-format */
fprintf (file, _("Image section descriptor: (major: %u, minor: %u, "
"size: %u, offset: %u)\n"),
(unsigned)bfd_getl32 (eisd.majorid),
len, eisd_off);
if (len == 0)
break;
+ /* xgettext:c-format */
fprintf (file, _(" section: base: 0x%08x%08x size: 0x%08x\n"),
(unsigned)bfd_getl32 (eisd.virt_addr + 4),
(unsigned)bfd_getl32 (eisd.virt_addr + 0),
eiaf_vbn = bfd_getl32 (eisd.vbn);
eiaf_size = bfd_getl32 (eisd.secsize);
}
+ /* xgettext:c-format */
fprintf (file, _(" vbn: %u, pfc: %u, matchctl: %u type: %u ("),
(unsigned)bfd_getl32 (eisd.vbn),
eisd.pfc, eisd.matchctl, eisd.type);
}
fputs (_(")\n"), file);
if (val & EISD__M_GBL)
+ /* xgettext:c-format */
fprintf (file, _(" ident: 0x%08x, name: %.*s\n"),
(unsigned)bfd_getl32 (eisd.ident),
eisd.gblnam[0], eisd.gblnam + 1);
}
count = bfd_getl16 (dmth.psect_count);
fprintf (file,
+ /* xgettext:c-format */
_(" module offset: 0x%08x, size: 0x%08x, (%u psects)\n"),
(unsigned)bfd_getl32 (dmth.modbeg),
(unsigned)bfd_getl32 (dmth.size), count);
fprintf (file, _("cannot read DMT psect\n"));
return;
}
+ /* xgettext:c-format */
fprintf (file, _(" psect start: 0x%08x, length: %u\n"),
(unsigned)bfd_getl32 (dmtp.start),
(unsigned)bfd_getl32 (dmtp.length));
}
eiaf = (struct vms_eiaf *)buf;
fprintf (file,
+ /* xgettext:c-format */
_("Image activator fixup: (major: %u, minor: %u)\n"),
(unsigned)bfd_getl32 (eiaf->majorid),
(unsigned)bfd_getl32 (eiaf->minorid));
+ /* xgettext:c-format */
fprintf (file, _(" iaflink : 0x%08x %08x\n"),
(unsigned)bfd_getl32 (eiaf->iaflink + 0),
(unsigned)bfd_getl32 (eiaf->iaflink + 4));
+ /* xgettext:c-format */
fprintf (file, _(" fixuplnk: 0x%08x %08x\n"),
(unsigned)bfd_getl32 (eiaf->fixuplnk + 0),
(unsigned)bfd_getl32 (eiaf->fixuplnk + 4));
(unsigned)bfd_getl32 (eiaf->flags));
qrelfixoff = bfd_getl32 (eiaf->qrelfixoff);
lrelfixoff = bfd_getl32 (eiaf->lrelfixoff);
+ /* xgettext:c-format */
fprintf (file, _(" qrelfixoff: %5u, lrelfixoff: %5u\n"),
qrelfixoff, lrelfixoff);
qdotadroff = bfd_getl32 (eiaf->qdotadroff);
ldotadroff = bfd_getl32 (eiaf->ldotadroff);
+ /* xgettext:c-format */
fprintf (file, _(" qdotadroff: %5u, ldotadroff: %5u\n"),
qdotadroff, ldotadroff);
codeadroff = bfd_getl32 (eiaf->codeadroff);
lpfixoff = bfd_getl32 (eiaf->lpfixoff);
+ /* xgettext:c-format */
fprintf (file, _(" codeadroff: %5u, lpfixoff : %5u\n"),
codeadroff, lpfixoff);
chgprtoff = bfd_getl32 (eiaf->chgprtoff);
fprintf (file, _(" chgprtoff : %5u\n"), chgprtoff);
shrimgcnt = bfd_getl32 (eiaf->shrimgcnt);
shlstoff = bfd_getl32 (eiaf->shlstoff);
+ /* xgettext:c-format */
fprintf (file, _(" shlstoff : %5u, shrimgcnt : %5u\n"),
shlstoff, shrimgcnt);
+ /* xgettext:c-format */
fprintf (file, _(" shlextra : %5u, permctx : %5u\n"),
(unsigned)bfd_getl32 (eiaf->shlextra),
(unsigned)bfd_getl32 (eiaf->permctx));
for (j = 0; j < shrimgcnt; j++, shl++)
{
fprintf (file,
+ /* xgettext:c-format */
_(" %u: size: %u, flags: 0x%02x, name: %.*s\n"),
j, shl->size, shl->flags,
shl->imgnam[0], shl->imgnam + 1);
}
if (lpfixoff != 0)
{
- fprintf (file, _(" Linkage Pairs Referece Fixups:\n"));
+ fprintf (file, _(" Linkage Pairs Reference Fixups:\n"));
evax_bfd_print_reference_fixups (file, buf + lpfixoff);
}
if (chgprtoff)
{
unsigned int prot = bfd_getl32 (eicp->newprt);
fprintf (file,
+ /* xgettext:c-format */
_(" base: 0x%08x %08x, size: 0x%08x, prot: 0x%08x "),
(unsigned)bfd_getl32 (eicp->baseva + 4),
(unsigned)bfd_getl32 (eicp->baseva + 0),
sl->has_fixups = TRUE;
VEC_APPEND_EL (sl->lp, bfd_vma,
sect->output_section->vma + sect->output_offset + offset);
+ sect->output_section->flags |= SEC_RELOC;
}
+/* Add a code address fixup at address SECT + OFFSET to SHLIB. */
+
static void
alpha_vms_add_fixup_ca (struct bfd_link_info *info, bfd *src, bfd *shlib)
{
sl->has_fixups = TRUE;
VEC_APPEND_EL (sl->ca, bfd_vma,
sect->output_section->vma + sect->output_offset + offset);
+ sect->output_section->flags |= SEC_RELOC;
}
+/* Add a quad word relocation fixup at address SECT + OFFSET to SHLIB. */
+
static void
alpha_vms_add_fixup_qr (struct bfd_link_info *info, bfd *src,
bfd *shlib, bfd_vma vec)
r = VEC_APPEND (sl->qr, struct alpha_vms_vma_ref);
r->vma = sect->output_section->vma + sect->output_offset + offset;
r->ref = vec;
+ sect->output_section->flags |= SEC_RELOC;
}
static void
-alpha_vms_add_lw_fixup (struct bfd_link_info *info ATTRIBUTE_UNUSED,
+alpha_vms_add_fixup_lr (struct bfd_link_info *info ATTRIBUTE_UNUSED,
unsigned int shr ATTRIBUTE_UNUSED,
bfd_vma vec ATTRIBUTE_UNUSED)
{
+ /* Not yet supported. */
abort ();
}
-#if 0
-static void
-alpha_vms_add_qw_fixup (struct bfd_link_info *info ATTRIBUTE_UNUSED,
- unsigned int shr ATTRIBUTE_UNUSED,
- bfd_vma vec ATTRIBUTE_UNUSED)
-{
- abort ();
-}
-#endif
+/* Add relocation. FIXME: Not yet emitted. */
static void
alpha_vms_add_lw_reloc (struct bfd_link_info *info ATTRIBUTE_UNUSED)
h = NULL;
h_root = (struct bfd_link_hash_entry *) h;
- if (_bfd_generic_link_add_one_symbol
- (info, abfd, sym.name, sym.flags, sym.section, sym.value,
- NULL, FALSE, FALSE, &h_root) == FALSE)
+ if (!_bfd_generic_link_add_one_symbol (info, abfd, sym.name, sym.flags,
+ sym.section, sym.value, NULL,
+ FALSE, FALSE, &h_root))
return FALSE;
h = (struct alpha_vms_link_hash_entry *) h_root;
return FALSE;
if (element->archive_pass == -1 || element->archive_pass == pass)
- continue;
+ {
+ /* Next symbol if this archive is wrong or already handled. */
+ continue;
+ }
if (! bfd_check_format (element, bfd_object))
{
/* Unlike the generic linker, we know that this element provides
a definition for an undefined symbol and we know that we want
to include it. We don't need to check anything. */
- if (! (*info->callbacks->add_archive_element) (info, element,
- h->root.string))
- return FALSE;
- if (! alpha_vms_link_add_object_symbols (element, info))
+ if (!(*info->callbacks
+ ->add_archive_element) (info, element, h->root.string, &element))
+ continue;
+ if (!alpha_vms_link_add_object_symbols (element, info))
return FALSE;
orig_element->archive_pass = pass;
unsigned int ca_sz = 0;
unsigned int qr_sz = 0;
unsigned int shrimg_cnt = 0;
+ unsigned int chgprt_num = 0;
+ unsigned int chgprt_sz = 0;
struct vms_eiaf *eiaf;
unsigned int off;
asection *sec;
if (ca_sz + lp_sz + qr_sz == 0)
return TRUE;
+ /* Add an eicp entry for the fixup itself. */
+ chgprt_num = 1;
+ for (sec = info->output_bfd->sections; sec != NULL; sec = sec->next)
+ {
+ /* This isect could be made RO or EXE after relocations are applied. */
+ if ((sec->flags & SEC_RELOC) != 0
+ && (sec->flags & (SEC_CODE | SEC_READONLY)) != 0)
+ chgprt_num++;
+ }
+ chgprt_sz = 4 + chgprt_num * sizeof (struct vms_eicp);
+
/* Allocate section content (round-up size) */
sz = sizeof (struct vms_eiaf) + shrimg_cnt * sizeof (struct vms_shl)
- + ca_sz + lp_sz + qr_sz;
+ + ca_sz + lp_sz + qr_sz + chgprt_sz;
sz = (sz + VMS_BLOCK_SIZE - 1) & ~(VMS_BLOCK_SIZE - 1);
content = bfd_zalloc (info->output_bfd, sz);
if (content == NULL)
bfd_putl32 (0, content + off + 4);
off += 8;
}
+ }
- /* CA fixups. */
+ /* Write the change protection table. */
+ bfd_putl32 (off, eiaf->chgprtoff);
+ bfd_putl32 (chgprt_num, content + off);
+ off += 4;
+
+ for (sec = info->output_bfd->sections; sec != NULL; sec = sec->next)
+ {
+ struct vms_eicp *eicp;
+ unsigned int prot;
+
+ if ((sec->flags & SEC_LINKER_CREATED) != 0 &&
+ strcmp (sec->name, "$FIXUP$") == 0)
+ prot = PRT__C_UREW;
+ else if ((sec->flags & SEC_RELOC) != 0
+ && (sec->flags & (SEC_CODE | SEC_READONLY)) != 0)
+ prot = PRT__C_UR;
+ else
+ continue;
+
+ eicp = (struct vms_eicp *)(content + off);
+ bfd_putl64 (sec->vma - t->base_addr, eicp->baseva);
+ bfd_putl32 ((sec->size + VMS_BLOCK_SIZE - 1) & ~(VMS_BLOCK_SIZE - 1),
+ eicp->size);
+ bfd_putl32 (prot, eicp->newprt);
+ off += sizeof (struct vms_eicp);
}
return TRUE;
}
-/* Called by bfd_link_hash_traverse to fill the symbol table.
+/* Called by bfd_hash_traverse to fill the symbol table.
Return FALSE in case of failure. */
static bfd_boolean
-alpha_vms_link_output_symbol (struct bfd_link_hash_entry *hc, void *infov)
+alpha_vms_link_output_symbol (struct bfd_hash_entry *bh, void *infov)
{
+ struct bfd_link_hash_entry *hc = (struct bfd_link_hash_entry *) bh;
struct bfd_link_info *info = (struct bfd_link_info *)infov;
- struct alpha_vms_link_hash_entry *h = (struct alpha_vms_link_hash_entry *)hc;
+ struct alpha_vms_link_hash_entry *h;
struct vms_symbol_entry *sym;
+ if (hc->type == bfd_link_hash_warning)
+ {
+ hc = hc->u.i.link;
+ if (hc->type == bfd_link_hash_new)
+ return TRUE;
+ }
+ h = (struct alpha_vms_link_hash_entry *) hc;
+
switch (h->root.type)
{
- case bfd_link_hash_new:
case bfd_link_hash_undefined:
+ return TRUE;
+ case bfd_link_hash_new:
+ case bfd_link_hash_warning:
abort ();
case bfd_link_hash_undefweak:
return TRUE;
case bfd_link_hash_common:
break;
case bfd_link_hash_indirect:
- case bfd_link_hash_warning:
return TRUE;
}
asection *dst;
asection *dmt;
+ if (bfd_link_relocatable (info))
+ {
+ /* FIXME: we do not yet support relocatable link. It is not obvious
+ how to do it for debug infos. */
+ (*info->callbacks->einfo)(_("%P: relocatable link is not supported\n"));
+ return FALSE;
+ }
+
bfd_get_outsymbols (abfd) = NULL;
bfd_get_symcount (abfd) = 0;
/* Generate the symbol table. */
BFD_ASSERT (PRIV (syms) == NULL);
if (info->strip != strip_all)
- bfd_link_hash_traverse (info->hash, alpha_vms_link_output_symbol, info);
+ bfd_hash_traverse (&info->hash->table, alpha_vms_link_output_symbol, info);
/* Find the entry point. */
if (bfd_get_start_address (abfd) == 0)
{
bfd *startbfd = NULL;
- for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
+ for (sub = info->input_bfds; sub != NULL; sub = sub->link.next)
{
/* Consider only VMS object files. */
if (sub->xvec != abfd->xvec)
&& !(PRIV2 (sub, eom_data).eom_b_tfrflg & EEOM__M_WKTFR))
{
(*info->callbacks->einfo)
+ /* xgettext:c-format */
(_("%P: multiple entry points: in modules %B and %B\n"),
startbfd, sub);
continue;
PRIV (transfer_address[i++]) = 0;
}
- /* Allocate contents. */
+ /* Allocate contents.
+ Also compute the virtual base address. */
base_addr = (bfd_vma)-1;
last_addr = 0;
for (o = abfd->sections; o != NULL; o = o->next)
if (o->vma + o->size > last_addr)
last_addr = o->vma + o->size;
}
+ /* Clear the RELOC flags. Currently we don't support incremental
+ linking. We use the RELOC flag for computing the eicp entries. */
+ o->flags &= ~SEC_RELOC;
}
/* Create the fixup section. */
dmt = NULL;
/* Read all sections from the inputs. */
- for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
+ for (sub = info->input_bfds; sub != NULL; sub = sub->link.next)
{
if (sub->flags & DYNAMIC)
{
unsigned int off = 0;
/* For each object file (ie for each module). */
- for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
+ for (sub = info->input_bfds; sub != NULL; sub = sub->link.next)
{
asection *sub_dst;
struct vms_dmt_header *dmth = NULL;
return FALSE;
}
- /* Alloc in memory and read ETIRs. */
- BFD_ASSERT (section->contents == NULL);
+ /* If the section is already in memory, just copy it. */
+ if (section->flags & SEC_IN_MEMORY)
+ {
+ BFD_ASSERT (section->contents != NULL);
+ memcpy (buf, section->contents + offset, count);
+ return TRUE;
+ }
+ if (section->size == 0)
+ return TRUE;
+ /* Alloc in memory and read ETIRs. */
for (sec = abfd->sections; sec; sec = sec->next)
{
BFD_ASSERT (sec->contents == NULL);
if (!alpha_vms_read_sections_content (abfd, NULL))
return FALSE;
for (sec = abfd->sections; sec; sec = sec->next)
- if (section->contents)
- section->flags |= SEC_IN_MEMORY;
+ if (sec->contents)
+ sec->flags |= SEC_IN_MEMORY;
memcpy (buf, section->contents + offset, count);
return TRUE;
}
{
/* Last step on VMS is to convert the file to variable record length
format. */
- if (bfd_cache_close (abfd) != TRUE)
+ if (!bfd_cache_close (abfd))
return FALSE;
- if (_bfd_vms_convert_to_var_unix_filename (abfd->filename) != TRUE)
+ if (!_bfd_vms_convert_to_var_unix_filename (abfd->filename))
return FALSE;
}
#endif
{
bfd_size_type amt;
- vms_debug2 ((1, "vms_new_section_hook (%p, [%d]%s)\n",
+ vms_debug2 ((1, "vms_new_section_hook (%p, [%u]%s)\n",
abfd, section->index, section->name));
- bfd_set_section_alignment (abfd, section, 0);
+ if (! bfd_set_section_alignment (abfd, section, 0))
+ return FALSE;
- vms_debug2 ((7, "%d: %s\n", section->index, section->name));
+ vms_debug2 ((7, "%u: %s\n", section->index, section->name));
amt = sizeof (struct vms_section_data_struct);
- section->used_by_bfd = (PTR) bfd_zalloc (abfd, amt);
+ section->used_by_bfd = bfd_zalloc (abfd, amt);
if (section->used_by_bfd == NULL)
return FALSE;
else if (bfd_get_section_flags (abfd, sec) & SEC_ALLOC)
ret->type = 'B';
else
- ret->type = '-';
+ ret->type = '?';
if (ret->type != 'U')
ret->value = symbol->value + symbol->section->vma;
vms_bfd_is_local_label_name (bfd * abfd ATTRIBUTE_UNUSED,
const char *name)
{
- vms_debug2 ((1, "vms_bfd_is_local_label_name (%p, %s)\n", abfd, name));
return name[0] == '$';
}
\f
((bfd_boolean (*) (bfd *, asymbol *)) bfd_false)
#define alpha_vms_print_symbol vms_print_symbol
#define alpha_vms_get_symbol_info vms_get_symbol_info
+#define alpha_vms_get_symbol_version_string \
+ _bfd_nosymbols_get_symbol_version_string
+
#define alpha_vms_read_minisymbols _bfd_generic_read_minisymbols
#define alpha_vms_minisymbol_to_symbol _bfd_generic_minisymbol_to_symbol
#define alpha_vms_get_lineno _bfd_nosymbols_get_lineno
#define alpha_vms_find_inliner_info _bfd_nosymbols_find_inliner_info
#define alpha_vms_bfd_make_debug_symbol _bfd_nosymbols_bfd_make_debug_symbol
-#define alpha_vms_find_nearest_line _bfd_vms_find_nearest_dst_line
+#define alpha_vms_find_nearest_line _bfd_vms_find_nearest_line
+#define alpha_vms_find_line _bfd_nosymbols_find_line
#define alpha_vms_bfd_is_local_label_name vms_bfd_is_local_label_name
/* Generic table. */
#define alpha_vms_bfd_relax_section bfd_generic_relax_section
#define alpha_vms_bfd_gc_sections bfd_generic_gc_sections
+#define alpha_vms_bfd_lookup_section_flags bfd_generic_lookup_section_flags
#define alpha_vms_bfd_merge_sections bfd_generic_merge_sections
#define alpha_vms_bfd_is_group_section bfd_generic_is_group_section
#define alpha_vms_bfd_discard_group bfd_generic_discard_group
_bfd_generic_section_already_linked
#define alpha_vms_bfd_define_common_symbol bfd_generic_define_common_symbol
-#define alpha_vms_bfd_link_hash_table_free _bfd_generic_link_hash_table_free
#define alpha_vms_bfd_link_just_syms _bfd_generic_link_just_syms
#define alpha_vms_bfd_copy_link_hash_symbol_type \
_bfd_generic_copy_link_hash_symbol_type
_bfd_nodynamic_get_dynamic_reloc_upper_bound
#define alpha_vms_canonicalize_dynamic_reloc \
_bfd_nodynamic_canonicalize_dynamic_reloc
+#define alpha_vms_bfd_link_check_relocs _bfd_generic_link_check_relocs
-const bfd_target vms_alpha_vec =
+const bfd_target alpha_vms_vec =
{
"vms-alpha", /* Name. */
bfd_target_evax_flavour,
0, /* symbol_leading_char. */
' ', /* ar_pad_char. */
15, /* ar_max_namelen. */
+ 0, /* match priority. */
bfd_getl64, bfd_getl_signed_64, bfd_putl64,
bfd_getl32, bfd_getl_signed_32, bfd_putl32,
bfd_getl16, bfd_getl_signed_16, bfd_putl16,
NULL,
- (PTR) 0
+ NULL
};