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