Annotation of src/external/gpl3/binutils.old/dist/gas/config/tc-i370.c, Revision 1.3
1.1 christos 1: /* tc-i370.c -- Assembler for the IBM 360/370/390 instruction set.
2: Loosely based on the ppc files by Linas Vepstas <linas@linas.org> 1998, 99
1.3 ! christos 3: Copyright (C) 1994-2015 Free Software Foundation, Inc.
1.1 christos 4: Written by Ian Lance Taylor, Cygnus Support.
5:
6: This file is part of GAS, the GNU Assembler.
7:
8: GAS is free software; you can redistribute it and/or modify
9: it under the terms of the GNU General Public License as published by
10: the Free Software Foundation; either version 3, or (at your option)
11: any later version.
12:
13: GAS is distributed in the hope that it will be useful,
14: but WITHOUT ANY WARRANTY; without even the implied warranty of
15: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16: GNU General Public License for more details.
17:
18: You should have received a copy of the GNU General Public License
19: along with GAS; see the file COPYING. If not, write to the Free
20: Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
21: 02110-1301, USA. */
22:
23: /* This assembler implements a very hacked version of an elf-like thing
24: that gcc emits (when gcc is suitably hacked). To make it behave more
25: HLASM-like, try turning on the -M or --mri flag (as there are various
26: similarities between HLASM and the MRI assemblers, such as section
27: names, lack of leading . in pseudo-ops, DC and DS, etc. */
28:
29: #include "as.h"
30: #include "safe-ctype.h"
31: #include "subsegs.h"
32: #include "struc-symbol.h"
33:
34: #include "opcode/i370.h"
35:
36: #ifdef OBJ_ELF
37: #include "elf/i370.h"
38: #endif
39:
40: /* This is the assembler for the System/390 Architecture. */
41:
42: /* Tell the main code what the endianness is. */
43: extern int target_big_endian;
44:
45:
46: /* Generic assembler global variables which must be defined by all
47: targets. */
48:
49: #ifdef OBJ_ELF
50: /* This string holds the chars that always start a comment. If the
51: pre-processor is disabled, these aren't very useful. The macro
52: tc_comment_chars points to this. We use this, rather than the
53: usual comment_chars, so that we can switch for Solaris conventions. */
54: static const char i370_eabi_comment_chars[] = "#";
55:
56: const char *i370_comment_chars = i370_eabi_comment_chars;
57: #else
58: const char comment_chars[] = "#";
59: #endif
60:
61: /* Characters which start a comment at the beginning of a line. */
62: const char line_comment_chars[] = "#*";
63:
64: /* Characters which may be used to separate multiple commands on a
65: single line. */
66: const char line_separator_chars[] = ";";
67:
68: /* Characters which are used to indicate an exponent in a floating
69: point number. */
70: const char EXP_CHARS[] = "eE";
71:
72: /* Characters which mean that a number is a floating point constant,
73: as in 0d1.0. */
74: const char FLT_CHARS[] = "dD";
75:
76: void
77: md_show_usage (FILE *stream)
78: {
79: fprintf (stream, "\
80: S/370 options: (these have not yet been tested and may not work) \n\
81: -u ignored\n\
82: -mregnames Allow symbolic names for registers\n\
83: -mno-regnames Do not allow symbolic names for registers\n");
84: #ifdef OBJ_ELF
85: fprintf (stream, "\
86: -mrelocatable support for GCC's -mrelocatble option\n\
87: -mrelocatable-lib support for GCC's -mrelocatble-lib option\n\
88: -V print assembler version number\n");
89: #endif
90: }
91:
92: /* Whether to use user friendly register names. */
93: #define TARGET_REG_NAMES_P TRUE
94:
95: static bfd_boolean reg_names_p = TARGET_REG_NAMES_P;
96:
97:
98: /* Predefined register names if -mregnames
99: In general, there are lots of them, in an attempt to be compatible
100: with a number of assemblers. */
101:
102: /* Structure to hold information about predefined registers. */
103: struct pd_reg
104: {
105: char *name;
106: int value;
107: };
108:
109: /* List of registers that are pre-defined:
110:
111: Each general register has predefined names of the form:
112: 1. r<reg_num> which has the value <reg_num>.
113: 2. r.<reg_num> which has the value <reg_num>.
114:
115: Each floating point register has predefined names of the form:
116: 1. f<reg_num> which has the value <reg_num>.
117: 2. f.<reg_num> which has the value <reg_num>.
118:
119: There are only four floating point registers, and these are
120: commonly labelled 0,2,4 and 6. Thus, there is no f1, f3, etc.
121:
122: There are individual registers as well:
123: rbase or r.base has the value 3 (base register)
124: rpgt or r.pgt has the value 4 (page origin table pointer)
125: rarg or r.arg has the value 11 (argument pointer)
126: rtca or r.tca has the value 12 (table of contents pointer)
127: rtoc or r.toc has the value 12 (table of contents pointer)
128: sp or r.sp has the value 13 (stack pointer)
129: dsa or r.dsa has the value 13 (stack pointer)
130: lr has the value 14 (link reg)
131:
132: The table is sorted. Suitable for searching by a binary search. */
133:
134: static const struct pd_reg pre_defined_registers[] =
135: {
136: { "arg", 11 }, /* Argument Pointer. */
137: { "base", 3 }, /* Base Reg. */
138:
139: { "f.0", 0 }, /* Floating point registers. */
140: { "f.2", 2 },
141: { "f.4", 4 },
142: { "f.6", 6 },
143:
144: { "f0", 0 },
145: { "f2", 2 },
146: { "f4", 4 },
147: { "f6", 6 },
148:
149: { "dsa",13 }, /* Stack pointer. */
150: { "lr", 14 }, /* Link Register. */
151: { "pgt", 4 }, /* Page Origin Table Pointer. */
152:
153: { "r.0", 0 }, /* General Purpose Registers. */
154: { "r.1", 1 },
155: { "r.10", 10 },
156: { "r.11", 11 },
157: { "r.12", 12 },
158: { "r.13", 13 },
159: { "r.14", 14 },
160: { "r.15", 15 },
161: { "r.2", 2 },
162: { "r.3", 3 },
163: { "r.4", 4 },
164: { "r.5", 5 },
165: { "r.6", 6 },
166: { "r.7", 7 },
167: { "r.8", 8 },
168: { "r.9", 9 },
169:
170: { "r.arg", 11 }, /* Argument Pointer. */
171: { "r.base", 3 }, /* Base Reg. */
172: { "r.dsa", 13 }, /* Stack Pointer. */
173: { "r.pgt", 4 }, /* Page Origin Table Pointer. */
174: { "r.sp", 13 }, /* Stack Pointer. */
175:
176: { "r.tca", 12 }, /* Pointer to the table of contents. */
177: { "r.toc", 12 }, /* Pointer to the table of contents. */
178:
179: { "r0", 0 }, /* More general purpose registers. */
180: { "r1", 1 },
181: { "r10", 10 },
182: { "r11", 11 },
183: { "r12", 12 },
184: { "r13", 13 },
185: { "r14", 14 },
186: { "r15", 15 },
187: { "r2", 2 },
188: { "r3", 3 },
189: { "r4", 4 },
190: { "r5", 5 },
191: { "r6", 6 },
192: { "r7", 7 },
193: { "r8", 8 },
194: { "r9", 9 },
195:
196: { "rbase", 3 }, /* Base Reg. */
197:
198: { "rtca", 12 }, /* Pointer to the table of contents. */
199: { "rtoc", 12 }, /* Pointer to the table of contents. */
200:
201: { "sp", 13 }, /* Stack Pointer. */
202:
203: };
204:
205: #define REG_NAME_CNT (sizeof (pre_defined_registers) / sizeof (struct pd_reg))
206:
207: /* Given NAME, find the register number associated with that name, return
208: the integer value associated with the given name or -1 on failure. */
209:
210: static int
211: reg_name_search (const struct pd_reg *regs,
212: int regcount,
213: const char *name)
214: {
215: int middle, low, high;
216: int cmp;
217:
218: low = 0;
219: high = regcount - 1;
220:
221: do
222: {
223: middle = (low + high) / 2;
224: cmp = strcasecmp (name, regs[middle].name);
225: if (cmp < 0)
226: high = middle - 1;
227: else if (cmp > 0)
228: low = middle + 1;
229: else
230: return regs[middle].value;
231: }
232: while (low <= high);
233:
234: return -1;
235: }
236:
237: /* Summary of register_name().
238:
239: in: Input_line_pointer points to 1st char of operand.
240:
241: out: An expressionS.
242: The operand may have been a register: in this case, X_op == O_register,
243: X_add_number is set to the register number, and truth is returned.
244: Input_line_pointer->(next non-blank) char after operand, or is in its
245: original state. */
246:
247: static bfd_boolean
248: register_name (expressionS *expressionP)
249: {
250: int reg_number;
251: char *name;
252: char *start;
253: char c;
254:
255: /* Find the spelling of the operand. */
256: start = name = input_line_pointer;
257: if (name[0] == '%' && ISALPHA (name[1]))
258: name = ++input_line_pointer;
259:
260: else if (!reg_names_p)
261: return FALSE;
262:
263: while (' ' == *name)
264: name = ++input_line_pointer;
265:
266: /* If it's a number, treat it as a number. If it's alpha, look to
267: see if it's in the register table. */
268: if (!ISALPHA (name[0]))
269: reg_number = get_single_number ();
270: else
271: {
1.3 ! christos 272: c = get_symbol_name (&name);
1.1 christos 273: reg_number = reg_name_search (pre_defined_registers, REG_NAME_CNT, name);
274:
275: /* Put back the delimiting char. */
1.3 ! christos 276: (void) restore_line_pointer (c);
1.1 christos 277: }
278:
279: /* If numeric, make sure its not out of bounds. */
280: if ((0 <= reg_number) && (16 >= reg_number))
281: {
282: expressionP->X_op = O_register;
283: expressionP->X_add_number = reg_number;
284:
285: /* Make the rest nice. */
286: expressionP->X_add_symbol = NULL;
287: expressionP->X_op_symbol = NULL;
288: return TRUE;
289: }
290:
291: /* Reset the line as if we had not done anything. */
292: input_line_pointer = start;
293: return FALSE;
294: }
295:
296: /* Local variables. */
297:
298: /* The type of processor we are assembling for. This is one or more
299: of the I370_OPCODE flags defined in opcode/i370.h. */
300: static int i370_cpu = 0;
301:
302: /* The base register to use for opcode with optional operands.
303: We define two of these: "text" and "other". Normally, "text"
304: would get used in the .text section for branches, while "other"
305: gets used in the .data section for address constants.
306:
307: The idea of a second base register in a different section
308: is foreign to the usual HLASM-style semantics; however, it
309: allows us to provide support for dynamically loaded libraries,
310: by allowing us to place address constants in a section other
311: than the text section. The "other" section need not be the
312: .data section, it can be any section that isn't the .text section.
313:
314: Note that HLASM defines a multiple, concurrent .using semantic
315: that we do not: in calculating offsets, it uses either the most
316: recent .using directive, or the one with the smallest displacement.
317: This allows HLASM to support a quasi-block-scope-like behaviour.
318: Handy for people writing assembly by hand ... but not supported
319: by us. */
320: static int i370_using_text_regno = -1;
321: static int i370_using_other_regno = -1;
322:
323: /* The base address for address literals. */
324: static expressionS i370_using_text_baseaddr;
325: static expressionS i370_using_other_baseaddr;
326:
327: /* the "other" section, used only for syntax error detection. */
328: static segT i370_other_section = undefined_section;
329:
330: /* Opcode hash table. */
331: static struct hash_control *i370_hash;
332:
333: /* Macro hash table. */
334: static struct hash_control *i370_macro_hash;
335:
336: #ifdef OBJ_ELF
337: /* What type of shared library support to use. */
338: static enum { SHLIB_NONE, SHLIB_PIC, SHILB_MRELOCATABLE } shlib = SHLIB_NONE;
339: #endif
340:
341: /* Flags to set in the elf header. */
342: static flagword i370_flags = 0;
343:
344: #ifndef WORKING_DOT_WORD
345: int md_short_jump_size = 4;
346: int md_long_jump_size = 4;
347: #endif
348:
349: #ifdef OBJ_ELF
350: const char *md_shortopts = "l:um:K:VQ:";
351: #else
352: const char *md_shortopts = "um:";
353: #endif
354: struct option md_longopts[] =
355: {
356: {NULL, no_argument, NULL, 0}
357: };
358: size_t md_longopts_size = sizeof (md_longopts);
359:
360: int
361: md_parse_option (int c, char *arg)
362: {
363: switch (c)
364: {
365: case 'u':
366: /* -u means that any undefined symbols should be treated as
367: external, which is the default for gas anyhow. */
368: break;
369:
370: #ifdef OBJ_ELF
371: case 'K':
372: /* Recognize -K PIC */
373: if (strcmp (arg, "PIC") == 0 || strcmp (arg, "pic") == 0)
374: {
375: shlib = SHLIB_PIC;
376: i370_flags |= EF_I370_RELOCATABLE_LIB;
377: }
378: else
379: return 0;
380:
381: break;
382: #endif
383:
384: case 'm':
385:
386: /* -m360 mean to assemble for the ancient 360 architecture. */
387: if (strcmp (arg, "360") == 0 || strcmp (arg, "i360") == 0)
388: i370_cpu = I370_OPCODE_360;
389: /* -mxa means to assemble for the IBM 370 XA. */
390: else if (strcmp (arg, "xa") == 0)
391: i370_cpu = I370_OPCODE_370_XA;
392: /* -many means to assemble for any architecture (370/XA). */
393: else if (strcmp (arg, "any") == 0)
394: i370_cpu = I370_OPCODE_370;
395:
396: else if (strcmp (arg, "regnames") == 0)
397: reg_names_p = TRUE;
398:
399: else if (strcmp (arg, "no-regnames") == 0)
400: reg_names_p = FALSE;
401:
402: #ifdef OBJ_ELF
403: /* -mrelocatable/-mrelocatable-lib -- warn about
404: initializations that require relocation. */
405: else if (strcmp (arg, "relocatable") == 0)
406: {
407: shlib = SHILB_MRELOCATABLE;
408: i370_flags |= EF_I370_RELOCATABLE;
409: }
410: else if (strcmp (arg, "relocatable-lib") == 0)
411: {
412: shlib = SHILB_MRELOCATABLE;
413: i370_flags |= EF_I370_RELOCATABLE_LIB;
414: }
415: #endif
416: else
417: {
418: as_bad (_("invalid switch -m%s"), arg);
419: return 0;
420: }
421: break;
422:
423: #ifdef OBJ_ELF
424: /* -V: SVR4 argument to print version ID. */
425: case 'V':
426: print_version_id ();
427: break;
428:
429: /* -Qy, -Qn: SVR4 arguments controlling whether a .comment section
430: should be emitted or not. FIXME: Not implemented. */
431: case 'Q':
432: break;
433:
434: #endif
435:
436: default:
437: return 0;
438: }
439:
440: return 1;
441: }
442:
443:
444: /* Set i370_cpu if it is not already set.
445: Currently defaults to the reasonable superset;
446: but can be made more fine grained if desred. */
447:
448: static void
449: i370_set_cpu (void)
450: {
451: const char *default_os = TARGET_OS;
452: const char *default_cpu = TARGET_CPU;
453:
454: /* Override with the superset for the moment. */
455: i370_cpu = I370_OPCODE_ESA390_SUPERSET;
456: if (i370_cpu == 0)
457: {
458: if (strcmp (default_cpu, "i360") == 0)
459: i370_cpu = I370_OPCODE_360;
460: else if (strcmp (default_cpu, "i370") == 0)
461: i370_cpu = I370_OPCODE_370;
462: else if (strcmp (default_cpu, "XA") == 0)
463: i370_cpu = I370_OPCODE_370_XA;
464: else
465: as_fatal ("Unknown default cpu = %s, os = %s", default_cpu, default_os);
466: }
467: }
468:
469: /* Figure out the BFD architecture to use.
470: FIXME: specify the different 370 architectures. */
471:
472: enum bfd_architecture
473: i370_arch (void)
474: {
475: return bfd_arch_i370;
476: }
477:
478: /* This function is called when the assembler starts up. It is called
479: after the options have been parsed and the output file has been
480: opened. */
481:
482: void
483: md_begin (void)
484: {
485: const struct i370_opcode *op;
486: const struct i370_opcode *op_end;
487: const struct i370_macro *macro;
488: const struct i370_macro *macro_end;
489: bfd_boolean dup_insn = FALSE;
490:
491: i370_set_cpu ();
492:
493: #ifdef OBJ_ELF
494: /* Set the ELF flags if desired. */
495: if (i370_flags)
496: bfd_set_private_flags (stdoutput, i370_flags);
497: #endif
498:
499: /* Insert the opcodes into a hash table. */
500: i370_hash = hash_new ();
501:
502: op_end = i370_opcodes + i370_num_opcodes;
503: for (op = i370_opcodes; op < op_end; op++)
504: {
505: know ((op->opcode.i[0] & op->mask.i[0]) == op->opcode.i[0]
506: && (op->opcode.i[1] & op->mask.i[1]) == op->opcode.i[1]);
507:
508: if ((op->flags & i370_cpu) != 0)
509: {
510: const char *retval;
511:
512: retval = hash_insert (i370_hash, op->name, (void *) op);
513: if (retval != (const char *) NULL)
514: {
515: as_bad (_("Internal assembler error for instruction %s"), op->name);
516: dup_insn = TRUE;
517: }
518: }
519: }
520:
521: /* Insert the macros into a hash table. */
522: i370_macro_hash = hash_new ();
523:
524: macro_end = i370_macros + i370_num_macros;
525: for (macro = i370_macros; macro < macro_end; macro++)
526: {
527: if ((macro->flags & i370_cpu) != 0)
528: {
529: const char *retval;
530:
531: retval = hash_insert (i370_macro_hash, macro->name, (void *) macro);
532: if (retval != (const char *) NULL)
533: {
534: as_bad (_("Internal assembler error for macro %s"), macro->name);
535: dup_insn = TRUE;
536: }
537: }
538: }
539:
540: if (dup_insn)
541: abort ();
542: }
543:
544: /* Insert an operand value into an instruction. */
545:
546: static i370_insn_t
547: i370_insert_operand (i370_insn_t insn,
548: const struct i370_operand *operand,
549: offsetT val)
550: {
551: if (operand->insert)
552: {
553: const char *errmsg;
554:
555: /* Used for 48-bit insn's. */
556: errmsg = NULL;
557: insn = (*operand->insert) (insn, (long) val, &errmsg);
558: if (errmsg)
559: as_bad ("%s", errmsg);
560: }
561: else
562: /* This is used only for 16, 32 bit insn's. */
563: insn.i[0] |= (((long) val & ((1 << operand->bits) - 1))
564: << operand->shift);
565:
566: return insn;
567: }
568:
569:
570: #ifdef OBJ_ELF
571: /* Parse @got, etc. and return the desired relocation.
572: Currently, i370 does not support (don't really need to support) any
573: of these fancier markups ... for example, no one is going to
574: write 'L 6,=V(bogus)@got' it just doesn't make sense (at least to me).
575: So basically, we could get away with this routine returning
576: BFD_RELOC_UNUSED in all circumstances. However, I'll leave
577: in for now in case someone ambitious finds a good use for this stuff ...
578: this routine was pretty much just copied from the powerpc code ... */
579:
580: static bfd_reloc_code_real_type
581: i370_elf_suffix (char **str_p, expressionS *exp_p)
582: {
583: struct map_bfd
584: {
585: char *string;
586: int length;
587: bfd_reloc_code_real_type reloc;
588: };
589:
590: char ident[20];
591: char *str = *str_p;
592: char *str2;
593: int ch;
594: int len;
595: struct map_bfd *ptr;
596:
597: #define MAP(str,reloc) { str, sizeof (str) - 1, reloc }
598:
599: static struct map_bfd mapping[] =
600: {
601: /* warnings with -mrelocatable. */
602: MAP ("fixup", BFD_RELOC_CTOR),
603: { (char *)0, 0, BFD_RELOC_UNUSED }
604: };
605:
606: if (*str++ != '@')
607: return BFD_RELOC_UNUSED;
608:
609: for (ch = *str, str2 = ident;
610: (str2 < ident + sizeof (ident) - 1
611: && (ISALNUM (ch) || ch == '@'));
612: ch = *++str)
613: *str2++ = TOLOWER (ch);
614:
615: *str2 = '\0';
616: len = str2 - ident;
617:
618: ch = ident[0];
619: for (ptr = &mapping[0]; ptr->length > 0; ptr++)
620: if (ch == ptr->string[0]
621: && len == ptr->length
622: && memcmp (ident, ptr->string, ptr->length) == 0)
623: {
624: if (exp_p->X_add_number != 0
625: && (ptr->reloc == BFD_RELOC_16_GOTOFF
626: || ptr->reloc == BFD_RELOC_LO16_GOTOFF
627: || ptr->reloc == BFD_RELOC_HI16_GOTOFF
628: || ptr->reloc == BFD_RELOC_HI16_S_GOTOFF))
629: as_warn (_("identifier+constant@got means identifier@got+constant"));
630:
631: /* Now check for identifier@suffix+constant */
632: if (*str == '-' || *str == '+')
633: {
634: char *orig_line = input_line_pointer;
635: expressionS new_exp;
636:
637: input_line_pointer = str;
638: expression (&new_exp);
639: if (new_exp.X_op == O_constant)
640: {
641: exp_p->X_add_number += new_exp.X_add_number;
642: str = input_line_pointer;
643: }
644:
645: if (&input_line_pointer != str_p)
646: input_line_pointer = orig_line;
647: }
648:
649: *str_p = str;
650: return ptr->reloc;
651: }
652:
653: return BFD_RELOC_UNUSED;
654: }
655:
656: /* Like normal .long/.short/.word, except support @got, etc.
657: Clobbers input_line_pointer, checks end-of-line. */
658:
659: static void
660: i370_elf_cons (int nbytes) /* 1=.byte, 2=.word, 4=.long. */
661: {
662: expressionS exp;
663: bfd_reloc_code_real_type reloc;
664:
665: if (is_it_end_of_statement ())
666: {
667: demand_empty_rest_of_line ();
668: return;
669: }
670:
671: do
672: {
673: expression (&exp);
674:
675: if (exp.X_op == O_symbol
676: && *input_line_pointer == '@'
677: && (reloc = i370_elf_suffix (&input_line_pointer, &exp)) != BFD_RELOC_UNUSED)
678: {
679: reloc_howto_type *reloc_howto = bfd_reloc_type_lookup (stdoutput, reloc);
680: int size = bfd_get_reloc_size (reloc_howto);
681:
682: if (size > nbytes)
683: as_bad (_("%s relocations do not fit in %d bytes\n"),
684: reloc_howto->name, nbytes);
685: else
686: {
687: char *p = frag_more ((int) nbytes);
688: int offset = nbytes - size;
689:
690: fix_new_exp (frag_now, p - frag_now->fr_literal + offset, size, &exp, 0, reloc);
691: }
692: }
693: else
694: emit_expr (&exp, (unsigned int) nbytes);
695: }
696: while (*input_line_pointer++ == ',');
697:
698: input_line_pointer--; /* Put terminator back into stream. */
699: demand_empty_rest_of_line ();
700: }
701:
702:
703: /* ASCII to EBCDIC conversion table. */
704: static unsigned char ascebc[256] =
705: {
706: /*00 NL SH SX EX ET NQ AK BL */
707: 0x00, 0x01, 0x02, 0x03, 0x37, 0x2D, 0x2E, 0x2F,
708: /*08 BS HT LF VT FF CR SO SI */
709: 0x16, 0x05, 0x15, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
710: /*10 DL D1 D2 D3 D4 NK SN EB */
711: 0x10, 0x11, 0x12, 0x13, 0x3C, 0x3D, 0x32, 0x26,
712: /*18 CN EM SB EC FS GS RS US */
713: 0x18, 0x19, 0x3F, 0x27, 0x1C, 0x1D, 0x1E, 0x1F,
714: /*20 SP ! " # $ % & ' */
715: 0x40, 0x5A, 0x7F, 0x7B, 0x5B, 0x6C, 0x50, 0x7D,
716: /*28 ( ) * + , - . / */
717: 0x4D, 0x5D, 0x5C, 0x4E, 0x6B, 0x60, 0x4B, 0x61,
718: /*30 0 1 2 3 4 5 6 7 */
719: 0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7,
720: /*38 8 9 : ; < = > ? */
721: 0xF8, 0xF9, 0x7A, 0x5E, 0x4C, 0x7E, 0x6E, 0x6F,
722: /*40 @ A B C D E F G */
723: 0x7C, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7,
724: /*48 H I J K L M N O */
725: 0xC8, 0xC9, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6,
726: /*50 P Q R S T U V W */
727: 0xD7, 0xD8, 0xD9, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6,
728: /*58 X Y Z [ \ ] ^ _ */
729: 0xE7, 0xE8, 0xE9, 0xAD, 0xE0, 0xBD, 0x5F, 0x6D,
730: /*60 ` a b c d e f g */
731: 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
732: /*68 h i j k l m n o */
733: 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96,
734: /*70 p q r s t u v w */
735: 0x97, 0x98, 0x99, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6,
736: /*78 x y z { | } ~ DL */
737: 0xA7, 0xA8, 0xA9, 0xC0, 0x4F, 0xD0, 0xA1, 0x07,
738: 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F,
739: 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F,
740: 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F,
741: 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F,
742: 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F,
743: 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F,
744: 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F,
745: 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F,
746: 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F,
747: 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F,
748: 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F,
749: 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F,
750: 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F,
751: 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F,
752: 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F,
753: 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0xFF
754: };
755:
756: /* EBCDIC to ASCII conversion table. */
757: unsigned char ebcasc[256] =
758: {
759: /*00 NU SH SX EX PF HT LC DL */
760: 0x00, 0x01, 0x02, 0x03, 0x00, 0x09, 0x00, 0x7F,
761: /*08 SM VT FF CR SO SI */
762: 0x00, 0x00, 0x00, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
763: /*10 DE D1 D2 TM RS NL BS IL */
764: 0x10, 0x11, 0x12, 0x13, 0x14, 0x0A, 0x08, 0x00,
765: /*18 CN EM CC C1 FS GS RS US */
766: 0x18, 0x19, 0x00, 0x00, 0x1C, 0x1D, 0x1E, 0x1F,
767: /*20 DS SS FS BP LF EB EC */
768: 0x00, 0x00, 0x00, 0x00, 0x00, 0x0A, 0x17, 0x1B,
769: /*28 SM C2 EQ AK BL */
770: 0x00, 0x00, 0x00, 0x00, 0x05, 0x06, 0x07, 0x00,
771: /*30 SY PN RS UC ET */
772: 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04,
773: /*38 C3 D4 NK SU */
774: 0x00, 0x00, 0x00, 0x00, 0x14, 0x15, 0x00, 0x1A,
775: /*40 SP */
776: 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
777: /*48 . < ( + | */
778: 0x00, 0x00, 0x00, 0x2E, 0x3C, 0x28, 0x2B, 0x7C,
779: /*50 & */
780: 0x26, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
781: /*58 ! $ * ) ; ^ */
782: 0x00, 0x00, 0x21, 0x24, 0x2A, 0x29, 0x3B, 0x5E,
783: /*60 - / */
784: 0x2D, 0x2F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
785: /*68 , % _ > ? */
786: 0x00, 0x00, 0x00, 0x2C, 0x25, 0x5F, 0x3E, 0x3F,
787: /*70 */
788: 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
789: /*78 ` : # @ ' = " */
790: 0x00, 0x60, 0x3A, 0x23, 0x40, 0x27, 0x3D, 0x22,
791: /*80 a b c d e f g */
792: 0x00, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
793: /*88 h i { */
794: 0x68, 0x69, 0x00, 0x7B, 0x00, 0x00, 0x00, 0x00,
795: /*90 j k l m n o p */
796: 0x00, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, 0x70,
797: /*98 q r } */
798: 0x71, 0x72, 0x00, 0x7D, 0x00, 0x00, 0x00, 0x00,
799: /*A0 ~ s t u v w x */
800: 0x00, 0x7E, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
801: /*A8 y z [ */
802: 0x79, 0x7A, 0x00, 0x00, 0x00, 0x5B, 0x00, 0x00,
803: /*B0 */
804: 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
805: /*B8 ] */
806: 0x00, 0x00, 0x00, 0x00, 0x00, 0x5D, 0x00, 0x00,
807: /*C0 { A B C D E F G */
808: 0x7B, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
809: /*C8 H I */
810: 0x48, 0x49, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
811: /*D0 } J K L M N O P */
812: 0x7D, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 0x50,
813: /*D8 Q R */
814: 0x51, 0x52, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
815: /*E0 \ S T U V W X */
816: 0x5C, 0x00, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
817: /*E8 Y Z */
818: 0x59, 0x5A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
819: /*F0 0 1 2 3 4 5 6 7 */
820: 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
821: /*F8 8 9 */
822: 0x38, 0x39, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF
823: };
824:
825: /* EBCDIC translation tables needed for 3270 support. */
826:
827: static void
828: i370_ebcdic (int unused ATTRIBUTE_UNUSED)
829: {
830: char *p, *end;
831: char delim = 0;
832: size_t nbytes;
833:
834: nbytes = strlen (input_line_pointer);
835: end = input_line_pointer + nbytes;
836: while ('\r' == *end) end --;
837: while ('\n' == *end) end --;
838:
839: delim = *input_line_pointer;
840: if (('\'' == delim) || ('\"' == delim))
841: {
842: input_line_pointer ++;
843: end = rindex (input_line_pointer, delim);
844: }
845:
846: if (end > input_line_pointer)
847: {
848: nbytes = end - input_line_pointer +1;
849: p = frag_more (nbytes);
850: while (end > input_line_pointer)
851: {
852: *p = ascebc [(unsigned char) (*input_line_pointer)];
853: ++p; ++input_line_pointer;
854: }
855: *p = '\0';
856: }
857: if (delim == *input_line_pointer) ++input_line_pointer;
858: }
859:
860:
861: /* Stub out a couple of routines. */
862:
863: static void
864: i370_rmode (int unused ATTRIBUTE_UNUSED)
865: {
866: as_tsktsk ("rmode ignored");
867: }
868:
869: static void
870: i370_dsect (int sect)
871: {
872: char *save_line = input_line_pointer;
873: static char section[] = ".data\n";
874:
875: /* Just pretend this is .section .data. */
876: input_line_pointer = section;
877: obj_elf_section (sect);
878:
879: input_line_pointer = save_line;
880: }
881:
882: static void
883: i370_csect (int unused ATTRIBUTE_UNUSED)
884: {
885: as_tsktsk ("csect not supported");
886: }
887:
888:
889: /* DC Define Const is only partially supported.
890: For samplecode on what to do, look at i370_elf_cons() above.
891: This code handles pseudoops of the style
892: DC D'3.141592653' # in sysv4, .double 3.14159265
893: DC F'1' # in sysv4, .long 1. */
894:
895: static void
896: i370_dc (int unused ATTRIBUTE_UNUSED)
897: {
898: char * p, tmp[50];
899: int nbytes=0;
900: expressionS exp;
901: char type=0;
902: char * clse;
903:
904: if (is_it_end_of_statement ())
905: {
906: demand_empty_rest_of_line ();
907: return;
908: }
909:
910: /* Figure out the size. */
911: type = *input_line_pointer++;
912: switch (type)
913: {
914: case 'H': /* 16-bit */
915: nbytes = 2;
916: break;
917: case 'E': /* 32-bit */
918: case 'F': /* 32-bit */
919: nbytes = 4;
920: break;
921: case 'D': /* 64-bit */
922: nbytes = 8;
923: break;
924: default:
925: as_bad (_("unsupported DC type"));
926: return;
927: }
928:
929: /* Get rid of pesky quotes. */
930: if ('\'' == *input_line_pointer)
931: {
932: ++input_line_pointer;
933: clse = strchr (input_line_pointer, '\'');
934: if (clse)
935: *clse= ' ';
936: else
937: as_bad (_("missing end-quote"));
938: }
939:
940: if ('\"' == *input_line_pointer)
941: {
942: ++input_line_pointer;
943: clse = strchr (input_line_pointer, '\"');
944: if (clse)
945: *clse= ' ';
946: else
947: as_bad (_("missing end-quote"));
948: }
949:
950: switch (type)
951: {
952: case 'H': /* 16-bit */
953: case 'F': /* 32-bit */
954: expression (&exp);
955: emit_expr (&exp, nbytes);
956: break;
957: case 'E': /* 32-bit */
958: type = 'f';
959: case 'D': /* 64-bit */
960: md_atof (type, tmp, &nbytes);
961: p = frag_more (nbytes);
962: memcpy (p, tmp, nbytes);
963: break;
964: default:
965: as_bad (_("unsupported DC type"));
966: return;
967: }
968:
969: demand_empty_rest_of_line ();
970: }
971:
972:
973: /* Provide minimal support for DS Define Storage. */
974:
975: static void
976: i370_ds (int unused ATTRIBUTE_UNUSED)
977: {
978: /* DS 0H or DS 0F or DS 0D. */
979: if ('0' == *input_line_pointer)
980: {
981: int alignment = 0; /* Left shift 1 << align. */
982: input_line_pointer ++;
983: switch (*input_line_pointer++)
984: {
985: case 'H': /* 16-bit */
986: alignment = 1;
987: break;
988: case 'F': /* 32-bit */
989: alignment = 2;
990: break;
991: case 'D': /* 64-bit */
992: alignment = 3;
993: break;
994: default:
995: as_bad (_("unsupported alignment"));
996: return;
997: }
998: frag_align (alignment, 0, 0);
999: record_alignment (now_seg, alignment);
1000: }
1001: else
1002: as_bad (_("this DS form not yet supported"));
1003: }
1004:
1005: /* Solaris pseudo op to change to the .rodata section. */
1006:
1007: static void
1008: i370_elf_rdata (int sect)
1009: {
1010: char *save_line = input_line_pointer;
1011: static char section[] = ".rodata\n";
1012:
1013: /* Just pretend this is .section .rodata. */
1014: input_line_pointer = section;
1015: obj_elf_section (sect);
1016:
1017: input_line_pointer = save_line;
1018: }
1019:
1020: /* Pseudo op to make file scope bss items. */
1021:
1022: static void
1023: i370_elf_lcomm (int unused ATTRIBUTE_UNUSED)
1024: {
1025: char *name;
1026: char c;
1027: char *p;
1028: offsetT size;
1029: symbolS *symbolP;
1030: offsetT align;
1031: segT old_sec;
1032: int old_subsec;
1033: char *pfrag;
1034: int align2;
1035:
1.3 ! christos 1036: c = get_symbol_name (&name);
1.1 christos 1037:
1038: /* Just after name is now '\0'. */
1039: p = input_line_pointer;
1.3 ! christos 1040: (void) restore_line_pointer (c);
1.1 christos 1041: SKIP_WHITESPACE ();
1042: if (*input_line_pointer != ',')
1043: {
1044: as_bad (_("Expected comma after symbol-name: rest of line ignored."));
1045: ignore_rest_of_line ();
1046: return;
1047: }
1048:
1049: /* Skip ','. */
1050: input_line_pointer++;
1051: if ((size = get_absolute_expression ()) < 0)
1052: {
1053: as_warn (_(".COMMon length (%ld.) <0! Ignored."), (long) size);
1054: ignore_rest_of_line ();
1055: return;
1056: }
1057:
1058: /* The third argument to .lcomm is the alignment. */
1059: if (*input_line_pointer != ',')
1060: align = 8;
1061: else
1062: {
1063: ++input_line_pointer;
1064: align = get_absolute_expression ();
1065: if (align <= 0)
1066: {
1067: as_warn (_("ignoring bad alignment"));
1068: align = 8;
1069: }
1070: }
1071:
1072: *p = 0;
1073: symbolP = symbol_find_or_make (name);
1074: *p = c;
1075:
1076: if (S_IS_DEFINED (symbolP) && ! S_IS_COMMON (symbolP))
1077: {
1078: as_bad (_("Ignoring attempt to re-define symbol `%s'."),
1079: S_GET_NAME (symbolP));
1080: ignore_rest_of_line ();
1081: return;
1082: }
1083:
1084: if (S_GET_VALUE (symbolP) && S_GET_VALUE (symbolP) != (valueT) size)
1085: {
1086: as_bad (_("Length of .lcomm \"%s\" is already %ld. Not changed to %ld."),
1087: S_GET_NAME (symbolP),
1088: (long) S_GET_VALUE (symbolP),
1089: (long) size);
1090:
1091: ignore_rest_of_line ();
1092: return;
1093: }
1094:
1095: /* Allocate_bss: */
1096: old_sec = now_seg;
1097: old_subsec = now_subseg;
1098: if (align)
1099: {
1100: /* Convert to a power of 2 alignment. */
1101: for (align2 = 0; (align & 1) == 0; align >>= 1, ++align2)
1102: ;
1103: if (align != 1)
1104: {
1105: as_bad (_("Common alignment not a power of 2"));
1106: ignore_rest_of_line ();
1107: return;
1108: }
1109: }
1110: else
1111: align2 = 0;
1112:
1113: record_alignment (bss_section, align2);
1114: subseg_set (bss_section, 0);
1115: if (align2)
1116: frag_align (align2, 0, 0);
1117: if (S_GET_SEGMENT (symbolP) == bss_section)
1118: symbol_get_frag (symbolP)->fr_symbol = 0;
1119: symbol_set_frag (symbolP, frag_now);
1120: pfrag = frag_var (rs_org, 1, 1, (relax_substateT) 0, symbolP, size,
1121: (char *) 0);
1122: *pfrag = 0;
1123: S_SET_SIZE (symbolP, size);
1124: S_SET_SEGMENT (symbolP, bss_section);
1125: subseg_set (old_sec, old_subsec);
1126: demand_empty_rest_of_line ();
1127: }
1128:
1129: /* Validate any relocations emitted for -mrelocatable, possibly adding
1130: fixups for word relocations in writable segments, so we can adjust
1131: them at runtime. */
1132:
1133: static void
1134: i370_elf_validate_fix (fixS *fixp, segT seg)
1135: {
1136: if (fixp->fx_done || fixp->fx_pcrel)
1137: return;
1138:
1139: switch (shlib)
1140: {
1141: case SHLIB_NONE:
1142: case SHLIB_PIC:
1143: return;
1144:
1145: case SHILB_MRELOCATABLE:
1146: if (fixp->fx_r_type <= BFD_RELOC_UNUSED
1147: && fixp->fx_r_type != BFD_RELOC_16_GOTOFF
1148: && fixp->fx_r_type != BFD_RELOC_HI16_GOTOFF
1149: && fixp->fx_r_type != BFD_RELOC_LO16_GOTOFF
1150: && fixp->fx_r_type != BFD_RELOC_HI16_S_GOTOFF
1151: && fixp->fx_r_type != BFD_RELOC_32_BASEREL
1152: && fixp->fx_r_type != BFD_RELOC_LO16_BASEREL
1153: && fixp->fx_r_type != BFD_RELOC_HI16_BASEREL
1154: && fixp->fx_r_type != BFD_RELOC_HI16_S_BASEREL
1155: && strcmp (segment_name (seg), ".got2") != 0
1156: && strcmp (segment_name (seg), ".dtors") != 0
1157: && strcmp (segment_name (seg), ".ctors") != 0
1158: && strcmp (segment_name (seg), ".fixup") != 0
1159: && strcmp (segment_name (seg), ".stab") != 0
1160: && strcmp (segment_name (seg), ".gcc_except_table") != 0
1161: && strcmp (segment_name (seg), ".ex_shared") != 0)
1162: {
1163: if ((seg->flags & (SEC_READONLY | SEC_CODE)) != 0
1164: || fixp->fx_r_type != BFD_RELOC_CTOR)
1165: as_bad_where (fixp->fx_file, fixp->fx_line,
1166: "Relocation cannot be done when using -mrelocatable");
1167: }
1168: return;
1169: default:
1170: break;
1171: }
1172: }
1173: #endif /* OBJ_ELF */
1174:
1175:
1176: #define LITERAL_POOL_SUPPORT
1177: #ifdef LITERAL_POOL_SUPPORT
1178: /* Provide support for literal pools within the text section.
1179: Loosely based on similar code from tc-arm.c.
1180: We will use four symbols to locate four parts of the literal pool.
1181: These four sections contain 64,32,16 and 8-bit constants; we use
1182: four sections so that all memory access can be appropriately aligned.
1183: That is, we want to avoid mixing these together so that we don't
1184: waste space padding out to alignments. The four pointers
1185: longlong_poolP, word_poolP, etc. point to a symbol labeling the
1186: start of each pool part.
1.3 ! christos 1187:
1.1 christos 1188: lit_pool_num increments from zero to infinity and uniquely id's
1189: -- its used to generate the *_poolP symbol name. */
1190:
1191: #define MAX_LITERAL_POOL_SIZE 1024
1192:
1193: typedef struct literalS
1194: {
1195: struct expressionS exp;
1196: char * sym_name;
1197: char size; /* 1,2,4 or 8 */
1198: short offset;
1199: } literalT;
1200:
1201: literalT literals[MAX_LITERAL_POOL_SIZE];
1202: int next_literal_pool_place = 0; /* Next free entry in the pool. */
1203:
1204: static symbolS *longlong_poolP = NULL; /* 64-bit pool entries. */
1205: static symbolS *word_poolP = NULL; /* 32-bit pool entries. */
1206: static symbolS *short_poolP = NULL; /* 16-bit pool entries. */
1207: static symbolS *byte_poolP = NULL; /* 8-bit pool entries. */
1208:
1209: static int lit_pool_num = 1;
1210:
1211: /* Create a new, empty symbol. */
1212: static symbolS *
1213: symbol_make_empty (void)
1214: {
1215: return symbol_create (FAKE_LABEL_NAME, undefined_section,
1216: (valueT) 0, &zero_address_frag);
1217: }
1218:
1219: /* Make the first argument an address-relative expression
1220: by subtracting the second argument. */
1221:
1222: static void
1223: i370_make_relative (expressionS *exx, expressionS *baseaddr)
1224: {
1225: if (O_constant == baseaddr->X_op)
1226: {
1227: exx->X_op = O_symbol;
1228: exx->X_add_number -= baseaddr->X_add_number;
1229: }
1230: else if (O_symbol == baseaddr->X_op)
1231: {
1232: exx->X_op = O_subtract;
1233: exx->X_op_symbol = baseaddr->X_add_symbol;
1234: exx->X_add_number -= baseaddr->X_add_number;
1235: }
1236: else if (O_uminus == baseaddr->X_op)
1237: {
1238: exx->X_op = O_add;
1239: exx->X_op_symbol = baseaddr->X_add_symbol;
1240: exx->X_add_number += baseaddr->X_add_number;
1241: }
1242: else
1243: as_bad (_("Missing or bad .using directive"));
1244: }
1245: /* Add an expression to the literal pool. */
1246:
1247: static void
1248: add_to_lit_pool (expressionS *exx, char *name, int sz)
1249: {
1250: int lit_count = 0;
1251: int offset_in_pool = 0;
1252:
1253: /* Start a new pool, if necessary. */
1254: if (8 == sz && NULL == longlong_poolP)
1255: longlong_poolP = symbol_make_empty ();
1256: else if (4 == sz && NULL == word_poolP)
1257: word_poolP = symbol_make_empty ();
1258: else if (2 == sz && NULL == short_poolP)
1259: short_poolP = symbol_make_empty ();
1260: else if (1 == sz && NULL == byte_poolP)
1261: byte_poolP = symbol_make_empty ();
1262:
1263: /* Check if this literal value is already in the pool.
1264: FIXME: We should probably be checking expressions
1265: of type O_symbol as well.
1266: FIXME: This is probably(certainly?) broken for O_big,
1267: which includes 64-bit long-longs. */
1268: while (lit_count < next_literal_pool_place)
1269: {
1270: if (exx->X_op == O_constant
1271: && literals[lit_count].exp.X_op == exx->X_op
1272: && literals[lit_count].exp.X_add_number == exx->X_add_number
1273: && literals[lit_count].exp.X_unsigned == exx->X_unsigned
1274: && literals[lit_count].size == sz)
1275: break;
1276: else if (literals[lit_count].sym_name
1277: && name
1278: && !strcmp (name, literals[lit_count].sym_name))
1279: break;
1280: if (sz == literals[lit_count].size)
1281: offset_in_pool += sz;
1282: lit_count ++;
1283: }
1284:
1285: if (lit_count == next_literal_pool_place) /* new entry */
1286: {
1287: if (next_literal_pool_place > MAX_LITERAL_POOL_SIZE)
1288: as_bad (_("Literal Pool Overflow"));
1289:
1290: literals[next_literal_pool_place].exp = *exx;
1291: literals[next_literal_pool_place].size = sz;
1292: literals[next_literal_pool_place].offset = offset_in_pool;
1293: if (name)
1294: literals[next_literal_pool_place].sym_name = strdup (name);
1295: else
1296: literals[next_literal_pool_place].sym_name = NULL;
1297: next_literal_pool_place++;
1298: }
1299:
1300: /* ???_poolP points to the beginning of the literal pool.
1301: X_add_number is the offset from the beginning of the
1302: literal pool to this expr minus the location of the most
1303: recent .using directive. Thus, the grand total value of the
1304: expression is the distance from .using to the literal. */
1305: if (8 == sz)
1306: exx->X_add_symbol = longlong_poolP;
1307: else if (4 == sz)
1308: exx->X_add_symbol = word_poolP;
1309: else if (2 == sz)
1310: exx->X_add_symbol = short_poolP;
1311: else if (1 == sz)
1312: exx->X_add_symbol = byte_poolP;
1313: exx->X_add_number = offset_in_pool;
1314: exx->X_op_symbol = NULL;
1315:
1316: /* If the user has set up a base reg in another section,
1317: use that; otherwise use the text section. */
1318: if (0 < i370_using_other_regno)
1319: i370_make_relative (exx, &i370_using_other_baseaddr);
1320: else
1321: i370_make_relative (exx, &i370_using_text_baseaddr);
1322: }
1323:
1324: /* The symbol setup for the literal pool is done in two steps. First,
1325: a symbol that represents the start of the literal pool is created,
1326: above, in the add_to_pool() routine. This sym ???_poolP.
1327: However, we don't know what fragment its in until a bit later.
1328: So we defer the frag_now thing, and the symbol name, until .ltorg time. */
1329:
1330: /* Can't use symbol_new here, so have to create a symbol and then at
1331: a later date assign it a value. Thats what these functions do. */
1332:
1333: static void
1334: symbol_locate (symbolS *symbolP,
1335: const char *name, /* It is copied, the caller can modify. */
1336: segT segment, /* Segment identifier (SEG_<something>). */
1337: valueT valu, /* Symbol value. */
1338: fragS *frag) /* Associated fragment. */
1339: {
1340: size_t name_length;
1341: char *preserved_copy_of_name;
1342:
1343: name_length = strlen (name) + 1; /* +1 for \0 */
1344: obstack_grow (¬es, name, name_length);
1345: preserved_copy_of_name = obstack_finish (¬es);
1346:
1347: S_SET_NAME (symbolP, preserved_copy_of_name);
1348:
1349: S_SET_SEGMENT (symbolP, segment);
1350: S_SET_VALUE (symbolP, valu);
1351: symbol_clear_list_pointers (symbolP);
1352:
1353: symbol_set_frag (symbolP, frag);
1354:
1355: /* Link to end of symbol chain. */
1356: {
1357: extern int symbol_table_frozen;
1358:
1359: if (symbol_table_frozen)
1360: abort ();
1361: }
1362:
1363: symbol_append (symbolP, symbol_lastP, &symbol_rootP, &symbol_lastP);
1364:
1365: obj_symbol_new_hook (symbolP);
1366:
1367: #ifdef tc_symbol_new_hook
1368: tc_symbol_new_hook (symbolP);
1369: #endif
1370:
1371: #define DEBUG_SYMS
1372: #ifdef DEBUG_SYMS
1373: verify_symbol_chain(symbol_rootP, symbol_lastP);
1374: #endif /* DEBUG_SYMS */
1375: }
1376:
1377: /* i370_addr_offset() will convert operand expressions
1378: that appear to be absolute into thier base-register
1379: relative form. These expressions come in two types:
1380:
1381: (1) of the form "* + const" * where "*" means
1382: relative offset since the last using
1383: i.e. "*" means ".-using_baseaddr"
1384:
1385: (2) labels, which are never absolute, but are always
1386: relative to the last "using". Anything with an alpha
1387: character is considered to be a label (since symbols
1388: can never be operands), and since we've already handled
1389: register operands. For example, "BL .L33" branch low
1390: to .L33 RX form insn frequently terminates for-loops. */
1391:
1392: static bfd_boolean
1393: i370_addr_offset (expressionS *exx)
1394: {
1395: char *dot, *lab;
1396: int islabel = 0;
1397: int all_digits = 0;
1398:
1399: /* Search for a label; anything with an alpha char will do.
1400: Local labels consist of N digits followed by either b or f. */
1401: lab = input_line_pointer;
1402: while (*lab && (',' != *lab) && ('(' != *lab))
1403: {
1404: if (ISDIGIT (*lab))
1405: all_digits = 1;
1406: else if (ISALPHA (*lab))
1407: {
1408: if (!all_digits)
1409: {
1410: islabel = 1;
1411: break;
1412: }
1413: else if (('f' == *lab) || ('b' == *lab))
1414: {
1415: islabel = 1;
1416: break;
1417: }
1418: if (all_digits)
1419: break;
1420: }
1421: else if ('.' != *lab)
1422: break;
1423: ++lab;
1424: }
1425:
1426: /* See if operand has a * in it. */
1427: dot = strchr (input_line_pointer, '*');
1428:
1429: if (!dot && !islabel)
1430: return FALSE;
1431:
1432: /* Replace * with . and let expr munch on it. */
1433: if (dot)
1434: *dot = '.';
1435: expression (exx);
1436:
1437: /* OK, now we have to subtract the "using" location.
1438: Normally branches appear in the text section only. */
1439: if (0 == strncmp (now_seg->name, ".text", 5) || 0 > i370_using_other_regno)
1440: i370_make_relative (exx, &i370_using_text_baseaddr);
1441: else
1442: i370_make_relative (exx, &i370_using_other_baseaddr);
1443:
1444: /* Put the * back. */
1445: if (dot)
1446: *dot = '*';
1447:
1448: return TRUE;
1449: }
1450:
1451: /* Handle address constants of various sorts. */
1452: /* The currently supported types are
1453: =A(some_symb)
1454: =V(some_extern)
1455: =X'deadbeef' hexadecimal
1456: =F'1234' 32-bit const int
1457: =H'1234' 16-bit const int. */
1458:
1459: static bfd_boolean
1460: i370_addr_cons (expressionS *exp)
1461: {
1462: char *name;
1463: char *sym_name, delim;
1464: int name_len;
1465: int hex_len = 0;
1466: int cons_len = 0;
1467:
1468: name = input_line_pointer;
1469: sym_name = input_line_pointer;
1470: /* Find the spelling of the operand. */
1471: if (name[0] == '=' && ISALPHA (name[1]))
1472: name = ++input_line_pointer;
1473: else
1474: return FALSE;
1475:
1476: switch (name[0])
1477: {
1478: case 'A': /* A == address-of. */
1479: case 'V': /* V == extern. */
1480: ++input_line_pointer;
1481: expression (exp);
1482:
1483: /* We use a simple string name to collapse together
1484: multiple refrences to the same address literal. */
1485: name_len = strcspn (sym_name, ", ");
1486: delim = *(sym_name + name_len);
1487: *(sym_name + name_len) = 0x0;
1488: add_to_lit_pool (exp, sym_name, 4);
1489: *(sym_name + name_len) = delim;
1490:
1491: break;
1492: case 'H':
1493: case 'F':
1494: case 'X':
1495: case 'E': /* Single-precision float point. */
1496: case 'D': /* Double-precision float point. */
1497:
1498: /* H == 16-bit fixed-point const; expression must be const. */
1499: /* F == fixed-point const; expression must be const. */
1500: /* X == fixed-point const; expression must be const. */
1501: if ('H' == name[0]) cons_len = 2;
1502: else if ('F' == name[0]) cons_len = 4;
1503: else if ('X' == name[0]) cons_len = -1;
1504: else if ('E' == name[0]) cons_len = 4;
1505: else if ('D' == name[0]) cons_len = 8;
1506:
1507: /* Extract length, if it is present;
1508: FIXME: assume single-digit length. */
1509: if ('L' == name[1])
1510: {
1511: /* Should work for ASCII and EBCDIC. */
1512: cons_len = name[2] - '0';
1513: input_line_pointer += 2;
1514: }
1515:
1516: ++input_line_pointer;
1517:
1518: /* Get rid of pesky quotes. */
1519: if ('\'' == *input_line_pointer)
1520: {
1521: char * clse;
1522:
1523: ++input_line_pointer;
1524: clse = strchr (input_line_pointer, '\'');
1525: if (clse)
1526: *clse= ' ';
1527: else
1528: as_bad (_("missing end-quote"));
1529: }
1530: if ('\"' == *input_line_pointer)
1531: {
1532: char * clse;
1533:
1534: ++input_line_pointer;
1535: clse = strchr (input_line_pointer, '\"');
1536: if (clse)
1537: *clse= ' ';
1538: else
1539: as_bad (_("missing end-quote"));
1540: }
1541: if (('X' == name[0]) || ('E' == name[0]) || ('D' == name[0]))
1542: {
1543: char tmp[50];
1544: char *save;
1545:
1546: /* The length of hex constants is specified directly with L,
1547: or implied through the number of hex digits. For example:
1548: =X'AB' one byte
1549: =X'abcd' two bytes
1550: =X'000000AB' four bytes
1551: =XL4'AB' four bytes, left-padded withn zero. */
1552: if (('X' == name[0]) && (0 > cons_len))
1553: {
1554: save = input_line_pointer;
1555: while (*save)
1556: {
1557: if (ISXDIGIT (*save))
1558: hex_len++;
1559: save++;
1560: }
1561: cons_len = (hex_len+1) /2;
1562: }
1563: /* I believe this works even for =XL8'dada0000beeebaaa'
1564: which should parse out to X_op == O_big
1565: Note that floats and doubles get represented as
1566: 0d3.14159265358979 or 0f 2.7. */
1567: tmp[0] = '0';
1568: tmp[1] = name[0];
1569: tmp[2] = 0;
1570: strcat (tmp, input_line_pointer);
1571: save = input_line_pointer;
1572: input_line_pointer = tmp;
1573: expression (exp);
1574: input_line_pointer = save + (input_line_pointer-tmp-2);
1575:
1576: /* Fix up lengths for floats and doubles. */
1577: if (O_big == exp->X_op)
1578: exp->X_add_number = cons_len / CHARS_PER_LITTLENUM;
1579: }
1580: else
1581: expression (exp);
1582:
1583: /* O_big occurs when more than 4 bytes worth gets parsed. */
1584: if ((exp->X_op != O_constant) && (exp->X_op != O_big))
1585: {
1586: as_bad (_("expression not a constant"));
1587: return FALSE;
1588: }
1589: add_to_lit_pool (exp, 0x0, cons_len);
1590: break;
1591:
1592: default:
1593: as_bad (_("Unknown/unsupported address literal type"));
1594: return FALSE;
1595: }
1596:
1597: return TRUE;
1598: }
1599:
1600:
1601: /* Dump the contents of the literal pool that we've accumulated so far.
1602: This aligns the pool to the size of the largest literal in the pool. */
1603:
1604: static void
1605: i370_ltorg (int ignore ATTRIBUTE_UNUSED)
1606: {
1607: int litsize;
1608: int lit_count = 0;
1609: int biggest_literal_size = 0;
1610: int biggest_align = 0;
1611: char pool_name[20];
1612:
1613: if (strncmp (now_seg->name, ".text", 5))
1614: {
1615: if (i370_other_section == undefined_section)
1616: as_bad (_(".ltorg without prior .using in section %s"),
1617: now_seg->name);
1618:
1619: if (i370_other_section != now_seg)
1620: as_bad (_(".ltorg in section %s paired to .using in section %s"),
1621: now_seg->name, i370_other_section->name);
1622: }
1623:
1624: if (! longlong_poolP
1625: && ! word_poolP
1626: && ! short_poolP
1627: && ! byte_poolP)
1628: /* Nothing to do. */
1629: return;
1630:
1631: /* Find largest literal .. 2 4 or 8. */
1632: lit_count = 0;
1633: while (lit_count < next_literal_pool_place)
1634: {
1635: if (biggest_literal_size < literals[lit_count].size)
1636: biggest_literal_size = literals[lit_count].size;
1637: lit_count ++;
1638: }
1639: if (1 == biggest_literal_size) biggest_align = 0;
1640: else if (2 == biggest_literal_size) biggest_align = 1;
1641: else if (4 == biggest_literal_size) biggest_align = 2;
1642: else if (8 == biggest_literal_size) biggest_align = 3;
1643: else as_bad (_("bad alignment of %d bytes in literal pool"), biggest_literal_size);
1644: if (0 == biggest_align) biggest_align = 1;
1645:
1646: /* Align pool for short, word, double word accesses. */
1647: frag_align (biggest_align, 0, 0);
1648: record_alignment (now_seg, biggest_align);
1649:
1650: /* Note that the gas listing will print only the first five
1651: entries in the pool .... wonder how to make it print more. */
1652: /* Output largest literals first, then the smaller ones. */
1653: for (litsize=8; litsize; litsize /=2)
1654: {
1655: symbolS *current_poolP = NULL;
1656: switch (litsize)
1657: {
1658: case 8:
1659: current_poolP = longlong_poolP; break;
1660: case 4:
1661: current_poolP = word_poolP; break;
1662: case 2:
1663: current_poolP = short_poolP; break;
1664: case 1:
1665: current_poolP = byte_poolP; break;
1666: default:
1667: as_bad (_("bad literal size\n"));
1668: }
1669: if (NULL == current_poolP)
1670: continue;
1671: sprintf (pool_name, ".LITP%01d%06d", litsize, lit_pool_num);
1672: symbol_locate (current_poolP, pool_name, now_seg,
1673: (valueT) frag_now_fix (), frag_now);
1674: symbol_table_insert (current_poolP);
1675:
1676: lit_count = 0;
1677: while (lit_count < next_literal_pool_place)
1678: {
1679: if (litsize == literals[lit_count].size)
1680: {
1681: #define EMIT_ADDR_CONS_SYMBOLS
1682: #ifdef EMIT_ADDR_CONS_SYMBOLS
1683: /* Create a bogus symbol, add it to the pool ...
1684: For the most part, I think this is a useless exercise,
1685: except that having these symbol names in the objects
1686: is vaguely useful for debugging. */
1687: if (literals[lit_count].sym_name)
1688: {
1689: symbolS * symP = symbol_make_empty ();
1690: symbol_locate (symP, literals[lit_count].sym_name, now_seg,
1691: (valueT) frag_now_fix (), frag_now);
1692: symbol_table_insert (symP);
1693: }
1694: #endif /* EMIT_ADDR_CONS_SYMBOLS */
1695:
1696: emit_expr (&(literals[lit_count].exp), literals[lit_count].size);
1697: }
1698: lit_count ++;
1699: }
1700: }
1701:
1702: next_literal_pool_place = 0;
1703: longlong_poolP = NULL;
1704: word_poolP = NULL;
1705: short_poolP = NULL;
1706: byte_poolP = NULL;
1707: lit_pool_num++;
1708: }
1709:
1710: #endif /* LITERAL_POOL_SUPPORT */
1711:
1712:
1713: /* Add support for the HLASM-like USING directive to indicate
1714: the base register to use ... we don't support the full
1715: hlasm semantics for this ... we merely pluck a base address
1716: and a register number out. We print a warning if using is
1717: called multiple times. I suppose we should check to see
1718: if the regno is valid. */
1719:
1720: static void
1721: i370_using (int ignore ATTRIBUTE_UNUSED)
1722: {
1723: expressionS ex, baseaddr;
1724: int iregno;
1725: char *star;
1726:
1727: /* If "*" appears in a using, it means "."
1728: replace it with "." so that expr doesn't get confused. */
1729: star = strchr (input_line_pointer, '*');
1730: if (star)
1731: *star = '.';
1732:
1733: /* The first arg to using will usually be ".", but it can
1734: be a more complex expression too. */
1735: expression (&baseaddr);
1736: if (star)
1737: *star = '*';
1738: if (O_constant != baseaddr.X_op
1739: && O_symbol != baseaddr.X_op
1740: && O_uminus != baseaddr.X_op)
1741: as_bad (_(".using: base address expression illegal or too complex"));
1742:
1743: if (*input_line_pointer != '\0') ++input_line_pointer;
1744:
1745: /* The second arg to using had better be a register. */
1746: register_name (&ex);
1747: demand_empty_rest_of_line ();
1748: iregno = ex.X_add_number;
1749:
1750: if (0 == strncmp (now_seg->name, ".text", 5))
1751: {
1752: i370_using_text_baseaddr = baseaddr;
1753: i370_using_text_regno = iregno;
1754: }
1755: else
1756: {
1757: i370_using_other_baseaddr = baseaddr;
1758: i370_using_other_regno = iregno;
1759: i370_other_section = now_seg;
1760: }
1761: }
1762:
1763: static void
1764: i370_drop (int ignore ATTRIBUTE_UNUSED)
1765: {
1766: expressionS ex;
1767: int iregno;
1768:
1769: register_name (&ex);
1770: demand_empty_rest_of_line ();
1771: iregno = ex.X_add_number;
1772:
1773: if (0 == strncmp (now_seg->name, ".text", 5))
1774: {
1775: if (iregno != i370_using_text_regno)
1776: as_bad (_("droping register %d in section %s does not match using register %d"),
1777: iregno, now_seg->name, i370_using_text_regno);
1778:
1779: i370_using_text_regno = -1;
1780: i370_using_text_baseaddr.X_op = O_absent;
1781: }
1782: else
1783: {
1784: if (iregno != i370_using_other_regno)
1785: as_bad (_("droping register %d in section %s does not match using register %d"),
1786: iregno, now_seg->name, i370_using_other_regno);
1787:
1788: if (i370_other_section != now_seg)
1789: as_bad (_("droping register %d in section %s previously used in section %s"),
1790: iregno, now_seg->name, i370_other_section->name);
1791:
1792: i370_using_other_regno = -1;
1793: i370_using_other_baseaddr.X_op = O_absent;
1794: i370_other_section = undefined_section;
1795: }
1796: }
1797:
1798:
1799: /* We need to keep a list of fixups. We can't simply generate them as
1800: we go, because that would require us to first create the frag, and
1801: that would screw up references to ``.''. */
1802:
1803: struct i370_fixup
1804: {
1805: expressionS exp;
1806: int opindex;
1807: bfd_reloc_code_real_type reloc;
1808: };
1809:
1810: #define MAX_INSN_FIXUPS 5
1811:
1812: /* Handle a macro. Gather all the operands, transform them as
1813: described by the macro, and call md_assemble recursively. All the
1814: operands are separated by commas; we don't accept parentheses
1815: around operands here. */
1816:
1817: static void
1818: i370_macro (char *str, const struct i370_macro *macro)
1819: {
1820: char *operands[10];
1821: unsigned int count;
1822: char *s;
1823: unsigned int len;
1824: const char *format;
1825: int arg;
1826: char *send;
1827: char *complete;
1828:
1829: /* Gather the users operands into the operands array. */
1830: count = 0;
1831: s = str;
1832: while (1)
1833: {
1834: if (count >= sizeof operands / sizeof operands[0])
1835: break;
1836: operands[count++] = s;
1837: s = strchr (s, ',');
1838: if (s == (char *) NULL)
1839: break;
1840: *s++ = '\0';
1841: }
1842:
1843: if (count != macro->operands)
1844: {
1845: as_bad (_("wrong number of operands"));
1846: return;
1847: }
1848:
1849: /* Work out how large the string must be (the size is unbounded
1850: because it includes user input). */
1851: len = 0;
1852: format = macro->format;
1853: while (*format != '\0')
1854: {
1855: if (*format != '%')
1856: {
1857: ++len;
1858: ++format;
1859: }
1860: else
1861: {
1862: arg = strtol (format + 1, &send, 10);
1863: know (send != format && arg >= 0 && (unsigned) arg < count);
1864: len += strlen (operands[arg]);
1865: format = send;
1866: }
1867: }
1868:
1869: /* Put the string together. */
1870: complete = s = alloca (len + 1);
1871: format = macro->format;
1872: while (*format != '\0')
1873: {
1874: if (*format != '%')
1875: *s++ = *format++;
1876: else
1877: {
1878: arg = strtol (format + 1, &send, 10);
1879: strcpy (s, operands[arg]);
1880: s += strlen (s);
1881: format = send;
1882: }
1883: }
1884: *s = '\0';
1885:
1886: /* Assemble the constructed instruction. */
1887: md_assemble (complete);
1888: }
1889:
1890: /* This routine is called for each instruction to be assembled. */
1891:
1892: void
1893: md_assemble (char *str)
1894: {
1895: char *s;
1896: const struct i370_opcode *opcode;
1897: i370_insn_t insn;
1898: const unsigned char *opindex_ptr;
1899: int have_optional_index, have_optional_basereg, have_optional_reg;
1900: int skip_optional_index, skip_optional_basereg, skip_optional_reg;
1901: int use_text=0, use_other=0;
1902: int off_by_one;
1903: struct i370_fixup fixups[MAX_INSN_FIXUPS];
1904: int fc;
1905: char *f;
1906: int i;
1907: #ifdef OBJ_ELF
1908: bfd_reloc_code_real_type reloc;
1909: #endif
1910:
1911: /* Get the opcode. */
1912: for (s = str; *s != '\0' && ! ISSPACE (*s); s++)
1913: ;
1914: if (*s != '\0')
1915: *s++ = '\0';
1916:
1917: /* Look up the opcode in the hash table. */
1918: opcode = (const struct i370_opcode *) hash_find (i370_hash, str);
1919: if (opcode == (const struct i370_opcode *) NULL)
1920: {
1921: const struct i370_macro *macro;
1922:
1923: gas_assert (i370_macro_hash);
1924: macro = (const struct i370_macro *) hash_find (i370_macro_hash, str);
1925: if (macro == (const struct i370_macro *) NULL)
1926: as_bad (_("Unrecognized opcode: `%s'"), str);
1927: else
1928: i370_macro (s, macro);
1929:
1930: return;
1931: }
1932:
1933: insn = opcode->opcode;
1934:
1935: str = s;
1936: while (ISSPACE (*str))
1937: ++str;
1938:
1939: /* I370 operands are either expressions or address constants.
1940: Many operand types are optional. The optional operands
1941: are always surrounded by parens, and are used to denote the base
1942: register ... e.g. "A R1, D2" or "A R1, D2(,B2) as opposed to
1943: the fully-formed "A R1, D2(X2,B2)". Note also the = sign,
1944: such as A R1,=A(i) where the address-of operator =A implies
1945: use of both a base register, and a missing index register.
1946:
1947: So, before we start seriously parsing the operands, we check
1948: to see if we have an optional operand, and, if we do, we count
1949: the number of commas to see which operand should be omitted. */
1950:
1951: have_optional_index = have_optional_basereg = have_optional_reg = 0;
1952: for (opindex_ptr = opcode->operands; *opindex_ptr != 0; opindex_ptr++)
1953: {
1954: const struct i370_operand *operand;
1955:
1956: operand = &i370_operands[*opindex_ptr];
1957: if ((operand->flags & I370_OPERAND_INDEX) != 0)
1958: have_optional_index = 1;
1959: if ((operand->flags & I370_OPERAND_BASE) != 0)
1960: have_optional_basereg = 1;
1961: if ((operand->flags & I370_OPERAND_OPTIONAL) != 0)
1962: have_optional_reg = 1;
1963: }
1964:
1965: skip_optional_index = skip_optional_basereg = skip_optional_reg = 0;
1966: if (have_optional_index || have_optional_basereg)
1967: {
1968: unsigned int opcount, nwanted;
1969:
1970: /* There is an optional operand. Count the number of
1971: commas and open-parens in the input line. */
1972: if (*str == '\0')
1973: opcount = 0;
1974: else
1975: {
1976: opcount = 1;
1977: s = str;
1978: while ((s = strpbrk (s, ",(=")) != (char *) NULL)
1979: {
1980: ++opcount;
1981: ++s;
1982: if (',' == *s) ++s; /* avoid counting things like (, */
1983: if ('=' == *s) { ++s; --opcount; }
1984: }
1985: }
1986:
1987: /* If there are fewer operands in the line then are called
1988: for by the instruction, we want to skip the optional
1989: operand. */
1990: nwanted = strlen ((char *) opcode->operands);
1991: if (have_optional_index)
1992: {
1993: if (opcount < nwanted)
1994: skip_optional_index = 1;
1995: if (have_optional_basereg && ((opcount+1) < nwanted))
1996: skip_optional_basereg = 1;
1997: if (have_optional_reg && ((opcount+1) < nwanted))
1998: skip_optional_reg = 1;
1999: }
2000: else
2001: {
2002: if (have_optional_basereg && (opcount < nwanted))
2003: skip_optional_basereg = 1;
2004: if (have_optional_reg && (opcount < nwanted))
2005: skip_optional_reg = 1;
2006: }
2007: }
2008:
2009: /* Perform some off-by-one hacks on the length field of certain instructions.
2010: Its such a shame to have to do this, but the problem is that HLASM got
2011: defined so that the lengths differ by one from the actual machine instructions.
2012: this code should probably be moved to a special inster-operand routine.
2013: Sigh. Affected instructions are Compare Logical, Move and Exclusive OR
2014: hack alert -- aren't *all* SS instructions affected ?? */
2015: off_by_one = 0;
2016: if (0 == strcasecmp ("CLC", opcode->name)
2017: || 0 == strcasecmp ("ED", opcode->name)
2018: || 0 == strcasecmp ("EDMK", opcode->name)
2019: || 0 == strcasecmp ("MVC", opcode->name)
2020: || 0 == strcasecmp ("MVCIN", opcode->name)
2021: || 0 == strcasecmp ("MVN", opcode->name)
2022: || 0 == strcasecmp ("MVZ", opcode->name)
2023: || 0 == strcasecmp ("NC", opcode->name)
2024: || 0 == strcasecmp ("OC", opcode->name)
2025: || 0 == strcasecmp ("XC", opcode->name))
2026: off_by_one = 1;
2027:
2028: /* Gather the operands. */
2029: fc = 0;
2030: for (opindex_ptr = opcode->operands; *opindex_ptr != 0; opindex_ptr++)
2031: {
2032: const struct i370_operand *operand;
2033: char *hold;
2034: expressionS ex;
2035:
2036: operand = &i370_operands[*opindex_ptr];
2037:
2038: /* If this is an index operand, and we are skipping it,
2039: just insert a zero. */
2040: if (skip_optional_index &&
2041: ((operand->flags & I370_OPERAND_INDEX) != 0))
2042: {
2043: insn = i370_insert_operand (insn, operand, 0);
2044: continue;
2045: }
2046:
2047: /* If this is the base operand, and we are skipping it,
2048: just insert the current using basreg. */
2049: if (skip_optional_basereg &&
2050: ((operand->flags & I370_OPERAND_BASE) != 0))
2051: {
2052: int basereg = -1;
2053: if (use_text)
2054: {
2055: if (0 == strncmp (now_seg->name, ".text", 5)
2056: || 0 > i370_using_other_regno)
2057: basereg = i370_using_text_regno;
2058: else
2059: basereg = i370_using_other_regno;
2060: }
2061: else if (use_other)
2062: {
2063: if (0 > i370_using_other_regno)
2064: basereg = i370_using_text_regno;
2065: else
2066: basereg = i370_using_other_regno;
2067: }
2068: if (0 > basereg)
2069: as_bad (_("not using any base register"));
2070:
2071: insn = i370_insert_operand (insn, operand, basereg);
2072: continue;
2073: }
2074:
2075: /* If this is an optional operand, and we are skipping it,
2076: Use zero (since a non-zero value would denote a register) */
2077: if (skip_optional_reg
2078: && ((operand->flags & I370_OPERAND_OPTIONAL) != 0))
2079: {
2080: insn = i370_insert_operand (insn, operand, 0);
2081: continue;
2082: }
2083:
2084: /* Gather the operand. */
2085: hold = input_line_pointer;
2086: input_line_pointer = str;
2087:
2088: /* Register names are only allowed where there are registers. */
2089: if ((operand->flags & I370_OPERAND_GPR) != 0)
2090: {
2091: /* Quickie hack to get past things like (,r13). */
2092: if (skip_optional_index && (',' == *input_line_pointer))
2093: {
2094: *input_line_pointer = ' ';
2095: input_line_pointer ++;
2096: }
2097:
2098: if (! register_name (&ex))
2099: as_bad (_("expecting a register for operand %d"),
2100: (int) (opindex_ptr - opcode->operands + 1));
2101: }
2102:
2103: /* Check for an address constant expression. */
2104: /* We will put PSW-relative addresses in the text section,
2105: and address literals in the .data (or other) section. */
2106: else if (i370_addr_cons (&ex))
2107: use_other = 1;
2108: else if (i370_addr_offset (&ex))
2109: use_text = 1;
2110: else expression (&ex);
2111:
2112: str = input_line_pointer;
2113: input_line_pointer = hold;
2114:
2115: /* Perform some off-by-one hacks on the length field of certain instructions.
2116: Its such a shame to have to do this, but the problem is that HLASM got
2117: defined so that the programmer specifies a length that is one greater
2118: than what the machine instruction wants. Sigh. */
2119: if (off_by_one && (0 == strcasecmp ("SS L", operand->name)))
2120: ex.X_add_number --;
2121:
2122: if (ex.X_op == O_illegal)
2123: as_bad (_("illegal operand"));
2124: else if (ex.X_op == O_absent)
2125: as_bad (_("missing operand"));
2126: else if (ex.X_op == O_register)
2127: insn = i370_insert_operand (insn, operand, ex.X_add_number);
2128: else if (ex.X_op == O_constant)
2129: {
2130: #ifdef OBJ_ELF
2131: /* Allow @HA, @L, @H on constants.
2132: Well actually, no we don't; there really don't make sense
2133: (at least not to me) for the i370. However, this code is
2134: left here for any dubious future expansion reasons. */
2135: char *orig_str = str;
2136:
2137: if ((reloc = i370_elf_suffix (&str, &ex)) != BFD_RELOC_UNUSED)
2138: switch (reloc)
2139: {
2140: default:
2141: str = orig_str;
2142: break;
2143:
2144: case BFD_RELOC_LO16:
2145: /* X_unsigned is the default, so if the user has done
2146: something which cleared it, we always produce a
2147: signed value. */
2148: ex.X_add_number = (((ex.X_add_number & 0xffff)
2149: ^ 0x8000)
2150: - 0x8000);
2151: break;
2152:
2153: case BFD_RELOC_HI16:
2154: ex.X_add_number = (ex.X_add_number >> 16) & 0xffff;
2155: break;
2156:
2157: case BFD_RELOC_HI16_S:
2158: ex.X_add_number = (((ex.X_add_number >> 16) & 0xffff)
2159: + ((ex.X_add_number >> 15) & 1));
2160: break;
2161: }
2162: #endif
2163: insn = i370_insert_operand (insn, operand, ex.X_add_number);
2164: }
2165: #ifdef OBJ_ELF
2166: else if ((reloc = i370_elf_suffix (&str, &ex)) != BFD_RELOC_UNUSED)
2167: {
2168: as_tsktsk ("md_assemble(): suffixed relocations not supported\n");
2169:
2170: /* We need to generate a fixup for this expression. */
2171: if (fc >= MAX_INSN_FIXUPS)
2172: as_fatal ("too many fixups");
2173: fixups[fc].exp = ex;
2174: fixups[fc].opindex = 0;
2175: fixups[fc].reloc = reloc;
2176: ++fc;
2177: }
2178: #endif /* OBJ_ELF */
2179: else
2180: {
2181: /* We need to generate a fixup for this expression. */
2182: /* Typically, the expression will just be a symbol ...
2183: printf ("insn %s needs fixup for %s \n",
2184: opcode->name, ex.X_add_symbol->bsym->name); */
2185:
2186: if (fc >= MAX_INSN_FIXUPS)
2187: as_fatal ("too many fixups");
2188: fixups[fc].exp = ex;
2189: fixups[fc].opindex = *opindex_ptr;
2190: fixups[fc].reloc = BFD_RELOC_UNUSED;
2191: ++fc;
2192: }
2193:
2194: /* Skip over delimiter (close paren, or comma). */
2195: if ((')' == *str) && (',' == *(str+1)))
2196: ++str;
2197: if (*str != '\0')
2198: ++str;
2199: }
2200:
2201: while (ISSPACE (*str))
2202: ++str;
2203:
2204: if (*str != '\0')
2205: as_bad (_("junk at end of line: `%s'"), str);
2206:
2207: /* Write out the instruction. */
2208: f = frag_more (opcode->len);
2209: if (4 >= opcode->len)
2210: md_number_to_chars (f, insn.i[0], opcode->len);
2211: else
2212: {
2213: md_number_to_chars (f, insn.i[0], 4);
2214:
2215: if (6 == opcode->len)
2216: md_number_to_chars ((f + 4), ((insn.i[1])>>16), 2);
2217: else
2218: {
2219: /* Not used --- don't have any 8 byte instructions. */
2220: as_bad (_("Internal Error: bad instruction length"));
2221: md_number_to_chars ((f + 4), insn.i[1], opcode->len -4);
2222: }
2223: }
2224:
2225: /* Create any fixups. At this point we do not use a
2226: bfd_reloc_code_real_type, but instead just use the
2227: BFD_RELOC_UNUSED plus the operand index. This lets us easily
2228: handle fixups for any operand type, although that is admittedly
2229: not a very exciting feature. We pick a BFD reloc type in
2230: md_apply_fix. */
2231: for (i = 0; i < fc; i++)
2232: {
2233: const struct i370_operand *operand;
2234:
2235: operand = &i370_operands[fixups[i].opindex];
2236: if (fixups[i].reloc != BFD_RELOC_UNUSED)
2237: {
2238: reloc_howto_type *reloc_howto = bfd_reloc_type_lookup (stdoutput, fixups[i].reloc);
2239: int size;
2240: fixS *fixP;
2241:
2242: if (!reloc_howto)
2243: abort ();
2244:
2245: size = bfd_get_reloc_size (reloc_howto);
2246:
2247: if (size < 1 || size > 4)
2248: abort ();
2249:
2250: printf (" gwana doo fixup %d \n", i);
2251: fixP = fix_new_exp (frag_now, f - frag_now->fr_literal, size,
2252: &fixups[i].exp, reloc_howto->pc_relative,
2253: fixups[i].reloc);
2254:
2255: /* Turn off complaints that the addend is too large for things like
2256: foo+100000@ha. */
2257: switch (fixups[i].reloc)
2258: {
2259: case BFD_RELOC_16_GOTOFF:
2260: case BFD_RELOC_LO16:
2261: case BFD_RELOC_HI16:
2262: case BFD_RELOC_HI16_S:
2263: fixP->fx_no_overflow = 1;
2264: break;
2265: default:
2266: break;
2267: }
2268: }
2269: else
2270: {
2271: fix_new_exp (frag_now, f - frag_now->fr_literal, opcode->len,
2272: &fixups[i].exp,
2273: (operand->flags & I370_OPERAND_RELATIVE) != 0,
2274: ((bfd_reloc_code_real_type)
2275: (fixups[i].opindex + (int) BFD_RELOC_UNUSED)));
2276: }
2277: }
2278: }
2279:
2280:
2281: /* Pseudo-op handling. */
2282:
2283: /* The .byte pseudo-op. This is similar to the normal .byte
2284: pseudo-op, but it can also take a single ASCII string. */
2285:
2286: static void
2287: i370_byte (int ignore ATTRIBUTE_UNUSED)
2288: {
2289: if (*input_line_pointer != '\"')
2290: {
2291: cons (1);
2292: return;
2293: }
2294:
2295: /* Gather characters. A real double quote is doubled. Unusual
2296: characters are not permitted. */
2297: ++input_line_pointer;
2298: while (1)
2299: {
2300: char c;
2301:
2302: c = *input_line_pointer++;
2303:
2304: if (c == '\"')
2305: {
2306: if (*input_line_pointer != '\"')
2307: break;
2308: ++input_line_pointer;
2309: }
2310:
2311: FRAG_APPEND_1_CHAR (c);
2312: }
2313:
2314: demand_empty_rest_of_line ();
2315: }
2316:
2317: /* The .tc pseudo-op. This is used when generating XCOFF and ELF.
2318: This takes two or more arguments.
2319:
2320: When generating XCOFF output, the first argument is the name to
2321: give to this location in the toc; this will be a symbol with class
2322: TC. The rest of the arguments are 4 byte values to actually put at
2323: this location in the TOC; often there is just one more argument, a
2324: relocatable symbol reference.
2325:
2326: When not generating XCOFF output, the arguments are the same, but
2327: the first argument is simply ignored. */
2328:
2329: static void
2330: i370_tc (int ignore ATTRIBUTE_UNUSED)
2331: {
2332:
2333: /* Skip the TOC symbol name. */
2334: while (is_part_of_name (*input_line_pointer)
2335: || *input_line_pointer == '['
2336: || *input_line_pointer == ']'
2337: || *input_line_pointer == '{'
2338: || *input_line_pointer == '}')
2339: ++input_line_pointer;
2340:
2341: /* Align to a four byte boundary. */
2342: frag_align (2, 0, 0);
2343: record_alignment (now_seg, 2);
2344:
2345: if (*input_line_pointer != ',')
2346: demand_empty_rest_of_line ();
2347: else
2348: {
2349: ++input_line_pointer;
2350: cons (4);
2351: }
2352: }
2353:
2354: char *
2355: md_atof (int type, char *litp, int *sizep)
2356: {
2357: /* 360/370/390 have two float formats: an old, funky 360 single-precision
2358: format, and the ieee format. Support only the ieee format. */
2359: return ieee_md_atof (type, litp, sizep, TRUE);
2360: }
2361:
2362: /* Write a value out to the object file, using the appropriate
2363: endianness. */
2364:
2365: void
2366: md_number_to_chars (char *buf, valueT val, int n)
2367: {
2368: number_to_chars_bigendian (buf, val, n);
2369: }
2370:
2371: /* Align a section (I don't know why this is machine dependent). */
2372:
2373: valueT
2374: md_section_align (asection *seg, valueT addr)
2375: {
2376: int align = bfd_get_section_alignment (stdoutput, seg);
2377:
1.3 ! christos 2378: return (addr + (1 << align) - 1) & -(1 << align);
1.1 christos 2379: }
2380:
2381: /* We don't have any form of relaxing. */
2382:
2383: int
2384: md_estimate_size_before_relax (fragS *fragp ATTRIBUTE_UNUSED,
2385: asection *seg ATTRIBUTE_UNUSED)
2386: {
2387: abort ();
2388: return 0;
2389: }
2390:
2391: /* Convert a machine dependent frag. We never generate these. */
2392:
2393: void
2394: md_convert_frag (bfd *abfd ATTRIBUTE_UNUSED,
2395: asection *sec ATTRIBUTE_UNUSED,
2396: fragS *fragp ATTRIBUTE_UNUSED)
2397: {
2398: abort ();
2399: }
2400:
2401: /* We have no need to default values of symbols. */
2402:
2403: symbolS *
2404: md_undefined_symbol (char *name ATTRIBUTE_UNUSED)
2405: {
2406: return 0;
2407: }
2408:
2409: /* Functions concerning relocs. */
2410:
2411: /* The location from which a PC relative jump should be calculated,
2412: given a PC relative reloc. */
2413:
2414: long
2415: md_pcrel_from_section (fixS *fixp, segT sec ATTRIBUTE_UNUSED)
2416: {
2417: return fixp->fx_frag->fr_address + fixp->fx_where;
2418: }
2419:
2420: /* Apply a fixup to the object code. This is called for all the
2421: fixups we generated by the call to fix_new_exp, above. In the call
2422: above we used a reloc code which was the largest legal reloc code
2423: plus the operand index. Here we undo that to recover the operand
2424: index. At this point all symbol values should be fully resolved,
2425: and we attempt to completely resolve the reloc. If we can not do
2426: that, we determine the correct reloc code and put it back in the
2427: fixup.
2428:
2429: See gas/cgen.c for more sample code and explanations of what's
2430: going on here. */
2431:
2432: void
2433: md_apply_fix (fixS *fixP, valueT * valP, segT seg)
2434: {
2435: valueT value = * valP;
2436:
2437: if (fixP->fx_addsy != NULL)
2438: {
2439: #ifdef DEBUG
2440: printf ("\nmd_apply_fix: symbol %s at 0x%x (%s:%d) val=0x%x addend=0x%x\n",
2441: S_GET_NAME (fixP->fx_addsy),
2442: fixP->fx_frag->fr_address + fixP->fx_where,
2443: fixP->fx_file, fixP->fx_line,
2444: S_GET_VALUE (fixP->fx_addsy), value);
2445: #endif
2446: }
2447: else
2448: fixP->fx_done = 1;
2449:
2450: /* Apply fixups to operands. Note that there should be no relocations
2451: for any operands, since no instruction ever takes an operand
2452: that requires reloc. */
2453: if ((int) fixP->fx_r_type >= (int) BFD_RELOC_UNUSED)
2454: {
2455: int opindex;
2456: const struct i370_operand *operand;
2457: char *where;
2458: i370_insn_t insn;
2459:
2460: opindex = (int) fixP->fx_r_type - (int) BFD_RELOC_UNUSED;
2461:
2462: operand = &i370_operands[opindex];
2463:
2464: #ifdef DEBUG
2465: printf ("\nmd_apply_fix: fixup operand %s at 0x%x in %s:%d addend=0x%x\n",
2466: operand->name,
2467: fixP->fx_frag->fr_address + fixP->fx_where,
2468: fixP->fx_file, fixP->fx_line,
2469: value);
2470: #endif
2471: /* Fetch the instruction, insert the fully resolved operand
2472: value, and stuff the instruction back again.
2473: fisxp->fx_size is the length of the instruction. */
2474: where = fixP->fx_frag->fr_literal + fixP->fx_where;
2475: insn.i[0] = bfd_getb32 ((unsigned char *) where);
2476:
2477: if (6 <= fixP->fx_size)
2478: /* Deal with 48-bit insn's. */
2479: insn.i[1] = bfd_getb32 (((unsigned char *) where)+4);
2480:
2481: insn = i370_insert_operand (insn, operand, (offsetT) value);
2482: bfd_putb32 ((bfd_vma) insn.i[0], (unsigned char *) where);
2483:
2484: if (6 <= fixP->fx_size)
2485: /* Deal with 48-bit insn's. */
2486: bfd_putb32 ((bfd_vma) insn.i[1], (((unsigned char *) where)+4));
2487:
2488: /* We are done, right? right !! */
2489: fixP->fx_done = 1;
2490: if (fixP->fx_done)
2491: /* Nothing else to do here. */
2492: return;
2493:
2494: /* Determine a BFD reloc value based on the operand information.
2495: We are only prepared to turn a few of the operands into
2496: relocs. In fact, we support *zero* operand relocations ...
2497: Why? Because we are not expecting the compiler to generate
2498: any operands that need relocation. Due to the 12-bit naturew of
2499: i370 addressing, this would be unusual. */
2500: {
2501: char *sfile;
2502: unsigned int sline;
2503:
2504: /* Use expr_symbol_where to see if this is an expression
2505: symbol. */
2506: if (expr_symbol_where (fixP->fx_addsy, &sfile, &sline))
2507: as_bad_where (fixP->fx_file, fixP->fx_line,
2508: "unresolved expression that must be resolved");
2509: else
2510: as_bad_where (fixP->fx_file, fixP->fx_line,
2511: "unsupported relocation type");
2512: fixP->fx_done = 1;
2513: return;
2514: }
2515: }
2516: else
2517: {
2518: /* We branch to here if the fixup is not to a symbol that
2519: appears in an instruction operand, but is rather some
2520: declared storage. */
2521: #ifdef OBJ_ELF
2522: i370_elf_validate_fix (fixP, seg);
2523: #endif
2524: #ifdef DEBUG
2525: printf ("md_apply_fix: reloc case %d in segment %s %s:%d\n",
2526: fixP->fx_r_type, segment_name (seg), fixP->fx_file, fixP->fx_line);
2527: printf ("\tcurrent fixup value is 0x%x \n", value);
2528: #endif
2529: switch (fixP->fx_r_type)
2530: {
2531: case BFD_RELOC_32:
2532: case BFD_RELOC_CTOR:
2533: if (fixP->fx_pcrel)
2534: fixP->fx_r_type = BFD_RELOC_32_PCREL;
2535: /* Fall through. */
2536:
2537: case BFD_RELOC_RVA:
2538: case BFD_RELOC_32_PCREL:
2539: case BFD_RELOC_32_BASEREL:
2540: #ifdef DEBUG
2541: printf ("\t32 bit relocation at 0x%x\n",
2542: fixP->fx_frag->fr_address + fixP->fx_where);
2543: #endif
2544: md_number_to_chars (fixP->fx_frag->fr_literal + fixP->fx_where,
2545: value, 4);
2546: break;
2547:
2548: case BFD_RELOC_LO16:
2549: case BFD_RELOC_16:
2550: if (fixP->fx_pcrel)
2551: as_bad_where (fixP->fx_file, fixP->fx_line,
2552: "cannot emit PC relative %s relocation%s%s",
2553: bfd_get_reloc_code_name (fixP->fx_r_type),
2554: fixP->fx_addsy != NULL ? " against " : "",
2555: (fixP->fx_addsy != NULL
2556: ? S_GET_NAME (fixP->fx_addsy)
2557: : ""));
2558:
2559: md_number_to_chars (fixP->fx_frag->fr_literal + fixP->fx_where,
2560: value, 2);
2561: break;
2562:
2563: /* This case happens when you write, for example,
2564: lis %r3,(L1-L2)@ha
2565: where L1 and L2 are defined later. */
2566: case BFD_RELOC_HI16:
2567: if (fixP->fx_pcrel)
2568: abort ();
2569: md_number_to_chars (fixP->fx_frag->fr_literal + fixP->fx_where,
2570: value >> 16, 2);
2571: break;
2572: case BFD_RELOC_HI16_S:
2573: if (fixP->fx_pcrel)
2574: abort ();
2575: md_number_to_chars (fixP->fx_frag->fr_literal + fixP->fx_where,
2576: (value + 0x8000) >> 16, 2);
2577: break;
2578:
2579: case BFD_RELOC_8:
2580: if (fixP->fx_pcrel)
2581: abort ();
2582:
2583: md_number_to_chars (fixP->fx_frag->fr_literal + fixP->fx_where,
2584: value, 1);
2585: break;
2586:
2587: default:
2588: fprintf (stderr,
2589: "Gas failure, reloc value %d\n", fixP->fx_r_type);
2590: fflush (stderr);
2591: abort ();
2592: }
2593: }
2594:
2595: fixP->fx_addnumber = value;
2596: }
2597:
2598: /* Generate a reloc for a fixup. */
2599:
2600: arelent *
2601: tc_gen_reloc (asection *seg ATTRIBUTE_UNUSED, fixS *fixp)
2602: {
2603: arelent *reloc;
2604:
2605: reloc = xmalloc (sizeof (arelent));
2606:
2607: reloc->sym_ptr_ptr = xmalloc (sizeof (asymbol *));
2608: *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
2609: reloc->address = fixp->fx_frag->fr_address + fixp->fx_where;
2610: reloc->howto = bfd_reloc_type_lookup (stdoutput, fixp->fx_r_type);
2611: if (reloc->howto == (reloc_howto_type *) NULL)
2612: {
2613: as_bad_where (fixp->fx_file, fixp->fx_line,
2614: "reloc %d not supported by object file format", (int)fixp->fx_r_type);
2615: return NULL;
2616: }
2617: reloc->addend = fixp->fx_addnumber;
2618:
2619: #ifdef DEBUG
2620: printf ("\ngen_reloc(): sym %s (%s:%d) at addr 0x%x addend=0x%x\n",
2621: fixp->fx_addsy->bsym->name,
2622: fixp->fx_file, fixp->fx_line,
2623: reloc->address, reloc->addend);
2624: #endif
2625:
2626: return reloc;
2627: }
2628:
2629: /* The target specific pseudo-ops which we support. */
2630:
2631: const pseudo_typeS md_pseudo_table[] =
2632: {
2633: /* Pseudo-ops which must be overridden. */
2634: { "byte", i370_byte, 0 },
2635:
2636: { "dc", i370_dc, 0 },
2637: { "ds", i370_ds, 0 },
2638: { "rmode", i370_rmode, 0 },
2639: { "csect", i370_csect, 0 },
2640: { "dsect", i370_dsect, 0 },
2641:
2642: /* enable ebcdic strings e.g. for 3270 support */
2643: { "ebcdic", i370_ebcdic, 0 },
2644:
2645: #ifdef OBJ_ELF
2646: { "long", i370_elf_cons, 4 },
2647: { "word", i370_elf_cons, 4 },
2648: { "short", i370_elf_cons, 2 },
2649: { "rdata", i370_elf_rdata, 0 },
2650: { "rodata", i370_elf_rdata, 0 },
2651: { "lcomm", i370_elf_lcomm, 0 },
2652: #endif
2653:
2654: /* This pseudo-op is used even when not generating XCOFF output. */
2655: { "tc", i370_tc, 0 },
2656:
2657: /* dump the literal pool */
2658: { "ltorg", i370_ltorg, 0 },
2659:
2660: /* support the hlasm-style USING directive */
2661: { "using", i370_using, 0 },
2662: { "drop", i370_drop, 0 },
2663:
2664: { NULL, NULL, 0 }
2665: };
CVSweb <webmaster@jp.NetBSD.org>
![[BACK]](/icons/back.gif){kind=icon}
Return to tc-i370.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [cvs.NetBSD.org] / src / external / gpl3 / binutils.old / dist / gas / config