1 /* BFD back-end for VMS archive files.
3 Copyright 2010 Free Software Foundation, Inc.
4 Written by Tristan Gingold <gingold@adacore.com>, AdaCore.
6 This file is part of BFD, the Binary File Descriptor library.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21 MA 02110-1301, USA. */
26 #include "safe-ctype.h"
32 /* The standard VMS disk block size. */
33 #ifndef VMS_BLOCK_SIZE
34 #define VMS_BLOCK_SIZE 512
37 /* Maximum key length (which is also the maximum symbol length in archive). */
38 #define MAX_KEYLEN 129
44 unsigned char min_char
;
45 unsigned char max_char
;
51 /* Kind of library. Used to filter in archive_p. */
61 /* Back-end private data. */
65 /* Standard tdata for an archive. But we don't use many fields. */
66 struct artdata artdata
;
71 /* Type of the archive. */
74 /* Kind of archive. Summary of its type. */
75 enum vms_lib_kind kind
;
77 /* Total size of the mhd (element header). */
78 unsigned int mhd_size
;
80 /* Vector of modules (archive elements), already sorted. */
81 unsigned int nbr_modules
;
82 struct carsym
*modules
;
85 /* DCX (decompression) data. */
86 unsigned int nbr_dcxsbm
;
87 struct dcxsbm_desc
*dcxsbm
;
90 #define bfd_libdata(bfd) ((struct lib_tdata *)((bfd)->tdata.any))
92 /* End-Of-Text pattern. This is a special record to mark the end of file. */
94 static const unsigned char eotdesc
[] = { 0x03, 0x00, 0x77, 0x00, 0x77, 0x00 };
96 /* Describe the current state of carsym entries while building the archive
97 table of content. Things are simple with Alpha archives as the number
98 of entries is known, but with IA64 archives a entry can make a reference
99 to severals members. Therefore we must be able to extend the table on the
100 fly, but it should be allocated on the bfd - which doesn't support realloc.
101 To reduce the overhead, the table is initially allocated in the BFD's
102 objalloc and extended if necessary on the heap. In the later case, it
103 is finally copied to the BFD's objalloc so that it will automatically be
108 /* The table of content. */
111 /* Number of entries used in the table. */
114 /* Maximum number of entries. */
117 /* If true, the table was reallocated on the heap. If false, it is still
118 in the BFD's objalloc. */
119 bfd_boolean realloced
;
122 /* Simply add a name to the index. */
125 vms_add_index (struct carsym_mem
*cs
, char *name
,
126 unsigned int idx_vbn
, unsigned int idx_off
)
128 if (cs
->nbr
== cs
->max
)
132 cs
->max
= 2 * cs
->max
+ 32;
136 n
= bfd_malloc2 (cs
->max
, sizeof (struct carsym
));
139 memcpy (n
, cs
->idx
, cs
->nbr
* sizeof (struct carsym
));
140 /* And unfortunately we can't free cs->idx. */
144 n
= bfd_realloc_or_free (cs
->idx
, cs
->nbr
* sizeof (struct carsym
));
149 cs
->realloced
= TRUE
;
151 cs
->idx
[cs
->nbr
].file_offset
= (idx_vbn
- 1) * VMS_BLOCK_SIZE
+ idx_off
;
152 cs
->idx
[cs
->nbr
].name
= name
;
157 /* Follow all member of a lns list (pointed by RFA) and add indexes for
158 NAME. Return FALSE in case of error. */
161 vms_add_indexes_from_list (bfd
*abfd
, struct carsym_mem
*cs
, char *name
,
170 vbn
= bfd_getl32 (rfa
->vbn
);
175 off
= (vbn
- 1) * VMS_BLOCK_SIZE
+ bfd_getl16 (rfa
->offset
);
176 if (bfd_seek (abfd
, off
, SEEK_SET
) != 0
177 || bfd_bread (&lns
, sizeof (lns
), abfd
) != sizeof (lns
))
180 if (!vms_add_index (cs
, name
,
181 bfd_getl32 (lns
.modrfa
.vbn
),
182 bfd_getl16 (lns
.modrfa
.offset
)))
189 /* Read block VBN from ABFD and store it into BLK. */
192 vms_read_block (bfd
*abfd
, unsigned int vbn
, void *blk
)
196 /* Read the index block. */
197 off
= (vbn
- 1) * VMS_BLOCK_SIZE
;
198 if (bfd_seek (abfd
, off
, SEEK_SET
) != 0
199 || bfd_bread (blk
, VMS_BLOCK_SIZE
, abfd
) != VMS_BLOCK_SIZE
)
205 /* Read index block VBN and put the entry in **IDX (which is updated).
206 If the entry is indirect, recurse. */
209 vms_traverse_index (bfd
*abfd
, unsigned int vbn
, struct carsym_mem
*cs
)
211 struct vms_indexdef indexdef
;
216 /* Read the index block. */
217 BFD_ASSERT (sizeof (indexdef
) == VMS_BLOCK_SIZE
);
218 if (!vms_read_block (abfd
, vbn
, &indexdef
))
222 p
= &indexdef
.keys
[0];
223 endp
= p
+ bfd_getl16 (indexdef
.used
);
226 unsigned int idx_vbn
;
227 unsigned int idx_off
;
229 unsigned char *keyname
;
232 /* Extract key length. */
233 if (bfd_libdata (abfd
)->ver
== LBR_MAJORID
)
235 struct vms_idx
*ridx
= (struct vms_idx
*)p
;
237 idx_vbn
= bfd_getl32 (ridx
->rfa
.vbn
);
238 idx_off
= bfd_getl16 (ridx
->rfa
.offset
);
240 keylen
= ridx
->keylen
;
242 keyname
= ridx
->keyname
;
244 else if (bfd_libdata (abfd
)->ver
== LBR_ELFMAJORID
)
246 struct vms_elfidx
*ridx
= (struct vms_elfidx
*)p
;
248 idx_vbn
= bfd_getl32 (ridx
->rfa
.vbn
);
249 idx_off
= bfd_getl16 (ridx
->rfa
.offset
);
251 keylen
= bfd_getl16 (ridx
->keylen
);
253 keyname
= ridx
->keyname
;
262 if (idx_off
== RFADEF__C_INDEX
)
264 /* Indirect entry. Recurse. */
265 if (!vms_traverse_index (abfd
, idx_vbn
, cs
))
270 /* Add a new entry. */
273 if (flags
& ELFIDX__SYMESC
)
275 /* Extended key name. */
276 unsigned int noff
= 0;
280 unsigned char kblk
[VMS_BLOCK_SIZE
];
283 if (keylen
!= sizeof (struct vms_kbn
))
286 kbn
= (struct vms_kbn
*)keyname
;
287 keylen
= bfd_getl16 (kbn
->keylen
);
289 name
= bfd_alloc (abfd
, keylen
+ 1);
292 kvbn
= bfd_getl32 (kbn
->rfa
.vbn
);
293 koff
= bfd_getl16 (kbn
->rfa
.offset
);
295 /* Read the key, chunk by chunk. */
300 if (!vms_read_block (abfd
, kvbn
, kblk
))
302 kbn
= (struct vms_kbn
*)(kblk
+ koff
);
303 klen
= bfd_getl16 (kbn
->keylen
);
304 kvbn
= bfd_getl32 (kbn
->rfa
.vbn
);
305 koff
= bfd_getl16 (kbn
->rfa
.offset
);
307 memcpy (name
+ noff
, kbn
+ 1, klen
);
318 /* Usual key name. */
319 name
= bfd_alloc (abfd
, keylen
+ 1);
323 memcpy (name
, keyname
, keylen
);
327 if (flags
& ELFIDX__LISTRFA
)
332 off
= (idx_vbn
- 1) * VMS_BLOCK_SIZE
+ idx_off
;
333 if (bfd_seek (abfd
, off
, SEEK_SET
) != 0
334 || bfd_bread (&lhs
, sizeof (lhs
), abfd
) != sizeof (lhs
))
337 /* FIXME: this adds extra entries that were not accounted. */
338 if (!vms_add_indexes_from_list (abfd
, cs
, name
, &lhs
.ng_g_rfa
))
340 if (!vms_add_indexes_from_list (abfd
, cs
, name
, &lhs
.ng_wk_rfa
))
342 if (!vms_add_indexes_from_list (abfd
, cs
, name
, &lhs
.g_g_rfa
))
344 if (!vms_add_indexes_from_list (abfd
, cs
, name
, &lhs
.g_wk_rfa
))
349 if (!vms_add_index (cs
, name
, idx_vbn
, idx_off
))
354 /* Point to the next index entry. */
355 p
= keyname
+ keylen
;
361 /* Read index #IDX, which must have NBREL entries. */
363 static struct carsym
*
364 vms_lib_read_index (bfd
*abfd
, int idx
, unsigned int *nbrel
)
369 struct carsym
*csbuf
;
370 struct carsym_mem csm
;
372 /* Read index desription. */
373 if (bfd_seek (abfd
, LHD_IDXDESC
+ idx
* IDD_LENGTH
, SEEK_SET
) != 0
374 || bfd_bread (&idd
, sizeof (idd
), abfd
) != sizeof (idd
))
378 flags
= bfd_getl16 (idd
.flags
);
379 if (!(flags
& IDD__FLAGS_ASCII
)
380 || !(flags
& IDD__FLAGS_VARLENIDX
))
383 csbuf
= bfd_alloc (abfd
, *nbrel
* sizeof (struct carsym
));
389 csm
.realloced
= FALSE
;
392 /* Note: if the index is empty, there is no block to traverse. */
393 vbn
= bfd_getl32 (idd
.vbn
);
394 if (vbn
!= 0 && !vms_traverse_index (abfd
, vbn
, &csm
))
396 if (csm
.realloced
&& csm
.idx
!= NULL
)
399 /* Note: in case of error, we can free what was allocated on the
401 bfd_release (abfd
, csbuf
);
407 /* There are more entries than the first estimate. Allocate on
408 the BFD's objalloc. */
409 csbuf
= bfd_alloc (abfd
, csm
.nbr
* sizeof (struct carsym
));
412 memcpy (csbuf
, csm
.idx
, csm
.nbr
* sizeof (struct carsym
));
419 /* Standard function. */
421 static const bfd_target
*
422 _bfd_vms_lib_archive_p (bfd
*abfd
, enum vms_lib_kind kind
)
426 struct lib_tdata
*tdata_hold
;
427 struct lib_tdata
*tdata
;
429 unsigned int nbr_ent
;
432 if (bfd_bread (&lhd
, sizeof (lhd
), abfd
) != sizeof (lhd
))
434 if (bfd_get_error () != bfd_error_system_call
)
435 bfd_set_error (bfd_error_wrong_format
);
439 /* Check sanity (= magic) number. */
440 sanity
= bfd_getl32 (lhd
.sanity
);
441 if (!(sanity
== LHD_SANEID3
442 || sanity
== LHD_SANEID6
443 || sanity
== LHD_SANEID_DCX
))
445 bfd_set_error (bfd_error_wrong_format
);
449 /* Check archive kind. */
453 if ((lhd
.type
!= LBR__C_TYP_EOBJ
&& lhd
.type
!= LBR__C_TYP_ESHSTB
)
454 || bfd_getl32 (lhd
.majorid
) != 3
457 bfd_set_error (bfd_error_wrong_format
);
462 if ((lhd
.type
!= LBR__C_TYP_IOBJ
&& lhd
.type
!= LBR__C_TYP_ISHSTB
)
463 || bfd_getl32 (lhd
.majorid
) != 6
466 bfd_set_error (bfd_error_wrong_format
);
471 if ((lhd
.type
!= LBR__C_TYP_TXT
472 && lhd
.type
!= LBR__C_TYP_MLB
473 && lhd
.type
!= LBR__C_TYP_HLP
)
474 || bfd_getl32 (lhd
.majorid
) != 3
477 bfd_set_error (bfd_error_wrong_format
);
485 /* Allocate and initialize private data. */
486 tdata_hold
= bfd_libdata (abfd
);
487 tdata
= (struct lib_tdata
*) bfd_zalloc (abfd
, sizeof (struct lib_tdata
));
490 abfd
->tdata
.any
= (void *)tdata
;
491 tdata
->ver
= bfd_getl32 (lhd
.majorid
);
492 tdata
->mhd_size
= MHD__C_USRDAT
+ lhd
.mhdusz
;
493 tdata
->type
= lhd
.type
;
497 tdata
->nbr_modules
= bfd_getl32 (lhd
.modcnt
);
498 tdata
->artdata
.symdef_count
= bfd_getl32 (lhd
.idxcnt
) - tdata
->nbr_modules
;
499 nbr_ent
= tdata
->nbr_modules
;
500 tdata
->modules
= vms_lib_read_index (abfd
, 0, &nbr_ent
);
501 if (tdata
->modules
== NULL
|| nbr_ent
!= tdata
->nbr_modules
)
505 nbr_ent
= tdata
->artdata
.symdef_count
;
506 tdata
->artdata
.symdefs
= vms_lib_read_index (abfd
, 1, &nbr_ent
);
507 if (tdata
->artdata
.symdefs
== NULL
)
509 /* Only IA64 archives may have more entries in the index that what
511 if (nbr_ent
!= tdata
->artdata
.symdef_count
512 && kind
!= vms_lib_ia64
)
514 tdata
->artdata
.symdef_count
= nbr_ent
;
516 tdata
->cache
= bfd_zalloc (abfd
, sizeof (bfd
*) * tdata
->nbr_modules
);
517 if (tdata
->cache
== NULL
)
520 /* Read DCX submaps. */
521 dcxvbn
= bfd_getl32 (lhd
.dcxmapvbn
);
524 unsigned char buf_reclen
[4];
527 struct vms_dcxmap
*map
;
528 unsigned int sbm_off
;
531 if (bfd_seek (abfd
, (dcxvbn
- 1) * VMS_BLOCK_SIZE
, SEEK_SET
) != 0
532 || bfd_bread (buf_reclen
, sizeof (buf_reclen
), abfd
)
533 != sizeof (buf_reclen
))
535 reclen
= bfd_getl32 (buf_reclen
);
536 buf
= bfd_malloc (reclen
);
539 if (bfd_bread (buf
, reclen
, abfd
) != reclen
)
544 map
= (struct vms_dcxmap
*)buf
;
545 tdata
->nbr_dcxsbm
= bfd_getl16 (map
->nsubs
);
546 sbm_off
= bfd_getl16 (map
->sub0
);
547 tdata
->dcxsbm
= (struct dcxsbm_desc
*)bfd_alloc
548 (abfd
, tdata
->nbr_dcxsbm
* sizeof (struct dcxsbm_desc
));
549 for (i
= 0; i
< tdata
->nbr_dcxsbm
; i
++)
551 struct vms_dcxsbm
*sbm
= (struct vms_dcxsbm
*) (buf
+ sbm_off
);
552 struct dcxsbm_desc
*sbmdesc
= &tdata
->dcxsbm
[i
];
553 unsigned int sbm_len
;
555 unsigned char *data
= (unsigned char *)sbm
;
559 sbm_sz
= bfd_getl16 (sbm
->size
);
561 BFD_ASSERT (sbm_off
<= reclen
);
563 sbmdesc
->min_char
= sbm
->min_char
;
564 BFD_ASSERT (sbmdesc
->min_char
== 0);
565 sbmdesc
->max_char
= sbm
->max_char
;
566 sbm_len
= sbmdesc
->max_char
- sbmdesc
->min_char
+ 1;
567 l
= (2 * sbm_len
+ 7) / 8;
568 BFD_ASSERT (sbm_sz
>= sizeof (struct vms_dcxsbm
) + l
+ 3 * sbm_len
);
569 sbmdesc
->flags
= (unsigned char *)bfd_alloc (abfd
, l
);
570 memcpy (sbmdesc
->flags
, data
+ bfd_getl16 (sbm
->flags
), l
);
571 sbmdesc
->nodes
= (unsigned char *)bfd_alloc (abfd
, 2 * sbm_len
);
572 memcpy (sbmdesc
->nodes
, data
+ bfd_getl16 (sbm
->nodes
), 2 * sbm_len
);
573 sbmdesc
->next
= (unsigned short *)bfd_alloc
574 (abfd
, sbm_len
* sizeof (unsigned short));
575 buf1
= data
+ bfd_getl16 (sbm
->next
);
576 for (j
= 0; j
< sbm_len
; j
++)
577 sbmdesc
->next
[j
] = bfd_getl16 (buf1
+ j
* 2);
583 tdata
->nbr_dcxsbm
= 0;
586 /* The map is always present. Also mark shared image library. */
587 abfd
->has_armap
= TRUE
;
588 if (tdata
->type
== LBR__C_TYP_ESHSTB
|| tdata
->type
== LBR__C_TYP_ISHSTB
)
589 abfd
->is_thin_archive
= TRUE
;
594 bfd_release (abfd
, tdata
);
595 abfd
->tdata
.any
= (void *)tdata_hold
;;
599 /* Standard function for alpha libraries. */
602 _bfd_vms_lib_alpha_archive_p (bfd
*abfd
)
604 return _bfd_vms_lib_archive_p (abfd
, vms_lib_alpha
);
607 /* Standard function for text libraries. */
609 static const bfd_target
*
610 _bfd_vms_lib_txt_archive_p (bfd
*abfd
)
612 return _bfd_vms_lib_archive_p (abfd
, vms_lib_txt
);
615 /* Standard bfd function. */
618 _bfd_vms_lib_mkarchive (bfd
*abfd
)
620 struct lib_tdata
*tdata
;
622 tdata
= (struct lib_tdata
*) bfd_zalloc (abfd
, sizeof (struct lib_tdata
));
626 abfd
->tdata
.any
= (void *)tdata
;
628 tdata
->mhd_size
= sizeof (struct vms_mhd
);
629 tdata
->type
= LBR__C_TYP_EOBJ
;
631 tdata
->nbr_modules
= 0;
632 tdata
->artdata
.symdef_count
= 0;
633 tdata
->modules
= NULL
;
634 tdata
->artdata
.symdefs
= NULL
;
640 /* Find NAME in the symbol index. Return the index. */
643 _bfd_vms_lib_find_symbol (bfd
*abfd
, const char *name
)
645 struct lib_tdata
*tdata
= bfd_libdata (abfd
);
646 carsym
*syms
= tdata
->artdata
.symdefs
;
649 /* Open-coded binary search for speed. */
651 hi
= tdata
->artdata
.symdef_count
- 1;
655 int mid
= lo
+ (hi
- lo
) / 2;
658 diff
= (char)(name
[0] - syms
[mid
].name
[0]);
660 diff
= strcmp (name
, syms
[mid
].name
);
668 return BFD_NO_MORE_SYMBOLS
;
671 /* IO vector for archive member. Need that because members are not linearly
672 stored in archives. */
676 /* Current offset. */
679 /* Length of the module, when known. */
682 /* Current position in the record from bfd_bread point of view (ie, after
683 decompression). 0 means that no data byte have been read, -2 and -1
684 are reserved for the length word. */
686 #define REC_POS_NL -4
687 #define REC_POS_PAD -3
688 #define REC_POS_LEN0 -2
689 #define REC_POS_LEN1 -1
692 unsigned short rec_len
;
693 /* Number of bytes to read in the current record. */
694 unsigned short rec_rem
;
695 /* Offset of the next block. */
697 /* Current *data* offset in the data block. */
698 unsigned short blk_off
;
700 /* Offset of the first block. Extracted from the index. */
701 file_ptr first_block
;
703 /* Initial next_block. Extracted when the MHD is read. */
704 file_ptr init_next_block
;
705 /* Initial blk_off, once the MHD is read. */
706 unsigned short init_blk_off
;
708 /* Used to store any 3 byte record, which could be the EOF pattern. */
709 unsigned char pattern
[4];
712 struct dcxsbm_desc
*dcxsbms
;
713 /* Current submap. */
714 struct dcxsbm_desc
*dcx_sbm
;
715 /* Current offset in the submap. */
716 unsigned int dcx_offset
;
719 /* Compressed buffer. */
720 unsigned char *dcx_buf
;
721 /* Size of the buffer. Used to resize. */
722 unsigned int dcx_max
;
723 /* Number of valid bytes in the buffer. */
724 unsigned int dcx_rlen
;
727 /* Return the current position. */
730 vms_lib_btell (struct bfd
*abfd
)
732 struct vms_lib_iovec
*vec
= (struct vms_lib_iovec
*) abfd
->iostream
;
736 /* Read the header of the next data block if all bytes of the current block
740 vms_lib_read_block (struct bfd
*abfd
)
742 struct vms_lib_iovec
*vec
= (struct vms_lib_iovec
*) abfd
->iostream
;
744 if (vec
->blk_off
== DATA__LENGTH
)
746 unsigned char hdr
[DATA__DATA
];
748 /* Read next block. */
749 if (bfd_seek (abfd
->my_archive
, vec
->next_block
, SEEK_SET
) != 0)
751 if (bfd_bread (hdr
, sizeof (hdr
), abfd
->my_archive
) != sizeof (hdr
))
753 vec
->next_block
= (bfd_getl32 (hdr
+ 2) - 1) * VMS_BLOCK_SIZE
;
754 vec
->blk_off
= sizeof (hdr
);
759 /* Read NBYTES from ABFD into BUF if not NULL. If BUF is NULL, bytes are
760 not stored. Read linearly from the library, but handle blocks. This
761 function does not handle records nor EOF. */
764 vms_lib_bread_raw (struct bfd
*abfd
, void *buf
, file_ptr nbytes
)
766 struct vms_lib_iovec
*vec
= (struct vms_lib_iovec
*) abfd
->iostream
;
774 /* Be sure the current data block is read. */
775 if (!vms_lib_read_block (abfd
))
778 /* Do not read past the data block, do not read more than requested. */
779 l
= DATA__LENGTH
- vec
->blk_off
;
786 /* Really read into BUF. */
787 if (bfd_bread (buf
, l
, abfd
->my_archive
) != l
)
792 /* Make as if we are reading. */
793 if (bfd_seek (abfd
->my_archive
, l
, SEEK_CUR
) != 0)
806 /* Decompress NBYTES from VEC. Store the bytes into BUF if not NULL. */
809 vms_lib_dcx (struct vms_lib_iovec
*vec
, unsigned char *buf
, file_ptr nbytes
)
811 struct dcxsbm_desc
*sbm
;
817 /* The loop below expect to deliver at least one byte. */
821 /* Get the current state. */
823 offset
= vec
->dcx_offset
;
824 j
= vec
->dcx_pos
& 7;
826 for (i
= vec
->dcx_pos
>> 3; i
< vec
->dcx_rlen
; i
++)
828 unsigned char b
= vec
->dcx_buf
[i
];
834 if (!(sbm
->flags
[offset
>> 3] & (1 << (offset
& 7))))
836 unsigned int n_offset
= sbm
->nodes
[offset
];
839 /* End of buffer. Stay where we are. */
840 vec
->dcx_pos
= (i
<< 3) + j
;
843 vec
->dcx_offset
= offset
;
847 offset
= 2 * n_offset
;
851 unsigned char v
= sbm
->nodes
[offset
];
853 sbm
= vec
->dcxsbms
+ sbm
->next
[v
];
864 vec
->dcx_pos
= (i
<< 3) + j
+ 1;
865 vec
->dcx_offset
= offset
;
878 /* Standard IOVEC function. */
881 vms_lib_bread (struct bfd
*abfd
, void *buf
, file_ptr nbytes
)
883 struct vms_lib_iovec
*vec
= (struct vms_lib_iovec
*) abfd
->iostream
;
887 /* Do not read past the end. */
888 if (vec
->where
>= vec
->file_len
)
894 if (vec
->rec_rem
== 0)
896 unsigned char blen
[2];
898 /* Read record length. */
899 if (vms_lib_bread_raw (abfd
, &blen
, sizeof (blen
)) != sizeof (blen
))
901 vec
->rec_len
= bfd_getl16 (blen
);
902 if (bfd_libdata (abfd
->my_archive
)->kind
== vms_lib_txt
)
904 /* Discard record size and align byte. */
906 vec
->rec_rem
= vec
->rec_len
;
910 /* Prepend record size. */
911 vec
->rec_pos
= REC_POS_LEN0
;
912 vec
->rec_rem
= (vec
->rec_len
+ 1) & ~1; /* With align byte. */
914 if (vec
->rec_len
== 3)
916 /* Possibly end of file. Check the pattern. */
917 if (vms_lib_bread_raw (abfd
, vec
->pattern
, 4) != 4)
919 if (!memcmp (vec
->pattern
, eotdesc
+ 2, 3))
921 /* This is really an EOF. */
923 vec
->file_len
= vec
->where
;
928 if (vec
->dcxsbms
!= NULL
)
930 /* This is a compressed member. */
934 /* Be sure there is enough room for the expansion. */
935 len
= (vec
->rec_len
+ 1) & ~1;
936 if (len
> vec
->dcx_max
)
938 while (len
> vec
->dcx_max
)
940 vec
->dcx_buf
= bfd_alloc (abfd
, vec
->dcx_max
);
941 if (vec
->dcx_buf
== NULL
)
945 /* Read the compressed record. */
947 if (vec
->rec_len
== 3)
950 memcpy (vec
->dcx_buf
, vec
->pattern
, 3);
954 elen
= vms_lib_bread_raw (abfd
, vec
->dcx_buf
, len
);
959 /* Dummy expansion to get the expanded length. */
961 vec
->dcx_sbm
= vec
->dcxsbms
;
963 elen
= vms_lib_dcx (vec
, NULL
, 0x10000);
969 /* Reset the state. */
971 vec
->dcx_sbm
= vec
->dcxsbms
;
975 if (vec
->rec_pos
< 0)
978 switch (vec
->rec_pos
)
981 c
= vec
->rec_len
& 0xff;
982 vec
->rec_pos
= REC_POS_LEN1
;
985 c
= (vec
->rec_len
>> 8) & 0xff;
1001 *(unsigned char *)buf
= c
;
1009 if (nbytes
> vec
->rec_rem
)
1010 chunk
= vec
->rec_rem
;
1014 if (vec
->dcxsbms
!= NULL
)
1016 /* Optimize the stat() case: no need to decompress again as we
1018 if (!(buf
== NULL
&& chunk
== vec
->rec_rem
))
1019 chunk
= vms_lib_dcx (vec
, buf
, chunk
);
1023 if (vec
->rec_len
== 3)
1026 memcpy (buf
, vec
->pattern
+ vec
->rec_pos
, chunk
);
1029 chunk
= vms_lib_bread_raw (abfd
, buf
, chunk
);
1037 vec
->rec_pos
+= chunk
;
1038 vec
->rec_rem
-= chunk
;
1040 if (vec
->rec_rem
== 0)
1042 /* End of record reached. */
1043 if (bfd_libdata (abfd
->my_archive
)->kind
== vms_lib_txt
)
1045 if ((vec
->rec_len
& 1) == 1
1046 && vec
->rec_len
!= 3
1047 && vec
->dcxsbms
== NULL
)
1049 /* Eat the pad byte. */
1051 if (vms_lib_bread_raw (abfd
, &pad
, 1) != 1)
1054 vec
->rec_pos
= REC_POS_NL
;
1059 if ((vec
->rec_len
& 1) == 1 && vec
->dcxsbms
!= NULL
)
1061 vec
->rec_pos
= REC_POS_PAD
;
1071 /* Standard function, but we currently only handle the rewind case. */
1074 vms_lib_bseek (struct bfd
*abfd
, file_ptr offset
, int whence
)
1076 struct vms_lib_iovec
*vec
= (struct vms_lib_iovec
*) abfd
->iostream
;
1078 if (whence
== SEEK_SET
&& offset
== 0)
1083 vec
->blk_off
= vec
->init_blk_off
;
1084 vec
->next_block
= vec
->init_next_block
;
1086 if (bfd_seek (abfd
->my_archive
, vec
->first_block
, SEEK_SET
) != 0)
1095 vms_lib_bwrite (struct bfd
*abfd ATTRIBUTE_UNUSED
,
1096 const void *where ATTRIBUTE_UNUSED
,
1097 file_ptr nbytes ATTRIBUTE_UNUSED
)
1103 vms_lib_bclose (struct bfd
*abfd
)
1105 abfd
->iostream
= NULL
;
1110 vms_lib_bflush (struct bfd
*abfd ATTRIBUTE_UNUSED
)
1116 vms_lib_bstat (struct bfd
*abfd ATTRIBUTE_UNUSED
,
1117 struct stat
*sb ATTRIBUTE_UNUSED
)
1119 /* Not supported. */
1124 vms_lib_bmmap (struct bfd
*abfd ATTRIBUTE_UNUSED
,
1125 void *addr ATTRIBUTE_UNUSED
,
1126 bfd_size_type len ATTRIBUTE_UNUSED
,
1127 int prot ATTRIBUTE_UNUSED
,
1128 int flags ATTRIBUTE_UNUSED
,
1129 file_ptr offset ATTRIBUTE_UNUSED
)
1134 static const struct bfd_iovec vms_lib_iovec
= {
1135 &vms_lib_bread
, &vms_lib_bwrite
, &vms_lib_btell
, &vms_lib_bseek
,
1136 &vms_lib_bclose
, &vms_lib_bflush
, &vms_lib_bstat
, &vms_lib_bmmap
1139 /* Open a library module. FILEPOS is the position of the module header. */
1142 vms_lib_bopen (bfd
*el
, file_ptr filepos
)
1144 struct vms_lib_iovec
*vec
;
1146 struct vms_mhd
*mhd
;
1147 struct lib_tdata
*tdata
= bfd_libdata (el
->my_archive
);
1150 /* Allocate and initialized the iovec. */
1151 vec
= bfd_zalloc (el
, sizeof (*vec
));
1156 el
->iovec
= &vms_lib_iovec
;
1158 /* File length is not known. */
1161 /* Read the first data block. */
1162 vec
->next_block
= filepos
& ~(VMS_BLOCK_SIZE
- 1);
1163 vec
->blk_off
= DATA__LENGTH
;
1164 if (!vms_lib_read_block (el
))
1167 /* Prepare to read the first record. */
1168 vec
->blk_off
= filepos
& (VMS_BLOCK_SIZE
- 1);
1170 if (bfd_seek (el
->my_archive
, filepos
, SEEK_SET
) != 0)
1173 /* Read Record length + MHD + align byte. */
1174 len
= tdata
->mhd_size
;
1175 if (vms_lib_bread_raw (el
, buf
, 2) != 2)
1177 if (bfd_getl16 (buf
) != len
)
1179 len
= (len
+ 1) & ~1;
1180 BFD_ASSERT (len
<= sizeof (buf
));
1181 if (vms_lib_bread_raw (el
, buf
, len
) != len
)
1184 /* Get info from mhd. */
1185 mhd
= (struct vms_mhd
*)buf
;
1187 if (mhd
->id
!= MHD__C_MHDID
)
1189 if (len
>= sizeof (struct vms_mhd
))
1190 el
->selective_search
= (mhd
->objstat
& MHD__M_SELSRC
) ? 1 : 0;
1191 el
->mtime
= vms_rawtime_to_time_t (mhd
->datim
);
1192 el
->mtime_set
= TRUE
;
1194 /* Reinit the iovec so that seek() will point to the first record after
1197 vec
->init_blk_off
= vec
->blk_off
;
1198 vec
->init_next_block
= vec
->next_block
;
1199 vec
->first_block
= bfd_tell (el
->my_archive
);
1200 vec
->dcxsbms
= bfd_libdata (el
->my_archive
)->dcxsbm
;
1202 if (vec
->dcxsbms
!= NULL
)
1205 vec
->dcx_max
= 10 * 1024;
1206 vec
->dcx_buf
= bfd_alloc (el
, vec
->dcx_max
);
1208 if (vec
->dcx_buf
== NULL
)
1214 /* Get member MODIDX. Return NULL in case of error. */
1217 _bfd_vms_lib_get_module (bfd
*abfd
, unsigned int modidx
)
1219 struct lib_tdata
*tdata
= bfd_libdata (abfd
);
1224 if (modidx
>= tdata
->nbr_modules
)
1227 /* Already loaded. */
1228 if (tdata
->cache
[modidx
])
1229 return tdata
->cache
[modidx
];
1232 file_off
= tdata
->modules
[modidx
].file_offset
;
1233 if (tdata
->type
!= LBR__C_TYP_IOBJ
)
1235 res
= _bfd_create_empty_archive_element_shell (abfd
);
1239 /* Special reader to deal with data blocks. */
1240 if (!vms_lib_bopen (res
, file_off
))
1246 struct vms_mhd
*mhd
;
1247 struct areltdata
*arelt
;
1249 /* Sanity check. The MHD must be big enough to contain module size. */
1250 if (tdata
->mhd_size
< offsetof (struct vms_mhd
, modsize
) + 4)
1253 /* Read the MHD now. */
1254 if (bfd_seek (abfd
, file_off
, SEEK_SET
) != 0)
1256 if (bfd_bread (buf
, tdata
->mhd_size
, abfd
) != tdata
->mhd_size
)
1259 res
= _bfd_create_empty_archive_element_shell (abfd
);
1262 arelt
= bfd_zalloc (res
, sizeof (*arelt
));
1265 res
->arelt_data
= arelt
;
1267 /* Get info from mhd. */
1268 mhd
= (struct vms_mhd
*)buf
;
1269 if (mhd
->id
!= MHD__C_MHDID
)
1271 if (tdata
->mhd_size
>= offsetof (struct vms_mhd
, objstat
) + 1)
1272 res
->selective_search
= (mhd
->objstat
& MHD__M_SELSRC
) ? 1 : 0;
1273 res
->mtime
= vms_rawtime_to_time_t (mhd
->datim
);
1274 res
->mtime_set
= TRUE
;
1276 arelt
->parsed_size
= bfd_getl32 (mhd
->modsize
);
1278 /* No need for a special reader as members are stored linearly.
1279 Just skip the MHD. */
1280 res
->origin
= file_off
+ tdata
->mhd_size
;
1283 res
->filename
= tdata
->modules
[modidx
].name
;
1285 tdata
->cache
[modidx
] = res
;
1290 /* Standard function: get member at IDX. */
1293 _bfd_vms_lib_get_elt_at_index (bfd
*abfd
, symindex symidx
)
1295 struct lib_tdata
*tdata
= bfd_libdata (abfd
);
1297 unsigned int modidx
;
1300 if (symidx
> tdata
->artdata
.symdef_count
)
1302 file_off
= tdata
->artdata
.symdefs
[symidx
].file_offset
;
1305 for (modidx
= 0; modidx
< tdata
->nbr_modules
; modidx
++)
1307 if (tdata
->modules
[modidx
].file_offset
== file_off
)
1310 if (modidx
>= tdata
->nbr_modules
)
1313 return _bfd_vms_lib_get_module (abfd
, modidx
);
1316 /* Elements of an imagelib are stubs. You can get the real image with this
1320 _bfd_vms_lib_get_imagelib_file (bfd
*el
)
1322 bfd
*archive
= el
->my_archive
;
1323 const char *modname
= el
->filename
;
1324 int modlen
= strlen (modname
);
1329 /* Convert module name to lower case and append '.exe'. */
1330 filename
= bfd_alloc (el
, modlen
+ 5);
1331 if (filename
== NULL
)
1333 for (j
= 0; j
< modlen
; j
++)
1334 if (ISALPHA (modname
[j
]))
1335 filename
[j
] = TOLOWER (modname
[j
]);
1337 filename
[j
] = modname
[j
];
1338 memcpy (filename
+ modlen
, ".exe", 5);
1340 filename
= _bfd_append_relative_path (archive
, filename
);
1341 if (filename
== NULL
)
1343 res
= bfd_openr (filename
, NULL
);
1347 (*_bfd_error_handler
)(_("could not open shared image '%s' from '%s'"),
1348 filename
, archive
->filename
);
1349 bfd_release (archive
, filename
);
1353 /* FIXME: put it in a cache ? */
1357 /* Standard function. */
1360 _bfd_vms_lib_openr_next_archived_file (bfd
*archive
,
1369 idx
= last_file
->proxy_origin
+ 1;
1371 if (idx
>= bfd_libdata (archive
)->nbr_modules
)
1373 bfd_set_error (bfd_error_no_more_archived_files
);
1377 res
= _bfd_vms_lib_get_module (archive
, idx
);
1380 res
->proxy_origin
= idx
;
1384 /* Standard function. Just compute the length. */
1387 _bfd_vms_lib_generic_stat_arch_elt (bfd
*abfd
, struct stat
*st
)
1389 struct lib_tdata
*tdata
;
1392 if (abfd
->my_archive
== NULL
)
1394 bfd_set_error (bfd_error_invalid_operation
);
1398 tdata
= bfd_libdata (abfd
->my_archive
);
1399 if (tdata
->type
!= LBR__C_TYP_IOBJ
)
1401 struct vms_lib_iovec
*vec
= (struct vms_lib_iovec
*) abfd
->iostream
;
1403 if (vec
->file_len
== (ufile_ptr
)-1)
1405 if (vms_lib_bseek (abfd
, 0, SEEK_SET
) != 0)
1408 /* Compute length. */
1409 while (vms_lib_bread (abfd
, NULL
, 1 << 20) > 0)
1412 st
->st_size
= vec
->file_len
;
1416 st
->st_size
= ((struct areltdata
*)abfd
->arelt_data
)->parsed_size
;
1419 if (abfd
->mtime_set
)
1420 st
->st_mtime
= abfd
->mtime
;
1430 /* Internal representation of an index entry. */
1434 /* Corresponding archive member. */
1437 /* Number of reference to this entry. */
1440 /* Length of the key. */
1441 unsigned short namlen
;
1447 /* Used to sort index entries. */
1450 vms_index_cmp (const void *lv
, const void *rv
)
1452 const struct vms_index
*l
= lv
;
1453 const struct vms_index
*r
= rv
;
1455 return strcmp (l
->name
, r
->name
);
1458 /* Maximum number of index blocks level. */
1460 #define MAX_LEVEL 10
1462 /* Get the size of an index entry. */
1465 get_idxlen (struct vms_index
*idx
)
1467 return 7 + idx
->namlen
;
1470 /* Write the index. VBN is the first vbn to be used, and will contain
1471 on return the last vbn.
1472 Return TRUE on success. */
1475 vms_write_index (bfd
*abfd
,
1476 struct vms_index
*idx
, unsigned int nbr
, unsigned int *vbn
,
1477 unsigned int *topvbn
)
1482 struct vms_indexdef
*rblk
[MAX_LEVEL
];
1487 unsigned short lastlen
;
1499 /* Sort the index the first time this function is called. */
1500 qsort (idx
, nbr
, sizeof (struct vms_index
), vms_index_cmp
);
1503 /* Allocate first index block. */
1506 rblk
[0] = bfd_malloc (sizeof (struct vms_indexdef
));
1507 blk
[0].vbn
= (*vbn
)++;
1511 for (i
= 0; i
< nbr
; i
++, idx
++)
1513 unsigned int idxlen
= get_idxlen (idx
);
1517 /* Check if a block might overflow. In this case we will flush this
1518 block and all the blocks below it. */
1519 for (j
= 0; j
< level
; j
++)
1520 if (blk
[j
].len
+ blk
[j
].lastlen
+ idxlen
> INDEXDEF__BLKSIZ
)
1523 for (j
= 0; j
< level
; j
++)
1527 /* There is not enough room to write the new entry in this
1528 block or in a parent block. */
1532 BFD_ASSERT (level
< MAX_LEVEL
);
1534 /* Need to create a parent. */
1537 rblk
[level
] = bfd_malloc (sizeof (struct vms_indexdef
));
1538 bfd_putl32 (*vbn
, rblk
[j
]->parent
);
1540 blk
[level
].vbn
= (*vbn
)++;
1542 blk
[level
].lastlen
= 0;
1547 /* Update parent block: write the new entry. */
1550 en
= (struct vms_idx
*)(rblk
[j
]->keys
+ blk
[j
].len
);
1551 memcpy (rblk
[j
+ 1]->keys
+ blk
[j
+ 1].len
, en
,
1553 en
= (struct vms_idx
*)(rblk
[j
+ 1]->keys
+ blk
[j
+ 1].len
);
1554 bfd_putl32 (blk
[j
].vbn
, en
->rfa
.vbn
);
1555 bfd_putl16 (RFADEF__C_INDEX
, en
->rfa
.offset
);
1560 /* And allocate it. Do it only on the block that won't be
1561 flushed (so that the parent of the parent can be
1563 blk
[j
+ 1].len
+= blk
[j
].lastlen
;
1564 blk
[j
+ 1].lastlen
= 0;
1567 /* Write this block on the disk. */
1570 bfd_putl16 (blk
[j
].len
+ blk
[j
].lastlen
, rblk
[j
]->used
);
1571 if (bfd_seek (abfd
, (blk
[j
].vbn
- 1) * VMS_BLOCK_SIZE
,
1574 if (bfd_bwrite (rblk
[j
], sizeof (struct vms_indexdef
), abfd
)
1575 != sizeof (struct vms_indexdef
))
1579 /* Reset this block. */
1582 blk
[j
].vbn
= (*vbn
)++;
1585 /* Append it to the block. */
1588 blk
[j
].len
+= blk
[j
].lastlen
;
1592 en
= (struct vms_idx
*)(rblk
[j
]->keys
+ blk
[j
].len
);
1593 bfd_putl32 ((idx
->abfd
->proxy_origin
/ VMS_BLOCK_SIZE
) + 1,
1596 ((idx
->abfd
->proxy_origin
% VMS_BLOCK_SIZE
) + DATA__DATA
,
1598 en
->keylen
= idx
->namlen
;
1599 memcpy (en
->keyname
, idx
->name
, idx
->namlen
);
1603 blk
[j
].lastlen
= idxlen
;
1608 *topvbn
= blk
[level
- 1].vbn
;
1614 for (j
= 0; j
< level
; j
++)
1618 /* Update parent block: write the new entry. */
1620 struct vms_idx
*par
;
1622 en
= (struct vms_idx
*)(rblk
[j
- 1]->keys
+ blk
[j
- 1].len
);
1623 par
= (struct vms_idx
*)(rblk
[j
]->keys
+ blk
[j
].len
);
1624 memcpy (par
, en
, blk
[j
- 1].lastlen
);
1625 bfd_putl32 (blk
[j
- 1].vbn
, par
->rfa
.vbn
);
1626 bfd_putl16 (RFADEF__C_INDEX
, par
->rfa
.offset
);
1629 /* Write this block on the disk. */
1630 bfd_putl16 (blk
[j
].len
+ blk
[j
].lastlen
, rblk
[j
]->used
);
1631 if (bfd_seek (abfd
, (blk
[j
].vbn
- 1) * VMS_BLOCK_SIZE
,
1634 if (bfd_bwrite (rblk
[j
], sizeof (struct vms_indexdef
), abfd
)
1635 != sizeof (struct vms_indexdef
))
1644 /* Append data to the data block DATA. Force write if PAD is true. */
1647 vms_write_data_block (bfd
*arch
, struct vms_datadef
*data
, file_ptr
*off
,
1648 const unsigned char *buf
, unsigned int len
, int pad
)
1650 while (len
> 0 || pad
)
1652 unsigned int doff
= *off
& (VMS_BLOCK_SIZE
- 1);
1653 unsigned int remlen
= (DATA__LENGTH
- DATA__DATA
) - doff
;
1656 l
= (len
> remlen
) ? remlen
: len
;
1657 memcpy (data
->data
+ doff
, buf
, l
);
1663 if (doff
== (DATA__LENGTH
- DATA__DATA
) || (len
== 0 && pad
))
1667 bfd_putl32 ((*off
/ VMS_BLOCK_SIZE
) + 2, data
->link
);
1669 if (bfd_bwrite (data
, sizeof (*data
), arch
) != sizeof (*data
))
1672 *off
+= DATA__LENGTH
- doff
;
1681 /* Build the symbols index. */
1684 _bfd_vms_lib_build_map (unsigned int nbr_modules
,
1685 struct vms_index
*modules
,
1686 unsigned int *res_cnt
,
1687 struct vms_index
**res
)
1690 asymbol
**syms
= NULL
;
1692 struct vms_index
*map
= NULL
;
1693 unsigned int map_max
= 1024; /* Fine initial default. */
1694 unsigned int map_count
= 0;
1696 map
= (struct vms_index
*) bfd_malloc (map_max
* sizeof (struct vms_index
));
1700 /* Gather symbols. */
1701 for (i
= 0; i
< nbr_modules
; i
++)
1706 bfd
*current
= modules
[i
].abfd
;
1708 if ((bfd_get_file_flags (current
) & HAS_SYMS
) == 0)
1711 storage
= bfd_get_symtab_upper_bound (current
);
1717 if (storage
> syms_max
)
1722 syms
= (asymbol
**) bfd_malloc (syms_max
);
1726 symcount
= bfd_canonicalize_symtab (current
, syms
);
1730 /* Now map over all the symbols, picking out the ones we
1732 for (src_count
= 0; src_count
< symcount
; src_count
++)
1734 flagword flags
= (syms
[src_count
])->flags
;
1735 asection
*sec
= syms
[src_count
]->section
;
1737 if ((flags
& BSF_GLOBAL
1739 || flags
& BSF_INDIRECT
1740 || bfd_is_com_section (sec
))
1741 && ! bfd_is_und_section (sec
))
1743 struct vms_index
*new_map
;
1745 /* This symbol will go into the archive header. */
1746 if (map_count
== map_max
)
1749 new_map
= (struct vms_index
*)
1750 bfd_realloc (map
, map_max
* sizeof (struct vms_index
));
1751 if (new_map
== NULL
)
1756 map
[map_count
].abfd
= current
;
1757 /* FIXME: check length. */
1758 map
[map_count
].namlen
= strlen (syms
[src_count
]->name
);
1759 map
[map_count
].name
= syms
[src_count
]->name
;
1767 *res_cnt
= map_count
;
1779 /* Do the hard work: write an archive on the disk. */
1782 _bfd_vms_lib_write_archive_contents (bfd
*arch
)
1785 unsigned int nbr_modules
;
1786 struct vms_index
*modules
;
1787 unsigned int nbr_symbols
;
1788 struct vms_index
*symbols
;
1789 struct lib_tdata
*tdata
= bfd_libdata (arch
);
1792 unsigned int nbr_mod_iblk
;
1793 unsigned int nbr_sym_iblk
;
1795 unsigned int mod_idx_vbn
;
1796 unsigned int sym_idx_vbn
;
1798 /* Count the number of modules (and do a first sanity check). */
1800 for (current
= arch
->archive_head
;
1802 current
= current
->archive_next
)
1804 /* This check is checking the bfds for the objects we're reading
1805 from (which are usually either an object file or archive on
1806 disk), not the archive entries we're writing to. We don't
1807 actually create bfds for the archive members, we just copy
1808 them byte-wise when we write out the archive. */
1809 if (bfd_write_p (current
) || !bfd_check_format (current
, bfd_object
))
1811 bfd_set_error (bfd_error_invalid_operation
);
1818 /* Build the modules list. */
1819 BFD_ASSERT (tdata
->modules
== NULL
);
1820 modules
= bfd_alloc (arch
, nbr_modules
* sizeof (struct vms_index
));
1821 if (modules
== NULL
)
1824 for (current
= arch
->archive_head
, i
= 0;
1826 current
= current
->archive_next
, i
++)
1830 modules
[i
].abfd
= current
;
1831 modules
[i
].name
= vms_get_module_name (current
->filename
, FALSE
);
1834 /* FIXME: silently truncate long names ? */
1835 nl
= strlen (modules
[i
].name
);
1836 modules
[i
].namlen
= (nl
> MAX_KEYLEN
? MAX_KEYLEN
: nl
);
1839 /* Create the module index. */
1841 if (!vms_write_index (NULL
, modules
, nbr_modules
, &vbn
, NULL
))
1845 /* Create symbol index. */
1846 if (!_bfd_vms_lib_build_map (nbr_modules
, modules
, &nbr_symbols
, &symbols
))
1850 if (!vms_write_index (NULL
, symbols
, nbr_symbols
, &vbn
, NULL
))
1854 /* Write modules and remember their position. */
1855 off
= (1 + nbr_mod_iblk
+ nbr_sym_iblk
) * VMS_BLOCK_SIZE
;
1857 if (bfd_seek (arch
, off
, SEEK_SET
) != 0)
1860 for (i
= 0; i
< nbr_modules
; i
++)
1862 struct vms_datadef data
;
1863 unsigned char blk
[VMS_BLOCK_SIZE
];
1864 struct vms_mhd
*mhd
;
1867 current
= modules
[i
].abfd
;
1868 current
->proxy_origin
= off
;
1870 bfd_putl16 (sizeof (struct vms_mhd
), blk
);
1871 mhd
= (struct vms_mhd
*)(blk
+ 2);
1872 memset (mhd
, 0, sizeof (struct vms_mhd
));
1874 mhd
->id
= MHD__C_MHDID
;
1876 memcpy (mhd
->objid
, "V1.0", 4);
1877 bfd_putl32 (modules
[i
].ref
, mhd
->refcnt
);
1880 sz
= (2 + sizeof (struct vms_mhd
) + 1) & ~1;
1881 if (vms_write_data_block (arch
, &data
, &off
, blk
, sz
, 0) < 0)
1884 if (bfd_seek (current
, 0, SEEK_SET
) != 0)
1889 sz
= bfd_bread (blk
, sizeof (blk
), current
);
1892 if (vms_write_data_block (arch
, &data
, &off
, blk
, sz
, 0) < 0)
1895 if (vms_write_data_block (arch
, &data
, &off
,
1896 eotdesc
, sizeof (eotdesc
), 1) < 0)
1900 /* Write the indexes. */
1902 if (vms_write_index (arch
, modules
, nbr_modules
, &vbn
, &mod_idx_vbn
) != TRUE
)
1904 if (vms_write_index (arch
, symbols
, nbr_symbols
, &vbn
, &sym_idx_vbn
) != TRUE
)
1907 /* Write libary header. */
1909 unsigned char blk
[VMS_BLOCK_SIZE
];
1910 struct vms_lhd
*lhd
= (struct vms_lhd
*)blk
;
1911 struct vms_idd
*idd
= (struct vms_idd
*)(blk
+ sizeof (*lhd
));
1912 unsigned int idd_flags
;
1914 memset (blk
, 0, sizeof (blk
));
1916 lhd
->type
= LBR__C_TYP_EOBJ
;
1918 bfd_putl32 (LHD_SANEID3
, lhd
->sanity
);
1919 bfd_putl16 (3, lhd
->majorid
);
1920 bfd_putl16 (0, lhd
->minorid
);
1921 snprintf ((char *)lhd
->lbrver
+ 1, sizeof (lhd
->lbrver
) - 1,
1923 (unsigned)(BFD_VERSION
/ 100000000UL),
1924 (unsigned)(BFD_VERSION
/ 1000000UL) % 100,
1925 (unsigned)(BFD_VERSION
/ 10000UL) % 100);
1926 lhd
->lbrver
[sizeof (lhd
->lbrver
) - 1] = 0;
1927 lhd
->lbrver
[0] = strlen ((char *)lhd
->lbrver
+ 1);
1930 bfd_putl64 (0, lhd
->credat
);
1931 bfd_putl64 (0, lhd
->updtim
);
1933 lhd
->mhdusz
= sizeof (struct vms_mhd
) - MHD__C_USRDAT
;
1935 bfd_putl32 (nbr_modules
+ nbr_symbols
, lhd
->idxcnt
);
1936 bfd_putl32 (nbr_modules
, lhd
->modcnt
);
1937 bfd_putl32 (nbr_modules
, lhd
->modhdrs
);
1939 bfd_putl32 (vbn
- 1, lhd
->hipreal
);
1940 bfd_putl32 (vbn
- 1, lhd
->hiprusd
);
1942 /* First index (modules name). */
1943 idd_flags
= IDD__FLAGS_ASCII
| IDD__FLAGS_VARLENIDX
1944 | IDD__FLAGS_NOCASECMP
| IDD__FLAGS_NOCASENTR
;
1945 bfd_putl16 (idd_flags
, idd
->flags
);
1946 bfd_putl16 (MAX_KEYLEN
, idd
->keylen
);
1947 bfd_putl16 (mod_idx_vbn
, idd
->vbn
);
1950 /* Second index (symbols name). */
1951 bfd_putl16 (idd_flags
, idd
->flags
);
1952 bfd_putl16 (MAX_KEYLEN
, idd
->keylen
);
1953 bfd_putl16 (sym_idx_vbn
, idd
->vbn
);
1956 if (bfd_seek (arch
, 0, SEEK_SET
) != 0)
1958 if (bfd_bwrite (blk
, sizeof (blk
), arch
) != sizeof (blk
))
1965 bfd_set_error (bfd_error_on_input
, current
, bfd_get_error ());
1969 /* Add a target for text library. This costs almost nothing and is useful to
1970 read VMS library on the host. */
1972 const bfd_target vms_lib_txt_vec
=
1974 "vms-libtxt", /* Name. */
1975 bfd_target_unknown_flavour
,
1976 BFD_ENDIAN_UNKNOWN
, /* byteorder */
1977 BFD_ENDIAN_UNKNOWN
, /* header_byteorder */
1978 0, /* Object flags. */
1979 0, /* Sect flags. */
1980 0, /* symbol_leading_char. */
1981 ' ', /* ar_pad_char. */
1982 15, /* ar_max_namelen. */
1983 bfd_getl64
, bfd_getl_signed_64
, bfd_putl64
,
1984 bfd_getl32
, bfd_getl_signed_32
, bfd_putl32
,
1985 bfd_getl16
, bfd_getl_signed_16
, bfd_putl16
,
1986 bfd_getl64
, bfd_getl_signed_64
, bfd_putl64
,
1987 bfd_getl32
, bfd_getl_signed_32
, bfd_putl32
,
1988 bfd_getl16
, bfd_getl_signed_16
, bfd_putl16
,
1990 {_bfd_dummy_target
, _bfd_dummy_target
, /* bfd_check_format. */
1991 _bfd_vms_lib_txt_archive_p
, _bfd_dummy_target
},
1992 {bfd_false
, bfd_false
, bfd_false
, bfd_false
}, /* bfd_set_format. */
1993 {bfd_false
, bfd_false
, bfd_false
, bfd_false
}, /* bfd_write_contents. */
1995 BFD_JUMP_TABLE_GENERIC (_bfd_generic
),
1996 BFD_JUMP_TABLE_COPY (_bfd_generic
),
1997 BFD_JUMP_TABLE_CORE (_bfd_nocore
),
1998 BFD_JUMP_TABLE_ARCHIVE (_bfd_vms_lib
),
1999 BFD_JUMP_TABLE_SYMBOLS (_bfd_nosymbols
),
2000 BFD_JUMP_TABLE_RELOCS (_bfd_norelocs
),
2001 BFD_JUMP_TABLE_WRITE (_bfd_nowrite
),
2002 BFD_JUMP_TABLE_LINK (_bfd_nolink
),
2003 BFD_JUMP_TABLE_DYNAMIC (_bfd_nodynamic
),