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