1 /* BFD back-end for VMS archive files.
3 Copyright (C) 2010-2020 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"
28 #include "libiberty.h"
33 /* The standard VMS disk block size. */
34 #ifndef VMS_BLOCK_SIZE
35 #define VMS_BLOCK_SIZE 512
38 /* Maximum key length (which is also the maximum symbol length in archive). */
39 #define MAX_KEYLEN 128
40 #define MAX_EKEYLEN 1024
46 unsigned char min_char
;
47 unsigned char max_char
;
53 /* Kind of library. Used to filter in archive_p. */
63 /* Back-end private data. */
67 /* Standard tdata for an archive. But we don't use many fields. */
68 struct artdata artdata
;
73 /* Type of the archive. */
76 /* Kind of archive. Summary of its type. */
77 enum vms_lib_kind kind
;
79 /* Total size of the mhd (element header). */
80 unsigned int mhd_size
;
83 unsigned int credat_lo
;
84 unsigned int credat_hi
;
86 /* Vector of modules (archive elements), already sorted. */
87 unsigned int nbr_modules
;
88 struct carsym
*modules
;
91 /* DCX (decompression) data. */
92 unsigned int nbr_dcxsbm
;
93 struct dcxsbm_desc
*dcxsbm
;
96 #define bfd_libdata(bfd) ((struct lib_tdata *)((bfd)->tdata.any))
98 /* End-Of-Text pattern. This is a special record to mark the end of file. */
100 static const unsigned char eotdesc
[] = { 0x03, 0x00, 0x77, 0x00, 0x77, 0x00 };
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
114 /* The table of content. */
117 /* Number of entries used in the table. */
120 /* Maximum number of entries. */
123 /* Do not allocate more that this number of entries. */
126 /* If true, the table was reallocated on the heap. If false, it is still
127 in the BFD's objalloc. */
128 bfd_boolean realloced
;
131 /* Simply add a name to the index. */
134 vms_add_index (struct carsym_mem
*cs
, char *name
,
135 unsigned int idx_vbn
, unsigned int idx_off
)
137 if (cs
->nbr
== cs
->max
)
142 if (cs
->max
> -33u / 2 || cs
->max
>= cs
->limit
)
144 bfd_set_error (bfd_error_file_too_big
);
147 cs
->max
= 2 * cs
->max
+ 32;
148 if (cs
->max
> cs
->limit
)
150 if (_bfd_mul_overflow (cs
->max
, sizeof (struct carsym
), &amt
))
152 bfd_set_error (bfd_error_file_too_big
);
158 n
= bfd_malloc (amt
);
161 memcpy (n
, cs
->idx
, cs
->nbr
* sizeof (struct carsym
));
162 /* And unfortunately we can't free cs->idx. */
166 n
= bfd_realloc_or_free (cs
->idx
, amt
);
171 cs
->realloced
= TRUE
;
173 cs
->idx
[cs
->nbr
].file_offset
= (idx_vbn
- 1) * VMS_BLOCK_SIZE
+ idx_off
;
174 cs
->idx
[cs
->nbr
].name
= name
;
179 /* Follow all member of a lns list (pointed by RFA) and add indexes for
180 NAME. Return FALSE in case of error. */
183 vms_add_indexes_from_list (bfd
*abfd
, struct carsym_mem
*cs
, char *name
,
192 vbn
= bfd_getl32 (rfa
->vbn
);
197 off
= (vbn
- 1) * VMS_BLOCK_SIZE
+ bfd_getl16 (rfa
->offset
);
198 if (bfd_seek (abfd
, off
, SEEK_SET
) != 0
199 || bfd_bread (&lns
, sizeof (lns
), abfd
) != sizeof (lns
))
202 if (!vms_add_index (cs
, name
,
203 bfd_getl32 (lns
.modrfa
.vbn
),
204 bfd_getl16 (lns
.modrfa
.offset
)))
211 /* Read block VBN from ABFD and store it into BLK. Return FALSE in case of error. */
214 vms_read_block (bfd
*abfd
, unsigned int vbn
, void *blk
)
218 off
= (vbn
- 1) * VMS_BLOCK_SIZE
;
219 if (bfd_seek (abfd
, off
, SEEK_SET
) != 0
220 || bfd_bread (blk
, VMS_BLOCK_SIZE
, abfd
) != VMS_BLOCK_SIZE
)
226 /* Write the content of BLK to block VBN of ABFD. Return FALSE in case of error. */
229 vms_write_block (bfd
*abfd
, unsigned int vbn
, void *blk
)
233 off
= (vbn
- 1) * VMS_BLOCK_SIZE
;
234 if (bfd_seek (abfd
, off
, SEEK_SET
) != 0
235 || bfd_bwrite (blk
, VMS_BLOCK_SIZE
, abfd
) != VMS_BLOCK_SIZE
)
241 /* Read index block VBN and put the entry in **IDX (which is updated).
242 If the entry is indirect, recurse. */
245 vms_traverse_index (bfd
*abfd
, unsigned int vbn
, struct carsym_mem
*cs
)
247 struct vms_indexdef indexdef
;
253 /* Read the index block. */
254 BFD_ASSERT (sizeof (indexdef
) == VMS_BLOCK_SIZE
);
255 if (!vms_read_block (abfd
, vbn
, &indexdef
))
259 p
= &indexdef
.keys
[0];
260 n
= bfd_getl16 (indexdef
.used
);
261 if (n
> sizeof (indexdef
.keys
))
266 unsigned int idx_vbn
;
267 unsigned int idx_off
;
269 unsigned char *keyname
;
272 /* Extract key length. */
273 if (bfd_libdata (abfd
)->ver
== LBR_MAJORID
)
275 struct vms_idx
*ridx
= (struct vms_idx
*)p
;
277 idx_vbn
= bfd_getl32 (ridx
->rfa
.vbn
);
278 idx_off
= bfd_getl16 (ridx
->rfa
.offset
);
280 keylen
= ridx
->keylen
;
282 keyname
= ridx
->keyname
;
284 else if (bfd_libdata (abfd
)->ver
== LBR_ELFMAJORID
)
286 struct vms_elfidx
*ridx
= (struct vms_elfidx
*)p
;
288 idx_vbn
= bfd_getl32 (ridx
->rfa
.vbn
);
289 idx_off
= bfd_getl16 (ridx
->rfa
.offset
);
291 keylen
= bfd_getl16 (ridx
->keylen
);
293 keyname
= ridx
->keyname
;
302 /* Point to the next index entry. */
303 p
= keyname
+ keylen
;
307 if (idx_off
== RFADEF__C_INDEX
)
309 /* Indirect entry. Recurse. */
310 if (!vms_traverse_index (abfd
, idx_vbn
, cs
))
315 /* Add a new entry. */
318 if (flags
& ELFIDX__SYMESC
)
320 /* Extended key name. */
321 unsigned int noff
= 0;
325 unsigned char kblk
[VMS_BLOCK_SIZE
];
328 if (keylen
!= sizeof (struct vms_kbn
))
331 kbn
= (struct vms_kbn
*)keyname
;
332 keylen
= bfd_getl16 (kbn
->keylen
);
334 name
= bfd_alloc (abfd
, keylen
+ 1);
337 kvbn
= bfd_getl32 (kbn
->rfa
.vbn
);
338 koff
= bfd_getl16 (kbn
->rfa
.offset
);
340 /* Read the key, chunk by chunk. */
345 if (!vms_read_block (abfd
, kvbn
, kblk
))
347 if (koff
> sizeof (kblk
) - sizeof (struct vms_kbn
))
349 kbn
= (struct vms_kbn
*)(kblk
+ koff
);
350 klen
= bfd_getl16 (kbn
->keylen
);
351 if (klen
> sizeof (kblk
) - koff
)
353 kvbn
= bfd_getl32 (kbn
->rfa
.vbn
);
354 koff
= bfd_getl16 (kbn
->rfa
.offset
);
356 if (noff
+ klen
> keylen
)
358 memcpy (name
+ noff
, kbn
+ 1, klen
);
369 /* Usual key name. */
370 name
= bfd_alloc (abfd
, keylen
+ 1);
374 memcpy (name
, keyname
, keylen
);
378 if (flags
& ELFIDX__LISTRFA
)
383 off
= (idx_vbn
- 1) * VMS_BLOCK_SIZE
+ idx_off
;
384 if (bfd_seek (abfd
, off
, SEEK_SET
) != 0
385 || bfd_bread (&lhs
, sizeof (lhs
), abfd
) != sizeof (lhs
))
388 /* These extra entries may cause reallocation of CS. */
389 if (!vms_add_indexes_from_list (abfd
, cs
, name
, &lhs
.ng_g_rfa
))
391 if (!vms_add_indexes_from_list (abfd
, cs
, name
, &lhs
.ng_wk_rfa
))
393 if (!vms_add_indexes_from_list (abfd
, cs
, name
, &lhs
.g_g_rfa
))
395 if (!vms_add_indexes_from_list (abfd
, cs
, name
, &lhs
.g_wk_rfa
))
400 if (!vms_add_index (cs
, name
, idx_vbn
, idx_off
))
409 /* Read index #IDX, which must have NBREL entries. */
411 static struct carsym
*
412 vms_lib_read_index (bfd
*abfd
, int idx
, unsigned int *nbrel
)
419 struct carsym_mem csm
;
421 /* Read index desription. */
422 if (bfd_seek (abfd
, LHD_IDXDESC
+ idx
* IDD_LENGTH
, SEEK_SET
) != 0
423 || bfd_bread (&idd
, sizeof (idd
), abfd
) != sizeof (idd
))
427 flags
= bfd_getl16 (idd
.flags
);
428 if (!(flags
& IDD__FLAGS_ASCII
)
429 || !(flags
& IDD__FLAGS_VARLENIDX
))
432 filesize
= bfd_get_file_size (abfd
);
436 csm
.realloced
= FALSE
;
439 /* Put an upper bound based on a file full of single char keys.
440 This is to prevent fuzzed binary silliness. It is easily
441 possible to set up loops over file blocks that add syms
443 if (filesize
/ (sizeof (struct vms_rfa
) + 2) <= -1u)
444 csm
.limit
= filesize
/ (sizeof (struct vms_rfa
) + 2);
446 if (csm
.max
> csm
.limit
)
448 if (_bfd_mul_overflow (csm
.max
, sizeof (struct carsym
), &amt
))
450 csm
.idx
= bfd_alloc (abfd
, amt
);
454 /* Note: if the index is empty, there is no block to traverse. */
455 vbn
= bfd_getl32 (idd
.vbn
);
456 if (vbn
!= 0 && !vms_traverse_index (abfd
, vbn
, &csm
))
458 if (csm
.realloced
&& csm
.idx
!= NULL
)
461 /* Note: in case of error, we can free what was allocated on the
463 bfd_release (abfd
, csm
.idx
);
469 /* There are more entries than the first estimate. Allocate on
470 the BFD's objalloc. */
471 struct carsym
*csbuf
;
472 csbuf
= bfd_alloc (abfd
, csm
.nbr
* sizeof (struct carsym
));
475 memcpy (csbuf
, csm
.idx
, csm
.nbr
* sizeof (struct carsym
));
483 /* Standard function. */
485 static const bfd_target
*
486 _bfd_vms_lib_archive_p (bfd
*abfd
, enum vms_lib_kind kind
)
490 unsigned int majorid
;
491 struct lib_tdata
*tdata_hold
;
492 struct lib_tdata
*tdata
;
494 unsigned int nbr_ent
;
497 if (bfd_bread (&lhd
, sizeof (lhd
), abfd
) != sizeof (lhd
))
499 if (bfd_get_error () != bfd_error_system_call
)
500 bfd_set_error (bfd_error_wrong_format
);
504 /* Check sanity (= magic) number. */
505 sanity
= bfd_getl32 (lhd
.sanity
);
506 if (!(sanity
== LHD_SANEID3
507 || sanity
== LHD_SANEID6
508 || sanity
== LHD_SANEID_DCX
))
510 bfd_set_error (bfd_error_wrong_format
);
513 majorid
= bfd_getl32 (lhd
.majorid
);
515 /* Check archive kind. */
519 if ((lhd
.type
!= LBR__C_TYP_EOBJ
&& lhd
.type
!= LBR__C_TYP_ESHSTB
)
520 || majorid
!= LBR_MAJORID
523 bfd_set_error (bfd_error_wrong_format
);
528 if ((lhd
.type
!= LBR__C_TYP_IOBJ
&& lhd
.type
!= LBR__C_TYP_ISHSTB
)
529 || majorid
!= LBR_ELFMAJORID
532 bfd_set_error (bfd_error_wrong_format
);
537 if ((lhd
.type
!= LBR__C_TYP_TXT
538 && lhd
.type
!= LBR__C_TYP_MLB
539 && lhd
.type
!= LBR__C_TYP_HLP
)
540 || majorid
!= LBR_MAJORID
543 bfd_set_error (bfd_error_wrong_format
);
551 /* Allocate and initialize private data. */
552 tdata_hold
= bfd_libdata (abfd
);
553 tdata
= (struct lib_tdata
*) bfd_zalloc (abfd
, sizeof (struct lib_tdata
));
556 abfd
->tdata
.any
= (void *)tdata
;
557 tdata
->ver
= majorid
;
558 tdata
->mhd_size
= MHD__C_USRDAT
+ lhd
.mhdusz
;
559 tdata
->type
= lhd
.type
;
561 tdata
->credat_lo
= bfd_getl32 (lhd
.credat
+ 0);
562 tdata
->credat_hi
= bfd_getl32 (lhd
.credat
+ 4);
565 tdata
->nbr_modules
= bfd_getl32 (lhd
.modcnt
);
566 tdata
->artdata
.symdef_count
= bfd_getl32 (lhd
.idxcnt
) - tdata
->nbr_modules
;
567 nbr_ent
= tdata
->nbr_modules
;
568 tdata
->modules
= vms_lib_read_index (abfd
, 0, &nbr_ent
);
569 if (tdata
->modules
== NULL
|| nbr_ent
!= tdata
->nbr_modules
)
573 nbr_ent
= tdata
->artdata
.symdef_count
;
574 tdata
->artdata
.symdefs
= vms_lib_read_index (abfd
, 1, &nbr_ent
);
575 if (tdata
->artdata
.symdefs
== NULL
)
577 /* Only IA64 archives may have more entries in the index that what
579 if (nbr_ent
!= tdata
->artdata
.symdef_count
580 && kind
!= vms_lib_ia64
)
582 tdata
->artdata
.symdef_count
= nbr_ent
;
584 tdata
->cache
= bfd_zalloc (abfd
, sizeof (bfd
*) * tdata
->nbr_modules
);
585 if (tdata
->cache
== NULL
)
588 /* Read DCX submaps. */
589 dcxvbn
= bfd_getl32 (lhd
.dcxmapvbn
);
592 unsigned char buf_reclen
[4];
595 struct vms_dcxmap
*map
;
596 unsigned int sbm_off
;
599 if (bfd_seek (abfd
, (dcxvbn
- 1) * VMS_BLOCK_SIZE
, SEEK_SET
) != 0
600 || bfd_bread (buf_reclen
, sizeof (buf_reclen
), abfd
)
601 != sizeof (buf_reclen
))
603 reclen
= bfd_getl32 (buf_reclen
);
604 if (reclen
< sizeof (struct vms_dcxmap
))
606 buf
= _bfd_malloc_and_read (abfd
, reclen
, reclen
);
609 map
= (struct vms_dcxmap
*)buf
;
610 tdata
->nbr_dcxsbm
= bfd_getl16 (map
->nsubs
);
611 sbm_off
= bfd_getl16 (map
->sub0
);
612 tdata
->dcxsbm
= (struct dcxsbm_desc
*)bfd_alloc
613 (abfd
, tdata
->nbr_dcxsbm
* sizeof (struct dcxsbm_desc
));
614 for (i
= 0; i
< tdata
->nbr_dcxsbm
; i
++)
616 struct vms_dcxsbm
*sbm
;
617 struct dcxsbm_desc
*sbmdesc
= &tdata
->dcxsbm
[i
];
618 unsigned int sbm_len
;
625 || reclen
- sbm_off
< sizeof (struct vms_dcxsbm
))
627 sbm
= (struct vms_dcxsbm
*) (buf
+ sbm_off
);
628 sbm_sz
= bfd_getl16 (sbm
->size
);
631 sbmdesc
->min_char
= sbm
->min_char
;
632 BFD_ASSERT (sbmdesc
->min_char
== 0);
633 sbmdesc
->max_char
= sbm
->max_char
;
634 sbm_len
= sbmdesc
->max_char
- sbmdesc
->min_char
+ 1;
635 l
= (2 * sbm_len
+ 7) / 8;
636 if (sbm_sz
< sizeof (struct vms_dcxsbm
) + l
+ sbm_len
637 || (tdata
->nbr_dcxsbm
> 1
638 && sbm_sz
< sizeof (struct vms_dcxsbm
) + l
+ 3 * sbm_len
))
640 sbmdesc
->flags
= (unsigned char *)bfd_alloc (abfd
, l
);
641 off
= bfd_getl16 (sbm
->flags
);
642 if (off
> reclen
- sbm_off
643 || reclen
- sbm_off
- off
< l
)
645 memcpy (sbmdesc
->flags
, (bfd_byte
*) sbm
+ off
, l
);
646 sbmdesc
->nodes
= (unsigned char *)bfd_alloc (abfd
, 2 * sbm_len
);
647 off
= bfd_getl16 (sbm
->nodes
);
648 if (off
> reclen
- sbm_off
649 || reclen
- sbm_off
- off
< 2 * sbm_len
)
651 memcpy (sbmdesc
->nodes
, (bfd_byte
*) sbm
+ off
, 2 * sbm_len
);
652 off
= bfd_getl16 (sbm
->next
);
655 if (off
> reclen
- sbm_off
656 || reclen
- sbm_off
- off
< 2 * sbm_len
)
658 /* Read the 'next' array. */
659 sbmdesc
->next
= (unsigned short *) bfd_alloc (abfd
, 2 * sbm_len
);
660 buf1
= (bfd_byte
*) sbm
+ off
;
661 for (j
= 0; j
< sbm_len
; j
++)
662 sbmdesc
->next
[j
] = bfd_getl16 (buf1
+ j
* 2);
666 /* There is no next array if there is only one submap. */
667 BFD_ASSERT (tdata
->nbr_dcxsbm
== 1);
668 sbmdesc
->next
= NULL
;
675 tdata
->nbr_dcxsbm
= 0;
678 /* The map is always present. Also mark shared image library. */
679 abfd
->has_armap
= TRUE
;
680 if (tdata
->type
== LBR__C_TYP_ESHSTB
|| tdata
->type
== LBR__C_TYP_ISHSTB
)
681 abfd
->is_thin_archive
= TRUE
;
686 bfd_release (abfd
, tdata
);
687 abfd
->tdata
.any
= (void *)tdata_hold
;
691 /* Standard function for alpha libraries. */
694 _bfd_vms_lib_alpha_archive_p (bfd
*abfd
)
696 return _bfd_vms_lib_archive_p (abfd
, vms_lib_alpha
);
699 /* Standard function for ia64 libraries. */
702 _bfd_vms_lib_ia64_archive_p (bfd
*abfd
)
704 return _bfd_vms_lib_archive_p (abfd
, vms_lib_ia64
);
707 /* Standard function for text libraries. */
709 static const bfd_target
*
710 _bfd_vms_lib_txt_archive_p (bfd
*abfd
)
712 return _bfd_vms_lib_archive_p (abfd
, vms_lib_txt
);
715 /* Standard bfd function. */
718 _bfd_vms_lib_mkarchive (bfd
*abfd
, enum vms_lib_kind kind
)
720 struct lib_tdata
*tdata
;
722 tdata
= (struct lib_tdata
*) bfd_zalloc (abfd
, sizeof (struct lib_tdata
));
726 abfd
->tdata
.any
= (void *)tdata
;
727 vms_get_time (&tdata
->credat_hi
, &tdata
->credat_lo
);
733 tdata
->ver
= LBR_MAJORID
;
734 tdata
->mhd_size
= offsetof (struct vms_mhd
, pad1
);
735 tdata
->type
= LBR__C_TYP_EOBJ
;
738 tdata
->ver
= LBR_ELFMAJORID
;
739 tdata
->mhd_size
= sizeof (struct vms_mhd
);
740 tdata
->type
= LBR__C_TYP_IOBJ
;
746 tdata
->nbr_modules
= 0;
747 tdata
->artdata
.symdef_count
= 0;
748 tdata
->modules
= NULL
;
749 tdata
->artdata
.symdefs
= NULL
;
756 _bfd_vms_lib_alpha_mkarchive (bfd
*abfd
)
758 return _bfd_vms_lib_mkarchive (abfd
, vms_lib_alpha
);
762 _bfd_vms_lib_ia64_mkarchive (bfd
*abfd
)
764 return _bfd_vms_lib_mkarchive (abfd
, vms_lib_ia64
);
767 /* Find NAME in the symbol index. Return the index. */
770 _bfd_vms_lib_find_symbol (bfd
*abfd
, const char *name
)
772 struct lib_tdata
*tdata
= bfd_libdata (abfd
);
773 carsym
*syms
= tdata
->artdata
.symdefs
;
776 /* Open-coded binary search for speed. */
778 hi
= tdata
->artdata
.symdef_count
- 1;
782 int mid
= lo
+ (hi
- lo
) / 2;
785 diff
= (char)(name
[0] - syms
[mid
].name
[0]);
787 diff
= strcmp (name
, syms
[mid
].name
);
795 return BFD_NO_MORE_SYMBOLS
;
798 /* IO vector for archive member. Need that because members are not linearly
799 stored in archives. */
803 /* Current offset. */
806 /* Length of the module, when known. */
809 /* Current position in the record from bfd_bread point of view (ie, after
810 decompression). 0 means that no data byte have been read, -2 and -1
811 are reserved for the length word. */
813 #define REC_POS_NL -4
814 #define REC_POS_PAD -3
815 #define REC_POS_LEN0 -2
816 #define REC_POS_LEN1 -1
819 unsigned short rec_len
;
820 /* Number of bytes to read in the current record. */
821 unsigned short rec_rem
;
822 /* Offset of the next block. */
824 /* Current *data* offset in the data block. */
825 unsigned short blk_off
;
827 /* Offset of the first block. Extracted from the index. */
828 file_ptr first_block
;
830 /* Initial next_block. Extracted when the MHD is read. */
831 file_ptr init_next_block
;
832 /* Initial blk_off, once the MHD is read. */
833 unsigned short init_blk_off
;
835 /* Used to store any 3 byte record, which could be the EOF pattern. */
836 unsigned char pattern
[4];
839 struct dcxsbm_desc
*dcxsbms
;
840 /* Current submap. */
841 struct dcxsbm_desc
*dcx_sbm
;
842 /* Current offset in the submap. */
843 unsigned int dcx_offset
;
846 /* Compressed buffer. */
847 unsigned char *dcx_buf
;
848 /* Size of the buffer. Used to resize. */
849 unsigned int dcx_max
;
850 /* Number of valid bytes in the buffer. */
851 unsigned int dcx_rlen
;
854 /* Return the current position. */
857 vms_lib_btell (struct bfd
*abfd
)
859 struct vms_lib_iovec
*vec
= (struct vms_lib_iovec
*) abfd
->iostream
;
863 /* Read the header of the next data block if all bytes of the current block
867 vms_lib_read_block (struct bfd
*abfd
)
869 struct vms_lib_iovec
*vec
= (struct vms_lib_iovec
*) abfd
->iostream
;
871 if (vec
->blk_off
== DATA__LENGTH
)
873 unsigned char hdr
[DATA__DATA
];
875 /* Read next block. */
876 if (bfd_seek (abfd
->my_archive
, vec
->next_block
, SEEK_SET
) != 0)
878 if (bfd_bread (hdr
, sizeof (hdr
), abfd
->my_archive
) != sizeof (hdr
))
880 vec
->next_block
= (bfd_getl32 (hdr
+ 2) - 1) * VMS_BLOCK_SIZE
;
881 vec
->blk_off
= sizeof (hdr
);
886 /* Read NBYTES from ABFD into BUF if not NULL. If BUF is NULL, bytes are
887 not stored. Read linearly from the library, but handle blocks. This
888 function does not handle records nor EOF. */
891 vms_lib_bread_raw (struct bfd
*abfd
, unsigned char *buf
, file_ptr nbytes
)
893 struct vms_lib_iovec
*vec
= (struct vms_lib_iovec
*) abfd
->iostream
;
901 /* Be sure the current data block is read. */
902 if (!vms_lib_read_block (abfd
))
905 /* Do not read past the data block, do not read more than requested. */
906 l
= DATA__LENGTH
- vec
->blk_off
;
913 /* Really read into BUF. */
914 if (bfd_bread (buf
, l
, abfd
->my_archive
) != l
)
919 /* Make as if we are reading. */
920 if (bfd_seek (abfd
->my_archive
, l
, SEEK_CUR
) != 0)
933 /* Decompress NBYTES from VEC. Store the bytes into BUF if not NULL. */
936 vms_lib_dcx (struct vms_lib_iovec
*vec
, unsigned char *buf
, file_ptr nbytes
)
938 struct dcxsbm_desc
*sbm
;
944 /* The loop below expect to deliver at least one byte. */
948 /* Get the current state. */
950 offset
= vec
->dcx_offset
;
951 j
= vec
->dcx_pos
& 7;
953 for (i
= vec
->dcx_pos
>> 3; i
< vec
->dcx_rlen
; i
++)
955 unsigned char b
= vec
->dcx_buf
[i
];
961 if (!(sbm
->flags
[offset
>> 3] & (1 << (offset
& 7))))
963 unsigned int n_offset
= sbm
->nodes
[offset
];
966 /* End of buffer. Stay where we are. */
967 vec
->dcx_pos
= (i
<< 3) + j
;
970 vec
->dcx_offset
= offset
;
974 offset
= 2 * n_offset
;
978 unsigned char v
= sbm
->nodes
[offset
];
980 if (sbm
->next
!= NULL
)
981 sbm
= vec
->dcxsbms
+ sbm
->next
[v
];
992 vec
->dcx_pos
= (i
<< 3) + j
+ 1;
993 vec
->dcx_offset
= offset
;
1006 /* Standard IOVEC function. */
1009 vms_lib_bread (struct bfd
*abfd
, void *vbuf
, file_ptr nbytes
)
1011 struct vms_lib_iovec
*vec
= (struct vms_lib_iovec
*) abfd
->iostream
;
1014 unsigned char *buf
= (unsigned char *)vbuf
;
1016 /* Do not read past the end. */
1017 if (vec
->where
>= vec
->file_len
)
1023 if (vec
->rec_rem
== 0)
1025 unsigned char blen
[2];
1027 /* Read record length. */
1028 if (vms_lib_bread_raw (abfd
, blen
, sizeof (blen
)) != sizeof (blen
))
1030 vec
->rec_len
= bfd_getl16 (blen
);
1031 if (bfd_libdata (abfd
->my_archive
)->kind
== vms_lib_txt
)
1033 /* Discard record size and align byte. */
1035 vec
->rec_rem
= vec
->rec_len
;
1039 /* Prepend record size. */
1040 vec
->rec_pos
= REC_POS_LEN0
;
1041 vec
->rec_rem
= (vec
->rec_len
+ 1) & ~1; /* With align byte. */
1043 if (vec
->rec_len
== 3)
1045 /* Possibly end of file. Check the pattern. */
1046 if (vms_lib_bread_raw (abfd
, vec
->pattern
, 4) != 4)
1048 if (!memcmp (vec
->pattern
, eotdesc
+ 2, 3))
1050 /* This is really an EOF. */
1052 vec
->file_len
= vec
->where
;
1057 if (vec
->dcxsbms
!= NULL
)
1059 /* This is a compressed member. */
1063 /* Be sure there is enough room for the expansion. */
1064 len
= (vec
->rec_len
+ 1) & ~1;
1065 if (len
> vec
->dcx_max
)
1067 while (len
> vec
->dcx_max
)
1069 vec
->dcx_buf
= bfd_alloc (abfd
, vec
->dcx_max
);
1070 if (vec
->dcx_buf
== NULL
)
1074 /* Read the compressed record. */
1075 vec
->dcx_rlen
= len
;
1076 if (vec
->rec_len
== 3)
1079 memcpy (vec
->dcx_buf
, vec
->pattern
, 3);
1083 elen
= vms_lib_bread_raw (abfd
, vec
->dcx_buf
, len
);
1088 /* Dummy expansion to get the expanded length. */
1089 vec
->dcx_offset
= 0;
1090 vec
->dcx_sbm
= vec
->dcxsbms
;
1092 elen
= vms_lib_dcx (vec
, NULL
, 0x10000);
1095 vec
->rec_len
= elen
;
1096 vec
->rec_rem
= elen
;
1098 /* Reset the state. */
1099 vec
->dcx_offset
= 0;
1100 vec
->dcx_sbm
= vec
->dcxsbms
;
1104 if (vec
->rec_pos
< 0)
1107 switch (vec
->rec_pos
)
1110 c
= vec
->rec_len
& 0xff;
1111 vec
->rec_pos
= REC_POS_LEN1
;
1114 c
= (vec
->rec_len
>> 8) & 0xff;
1138 if (nbytes
> vec
->rec_rem
)
1139 chunk
= vec
->rec_rem
;
1143 if (vec
->dcxsbms
!= NULL
)
1145 /* Optimize the stat() case: no need to decompress again as we
1147 if (!(buf
== NULL
&& chunk
== vec
->rec_rem
))
1148 chunk
= vms_lib_dcx (vec
, buf
, chunk
);
1152 if (vec
->rec_len
== 3)
1155 memcpy (buf
, vec
->pattern
+ vec
->rec_pos
, chunk
);
1158 chunk
= vms_lib_bread_raw (abfd
, buf
, chunk
);
1166 vec
->rec_pos
+= chunk
;
1167 vec
->rec_rem
-= chunk
;
1169 if (vec
->rec_rem
== 0)
1171 /* End of record reached. */
1172 if (bfd_libdata (abfd
->my_archive
)->kind
== vms_lib_txt
)
1174 if ((vec
->rec_len
& 1) == 1
1175 && vec
->rec_len
!= 3
1176 && vec
->dcxsbms
== NULL
)
1178 /* Eat the pad byte. */
1180 if (vms_lib_bread_raw (abfd
, &pad
, 1) != 1)
1183 vec
->rec_pos
= REC_POS_NL
;
1188 if ((vec
->rec_len
& 1) == 1 && vec
->dcxsbms
!= NULL
)
1190 vec
->rec_pos
= REC_POS_PAD
;
1200 /* Standard function, but we currently only handle the rewind case. */
1203 vms_lib_bseek (struct bfd
*abfd
, file_ptr offset
, int whence
)
1205 struct vms_lib_iovec
*vec
= (struct vms_lib_iovec
*) abfd
->iostream
;
1207 if (whence
== SEEK_SET
&& offset
== 0)
1212 vec
->blk_off
= vec
->init_blk_off
;
1213 vec
->next_block
= vec
->init_next_block
;
1215 if (bfd_seek (abfd
->my_archive
, vec
->first_block
, SEEK_SET
) != 0)
1224 vms_lib_bwrite (struct bfd
*abfd ATTRIBUTE_UNUSED
,
1225 const void *where ATTRIBUTE_UNUSED
,
1226 file_ptr nbytes ATTRIBUTE_UNUSED
)
1232 vms_lib_bclose (struct bfd
*abfd
)
1234 abfd
->iostream
= NULL
;
1239 vms_lib_bflush (struct bfd
*abfd ATTRIBUTE_UNUSED
)
1245 vms_lib_bstat (struct bfd
*abfd ATTRIBUTE_UNUSED
,
1246 struct stat
*sb ATTRIBUTE_UNUSED
)
1248 /* Not supported. */
1253 vms_lib_bmmap (struct bfd
*abfd ATTRIBUTE_UNUSED
,
1254 void *addr ATTRIBUTE_UNUSED
,
1255 bfd_size_type len ATTRIBUTE_UNUSED
,
1256 int prot ATTRIBUTE_UNUSED
,
1257 int flags ATTRIBUTE_UNUSED
,
1258 file_ptr offset ATTRIBUTE_UNUSED
,
1259 void **map_addr ATTRIBUTE_UNUSED
,
1260 bfd_size_type
*map_len ATTRIBUTE_UNUSED
)
1265 static const struct bfd_iovec vms_lib_iovec
= {
1266 &vms_lib_bread
, &vms_lib_bwrite
, &vms_lib_btell
, &vms_lib_bseek
,
1267 &vms_lib_bclose
, &vms_lib_bflush
, &vms_lib_bstat
, &vms_lib_bmmap
1270 /* Open a library module. FILEPOS is the position of the module header. */
1273 vms_lib_bopen (bfd
*el
, file_ptr filepos
)
1275 struct vms_lib_iovec
*vec
;
1276 unsigned char buf
[256];
1277 struct vms_mhd
*mhd
;
1278 struct lib_tdata
*tdata
= bfd_libdata (el
->my_archive
);
1281 /* Allocate and initialized the iovec. */
1282 vec
= bfd_zalloc (el
, sizeof (*vec
));
1287 el
->iovec
= &vms_lib_iovec
;
1289 /* File length is not known. */
1292 /* Read the first data block. */
1293 vec
->next_block
= filepos
& ~(VMS_BLOCK_SIZE
- 1);
1294 vec
->blk_off
= DATA__LENGTH
;
1295 if (!vms_lib_read_block (el
))
1298 /* Prepare to read the first record. */
1299 vec
->blk_off
= filepos
& (VMS_BLOCK_SIZE
- 1);
1301 if (bfd_seek (el
->my_archive
, filepos
, SEEK_SET
) != 0)
1304 /* Read Record length + MHD + align byte. */
1305 len
= tdata
->mhd_size
;
1306 if (vms_lib_bread_raw (el
, buf
, 2) != 2)
1308 if (bfd_getl16 (buf
) != len
)
1310 len
= (len
+ 1) & ~1;
1311 BFD_ASSERT (len
<= sizeof (buf
));
1312 if (vms_lib_bread_raw (el
, buf
, len
) != len
)
1315 /* Get info from mhd. */
1316 mhd
= (struct vms_mhd
*)buf
;
1318 if (mhd
->id
!= MHD__C_MHDID
)
1320 if (len
>= MHD__C_MHDLEN
+ 1)
1321 el
->selective_search
= (mhd
->objstat
& MHD__M_SELSRC
) ? 1 : 0;
1322 el
->mtime
= vms_rawtime_to_time_t (mhd
->datim
);
1323 el
->mtime_set
= TRUE
;
1325 /* Reinit the iovec so that seek() will point to the first record after
1328 vec
->init_blk_off
= vec
->blk_off
;
1329 vec
->init_next_block
= vec
->next_block
;
1330 vec
->first_block
= bfd_tell (el
->my_archive
);
1331 vec
->dcxsbms
= bfd_libdata (el
->my_archive
)->dcxsbm
;
1333 if (vec
->dcxsbms
!= NULL
)
1336 vec
->dcx_max
= 10 * 1024;
1337 vec
->dcx_buf
= bfd_alloc (el
, vec
->dcx_max
);
1339 if (vec
->dcx_buf
== NULL
)
1345 /* Get member MODIDX. Return NULL in case of error. */
1348 _bfd_vms_lib_get_module (bfd
*abfd
, unsigned int modidx
)
1350 struct lib_tdata
*tdata
= bfd_libdata (abfd
);
1358 if (modidx
>= tdata
->nbr_modules
)
1361 /* Already loaded. */
1362 if (tdata
->cache
[modidx
])
1363 return tdata
->cache
[modidx
];
1366 file_off
= tdata
->modules
[modidx
].file_offset
;
1367 if (tdata
->type
!= LBR__C_TYP_IOBJ
)
1369 res
= _bfd_create_empty_archive_element_shell (abfd
);
1373 /* Special reader to deal with data blocks. */
1374 if (!vms_lib_bopen (res
, file_off
))
1380 struct vms_mhd
*mhd
;
1381 struct areltdata
*arelt
;
1383 /* Sanity check. The MHD must be big enough to contain module size. */
1384 if (tdata
->mhd_size
< offsetof (struct vms_mhd
, modsize
) + 4)
1387 /* Read the MHD now. */
1388 if (bfd_seek (abfd
, file_off
, SEEK_SET
) != 0)
1390 if (bfd_bread (buf
, tdata
->mhd_size
, abfd
) != tdata
->mhd_size
)
1393 mhd
= (struct vms_mhd
*) buf
;
1394 if (mhd
->id
!= MHD__C_MHDID
)
1397 res
= _bfd_create_empty_archive_element_shell (abfd
);
1400 arelt
= bfd_zmalloc (sizeof (*arelt
));
1406 res
->arelt_data
= arelt
;
1408 /* Get info from mhd. */
1409 if (tdata
->mhd_size
>= offsetof (struct vms_mhd
, objstat
) + 1)
1410 res
->selective_search
= (mhd
->objstat
& MHD__M_SELSRC
) ? 1 : 0;
1411 res
->mtime
= vms_rawtime_to_time_t (mhd
->datim
);
1412 res
->mtime_set
= TRUE
;
1414 arelt
->parsed_size
= bfd_getl32 (mhd
->modsize
);
1416 /* No need for a special reader as members are stored linearly.
1417 Just skip the MHD. */
1418 res
->origin
= file_off
+ tdata
->mhd_size
;
1422 name
= tdata
->modules
[modidx
].name
;
1423 namelen
= strlen (name
);
1424 newname
= bfd_malloc (namelen
+ 4 + 1);
1425 if (newname
== NULL
)
1430 strcpy (newname
, name
);
1431 switch (tdata
->type
)
1433 case LBR__C_TYP_IOBJ
:
1434 case LBR__C_TYP_EOBJ
:
1435 /* For object archives, append .obj to mimic standard behaviour. */
1436 strcpy (newname
+ namelen
, ".obj");
1441 bfd_set_filename (res
, newname
);
1443 tdata
->cache
[modidx
] = res
;
1448 /* Standard function: get member at IDX. */
1451 _bfd_vms_lib_get_elt_at_index (bfd
*abfd
, symindex symidx
)
1453 struct lib_tdata
*tdata
= bfd_libdata (abfd
);
1455 unsigned int modidx
;
1458 if (symidx
> tdata
->artdata
.symdef_count
)
1460 file_off
= tdata
->artdata
.symdefs
[symidx
].file_offset
;
1463 for (modidx
= 0; modidx
< tdata
->nbr_modules
; modidx
++)
1465 if (tdata
->modules
[modidx
].file_offset
== file_off
)
1468 if (modidx
>= tdata
->nbr_modules
)
1471 return _bfd_vms_lib_get_module (abfd
, modidx
);
1474 /* Elements of an imagelib are stubs. You can get the real image with this
1478 _bfd_vms_lib_get_imagelib_file (bfd
*el
)
1480 bfd
*archive
= el
->my_archive
;
1481 const char *modname
= el
->filename
;
1482 int modlen
= strlen (modname
);
1487 /* Convert module name to lower case and append '.exe'. */
1488 filename
= bfd_alloc (el
, modlen
+ 5);
1489 if (filename
== NULL
)
1491 for (j
= 0; j
< modlen
; j
++)
1492 if (ISALPHA (modname
[j
]))
1493 filename
[j
] = TOLOWER (modname
[j
]);
1495 filename
[j
] = modname
[j
];
1496 memcpy (filename
+ modlen
, ".exe", 5);
1498 filename
= _bfd_append_relative_path (archive
, filename
);
1499 if (filename
== NULL
)
1501 res
= bfd_openr (filename
, NULL
);
1505 /* xgettext:c-format */
1506 _bfd_error_handler(_("could not open shared image '%s' from '%s'"),
1507 filename
, archive
->filename
);
1508 bfd_release (archive
, filename
);
1512 /* FIXME: put it in a cache ? */
1516 /* Standard function. */
1519 _bfd_vms_lib_openr_next_archived_file (bfd
*archive
,
1528 idx
= last_file
->proxy_origin
+ 1;
1530 if (idx
>= bfd_libdata (archive
)->nbr_modules
)
1532 bfd_set_error (bfd_error_no_more_archived_files
);
1536 res
= _bfd_vms_lib_get_module (archive
, idx
);
1539 res
->proxy_origin
= idx
;
1543 /* Standard function. Just compute the length. */
1546 _bfd_vms_lib_generic_stat_arch_elt (bfd
*abfd
, struct stat
*st
)
1548 struct lib_tdata
*tdata
;
1551 if (abfd
->my_archive
== NULL
)
1553 bfd_set_error (bfd_error_invalid_operation
);
1557 tdata
= bfd_libdata (abfd
->my_archive
);
1558 if (tdata
->type
!= LBR__C_TYP_IOBJ
)
1560 struct vms_lib_iovec
*vec
= (struct vms_lib_iovec
*) abfd
->iostream
;
1562 if (vec
->file_len
== (ufile_ptr
)-1)
1564 if (vms_lib_bseek (abfd
, 0, SEEK_SET
) != 0)
1567 /* Compute length. */
1568 while (vms_lib_bread (abfd
, NULL
, 1 << 20) > 0)
1571 st
->st_size
= vec
->file_len
;
1575 st
->st_size
= ((struct areltdata
*)abfd
->arelt_data
)->parsed_size
;
1578 if (abfd
->mtime_set
)
1579 st
->st_mtime
= abfd
->mtime
;
1589 /* Internal representation of an index entry. */
1593 /* Corresponding archive member. */
1596 /* Number of reference to this entry. */
1599 /* Length of the key. */
1600 unsigned short namlen
;
1606 /* Used to sort index entries. */
1609 lib_index_cmp (const void *lv
, const void *rv
)
1611 const struct lib_index
*l
= lv
;
1612 const struct lib_index
*r
= rv
;
1614 return strcmp (l
->name
, r
->name
);
1617 /* Maximum number of index blocks level. */
1619 #define MAX_LEVEL 10
1621 /* Get the size of an index entry. */
1624 get_idxlen (struct lib_index
*idx
, bfd_boolean is_elfidx
)
1628 /* 9 is the size of struct vms_elfidx without keyname. */
1629 if (idx
->namlen
> MAX_KEYLEN
)
1630 return 9 + sizeof (struct vms_kbn
);
1632 return 9 + idx
->namlen
;
1636 /* 7 is the size of struct vms_idx without keyname. */
1637 return 7 + idx
->namlen
;
1641 /* Write the index composed by NBR symbols contained in IDX.
1642 VBN is the first vbn to be used, and will contain on return the last vbn.
1643 Can be called with ABFD set to NULL just to size the index.
1644 If not null, TOPVBN will be assigned to the vbn of the root index tree.
1645 IS_ELFIDX is true for elfidx (ie ia64) indexes layout.
1646 Return TRUE on success. */
1649 vms_write_index (bfd
*abfd
,
1650 struct lib_index
*idx
, unsigned int nbr
, unsigned int *vbn
,
1651 unsigned int *topvbn
, bfd_boolean is_elfidx
)
1653 /* The index is organized as a tree. This function implements a naive
1654 algorithm to balance the tree: it fills the leaves, and create a new
1655 branch when all upper leaves and branches are full. We only keep in
1656 memory a path to the current leaf. */
1660 /* Disk blocks for the current path. */
1661 struct vms_indexdef
*rblk
[MAX_LEVEL
];
1662 /* Info on the current blocks. */
1665 unsigned int vbn
; /* VBN of the block. */
1666 /* The last entry is identified so that it could be copied to the
1668 unsigned short len
; /* Length up to the last entry. */
1669 unsigned short lastlen
; /* Length of the last entry. */
1672 /* The kbn blocks are used to store long symbol names. */
1673 unsigned int kbn_sz
= 0; /* Number of bytes available in the kbn block. */
1674 unsigned int kbn_vbn
= 0; /* VBN of the kbn block. */
1675 unsigned char *kbn_blk
= NULL
; /* Contents of the kbn block. */
1679 /* No entries. Very easy to handle. */
1687 /* Sort the index the first time this function is called. */
1688 qsort (idx
, nbr
, sizeof (struct lib_index
), lib_index_cmp
);
1691 /* Allocate first index block. */
1694 rblk
[0] = bfd_zmalloc (sizeof (struct vms_indexdef
));
1695 blk
[0].vbn
= (*vbn
)++;
1699 for (i
= 0; i
< nbr
; i
++, idx
++)
1701 unsigned int idxlen
;
1703 unsigned int key_vbn
= 0;
1704 unsigned int key_off
= 0;
1706 idxlen
= get_idxlen (idx
, is_elfidx
);
1708 if (is_elfidx
&& idx
->namlen
> MAX_KEYLEN
)
1710 /* If the key (ie name) is too long, write it in the kbn block. */
1711 unsigned int kl
= idx
->namlen
;
1712 unsigned int kl_chunk
;
1713 const char *key
= idx
->name
;
1715 /* Write the key in the kbn, chunk after chunk. */
1718 if (kbn_sz
< sizeof (struct vms_kbn
))
1720 /* Not enough room in the kbn block. */
1723 /* Write it to the disk (if there is one). */
1726 if (!vms_write_block (abfd
, kbn_vbn
, kbn_blk
))
1731 kbn_blk
= bfd_malloc (VMS_BLOCK_SIZE
);
1732 if (kbn_blk
== NULL
)
1735 *(unsigned short *)kbn_blk
= 0;
1737 /* Allocate a new block for the keys. */
1739 kbn_sz
= VMS_BLOCK_SIZE
- 2;
1741 /* Size of the chunk written to the current key block. */
1742 if (kl
+ sizeof (struct vms_kbn
) > kbn_sz
)
1743 kl_chunk
= kbn_sz
- sizeof (struct vms_kbn
);
1747 if (kbn_blk
!= NULL
)
1749 struct vms_kbn
*kbn
;
1751 kbn
= (struct vms_kbn
*)(kbn_blk
+ VMS_BLOCK_SIZE
- kbn_sz
);
1755 /* Save the rfa of the first chunk. */
1757 key_off
= VMS_BLOCK_SIZE
- kbn_sz
;
1760 bfd_putl16 (kl_chunk
, kbn
->keylen
);
1763 /* No next chunk. */
1764 bfd_putl32 (0, kbn
->rfa
.vbn
);
1765 bfd_putl16 (0, kbn
->rfa
.offset
);
1769 /* Next chunk will be at the start of the next block. */
1770 bfd_putl32 (*vbn
, kbn
->rfa
.vbn
);
1771 bfd_putl16 (2, kbn
->rfa
.offset
);
1773 memcpy ((char *)(kbn
+ 1), key
, kl_chunk
);
1777 kl_chunk
= (kl_chunk
+ 1) & ~1; /* Always align. */
1778 kbn_sz
-= kl_chunk
+ sizeof (struct vms_kbn
);
1783 /* Check if a block might overflow. In this case we will flush this
1784 block and all the blocks below it. */
1785 for (j
= 0; j
< level
; j
++)
1786 if (blk
[j
].len
+ blk
[j
].lastlen
+ idxlen
> INDEXDEF__BLKSIZ
)
1789 for (j
= 0; j
< level
; j
++)
1793 /* There is not enough room to write the new entry in this
1794 block or in a parent block. */
1798 BFD_ASSERT (level
< MAX_LEVEL
);
1800 /* Need to create a parent. */
1803 rblk
[level
] = bfd_zmalloc (sizeof (struct vms_indexdef
));
1804 bfd_putl32 (*vbn
, rblk
[j
]->parent
);
1806 blk
[level
].vbn
= (*vbn
)++;
1808 blk
[level
].lastlen
= blk
[j
].lastlen
;
1813 /* Update parent block: write the last entry from the current
1817 struct vms_rfa
*rfa
;
1819 /* Pointer to the last entry in parent block. */
1820 rfa
= (struct vms_rfa
*)(rblk
[j
+ 1]->keys
+ blk
[j
+ 1].len
);
1822 /* Copy the whole entry. */
1823 BFD_ASSERT (blk
[j
+ 1].lastlen
== blk
[j
].lastlen
);
1824 memcpy (rfa
, rblk
[j
]->keys
+ blk
[j
].len
, blk
[j
].lastlen
);
1825 /* Fix the entry (which in always the first field of an
1827 bfd_putl32 (blk
[j
].vbn
, rfa
->vbn
);
1828 bfd_putl16 (RFADEF__C_INDEX
, rfa
->offset
);
1833 /* And allocate it. Do it only on the block that won't be
1834 flushed (so that the parent of the parent can be
1836 blk
[j
+ 1].len
+= blk
[j
+ 1].lastlen
;
1837 blk
[j
+ 1].lastlen
= 0;
1840 /* Write this block on the disk. */
1843 bfd_putl16 (blk
[j
].len
+ blk
[j
].lastlen
, rblk
[j
]->used
);
1844 if (!vms_write_block (abfd
, blk
[j
].vbn
, rblk
[j
]))
1848 /* Reset this block. */
1851 blk
[j
].vbn
= (*vbn
)++;
1854 /* Append it to the block. */
1857 /* Keep the previous last entry. */
1858 blk
[j
].len
+= blk
[j
].lastlen
;
1862 struct vms_rfa
*rfa
;
1864 rfa
= (struct vms_rfa
*)(rblk
[j
]->keys
+ blk
[j
].len
);
1865 bfd_putl32 ((idx
->abfd
->proxy_origin
/ VMS_BLOCK_SIZE
) + 1,
1868 ((idx
->abfd
->proxy_origin
% VMS_BLOCK_SIZE
)
1869 + (is_elfidx
? 0 : DATA__DATA
),
1874 /* Use elfidx format. */
1875 struct vms_elfidx
*en
= (struct vms_elfidx
*)rfa
;
1880 /* Long symbol name. */
1881 struct vms_kbn
*k
= (struct vms_kbn
*)(en
->keyname
);
1882 bfd_putl16 (sizeof (struct vms_kbn
), en
->keylen
);
1883 bfd_putl16 (idx
->namlen
, k
->keylen
);
1884 bfd_putl32 (key_vbn
, k
->rfa
.vbn
);
1885 bfd_putl16 (key_off
, k
->rfa
.offset
);
1886 en
->flags
|= ELFIDX__SYMESC
;
1890 bfd_putl16 (idx
->namlen
, en
->keylen
);
1891 memcpy (en
->keyname
, idx
->name
, idx
->namlen
);
1896 /* Use idx format. */
1897 struct vms_idx
*en
= (struct vms_idx
*)rfa
;
1898 en
->keylen
= idx
->namlen
;
1899 memcpy (en
->keyname
, idx
->name
, idx
->namlen
);
1903 /* The last added key can now be the last one all blocks in the
1905 blk
[j
].lastlen
= idxlen
;
1909 /* Save VBN of the root. */
1911 *topvbn
= blk
[level
- 1].vbn
;
1917 for (j
= 1; j
< level
; j
++)
1919 /* Update parent block: write the new entry. */
1922 struct vms_rfa
*rfa
;
1924 en
= rblk
[j
- 1]->keys
+ blk
[j
- 1].len
;
1925 par
= rblk
[j
]->keys
+ blk
[j
].len
;
1926 BFD_ASSERT (blk
[j
].lastlen
== blk
[j
- 1].lastlen
);
1927 memcpy (par
, en
, blk
[j
- 1].lastlen
);
1928 rfa
= (struct vms_rfa
*)par
;
1929 bfd_putl32 (blk
[j
- 1].vbn
, rfa
->vbn
);
1930 bfd_putl16 (RFADEF__C_INDEX
, rfa
->offset
);
1933 for (j
= 0; j
< level
; j
++)
1935 /* Write this block on the disk. */
1936 bfd_putl16 (blk
[j
].len
+ blk
[j
].lastlen
, rblk
[j
]->used
);
1937 if (!vms_write_block (abfd
, blk
[j
].vbn
, rblk
[j
]))
1943 /* Write the last kbn (if any). */
1946 if (!vms_write_block (abfd
, kbn_vbn
, kbn_blk
))
1954 /* Append data to the data block DATA. Force write if PAD is true. */
1957 vms_write_data_block (bfd
*arch
, struct vms_datadef
*data
, file_ptr
*off
,
1958 const unsigned char *buf
, unsigned int len
, int pad
)
1960 while (len
> 0 || pad
)
1962 unsigned int doff
= *off
& (VMS_BLOCK_SIZE
- 1);
1963 unsigned int remlen
= (DATA__LENGTH
- DATA__DATA
) - doff
;
1966 l
= (len
> remlen
) ? remlen
: len
;
1967 memcpy (data
->data
+ doff
, buf
, l
);
1973 if (doff
== (DATA__LENGTH
- DATA__DATA
) || (len
== 0 && pad
))
1977 bfd_putl32 ((*off
/ VMS_BLOCK_SIZE
) + 2, data
->link
);
1979 if (bfd_bwrite (data
, sizeof (*data
), arch
) != sizeof (*data
))
1982 *off
+= DATA__LENGTH
- doff
;
1991 /* Build the symbols index. */
1994 _bfd_vms_lib_build_map (unsigned int nbr_modules
,
1995 struct lib_index
*modules
,
1996 unsigned int *res_cnt
,
1997 struct lib_index
**res
)
2000 asymbol
**syms
= NULL
;
2002 struct lib_index
*map
= NULL
;
2003 unsigned int map_max
= 1024; /* Fine initial default. */
2004 unsigned int map_count
= 0;
2006 map
= (struct lib_index
*) bfd_malloc (map_max
* sizeof (struct lib_index
));
2010 /* Gather symbols. */
2011 for (i
= 0; i
< nbr_modules
; i
++)
2016 bfd
*current
= modules
[i
].abfd
;
2018 if ((bfd_get_file_flags (current
) & HAS_SYMS
) == 0)
2021 storage
= bfd_get_symtab_upper_bound (current
);
2027 if (storage
> syms_max
)
2032 syms
= (asymbol
**) bfd_malloc (syms_max
);
2036 symcount
= bfd_canonicalize_symtab (current
, syms
);
2040 /* Now map over all the symbols, picking out the ones we
2042 for (src_count
= 0; src_count
< symcount
; src_count
++)
2044 flagword flags
= (syms
[src_count
])->flags
;
2045 asection
*sec
= syms
[src_count
]->section
;
2047 if ((flags
& BSF_GLOBAL
2049 || flags
& BSF_INDIRECT
2050 || bfd_is_com_section (sec
))
2051 && ! bfd_is_und_section (sec
))
2053 struct lib_index
*new_map
;
2055 /* This symbol will go into the archive header. */
2056 if (map_count
== map_max
)
2059 new_map
= (struct lib_index
*)
2060 bfd_realloc (map
, map_max
* sizeof (struct lib_index
));
2061 if (new_map
== NULL
)
2066 map
[map_count
].abfd
= current
;
2067 map
[map_count
].namlen
= strlen (syms
[src_count
]->name
);
2068 map
[map_count
].name
= syms
[src_count
]->name
;
2076 *res_cnt
= map_count
;
2088 /* Do the hard work: write an archive on the disk. */
2091 _bfd_vms_lib_write_archive_contents (bfd
*arch
)
2094 unsigned int nbr_modules
;
2095 struct lib_index
*modules
;
2096 unsigned int nbr_symbols
;
2097 struct lib_index
*symbols
;
2098 struct lib_tdata
*tdata
= bfd_libdata (arch
);
2101 unsigned int nbr_mod_iblk
;
2102 unsigned int nbr_sym_iblk
;
2104 unsigned int mod_idx_vbn
;
2105 unsigned int sym_idx_vbn
;
2106 bfd_boolean is_elfidx
= tdata
->kind
== vms_lib_ia64
;
2107 unsigned int max_keylen
= is_elfidx
? MAX_EKEYLEN
: MAX_KEYLEN
;
2109 /* Count the number of modules (and do a first sanity check). */
2111 for (current
= arch
->archive_head
;
2113 current
= current
->archive_next
)
2115 /* This check is checking the bfds for the objects we're reading
2116 from (which are usually either an object file or archive on
2117 disk), not the archive entries we're writing to. We don't
2118 actually create bfds for the archive members, we just copy
2119 them byte-wise when we write out the archive. */
2120 if (bfd_write_p (current
) || !bfd_check_format (current
, bfd_object
))
2122 bfd_set_error (bfd_error_invalid_operation
);
2129 /* Build the modules list. */
2130 BFD_ASSERT (tdata
->modules
== NULL
);
2131 modules
= bfd_alloc (arch
, nbr_modules
* sizeof (struct lib_index
));
2132 if (modules
== NULL
)
2135 for (current
= arch
->archive_head
, i
= 0;
2137 current
= current
->archive_next
, i
++)
2141 modules
[i
].abfd
= current
;
2142 modules
[i
].name
= vms_get_module_name (current
->filename
, FALSE
);
2145 /* FIXME: silently truncate long names ? */
2146 nl
= strlen (modules
[i
].name
);
2147 modules
[i
].namlen
= (nl
> max_keylen
? max_keylen
: nl
);
2150 /* Create the module index. */
2152 if (!vms_write_index (NULL
, modules
, nbr_modules
, &vbn
, NULL
, is_elfidx
))
2156 /* Create symbol index. */
2157 if (!_bfd_vms_lib_build_map (nbr_modules
, modules
, &nbr_symbols
, &symbols
))
2161 if (!vms_write_index (NULL
, symbols
, nbr_symbols
, &vbn
, NULL
, is_elfidx
))
2165 /* Write modules and remember their position. */
2166 off
= (1 + nbr_mod_iblk
+ nbr_sym_iblk
) * VMS_BLOCK_SIZE
;
2168 if (bfd_seek (arch
, off
, SEEK_SET
) != 0)
2171 for (i
= 0; i
< nbr_modules
; i
++)
2173 struct vms_datadef data
;
2174 unsigned char blk
[VMS_BLOCK_SIZE
];
2175 struct vms_mhd
*mhd
;
2178 current
= modules
[i
].abfd
;
2179 current
->proxy_origin
= off
;
2185 /* Write the MHD as a record (ie, size first). */
2187 bfd_putl16 (tdata
->mhd_size
, blk
);
2189 mhd
= (struct vms_mhd
*)(blk
+ sz
);
2190 memset (mhd
, 0, sizeof (struct vms_mhd
));
2192 mhd
->id
= MHD__C_MHDID
;
2194 memcpy (mhd
->objid
, "V1.0", 4);
2195 bfd_putl32 (modules
[i
].ref
, mhd
->refcnt
);
2198 sz
+= tdata
->mhd_size
;
2201 /* Rewind the member to be put into the archive. */
2202 if (bfd_seek (current
, 0, SEEK_SET
) != 0)
2205 /* Copy the member into the archive. */
2208 unsigned int modsize
= 0;
2210 file_ptr off_hdr
= off
;
2212 /* Read to complete the first block. */
2213 amt
= bfd_bread (blk
+ sz
, VMS_BLOCK_SIZE
- sz
, current
);
2214 if (amt
== (bfd_size_type
)-1)
2217 if (amt
< VMS_BLOCK_SIZE
- sz
)
2219 /* The member size is less than a block. Pad the block. */
2220 memset (blk
+ sz
+ amt
, 0, VMS_BLOCK_SIZE
- sz
- amt
);
2222 bfd_putl32 (modsize
, mhd
->modsize
);
2224 /* Write the first block (which contains an mhd). */
2225 if (bfd_bwrite (blk
, VMS_BLOCK_SIZE
, arch
) != VMS_BLOCK_SIZE
)
2227 off
+= VMS_BLOCK_SIZE
;
2229 if (amt
== VMS_BLOCK_SIZE
- sz
)
2231 /* Copy the remaining. */
2232 char buffer
[DEFAULT_BUFFERSIZE
];
2236 amt
= bfd_bread (buffer
, sizeof (buffer
), current
);
2237 if (amt
== (bfd_size_type
)-1)
2242 if (amt
!= sizeof (buffer
))
2244 /* Clear the padding. */
2245 memset (buffer
+ amt
, 0, sizeof (buffer
) - amt
);
2246 amt
= (amt
+ VMS_BLOCK_SIZE
) & ~(VMS_BLOCK_SIZE
- 1);
2248 if (bfd_bwrite (buffer
, amt
, arch
) != amt
)
2253 /* Now that the size is known, write the first block (again). */
2254 bfd_putl32 (modsize
, mhd
->modsize
);
2255 if (bfd_seek (arch
, off_hdr
, SEEK_SET
) != 0
2256 || bfd_bwrite (blk
, VMS_BLOCK_SIZE
, arch
) != VMS_BLOCK_SIZE
)
2258 if (bfd_seek (arch
, off
, SEEK_SET
) != 0)
2264 /* Write the MHD. */
2265 if (vms_write_data_block (arch
, &data
, &off
, blk
, sz
, 0) < 0)
2268 /* Write the member. */
2271 sz
= bfd_bread (blk
, sizeof (blk
), current
);
2274 if (vms_write_data_block (arch
, &data
, &off
, blk
, sz
, 0) < 0)
2278 /* Write the end of module marker. */
2279 if (vms_write_data_block (arch
, &data
, &off
,
2280 eotdesc
, sizeof (eotdesc
), 1) < 0)
2285 /* Write the indexes. */
2287 if (!vms_write_index (arch
, modules
, nbr_modules
, &vbn
, &mod_idx_vbn
,
2290 if (!vms_write_index (arch
, symbols
, nbr_symbols
, &vbn
, &sym_idx_vbn
,
2294 /* Write libary header. */
2296 unsigned char blk
[VMS_BLOCK_SIZE
];
2297 struct vms_lhd
*lhd
= (struct vms_lhd
*)blk
;
2298 struct vms_idd
*idd
= (struct vms_idd
*)(blk
+ sizeof (*lhd
));
2299 unsigned int idd_flags
;
2300 unsigned int saneid
;
2302 memset (blk
, 0, sizeof (blk
));
2304 lhd
->type
= tdata
->type
;
2306 switch (tdata
->kind
)
2309 saneid
= LHD_SANEID3
;
2312 saneid
= LHD_SANEID6
;
2317 bfd_putl32 (saneid
, lhd
->sanity
);
2318 bfd_putl16 (tdata
->ver
, lhd
->majorid
);
2319 bfd_putl16 (0, lhd
->minorid
);
2320 snprintf ((char *)lhd
->lbrver
+ 1, sizeof (lhd
->lbrver
) - 1,
2322 (unsigned)(BFD_VERSION
/ 100000000UL),
2323 (unsigned)(BFD_VERSION
/ 1000000UL) % 100,
2324 (unsigned)(BFD_VERSION
/ 10000UL) % 100);
2325 lhd
->lbrver
[sizeof (lhd
->lbrver
) - 1] = 0;
2326 lhd
->lbrver
[0] = strlen ((char *)lhd
->lbrver
+ 1);
2328 bfd_putl32 (tdata
->credat_lo
, lhd
->credat
+ 0);
2329 bfd_putl32 (tdata
->credat_hi
, lhd
->credat
+ 4);
2330 vms_raw_get_time (lhd
->updtim
);
2332 lhd
->mhdusz
= tdata
->mhd_size
- MHD__C_USRDAT
;
2334 bfd_putl32 (nbr_modules
+ nbr_symbols
, lhd
->idxcnt
);
2335 bfd_putl32 (nbr_modules
, lhd
->modcnt
);
2336 bfd_putl32 (nbr_modules
, lhd
->modhdrs
);
2338 /* Number of blocks for index. */
2339 bfd_putl32 (nbr_mod_iblk
+ nbr_sym_iblk
, lhd
->idxblks
);
2340 bfd_putl32 (vbn
- 1, lhd
->hipreal
);
2341 bfd_putl32 (vbn
- 1, lhd
->hiprusd
);
2343 /* VBN of the next free block. */
2344 bfd_putl32 ((off
/ VMS_BLOCK_SIZE
) + 1, lhd
->nextvbn
);
2345 bfd_putl32 ((off
/ VMS_BLOCK_SIZE
) + 1, lhd
->nextrfa
+ 0);
2346 bfd_putl16 (0, lhd
->nextrfa
+ 4);
2348 /* First index (modules name). */
2349 idd_flags
= IDD__FLAGS_ASCII
| IDD__FLAGS_VARLENIDX
2350 | IDD__FLAGS_NOCASECMP
| IDD__FLAGS_NOCASENTR
;
2351 bfd_putl16 (idd_flags
, idd
->flags
);
2352 bfd_putl16 (max_keylen
+ 1, idd
->keylen
);
2353 bfd_putl16 (mod_idx_vbn
, idd
->vbn
);
2356 /* Second index (symbols name). */
2357 bfd_putl16 (idd_flags
, idd
->flags
);
2358 bfd_putl16 (max_keylen
+ 1, idd
->keylen
);
2359 bfd_putl16 (sym_idx_vbn
, idd
->vbn
);
2362 if (!vms_write_block (arch
, 1, blk
))
2369 bfd_set_input_error (current
, bfd_get_error ());
2373 /* Add a target for text library. This costs almost nothing and is useful to
2374 read VMS library on the host. */
2376 const bfd_target alpha_vms_lib_txt_vec
=
2378 "vms-libtxt", /* Name. */
2379 bfd_target_unknown_flavour
,
2380 BFD_ENDIAN_UNKNOWN
, /* byteorder */
2381 BFD_ENDIAN_UNKNOWN
, /* header_byteorder */
2382 0, /* Object flags. */
2383 0, /* Sect flags. */
2384 0, /* symbol_leading_char. */
2385 ' ', /* ar_pad_char. */
2386 15, /* ar_max_namelen. */
2387 0, /* match priority. */
2388 bfd_getl64
, bfd_getl_signed_64
, bfd_putl64
,
2389 bfd_getl32
, bfd_getl_signed_32
, bfd_putl32
,
2390 bfd_getl16
, bfd_getl_signed_16
, bfd_putl16
,
2391 bfd_getl64
, bfd_getl_signed_64
, bfd_putl64
,
2392 bfd_getl32
, bfd_getl_signed_32
, bfd_putl32
,
2393 bfd_getl16
, bfd_getl_signed_16
, bfd_putl16
,
2394 { /* bfd_check_format. */
2397 _bfd_vms_lib_txt_archive_p
,
2400 { /* bfd_set_format. */
2401 _bfd_bool_bfd_false_error
,
2402 _bfd_bool_bfd_false_error
,
2403 _bfd_bool_bfd_false_error
,
2404 _bfd_bool_bfd_false_error
2406 { /* bfd_write_contents. */
2407 _bfd_bool_bfd_false_error
,
2408 _bfd_bool_bfd_false_error
,
2409 _bfd_bool_bfd_false_error
,
2410 _bfd_bool_bfd_false_error
2412 BFD_JUMP_TABLE_GENERIC (_bfd_generic
),
2413 BFD_JUMP_TABLE_COPY (_bfd_generic
),
2414 BFD_JUMP_TABLE_CORE (_bfd_nocore
),
2415 BFD_JUMP_TABLE_ARCHIVE (_bfd_vms_lib
),
2416 BFD_JUMP_TABLE_SYMBOLS (_bfd_nosymbols
),
2417 BFD_JUMP_TABLE_RELOCS (_bfd_norelocs
),
2418 BFD_JUMP_TABLE_WRITE (_bfd_nowrite
),
2419 BFD_JUMP_TABLE_LINK (_bfd_nolink
),
2420 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic
),