bfd/vms-lib.c

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