Coverage Report

Created: 2024-05-21 06:29

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