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