OpenCores
URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [gdb-5.0/] [bfd/] [vms-tir.c] - Blame information for rev 1765

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 104 markom
/* vms-tir.c -- BFD back-end for VAX (openVMS/VAX) and
2
   EVAX (openVMS/Alpha) files.
3
   Copyright 1996, 1997, 1998, 1999 Free Software Foundation, Inc.
4
 
5
   TIR record handling functions
6
   ETIR record handling functions
7
 
8
   go and read the openVMS linker manual (esp. appendix B)
9
   if you don't know what's going on here :-)
10
 
11
   Written by Klaus K"ampf (kkaempf@rmi.de)
12
 
13
This program is free software; you can redistribute it and/or modify
14
it under the terms of the GNU General Public License as published by
15
the Free Software Foundation; either version 2 of the License, or
16
(at your option) any later version.
17
 
18
This program is distributed in the hope that it will be useful,
19
but WITHOUT ANY WARRANTY; without even the implied warranty of
20
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
21
GNU General Public License for more details.
22
 
23
You should have received a copy of the GNU General Public License
24
along with this program; if not, write to the Free Software
25
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
26
 
27
 
28
/* The following type abbreviations are used:
29
 
30
        cs      counted string (ascii string with length byte)
31
        by      byte (1 byte)
32
        sh      short (2 byte, 16 bit)
33
        lw      longword (4 byte, 32 bit)
34
        qw      quadword (8 byte, 64 bit)
35
        da      data stream  */
36
 
37
#include <ctype.h>
38
 
39
#include "bfd.h"
40
#include "sysdep.h"
41
#include "bfdlink.h"
42
#include "libbfd.h"
43
 
44
#include "vms.h"
45
 
46
static void image_set_ptr PARAMS ((bfd *abfd, int psect, uquad offset));
47
static void image_inc_ptr PARAMS ((bfd *abfd, uquad offset));
48
static void image_dump PARAMS ((bfd *abfd, unsigned char *ptr, int size, int offset));
49
static void image_write_b PARAMS ((bfd *abfd, unsigned int value));
50
static void image_write_w PARAMS ((bfd *abfd, unsigned int value));
51
static void image_write_l PARAMS ((bfd *abfd, unsigned long value));
52
static void image_write_q PARAMS ((bfd *abfd, uquad value));
53
 
54
/*-----------------------------------------------------------------------------*/
55
 
56
static int
57
check_section (abfd, size)
58
     bfd *abfd;
59
     int size;
60
{
61
  int offset;
62
 
63
  offset = PRIV(image_ptr) - PRIV(image_section)->contents;
64
  if ((bfd_size_type) (offset + size) > PRIV(image_section)->_raw_size)
65
    {
66
      PRIV(image_section)->contents = bfd_realloc (PRIV(image_section)->contents, offset + size);
67
      if (PRIV(image_section)->contents == 0)
68
        {
69
          (*_bfd_error_handler) (_("No Mem !"));
70
          return -1;
71
        }
72
      PRIV(image_section)->_raw_size = offset + size;
73
      PRIV(image_ptr) = PRIV(image_section)->contents + offset;
74
    }
75
 
76
  return 0;
77
}
78
 
79
/* routines to fill sections contents during tir/etir read */
80
 
81
/* Initialize image buffer pointer to be filled  */
82
 
83
static void
84
image_set_ptr (abfd, psect, offset)
85
     bfd *abfd;
86
     int psect;
87
     uquad offset;
88
{
89
#if VMS_DEBUG
90
  _bfd_vms_debug (4, "image_set_ptr (%d=%s, %d)\n",
91
                psect, PRIV(sections)[psect]->name, offset);
92
#endif
93
 
94
  PRIV(image_ptr) = PRIV(sections)[psect]->contents + offset;
95
  PRIV(image_section) = PRIV(sections)[psect];
96
  return;
97
}
98
 
99
 
100
/* Increment image buffer pointer by offset  */
101
 
102
static void
103
image_inc_ptr (abfd, offset)
104
     bfd *abfd;
105
     uquad offset;
106
{
107
#if VMS_DEBUG
108
  _bfd_vms_debug (4, "image_inc_ptr (%d)\n", offset);
109
#endif
110
 
111
  PRIV(image_ptr) += offset;
112
 
113
  return;
114
}
115
 
116
 
117
/* Dump multiple bytes to section image  */
118
 
119
static void
120
image_dump (abfd, ptr, size, offset)
121
    bfd *abfd;
122
    unsigned char *ptr;
123
    int size;
124
    int offset ATTRIBUTE_UNUSED;
125
{
126
#if VMS_DEBUG
127
  _bfd_vms_debug (8, "image_dump from (%p, %d) to (%p)\n", ptr, size, PRIV(image_ptr));
128
  _bfd_hexdump (9, ptr, size, offset);
129
#endif
130
 
131
  if (PRIV(is_vax) && check_section (abfd, size))
132
    return;
133
 
134
  while (size-- > 0)
135
    *PRIV(image_ptr)++ = *ptr++;
136
  return;
137
}
138
 
139
 
140
/* Write byte to section image  */
141
 
142
static void
143
image_write_b (abfd, value)
144
     bfd *abfd;
145
     unsigned int value;
146
{
147
#if VMS_DEBUG
148
  _bfd_vms_debug (6, "image_write_b(%02x)\n", (int)value);
149
#endif
150
 
151
  if (PRIV(is_vax) && check_section (abfd, 1))
152
    return;
153
 
154
  *PRIV(image_ptr)++ = (value & 0xff);
155
  return;
156
}
157
 
158
 
159
/* Write 2-byte word to image  */
160
 
161
static void
162
image_write_w (abfd, value)
163
     bfd *abfd;
164
     unsigned int value;
165
{
166
#if VMS_DEBUG
167
  _bfd_vms_debug (6, "image_write_w(%04x)\n", (int)value);
168
#endif
169
 
170
  if (PRIV(is_vax) && check_section (abfd, 2))
171
    return;
172
 
173
  bfd_putl16 (value, PRIV(image_ptr));
174
  PRIV(image_ptr) += 2;
175
 
176
  return;
177
}
178
 
179
 
180
/* Write 4-byte long to image  */
181
 
182
static void
183
image_write_l (abfd, value)
184
     bfd *abfd;
185
     unsigned long value;
186
{
187
#if VMS_DEBUG
188
  _bfd_vms_debug (6, "image_write_l (%08lx)\n", value);
189
#endif
190
 
191
  if (PRIV(is_vax) && check_section (abfd, 4))
192
    return;
193
 
194
  bfd_putl32 (value, PRIV(image_ptr));
195
  PRIV(image_ptr) += 4;
196
 
197
  return;
198
}
199
 
200
 
201
/* Write 8-byte quad to image  */
202
 
203
static void
204
image_write_q (abfd, value)
205
     bfd *abfd;
206
     uquad value;
207
{
208
#if VMS_DEBUG
209
  _bfd_vms_debug (6, "image_write_q (%016lx)\n", value);
210
#endif
211
 
212
  if (PRIV(is_vax) && check_section (abfd, 8))
213
    return;
214
 
215
  bfd_putl64 (value, PRIV(image_ptr));
216
  PRIV(image_ptr) += 8;
217
 
218
  return;
219
}
220
 
221
 
222
#define HIGHBIT(op) ((op & 0x80000000L) == 0x80000000L)
223
 
224
/* etir_sta
225
 
226
   vms stack commands
227
 
228
   handle sta_xxx commands in etir section
229
   ptr points to data area in record
230
 
231
   see table B-8 of the openVMS linker manual  */
232
 
233
static boolean
234
etir_sta (abfd, cmd, ptr)
235
     bfd *abfd;
236
     int cmd;
237
     unsigned char *ptr;
238
{
239
 
240
#if VMS_DEBUG
241
  _bfd_vms_debug (5, "etir_sta %d/%x\n", cmd, cmd);
242
  _bfd_hexdump (8, ptr, 16, (int)ptr);
243
#endif
244
 
245
  switch (cmd)
246
    {
247
      /* stack */
248
 
249
      /* stack global
250
           arg: cs      symbol name
251
 
252
           stack 32 bit value of symbol (high bits set to 0)  */
253
 
254
      case ETIR_S_C_STA_GBL:
255
        {
256
          char *name;
257
          vms_symbol_entry *entry;
258
 
259
          name = _bfd_vms_save_counted_string (ptr);
260
          entry = (vms_symbol_entry *)
261
                  bfd_hash_lookup (PRIV(vms_symbol_table), name, false, false);
262
          if (entry == (vms_symbol_entry *)NULL)
263
            {
264
#if VMS_DEBUG
265
              _bfd_vms_debug (3, "ETIR_S_C_STA_GBL: no symbol \"%s\"\n", name);
266
#endif
267
              _bfd_vms_push (abfd, (uquad)0, -1);
268
            }
269
          else
270
            {
271
              _bfd_vms_push (abfd, (uquad)(entry->symbol->value), -1);
272
            }
273
        }
274
      break;
275
 
276
        /* stack longword
277
           arg: lw      value
278
 
279
           stack 32 bit value, sign extend to 64 bit  */
280
 
281
      case ETIR_S_C_STA_LW:
282
        _bfd_vms_push (abfd, (uquad)bfd_getl32 (ptr), -1);
283
      break;
284
 
285
        /* stack global
286
           arg: qw      value
287
 
288
           stack 64 bit value of symbol  */
289
 
290
      case ETIR_S_C_STA_QW:
291
        _bfd_vms_push (abfd, (uquad)bfd_getl64(ptr), -1);
292
      break;
293
 
294
        /* stack psect base plus quadword offset
295
           arg: lw      section index
296
                qw      signed quadword offset (low 32 bits)
297
 
298
           stack qw argument and section index
299
           (see ETIR_S_C_STO_OFF, ETIR_S_C_CTL_SETRB)  */
300
 
301
      case ETIR_S_C_STA_PQ:
302
        {
303
          uquad dummy;
304
          unsigned int psect;
305
 
306
          psect = bfd_getl32 (ptr);
307
          if (psect >= PRIV(section_count))
308
            {
309
              (*_bfd_error_handler) (_("Bad section index in ETIR_S_C_STA_PQ"));
310
              bfd_set_error (bfd_error_bad_value);
311
              return false;
312
            }
313
          dummy = bfd_getl64 (ptr+4);
314
          _bfd_vms_push (abfd, dummy, psect);
315
        }
316
      break;
317
 
318
        /* all not supported  */
319
 
320
      case ETIR_S_C_STA_LI:
321
      case ETIR_S_C_STA_MOD:
322
      case ETIR_S_C_STA_CKARG:
323
 
324
        (*_bfd_error_handler) (_("Unsupported STA cmd %d"), cmd);
325
        return false;
326
      break;
327
 
328
      default:
329
        (*_bfd_error_handler) (_("Reserved STA cmd %d"), cmd);
330
        return false;
331
      break;
332
    }
333
#if VMS_DEBUG
334
  _bfd_vms_debug (5, "etir_sta true\n");
335
#endif
336
  return true;
337
}
338
 
339
 
340
/*
341
   etir_sto
342
 
343
   vms store commands
344
 
345
   handle sto_xxx commands in etir section
346
   ptr points to data area in record
347
 
348
   see table B-9 of the openVMS linker manual  */
349
 
350
static boolean
351
etir_sto (abfd, cmd, ptr)
352
     bfd *abfd;
353
     int cmd;
354
     unsigned char *ptr;
355
{
356
  uquad dummy;
357
  int psect;
358
 
359
#if VMS_DEBUG
360
  _bfd_vms_debug (5, "etir_sto %d/%x\n", cmd, cmd);
361
  _bfd_hexdump (8, ptr, 16, (int)ptr);
362
#endif
363
 
364
  switch (cmd)
365
    {
366
 
367
      /* store byte: pop stack, write byte
368
         arg: -  */
369
 
370
    case ETIR_S_C_STO_B:
371
      dummy = _bfd_vms_pop (abfd, &psect);
372
#if 0
373
      if (is_share)             /* FIXME */
374
        (*_bfd_error_handler) ("ETIR_S_C_STO_B: byte fixups not supported");
375
#endif
376
      image_write_b (abfd, dummy & 0xff);       /* FIXME: check top bits */
377
      break;
378
 
379
      /* store word: pop stack, write word
380
         arg: -  */
381
 
382
    case ETIR_S_C_STO_W:
383
      dummy = _bfd_vms_pop (abfd, &psect);
384
#if 0
385
      if (is_share)             /* FIXME */
386
        (*_bfd_error_handler) ("ETIR_S_C_STO_B: word fixups not supported");
387
#endif
388
      image_write_w (abfd, dummy & 0xffff);     /* FIXME: check top bits */
389
      break;
390
 
391
      /* store longword: pop stack, write longword
392
         arg: -  */
393
 
394
    case ETIR_S_C_STO_LW:
395
      dummy = _bfd_vms_pop (abfd, &psect);
396
      dummy += (PRIV(sections)[psect])->vma;
397
      image_write_l (abfd, dummy & 0xffffffff);/* FIXME: check top bits */
398
      break;
399
 
400
      /* store quadword: pop stack, write quadword
401
         arg: -  */
402
 
403
    case ETIR_S_C_STO_QW:
404
      dummy = _bfd_vms_pop (abfd, &psect);
405
      dummy += (PRIV(sections)[psect])->vma;
406
      image_write_q (abfd, dummy);              /* FIXME: check top bits */
407
      break;
408
 
409
      /* store immediate repeated: pop stack for repeat count
410
         arg: lw        byte count
411
         da     data  */
412
 
413
    case ETIR_S_C_STO_IMMR:
414
      {
415
        unsigned long size;
416
 
417
        size = bfd_getl32 (ptr);
418
        dummy = (unsigned long)_bfd_vms_pop (abfd, NULL);
419
        while (dummy-- > 0L)
420
          image_dump (abfd, ptr+4, size, 0);
421
      }
422
      break;
423
 
424
      /* store global: write symbol value
425
         arg: cs        global symbol name  */
426
 
427
    case ETIR_S_C_STO_GBL:
428
      {
429
        vms_symbol_entry *entry;
430
        char *name;
431
 
432
        name = _bfd_vms_save_counted_string (ptr);
433
        entry = (vms_symbol_entry *)bfd_hash_lookup (PRIV(vms_symbol_table), name, false, false);
434
        if (entry == (vms_symbol_entry *)NULL)
435
          {
436
            (*_bfd_error_handler) (_("ETIR_S_C_STO_GBL: no symbol \"%s\""),
437
                                   name);
438
            return false;
439
          }
440
        else
441
          image_write_q (abfd, (uquad)(entry->symbol->value));  /* FIXME, reloc */
442
      }
443
      break;
444
 
445
      /* store code address: write address of entry point
446
         arg: cs        global symbol name (procedure)  */
447
 
448
    case ETIR_S_C_STO_CA:
449
      {
450
        vms_symbol_entry *entry;
451
        char *name;
452
 
453
        name = _bfd_vms_save_counted_string (ptr);
454
        entry = (vms_symbol_entry *) bfd_hash_lookup (PRIV(vms_symbol_table), name, false, false);
455
        if (entry == (vms_symbol_entry *)NULL)
456
          {
457
            (*_bfd_error_handler) (_("ETIR_S_C_STO_CA: no symbol \"%s\""),
458
                                   name);
459
            return false;
460
          }
461
        else
462
          image_write_q (abfd, (uquad)(entry->symbol->value));  /* FIXME, reloc */
463
      }
464
      break;
465
 
466
      /* not supported  */
467
 
468
    case ETIR_S_C_STO_RB:
469
    case ETIR_S_C_STO_AB:
470
      (*_bfd_error_handler) (_("ETIR_S_C_STO_RB/AB: Not supported"));
471
      break;
472
 
473
    /* store offset to psect: pop stack, add low 32 bits to base of psect
474
       arg: -  */
475
 
476
    case ETIR_S_C_STO_OFF:
477
      {
478
        uquad q;
479
        int psect;
480
 
481
        q = _bfd_vms_pop (abfd, &psect);
482
        q += (PRIV(sections)[psect])->vma;
483
        image_write_q (abfd, q);
484
      }
485
      break;
486
 
487
      /* store immediate
488
         arg: lw        count of bytes
489
         da     data  */
490
 
491
    case ETIR_S_C_STO_IMM:
492
      {
493
        int size;
494
 
495
        size = bfd_getl32 (ptr);
496
        image_dump (abfd, ptr+4, size, 0);
497
      }
498
      break;
499
 
500
      /* this code is 'reserved to digital' according to the openVMS linker manual,
501
         however it is generated by the DEC C compiler and defined in the include file.
502
         FIXME, since the following is just a guess
503
         store global longword: store 32bit value of symbol
504
         arg: cs        symbol name  */
505
 
506
    case ETIR_S_C_STO_GBL_LW:
507
      {
508
        vms_symbol_entry *entry;
509
        char *name;
510
 
511
        name = _bfd_vms_save_counted_string (ptr);
512
        entry = (vms_symbol_entry *)bfd_hash_lookup (PRIV(vms_symbol_table), name, false, false);
513
        if (entry == (vms_symbol_entry *)NULL)
514
          {
515
#if VMS_DEBUG
516
            _bfd_vms_debug (3, "ETIR_S_C_STO_GBL_LW: no symbol \"%s\"\n", name);
517
#endif
518
            image_write_l (abfd, (unsigned long)0);      /* FIXME, reloc */
519
          }
520
        else
521
          image_write_l (abfd, (unsigned long)(entry->symbol->value));  /* FIXME, reloc */
522
      }
523
      break;
524
 
525
      /* not supported  */
526
 
527
    case ETIR_S_C_STO_LP_PSB:
528
      (*_bfd_error_handler) (_("ETIR_S_C_STO_LP_PSB: Not supported"));
529
      break;
530
 
531
    /* */
532
 
533
    case ETIR_S_C_STO_HINT_GBL:
534
      (*_bfd_error_handler) (_("ETIR_S_C_STO_HINT_GBL: not implemented"));
535
      break;
536
 
537
    /* */
538
 
539
    case ETIR_S_C_STO_HINT_PS:
540
      (*_bfd_error_handler) (_("ETIR_S_C_STO_HINT_PS: not implemented"));
541
      break;
542
 
543
    default:
544
      (*_bfd_error_handler) (_("Reserved STO cmd %d"), cmd);
545
      break;
546
    }
547
 
548
  return true;
549
}
550
 
551
/* stack operator commands
552
   all 32 bit signed arithmetic
553
   all word just like a stack calculator
554
   arguments are popped from stack, results are pushed on stack
555
 
556
   see table B-10 of the openVMS linker manual  */
557
 
558
static boolean
559
etir_opr (abfd, cmd, ptr)
560
     bfd *abfd;
561
     int cmd;
562
     unsigned char *ptr ATTRIBUTE_UNUSED;
563
{
564
  long op1, op2;
565
 
566
#if VMS_DEBUG
567
  _bfd_vms_debug (5, "etir_opr %d/%x\n", cmd, cmd);
568
  _bfd_hexdump (8, ptr, 16, (int)ptr);
569
#endif
570
 
571
  switch (cmd)
572
    {
573
      /* operation */
574
 
575
      /* no-op  */
576
 
577
    case ETIR_S_C_OPR_NOP:
578
      break;
579
 
580
      /* add  */
581
 
582
    case ETIR_S_C_OPR_ADD:
583
      op1 = (long)_bfd_vms_pop (abfd, NULL);
584
      op2 = (long)_bfd_vms_pop (abfd, NULL);
585
      _bfd_vms_push (abfd, (uquad)(op1 + op2), -1);
586
      break;
587
 
588
      /* subtract  */
589
 
590
    case ETIR_S_C_OPR_SUB:
591
      op1 = (long)_bfd_vms_pop (abfd, NULL);
592
      op2 = (long)_bfd_vms_pop (abfd, NULL);
593
      _bfd_vms_push (abfd, (uquad)(op2 - op1), -1);
594
      break;
595
 
596
      /* multiply  */
597
 
598
    case ETIR_S_C_OPR_MUL:
599
      op1 = (long)_bfd_vms_pop (abfd, NULL);
600
      op2 = (long)_bfd_vms_pop (abfd, NULL);
601
      _bfd_vms_push (abfd, (uquad)(op1 * op2), -1);
602
      break;
603
 
604
      /* divide  */
605
 
606
    case ETIR_S_C_OPR_DIV:
607
      op1 = (long)_bfd_vms_pop (abfd, NULL);
608
      op2 = (long)_bfd_vms_pop (abfd, NULL);
609
      if (op2 == 0)
610
        _bfd_vms_push (abfd, (uquad)0L, -1);
611
      else
612
        _bfd_vms_push (abfd, (uquad)(op2 / op1), -1);
613
      break;
614
 
615
      /* logical and  */
616
 
617
    case ETIR_S_C_OPR_AND:
618
      op1 = (long)_bfd_vms_pop (abfd, NULL);
619
      op2 = (long)_bfd_vms_pop (abfd, NULL);
620
      _bfd_vms_push (abfd, (uquad)(op1 & op2), -1);
621
      break;
622
 
623
      /* logical inclusive or    */
624
 
625
    case ETIR_S_C_OPR_IOR:
626
      op1 = (long)_bfd_vms_pop (abfd, NULL);
627
      op2 = (long)_bfd_vms_pop (abfd, NULL);
628
      _bfd_vms_push (abfd, (uquad)(op1 | op2), -1);
629
      break;
630
 
631
      /* logical exclusive or  */
632
 
633
    case ETIR_S_C_OPR_EOR:
634
      op1 = (long)_bfd_vms_pop (abfd, NULL);
635
      op2 = (long)_bfd_vms_pop (abfd, NULL);
636
      _bfd_vms_push (abfd, (uquad)(op1 ^ op2), -1);
637
      break;
638
 
639
      /* negate  */
640
 
641
    case ETIR_S_C_OPR_NEG:
642
      op1 = (long)_bfd_vms_pop (abfd, NULL);
643
      _bfd_vms_push (abfd, (uquad)(-op1), -1);
644
      break;
645
 
646
      /* complement  */
647
 
648
    case ETIR_S_C_OPR_COM:
649
      op1 = (long)_bfd_vms_pop (abfd, NULL);
650
      _bfd_vms_push (abfd, (uquad)(op1 ^ -1L), -1);
651
      break;
652
 
653
      /* insert field  */
654
 
655
    case ETIR_S_C_OPR_INSV:
656
      (void)_bfd_vms_pop (abfd, NULL);
657
      (*_bfd_error_handler) (_("ETIR_S_C_OPR_INSV: Not supported"));
658
      break;
659
 
660
    /* arithmetic shift  */
661
 
662
    case ETIR_S_C_OPR_ASH:
663
      op1 = (long)_bfd_vms_pop (abfd, NULL);
664
      op2 = (long)_bfd_vms_pop (abfd, NULL);
665
      if (op2 < 0)               /* shift right */
666
        op1 >>= -op2;
667
      else                      /* shift left */
668
        op1 <<= op2;
669
      _bfd_vms_push (abfd, (uquad)op1, -1);
670
      break;
671
 
672
      /* unsigned shift  */
673
 
674
    case ETIR_S_C_OPR_USH:
675
      (*_bfd_error_handler) (_("ETIR_S_C_OPR_USH: Not supported"));
676
      break;
677
 
678
      /* rotate  */
679
 
680
    case ETIR_S_C_OPR_ROT:
681
      (*_bfd_error_handler) (_("ETIR_S_C_OPR_ROT: Not supported"));
682
      break;
683
 
684
      /* select  */
685
 
686
    case ETIR_S_C_OPR_SEL:
687
      if ((long)_bfd_vms_pop (abfd, NULL) & 0x01L)
688
        (void)_bfd_vms_pop (abfd, NULL);
689
      else
690
        {
691
          op1 = (long)_bfd_vms_pop (abfd, NULL);
692
          (void)_bfd_vms_pop (abfd, NULL);
693
          _bfd_vms_push (abfd, (uquad)op1, -1);
694
        }
695
      break;
696
 
697
      /* redefine symbol to current location  */
698
 
699
    case ETIR_S_C_OPR_REDEF:
700
      (*_bfd_error_handler) (_("ETIR_S_C_OPR_REDEF: Not supported"));
701
      break;
702
 
703
      /* define a literal  */
704
 
705
    case ETIR_S_C_OPR_DFLIT:
706
      (*_bfd_error_handler) (_("ETIR_S_C_OPR_DFLIT: Not supported"));
707
      break;
708
 
709
    default:
710
      (*_bfd_error_handler) (_("Reserved OPR cmd %d"), cmd);
711
      break;
712
    }
713
 
714
  return true;
715
}
716
 
717
 
718
/* control commands
719
 
720
   see table B-11 of the openVMS linker manual  */
721
 
722
static boolean
723
etir_ctl (abfd, cmd, ptr)
724
     bfd *abfd;
725
     int cmd;
726
     unsigned char *ptr;
727
{
728
  uquad  dummy;
729
  int psect;
730
 
731
#if VMS_DEBUG
732
  _bfd_vms_debug (5, "etir_ctl %d/%x\n", cmd, cmd);
733
  _bfd_hexdump (8, ptr, 16, (int)ptr);
734
#endif
735
 
736
  switch (cmd)
737
    {
738
      /* set relocation base: pop stack, set image location counter
739
         arg: -  */
740
 
741
    case ETIR_S_C_CTL_SETRB:
742
      dummy = _bfd_vms_pop (abfd, &psect);
743
      image_set_ptr (abfd, psect, dummy);
744
      break;
745
 
746
      /* augment relocation base: increment image location counter by offset
747
         arg: lw        offset value  */
748
 
749
    case ETIR_S_C_CTL_AUGRB:
750
      dummy = bfd_getl32 (ptr);
751
      image_inc_ptr (abfd, dummy);
752
      break;
753
 
754
      /* define location: pop index, save location counter under index
755
         arg: -  */
756
 
757
    case ETIR_S_C_CTL_DFLOC:
758
      dummy = _bfd_vms_pop (abfd, NULL);
759
      /* FIXME */
760
      break;
761
 
762
      /* set location: pop index, restore location counter from index
763
         arg: -  */
764
 
765
    case ETIR_S_C_CTL_STLOC:
766
      dummy = _bfd_vms_pop (abfd, &psect);
767
      /* FIXME */
768
      break;
769
 
770
      /* stack defined location: pop index, push location counter from index
771
         arg: -  */
772
 
773
    case ETIR_S_C_CTL_STKDL:
774
      dummy = _bfd_vms_pop (abfd, &psect);
775
      /* FIXME */
776
      break;
777
 
778
    default:
779
      (*_bfd_error_handler) (_("Reserved CTL cmd %d"), cmd);
780
      break;
781
    }
782
  return true;
783
}
784
 
785
 
786
/* store conditional commands
787
 
788
   see table B-12 and B-13 of the openVMS linker manual  */
789
 
790
static boolean
791
etir_stc (abfd, cmd, ptr)
792
     bfd *abfd;
793
     int cmd;
794
     unsigned char *ptr ATTRIBUTE_UNUSED;
795
{
796
 
797
#if VMS_DEBUG
798
  _bfd_vms_debug (5, "etir_stc %d/%x\n", cmd, cmd);
799
  _bfd_hexdump (8, ptr, 16, (int)ptr);
800
#endif
801
 
802
  switch (cmd)
803
    {
804
      /* 200 Store-conditional Linkage Pair
805
         arg:  */
806
 
807
    case ETIR_S_C_STC_LP:
808
      (*_bfd_error_handler) (_("ETIR_S_C_STC_LP: not supported"));
809
      break;
810
 
811
      /* 201 Store-conditional Linkage Pair with Procedure Signature
812
         arg:   lw      linkage index
813
         cs     procedure name
814
         by     signature length
815
         da     signature  */
816
 
817
    case ETIR_S_C_STC_LP_PSB:
818
      image_inc_ptr (abfd, 16); /* skip entry,procval */
819
      break;
820
 
821
      /* 202 Store-conditional Address at global address
822
         arg:   lw      linkage index
823
         cs     global name  */
824
 
825
    case ETIR_S_C_STC_GBL:
826
      (*_bfd_error_handler) (_("ETIR_S_C_STC_GBL: not supported"));
827
      break;
828
 
829
      /* 203 Store-conditional Code Address at global address
830
         arg:   lw      linkage index
831
         cs     procedure name  */
832
 
833
    case ETIR_S_C_STC_GCA:
834
      (*_bfd_error_handler) (_("ETIR_S_C_STC_GCA: not supported"));
835
      break;
836
 
837
      /* 204 Store-conditional Address at psect + offset
838
         arg:   lw      linkage index
839
         lw     psect index
840
         qw     offset  */
841
 
842
    case ETIR_S_C_STC_PS:
843
      (*_bfd_error_handler) (_("ETIR_S_C_STC_PS: not supported"));
844
      break;
845
 
846
      /* 205 Store-conditional NOP at address of global
847
         arg:  */
848
 
849
    case ETIR_S_C_STC_NOP_GBL:
850
 
851
      /* 206 Store-conditional NOP at pect + offset
852
         arg:  */
853
 
854
    case ETIR_S_C_STC_NOP_PS:
855
 
856
      /* 207 Store-conditional BSR at global address
857
         arg:  */
858
 
859
    case ETIR_S_C_STC_BSR_GBL:
860
 
861
      /* 208 Store-conditional BSR at pect + offset
862
         arg:  */
863
 
864
    case ETIR_S_C_STC_BSR_PS:
865
 
866
      /* 209 Store-conditional LDA at global address
867
         arg:  */
868
 
869
    case ETIR_S_C_STC_LDA_GBL:
870
 
871
      /* 210 Store-conditional LDA at psect + offset
872
         arg:  */
873
 
874
    case ETIR_S_C_STC_LDA_PS:
875
 
876
      /* 211 Store-conditional BSR or Hint at global address
877
         arg:  */
878
 
879
    case ETIR_S_C_STC_BOH_GBL:
880
 
881
      /* 212 Store-conditional BSR or Hint at pect + offset
882
         arg:  */
883
 
884
    case ETIR_S_C_STC_BOH_PS:
885
 
886
      /* 213 Store-conditional NOP,BSR or HINT at global address
887
         arg:  */
888
 
889
    case ETIR_S_C_STC_NBH_GBL:
890
 
891
      /* 214 Store-conditional NOP,BSR or HINT at psect + offset
892
         arg:  */
893
 
894
    case ETIR_S_C_STC_NBH_PS:
895
/* FIXME     (*_bfd_error_handler) ("ETIR_S_C_STC_xx: (%d) not supported", cmd); */
896
      break;
897
 
898
    default:
899
#if VMS_DEBUG
900
      _bfd_vms_debug (3,  "Reserved STC cmd %d", cmd);
901
#endif
902
      break;
903
    }
904
  return true;
905
}
906
 
907
 
908
static asection *
909
new_section (abfd, idx)
910
     bfd *abfd ATTRIBUTE_UNUSED;
911
     int idx;
912
{
913
  asection *section;
914
  char sname[16];
915
  char *name;
916
 
917
#if VMS_DEBUG
918
  _bfd_vms_debug (5,  "new_section %d\n", idx);
919
#endif
920
  sprintf (sname, SECTION_NAME_TEMPLATE, idx);
921
 
922
  name = bfd_malloc (strlen (sname) + 1);
923
  if (name == 0)
924
    return 0;
925
  strcpy (name, sname);
926
 
927
  section = bfd_malloc (sizeof (asection));
928
  if (section == 0)
929
    {
930
#if VMS_DEBUG
931
      _bfd_vms_debug (6,  "bfd_make_section (%s) failed", name);
932
#endif
933
      return 0;
934
    }
935
 
936
  section->_raw_size = 0;
937
  section->vma = 0;
938
  section->contents = 0;
939
  section->_cooked_size = 0;
940
  section->name = name;
941
  section->index = idx;
942
 
943
  return section;
944
}
945
 
946
 
947
static int
948
alloc_section (abfd, idx)
949
     bfd *abfd;
950
     unsigned int idx;
951
{
952
#if VMS_DEBUG
953
  _bfd_vms_debug (4,  "alloc_section %d\n", idx);
954
#endif
955
 
956
  PRIV(sections) = ((asection **)
957
                    bfd_realloc (PRIV(sections), (idx+1) * sizeof (asection *)));
958
  if (PRIV(sections) == 0)
959
    return -1;
960
 
961
  while (PRIV(section_count) <= idx)
962
    {
963
      PRIV(sections)[PRIV(section_count)] = new_section (abfd, PRIV(section_count));
964
      if (PRIV(sections)[PRIV(section_count)] == 0)
965
        return -1;
966
      PRIV(section_count)++;
967
    }
968
 
969
  return 0;
970
}
971
 
972
 
973
/*
974
 * tir_sta
975
 *
976
 * vax stack commands
977
 *
978
 * handle sta_xxx commands in tir section
979
 * ptr points to data area in record
980
 *
981
 * see table 7-3 of the VAX/VMS linker manual
982
 */
983
 
984
static unsigned char *
985
tir_sta (bfd *abfd, unsigned char *ptr)
986
{
987
  int cmd = *ptr++;
988
 
989
#if VMS_DEBUG
990
  _bfd_vms_debug (5, "tir_sta %d\n", cmd);
991
#endif
992
 
993
  switch (cmd)
994
    {
995
  /* stack */
996
      case TIR_S_C_STA_GBL:
997
        /*
998
         * stack global
999
         * arg: cs      symbol name
1000
         *
1001
         * stack 32 bit value of symbol (high bits set to 0)
1002
         */
1003
        {
1004
          char *name;
1005
          vms_symbol_entry *entry;
1006
 
1007
          name = _bfd_vms_save_counted_string (ptr);
1008
 
1009
          entry = _bfd_vms_enter_symbol (abfd, name);
1010
          if (entry == (vms_symbol_entry *)NULL)
1011
            return 0;
1012
 
1013
          _bfd_vms_push (abfd, (unsigned long)(entry->symbol->value), -1);
1014
          ptr += *ptr + 1;
1015
        }
1016
      break;
1017
 
1018
      case TIR_S_C_STA_SB:
1019
        /*
1020
         * stack signed byte
1021
         * arg: by      value
1022
         *
1023
         * stack byte value, sign extend to 32 bit
1024
         */
1025
        _bfd_vms_push (abfd, (long)*ptr++, -1);
1026
      break;
1027
 
1028
      case TIR_S_C_STA_SW:
1029
        /*
1030
         * stack signed short word
1031
         * arg: sh      value
1032
         *
1033
         * stack 16 bit value, sign extend to 32 bit
1034
         */
1035
        _bfd_vms_push (abfd, (long)bfd_getl16(ptr), -1);
1036
        ptr += 2;
1037
      break;
1038
 
1039
      case TIR_S_C_STA_LW:
1040
        /*
1041
         * stack signed longword
1042
         * arg: lw      value
1043
         *
1044
         * stack 32 bit value
1045
         */
1046
        _bfd_vms_push (abfd, (long)bfd_getl32 (ptr), -1);
1047
        ptr += 4;
1048
      break;
1049
 
1050
      case TIR_S_C_STA_PB:
1051
      case TIR_S_C_STA_WPB:
1052
        /*
1053
         * stack psect base plus byte offset (word index)
1054
         * arg: by      section index
1055
         *      (sh     section index)
1056
         *      by      signed byte offset
1057
         *
1058
         */
1059
        {
1060
          unsigned long dummy;
1061
          unsigned int psect;
1062
 
1063
          if (cmd == TIR_S_C_STA_PB)
1064
            psect = *ptr++;
1065
          else
1066
            {
1067
              psect = bfd_getl16(ptr);
1068
              ptr += 2;
1069
            }
1070
 
1071
          if (psect >= PRIV(section_count))
1072
            {
1073
              alloc_section (abfd, psect);
1074
            }
1075
 
1076
          dummy = (long)*ptr++;
1077
          dummy += (PRIV(sections)[psect])->vma;
1078
          _bfd_vms_push (abfd, dummy, psect);
1079
        }
1080
      break;
1081
 
1082
      case TIR_S_C_STA_PW:
1083
      case TIR_S_C_STA_WPW:
1084
        /*
1085
         * stack psect base plus word offset (word index)
1086
         * arg: by      section index
1087
         *      (sh     section index)
1088
         *      sh      signed short offset
1089
         *
1090
         */
1091
        {
1092
          unsigned long dummy;
1093
          unsigned int psect;
1094
 
1095
          if (cmd == TIR_S_C_STA_PW)
1096
            psect = *ptr++;
1097
          else
1098
            {
1099
              psect = bfd_getl16(ptr);
1100
              ptr += 2;
1101
            }
1102
 
1103
          if (psect >= PRIV(section_count))
1104
            {
1105
              alloc_section (abfd, psect);
1106
            }
1107
 
1108
          dummy = bfd_getl16(ptr); ptr+=2;
1109
          dummy += (PRIV(sections)[psect])->vma;
1110
          _bfd_vms_push (abfd, dummy, psect);
1111
        }
1112
      break;
1113
 
1114
      case TIR_S_C_STA_PL:
1115
      case TIR_S_C_STA_WPL:
1116
        /*
1117
         * stack psect base plus long offset (word index)
1118
         * arg: by      section index
1119
         *      (sh     section index)
1120
         *      lw      signed longword offset
1121
         *
1122
         */
1123
        {
1124
          unsigned long dummy;
1125
          unsigned int psect;
1126
 
1127
          if (cmd == TIR_S_C_STA_PL)
1128
            psect = *ptr++;
1129
          else
1130
            {
1131
              psect = bfd_getl16(ptr);
1132
              ptr += 2;
1133
            }
1134
 
1135
          if (psect >= PRIV(section_count))
1136
            {
1137
              alloc_section (abfd, psect);
1138
            }
1139
 
1140
          dummy = bfd_getl32 (ptr); ptr += 4;
1141
          dummy += (PRIV(sections)[psect])->vma;
1142
          _bfd_vms_push (abfd, dummy, psect);
1143
        }
1144
      break;
1145
 
1146
      case TIR_S_C_STA_UB:
1147
        /*
1148
         * stack unsigned byte
1149
         * arg: by      value
1150
         *
1151
         * stack byte value
1152
         */
1153
        _bfd_vms_push (abfd, (unsigned long)*ptr++, -1);
1154
      break;
1155
 
1156
      case TIR_S_C_STA_UW:
1157
        /*
1158
         * stack unsigned short word
1159
         * arg: sh      value
1160
         *
1161
         * stack 16 bit value
1162
         */
1163
        _bfd_vms_push (abfd, (unsigned long)bfd_getl16(ptr), -1);
1164
        ptr += 2;
1165
      break;
1166
 
1167
      case TIR_S_C_STA_BFI:
1168
        /*
1169
         * stack byte from image
1170
         * arg: -
1171
         *
1172
         */
1173
        /*FALLTHRU*/
1174
      case TIR_S_C_STA_WFI:
1175
        /*
1176
         * stack byte from image
1177
         * arg: -
1178
         *
1179
         */
1180
        /*FALLTHRU*/
1181
      case TIR_S_C_STA_LFI:
1182
        /*
1183
         * stack byte from image
1184
         * arg: -
1185
         *
1186
         */
1187
        (*_bfd_error_handler) (_("Stack-from-image not implemented"));
1188
        return NULL;
1189
 
1190
      case TIR_S_C_STA_EPM:
1191
        /*
1192
         * stack entry point mask
1193
         * arg: cs      symbol name
1194
         *
1195
         * stack (unsigned) entry point mask of symbol
1196
         * err if symbol is no entry point
1197
         */
1198
        {
1199
          char *name;
1200
          vms_symbol_entry *entry;
1201
 
1202
          name = _bfd_vms_save_counted_string (ptr);
1203
          entry = _bfd_vms_enter_symbol (abfd, name);
1204
          if (entry == (vms_symbol_entry *)NULL)
1205
            return 0;
1206
 
1207
          (*_bfd_error_handler) (_("Stack-entry-mask not fully implemented"));
1208
          _bfd_vms_push (abfd, 0L, -1);
1209
          ptr += *ptr + 1;
1210
        }
1211
      break;
1212
 
1213
      case TIR_S_C_STA_CKARG:
1214
        /*
1215
         * compare procedure argument
1216
         * arg: cs      symbol name
1217
         *      by      argument index
1218
         *      da      argument descriptor
1219
         *
1220
         * compare argument descriptor with symbol argument (ARG$V_PASSMECH)
1221
         * and stack TRUE (args match) or FALSE (args dont match) value
1222
         */
1223
        (*_bfd_error_handler) (_("PASSMECH not fully implemented"));
1224
        _bfd_vms_push (abfd, 1L, -1);
1225
        break;
1226
 
1227
      case TIR_S_C_STA_LSY:
1228
        /*
1229
         * stack local symbol value
1230
         * arg: sh      environment index
1231
         *      cs      symbol name
1232
         */
1233
        {
1234
          int envidx;
1235
          char *name;
1236
          vms_symbol_entry *entry;
1237
 
1238
          envidx = bfd_getl16(ptr); ptr += 2;
1239
          name = _bfd_vms_save_counted_string (ptr);
1240
          entry = _bfd_vms_enter_symbol (abfd, name);
1241
          if (entry == (vms_symbol_entry *)NULL)
1242
            return 0;
1243
          (*_bfd_error_handler) (_("Stack-local-symbol not fully implemented"));
1244
          _bfd_vms_push (abfd, 0L, -1);
1245
          ptr += *ptr + 1;
1246
        }
1247
      break;
1248
 
1249
      case TIR_S_C_STA_LIT:
1250
        /*
1251
         * stack literal
1252
         * arg: by      literal index
1253
         *
1254
         * stack literal
1255
         */
1256
        ptr++;
1257
        _bfd_vms_push (abfd, 0L, -1);
1258
        (*_bfd_error_handler) (_("Stack-literal not fully implemented"));
1259
        break;
1260
 
1261
      case TIR_S_C_STA_LEPM:
1262
        /*
1263
         * stack local symbol entry point mask
1264
         * arg: sh      environment index
1265
         *      cs      symbol name
1266
         *
1267
         * stack (unsigned) entry point mask of symbol
1268
         * err if symbol is no entry point
1269
         */
1270
        {
1271
          int envidx;
1272
          char *name;
1273
          vms_symbol_entry *entry;
1274
 
1275
          envidx = bfd_getl16(ptr); ptr += 2;
1276
          name = _bfd_vms_save_counted_string (ptr);
1277
          entry = _bfd_vms_enter_symbol (abfd, name);
1278
          if (entry == (vms_symbol_entry *)NULL)
1279
            return 0;
1280
          (*_bfd_error_handler) (_("Stack-local-symbol-entry-point-mask not fully implemented"));
1281
          _bfd_vms_push (abfd, 0L, -1);
1282
          ptr += *ptr + 1;
1283
        }
1284
      break;
1285
 
1286
      default:
1287
        (*_bfd_error_handler) (_("Reserved STA cmd %d"), ptr[-1]);
1288
        return NULL;
1289
      break;
1290
  }
1291
 
1292
  return ptr;
1293
}
1294
 
1295
 
1296
/*
1297
 * tir_sto
1298
 *
1299
 * vax store commands
1300
 *
1301
 * handle sto_xxx commands in tir section
1302
 * ptr points to data area in record
1303
 *
1304
 * see table 7-4 of the VAX/VMS linker manual
1305
 */
1306
 
1307
static unsigned char *
1308
tir_sto (bfd *abfd, unsigned char *ptr)
1309
{
1310
  unsigned long dummy;
1311
  int size;
1312
  int psect;
1313
 
1314
#if VMS_DEBUG
1315
  _bfd_vms_debug (5, "tir_sto %d\n", *ptr);
1316
#endif
1317
 
1318
  switch (*ptr++)
1319
    {
1320
      case TIR_S_C_STO_SB:
1321
        /*
1322
         * store signed byte: pop stack, write byte
1323
         * arg: -
1324
         */
1325
        dummy = _bfd_vms_pop (abfd, &psect);
1326
        image_write_b (abfd, dummy & 0xff);     /* FIXME: check top bits */
1327
      break;
1328
 
1329
      case TIR_S_C_STO_SW:
1330
        /*
1331
         * store signed word: pop stack, write word
1332
         * arg: -
1333
         */
1334
        dummy = _bfd_vms_pop (abfd, &psect);
1335
        image_write_w (abfd, dummy & 0xffff);   /* FIXME: check top bits */
1336
      break;
1337
 
1338
      case TIR_S_C_STO_LW:
1339
        /*
1340
         * store longword: pop stack, write longword
1341
         * arg: -
1342
         */
1343
        dummy = _bfd_vms_pop (abfd, &psect);
1344
        image_write_l (abfd, dummy & 0xffffffff);/* FIXME: check top bits */
1345
      break;
1346
 
1347
      case TIR_S_C_STO_BD:
1348
        /*
1349
         * store byte displaced: pop stack, sub lc+1, write byte
1350
         * arg: -
1351
         */
1352
        dummy = _bfd_vms_pop (abfd, &psect);
1353
        dummy -= ((PRIV(sections)[psect])->vma + 1);
1354
        image_write_b (abfd, dummy & 0xff);/* FIXME: check top bits */
1355
      break;
1356
 
1357
      case TIR_S_C_STO_WD:
1358
        /*
1359
         * store word displaced: pop stack, sub lc+2, write word
1360
         * arg: -
1361
         */
1362
        dummy = _bfd_vms_pop (abfd, &psect);
1363
        dummy -= ((PRIV(sections)[psect])->vma + 2);
1364
        image_write_w (abfd, dummy & 0xffff);/* FIXME: check top bits */
1365
      break;
1366
      case TIR_S_C_STO_LD:
1367
        /*
1368
         * store long displaced: pop stack, sub lc+4, write long
1369
         * arg: -
1370
         */
1371
        dummy = _bfd_vms_pop (abfd, &psect);
1372
        dummy -= ((PRIV(sections)[psect])->vma + 4);
1373
        image_write_l (abfd, dummy & 0xffffffff);/* FIXME: check top bits */
1374
      break;
1375
      case TIR_S_C_STO_LI:
1376
        /*
1377
         * store short literal: pop stack, write byte
1378
         * arg: -
1379
         */
1380
        dummy = _bfd_vms_pop (abfd, &psect);
1381
        image_write_b (abfd, dummy & 0xff);/* FIXME: check top bits */
1382
      break;
1383
      case TIR_S_C_STO_PIDR:
1384
        /*
1385
         * store position independent data reference: pop stack, write longword
1386
         * arg: -
1387
         * FIXME: incomplete !
1388
         */
1389
        dummy = _bfd_vms_pop (abfd, &psect);
1390
        image_write_l (abfd, dummy & 0xffffffff);
1391
      break;
1392
      case TIR_S_C_STO_PICR:
1393
        /*
1394
         * store position independent code reference: pop stack, write longword
1395
         * arg: -
1396
         * FIXME: incomplete !
1397
         */
1398
        dummy = _bfd_vms_pop (abfd, &psect);
1399
        image_write_b (abfd, 0x9f);
1400
        image_write_l (abfd, dummy & 0xffffffff);
1401
      break;
1402
      case TIR_S_C_STO_RIVB:
1403
        /*
1404
         * store repeated immediate variable bytes
1405
         * 1-byte count n field followed by n bytes of data
1406
         * pop stack, write n bytes <stack> times
1407
         */
1408
        size = *ptr++;
1409
        dummy = (unsigned long)_bfd_vms_pop (abfd, NULL);
1410
        while (dummy-- > 0L)
1411
          image_dump (abfd, ptr, size, 0);
1412
        ptr += size;
1413
        break;
1414
      case TIR_S_C_STO_B:
1415
        /*
1416
         * store byte from top longword
1417
         */
1418
        dummy = (unsigned long)_bfd_vms_pop (abfd, NULL);
1419
        image_write_b (abfd, dummy & 0xff);
1420
        break;
1421
      case TIR_S_C_STO_W:
1422
        /*
1423
         * store word from top longword
1424
         */
1425
        dummy = (unsigned long)_bfd_vms_pop (abfd, NULL);
1426
        image_write_w (abfd, dummy & 0xffff);
1427
        break;
1428
      case TIR_S_C_STO_RB:
1429
        /*
1430
         * store repeated byte from top longword
1431
         */
1432
        size = (unsigned long)_bfd_vms_pop (abfd, NULL);
1433
        dummy = (unsigned long)_bfd_vms_pop (abfd, NULL);
1434
        while (size-- > 0)
1435
          image_write_b (abfd, dummy & 0xff);
1436
        break;
1437
      case TIR_S_C_STO_RW:
1438
        /*
1439
         * store repeated word from top longword
1440
         */
1441
        size = (unsigned long)_bfd_vms_pop (abfd, NULL);
1442
        dummy = (unsigned long)_bfd_vms_pop (abfd, NULL);
1443
        while (size-- > 0)
1444
          image_write_w (abfd, dummy & 0xffff);
1445
        break;
1446
 
1447
      case TIR_S_C_STO_RSB:
1448
      case TIR_S_C_STO_RSW:
1449
      case TIR_S_C_STO_RL:
1450
      case TIR_S_C_STO_VPS:
1451
      case TIR_S_C_STO_USB:
1452
      case TIR_S_C_STO_USW:
1453
      case TIR_S_C_STO_RUB:
1454
      case TIR_S_C_STO_RUW:
1455
      case TIR_S_C_STO_PIRR:
1456
        (*_bfd_error_handler) (_("Unimplemented STO cmd %d"), ptr[-1]);
1457
      break;
1458
 
1459
      default:
1460
        (*_bfd_error_handler) (_("Reserved STO cmd %d"), ptr[-1]);
1461
      break;
1462
  }
1463
 
1464
  return ptr;
1465
}
1466
 
1467
 
1468
/*
1469
 * stack operator commands
1470
 * all 32 bit signed arithmetic
1471
 * all word just like a stack calculator
1472
 * arguments are popped from stack, results are pushed on stack
1473
 *
1474
 * see table 7-5 of the VAX/VMS linker manual
1475
 */
1476
 
1477
static unsigned char *
1478
tir_opr (bfd *abfd, unsigned char *ptr)
1479
{
1480
  long op1, op2;
1481
 
1482
#if VMS_DEBUG
1483
  _bfd_vms_debug (5, "tir_opr %d\n", *ptr);
1484
#endif
1485
 
1486
  switch (*ptr++)
1487
    {
1488
  /* operation */
1489
      case TIR_S_C_OPR_NOP:
1490
        /*
1491
         * no-op
1492
         */
1493
      break;
1494
 
1495
      case TIR_S_C_OPR_ADD:
1496
        /*
1497
         * add
1498
         */
1499
        op1 = (long)_bfd_vms_pop (abfd, NULL);
1500
        op2 = (long)_bfd_vms_pop (abfd, NULL);
1501
        _bfd_vms_push (abfd, (unsigned long)(op1 + op2), -1);
1502
      break;
1503
 
1504
      case TIR_S_C_OPR_SUB:
1505
        /*
1506
         * subtract
1507
         */
1508
        op1 = (long)_bfd_vms_pop (abfd, NULL);
1509
        op2 = (long)_bfd_vms_pop (abfd, NULL);
1510
        _bfd_vms_push (abfd, (unsigned long)(op2 - op1), -1);
1511
      break;
1512
 
1513
      case TIR_S_C_OPR_MUL:
1514
        /*
1515
         * multiply
1516
         */
1517
        op1 = (long)_bfd_vms_pop (abfd, NULL);
1518
        op2 = (long)_bfd_vms_pop (abfd, NULL);
1519
        _bfd_vms_push (abfd, (unsigned long)(op1 * op2), -1);
1520
      break;
1521
 
1522
      case TIR_S_C_OPR_DIV:
1523
        /*
1524
         * divide
1525
         */
1526
        op1 = (long)_bfd_vms_pop (abfd, NULL);
1527
        op2 = (long)_bfd_vms_pop (abfd, NULL);
1528
        if (op2 == 0)
1529
          _bfd_vms_push (abfd, (unsigned long)0L, -1);
1530
        else
1531
          _bfd_vms_push (abfd, (unsigned long)(op2 / op1), -1);
1532
      break;
1533
 
1534
      case TIR_S_C_OPR_AND:
1535
        /*
1536
         * logical and
1537
         */
1538
        op1 = (long)_bfd_vms_pop (abfd, NULL);
1539
        op2 = (long)_bfd_vms_pop (abfd, NULL);
1540
        _bfd_vms_push (abfd, (unsigned long)(op1 & op2), -1);
1541
      break;
1542
 
1543
      case TIR_S_C_OPR_IOR:
1544
        op1 = (long)_bfd_vms_pop (abfd, NULL);
1545
        /*
1546
         * logical inclusive or
1547
         */
1548
        op2 = (long)_bfd_vms_pop (abfd, NULL);
1549
        _bfd_vms_push (abfd, (unsigned long)(op1 | op2), -1);
1550
      break;
1551
 
1552
      case TIR_S_C_OPR_EOR:
1553
        /*
1554
         * logical exclusive or
1555
         */
1556
        op1 = (long)_bfd_vms_pop (abfd, NULL);
1557
        op2 = (long)_bfd_vms_pop (abfd, NULL);
1558
        _bfd_vms_push (abfd, (unsigned long)(op1 ^ op2), -1);
1559
      break;
1560
 
1561
      case TIR_S_C_OPR_NEG:
1562
        /*
1563
         * negate
1564
         */
1565
        op1 = (long)_bfd_vms_pop (abfd, NULL);
1566
        _bfd_vms_push (abfd, (unsigned long)(-op1), -1);
1567
      break;
1568
 
1569
      case TIR_S_C_OPR_COM:
1570
        /*
1571
         * complement
1572
         */
1573
        op1 = (long)_bfd_vms_pop (abfd, NULL);
1574
        _bfd_vms_push (abfd, (unsigned long)(op1 ^ -1L), -1);
1575
      break;
1576
 
1577
      case TIR_S_C_OPR_INSV:
1578
        /*
1579
         * insert field
1580
         */
1581
        (void)_bfd_vms_pop (abfd, NULL);
1582
        (*_bfd_error_handler)  ("TIR_S_C_OPR_INSV incomplete");
1583
      break;
1584
 
1585
      case TIR_S_C_OPR_ASH:
1586
        /*
1587
         * arithmetic shift
1588
         */
1589
        op1 = (long)_bfd_vms_pop (abfd, NULL);
1590
        op2 = (long)_bfd_vms_pop (abfd, NULL);
1591
        if (HIGHBIT(op1))               /* shift right */
1592
          op2 >>= op1;
1593
        else                    /* shift left */
1594
          op2 <<= op1;
1595
        _bfd_vms_push (abfd, (unsigned long)op2, -1);
1596
        (*_bfd_error_handler) (_("TIR_S_C_OPR_ASH incomplete"));
1597
      break;
1598
 
1599
      case TIR_S_C_OPR_USH:
1600
        /*
1601
         * unsigned shift
1602
         */
1603
        op1 = (long)_bfd_vms_pop (abfd, NULL);
1604
        op2 = (long)_bfd_vms_pop (abfd, NULL);
1605
        if (HIGHBIT(op1))               /* shift right */
1606
          op2 >>= op1;
1607
        else                    /* shift left */
1608
          op2 <<= op1;
1609
        _bfd_vms_push (abfd, (unsigned long)op2, -1);
1610
        (*_bfd_error_handler) (_("TIR_S_C_OPR_USH incomplete"));
1611
      break;
1612
 
1613
      case TIR_S_C_OPR_ROT:
1614
        /*
1615
         * rotate
1616
         */
1617
        op1 = (long)_bfd_vms_pop (abfd, NULL);
1618
        op2 = (long)_bfd_vms_pop (abfd, NULL);
1619
        if (HIGHBIT(0))          /* shift right */
1620
          op2 >>= op1;
1621
        else                    /* shift left */
1622
          op2 <<= op1;
1623
        _bfd_vms_push (abfd, (unsigned long)op2, -1);
1624
        (*_bfd_error_handler) (_("TIR_S_C_OPR_ROT incomplete"));
1625
      break;
1626
 
1627
      case TIR_S_C_OPR_SEL:
1628
        /*
1629
         * select
1630
         */
1631
        if ((long)_bfd_vms_pop (abfd, NULL) & 0x01L)
1632
          (void)_bfd_vms_pop (abfd, NULL);
1633
        else
1634
          {
1635
            op1 = (long)_bfd_vms_pop (abfd, NULL);
1636
            (void)_bfd_vms_pop (abfd, NULL);
1637
            _bfd_vms_push (abfd, (unsigned long)op1, -1);
1638
          }
1639
      break;
1640
 
1641
      case TIR_S_C_OPR_REDEF:
1642
        /*
1643
         * redefine symbol to current location
1644
         */
1645
        (*_bfd_error_handler) (_("TIR_S_C_OPR_REDEF not supported"));
1646
      break;
1647
 
1648
      case TIR_S_C_OPR_DFLIT:
1649
        /*
1650
         * define a literal
1651
         */
1652
        (*_bfd_error_handler) (_("TIR_S_C_OPR_DFLIT not supported"));
1653
      break;
1654
 
1655
      default:
1656
        (*_bfd_error_handler) (_("Reserved OPR cmd %d"), ptr[-1]);
1657
      break;
1658
    }
1659
 
1660
  return ptr;
1661
}
1662
 
1663
 
1664
static unsigned char *
1665
tir_ctl (bfd *abfd, unsigned char *ptr)
1666
/*
1667
 * control commands
1668
 *
1669
 * see table 7-6 of the VAX/VMS linker manual
1670
 */
1671
{
1672
  unsigned long dummy;
1673
  unsigned int psect;
1674
 
1675
#if VMS_DEBUG
1676
  _bfd_vms_debug (5, "tir_ctl %d\n", *ptr);
1677
#endif
1678
 
1679
  switch (*ptr++)
1680
    {
1681
      case TIR_S_C_CTL_SETRB:
1682
        /*
1683
         * set relocation base: pop stack, set image location counter
1684
         * arg: -
1685
         */
1686
        dummy = _bfd_vms_pop (abfd, &psect);
1687
        if (psect >= PRIV(section_count))
1688
          {
1689
            alloc_section (abfd, psect);
1690
          }
1691
        image_set_ptr (abfd, psect, dummy);
1692
      break;
1693
      case TIR_S_C_CTL_AUGRB:
1694
        /*
1695
         * augment relocation base: increment image location counter by offset
1696
         * arg: lw      offset value
1697
         */
1698
        dummy = bfd_getl32 (ptr);
1699
        image_inc_ptr (abfd, dummy);
1700
      break;
1701
      case TIR_S_C_CTL_DFLOC:
1702
        /*
1703
         * define location: pop index, save location counter under index
1704
         * arg: -
1705
         */
1706
        dummy = _bfd_vms_pop (abfd, NULL);
1707
        (*_bfd_error_handler) (_("TIR_S_C_CTL_DFLOC not fully implemented"));
1708
      break;
1709
      case TIR_S_C_CTL_STLOC:
1710
        /*
1711
         * set location: pop index, restore location counter from index
1712
         * arg: -
1713
         */
1714
        dummy = _bfd_vms_pop (abfd, &psect);
1715
        (*_bfd_error_handler) (_("TIR_S_C_CTL_STLOC not fully implemented"));
1716
      break;
1717
    case TIR_S_C_CTL_STKDL:
1718
        /*
1719
         * stack defined location: pop index, push location counter from index
1720
         * arg: -
1721
         */
1722
        dummy = _bfd_vms_pop (abfd, &psect);
1723
        (*_bfd_error_handler) (_("TIR_S_C_CTL_STKDL not fully implemented"));
1724
      break;
1725
    default:
1726
        (*_bfd_error_handler) (_("Reserved CTL cmd %d"), ptr[-1]);
1727
        break;
1728
  }
1729
  return ptr;
1730
}
1731
 
1732
 
1733
/*
1734
 * handle command from TIR section
1735
 */
1736
 
1737
static unsigned char *
1738
tir_cmd (bfd *abfd, unsigned char *ptr)
1739
{
1740
  struct {
1741
    int mincod;
1742
    int maxcod;
1743
    unsigned char * (*explain)(bfd *, unsigned char *);
1744
  } tir_table[] = {
1745
    { 0,          TIR_S_C_MAXSTACOD, tir_sta }
1746
   ,{ TIR_S_C_MINSTOCOD, TIR_S_C_MAXSTOCOD, tir_sto }
1747
   ,{ TIR_S_C_MINOPRCOD, TIR_S_C_MAXOPRCOD, tir_opr }
1748
   ,{ TIR_S_C_MINCTLCOD, TIR_S_C_MAXCTLCOD, tir_ctl }
1749
   ,{ -1, -1, NULL }
1750
  };
1751
  int i = 0;
1752
 
1753
#if VMS_DEBUG
1754
  _bfd_vms_debug (4, "tir_cmd %d/%x\n", *ptr, *ptr);
1755
  _bfd_hexdump (8, ptr, 16, (int)ptr);
1756
#endif
1757
 
1758
  if (*ptr & 0x80)                              /* store immediate */
1759
    {
1760
      i = 128 - (*ptr++ & 0x7f);
1761
      image_dump (abfd, ptr, i, 0);
1762
      ptr += i;
1763
    }
1764
  else
1765
    {
1766
      while (tir_table[i].mincod >= 0)
1767
        {
1768
          if ( (tir_table[i].mincod <= *ptr)
1769
            && (*ptr <= tir_table[i].maxcod))
1770
            {
1771
              ptr = tir_table[i].explain (abfd, ptr);
1772
              break;
1773
            }
1774
          i++;
1775
        }
1776
      if (tir_table[i].mincod < 0)
1777
        {
1778
          (*_bfd_error_handler) (_("Obj code %d not found"), *ptr);
1779
          ptr = 0;
1780
        }
1781
    }
1782
 
1783
  return ptr;
1784
}
1785
 
1786
 
1787
/* handle command from ETIR section  */
1788
 
1789
static int
1790
etir_cmd (abfd, cmd, ptr)
1791
     bfd *abfd;
1792
     int cmd;
1793
     unsigned char *ptr;
1794
{
1795
  static struct {
1796
    int mincod;
1797
    int maxcod;
1798
    boolean (*explain) PARAMS((bfd *, int, unsigned char *));
1799
  } etir_table[] = {
1800
    { ETIR_S_C_MINSTACOD, ETIR_S_C_MAXSTACOD, etir_sta },
1801
    { ETIR_S_C_MINSTOCOD, ETIR_S_C_MAXSTOCOD, etir_sto },
1802
    { ETIR_S_C_MINOPRCOD, ETIR_S_C_MAXOPRCOD, etir_opr },
1803
    { ETIR_S_C_MINCTLCOD, ETIR_S_C_MAXCTLCOD, etir_ctl },
1804
    { ETIR_S_C_MINSTCCOD, ETIR_S_C_MAXSTCCOD, etir_stc },
1805
    { -1, -1, NULL }
1806
  };
1807
 
1808
  int i = 0;
1809
 
1810
#if VMS_DEBUG
1811
  _bfd_vms_debug (4, "etir_cmd %d/%x\n", cmd, cmd);
1812
  _bfd_hexdump (8, ptr, 16, (int)ptr);
1813
#endif
1814
 
1815
  while (etir_table[i].mincod >= 0)
1816
    {
1817
      if ( (etir_table[i].mincod <= cmd)
1818
        && (cmd <= etir_table[i].maxcod))
1819
        {
1820
          if (!etir_table[i].explain (abfd, cmd, ptr))
1821
            return -1;
1822
          break;
1823
        }
1824
      i++;
1825
    }
1826
 
1827
#if VMS_DEBUG
1828
  _bfd_vms_debug (4, "etir_cmd: = 0\n");
1829
#endif
1830
  return 0;
1831
}
1832
 
1833
 
1834
/* Text Information and Relocation Records (OBJ$C_TIR)
1835
   handle tir record  */
1836
 
1837
static int
1838
analyze_tir (abfd, ptr, length)
1839
     bfd *abfd;
1840
     unsigned char *ptr;
1841
     unsigned int length;
1842
{
1843
  unsigned char *maxptr;
1844
 
1845
#if VMS_DEBUG
1846
  _bfd_vms_debug (3, "analyze_tir: %d bytes\n", length);
1847
#endif
1848
 
1849
  maxptr = ptr + length;
1850
 
1851
  while (ptr < maxptr)
1852
    {
1853
      ptr = tir_cmd (abfd, ptr);
1854
      if (ptr == 0)
1855
        return -1;
1856
    }
1857
 
1858
  return 0;
1859
}
1860
 
1861
 
1862
/* Text Information and Relocation Records (EOBJ$C_ETIR)
1863
   handle etir record  */
1864
 
1865
static int
1866
analyze_etir (abfd, ptr, length)
1867
     bfd *abfd;
1868
     unsigned char *ptr;
1869
     unsigned int length;
1870
{
1871
  int cmd;
1872
  unsigned char *maxptr;
1873
  int result = 0;
1874
 
1875
#if VMS_DEBUG
1876
  _bfd_vms_debug (3, "analyze_etir: %d bytes\n", length);
1877
#endif
1878
 
1879
  maxptr = ptr + length;
1880
 
1881
  while (ptr < maxptr)
1882
    {
1883
      cmd = bfd_getl16 (ptr);
1884
      length = bfd_getl16 (ptr + 2);
1885
      result = etir_cmd (abfd, cmd, ptr+4);
1886
      if (result != 0)
1887
        break;
1888
      ptr += length;
1889
    }
1890
 
1891
#if VMS_DEBUG
1892
  _bfd_vms_debug (3, "analyze_etir: = %d\n", result);
1893
#endif
1894
 
1895
  return result;
1896
}
1897
 
1898
 
1899
/* process ETIR record
1900
 
1901
   return 0 on success, -1 on error  */
1902
 
1903
int
1904
_bfd_vms_slurp_tir (abfd, objtype)
1905
     bfd *abfd;
1906
     int objtype;
1907
{
1908
  int result;
1909
 
1910
#if VMS_DEBUG
1911
  _bfd_vms_debug (2, "TIR/ETIR\n");
1912
#endif
1913
 
1914
  switch (objtype)
1915
    {
1916
      case EOBJ_S_C_ETIR:
1917
        PRIV(vms_rec) += 4;     /* skip type, size */
1918
        PRIV(rec_size) -= 4;
1919
        result = analyze_etir (abfd, PRIV(vms_rec), PRIV(rec_size));
1920
        break;
1921
      case OBJ_S_C_TIR:
1922
        PRIV(vms_rec) += 1;     /* skip type */
1923
        PRIV(rec_size) -= 1;
1924
        result = analyze_tir (abfd, PRIV(vms_rec), PRIV(rec_size));
1925
        break;
1926
      default:
1927
        result = -1;
1928
        break;
1929
    }
1930
 
1931
  return result;
1932
}
1933
 
1934
 
1935
/* process EDBG record
1936
   return 0 on success, -1 on error
1937
 
1938
   not implemented yet  */
1939
 
1940
int
1941
_bfd_vms_slurp_dbg (abfd, objtype)
1942
     bfd *abfd;
1943
     int objtype ATTRIBUTE_UNUSED;
1944
{
1945
#if VMS_DEBUG
1946
  _bfd_vms_debug (2, "DBG/EDBG\n");
1947
#endif
1948
 
1949
  abfd->flags |= (HAS_DEBUG | HAS_LINENO);
1950
  return 0;
1951
}
1952
 
1953
 
1954
/* process ETBT record
1955
   return 0 on success, -1 on error
1956
 
1957
   not implemented yet  */
1958
 
1959
int
1960
_bfd_vms_slurp_tbt (abfd, objtype)
1961
     bfd *abfd ATTRIBUTE_UNUSED;
1962
     int objtype ATTRIBUTE_UNUSED;
1963
{
1964
#if VMS_DEBUG
1965
  _bfd_vms_debug (2, "TBT/ETBT\n");
1966
#endif
1967
 
1968
  return 0;
1969
}
1970
 
1971
 
1972
/* process LNK record
1973
   return 0 on success, -1 on error
1974
 
1975
   not implemented yet  */
1976
 
1977
int
1978
_bfd_vms_slurp_lnk (abfd, objtype)
1979
     bfd *abfd ATTRIBUTE_UNUSED;
1980
     int objtype ATTRIBUTE_UNUSED;
1981
{
1982
#if VMS_DEBUG
1983
  _bfd_vms_debug (2, "LNK\n");
1984
#endif
1985
 
1986
  return 0;
1987
}
1988
 
1989
/*----------------------------------------------------------------------*/
1990
/*                                                                      */
1991
/*      WRITE ETIR SECTION                                              */
1992
/*                                                                      */
1993
/*      this is still under construction and therefore not documented   */
1994
/*                                                                      */
1995
/*----------------------------------------------------------------------*/
1996
 
1997
static void start_etir_record PARAMS ((bfd *abfd, int index, uquad offset, boolean justoffset));
1998
static void sto_imm PARAMS ((bfd *abfd, vms_section *sptr, bfd_vma vaddr, int index));
1999
static void end_etir_record PARAMS ((bfd *abfd));
2000
 
2001
static void
2002
sto_imm (abfd, sptr, vaddr, index)
2003
     bfd *abfd;
2004
     vms_section *sptr;
2005
     bfd_vma vaddr;
2006
     int index;
2007
{
2008
  int size;
2009
  int ssize;
2010
  unsigned char *cptr;
2011
 
2012
#if VMS_DEBUG
2013
  _bfd_vms_debug (8, "sto_imm %d bytes\n", sptr->size);
2014
  _bfd_hexdump (9, sptr->contents, (int)sptr->size, (int)vaddr);
2015
#endif
2016
 
2017
  ssize = sptr->size;
2018
  cptr = sptr->contents;
2019
 
2020
  while (ssize > 0)
2021
    {
2022
 
2023
      size = ssize;                             /* try all the rest */
2024
 
2025
      if (_bfd_vms_output_check (abfd, size) < 0)
2026
        {                                       /* doesn't fit, split ! */
2027
          end_etir_record (abfd);
2028
          start_etir_record (abfd, index, vaddr, false);
2029
          size = _bfd_vms_output_check (abfd, 0);        /* get max size */
2030
          if (size > ssize)                     /* more than what's left ? */
2031
            size = ssize;
2032
        }
2033
 
2034
      _bfd_vms_output_begin (abfd, ETIR_S_C_STO_IMM, -1);
2035
      _bfd_vms_output_long (abfd, (unsigned long)(size));
2036
      _bfd_vms_output_dump (abfd, cptr, size);
2037
      _bfd_vms_output_flush (abfd);
2038
 
2039
#if VMS_DEBUG
2040
      _bfd_vms_debug (10, "dumped %d bytes\n", size);
2041
      _bfd_hexdump (10, cptr, (int)size, (int)vaddr);
2042
#endif
2043
 
2044
      vaddr += size;
2045
      ssize -= size;
2046
      cptr += size;
2047
    }
2048
 
2049
  return;
2050
}
2051
 
2052
/*-------------------------------------------------------------------*/
2053
 
2054
/* start ETIR record for section #index at virtual addr offset.  */
2055
 
2056
static void
2057
start_etir_record (abfd, index, offset, justoffset)
2058
    bfd *abfd;
2059
    int index;
2060
    uquad offset;
2061
    boolean justoffset;
2062
{
2063
  if (!justoffset)
2064
    {
2065
      _bfd_vms_output_begin (abfd, EOBJ_S_C_ETIR, -1);  /* one ETIR per section */
2066
      _bfd_vms_output_push (abfd);
2067
    }
2068
 
2069
  _bfd_vms_output_begin (abfd, ETIR_S_C_STA_PQ, -1);    /* push start offset */
2070
  _bfd_vms_output_long (abfd, (unsigned long)index);
2071
  _bfd_vms_output_quad (abfd, (uquad)offset);
2072
  _bfd_vms_output_flush (abfd);
2073
 
2074
  _bfd_vms_output_begin (abfd, ETIR_S_C_CTL_SETRB, -1); /* start = pop () */
2075
  _bfd_vms_output_flush (abfd);
2076
 
2077
  return;
2078
}
2079
 
2080
 
2081
/* end etir record  */
2082
static void
2083
end_etir_record (abfd)
2084
    bfd *abfd;
2085
{
2086
  _bfd_vms_output_pop (abfd);
2087
  _bfd_vms_output_end (abfd);
2088
}
2089
 
2090
/* write section contents for bfd abfd  */
2091
 
2092
int
2093
_bfd_vms_write_tir (abfd, objtype)
2094
     bfd *abfd;
2095
     int objtype ATTRIBUTE_UNUSED;
2096
{
2097
  asection *section;
2098
  vms_section *sptr;
2099
  int nextoffset;
2100
 
2101
#if VMS_DEBUG
2102
  _bfd_vms_debug (2, "vms_write_tir (%p, %d)\n", abfd, objtype);
2103
#endif
2104
 
2105
  _bfd_vms_output_alignment (abfd, 4);
2106
 
2107
  nextoffset = 0;
2108
  PRIV(vms_linkage_index) = 1;
2109
 
2110
  /* dump all other sections  */
2111
 
2112
  section = abfd->sections;
2113
 
2114
  while (section != NULL)
2115
    {
2116
 
2117
#if VMS_DEBUG
2118
      _bfd_vms_debug (4, "writing %d. section '%s' (%d bytes)\n", section->index, section->name, (int)(section->_raw_size));
2119
#endif
2120
 
2121
      if (section->flags & SEC_RELOC)
2122
        {
2123
          int i;
2124
 
2125
          if ((i = section->reloc_count) <= 0)
2126
            {
2127
              (*_bfd_error_handler) (_("SEC_RELOC with no relocs in section %s"),
2128
                                     section->name);
2129
            }
2130
#if VMS_DEBUG
2131
          else
2132
            {
2133
              arelent **rptr;
2134
              _bfd_vms_debug (4, "%d relocations:\n", i);
2135
              rptr = section->orelocation;
2136
              while (i-- > 0)
2137
                {
2138
                  _bfd_vms_debug (4, "sym %s in sec %s, value %08lx, addr %08lx, off %08lx, len %d: %s\n",
2139
                              (*(*rptr)->sym_ptr_ptr)->name,
2140
                              (*(*rptr)->sym_ptr_ptr)->section->name,
2141
                              (long)(*(*rptr)->sym_ptr_ptr)->value,
2142
                              (*rptr)->address, (*rptr)->addend,
2143
                              bfd_get_reloc_size((*rptr)->howto),
2144
                              (*rptr)->howto->name);
2145
                  rptr++;
2146
                }
2147
            }
2148
#endif
2149
        }
2150
 
2151
      if ((section->flags & SEC_HAS_CONTENTS)
2152
        && (! bfd_is_com_section (section)))
2153
        {
2154
          bfd_vma vaddr;                /* virtual addr in section */
2155
 
2156
          sptr = _bfd_get_vms_section (abfd, section->index);
2157
          if (sptr == NULL)
2158
            {
2159
              bfd_set_error (bfd_error_no_contents);
2160
              return -1;
2161
            }
2162
 
2163
          vaddr = (bfd_vma)(sptr->offset);
2164
 
2165
          start_etir_record (abfd, section->index, (uquad) sptr->offset,
2166
                             false);
2167
 
2168
          while (sptr != NULL)                          /* one STA_PQ, CTL_SETRB per vms_section */
2169
            {
2170
 
2171
              if (section->flags & SEC_RELOC)                   /* check for relocs */
2172
                {
2173
                  arelent **rptr = section->orelocation;
2174
                  int i = section->reloc_count;
2175
                  for (;;)
2176
                    {
2177
                      bfd_size_type addr = (*rptr)->address;
2178
                      bfd_size_type len = bfd_get_reloc_size ((*rptr)->howto);
2179
                      if (sptr->offset < addr)          /* sptr starts before reloc */
2180
                        {
2181
                          bfd_size_type before = addr - sptr->offset;
2182
                          if (sptr->size <= before)             /* complete before */
2183
                            {
2184
                              sto_imm (abfd, sptr, vaddr, section->index);
2185
                              vaddr += sptr->size;
2186
                              break;
2187
                            }
2188
                          else                          /* partly before */
2189
                            {
2190
                              int after = sptr->size - before;
2191
                              sptr->size = before;
2192
                              sto_imm (abfd, sptr, vaddr, section->index);
2193
                              vaddr += sptr->size;
2194
                              sptr->contents += before;
2195
                              sptr->offset += before;
2196
                              sptr->size = after;
2197
                            }
2198
                        }
2199
                      else if (sptr->offset == addr)    /* sptr starts at reloc */
2200
                        {
2201
                          asymbol *sym = *(*rptr)->sym_ptr_ptr;
2202
                          asection *sec = sym->section;
2203
 
2204
                          switch ((*rptr)->howto->type)
2205
                            {
2206
                            case ALPHA_R_IGNORE:
2207
                              break;
2208
 
2209
                            case ALPHA_R_REFLONG:
2210
                              {
2211
                                if (bfd_is_und_section (sym->section))
2212
                                  {
2213
                                    if (_bfd_vms_output_check (abfd,
2214
                                                                strlen((char *)sym->name))
2215
                                        < 0)
2216
                                      {
2217
                                        end_etir_record (abfd);
2218
                                        start_etir_record (abfd,
2219
                                                           section->index,
2220
                                                           vaddr, false);
2221
                                      }
2222
                                    _bfd_vms_output_begin (abfd,
2223
                                                            ETIR_S_C_STO_GBL_LW,
2224
                                                            -1);
2225
                                    _bfd_vms_output_counted (abfd,
2226
                                                              _bfd_vms_length_hash_symbol (abfd, sym->name, EOBJ_S_C_SYMSIZ));
2227
                                    _bfd_vms_output_flush (abfd);
2228
                                  }
2229
                                else if (bfd_is_abs_section (sym->section))
2230
                                  {
2231
                                    if (_bfd_vms_output_check (abfd, 16) < 0)
2232
                                      {
2233
                                        end_etir_record (abfd);
2234
                                        start_etir_record (abfd,
2235
                                                           section->index,
2236
                                                           vaddr, false);
2237
                                      }
2238
                                    _bfd_vms_output_begin (abfd,
2239
                                                            ETIR_S_C_STA_LW,
2240
                                                            -1);
2241
                                    _bfd_vms_output_quad (abfd,
2242
                                                           (uquad)sym->value);
2243
                                    _bfd_vms_output_flush (abfd);
2244
                                    _bfd_vms_output_begin (abfd,
2245
                                                            ETIR_S_C_STO_LW,
2246
                                                            -1);
2247
                                    _bfd_vms_output_flush (abfd);
2248
                                  }
2249
                                else
2250
                                  {
2251
                                    if (_bfd_vms_output_check (abfd, 32) < 0)
2252
                                      {
2253
                                        end_etir_record (abfd);
2254
                                        start_etir_record (abfd,
2255
                                                           section->index,
2256
                                                           vaddr, false);
2257
                                      }
2258
                                    _bfd_vms_output_begin (abfd,
2259
                                                            ETIR_S_C_STA_PQ,
2260
                                                            -1);
2261
                                    _bfd_vms_output_long (abfd,
2262
                                                           (unsigned long)(sec->index));
2263
                                    _bfd_vms_output_quad (abfd,
2264
                                                           ((uquad)(*rptr)->addend
2265
                                                            + (uquad)sym->value));
2266
                                    _bfd_vms_output_flush (abfd);
2267
                                    _bfd_vms_output_begin (abfd,
2268
                                                            ETIR_S_C_STO_LW,
2269
                                                            -1);
2270
                                    _bfd_vms_output_flush (abfd);
2271
                                  }
2272
                              }
2273
                              break;
2274
 
2275
                            case ALPHA_R_REFQUAD:
2276
                              {
2277
                                if (bfd_is_und_section (sym->section))
2278
                                  {
2279
                                    if (_bfd_vms_output_check (abfd,
2280
                                                                strlen((char *)sym->name))
2281
                                        < 0)
2282
                                      {
2283
                                        end_etir_record (abfd);
2284
                                        start_etir_record (abfd,
2285
                                                           section->index,
2286
                                                           vaddr, false);
2287
                                      }
2288
                                    _bfd_vms_output_begin (abfd,
2289
                                                            ETIR_S_C_STO_GBL,
2290
                                                            -1);
2291
                                    _bfd_vms_output_counted (abfd,
2292
                                                              _bfd_vms_length_hash_symbol (abfd, sym->name, EOBJ_S_C_SYMSIZ));
2293
                                    _bfd_vms_output_flush (abfd);
2294
                                  }
2295
                                else if (bfd_is_abs_section (sym->section))
2296
                                  {
2297
                                    if (_bfd_vms_output_check (abfd, 16) < 0)
2298
                                      {
2299
                                        end_etir_record (abfd);
2300
                                        start_etir_record (abfd,
2301
                                                           section->index,
2302
                                                           vaddr, false);
2303
                                      }
2304
                                    _bfd_vms_output_begin (abfd,
2305
                                                            ETIR_S_C_STA_QW,
2306
                                                            -1);
2307
                                    _bfd_vms_output_quad (abfd,
2308
                                                           (uquad)sym->value);
2309
                                    _bfd_vms_output_flush (abfd);
2310
                                    _bfd_vms_output_begin (abfd,
2311
                                                            ETIR_S_C_STO_QW,
2312
                                                            -1);
2313
                                    _bfd_vms_output_flush (abfd);
2314
                                  }
2315
                                else
2316
                                  {
2317
                                    if (_bfd_vms_output_check (abfd, 32) < 0)
2318
                                      {
2319
                                        end_etir_record (abfd);
2320
                                        start_etir_record (abfd,
2321
                                                           section->index,
2322
                                                           vaddr, false);
2323
                                      }
2324
                                    _bfd_vms_output_begin (abfd,
2325
                                                            ETIR_S_C_STA_PQ,
2326
                                                            -1);
2327
                                    _bfd_vms_output_long (abfd,
2328
                                                           (unsigned long)(sec->index));
2329
                                    _bfd_vms_output_quad (abfd,
2330
                                                           ((uquad)(*rptr)->addend
2331
                                                            + (uquad)sym->value));
2332
                                    _bfd_vms_output_flush (abfd);
2333
                                    _bfd_vms_output_begin (abfd,
2334
                                                            ETIR_S_C_STO_OFF,
2335
                                                            -1);
2336
                                    _bfd_vms_output_flush (abfd);
2337
                                  }
2338
                              }
2339
                              break;
2340
 
2341
                            case ALPHA_R_HINT:
2342
                              {
2343
                                int hint_size;
2344
 
2345
                                hint_size = sptr->size;
2346
                                sptr->size = len;
2347
                                sto_imm (abfd, sptr, vaddr, section->index);
2348
                                sptr->size = hint_size;
2349
#if 0
2350
                                vms_output_begin(abfd, ETIR_S_C_STO_HINT_GBL, -1);
2351
                                vms_output_long(abfd, (unsigned long)(sec->index));
2352
                                vms_output_quad(abfd, (uquad)addr);
2353
 
2354
                                vms_output_counted(abfd, _bfd_vms_length_hash_symbol (abfd, sym->name, EOBJ_S_C_SYMSIZ));
2355
                                vms_output_flush(abfd);
2356
#endif
2357
                              }
2358
                              break;
2359
                            case ALPHA_R_LINKAGE:
2360
                              {
2361
                                if (_bfd_vms_output_check (abfd, 64) < 0)
2362
                                  {
2363
                                    end_etir_record (abfd);
2364
                                    start_etir_record (abfd, section->index,
2365
                                                       vaddr, false);
2366
                                  }
2367
                                _bfd_vms_output_begin (abfd,
2368
                                                        ETIR_S_C_STC_LP_PSB,
2369
                                                        -1);
2370
                                _bfd_vms_output_long (abfd,
2371
                                                       (unsigned long)PRIV(vms_linkage_index));
2372
                                PRIV(vms_linkage_index) += 2;
2373
                                _bfd_vms_output_counted (abfd,
2374
                                                          _bfd_vms_length_hash_symbol (abfd, sym->name, EOBJ_S_C_SYMSIZ));
2375
                                _bfd_vms_output_byte (abfd, 0);
2376
                                _bfd_vms_output_flush (abfd);
2377
                              }
2378
                              break;
2379
 
2380
                            case ALPHA_R_CODEADDR:
2381
                              {
2382
                                if (_bfd_vms_output_check (abfd,
2383
                                                            strlen((char *)sym->name))
2384
                                    < 0)
2385
                                  {
2386
                                    end_etir_record (abfd);
2387
                                    start_etir_record (abfd,
2388
                                                       section->index,
2389
                                                       vaddr, false);
2390
                                  }
2391
                                _bfd_vms_output_begin (abfd,
2392
                                                        ETIR_S_C_STO_CA,
2393
                                                        -1);
2394
                                _bfd_vms_output_counted (abfd,
2395
                                                          _bfd_vms_length_hash_symbol (abfd, sym->name, EOBJ_S_C_SYMSIZ));
2396
                                _bfd_vms_output_flush (abfd);
2397
                              }
2398
                              break;
2399
 
2400
                            default:
2401
                              (*_bfd_error_handler) (_("Unhandled relocation %s"),
2402
                                                     (*rptr)->howto->name);
2403
                              break;
2404
                            }
2405
 
2406
                          vaddr += len;
2407
 
2408
                          if (len == sptr->size)
2409
                            {
2410
                              break;
2411
                            }
2412
                          else
2413
                            {
2414
                              sptr->contents += len;
2415
                              sptr->offset += len;
2416
                              sptr->size -= len;
2417
                              i--;
2418
                              rptr++;
2419
                            }
2420
                        }
2421
                      else                                      /* sptr starts after reloc */
2422
                        {
2423
                          i--;                          /* check next reloc */
2424
                          rptr++;
2425
                        }
2426
 
2427
                      if (i==0)                          /* all reloc checked */
2428
                        {
2429
                          if (sptr->size > 0)
2430
                            {
2431
                              sto_imm (abfd, sptr, vaddr, section->index);      /* dump rest */
2432
                              vaddr += sptr->size;
2433
                            }
2434
                          break;
2435
                        }
2436
                    } /* for (;;) */
2437
                } /* if SEC_RELOC */
2438
              else                                              /* no relocs, just dump */
2439
                {
2440
                  sto_imm (abfd, sptr, vaddr, section->index);
2441
                  vaddr += sptr->size;
2442
                }
2443
 
2444
              sptr = sptr->next;
2445
 
2446
            } /* while (sptr != 0) */
2447
 
2448
          end_etir_record (abfd);
2449
 
2450
        } /* has_contents */
2451
 
2452
      section = section->next;
2453
    }
2454
 
2455
  _bfd_vms_output_alignment(abfd, 2);
2456
  return 0;
2457
}
2458
 
2459
 
2460
/* write traceback data for bfd abfd  */
2461
 
2462
int
2463
_bfd_vms_write_tbt (abfd, objtype)
2464
     bfd *abfd ATTRIBUTE_UNUSED;
2465
     int objtype ATTRIBUTE_UNUSED;
2466
{
2467
#if VMS_DEBUG
2468
  _bfd_vms_debug (2, "vms_write_tbt (%p, %d)\n", abfd, objtype);
2469
#endif
2470
 
2471
  return 0;
2472
}
2473
 
2474
 
2475
/* write debug info for bfd abfd  */
2476
 
2477
int
2478
_bfd_vms_write_dbg (abfd, objtype)
2479
     bfd *abfd ATTRIBUTE_UNUSED;
2480
     int objtype ATTRIBUTE_UNUSED;
2481
{
2482
#if VMS_DEBUG
2483
  _bfd_vms_debug (2, "vms_write_dbg (%p, objtype)\n", abfd, objtype);
2484
#endif
2485
 
2486
  return 0;
2487
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.