bfd/vms-lib.c

   1 /* BFD back-end for VMS archive files.
   2
   3    Copyright (C) 2010-2014 Free Software Foundation, Inc.
   4    Written by Tristan Gingold <gingold@adacore.com>, AdaCore.
   5
   6    This file is part of BFD, the Binary File Descriptor library.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  21    MA 02110-1301, USA.  */
  22
  23 #include "sysdep.h"
  24 #include "bfd.h"
  25 #include "libbfd.h"
  26 #include "safe-ctype.h"
  27 #include "bfdver.h"
  28 #include "libiberty.h"
  29 #include "vms.h"
  30 #include "vms/lbr.h"
  31 #include "vms/dcx.h"
  32
  33 /* The standard VMS disk block size.  */
  34 #ifndef VMS_BLOCK_SIZE
  35 #define VMS_BLOCK_SIZE 512
  36 #endif
  37
  38 /* Maximum key length (which is also the maximum symbol length in archive).  */
  39 #define MAX_KEYLEN 128
  40 #define MAX_EKEYLEN 1024
  41
  42 /* DCX Submaps.  */
  43
  44 struct dcxsbm_desc
  45 {
  46   unsigned char min_char;
  47   unsigned char max_char;
  48   unsigned char *flags;
  49   unsigned char *nodes;
  50   unsigned short *next;
  51 };
  52
  53 /* Kind of library.  Used to filter in archive_p.  */
  54
  55 enum vms_lib_kind
  56   {
  57     vms_lib_vax,
  58     vms_lib_alpha,
  59     vms_lib_ia64,
  60     vms_lib_txt
  61   };
  62
  63 /* Back-end private data.  */
  64
  65 struct lib_tdata
  66 {
  67   /* Standard tdata for an archive.  But we don't use many fields.  */
  68   struct artdata artdata;
  69
  70   /* Major version.  */
  71   unsigned char ver;
  72
  73   /* Type of the archive.  */
  74   unsigned char type;
  75
  76   /* Kind of archive.  Summary of its type.  */
  77   enum vms_lib_kind kind;
  78
  79   /* Total size of the mhd (element header).  */
  80   unsigned int mhd_size;
  81
  82   /* Creation date.  */
  83   unsigned int credat_lo;
  84   unsigned int credat_hi;
  85
  86   /* Vector of modules (archive elements), already sorted.  */
  87   unsigned int nbr_modules;
  88   struct carsym *modules;
  89   bfd **cache;
  90
  91   /* DCX (decompression) data.  */
  92   unsigned int nbr_dcxsbm;
  93   struct dcxsbm_desc *dcxsbm;
  94 };
  95
  96 #define bfd_libdata(bfd) ((struct lib_tdata *)((bfd)->tdata.any))
  97
  98 /* End-Of-Text pattern.  This is a special record to mark the end of file.  */
  99
 100 static const unsigned char eotdesc[] = { 0x03, 0x00, 0x77, 0x00, 0x77, 0x00 };
 101
 102 /* Describe the current state of carsym entries while building the archive
 103    table of content.  Things are simple with Alpha archives as the number
 104    of entries is known, but with IA64 archives a entry can make a reference
 105    to severals members.  Therefore we must be able to extend the table on the
 106    fly, but it should be allocated on the bfd - which doesn't support realloc.
 107    To reduce the overhead, the table is initially allocated in the BFD's
 108    objalloc and extended if necessary on the heap.  In the later case, it
 109    is finally copied to the BFD's objalloc so that it will automatically be
 110    freed.  */
 111
 112 struct carsym_mem
 113 {
 114   /* The table of content.  */
 115   struct carsym *idx;
 116
 117   /* Number of entries used in the table.  */
 118   unsigned int nbr;
 119
 120   /* Maximum number of entries.  */
 121   unsigned int max;
 122
 123   /* If true, the table was reallocated on the heap.  If false, it is still
 124      in the BFD's objalloc.  */
 125   bfd_boolean realloced;
 126 };
 127
 128 /* Simply add a name to the index.  */
 129
 130 static bfd_boolean
 131 vms_add_index (struct carsym_mem *cs, char *name,
 132                unsigned int idx_vbn, unsigned int idx_off)
 133 {
 134   if (cs->nbr == cs->max)
 135     {
 136       struct carsym *n;
 137
 138       cs->max = 2 * cs->max + 32;
 139
 140       if (!cs->realloced)
 141         {
 142           n = bfd_malloc2 (cs->max, sizeof (struct carsym));
 143           if (n == NULL)
 144             return FALSE;
 145           memcpy (n, cs->idx, cs->nbr * sizeof (struct carsym));
 146           /* And unfortunately we can't free cs->idx.  */
 147         }
 148       else
 149         {
 150           n = bfd_realloc_or_free (cs->idx, cs->nbr * sizeof (struct carsym));
 151           if (n == NULL)
 152             return FALSE;
 153         }
 154       cs->idx = n;
 155       cs->realloced = TRUE;
 156     }
 157   cs->idx[cs->nbr].file_offset = (idx_vbn - 1) * VMS_BLOCK_SIZE + idx_off;
 158   cs->idx[cs->nbr].name = name;
 159   cs->nbr++;
 160   return TRUE;
 161 }
 162
 163 /* Follow all member of a lns list (pointed by RFA) and add indexes for
 164    NAME.  Return FALSE in case of error.  */
 165
 166 static bfd_boolean
 167 vms_add_indexes_from_list (bfd *abfd, struct carsym_mem *cs, char *name,
 168                            struct vms_rfa *rfa)
 169 {
 170   struct vms_lns lns;
 171   unsigned int vbn;
 172   file_ptr off;
 173
 174   while (1)
 175     {
 176       vbn = bfd_getl32 (rfa->vbn);
 177       if (vbn == 0)
 178         return TRUE;
 179
 180       /* Read the LHS.  */
 181       off = (vbn - 1) * VMS_BLOCK_SIZE + bfd_getl16 (rfa->offset);
 182       if (bfd_seek (abfd, off, SEEK_SET) != 0
 183           || bfd_bread (&lns, sizeof (lns), abfd) != sizeof (lns))
 184         return FALSE;
 185
 186       if (!vms_add_index (cs, name,
 187                           bfd_getl32 (lns.modrfa.vbn),
 188                           bfd_getl16 (lns.modrfa.offset)))
 189         return FALSE;
 190
 191       rfa = &lns.nxtrfa;
 192     }
 193 }
 194
 195 /* Read block VBN from ABFD and store it into BLK.  Return FALSE in case of error.  */
 196
 197 static bfd_boolean
 198 vms_read_block (bfd *abfd, unsigned int vbn, void *blk)
 199 {
 200   file_ptr off;
 201
 202   off = (vbn - 1) * VMS_BLOCK_SIZE;
 203   if (bfd_seek (abfd, off, SEEK_SET) != 0
 204       || bfd_bread (blk, VMS_BLOCK_SIZE, abfd) != VMS_BLOCK_SIZE)
 205     return FALSE;
 206
 207   return TRUE;
 208 }
 209
 210 /* Write the content of BLK to block VBN of ABFD.  Return FALSE in case of error.  */
 211
 212 static bfd_boolean
 213 vms_write_block (bfd *abfd, unsigned int vbn, void *blk)
 214 {
 215   file_ptr off;
 216
 217   off = (vbn - 1) * VMS_BLOCK_SIZE;
 218   if (bfd_seek (abfd, off, SEEK_SET) != 0
 219       || bfd_bwrite (blk, VMS_BLOCK_SIZE, abfd) != VMS_BLOCK_SIZE)
 220     return FALSE;
 221
 222   return TRUE;
 223 }
 224
 225 /* Read index block VBN and put the entry in **IDX (which is updated).
 226    If the entry is indirect, recurse.  */
 227
 228 static bfd_boolean
 229 vms_traverse_index (bfd *abfd, unsigned int vbn, struct carsym_mem *cs)
 230 {
 231   struct vms_indexdef indexdef;
 232   file_ptr off;
 233   unsigned char *p;
 234   unsigned char *endp;
 235
 236   /* Read the index block.  */
 237   BFD_ASSERT (sizeof (indexdef) == VMS_BLOCK_SIZE);
 238   if (!vms_read_block (abfd, vbn, &indexdef))
 239     return FALSE;
 240
 241   /* Traverse it.  */
 242   p = &indexdef.keys[0];
 243   endp = p + bfd_getl16 (indexdef.used);
 244   while (p < endp)
 245     {
 246       unsigned int idx_vbn;
 247       unsigned int idx_off;
 248       unsigned int keylen;
 249       unsigned char *keyname;
 250       unsigned int flags;
 251
 252       /* Extract key length.  */
 253       if (bfd_libdata (abfd)->ver == LBR_MAJORID)
 254         {
 255           struct vms_idx *ridx = (struct vms_idx *)p;
 256
 257           idx_vbn = bfd_getl32 (ridx->rfa.vbn);
 258           idx_off = bfd_getl16 (ridx->rfa.offset);
 259
 260           keylen = ridx->keylen;
 261           flags = 0;
 262           keyname = ridx->keyname;
 263         }
 264       else if (bfd_libdata (abfd)->ver == LBR_ELFMAJORID)
 265         {
 266           struct vms_elfidx *ridx = (struct vms_elfidx *)p;
 267
 268           idx_vbn = bfd_getl32 (ridx->rfa.vbn);
 269           idx_off = bfd_getl16 (ridx->rfa.offset);
 270
 271           keylen = bfd_getl16 (ridx->keylen);
 272           flags = ridx->flags;
 273           keyname = ridx->keyname;
 274         }
 275       else
 276         return FALSE;
 277
 278       /* Illegal value.  */
 279       if (idx_vbn == 0)
 280         return FALSE;
 281
 282       /* Point to the next index entry.  */
 283       p = keyname + keylen;
 284
 285       if (idx_off == RFADEF__C_INDEX)
 286         {
 287           /* Indirect entry.  Recurse.  */
 288           if (!vms_traverse_index (abfd, idx_vbn, cs))
 289             return FALSE;
 290         }
 291       else
 292         {
 293           /* Add a new entry.  */
 294           char *name;
 295
 296           if (flags & ELFIDX__SYMESC)
 297             {
 298               /* Extended key name.  */
 299               unsigned int noff = 0;
 300               unsigned int koff;
 301               unsigned int kvbn;
 302               struct vms_kbn *kbn;
 303               unsigned char kblk[VMS_BLOCK_SIZE];
 304
 305               /* Sanity check.  */
 306               if (keylen != sizeof (struct vms_kbn))
 307                 return FALSE;
 308
 309               kbn = (struct vms_kbn *)keyname;
 310               keylen = bfd_getl16 (kbn->keylen);
 311
 312               name = bfd_alloc (abfd, keylen + 1);
 313               if (name == NULL)
 314                 return FALSE;
 315               kvbn = bfd_getl32 (kbn->rfa.vbn);
 316               koff = bfd_getl16 (kbn->rfa.offset);
 317
 318               /* Read the key, chunk by chunk.  */
 319               do
 320                 {
 321                   unsigned int klen;
 322
 323                   if (!vms_read_block (abfd, kvbn, kblk))
 324                     return FALSE;
 325                   kbn = (struct vms_kbn *)(kblk + koff);
 326                   klen = bfd_getl16 (kbn->keylen);
 327                   kvbn = bfd_getl32 (kbn->rfa.vbn);
 328                   koff = bfd_getl16 (kbn->rfa.offset);
 329
 330                   memcpy (name + noff, kbn + 1, klen);
 331                   noff += klen;
 332                 }
 333               while (kvbn != 0);
 334
 335               /* Sanity check.  */
 336               if (noff != keylen)
 337                 return FALSE;
 338             }
 339           else
 340             {
 341               /* Usual key name.  */
 342               name = bfd_alloc (abfd, keylen + 1);
 343               if (name == NULL)
 344                 return FALSE;
 345
 346               memcpy (name, keyname, keylen);
 347             }
 348           name[keylen] = 0;
 349
 350           if (flags & ELFIDX__LISTRFA)
 351             {
 352               struct vms_lhs lhs;
 353
 354               /* Read the LHS.  */
 355               off = (idx_vbn - 1) * VMS_BLOCK_SIZE + idx_off;
 356               if (bfd_seek (abfd, off, SEEK_SET) != 0
 357                   || bfd_bread (&lhs, sizeof (lhs), abfd) != sizeof (lhs))
 358                 return FALSE;
 359
 360               /* FIXME: this adds extra entries that were not accounted.  */
 361               if (!vms_add_indexes_from_list (abfd, cs, name, &lhs.ng_g_rfa))
 362                 return FALSE;
 363               if (!vms_add_indexes_from_list (abfd, cs, name, &lhs.ng_wk_rfa))
 364                 return FALSE;
 365               if (!vms_add_indexes_from_list (abfd, cs, name, &lhs.g_g_rfa))
 366                 return FALSE;
 367               if (!vms_add_indexes_from_list (abfd, cs, name, &lhs.g_wk_rfa))
 368                 return FALSE;
 369             }
 370           else
 371             {
 372               if (!vms_add_index (cs, name, idx_vbn, idx_off))
 373                 return FALSE;
 374             }
 375         }
 376     }
 377
 378   return TRUE;
 379 }
 380
 381 /* Read index #IDX, which must have NBREL entries.  */
 382
 383 static struct carsym *
 384 vms_lib_read_index (bfd *abfd, int idx, unsigned int *nbrel)
 385 {
 386   struct vms_idd idd;
 387   unsigned int flags;
 388   unsigned int vbn;
 389   struct carsym *csbuf;
 390   struct carsym_mem csm;
 391
 392   /* Read index desription.  */
 393   if (bfd_seek (abfd, LHD_IDXDESC + idx * IDD_LENGTH, SEEK_SET) != 0
 394       || bfd_bread (&idd, sizeof (idd), abfd) != sizeof (idd))
 395     return NULL;
 396
 397   /* Sanity checks.  */
 398   flags = bfd_getl16 (idd.flags);
 399   if (!(flags & IDD__FLAGS_ASCII)
 400       || !(flags & IDD__FLAGS_VARLENIDX))
 401     return NULL;
 402
 403   csbuf = bfd_alloc (abfd, *nbrel * sizeof (struct carsym));
 404   if (csbuf == NULL)
 405     return NULL;
 406
 407   csm.max = *nbrel;
 408   csm.nbr = 0;
 409   csm.realloced = FALSE;
 410   csm.idx = csbuf;
 411
 412   /* Note: if the index is empty, there is no block to traverse.  */
 413   vbn = bfd_getl32 (idd.vbn);
 414   if (vbn != 0 && !vms_traverse_index (abfd, vbn, &csm))
 415     {
 416       if (csm.realloced && csm.idx != NULL)
 417         free (csm.idx);
 418
 419       /* Note: in case of error, we can free what was allocated on the
 420          BFD's objalloc.  */
 421       bfd_release (abfd, csbuf);
 422       return NULL;
 423     }
 424
 425   if (csm.realloced)
 426     {
 427       /* There are more entries than the first estimate.  Allocate on
 428          the BFD's objalloc.  */
 429       csbuf = bfd_alloc (abfd, csm.nbr * sizeof (struct carsym));
 430       if (csbuf == NULL)
 431         return NULL;
 432       memcpy (csbuf, csm.idx, csm.nbr * sizeof (struct carsym));
 433       free (csm.idx);
 434       *nbrel = csm.nbr;
 435     }
 436   return csbuf;
 437 }
 438
 439 /* Standard function.  */
 440
 441 static const bfd_target *
 442 _bfd_vms_lib_archive_p (bfd *abfd, enum vms_lib_kind kind)
 443 {
 444   struct vms_lhd lhd;
 445   unsigned int sanity;
 446   unsigned int majorid;
 447   struct lib_tdata *tdata_hold;
 448   struct lib_tdata *tdata;
 449   unsigned int dcxvbn;
 450   unsigned int nbr_ent;
 451
 452   /* Read header.  */
 453   if (bfd_bread (&lhd, sizeof (lhd), abfd) != sizeof (lhd))
 454     {
 455       if (bfd_get_error () != bfd_error_system_call)
 456         bfd_set_error (bfd_error_wrong_format);
 457       return NULL;
 458     }
 459
 460   /* Check sanity (= magic) number.  */
 461   sanity = bfd_getl32 (lhd.sanity);
 462   if (!(sanity == LHD_SANEID3
 463         || sanity == LHD_SANEID6
 464         || sanity == LHD_SANEID_DCX))
 465     {
 466       bfd_set_error (bfd_error_wrong_format);
 467       return NULL;
 468     }
 469   majorid = bfd_getl32 (lhd.majorid);
 470
 471   /* Check archive kind.  */
 472   switch (kind)
 473     {
 474     case vms_lib_alpha:
 475       if ((lhd.type != LBR__C_TYP_EOBJ && lhd.type != LBR__C_TYP_ESHSTB)
 476           || majorid != LBR_MAJORID
 477           || lhd.nindex != 2)
 478         {
 479           bfd_set_error (bfd_error_wrong_format);
 480           return NULL;
 481         }
 482       break;
 483     case vms_lib_ia64:
 484       if ((lhd.type != LBR__C_TYP_IOBJ && lhd.type != LBR__C_TYP_ISHSTB)
 485           || majorid != LBR_ELFMAJORID
 486           || lhd.nindex != 2)
 487         {
 488           bfd_set_error (bfd_error_wrong_format);
 489           return NULL;
 490         }
 491       break;
 492     case vms_lib_txt:
 493       if ((lhd.type != LBR__C_TYP_TXT
 494            && lhd.type != LBR__C_TYP_MLB
 495            && lhd.type != LBR__C_TYP_HLP)
 496           || majorid != LBR_MAJORID
 497           || lhd.nindex != 1)
 498         {
 499           bfd_set_error (bfd_error_wrong_format);
 500           return NULL;
 501         }
 502       break;
 503     default:
 504       abort ();
 505     }
 506
 507   /* Allocate and initialize private data.  */
 508   tdata_hold = bfd_libdata (abfd);
 509   tdata = (struct lib_tdata *) bfd_zalloc (abfd, sizeof (struct lib_tdata));
 510   if (tdata == NULL)
 511     return NULL;
 512   abfd->tdata.any = (void *)tdata;
 513   tdata->ver = majorid;
 514   tdata->mhd_size = MHD__C_USRDAT + lhd.mhdusz;
 515   tdata->type = lhd.type;
 516   tdata->kind = kind;
 517   tdata->credat_lo = bfd_getl32 (lhd.credat + 0);
 518   tdata->credat_hi = bfd_getl32 (lhd.credat + 4);
 519
 520   /* Read indexes.  */
 521   tdata->nbr_modules = bfd_getl32 (lhd.modcnt);
 522   tdata->artdata.symdef_count = bfd_getl32 (lhd.idxcnt) - tdata->nbr_modules;
 523   nbr_ent = tdata->nbr_modules;
 524   tdata->modules = vms_lib_read_index (abfd, 0, &nbr_ent);
 525   if (tdata->modules == NULL || nbr_ent != tdata->nbr_modules)
 526     goto err;
 527   if (lhd.nindex == 2)
 528     {
 529       nbr_ent = tdata->artdata.symdef_count;
 530       tdata->artdata.symdefs = vms_lib_read_index (abfd, 1, &nbr_ent);
 531       if (tdata->artdata.symdefs == NULL)
 532         goto err;
 533       /* Only IA64 archives may have more entries in the index that what
 534          was declared.  */
 535       if (nbr_ent != tdata->artdata.symdef_count
 536           && kind != vms_lib_ia64)
 537         goto err;
 538       tdata->artdata.symdef_count = nbr_ent;
 539     }
 540   tdata->cache = bfd_zalloc (abfd, sizeof (bfd *) * tdata->nbr_modules);
 541   if (tdata->cache == NULL)
 542     goto err;
 543
 544   /* Read DCX submaps.  */
 545   dcxvbn = bfd_getl32 (lhd.dcxmapvbn);
 546   if (dcxvbn != 0)
 547     {
 548       unsigned char buf_reclen[4];
 549       unsigned int reclen;
 550       unsigned char *buf;
 551       struct vms_dcxmap *map;
 552       unsigned int sbm_off;
 553       unsigned int i;
 554
 555       if (bfd_seek (abfd, (dcxvbn - 1) * VMS_BLOCK_SIZE, SEEK_SET) != 0
 556           || bfd_bread (buf_reclen, sizeof (buf_reclen), abfd)
 557           != sizeof (buf_reclen))
 558         goto err;
 559       reclen = bfd_getl32 (buf_reclen);
 560       buf = bfd_malloc (reclen);
 561       if (buf == NULL)
 562         goto err;
 563       if (bfd_bread (buf, reclen, abfd) != reclen)
 564         {
 565           free (buf);
 566           goto err;
 567         }
 568       map = (struct vms_dcxmap *)buf;
 569       tdata->nbr_dcxsbm = bfd_getl16 (map->nsubs);
 570       sbm_off = bfd_getl16 (map->sub0);
 571       tdata->dcxsbm = (struct dcxsbm_desc *)bfd_alloc
 572         (abfd, tdata->nbr_dcxsbm * sizeof (struct dcxsbm_desc));
 573       for (i = 0; i < tdata->nbr_dcxsbm; i++)
 574         {
 575           struct vms_dcxsbm *sbm = (struct vms_dcxsbm *) (buf + sbm_off);
 576           struct dcxsbm_desc *sbmdesc = &tdata->dcxsbm[i];
 577           unsigned int sbm_len;
 578           unsigned int sbm_sz;
 579           unsigned int off;
 580           unsigned char *data = (unsigned char *)sbm;
 581           unsigned char *buf1;
 582           unsigned int l, j;
 583
 584           sbm_sz = bfd_getl16 (sbm->size);
 585           sbm_off += sbm_sz;
 586           BFD_ASSERT (sbm_off <= reclen);
 587
 588           sbmdesc->min_char = sbm->min_char;
 589           BFD_ASSERT (sbmdesc->min_char == 0);
 590           sbmdesc->max_char = sbm->max_char;
 591           sbm_len = sbmdesc->max_char - sbmdesc->min_char + 1;
 592           l = (2 * sbm_len + 7) / 8;
 593           BFD_ASSERT
 594             (sbm_sz >= sizeof (struct vms_dcxsbm) + l + 3 * sbm_len
 595              || (tdata->nbr_dcxsbm == 1
 596                  && sbm_sz >= sizeof (struct vms_dcxsbm) + l + sbm_len));
 597           sbmdesc->flags = (unsigned char *)bfd_alloc (abfd, l);
 598           memcpy (sbmdesc->flags, data + bfd_getl16 (sbm->flags), l);
 599           sbmdesc->nodes = (unsigned char *)bfd_alloc (abfd, 2 * sbm_len);
 600           memcpy (sbmdesc->nodes, data + bfd_getl16 (sbm->nodes), 2 * sbm_len);
 601           off = bfd_getl16 (sbm->next);
 602           if (off != 0)
 603             {
 604               /* Read the 'next' array.  */
 605               sbmdesc->next = (unsigned short *)bfd_alloc
 606                 (abfd, sbm_len * sizeof (unsigned short));
 607               buf1 = data + off;
 608               for (j = 0; j < sbm_len; j++)
 609                 sbmdesc->next[j] = bfd_getl16 (buf1 + j * 2);
 610             }
 611           else
 612             {
 613               /* There is no next array if there is only one submap.  */
 614               BFD_ASSERT (tdata->nbr_dcxsbm == 1);
 615               sbmdesc->next = NULL;
 616             }
 617         }
 618       free (buf);
 619     }
 620   else
 621     {
 622       tdata->nbr_dcxsbm = 0;
 623     }
 624
 625   /* The map is always present.  Also mark shared image library.  */
 626   abfd->has_armap = TRUE;
 627   if (tdata->type == LBR__C_TYP_ESHSTB || tdata->type == LBR__C_TYP_ISHSTB)
 628     abfd->is_thin_archive = TRUE;
 629
 630   return abfd->xvec;
 631
 632  err:
 633   bfd_release (abfd, tdata);
 634   abfd->tdata.any = (void *)tdata_hold;
 635   return NULL;
 636 }
 637
 638 /* Standard function for alpha libraries.  */
 639
 640 const bfd_target *
 641 _bfd_vms_lib_alpha_archive_p (bfd *abfd)
 642 {
 643   return _bfd_vms_lib_archive_p (abfd, vms_lib_alpha);
 644 }
 645
 646 /* Standard function for ia64 libraries.  */
 647
 648 const bfd_target *
 649 _bfd_vms_lib_ia64_archive_p (bfd *abfd)
 650 {
 651   return _bfd_vms_lib_archive_p (abfd, vms_lib_ia64);
 652 }
 653
 654 /* Standard function for text libraries.  */
 655
 656 static const bfd_target *
 657 _bfd_vms_lib_txt_archive_p (bfd *abfd)
 658 {
 659   return _bfd_vms_lib_archive_p (abfd, vms_lib_txt);
 660 }
 661
 662 /* Standard bfd function.  */
 663
 664 static bfd_boolean
 665 _bfd_vms_lib_mkarchive (bfd *abfd, enum vms_lib_kind kind)
 666 {
 667   struct lib_tdata *tdata;
 668
 669   tdata = (struct lib_tdata *) bfd_zalloc (abfd, sizeof (struct lib_tdata));
 670   if (tdata == NULL)
 671     return FALSE;
 672
 673   abfd->tdata.any = (void *)tdata;
 674   vms_get_time (&tdata->credat_hi, &tdata->credat_lo);
 675
 676   tdata->kind = kind;
 677   switch (kind)
 678     {
 679     case vms_lib_alpha:
 680       tdata->ver = LBR_MAJORID;
 681       tdata->mhd_size = offsetof (struct vms_mhd, pad1);
 682       tdata->type = LBR__C_TYP_EOBJ;
 683       break;
 684     case vms_lib_ia64:
 685       tdata->ver = LBR_ELFMAJORID;
 686       tdata->mhd_size = sizeof (struct vms_mhd);
 687       tdata->type = LBR__C_TYP_IOBJ;
 688       break;
 689     default:
 690       abort ();
 691     }
 692
 693   tdata->nbr_modules = 0;
 694   tdata->artdata.symdef_count = 0;
 695   tdata->modules = NULL;
 696   tdata->artdata.symdefs = NULL;
 697   tdata->cache = NULL;
 698
 699   return TRUE;
 700 }
 701
 702 bfd_boolean
 703 _bfd_vms_lib_alpha_mkarchive (bfd *abfd)
 704 {
 705   return _bfd_vms_lib_mkarchive (abfd, vms_lib_alpha);
 706 }
 707
 708 bfd_boolean
 709 _bfd_vms_lib_ia64_mkarchive (bfd *abfd)
 710 {
 711   return _bfd_vms_lib_mkarchive (abfd, vms_lib_ia64);
 712 }
 713
 714 /* Find NAME in the symbol index.  Return the index.  */
 715
 716 symindex
 717 _bfd_vms_lib_find_symbol (bfd *abfd, const char *name)
 718 {
 719   struct lib_tdata *tdata = bfd_libdata (abfd);
 720   carsym *syms = tdata->artdata.symdefs;
 721   int lo, hi;
 722
 723   /* Open-coded binary search for speed.  */
 724   lo = 0;
 725   hi = tdata->artdata.symdef_count - 1;
 726
 727   while (lo <= hi)
 728     {
 729       int mid = lo + (hi - lo) / 2;
 730       int diff;
 731
 732       diff = (char)(name[0] - syms[mid].name[0]);
 733       if (diff == 0)
 734         diff = strcmp (name, syms[mid].name);
 735       if (diff == 0)
 736         return mid;
 737       else if (diff < 0)
 738         hi = mid - 1;
 739       else
 740         lo = mid + 1;
 741     }
 742   return BFD_NO_MORE_SYMBOLS;
 743 }
 744
 745 /* IO vector for archive member.  Need that because members are not linearly
 746    stored in archives.  */
 747
 748 struct vms_lib_iovec
 749 {
 750   /* Current offset.  */
 751   ufile_ptr where;
 752
 753   /* Length of the module, when known.  */
 754   ufile_ptr file_len;
 755
 756   /* Current position in the record from bfd_bread point of view (ie, after
 757      decompression).  0 means that no data byte have been read, -2 and -1
 758      are reserved for the length word.  */
 759   int rec_pos;
 760 #define REC_POS_NL   -4
 761 #define REC_POS_PAD  -3
 762 #define REC_POS_LEN0 -2
 763 #define REC_POS_LEN1 -1
 764
 765   /* Record length.  */
 766   unsigned short rec_len;
 767   /* Number of bytes to read in the current record.  */
 768   unsigned short rec_rem;
 769   /* Offset of the next block.  */
 770   file_ptr next_block;
 771   /* Current *data* offset in the data block.  */
 772   unsigned short blk_off;
 773
 774   /* Offset of the first block.  Extracted from the index.  */
 775   file_ptr first_block;
 776
 777   /* Initial next_block.  Extracted when the MHD is read.  */
 778   file_ptr init_next_block;
 779   /* Initial blk_off, once the MHD is read.  */
 780   unsigned short init_blk_off;
 781
 782   /* Used to store any 3 byte record, which could be the EOF pattern.  */
 783   unsigned char pattern[4];
 784
 785   /* DCX.  */
 786   struct dcxsbm_desc *dcxsbms;
 787   /* Current submap.  */
 788   struct dcxsbm_desc *dcx_sbm;
 789   /* Current offset in the submap.  */
 790   unsigned int dcx_offset;
 791   int dcx_pos;
 792
 793   /* Compressed buffer.  */
 794   unsigned char *dcx_buf;
 795   /* Size of the buffer.  Used to resize.  */
 796   unsigned int dcx_max;
 797   /* Number of valid bytes in the buffer.  */
 798   unsigned int dcx_rlen;
 799 };
 800
 801 /* Return the current position.  */
 802
 803 static file_ptr
 804 vms_lib_btell (struct bfd *abfd)
 805 {
 806   struct vms_lib_iovec *vec = (struct vms_lib_iovec *) abfd->iostream;
 807   return vec->where;
 808 }
 809
 810 /* Read the header of the next data block if all bytes of the current block
 811    have been read.  */
 812
 813 static bfd_boolean
 814 vms_lib_read_block (struct bfd *abfd)
 815 {
 816   struct vms_lib_iovec *vec = (struct vms_lib_iovec *) abfd->iostream;
 817
 818   if (vec->blk_off == DATA__LENGTH)
 819     {
 820       unsigned char hdr[DATA__DATA];
 821
 822       /* Read next block.  */
 823       if (bfd_seek (abfd->my_archive, vec->next_block, SEEK_SET) != 0)
 824         return FALSE;
 825       if (bfd_bread (hdr, sizeof (hdr), abfd->my_archive) != sizeof (hdr))
 826         return FALSE;
 827       vec->next_block = (bfd_getl32 (hdr + 2) - 1) * VMS_BLOCK_SIZE;
 828       vec->blk_off = sizeof (hdr);
 829     }
 830   return TRUE;
 831 }
 832
 833 /* Read NBYTES from ABFD into BUF if not NULL.  If BUF is NULL, bytes are
 834    not stored.  Read linearly from the library, but handle blocks.  This
 835    function does not handle records nor EOF.  */
 836
 837 static file_ptr
 838 vms_lib_bread_raw (struct bfd *abfd, unsigned char *buf, file_ptr nbytes)
 839 {
 840   struct vms_lib_iovec *vec = (struct vms_lib_iovec *) abfd->iostream;
 841   file_ptr res;
 842
 843   res = 0;
 844   while (nbytes > 0)
 845     {
 846       unsigned int l;
 847
 848       /* Be sure the current data block is read.  */
 849       if (!vms_lib_read_block (abfd))
 850         return -1;
 851
 852       /* Do not read past the data block, do not read more than requested.  */
 853       l = DATA__LENGTH - vec->blk_off;
 854       if (l > nbytes)
 855         l = nbytes;
 856       if (l == 0)
 857         return 0;
 858       if (buf != NULL)
 859         {
 860           /* Really read into BUF.  */
 861           if (bfd_bread (buf, l, abfd->my_archive) != l)
 862             return -1;
 863         }
 864       else
 865         {
 866           /* Make as if we are reading.  */
 867           if (bfd_seek (abfd->my_archive, l, SEEK_CUR) != 0)
 868             return -1;
 869         }
 870
 871       if (buf != NULL)
 872         buf += l;
 873       vec->blk_off += l;
 874       nbytes -= l;
 875       res += l;
 876     }
 877   return res;
 878 }
 879
 880 /* Decompress NBYTES from VEC.  Store the bytes into BUF if not NULL.  */
 881
 882 static file_ptr
 883 vms_lib_dcx (struct vms_lib_iovec *vec, unsigned char *buf, file_ptr nbytes)
 884 {
 885   struct dcxsbm_desc *sbm;
 886   unsigned int i;
 887   unsigned int offset;
 888   unsigned int j;
 889   file_ptr res = 0;
 890
 891   /* The loop below expect to deliver at least one byte.  */
 892   if (nbytes == 0)
 893     return 0;
 894
 895   /* Get the current state.  */
 896   sbm = vec->dcx_sbm;
 897   offset = vec->dcx_offset;
 898   j = vec->dcx_pos & 7;
 899
 900   for (i = vec->dcx_pos >> 3; i < vec->dcx_rlen; i++)
 901     {
 902       unsigned char b = vec->dcx_buf[i];
 903
 904       for (; j < 8; j++)
 905         {
 906           if (b & (1 << j))
 907             offset++;
 908           if (!(sbm->flags[offset >> 3] & (1 << (offset & 7))))
 909             {
 910               unsigned int n_offset = sbm->nodes[offset];
 911               if (n_offset == 0)
 912                 {
 913                   /* End of buffer.  Stay where we are.  */
 914                   vec->dcx_pos = (i << 3) + j;
 915                   if (b & (1 << j))
 916                     offset--;
 917                   vec->dcx_offset = offset;
 918                   vec->dcx_sbm = sbm;
 919                   return res;
 920                 }
 921               offset = 2 * n_offset;
 922             }
 923           else
 924             {
 925               unsigned char v = sbm->nodes[offset];
 926
 927               if (sbm->next != NULL)
 928                 sbm = vec->dcxsbms + sbm->next[v];
 929               offset = 0;
 930               res++;
 931
 932               if (buf)
 933                 {
 934                   *buf++ = v;
 935                   nbytes--;
 936
 937                   if (nbytes == 0)
 938                     {
 939                       vec->dcx_pos = (i << 3) + j + 1;
 940                       vec->dcx_offset = offset;
 941                       vec->dcx_sbm = sbm;
 942
 943                       return res;
 944                     }
 945                 }
 946             }
 947         }
 948       j = 0;
 949     }
 950   return -1;
 951 }
 952
 953 /* Standard IOVEC function.  */
 954
 955 static file_ptr
 956 vms_lib_bread (struct bfd *abfd, void *vbuf, file_ptr nbytes)
 957 {
 958   struct vms_lib_iovec *vec = (struct vms_lib_iovec *) abfd->iostream;
 959   file_ptr res;
 960   file_ptr chunk;
 961   unsigned char *buf = (unsigned char *)vbuf;
 962
 963   /* Do not read past the end.  */
 964   if (vec->where >= vec->file_len)
 965     return 0;
 966
 967   res = 0;
 968   while (nbytes > 0)
 969     {
 970       if (vec->rec_rem == 0)
 971         {
 972           unsigned char blen[2];
 973
 974           /* Read record length.  */
 975           if (vms_lib_bread_raw (abfd, blen, sizeof (blen)) != sizeof (blen))
 976             return -1;
 977           vec->rec_len = bfd_getl16 (blen);
 978           if (bfd_libdata (abfd->my_archive)->kind == vms_lib_txt)
 979             {
 980               /* Discard record size and align byte.  */
 981               vec->rec_pos = 0;
 982               vec->rec_rem = vec->rec_len;
 983             }
 984           else
 985             {
 986               /* Prepend record size.  */
 987               vec->rec_pos = REC_POS_LEN0;
 988               vec->rec_rem = (vec->rec_len + 1) & ~1;   /* With align byte.  */
 989             }
 990           if (vec->rec_len == 3)
 991             {
 992               /* Possibly end of file.  Check the pattern.  */
 993               if (vms_lib_bread_raw (abfd, vec->pattern, 4) != 4)
 994                 return -1;
 995               if (!memcmp (vec->pattern, eotdesc + 2, 3))
 996                 {
 997                   /* This is really an EOF.  */
 998                   vec->where += res;
 999                   vec->file_len = vec->where;
1000                   return res;
1001                 }
1002             }
1003
1004           if (vec->dcxsbms != NULL)
1005             {
1006               /* This is a compressed member.  */
1007               unsigned int len;
1008               file_ptr elen;
1009
1010               /* Be sure there is enough room for the expansion.  */
1011               len = (vec->rec_len + 1) & ~1;
1012               if (len > vec->dcx_max)
1013                 {
1014                   while (len > vec->dcx_max)
1015                     vec->dcx_max *= 2;
1016                   vec->dcx_buf = bfd_alloc (abfd, vec->dcx_max);
1017                   if (vec->dcx_buf == NULL)
1018                     return -1;
1019                 }
1020
1021               /* Read the compressed record.  */
1022               vec->dcx_rlen = len;
1023               if (vec->rec_len == 3)
1024                 {
1025                   /* Already read.  */
1026                   memcpy (vec->dcx_buf, vec->pattern, 3);
1027                 }
1028               else
1029                 {
1030                   elen = vms_lib_bread_raw (abfd, vec->dcx_buf, len);
1031                   if (elen != len)
1032                     return -1;
1033                 }
1034
1035               /* Dummy expansion to get the expanded length.  */
1036               vec->dcx_offset = 0;
1037               vec->dcx_sbm = vec->dcxsbms;
1038               vec->dcx_pos = 0;
1039               elen = vms_lib_dcx (vec, NULL, 0x10000);
1040               if (elen < 0)
1041                 return -1;
1042               vec->rec_len = elen;
1043               vec->rec_rem = elen;
1044
1045               /* Reset the state.  */
1046               vec->dcx_offset = 0;
1047               vec->dcx_sbm = vec->dcxsbms;
1048               vec->dcx_pos = 0;
1049             }
1050         }
1051       if (vec->rec_pos < 0)
1052         {
1053           unsigned char c;
1054           switch (vec->rec_pos)
1055             {
1056             case REC_POS_LEN0:
1057               c = vec->rec_len & 0xff;
1058               vec->rec_pos = REC_POS_LEN1;
1059               break;
1060             case REC_POS_LEN1:
1061               c = (vec->rec_len >> 8) & 0xff;
1062               vec->rec_pos = 0;
1063               break;
1064             case REC_POS_PAD:
1065               c = 0;
1066               vec->rec_rem = 0;
1067               break;
1068             case REC_POS_NL:
1069               c = '\n';
1070               vec->rec_rem = 0;
1071               break;
1072             default:
1073               abort ();
1074             }
1075           if (buf != NULL)
1076             {
1077               *buf = c;
1078               buf++;
1079             }
1080           nbytes--;
1081           res++;
1082           continue;
1083         }
1084
1085       if (nbytes > vec->rec_rem)
1086         chunk = vec->rec_rem;
1087       else
1088         chunk = nbytes;
1089
1090       if (vec->dcxsbms != NULL)
1091         {
1092           /* Optimize the stat() case: no need to decompress again as we
1093              know the length.  */
1094           if (!(buf == NULL && chunk == vec->rec_rem))
1095             chunk = vms_lib_dcx (vec, buf, chunk);
1096         }
1097       else
1098         {
1099           if (vec->rec_len == 3)
1100             {
1101               if (buf != NULL)
1102                 memcpy (buf, vec->pattern + vec->rec_pos, chunk);
1103             }
1104           else
1105             chunk = vms_lib_bread_raw (abfd, buf, chunk);
1106         }
1107       if (chunk < 0)
1108         return -1;
1109       res += chunk;
1110       if (buf != NULL)
1111         buf += chunk;
1112       nbytes -= chunk;
1113       vec->rec_pos += chunk;
1114       vec->rec_rem -= chunk;
1115
1116       if (vec->rec_rem == 0)
1117         {
1118           /* End of record reached.  */
1119           if (bfd_libdata (abfd->my_archive)->kind == vms_lib_txt)
1120             {
1121               if ((vec->rec_len & 1) == 1
1122                   && vec->rec_len != 3
1123                   && vec->dcxsbms == NULL)
1124                 {
1125                   /* Eat the pad byte.  */
1126                   unsigned char pad;
1127                   if (vms_lib_bread_raw (abfd, &pad, 1) != 1)
1128                     return -1;
1129                 }
1130               vec->rec_pos = REC_POS_NL;
1131               vec->rec_rem = 1;
1132             }
1133           else
1134             {
1135               if ((vec->rec_len & 1) == 1 && vec->dcxsbms != NULL)
1136                 {
1137                   vec->rec_pos = REC_POS_PAD;
1138                   vec->rec_rem = 1;
1139                 }
1140             }
1141         }
1142     }
1143   vec->where += res;
1144   return res;
1145 }
1146
1147 /* Standard function, but we currently only handle the rewind case.  */
1148
1149 static int
1150 vms_lib_bseek (struct bfd *abfd, file_ptr offset, int whence)
1151 {
1152   struct vms_lib_iovec *vec = (struct vms_lib_iovec *) abfd->iostream;
1153
1154   if (whence == SEEK_SET && offset == 0)
1155     {
1156       vec->where = 0;
1157       vec->rec_rem = 0;
1158       vec->dcx_pos = -1;
1159       vec->blk_off = vec->init_blk_off;
1160       vec->next_block = vec->init_next_block;
1161
1162       if (bfd_seek (abfd->my_archive, vec->first_block, SEEK_SET) != 0)
1163         return -1;
1164     }
1165   else
1166     abort ();
1167   return 0;
1168 }
1169
1170 static file_ptr
1171 vms_lib_bwrite (struct bfd *abfd ATTRIBUTE_UNUSED,
1172               const void *where ATTRIBUTE_UNUSED,
1173               file_ptr nbytes ATTRIBUTE_UNUSED)
1174 {
1175   return -1;
1176 }
1177
1178 static int
1179 vms_lib_bclose (struct bfd *abfd)
1180 {
1181   abfd->iostream = NULL;
1182   return 0;
1183 }
1184
1185 static int
1186 vms_lib_bflush (struct bfd *abfd ATTRIBUTE_UNUSED)
1187 {
1188   return 0;
1189 }
1190
1191 static int
1192 vms_lib_bstat (struct bfd *abfd ATTRIBUTE_UNUSED,
1193                struct stat *sb ATTRIBUTE_UNUSED)
1194 {
1195   /* Not supported.  */
1196   return 0;
1197 }
1198
1199 static void *
1200 vms_lib_bmmap (struct bfd *abfd ATTRIBUTE_UNUSED,
1201                void *addr ATTRIBUTE_UNUSED,
1202                bfd_size_type len ATTRIBUTE_UNUSED,
1203                int prot ATTRIBUTE_UNUSED,
1204                int flags ATTRIBUTE_UNUSED,
1205                file_ptr offset ATTRIBUTE_UNUSED,
1206                void **map_addr ATTRIBUTE_UNUSED,
1207                bfd_size_type *map_len ATTRIBUTE_UNUSED)
1208 {
1209   return (void *) -1;
1210 }
1211
1212 static const struct bfd_iovec vms_lib_iovec = {
1213   &vms_lib_bread, &vms_lib_bwrite, &vms_lib_btell, &vms_lib_bseek,
1214   &vms_lib_bclose, &vms_lib_bflush, &vms_lib_bstat, &vms_lib_bmmap
1215 };
1216
1217 /* Open a library module.  FILEPOS is the position of the module header.  */
1218
1219 static bfd_boolean
1220 vms_lib_bopen (bfd *el, file_ptr filepos)
1221 {
1222   struct vms_lib_iovec *vec;
1223   unsigned char buf[256];
1224   struct vms_mhd *mhd;
1225   struct lib_tdata *tdata = bfd_libdata (el->my_archive);
1226   unsigned int len;
1227
1228   /* Allocate and initialized the iovec.  */
1229   vec = bfd_zalloc (el, sizeof (*vec));
1230   if (vec == NULL)
1231     return FALSE;
1232
1233   el->iostream = vec;
1234   el->iovec = &vms_lib_iovec;
1235
1236   /* File length is not known.  */
1237   vec->file_len = -1;
1238
1239   /* Read the first data block.  */
1240   vec->next_block = filepos & ~(VMS_BLOCK_SIZE - 1);
1241   vec->blk_off = DATA__LENGTH;
1242   if (!vms_lib_read_block (el))
1243     return FALSE;
1244
1245   /* Prepare to read the first record.  */
1246   vec->blk_off = filepos & (VMS_BLOCK_SIZE - 1);
1247   vec->rec_rem = 0;
1248   if (bfd_seek (el->my_archive, filepos, SEEK_SET) != 0)
1249     return FALSE;
1250
1251   /* Read Record length + MHD + align byte.  */
1252   len = tdata->mhd_size;
1253   if (vms_lib_bread_raw (el, buf, 2) != 2)
1254     return FALSE;
1255   if (bfd_getl16 (buf) != len)
1256     return FALSE;
1257   len = (len + 1) & ~1;
1258   BFD_ASSERT (len <= sizeof (buf));
1259   if (vms_lib_bread_raw (el, buf, len) != len)
1260     return FALSE;
1261
1262   /* Get info from mhd.  */
1263   mhd = (struct vms_mhd *)buf;
1264   /* Check id.  */
1265   if (mhd->id != MHD__C_MHDID)
1266     return FALSE;
1267   if (len >= MHD__C_MHDLEN + 1)
1268     el->selective_search = (mhd->objstat & MHD__M_SELSRC) ? 1 : 0;
1269   el->mtime = vms_rawtime_to_time_t (mhd->datim);
1270   el->mtime_set = TRUE;
1271
1272   /* Reinit the iovec so that seek() will point to the first record after
1273      the mhd.  */
1274   vec->where = 0;
1275   vec->init_blk_off = vec->blk_off;
1276   vec->init_next_block = vec->next_block;
1277   vec->first_block = bfd_tell (el->my_archive);
1278   vec->dcxsbms = bfd_libdata (el->my_archive)->dcxsbm;
1279
1280   if (vec->dcxsbms != NULL)
1281     {
1282       /* Handle DCX.  */
1283       vec->dcx_max = 10 * 1024;
1284       vec->dcx_buf = bfd_alloc (el, vec->dcx_max);
1285       vec->dcx_pos = -1;
1286       if (vec->dcx_buf == NULL)
1287         return -1;
1288     }
1289   return TRUE;
1290 }
1291
1292 /* Get member MODIDX.  Return NULL in case of error.  */
1293
1294 static bfd *
1295 _bfd_vms_lib_get_module (bfd *abfd, unsigned int modidx)
1296 {
1297   struct lib_tdata *tdata = bfd_libdata (abfd);
1298   bfd *res;
1299   file_ptr file_off;
1300   char *name;
1301
1302   /* Sanity check.  */
1303   if (modidx >= tdata->nbr_modules)
1304     return NULL;
1305
1306   /* Already loaded.  */
1307   if (tdata->cache[modidx])
1308     return tdata->cache[modidx];
1309
1310   /* Build it.  */
1311   file_off = tdata->modules[modidx].file_offset;
1312   if (tdata->type != LBR__C_TYP_IOBJ)
1313     {
1314       res = _bfd_create_empty_archive_element_shell (abfd);
1315       if (res == NULL)
1316         return NULL;
1317
1318       /* Special reader to deal with data blocks.  */
1319       if (!vms_lib_bopen (res, file_off))
1320         return NULL;
1321     }
1322   else
1323     {
1324       char buf[256];
1325       struct vms_mhd *mhd;
1326       struct areltdata *arelt;
1327
1328       /* Sanity check.  The MHD must be big enough to contain module size.  */
1329       if (tdata->mhd_size < offsetof (struct vms_mhd, modsize) + 4)
1330         return NULL;
1331
1332       /* Read the MHD now.  */
1333       if (bfd_seek (abfd, file_off, SEEK_SET) != 0)
1334         return NULL;
1335       if (bfd_bread (buf, tdata->mhd_size, abfd) != tdata->mhd_size)
1336         return NULL;
1337
1338       res = _bfd_create_empty_archive_element_shell (abfd);
1339       if (res == NULL)
1340         return NULL;
1341       arelt = bfd_zmalloc (sizeof (*arelt));
1342       if (arelt == NULL)
1343         return NULL;
1344       res->arelt_data = arelt;
1345
1346       /* Get info from mhd.  */
1347       mhd = (struct vms_mhd *)buf;
1348       if (mhd->id != MHD__C_MHDID)
1349         return NULL;
1350       if (tdata->mhd_size >= offsetof (struct vms_mhd, objstat) + 1)
1351         res->selective_search = (mhd->objstat & MHD__M_SELSRC) ? 1 : 0;
1352       res->mtime = vms_rawtime_to_time_t (mhd->datim);
1353       res->mtime_set = TRUE;
1354
1355       arelt->parsed_size = bfd_getl32 (mhd->modsize);
1356
1357       /* No need for a special reader as members are stored linearly.
1358          Just skip the MHD.  */
1359       res->origin = file_off + tdata->mhd_size;
1360     }
1361
1362   /* Set filename.  */
1363   name = tdata->modules[modidx].name;
1364   switch (tdata->type)
1365     {
1366     case LBR__C_TYP_IOBJ:
1367     case LBR__C_TYP_EOBJ:
1368       /* For object archives, append .obj to mimic standard behaviour.  */
1369       {
1370         size_t namelen = strlen (name);
1371         char *name1 = bfd_alloc (res, namelen + 4 + 1);
1372         memcpy (name1, name, namelen);
1373         strcpy (name1 + namelen, ".obj");
1374         name = name1;
1375       }
1376       break;
1377     default:
1378       break;
1379     }
1380   res->filename = xstrdup (name);
1381
1382   tdata->cache[modidx] = res;
1383
1384   return res;
1385 }
1386
1387 /* Standard function: get member at IDX.  */
1388
1389 bfd *
1390 _bfd_vms_lib_get_elt_at_index (bfd *abfd, symindex symidx)
1391 {
1392   struct lib_tdata *tdata = bfd_libdata (abfd);
1393   file_ptr file_off;
1394   unsigned int modidx;
1395
1396   /* Check symidx.  */
1397   if (symidx > tdata->artdata.symdef_count)
1398     return NULL;
1399   file_off = tdata->artdata.symdefs[symidx].file_offset;
1400
1401   /* Linear-scan.  */
1402   for (modidx = 0; modidx < tdata->nbr_modules; modidx++)
1403     {
1404       if (tdata->modules[modidx].file_offset == file_off)
1405         break;
1406     }
1407   if (modidx >= tdata->nbr_modules)
1408     return NULL;
1409
1410   return _bfd_vms_lib_get_module (abfd, modidx);
1411 }
1412
1413 /* Elements of an imagelib are stubs.  You can get the real image with this
1414    function.  */
1415
1416 bfd *
1417 _bfd_vms_lib_get_imagelib_file (bfd *el)
1418 {
1419   bfd *archive = el->my_archive;
1420   const char *modname = el->filename;
1421   int modlen = strlen (modname);
1422   char *filename;
1423   int j;
1424   bfd *res;
1425
1426   /* Convert module name to lower case and append '.exe'.  */
1427   filename = bfd_alloc (el, modlen + 5);
1428   if (filename == NULL)
1429     return NULL;
1430   for (j = 0; j < modlen; j++)
1431     if (ISALPHA (modname[j]))
1432       filename[j] = TOLOWER (modname[j]);
1433     else
1434       filename[j] = modname[j];
1435   memcpy (filename + modlen, ".exe", 5);
1436
1437   filename = _bfd_append_relative_path (archive, filename);
1438   if (filename == NULL)
1439     return NULL;
1440   res = bfd_openr (filename, NULL);
1441
1442   if (res == NULL)
1443     {
1444       (*_bfd_error_handler)(_("could not open shared image '%s' from '%s'"),
1445                             filename, archive->filename);
1446       bfd_release (archive, filename);
1447       return NULL;
1448     }
1449
1450   /* FIXME: put it in a cache ?  */
1451   return res;
1452 }
1453
1454 /* Standard function.  */
1455
1456 bfd *
1457 _bfd_vms_lib_openr_next_archived_file (bfd *archive,
1458                                        bfd *last_file)
1459 {
1460   unsigned int idx;
1461   bfd *res;
1462
1463   if (!last_file)
1464     idx = 0;
1465   else
1466     idx = last_file->proxy_origin + 1;
1467
1468   if (idx >= bfd_libdata (archive)->nbr_modules)
1469     {
1470       bfd_set_error (bfd_error_no_more_archived_files);
1471       return NULL;
1472     }
1473
1474   res = _bfd_vms_lib_get_module (archive, idx);
1475   if (res == NULL)
1476     return res;
1477   res->proxy_origin = idx;
1478   return res;
1479 }
1480
1481 /* Standard function.  Just compute the length.  */
1482
1483 int
1484 _bfd_vms_lib_generic_stat_arch_elt (bfd *abfd, struct stat *st)
1485 {
1486   struct lib_tdata *tdata;
1487
1488   /* Sanity check.  */
1489   if (abfd->my_archive == NULL)
1490     {
1491       bfd_set_error (bfd_error_invalid_operation);
1492       return -1;
1493     }
1494
1495   tdata = bfd_libdata (abfd->my_archive);
1496   if (tdata->type != LBR__C_TYP_IOBJ)
1497     {
1498       struct vms_lib_iovec *vec = (struct vms_lib_iovec *) abfd->iostream;
1499
1500       if (vec->file_len == (ufile_ptr)-1)
1501         {
1502           if (vms_lib_bseek (abfd, 0, SEEK_SET) != 0)
1503             return -1;
1504
1505           /* Compute length.  */
1506           while (vms_lib_bread (abfd, NULL, 1 << 20) > 0)
1507             ;
1508         }
1509       st->st_size = vec->file_len;
1510     }
1511   else
1512     {
1513       st->st_size = ((struct areltdata *)abfd->arelt_data)->parsed_size;
1514     }
1515
1516   if (abfd->mtime_set)
1517     st->st_mtime = abfd->mtime;
1518   else
1519     st->st_mtime = 0;
1520   st->st_uid = 0;
1521   st->st_gid = 0;
1522   st->st_mode = 0644;
1523
1524   return 0;
1525 }
1526
1527 /* Internal representation of an index entry.  */
1528
1529 struct lib_index
1530 {
1531   /* Corresponding archive member.  */
1532   bfd *abfd;
1533
1534   /* Number of reference to this entry.  */
1535   unsigned int ref;
1536
1537   /* Length of the key.  */
1538   unsigned short namlen;
1539
1540   /* Key.  */
1541   const char *name;
1542 };
1543
1544 /* Used to sort index entries.  */
1545
1546 static int
1547 lib_index_cmp (const void *lv, const void *rv)
1548 {
1549   const struct lib_index *l = lv;
1550   const struct lib_index *r = rv;
1551
1552   return strcmp (l->name, r->name);
1553 }
1554
1555 /* Maximum number of index blocks level.  */
1556
1557 #define MAX_LEVEL 10
1558
1559 /* Get the size of an index entry.  */
1560
1561 static unsigned int
1562 get_idxlen (struct lib_index *idx, bfd_boolean is_elfidx)
1563 {
1564   if (is_elfidx)
1565     {
1566       /* 9 is the size of struct vms_elfidx without keyname.  */
1567       if (idx->namlen > MAX_KEYLEN)
1568         return 9 + sizeof (struct vms_kbn);
1569       else
1570         return 9 + idx->namlen;
1571     }
1572   else
1573     {
1574       /* 7 is the size of struct vms_idx without keyname.  */
1575       return 7 + idx->namlen;
1576     }
1577 }
1578
1579 /* Write the index composed by NBR symbols contained in IDX.
1580    VBN is the first vbn to be used, and will contain on return the last vbn.
1581    Can be called with ABFD set to NULL just to size the index.
1582    If not null, TOPVBN will be assigned to the vbn of the root index tree.
1583    IS_ELFIDX is true for elfidx (ie ia64) indexes layout.
1584    Return TRUE on success.  */
1585
1586 static bfd_boolean
1587 vms_write_index (bfd *abfd,
1588                  struct lib_index *idx, unsigned int nbr, unsigned int *vbn,
1589                  unsigned int *topvbn, bfd_boolean is_elfidx)
1590 {
1591   /* The index is organized as a tree.  This function implements a naive
1592      algorithm to balance the tree: it fills the leaves, and create a new
1593      branch when all upper leaves and branches are full.  We only keep in
1594      memory a path to the current leaf.  */
1595   unsigned int i;
1596   int j;
1597   int level;
1598   /* Disk blocks for the current path.  */
1599   struct vms_indexdef *rblk[MAX_LEVEL];
1600   /* Info on the current blocks.  */
1601   struct idxblk
1602   {
1603     unsigned int vbn;           /* VBN of the block.  */
1604     /* The last entry is identified so that it could be copied to the
1605        parent block.  */
1606     unsigned short len;         /* Length up to the last entry.  */
1607     unsigned short lastlen;     /* Length of the last entry.  */
1608   } blk[MAX_LEVEL];
1609
1610   /* The kbn blocks are used to store long symbol names.  */
1611   unsigned int kbn_sz = 0;   /* Number of bytes available in the kbn block.  */
1612   unsigned int kbn_vbn = 0;  /* VBN of the kbn block.  */
1613   unsigned char *kbn_blk = NULL; /* Contents of the kbn block.  */
1614
1615   if (nbr == 0)
1616     {
1617       /* No entries.  Very easy to handle.  */
1618       if (topvbn != NULL)
1619         *topvbn = 0;
1620       return TRUE;
1621     }
1622
1623   if (abfd == NULL)
1624     {
1625       /* Sort the index the first time this function is called.  */
1626       qsort (idx, nbr, sizeof (struct lib_index), lib_index_cmp);
1627     }
1628
1629   /* Allocate first index block.  */
1630   level = 1;
1631   if (abfd != NULL)
1632     rblk[0] = bfd_zmalloc (sizeof (struct vms_indexdef));
1633   blk[0].vbn = (*vbn)++;
1634   blk[0].len = 0;
1635   blk[0].lastlen = 0;
1636
1637   for (i = 0; i < nbr; i++, idx++)
1638     {
1639       unsigned int idxlen;
1640       int flush = 0;
1641       unsigned int key_vbn = 0;
1642       unsigned int key_off = 0;
1643
1644       idxlen = get_idxlen (idx, is_elfidx);
1645
1646       if (is_elfidx && idx->namlen > MAX_KEYLEN)
1647         {
1648           /* If the key (ie name) is too long, write it in the kbn block.  */
1649           unsigned int kl = idx->namlen;
1650           unsigned int kl_chunk;
1651           const char *key = idx->name;
1652
1653           /* Write the key in the kbn, chunk after chunk.  */
1654           do
1655             {
1656               if (kbn_sz < sizeof (struct vms_kbn))
1657                 {
1658                   /* Not enough room in the kbn block.  */
1659                   if (abfd != NULL)
1660                     {
1661                       /* Write it to the disk (if there is one).  */
1662                       if (kbn_vbn != 0)
1663                         {
1664                           if (vms_write_block (abfd, kbn_vbn, kbn_blk) != TRUE)
1665                             return FALSE;
1666                         }
1667                       else
1668                         {
1669                           kbn_blk = bfd_malloc (VMS_BLOCK_SIZE);
1670                           if (kbn_blk == NULL)
1671                             return FALSE;
1672                         }
1673                       *(unsigned short *)kbn_blk = 0;
1674                     }
1675                   /* Allocate a new block for the keys.  */
1676                   kbn_vbn = (*vbn)++;
1677                   kbn_sz = VMS_BLOCK_SIZE - 2;
1678                 }
1679               /* Size of the chunk written to the current key block.  */
1680               if (kl + sizeof (struct vms_kbn) > kbn_sz)
1681                 kl_chunk = kbn_sz - sizeof (struct vms_kbn);
1682               else
1683                 kl_chunk = kl;
1684
1685               if (kbn_blk != NULL)
1686                 {
1687                   struct vms_kbn *kbn;
1688
1689                   kbn = (struct vms_kbn *)(kbn_blk + VMS_BLOCK_SIZE - kbn_sz);
1690
1691                   if (key_vbn == 0)
1692                     {
1693                       /* Save the rfa of the first chunk.  */
1694                       key_vbn = kbn_vbn;
1695                       key_off = VMS_BLOCK_SIZE - kbn_sz;
1696                     }
1697
1698                   bfd_putl16 (kl_chunk, kbn->keylen);
1699                   if (kl_chunk == kl)
1700                     {
1701                       /* No next chunk.  */
1702                       bfd_putl32 (0, kbn->rfa.vbn);
1703                       bfd_putl16 (0, kbn->rfa.offset);
1704                     }
1705                   else
1706                     {
1707                       /* Next chunk will be at the start of the next block.  */
1708                       bfd_putl32 (*vbn, kbn->rfa.vbn);
1709                       bfd_putl16 (2, kbn->rfa.offset);
1710                     }
1711                   memcpy ((char *)(kbn + 1), key, kl_chunk);
1712                   key += kl_chunk;
1713                 }
1714               kl -= kl_chunk;
1715               kl_chunk = (kl_chunk + 1) & ~1;     /* Always align.  */
1716               kbn_sz -= kl_chunk + sizeof (struct vms_kbn);
1717             }
1718           while (kl > 0);
1719         }
1720
1721       /* Check if a block might overflow.  In this case we will flush this
1722          block and all the blocks below it.  */
1723       for (j = 0; j < level; j++)
1724         if (blk[j].len + blk[j].lastlen + idxlen > INDEXDEF__BLKSIZ)
1725           flush = j + 1;
1726
1727       for (j = 0; j < level; j++)
1728         {
1729           if (j < flush)
1730             {
1731               /* There is not enough room to write the new entry in this
1732                  block or in a parent block.  */
1733
1734               if (j + 1 == level)
1735                 {
1736                   BFD_ASSERT (level < MAX_LEVEL);
1737
1738                   /* Need to create a parent.  */
1739                   if (abfd != NULL)
1740                     {
1741                       rblk[level] = bfd_zmalloc (sizeof (struct vms_indexdef));
1742                       bfd_putl32 (*vbn, rblk[j]->parent);
1743                     }
1744                   blk[level].vbn = (*vbn)++;
1745                   blk[level].len = 0;
1746                   blk[level].lastlen = blk[j].lastlen;
1747
1748                   level++;
1749                 }
1750
1751               /* Update parent block: write the last entry from the current
1752                  block.  */
1753               if (abfd != NULL)
1754                 {
1755                   struct vms_rfa *rfa;
1756
1757                   /* Pointer to the last entry in parent block.  */
1758                   rfa = (struct vms_rfa *)(rblk[j + 1]->keys + blk[j + 1].len);
1759
1760                   /* Copy the whole entry.  */
1761                   BFD_ASSERT (blk[j + 1].lastlen == blk[j].lastlen);
1762                   memcpy (rfa, rblk[j]->keys + blk[j].len, blk[j].lastlen);
1763                   /* Fix the entry (which in always the first field of an
1764                      entry.  */
1765                   bfd_putl32 (blk[j].vbn, rfa->vbn);
1766                   bfd_putl16 (RFADEF__C_INDEX, rfa->offset);
1767                 }
1768
1769               if (j + 1 == flush)
1770                 {
1771                   /* And allocate it.  Do it only on the block that won't be
1772                      flushed (so that the parent of the parent can be
1773                      updated too).  */
1774                   blk[j + 1].len += blk[j + 1].lastlen;
1775                   blk[j + 1].lastlen = 0;
1776                 }
1777
1778               /* Write this block on the disk.  */
1779               if (abfd != NULL)
1780                 {
1781                   bfd_putl16 (blk[j].len + blk[j].lastlen, rblk[j]->used);
1782                   if (vms_write_block (abfd, blk[j].vbn, rblk[j]) != TRUE)
1783                     return FALSE;
1784                 }
1785
1786               /* Reset this block.  */
1787               blk[j].len = 0;
1788               blk[j].lastlen = 0;
1789               blk[j].vbn = (*vbn)++;
1790             }
1791
1792           /* Append it to the block.  */
1793           if (j == 0)
1794             {
1795               /* Keep the previous last entry.  */
1796               blk[j].len += blk[j].lastlen;
1797
1798               if (abfd != NULL)
1799                 {
1800                   struct vms_rfa *rfa;
1801
1802                   rfa = (struct vms_rfa *)(rblk[j]->keys + blk[j].len);
1803                   bfd_putl32 ((idx->abfd->proxy_origin / VMS_BLOCK_SIZE) + 1,
1804                               rfa->vbn);
1805                   bfd_putl16
1806                     ((idx->abfd->proxy_origin % VMS_BLOCK_SIZE)
1807                      + (is_elfidx ? 0 : DATA__DATA),
1808                      rfa->offset);
1809
1810                   if (is_elfidx)
1811                     {
1812                       /* Use elfidx format.  */
1813                       struct vms_elfidx *en = (struct vms_elfidx *)rfa;
1814
1815                       en->flags = 0;
1816                       if (key_vbn != 0)
1817                         {
1818                           /* Long symbol name.  */
1819                           struct vms_kbn *k = (struct vms_kbn *)(en->keyname);
1820                           bfd_putl16 (sizeof (struct vms_kbn), en->keylen);
1821                           bfd_putl16 (idx->namlen, k->keylen);
1822                           bfd_putl32 (key_vbn, k->rfa.vbn);
1823                           bfd_putl16 (key_off, k->rfa.offset);
1824                           en->flags |= ELFIDX__SYMESC;
1825                         }
1826                       else
1827                         {
1828                           bfd_putl16 (idx->namlen, en->keylen);
1829                           memcpy (en->keyname, idx->name, idx->namlen);
1830                         }
1831                     }
1832                   else
1833                     {
1834                       /* Use idx format.  */
1835                       struct vms_idx *en = (struct vms_idx *)rfa;
1836                       en->keylen = idx->namlen;
1837                       memcpy (en->keyname, idx->name, idx->namlen);
1838                     }
1839                 }
1840             }
1841           /* The last added key can now be the last one all blocks in the
1842              path.  */
1843           blk[j].lastlen = idxlen;
1844         }
1845     }
1846
1847   /* Save VBN of the root.  */
1848   if (topvbn != NULL)
1849     *topvbn = blk[level - 1].vbn;
1850
1851   if (abfd == NULL)
1852     return TRUE;
1853
1854   /* Flush.  */
1855   for (j = 1; j < level; j++)
1856     {
1857       /* Update parent block: write the new entry.  */
1858       unsigned char *en;
1859       unsigned char *par;
1860       struct vms_rfa *rfa;
1861
1862       en = rblk[j - 1]->keys + blk[j - 1].len;
1863       par = rblk[j]->keys + blk[j].len;
1864       BFD_ASSERT (blk[j].lastlen == blk[j - 1].lastlen);
1865       memcpy (par, en, blk[j - 1].lastlen);
1866       rfa = (struct vms_rfa *)par;
1867       bfd_putl32 (blk[j - 1].vbn, rfa->vbn);
1868       bfd_putl16 (RFADEF__C_INDEX, rfa->offset);
1869     }
1870
1871   for (j = 0; j < level; j++)
1872     {
1873       /* Write this block on the disk.  */
1874       bfd_putl16 (blk[j].len + blk[j].lastlen, rblk[j]->used);
1875       if (vms_write_block (abfd, blk[j].vbn, rblk[j]) != TRUE)
1876         return FALSE;
1877
1878       free (rblk[j]);
1879     }
1880
1881   /* Write the last kbn (if any).  */
1882   if (kbn_vbn != 0)
1883     {
1884       if (vms_write_block (abfd, kbn_vbn, kbn_blk) != TRUE)
1885         return FALSE;
1886       free (kbn_blk);
1887     }
1888
1889   return TRUE;
1890 }
1891
1892 /* Append data to the data block DATA.  Force write if PAD is true.  */
1893
1894 static bfd_boolean
1895 vms_write_data_block (bfd *arch, struct vms_datadef *data, file_ptr *off,
1896                       const unsigned char *buf, unsigned int len, int pad)
1897 {
1898   while (len > 0 || pad)
1899     {
1900       unsigned int doff = *off & (VMS_BLOCK_SIZE - 1);
1901       unsigned int remlen = (DATA__LENGTH - DATA__DATA) - doff;
1902       unsigned int l;
1903
1904       l = (len > remlen) ? remlen : len;
1905       memcpy (data->data + doff, buf, l);
1906       buf += l;
1907       len -= l;
1908       doff += l;
1909       *off += l;
1910
1911       if (doff == (DATA__LENGTH - DATA__DATA) || (len == 0 && pad))
1912         {
1913           data->recs = 0;
1914           data->fill_1 = 0;
1915           bfd_putl32 ((*off / VMS_BLOCK_SIZE) + 2, data->link);
1916
1917           if (bfd_bwrite (data, sizeof (*data), arch) != sizeof (*data))
1918             return FALSE;
1919
1920           *off += DATA__LENGTH - doff;
1921
1922           if (len == 0)
1923             break;
1924         }
1925     }
1926   return TRUE;
1927 }
1928
1929 /* Build the symbols index.  */
1930
1931 static bfd_boolean
1932 _bfd_vms_lib_build_map (unsigned int nbr_modules,
1933                         struct lib_index *modules,
1934                         unsigned int *res_cnt,
1935                         struct lib_index **res)
1936 {
1937   unsigned int i;
1938   asymbol **syms = NULL;
1939   long syms_max = 0;
1940   struct lib_index *map = NULL;
1941   unsigned int map_max = 1024;          /* Fine initial default.  */
1942   unsigned int map_count = 0;
1943
1944   map = (struct lib_index *) bfd_malloc (map_max * sizeof (struct lib_index));
1945   if (map == NULL)
1946     goto error_return;
1947
1948   /* Gather symbols.  */
1949   for (i = 0; i < nbr_modules; i++)
1950     {
1951       long storage;
1952       long symcount;
1953       long src_count;
1954       bfd *current = modules[i].abfd;
1955
1956       if ((bfd_get_file_flags (current) & HAS_SYMS) == 0)
1957         continue;
1958
1959       storage = bfd_get_symtab_upper_bound (current);
1960       if (storage < 0)
1961         goto error_return;
1962
1963       if (storage != 0)
1964         {
1965           if (storage > syms_max)
1966             {
1967               if (syms_max > 0)
1968                 free (syms);
1969               syms_max = storage;
1970               syms = (asymbol **) bfd_malloc (syms_max);
1971               if (syms == NULL)
1972                 goto error_return;
1973             }
1974           symcount = bfd_canonicalize_symtab (current, syms);
1975           if (symcount < 0)
1976             goto error_return;
1977
1978           /* Now map over all the symbols, picking out the ones we
1979              want.  */
1980           for (src_count = 0; src_count < symcount; src_count++)
1981             {
1982               flagword flags = (syms[src_count])->flags;
1983               asection *sec = syms[src_count]->section;
1984
1985               if ((flags & BSF_GLOBAL
1986                    || flags & BSF_WEAK
1987                    || flags & BSF_INDIRECT
1988                    || bfd_is_com_section (sec))
1989                   && ! bfd_is_und_section (sec))
1990                 {
1991                   struct lib_index *new_map;
1992
1993                   /* This symbol will go into the archive header.  */
1994                   if (map_count == map_max)
1995                     {
1996                       map_max *= 2;
1997                       new_map = (struct lib_index *)
1998                         bfd_realloc (map, map_max * sizeof (struct lib_index));
1999                       if (new_map == NULL)
2000                         goto error_return;
2001                       map = new_map;
2002                     }
2003
2004                   map[map_count].abfd = current;
2005                   map[map_count].namlen = strlen (syms[src_count]->name);
2006                   map[map_count].name = syms[src_count]->name;
2007                   map_count++;
2008                   modules[i].ref++;
2009                 }
2010             }
2011         }
2012     }
2013
2014   *res_cnt = map_count;
2015   *res = map;
2016   return TRUE;
2017
2018  error_return:
2019   if (syms_max > 0)
2020     free (syms);
2021   if (map != NULL)
2022     free (map);
2023   return FALSE;
2024 }
2025
2026 /* Do the hard work: write an archive on the disk.  */
2027
2028 bfd_boolean
2029 _bfd_vms_lib_write_archive_contents (bfd *arch)
2030 {
2031   bfd *current;
2032   unsigned int nbr_modules;
2033   struct lib_index *modules;
2034   unsigned int nbr_symbols;
2035   struct lib_index *symbols;
2036   struct lib_tdata *tdata = bfd_libdata (arch);
2037   unsigned int i;
2038   file_ptr off;
2039   unsigned int nbr_mod_iblk;
2040   unsigned int nbr_sym_iblk;
2041   unsigned int vbn;
2042   unsigned int mod_idx_vbn;
2043   unsigned int sym_idx_vbn;
2044   bfd_boolean is_elfidx = tdata->kind == vms_lib_ia64;
2045   unsigned int max_keylen = is_elfidx ? MAX_EKEYLEN : MAX_KEYLEN;
2046
2047   /* Count the number of modules (and do a first sanity check).  */
2048   nbr_modules = 0;
2049   for (current = arch->archive_head;
2050        current != NULL;
2051        current = current->archive_next)
2052     {
2053       /* This check is checking the bfds for the objects we're reading
2054          from (which are usually either an object file or archive on
2055          disk), not the archive entries we're writing to.  We don't
2056          actually create bfds for the archive members, we just copy
2057          them byte-wise when we write out the archive.  */
2058       if (bfd_write_p (current) || !bfd_check_format (current, bfd_object))
2059         {
2060           bfd_set_error (bfd_error_invalid_operation);
2061           goto input_err;
2062         }
2063
2064       nbr_modules++;
2065     }
2066
2067   /* Build the modules list.  */
2068   BFD_ASSERT (tdata->modules == NULL);
2069   modules = bfd_alloc (arch, nbr_modules * sizeof (struct lib_index));
2070   if (modules == NULL)
2071     return FALSE;
2072
2073   for (current = arch->archive_head, i = 0;
2074        current != NULL;
2075        current = current->archive_next, i++)
2076     {
2077       unsigned int nl;
2078
2079       modules[i].abfd = current;
2080       modules[i].name = vms_get_module_name (current->filename, FALSE);
2081       modules[i].ref = 1;
2082
2083       /* FIXME: silently truncate long names ?  */
2084       nl = strlen (modules[i].name);
2085       modules[i].namlen = (nl > max_keylen ? max_keylen : nl);
2086     }
2087
2088   /* Create the module index.  */
2089   vbn = 0;
2090   if (!vms_write_index (NULL, modules, nbr_modules, &vbn, NULL, is_elfidx))
2091     return FALSE;
2092   nbr_mod_iblk = vbn;
2093
2094   /* Create symbol index.  */
2095   if (!_bfd_vms_lib_build_map (nbr_modules, modules, &nbr_symbols, &symbols))
2096     return FALSE;
2097
2098   vbn = 0;
2099   if (!vms_write_index (NULL, symbols, nbr_symbols, &vbn, NULL, is_elfidx))
2100     return FALSE;
2101   nbr_sym_iblk = vbn;
2102
2103   /* Write modules and remember their position.  */
2104   off = (1 + nbr_mod_iblk + nbr_sym_iblk) * VMS_BLOCK_SIZE;
2105
2106   if (bfd_seek (arch, off, SEEK_SET) != 0)
2107     return FALSE;
2108
2109   for (i = 0; i < nbr_modules; i++)
2110     {
2111       struct vms_datadef data;
2112       unsigned char blk[VMS_BLOCK_SIZE];
2113       struct vms_mhd *mhd;
2114       unsigned int sz;
2115
2116       current = modules[i].abfd;
2117       current->proxy_origin = off;
2118
2119       if (is_elfidx)
2120         sz = 0;
2121       else
2122         {
2123           /* Write the MHD as a record (ie, size first).  */
2124           sz = 2;
2125           bfd_putl16 (tdata->mhd_size, blk);
2126         }
2127       mhd = (struct vms_mhd *)(blk + sz);
2128       memset (mhd, 0, sizeof (struct vms_mhd));
2129       mhd->lbrflag = 0;
2130       mhd->id = MHD__C_MHDID;
2131       mhd->objidlng = 4;
2132       memcpy (mhd->objid, "V1.0", 4);
2133       bfd_putl32 (modules[i].ref, mhd->refcnt);
2134       /* FIXME: datim.  */
2135
2136       sz += tdata->mhd_size;
2137       sz = (sz + 1) & ~1;
2138
2139       /* Rewind the member to be put into the archive.  */
2140       if (bfd_seek (current, 0, SEEK_SET) != 0)
2141         goto input_err;
2142
2143       /* Copy the member into the archive.  */
2144       if (is_elfidx)
2145         {
2146           unsigned int modsize = 0;
2147           bfd_size_type amt;
2148           file_ptr off_hdr = off;
2149
2150           /* Read to complete the first block.  */
2151           amt = bfd_bread (blk + sz, VMS_BLOCK_SIZE - sz, current);
2152           if (amt == (bfd_size_type)-1)
2153             goto input_err;
2154           modsize = amt;
2155           if (amt < VMS_BLOCK_SIZE - sz)
2156             {
2157               /* The member size is less than a block.  Pad the block.  */
2158               memset (blk + sz + amt, 0, VMS_BLOCK_SIZE - sz - amt);
2159             }
2160           bfd_putl32 (modsize, mhd->modsize);
2161
2162           /* Write the first block (which contains an mhd).  */
2163           if (bfd_bwrite (blk, VMS_BLOCK_SIZE, arch) != VMS_BLOCK_SIZE)
2164             goto input_err;
2165           off += VMS_BLOCK_SIZE;
2166
2167           if (amt == VMS_BLOCK_SIZE - sz)
2168             {
2169               /* Copy the remaining.  */
2170               char buffer[DEFAULT_BUFFERSIZE];
2171
2172               while (1)
2173                 {
2174                   amt = bfd_bread (buffer, sizeof (buffer), current);
2175                   if (amt == (bfd_size_type)-1)
2176                     goto input_err;
2177                   if (amt == 0)
2178                     break;
2179                   modsize += amt;
2180                   if (amt != sizeof (buffer))
2181                     {
2182                       /* Clear the padding.  */
2183                       memset (buffer + amt, 0, sizeof (buffer) - amt);
2184                       amt = (amt + VMS_BLOCK_SIZE) & ~(VMS_BLOCK_SIZE - 1);
2185                     }
2186                   if (bfd_bwrite (buffer, amt, arch) != amt)
2187                     goto input_err;
2188                   off += amt;
2189                 }
2190
2191               /* Now that the size is known, write the first block (again).  */
2192               bfd_putl32 (modsize, mhd->modsize);
2193               if (bfd_seek (arch, off_hdr, SEEK_SET) != 0
2194                   || bfd_bwrite (blk, VMS_BLOCK_SIZE, arch) != VMS_BLOCK_SIZE)
2195                 goto input_err;
2196               if (bfd_seek (arch, off, SEEK_SET) != 0)
2197                 goto input_err;
2198             }
2199         }
2200       else
2201         {
2202           /* Write the MHD.  */
2203           if (vms_write_data_block (arch, &data, &off, blk, sz, 0) < 0)
2204             goto input_err;
2205
2206           /* Write the member.  */
2207           while (1)
2208             {
2209               sz = bfd_bread (blk, sizeof (blk), current);
2210               if (sz == 0)
2211                 break;
2212               if (vms_write_data_block (arch, &data, &off, blk, sz, 0) < 0)
2213                 goto input_err;
2214             }
2215
2216           /* Write the end of module marker.  */
2217           if (vms_write_data_block (arch, &data, &off,
2218                                     eotdesc, sizeof (eotdesc), 1) < 0)
2219             goto input_err;
2220         }
2221     }
2222
2223   /* Write the indexes.  */
2224   vbn = 2;
2225   if (vms_write_index (arch, modules, nbr_modules, &vbn, &mod_idx_vbn,
2226                        is_elfidx) != TRUE)
2227     return FALSE;
2228   if (vms_write_index (arch, symbols, nbr_symbols, &vbn, &sym_idx_vbn,
2229                        is_elfidx) != TRUE)
2230     return FALSE;
2231
2232   /* Write libary header.  */
2233   {
2234     unsigned char blk[VMS_BLOCK_SIZE];
2235     struct vms_lhd *lhd = (struct vms_lhd *)blk;
2236     struct vms_idd *idd = (struct vms_idd *)(blk + sizeof (*lhd));
2237     unsigned int idd_flags;
2238     unsigned int saneid;
2239
2240     memset (blk, 0, sizeof (blk));
2241
2242     lhd->type = tdata->type;
2243     lhd->nindex = 2;
2244     switch (tdata->kind)
2245       {
2246       case vms_lib_alpha:
2247         saneid = LHD_SANEID3;
2248         break;
2249       case vms_lib_ia64:
2250         saneid = LHD_SANEID6;
2251         break;
2252       default:
2253         abort ();
2254       }
2255     bfd_putl32 (saneid, lhd->sanity);
2256     bfd_putl16 (tdata->ver, lhd->majorid);
2257     bfd_putl16 (0, lhd->minorid);
2258     snprintf ((char *)lhd->lbrver + 1, sizeof (lhd->lbrver) - 1,
2259               "GNU ar %u.%u.%u",
2260               (unsigned)(BFD_VERSION / 100000000UL),
2261               (unsigned)(BFD_VERSION / 1000000UL) % 100,
2262               (unsigned)(BFD_VERSION / 10000UL) % 100);
2263     lhd->lbrver[sizeof (lhd->lbrver) - 1] = 0;
2264     lhd->lbrver[0] = strlen ((char *)lhd->lbrver + 1);
2265
2266     bfd_putl32 (tdata->credat_lo, lhd->credat + 0);
2267     bfd_putl32 (tdata->credat_hi, lhd->credat + 4);
2268     vms_raw_get_time (lhd->updtim);
2269
2270     lhd->mhdusz = tdata->mhd_size - MHD__C_USRDAT;
2271
2272     bfd_putl32 (nbr_modules + nbr_symbols, lhd->idxcnt);
2273     bfd_putl32 (nbr_modules, lhd->modcnt);
2274     bfd_putl32 (nbr_modules, lhd->modhdrs);
2275
2276     /* Number of blocks for index.  */
2277     bfd_putl32 (nbr_mod_iblk + nbr_sym_iblk, lhd->idxblks);
2278     bfd_putl32 (vbn - 1, lhd->hipreal);
2279     bfd_putl32 (vbn - 1, lhd->hiprusd);
2280
2281     /* VBN of the next free block.  */
2282     bfd_putl32 ((off / VMS_BLOCK_SIZE) + 1, lhd->nextvbn);
2283     bfd_putl32 ((off / VMS_BLOCK_SIZE) + 1, lhd->nextrfa + 0);
2284     bfd_putl16 (0, lhd->nextrfa + 4);
2285
2286     /* First index (modules name).  */
2287     idd_flags = IDD__FLAGS_ASCII | IDD__FLAGS_VARLENIDX
2288       | IDD__FLAGS_NOCASECMP | IDD__FLAGS_NOCASENTR;
2289     bfd_putl16 (idd_flags, idd->flags);
2290     bfd_putl16 (max_keylen + 1, idd->keylen);
2291     bfd_putl16 (mod_idx_vbn, idd->vbn);
2292     idd++;
2293
2294     /* Second index (symbols name).  */
2295     bfd_putl16 (idd_flags, idd->flags);
2296     bfd_putl16 (max_keylen + 1, idd->keylen);
2297     bfd_putl16 (sym_idx_vbn, idd->vbn);
2298     idd++;
2299
2300     if (vms_write_block (arch, 1, blk) != TRUE)
2301       return FALSE;
2302   }
2303
2304   return TRUE;
2305
2306  input_err:
2307   bfd_set_error (bfd_error_on_input, current, bfd_get_error ());
2308   return FALSE;
2309 }
2310
2311 /* Add a target for text library.  This costs almost nothing and is useful to
2312    read VMS library on the host.  */
2313
2314 const bfd_target alpha_vms_lib_txt_vec =
2315 {
2316   "vms-libtxt",                 /* Name.  */
2317   bfd_target_unknown_flavour,
2318   BFD_ENDIAN_UNKNOWN,           /* byteorder */
2319   BFD_ENDIAN_UNKNOWN,           /* header_byteorder */
2320   0,                            /* Object flags.  */
2321   0,                            /* Sect flags.  */
2322   0,                            /* symbol_leading_char.  */
2323   ' ',                          /* ar_pad_char.  */
2324   15,                           /* ar_max_namelen.  */
2325   0,                            /* match priority.  */
2326   bfd_getl64, bfd_getl_signed_64, bfd_putl64,
2327   bfd_getl32, bfd_getl_signed_32, bfd_putl32,
2328   bfd_getl16, bfd_getl_signed_16, bfd_putl16,
2329   bfd_getl64, bfd_getl_signed_64, bfd_putl64,
2330   bfd_getl32, bfd_getl_signed_32, bfd_putl32,
2331   bfd_getl16, bfd_getl_signed_16, bfd_putl16,
2332
2333   {_bfd_dummy_target, _bfd_dummy_target,        /* bfd_check_format.  */
2334    _bfd_vms_lib_txt_archive_p, _bfd_dummy_target},
2335   {bfd_false, bfd_false, bfd_false, bfd_false}, /* bfd_set_format.  */
2336   {bfd_false, bfd_false, bfd_false, bfd_false}, /* bfd_write_contents.  */
2337
2338   BFD_JUMP_TABLE_GENERIC (_bfd_generic),
2339   BFD_JUMP_TABLE_COPY (_bfd_generic),
2340   BFD_JUMP_TABLE_CORE (_bfd_nocore),
2341   BFD_JUMP_TABLE_ARCHIVE (_bfd_vms_lib),
2342   BFD_JUMP_TABLE_SYMBOLS (_bfd_nosymbols),
2343   BFD_JUMP_TABLE_RELOCS (_bfd_norelocs),
2344   BFD_JUMP_TABLE_WRITE (_bfd_nowrite),
2345   BFD_JUMP_TABLE_LINK (_bfd_nolink),
2346   BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
2347
2348   NULL,
2349
2350   NULL
2351 };