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
;
81 unsigned int credat_lo
;
82 unsigned int credat_hi
;
84 /* Vector of modules (archive elements), already sorted. */
85 unsigned int nbr_modules
;
86 struct carsym
*modules
;
89 /* DCX (decompression) data. */
90 unsigned int nbr_dcxsbm
;
91 struct dcxsbm_desc
*dcxsbm
;
94 #define bfd_libdata(bfd) ((struct lib_tdata *)((bfd)->tdata.any))
96 /* End-Of-Text pattern. This is a special record to mark the end of file. */
98 static const unsigned char eotdesc
[] = { 0x03, 0x00, 0x77, 0x00, 0x77, 0x00 };
100 /* Describe the current state of carsym entries while building the archive
101 table of content. Things are simple with Alpha archives as the number
102 of entries is known, but with IA64 archives a entry can make a reference
103 to severals members. Therefore we must be able to extend the table on the
104 fly, but it should be allocated on the bfd - which doesn't support realloc.
105 To reduce the overhead, the table is initially allocated in the BFD's
106 objalloc and extended if necessary on the heap. In the later case, it
107 is finally copied to the BFD's objalloc so that it will automatically be
112 /* The table of content. */
115 /* Number of entries used in the table. */
118 /* Maximum number of entries. */
121 /* If true, the table was reallocated on the heap. If false, it is still
122 in the BFD's objalloc. */
123 bfd_boolean realloced
;
126 /* Simply add a name to the index. */
129 vms_add_index (struct carsym_mem
*cs
, char *name
,
130 unsigned int idx_vbn
, unsigned int idx_off
)
132 if (cs
->nbr
== cs
->max
)
136 cs
->max
= 2 * cs
->max
+ 32;
140 n
= bfd_malloc2 (cs
->max
, sizeof (struct carsym
));
143 memcpy (n
, cs
->idx
, cs
->nbr
* sizeof (struct carsym
));
144 /* And unfortunately we can't free cs->idx. */
148 n
= bfd_realloc_or_free (cs
->idx
, cs
->nbr
* sizeof (struct carsym
));
153 cs
->realloced
= TRUE
;
155 cs
->idx
[cs
->nbr
].file_offset
= (idx_vbn
- 1) * VMS_BLOCK_SIZE
+ idx_off
;
156 cs
->idx
[cs
->nbr
].name
= name
;
161 /* Follow all member of a lns list (pointed by RFA) and add indexes for
162 NAME. Return FALSE in case of error. */
165 vms_add_indexes_from_list (bfd
*abfd
, struct carsym_mem
*cs
, char *name
,
174 vbn
= bfd_getl32 (rfa
->vbn
);
179 off
= (vbn
- 1) * VMS_BLOCK_SIZE
+ bfd_getl16 (rfa
->offset
);
180 if (bfd_seek (abfd
, off
, SEEK_SET
) != 0
181 || bfd_bread (&lns
, sizeof (lns
), abfd
) != sizeof (lns
))
184 if (!vms_add_index (cs
, name
,
185 bfd_getl32 (lns
.modrfa
.vbn
),
186 bfd_getl16 (lns
.modrfa
.offset
)))
193 /* Read block VBN from ABFD and store it into BLK. Return FALSE in case of error. */
196 vms_read_block (bfd
*abfd
, unsigned int vbn
, void *blk
)
200 off
= (vbn
- 1) * VMS_BLOCK_SIZE
;
201 if (bfd_seek (abfd
, off
, SEEK_SET
) != 0
202 || bfd_bread (blk
, VMS_BLOCK_SIZE
, abfd
) != VMS_BLOCK_SIZE
)
208 /* Write the content of BLK to block VBN of ABFD. Return FALSE in case of error. */
211 vms_write_block (bfd
*abfd
, unsigned int vbn
, void *blk
)
215 off
= (vbn
- 1) * VMS_BLOCK_SIZE
;
216 if (bfd_seek (abfd
, off
, SEEK_SET
) != 0
217 || bfd_bwrite (blk
, VMS_BLOCK_SIZE
, abfd
) != VMS_BLOCK_SIZE
)
223 /* Read index block VBN and put the entry in **IDX (which is updated).
224 If the entry is indirect, recurse. */
227 vms_traverse_index (bfd
*abfd
, unsigned int vbn
, struct carsym_mem
*cs
)
229 struct vms_indexdef indexdef
;
234 /* Read the index block. */
235 BFD_ASSERT (sizeof (indexdef
) == VMS_BLOCK_SIZE
);
236 if (!vms_read_block (abfd
, vbn
, &indexdef
))
240 p
= &indexdef
.keys
[0];
241 endp
= p
+ bfd_getl16 (indexdef
.used
);
244 unsigned int idx_vbn
;
245 unsigned int idx_off
;
247 unsigned char *keyname
;
250 /* Extract key length. */
251 if (bfd_libdata (abfd
)->ver
== LBR_MAJORID
)
253 struct vms_idx
*ridx
= (struct vms_idx
*)p
;
255 idx_vbn
= bfd_getl32 (ridx
->rfa
.vbn
);
256 idx_off
= bfd_getl16 (ridx
->rfa
.offset
);
258 keylen
= ridx
->keylen
;
260 keyname
= ridx
->keyname
;
262 else if (bfd_libdata (abfd
)->ver
== LBR_ELFMAJORID
)
264 struct vms_elfidx
*ridx
= (struct vms_elfidx
*)p
;
266 idx_vbn
= bfd_getl32 (ridx
->rfa
.vbn
);
267 idx_off
= bfd_getl16 (ridx
->rfa
.offset
);
269 keylen
= bfd_getl16 (ridx
->keylen
);
271 keyname
= ridx
->keyname
;
280 if (idx_off
== RFADEF__C_INDEX
)
282 /* Indirect entry. Recurse. */
283 if (!vms_traverse_index (abfd
, idx_vbn
, cs
))
288 /* Add a new entry. */
291 if (flags
& ELFIDX__SYMESC
)
293 /* Extended key name. */
294 unsigned int noff
= 0;
298 unsigned char kblk
[VMS_BLOCK_SIZE
];
301 if (keylen
!= sizeof (struct vms_kbn
))
304 kbn
= (struct vms_kbn
*)keyname
;
305 keylen
= bfd_getl16 (kbn
->keylen
);
307 name
= bfd_alloc (abfd
, keylen
+ 1);
310 kvbn
= bfd_getl32 (kbn
->rfa
.vbn
);
311 koff
= bfd_getl16 (kbn
->rfa
.offset
);
313 /* Read the key, chunk by chunk. */
318 if (!vms_read_block (abfd
, kvbn
, kblk
))
320 kbn
= (struct vms_kbn
*)(kblk
+ koff
);
321 klen
= bfd_getl16 (kbn
->keylen
);
322 kvbn
= bfd_getl32 (kbn
->rfa
.vbn
);
323 koff
= bfd_getl16 (kbn
->rfa
.offset
);
325 memcpy (name
+ noff
, kbn
+ 1, klen
);
336 /* Usual key name. */
337 name
= bfd_alloc (abfd
, keylen
+ 1);
341 memcpy (name
, keyname
, keylen
);
345 if (flags
& ELFIDX__LISTRFA
)
350 off
= (idx_vbn
- 1) * VMS_BLOCK_SIZE
+ idx_off
;
351 if (bfd_seek (abfd
, off
, SEEK_SET
) != 0
352 || bfd_bread (&lhs
, sizeof (lhs
), abfd
) != sizeof (lhs
))
355 /* FIXME: this adds extra entries that were not accounted. */
356 if (!vms_add_indexes_from_list (abfd
, cs
, name
, &lhs
.ng_g_rfa
))
358 if (!vms_add_indexes_from_list (abfd
, cs
, name
, &lhs
.ng_wk_rfa
))
360 if (!vms_add_indexes_from_list (abfd
, cs
, name
, &lhs
.g_g_rfa
))
362 if (!vms_add_indexes_from_list (abfd
, cs
, name
, &lhs
.g_wk_rfa
))
367 if (!vms_add_index (cs
, name
, idx_vbn
, idx_off
))
372 /* Point to the next index entry. */
373 p
= keyname
+ keylen
;
379 /* Read index #IDX, which must have NBREL entries. */
381 static struct carsym
*
382 vms_lib_read_index (bfd
*abfd
, int idx
, unsigned int *nbrel
)
387 struct carsym
*csbuf
;
388 struct carsym_mem csm
;
390 /* Read index desription. */
391 if (bfd_seek (abfd
, LHD_IDXDESC
+ idx
* IDD_LENGTH
, SEEK_SET
) != 0
392 || bfd_bread (&idd
, sizeof (idd
), abfd
) != sizeof (idd
))
396 flags
= bfd_getl16 (idd
.flags
);
397 if (!(flags
& IDD__FLAGS_ASCII
)
398 || !(flags
& IDD__FLAGS_VARLENIDX
))
401 csbuf
= bfd_alloc (abfd
, *nbrel
* sizeof (struct carsym
));
407 csm
.realloced
= FALSE
;
410 /* Note: if the index is empty, there is no block to traverse. */
411 vbn
= bfd_getl32 (idd
.vbn
);
412 if (vbn
!= 0 && !vms_traverse_index (abfd
, vbn
, &csm
))
414 if (csm
.realloced
&& csm
.idx
!= NULL
)
417 /* Note: in case of error, we can free what was allocated on the
419 bfd_release (abfd
, csbuf
);
425 /* There are more entries than the first estimate. Allocate on
426 the BFD's objalloc. */
427 csbuf
= bfd_alloc (abfd
, csm
.nbr
* sizeof (struct carsym
));
430 memcpy (csbuf
, csm
.idx
, csm
.nbr
* sizeof (struct carsym
));
437 /* Standard function. */
439 static const bfd_target
*
440 _bfd_vms_lib_archive_p (bfd
*abfd
, enum vms_lib_kind kind
)
444 unsigned int majorid
;
445 struct lib_tdata
*tdata_hold
;
446 struct lib_tdata
*tdata
;
448 unsigned int nbr_ent
;
451 if (bfd_bread (&lhd
, sizeof (lhd
), abfd
) != sizeof (lhd
))
453 if (bfd_get_error () != bfd_error_system_call
)
454 bfd_set_error (bfd_error_wrong_format
);
458 /* Check sanity (= magic) number. */
459 sanity
= bfd_getl32 (lhd
.sanity
);
460 if (!(sanity
== LHD_SANEID3
461 || sanity
== LHD_SANEID6
462 || sanity
== LHD_SANEID_DCX
))
464 bfd_set_error (bfd_error_wrong_format
);
467 majorid
= bfd_getl32 (lhd
.majorid
);
469 /* Check archive kind. */
473 if ((lhd
.type
!= LBR__C_TYP_EOBJ
&& lhd
.type
!= LBR__C_TYP_ESHSTB
)
474 || majorid
!= LBR_MAJORID
477 bfd_set_error (bfd_error_wrong_format
);
482 if ((lhd
.type
!= LBR__C_TYP_IOBJ
&& lhd
.type
!= LBR__C_TYP_ISHSTB
)
483 || majorid
!= LBR_ELFMAJORID
486 bfd_set_error (bfd_error_wrong_format
);
491 if ((lhd
.type
!= LBR__C_TYP_TXT
492 && lhd
.type
!= LBR__C_TYP_MLB
493 && lhd
.type
!= LBR__C_TYP_HLP
)
494 || majorid
!= LBR_MAJORID
497 bfd_set_error (bfd_error_wrong_format
);
505 /* Allocate and initialize private data. */
506 tdata_hold
= bfd_libdata (abfd
);
507 tdata
= (struct lib_tdata
*) bfd_zalloc (abfd
, sizeof (struct lib_tdata
));
510 abfd
->tdata
.any
= (void *)tdata
;
511 tdata
->ver
= majorid
;
512 tdata
->mhd_size
= MHD__C_USRDAT
+ lhd
.mhdusz
;
513 tdata
->type
= lhd
.type
;
515 tdata
->credat_lo
= bfd_getl32 (lhd
.credat
+ 0);
516 tdata
->credat_hi
= bfd_getl32 (lhd
.credat
+ 4);
519 tdata
->nbr_modules
= bfd_getl32 (lhd
.modcnt
);
520 tdata
->artdata
.symdef_count
= bfd_getl32 (lhd
.idxcnt
) - tdata
->nbr_modules
;
521 nbr_ent
= tdata
->nbr_modules
;
522 tdata
->modules
= vms_lib_read_index (abfd
, 0, &nbr_ent
);
523 if (tdata
->modules
== NULL
|| nbr_ent
!= tdata
->nbr_modules
)
527 nbr_ent
= tdata
->artdata
.symdef_count
;
528 tdata
->artdata
.symdefs
= vms_lib_read_index (abfd
, 1, &nbr_ent
);
529 if (tdata
->artdata
.symdefs
== NULL
)
531 /* Only IA64 archives may have more entries in the index that what
533 if (nbr_ent
!= tdata
->artdata
.symdef_count
534 && kind
!= vms_lib_ia64
)
536 tdata
->artdata
.symdef_count
= nbr_ent
;
538 tdata
->cache
= bfd_zalloc (abfd
, sizeof (bfd
*) * tdata
->nbr_modules
);
539 if (tdata
->cache
== NULL
)
542 /* Read DCX submaps. */
543 dcxvbn
= bfd_getl32 (lhd
.dcxmapvbn
);
546 unsigned char buf_reclen
[4];
549 struct vms_dcxmap
*map
;
550 unsigned int sbm_off
;
553 if (bfd_seek (abfd
, (dcxvbn
- 1) * VMS_BLOCK_SIZE
, SEEK_SET
) != 0
554 || bfd_bread (buf_reclen
, sizeof (buf_reclen
), abfd
)
555 != sizeof (buf_reclen
))
557 reclen
= bfd_getl32 (buf_reclen
);
558 buf
= bfd_malloc (reclen
);
561 if (bfd_bread (buf
, reclen
, abfd
) != reclen
)
566 map
= (struct vms_dcxmap
*)buf
;
567 tdata
->nbr_dcxsbm
= bfd_getl16 (map
->nsubs
);
568 sbm_off
= bfd_getl16 (map
->sub0
);
569 tdata
->dcxsbm
= (struct dcxsbm_desc
*)bfd_alloc
570 (abfd
, tdata
->nbr_dcxsbm
* sizeof (struct dcxsbm_desc
));
571 for (i
= 0; i
< tdata
->nbr_dcxsbm
; i
++)
573 struct vms_dcxsbm
*sbm
= (struct vms_dcxsbm
*) (buf
+ sbm_off
);
574 struct dcxsbm_desc
*sbmdesc
= &tdata
->dcxsbm
[i
];
575 unsigned int sbm_len
;
578 unsigned char *data
= (unsigned char *)sbm
;
582 sbm_sz
= bfd_getl16 (sbm
->size
);
584 BFD_ASSERT (sbm_off
<= reclen
);
586 sbmdesc
->min_char
= sbm
->min_char
;
587 BFD_ASSERT (sbmdesc
->min_char
== 0);
588 sbmdesc
->max_char
= sbm
->max_char
;
589 sbm_len
= sbmdesc
->max_char
- sbmdesc
->min_char
+ 1;
590 l
= (2 * sbm_len
+ 7) / 8;
592 (sbm_sz
>= sizeof (struct vms_dcxsbm
) + l
+ 3 * sbm_len
593 || (tdata
->nbr_dcxsbm
== 1
594 && sbm_sz
>= sizeof (struct vms_dcxsbm
) + l
+ sbm_len
));
595 sbmdesc
->flags
= (unsigned char *)bfd_alloc (abfd
, l
);
596 memcpy (sbmdesc
->flags
, data
+ bfd_getl16 (sbm
->flags
), l
);
597 sbmdesc
->nodes
= (unsigned char *)bfd_alloc (abfd
, 2 * sbm_len
);
598 memcpy (sbmdesc
->nodes
, data
+ bfd_getl16 (sbm
->nodes
), 2 * sbm_len
);
599 off
= bfd_getl16 (sbm
->next
);
602 /* Read the 'next' array. */
603 sbmdesc
->next
= (unsigned short *)bfd_alloc
604 (abfd
, sbm_len
* sizeof (unsigned short));
606 for (j
= 0; j
< sbm_len
; j
++)
607 sbmdesc
->next
[j
] = bfd_getl16 (buf1
+ j
* 2);
611 /* There is no next array if there is only one submap. */
612 BFD_ASSERT (tdata
->nbr_dcxsbm
== 1);
613 sbmdesc
->next
= NULL
;
620 tdata
->nbr_dcxsbm
= 0;
623 /* The map is always present. Also mark shared image library. */
624 abfd
->has_armap
= TRUE
;
625 if (tdata
->type
== LBR__C_TYP_ESHSTB
|| tdata
->type
== LBR__C_TYP_ISHSTB
)
626 abfd
->is_thin_archive
= TRUE
;
631 bfd_release (abfd
, tdata
);
632 abfd
->tdata
.any
= (void *)tdata_hold
;;
636 /* Standard function for alpha libraries. */
639 _bfd_vms_lib_alpha_archive_p (bfd
*abfd
)
641 return _bfd_vms_lib_archive_p (abfd
, vms_lib_alpha
);
644 /* Standard function for ia64 libraries. */
647 _bfd_vms_lib_ia64_archive_p (bfd
*abfd
)
649 return _bfd_vms_lib_archive_p (abfd
, vms_lib_ia64
);
652 /* Standard function for text libraries. */
654 static const bfd_target
*
655 _bfd_vms_lib_txt_archive_p (bfd
*abfd
)
657 return _bfd_vms_lib_archive_p (abfd
, vms_lib_txt
);
660 /* Standard bfd function. */
663 _bfd_vms_lib_mkarchive (bfd
*abfd
, enum vms_lib_kind kind
)
665 struct lib_tdata
*tdata
;
667 tdata
= (struct lib_tdata
*) bfd_zalloc (abfd
, sizeof (struct lib_tdata
));
671 abfd
->tdata
.any
= (void *)tdata
;
672 vms_get_time (&tdata
->credat_hi
, &tdata
->credat_lo
);
678 tdata
->ver
= LBR_MAJORID
;
679 tdata
->mhd_size
= offsetof (struct vms_mhd
, pad1
);
680 tdata
->type
= LBR__C_TYP_EOBJ
;
683 tdata
->ver
= LBR_ELFMAJORID
;
684 tdata
->mhd_size
= sizeof (struct vms_mhd
);
685 tdata
->type
= LBR__C_TYP_IOBJ
;
691 tdata
->nbr_modules
= 0;
692 tdata
->artdata
.symdef_count
= 0;
693 tdata
->modules
= NULL
;
694 tdata
->artdata
.symdefs
= NULL
;
701 _bfd_vms_lib_alpha_mkarchive (bfd
*abfd
)
703 return _bfd_vms_lib_mkarchive (abfd
, vms_lib_alpha
);
706 /* Find NAME in the symbol index. Return the index. */
709 _bfd_vms_lib_find_symbol (bfd
*abfd
, const char *name
)
711 struct lib_tdata
*tdata
= bfd_libdata (abfd
);
712 carsym
*syms
= tdata
->artdata
.symdefs
;
715 /* Open-coded binary search for speed. */
717 hi
= tdata
->artdata
.symdef_count
- 1;
721 int mid
= lo
+ (hi
- lo
) / 2;
724 diff
= (char)(name
[0] - syms
[mid
].name
[0]);
726 diff
= strcmp (name
, syms
[mid
].name
);
734 return BFD_NO_MORE_SYMBOLS
;
737 /* IO vector for archive member. Need that because members are not linearly
738 stored in archives. */
742 /* Current offset. */
745 /* Length of the module, when known. */
748 /* Current position in the record from bfd_bread point of view (ie, after
749 decompression). 0 means that no data byte have been read, -2 and -1
750 are reserved for the length word. */
752 #define REC_POS_NL -4
753 #define REC_POS_PAD -3
754 #define REC_POS_LEN0 -2
755 #define REC_POS_LEN1 -1
758 unsigned short rec_len
;
759 /* Number of bytes to read in the current record. */
760 unsigned short rec_rem
;
761 /* Offset of the next block. */
763 /* Current *data* offset in the data block. */
764 unsigned short blk_off
;
766 /* Offset of the first block. Extracted from the index. */
767 file_ptr first_block
;
769 /* Initial next_block. Extracted when the MHD is read. */
770 file_ptr init_next_block
;
771 /* Initial blk_off, once the MHD is read. */
772 unsigned short init_blk_off
;
774 /* Used to store any 3 byte record, which could be the EOF pattern. */
775 unsigned char pattern
[4];
778 struct dcxsbm_desc
*dcxsbms
;
779 /* Current submap. */
780 struct dcxsbm_desc
*dcx_sbm
;
781 /* Current offset in the submap. */
782 unsigned int dcx_offset
;
785 /* Compressed buffer. */
786 unsigned char *dcx_buf
;
787 /* Size of the buffer. Used to resize. */
788 unsigned int dcx_max
;
789 /* Number of valid bytes in the buffer. */
790 unsigned int dcx_rlen
;
793 /* Return the current position. */
796 vms_lib_btell (struct bfd
*abfd
)
798 struct vms_lib_iovec
*vec
= (struct vms_lib_iovec
*) abfd
->iostream
;
802 /* Read the header of the next data block if all bytes of the current block
806 vms_lib_read_block (struct bfd
*abfd
)
808 struct vms_lib_iovec
*vec
= (struct vms_lib_iovec
*) abfd
->iostream
;
810 if (vec
->blk_off
== DATA__LENGTH
)
812 unsigned char hdr
[DATA__DATA
];
814 /* Read next block. */
815 if (bfd_seek (abfd
->my_archive
, vec
->next_block
, SEEK_SET
) != 0)
817 if (bfd_bread (hdr
, sizeof (hdr
), abfd
->my_archive
) != sizeof (hdr
))
819 vec
->next_block
= (bfd_getl32 (hdr
+ 2) - 1) * VMS_BLOCK_SIZE
;
820 vec
->blk_off
= sizeof (hdr
);
825 /* Read NBYTES from ABFD into BUF if not NULL. If BUF is NULL, bytes are
826 not stored. Read linearly from the library, but handle blocks. This
827 function does not handle records nor EOF. */
830 vms_lib_bread_raw (struct bfd
*abfd
, void *buf
, file_ptr nbytes
)
832 struct vms_lib_iovec
*vec
= (struct vms_lib_iovec
*) abfd
->iostream
;
840 /* Be sure the current data block is read. */
841 if (!vms_lib_read_block (abfd
))
844 /* Do not read past the data block, do not read more than requested. */
845 l
= DATA__LENGTH
- vec
->blk_off
;
852 /* Really read into BUF. */
853 if (bfd_bread (buf
, l
, abfd
->my_archive
) != l
)
858 /* Make as if we are reading. */
859 if (bfd_seek (abfd
->my_archive
, l
, SEEK_CUR
) != 0)
872 /* Decompress NBYTES from VEC. Store the bytes into BUF if not NULL. */
875 vms_lib_dcx (struct vms_lib_iovec
*vec
, unsigned char *buf
, file_ptr nbytes
)
877 struct dcxsbm_desc
*sbm
;
883 /* The loop below expect to deliver at least one byte. */
887 /* Get the current state. */
889 offset
= vec
->dcx_offset
;
890 j
= vec
->dcx_pos
& 7;
892 for (i
= vec
->dcx_pos
>> 3; i
< vec
->dcx_rlen
; i
++)
894 unsigned char b
= vec
->dcx_buf
[i
];
900 if (!(sbm
->flags
[offset
>> 3] & (1 << (offset
& 7))))
902 unsigned int n_offset
= sbm
->nodes
[offset
];
905 /* End of buffer. Stay where we are. */
906 vec
->dcx_pos
= (i
<< 3) + j
;
909 vec
->dcx_offset
= offset
;
913 offset
= 2 * n_offset
;
917 unsigned char v
= sbm
->nodes
[offset
];
919 if (sbm
->next
!= NULL
)
920 sbm
= vec
->dcxsbms
+ sbm
->next
[v
];
931 vec
->dcx_pos
= (i
<< 3) + j
+ 1;
932 vec
->dcx_offset
= offset
;
945 /* Standard IOVEC function. */
948 vms_lib_bread (struct bfd
*abfd
, void *buf
, file_ptr nbytes
)
950 struct vms_lib_iovec
*vec
= (struct vms_lib_iovec
*) abfd
->iostream
;
954 /* Do not read past the end. */
955 if (vec
->where
>= vec
->file_len
)
961 if (vec
->rec_rem
== 0)
963 unsigned char blen
[2];
965 /* Read record length. */
966 if (vms_lib_bread_raw (abfd
, &blen
, sizeof (blen
)) != sizeof (blen
))
968 vec
->rec_len
= bfd_getl16 (blen
);
969 if (bfd_libdata (abfd
->my_archive
)->kind
== vms_lib_txt
)
971 /* Discard record size and align byte. */
973 vec
->rec_rem
= vec
->rec_len
;
977 /* Prepend record size. */
978 vec
->rec_pos
= REC_POS_LEN0
;
979 vec
->rec_rem
= (vec
->rec_len
+ 1) & ~1; /* With align byte. */
981 if (vec
->rec_len
== 3)
983 /* Possibly end of file. Check the pattern. */
984 if (vms_lib_bread_raw (abfd
, vec
->pattern
, 4) != 4)
986 if (!memcmp (vec
->pattern
, eotdesc
+ 2, 3))
988 /* This is really an EOF. */
990 vec
->file_len
= vec
->where
;
995 if (vec
->dcxsbms
!= NULL
)
997 /* This is a compressed member. */
1001 /* Be sure there is enough room for the expansion. */
1002 len
= (vec
->rec_len
+ 1) & ~1;
1003 if (len
> vec
->dcx_max
)
1005 while (len
> vec
->dcx_max
)
1007 vec
->dcx_buf
= bfd_alloc (abfd
, vec
->dcx_max
);
1008 if (vec
->dcx_buf
== NULL
)
1012 /* Read the compressed record. */
1013 vec
->dcx_rlen
= len
;
1014 if (vec
->rec_len
== 3)
1017 memcpy (vec
->dcx_buf
, vec
->pattern
, 3);
1021 elen
= vms_lib_bread_raw (abfd
, vec
->dcx_buf
, len
);
1026 /* Dummy expansion to get the expanded length. */
1027 vec
->dcx_offset
= 0;
1028 vec
->dcx_sbm
= vec
->dcxsbms
;
1030 elen
= vms_lib_dcx (vec
, NULL
, 0x10000);
1033 vec
->rec_len
= elen
;
1034 vec
->rec_rem
= elen
;
1036 /* Reset the state. */
1037 vec
->dcx_offset
= 0;
1038 vec
->dcx_sbm
= vec
->dcxsbms
;
1042 if (vec
->rec_pos
< 0)
1045 switch (vec
->rec_pos
)
1048 c
= vec
->rec_len
& 0xff;
1049 vec
->rec_pos
= REC_POS_LEN1
;
1052 c
= (vec
->rec_len
>> 8) & 0xff;
1068 *(unsigned char *)buf
= c
;
1076 if (nbytes
> vec
->rec_rem
)
1077 chunk
= vec
->rec_rem
;
1081 if (vec
->dcxsbms
!= NULL
)
1083 /* Optimize the stat() case: no need to decompress again as we
1085 if (!(buf
== NULL
&& chunk
== vec
->rec_rem
))
1086 chunk
= vms_lib_dcx (vec
, buf
, chunk
);
1090 if (vec
->rec_len
== 3)
1093 memcpy (buf
, vec
->pattern
+ vec
->rec_pos
, chunk
);
1096 chunk
= vms_lib_bread_raw (abfd
, buf
, chunk
);
1104 vec
->rec_pos
+= chunk
;
1105 vec
->rec_rem
-= chunk
;
1107 if (vec
->rec_rem
== 0)
1109 /* End of record reached. */
1110 if (bfd_libdata (abfd
->my_archive
)->kind
== vms_lib_txt
)
1112 if ((vec
->rec_len
& 1) == 1
1113 && vec
->rec_len
!= 3
1114 && vec
->dcxsbms
== NULL
)
1116 /* Eat the pad byte. */
1118 if (vms_lib_bread_raw (abfd
, &pad
, 1) != 1)
1121 vec
->rec_pos
= REC_POS_NL
;
1126 if ((vec
->rec_len
& 1) == 1 && vec
->dcxsbms
!= NULL
)
1128 vec
->rec_pos
= REC_POS_PAD
;
1138 /* Standard function, but we currently only handle the rewind case. */
1141 vms_lib_bseek (struct bfd
*abfd
, file_ptr offset
, int whence
)
1143 struct vms_lib_iovec
*vec
= (struct vms_lib_iovec
*) abfd
->iostream
;
1145 if (whence
== SEEK_SET
&& offset
== 0)
1150 vec
->blk_off
= vec
->init_blk_off
;
1151 vec
->next_block
= vec
->init_next_block
;
1153 if (bfd_seek (abfd
->my_archive
, vec
->first_block
, SEEK_SET
) != 0)
1162 vms_lib_bwrite (struct bfd
*abfd ATTRIBUTE_UNUSED
,
1163 const void *where ATTRIBUTE_UNUSED
,
1164 file_ptr nbytes ATTRIBUTE_UNUSED
)
1170 vms_lib_bclose (struct bfd
*abfd
)
1172 abfd
->iostream
= NULL
;
1177 vms_lib_bflush (struct bfd
*abfd ATTRIBUTE_UNUSED
)
1183 vms_lib_bstat (struct bfd
*abfd ATTRIBUTE_UNUSED
,
1184 struct stat
*sb ATTRIBUTE_UNUSED
)
1186 /* Not supported. */
1191 vms_lib_bmmap (struct bfd
*abfd ATTRIBUTE_UNUSED
,
1192 void *addr ATTRIBUTE_UNUSED
,
1193 bfd_size_type len ATTRIBUTE_UNUSED
,
1194 int prot ATTRIBUTE_UNUSED
,
1195 int flags ATTRIBUTE_UNUSED
,
1196 file_ptr offset ATTRIBUTE_UNUSED
)
1201 static const struct bfd_iovec vms_lib_iovec
= {
1202 &vms_lib_bread
, &vms_lib_bwrite
, &vms_lib_btell
, &vms_lib_bseek
,
1203 &vms_lib_bclose
, &vms_lib_bflush
, &vms_lib_bstat
, &vms_lib_bmmap
1206 /* Open a library module. FILEPOS is the position of the module header. */
1209 vms_lib_bopen (bfd
*el
, file_ptr filepos
)
1211 struct vms_lib_iovec
*vec
;
1213 struct vms_mhd
*mhd
;
1214 struct lib_tdata
*tdata
= bfd_libdata (el
->my_archive
);
1217 /* Allocate and initialized the iovec. */
1218 vec
= bfd_zalloc (el
, sizeof (*vec
));
1223 el
->iovec
= &vms_lib_iovec
;
1225 /* File length is not known. */
1228 /* Read the first data block. */
1229 vec
->next_block
= filepos
& ~(VMS_BLOCK_SIZE
- 1);
1230 vec
->blk_off
= DATA__LENGTH
;
1231 if (!vms_lib_read_block (el
))
1234 /* Prepare to read the first record. */
1235 vec
->blk_off
= filepos
& (VMS_BLOCK_SIZE
- 1);
1237 if (bfd_seek (el
->my_archive
, filepos
, SEEK_SET
) != 0)
1240 /* Read Record length + MHD + align byte. */
1241 len
= tdata
->mhd_size
;
1242 if (vms_lib_bread_raw (el
, buf
, 2) != 2)
1244 if (bfd_getl16 (buf
) != len
)
1246 len
= (len
+ 1) & ~1;
1247 BFD_ASSERT (len
<= sizeof (buf
));
1248 if (vms_lib_bread_raw (el
, buf
, len
) != len
)
1251 /* Get info from mhd. */
1252 mhd
= (struct vms_mhd
*)buf
;
1254 if (mhd
->id
!= MHD__C_MHDID
)
1256 if (len
>= MHD__C_MHDLEN
+ 1)
1257 el
->selective_search
= (mhd
->objstat
& MHD__M_SELSRC
) ? 1 : 0;
1258 el
->mtime
= vms_rawtime_to_time_t (mhd
->datim
);
1259 el
->mtime_set
= TRUE
;
1261 /* Reinit the iovec so that seek() will point to the first record after
1264 vec
->init_blk_off
= vec
->blk_off
;
1265 vec
->init_next_block
= vec
->next_block
;
1266 vec
->first_block
= bfd_tell (el
->my_archive
);
1267 vec
->dcxsbms
= bfd_libdata (el
->my_archive
)->dcxsbm
;
1269 if (vec
->dcxsbms
!= NULL
)
1272 vec
->dcx_max
= 10 * 1024;
1273 vec
->dcx_buf
= bfd_alloc (el
, vec
->dcx_max
);
1275 if (vec
->dcx_buf
== NULL
)
1281 /* Get member MODIDX. Return NULL in case of error. */
1284 _bfd_vms_lib_get_module (bfd
*abfd
, unsigned int modidx
)
1286 struct lib_tdata
*tdata
= bfd_libdata (abfd
);
1291 if (modidx
>= tdata
->nbr_modules
)
1294 /* Already loaded. */
1295 if (tdata
->cache
[modidx
])
1296 return tdata
->cache
[modidx
];
1299 file_off
= tdata
->modules
[modidx
].file_offset
;
1300 if (tdata
->type
!= LBR__C_TYP_IOBJ
)
1302 res
= _bfd_create_empty_archive_element_shell (abfd
);
1306 /* Special reader to deal with data blocks. */
1307 if (!vms_lib_bopen (res
, file_off
))
1313 struct vms_mhd
*mhd
;
1314 struct areltdata
*arelt
;
1316 /* Sanity check. The MHD must be big enough to contain module size. */
1317 if (tdata
->mhd_size
< offsetof (struct vms_mhd
, modsize
) + 4)
1320 /* Read the MHD now. */
1321 if (bfd_seek (abfd
, file_off
, SEEK_SET
) != 0)
1323 if (bfd_bread (buf
, tdata
->mhd_size
, abfd
) != tdata
->mhd_size
)
1326 res
= _bfd_create_empty_archive_element_shell (abfd
);
1329 arelt
= bfd_zalloc (res
, sizeof (*arelt
));
1332 res
->arelt_data
= arelt
;
1334 /* Get info from mhd. */
1335 mhd
= (struct vms_mhd
*)buf
;
1336 if (mhd
->id
!= MHD__C_MHDID
)
1338 if (tdata
->mhd_size
>= offsetof (struct vms_mhd
, objstat
) + 1)
1339 res
->selective_search
= (mhd
->objstat
& MHD__M_SELSRC
) ? 1 : 0;
1340 res
->mtime
= vms_rawtime_to_time_t (mhd
->datim
);
1341 res
->mtime_set
= TRUE
;
1343 arelt
->parsed_size
= bfd_getl32 (mhd
->modsize
);
1345 /* No need for a special reader as members are stored linearly.
1346 Just skip the MHD. */
1347 res
->origin
= file_off
+ tdata
->mhd_size
;
1350 res
->filename
= tdata
->modules
[modidx
].name
;
1352 tdata
->cache
[modidx
] = res
;
1357 /* Standard function: get member at IDX. */
1360 _bfd_vms_lib_get_elt_at_index (bfd
*abfd
, symindex symidx
)
1362 struct lib_tdata
*tdata
= bfd_libdata (abfd
);
1364 unsigned int modidx
;
1367 if (symidx
> tdata
->artdata
.symdef_count
)
1369 file_off
= tdata
->artdata
.symdefs
[symidx
].file_offset
;
1372 for (modidx
= 0; modidx
< tdata
->nbr_modules
; modidx
++)
1374 if (tdata
->modules
[modidx
].file_offset
== file_off
)
1377 if (modidx
>= tdata
->nbr_modules
)
1380 return _bfd_vms_lib_get_module (abfd
, modidx
);
1383 /* Elements of an imagelib are stubs. You can get the real image with this
1387 _bfd_vms_lib_get_imagelib_file (bfd
*el
)
1389 bfd
*archive
= el
->my_archive
;
1390 const char *modname
= el
->filename
;
1391 int modlen
= strlen (modname
);
1396 /* Convert module name to lower case and append '.exe'. */
1397 filename
= bfd_alloc (el
, modlen
+ 5);
1398 if (filename
== NULL
)
1400 for (j
= 0; j
< modlen
; j
++)
1401 if (ISALPHA (modname
[j
]))
1402 filename
[j
] = TOLOWER (modname
[j
]);
1404 filename
[j
] = modname
[j
];
1405 memcpy (filename
+ modlen
, ".exe", 5);
1407 filename
= _bfd_append_relative_path (archive
, filename
);
1408 if (filename
== NULL
)
1410 res
= bfd_openr (filename
, NULL
);
1414 (*_bfd_error_handler
)(_("could not open shared image '%s' from '%s'"),
1415 filename
, archive
->filename
);
1416 bfd_release (archive
, filename
);
1420 /* FIXME: put it in a cache ? */
1424 /* Standard function. */
1427 _bfd_vms_lib_openr_next_archived_file (bfd
*archive
,
1436 idx
= last_file
->proxy_origin
+ 1;
1438 if (idx
>= bfd_libdata (archive
)->nbr_modules
)
1440 bfd_set_error (bfd_error_no_more_archived_files
);
1444 res
= _bfd_vms_lib_get_module (archive
, idx
);
1447 res
->proxy_origin
= idx
;
1451 /* Standard function. Just compute the length. */
1454 _bfd_vms_lib_generic_stat_arch_elt (bfd
*abfd
, struct stat
*st
)
1456 struct lib_tdata
*tdata
;
1459 if (abfd
->my_archive
== NULL
)
1461 bfd_set_error (bfd_error_invalid_operation
);
1465 tdata
= bfd_libdata (abfd
->my_archive
);
1466 if (tdata
->type
!= LBR__C_TYP_IOBJ
)
1468 struct vms_lib_iovec
*vec
= (struct vms_lib_iovec
*) abfd
->iostream
;
1470 if (vec
->file_len
== (ufile_ptr
)-1)
1472 if (vms_lib_bseek (abfd
, 0, SEEK_SET
) != 0)
1475 /* Compute length. */
1476 while (vms_lib_bread (abfd
, NULL
, 1 << 20) > 0)
1479 st
->st_size
= vec
->file_len
;
1483 st
->st_size
= ((struct areltdata
*)abfd
->arelt_data
)->parsed_size
;
1486 if (abfd
->mtime_set
)
1487 st
->st_mtime
= abfd
->mtime
;
1497 /* Internal representation of an index entry. */
1501 /* Corresponding archive member. */
1504 /* Number of reference to this entry. */
1507 /* Length of the key. */
1508 unsigned short namlen
;
1514 /* Used to sort index entries. */
1517 lib_index_cmp (const void *lv
, const void *rv
)
1519 const struct lib_index
*l
= lv
;
1520 const struct lib_index
*r
= rv
;
1522 return strcmp (l
->name
, r
->name
);
1525 /* Maximum number of index blocks level. */
1527 #define MAX_LEVEL 10
1529 /* Get the size of an index entry. */
1532 get_idxlen (struct lib_index
*idx
, bfd_boolean is_elfidx
)
1536 if (idx
->namlen
> MAX_KEYLEN
)
1537 return 9 + sizeof (struct vms_rfa
);
1539 return 9 + idx
->namlen
;
1542 return 7 + idx
->namlen
;
1545 /* Write the index. VBN is the first vbn to be used, and will contain
1546 on return the last vbn.
1547 Return TRUE on success. */
1550 vms_write_index (bfd
*abfd
,
1551 struct lib_index
*idx
, unsigned int nbr
, unsigned int *vbn
,
1552 unsigned int *topvbn
, bfd_boolean is_elfidx
)
1557 struct vms_indexdef
*rblk
[MAX_LEVEL
];
1562 unsigned short lastlen
;
1565 /* The kbn blocks are used to store long symbol names. */
1566 unsigned int kbn_sz
= 0; /* Number of bytes availble in the kbn block. */
1567 unsigned int kbn_vbn
= 0; /* VBN of the kbn block. */
1568 unsigned char *kbn_blk
= NULL
; /* Contents of the kbn block. */
1572 /* No entries. Very easy to handle. */
1580 /* Sort the index the first time this function is called. */
1581 qsort (idx
, nbr
, sizeof (struct lib_index
), lib_index_cmp
);
1584 /* Allocate first index block. */
1587 rblk
[0] = bfd_malloc (sizeof (struct vms_indexdef
));
1588 blk
[0].vbn
= (*vbn
)++;
1592 for (i
= 0; i
< nbr
; i
++, idx
++)
1594 unsigned int idxlen
;
1596 unsigned int key_vbn
= 0;
1597 unsigned int key_off
= 0;
1599 idxlen
= get_idxlen (idx
, is_elfidx
);
1601 if (is_elfidx
&& idx
->namlen
>= MAX_KEYLEN
)
1603 /* If the name is too long, write it in the kbn block. */
1604 unsigned int kl
= idx
->namlen
;
1605 unsigned int kl_chunk
;
1606 const char *key
= idx
->name
;
1608 /* Write the name in the kbn, chunk after chunk. */
1611 if (kbn_sz
< sizeof (struct vms_kbn
))
1613 /* Not enough room in the kbn block. */
1616 /* Write it to the disk (if there is one). */
1619 if (vms_write_block (abfd
, kbn_vbn
, kbn_blk
) != TRUE
)
1624 kbn_blk
= bfd_malloc (VMS_BLOCK_SIZE
);
1625 if (kbn_blk
== NULL
)
1628 *(unsigned short *)kbn_blk
= 0;
1631 kbn_sz
= VMS_BLOCK_SIZE
- 2;
1633 if (kl
+ sizeof (struct vms_kbn
) > kbn_sz
)
1634 kl_chunk
= kbn_sz
- sizeof (struct vms_kbn
);
1638 if (kbn_blk
!= NULL
)
1640 struct vms_kbn
*kbn
;
1642 kbn
= (struct vms_kbn
*)(kbn_blk
+ VMS_BLOCK_SIZE
- kbn_sz
);
1646 /* Save the rfa of the first chunk. */
1648 key_off
= VMS_BLOCK_SIZE
- kbn_sz
;
1651 bfd_putl16 (kl_chunk
, kbn
->keylen
);
1654 /* No next chunk. */
1655 bfd_putl32 (0, kbn
->rfa
.vbn
);
1656 bfd_putl16 (0, kbn
->rfa
.offset
);
1660 /* Next chunk will be at the start of the next block. */
1661 bfd_putl32 (*vbn
, kbn
->rfa
.vbn
);
1662 bfd_putl16 (2, kbn
->rfa
.offset
);
1664 memcpy ((char *)(kbn
+ 1), key
, kl_chunk
);
1668 kl_chunk
= (kl_chunk
+ 1) & ~1; /* Always align. */
1669 kbn_sz
-= kl_chunk
+ sizeof (struct vms_kbn
);
1674 /* Check if a block might overflow. In this case we will flush this
1675 block and all the blocks below it. */
1676 for (j
= 0; j
< level
; j
++)
1677 if (blk
[j
].len
+ blk
[j
].lastlen
+ idxlen
> INDEXDEF__BLKSIZ
)
1680 for (j
= 0; j
< level
; j
++)
1684 /* There is not enough room to write the new entry in this
1685 block or in a parent block. */
1689 BFD_ASSERT (level
< MAX_LEVEL
);
1691 /* Need to create a parent. */
1694 rblk
[level
] = bfd_malloc (sizeof (struct vms_indexdef
));
1695 bfd_putl32 (*vbn
, rblk
[j
]->parent
);
1697 blk
[level
].vbn
= (*vbn
)++;
1699 blk
[level
].lastlen
= 0;
1704 /* Update parent block: write the new entry. */
1707 struct vms_rfa
*rfa
;
1709 /* Copy the whole entry. */
1710 memcpy (rblk
[j
+ 1]->keys
+ blk
[j
+ 1].len
,
1711 rblk
[j
]->keys
+ blk
[j
].len
,
1713 /* Fix the entry (which in always the first field of an entry. */
1714 rfa
= (struct vms_rfa
*)(rblk
[j
+ 1]->keys
+ blk
[j
+ 1].len
);
1715 bfd_putl32 (blk
[j
].vbn
, rfa
->vbn
);
1716 bfd_putl16 (RFADEF__C_INDEX
, rfa
->offset
);
1721 /* And allocate it. Do it only on the block that won't be
1722 flushed (so that the parent of the parent can be
1724 blk
[j
+ 1].len
+= blk
[j
].lastlen
;
1725 blk
[j
+ 1].lastlen
= 0;
1728 /* Write this block on the disk. */
1731 bfd_putl16 (blk
[j
].len
+ blk
[j
].lastlen
, rblk
[j
]->used
);
1732 if (vms_write_block (abfd
, blk
[j
].vbn
, rblk
[j
]) != TRUE
)
1736 /* Reset this block. */
1739 blk
[j
].vbn
= (*vbn
)++;
1742 /* Append it to the block. */
1745 blk
[j
].len
+= blk
[j
].lastlen
;
1749 struct vms_rfa
*rfa
;
1751 rfa
= (struct vms_rfa
*)(rblk
[j
]->keys
+ blk
[j
].len
);
1752 bfd_putl32 ((idx
->abfd
->proxy_origin
/ VMS_BLOCK_SIZE
) + 1,
1755 ((idx
->abfd
->proxy_origin
% VMS_BLOCK_SIZE
)
1756 + (is_elfidx
? 0 : DATA__DATA
),
1761 /* Use elfidx format. */
1762 struct vms_elfidx
*en
= (struct vms_elfidx
*)rfa
;
1767 /* Long symbol name. */
1768 struct vms_kbn
*k
= (struct vms_kbn
*)(en
->keyname
);
1769 bfd_putl16 (sizeof (struct vms_kbn
), en
->keylen
);
1770 bfd_putl16 (idx
->namlen
, k
->keylen
);
1771 bfd_putl32 (key_vbn
, k
->rfa
.vbn
);
1772 bfd_putl16 (key_off
, k
->rfa
.offset
);
1773 en
->flags
|= ELFIDX__SYMESC
;
1777 bfd_putl16 (idx
->namlen
, en
->keylen
);
1778 memcpy (en
->keyname
, idx
->name
, idx
->namlen
);
1783 /* Use idx format. */
1784 struct vms_idx
*en
= (struct vms_idx
*)rfa
;
1785 en
->keylen
= idx
->namlen
;
1786 memcpy (en
->keyname
, idx
->name
, idx
->namlen
);
1791 blk
[j
].lastlen
= idxlen
;
1796 *topvbn
= blk
[level
- 1].vbn
;
1802 for (j
= 0; j
< level
; j
++)
1806 /* Update parent block: write the new entry. */
1809 struct vms_rfa
*rfa
;
1811 en
= rblk
[j
- 1]->keys
+ blk
[j
- 1].len
;
1812 par
= rblk
[j
]->keys
+ blk
[j
].len
;
1813 memcpy (par
, en
, blk
[j
- 1].lastlen
);
1814 rfa
= (struct vms_rfa
*)par
;
1815 bfd_putl32 (blk
[j
- 1].vbn
, rfa
->vbn
);
1816 bfd_putl16 (RFADEF__C_INDEX
, rfa
->offset
);
1819 /* Write this block on the disk. */
1820 bfd_putl16 (blk
[j
].len
+ blk
[j
].lastlen
, rblk
[j
]->used
);
1821 if (vms_write_block (abfd
, blk
[j
].vbn
, rblk
[j
]) != TRUE
)
1829 if (vms_write_block (abfd
, kbn_vbn
, kbn_blk
) != TRUE
)
1836 /* Append data to the data block DATA. Force write if PAD is true. */
1839 vms_write_data_block (bfd
*arch
, struct vms_datadef
*data
, file_ptr
*off
,
1840 const unsigned char *buf
, unsigned int len
, int pad
)
1842 while (len
> 0 || pad
)
1844 unsigned int doff
= *off
& (VMS_BLOCK_SIZE
- 1);
1845 unsigned int remlen
= (DATA__LENGTH
- DATA__DATA
) - doff
;
1848 l
= (len
> remlen
) ? remlen
: len
;
1849 memcpy (data
->data
+ doff
, buf
, l
);
1855 if (doff
== (DATA__LENGTH
- DATA__DATA
) || (len
== 0 && pad
))
1859 bfd_putl32 ((*off
/ VMS_BLOCK_SIZE
) + 2, data
->link
);
1861 if (bfd_bwrite (data
, sizeof (*data
), arch
) != sizeof (*data
))
1864 *off
+= DATA__LENGTH
- doff
;
1873 /* Build the symbols index. */
1876 _bfd_vms_lib_build_map (unsigned int nbr_modules
,
1877 struct lib_index
*modules
,
1878 unsigned int *res_cnt
,
1879 struct lib_index
**res
)
1882 asymbol
**syms
= NULL
;
1884 struct lib_index
*map
= NULL
;
1885 unsigned int map_max
= 1024; /* Fine initial default. */
1886 unsigned int map_count
= 0;
1888 map
= (struct lib_index
*) bfd_malloc (map_max
* sizeof (struct lib_index
));
1892 /* Gather symbols. */
1893 for (i
= 0; i
< nbr_modules
; i
++)
1898 bfd
*current
= modules
[i
].abfd
;
1900 if ((bfd_get_file_flags (current
) & HAS_SYMS
) == 0)
1903 storage
= bfd_get_symtab_upper_bound (current
);
1909 if (storage
> syms_max
)
1914 syms
= (asymbol
**) bfd_malloc (syms_max
);
1918 symcount
= bfd_canonicalize_symtab (current
, syms
);
1922 /* Now map over all the symbols, picking out the ones we
1924 for (src_count
= 0; src_count
< symcount
; src_count
++)
1926 flagword flags
= (syms
[src_count
])->flags
;
1927 asection
*sec
= syms
[src_count
]->section
;
1929 if ((flags
& BSF_GLOBAL
1931 || flags
& BSF_INDIRECT
1932 || bfd_is_com_section (sec
))
1933 && ! bfd_is_und_section (sec
))
1935 struct lib_index
*new_map
;
1937 /* This symbol will go into the archive header. */
1938 if (map_count
== map_max
)
1941 new_map
= (struct lib_index
*)
1942 bfd_realloc (map
, map_max
* sizeof (struct lib_index
));
1943 if (new_map
== NULL
)
1948 map
[map_count
].abfd
= current
;
1949 map
[map_count
].namlen
= strlen (syms
[src_count
]->name
);
1950 map
[map_count
].name
= syms
[src_count
]->name
;
1958 *res_cnt
= map_count
;
1970 /* Do the hard work: write an archive on the disk. */
1973 _bfd_vms_lib_write_archive_contents (bfd
*arch
)
1976 unsigned int nbr_modules
;
1977 struct lib_index
*modules
;
1978 unsigned int nbr_symbols
;
1979 struct lib_index
*symbols
;
1980 struct lib_tdata
*tdata
= bfd_libdata (arch
);
1983 unsigned int nbr_mod_iblk
;
1984 unsigned int nbr_sym_iblk
;
1986 unsigned int mod_idx_vbn
;
1987 unsigned int sym_idx_vbn
;
1988 bfd_boolean is_elfidx
= tdata
->kind
== vms_lib_ia64
;
1990 /* Count the number of modules (and do a first sanity check). */
1992 for (current
= arch
->archive_head
;
1994 current
= current
->archive_next
)
1996 /* This check is checking the bfds for the objects we're reading
1997 from (which are usually either an object file or archive on
1998 disk), not the archive entries we're writing to. We don't
1999 actually create bfds for the archive members, we just copy
2000 them byte-wise when we write out the archive. */
2001 if (bfd_write_p (current
) || !bfd_check_format (current
, bfd_object
))
2003 bfd_set_error (bfd_error_invalid_operation
);
2010 /* Build the modules list. */
2011 BFD_ASSERT (tdata
->modules
== NULL
);
2012 modules
= bfd_alloc (arch
, nbr_modules
* sizeof (struct lib_index
));
2013 if (modules
== NULL
)
2016 for (current
= arch
->archive_head
, i
= 0;
2018 current
= current
->archive_next
, i
++)
2022 modules
[i
].abfd
= current
;
2023 modules
[i
].name
= vms_get_module_name (current
->filename
, FALSE
);
2026 /* FIXME: silently truncate long names ? */
2027 nl
= strlen (modules
[i
].name
);
2028 modules
[i
].namlen
= (nl
> MAX_KEYLEN
? MAX_KEYLEN
: nl
);
2031 /* Create the module index. */
2033 if (!vms_write_index (NULL
, modules
, nbr_modules
, &vbn
, NULL
, is_elfidx
))
2037 /* Create symbol index. */
2038 if (!_bfd_vms_lib_build_map (nbr_modules
, modules
, &nbr_symbols
, &symbols
))
2042 if (!vms_write_index (NULL
, symbols
, nbr_symbols
, &vbn
, NULL
, is_elfidx
))
2046 /* Write modules and remember their position. */
2047 off
= (1 + nbr_mod_iblk
+ nbr_sym_iblk
) * VMS_BLOCK_SIZE
;
2049 if (bfd_seek (arch
, off
, SEEK_SET
) != 0)
2052 for (i
= 0; i
< nbr_modules
; i
++)
2054 struct vms_datadef data
;
2055 unsigned char blk
[VMS_BLOCK_SIZE
];
2056 struct vms_mhd
*mhd
;
2059 current
= modules
[i
].abfd
;
2060 current
->proxy_origin
= off
;
2066 /* Write the MHD as a record (ie, size first). */
2068 bfd_putl16 (tdata
->mhd_size
, blk
);
2070 mhd
= (struct vms_mhd
*)(blk
+ sz
);
2071 memset (mhd
, 0, sizeof (struct vms_mhd
));
2073 mhd
->id
= MHD__C_MHDID
;
2075 memcpy (mhd
->objid
, "V1.0", 4);
2076 bfd_putl32 (modules
[i
].ref
, mhd
->refcnt
);
2079 sz
+= tdata
->mhd_size
;
2082 /* Rewind the member to be put into the archive. */
2083 if (bfd_seek (current
, 0, SEEK_SET
) != 0)
2086 /* Copy the member into the archive. */
2089 unsigned int modsize
= 0;
2091 file_ptr off_hdr
= off
;
2093 /* Read to complete the first block. */
2094 amt
= bfd_bread (blk
+ sz
, VMS_BLOCK_SIZE
- sz
, current
);
2095 if (amt
== (bfd_size_type
)-1)
2098 if (amt
< VMS_BLOCK_SIZE
- sz
)
2100 /* The member size is less than a block. Pad the block. */
2101 memset (blk
+ sz
+ amt
, 0, VMS_BLOCK_SIZE
- sz
- amt
);
2103 bfd_putl32 (modsize
, mhd
->modsize
);
2105 /* Write the first block (which contains an mhd). */
2106 if (bfd_bwrite (blk
, VMS_BLOCK_SIZE
, arch
) != VMS_BLOCK_SIZE
)
2109 if (amt
== VMS_BLOCK_SIZE
- sz
)
2111 /* Copy the remaining. */
2112 char buffer
[DEFAULT_BUFFERSIZE
];
2116 amt
= bfd_bread (buffer
, sizeof (buffer
), current
);
2117 if (amt
== (bfd_size_type
)-1)
2122 if (amt
!= sizeof (buffer
))
2124 /* Clear the padding. */
2125 memset (buffer
+ amt
, 0, sizeof (buffer
) - amt
);
2126 amt
= (amt
+ VMS_BLOCK_SIZE
) & ~(VMS_BLOCK_SIZE
- 1);
2128 if (bfd_bwrite (buffer
, amt
, arch
) != amt
)
2133 /* Now that the size is known, write the first block (again). */
2134 bfd_putl32 (modsize
, mhd
->modsize
);
2135 if (bfd_seek (arch
, off_hdr
, SEEK_SET
) != 0
2136 || bfd_bwrite (blk
, VMS_BLOCK_SIZE
, arch
) != VMS_BLOCK_SIZE
)
2138 if (bfd_seek (arch
, off
, SEEK_SET
) != 0)
2144 /* Write the MHD. */
2145 if (vms_write_data_block (arch
, &data
, &off
, blk
, sz
, 0) < 0)
2148 /* Write the member. */
2151 sz
= bfd_bread (blk
, sizeof (blk
), current
);
2154 if (vms_write_data_block (arch
, &data
, &off
, blk
, sz
, 0) < 0)
2158 /* Write the end of module marker. */
2159 if (vms_write_data_block (arch
, &data
, &off
,
2160 eotdesc
, sizeof (eotdesc
), 1) < 0)
2165 /* Write the indexes. */
2167 if (vms_write_index (arch
, modules
, nbr_modules
, &vbn
, &mod_idx_vbn
,
2170 if (vms_write_index (arch
, symbols
, nbr_symbols
, &vbn
, &sym_idx_vbn
,
2174 /* Write libary header. */
2176 unsigned char blk
[VMS_BLOCK_SIZE
];
2177 struct vms_lhd
*lhd
= (struct vms_lhd
*)blk
;
2178 struct vms_idd
*idd
= (struct vms_idd
*)(blk
+ sizeof (*lhd
));
2179 unsigned int idd_flags
;
2180 unsigned int saneid
;
2182 memset (blk
, 0, sizeof (blk
));
2184 lhd
->type
= tdata
->type
;
2186 switch (tdata
->kind
)
2189 saneid
= LHD_SANEID3
;
2192 saneid
= LHD_SANEID6
;
2197 bfd_putl32 (saneid
, lhd
->sanity
);
2198 bfd_putl16 (tdata
->ver
, lhd
->majorid
);
2199 bfd_putl16 (0, lhd
->minorid
);
2200 snprintf ((char *)lhd
->lbrver
+ 1, sizeof (lhd
->lbrver
) - 1,
2202 (unsigned)(BFD_VERSION
/ 100000000UL),
2203 (unsigned)(BFD_VERSION
/ 1000000UL) % 100,
2204 (unsigned)(BFD_VERSION
/ 10000UL) % 100);
2205 lhd
->lbrver
[sizeof (lhd
->lbrver
) - 1] = 0;
2206 lhd
->lbrver
[0] = strlen ((char *)lhd
->lbrver
+ 1);
2208 bfd_putl32 (tdata
->credat_lo
, lhd
->credat
+ 0);
2209 bfd_putl32 (tdata
->credat_hi
, lhd
->credat
+ 4);
2210 vms_raw_get_time (lhd
->updtim
);
2212 lhd
->mhdusz
= tdata
->mhd_size
- MHD__C_USRDAT
;
2214 bfd_putl32 (nbr_modules
+ nbr_symbols
, lhd
->idxcnt
);
2215 bfd_putl32 (nbr_modules
, lhd
->modcnt
);
2216 bfd_putl32 (nbr_modules
, lhd
->modhdrs
);
2218 bfd_putl32 (vbn
- 1, lhd
->hipreal
);
2219 bfd_putl32 (vbn
- 1, lhd
->hiprusd
);
2221 /* First index (modules name). */
2222 idd_flags
= IDD__FLAGS_ASCII
| IDD__FLAGS_VARLENIDX
2223 | IDD__FLAGS_NOCASECMP
| IDD__FLAGS_NOCASENTR
;
2224 bfd_putl16 (idd_flags
, idd
->flags
);
2225 bfd_putl16 (MAX_KEYLEN
, idd
->keylen
);
2226 bfd_putl16 (mod_idx_vbn
, idd
->vbn
);
2229 /* Second index (symbols name). */
2230 bfd_putl16 (idd_flags
, idd
->flags
);
2231 bfd_putl16 (MAX_KEYLEN
, idd
->keylen
);
2232 bfd_putl16 (sym_idx_vbn
, idd
->vbn
);
2235 if (vms_write_block (arch
, 1, blk
) != TRUE
)
2242 bfd_set_error (bfd_error_on_input
, current
, bfd_get_error ());
2246 /* Add a target for text library. This costs almost nothing and is useful to
2247 read VMS library on the host. */
2249 const bfd_target vms_lib_txt_vec
=
2251 "vms-libtxt", /* Name. */
2252 bfd_target_unknown_flavour
,
2253 BFD_ENDIAN_UNKNOWN
, /* byteorder */
2254 BFD_ENDIAN_UNKNOWN
, /* header_byteorder */
2255 0, /* Object flags. */
2256 0, /* Sect flags. */
2257 0, /* symbol_leading_char. */
2258 ' ', /* ar_pad_char. */
2259 15, /* ar_max_namelen. */
2260 bfd_getl64
, bfd_getl_signed_64
, bfd_putl64
,
2261 bfd_getl32
, bfd_getl_signed_32
, bfd_putl32
,
2262 bfd_getl16
, bfd_getl_signed_16
, bfd_putl16
,
2263 bfd_getl64
, bfd_getl_signed_64
, bfd_putl64
,
2264 bfd_getl32
, bfd_getl_signed_32
, bfd_putl32
,
2265 bfd_getl16
, bfd_getl_signed_16
, bfd_putl16
,
2267 {_bfd_dummy_target
, _bfd_dummy_target
, /* bfd_check_format. */
2268 _bfd_vms_lib_txt_archive_p
, _bfd_dummy_target
},
2269 {bfd_false
, bfd_false
, bfd_false
, bfd_false
}, /* bfd_set_format. */
2270 {bfd_false
, bfd_false
, bfd_false
, bfd_false
}, /* bfd_write_contents. */
2272 BFD_JUMP_TABLE_GENERIC (_bfd_generic
),
2273 BFD_JUMP_TABLE_COPY (_bfd_generic
),
2274 BFD_JUMP_TABLE_CORE (_bfd_nocore
),
2275 BFD_JUMP_TABLE_ARCHIVE (_bfd_vms_lib
),
2276 BFD_JUMP_TABLE_SYMBOLS (_bfd_nosymbols
),
2277 BFD_JUMP_TABLE_RELOCS (_bfd_norelocs
),
2278 BFD_JUMP_TABLE_WRITE (_bfd_nowrite
),
2279 BFD_JUMP_TABLE_LINK (_bfd_nolink
),
2280 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic
),