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