1 /* BFD back-end for VMS archive files.
3 Copyright 2010 Free Software Foundation, Inc.
4 Written by Tristan Gingold <gingold@adacore.com>, AdaCore.
6 This file is part of BFD, the Binary File Descriptor library.
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.
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.
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. */
26 #include "safe-ctype.h"
32 /* The standard VMS disk block size. */
33 #ifndef VMS_BLOCK_SIZE
34 #define VMS_BLOCK_SIZE 512
37 /* Maximum key length (which is also the maximum symbol length in archive). */
38 #define MAX_KEYLEN 129
44 unsigned char min_char;
45 unsigned char max_char;
51 /* Kind of library. Used to filter in archive_p. */
61 /* Back-end private data. */
65 /* Standard tdata for an archive. But we don't use many fields. */
66 struct artdata artdata;
71 /* Type of the archive. */
74 /* Kind of archive. Summary of its type. */
75 enum vms_lib_kind kind;
77 /* Total size of the mhd (element header). */
78 unsigned int mhd_size;
80 /* Vector of modules (archive elements), already sorted. */
81 unsigned int nbr_modules;
82 struct carsym *modules;
85 /* DCX (decompression) data. */
86 unsigned int nbr_dcxsbm;
87 struct dcxsbm_desc *dcxsbm;
90 #define bfd_libdata(bfd) ((struct lib_tdata *)((bfd)->tdata.any))
92 /* End-Of-Text pattern. This is a special record to mark the end of file. */
94 static const unsigned char eotdesc[] = { 0x03, 0x00, 0x77, 0x00, 0x77, 0x00 };
96 /* Describe the current state of carsym entries while building the archive
97 table of content. Things are simple with Alpha archives as the number
98 of entries is known, but with IA64 archives a entry can make a reference
99 to severals members. Therefore we must be able to extend the table on the
100 fly, but it should be allocated on the bfd - which doesn't support realloc.
101 To reduce the overhead, the table is initially allocated in the BFD's
102 objalloc and extended if necessary on the heap. In the later case, it
103 is finally copied to the BFD's objalloc so that it will automatically be
108 /* The table of content. */
111 /* Number of entries used in the table. */
114 /* Maximum number of entries. */
117 /* If true, the table was reallocated on the heap. If false, it is still
118 in the BFD's objalloc. */
119 bfd_boolean realloced;
122 /* Simply add a name to the index. */
125 vms_add_index (struct carsym_mem *cs, char *name,
126 unsigned int idx_vbn, unsigned int idx_off)
128 if (cs->nbr == cs->max)
132 cs->max = 2 * cs->max + 32;
136 n = bfd_malloc2 (cs->max, sizeof (struct carsym));
139 memcpy (n, cs->idx, cs->nbr * sizeof (struct carsym));
140 /* And unfortunately we can't free cs->idx. */
144 n = bfd_realloc_or_free (cs->idx, cs->nbr * sizeof (struct carsym));
149 cs->realloced = TRUE;
151 cs->idx[cs->nbr].file_offset = (idx_vbn - 1) * VMS_BLOCK_SIZE + idx_off;
152 cs->idx[cs->nbr].name = name;
157 /* Follow all member of a lns list (pointed by RFA) and add indexes for
158 NAME. Return FALSE in case of error. */
161 vms_add_indexes_from_list (bfd *abfd, struct carsym_mem *cs, char *name,
170 vbn = bfd_getl32 (rfa->vbn);
175 off = (vbn - 1) * VMS_BLOCK_SIZE + bfd_getl16 (rfa->offset);
176 if (bfd_seek (abfd, off, SEEK_SET) != 0
177 || bfd_bread (&lns, sizeof (lns), abfd) != sizeof (lns))
180 if (!vms_add_index (cs, name,
181 bfd_getl32 (lns.modrfa.vbn),
182 bfd_getl16 (lns.modrfa.offset)))
189 /* Read block VBN from ABFD and store it into BLK. */
192 vms_read_block (bfd *abfd, unsigned int vbn, void *blk)
196 /* Read the index block. */
197 off = (vbn - 1) * VMS_BLOCK_SIZE;
198 if (bfd_seek (abfd, off, SEEK_SET) != 0
199 || bfd_bread (blk, VMS_BLOCK_SIZE, abfd) != VMS_BLOCK_SIZE)
205 /* Read index block VBN and put the entry in **IDX (which is updated).
206 If the entry is indirect, recurse. */
209 vms_traverse_index (bfd *abfd, unsigned int vbn, struct carsym_mem *cs)
211 struct vms_indexdef indexdef;
216 /* Read the index block. */
217 BFD_ASSERT (sizeof (indexdef) == VMS_BLOCK_SIZE);
218 if (!vms_read_block (abfd, vbn, &indexdef))
222 p = &indexdef.keys[0];
223 endp = p + bfd_getl16 (indexdef.used);
226 unsigned int idx_vbn;
227 unsigned int idx_off;
229 unsigned char *keyname;
232 /* Extract key length. */
233 if (bfd_libdata (abfd)->ver == LBR_MAJORID)
235 struct vms_idx *ridx = (struct vms_idx *)p;
237 idx_vbn = bfd_getl32 (ridx->rfa.vbn);
238 idx_off = bfd_getl16 (ridx->rfa.offset);
240 keylen = ridx->keylen;
242 keyname = ridx->keyname;
244 else if (bfd_libdata (abfd)->ver == LBR_ELFMAJORID)
246 struct vms_elfidx *ridx = (struct vms_elfidx *)p;
248 idx_vbn = bfd_getl32 (ridx->rfa.vbn);
249 idx_off = bfd_getl16 (ridx->rfa.offset);
251 keylen = bfd_getl16 (ridx->keylen);
253 keyname = ridx->keyname;
262 if (idx_off == RFADEF__C_INDEX)
264 /* Indirect entry. Recurse. */
265 if (!vms_traverse_index (abfd, idx_vbn, cs))
270 /* Add a new entry. */
273 if (flags & ELFIDX__SYMESC)
275 /* Extended key name. */
276 unsigned int noff = 0;
280 unsigned char kblk[VMS_BLOCK_SIZE];
283 if (keylen != sizeof (struct vms_kbn))
286 kbn = (struct vms_kbn *)keyname;
287 keylen = bfd_getl16 (kbn->keylen);
289 name = bfd_alloc (abfd, keylen + 1);
292 kvbn = bfd_getl32 (kbn->rfa.vbn);
293 koff = bfd_getl16 (kbn->rfa.offset);
295 /* Read the key, chunk by chunk. */
300 if (!vms_read_block (abfd, kvbn, kblk))
302 kbn = (struct vms_kbn *)(kblk + koff);
303 klen = bfd_getl16 (kbn->keylen);
304 kvbn = bfd_getl32 (kbn->rfa.vbn);
305 koff = bfd_getl16 (kbn->rfa.offset);
307 memcpy (name + noff, kbn + 1, klen);
318 /* Usual key name. */
319 name = bfd_alloc (abfd, keylen + 1);
323 memcpy (name, keyname, keylen);
327 if (flags & ELFIDX__LISTRFA)
332 off = (idx_vbn - 1) * VMS_BLOCK_SIZE + idx_off;
333 if (bfd_seek (abfd, off, SEEK_SET) != 0
334 || bfd_bread (&lhs, sizeof (lhs), abfd) != sizeof (lhs))
337 /* FIXME: this adds extra entries that were not accounted. */
338 if (!vms_add_indexes_from_list (abfd, cs, name, &lhs.ng_g_rfa))
340 if (!vms_add_indexes_from_list (abfd, cs, name, &lhs.ng_wk_rfa))
342 if (!vms_add_indexes_from_list (abfd, cs, name, &lhs.g_g_rfa))
344 if (!vms_add_indexes_from_list (abfd, cs, name, &lhs.g_wk_rfa))
349 if (!vms_add_index (cs, name, idx_vbn, idx_off))
354 /* Point to the next index entry. */
355 p = keyname + keylen;
361 /* Read index #IDX, which must have NBREL entries. */
363 static struct carsym *
364 vms_lib_read_index (bfd *abfd, int idx, unsigned int *nbrel)
369 struct carsym *csbuf;
370 struct carsym_mem csm;
372 /* Read index desription. */
373 if (bfd_seek (abfd, LHD_IDXDESC + idx * IDD_LENGTH, SEEK_SET) != 0
374 || bfd_bread (&idd, sizeof (idd), abfd) != sizeof (idd))
378 flags = bfd_getl16 (idd.flags);
379 if (!(flags & IDD__FLAGS_ASCII)
380 || !(flags & IDD__FLAGS_VARLENIDX))
383 csbuf = bfd_alloc (abfd, *nbrel * sizeof (struct carsym));
389 csm.realloced = FALSE;
392 /* Note: if the index is empty, there is no block to traverse. */
393 vbn = bfd_getl32 (idd.vbn);
394 if (vbn != 0 && !vms_traverse_index (abfd, vbn, &csm))
396 if (csm.realloced && csm.idx != NULL)
399 /* Note: in case of error, we can free what was allocated on the
401 bfd_release (abfd, csbuf);
407 /* There are more entries than the first estimate. Allocate on
408 the BFD's objalloc. */
409 csbuf = bfd_alloc (abfd, csm.nbr * sizeof (struct carsym));
412 memcpy (csbuf, csm.idx, csm.nbr * sizeof (struct carsym));
419 /* Standard function. */
421 static const bfd_target *
422 _bfd_vms_lib_archive_p (bfd *abfd, enum vms_lib_kind kind)
426 struct lib_tdata *tdata_hold;
427 struct lib_tdata *tdata;
429 unsigned int nbr_ent;
432 if (bfd_bread (&lhd, sizeof (lhd), abfd) != sizeof (lhd))
434 if (bfd_get_error () != bfd_error_system_call)
435 bfd_set_error (bfd_error_wrong_format);
439 /* Check sanity (= magic) number. */
440 sanity = bfd_getl32 (lhd.sanity);
441 if (!(sanity == LHD_SANEID3
442 || sanity == LHD_SANEID6
443 || sanity == LHD_SANEID_DCX))
445 bfd_set_error (bfd_error_wrong_format);
449 /* Check archive kind. */
453 if ((lhd.type != LBR__C_TYP_EOBJ && lhd.type != LBR__C_TYP_ESHSTB)
454 || bfd_getl32 (lhd.majorid) != 3
457 bfd_set_error (bfd_error_wrong_format);
462 if ((lhd.type != LBR__C_TYP_IOBJ && lhd.type != LBR__C_TYP_ISHSTB)
463 || bfd_getl32 (lhd.majorid) != 6
466 bfd_set_error (bfd_error_wrong_format);
471 if ((lhd.type != LBR__C_TYP_TXT
472 && lhd.type != LBR__C_TYP_MLB
473 && lhd.type != LBR__C_TYP_HLP)
474 || bfd_getl32 (lhd.majorid) != 3
477 bfd_set_error (bfd_error_wrong_format);
485 /* Allocate and initialize private data. */
486 tdata_hold = bfd_libdata (abfd);
487 tdata = (struct lib_tdata *) bfd_zalloc (abfd, sizeof (struct lib_tdata));
490 abfd->tdata.any = (void *)tdata;
491 tdata->ver = bfd_getl32 (lhd.majorid);
492 tdata->mhd_size = MHD__C_USRDAT + lhd.mhdusz;
493 tdata->type = lhd.type;
497 tdata->nbr_modules = bfd_getl32 (lhd.modcnt);
498 tdata->artdata.symdef_count = bfd_getl32 (lhd.idxcnt) - tdata->nbr_modules;
499 nbr_ent = tdata->nbr_modules;
500 tdata->modules = vms_lib_read_index (abfd, 0, &nbr_ent);
501 if (tdata->modules == NULL || nbr_ent != tdata->nbr_modules)
505 nbr_ent = tdata->artdata.symdef_count;
506 tdata->artdata.symdefs = vms_lib_read_index (abfd, 1, &nbr_ent);
507 if (tdata->artdata.symdefs == NULL)
509 /* Only IA64 archives may have more entries in the index that what
511 if (nbr_ent != tdata->artdata.symdef_count
512 && kind != vms_lib_ia64)
514 tdata->artdata.symdef_count = nbr_ent;
516 tdata->cache = bfd_zalloc (abfd, sizeof (bfd *) * tdata->nbr_modules);
517 if (tdata->cache == NULL)
520 /* Read DCX submaps. */
521 dcxvbn = bfd_getl32 (lhd.dcxmapvbn);
524 unsigned char buf_reclen[4];
527 struct vms_dcxmap *map;
528 unsigned int sbm_off;
531 if (bfd_seek (abfd, (dcxvbn - 1) * VMS_BLOCK_SIZE, SEEK_SET) != 0
532 || bfd_bread (buf_reclen, sizeof (buf_reclen), abfd)
533 != sizeof (buf_reclen))
535 reclen = bfd_getl32 (buf_reclen);
536 buf = bfd_malloc (reclen);
539 if (bfd_bread (buf, reclen, abfd) != reclen)
544 map = (struct vms_dcxmap *)buf;
545 tdata->nbr_dcxsbm = bfd_getl16 (map->nsubs);
546 sbm_off = bfd_getl16 (map->sub0);
547 tdata->dcxsbm = (struct dcxsbm_desc *)bfd_alloc
548 (abfd, tdata->nbr_dcxsbm * sizeof (struct dcxsbm_desc));
549 for (i = 0; i < tdata->nbr_dcxsbm; i++)
551 struct vms_dcxsbm *sbm = (struct vms_dcxsbm *) (buf + sbm_off);
552 struct dcxsbm_desc *sbmdesc = &tdata->dcxsbm[i];
553 unsigned int sbm_len;
556 unsigned char *data = (unsigned char *)sbm;
560 sbm_sz = bfd_getl16 (sbm->size);
562 BFD_ASSERT (sbm_off <= reclen);
564 sbmdesc->min_char = sbm->min_char;
565 BFD_ASSERT (sbmdesc->min_char == 0);
566 sbmdesc->max_char = sbm->max_char;
567 sbm_len = sbmdesc->max_char - sbmdesc->min_char + 1;
568 l = (2 * sbm_len + 7) / 8;
570 (sbm_sz >= sizeof (struct vms_dcxsbm) + l + 3 * sbm_len
571 || (tdata->nbr_dcxsbm == 1
572 && sbm_sz >= sizeof (struct vms_dcxsbm) + l + sbm_len));
573 sbmdesc->flags = (unsigned char *)bfd_alloc (abfd, l);
574 memcpy (sbmdesc->flags, data + bfd_getl16 (sbm->flags), l);
575 sbmdesc->nodes = (unsigned char *)bfd_alloc (abfd, 2 * sbm_len);
576 memcpy (sbmdesc->nodes, data + bfd_getl16 (sbm->nodes), 2 * sbm_len);
577 off = bfd_getl16 (sbm->next);
580 /* Read the 'next' array. */
581 sbmdesc->next = (unsigned short *)bfd_alloc
582 (abfd, sbm_len * sizeof (unsigned short));
584 for (j = 0; j < sbm_len; j++)
585 sbmdesc->next[j] = bfd_getl16 (buf1 + j * 2);
589 /* There is no next array if there is only one submap. */
590 BFD_ASSERT (tdata->nbr_dcxsbm == 1);
591 sbmdesc->next = NULL;
598 tdata->nbr_dcxsbm = 0;
601 /* The map is always present. Also mark shared image library. */
602 abfd->has_armap = TRUE;
603 if (tdata->type == LBR__C_TYP_ESHSTB || tdata->type == LBR__C_TYP_ISHSTB)
604 abfd->is_thin_archive = TRUE;
609 bfd_release (abfd, tdata);
610 abfd->tdata.any = (void *)tdata_hold;;
614 /* Standard function for alpha libraries. */
617 _bfd_vms_lib_alpha_archive_p (bfd *abfd)
619 return _bfd_vms_lib_archive_p (abfd, vms_lib_alpha);
622 /* Standard function for text libraries. */
624 static const bfd_target *
625 _bfd_vms_lib_txt_archive_p (bfd *abfd)
627 return _bfd_vms_lib_archive_p (abfd, vms_lib_txt);
630 /* Standard bfd function. */
633 _bfd_vms_lib_mkarchive (bfd *abfd)
635 struct lib_tdata *tdata;
637 tdata = (struct lib_tdata *) bfd_zalloc (abfd, sizeof (struct lib_tdata));
641 abfd->tdata.any = (void *)tdata;
643 tdata->mhd_size = sizeof (struct vms_mhd);
644 tdata->type = LBR__C_TYP_EOBJ;
646 tdata->nbr_modules = 0;
647 tdata->artdata.symdef_count = 0;
648 tdata->modules = NULL;
649 tdata->artdata.symdefs = NULL;
655 /* Find NAME in the symbol index. Return the index. */
658 _bfd_vms_lib_find_symbol (bfd *abfd, const char *name)
660 struct lib_tdata *tdata = bfd_libdata (abfd);
661 carsym *syms = tdata->artdata.symdefs;
664 /* Open-coded binary search for speed. */
666 hi = tdata->artdata.symdef_count - 1;
670 int mid = lo + (hi - lo) / 2;
673 diff = (char)(name[0] - syms[mid].name[0]);
675 diff = strcmp (name, syms[mid].name);
683 return BFD_NO_MORE_SYMBOLS;
686 /* IO vector for archive member. Need that because members are not linearly
687 stored in archives. */
691 /* Current offset. */
694 /* Length of the module, when known. */
697 /* Current position in the record from bfd_bread point of view (ie, after
698 decompression). 0 means that no data byte have been read, -2 and -1
699 are reserved for the length word. */
701 #define REC_POS_NL -4
702 #define REC_POS_PAD -3
703 #define REC_POS_LEN0 -2
704 #define REC_POS_LEN1 -1
707 unsigned short rec_len;
708 /* Number of bytes to read in the current record. */
709 unsigned short rec_rem;
710 /* Offset of the next block. */
712 /* Current *data* offset in the data block. */
713 unsigned short blk_off;
715 /* Offset of the first block. Extracted from the index. */
716 file_ptr first_block;
718 /* Initial next_block. Extracted when the MHD is read. */
719 file_ptr init_next_block;
720 /* Initial blk_off, once the MHD is read. */
721 unsigned short init_blk_off;
723 /* Used to store any 3 byte record, which could be the EOF pattern. */
724 unsigned char pattern[4];
727 struct dcxsbm_desc *dcxsbms;
728 /* Current submap. */
729 struct dcxsbm_desc *dcx_sbm;
730 /* Current offset in the submap. */
731 unsigned int dcx_offset;
734 /* Compressed buffer. */
735 unsigned char *dcx_buf;
736 /* Size of the buffer. Used to resize. */
737 unsigned int dcx_max;
738 /* Number of valid bytes in the buffer. */
739 unsigned int dcx_rlen;
742 /* Return the current position. */
745 vms_lib_btell (struct bfd *abfd)
747 struct vms_lib_iovec *vec = (struct vms_lib_iovec *) abfd->iostream;
751 /* Read the header of the next data block if all bytes of the current block
755 vms_lib_read_block (struct bfd *abfd)
757 struct vms_lib_iovec *vec = (struct vms_lib_iovec *) abfd->iostream;
759 if (vec->blk_off == DATA__LENGTH)
761 unsigned char hdr[DATA__DATA];
763 /* Read next block. */
764 if (bfd_seek (abfd->my_archive, vec->next_block, SEEK_SET) != 0)
766 if (bfd_bread (hdr, sizeof (hdr), abfd->my_archive) != sizeof (hdr))
768 vec->next_block = (bfd_getl32 (hdr + 2) - 1) * VMS_BLOCK_SIZE;
769 vec->blk_off = sizeof (hdr);
774 /* Read NBYTES from ABFD into BUF if not NULL. If BUF is NULL, bytes are
775 not stored. Read linearly from the library, but handle blocks. This
776 function does not handle records nor EOF. */
779 vms_lib_bread_raw (struct bfd *abfd, void *buf, file_ptr nbytes)
781 struct vms_lib_iovec *vec = (struct vms_lib_iovec *) abfd->iostream;
789 /* Be sure the current data block is read. */
790 if (!vms_lib_read_block (abfd))
793 /* Do not read past the data block, do not read more than requested. */
794 l = DATA__LENGTH - vec->blk_off;
801 /* Really read into BUF. */
802 if (bfd_bread (buf, l, abfd->my_archive) != l)
807 /* Make as if we are reading. */
808 if (bfd_seek (abfd->my_archive, l, SEEK_CUR) != 0)
821 /* Decompress NBYTES from VEC. Store the bytes into BUF if not NULL. */
824 vms_lib_dcx (struct vms_lib_iovec *vec, unsigned char *buf, file_ptr nbytes)
826 struct dcxsbm_desc *sbm;
832 /* The loop below expect to deliver at least one byte. */
836 /* Get the current state. */
838 offset = vec->dcx_offset;
839 j = vec->dcx_pos & 7;
841 for (i = vec->dcx_pos >> 3; i < vec->dcx_rlen; i++)
843 unsigned char b = vec->dcx_buf[i];
849 if (!(sbm->flags[offset >> 3] & (1 << (offset & 7))))
851 unsigned int n_offset = sbm->nodes[offset];
854 /* End of buffer. Stay where we are. */
855 vec->dcx_pos = (i << 3) + j;
858 vec->dcx_offset = offset;
862 offset = 2 * n_offset;
866 unsigned char v = sbm->nodes[offset];
868 if (sbm->next != NULL)
869 sbm = vec->dcxsbms + sbm->next[v];
880 vec->dcx_pos = (i << 3) + j + 1;
881 vec->dcx_offset = offset;
894 /* Standard IOVEC function. */
897 vms_lib_bread (struct bfd *abfd, void *buf, file_ptr nbytes)
899 struct vms_lib_iovec *vec = (struct vms_lib_iovec *) abfd->iostream;
903 /* Do not read past the end. */
904 if (vec->where >= vec->file_len)
910 if (vec->rec_rem == 0)
912 unsigned char blen[2];
914 /* Read record length. */
915 if (vms_lib_bread_raw (abfd, &blen, sizeof (blen)) != sizeof (blen))
917 vec->rec_len = bfd_getl16 (blen);
918 if (bfd_libdata (abfd->my_archive)->kind == vms_lib_txt)
920 /* Discard record size and align byte. */
922 vec->rec_rem = vec->rec_len;
926 /* Prepend record size. */
927 vec->rec_pos = REC_POS_LEN0;
928 vec->rec_rem = (vec->rec_len + 1) & ~1; /* With align byte. */
930 if (vec->rec_len == 3)
932 /* Possibly end of file. Check the pattern. */
933 if (vms_lib_bread_raw (abfd, vec->pattern, 4) != 4)
935 if (!memcmp (vec->pattern, eotdesc + 2, 3))
937 /* This is really an EOF. */
939 vec->file_len = vec->where;
944 if (vec->dcxsbms != NULL)
946 /* This is a compressed member. */
950 /* Be sure there is enough room for the expansion. */
951 len = (vec->rec_len + 1) & ~1;
952 if (len > vec->dcx_max)
954 while (len > vec->dcx_max)
956 vec->dcx_buf = bfd_alloc (abfd, vec->dcx_max);
957 if (vec->dcx_buf == NULL)
961 /* Read the compressed record. */
963 if (vec->rec_len == 3)
966 memcpy (vec->dcx_buf, vec->pattern, 3);
970 elen = vms_lib_bread_raw (abfd, vec->dcx_buf, len);
975 /* Dummy expansion to get the expanded length. */
977 vec->dcx_sbm = vec->dcxsbms;
979 elen = vms_lib_dcx (vec, NULL, 0x10000);
985 /* Reset the state. */
987 vec->dcx_sbm = vec->dcxsbms;
991 if (vec->rec_pos < 0)
994 switch (vec->rec_pos)
997 c = vec->rec_len & 0xff;
998 vec->rec_pos = REC_POS_LEN1;
1001 c = (vec->rec_len >> 8) & 0xff;
1017 *(unsigned char *)buf = c;
1025 if (nbytes > vec->rec_rem)
1026 chunk = vec->rec_rem;
1030 if (vec->dcxsbms != NULL)
1032 /* Optimize the stat() case: no need to decompress again as we
1034 if (!(buf == NULL && chunk == vec->rec_rem))
1035 chunk = vms_lib_dcx (vec, buf, chunk);
1039 if (vec->rec_len == 3)
1042 memcpy (buf, vec->pattern + vec->rec_pos, chunk);
1045 chunk = vms_lib_bread_raw (abfd, buf, chunk);
1053 vec->rec_pos += chunk;
1054 vec->rec_rem -= chunk;
1056 if (vec->rec_rem == 0)
1058 /* End of record reached. */
1059 if (bfd_libdata (abfd->my_archive)->kind == vms_lib_txt)
1061 if ((vec->rec_len & 1) == 1
1062 && vec->rec_len != 3
1063 && vec->dcxsbms == NULL)
1065 /* Eat the pad byte. */
1067 if (vms_lib_bread_raw (abfd, &pad, 1) != 1)
1070 vec->rec_pos = REC_POS_NL;
1075 if ((vec->rec_len & 1) == 1 && vec->dcxsbms != NULL)
1077 vec->rec_pos = REC_POS_PAD;
1087 /* Standard function, but we currently only handle the rewind case. */
1090 vms_lib_bseek (struct bfd *abfd, file_ptr offset, int whence)
1092 struct vms_lib_iovec *vec = (struct vms_lib_iovec *) abfd->iostream;
1094 if (whence == SEEK_SET && offset == 0)
1099 vec->blk_off = vec->init_blk_off;
1100 vec->next_block = vec->init_next_block;
1102 if (bfd_seek (abfd->my_archive, vec->first_block, SEEK_SET) != 0)
1111 vms_lib_bwrite (struct bfd *abfd ATTRIBUTE_UNUSED,
1112 const void *where ATTRIBUTE_UNUSED,
1113 file_ptr nbytes ATTRIBUTE_UNUSED)
1119 vms_lib_bclose (struct bfd *abfd)
1121 abfd->iostream = NULL;
1126 vms_lib_bflush (struct bfd *abfd ATTRIBUTE_UNUSED)
1132 vms_lib_bstat (struct bfd *abfd ATTRIBUTE_UNUSED,
1133 struct stat *sb ATTRIBUTE_UNUSED)
1135 /* Not supported. */
1140 vms_lib_bmmap (struct bfd *abfd ATTRIBUTE_UNUSED,
1141 void *addr ATTRIBUTE_UNUSED,
1142 bfd_size_type len ATTRIBUTE_UNUSED,
1143 int prot ATTRIBUTE_UNUSED,
1144 int flags ATTRIBUTE_UNUSED,
1145 file_ptr offset ATTRIBUTE_UNUSED)
1150 static const struct bfd_iovec vms_lib_iovec = {
1151 &vms_lib_bread, &vms_lib_bwrite, &vms_lib_btell, &vms_lib_bseek,
1152 &vms_lib_bclose, &vms_lib_bflush, &vms_lib_bstat, &vms_lib_bmmap
1155 /* Open a library module. FILEPOS is the position of the module header. */
1158 vms_lib_bopen (bfd *el, file_ptr filepos)
1160 struct vms_lib_iovec *vec;
1162 struct vms_mhd *mhd;
1163 struct lib_tdata *tdata = bfd_libdata (el->my_archive);
1166 /* Allocate and initialized the iovec. */
1167 vec = bfd_zalloc (el, sizeof (*vec));
1172 el->iovec = &vms_lib_iovec;
1174 /* File length is not known. */
1177 /* Read the first data block. */
1178 vec->next_block = filepos & ~(VMS_BLOCK_SIZE - 1);
1179 vec->blk_off = DATA__LENGTH;
1180 if (!vms_lib_read_block (el))
1183 /* Prepare to read the first record. */
1184 vec->blk_off = filepos & (VMS_BLOCK_SIZE - 1);
1186 if (bfd_seek (el->my_archive, filepos, SEEK_SET) != 0)
1189 /* Read Record length + MHD + align byte. */
1190 len = tdata->mhd_size;
1191 if (vms_lib_bread_raw (el, buf, 2) != 2)
1193 if (bfd_getl16 (buf) != len)
1195 len = (len + 1) & ~1;
1196 BFD_ASSERT (len <= sizeof (buf));
1197 if (vms_lib_bread_raw (el, buf, len) != len)
1200 /* Get info from mhd. */
1201 mhd = (struct vms_mhd *)buf;
1203 if (mhd->id != MHD__C_MHDID)
1205 if (len >= MHD__C_MHDLEN + 1)
1206 el->selective_search = (mhd->objstat & MHD__M_SELSRC) ? 1 : 0;
1207 el->mtime = vms_rawtime_to_time_t (mhd->datim);
1208 el->mtime_set = TRUE;
1210 /* Reinit the iovec so that seek() will point to the first record after
1213 vec->init_blk_off = vec->blk_off;
1214 vec->init_next_block = vec->next_block;
1215 vec->first_block = bfd_tell (el->my_archive);
1216 vec->dcxsbms = bfd_libdata (el->my_archive)->dcxsbm;
1218 if (vec->dcxsbms != NULL)
1221 vec->dcx_max = 10 * 1024;
1222 vec->dcx_buf = bfd_alloc (el, vec->dcx_max);
1224 if (vec->dcx_buf == NULL)
1230 /* Get member MODIDX. Return NULL in case of error. */
1233 _bfd_vms_lib_get_module (bfd *abfd, unsigned int modidx)
1235 struct lib_tdata *tdata = bfd_libdata (abfd);
1240 if (modidx >= tdata->nbr_modules)
1243 /* Already loaded. */
1244 if (tdata->cache[modidx])
1245 return tdata->cache[modidx];
1248 file_off = tdata->modules[modidx].file_offset;
1249 if (tdata->type != LBR__C_TYP_IOBJ)
1251 res = _bfd_create_empty_archive_element_shell (abfd);
1255 /* Special reader to deal with data blocks. */
1256 if (!vms_lib_bopen (res, file_off))
1262 struct vms_mhd *mhd;
1263 struct areltdata *arelt;
1265 /* Sanity check. The MHD must be big enough to contain module size. */
1266 if (tdata->mhd_size < offsetof (struct vms_mhd, modsize) + 4)
1269 /* Read the MHD now. */
1270 if (bfd_seek (abfd, file_off, SEEK_SET) != 0)
1272 if (bfd_bread (buf, tdata->mhd_size, abfd) != tdata->mhd_size)
1275 res = _bfd_create_empty_archive_element_shell (abfd);
1278 arelt = bfd_zalloc (res, sizeof (*arelt));
1281 res->arelt_data = arelt;
1283 /* Get info from mhd. */
1284 mhd = (struct vms_mhd *)buf;
1285 if (mhd->id != MHD__C_MHDID)
1287 if (tdata->mhd_size >= offsetof (struct vms_mhd, objstat) + 1)
1288 res->selective_search = (mhd->objstat & MHD__M_SELSRC) ? 1 : 0;
1289 res->mtime = vms_rawtime_to_time_t (mhd->datim);
1290 res->mtime_set = TRUE;
1292 arelt->parsed_size = bfd_getl32 (mhd->modsize);
1294 /* No need for a special reader as members are stored linearly.
1295 Just skip the MHD. */
1296 res->origin = file_off + tdata->mhd_size;
1299 res->filename = tdata->modules[modidx].name;
1301 tdata->cache[modidx] = res;
1306 /* Standard function: get member at IDX. */
1309 _bfd_vms_lib_get_elt_at_index (bfd *abfd, symindex symidx)
1311 struct lib_tdata *tdata = bfd_libdata (abfd);
1313 unsigned int modidx;
1316 if (symidx > tdata->artdata.symdef_count)
1318 file_off = tdata->artdata.symdefs[symidx].file_offset;
1321 for (modidx = 0; modidx < tdata->nbr_modules; modidx++)
1323 if (tdata->modules[modidx].file_offset == file_off)
1326 if (modidx >= tdata->nbr_modules)
1329 return _bfd_vms_lib_get_module (abfd, modidx);
1332 /* Elements of an imagelib are stubs. You can get the real image with this
1336 _bfd_vms_lib_get_imagelib_file (bfd *el)
1338 bfd *archive = el->my_archive;
1339 const char *modname = el->filename;
1340 int modlen = strlen (modname);
1345 /* Convert module name to lower case and append '.exe'. */
1346 filename = bfd_alloc (el, modlen + 5);
1347 if (filename == NULL)
1349 for (j = 0; j < modlen; j++)
1350 if (ISALPHA (modname[j]))
1351 filename[j] = TOLOWER (modname[j]);
1353 filename[j] = modname[j];
1354 memcpy (filename + modlen, ".exe", 5);
1356 filename = _bfd_append_relative_path (archive, filename);
1357 if (filename == NULL)
1359 res = bfd_openr (filename, NULL);
1363 (*_bfd_error_handler)(_("could not open shared image '%s' from '%s'"),
1364 filename, archive->filename);
1365 bfd_release (archive, filename);
1369 /* FIXME: put it in a cache ? */
1373 /* Standard function. */
1376 _bfd_vms_lib_openr_next_archived_file (bfd *archive,
1385 idx = last_file->proxy_origin + 1;
1387 if (idx >= bfd_libdata (archive)->nbr_modules)
1389 bfd_set_error (bfd_error_no_more_archived_files);
1393 res = _bfd_vms_lib_get_module (archive, idx);
1396 res->proxy_origin = idx;
1400 /* Standard function. Just compute the length. */
1403 _bfd_vms_lib_generic_stat_arch_elt (bfd *abfd, struct stat *st)
1405 struct lib_tdata *tdata;
1408 if (abfd->my_archive == NULL)
1410 bfd_set_error (bfd_error_invalid_operation);
1414 tdata = bfd_libdata (abfd->my_archive);
1415 if (tdata->type != LBR__C_TYP_IOBJ)
1417 struct vms_lib_iovec *vec = (struct vms_lib_iovec *) abfd->iostream;
1419 if (vec->file_len == (ufile_ptr)-1)
1421 if (vms_lib_bseek (abfd, 0, SEEK_SET) != 0)
1424 /* Compute length. */
1425 while (vms_lib_bread (abfd, NULL, 1 << 20) > 0)
1428 st->st_size = vec->file_len;
1432 st->st_size = ((struct areltdata *)abfd->arelt_data)->parsed_size;
1435 if (abfd->mtime_set)
1436 st->st_mtime = abfd->mtime;
1446 /* Internal representation of an index entry. */
1450 /* Corresponding archive member. */
1453 /* Number of reference to this entry. */
1456 /* Length of the key. */
1457 unsigned short namlen;
1463 /* Used to sort index entries. */
1466 vms_index_cmp (const void *lv, const void *rv)
1468 const struct vms_index *l = lv;
1469 const struct vms_index *r = rv;
1471 return strcmp (l->name, r->name);
1474 /* Maximum number of index blocks level. */
1476 #define MAX_LEVEL 10
1478 /* Get the size of an index entry. */
1481 get_idxlen (struct vms_index *idx)
1483 return 7 + idx->namlen;
1486 /* Write the index. VBN is the first vbn to be used, and will contain
1487 on return the last vbn.
1488 Return TRUE on success. */
1491 vms_write_index (bfd *abfd,
1492 struct vms_index *idx, unsigned int nbr, unsigned int *vbn,
1493 unsigned int *topvbn)
1498 struct vms_indexdef *rblk[MAX_LEVEL];
1503 unsigned short lastlen;
1515 /* Sort the index the first time this function is called. */
1516 qsort (idx, nbr, sizeof (struct vms_index), vms_index_cmp);
1519 /* Allocate first index block. */
1522 rblk[0] = bfd_malloc (sizeof (struct vms_indexdef));
1523 blk[0].vbn = (*vbn)++;
1527 for (i = 0; i < nbr; i++, idx++)
1529 unsigned int idxlen = get_idxlen (idx);
1533 /* Check if a block might overflow. In this case we will flush this
1534 block and all the blocks below it. */
1535 for (j = 0; j < level; j++)
1536 if (blk[j].len + blk[j].lastlen + idxlen > INDEXDEF__BLKSIZ)
1539 for (j = 0; j < level; j++)
1543 /* There is not enough room to write the new entry in this
1544 block or in a parent block. */
1548 BFD_ASSERT (level < MAX_LEVEL);
1550 /* Need to create a parent. */
1553 rblk[level] = bfd_malloc (sizeof (struct vms_indexdef));
1554 bfd_putl32 (*vbn, rblk[j]->parent);
1556 blk[level].vbn = (*vbn)++;
1558 blk[level].lastlen = 0;
1563 /* Update parent block: write the new entry. */
1566 en = (struct vms_idx *)(rblk[j]->keys + blk[j].len);
1567 memcpy (rblk[j + 1]->keys + blk[j + 1].len, en,
1569 en = (struct vms_idx *)(rblk[j + 1]->keys + blk[j + 1].len);
1570 bfd_putl32 (blk[j].vbn, en->rfa.vbn);
1571 bfd_putl16 (RFADEF__C_INDEX, en->rfa.offset);
1576 /* And allocate it. Do it only on the block that won't be
1577 flushed (so that the parent of the parent can be
1579 blk[j + 1].len += blk[j].lastlen;
1580 blk[j + 1].lastlen = 0;
1583 /* Write this block on the disk. */
1586 bfd_putl16 (blk[j].len + blk[j].lastlen, rblk[j]->used);
1587 if (bfd_seek (abfd, (blk[j].vbn - 1) * VMS_BLOCK_SIZE,
1590 if (bfd_bwrite (rblk[j], sizeof (struct vms_indexdef), abfd)
1591 != sizeof (struct vms_indexdef))
1595 /* Reset this block. */
1598 blk[j].vbn = (*vbn)++;
1601 /* Append it to the block. */
1604 blk[j].len += blk[j].lastlen;
1608 en = (struct vms_idx *)(rblk[j]->keys + blk[j].len);
1609 bfd_putl32 ((idx->abfd->proxy_origin / VMS_BLOCK_SIZE) + 1,
1612 ((idx->abfd->proxy_origin % VMS_BLOCK_SIZE) + DATA__DATA,
1614 en->keylen = idx->namlen;
1615 memcpy (en->keyname, idx->name, idx->namlen);
1619 blk[j].lastlen = idxlen;
1624 *topvbn = blk[level - 1].vbn;
1630 for (j = 0; j < level; j++)
1634 /* Update parent block: write the new entry. */
1636 struct vms_idx *par;
1638 en = (struct vms_idx *)(rblk[j - 1]->keys + blk[j - 1].len);
1639 par = (struct vms_idx *)(rblk[j]->keys + blk[j].len);
1640 memcpy (par, en, blk[j - 1].lastlen);
1641 bfd_putl32 (blk[j - 1].vbn, par->rfa.vbn);
1642 bfd_putl16 (RFADEF__C_INDEX, par->rfa.offset);
1645 /* Write this block on the disk. */
1646 bfd_putl16 (blk[j].len + blk[j].lastlen, rblk[j]->used);
1647 if (bfd_seek (abfd, (blk[j].vbn - 1) * VMS_BLOCK_SIZE,
1650 if (bfd_bwrite (rblk[j], sizeof (struct vms_indexdef), abfd)
1651 != sizeof (struct vms_indexdef))
1660 /* Append data to the data block DATA. Force write if PAD is true. */
1663 vms_write_data_block (bfd *arch, struct vms_datadef *data, file_ptr *off,
1664 const unsigned char *buf, unsigned int len, int pad)
1666 while (len > 0 || pad)
1668 unsigned int doff = *off & (VMS_BLOCK_SIZE - 1);
1669 unsigned int remlen = (DATA__LENGTH - DATA__DATA) - doff;
1672 l = (len > remlen) ? remlen : len;
1673 memcpy (data->data + doff, buf, l);
1679 if (doff == (DATA__LENGTH - DATA__DATA) || (len == 0 && pad))
1683 bfd_putl32 ((*off / VMS_BLOCK_SIZE) + 2, data->link);
1685 if (bfd_bwrite (data, sizeof (*data), arch) != sizeof (*data))
1688 *off += DATA__LENGTH - doff;
1697 /* Build the symbols index. */
1700 _bfd_vms_lib_build_map (unsigned int nbr_modules,
1701 struct vms_index *modules,
1702 unsigned int *res_cnt,
1703 struct vms_index **res)
1706 asymbol **syms = NULL;
1708 struct vms_index *map = NULL;
1709 unsigned int map_max = 1024; /* Fine initial default. */
1710 unsigned int map_count = 0;
1712 map = (struct vms_index *) bfd_malloc (map_max * sizeof (struct vms_index));
1716 /* Gather symbols. */
1717 for (i = 0; i < nbr_modules; i++)
1722 bfd *current = modules[i].abfd;
1724 if ((bfd_get_file_flags (current) & HAS_SYMS) == 0)
1727 storage = bfd_get_symtab_upper_bound (current);
1733 if (storage > syms_max)
1738 syms = (asymbol **) bfd_malloc (syms_max);
1742 symcount = bfd_canonicalize_symtab (current, syms);
1746 /* Now map over all the symbols, picking out the ones we
1748 for (src_count = 0; src_count < symcount; src_count++)
1750 flagword flags = (syms[src_count])->flags;
1751 asection *sec = syms[src_count]->section;
1753 if ((flags & BSF_GLOBAL
1755 || flags & BSF_INDIRECT
1756 || bfd_is_com_section (sec))
1757 && ! bfd_is_und_section (sec))
1759 struct vms_index *new_map;
1761 /* This symbol will go into the archive header. */
1762 if (map_count == map_max)
1765 new_map = (struct vms_index *)
1766 bfd_realloc (map, map_max * sizeof (struct vms_index));
1767 if (new_map == NULL)
1772 map[map_count].abfd = current;
1773 /* FIXME: check length. */
1774 map[map_count].namlen = strlen (syms[src_count]->name);
1775 map[map_count].name = syms[src_count]->name;
1783 *res_cnt = map_count;
1795 /* Do the hard work: write an archive on the disk. */
1798 _bfd_vms_lib_write_archive_contents (bfd *arch)
1801 unsigned int nbr_modules;
1802 struct vms_index *modules;
1803 unsigned int nbr_symbols;
1804 struct vms_index *symbols;
1805 struct lib_tdata *tdata = bfd_libdata (arch);
1808 unsigned int nbr_mod_iblk;
1809 unsigned int nbr_sym_iblk;
1811 unsigned int mod_idx_vbn;
1812 unsigned int sym_idx_vbn;
1814 /* Count the number of modules (and do a first sanity check). */
1816 for (current = arch->archive_head;
1818 current = current->archive_next)
1820 /* This check is checking the bfds for the objects we're reading
1821 from (which are usually either an object file or archive on
1822 disk), not the archive entries we're writing to. We don't
1823 actually create bfds for the archive members, we just copy
1824 them byte-wise when we write out the archive. */
1825 if (bfd_write_p (current) || !bfd_check_format (current, bfd_object))
1827 bfd_set_error (bfd_error_invalid_operation);
1834 /* Build the modules list. */
1835 BFD_ASSERT (tdata->modules == NULL);
1836 modules = bfd_alloc (arch, nbr_modules * sizeof (struct vms_index));
1837 if (modules == NULL)
1840 for (current = arch->archive_head, i = 0;
1842 current = current->archive_next, i++)
1846 modules[i].abfd = current;
1847 modules[i].name = vms_get_module_name (current->filename, FALSE);
1850 /* FIXME: silently truncate long names ? */
1851 nl = strlen (modules[i].name);
1852 modules[i].namlen = (nl > MAX_KEYLEN ? MAX_KEYLEN : nl);
1855 /* Create the module index. */
1857 if (!vms_write_index (NULL, modules, nbr_modules, &vbn, NULL))
1861 /* Create symbol index. */
1862 if (!_bfd_vms_lib_build_map (nbr_modules, modules, &nbr_symbols, &symbols))
1866 if (!vms_write_index (NULL, symbols, nbr_symbols, &vbn, NULL))
1870 /* Write modules and remember their position. */
1871 off = (1 + nbr_mod_iblk + nbr_sym_iblk) * VMS_BLOCK_SIZE;
1873 if (bfd_seek (arch, off, SEEK_SET) != 0)
1876 for (i = 0; i < nbr_modules; i++)
1878 struct vms_datadef data;
1879 unsigned char blk[VMS_BLOCK_SIZE];
1880 struct vms_mhd *mhd;
1883 current = modules[i].abfd;
1884 current->proxy_origin = off;
1886 bfd_putl16 (sizeof (struct vms_mhd), blk);
1887 mhd = (struct vms_mhd *)(blk + 2);
1888 memset (mhd, 0, sizeof (struct vms_mhd));
1890 mhd->id = MHD__C_MHDID;
1892 memcpy (mhd->objid, "V1.0", 4);
1893 bfd_putl32 (modules[i].ref, mhd->refcnt);
1896 sz = (2 + sizeof (struct vms_mhd) + 1) & ~1;
1897 if (vms_write_data_block (arch, &data, &off, blk, sz, 0) < 0)
1900 if (bfd_seek (current, 0, SEEK_SET) != 0)
1905 sz = bfd_bread (blk, sizeof (blk), current);
1908 if (vms_write_data_block (arch, &data, &off, blk, sz, 0) < 0)
1911 if (vms_write_data_block (arch, &data, &off,
1912 eotdesc, sizeof (eotdesc), 1) < 0)
1916 /* Write the indexes. */
1918 if (vms_write_index (arch, modules, nbr_modules, &vbn, &mod_idx_vbn) != TRUE)
1920 if (vms_write_index (arch, symbols, nbr_symbols, &vbn, &sym_idx_vbn) != TRUE)
1923 /* Write libary header. */
1925 unsigned char blk[VMS_BLOCK_SIZE];
1926 struct vms_lhd *lhd = (struct vms_lhd *)blk;
1927 struct vms_idd *idd = (struct vms_idd *)(blk + sizeof (*lhd));
1928 unsigned int idd_flags;
1930 memset (blk, 0, sizeof (blk));
1932 lhd->type = LBR__C_TYP_EOBJ;
1934 bfd_putl32 (LHD_SANEID3, lhd->sanity);
1935 bfd_putl16 (3, lhd->majorid);
1936 bfd_putl16 (0, lhd->minorid);
1937 snprintf ((char *)lhd->lbrver + 1, sizeof (lhd->lbrver) - 1,
1939 (unsigned)(BFD_VERSION / 100000000UL),
1940 (unsigned)(BFD_VERSION / 1000000UL) % 100,
1941 (unsigned)(BFD_VERSION / 10000UL) % 100);
1942 lhd->lbrver[sizeof (lhd->lbrver) - 1] = 0;
1943 lhd->lbrver[0] = strlen ((char *)lhd->lbrver + 1);
1946 bfd_putl64 (0, lhd->credat);
1947 bfd_putl64 (0, lhd->updtim);
1949 lhd->mhdusz = sizeof (struct vms_mhd) - MHD__C_USRDAT;
1951 bfd_putl32 (nbr_modules + nbr_symbols, lhd->idxcnt);
1952 bfd_putl32 (nbr_modules, lhd->modcnt);
1953 bfd_putl32 (nbr_modules, lhd->modhdrs);
1955 bfd_putl32 (vbn - 1, lhd->hipreal);
1956 bfd_putl32 (vbn - 1, lhd->hiprusd);
1958 /* First index (modules name). */
1959 idd_flags = IDD__FLAGS_ASCII | IDD__FLAGS_VARLENIDX
1960 | IDD__FLAGS_NOCASECMP | IDD__FLAGS_NOCASENTR;
1961 bfd_putl16 (idd_flags, idd->flags);
1962 bfd_putl16 (MAX_KEYLEN, idd->keylen);
1963 bfd_putl16 (mod_idx_vbn, idd->vbn);
1966 /* Second index (symbols name). */
1967 bfd_putl16 (idd_flags, idd->flags);
1968 bfd_putl16 (MAX_KEYLEN, idd->keylen);
1969 bfd_putl16 (sym_idx_vbn, idd->vbn);
1972 if (bfd_seek (arch, 0, SEEK_SET) != 0)
1974 if (bfd_bwrite (blk, sizeof (blk), arch) != sizeof (blk))
1981 bfd_set_error (bfd_error_on_input, current, bfd_get_error ());
1985 /* Add a target for text library. This costs almost nothing and is useful to
1986 read VMS library on the host. */
1988 const bfd_target vms_lib_txt_vec =
1990 "vms-libtxt", /* Name. */
1991 bfd_target_unknown_flavour,
1992 BFD_ENDIAN_UNKNOWN, /* byteorder */
1993 BFD_ENDIAN_UNKNOWN, /* header_byteorder */
1994 0, /* Object flags. */
1995 0, /* Sect flags. */
1996 0, /* symbol_leading_char. */
1997 ' ', /* ar_pad_char. */
1998 15, /* ar_max_namelen. */
1999 bfd_getl64, bfd_getl_signed_64, bfd_putl64,
2000 bfd_getl32, bfd_getl_signed_32, bfd_putl32,
2001 bfd_getl16, bfd_getl_signed_16, bfd_putl16,
2002 bfd_getl64, bfd_getl_signed_64, bfd_putl64,
2003 bfd_getl32, bfd_getl_signed_32, bfd_putl32,
2004 bfd_getl16, bfd_getl_signed_16, bfd_putl16,
2006 {_bfd_dummy_target, _bfd_dummy_target, /* bfd_check_format. */
2007 _bfd_vms_lib_txt_archive_p, _bfd_dummy_target},
2008 {bfd_false, bfd_false, bfd_false, bfd_false}, /* bfd_set_format. */
2009 {bfd_false, bfd_false, bfd_false, bfd_false}, /* bfd_write_contents. */
2011 BFD_JUMP_TABLE_GENERIC (_bfd_generic),
2012 BFD_JUMP_TABLE_COPY (_bfd_generic),
2013 BFD_JUMP_TABLE_CORE (_bfd_nocore),
2014 BFD_JUMP_TABLE_ARCHIVE (_bfd_vms_lib),
2015 BFD_JUMP_TABLE_SYMBOLS (_bfd_nosymbols),
2016 BFD_JUMP_TABLE_RELOCS (_bfd_norelocs),
2017 BFD_JUMP_TABLE_WRITE (_bfd_nowrite),
2018 BFD_JUMP_TABLE_LINK (_bfd_nolink),
2019 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic),