* config/tc-arm.c (arm_force_relocation): Return 0 for ARM_IMMEDIATE
[binutils.git] / bfd / vms-tir.c
blobbd748ca3fa7037a072d6ba315a2e45b8b1c9024f
1 /* vms-tir.c -- BFD back-end for VAX (openVMS/VAX) and
2 EVAX (openVMS/Alpha) files.
3 Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002
4 Free Software Foundation, Inc.
6 TIR record handling functions
7 ETIR record handling functions
9 go and read the openVMS linker manual (esp. appendix B)
10 if you don't know what's going on here :-)
12 Written by Klaus K"ampf (kkaempf@rmi.de)
14 This program is free software; you can redistribute it and/or modify
15 it under the terms of the GNU General Public License as published by
16 the Free Software Foundation; either version 2 of the License, or
17 (at your option) any later version.
19 This program is distributed in the hope that it will be useful,
20 but WITHOUT ANY WARRANTY; without even the implied warranty of
21 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22 GNU General Public License for more details.
24 You should have received a copy of the GNU General Public License
25 along with this program; if not, write to the Free Software
26 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
28 /* The following type abbreviations are used:
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 */
37 #include "bfd.h"
38 #include "sysdep.h"
39 #include "bfdlink.h"
40 #include "libbfd.h"
42 #include "vms.h"
44 static void image_set_ptr
45 PARAMS ((bfd *abfd, int psect, uquad offset));
46 static void image_inc_ptr
47 PARAMS ((bfd *abfd, uquad offset));
48 static void image_dump
49 PARAMS ((bfd *abfd, unsigned char *ptr, int size, int offset));
50 static void image_write_b
51 PARAMS ((bfd *abfd, unsigned int value));
52 static void image_write_w
53 PARAMS ((bfd *abfd, unsigned int value));
54 static void image_write_l
55 PARAMS ((bfd *abfd, unsigned long value));
56 static void image_write_q
57 PARAMS ((bfd *abfd, uquad value));
58 static int check_section
59 PARAMS ((bfd *, int));
60 static bfd_boolean etir_sta
61 PARAMS ((bfd *, int, unsigned char *));
62 static bfd_boolean etir_sto
63 PARAMS ((bfd *, int, unsigned char *));
64 static bfd_boolean etir_opr
65 PARAMS ((bfd *, int, unsigned char *));
66 static bfd_boolean etir_ctl
67 PARAMS ((bfd *, int, unsigned char *));
68 static bfd_boolean etir_stc
69 PARAMS ((bfd *, int, unsigned char *));
70 static asection *new_section
71 PARAMS ((bfd *, int));
72 static int alloc_section
73 PARAMS ((bfd *, unsigned int));
74 static int etir_cmd
75 PARAMS ((bfd *, int, unsigned char *));
76 static int analyze_tir
77 PARAMS ((bfd *, unsigned char *, unsigned int));
78 static int analyze_etir
79 PARAMS ((bfd *, unsigned char *, unsigned int));
80 static unsigned char * tir_opr
81 PARAMS ((bfd *, unsigned char *));
82 static const char * tir_cmd_name
83 PARAMS ((int));
84 static const char * cmd_name
85 PARAMS ((int));
88 static int
89 check_section (abfd, size)
90 bfd *abfd;
91 int size;
93 bfd_size_type offset;
95 offset = PRIV (image_ptr) - PRIV (image_section)->contents;
96 if (offset + size > PRIV (image_section)->_raw_size)
98 PRIV (image_section)->contents
99 = bfd_realloc (PRIV (image_section)->contents, offset + size);
100 if (PRIV (image_section)->contents == 0)
102 (*_bfd_error_handler) (_("No Mem !"));
103 return -1;
105 PRIV (image_section)->_raw_size = offset + size;
106 PRIV (image_ptr) = PRIV (image_section)->contents + offset;
109 return 0;
112 /* Routines to fill sections contents during tir/etir read. */
114 /* Initialize image buffer pointer to be filled. */
116 static void
117 image_set_ptr (abfd, psect, offset)
118 bfd *abfd;
119 int psect;
120 uquad offset;
122 #if VMS_DEBUG
123 _bfd_vms_debug (4, "image_set_ptr (%d=%s, %d)\n",
124 psect, PRIV (sections)[psect]->name, offset);
125 #endif
127 PRIV (image_ptr) = PRIV (sections)[psect]->contents + offset;
128 PRIV (image_section) = PRIV (sections)[psect];
129 return;
132 /* Increment image buffer pointer by offset. */
134 static void
135 image_inc_ptr (abfd, offset)
136 bfd *abfd;
137 uquad offset;
139 #if VMS_DEBUG
140 _bfd_vms_debug (4, "image_inc_ptr (%d)\n", offset);
141 #endif
143 PRIV (image_ptr) += offset;
145 return;
148 /* Dump multiple bytes to section image. */
150 static void
151 image_dump (abfd, ptr, size, offset)
152 bfd *abfd;
153 unsigned char *ptr;
154 int size;
155 int offset ATTRIBUTE_UNUSED;
157 #if VMS_DEBUG
158 _bfd_vms_debug (8, "image_dump from (%p, %d) to (%p)\n", ptr, size,
159 PRIV (image_ptr));
160 _bfd_hexdump (9, ptr, size, offset);
161 #endif
163 if (PRIV (is_vax) && check_section (abfd, size))
164 return;
166 while (size-- > 0)
167 *PRIV (image_ptr)++ = *ptr++;
168 return;
171 /* Write byte to section image. */
173 static void
174 image_write_b (abfd, value)
175 bfd *abfd;
176 unsigned int value;
178 #if VMS_DEBUG
179 _bfd_vms_debug (6, "image_write_b(%02x)\n", (int) value);
180 #endif
182 if (PRIV (is_vax) && check_section (abfd, 1))
183 return;
185 *PRIV (image_ptr)++ = (value & 0xff);
186 return;
189 /* Write 2-byte word to image. */
191 static void
192 image_write_w (abfd, value)
193 bfd *abfd;
194 unsigned int value;
196 #if VMS_DEBUG
197 _bfd_vms_debug (6, "image_write_w(%04x)\n", (int) value);
198 #endif
200 if (PRIV (is_vax) && check_section (abfd, 2))
201 return;
203 bfd_putl16 ((bfd_vma) value, PRIV (image_ptr));
204 PRIV (image_ptr) += 2;
206 return;
209 /* Write 4-byte long to image. */
211 static void
212 image_write_l (abfd, value)
213 bfd *abfd;
214 unsigned long value;
216 #if VMS_DEBUG
217 _bfd_vms_debug (6, "image_write_l (%08lx)\n", value);
218 #endif
220 if (PRIV (is_vax) && check_section (abfd, 4))
221 return;
223 bfd_putl32 ((bfd_vma) value, PRIV (image_ptr));
224 PRIV (image_ptr) += 4;
226 return;
229 /* Write 8-byte quad to image. */
231 static void
232 image_write_q (abfd, value)
233 bfd *abfd;
234 uquad value;
236 #if VMS_DEBUG
237 _bfd_vms_debug (6, "image_write_q (%016lx)\n", value);
238 #endif
240 if (PRIV (is_vax) && check_section (abfd, 8))
241 return;
243 bfd_putl64 (value, PRIV (image_ptr));
244 PRIV (image_ptr) += 8;
246 return;
249 static const char *
250 cmd_name (cmd)
251 int cmd;
253 switch (cmd)
255 case ETIR_S_C_STA_GBL: return "ETIR_S_C_STA_GBL";
256 case ETIR_S_C_STA_PQ: return "ETIR_S_C_STA_PQ";
257 case ETIR_S_C_STA_LI: return "ETIR_S_C_STA_LI";
258 case ETIR_S_C_STA_MOD: return "ETIR_S_C_STA_MOD";
259 case ETIR_S_C_STA_CKARG: return "ETIR_S_C_STA_CKARG";
260 case ETIR_S_C_STO_B: return "ETIR_S_C_STO_B";
261 case ETIR_S_C_STO_W: return "ETIR_S_C_STO_W";
262 case ETIR_S_C_STO_GBL: return "ETIR_S_C_STO_GBL";
263 case ETIR_S_C_STO_CA: return "ETIR_S_C_STO_CA";
264 case ETIR_S_C_STO_RB: return "ETIR_S_C_STO_RB";
265 case ETIR_S_C_STO_AB: return "ETIR_S_C_STO_AB";
266 case ETIR_S_C_STO_GBL_LW: return "ETIR_S_C_STO_GBL_LW";
267 case ETIR_S_C_STO_LP_PSB: return "ETIR_S_C_STO_LP_PSB";
268 case ETIR_S_C_STO_HINT_GBL: return "ETIR_S_C_STO_HINT_GBL";
269 case ETIR_S_C_STO_HINT_PS: return "ETIR_S_C_STO_HINT_PS";
270 case ETIR_S_C_OPR_INSV: return "ETIR_S_C_OPR_INSV";
271 case ETIR_S_C_OPR_USH: return "ETIR_S_C_OPR_USH";
272 case ETIR_S_C_OPR_ROT: return "ETIR_S_C_OPR_ROT";
273 case ETIR_S_C_OPR_REDEF: return "ETIR_S_C_OPR_REDEF";
274 case ETIR_S_C_OPR_DFLIT: return "ETIR_S_C_OPR_DFLIT";
275 case ETIR_S_C_STC_LP: return "ETIR_S_C_STC_LP";
276 case ETIR_S_C_STC_GBL: return "ETIR_S_C_STC_GBL";
277 case ETIR_S_C_STC_GCA: return "ETIR_S_C_STC_GCA";
278 case ETIR_S_C_STC_PS: return "ETIR_S_C_STC_PS";
279 case ETIR_S_C_STC_NBH_PS: return "ETIR_S_C_STC_NBH_PS";
280 case ETIR_S_C_STC_NOP_GBL: return "ETIR_S_C_STC_NOP_GBL";
281 case ETIR_S_C_STC_NOP_PS: return "ETIR_S_C_STC_NOP_PS";
282 case ETIR_S_C_STC_BSR_GBL: return "ETIR_S_C_STC_BSR_GBL";
283 case ETIR_S_C_STC_BSR_PS: return "ETIR_S_C_STC_BSR_PS";
284 case ETIR_S_C_STC_LDA_GBL: return "ETIR_S_C_STC_LDA_GBL";
285 case ETIR_S_C_STC_LDA_PS: return "ETIR_S_C_STC_LDA_PS";
286 case ETIR_S_C_STC_BOH_GBL: return "ETIR_S_C_STC_BOH_GBL";
287 case ETIR_S_C_STC_BOH_PS: return "ETIR_S_C_STC_BOH_PS";
288 case ETIR_S_C_STC_NBH_GBL: return "ETIR_S_C_STC_NBH_GBL";
290 default:
291 /* These names have not yet been added to this switch statement. */
292 abort ();
295 #define HIGHBIT(op) ((op & 0x80000000L) == 0x80000000L)
297 /* etir_sta
299 vms stack commands
301 handle sta_xxx commands in etir section
302 ptr points to data area in record
304 see table B-8 of the openVMS linker manual. */
306 static bfd_boolean
307 etir_sta (abfd, cmd, ptr)
308 bfd *abfd;
309 int cmd;
310 unsigned char *ptr;
313 #if VMS_DEBUG
314 _bfd_vms_debug (5, "etir_sta %d/%x\n", cmd, cmd);
315 _bfd_hexdump (8, ptr, 16, (int) ptr);
316 #endif
318 switch (cmd)
320 /* stack */
322 /* stack global
323 arg: cs symbol name
325 stack 32 bit value of symbol (high bits set to 0) */
327 case ETIR_S_C_STA_GBL:
329 char *name;
330 vms_symbol_entry *entry;
332 name = _bfd_vms_save_counted_string (ptr);
333 entry = (vms_symbol_entry *)
334 bfd_hash_lookup (PRIV (vms_symbol_table), name, FALSE, FALSE);
335 if (entry == (vms_symbol_entry *) NULL)
337 #if VMS_DEBUG
338 _bfd_vms_debug (3, "%s: no symbol \"%s\"\n",
339 cmd_name (cmd), name);
340 #endif
341 _bfd_vms_push (abfd, (uquad) 0, -1);
343 else
345 _bfd_vms_push (abfd, (uquad) (entry->symbol->value), -1);
348 break;
350 /* stack longword
351 arg: lw value
353 stack 32 bit value, sign extend to 64 bit */
355 case ETIR_S_C_STA_LW:
356 _bfd_vms_push (abfd, (uquad) bfd_getl32 (ptr), -1);
357 break;
359 /* stack global
360 arg: qw value
362 stack 64 bit value of symbol */
364 case ETIR_S_C_STA_QW:
365 _bfd_vms_push (abfd, (uquad) bfd_getl64 (ptr), -1);
366 break;
368 /* stack psect base plus quadword offset
369 arg: lw section index
370 qw signed quadword offset (low 32 bits)
372 stack qw argument and section index
373 (see ETIR_S_C_STO_OFF, ETIR_S_C_CTL_SETRB) */
375 case ETIR_S_C_STA_PQ:
377 uquad dummy;
378 unsigned int psect;
380 psect = bfd_getl32 (ptr);
381 if (psect >= PRIV (section_count))
383 (*_bfd_error_handler) (_("bad section index in %s"),
384 cmd_name (cmd));
385 bfd_set_error (bfd_error_bad_value);
386 return FALSE;
388 dummy = bfd_getl64 (ptr+4);
389 _bfd_vms_push (abfd, dummy, (int) psect);
391 break;
393 case ETIR_S_C_STA_LI:
394 case ETIR_S_C_STA_MOD:
395 case ETIR_S_C_STA_CKARG:
396 (*_bfd_error_handler) (_("unsupported STA cmd %s"), cmd_name (cmd));
397 return FALSE;
398 break;
400 default:
401 (*_bfd_error_handler) (_("reserved STA cmd %d"), cmd);
402 return FALSE;
403 break;
405 #if VMS_DEBUG
406 _bfd_vms_debug (5, "etir_sta true\n");
407 #endif
408 return TRUE;
412 etir_sto
414 vms store commands
416 handle sto_xxx commands in etir section
417 ptr points to data area in record
419 see table B-9 of the openVMS linker manual. */
421 static bfd_boolean
422 etir_sto (abfd, cmd, ptr)
423 bfd *abfd;
424 int cmd;
425 unsigned char *ptr;
427 uquad dummy;
428 int psect;
430 #if VMS_DEBUG
431 _bfd_vms_debug (5, "etir_sto %d/%x\n", cmd, cmd);
432 _bfd_hexdump (8, ptr, 16, (int) ptr);
433 #endif
435 switch (cmd)
437 /* store byte: pop stack, write byte
438 arg: - */
440 case ETIR_S_C_STO_B:
441 dummy = _bfd_vms_pop (abfd, &psect);
442 #if 0
443 if (is_share) /* FIXME */
444 (*_bfd_error_handler) ("%s: byte fixups not supported",
445 cmd_name (cmd));
446 #endif
447 /* FIXME: check top bits */
448 image_write_b (abfd, (unsigned int) dummy & 0xff);
449 break;
451 /* store word: pop stack, write word
452 arg: - */
454 case ETIR_S_C_STO_W:
455 dummy = _bfd_vms_pop (abfd, &psect);
456 #if 0
457 if (is_share) /* FIXME */
458 (*_bfd_error_handler) ("%s: word fixups not supported",
459 cmd_name (cmd));
460 #endif
461 /* FIXME: check top bits */
462 image_write_w (abfd, (unsigned int) dummy & 0xffff);
463 break;
465 /* store longword: pop stack, write longword
466 arg: - */
468 case ETIR_S_C_STO_LW:
469 dummy = _bfd_vms_pop (abfd, &psect);
470 dummy += (PRIV (sections)[psect])->vma;
471 /* FIXME: check top bits. */
472 image_write_l (abfd, (unsigned int) dummy & 0xffffffff);
473 break;
475 /* store quadword: pop stack, write quadword
476 arg: - */
478 case ETIR_S_C_STO_QW:
479 dummy = _bfd_vms_pop (abfd, &psect);
480 dummy += (PRIV (sections)[psect])->vma;
481 image_write_q (abfd, dummy); /* FIXME: check top bits */
482 break;
484 /* store immediate repeated: pop stack for repeat count
485 arg: lw byte count
486 da data */
488 case ETIR_S_C_STO_IMMR:
490 int size;
492 size = bfd_getl32 (ptr);
493 dummy = (unsigned long) _bfd_vms_pop (abfd, NULL);
494 while (dummy-- > 0)
495 image_dump (abfd, ptr+4, size, 0);
497 break;
499 /* store global: write symbol value
500 arg: cs global symbol name. */
502 case ETIR_S_C_STO_GBL:
504 vms_symbol_entry *entry;
505 char *name;
507 name = _bfd_vms_save_counted_string (ptr);
508 entry = (vms_symbol_entry *) bfd_hash_lookup (PRIV (vms_symbol_table),
509 name, FALSE, FALSE);
510 if (entry == (vms_symbol_entry *) NULL)
512 (*_bfd_error_handler) (_("%s: no symbol \"%s\""),
513 cmd_name (cmd), name);
514 return FALSE;
516 else
517 /* FIXME, reloc. */
518 image_write_q (abfd, (uquad) (entry->symbol->value));
520 break;
522 /* store code address: write address of entry point
523 arg: cs global symbol name (procedure). */
525 case ETIR_S_C_STO_CA:
527 vms_symbol_entry *entry;
528 char *name;
530 name = _bfd_vms_save_counted_string (ptr);
531 entry = (vms_symbol_entry *) bfd_hash_lookup (PRIV (vms_symbol_table),
532 name, FALSE, FALSE);
533 if (entry == (vms_symbol_entry *) NULL)
535 (*_bfd_error_handler) (_("%s: no symbol \"%s\""),
536 cmd_name (cmd), name);
537 return FALSE;
539 else
540 image_write_q (abfd, (uquad) (entry->symbol->value)); /* FIXME, reloc */
542 break;
544 /* Store offset to psect: pop stack, add low 32 bits to base of psect
545 arg: none. */
547 case ETIR_S_C_STO_OFF:
549 uquad q;
550 int psect1;
552 q = _bfd_vms_pop (abfd, &psect1);
553 q += (PRIV (sections)[psect1])->vma;
554 image_write_q (abfd, q);
556 break;
558 /* Store immediate
559 arg: lw count of bytes
560 da data. */
562 case ETIR_S_C_STO_IMM:
564 int size;
566 size = bfd_getl32 (ptr);
567 image_dump (abfd, ptr+4, size, 0);
569 break;
571 /* This code is 'reserved to digital' according to the openVMS
572 linker manual, however it is generated by the DEC C compiler
573 and defined in the include file.
574 FIXME, since the following is just a guess
575 store global longword: store 32bit value of symbol
576 arg: cs symbol name. */
578 case ETIR_S_C_STO_GBL_LW:
580 vms_symbol_entry *entry;
581 char *name;
583 name = _bfd_vms_save_counted_string (ptr);
584 entry = (vms_symbol_entry *) bfd_hash_lookup (PRIV (vms_symbol_table),
585 name, FALSE, FALSE);
586 if (entry == (vms_symbol_entry *) NULL)
588 #if VMS_DEBUG
589 _bfd_vms_debug (3, "%s: no symbol \"%s\"\n", cmd_name (cmd), name);
590 #endif
591 image_write_l (abfd, (unsigned long) 0); /* FIXME, reloc */
593 else
594 /* FIXME, reloc. */
595 image_write_l (abfd, (unsigned long) (entry->symbol->value));
597 break;
599 case ETIR_S_C_STO_RB:
600 case ETIR_S_C_STO_AB:
601 case ETIR_S_C_STO_LP_PSB:
602 (*_bfd_error_handler) (_("%s: not supported"), cmd_name (cmd));
603 break;
605 case ETIR_S_C_STO_HINT_GBL:
606 case ETIR_S_C_STO_HINT_PS:
607 (*_bfd_error_handler) (_("%s: not implemented"), cmd_name (cmd));
608 break;
610 default:
611 (*_bfd_error_handler) (_("reserved STO cmd %d"), cmd);
612 break;
615 return TRUE;
618 /* Stack operator commands
619 all 32 bit signed arithmetic
620 all word just like a stack calculator
621 arguments are popped from stack, results are pushed on stack
623 see table B-10 of the openVMS linker manual. */
625 static bfd_boolean
626 etir_opr (abfd, cmd, ptr)
627 bfd *abfd;
628 int cmd;
629 unsigned char *ptr ATTRIBUTE_UNUSED;
631 long op1, op2;
633 #if VMS_DEBUG
634 _bfd_vms_debug (5, "etir_opr %d/%x\n", cmd, cmd);
635 _bfd_hexdump (8, ptr, 16, (int) ptr);
636 #endif
638 switch (cmd)
640 case ETIR_S_C_OPR_NOP: /* no-op */
641 break;
643 case ETIR_S_C_OPR_ADD: /* add */
644 op1 = (long) _bfd_vms_pop (abfd, NULL);
645 op2 = (long) _bfd_vms_pop (abfd, NULL);
646 _bfd_vms_push (abfd, (uquad) (op1 + op2), -1);
647 break;
649 case ETIR_S_C_OPR_SUB: /* subtract */
650 op1 = (long) _bfd_vms_pop (abfd, NULL);
651 op2 = (long) _bfd_vms_pop (abfd, NULL);
652 _bfd_vms_push (abfd, (uquad) (op2 - op1), -1);
653 break;
655 case ETIR_S_C_OPR_MUL: /* multiply */
656 op1 = (long) _bfd_vms_pop (abfd, NULL);
657 op2 = (long) _bfd_vms_pop (abfd, NULL);
658 _bfd_vms_push (abfd, (uquad) (op1 * op2), -1);
659 break;
661 case ETIR_S_C_OPR_DIV: /* divide */
662 op1 = (long) _bfd_vms_pop (abfd, NULL);
663 op2 = (long) _bfd_vms_pop (abfd, NULL);
664 if (op2 == 0)
665 _bfd_vms_push (abfd, (uquad) 0, -1);
666 else
667 _bfd_vms_push (abfd, (uquad) (op2 / op1), -1);
668 break;
670 case ETIR_S_C_OPR_AND: /* logical and */
671 op1 = (long) _bfd_vms_pop (abfd, NULL);
672 op2 = (long) _bfd_vms_pop (abfd, NULL);
673 _bfd_vms_push (abfd, (uquad) (op1 & op2), -1);
674 break;
676 case ETIR_S_C_OPR_IOR: /* logical inclusive or */
677 op1 = (long) _bfd_vms_pop (abfd, NULL);
678 op2 = (long) _bfd_vms_pop (abfd, NULL);
679 _bfd_vms_push (abfd, (uquad) (op1 | op2), -1);
680 break;
682 case ETIR_S_C_OPR_EOR: /* logical exclusive or */
683 op1 = (long) _bfd_vms_pop (abfd, NULL);
684 op2 = (long) _bfd_vms_pop (abfd, NULL);
685 _bfd_vms_push (abfd, (uquad) (op1 ^ op2), -1);
686 break;
688 case ETIR_S_C_OPR_NEG: /* negate */
689 op1 = (long) _bfd_vms_pop (abfd, NULL);
690 _bfd_vms_push (abfd, (uquad) (-op1), -1);
691 break;
693 case ETIR_S_C_OPR_COM: /* complement */
694 op1 = (long) _bfd_vms_pop (abfd, NULL);
695 _bfd_vms_push (abfd, (uquad) (op1 ^ -1L), -1);
696 break;
698 case ETIR_S_C_OPR_ASH: /* arithmetic shift */
699 op1 = (long) _bfd_vms_pop (abfd, NULL);
700 op2 = (long) _bfd_vms_pop (abfd, NULL);
701 if (op2 < 0) /* shift right */
702 op1 >>= -op2;
703 else /* shift left */
704 op1 <<= op2;
705 _bfd_vms_push (abfd, (uquad) op1, -1);
706 break;
708 case ETIR_S_C_OPR_INSV: /* insert field */
709 (void) _bfd_vms_pop (abfd, NULL);
710 case ETIR_S_C_OPR_USH: /* unsigned shift */
711 case ETIR_S_C_OPR_ROT: /* rotate */
712 case ETIR_S_C_OPR_REDEF: /* Redefine symbol to current location. */
713 case ETIR_S_C_OPR_DFLIT: /* Define a literal. */
714 (*_bfd_error_handler) (_("%s: not supported"), cmd_name (cmd));
715 break;
717 case ETIR_S_C_OPR_SEL: /* select */
718 if ((long) _bfd_vms_pop (abfd, NULL) & 0x01L)
719 (void) _bfd_vms_pop (abfd, NULL);
720 else
722 op1 = (long) _bfd_vms_pop (abfd, NULL);
723 (void) _bfd_vms_pop (abfd, NULL);
724 _bfd_vms_push (abfd, (uquad) op1, -1);
726 break;
728 default:
729 (*_bfd_error_handler) (_("reserved OPR cmd %d"), cmd);
730 break;
733 return TRUE;
736 /* Control commands.
738 See table B-11 of the openVMS linker manual. */
740 static bfd_boolean
741 etir_ctl (abfd, cmd, ptr)
742 bfd *abfd;
743 int cmd;
744 unsigned char *ptr;
746 uquad dummy;
747 int psect;
749 #if VMS_DEBUG
750 _bfd_vms_debug (5, "etir_ctl %d/%x\n", cmd, cmd);
751 _bfd_hexdump (8, ptr, 16, (int) ptr);
752 #endif
754 switch (cmd)
756 /* set relocation base: pop stack, set image location counter
757 arg: none. */
759 case ETIR_S_C_CTL_SETRB:
760 dummy = _bfd_vms_pop (abfd, &psect);
761 image_set_ptr (abfd, psect, dummy);
762 break;
764 /* augment relocation base: increment image location counter by offset
765 arg: lw offset value */
767 case ETIR_S_C_CTL_AUGRB:
768 dummy = bfd_getl32 (ptr);
769 image_inc_ptr (abfd, dummy);
770 break;
772 /* define location: pop index, save location counter under index
773 arg: none. */
775 case ETIR_S_C_CTL_DFLOC:
776 dummy = _bfd_vms_pop (abfd, NULL);
777 /* FIXME */
778 break;
780 /* set location: pop index, restore location counter from index
781 arg: none. */
783 case ETIR_S_C_CTL_STLOC:
784 dummy = _bfd_vms_pop (abfd, &psect);
785 /* FIXME */
786 break;
788 /* stack defined location: pop index, push location counter from index
789 arg: none. */
791 case ETIR_S_C_CTL_STKDL:
792 dummy = _bfd_vms_pop (abfd, &psect);
793 /* FIXME */
794 break;
796 default:
797 (*_bfd_error_handler) (_("reserved CTL cmd %d"), cmd);
798 break;
800 return TRUE;
803 /* store conditional commands
805 See table B-12 and B-13 of the openVMS linker manual. */
807 static bfd_boolean
808 etir_stc (abfd, cmd, ptr)
809 bfd *abfd;
810 int cmd;
811 unsigned char *ptr ATTRIBUTE_UNUSED;
813 #if VMS_DEBUG
814 _bfd_vms_debug (5, "etir_stc %d/%x\n", cmd, cmd);
815 _bfd_hexdump (8, ptr, 16, (int) ptr);
816 #endif
818 switch (cmd)
820 /* 200 Store-conditional Linkage Pair
821 arg: none. */
823 case ETIR_S_C_STC_LP:
824 (*_bfd_error_handler) (_("%s: not supported"), cmd_name (cmd));
825 break;
827 /* 201 Store-conditional Linkage Pair with Procedure Signature
828 arg: lw linkage index
829 cs procedure name
830 by signature length
831 da signature. */
833 case ETIR_S_C_STC_LP_PSB:
834 image_inc_ptr (abfd, (uquad) 16); /* skip entry,procval */
835 break;
837 /* 202 Store-conditional Address at global address
838 arg: lw linkage index
839 cs global name. */
841 case ETIR_S_C_STC_GBL:
842 (*_bfd_error_handler) (_("%s: not supported"), cmd_name (cmd));
843 break;
845 /* 203 Store-conditional Code Address at global address
846 arg: lw linkage index
847 cs procedure name. */
849 case ETIR_S_C_STC_GCA:
850 (*_bfd_error_handler) (_("%s: not supported"), cmd_name (cmd));
851 break;
853 /* 204 Store-conditional Address at psect + offset
854 arg: lw linkage index
855 lw psect index
856 qw offset. */
858 case ETIR_S_C_STC_PS:
859 (*_bfd_error_handler) (_("%s: not supported"), cmd_name (cmd));
860 break;
862 /* 205 Store-conditional NOP at address of global
863 arg: none. */
865 case ETIR_S_C_STC_NOP_GBL:
867 /* 206 Store-conditional NOP at pect + offset
868 arg: none. */
870 case ETIR_S_C_STC_NOP_PS:
872 /* 207 Store-conditional BSR at global address
873 arg: none. */
875 case ETIR_S_C_STC_BSR_GBL:
877 /* 208 Store-conditional BSR at pect + offset
878 arg: none. */
880 case ETIR_S_C_STC_BSR_PS:
882 /* 209 Store-conditional LDA at global address
883 arg: none. */
885 case ETIR_S_C_STC_LDA_GBL:
887 /* 210 Store-conditional LDA at psect + offset
888 arg: none. */
890 case ETIR_S_C_STC_LDA_PS:
892 /* 211 Store-conditional BSR or Hint at global address
893 arg: none. */
895 case ETIR_S_C_STC_BOH_GBL:
897 /* 212 Store-conditional BSR or Hint at pect + offset
898 arg: none. */
900 case ETIR_S_C_STC_BOH_PS:
902 /* 213 Store-conditional NOP,BSR or HINT at global address
903 arg: none. */
905 case ETIR_S_C_STC_NBH_GBL:
907 /* 214 Store-conditional NOP,BSR or HINT at psect + offset
908 arg: none. */
910 case ETIR_S_C_STC_NBH_PS:
911 /* FIXME */
912 #if 0
913 (*_bfd_error_handler) ("%s: not supported", cmd_name (cmd));
914 #endif
915 break;
917 default:
918 #if VMS_DEBUG
919 _bfd_vms_debug (3, "reserved STC cmd %d", cmd);
920 #endif
921 break;
923 return TRUE;
926 static asection *
927 new_section (abfd, idx)
928 bfd *abfd ATTRIBUTE_UNUSED;
929 int idx;
931 asection *section;
932 char sname[16];
933 char *name;
935 #if VMS_DEBUG
936 _bfd_vms_debug (5, "new_section %d\n", idx);
937 #endif
938 sprintf (sname, SECTION_NAME_TEMPLATE, idx);
940 name = bfd_malloc ((bfd_size_type) strlen (sname) + 1);
941 if (name == 0)
942 return 0;
943 strcpy (name, sname);
945 section = bfd_malloc ((bfd_size_type) sizeof (asection));
946 if (section == 0)
948 #if VMS_DEBUG
949 _bfd_vms_debug (6, "bfd_make_section (%s) failed", name);
950 #endif
951 return 0;
954 section->_raw_size = 0;
955 section->vma = 0;
956 section->contents = 0;
957 section->_cooked_size = 0;
958 section->name = name;
959 section->index = idx;
961 return section;
964 static int
965 alloc_section (abfd, idx)
966 bfd *abfd;
967 unsigned int idx;
969 bfd_size_type amt;
971 #if VMS_DEBUG
972 _bfd_vms_debug (4, "alloc_section %d\n", idx);
973 #endif
975 amt = idx + 1;
976 amt *= sizeof (asection *);
977 PRIV (sections) = (asection **) bfd_realloc (PRIV (sections), amt);
978 if (PRIV (sections) == 0)
979 return -1;
981 while (PRIV (section_count) <= idx)
983 PRIV (sections)[PRIV (section_count)]
984 = new_section (abfd, (int) PRIV (section_count));
985 if (PRIV (sections)[PRIV (section_count)] == 0)
986 return -1;
987 PRIV (section_count)++;
990 return 0;
993 /* tir_sta
995 vax stack commands
997 Handle sta_xxx commands in tir section
998 ptr points to data area in record
1000 See table 7-3 of the VAX/VMS linker manual. */
1002 static unsigned char *
1003 tir_sta (bfd *abfd, unsigned char *ptr)
1005 int cmd = *ptr++;
1007 #if VMS_DEBUG
1008 _bfd_vms_debug (5, "tir_sta %d\n", cmd);
1009 #endif
1011 switch (cmd)
1013 /* stack */
1014 case TIR_S_C_STA_GBL:
1015 /* stack global
1016 arg: cs symbol name
1018 stack 32 bit value of symbol (high bits set to 0). */
1020 char *name;
1021 vms_symbol_entry *entry;
1023 name = _bfd_vms_save_counted_string (ptr);
1025 entry = _bfd_vms_enter_symbol (abfd, name);
1026 if (entry == (vms_symbol_entry *) NULL)
1027 return 0;
1029 _bfd_vms_push (abfd, (uquad) (entry->symbol->value), -1);
1030 ptr += *ptr + 1;
1032 break;
1034 case TIR_S_C_STA_SB:
1035 /* stack signed byte
1036 arg: by value
1038 stack byte value, sign extend to 32 bit. */
1039 _bfd_vms_push (abfd, (uquad) *ptr++, -1);
1040 break;
1042 case TIR_S_C_STA_SW:
1043 /* stack signed short word
1044 arg: sh value
1046 stack 16 bit value, sign extend to 32 bit. */
1047 _bfd_vms_push (abfd, (uquad) bfd_getl16 (ptr), -1);
1048 ptr += 2;
1049 break;
1051 case TIR_S_C_STA_LW:
1052 /* stack signed longword
1053 arg: lw value
1055 stack 32 bit value. */
1056 _bfd_vms_push (abfd, (uquad) bfd_getl32 (ptr), -1);
1057 ptr += 4;
1058 break;
1060 case TIR_S_C_STA_PB:
1061 case TIR_S_C_STA_WPB:
1062 /* stack psect base plus byte offset (word index)
1063 arg: by section index
1064 (sh section index)
1065 by signed byte offset. */
1067 unsigned long dummy;
1068 unsigned int psect;
1070 if (cmd == TIR_S_C_STA_PB)
1071 psect = *ptr++;
1072 else
1074 psect = bfd_getl16 (ptr);
1075 ptr += 2;
1078 if (psect >= PRIV (section_count))
1079 alloc_section (abfd, psect);
1081 dummy = (long) *ptr++;
1082 dummy += (PRIV (sections)[psect])->vma;
1083 _bfd_vms_push (abfd, (uquad) dummy, (int) psect);
1085 break;
1087 case TIR_S_C_STA_PW:
1088 case TIR_S_C_STA_WPW:
1089 /* stack psect base plus word offset (word index)
1090 arg: by section index
1091 (sh section index)
1092 sh signed short offset. */
1094 unsigned long dummy;
1095 unsigned int psect;
1097 if (cmd == TIR_S_C_STA_PW)
1098 psect = *ptr++;
1099 else
1101 psect = bfd_getl16 (ptr);
1102 ptr += 2;
1105 if (psect >= PRIV (section_count))
1106 alloc_section (abfd, psect);
1108 dummy = bfd_getl16 (ptr); ptr+=2;
1109 dummy += (PRIV (sections)[psect])->vma;
1110 _bfd_vms_push (abfd, (uquad) dummy, (int) psect);
1112 break;
1114 case TIR_S_C_STA_PL:
1115 case TIR_S_C_STA_WPL:
1116 /* stack psect base plus long offset (word index)
1117 arg: by section index
1118 (sh section index)
1119 lw signed longword offset. */
1121 unsigned long dummy;
1122 unsigned int psect;
1124 if (cmd == TIR_S_C_STA_PL)
1125 psect = *ptr++;
1126 else
1128 psect = bfd_getl16 (ptr);
1129 ptr += 2;
1132 if (psect >= PRIV (section_count))
1133 alloc_section (abfd, psect);
1135 dummy = bfd_getl32 (ptr); ptr += 4;
1136 dummy += (PRIV (sections)[psect])->vma;
1137 _bfd_vms_push (abfd, (uquad) dummy, (int) psect);
1139 break;
1141 case TIR_S_C_STA_UB:
1142 /* stack unsigned byte
1143 arg: by value
1145 stack byte value. */
1146 _bfd_vms_push (abfd, (uquad) *ptr++, -1);
1147 break;
1149 case TIR_S_C_STA_UW:
1150 /* stack unsigned short word
1151 arg: sh value
1153 stack 16 bit value. */
1154 _bfd_vms_push (abfd, (uquad) bfd_getl16 (ptr), -1);
1155 ptr += 2;
1156 break;
1158 case TIR_S_C_STA_BFI:
1159 /* stack byte from image
1160 arg: none. */
1161 /* FALLTHRU */
1162 case TIR_S_C_STA_WFI:
1163 /* stack byte from image
1164 arg: none. */
1165 /* FALLTHRU */
1166 case TIR_S_C_STA_LFI:
1167 /* stack byte from image
1168 arg: none. */
1169 (*_bfd_error_handler) (_("stack-from-image not implemented"));
1170 return NULL;
1172 case TIR_S_C_STA_EPM:
1173 /* stack entry point mask
1174 arg: cs symbol name
1176 stack (unsigned) entry point mask of symbol
1177 err if symbol is no entry point. */
1179 char *name;
1180 vms_symbol_entry *entry;
1182 name = _bfd_vms_save_counted_string (ptr);
1183 entry = _bfd_vms_enter_symbol (abfd, name);
1184 if (entry == (vms_symbol_entry *) NULL)
1185 return 0;
1187 (*_bfd_error_handler) (_("stack-entry-mask not fully implemented"));
1188 _bfd_vms_push (abfd, (uquad) 0, -1);
1189 ptr += *ptr + 1;
1191 break;
1193 case TIR_S_C_STA_CKARG:
1194 /* compare procedure argument
1195 arg: cs symbol name
1196 by argument index
1197 da argument descriptor
1199 compare argument descriptor with symbol argument (ARG$V_PASSMECH)
1200 and stack TRUE (args match) or FALSE (args dont match) value. */
1201 (*_bfd_error_handler) (_("PASSMECH not fully implemented"));
1202 _bfd_vms_push (abfd, (uquad) 1, -1);
1203 break;
1205 case TIR_S_C_STA_LSY:
1206 /* stack local symbol value
1207 arg: sh environment index
1208 cs symbol name. */
1210 int envidx;
1211 char *name;
1212 vms_symbol_entry *entry;
1214 envidx = bfd_getl16 (ptr);
1215 ptr += 2;
1216 name = _bfd_vms_save_counted_string (ptr);
1217 entry = _bfd_vms_enter_symbol (abfd, name);
1218 if (entry == (vms_symbol_entry *) NULL)
1219 return 0;
1220 (*_bfd_error_handler) (_("stack-local-symbol not fully implemented"));
1221 _bfd_vms_push (abfd, (uquad) 0, -1);
1222 ptr += *ptr + 1;
1224 break;
1226 case TIR_S_C_STA_LIT:
1227 /* stack literal
1228 arg: by literal index
1230 stack literal. */
1231 ptr++;
1232 _bfd_vms_push (abfd, (uquad) 0, -1);
1233 (*_bfd_error_handler) (_("stack-literal not fully implemented"));
1234 break;
1236 case TIR_S_C_STA_LEPM:
1237 /* stack local symbol entry point mask
1238 arg: sh environment index
1239 cs symbol name
1241 stack (unsigned) entry point mask of symbol
1242 err if symbol is no entry point. */
1244 int envidx;
1245 char *name;
1246 vms_symbol_entry *entry;
1248 envidx = bfd_getl16 (ptr);
1249 ptr += 2;
1250 name = _bfd_vms_save_counted_string (ptr);
1251 entry = _bfd_vms_enter_symbol (abfd, name);
1252 if (entry == (vms_symbol_entry *) NULL)
1253 return 0;
1254 (*_bfd_error_handler) (_("stack-local-symbol-entry-point-mask not fully implemented"));
1255 _bfd_vms_push (abfd, (uquad) 0, -1);
1256 ptr += *ptr + 1;
1258 break;
1260 default:
1261 (*_bfd_error_handler) (_("reserved STA cmd %d"), ptr[-1]);
1262 return NULL;
1263 break;
1266 return ptr;
1269 static const char *
1270 tir_cmd_name (cmd)
1271 int cmd;
1273 switch (cmd)
1275 case TIR_S_C_STO_RSB: return "TIR_S_C_STO_RSB";
1276 case TIR_S_C_STO_RSW: return "TIR_S_C_STO_RSW";
1277 case TIR_S_C_STO_RL: return "TIR_S_C_STO_RL";
1278 case TIR_S_C_STO_VPS: return "TIR_S_C_STO_VPS";
1279 case TIR_S_C_STO_USB: return "TIR_S_C_STO_USB";
1280 case TIR_S_C_STO_USW: return "TIR_S_C_STO_USW";
1281 case TIR_S_C_STO_RUB: return "TIR_S_C_STO_RUB";
1282 case TIR_S_C_STO_RUW: return "TIR_S_C_STO_RUW";
1283 case TIR_S_C_STO_PIRR: return "TIR_S_C_STO_PIRR";
1284 case TIR_S_C_OPR_INSV: return "TIR_S_C_OPR_INSV";
1285 case TIR_S_C_OPR_DFLIT: return "TIR_S_C_OPR_DFLIT";
1286 case TIR_S_C_OPR_REDEF: return "TIR_S_C_OPR_REDEF";
1287 case TIR_S_C_OPR_ROT: return "TIR_S_C_OPR_ROT";
1288 case TIR_S_C_OPR_USH: return "TIR_S_C_OPR_USH";
1289 case TIR_S_C_OPR_ASH: return "TIR_S_C_OPR_ASH";
1290 case TIR_S_C_CTL_DFLOC: return "TIR_S_C_CTL_DFLOC";
1291 case TIR_S_C_CTL_STLOC: return "TIR_S_C_CTL_STLOC";
1292 case TIR_S_C_CTL_STKDL: return "TIR_S_C_CTL_STKDL";
1294 default:
1295 /* These strings have not been added yet. */
1296 abort ();
1300 /* tir_sto
1302 vax store commands
1304 handle sto_xxx commands in tir section
1305 ptr points to data area in record
1307 See table 7-4 of the VAX/VMS linker manual. */
1309 static unsigned char *
1310 tir_sto (bfd *abfd, unsigned char *ptr)
1312 unsigned long dummy;
1313 int size;
1314 int psect;
1316 #if VMS_DEBUG
1317 _bfd_vms_debug (5, "tir_sto %d\n", *ptr);
1318 #endif
1320 switch (*ptr++)
1322 case TIR_S_C_STO_SB:
1323 /* store signed byte: pop stack, write byte
1324 arg: none. */
1325 dummy = _bfd_vms_pop (abfd, &psect);
1326 image_write_b (abfd, dummy & 0xff); /* FIXME: check top bits */
1327 break;
1329 case TIR_S_C_STO_SW:
1330 /* store signed word: pop stack, write word
1331 arg: none. */
1332 dummy = _bfd_vms_pop (abfd, &psect);
1333 image_write_w (abfd, dummy & 0xffff); /* FIXME: check top bits */
1334 break;
1336 case TIR_S_C_STO_LW:
1337 /* store longword: pop stack, write longword
1338 arg: none. */
1339 dummy = _bfd_vms_pop (abfd, &psect);
1340 image_write_l (abfd, dummy & 0xffffffff); /* FIXME: check top bits */
1341 break;
1343 case TIR_S_C_STO_BD:
1344 /* store byte displaced: pop stack, sub lc+1, write byte
1345 arg: none. */
1346 dummy = _bfd_vms_pop (abfd, &psect);
1347 dummy -= ((PRIV (sections)[psect])->vma + 1);
1348 image_write_b (abfd, dummy & 0xff);/* FIXME: check top bits */
1349 break;
1351 case TIR_S_C_STO_WD:
1352 /* store word displaced: pop stack, sub lc+2, write word
1353 arg: none. */
1354 dummy = _bfd_vms_pop (abfd, &psect);
1355 dummy -= ((PRIV (sections)[psect])->vma + 2);
1356 image_write_w (abfd, dummy & 0xffff);/* FIXME: check top bits */
1357 break;
1359 case TIR_S_C_STO_LD:
1360 /* store long displaced: pop stack, sub lc+4, write long
1361 arg: none. */
1362 dummy = _bfd_vms_pop (abfd, &psect);
1363 dummy -= ((PRIV (sections)[psect])->vma + 4);
1364 image_write_l (abfd, dummy & 0xffffffff);/* FIXME: check top bits */
1365 break;
1367 case TIR_S_C_STO_LI:
1368 /* store short literal: pop stack, write byte
1369 arg: none. */
1370 dummy = _bfd_vms_pop (abfd, &psect);
1371 image_write_b (abfd, dummy & 0xff);/* FIXME: check top bits */
1372 break;
1374 case TIR_S_C_STO_PIDR:
1375 /* store position independent data reference: pop stack, write longword
1376 arg: none.
1377 FIXME: incomplete ! */
1378 dummy = _bfd_vms_pop (abfd, &psect);
1379 image_write_l (abfd, dummy & 0xffffffff);
1380 break;
1382 case TIR_S_C_STO_PICR:
1383 /* store position independent code reference: pop stack, write longword
1384 arg: none.
1385 FIXME: incomplete ! */
1386 dummy = _bfd_vms_pop (abfd, &psect);
1387 image_write_b (abfd, 0x9f);
1388 image_write_l (abfd, dummy & 0xffffffff);
1389 break;
1391 case TIR_S_C_STO_RIVB:
1392 /* store repeated immediate variable bytes
1393 1-byte count n field followed by n bytes of data
1394 pop stack, write n bytes <stack> times. */
1395 size = *ptr++;
1396 dummy = (unsigned long) _bfd_vms_pop (abfd, NULL);
1397 while (dummy-- > 0L)
1398 image_dump (abfd, ptr, size, 0);
1399 ptr += size;
1400 break;
1402 case TIR_S_C_STO_B:
1403 /* store byte from top longword. */
1404 dummy = (unsigned long) _bfd_vms_pop (abfd, NULL);
1405 image_write_b (abfd, dummy & 0xff);
1406 break;
1408 case TIR_S_C_STO_W:
1409 /* store word from top longword. */
1410 dummy = (unsigned long) _bfd_vms_pop (abfd, NULL);
1411 image_write_w (abfd, dummy & 0xffff);
1412 break;
1414 case TIR_S_C_STO_RB:
1415 /* store repeated byte from top longword. */
1416 size = (unsigned long) _bfd_vms_pop (abfd, NULL);
1417 dummy = (unsigned long) _bfd_vms_pop (abfd, NULL);
1418 while (size-- > 0)
1419 image_write_b (abfd, dummy & 0xff);
1420 break;
1422 case TIR_S_C_STO_RW:
1423 /* store repeated word from top longword. */
1424 size = (unsigned long) _bfd_vms_pop (abfd, NULL);
1425 dummy = (unsigned long) _bfd_vms_pop (abfd, NULL);
1426 while (size-- > 0)
1427 image_write_w (abfd, dummy & 0xffff);
1428 break;
1430 case TIR_S_C_STO_RSB:
1431 case TIR_S_C_STO_RSW:
1432 case TIR_S_C_STO_RL:
1433 case TIR_S_C_STO_VPS:
1434 case TIR_S_C_STO_USB:
1435 case TIR_S_C_STO_USW:
1436 case TIR_S_C_STO_RUB:
1437 case TIR_S_C_STO_RUW:
1438 case TIR_S_C_STO_PIRR:
1439 (*_bfd_error_handler) (_("%s: not implemented"), tir_cmd_name (ptr[-1]));
1440 break;
1442 default:
1443 (*_bfd_error_handler) (_("reserved STO cmd %d"), ptr[-1]);
1444 break;
1447 return ptr;
1450 /* stack operator commands
1451 all 32 bit signed arithmetic
1452 all word just like a stack calculator
1453 arguments are popped from stack, results are pushed on stack
1455 See table 7-5 of the VAX/VMS linker manual. */
1457 static unsigned char *
1458 tir_opr (abfd, ptr)
1459 bfd *abfd;
1460 unsigned char *ptr;
1462 long op1, op2;
1464 #if VMS_DEBUG
1465 _bfd_vms_debug (5, "tir_opr %d\n", *ptr);
1466 #endif
1468 switch (*ptr++)
1470 /* operation */
1471 case TIR_S_C_OPR_NOP: /* no-op */
1472 break;
1474 case TIR_S_C_OPR_ADD: /* add */
1475 op1 = (long) _bfd_vms_pop (abfd, NULL);
1476 op2 = (long) _bfd_vms_pop (abfd, NULL);
1477 _bfd_vms_push (abfd, (uquad) (op1 + op2), -1);
1478 break;
1480 case TIR_S_C_OPR_SUB: /* subtract */
1481 op1 = (long) _bfd_vms_pop (abfd, NULL);
1482 op2 = (long) _bfd_vms_pop (abfd, NULL);
1483 _bfd_vms_push (abfd, (uquad) (op2 - op1), -1);
1484 break;
1486 case TIR_S_C_OPR_MUL: /* multiply */
1487 op1 = (long) _bfd_vms_pop (abfd, NULL);
1488 op2 = (long) _bfd_vms_pop (abfd, NULL);
1489 _bfd_vms_push (abfd, (uquad) (op1 * op2), -1);
1490 break;
1492 case TIR_S_C_OPR_DIV: /* divide */
1493 op1 = (long) _bfd_vms_pop (abfd, NULL);
1494 op2 = (long) _bfd_vms_pop (abfd, NULL);
1495 if (op2 == 0)
1496 _bfd_vms_push (abfd, (uquad) 0, -1);
1497 else
1498 _bfd_vms_push (abfd, (uquad) (op2 / op1), -1);
1499 break;
1501 case TIR_S_C_OPR_AND: /* logical and */
1502 op1 = (long) _bfd_vms_pop (abfd, NULL);
1503 op2 = (long) _bfd_vms_pop (abfd, NULL);
1504 _bfd_vms_push (abfd, (uquad) (op1 & op2), -1);
1505 break;
1507 case TIR_S_C_OPR_IOR: /* logical inclusive or */
1508 op1 = (long) _bfd_vms_pop (abfd, NULL);
1509 op2 = (long) _bfd_vms_pop (abfd, NULL);
1510 _bfd_vms_push (abfd, (uquad) (op1 | op2), -1);
1511 break;
1513 case TIR_S_C_OPR_EOR: /* logical exclusive or */
1514 op1 = (long) _bfd_vms_pop (abfd, NULL);
1515 op2 = (long) _bfd_vms_pop (abfd, NULL);
1516 _bfd_vms_push (abfd, (uquad) (op1 ^ op2), -1);
1517 break;
1519 case TIR_S_C_OPR_NEG: /* negate */
1520 op1 = (long) _bfd_vms_pop (abfd, NULL);
1521 _bfd_vms_push (abfd, (uquad) (-op1), -1);
1522 break;
1524 case TIR_S_C_OPR_COM: /* complement */
1525 op1 = (long) _bfd_vms_pop (abfd, NULL);
1526 _bfd_vms_push (abfd, (uquad) (op1 ^ -1L), -1);
1527 break;
1529 case TIR_S_C_OPR_INSV: /* insert field */
1530 (void) _bfd_vms_pop (abfd, NULL);
1531 (*_bfd_error_handler) (_("%s: not fully implemented"),
1532 tir_cmd_name (ptr[-1]));
1533 break;
1535 case TIR_S_C_OPR_ASH: /* arithmetic shift */
1536 op1 = (long) _bfd_vms_pop (abfd, NULL);
1537 op2 = (long) _bfd_vms_pop (abfd, NULL);
1538 if (HIGHBIT (op1)) /* shift right */
1539 op2 >>= op1;
1540 else /* shift left */
1541 op2 <<= op1;
1542 _bfd_vms_push (abfd, (uquad) op2, -1);
1543 (*_bfd_error_handler) (_("%s: not fully implemented"),
1544 tir_cmd_name (ptr[-1]));
1545 break;
1547 case TIR_S_C_OPR_USH: /* unsigned shift */
1548 op1 = (long) _bfd_vms_pop (abfd, NULL);
1549 op2 = (long) _bfd_vms_pop (abfd, NULL);
1550 if (HIGHBIT (op1)) /* shift right */
1551 op2 >>= op1;
1552 else /* shift left */
1553 op2 <<= op1;
1554 _bfd_vms_push (abfd, (uquad) op2, -1);
1555 (*_bfd_error_handler) (_("%s: not fully implemented"),
1556 tir_cmd_name (ptr[-1]));
1557 break;
1559 case TIR_S_C_OPR_ROT: /* rotate */
1560 op1 = (long) _bfd_vms_pop (abfd, NULL);
1561 op2 = (long) _bfd_vms_pop (abfd, NULL);
1562 if (HIGHBIT (0)) /* shift right */
1563 op2 >>= op1;
1564 else /* shift left */
1565 op2 <<= op1;
1566 _bfd_vms_push (abfd, (uquad) op2, -1);
1567 (*_bfd_error_handler) (_("%s: not fully implemented"),
1568 tir_cmd_name (ptr[-1]));
1569 break;
1571 case TIR_S_C_OPR_SEL: /* select */
1572 if ((long) _bfd_vms_pop (abfd, NULL) & 0x01L)
1573 (void) _bfd_vms_pop (abfd, NULL);
1574 else
1576 op1 = (long) _bfd_vms_pop (abfd, NULL);
1577 (void) _bfd_vms_pop (abfd, NULL);
1578 _bfd_vms_push (abfd, (uquad) op1, -1);
1580 break;
1582 case TIR_S_C_OPR_REDEF: /* Redefine symbol to current location. */
1583 case TIR_S_C_OPR_DFLIT: /* Define a literal. */
1584 (*_bfd_error_handler) (_("%s: not supported"),
1585 tir_cmd_name (ptr[-1]));
1586 break;
1588 default:
1589 (*_bfd_error_handler) (_("reserved OPR cmd %d"), ptr[-1]);
1590 break;
1593 return ptr;
1596 /* control commands
1598 See table 7-6 of the VAX/VMS linker manual. */
1600 static unsigned char *
1601 tir_ctl (bfd *abfd, unsigned char *ptr)
1603 unsigned long dummy;
1604 unsigned int psect;
1606 #if VMS_DEBUG
1607 _bfd_vms_debug (5, "tir_ctl %d\n", *ptr);
1608 #endif
1610 switch (*ptr++)
1612 case TIR_S_C_CTL_SETRB:
1613 /* Set relocation base: pop stack, set image location counter
1614 arg: none. */
1615 dummy = _bfd_vms_pop (abfd, &psect);
1616 if (psect >= PRIV (section_count))
1617 alloc_section (abfd, psect);
1618 image_set_ptr (abfd, (int) psect, (uquad) dummy);
1619 break;
1621 case TIR_S_C_CTL_AUGRB:
1622 /* Augment relocation base: increment image location counter by offset
1623 arg: lw offset value. */
1624 dummy = bfd_getl32 (ptr);
1625 image_inc_ptr (abfd, (uquad) dummy);
1626 break;
1628 case TIR_S_C_CTL_DFLOC:
1629 /* Define location: pop index, save location counter under index
1630 arg: none. */
1631 dummy = _bfd_vms_pop (abfd, NULL);
1632 (*_bfd_error_handler) (_("%s: not fully implemented"),
1633 tir_cmd_name (ptr[-1]));
1634 break;
1636 case TIR_S_C_CTL_STLOC:
1637 /* Set location: pop index, restore location counter from index
1638 arg: none. */
1639 dummy = _bfd_vms_pop (abfd, &psect);
1640 (*_bfd_error_handler) (_("%s: not fully implemented"),
1641 tir_cmd_name (ptr[-1]));
1642 break;
1644 case TIR_S_C_CTL_STKDL:
1645 /* Stack defined location: pop index, push location counter from index
1646 arg: none. */
1647 dummy = _bfd_vms_pop (abfd, &psect);
1648 (*_bfd_error_handler) (_("%s: not fully implemented"),
1649 tir_cmd_name (ptr[-1]));
1650 break;
1652 default:
1653 (*_bfd_error_handler) (_("reserved CTL cmd %d"), ptr[-1]);
1654 break;
1656 return ptr;
1659 /* Handle command from TIR section. */
1661 static unsigned char *
1662 tir_cmd (bfd *abfd, unsigned char *ptr)
1664 struct
1666 int mincod;
1667 int maxcod;
1668 unsigned char * (*explain) (bfd *, unsigned char *);
1670 tir_table[] =
1672 { 0, TIR_S_C_MAXSTACOD, tir_sta },
1673 { TIR_S_C_MINSTOCOD, TIR_S_C_MAXSTOCOD, tir_sto },
1674 { TIR_S_C_MINOPRCOD, TIR_S_C_MAXOPRCOD, tir_opr },
1675 { TIR_S_C_MINCTLCOD, TIR_S_C_MAXCTLCOD, tir_ctl },
1676 { -1, -1, NULL }
1678 int i = 0;
1680 #if VMS_DEBUG
1681 _bfd_vms_debug (4, "tir_cmd %d/%x\n", *ptr, *ptr);
1682 _bfd_hexdump (8, ptr, 16, (int) ptr);
1683 #endif
1685 if (*ptr & 0x80) /* store immediate */
1687 i = 128 - (*ptr++ & 0x7f);
1688 image_dump (abfd, ptr, i, 0);
1689 ptr += i;
1691 else
1693 while (tir_table[i].mincod >= 0)
1695 if ( (tir_table[i].mincod <= *ptr)
1696 && (*ptr <= tir_table[i].maxcod))
1698 ptr = tir_table[i].explain (abfd, ptr);
1699 break;
1701 i++;
1703 if (tir_table[i].mincod < 0)
1705 (*_bfd_error_handler) (_("obj code %d not found"), *ptr);
1706 ptr = 0;
1710 return ptr;
1713 /* Handle command from ETIR section. */
1715 static int
1716 etir_cmd (abfd, cmd, ptr)
1717 bfd *abfd;
1718 int cmd;
1719 unsigned char *ptr;
1721 static struct
1723 int mincod;
1724 int maxcod;
1725 bfd_boolean (*explain) PARAMS ((bfd *, int, unsigned char *));
1727 etir_table[] =
1729 { ETIR_S_C_MINSTACOD, ETIR_S_C_MAXSTACOD, etir_sta },
1730 { ETIR_S_C_MINSTOCOD, ETIR_S_C_MAXSTOCOD, etir_sto },
1731 { ETIR_S_C_MINOPRCOD, ETIR_S_C_MAXOPRCOD, etir_opr },
1732 { ETIR_S_C_MINCTLCOD, ETIR_S_C_MAXCTLCOD, etir_ctl },
1733 { ETIR_S_C_MINSTCCOD, ETIR_S_C_MAXSTCCOD, etir_stc },
1734 { -1, -1, NULL }
1737 int i = 0;
1739 #if VMS_DEBUG
1740 _bfd_vms_debug (4, "etir_cmd %d/%x\n", cmd, cmd);
1741 _bfd_hexdump (8, ptr, 16, (int) ptr);
1742 #endif
1744 while (etir_table[i].mincod >= 0)
1746 if ( (etir_table[i].mincod <= cmd)
1747 && (cmd <= etir_table[i].maxcod))
1749 if (!etir_table[i].explain (abfd, cmd, ptr))
1750 return -1;
1751 break;
1753 i++;
1756 #if VMS_DEBUG
1757 _bfd_vms_debug (4, "etir_cmd: = 0\n");
1758 #endif
1759 return 0;
1762 /* Text Information and Relocation Records (OBJ$C_TIR)
1763 handle tir record. */
1765 static int
1766 analyze_tir (abfd, ptr, length)
1767 bfd *abfd;
1768 unsigned char *ptr;
1769 unsigned int length;
1771 unsigned char *maxptr;
1773 #if VMS_DEBUG
1774 _bfd_vms_debug (3, "analyze_tir: %d bytes\n", length);
1775 #endif
1777 maxptr = ptr + length;
1779 while (ptr < maxptr)
1781 ptr = tir_cmd (abfd, ptr);
1782 if (ptr == 0)
1783 return -1;
1786 return 0;
1789 /* Text Information and Relocation Records (EOBJ$C_ETIR)
1790 handle etir record. */
1792 static int
1793 analyze_etir (abfd, ptr, length)
1794 bfd *abfd;
1795 unsigned char *ptr;
1796 unsigned int length;
1798 int cmd;
1799 unsigned char *maxptr;
1800 int result = 0;
1802 #if VMS_DEBUG
1803 _bfd_vms_debug (3, "analyze_etir: %d bytes\n", length);
1804 #endif
1806 maxptr = ptr + length;
1808 while (ptr < maxptr)
1810 cmd = bfd_getl16 (ptr);
1811 length = bfd_getl16 (ptr + 2);
1812 result = etir_cmd (abfd, cmd, ptr+4);
1813 if (result != 0)
1814 break;
1815 ptr += length;
1818 #if VMS_DEBUG
1819 _bfd_vms_debug (3, "analyze_etir: = %d\n", result);
1820 #endif
1822 return result;
1825 /* Process ETIR record
1826 Return 0 on success, -1 on error. */
1829 _bfd_vms_slurp_tir (abfd, objtype)
1830 bfd *abfd;
1831 int objtype;
1833 int result;
1835 #if VMS_DEBUG
1836 _bfd_vms_debug (2, "TIR/ETIR\n");
1837 #endif
1839 switch (objtype)
1841 case EOBJ_S_C_ETIR:
1842 PRIV (vms_rec) += 4; /* skip type, size */
1843 PRIV (rec_size) -= 4;
1844 result = analyze_etir (abfd, PRIV (vms_rec), (unsigned) PRIV (rec_size));
1845 break;
1846 case OBJ_S_C_TIR:
1847 PRIV (vms_rec) += 1; /* skip type */
1848 PRIV (rec_size) -= 1;
1849 result = analyze_tir (abfd, PRIV (vms_rec), (unsigned) PRIV (rec_size));
1850 break;
1851 default:
1852 result = -1;
1853 break;
1856 return result;
1859 /* Process EDBG record
1860 Return 0 on success, -1 on error
1862 Not implemented yet. */
1865 _bfd_vms_slurp_dbg (abfd, objtype)
1866 bfd *abfd;
1867 int objtype ATTRIBUTE_UNUSED;
1869 #if VMS_DEBUG
1870 _bfd_vms_debug (2, "DBG/EDBG\n");
1871 #endif
1873 abfd->flags |= (HAS_DEBUG | HAS_LINENO);
1874 return 0;
1877 /* Process ETBT record
1878 Return 0 on success, -1 on error
1880 Not implemented yet. */
1883 _bfd_vms_slurp_tbt (abfd, objtype)
1884 bfd *abfd ATTRIBUTE_UNUSED;
1885 int objtype ATTRIBUTE_UNUSED;
1887 #if VMS_DEBUG
1888 _bfd_vms_debug (2, "TBT/ETBT\n");
1889 #endif
1891 return 0;
1894 /* Process LNK record
1895 Return 0 on success, -1 on error
1897 Not implemented yet. */
1900 _bfd_vms_slurp_lnk (abfd, objtype)
1901 bfd *abfd ATTRIBUTE_UNUSED;
1902 int objtype ATTRIBUTE_UNUSED;
1904 #if VMS_DEBUG
1905 _bfd_vms_debug (2, "LNK\n");
1906 #endif
1908 return 0;
1911 /* WRITE ETIR SECTION
1913 This is still under construction and therefore not documented. */
1915 static void start_etir_record
1916 PARAMS ((bfd *abfd, int index, uquad offset, bfd_boolean justoffset));
1917 static void sto_imm
1918 PARAMS ((bfd *abfd, vms_section *sptr, bfd_vma vaddr, int index));
1919 static void end_etir_record
1920 PARAMS ((bfd *abfd));
1922 static void
1923 sto_imm (abfd, sptr, vaddr, index)
1924 bfd *abfd;
1925 vms_section *sptr;
1926 bfd_vma vaddr;
1927 int index;
1929 int size;
1930 int ssize;
1931 unsigned char *cptr;
1933 #if VMS_DEBUG
1934 _bfd_vms_debug (8, "sto_imm %d bytes\n", sptr->size);
1935 _bfd_hexdump (9, sptr->contents, (int) sptr->size, (int) vaddr);
1936 #endif
1938 ssize = sptr->size;
1939 cptr = sptr->contents;
1941 while (ssize > 0)
1943 size = ssize; /* try all the rest */
1945 if (_bfd_vms_output_check (abfd, size) < 0)
1946 { /* doesn't fit, split ! */
1947 end_etir_record (abfd);
1948 start_etir_record (abfd, index, vaddr, FALSE);
1949 size = _bfd_vms_output_check (abfd, 0); /* get max size */
1950 if (size > ssize) /* more than what's left ? */
1951 size = ssize;
1954 _bfd_vms_output_begin (abfd, ETIR_S_C_STO_IMM, -1);
1955 _bfd_vms_output_long (abfd, (unsigned long) (size));
1956 _bfd_vms_output_dump (abfd, cptr, size);
1957 _bfd_vms_output_flush (abfd);
1959 #if VMS_DEBUG
1960 _bfd_vms_debug (10, "dumped %d bytes\n", size);
1961 _bfd_hexdump (10, cptr, (int) size, (int) vaddr);
1962 #endif
1964 vaddr += size;
1965 ssize -= size;
1966 cptr += size;
1970 /* Start ETIR record for section #index at virtual addr offset. */
1972 static void
1973 start_etir_record (abfd, index, offset, justoffset)
1974 bfd *abfd;
1975 int index;
1976 uquad offset;
1977 bfd_boolean justoffset;
1979 if (!justoffset)
1981 _bfd_vms_output_begin (abfd, EOBJ_S_C_ETIR, -1); /* one ETIR per section */
1982 _bfd_vms_output_push (abfd);
1985 _bfd_vms_output_begin (abfd, ETIR_S_C_STA_PQ, -1); /* push start offset */
1986 _bfd_vms_output_long (abfd, (unsigned long) index);
1987 _bfd_vms_output_quad (abfd, (uquad) offset);
1988 _bfd_vms_output_flush (abfd);
1990 _bfd_vms_output_begin (abfd, ETIR_S_C_CTL_SETRB, -1); /* start = pop () */
1991 _bfd_vms_output_flush (abfd);
1994 /* End etir record. */
1996 static void
1997 end_etir_record (abfd)
1998 bfd *abfd;
2000 _bfd_vms_output_pop (abfd);
2001 _bfd_vms_output_end (abfd);
2004 /* Write section contents for bfd abfd. */
2007 _bfd_vms_write_tir (abfd, objtype)
2008 bfd *abfd;
2009 int objtype ATTRIBUTE_UNUSED;
2011 asection *section;
2012 vms_section *sptr;
2013 int nextoffset;
2015 #if VMS_DEBUG
2016 _bfd_vms_debug (2, "vms_write_tir (%p, %d)\n", abfd, objtype);
2017 #endif
2019 _bfd_vms_output_alignment (abfd, 4);
2021 nextoffset = 0;
2022 PRIV (vms_linkage_index) = 1;
2024 /* Dump all other sections. */
2026 section = abfd->sections;
2028 while (section != NULL)
2031 #if VMS_DEBUG
2032 _bfd_vms_debug (4, "writing %d. section '%s' (%d bytes)\n",
2033 section->index, section->name,
2034 (int) (section->_raw_size));
2035 #endif
2037 if (section->flags & SEC_RELOC)
2039 int i;
2041 if ((i = section->reloc_count) <= 0)
2043 (*_bfd_error_handler) (_("SEC_RELOC with no relocs in section %s"),
2044 section->name);
2046 #if VMS_DEBUG
2047 else
2049 arelent **rptr;
2050 _bfd_vms_debug (4, "%d relocations:\n", i);
2051 rptr = section->orelocation;
2052 while (i-- > 0)
2054 _bfd_vms_debug (4, "sym %s in sec %s, value %08lx, addr %08lx, off %08lx, len %d: %s\n",
2055 (*(*rptr)->sym_ptr_ptr)->name,
2056 (*(*rptr)->sym_ptr_ptr)->section->name,
2057 (long) (*(*rptr)->sym_ptr_ptr)->value,
2058 (*rptr)->address, (*rptr)->addend,
2059 bfd_get_reloc_size ((*rptr)->howto),
2060 (*rptr)->howto->name);
2061 rptr++;
2064 #endif
2067 if ((section->flags & SEC_HAS_CONTENTS)
2068 && (! bfd_is_com_section (section)))
2070 bfd_vma vaddr; /* Virtual addr in section. */
2072 sptr = _bfd_get_vms_section (abfd, section->index);
2073 if (sptr == NULL)
2075 bfd_set_error (bfd_error_no_contents);
2076 return -1;
2079 vaddr = (bfd_vma) (sptr->offset);
2081 start_etir_record (abfd, section->index, (uquad) sptr->offset,
2082 FALSE);
2084 while (sptr != NULL) /* one STA_PQ, CTL_SETRB per vms_section */
2087 if (section->flags & SEC_RELOC) /* check for relocs */
2089 arelent **rptr = section->orelocation;
2090 int i = section->reloc_count;
2092 for (;;)
2094 bfd_size_type addr = (*rptr)->address;
2095 bfd_size_type len = bfd_get_reloc_size ((*rptr)->howto);
2096 if (sptr->offset < addr) /* sptr starts before reloc */
2098 bfd_size_type before = addr - sptr->offset;
2099 if (sptr->size <= before) /* complete before */
2101 sto_imm (abfd, sptr, vaddr, section->index);
2102 vaddr += sptr->size;
2103 break;
2105 else /* partly before */
2107 int after = sptr->size - before;
2108 sptr->size = before;
2109 sto_imm (abfd, sptr, vaddr, section->index);
2110 vaddr += sptr->size;
2111 sptr->contents += before;
2112 sptr->offset += before;
2113 sptr->size = after;
2116 else if (sptr->offset == addr) /* sptr starts at reloc */
2118 asymbol *sym = *(*rptr)->sym_ptr_ptr;
2119 asection *sec = sym->section;
2121 switch ((*rptr)->howto->type)
2123 case ALPHA_R_IGNORE:
2124 break;
2126 case ALPHA_R_REFLONG:
2128 if (bfd_is_und_section (sym->section))
2130 int slen = strlen ((char *) sym->name);
2131 char *hash;
2133 if (_bfd_vms_output_check (abfd, slen) < 0)
2135 end_etir_record (abfd);
2136 start_etir_record (abfd,
2137 section->index,
2138 vaddr, FALSE);
2140 _bfd_vms_output_begin (abfd,
2141 ETIR_S_C_STO_GBL_LW,
2142 -1);
2143 hash = (_bfd_vms_length_hash_symbol
2144 (abfd, sym->name, EOBJ_S_C_SYMSIZ));
2145 _bfd_vms_output_counted (abfd, hash);
2146 _bfd_vms_output_flush (abfd);
2148 else if (bfd_is_abs_section (sym->section))
2150 if (_bfd_vms_output_check (abfd, 16) < 0)
2152 end_etir_record (abfd);
2153 start_etir_record (abfd,
2154 section->index,
2155 vaddr, FALSE);
2157 _bfd_vms_output_begin (abfd,
2158 ETIR_S_C_STA_LW,
2159 -1);
2160 _bfd_vms_output_quad (abfd,
2161 (uquad) sym->value);
2162 _bfd_vms_output_flush (abfd);
2163 _bfd_vms_output_begin (abfd,
2164 ETIR_S_C_STO_LW,
2165 -1);
2166 _bfd_vms_output_flush (abfd);
2168 else
2170 if (_bfd_vms_output_check (abfd, 32) < 0)
2172 end_etir_record (abfd);
2173 start_etir_record (abfd,
2174 section->index,
2175 vaddr, FALSE);
2177 _bfd_vms_output_begin (abfd,
2178 ETIR_S_C_STA_PQ,
2179 -1);
2180 _bfd_vms_output_long (abfd,
2181 (unsigned long) (sec->index));
2182 _bfd_vms_output_quad (abfd,
2183 ((uquad) (*rptr)->addend
2184 + (uquad) sym->value));
2185 _bfd_vms_output_flush (abfd);
2186 _bfd_vms_output_begin (abfd,
2187 ETIR_S_C_STO_LW,
2188 -1);
2189 _bfd_vms_output_flush (abfd);
2192 break;
2194 case ALPHA_R_REFQUAD:
2196 if (bfd_is_und_section (sym->section))
2198 int slen = strlen ((char *) sym->name);
2199 char *hash;
2200 if (_bfd_vms_output_check (abfd, slen) < 0)
2202 end_etir_record (abfd);
2203 start_etir_record (abfd,
2204 section->index,
2205 vaddr, FALSE);
2207 _bfd_vms_output_begin (abfd,
2208 ETIR_S_C_STO_GBL,
2209 -1);
2210 hash = (_bfd_vms_length_hash_symbol
2211 (abfd, sym->name, EOBJ_S_C_SYMSIZ));
2212 _bfd_vms_output_counted (abfd, hash);
2213 _bfd_vms_output_flush (abfd);
2215 else if (bfd_is_abs_section (sym->section))
2217 if (_bfd_vms_output_check (abfd, 16) < 0)
2219 end_etir_record (abfd);
2220 start_etir_record (abfd,
2221 section->index,
2222 vaddr, FALSE);
2224 _bfd_vms_output_begin (abfd,
2225 ETIR_S_C_STA_QW,
2226 -1);
2227 _bfd_vms_output_quad (abfd,
2228 (uquad) sym->value);
2229 _bfd_vms_output_flush (abfd);
2230 _bfd_vms_output_begin (abfd,
2231 ETIR_S_C_STO_QW,
2232 -1);
2233 _bfd_vms_output_flush (abfd);
2235 else
2237 if (_bfd_vms_output_check (abfd, 32) < 0)
2239 end_etir_record (abfd);
2240 start_etir_record (abfd,
2241 section->index,
2242 vaddr, FALSE);
2244 _bfd_vms_output_begin (abfd,
2245 ETIR_S_C_STA_PQ,
2246 -1);
2247 _bfd_vms_output_long (abfd,
2248 (unsigned long) (sec->index));
2249 _bfd_vms_output_quad (abfd,
2250 ((uquad) (*rptr)->addend
2251 + (uquad) sym->value));
2252 _bfd_vms_output_flush (abfd);
2253 _bfd_vms_output_begin (abfd,
2254 ETIR_S_C_STO_OFF,
2255 -1);
2256 _bfd_vms_output_flush (abfd);
2259 break;
2261 case ALPHA_R_HINT:
2263 int hint_size;
2264 char *hash ATTRIBUTE_UNUSED;
2266 hint_size = sptr->size;
2267 sptr->size = len;
2268 sto_imm (abfd, sptr, vaddr, section->index);
2269 sptr->size = hint_size;
2270 #if 0
2271 vms_output_begin (abfd,
2272 ETIR_S_C_STO_HINT_GBL, -1);
2273 vms_output_long (abfd,
2274 (unsigned long) (sec->index));
2275 vms_output_quad (abfd, (uquad) addr);
2277 hash = (_bfd_vms_length_hash_symbol
2278 (abfd, sym->name, EOBJ_S_C_SYMSIZ));
2279 vms_output_counted (abfd, hash);
2281 vms_output_flush (abfd);
2282 #endif
2284 break;
2285 case ALPHA_R_LINKAGE:
2287 char *hash;
2289 if (_bfd_vms_output_check (abfd, 64) < 0)
2291 end_etir_record (abfd);
2292 start_etir_record (abfd, section->index,
2293 vaddr, FALSE);
2295 _bfd_vms_output_begin (abfd,
2296 ETIR_S_C_STC_LP_PSB,
2297 -1);
2298 _bfd_vms_output_long (abfd,
2299 (unsigned long) PRIV (vms_linkage_index));
2300 PRIV (vms_linkage_index) += 2;
2301 hash = (_bfd_vms_length_hash_symbol
2302 (abfd, sym->name, EOBJ_S_C_SYMSIZ));
2303 _bfd_vms_output_counted (abfd, hash);
2304 _bfd_vms_output_byte (abfd, 0);
2305 _bfd_vms_output_flush (abfd);
2307 break;
2309 case ALPHA_R_CODEADDR:
2311 int slen = strlen ((char *) sym->name);
2312 char *hash;
2313 if (_bfd_vms_output_check (abfd, slen) < 0)
2315 end_etir_record (abfd);
2316 start_etir_record (abfd,
2317 section->index,
2318 vaddr, FALSE);
2320 _bfd_vms_output_begin (abfd,
2321 ETIR_S_C_STO_CA,
2322 -1);
2323 hash = (_bfd_vms_length_hash_symbol
2324 (abfd, sym->name, EOBJ_S_C_SYMSIZ));
2325 _bfd_vms_output_counted (abfd, hash);
2326 _bfd_vms_output_flush (abfd);
2328 break;
2330 default:
2331 (*_bfd_error_handler) (_("Unhandled relocation %s"),
2332 (*rptr)->howto->name);
2333 break;
2336 vaddr += len;
2338 if (len == sptr->size)
2340 break;
2342 else
2344 sptr->contents += len;
2345 sptr->offset += len;
2346 sptr->size -= len;
2347 i--;
2348 rptr++;
2351 else /* sptr starts after reloc */
2353 i--; /* check next reloc */
2354 rptr++;
2357 if (i==0) /* all reloc checked */
2359 if (sptr->size > 0)
2361 /* dump rest */
2362 sto_imm (abfd, sptr, vaddr, section->index);
2363 vaddr += sptr->size;
2365 break;
2367 } /* for (;;) */
2368 } /* if SEC_RELOC */
2369 else /* no relocs, just dump */
2371 sto_imm (abfd, sptr, vaddr, section->index);
2372 vaddr += sptr->size;
2375 sptr = sptr->next;
2377 } /* while (sptr != 0) */
2379 end_etir_record (abfd);
2381 } /* has_contents */
2383 section = section->next;
2386 _bfd_vms_output_alignment (abfd, 2);
2387 return 0;
2390 /* Write traceback data for bfd abfd. */
2393 _bfd_vms_write_tbt (abfd, objtype)
2394 bfd *abfd ATTRIBUTE_UNUSED;
2395 int objtype ATTRIBUTE_UNUSED;
2397 #if VMS_DEBUG
2398 _bfd_vms_debug (2, "vms_write_tbt (%p, %d)\n", abfd, objtype);
2399 #endif
2401 return 0;
2404 /* Write debug info for bfd abfd. */
2407 _bfd_vms_write_dbg (abfd, objtype)
2408 bfd *abfd ATTRIBUTE_UNUSED;
2409 int objtype ATTRIBUTE_UNUSED;
2411 #if VMS_DEBUG
2412 _bfd_vms_debug (2, "vms_write_dbg (%p, objtype)\n", abfd, objtype);
2413 #endif
2415 return 0;