/* BFD back-end for VMS archive files.
- Copyright 2010, 2011 Free Software Foundation, Inc.
+ Copyright (C) 2010-2020 Free Software Foundation, Inc.
Written by Tristan Gingold <gingold@adacore.com>, AdaCore.
This file is part of BFD, the Binary File Descriptor library.
#include "libbfd.h"
#include "safe-ctype.h"
#include "bfdver.h"
+#include "libiberty.h"
#include "vms.h"
#include "vms/lbr.h"
#include "vms/dcx.h"
/* Maximum number of entries. */
unsigned int max;
+ /* Do not allocate more that this number of entries. */
+ unsigned int limit;
+
/* If true, the table was reallocated on the heap. If false, it is still
in the BFD's objalloc. */
bfd_boolean realloced;
static bfd_boolean
vms_add_index (struct carsym_mem *cs, char *name,
- unsigned int idx_vbn, unsigned int idx_off)
+ unsigned int idx_vbn, unsigned int idx_off)
{
if (cs->nbr == cs->max)
{
struct carsym *n;
+ size_t amt;
+ if (cs->max > -33u / 2 || cs->max >= cs->limit)
+ {
+ bfd_set_error (bfd_error_file_too_big);
+ return FALSE;
+ }
cs->max = 2 * cs->max + 32;
+ if (cs->max > cs->limit)
+ cs->max = cs->limit;
+ if (_bfd_mul_overflow (cs->max, sizeof (struct carsym), &amt))
+ {
+ bfd_set_error (bfd_error_file_too_big);
+ return FALSE;
+ }
if (!cs->realloced)
- {
- n = bfd_malloc2 (cs->max, sizeof (struct carsym));
- if (n == NULL)
- return FALSE;
- memcpy (n, cs->idx, cs->nbr * sizeof (struct carsym));
- /* And unfortunately we can't free cs->idx. */
- }
+ {
+ n = bfd_malloc (amt);
+ if (n == NULL)
+ return FALSE;
+ memcpy (n, cs->idx, cs->nbr * sizeof (struct carsym));
+ /* And unfortunately we can't free cs->idx. */
+ }
else
- {
- n = bfd_realloc_or_free (cs->idx, cs->nbr * sizeof (struct carsym));
- if (n == NULL)
- return FALSE;
- }
+ {
+ n = bfd_realloc_or_free (cs->idx, amt);
+ if (n == NULL)
+ return FALSE;
+ }
cs->idx = n;
cs->realloced = TRUE;
}
static bfd_boolean
vms_add_indexes_from_list (bfd *abfd, struct carsym_mem *cs, char *name,
- struct vms_rfa *rfa)
+ struct vms_rfa *rfa)
{
struct vms_lns lns;
unsigned int vbn;
{
vbn = bfd_getl32 (rfa->vbn);
if (vbn == 0)
- return TRUE;
+ return TRUE;
/* Read the LHS. */
off = (vbn - 1) * VMS_BLOCK_SIZE + bfd_getl16 (rfa->offset);
if (bfd_seek (abfd, off, SEEK_SET) != 0
- || bfd_bread (&lns, sizeof (lns), abfd) != sizeof (lns))
- return FALSE;
+ || bfd_bread (&lns, sizeof (lns), abfd) != sizeof (lns))
+ return FALSE;
if (!vms_add_index (cs, name,
- bfd_getl32 (lns.modrfa.vbn),
- bfd_getl16 (lns.modrfa.offset)))
- return FALSE;
+ bfd_getl32 (lns.modrfa.vbn),
+ bfd_getl16 (lns.modrfa.offset)))
+ return FALSE;
rfa = &lns.nxtrfa;
}
file_ptr off;
unsigned char *p;
unsigned char *endp;
+ unsigned int n;
/* Read the index block. */
BFD_ASSERT (sizeof (indexdef) == VMS_BLOCK_SIZE);
/* Traverse it. */
p = &indexdef.keys[0];
- endp = p + bfd_getl16 (indexdef.used);
+ n = bfd_getl16 (indexdef.used);
+ if (n > sizeof (indexdef.keys))
+ return FALSE;
+ endp = p + n;
while (p < endp)
{
unsigned int idx_vbn;
/* Extract key length. */
if (bfd_libdata (abfd)->ver == LBR_MAJORID)
- {
- struct vms_idx *ridx = (struct vms_idx *)p;
+ {
+ struct vms_idx *ridx = (struct vms_idx *)p;
- idx_vbn = bfd_getl32 (ridx->rfa.vbn);
- idx_off = bfd_getl16 (ridx->rfa.offset);
+ idx_vbn = bfd_getl32 (ridx->rfa.vbn);
+ idx_off = bfd_getl16 (ridx->rfa.offset);
- keylen = ridx->keylen;
- flags = 0;
- keyname = ridx->keyname;
- }
+ keylen = ridx->keylen;
+ flags = 0;
+ keyname = ridx->keyname;
+ }
else if (bfd_libdata (abfd)->ver == LBR_ELFMAJORID)
- {
- struct vms_elfidx *ridx = (struct vms_elfidx *)p;
+ {
+ struct vms_elfidx *ridx = (struct vms_elfidx *)p;
- idx_vbn = bfd_getl32 (ridx->rfa.vbn);
- idx_off = bfd_getl16 (ridx->rfa.offset);
+ idx_vbn = bfd_getl32 (ridx->rfa.vbn);
+ idx_off = bfd_getl16 (ridx->rfa.offset);
- keylen = bfd_getl16 (ridx->keylen);
- flags = ridx->flags;
- keyname = ridx->keyname;
- }
+ keylen = bfd_getl16 (ridx->keylen);
+ flags = ridx->flags;
+ keyname = ridx->keyname;
+ }
else
- return FALSE;
+ return FALSE;
/* Illegal value. */
if (idx_vbn == 0)
- return FALSE;
+ return FALSE;
/* Point to the next index entry. */
p = keyname + keylen;
+ if (p > endp)
+ return FALSE;
if (idx_off == RFADEF__C_INDEX)
- {
- /* Indirect entry. Recurse. */
- if (!vms_traverse_index (abfd, idx_vbn, cs))
- return FALSE;
- }
+ {
+ /* Indirect entry. Recurse. */
+ if (!vms_traverse_index (abfd, idx_vbn, cs))
+ return FALSE;
+ }
else
- {
- /* Add a new entry. */
- char *name;
-
- if (flags & ELFIDX__SYMESC)
- {
- /* Extended key name. */
- unsigned int noff = 0;
- unsigned int koff;
- unsigned int kvbn;
- struct vms_kbn *kbn;
- unsigned char kblk[VMS_BLOCK_SIZE];
-
- /* Sanity check. */
- if (keylen != sizeof (struct vms_kbn))
- return FALSE;
-
- kbn = (struct vms_kbn *)keyname;
- keylen = bfd_getl16 (kbn->keylen);
-
- name = bfd_alloc (abfd, keylen + 1);
- if (name == NULL)
- return FALSE;
- kvbn = bfd_getl32 (kbn->rfa.vbn);
- koff = bfd_getl16 (kbn->rfa.offset);
-
- /* Read the key, chunk by chunk. */
- do
- {
- unsigned int klen;
-
- if (!vms_read_block (abfd, kvbn, kblk))
- return FALSE;
- kbn = (struct vms_kbn *)(kblk + koff);
- klen = bfd_getl16 (kbn->keylen);
- kvbn = bfd_getl32 (kbn->rfa.vbn);
- koff = bfd_getl16 (kbn->rfa.offset);
-
- memcpy (name + noff, kbn + 1, klen);
- noff += klen;
- }
- while (kvbn != 0);
-
- /* Sanity check. */
- if (noff != keylen)
- return FALSE;
- }
- else
- {
- /* Usual key name. */
- name = bfd_alloc (abfd, keylen + 1);
- if (name == NULL)
- return FALSE;
-
- memcpy (name, keyname, keylen);
- }
- name[keylen] = 0;
-
- if (flags & ELFIDX__LISTRFA)
- {
- struct vms_lhs lhs;
-
- /* Read the LHS. */
- off = (idx_vbn - 1) * VMS_BLOCK_SIZE + idx_off;
- if (bfd_seek (abfd, off, SEEK_SET) != 0
- || bfd_bread (&lhs, sizeof (lhs), abfd) != sizeof (lhs))
- return FALSE;
-
- /* FIXME: this adds extra entries that were not accounted. */
- if (!vms_add_indexes_from_list (abfd, cs, name, &lhs.ng_g_rfa))
- return FALSE;
- if (!vms_add_indexes_from_list (abfd, cs, name, &lhs.ng_wk_rfa))
- return FALSE;
- if (!vms_add_indexes_from_list (abfd, cs, name, &lhs.g_g_rfa))
- return FALSE;
- if (!vms_add_indexes_from_list (abfd, cs, name, &lhs.g_wk_rfa))
- return FALSE;
- }
- else
- {
- if (!vms_add_index (cs, name, idx_vbn, idx_off))
- return FALSE;
- }
- }
+ {
+ /* Add a new entry. */
+ char *name;
+
+ if (flags & ELFIDX__SYMESC)
+ {
+ /* Extended key name. */
+ unsigned int noff = 0;
+ unsigned int koff;
+ unsigned int kvbn;
+ struct vms_kbn *kbn;
+ unsigned char kblk[VMS_BLOCK_SIZE];
+
+ /* Sanity check. */
+ if (keylen != sizeof (struct vms_kbn))
+ return FALSE;
+
+ kbn = (struct vms_kbn *)keyname;
+ keylen = bfd_getl16 (kbn->keylen);
+
+ name = bfd_alloc (abfd, keylen + 1);
+ if (name == NULL)
+ return FALSE;
+ kvbn = bfd_getl32 (kbn->rfa.vbn);
+ koff = bfd_getl16 (kbn->rfa.offset);
+
+ /* Read the key, chunk by chunk. */
+ do
+ {
+ unsigned int klen;
+
+ if (!vms_read_block (abfd, kvbn, kblk))
+ return FALSE;
+ if (koff > sizeof (kblk) - sizeof (struct vms_kbn))
+ return FALSE;
+ kbn = (struct vms_kbn *)(kblk + koff);
+ klen = bfd_getl16 (kbn->keylen);
+ if (klen > sizeof (kblk) - koff)
+ return FALSE;
+ kvbn = bfd_getl32 (kbn->rfa.vbn);
+ koff = bfd_getl16 (kbn->rfa.offset);
+
+ if (noff + klen > keylen)
+ return FALSE;
+ memcpy (name + noff, kbn + 1, klen);
+ noff += klen;
+ }
+ while (kvbn != 0);
+
+ /* Sanity check. */
+ if (noff != keylen)
+ return FALSE;
+ }
+ else
+ {
+ /* Usual key name. */
+ name = bfd_alloc (abfd, keylen + 1);
+ if (name == NULL)
+ return FALSE;
+
+ memcpy (name, keyname, keylen);
+ }
+ name[keylen] = 0;
+
+ if (flags & ELFIDX__LISTRFA)
+ {
+ struct vms_lhs lhs;
+
+ /* Read the LHS. */
+ off = (idx_vbn - 1) * VMS_BLOCK_SIZE + idx_off;
+ if (bfd_seek (abfd, off, SEEK_SET) != 0
+ || bfd_bread (&lhs, sizeof (lhs), abfd) != sizeof (lhs))
+ return FALSE;
+
+ /* These extra entries may cause reallocation of CS. */
+ if (!vms_add_indexes_from_list (abfd, cs, name, &lhs.ng_g_rfa))
+ return FALSE;
+ if (!vms_add_indexes_from_list (abfd, cs, name, &lhs.ng_wk_rfa))
+ return FALSE;
+ if (!vms_add_indexes_from_list (abfd, cs, name, &lhs.g_g_rfa))
+ return FALSE;
+ if (!vms_add_indexes_from_list (abfd, cs, name, &lhs.g_wk_rfa))
+ return FALSE;
+ }
+ else
+ {
+ if (!vms_add_index (cs, name, idx_vbn, idx_off))
+ return FALSE;
+ }
+ }
}
return TRUE;
struct vms_idd idd;
unsigned int flags;
unsigned int vbn;
+ ufile_ptr filesize;
+ size_t amt;
struct carsym *csbuf;
struct carsym_mem csm;
|| !(flags & IDD__FLAGS_VARLENIDX))
return NULL;
- csbuf = bfd_alloc (abfd, *nbrel * sizeof (struct carsym));
- if (csbuf == NULL)
- return NULL;
-
- csm.max = *nbrel;
+ filesize = bfd_get_file_size (abfd);
csm.nbr = 0;
+ csm.max = *nbrel;
+ csm.limit = -1u;
csm.realloced = FALSE;
- csm.idx = csbuf;
+ if (filesize != 0)
+ {
+ /* Put an upper bound based on a file full of single char keys.
+ This is to prevent fuzzed binary silliness. It is easily
+ possible to set up loops over file blocks that add syms
+ without end. */
+ if (filesize / (sizeof (struct vms_rfa) + 2) <= -1u)
+ csm.limit = filesize / (sizeof (struct vms_rfa) + 2);
+ }
+ if (csm.max > csm.limit)
+ csm.max = csm.limit;
+ if (_bfd_mul_overflow (csm.max, sizeof (struct carsym), &amt))
+ return NULL;
+ csm.idx = csbuf = bfd_alloc (abfd, amt);
+ if (csm.idx == NULL)
+ return NULL;
/* Note: if the index is empty, there is no block to traverse. */
vbn = bfd_getl32 (idd.vbn);
if (vbn != 0 && !vms_traverse_index (abfd, vbn, &csm))
{
- if (csm.realloced && csm.idx != NULL)
- free (csm.idx);
+ if (csm.realloced)
+ free (csm.idx);
/* Note: in case of error, we can free what was allocated on the
- BFD's objalloc. */
+ BFD's objalloc. */
bfd_release (abfd, csbuf);
return NULL;
}
if (csm.realloced)
{
/* There are more entries than the first estimate. Allocate on
- the BFD's objalloc. */
+ the BFD's objalloc. */
csbuf = bfd_alloc (abfd, csm.nbr * sizeof (struct carsym));
if (csbuf == NULL)
- return NULL;
+ return NULL;
memcpy (csbuf, csm.idx, csm.nbr * sizeof (struct carsym));
free (csm.idx);
- *nbrel = csm.nbr;
+ csm.idx = csbuf;
}
- return csbuf;
+ *nbrel = csm.nbr;
+ return csm.idx;
}
/* Standard function. */
/* Check sanity (= magic) number. */
sanity = bfd_getl32 (lhd.sanity);
if (!(sanity == LHD_SANEID3
- || sanity == LHD_SANEID6
- || sanity == LHD_SANEID_DCX))
+ || sanity == LHD_SANEID6
+ || sanity == LHD_SANEID_DCX))
{
bfd_set_error (bfd_error_wrong_format);
return NULL;
{
case vms_lib_alpha:
if ((lhd.type != LBR__C_TYP_EOBJ && lhd.type != LBR__C_TYP_ESHSTB)
- || majorid != LBR_MAJORID
- || lhd.nindex != 2)
- {
- bfd_set_error (bfd_error_wrong_format);
- return NULL;
- }
+ || majorid != LBR_MAJORID
+ || lhd.nindex != 2)
+ {
+ bfd_set_error (bfd_error_wrong_format);
+ return NULL;
+ }
break;
case vms_lib_ia64:
if ((lhd.type != LBR__C_TYP_IOBJ && lhd.type != LBR__C_TYP_ISHSTB)
- || majorid != LBR_ELFMAJORID
- || lhd.nindex != 2)
- {
- bfd_set_error (bfd_error_wrong_format);
- return NULL;
- }
+ || majorid != LBR_ELFMAJORID
+ || lhd.nindex != 2)
+ {
+ bfd_set_error (bfd_error_wrong_format);
+ return NULL;
+ }
break;
case vms_lib_txt:
if ((lhd.type != LBR__C_TYP_TXT
- && lhd.type != LBR__C_TYP_MLB
- && lhd.type != LBR__C_TYP_HLP)
- || majorid != LBR_MAJORID
- || lhd.nindex != 1)
- {
- bfd_set_error (bfd_error_wrong_format);
- return NULL;
- }
+ && lhd.type != LBR__C_TYP_MLB
+ && lhd.type != LBR__C_TYP_HLP)
+ || majorid != LBR_MAJORID
+ || lhd.nindex != 1)
+ {
+ bfd_set_error (bfd_error_wrong_format);
+ return NULL;
+ }
break;
default:
abort ();
nbr_ent = tdata->artdata.symdef_count;
tdata->artdata.symdefs = vms_lib_read_index (abfd, 1, &nbr_ent);
if (tdata->artdata.symdefs == NULL)
- goto err;
+ goto err;
/* Only IA64 archives may have more entries in the index that what
- was declared. */
+ was declared. */
if (nbr_ent != tdata->artdata.symdef_count
- && kind != vms_lib_ia64)
- goto err;
+ && kind != vms_lib_ia64)
+ goto err;
tdata->artdata.symdef_count = nbr_ent;
}
tdata->cache = bfd_zalloc (abfd, sizeof (bfd *) * tdata->nbr_modules);
unsigned int i;
if (bfd_seek (abfd, (dcxvbn - 1) * VMS_BLOCK_SIZE, SEEK_SET) != 0
- || bfd_bread (buf_reclen, sizeof (buf_reclen), abfd)
- != sizeof (buf_reclen))
- goto err;
+ || bfd_bread (buf_reclen, sizeof (buf_reclen), abfd)
+ != sizeof (buf_reclen))
+ goto err;
reclen = bfd_getl32 (buf_reclen);
- buf = bfd_malloc (reclen);
+ if (reclen < sizeof (struct vms_dcxmap))
+ goto err;
+ buf = _bfd_malloc_and_read (abfd, reclen, reclen);
if (buf == NULL)
- goto err;
- if (bfd_bread (buf, reclen, abfd) != reclen)
- {
- free (buf);
- goto err;
- }
+ goto err;
map = (struct vms_dcxmap *)buf;
tdata->nbr_dcxsbm = bfd_getl16 (map->nsubs);
sbm_off = bfd_getl16 (map->sub0);
tdata->dcxsbm = (struct dcxsbm_desc *)bfd_alloc
- (abfd, tdata->nbr_dcxsbm * sizeof (struct dcxsbm_desc));
+ (abfd, tdata->nbr_dcxsbm * sizeof (struct dcxsbm_desc));
for (i = 0; i < tdata->nbr_dcxsbm; i++)
- {
- struct vms_dcxsbm *sbm = (struct vms_dcxsbm *) (buf + sbm_off);
- struct dcxsbm_desc *sbmdesc = &tdata->dcxsbm[i];
- unsigned int sbm_len;
- unsigned int sbm_sz;
- unsigned int off;
- unsigned char *data = (unsigned char *)sbm;
- unsigned char *buf1;
- unsigned int l, j;
-
- sbm_sz = bfd_getl16 (sbm->size);
- sbm_off += sbm_sz;
- BFD_ASSERT (sbm_off <= reclen);
-
- sbmdesc->min_char = sbm->min_char;
- BFD_ASSERT (sbmdesc->min_char == 0);
- sbmdesc->max_char = sbm->max_char;
- sbm_len = sbmdesc->max_char - sbmdesc->min_char + 1;
- l = (2 * sbm_len + 7) / 8;
- BFD_ASSERT
- (sbm_sz >= sizeof (struct vms_dcxsbm) + l + 3 * sbm_len
- || (tdata->nbr_dcxsbm == 1
- && sbm_sz >= sizeof (struct vms_dcxsbm) + l + sbm_len));
- sbmdesc->flags = (unsigned char *)bfd_alloc (abfd, l);
- memcpy (sbmdesc->flags, data + bfd_getl16 (sbm->flags), l);
- sbmdesc->nodes = (unsigned char *)bfd_alloc (abfd, 2 * sbm_len);
- memcpy (sbmdesc->nodes, data + bfd_getl16 (sbm->nodes), 2 * sbm_len);
- off = bfd_getl16 (sbm->next);
- if (off != 0)
- {
- /* Read the 'next' array. */
- sbmdesc->next = (unsigned short *)bfd_alloc
- (abfd, sbm_len * sizeof (unsigned short));
- buf1 = data + off;
- for (j = 0; j < sbm_len; j++)
- sbmdesc->next[j] = bfd_getl16 (buf1 + j * 2);
- }
- else
- {
- /* There is no next array if there is only one submap. */
- BFD_ASSERT (tdata->nbr_dcxsbm == 1);
- sbmdesc->next = NULL;
- }
- }
+ {
+ struct vms_dcxsbm *sbm;
+ struct dcxsbm_desc *sbmdesc = &tdata->dcxsbm[i];
+ unsigned int sbm_len;
+ unsigned int sbm_sz;
+ unsigned int off;
+ unsigned char *buf1;
+ unsigned int l, j;
+
+ if (sbm_off > reclen
+ || reclen - sbm_off < sizeof (struct vms_dcxsbm))
+ {
+ err_free_buf:
+ free (buf);
+ goto err;
+ }
+ sbm = (struct vms_dcxsbm *) (buf + sbm_off);
+ sbm_sz = bfd_getl16 (sbm->size);
+ sbm_off += sbm_sz;
+ if (sbm_off > reclen)
+ goto err_free_buf;
+
+ sbmdesc->min_char = sbm->min_char;
+ BFD_ASSERT (sbmdesc->min_char == 0);
+ sbmdesc->max_char = sbm->max_char;
+ sbm_len = sbmdesc->max_char - sbmdesc->min_char + 1;
+ l = (2 * sbm_len + 7) / 8;
+ if (sbm_sz < sizeof (struct vms_dcxsbm) + l + sbm_len
+ || (tdata->nbr_dcxsbm > 1
+ && sbm_sz < sizeof (struct vms_dcxsbm) + l + 3 * sbm_len))
+ goto err_free_buf;
+ sbmdesc->flags = (unsigned char *)bfd_alloc (abfd, l);
+ off = bfd_getl16 (sbm->flags);
+ if (off > sbm_sz
+ || sbm_sz - off < l)
+ goto err_free_buf;
+ memcpy (sbmdesc->flags, (bfd_byte *) sbm + off, l);
+ sbmdesc->nodes = (unsigned char *)bfd_alloc (abfd, 2 * sbm_len);
+ off = bfd_getl16 (sbm->nodes);
+ if (off > sbm_sz
+ || sbm_sz - off < 2 * sbm_len)
+ goto err_free_buf;
+ memcpy (sbmdesc->nodes, (bfd_byte *) sbm + off, 2 * sbm_len);
+ off = bfd_getl16 (sbm->next);
+ if (off != 0)
+ {
+ if (off > sbm_sz
+ || sbm_sz - off < 2 * sbm_len)
+ goto err_free_buf;
+ /* Read the 'next' array. */
+ sbmdesc->next = (unsigned short *) bfd_alloc (abfd, 2 * sbm_len);
+ buf1 = (bfd_byte *) sbm + off;
+ for (j = 0; j < sbm_len; j++)
+ sbmdesc->next[j] = bfd_getl16 (buf1 + j * 2);
+ }
+ else
+ {
+ /* There is no next array if there is only one submap. */
+ BFD_ASSERT (tdata->nbr_dcxsbm == 1);
+ sbmdesc->next = NULL;
+ }
+ }
free (buf);
}
else
err:
bfd_release (abfd, tdata);
- abfd->tdata.any = (void *)tdata_hold;;
+ abfd->tdata.any = (void *)tdata_hold;
return NULL;
}
diff = (char)(name[0] - syms[mid].name[0]);
if (diff == 0)
- diff = strcmp (name, syms[mid].name);
+ diff = strcmp (name, syms[mid].name);
if (diff == 0)
- return mid;
+ return mid;
else if (diff < 0)
- hi = mid - 1;
+ hi = mid - 1;
else
- lo = mid + 1;
+ lo = mid + 1;
}
return BFD_NO_MORE_SYMBOLS;
}
/* Read next block. */
if (bfd_seek (abfd->my_archive, vec->next_block, SEEK_SET) != 0)
- return FALSE;
+ return FALSE;
if (bfd_bread (hdr, sizeof (hdr), abfd->my_archive) != sizeof (hdr))
- return FALSE;
+ return FALSE;
vec->next_block = (bfd_getl32 (hdr + 2) - 1) * VMS_BLOCK_SIZE;
vec->blk_off = sizeof (hdr);
}
/* Be sure the current data block is read. */
if (!vms_lib_read_block (abfd))
- return -1;
+ return -1;
/* Do not read past the data block, do not read more than requested. */
l = DATA__LENGTH - vec->blk_off;
if (l > nbytes)
- l = nbytes;
+ l = nbytes;
if (l == 0)
- return 0;
+ return 0;
if (buf != NULL)
- {
- /* Really read into BUF. */
- if (bfd_bread (buf, l, abfd->my_archive) != l)
- return -1;
- }
+ {
+ /* Really read into BUF. */
+ if (bfd_bread (buf, l, abfd->my_archive) != l)
+ return -1;
+ }
else
- {
- /* Make as if we are reading. */
- if (bfd_seek (abfd->my_archive, l, SEEK_CUR) != 0)
- return -1;
- }
+ {
+ /* Make as if we are reading. */
+ if (bfd_seek (abfd->my_archive, l, SEEK_CUR) != 0)
+ return -1;
+ }
if (buf != NULL)
- buf += l;
+ buf += l;
vec->blk_off += l;
nbytes -= l;
res += l;
unsigned char b = vec->dcx_buf[i];
for (; j < 8; j++)
- {
- if (b & (1 << j))
- offset++;
- if (!(sbm->flags[offset >> 3] & (1 << (offset & 7))))
- {
- unsigned int n_offset = sbm->nodes[offset];
- if (n_offset == 0)
- {
- /* End of buffer. Stay where we are. */
- vec->dcx_pos = (i << 3) + j;
- if (b & (1 << j))
- offset--;
- vec->dcx_offset = offset;
- vec->dcx_sbm = sbm;
- return res;
- }
- offset = 2 * n_offset;
- }
- else
- {
- unsigned char v = sbm->nodes[offset];
-
- if (sbm->next != NULL)
- sbm = vec->dcxsbms + sbm->next[v];
- offset = 0;
- res++;
-
- if (buf)
- {
- *buf++ = v;
- nbytes--;
-
- if (nbytes == 0)
- {
- vec->dcx_pos = (i << 3) + j + 1;
- vec->dcx_offset = offset;
- vec->dcx_sbm = sbm;
-
- return res;
- }
- }
- }
- }
+ {
+ if (b & (1 << j))
+ offset++;
+ if (!(sbm->flags[offset >> 3] & (1 << (offset & 7))))
+ {
+ unsigned int n_offset = sbm->nodes[offset];
+ if (n_offset == 0)
+ {
+ /* End of buffer. Stay where we are. */
+ vec->dcx_pos = (i << 3) + j;
+ if (b & (1 << j))
+ offset--;
+ vec->dcx_offset = offset;
+ vec->dcx_sbm = sbm;
+ return res;
+ }
+ offset = 2 * n_offset;
+ }
+ else
+ {
+ unsigned char v = sbm->nodes[offset];
+
+ if (sbm->next != NULL)
+ sbm = vec->dcxsbms + sbm->next[v];
+ offset = 0;
+ res++;
+
+ if (buf)
+ {
+ *buf++ = v;
+ nbytes--;
+
+ if (nbytes == 0)
+ {
+ vec->dcx_pos = (i << 3) + j + 1;
+ vec->dcx_offset = offset;
+ vec->dcx_sbm = sbm;
+
+ return res;
+ }
+ }
+ }
+ }
j = 0;
}
return -1;
while (nbytes > 0)
{
if (vec->rec_rem == 0)
- {
- unsigned char blen[2];
-
- /* Read record length. */
- if (vms_lib_bread_raw (abfd, blen, sizeof (blen)) != sizeof (blen))
- return -1;
- vec->rec_len = bfd_getl16 (blen);
- if (bfd_libdata (abfd->my_archive)->kind == vms_lib_txt)
- {
- /* Discard record size and align byte. */
- vec->rec_pos = 0;
- vec->rec_rem = vec->rec_len;
- }
- else
- {
- /* Prepend record size. */
- vec->rec_pos = REC_POS_LEN0;
- vec->rec_rem = (vec->rec_len + 1) & ~1; /* With align byte. */
- }
- if (vec->rec_len == 3)
- {
- /* Possibly end of file. Check the pattern. */
- if (vms_lib_bread_raw (abfd, vec->pattern, 4) != 4)
- return -1;
- if (!memcmp (vec->pattern, eotdesc + 2, 3))
- {
- /* This is really an EOF. */
- vec->where += res;
- vec->file_len = vec->where;
- return res;
- }
- }
-
- if (vec->dcxsbms != NULL)
- {
- /* This is a compressed member. */
- unsigned int len;
- file_ptr elen;
-
- /* Be sure there is enough room for the expansion. */
- len = (vec->rec_len + 1) & ~1;
- if (len > vec->dcx_max)
- {
- while (len > vec->dcx_max)
- vec->dcx_max *= 2;
- vec->dcx_buf = bfd_alloc (abfd, vec->dcx_max);
- if (vec->dcx_buf == NULL)
- return -1;
- }
-
- /* Read the compressed record. */
- vec->dcx_rlen = len;
- if (vec->rec_len == 3)
- {
- /* Already read. */
- memcpy (vec->dcx_buf, vec->pattern, 3);
- }
- else
- {
- elen = vms_lib_bread_raw (abfd, vec->dcx_buf, len);
- if (elen != len)
- return -1;
- }
-
- /* Dummy expansion to get the expanded length. */
- vec->dcx_offset = 0;
- vec->dcx_sbm = vec->dcxsbms;
- vec->dcx_pos = 0;
- elen = vms_lib_dcx (vec, NULL, 0x10000);
- if (elen < 0)
- return -1;
- vec->rec_len = elen;
- vec->rec_rem = elen;
-
- /* Reset the state. */
- vec->dcx_offset = 0;
- vec->dcx_sbm = vec->dcxsbms;
- vec->dcx_pos = 0;
- }
- }
+ {
+ unsigned char blen[2];
+
+ /* Read record length. */
+ if (vms_lib_bread_raw (abfd, blen, sizeof (blen)) != sizeof (blen))
+ return -1;
+ vec->rec_len = bfd_getl16 (blen);
+ if (bfd_libdata (abfd->my_archive)->kind == vms_lib_txt)
+ {
+ /* Discard record size and align byte. */
+ vec->rec_pos = 0;
+ vec->rec_rem = vec->rec_len;
+ }
+ else
+ {
+ /* Prepend record size. */
+ vec->rec_pos = REC_POS_LEN0;
+ vec->rec_rem = (vec->rec_len + 1) & ~1; /* With align byte. */
+ }
+ if (vec->rec_len == 3)
+ {
+ /* Possibly end of file. Check the pattern. */
+ if (vms_lib_bread_raw (abfd, vec->pattern, 4) != 4)
+ return -1;
+ if (!memcmp (vec->pattern, eotdesc + 2, 3))
+ {
+ /* This is really an EOF. */
+ vec->where += res;
+ vec->file_len = vec->where;
+ return res;
+ }
+ }
+
+ if (vec->dcxsbms != NULL)
+ {
+ /* This is a compressed member. */
+ unsigned int len;
+ file_ptr elen;
+
+ /* Be sure there is enough room for the expansion. */
+ len = (vec->rec_len + 1) & ~1;
+ if (len > vec->dcx_max)
+ {
+ while (len > vec->dcx_max)
+ vec->dcx_max *= 2;
+ vec->dcx_buf = bfd_alloc (abfd, vec->dcx_max);
+ if (vec->dcx_buf == NULL)
+ return -1;
+ }
+
+ /* Read the compressed record. */
+ vec->dcx_rlen = len;
+ if (vec->rec_len == 3)
+ {
+ /* Already read. */
+ memcpy (vec->dcx_buf, vec->pattern, 3);
+ }
+ else
+ {
+ elen = vms_lib_bread_raw (abfd, vec->dcx_buf, len);
+ if (elen != len)
+ return -1;
+ }
+
+ /* Dummy expansion to get the expanded length. */
+ vec->dcx_offset = 0;
+ vec->dcx_sbm = vec->dcxsbms;
+ vec->dcx_pos = 0;
+ elen = vms_lib_dcx (vec, NULL, 0x10000);
+ if (elen < 0)
+ return -1;
+ vec->rec_len = elen;
+ vec->rec_rem = elen;
+
+ /* Reset the state. */
+ vec->dcx_offset = 0;
+ vec->dcx_sbm = vec->dcxsbms;
+ vec->dcx_pos = 0;
+ }
+ }
if (vec->rec_pos < 0)
- {
- unsigned char c;
- switch (vec->rec_pos)
- {
- case REC_POS_LEN0:
- c = vec->rec_len & 0xff;
- vec->rec_pos = REC_POS_LEN1;
- break;
- case REC_POS_LEN1:
- c = (vec->rec_len >> 8) & 0xff;
- vec->rec_pos = 0;
- break;
- case REC_POS_PAD:
- c = 0;
- vec->rec_rem = 0;
- break;
- case REC_POS_NL:
- c = '\n';
- vec->rec_rem = 0;
- break;
- default:
- abort ();
- }
- if (buf != NULL)
- {
- *buf = c;
- buf++;
- }
- nbytes--;
- res++;
- continue;
- }
+ {
+ unsigned char c;
+ switch (vec->rec_pos)
+ {
+ case REC_POS_LEN0:
+ c = vec->rec_len & 0xff;
+ vec->rec_pos = REC_POS_LEN1;
+ break;
+ case REC_POS_LEN1:
+ c = (vec->rec_len >> 8) & 0xff;
+ vec->rec_pos = 0;
+ break;
+ case REC_POS_PAD:
+ c = 0;
+ vec->rec_rem = 0;
+ break;
+ case REC_POS_NL:
+ c = '\n';
+ vec->rec_rem = 0;
+ break;
+ default:
+ abort ();
+ }
+ if (buf != NULL)
+ {
+ *buf = c;
+ buf++;
+ }
+ nbytes--;
+ res++;
+ continue;
+ }
if (nbytes > vec->rec_rem)
- chunk = vec->rec_rem;
+ chunk = vec->rec_rem;
else
- chunk = nbytes;
+ chunk = nbytes;
if (vec->dcxsbms != NULL)
- {
- /* Optimize the stat() case: no need to decompress again as we
- know the length. */
- if (!(buf == NULL && chunk == vec->rec_rem))
- chunk = vms_lib_dcx (vec, buf, chunk);
- }
+ {
+ /* Optimize the stat() case: no need to decompress again as we
+ know the length. */
+ if (!(buf == NULL && chunk == vec->rec_rem))
+ chunk = vms_lib_dcx (vec, buf, chunk);
+ }
else
- {
- if (vec->rec_len == 3)
- {
- if (buf != NULL)
- memcpy (buf, vec->pattern + vec->rec_pos, chunk);
- }
- else
- chunk = vms_lib_bread_raw (abfd, buf, chunk);
- }
+ {
+ if (vec->rec_len == 3)
+ {
+ if (buf != NULL)
+ memcpy (buf, vec->pattern + vec->rec_pos, chunk);
+ }
+ else
+ chunk = vms_lib_bread_raw (abfd, buf, chunk);
+ }
if (chunk < 0)
- return -1;
+ return -1;
res += chunk;
if (buf != NULL)
- buf += chunk;
+ buf += chunk;
nbytes -= chunk;
vec->rec_pos += chunk;
vec->rec_rem -= chunk;
if (vec->rec_rem == 0)
- {
- /* End of record reached. */
- if (bfd_libdata (abfd->my_archive)->kind == vms_lib_txt)
- {
- if ((vec->rec_len & 1) == 1
- && vec->rec_len != 3
- && vec->dcxsbms == NULL)
- {
- /* Eat the pad byte. */
- unsigned char pad;
- if (vms_lib_bread_raw (abfd, &pad, 1) != 1)
- return -1;
- }
- vec->rec_pos = REC_POS_NL;
- vec->rec_rem = 1;
- }
- else
- {
- if ((vec->rec_len & 1) == 1 && vec->dcxsbms != NULL)
- {
- vec->rec_pos = REC_POS_PAD;
- vec->rec_rem = 1;
- }
- }
- }
+ {
+ /* End of record reached. */
+ if (bfd_libdata (abfd->my_archive)->kind == vms_lib_txt)
+ {
+ if ((vec->rec_len & 1) == 1
+ && vec->rec_len != 3
+ && vec->dcxsbms == NULL)
+ {
+ /* Eat the pad byte. */
+ unsigned char pad;
+ if (vms_lib_bread_raw (abfd, &pad, 1) != 1)
+ return -1;
+ }
+ vec->rec_pos = REC_POS_NL;
+ vec->rec_rem = 1;
+ }
+ else
+ {
+ if ((vec->rec_len & 1) == 1 && vec->dcxsbms != NULL)
+ {
+ vec->rec_pos = REC_POS_PAD;
+ vec->rec_rem = 1;
+ }
+ }
+ }
}
vec->where += res;
return res;
vec->next_block = vec->init_next_block;
if (bfd_seek (abfd->my_archive, vec->first_block, SEEK_SET) != 0)
- return -1;
+ return -1;
}
else
abort ();
static int
vms_lib_bstat (struct bfd *abfd ATTRIBUTE_UNUSED,
- struct stat *sb ATTRIBUTE_UNUSED)
+ struct stat *sb ATTRIBUTE_UNUSED)
{
/* Not supported. */
return 0;
static void *
vms_lib_bmmap (struct bfd *abfd ATTRIBUTE_UNUSED,
- void *addr ATTRIBUTE_UNUSED,
- bfd_size_type len ATTRIBUTE_UNUSED,
- int prot ATTRIBUTE_UNUSED,
- int flags ATTRIBUTE_UNUSED,
- file_ptr offset ATTRIBUTE_UNUSED,
- void **map_addr ATTRIBUTE_UNUSED,
- bfd_size_type *map_len ATTRIBUTE_UNUSED)
+ void *addr ATTRIBUTE_UNUSED,
+ bfd_size_type len ATTRIBUTE_UNUSED,
+ int prot ATTRIBUTE_UNUSED,
+ int flags ATTRIBUTE_UNUSED,
+ file_ptr offset ATTRIBUTE_UNUSED,
+ void **map_addr ATTRIBUTE_UNUSED,
+ bfd_size_type *map_len ATTRIBUTE_UNUSED)
{
return (void *) -1;
}
vec->dcx_buf = bfd_alloc (el, vec->dcx_max);
vec->dcx_pos = -1;
if (vec->dcx_buf == NULL)
- return -1;
+ return -1;
}
return TRUE;
}
struct lib_tdata *tdata = bfd_libdata (abfd);
bfd *res;
file_ptr file_off;
- char *name;
+ const char *name;
+ char *newname;
+ size_t namelen;
/* Sanity check. */
if (modidx >= tdata->nbr_modules)
{
res = _bfd_create_empty_archive_element_shell (abfd);
if (res == NULL)
- return NULL;
+ return NULL;
/* Special reader to deal with data blocks. */
if (!vms_lib_bopen (res, file_off))
- return NULL;
+ return NULL;
}
else
{
/* Sanity check. The MHD must be big enough to contain module size. */
if (tdata->mhd_size < offsetof (struct vms_mhd, modsize) + 4)
- return NULL;
+ return NULL;
/* Read the MHD now. */
if (bfd_seek (abfd, file_off, SEEK_SET) != 0)
- return NULL;
+ return NULL;
if (bfd_bread (buf, tdata->mhd_size, abfd) != tdata->mhd_size)
- return NULL;
+ return NULL;
+
+ mhd = (struct vms_mhd *) buf;
+ if (mhd->id != MHD__C_MHDID)
+ return NULL;
res = _bfd_create_empty_archive_element_shell (abfd);
if (res == NULL)
- return NULL;
- arelt = bfd_zalloc (res, sizeof (*arelt));
+ return NULL;
+ arelt = bfd_zmalloc (sizeof (*arelt));
if (arelt == NULL)
- return NULL;
+ {
+ bfd_close (res);
+ return NULL;
+ }
res->arelt_data = arelt;
/* Get info from mhd. */
- mhd = (struct vms_mhd *)buf;
- if (mhd->id != MHD__C_MHDID)
- return NULL;
if (tdata->mhd_size >= offsetof (struct vms_mhd, objstat) + 1)
- res->selective_search = (mhd->objstat & MHD__M_SELSRC) ? 1 : 0;
+ res->selective_search = (mhd->objstat & MHD__M_SELSRC) ? 1 : 0;
res->mtime = vms_rawtime_to_time_t (mhd->datim);
res->mtime_set = TRUE;
arelt->parsed_size = bfd_getl32 (mhd->modsize);
/* No need for a special reader as members are stored linearly.
- Just skip the MHD. */
+ Just skip the MHD. */
res->origin = file_off + tdata->mhd_size;
}
/* Set filename. */
name = tdata->modules[modidx].name;
+ namelen = strlen (name);
+ newname = bfd_malloc (namelen + 4 + 1);
+ if (newname == NULL)
+ {
+ bfd_close (res);
+ return NULL;
+ }
+ strcpy (newname, name);
switch (tdata->type)
{
case LBR__C_TYP_IOBJ:
case LBR__C_TYP_EOBJ:
/* For object archives, append .obj to mimic standard behaviour. */
- {
- size_t namelen = strlen (name);
- char *name1 = bfd_alloc (res, namelen + 4 + 1);
- memcpy (name1, name, namelen);
- strcpy (name1 + namelen, ".obj");
- name = name1;
- }
+ strcpy (newname + namelen, ".obj");
break;
default:
break;
}
- res->filename = name;
+ bfd_set_filename (res, newname);
tdata->cache[modidx] = res;
for (modidx = 0; modidx < tdata->nbr_modules; modidx++)
{
if (tdata->modules[modidx].file_offset == file_off)
- break;
+ break;
}
if (modidx >= tdata->nbr_modules)
return NULL;
if (res == NULL)
{
- (*_bfd_error_handler)(_("could not open shared image '%s' from '%s'"),
- filename, archive->filename);
+ /* xgettext:c-format */
+ _bfd_error_handler(_("could not open shared image '%s' from '%s'"),
+ filename, archive->filename);
bfd_release (archive, filename);
return NULL;
}
bfd *
_bfd_vms_lib_openr_next_archived_file (bfd *archive,
- bfd *last_file)
+ bfd *last_file)
{
unsigned int idx;
bfd *res;
struct vms_lib_iovec *vec = (struct vms_lib_iovec *) abfd->iostream;
if (vec->file_len == (ufile_ptr)-1)
- {
- if (vms_lib_bseek (abfd, 0, SEEK_SET) != 0)
- return -1;
-
- /* Compute length. */
- while (vms_lib_bread (abfd, NULL, 1 << 20) > 0)
- ;
- }
+ {
+ if (vms_lib_bseek (abfd, 0, SEEK_SET) != 0)
+ return -1;
+
+ /* Compute length. */
+ while (vms_lib_bread (abfd, NULL, 1 << 20) > 0)
+ ;
+ }
st->st_size = vec->file_len;
}
else
{
/* 9 is the size of struct vms_elfidx without keyname. */
if (idx->namlen > MAX_KEYLEN)
- return 9 + sizeof (struct vms_kbn);
+ return 9 + sizeof (struct vms_kbn);
else
- return 9 + idx->namlen;
+ return 9 + idx->namlen;
}
else
{
static bfd_boolean
vms_write_index (bfd *abfd,
- struct lib_index *idx, unsigned int nbr, unsigned int *vbn,
- unsigned int *topvbn, bfd_boolean is_elfidx)
+ struct lib_index *idx, unsigned int nbr, unsigned int *vbn,
+ unsigned int *topvbn, bfd_boolean is_elfidx)
{
/* The index is organized as a tree. This function implements a naive
algorithm to balance the tree: it fills the leaves, and create a new
{
/* No entries. Very easy to handle. */
if (topvbn != NULL)
- *topvbn = 0;
+ *topvbn = 0;
return TRUE;
}
idxlen = get_idxlen (idx, is_elfidx);
if (is_elfidx && idx->namlen > MAX_KEYLEN)
- {
- /* If the key (ie name) is too long, write it in the kbn block. */
- unsigned int kl = idx->namlen;
- unsigned int kl_chunk;
- const char *key = idx->name;
-
- /* Write the key in the kbn, chunk after chunk. */
- do
- {
- if (kbn_sz < sizeof (struct vms_kbn))
- {
- /* Not enough room in the kbn block. */
- if (abfd != NULL)
- {
- /* Write it to the disk (if there is one). */
- if (kbn_vbn != 0)
- {
- if (vms_write_block (abfd, kbn_vbn, kbn_blk) != TRUE)
- return FALSE;
- }
- else
- {
- kbn_blk = bfd_malloc (VMS_BLOCK_SIZE);
- if (kbn_blk == NULL)
- return FALSE;
- }
- *(unsigned short *)kbn_blk = 0;
- }
- /* Allocate a new block for the keys. */
- kbn_vbn = (*vbn)++;
- kbn_sz = VMS_BLOCK_SIZE - 2;
- }
- /* Size of the chunk written to the current key block. */
- if (kl + sizeof (struct vms_kbn) > kbn_sz)
- kl_chunk = kbn_sz - sizeof (struct vms_kbn);
- else
- kl_chunk = kl;
-
- if (kbn_blk != NULL)
- {
- struct vms_kbn *kbn;
-
- kbn = (struct vms_kbn *)(kbn_blk + VMS_BLOCK_SIZE - kbn_sz);
-
- if (key_vbn == 0)
- {
- /* Save the rfa of the first chunk. */
- key_vbn = kbn_vbn;
- key_off = VMS_BLOCK_SIZE - kbn_sz;
- }
-
- bfd_putl16 (kl_chunk, kbn->keylen);
- if (kl_chunk == kl)
- {
- /* No next chunk. */
- bfd_putl32 (0, kbn->rfa.vbn);
- bfd_putl16 (0, kbn->rfa.offset);
- }
- else
- {
- /* Next chunk will be at the start of the next block. */
- bfd_putl32 (*vbn, kbn->rfa.vbn);
- bfd_putl16 (2, kbn->rfa.offset);
- }
- memcpy ((char *)(kbn + 1), key, kl_chunk);
- key += kl_chunk;
- }
- kl -= kl_chunk;
- kl_chunk = (kl_chunk + 1) & ~1; /* Always align. */
- kbn_sz -= kl_chunk + sizeof (struct vms_kbn);
- }
- while (kl > 0);
- }
+ {
+ /* If the key (ie name) is too long, write it in the kbn block. */
+ unsigned int kl = idx->namlen;
+ unsigned int kl_chunk;
+ const char *key = idx->name;
+
+ /* Write the key in the kbn, chunk after chunk. */
+ do
+ {
+ if (kbn_sz < sizeof (struct vms_kbn))
+ {
+ /* Not enough room in the kbn block. */
+ if (abfd != NULL)
+ {
+ /* Write it to the disk (if there is one). */
+ if (kbn_vbn != 0)
+ {
+ if (!vms_write_block (abfd, kbn_vbn, kbn_blk))
+ return FALSE;
+ }
+ else
+ {
+ kbn_blk = bfd_malloc (VMS_BLOCK_SIZE);
+ if (kbn_blk == NULL)
+ return FALSE;
+ }
+ *(unsigned short *)kbn_blk = 0;
+ }
+ /* Allocate a new block for the keys. */
+ kbn_vbn = (*vbn)++;
+ kbn_sz = VMS_BLOCK_SIZE - 2;
+ }
+ /* Size of the chunk written to the current key block. */
+ if (kl + sizeof (struct vms_kbn) > kbn_sz)
+ kl_chunk = kbn_sz - sizeof (struct vms_kbn);
+ else
+ kl_chunk = kl;
+
+ if (kbn_blk != NULL)
+ {
+ struct vms_kbn *kbn;
+
+ kbn = (struct vms_kbn *)(kbn_blk + VMS_BLOCK_SIZE - kbn_sz);
+
+ if (key_vbn == 0)
+ {
+ /* Save the rfa of the first chunk. */
+ key_vbn = kbn_vbn;
+ key_off = VMS_BLOCK_SIZE - kbn_sz;
+ }
+
+ bfd_putl16 (kl_chunk, kbn->keylen);
+ if (kl_chunk == kl)
+ {
+ /* No next chunk. */
+ bfd_putl32 (0, kbn->rfa.vbn);
+ bfd_putl16 (0, kbn->rfa.offset);
+ }
+ else
+ {
+ /* Next chunk will be at the start of the next block. */
+ bfd_putl32 (*vbn, kbn->rfa.vbn);
+ bfd_putl16 (2, kbn->rfa.offset);
+ }
+ memcpy ((char *)(kbn + 1), key, kl_chunk);
+ key += kl_chunk;
+ }
+ kl -= kl_chunk;
+ kl_chunk = (kl_chunk + 1) & ~1; /* Always align. */
+ kbn_sz -= kl_chunk + sizeof (struct vms_kbn);
+ }
+ while (kl > 0);
+ }
/* Check if a block might overflow. In this case we will flush this
- block and all the blocks below it. */
+ block and all the blocks below it. */
for (j = 0; j < level; j++)
- if (blk[j].len + blk[j].lastlen + idxlen > INDEXDEF__BLKSIZ)
+ if (blk[j].len + blk[j].lastlen + idxlen > INDEXDEF__BLKSIZ)
flush = j + 1;
for (j = 0; j < level; j++)
- {
- if (j < flush)
- {
- /* There is not enough room to write the new entry in this
- block or in a parent block. */
-
- if (j + 1 == level)
- {
- BFD_ASSERT (level < MAX_LEVEL);
-
- /* Need to create a parent. */
- if (abfd != NULL)
- {
- rblk[level] = bfd_zmalloc (sizeof (struct vms_indexdef));
- bfd_putl32 (*vbn, rblk[j]->parent);
- }
- blk[level].vbn = (*vbn)++;
- blk[level].len = 0;
- blk[level].lastlen = blk[j].lastlen;
-
- level++;
- }
-
- /* Update parent block: write the last entry from the current
+ {
+ if (j < flush)
+ {
+ /* There is not enough room to write the new entry in this
+ block or in a parent block. */
+
+ if (j + 1 == level)
+ {
+ BFD_ASSERT (level < MAX_LEVEL);
+
+ /* Need to create a parent. */
+ if (abfd != NULL)
+ {
+ rblk[level] = bfd_zmalloc (sizeof (struct vms_indexdef));
+ bfd_putl32 (*vbn, rblk[j]->parent);
+ }
+ blk[level].vbn = (*vbn)++;
+ blk[level].len = 0;
+ blk[level].lastlen = blk[j].lastlen;
+
+ level++;
+ }
+
+ /* Update parent block: write the last entry from the current
block. */
- if (abfd != NULL)
- {
- struct vms_rfa *rfa;
+ if (abfd != NULL)
+ {
+ struct vms_rfa *rfa;
/* Pointer to the last entry in parent block. */
rfa = (struct vms_rfa *)(rblk[j + 1]->keys + blk[j + 1].len);
- /* Copy the whole entry. */
+ /* Copy the whole entry. */
BFD_ASSERT (blk[j + 1].lastlen == blk[j].lastlen);
- memcpy (rfa, rblk[j]->keys + blk[j].len, blk[j].lastlen);
- /* Fix the entry (which in always the first field of an
+ memcpy (rfa, rblk[j]->keys + blk[j].len, blk[j].lastlen);
+ /* Fix the entry (which in always the first field of an
entry. */
- bfd_putl32 (blk[j].vbn, rfa->vbn);
- bfd_putl16 (RFADEF__C_INDEX, rfa->offset);
- }
-
- if (j + 1 == flush)
- {
- /* And allocate it. Do it only on the block that won't be
- flushed (so that the parent of the parent can be
- updated too). */
- blk[j + 1].len += blk[j + 1].lastlen;
- blk[j + 1].lastlen = 0;
- }
-
- /* Write this block on the disk. */
- if (abfd != NULL)
- {
- bfd_putl16 (blk[j].len + blk[j].lastlen, rblk[j]->used);
- if (vms_write_block (abfd, blk[j].vbn, rblk[j]) != TRUE)
- return FALSE;
- }
-
- /* Reset this block. */
- blk[j].len = 0;
- blk[j].lastlen = 0;
- blk[j].vbn = (*vbn)++;
- }
-
- /* Append it to the block. */
- if (j == 0)
- {
+ bfd_putl32 (blk[j].vbn, rfa->vbn);
+ bfd_putl16 (RFADEF__C_INDEX, rfa->offset);
+ }
+
+ if (j + 1 == flush)
+ {
+ /* And allocate it. Do it only on the block that won't be
+ flushed (so that the parent of the parent can be
+ updated too). */
+ blk[j + 1].len += blk[j + 1].lastlen;
+ blk[j + 1].lastlen = 0;
+ }
+
+ /* Write this block on the disk. */
+ if (abfd != NULL)
+ {
+ bfd_putl16 (blk[j].len + blk[j].lastlen, rblk[j]->used);
+ if (!vms_write_block (abfd, blk[j].vbn, rblk[j]))
+ return FALSE;
+ }
+
+ /* Reset this block. */
+ blk[j].len = 0;
+ blk[j].lastlen = 0;
+ blk[j].vbn = (*vbn)++;
+ }
+
+ /* Append it to the block. */
+ if (j == 0)
+ {
/* Keep the previous last entry. */
- blk[j].len += blk[j].lastlen;
-
- if (abfd != NULL)
- {
- struct vms_rfa *rfa;
-
- rfa = (struct vms_rfa *)(rblk[j]->keys + blk[j].len);
- bfd_putl32 ((idx->abfd->proxy_origin / VMS_BLOCK_SIZE) + 1,
- rfa->vbn);
- bfd_putl16
- ((idx->abfd->proxy_origin % VMS_BLOCK_SIZE)
- + (is_elfidx ? 0 : DATA__DATA),
- rfa->offset);
-
- if (is_elfidx)
- {
- /* Use elfidx format. */
- struct vms_elfidx *en = (struct vms_elfidx *)rfa;
-
- en->flags = 0;
- if (key_vbn != 0)
- {
- /* Long symbol name. */
- struct vms_kbn *k = (struct vms_kbn *)(en->keyname);
- bfd_putl16 (sizeof (struct vms_kbn), en->keylen);
- bfd_putl16 (idx->namlen, k->keylen);
- bfd_putl32 (key_vbn, k->rfa.vbn);
- bfd_putl16 (key_off, k->rfa.offset);
- en->flags |= ELFIDX__SYMESC;
- }
- else
- {
- bfd_putl16 (idx->namlen, en->keylen);
- memcpy (en->keyname, idx->name, idx->namlen);
- }
- }
- else
- {
- /* Use idx format. */
- struct vms_idx *en = (struct vms_idx *)rfa;
- en->keylen = idx->namlen;
- memcpy (en->keyname, idx->name, idx->namlen);
- }
- }
+ blk[j].len += blk[j].lastlen;
+
+ if (abfd != NULL)
+ {
+ struct vms_rfa *rfa;
+
+ rfa = (struct vms_rfa *)(rblk[j]->keys + blk[j].len);
+ bfd_putl32 ((idx->abfd->proxy_origin / VMS_BLOCK_SIZE) + 1,
+ rfa->vbn);
+ bfd_putl16
+ ((idx->abfd->proxy_origin % VMS_BLOCK_SIZE)
+ + (is_elfidx ? 0 : DATA__DATA),
+ rfa->offset);
+
+ if (is_elfidx)
+ {
+ /* Use elfidx format. */
+ struct vms_elfidx *en = (struct vms_elfidx *)rfa;
+
+ en->flags = 0;
+ if (key_vbn != 0)
+ {
+ /* Long symbol name. */
+ struct vms_kbn *k = (struct vms_kbn *)(en->keyname);
+ bfd_putl16 (sizeof (struct vms_kbn), en->keylen);
+ bfd_putl16 (idx->namlen, k->keylen);
+ bfd_putl32 (key_vbn, k->rfa.vbn);
+ bfd_putl16 (key_off, k->rfa.offset);
+ en->flags |= ELFIDX__SYMESC;
+ }
+ else
+ {
+ bfd_putl16 (idx->namlen, en->keylen);
+ memcpy (en->keyname, idx->name, idx->namlen);
+ }
+ }
+ else
+ {
+ /* Use idx format. */
+ struct vms_idx *en = (struct vms_idx *)rfa;
+ en->keylen = idx->namlen;
+ memcpy (en->keyname, idx->name, idx->namlen);
+ }
+ }
}
/* The last added key can now be the last one all blocks in the
path. */
blk[j].lastlen = idxlen;
- }
+ }
}
/* Save VBN of the root. */
{
/* Write this block on the disk. */
bfd_putl16 (blk[j].len + blk[j].lastlen, rblk[j]->used);
- if (vms_write_block (abfd, blk[j].vbn, rblk[j]) != TRUE)
- return FALSE;
+ if (!vms_write_block (abfd, blk[j].vbn, rblk[j]))
+ return FALSE;
free (rblk[j]);
}
/* Write the last kbn (if any). */
if (kbn_vbn != 0)
{
- if (vms_write_block (abfd, kbn_vbn, kbn_blk) != TRUE)
- return FALSE;
+ if (!vms_write_block (abfd, kbn_vbn, kbn_blk))
+ return FALSE;
free (kbn_blk);
}
static bfd_boolean
vms_write_data_block (bfd *arch, struct vms_datadef *data, file_ptr *off,
- const unsigned char *buf, unsigned int len, int pad)
+ const unsigned char *buf, unsigned int len, int pad)
{
while (len > 0 || pad)
{
*off += l;
if (doff == (DATA__LENGTH - DATA__DATA) || (len == 0 && pad))
- {
- data->recs = 0;
- data->fill_1 = 0;
- bfd_putl32 ((*off / VMS_BLOCK_SIZE) + 2, data->link);
+ {
+ data->recs = 0;
+ data->fill_1 = 0;
+ bfd_putl32 ((*off / VMS_BLOCK_SIZE) + 2, data->link);
- if (bfd_bwrite (data, sizeof (*data), arch) != sizeof (*data))
- return FALSE;
+ if (bfd_bwrite (data, sizeof (*data), arch) != sizeof (*data))
+ return FALSE;
- *off += DATA__LENGTH - doff;
+ *off += DATA__LENGTH - doff;
- if (len == 0)
- break;
- }
+ if (len == 0)
+ break;
+ }
}
return TRUE;
}
static bfd_boolean
_bfd_vms_lib_build_map (unsigned int nbr_modules,
- struct lib_index *modules,
- unsigned int *res_cnt,
- struct lib_index **res)
+ struct lib_index *modules,
+ unsigned int *res_cnt,
+ struct lib_index **res)
{
unsigned int i;
asymbol **syms = NULL;
bfd *current = modules[i].abfd;
if ((bfd_get_file_flags (current) & HAS_SYMS) == 0)
- continue;
+ continue;
storage = bfd_get_symtab_upper_bound (current);
if (storage < 0)
- goto error_return;
+ goto error_return;
if (storage != 0)
- {
- if (storage > syms_max)
- {
- if (syms_max > 0)
- free (syms);
- syms_max = storage;
- syms = (asymbol **) bfd_malloc (syms_max);
- if (syms == NULL)
- goto error_return;
- }
- symcount = bfd_canonicalize_symtab (current, syms);
- if (symcount < 0)
- goto error_return;
-
- /* Now map over all the symbols, picking out the ones we
- want. */
- for (src_count = 0; src_count < symcount; src_count++)
- {
- flagword flags = (syms[src_count])->flags;
- asection *sec = syms[src_count]->section;
-
- if ((flags & BSF_GLOBAL
- || flags & BSF_WEAK
- || flags & BSF_INDIRECT
- || bfd_is_com_section (sec))
- && ! bfd_is_und_section (sec))
- {
- struct lib_index *new_map;
-
- /* This symbol will go into the archive header. */
- if (map_count == map_max)
- {
- map_max *= 2;
- new_map = (struct lib_index *)
- bfd_realloc (map, map_max * sizeof (struct lib_index));
- if (new_map == NULL)
- goto error_return;
- map = new_map;
- }
-
- map[map_count].abfd = current;
- map[map_count].namlen = strlen (syms[src_count]->name);
- map[map_count].name = syms[src_count]->name;
- map_count++;
- modules[i].ref++;
- }
- }
+ {
+ if (storage > syms_max)
+ {
+ if (syms_max > 0)
+ free (syms);
+ syms_max = storage;
+ syms = (asymbol **) bfd_malloc (syms_max);
+ if (syms == NULL)
+ goto error_return;
+ }
+ symcount = bfd_canonicalize_symtab (current, syms);
+ if (symcount < 0)
+ goto error_return;
+
+ /* Now map over all the symbols, picking out the ones we
+ want. */
+ for (src_count = 0; src_count < symcount; src_count++)
+ {
+ flagword flags = (syms[src_count])->flags;
+ asection *sec = syms[src_count]->section;
+
+ if ((flags & BSF_GLOBAL
+ || flags & BSF_WEAK
+ || flags & BSF_INDIRECT
+ || bfd_is_com_section (sec))
+ && ! bfd_is_und_section (sec))
+ {
+ struct lib_index *new_map;
+
+ /* This symbol will go into the archive header. */
+ if (map_count == map_max)
+ {
+ map_max *= 2;
+ new_map = (struct lib_index *)
+ bfd_realloc (map, map_max * sizeof (struct lib_index));
+ if (new_map == NULL)
+ goto error_return;
+ map = new_map;
+ }
+
+ map[map_count].abfd = current;
+ map[map_count].namlen = strlen (syms[src_count]->name);
+ map[map_count].name = syms[src_count]->name;
+ map_count++;
+ modules[i].ref++;
+ }
+ }
}
}
current->proxy_origin = off;
if (is_elfidx)
- sz = 0;
+ sz = 0;
else
- {
- /* Write the MHD as a record (ie, size first). */
- sz = 2;
- bfd_putl16 (tdata->mhd_size, blk);
- }
+ {
+ /* Write the MHD as a record (ie, size first). */
+ sz = 2;
+ bfd_putl16 (tdata->mhd_size, blk);
+ }
mhd = (struct vms_mhd *)(blk + sz);
memset (mhd, 0, sizeof (struct vms_mhd));
mhd->lbrflag = 0;
/* Rewind the member to be put into the archive. */
if (bfd_seek (current, 0, SEEK_SET) != 0)
- goto input_err;
+ goto input_err;
/* Copy the member into the archive. */
if (is_elfidx)
- {
- unsigned int modsize = 0;
- bfd_size_type amt;
- file_ptr off_hdr = off;
-
- /* Read to complete the first block. */
- amt = bfd_bread (blk + sz, VMS_BLOCK_SIZE - sz, current);
- if (amt == (bfd_size_type)-1)
- goto input_err;
- modsize = amt;
- if (amt < VMS_BLOCK_SIZE - sz)
- {
- /* The member size is less than a block. Pad the block. */
- memset (blk + sz + amt, 0, VMS_BLOCK_SIZE - sz - amt);
- }
- bfd_putl32 (modsize, mhd->modsize);
-
- /* Write the first block (which contains an mhd). */
- if (bfd_bwrite (blk, VMS_BLOCK_SIZE, arch) != VMS_BLOCK_SIZE)
- goto input_err;
- off += VMS_BLOCK_SIZE;
-
- if (amt == VMS_BLOCK_SIZE - sz)
- {
- /* Copy the remaining. */
- char buffer[DEFAULT_BUFFERSIZE];
-
- while (1)
- {
- amt = bfd_bread (buffer, sizeof (buffer), current);
- if (amt == (bfd_size_type)-1)
- goto input_err;
- if (amt == 0)
- break;
- modsize += amt;
- if (amt != sizeof (buffer))
- {
- /* Clear the padding. */
- memset (buffer + amt, 0, sizeof (buffer) - amt);
- amt = (amt + VMS_BLOCK_SIZE) & ~(VMS_BLOCK_SIZE - 1);
- }
- if (bfd_bwrite (buffer, amt, arch) != amt)
- goto input_err;
- off += amt;
- }
-
- /* Now that the size is known, write the first block (again). */
- bfd_putl32 (modsize, mhd->modsize);
- if (bfd_seek (arch, off_hdr, SEEK_SET) != 0
- || bfd_bwrite (blk, VMS_BLOCK_SIZE, arch) != VMS_BLOCK_SIZE)
- goto input_err;
- if (bfd_seek (arch, off, SEEK_SET) != 0)
- goto input_err;
- }
- }
+ {
+ unsigned int modsize = 0;
+ bfd_size_type amt;
+ file_ptr off_hdr = off;
+
+ /* Read to complete the first block. */
+ amt = bfd_bread (blk + sz, VMS_BLOCK_SIZE - sz, current);
+ if (amt == (bfd_size_type)-1)
+ goto input_err;
+ modsize = amt;
+ if (amt < VMS_BLOCK_SIZE - sz)
+ {
+ /* The member size is less than a block. Pad the block. */
+ memset (blk + sz + amt, 0, VMS_BLOCK_SIZE - sz - amt);
+ }
+ bfd_putl32 (modsize, mhd->modsize);
+
+ /* Write the first block (which contains an mhd). */
+ if (bfd_bwrite (blk, VMS_BLOCK_SIZE, arch) != VMS_BLOCK_SIZE)
+ goto input_err;
+ off += VMS_BLOCK_SIZE;
+
+ if (amt == VMS_BLOCK_SIZE - sz)
+ {
+ /* Copy the remaining. */
+ char buffer[DEFAULT_BUFFERSIZE];
+
+ while (1)
+ {
+ amt = bfd_bread (buffer, sizeof (buffer), current);
+ if (amt == (bfd_size_type)-1)
+ goto input_err;
+ if (amt == 0)
+ break;
+ modsize += amt;
+ if (amt != sizeof (buffer))
+ {
+ /* Clear the padding. */
+ memset (buffer + amt, 0, sizeof (buffer) - amt);
+ amt = (amt + VMS_BLOCK_SIZE) & ~(VMS_BLOCK_SIZE - 1);
+ }
+ if (bfd_bwrite (buffer, amt, arch) != amt)
+ goto input_err;
+ off += amt;
+ }
+
+ /* Now that the size is known, write the first block (again). */
+ bfd_putl32 (modsize, mhd->modsize);
+ if (bfd_seek (arch, off_hdr, SEEK_SET) != 0
+ || bfd_bwrite (blk, VMS_BLOCK_SIZE, arch) != VMS_BLOCK_SIZE)
+ goto input_err;
+ if (bfd_seek (arch, off, SEEK_SET) != 0)
+ goto input_err;
+ }
+ }
else
- {
- /* Write the MHD. */
- if (vms_write_data_block (arch, &data, &off, blk, sz, 0) < 0)
- goto input_err;
-
- /* Write the member. */
- while (1)
- {
- sz = bfd_bread (blk, sizeof (blk), current);
- if (sz == 0)
- break;
- if (vms_write_data_block (arch, &data, &off, blk, sz, 0) < 0)
- goto input_err;
- }
-
- /* Write the end of module marker. */
- if (vms_write_data_block (arch, &data, &off,
- eotdesc, sizeof (eotdesc), 1) < 0)
- goto input_err;
- }
+ {
+ /* Write the MHD. */
+ if (vms_write_data_block (arch, &data, &off, blk, sz, 0) < 0)
+ goto input_err;
+
+ /* Write the member. */
+ while (1)
+ {
+ sz = bfd_bread (blk, sizeof (blk), current);
+ if (sz == 0)
+ break;
+ if (vms_write_data_block (arch, &data, &off, blk, sz, 0) < 0)
+ goto input_err;
+ }
+
+ /* Write the end of module marker. */
+ if (vms_write_data_block (arch, &data, &off,
+ eotdesc, sizeof (eotdesc), 1) < 0)
+ goto input_err;
+ }
}
/* Write the indexes. */
vbn = 2;
- if (vms_write_index (arch, modules, nbr_modules, &vbn, &mod_idx_vbn,
- is_elfidx) != TRUE)
+ if (!vms_write_index (arch, modules, nbr_modules, &vbn, &mod_idx_vbn,
+ is_elfidx))
return FALSE;
- if (vms_write_index (arch, symbols, nbr_symbols, &vbn, &sym_idx_vbn,
- is_elfidx) != TRUE)
+ if (!vms_write_index (arch, symbols, nbr_symbols, &vbn, &sym_idx_vbn,
+ is_elfidx))
return FALSE;
/* Write libary header. */
switch (tdata->kind)
{
case vms_lib_alpha:
- saneid = LHD_SANEID3;
- break;
+ saneid = LHD_SANEID3;
+ break;
case vms_lib_ia64:
- saneid = LHD_SANEID6;
- break;
+ saneid = LHD_SANEID6;
+ break;
default:
- abort ();
+ abort ();
}
bfd_putl32 (saneid, lhd->sanity);
bfd_putl16 (tdata->ver, lhd->majorid);
bfd_putl16 (0, lhd->minorid);
snprintf ((char *)lhd->lbrver + 1, sizeof (lhd->lbrver) - 1,
- "GNU ar %u.%u.%u",
- (unsigned)(BFD_VERSION / 100000000UL),
- (unsigned)(BFD_VERSION / 1000000UL) % 100,
- (unsigned)(BFD_VERSION / 10000UL) % 100);
+ "GNU ar %u.%u.%u",
+ (unsigned)(BFD_VERSION / 100000000UL),
+ (unsigned)(BFD_VERSION / 1000000UL) % 100,
+ (unsigned)(BFD_VERSION / 10000UL) % 100);
lhd->lbrver[sizeof (lhd->lbrver) - 1] = 0;
lhd->lbrver[0] = strlen ((char *)lhd->lbrver + 1);
bfd_putl16 (sym_idx_vbn, idd->vbn);
idd++;
- if (vms_write_block (arch, 1, blk) != TRUE)
+ if (!vms_write_block (arch, 1, blk))
return FALSE;
}
return TRUE;
input_err:
- bfd_set_error (bfd_error_on_input, current, bfd_get_error ());
+ bfd_set_input_error (current, bfd_get_error ());
return FALSE;
}
/* Add a target for text library. This costs almost nothing and is useful to
read VMS library on the host. */
-const bfd_target vms_lib_txt_vec =
+const bfd_target alpha_vms_lib_txt_vec =
{
"vms-libtxt", /* Name. */
bfd_target_unknown_flavour,
bfd_getl64, bfd_getl_signed_64, bfd_putl64,
bfd_getl32, bfd_getl_signed_32, bfd_putl32,
bfd_getl16, bfd_getl_signed_16, bfd_putl16,
-
- {_bfd_dummy_target, _bfd_dummy_target, /* bfd_check_format. */
- _bfd_vms_lib_txt_archive_p, _bfd_dummy_target},
- {bfd_false, bfd_false, bfd_false, bfd_false}, /* bfd_set_format. */
- {bfd_false, bfd_false, bfd_false, bfd_false}, /* bfd_write_contents. */
-
+ { /* bfd_check_format. */
+ _bfd_dummy_target,
+ _bfd_dummy_target,
+ _bfd_vms_lib_txt_archive_p,
+ _bfd_dummy_target
+ },
+ { /* bfd_set_format. */
+ _bfd_bool_bfd_false_error,
+ _bfd_bool_bfd_false_error,
+ _bfd_bool_bfd_false_error,
+ _bfd_bool_bfd_false_error
+ },
+ { /* bfd_write_contents. */
+ _bfd_bool_bfd_false_error,
+ _bfd_bool_bfd_false_error,
+ _bfd_bool_bfd_false_error,
+ _bfd_bool_bfd_false_error
+ },
BFD_JUMP_TABLE_GENERIC (_bfd_generic),
BFD_JUMP_TABLE_COPY (_bfd_generic),
BFD_JUMP_TABLE_CORE (_bfd_nocore),