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    Can be called with ABFD set to NULL just to size the index.
1555    Return TRUE on success.  */
1556
1557 static bfd_boolean
1558 vms_write_index (bfd *abfd,
1559                  struct lib_index *idx, unsigned int nbr, unsigned int *vbn,
1560                  unsigned int *topvbn, bfd_boolean is_elfidx)
1561 {
1562   unsigned int i;
1563   int j;
1564   int level;
1565   struct vms_indexdef *rblk[MAX_LEVEL];
1566   struct idxblk
1567   {
1568     unsigned int vbn;
1569     unsigned short len;
1570     unsigned short lastlen;
1571   } blk[MAX_LEVEL];
1572
1573   /* The kbn blocks are used to store long symbol names.  */
1574   unsigned int kbn_sz = 0;   /* Number of bytes available in the kbn block.  */
1575   unsigned int kbn_vbn = 0;  /* VBN of the kbn block.  */
1576   unsigned char *kbn_blk = NULL; /* Contents of the kbn block.  */
1577
1578   if (nbr == 0)
1579     {
1580       /* No entries.  Very easy to handle.  */
1581       if (topvbn != NULL)
1582         *topvbn = 0;
1583       return TRUE;
1584     }
1585
1586   if (abfd == NULL)
1587     {
1588       /* Sort the index the first time this function is called.  */
1589       qsort (idx, nbr, sizeof (struct lib_index), lib_index_cmp);
1590     }
1591
1592   /* Allocate first index block.  */
1593   level = 1;
1594   if (abfd != NULL)
1595     rblk[0] = bfd_zmalloc (sizeof (struct vms_indexdef));
1596   blk[0].vbn = (*vbn)++;
1597   blk[0].len = 0;
1598   blk[0].lastlen = 0;
1599
1600   for (i = 0; i < nbr; i++, idx++)
1601     {
1602       unsigned int idxlen;
1603       int flush = 0;
1604       unsigned int key_vbn = 0;
1605       unsigned int key_off = 0;
1606
1607       idxlen = get_idxlen (idx, is_elfidx);
1608
1609       if (is_elfidx && idx->namlen >= MAX_KEYLEN)
1610         {
1611           /* If the key (ie name) is too long, write it in the kbn block.  */
1612           unsigned int kl = idx->namlen;
1613           unsigned int kl_chunk;
1614           const char *key = idx->name;
1615
1616           /* Write the key in the kbn, chunk after chunk.  */
1617           do
1618             {
1619               if (kbn_sz < sizeof (struct vms_kbn))
1620                 {
1621                   /* Not enough room in the kbn block.  */
1622                   if (abfd != NULL)
1623                     {
1624                       /* Write it to the disk (if there is one).  */
1625                       if (kbn_vbn != 0)
1626                         {
1627                           if (vms_write_block (abfd, kbn_vbn, kbn_blk) != TRUE)
1628                             return FALSE;
1629                         }
1630                       else
1631                         {
1632                           kbn_blk = bfd_malloc (VMS_BLOCK_SIZE);
1633                           if (kbn_blk == NULL)
1634                             return FALSE;
1635                         }
1636                       *(unsigned short *)kbn_blk = 0;
1637                     }
1638                   kbn_vbn = (*vbn)++;
1639                   kbn_sz = VMS_BLOCK_SIZE - 2;
1640                 }
1641               if (kl + sizeof (struct vms_kbn) > kbn_sz)
1642                 kl_chunk = kbn_sz - sizeof (struct vms_kbn);
1643               else
1644                 kl_chunk = kl;
1645
1646               if (kbn_blk != NULL)
1647                 {
1648                   struct vms_kbn *kbn;
1649
1650                   kbn = (struct vms_kbn *)(kbn_blk + VMS_BLOCK_SIZE - kbn_sz);
1651
1652                   if (key_vbn == 0)
1653                     {
1654                       /* Save the rfa of the first chunk.  */
1655                       key_vbn = kbn_vbn;
1656                       key_off = VMS_BLOCK_SIZE - kbn_sz;
1657                     }
1658
1659                   bfd_putl16 (kl_chunk, kbn->keylen);
1660                   if (kl_chunk == kl)
1661                     {
1662                       /* No next chunk.  */
1663                       bfd_putl32 (0, kbn->rfa.vbn);
1664                       bfd_putl16 (0, kbn->rfa.offset);
1665                     }
1666                   else
1667                     {
1668                       /* Next chunk will be at the start of the next block.  */
1669                       bfd_putl32 (*vbn, kbn->rfa.vbn);
1670                       bfd_putl16 (2, kbn->rfa.offset);
1671                     }
1672                   memcpy ((char *)(kbn + 1), key, kl_chunk);
1673                   key += kl_chunk;
1674                 }
1675               kl -= kl_chunk;
1676               kl_chunk = (kl_chunk + 1) & ~1;     /* Always align.  */
1677               kbn_sz -= kl_chunk + sizeof (struct vms_kbn);
1678             }
1679           while (kl > 0);
1680         }
1681
1682       /* Check if a block might overflow.  In this case we will flush this
1683          block and all the blocks below it.  */
1684       for (j = 0; j < level; j++)
1685         if (blk[j].len + blk[j].lastlen + idxlen > INDEXDEF__BLKSIZ)
1686           flush = j + 1;
1687
1688       for (j = 0; j < level; j++)
1689         {
1690           if (j < flush)
1691             {
1692               /* There is not enough room to write the new entry in this
1693                  block or in a parent block.  */
1694
1695               if (j + 1 == level)
1696                 {
1697                   BFD_ASSERT (level < MAX_LEVEL);
1698
1699                   /* Need to create a parent.  */
1700                   if (abfd != NULL)
1701                     {
1702                       rblk[level] = bfd_zmalloc (sizeof (struct vms_indexdef));
1703                       bfd_putl32 (*vbn, rblk[j]->parent);
1704                     }
1705                   blk[level].vbn = (*vbn)++;
1706                   blk[level].len = 0;
1707                   blk[level].lastlen = 0;
1708
1709                   level++;
1710                 }
1711
1712               /* Update parent block: write the new entry.  */
1713               if (abfd != NULL)
1714                 {
1715                   struct vms_rfa *rfa;
1716
1717                   /* Copy the whole entry.  */
1718                   memcpy (rblk[j + 1]->keys + blk[j + 1].len,
1719                           rblk[j]->keys + blk[j].len,
1720                           blk[j].lastlen);
1721                   /* Fix the entry (which in always the first field of an
1722                      entry.  */
1723                   rfa = (struct vms_rfa *)(rblk[j + 1]->keys + blk[j + 1].len);
1724                   bfd_putl32 (blk[j].vbn, rfa->vbn);
1725                   bfd_putl16 (RFADEF__C_INDEX, rfa->offset);
1726                 }
1727
1728               if (j + 1 == flush)
1729                 {
1730                   /* And allocate it.  Do it only on the block that won't be
1731                      flushed (so that the parent of the parent can be
1732                      updated too).  */
1733                   blk[j + 1].len += blk[j].lastlen;
1734                   blk[j + 1].lastlen = 0;
1735                 }
1736
1737               /* Write this block on the disk.  */
1738               if (abfd != NULL)
1739                 {
1740                   bfd_putl16 (blk[j].len + blk[j].lastlen, rblk[j]->used);
1741                   if (vms_write_block (abfd, blk[j].vbn, rblk[j]) != TRUE)
1742                     return FALSE;
1743                 }
1744
1745               /* Reset this block.  */
1746               blk[j].len = 0;
1747               blk[j].lastlen = 0;
1748               blk[j].vbn = (*vbn)++;
1749             }
1750
1751           /* Append it to the block.  */
1752           if (j == 0)
1753             {
1754               blk[j].len += blk[j].lastlen;
1755
1756               if (abfd != NULL)
1757                 {
1758                   struct vms_rfa *rfa;
1759
1760                   rfa = (struct vms_rfa *)(rblk[j]->keys + blk[j].len);
1761                   bfd_putl32 ((idx->abfd->proxy_origin / VMS_BLOCK_SIZE) + 1,
1762                               rfa->vbn);
1763                   bfd_putl16
1764                     ((idx->abfd->proxy_origin % VMS_BLOCK_SIZE)
1765                      + (is_elfidx ? 0 : DATA__DATA),
1766                      rfa->offset);
1767
1768                   if (is_elfidx)
1769                     {
1770                       /* Use elfidx format.  */
1771                       struct vms_elfidx *en = (struct vms_elfidx *)rfa;
1772
1773                       en->flags = 0;
1774                       if (key_vbn != 0)
1775                         {
1776                           /* Long symbol name.  */
1777                           struct vms_kbn *k = (struct vms_kbn *)(en->keyname);
1778                           bfd_putl16 (sizeof (struct vms_kbn), en->keylen);
1779                           bfd_putl16 (idx->namlen, k->keylen);
1780                           bfd_putl32 (key_vbn, k->rfa.vbn);
1781                           bfd_putl16 (key_off, k->rfa.offset);
1782                           en->flags |= ELFIDX__SYMESC;
1783                         }
1784                       else
1785                         {
1786                           bfd_putl16 (idx->namlen, en->keylen);
1787                           memcpy (en->keyname, idx->name, idx->namlen);
1788                         }
1789                     }
1790                   else
1791                     {
1792                       /* Use idx format.  */
1793                       struct vms_idx *en = (struct vms_idx *)rfa;
1794                       en->keylen = idx->namlen;
1795                       memcpy (en->keyname, idx->name, idx->namlen);
1796                     }
1797                 }
1798             }
1799
1800           blk[j].lastlen = idxlen;
1801         }
1802     }
1803
1804   if (topvbn != NULL)
1805     *topvbn = blk[level - 1].vbn;
1806
1807   if (abfd == NULL)
1808     return TRUE;
1809
1810   /* Flush.  */
1811   for (j = 1; j < level; j++)
1812     {
1813       /* Update parent block: write the new entry.  */
1814       unsigned char *en;
1815       unsigned char *par;
1816       struct vms_rfa *rfa;
1817
1818       en = rblk[j - 1]->keys + blk[j - 1].len;
1819       par = rblk[j]->keys + blk[j].len;
1820       memcpy (par, en, blk[j - 1].lastlen);
1821       rfa = (struct vms_rfa *)par;
1822       bfd_putl32 (blk[j - 1].vbn, rfa->vbn);
1823       bfd_putl16 (RFADEF__C_INDEX, rfa->offset);
1824     }
1825
1826   for (j = 0; j < level; j++)
1827     {
1828       /* Write this block on the disk.  */
1829       bfd_putl16 (blk[j].len + blk[j].lastlen, rblk[j]->used);
1830       if (vms_write_block (abfd, blk[j].vbn, rblk[j]) != TRUE)
1831         return FALSE;
1832
1833       free (rblk[j]);
1834     }
1835
1836   /* Write the last kbn (if any).  */
1837   if (kbn_vbn != 0)
1838     {
1839       if (vms_write_block (abfd, kbn_vbn, kbn_blk) != TRUE)
1840         return FALSE;
1841     }
1842
1843   return TRUE;
1844 }
1845
1846 /* Append data to the data block DATA.  Force write if PAD is true.  */
1847
1848 static bfd_boolean
1849 vms_write_data_block (bfd *arch, struct vms_datadef *data, file_ptr *off,
1850                       const unsigned char *buf, unsigned int len, int pad)
1851 {
1852   while (len > 0 || pad)
1853     {
1854       unsigned int doff = *off & (VMS_BLOCK_SIZE - 1);
1855       unsigned int remlen = (DATA__LENGTH - DATA__DATA) - doff;
1856       unsigned int l;
1857
1858       l = (len > remlen) ? remlen : len;
1859       memcpy (data->data + doff, buf, l);
1860       buf += l;
1861       len -= l;
1862       doff += l;
1863       *off += l;
1864
1865       if (doff == (DATA__LENGTH - DATA__DATA) || (len == 0 && pad))
1866         {
1867           data->recs = 0;
1868           data->fill_1 = 0;
1869           bfd_putl32 ((*off / VMS_BLOCK_SIZE) + 2, data->link);
1870
1871           if (bfd_bwrite (data, sizeof (*data), arch) != sizeof (*data))
1872             return FALSE;
1873
1874           *off += DATA__LENGTH - doff;
1875
1876           if (len == 0)
1877             break;
1878         }
1879     }
1880   return TRUE;
1881 }
1882
1883 /* Build the symbols index.  */
1884
1885 static bfd_boolean
1886 _bfd_vms_lib_build_map (unsigned int nbr_modules,
1887                         struct lib_index *modules,
1888                         unsigned int *res_cnt,
1889                         struct lib_index **res)
1890 {
1891   unsigned int i;
1892   asymbol **syms = NULL;
1893   long syms_max = 0;
1894   struct lib_index *map = NULL;
1895   unsigned int map_max = 1024;          /* Fine initial default.  */
1896   unsigned int map_count = 0;
1897
1898   map = (struct lib_index *) bfd_malloc (map_max * sizeof (struct lib_index));
1899   if (map == NULL)
1900     goto error_return;
1901
1902   /* Gather symbols.  */
1903   for (i = 0; i < nbr_modules; i++)
1904     {
1905       long storage;
1906       long symcount;
1907       long src_count;
1908       bfd *current = modules[i].abfd;
1909
1910       if ((bfd_get_file_flags (current) & HAS_SYMS) == 0)
1911         continue;
1912
1913       storage = bfd_get_symtab_upper_bound (current);
1914       if (storage < 0)
1915         goto error_return;
1916
1917       if (storage != 0)
1918         {
1919           if (storage > syms_max)
1920             {
1921               if (syms_max > 0)
1922                 free (syms);
1923               syms_max = storage;
1924               syms = (asymbol **) bfd_malloc (syms_max);
1925               if (syms == NULL)
1926                 goto error_return;
1927             }
1928           symcount = bfd_canonicalize_symtab (current, syms);
1929           if (symcount < 0)
1930             goto error_return;
1931
1932           /* Now map over all the symbols, picking out the ones we
1933              want.  */
1934           for (src_count = 0; src_count < symcount; src_count++)
1935             {
1936               flagword flags = (syms[src_count])->flags;
1937               asection *sec = syms[src_count]->section;
1938
1939               if ((flags & BSF_GLOBAL
1940                    || flags & BSF_WEAK
1941                    || flags & BSF_INDIRECT
1942                    || bfd_is_com_section (sec))
1943                   && ! bfd_is_und_section (sec))
1944                 {
1945                   struct lib_index *new_map;
1946
1947                   /* This symbol will go into the archive header.  */
1948                   if (map_count == map_max)
1949                     {
1950                       map_max *= 2;
1951                       new_map = (struct lib_index *)
1952                         bfd_realloc (map, map_max * sizeof (struct lib_index));
1953                       if (new_map == NULL)
1954                         goto error_return;
1955                       map = new_map;
1956                     }
1957
1958                   map[map_count].abfd = current;
1959                   map[map_count].namlen = strlen (syms[src_count]->name);
1960                   map[map_count].name = syms[src_count]->name;
1961                   map_count++;
1962                   modules[i].ref++;
1963                 }
1964             }
1965         }
1966     }
1967
1968   *res_cnt = map_count;
1969   *res = map;
1970   return TRUE;
1971
1972  error_return:
1973   if (syms_max > 0)
1974     free (syms);
1975   if (map != NULL)
1976     free (map);
1977   return FALSE;
1978 }
1979
1980 /* Do the hard work: write an archive on the disk.  */
1981
1982 bfd_boolean
1983 _bfd_vms_lib_write_archive_contents (bfd *arch)
1984 {
1985   bfd *current;
1986   unsigned int nbr_modules;
1987   struct lib_index *modules;
1988   unsigned int nbr_symbols;
1989   struct lib_index *symbols;
1990   struct lib_tdata *tdata = bfd_libdata (arch);
1991   unsigned int i;
1992   file_ptr off;
1993   unsigned int nbr_mod_iblk;
1994   unsigned int nbr_sym_iblk;
1995   unsigned int vbn;
1996   unsigned int mod_idx_vbn;
1997   unsigned int sym_idx_vbn;
1998   bfd_boolean is_elfidx = tdata->kind == vms_lib_ia64;
1999
2000   /* Count the number of modules (and do a first sanity check).  */
2001   nbr_modules = 0;
2002   for (current = arch->archive_head;
2003        current != NULL;
2004        current = current->archive_next)
2005     {
2006       /* This check is checking the bfds for the objects we're reading
2007          from (which are usually either an object file or archive on
2008          disk), not the archive entries we're writing to.  We don't
2009          actually create bfds for the archive members, we just copy
2010          them byte-wise when we write out the archive.  */
2011       if (bfd_write_p (current) || !bfd_check_format (current, bfd_object))
2012         {
2013           bfd_set_error (bfd_error_invalid_operation);
2014           goto input_err;
2015         }
2016
2017       nbr_modules++;
2018     }
2019
2020   /* Build the modules list.  */
2021   BFD_ASSERT (tdata->modules == NULL);
2022   modules = bfd_alloc (arch, nbr_modules * sizeof (struct lib_index));
2023   if (modules == NULL)
2024     return FALSE;
2025
2026   for (current = arch->archive_head, i = 0;
2027        current != NULL;
2028        current = current->archive_next, i++)
2029     {
2030       int nl;
2031
2032       modules[i].abfd = current;
2033       modules[i].name = vms_get_module_name (current->filename, FALSE);
2034       modules[i].ref = 1;
2035
2036       /* FIXME: silently truncate long names ?  */
2037       nl = strlen (modules[i].name);
2038       modules[i].namlen = (nl > MAX_KEYLEN ? MAX_KEYLEN : nl);
2039     }
2040
2041   /* Create the module index.  */
2042   vbn = 0;
2043   if (!vms_write_index (NULL, modules, nbr_modules, &vbn, NULL, is_elfidx))
2044     return FALSE;
2045   nbr_mod_iblk = vbn;
2046
2047   /* Create symbol index.  */
2048   if (!_bfd_vms_lib_build_map (nbr_modules, modules, &nbr_symbols, &symbols))
2049     return FALSE;
2050
2051   vbn = 0;
2052   if (!vms_write_index (NULL, symbols, nbr_symbols, &vbn, NULL, is_elfidx))
2053     return FALSE;
2054   nbr_sym_iblk = vbn;
2055
2056   /* Write modules and remember their position.  */
2057   off = (1 + nbr_mod_iblk + nbr_sym_iblk) * VMS_BLOCK_SIZE;
2058
2059   if (bfd_seek (arch, off, SEEK_SET) != 0)
2060     return FALSE;
2061
2062   for (i = 0; i < nbr_modules; i++)
2063     {
2064       struct vms_datadef data;
2065       unsigned char blk[VMS_BLOCK_SIZE];
2066       struct vms_mhd *mhd;
2067       unsigned int sz;
2068
2069       current = modules[i].abfd;
2070       current->proxy_origin = off;
2071
2072       if (is_elfidx)
2073         sz = 0;
2074       else
2075         {
2076           /* Write the MHD as a record (ie, size first).  */
2077           sz = 2;
2078           bfd_putl16 (tdata->mhd_size, blk);
2079         }
2080       mhd = (struct vms_mhd *)(blk + sz);
2081       memset (mhd, 0, sizeof (struct vms_mhd));
2082       mhd->lbrflag = 0;
2083       mhd->id = MHD__C_MHDID;
2084       mhd->objidlng = 4;
2085       memcpy (mhd->objid, "V1.0", 4);
2086       bfd_putl32 (modules[i].ref, mhd->refcnt);
2087       /* FIXME: datim.  */
2088
2089       sz += tdata->mhd_size;
2090       sz = (sz + 1) & ~1;
2091
2092       /* Rewind the member to be put into the archive.  */
2093       if (bfd_seek (current, 0, SEEK_SET) != 0)
2094         goto input_err;
2095
2096       /* Copy the member into the archive.  */
2097       if (is_elfidx)
2098         {
2099           unsigned int modsize = 0;
2100           bfd_size_type amt;
2101           file_ptr off_hdr = off;
2102
2103           /* Read to complete the first block.  */
2104           amt = bfd_bread (blk + sz, VMS_BLOCK_SIZE - sz, current);
2105           if (amt == (bfd_size_type)-1)
2106             goto input_err;
2107           modsize = amt;
2108           if (amt < VMS_BLOCK_SIZE - sz)
2109             {
2110               /* The member size is less than a block.  Pad the block.  */
2111               memset (blk + sz + amt, 0, VMS_BLOCK_SIZE - sz - amt);
2112             }
2113           bfd_putl32 (modsize, mhd->modsize);
2114
2115           /* Write the first block (which contains an mhd).  */
2116           if (bfd_bwrite (blk, VMS_BLOCK_SIZE, arch) != VMS_BLOCK_SIZE)
2117             goto input_err;
2118           off += VMS_BLOCK_SIZE;
2119
2120           if (amt == VMS_BLOCK_SIZE - sz)
2121             {
2122               /* Copy the remaining.  */
2123               char buffer[DEFAULT_BUFFERSIZE];
2124
2125               while (1)
2126                 {
2127                   amt = bfd_bread (buffer, sizeof (buffer), current);
2128                   if (amt == (bfd_size_type)-1)
2129                     goto input_err;
2130                   if (amt == 0)
2131                     break;
2132                   modsize += amt;
2133                   if (amt != sizeof (buffer))
2134                     {
2135                       /* Clear the padding.  */
2136                       memset (buffer + amt, 0, sizeof (buffer) - amt);
2137                       amt = (amt + VMS_BLOCK_SIZE) & ~(VMS_BLOCK_SIZE - 1);
2138                     }
2139                   if (bfd_bwrite (buffer, amt, arch) != amt)
2140                     goto input_err;
2141                   off += amt;
2142                 }
2143
2144               /* Now that the size is known, write the first block (again).  */
2145               bfd_putl32 (modsize, mhd->modsize);
2146               if (bfd_seek (arch, off_hdr, SEEK_SET) != 0
2147                   || bfd_bwrite (blk, VMS_BLOCK_SIZE, arch) != VMS_BLOCK_SIZE)
2148                 goto input_err;
2149               if (bfd_seek (arch, off, SEEK_SET) != 0)
2150                 goto input_err;
2151             }
2152         }
2153       else
2154         {
2155           /* Write the MHD.  */
2156           if (vms_write_data_block (arch, &data, &off, blk, sz, 0) < 0)
2157             goto input_err;
2158
2159           /* Write the member.  */
2160           while (1)
2161             {
2162               sz = bfd_bread (blk, sizeof (blk), current);
2163               if (sz == 0)
2164                 break;
2165               if (vms_write_data_block (arch, &data, &off, blk, sz, 0) < 0)
2166                 goto input_err;
2167             }
2168
2169           /* Write the end of module marker.  */
2170           if (vms_write_data_block (arch, &data, &off,
2171                                     eotdesc, sizeof (eotdesc), 1) < 0)
2172             goto input_err;
2173         }
2174     }
2175
2176   /* Write the indexes.  */
2177   vbn = 2;
2178   if (vms_write_index (arch, modules, nbr_modules, &vbn, &mod_idx_vbn,
2179                        is_elfidx) != TRUE)
2180     return FALSE;
2181   if (vms_write_index (arch, symbols, nbr_symbols, &vbn, &sym_idx_vbn,
2182                        is_elfidx) != TRUE)
2183     return FALSE;
2184
2185   /* Write libary header.  */
2186   {
2187     unsigned char blk[VMS_BLOCK_SIZE];
2188     struct vms_lhd *lhd = (struct vms_lhd *)blk;
2189     struct vms_idd *idd = (struct vms_idd *)(blk + sizeof (*lhd));
2190     unsigned int idd_flags;
2191     unsigned int saneid;
2192
2193     memset (blk, 0, sizeof (blk));
2194
2195     lhd->type = tdata->type;
2196     lhd->nindex = 2;
2197     switch (tdata->kind)
2198       {
2199       case vms_lib_alpha:
2200         saneid = LHD_SANEID3;
2201         break;
2202       case vms_lib_ia64:
2203         saneid = LHD_SANEID6;
2204         break;
2205       default:
2206         abort ();
2207       }
2208     bfd_putl32 (saneid, lhd->sanity);
2209     bfd_putl16 (tdata->ver, lhd->majorid);
2210     bfd_putl16 (0, lhd->minorid);
2211     snprintf ((char *)lhd->lbrver + 1, sizeof (lhd->lbrver) - 1,
2212               "GNU ar %u.%u.%u",
2213               (unsigned)(BFD_VERSION / 100000000UL),
2214               (unsigned)(BFD_VERSION / 1000000UL) % 100,
2215               (unsigned)(BFD_VERSION / 10000UL) % 100);
2216     lhd->lbrver[sizeof (lhd->lbrver) - 1] = 0;
2217     lhd->lbrver[0] = strlen ((char *)lhd->lbrver + 1);
2218
2219     bfd_putl32 (tdata->credat_lo, lhd->credat + 0);
2220     bfd_putl32 (tdata->credat_hi, lhd->credat + 4);
2221     vms_raw_get_time (lhd->updtim);
2222
2223     lhd->mhdusz = tdata->mhd_size - MHD__C_USRDAT;
2224
2225     bfd_putl32 (nbr_modules + nbr_symbols, lhd->idxcnt);
2226     bfd_putl32 (nbr_modules, lhd->modcnt);
2227     bfd_putl32 (nbr_modules, lhd->modhdrs);
2228
2229     bfd_putl32 (vbn - 1, lhd->hipreal);
2230     bfd_putl32 (vbn - 1, lhd->hiprusd);
2231
2232     /* First index (modules name).  */
2233     idd_flags = IDD__FLAGS_ASCII | IDD__FLAGS_VARLENIDX
2234       | IDD__FLAGS_NOCASECMP | IDD__FLAGS_NOCASENTR;
2235     bfd_putl16 (idd_flags, idd->flags);
2236     bfd_putl16 (MAX_KEYLEN, idd->keylen);
2237     bfd_putl16 (mod_idx_vbn, idd->vbn);
2238     idd++;
2239
2240     /* Second index (symbols name).  */
2241     bfd_putl16 (idd_flags, idd->flags);
2242     bfd_putl16 (MAX_KEYLEN, idd->keylen);
2243     bfd_putl16 (sym_idx_vbn, idd->vbn);
2244     idd++;
2245
2246     if (vms_write_block (arch, 1, blk) != TRUE)
2247       return FALSE;
2248   }
2249
2250   return TRUE;
2251
2252  input_err:
2253   bfd_set_error (bfd_error_on_input, current, bfd_get_error ());
2254   return FALSE;
2255 }
2256
2257 /* Add a target for text library.  This costs almost nothing and is useful to
2258    read VMS library on the host.  */
2259
2260 const bfd_target vms_lib_txt_vec =
2261 {
2262   "vms-libtxt",                 /* Name.  */
2263   bfd_target_unknown_flavour,
2264   BFD_ENDIAN_UNKNOWN,           /* byteorder */
2265   BFD_ENDIAN_UNKNOWN,           /* header_byteorder */
2266   0,                            /* Object flags.  */
2267   0,                            /* Sect flags.  */
2268   0,                            /* symbol_leading_char.  */
2269   ' ',                          /* ar_pad_char.  */
2270   15,                           /* ar_max_namelen.  */
2271   bfd_getl64, bfd_getl_signed_64, bfd_putl64,
2272   bfd_getl32, bfd_getl_signed_32, bfd_putl32,
2273   bfd_getl16, bfd_getl_signed_16, bfd_putl16,
2274   bfd_getl64, bfd_getl_signed_64, bfd_putl64,
2275   bfd_getl32, bfd_getl_signed_32, bfd_putl32,
2276   bfd_getl16, bfd_getl_signed_16, bfd_putl16,
2277
2278   {_bfd_dummy_target, _bfd_dummy_target,        /* bfd_check_format.  */
2279    _bfd_vms_lib_txt_archive_p, _bfd_dummy_target},
2280   {bfd_false, bfd_false, bfd_false, bfd_false}, /* bfd_set_format.  */
2281   {bfd_false, bfd_false, bfd_false, bfd_false}, /* bfd_write_contents.  */
2282
2283   BFD_JUMP_TABLE_GENERIC (_bfd_generic),
2284   BFD_JUMP_TABLE_COPY (_bfd_generic),
2285   BFD_JUMP_TABLE_CORE (_bfd_nocore),
2286   BFD_JUMP_TABLE_ARCHIVE (_bfd_vms_lib),
2287   BFD_JUMP_TABLE_SYMBOLS (_bfd_nosymbols),
2288   BFD_JUMP_TABLE_RELOCS (_bfd_norelocs),
2289   BFD_JUMP_TABLE_WRITE (_bfd_nowrite),
2290   BFD_JUMP_TABLE_LINK (_bfd_nolink),
2291   BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),
2292
2293   NULL,
2294
2295   (PTR) 0
2296 };