/* vms.c -- BFD back-end for EVAX (openVMS/Alpha) files.
- Copyright (C) 1996-2019 Free Software Foundation, Inc.
+ Copyright (C) 1996-2020 Free Software Foundation, Inc.
Initial version written by Klaus Kaempf (kkaempf@rmi.de)
Major rewrite by Adacore.
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_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 *);
+static bfd_boolean alpha_vms_add_fixup_lp (struct bfd_link_info *,
+ bfd *, bfd *);
+static bfd_boolean alpha_vms_add_fixup_ca (struct bfd_link_info *,
+ bfd *, bfd *);
+static bfd_boolean alpha_vms_add_fixup_qr (struct bfd_link_info *,
+ bfd *, bfd *, bfd_vma);
+static bfd_boolean alpha_vms_add_fixup_lr (struct bfd_link_info *,
+ unsigned int, bfd_vma);
+static bfd_boolean alpha_vms_add_lw_reloc (struct bfd_link_info *);
+static bfd_boolean alpha_vms_add_qw_reloc (struct bfd_link_info *);
struct vector_type
{
/* Be sure there is room for a new element. */
-static void vector_grow1 (struct vector_type *vec, size_t elsz);
+static void *vector_grow1 (struct vector_type *vec, size_t elsz);
/* Allocate room for a new element and return its address. */
#define VEC_APPEND(VEC, TYPE) \
- (vector_grow1 (&VEC, sizeof (TYPE)), &VEC_EL(VEC, TYPE, (VEC).nbr_el++))
-
-/* Append an element. */
-
-#define VEC_APPEND_EL(VEC, TYPE, EL) \
- (*(VEC_APPEND (VEC, TYPE)) = EL)
+ ((TYPE *) vector_grow1 (&VEC, sizeof (TYPE)))
struct alpha_vms_vma_ref
{
vms_debug2 ((4, "EIHD size %d imgtype %d symvva 0x%lx eisd %d eihs %d\n",
size, imgtype, (unsigned long)symvva,
*eisd_offset, *eihs_offset));
+ (void) size;
return TRUE;
}
asection *section;
flagword bfd_flags;
- /* PR 17512: file: 3d9e9fe9.
- 12 is the offset of the eisdsize field from the start of the record (8)
- plus the size of the eisdsize field (4). */
- if (offset >= PRIV (recrd.rec_size) - 12)
+ /* PR 17512: file: 3d9e9fe9. */
+ if (offset > PRIV (recrd.rec_size)
+ || (PRIV (recrd.rec_size) - offset
+ < offsetof (struct vms_eisd, eisdsize) + 4))
return FALSE;
- eisd = (struct vms_eisd *)(PRIV (recrd.rec) + offset);
+ eisd = (struct vms_eisd *) (PRIV (recrd.rec) + offset);
rec_size = bfd_getl32 (eisd->eisdsize);
if (rec_size == 0)
break;
}
/* Make sure that there is enough data present in the record. */
- /* FIXME: Should we use sizeof (struct vms_eisd) rather than just 32 here ? */
- if (rec_size < 32)
+ if (rec_size < offsetof (struct vms_eisd, type) + 1)
return FALSE;
/* Make sure that the record is not too big either. */
- if (offset + rec_size >= PRIV (recrd.rec_size))
+ if (rec_size > PRIV (recrd.rec_size) - offset)
return FALSE;
offset += rec_size;
if (flags & EISD__M_GBL)
{
- if (rec_size < offsetof (struct vms_eisd, gblnam))
+ if (rec_size <= offsetof (struct vms_eisd, gblnam))
return FALSE;
else if (rec_size < sizeof (struct vms_eisd))
name = _bfd_vms_save_counted_string (abfd, eisd->gblnam,
else
name = _bfd_vms_save_counted_string (abfd, eisd->gblnam,
EISD__K_GBLNAMLEN);
- if (name == NULL)
+ if (name == NULL || name[0] == 0)
return FALSE;
bfd_flags |= SEC_COFF_SHARED_LIBRARY;
bfd_flags &= ~(SEC_ALLOC | SEC_LOAD);
if (to_read > PRIV (recrd.buf_size))
{
PRIV (recrd.buf)
- = (unsigned char *) bfd_realloc (PRIV (recrd.buf), to_read);
+ = (unsigned char *) bfd_realloc_or_free (PRIV (recrd.buf), to_read);
if (PRIV (recrd.buf) == NULL)
return 0;
PRIV (recrd.buf_size) = to_read;
else
{
PRIV (max_sym_count) *= 2;
- PRIV (syms) = bfd_realloc
+ PRIV (syms) = bfd_realloc_or_free
(PRIV (syms),
(PRIV (max_sym_count) * sizeof (struct vms_symbol_entry *)));
}
unsigned int gsd_size;
unsigned char *vms_rec;
bfd_vma base_addr;
+ long psindx;
vms_debug2 ((2, "EGSD\n"));
/* PR 21615: Check for size overflow. */
if (PRIV (recrd.rec_size) < gsd_size)
{
- _bfd_error_handler (_("corrupt EGSD record: size (%#x) is larger than remaining space (%#x)"),
- gsd_size, PRIV (recrd.rec_size));
+ _bfd_error_handler (_("corrupt EGSD record type %d: size (%#x) "
+ "is larger than remaining space (%#x)"),
+ gsd_type, gsd_size, PRIV (recrd.rec_size));
bfd_set_error (bfd_error_bad_value);
return FALSE;
}
if (gsd_size < 4)
{
- _bfd_error_handler (_("corrupt EGSD record: size (%#x) is too small"),
- gsd_size);
+ too_small:
+ _bfd_error_handler (_("corrupt EGSD record type %d: size (%#x) "
+ "is too small"),
+ gsd_type, gsd_size);
bfd_set_error (bfd_error_bad_value);
return FALSE;
}
case EGSD__C_PSC:
/* Program section definition. */
{
- struct vms_egps *egps = (struct vms_egps *)vms_rec;
+ struct vms_egps *egps = (struct vms_egps *) vms_rec;
flagword new_flags, vms_flags;
asection *section;
+ if (offsetof (struct vms_egps, flags) + 2 > gsd_size)
+ goto too_small;
vms_flags = bfd_getl16 (egps->flags);
if ((vms_flags & EGPS__V_REL) == 0)
{
char *name;
bfd_vma align_addr;
+ size_t left;
- name = _bfd_vms_save_counted_string (abfd, &egps->namlng,
- gsd_size - 4);
+ if (offsetof (struct vms_egps, namlng) >= gsd_size)
+ goto too_small;
+ left = gsd_size - offsetof (struct vms_egps, namlng);
+ name = _bfd_vms_save_counted_string (abfd, &egps->namlng, left);
+ if (name == NULL || name[0] == 0)
+ return FALSE;
section = bfd_make_section (abfd, name);
if (!section)
struct vms_egsy *egsy = (struct vms_egsy *) vms_rec;
flagword old_flags;
+ if (offsetof (struct vms_egsy, flags) + 2 > gsd_size)
+ goto too_small;
old_flags = bfd_getl16 (egsy->flags);
if (old_flags & EGSY__V_DEF)
nameoff = ESDF__B_NAMLNG;
nameoff = ESRF__B_NAMLNG;
if (nameoff >= gsd_size)
- {
- _bfd_error_handler (_("ECSD__C_SYM record is too small"));
- bfd_set_error (bfd_error_bad_value);
- return FALSE;
- }
+ goto too_small;
entry = add_symbol (abfd, vms_rec + nameoff, gsd_size - nameoff);
if (entry == NULL)
return FALSE;
if (old_flags & EGSY__V_DEF)
{
- struct vms_esdf *esdf = (struct vms_esdf *)vms_rec;
- long psindx;
+ struct vms_esdf *esdf = (struct vms_esdf *) vms_rec;
entry->value = bfd_getl64 (esdf->value);
if (PRIV (sections) == NULL)
/* PR 21813: Check for an out of range index. */
if (psindx < 0 || psindx >= (int) PRIV (section_count))
{
- _bfd_error_handler (_("corrupt EGSD record: its psindx field is too big (%#lx)"),
+ bad_psindx:
+ _bfd_error_handler (_("corrupt EGSD record: its psindx "
+ "field is too big (%#lx)"),
psindx);
bfd_set_error (bfd_error_bad_value);
return FALSE;
entry->code_value = bfd_getl64 (esdf->code_address);
psindx = bfd_getl32 (esdf->ca_psindx);
- /* PR 21813: Check for an out of range index. */
+ /* PR 21813: Check for an out of range index. */
if (psindx < 0 || psindx >= (int) PRIV (section_count))
- {
- _bfd_error_handler (_("corrupt EGSD record: its psindx field is too big (%#lx)"),
- psindx);
- bfd_set_error (bfd_error_bad_value);
- return FALSE;
- }
+ goto bad_psindx;
entry->code_section = PRIV (sections)[psindx];
}
}
old_flags = bfd_getl16 (egst->header.flags);
if (nameoff >= gsd_size)
- {
- _bfd_error_handler (_("ECSD__C_SYMG record is too small"));
- bfd_set_error (bfd_error_bad_value);
- return FALSE;
- }
+ goto too_small;
entry = add_symbol (abfd, &egst->namlng, gsd_size - nameoff);
if (entry == NULL)
return FALSE;
if (old_flags & EGSY__V_REL)
{
- long psindx;
-
if (PRIV (sections) == NULL)
return FALSE;
psindx = bfd_getl32 (egst->psindx);
/* PR 21813: Check for an out of range index. */
if (psindx < 0 || psindx >= (int) PRIV (section_count))
- {
- _bfd_error_handler (_("corrupt EGSD record: its psindx field is too big (%#lx)"),
- psindx);
- bfd_set_error (bfd_error_bad_value);
- return FALSE;
- }
+ goto bad_psindx;
entry->section = PRIV (sections)[psindx];
}
else
/* Push value and section index. */
-static void
+static bfd_boolean
_bfd_vms_push (bfd *abfd, bfd_vma val, unsigned int reloc)
{
vms_debug2 ((4, "<push %08lx (0x%08x) at %d>\n",
{
bfd_set_error (bfd_error_bad_value);
_bfd_error_handler (_("stack overflow (%d) in _bfd_vms_push"), PRIV (stackptr));
- exit (1);
+ return FALSE;
}
+ return TRUE;
}
/* Pop value and section index. */
-static void
+static bfd_boolean
_bfd_vms_pop (bfd *abfd, bfd_vma *val, unsigned int *rel)
{
if (PRIV (stackptr) == 0)
{
bfd_set_error (bfd_error_bad_value);
_bfd_error_handler (_("stack underflow in _bfd_vms_pop"));
- exit (1);
+ return FALSE;
}
PRIV (stackptr)--;
*val = PRIV (stack[PRIV (stackptr)]).value;
*rel = PRIV (stack[PRIV (stackptr)]).reloc;
vms_debug2 ((4, "<pop %08lx (0x%08x)>\n", (unsigned long)*val, *rel));
+ return TRUE;
}
/* Routines to fill sections contents during tir/etir read. */
/* Save current DST location counter under specified index. */
-static void
+static bfd_boolean
dst_define_location (bfd *abfd, unsigned int loc)
{
vms_debug2 ((4, "dst_define_location (%d)\n", (int)loc));
+ if (loc > 1 << 24)
+ {
+ /* 16M entries ought to be plenty. */
+ bfd_set_error (bfd_error_bad_value);
+ _bfd_error_handler (_("dst_define_location %u too large"), loc);
+ return FALSE;
+ }
+
/* Grow the ptr offset table if necessary. */
if (loc + 1 > PRIV (dst_ptr_offsets_count))
{
- PRIV (dst_ptr_offsets) = bfd_realloc (PRIV (dst_ptr_offsets),
- (loc + 1) * sizeof (unsigned int));
+ PRIV (dst_ptr_offsets)
+ = bfd_realloc_or_free (PRIV (dst_ptr_offsets),
+ (loc + 1) * sizeof (unsigned int));
+ if (PRIV (dst_ptr_offsets) == NULL)
+ return FALSE;
PRIV (dst_ptr_offsets_count) = loc + 1;
}
PRIV (dst_ptr_offsets)[loc] = PRIV (image_offset);
+ return TRUE;
}
/* Restore saved DST location counter from specified index. */
-static void
+static bfd_boolean
dst_restore_location (bfd *abfd, unsigned int loc)
{
vms_debug2 ((4, "dst_restore_location (%d)\n", (int)loc));
- PRIV (image_offset) = PRIV (dst_ptr_offsets)[loc];
+ if (loc < PRIV (dst_ptr_offsets_count))
+ {
+ PRIV (image_offset) = PRIV (dst_ptr_offsets)[loc];
+ return TRUE;
+ }
+ return FALSE;
}
/* Retrieve saved DST location counter from specified index. */
-static unsigned int
-dst_retrieve_location (bfd *abfd, unsigned int loc)
+static bfd_boolean
+dst_retrieve_location (bfd *abfd, bfd_vma *loc)
{
- vms_debug2 ((4, "dst_retrieve_location (%d)\n", (int)loc));
+ vms_debug2 ((4, "dst_retrieve_location (%d)\n", (int) *loc));
- return PRIV (dst_ptr_offsets)[loc];
+ if (*loc < PRIV (dst_ptr_offsets_count))
+ {
+ *loc = PRIV (dst_ptr_offsets)[*loc];
+ return TRUE;
+ }
+ return FALSE;
}
/* Write multiple bytes to section image. */
static bfd_boolean
image_write (bfd *abfd, unsigned char *ptr, unsigned int size)
{
+ asection *sec = PRIV (image_section);
+ size_t off = PRIV (image_offset);
+
+ /* Check bounds. */
+ if (off > sec->size
+ || size > sec->size - off)
+ {
+ bfd_set_error (bfd_error_bad_value);
+ return FALSE;
+ }
+
#if VMS_DEBUG
_bfd_vms_debug (8, "image_write from (%p, %d) to (%ld)\n", ptr, size,
- (long)PRIV (image_offset));
- _bfd_hexdump (9, ptr, size, 0);
+ (long) off));
#endif
if (PRIV (image_section)->contents != NULL)
+ memcpy (sec->contents + off, ptr, size);
+ else
{
- asection *sec = PRIV (image_section);
- file_ptr off = PRIV (image_offset);
-
- /* Check bounds. */
- if (off > (file_ptr)sec->size
- || size > (file_ptr)sec->size
- || off + size > (file_ptr)sec->size)
- {
- bfd_set_error (bfd_error_bad_value);
- return FALSE;
- }
-
- memcpy (sec->contents + off, ptr, size);
+ unsigned int i;
+ for (i = 0; i < size; i++)
+ if (ptr[i] != 0)
+ {
+ bfd_set_error (bfd_error_bad_value);
+ return FALSE;
+ }
}
+#if VMS_DEBUG
+ _bfd_hexdump (9, ptr, size, 0);
+#endif
+
PRIV (image_offset) += size;
return TRUE;
}
unsigned char *ptr;
unsigned int length;
unsigned char *maxptr;
- bfd_vma op1;
- bfd_vma op2;
- unsigned int rel1;
- unsigned int rel2;
+ bfd_vma op1 = 0;
+ bfd_vma op2 = 0;
+ unsigned int rel1 = RELC_NONE;
+ unsigned int rel2 = RELC_NONE;
struct alpha_vms_link_hash_entry *h;
PRIV (recrd.rec) += ETIR__C_HEADER_SIZE;
return FALSE;
}
ptr += 4;
+ cmd_length -= 4;
#if VMS_DEBUG
_bfd_vms_debug (4, "etir: %s(%d)\n",
_bfd_vms_etir_name (cmd), cmd);
- _bfd_hexdump (8, ptr, cmd_length - 4, 0);
+ _bfd_hexdump (8, ptr, cmd_length, 0);
#endif
switch (cmd)
stack 32 bit value of symbol (high bits set to 0). */
case ETIR__C_STA_GBL:
- _bfd_vms_get_value (abfd, ptr, maxptr, info, &op1, &h);
- _bfd_vms_push (abfd, op1, alpha_vms_sym_to_ctxt (h));
+ _bfd_vms_get_value (abfd, ptr, ptr + cmd_length, info, &op1, &h);
+ if (!_bfd_vms_push (abfd, op1, alpha_vms_sym_to_ctxt (h)))
+ return FALSE;
break;
/* Stack longword
stack 32 bit value, sign extend to 64 bit. */
case ETIR__C_STA_LW:
- if (ptr + 4 > maxptr)
+ if (cmd_length < 4)
goto corrupt_etir;
- _bfd_vms_push (abfd, bfd_getl32 (ptr), RELC_NONE);
+ if (!_bfd_vms_push (abfd, bfd_getl32 (ptr), RELC_NONE))
+ return FALSE;
break;
/* Stack quadword
stack 64 bit value of symbol. */
case ETIR__C_STA_QW:
- if (ptr + 8 > maxptr)
+ if (cmd_length < 8)
goto corrupt_etir;
- _bfd_vms_push (abfd, bfd_getl64 (ptr), RELC_NONE);
+ if (!_bfd_vms_push (abfd, bfd_getl64 (ptr), RELC_NONE))
+ return FALSE;
break;
/* Stack psect base plus quadword offset
{
int psect;
- if (ptr + 12 > maxptr)
+ if (cmd_length < 12)
goto corrupt_etir;
psect = bfd_getl32 (ptr);
if ((unsigned int) psect >= PRIV (section_count))
return FALSE;
}
op1 = bfd_getl64 (ptr + 4);
- _bfd_vms_push (abfd, op1, psect | RELC_SEC_BASE);
+ if (!_bfd_vms_push (abfd, op1, psect | RELC_SEC_BASE))
+ return FALSE;
}
break;
/* Store byte: pop stack, write byte
arg: -. */
case ETIR__C_STO_B:
- _bfd_vms_pop (abfd, &op1, &rel1);
+ if (!_bfd_vms_pop (abfd, &op1, &rel1))
+ return FALSE;
if (rel1 != RELC_NONE)
goto bad_context;
- image_write_b (abfd, (unsigned int) op1 & 0xff);
+ if (!image_write_b (abfd, (unsigned int) op1 & 0xff))
+ return FALSE;
break;
/* Store word: pop stack, write word
arg: -. */
case ETIR__C_STO_W:
- _bfd_vms_pop (abfd, &op1, &rel1);
+ if (!_bfd_vms_pop (abfd, &op1, &rel1))
+ return FALSE;
if (rel1 != RELC_NONE)
goto bad_context;
- image_write_w (abfd, (unsigned int) op1 & 0xffff);
+ if (!image_write_w (abfd, (unsigned int) op1 & 0xffff))
+ return FALSE;
break;
/* Store longword: pop stack, write longword
arg: -. */
case ETIR__C_STO_LW:
- _bfd_vms_pop (abfd, &op1, &rel1);
+ if (!_bfd_vms_pop (abfd, &op1, &rel1))
+ return FALSE;
if (rel1 & RELC_SEC_BASE)
{
op1 = alpha_vms_fix_sec_rel (abfd, info, rel1, op1);
}
else if (rel1 & RELC_SHR_BASE)
{
- alpha_vms_add_fixup_lr (info, rel1 & RELC_MASK, op1);
+ if (!alpha_vms_add_fixup_lr (info, rel1 & RELC_MASK, op1))
+ return FALSE;
rel1 = RELC_NONE;
}
if (rel1 != RELC_NONE)
{
if (rel1 != RELC_REL)
abort ();
- alpha_vms_add_lw_reloc (info);
+ if (!alpha_vms_add_lw_reloc (info))
+ return FALSE;
}
- image_write_l (abfd, op1);
+ if (!image_write_l (abfd, op1))
+ return FALSE;
break;
/* Store quadword: pop stack, write quadword
arg: -. */
case ETIR__C_STO_QW:
- _bfd_vms_pop (abfd, &op1, &rel1);
+ if (!_bfd_vms_pop (abfd, &op1, &rel1))
+ return FALSE;
if (rel1 & RELC_SEC_BASE)
{
op1 = alpha_vms_fix_sec_rel (abfd, info, rel1, op1);
{
if (rel1 != RELC_REL)
abort ();
- alpha_vms_add_qw_reloc (info);
+ if (!alpha_vms_add_qw_reloc (info))
+ return FALSE;
}
- image_write_q (abfd, op1);
+ if (!image_write_q (abfd, op1))
+ return FALSE;
break;
/* Store immediate repeated: pop stack for repeat count
{
int size;
- if (ptr + 4 > maxptr)
+ if (cmd_length < 4)
goto corrupt_etir;
size = bfd_getl32 (ptr);
- _bfd_vms_pop (abfd, &op1, &rel1);
+ if (size > cmd_length - 4)
+ goto corrupt_etir;
+ if (!_bfd_vms_pop (abfd, &op1, &rel1))
+ return FALSE;
if (rel1 != RELC_NONE)
goto bad_context;
+ if (size == 0)
+ break;
+ op1 &= 0xffffffff;
while (op1-- > 0)
- image_write (abfd, ptr + 4, size);
+ if (!image_write (abfd, ptr + 4, size))
+ return FALSE;
}
break;
/* Store global: write symbol value
arg: cs global symbol name. */
case ETIR__C_STO_GBL:
- _bfd_vms_get_value (abfd, ptr, maxptr, info, &op1, &h);
+ _bfd_vms_get_value (abfd, ptr, ptr + cmd_length, info, &op1, &h);
if (h && h->sym)
{
if (h->sym->typ == EGSD__C_SYMG)
{
- alpha_vms_add_fixup_qr
- (info, abfd, h->sym->owner, h->sym->symbol_vector);
+ if (!alpha_vms_add_fixup_qr (info, abfd, h->sym->owner,
+ h->sym->symbol_vector))
+ return FALSE;
op1 = 0;
}
else
{
op1 = alpha_vms_get_sym_value (h->sym->section,
h->sym->value);
- alpha_vms_add_qw_reloc (info);
+ if (!alpha_vms_add_qw_reloc (info))
+ return FALSE;
}
}
- image_write_q (abfd, op1);
+ if (!image_write_q (abfd, op1))
+ return FALSE;
break;
/* Store code address: write address of entry point
arg: cs global symbol name (procedure). */
case ETIR__C_STO_CA:
- _bfd_vms_get_value (abfd, ptr, maxptr, info, &op1, &h);
+ _bfd_vms_get_value (abfd, ptr, ptr + cmd_length, info, &op1, &h);
if (h && h->sym)
{
if (h->sym->flags & EGSY__V_NORM)
/* That's really a procedure. */
if (h->sym->typ == EGSD__C_SYMG)
{
- alpha_vms_add_fixup_ca (info, abfd, h->sym->owner);
+ if (!alpha_vms_add_fixup_ca (info, abfd, h->sym->owner))
+ return FALSE;
op1 = h->sym->symbol_vector;
}
else
{
op1 = alpha_vms_get_sym_value (h->sym->code_section,
h->sym->code_value);
- alpha_vms_add_qw_reloc (info);
+ if (!alpha_vms_add_qw_reloc (info))
+ return FALSE;
}
}
else
abort ();
}
}
- image_write_q (abfd, op1);
+ if (!image_write_q (abfd, op1))
+ return FALSE;
break;
/* Store offset to psect: pop stack, add low 32 bits to base of psect
arg: none. */
case ETIR__C_STO_OFF:
- _bfd_vms_pop (abfd, &op1, &rel1);
+ if (!_bfd_vms_pop (abfd, &op1, &rel1))
+ return FALSE;
if (!(rel1 & RELC_SEC_BASE))
abort ();
op1 = alpha_vms_fix_sec_rel (abfd, info, rel1, op1);
rel1 = RELC_REL;
- image_write_q (abfd, op1);
+ if (!image_write_q (abfd, op1))
+ return FALSE;
break;
/* Store immediate
{
unsigned int size;
- if (ptr + 4 > maxptr)
+ if (cmd_length < 4)
goto corrupt_etir;
size = bfd_getl32 (ptr);
- image_write (abfd, ptr + 4, size);
+ if (!image_write (abfd, ptr + 4, size))
+ return FALSE;
}
break;
store global longword: store 32bit value of symbol
arg: cs symbol name. */
case ETIR__C_STO_GBL_LW:
- _bfd_vms_get_value (abfd, ptr, maxptr, info, &op1, &h);
+ _bfd_vms_get_value (abfd, ptr, ptr + cmd_length, info, &op1, &h);
#if 0
abort ();
#endif
- image_write_l (abfd, op1);
+ if (!image_write_l (abfd, op1))
+ return FALSE;
break;
case ETIR__C_STO_RB:
da signature. */
case ETIR__C_STC_LP_PSB:
- _bfd_vms_get_value (abfd, ptr + 4, maxptr, info, &op1, &h);
+ if (cmd_length < 4)
+ goto corrupt_etir;
+ _bfd_vms_get_value (abfd, ptr + 4, ptr + cmd_length, info, &op1, &h);
if (h && h->sym)
{
if (h->sym->typ == EGSD__C_SYMG)
{
- alpha_vms_add_fixup_lp (info, abfd, h->sym->owner);
+ if (!alpha_vms_add_fixup_lp (info, abfd, h->sym->owner))
+ return FALSE;
op1 = h->sym->symbol_vector;
op2 = 0;
}
op1 = 0;
op2 = 0;
}
- image_write_q (abfd, op1);
- image_write_q (abfd, op2);
+ if (!image_write_q (abfd, op1)
+ || !image_write_q (abfd, op2))
+ return FALSE;
break;
/* 205 Store-conditional NOP at address of global
/* Det relocation base: pop stack, set image location counter
arg: none. */
case ETIR__C_CTL_SETRB:
- _bfd_vms_pop (abfd, &op1, &rel1);
+ if (!_bfd_vms_pop (abfd, &op1, &rel1))
+ return FALSE;
if (!(rel1 & RELC_SEC_BASE))
abort ();
image_set_ptr (abfd, op1, rel1 & RELC_MASK, info);
/* Augment relocation base: increment image location counter by offset
arg: lw offset value. */
case ETIR__C_CTL_AUGRB:
- if (ptr + 4 > maxptr)
+ if (cmd_length < 4)
goto corrupt_etir;
op1 = bfd_getl32 (ptr);
image_inc_ptr (abfd, op1);
/* Define location: pop index, save location counter under index
arg: none. */
case ETIR__C_CTL_DFLOC:
- _bfd_vms_pop (abfd, &op1, &rel1);
+ if (!_bfd_vms_pop (abfd, &op1, &rel1))
+ return FALSE;
if (rel1 != RELC_NONE)
goto bad_context;
- dst_define_location (abfd, op1);
+ if (!dst_define_location (abfd, op1))
+ return FALSE;
break;
/* Set location: pop index, restore location counter from index
arg: none. */
case ETIR__C_CTL_STLOC:
- _bfd_vms_pop (abfd, &op1, &rel1);
+ if (!_bfd_vms_pop (abfd, &op1, &rel1))
+ return FALSE;
if (rel1 != RELC_NONE)
goto bad_context;
- dst_restore_location (abfd, op1);
+ if (!dst_restore_location (abfd, op1))
+ {
+ bfd_set_error (bfd_error_bad_value);
+ _bfd_error_handler (_("invalid %s"), "ETIR__C_CTL_STLOC");
+ return FALSE;
+ }
break;
/* Stack defined location: pop index, push location counter from index
arg: none. */
case ETIR__C_CTL_STKDL:
- _bfd_vms_pop (abfd, &op1, &rel1);
+ if (!_bfd_vms_pop (abfd, &op1, &rel1))
+ return FALSE;
if (rel1 != RELC_NONE)
goto bad_context;
- _bfd_vms_push (abfd, dst_retrieve_location (abfd, op1), RELC_NONE);
+ if (!dst_retrieve_location (abfd, &op1))
+ {
+ bfd_set_error (bfd_error_bad_value);
+ _bfd_error_handler (_("invalid %s"), "ETIR__C_CTL_STKDL");
+ return FALSE;
+ }
+ if (!_bfd_vms_push (abfd, op1, RELC_NONE))
+ return FALSE;
break;
case ETIR__C_OPR_NOP: /* No-op. */
break;
case ETIR__C_OPR_ADD: /* Add. */
- _bfd_vms_pop (abfd, &op1, &rel1);
- _bfd_vms_pop (abfd, &op2, &rel2);
+ if (!_bfd_vms_pop (abfd, &op1, &rel1)
+ || !_bfd_vms_pop (abfd, &op2, &rel2))
+ return FALSE;
if (rel1 == RELC_NONE && rel2 != RELC_NONE)
rel1 = rel2;
else if (rel1 != RELC_NONE && rel2 != RELC_NONE)
goto bad_context;
- _bfd_vms_push (abfd, op1 + op2, rel1);
+ if (!_bfd_vms_push (abfd, op1 + op2, rel1))
+ return FALSE;
break;
case ETIR__C_OPR_SUB: /* Subtract. */
- _bfd_vms_pop (abfd, &op1, &rel1);
- _bfd_vms_pop (abfd, &op2, &rel2);
+ if (!_bfd_vms_pop (abfd, &op1, &rel1)
+ || !_bfd_vms_pop (abfd, &op2, &rel2))
+ return FALSE;
if (rel1 == RELC_NONE && rel2 != RELC_NONE)
rel1 = rel2;
else if ((rel1 & RELC_SEC_BASE) && (rel2 & RELC_SEC_BASE))
}
else if (rel1 != RELC_NONE && rel2 != RELC_NONE)
goto bad_context;
- _bfd_vms_push (abfd, op2 - op1, rel1);
+ if (!_bfd_vms_push (abfd, op2 - op1, rel1))
+ return FALSE;
break;
case ETIR__C_OPR_MUL: /* Multiply. */
- _bfd_vms_pop (abfd, &op1, &rel1);
- _bfd_vms_pop (abfd, &op2, &rel2);
+ if (!_bfd_vms_pop (abfd, &op1, &rel1)
+ || !_bfd_vms_pop (abfd, &op2, &rel2))
+ return FALSE;
if (rel1 != RELC_NONE || rel2 != RELC_NONE)
goto bad_context;
- _bfd_vms_push (abfd, op1 * op2, RELC_NONE);
+ if (!_bfd_vms_push (abfd, op1 * op2, RELC_NONE))
+ return FALSE;
break;
case ETIR__C_OPR_DIV: /* Divide. */
- _bfd_vms_pop (abfd, &op1, &rel1);
- _bfd_vms_pop (abfd, &op2, &rel2);
+ if (!_bfd_vms_pop (abfd, &op1, &rel1)
+ || !_bfd_vms_pop (abfd, &op2, &rel2))
+ return FALSE;
if (rel1 != RELC_NONE || rel2 != RELC_NONE)
goto bad_context;
- if (op2 == 0)
- _bfd_vms_push (abfd, 0, RELC_NONE);
+ if (op1 == 0)
+ {
+ /* Divide by zero is supposed to give a result of zero,
+ and a non-fatal warning message. */
+ _bfd_error_handler (_("%s divide by zero"), "ETIR__C_OPR_DIV");
+ if (!_bfd_vms_push (abfd, 0, RELC_NONE))
+ return FALSE;
+ }
else
- _bfd_vms_push (abfd, op2 / op1, RELC_NONE);
+ {
+ if (!_bfd_vms_push (abfd, op2 / op1, RELC_NONE))
+ return FALSE;
+ }
break;
case ETIR__C_OPR_AND: /* Logical AND. */
- _bfd_vms_pop (abfd, &op1, &rel1);
- _bfd_vms_pop (abfd, &op2, &rel2);
+ if (!_bfd_vms_pop (abfd, &op1, &rel1)
+ || !_bfd_vms_pop (abfd, &op2, &rel2))
+ return FALSE;
if (rel1 != RELC_NONE || rel2 != RELC_NONE)
goto bad_context;
- _bfd_vms_push (abfd, op1 & op2, RELC_NONE);
+ if (!_bfd_vms_push (abfd, op1 & op2, RELC_NONE))
+ return FALSE;
break;
case ETIR__C_OPR_IOR: /* Logical inclusive OR. */
- _bfd_vms_pop (abfd, &op1, &rel1);
- _bfd_vms_pop (abfd, &op2, &rel2);
+ if (!_bfd_vms_pop (abfd, &op1, &rel1)
+ || !_bfd_vms_pop (abfd, &op2, &rel2))
+ return FALSE;
if (rel1 != RELC_NONE || rel2 != RELC_NONE)
goto bad_context;
- _bfd_vms_push (abfd, op1 | op2, RELC_NONE);
+ if (!_bfd_vms_push (abfd, op1 | op2, RELC_NONE))
+ return FALSE;
break;
case ETIR__C_OPR_EOR: /* Logical exclusive OR. */
- _bfd_vms_pop (abfd, &op1, &rel1);
- _bfd_vms_pop (abfd, &op2, &rel2);
+ if (!_bfd_vms_pop (abfd, &op1, &rel1)
+ || !_bfd_vms_pop (abfd, &op2, &rel2))
+ return FALSE;
if (rel1 != RELC_NONE || rel2 != RELC_NONE)
goto bad_context;
- _bfd_vms_push (abfd, op1 ^ op2, RELC_NONE);
+ if (!_bfd_vms_push (abfd, op1 ^ op2, RELC_NONE))
+ return FALSE;
break;
case ETIR__C_OPR_NEG: /* Negate. */
- _bfd_vms_pop (abfd, &op1, &rel1);
+ if (!_bfd_vms_pop (abfd, &op1, &rel1))
+ return FALSE;
if (rel1 != RELC_NONE)
goto bad_context;
- _bfd_vms_push (abfd, -op1, RELC_NONE);
+ if (!_bfd_vms_push (abfd, -op1, RELC_NONE))
+ return FALSE;
break;
case ETIR__C_OPR_COM: /* Complement. */
- _bfd_vms_pop (abfd, &op1, &rel1);
+ if (!_bfd_vms_pop (abfd, &op1, &rel1))
+ return FALSE;
if (rel1 != RELC_NONE)
goto bad_context;
- _bfd_vms_push (abfd, ~op1, RELC_NONE);
+ if (!_bfd_vms_push (abfd, ~op1, RELC_NONE))
+ return FALSE;
break;
case ETIR__C_OPR_ASH: /* Arithmetic shift. */
- _bfd_vms_pop (abfd, &op1, &rel1);
- _bfd_vms_pop (abfd, &op2, &rel2);
+ if (!_bfd_vms_pop (abfd, &op1, &rel1)
+ || !_bfd_vms_pop (abfd, &op2, &rel2))
+ return FALSE;
if (rel1 != RELC_NONE || rel2 != RELC_NONE)
{
bad_context:
op1 >>= -(int)op2;
else /* Shift left. */
op1 <<= (int)op2;
- _bfd_vms_push (abfd, op1, RELC_NONE); /* FIXME: sym. */
+ if (!_bfd_vms_push (abfd, op1, RELC_NONE)) /* FIXME: sym. */
+ return FALSE;
break;
case ETIR__C_OPR_INSV: /* Insert field. */
break;
case ETIR__C_OPR_SEL: /* Select. */
- _bfd_vms_pop (abfd, &op1, &rel1);
+ if (!_bfd_vms_pop (abfd, &op1, &rel1))
+ return FALSE;
if (op1 & 0x01L)
- _bfd_vms_pop (abfd, &op1, &rel1);
+ {
+ if (!_bfd_vms_pop (abfd, &op1, &rel1))
+ return FALSE;
+ }
else
{
- _bfd_vms_pop (abfd, &op1, &rel1);
- _bfd_vms_pop (abfd, &op2, &rel2);
- _bfd_vms_push (abfd, op1, rel1);
+ if (!_bfd_vms_pop (abfd, &op1, &rel1)
+ || !_bfd_vms_pop (abfd, &op2, &rel2))
+ return FALSE;
+ if (!_bfd_vms_push (abfd, op1, rel1))
+ return FALSE;
}
break;
break;
}
- ptr += cmd_length - 4;
+ ptr += cmd_length;
}
return TRUE;
static bfd_boolean
_bfd_vms_slurp_object_records (bfd * abfd)
{
- bfd_boolean err;
+ bfd_boolean ok;
int type;
do
switch (type)
{
case EOBJ__C_EMH:
- err = _bfd_vms_slurp_ehdr (abfd);
+ ok = _bfd_vms_slurp_ehdr (abfd);
break;
case EOBJ__C_EEOM:
- err = _bfd_vms_slurp_eeom (abfd);
+ ok = _bfd_vms_slurp_eeom (abfd);
break;
case EOBJ__C_EGSD:
- err = _bfd_vms_slurp_egsd (abfd);
+ ok = _bfd_vms_slurp_egsd (abfd);
break;
case EOBJ__C_ETIR:
- err = TRUE; /* _bfd_vms_slurp_etir (abfd); */
+ ok = TRUE; /* _bfd_vms_slurp_etir (abfd); */
break;
case EOBJ__C_EDBG:
- err = _bfd_vms_slurp_edbg (abfd);
+ ok = _bfd_vms_slurp_edbg (abfd);
break;
case EOBJ__C_ETBT:
- err = _bfd_vms_slurp_etbt (abfd);
+ ok = _bfd_vms_slurp_etbt (abfd);
break;
default:
- err = FALSE;
+ ok = FALSE;
}
- if (!err)
+ if (!ok)
{
vms_debug2 ((2, "slurp type %d failed\n", type));
return FALSE;
static bfd_boolean
vms_initialize (bfd * abfd)
{
- bfd_size_type amt;
+ size_t amt;
amt = sizeof (struct vms_private_data_struct);
abfd->tdata.any = bfd_zalloc (abfd, amt);
/* Check the format for a file being read.
Return a (bfd_target *) if it's an object file or zero if not. */
-static const struct bfd_target *
+static bfd_cleanup
alpha_vms_object_p (bfd *abfd)
{
void *tdata_save = abfd->tdata.any;
}
if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET))
- goto err_wrong_format;
+ goto error_ret;
/* The first challenge with VMS is to discover the kind of the file.
2 bytes size repeated) and 12 bytes for images (4 bytes major id,
4 bytes minor id, 4 bytes length). */
test_len = 12;
-
- /* Size the main buffer. */
- buf = (unsigned char *) bfd_malloc (test_len);
+ buf = _bfd_malloc_and_read (abfd, test_len, test_len);
if (buf == NULL)
goto error_ret;
PRIV (recrd.buf) = buf;
PRIV (recrd.buf_size) = test_len;
-
- /* Initialize the record pointer. */
PRIV (recrd.rec) = buf;
- if (bfd_bread (buf, test_len, abfd) != test_len)
- goto err_wrong_format;
-
/* Is it an image? */
if ((bfd_getl32 (buf) == EIHD__K_MAJORID)
&& (bfd_getl32 (buf + 4) == EIHD__K_MINORID))
{
- unsigned int to_read;
- unsigned int read_so_far;
- unsigned int remaining;
unsigned int eisd_offset, eihs_offset;
/* Extract the header size. */
if (PRIV (recrd.rec_size) == 0)
PRIV (recrd.rec_size) = sizeof (struct vms_eihd);
- if (PRIV (recrd.rec_size) > PRIV (recrd.buf_size))
- {
- buf = bfd_realloc_or_free (buf, PRIV (recrd.rec_size));
-
- if (buf == NULL)
- {
- PRIV (recrd.buf) = NULL;
- goto error_ret;
- }
- PRIV (recrd.buf) = buf;
- PRIV (recrd.buf_size) = PRIV (recrd.rec_size);
- }
-
/* PR 21813: Check for a truncated record. */
- if (PRIV (recrd.rec_size < test_len))
- goto error_ret;
- /* Read the remaining record. */
- remaining = PRIV (recrd.rec_size) - test_len;
- to_read = MIN (VMS_BLOCK_SIZE - test_len, remaining);
- read_so_far = test_len;
-
- while (remaining > 0)
- {
- if (bfd_bread (buf + read_so_far, to_read, abfd) != to_read)
- goto err_wrong_format;
+ /* PR 17512: file: 7d7c57c2. */
+ if (PRIV (recrd.rec_size) < sizeof (struct vms_eihd))
+ goto err_wrong_format;
- read_so_far += to_read;
- remaining -= to_read;
+ if (bfd_seek (abfd, (file_ptr) 0, SEEK_SET))
+ goto error_ret;
- to_read = MIN (VMS_BLOCK_SIZE, remaining);
- }
+ free (PRIV (recrd.buf));
+ PRIV (recrd.buf) = NULL;
+ buf = _bfd_malloc_and_read (abfd, PRIV (recrd.rec_size),
+ PRIV (recrd.rec_size));
+ if (buf == NULL)
+ goto error_ret;
- /* Reset the record pointer. */
+ PRIV (recrd.buf) = buf;
+ PRIV (recrd.buf_size) = PRIV (recrd.rec_size);
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))
if (! bfd_default_set_arch_mach (abfd, bfd_arch_alpha, 0))
goto err_wrong_format;
- return abfd->xvec;
+ return alpha_vms_free_private;
err_wrong_format:
bfd_set_error (bfd_error_wrong_format);
return TRUE;
}
-static void
+static void *
vector_grow1 (struct vector_type *vec, size_t elsz)
{
- if (vec->nbr_el + 1 < vec->max_el)
- return;
-
- if (vec->max_el == 0)
+ if (vec->nbr_el >= vec->max_el)
{
- vec->max_el = 16;
- vec->els = bfd_malloc2 (vec->max_el, elsz);
- }
- else
- {
- vec->max_el *= 2;
- vec->els = bfd_realloc2 (vec->els, vec->max_el, elsz);
+ if (vec->max_el == 0)
+ {
+ vec->max_el = 16;
+ vec->els = bfd_malloc (vec->max_el * elsz);
+ }
+ else
+ {
+ size_t amt;
+ if (vec->max_el > -1u / 2)
+ {
+ bfd_set_error (bfd_error_file_too_big);
+ return NULL;
+ }
+ vec->max_el *= 2;
+ if (_bfd_mul_overflow (vec->max_el, elsz, &amt))
+ {
+ bfd_set_error (bfd_error_file_too_big);
+ return NULL;
+ }
+ vec->els = bfd_realloc_or_free (vec->els, amt);
+ }
}
+ if (vec->els == NULL)
+ return NULL;
+ return (char *) vec->els + elsz * vec->nbr_el++;
}
/* Bump ABFD file position to next block. */
/* Parse debug info for a module and internalize it. */
-static void
+static bfd_boolean
parse_module (bfd *abfd, struct module *module, unsigned char *ptr,
int length)
{
{
module->file_table_count *= 2;
module->file_table
- = bfd_realloc (module->file_table,
- module->file_table_count
- * sizeof (struct fileinfo));
+ = bfd_realloc_or_free (module->file_table,
+ module->file_table_count
+ * sizeof (struct fileinfo));
+ if (module->file_table == NULL)
+ return FALSE;
}
module->file_table [fileid].name = filename;
because parsing can be either performed at module creation
or deferred until debug info is consumed. */
SET_MODULE_PARSED (module);
+ return TRUE;
}
/* Build the list of modules for the specified BFD. */
return NULL;
module = new_module (abfd);
- parse_module (abfd, module, PRIV (dst_section)->contents, -1);
+ if (!parse_module (abfd, module, PRIV (dst_section)->contents, -1))
+ return NULL;
list = module;
}
{
unsigned int size = module->size;
unsigned int modbeg = PRIV (dst_section)->filepos + module->modbeg;
- unsigned char *buffer = (unsigned char *) bfd_malloc (module->size);
+ unsigned char *buffer;
if (bfd_seek (abfd, modbeg, SEEK_SET) != 0
- || bfd_bread (buffer, size, abfd) != size)
+ || (buffer = _bfd_malloc_and_read (abfd, size, size)) == NULL)
{
bfd_set_error (bfd_error_no_debug_section);
return FALSE;
}
- parse_module (abfd, module, buffer, size);
+ ret = parse_module (abfd, module, buffer, size);
free (buffer);
+ if (!ret)
+ return ret;
}
/* Find out the function (if any) that contains the address. */
else
{
vms_sec->reloc_max *= 2;
- sec->relocation = bfd_realloc
+ sec->relocation = bfd_realloc_or_free
(sec->relocation, vms_sec->reloc_max * sizeof (arelent));
+ if (sec->relocation == NULL)
+ return FALSE;
}
}
reloc = &sec->relocation[sec->reloc_count];
dst_size -= len;
off += len;
len -= sizeof (dsth);
- buf = bfd_malloc (len);
- if (bfd_bread (buf, len, abfd) != len)
+ buf = _bfd_malloc_and_read (abfd, len, len);
+ if (buf == NULL)
{
fprintf (file, _("cannot read DST symbol\n"));
return;
unsigned int codeadroff;
unsigned int lpfixoff;
unsigned int chgprtoff;
+ file_ptr f_off = (file_ptr) (eiaf_vbn - 1) * VMS_BLOCK_SIZE;
- buf = bfd_malloc (eiaf_size);
-
- if (bfd_seek (abfd, (file_ptr) (eiaf_vbn - 1) * VMS_BLOCK_SIZE, SEEK_SET)
- || bfd_bread (buf, eiaf_size, abfd) != eiaf_size)
+ if (bfd_seek (abfd, f_off, SEEK_SET) != 0
+ || (buf = _bfd_malloc_and_read (abfd, eiaf_size, eiaf_size)) == NULL)
{
fprintf (file, _("cannot read EIHA\n"));
- free (buf);
return;
}
eiaf = (struct vms_eiaf *)buf;
/* Add a linkage pair fixup at address SECT + OFFSET to SHLIB. */
-static void
+static bfd_boolean
alpha_vms_add_fixup_lp (struct bfd_link_info *info, bfd *src, bfd *shlib)
{
struct alpha_vms_shlib_el *sl;
asection *sect = PRIV2 (src, image_section);
file_ptr offset = PRIV2 (src, image_offset);
+ bfd_vma *p;
sl = &VEC_EL (alpha_vms_link_hash (info)->shrlibs,
struct alpha_vms_shlib_el, PRIV2 (shlib, shr_index));
sl->has_fixups = TRUE;
- VEC_APPEND_EL (sl->lp, bfd_vma,
- sect->output_section->vma + sect->output_offset + offset);
+ p = VEC_APPEND (sl->lp, bfd_vma);
+ if (p == NULL)
+ return FALSE;
+ *p = sect->output_section->vma + sect->output_offset + offset;
sect->output_section->flags |= SEC_RELOC;
+ return TRUE;
}
/* Add a code address fixup at address SECT + OFFSET to SHLIB. */
-static void
+static bfd_boolean
alpha_vms_add_fixup_ca (struct bfd_link_info *info, bfd *src, bfd *shlib)
{
struct alpha_vms_shlib_el *sl;
asection *sect = PRIV2 (src, image_section);
file_ptr offset = PRIV2 (src, image_offset);
+ bfd_vma *p;
sl = &VEC_EL (alpha_vms_link_hash (info)->shrlibs,
struct alpha_vms_shlib_el, PRIV2 (shlib, shr_index));
sl->has_fixups = TRUE;
- VEC_APPEND_EL (sl->ca, bfd_vma,
- sect->output_section->vma + sect->output_offset + offset);
+ p = VEC_APPEND (sl->ca, bfd_vma);
+ if (p == NULL)
+ return FALSE;
+ *p = sect->output_section->vma + sect->output_offset + offset;
sect->output_section->flags |= SEC_RELOC;
+ return TRUE;
}
/* Add a quad word relocation fixup at address SECT + OFFSET to SHLIB. */
-static void
+static bfd_boolean
alpha_vms_add_fixup_qr (struct bfd_link_info *info, bfd *src,
bfd *shlib, bfd_vma vec)
{
struct alpha_vms_shlib_el, PRIV2 (shlib, shr_index));
sl->has_fixups = TRUE;
r = VEC_APPEND (sl->qr, struct alpha_vms_vma_ref);
+ if (r == NULL)
+ return FALSE;
r->vma = sect->output_section->vma + sect->output_offset + offset;
r->ref = vec;
sect->output_section->flags |= SEC_RELOC;
+ return TRUE;
}
-static void
+static bfd_boolean
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 ();
+ return FALSE;
}
/* Add relocation. FIXME: Not yet emitted. */
-static void
+static bfd_boolean
alpha_vms_add_lw_reloc (struct bfd_link_info *info ATTRIBUTE_UNUSED)
{
+ return FALSE;
}
-static void
+static bfd_boolean
alpha_vms_add_qw_reloc (struct bfd_link_info *info ATTRIBUTE_UNUSED)
{
+ return FALSE;
}
static struct bfd_hash_entry *
alpha_vms_bfd_link_hash_table_create (bfd *abfd)
{
struct alpha_vms_link_hash_table *ret;
- bfd_size_type amt = sizeof (struct alpha_vms_link_hash_table);
+ size_t amt = sizeof (struct alpha_vms_link_hash_table);
ret = (struct alpha_vms_link_hash_table *) bfd_malloc (amt);
if (ret == NULL)
shlib = VEC_APPEND (alpha_vms_link_hash (info)->shrlibs,
struct alpha_vms_shlib_el);
+ if (shlib == NULL)
+ return FALSE;
shlib->abfd = abfd;
VEC_INIT (shlib->ca);
VEC_INIT (shlib->lp);
static bfd_boolean
vms_new_section_hook (bfd * abfd, asection *section)
{
- bfd_size_type amt;
+ size_t amt;
vms_debug2 ((1, "vms_new_section_hook (%p, [%u]%s)\n",
abfd, section->index, section->name));
projects / deliverable / binutils-gdb.git / blobdiff