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