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