Merge GDB 7.5.1

bfd/vms-lib.c

 /* BFD back-end for VMS archive files.
 
    Copyright 2010, 2011 Free Software Foundation, Inc.
    Written by Tristan Gingold <gingold@adacore.com>, AdaCore.
 
    This file is part of BFD, the Binary File Descriptor library.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 3 of the License, or
@@ skipping 17 matching lines @@
 #include "vms.h"
 #include "vms/lbr.h"
 #include "vms/dcx.h"
 
 /* The standard VMS disk block size.  */
 #ifndef VMS_BLOCK_SIZE
 #define VMS_BLOCK_SIZE 512
 #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.  */
 
 struct dcxsbm_desc
 {
   unsigned char min_char;
   unsigned char max_char;
   unsigned char *flags;
   unsigned char *nodes;
   unsigned short *next;
@@ skipping 221 matching lines @@
           flags = ridx->flags;
           keyname = ridx->keyname;
         }
       else
         return FALSE;
 
       /* Illegal value.  */
       if (idx_vbn == 0)
         return FALSE;
 
+      /* Point to the next index entry.  */
+      p = keyname + keylen;
+
       if (idx_off == RFADEF__C_INDEX)
         {
           /* Indirect entry.  Recurse.  */
           if (!vms_traverse_index (abfd, idx_vbn, cs))
             return FALSE;
         }
       else
         {
           /* Add a new entry.  */
           char *name;
@@ skipping 71 matching lines @@
                 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;
             }
         }
-
-      /* Point to the next index entry.  */
-      p = keyname + keylen;
     }
 
   return TRUE;
 }
 
 /* Read index #IDX, which must have NBREL entries.  */
 
 static struct carsym *
 vms_lib_read_index (bfd *abfd, int idx, unsigned int *nbrel)
 {
@@ skipping 904 matching lines @@
 }
 
 /* Get member MODIDX.  Return NULL in case of error.  */
 
 static bfd *
 _bfd_vms_lib_get_module (bfd *abfd, unsigned int modidx)
 {
   struct lib_tdata *tdata = bfd_libdata (abfd);
   bfd *res;
   file_ptr file_off;
+  char *name;
 
   /* Sanity check.  */
   if (modidx >= tdata->nbr_modules)
     return NULL;
 
   /* Already loaded.  */
   if (tdata->cache[modidx])
     return tdata->cache[modidx];
 
   /* Build it.  */
@@ skipping 41 matching lines @@
       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.  */
       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 = name;
 
   tdata->cache[modidx] = res;
 
   return res;
 }
 
 /* Standard function: get member at IDX.  */
 
 bfd *
 _bfd_vms_lib_get_elt_at_index (bfd *abfd, symindex symidx)
@@ skipping 190 matching lines @@
    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
 vms_write_index (bfd *abfd,
                  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.  */
   unsigned int kbn_sz = 0;   /* Number of bytes available in the kbn block.  */
   unsigned int kbn_vbn = 0;  /* VBN of the kbn block.  */
   unsigned char *kbn_blk = NULL; /* Contents of the kbn block.  */
 
   if (nbr == 0)
     {
       /* No entries.  Very easy to handle.  */
@@ skipping 18 matching lines @@
 
   for (i = 0; i < nbr; i++, idx++)
     {
       unsigned int idxlen;
       int flush = 0;
       unsigned int key_vbn = 0;
       unsigned int key_off = 0;
 
       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 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))
@@ skipping 58 matching lines @@
               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.  */
       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++)
         {
           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 = 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);
                 }
 
               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].lastlen;
+                  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)
             {
+              /* 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
@@ skipping 24 matching lines @@
                         }
                     }
                   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].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;
 
   if (abfd == NULL)
     return TRUE;
 
   /* Flush.  */
   for (j = 1; j < level; j++)
     {
       /* Update parent block: write the new entry.  */
       unsigned char *en;
       unsigned char *par;
       struct vms_rfa *rfa;
 
       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);
       bfd_putl16 (RFADEF__C_INDEX, rfa->offset);
     }
 
   for (j = 0; j < level; j++)
     {
       /* 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;
 
       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;
+      free (kbn_blk);
     }
 
   return TRUE;
 }
 
 /* Append data to the data block DATA.  Force write if PAD is true.  */
 
 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)
@@ skipping 138 matching lines @@
   struct lib_index *symbols;
   struct lib_tdata *tdata = bfd_libdata (arch);
   unsigned int i;
   file_ptr off;
   unsigned int nbr_mod_iblk;
   unsigned int nbr_sym_iblk;
   unsigned int vbn;
   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;
   for (current = arch->archive_head;
        current != NULL;
        current = current->archive_next)
     {
       /* This check is checking the bfds for the objects we're reading
          from (which are usually either an object file or archive on
          disk), not the archive entries we're writing to.  We don't
@@ skipping 11 matching lines @@
   /* Build the modules list.  */
   BFD_ASSERT (tdata->modules == NULL);
   modules = bfd_alloc (arch, nbr_modules * sizeof (struct lib_index));
   if (modules == NULL)
     return FALSE;
 
   for (current = arch->archive_head, i = 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);
       modules[i].ref = 1;
 
       /* 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.  */
   vbn = 0;
   if (!vms_write_index (NULL, modules, nbr_modules, &vbn, NULL, is_elfidx))
     return FALSE;
   nbr_mod_iblk = vbn;
 
   /* Create symbol index.  */
   if (!_bfd_vms_lib_build_map (nbr_modules, modules, &nbr_symbols, &symbols))
@@ skipping 170 matching lines @@
     bfd_putl32 (tdata->credat_lo, lhd->credat + 0);
     bfd_putl32 (tdata->credat_hi, lhd->credat + 4);
     vms_raw_get_time (lhd->updtim);
 
     lhd->mhdusz = tdata->mhd_size - MHD__C_USRDAT;
 
     bfd_putl32 (nbr_modules + nbr_symbols, lhd->idxcnt);
     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++;
 
     if (vms_write_block (arch, 1, blk) != TRUE)
       return FALSE;
   }
 
   return TRUE;
 
  input_err:
@@ skipping 33 matching lines @@
   BFD_JUMP_TABLE_CORE (_bfd_nocore),
   BFD_JUMP_TABLE_ARCHIVE (_bfd_vms_lib),
   BFD_JUMP_TABLE_SYMBOLS (_bfd_nosymbols),
   BFD_JUMP_TABLE_RELOCS (_bfd_norelocs),
   BFD_JUMP_TABLE_WRITE (_bfd_nowrite),
   BFD_JUMP_TABLE_LINK (_bfd_nolink),
   BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
 
   NULL,
 
-  (PTR) 0
+  NULL
 };