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