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