/* BFD back-end for VMS archive files.
- Copyright 2010, 2011 Free Software Foundation, Inc.
+ Copyright 2010-2013 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"
#endif
/* Maximum key length (which is also the maximum symbol length in archive). */
-#define MAX_KEYLEN 129
+#define MAX_KEYLEN 128
+#define MAX_EKEYLEN 1024
/* DCX Submaps. */
if (idx_vbn == 0)
return FALSE;
+ /* Point to the next index entry. */
+ p = keyname + keylen;
+
if (idx_off == RFADEF__C_INDEX)
{
/* Indirect entry. Recurse. */
return FALSE;
}
}
-
- /* Point to the next index entry. */
- p = keyname + keylen;
}
return TRUE;
err:
bfd_release (abfd, tdata);
- abfd->tdata.any = (void *)tdata_hold;;
+ abfd->tdata.any = (void *)tdata_hold;
return NULL;
}
struct lib_tdata *tdata = bfd_libdata (abfd);
bfd *res;
file_ptr file_off;
+ char *name;
/* Sanity check. */
if (modidx >= tdata->nbr_modules)
res = _bfd_create_empty_archive_element_shell (abfd);
if (res == NULL)
return NULL;
- arelt = bfd_zalloc (res, sizeof (*arelt));
+ arelt = bfd_zmalloc (sizeof (*arelt));
if (arelt == NULL)
return NULL;
res->arelt_data = arelt;
res->origin = file_off + tdata->mhd_size;
}
- res->filename = tdata->modules[modidx].name;
+ /* Set filename. */
+ name = tdata->modules[modidx].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;
+ }
+ break;
+ default:
+ break;
+ }
+ res->filename = xstrdup (name);
tdata->cache[modidx] = res;
{
if (is_elfidx)
{
+ /* 9 is the size of struct vms_elfidx without keyname. */
if (idx->namlen > MAX_KEYLEN)
- return 9 + sizeof (struct vms_rfa);
+ return 9 + sizeof (struct vms_kbn);
else
return 9 + idx->namlen;
}
else
- return 7 + idx->namlen;
+ {
+ /* 7 is the size of struct vms_idx without keyname. */
+ return 7 + idx->namlen;
+ }
}
-/* Write the index. VBN is the first vbn to be used, and will contain
- on return the last vbn.
+/* Write the index composed by NBR symbols contained in IDX.
+ VBN is the first vbn to be used, and will contain on return the last vbn.
Can be called with ABFD set to NULL just to size the index.
+ If not null, TOPVBN will be assigned to the vbn of the root index tree.
+ IS_ELFIDX is true for elfidx (ie ia64) indexes layout.
Return TRUE on success. */
static bfd_boolean
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
+ branch when all upper leaves and branches are full. We only keep in
+ memory a path to the current leaf. */
unsigned int i;
int j;
int level;
+ /* Disk blocks for the current path. */
struct vms_indexdef *rblk[MAX_LEVEL];
+ /* Info on the current blocks. */
struct idxblk
{
- unsigned int vbn;
- unsigned short len;
- unsigned short lastlen;
+ unsigned int vbn; /* VBN of the block. */
+ /* The last entry is identified so that it could be copied to the
+ parent block. */
+ unsigned short len; /* Length up to the last entry. */
+ unsigned short lastlen; /* Length of the last entry. */
} blk[MAX_LEVEL];
/* The kbn blocks are used to store long symbol names. */
idxlen = get_idxlen (idx, is_elfidx);
- if (is_elfidx && idx->namlen >= MAX_KEYLEN)
+ 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 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
block and all the blocks below it. */
for (j = 0; j < level; j++)
if (blk[j].len + blk[j].lastlen + idxlen > INDEXDEF__BLKSIZ)
- flush = j + 1;
+ flush = j + 1;
for (j = 0; j < level; j++)
{
}
blk[level].vbn = (*vbn)++;
blk[level].len = 0;
- blk[level].lastlen = 0;
+ blk[level].lastlen = blk[j].lastlen;
level++;
}
- /* Update parent block: write the new entry. */
+ /* Update parent block: write the last entry from the current
+ block. */
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. */
- memcpy (rblk[j + 1]->keys + blk[j + 1].len,
- rblk[j]->keys + blk[j].len,
- blk[j].lastlen);
+ 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
entry. */
- rfa = (struct vms_rfa *)(rblk[j + 1]->keys + blk[j + 1].len);
bfd_putl32 (blk[j].vbn, rfa->vbn);
bfd_putl16 (RFADEF__C_INDEX, rfa->offset);
}
/* 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].lastlen;
+ blk[j + 1].len += blk[j + 1].lastlen;
blk[j + 1].lastlen = 0;
}
/* Append it to the block. */
if (j == 0)
{
+ /* Keep the previous last entry. */
blk[j].len += blk[j].lastlen;
if (abfd != NULL)
memcpy (en->keyname, idx->name, idx->namlen);
}
}
- }
-
- blk[j].lastlen = idxlen;
+ }
+ /* The last added key can now be the last one all blocks in the
+ path. */
+ blk[j].lastlen = idxlen;
}
}
+ /* Save VBN of the root. */
if (topvbn != NULL)
*topvbn = blk[level - 1].vbn;
en = rblk[j - 1]->keys + blk[j - 1].len;
par = rblk[j]->keys + blk[j].len;
+ BFD_ASSERT (blk[j].lastlen == blk[j - 1].lastlen);
memcpy (par, en, blk[j - 1].lastlen);
rfa = (struct vms_rfa *)par;
bfd_putl32 (blk[j - 1].vbn, rfa->vbn);
{
if (vms_write_block (abfd, kbn_vbn, kbn_blk) != TRUE)
return FALSE;
+ free (kbn_blk);
}
return TRUE;
unsigned int mod_idx_vbn;
unsigned int sym_idx_vbn;
bfd_boolean is_elfidx = tdata->kind == vms_lib_ia64;
+ unsigned int max_keylen = is_elfidx ? MAX_EKEYLEN : MAX_KEYLEN;
/* Count the number of modules (and do a first sanity check). */
nbr_modules = 0;
current != NULL;
current = current->archive_next, i++)
{
- int nl;
+ unsigned int nl;
modules[i].abfd = current;
modules[i].name = vms_get_module_name (current->filename, FALSE);
/* FIXME: silently truncate long names ? */
nl = strlen (modules[i].name);
- modules[i].namlen = (nl > MAX_KEYLEN ? MAX_KEYLEN : nl);
+ modules[i].namlen = (nl > max_keylen ? max_keylen : nl);
}
/* Create the module index. */
bfd_putl32 (nbr_modules, lhd->modcnt);
bfd_putl32 (nbr_modules, lhd->modhdrs);
+ /* Number of blocks for index. */
+ bfd_putl32 (nbr_mod_iblk + nbr_sym_iblk, lhd->idxblks);
bfd_putl32 (vbn - 1, lhd->hipreal);
bfd_putl32 (vbn - 1, lhd->hiprusd);
+ /* VBN of the next free block. */
+ bfd_putl32 ((off / VMS_BLOCK_SIZE) + 1, lhd->nextvbn);
+ bfd_putl32 ((off / VMS_BLOCK_SIZE) + 1, lhd->nextrfa + 0);
+ bfd_putl16 (0, lhd->nextrfa + 4);
+
/* First index (modules name). */
idd_flags = IDD__FLAGS_ASCII | IDD__FLAGS_VARLENIDX
| IDD__FLAGS_NOCASECMP | IDD__FLAGS_NOCASENTR;
bfd_putl16 (idd_flags, idd->flags);
- bfd_putl16 (MAX_KEYLEN, idd->keylen);
+ bfd_putl16 (max_keylen + 1, idd->keylen);
bfd_putl16 (mod_idx_vbn, idd->vbn);
idd++;
/* Second index (symbols name). */
bfd_putl16 (idd_flags, idd->flags);
- bfd_putl16 (MAX_KEYLEN, idd->keylen);
+ bfd_putl16 (max_keylen + 1, idd->keylen);
bfd_putl16 (sym_idx_vbn, idd->vbn);
idd++;
NULL,
- (PTR) 0
+ NULL
};