![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sparc.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / GNUtools / cctools / as|
Return to sparc.c CVS log | Up to [Apple XNU] / GNUtools / cctools / as |
1.1 root 1: /* tc-sparc.c -- Assemble for the SPARC
2: Copyright (C) 1989, 1990, 1991, 1992 Free Software Foundation, Inc.
3:
4: This file is part of GAS, the GNU Assembler.
5:
6: GAS is free software; you can redistribute it and/or modify
7: it under the terms of the GNU General Public License as published by
8: the Free Software Foundation; either version 2, or (at your option)
9: any later version.
10:
11: GAS is distributed in the hope that it will be useful,
12: but WITHOUT ANY WARRANTY; without even the implied warranty of
13: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14: GNU General Public License for more details.
15:
16: You should have received a copy of the GNU General Public License
17: along with GAS; see the file COPYING. If not, write to
18: the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
19:
20: /* relocation type for internal assembler use only */
21: #define SPARC_RELOC_13 (127)
22: #define SPARC_RELOC_22 (126)
23:
24: #define cypress 1234
25:
26: #undef DEBUGINSN
27:
28: #include <stdio.h>
29: #include <ctype.h>
30: #include "as.h"
31: #include "libc.h"
32: #include "md.h"
33: #include "messages.h"
34: #include "symbols.h"
35:
36: /* careful, this file includes data *declarations* */
37: #include "sparc-opcode.h"
38: #include <mach-o/sparc/reloc.h>
39:
40: /* From GNU ansidecl.h */
41: #define PARAMS(paramlist) paramlist
42:
43: typedef long offsetT;
44:
45: /*
46: * These are the default cputype and cpusubtype for the Sparc architecture.
47: */
48: const cpu_type_t md_cputype = CPU_TYPE_SPARC;
49: cpu_subtype_t md_cpusubtype = CPU_SUBTYPE_SPARC_ALL;
50:
51: /* This is the byte sex for the Sparc architecture */
52: const enum byte_sex md_target_byte_sex = BIG_ENDIAN_BYTE_SEX;
53:
54: /* These characters start a comment anywhere on the line */
55: const char md_comment_chars[] = ";!";
56:
57: /* These characters only start a comment at the beginning of a line */
58: const char md_line_comment_chars[] = "#";
59:
60: /*
61: * These characters can be used to separate mantissa decimal digits from
62: * exponent decimal digits in floating point numbers.
63: */
64: const char md_EXP_CHARS[] = "eE";
65:
66: /*
67: * The characters after a leading 0 that means this number is a floating point
68: * constant as in 0f123.456 or 0d1.234E-12 (see md_EXP_CHARS above).
69: */
70: const char md_FLT_CHARS[] = "dDfF";
71:
72: static void sparc_ip PARAMS ((char *));
73:
74: static enum sparc_architecture current_architecture = v6;
75: static int architecture_requested;
76: static int warn_on_bump;
77:
78: const relax_typeS md_relax_table[1];
79:
80: /* handle of the OPCODE hash table */
81: static struct hash_control *op_hash = NULL;
82:
83: #ifdef NeXT
84: static void s_proc PARAMS ((int));
85: static void s_ignore PARAMS ((int));
86: extern void s_seg PARAMS ((int));
87: #else NeXT
88: static void s_data1 PARAMS ((void));
89: static void s_seg PARAMS ((int));
90: static void s_proc PARAMS ((int));
91: static void s_reserve PARAMS ((int));
92: static void s_common PARAMS ((int));
93: #endif NeXT
94:
95: const pseudo_typeS md_pseudo_table[] =
96: {
97: #ifdef NeXT
98: {"global", s_globl, 0}, /* Maybe we should fix compiler to use globl */
99: {"proc", s_proc, 0}, /* nop??? */
100: /* This are to handle SUN assembler files and point to existing handlers */
101: {"empty", s_ignore, 0},
102: {"ident", s_ignore, 0},
103: {"optim", s_ignore, 0},
104: {"skip", s_space, 0},
105: {"type", s_ignore, 0},
106: {"word", cons, 4},
107: {"half", cons, 2},
108: /* these are custom handlers for SUN SPARC assembler only */
109:
110: #else NeXT
111: {"seg", s_seg, 0},
112: {"align", s_align_bytes, 0}, /* Defaulting is invalid (0) */
113: {"common", s_common, 0},
114: {"global", s_globl, 0},
115: {"half", cons, 2},
116: {"optim", s_ignore, 0},
117: {"proc", s_proc, 0},
118: {"reserve", s_reserve, 0},
119: {"seg", s_seg, 0},
120: {"skip", s_space, 0},
121: {"word", cons, 4},
122: #endif NeXT
123: {NULL, 0, 0},
124: };
125:
126: const int md_short_jump_size = 4;
127: const int md_long_jump_size = 4;
128: const int md_reloc_size = 12; /* Size of relocation record */
129:
130: /* This array holds the chars that always start a comment. If the
131: pre-processor is disabled, these aren't very useful */
132: const char comment_chars[] = "!"; /* JF removed '|' from comment_chars */
133:
134: /* This array holds the chars that only start a comment at the beginning of
135: a line. If the line seems to have the form '# 123 filename'
136: .line and .file directives will appear in the pre-processed output */
137: /* Note that input_file.c hand checks for '#' at the beginning of the
138: first line of the input file. This is because the compiler outputs
139: #NO_APP at the beginning of its output. */
140: /* Also note that comments started like this one will always
141: work if '/' isn't otherwise defined. */
142: const char line_comment_chars[] = "#";
143:
144: const char line_separator_chars[] = "";
145:
146: /* Chars that can be used to separate mant from exp in floating point nums */
147: const char EXP_CHARS[] = "eE";
148:
149: /* Chars that mean this number is a floating point constant */
150: /* As in 0f12.456 */
151: /* or 0d1.2345e12 */
152: const char FLT_CHARS[] = "rRsSfFdDxXpP";
153:
154: /* Also be aware that MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT may have to be
155: changed in read.c. Ideally it shouldn't have to know about it at all,
156: but nothing is ideal around here. */
157:
158: static unsigned char octal[256];
159: #define isoctal(c) octal[(unsigned char) (c)]
160: static unsigned char toHex[256];
161:
162: struct sparc_it
163: {
164: char *error;
165: unsigned long opcode;
166: struct nlist *nlistp;
167: expressionS exp;
168: int pcrel;
169: char pcrel_reloc; /* do relocation? */
170: enum reloc_type_sparc reloc;
171: };
172:
173: struct sparc_it the_insn;
174:
175: #ifdef DEBUGINSN
176: static void print_insn PARAMS ((struct sparc_it *insn));
177: #endif
178: static int getExpression PARAMS ((char *str));
179:
180: static char *expr_end;
181:
182:
183: /*
184: * Indicates a 'set' instruction which may require a either
185: * of the following instructions depending on the size of the
186: * value argument:
187: *
188: * sethi %hi(value),reg
189: *
190: * or %g0,value,reg
191: *
192: * sethi %hi(value),reg
193: * or reg,%lo(value),reg
194: *
195: */
196: static int special_case_set = 0;
197:
198: /* s_proc and s_ignore are included for rudimentary
199: compatibility with the Sun assembler only */
200:
201: static void
202: s_proc (ignore)
203: int ignore;
204: {
205: totally_ignore_line();
206: }
207:
208: /* we simply ignore the rest of this statement */
209: static void
210: s_ignore (ignore)
211: int ignore;
212: {
213: totally_ignore_line();
214: }
215:
216: /* This function is called once, at assembler startup time. It should
217: set up all the tables, etc. that the MD part of the assembler will need. */
218: void
219: md_begin ()
220: {
221: register const char *retval = NULL;
222: int lose = 0;
223: register unsigned int i = 0;
224:
225: op_hash = hash_new ();
226:
227: while (i < NUMOPCODES)
228: {
229: const char *name = sparc_opcodes[i].name;
230: retval = hash_insert (op_hash, (char *)name, (char *)&sparc_opcodes[i]);
231:
232: if(retval != NULL && *retval != '\0') {
233: fprintf (stderr, "internal error: can't hash `%s': %s\n",
234: sparc_opcodes[i].name, retval);
235: lose = 1;
236: } do {
237: if (sparc_opcodes[i].match & sparc_opcodes[i].lose)
238: {
239: fprintf (stderr, "internal error: losing opcode: `%s' \"%s\"\n",
240: sparc_opcodes[i].name, sparc_opcodes[i].args);
241: lose = 1;
242: }
243: ++i;
244: }
245: while (i < NUMOPCODES
246: && !strcmp (sparc_opcodes[i].name, name));
247: }
248:
249: if (lose)
250: as_fatal ("Broken assembler. No assembly attempted.");
251:
252: for (i = '0'; i < '8'; ++i)
253: octal[i] = 1;
254: for (i = '0'; i <= '9'; ++i)
255: toHex[i] = i - '0';
256: for (i = 'a'; i <= 'f'; ++i)
257: toHex[i] = i + 10 - 'a';
258: for (i = 'A'; i <= 'F'; ++i)
259: toHex[i] = i + 10 - 'A';
260: }
261:
262: void
263: md_end(
264: void)
265: {
266: return;
267: }
268:
269: void
270: md_assemble (str)
271: char *str;
272: {
273: char *toP;
274: int rsd;
275:
276: know (str);
277: sparc_ip (str);
278:
279: #ifdef DEBUGINSN
280: print_insn(&the_insn);
281: #endif
282:
283: /* See if "set" operand is absolute and small; skip sethi if so. */
284: if (special_case_set && the_insn.exp.X_seg == SEG_ABSOLUTE)
285: {
286: if (the_insn.exp.X_add_number >= -(1 << 12)
287: && the_insn.exp.X_add_number < (1 << 12))
288: {
289: the_insn.opcode = 0x80102000 /* or %g0,imm,... */
290: | (the_insn.opcode & 0x3E000000) /* dest reg */
291: | (the_insn.exp.X_add_number & 0x1FFF); /* imm */
292: special_case_set = 0; /* No longer special */
293: the_insn.reloc = SPARC_RELOC_NONE; /* No longer relocated */
294: }
295: }
296:
297: toP = frag_more (4);
298: /* put out the opcode */
299: md_number_to_chars (toP, (valueT) the_insn.opcode, 4);
300:
301: /* put out the symbol-dependent stuff */
302: if (the_insn.reloc != SPARC_RELOC_NONE)
303: {
304: fix_new(frag_now,
305: (toP - frag_now->fr_literal),
306: 4,
307: the_insn.exp.X_add_symbol,
308: the_insn.exp.X_subtract_symbol,
309: the_insn.exp.X_add_number,
310: the_insn.pcrel,
311: the_insn.pcrel_reloc, /* 1 for local labels due to scatter loading */
312: the_insn.reloc);
313: }
314:
315: if (special_case_set) {
316: special_case_set = 0;
317: assert (the_insn.reloc == SPARC_RELOC_HI22);
318: /* See if "set" operand has no low-order bits; skip OR if so. */
319: if ((the_insn.exp.X_seg == SEG_ABSOLUTE) &&
320: ((the_insn.exp.X_add_number & 0x3FF) == 0))
321: return;
322:
323: toP = frag_more (4);
324: rsd = (the_insn.opcode >> 25) & 0x1f;
325: the_insn.opcode = 0x80102000 | (rsd << 25) | (rsd << 14);
326: md_number_to_chars (toP, (valueT) the_insn.opcode, 4);
327: the_insn.pcrel_reloc = 0;
328:
329: fix_new(frag_now,
330: (toP - frag_now->fr_literal),
331: 4,
332: the_insn.exp.X_add_symbol,
333: the_insn.exp.X_subtract_symbol,
334: the_insn.exp.X_add_number,
335: the_insn.pcrel,
336: the_insn.pcrel_reloc,
337: SPARC_RELOC_LO10);
338: return;
339: }
340: }
341:
342: static void
343: sparc_ip (str)
344: char *str;
345: {
346: char *error_message = "";
347: char *s;
348: const char *args;
349: char c;
350: struct sparc_opcode *insn;
351: char *argsStart;
352: unsigned long opcode;
353: unsigned int mask = 0;
354: int match = 0;
355: int comma = 0;
356: long immediate_max = 0;
357:
358: for (s = str; islower (*s) || (*s >= '0' && *s <= '3'); ++s)
359: ;
360: switch (*s)
361: {
362:
363: case '\0':
364: break;
365:
366: case ',':
367: comma = 1;
368:
369: /*FALLTHROUGH */
370:
371: case ' ':
372: *s++ = '\0';
373: break;
374:
375: default:
376: as_bad ("Unknown opcode: `%s'", str);
377: exit (1);
378: }
379: if ((insn = (struct sparc_opcode *) hash_find (op_hash, str)) == NULL)
380: {
381: as_bad ("Unknown opcode: `%s'", str);
382: return;
383: }
384: if (comma)
385: {
386: *--s = ',';
387: }
388: argsStart = s;
389: for (;;)
390: {
391: opcode = insn->match;
392: memset (&the_insn, '\0', sizeof (the_insn));
393: the_insn.reloc = SPARC_RELOC_NONE;
394: the_insn.pcrel_reloc = 1; /* default, reloc, for scatter loading */
395:
396: /*
397: * Build the opcode, checking as we go to make
398: * sure that the operands match
399: */
400: for (args = insn->args;; ++args)
401: {
402: switch (*args)
403: {
404: case 'M':
405: case 'm':
406: if (strncmp (s, "%asr", 4) == 0)
407: {
408: s += 4;
409:
410: if (isdigit (*s))
411: {
412: long num = 0;
413:
414: while (isdigit (*s))
415: {
416: num = num * 10 + *s - '0';
417: ++s;
418: }
419:
420: if (num < 16 || 31 < num)
421: {
422: error_message = ": asr number must be between 15 and 31";
423: goto error;
424: } /* out of range */
425:
426: opcode |= (*args == 'M' ? RS1 (num) : RD (num));
427: continue;
428: }
429: else
430: {
431: error_message = ": expecting %asrN";
432: goto error;
433: } /* if %asr followed by a number. */
434:
435: } /* if %asr */
436: break;
437:
438:
439: case '\0': /* end of args */
440: if (*s == '\0')
441: {
442: match = 1;
443: }
444: break;
445:
446: case '+':
447: if (*s == '+')
448: {
449: ++s;
450: continue;
451: }
452: if (*s == '-')
453: {
454: continue;
455: }
456: break;
457:
458: case '[': /* these must match exactly */
459: case ']':
460: case ',':
461: case ' ':
462: if (*s++ == *args)
463: continue;
464: break;
465:
466: case '#': /* must be at least one digit */
467: if (isdigit (*s++))
468: {
469: while (isdigit (*s))
470: {
471: ++s;
472: }
473: continue;
474: }
475: break;
476:
477: case 'C': /* coprocessor state register */
478: if (strncmp (s, "%csr", 4) == 0)
479: {
480: s += 4;
481: continue;
482: }
483: break;
484:
485: case 'b': /* next operand is a coprocessor register */
486: case 'c':
487: case 'D':
488: if (*s++ == '%' && *s++ == 'c' && isdigit (*s))
489: {
490: mask = *s++;
491: if (isdigit (*s))
492: {
493: mask = 10 * (mask - '0') + (*s++ - '0');
494: if (mask >= 32)
495: {
496: break;
497: }
498: }
499: else
500: {
501: mask -= '0';
502: }
503: switch (*args)
504: {
505:
506: case 'b':
507: opcode |= mask << 14;
508: continue;
509:
510: case 'c':
511: opcode |= mask;
512: continue;
513:
514: case 'D':
515: opcode |= mask << 25;
516: continue;
517: }
518: }
519: break;
520:
521: case 'r': /* next operand must be a register */
522: case 'u':
523: case '1':
524: case '2':
525: case 'd':
526: if (*s++ == '%')
527: {
528: switch (c = *s++)
529: {
530:
531: case 'f': /* frame pointer */
532: if (*s++ == 'p')
533: {
534: mask = 0x1e;
535: break;
536: }
537: error_message = ": register not fp";
538: goto error;
539:
540: case 'g': /* global register */
541: if (isoctal (c = *s++))
542: {
543: mask = c - '0';
544: break;
545: }
546: error_message = ": invalid global register";
547: goto error;
548:
549: case 'i': /* in register */
550: if (isoctal (c = *s++))
551: {
552: mask = c - '0' + 24;
553: break;
554: }
555: error_message = ": invalid in register";
556: goto error;
557:
558: case 'l': /* local register */
559: if (isoctal (c = *s++))
560: {
561: mask = (c - '0' + 16);
562: break;
563: }
564: error_message = ": invalid local register";
565: goto error;
566:
567: case 'o': /* out register */
568: if (isoctal (c = *s++))
569: {
570: mask = (c - '0' + 8);
571: break;
572: }
573: error_message = ": invalid out register";
574: goto error;
575:
576: case 's': /* stack pointer */
577: if (*s++ == 'p')
578: {
579: mask = 0xe;
580: break;
581: }
582: error_message = ": register is not sp";
583: goto error;
584:
585: case 'r': /* any register */
586: if (!isdigit (c = *s++))
587: {
588: error_message = ": invalid register";
589: goto error;
590: }
591: /* FALLTHROUGH */
592: case '0':
593: case '1':
594: case '2':
595: case '3':
596: case '4':
597: case '5':
598: case '6':
599: case '7':
600: case '8':
601: case '9':
602: if (isdigit (*s))
603: {
604: if ((c = 10 * (c - '0') + (*s++ - '0')) >= 32)
605: {
606: error_message = ": register # out of range";
607: goto error;
608: }
609: }
610: else
611: {
612: c -= '0';
613: }
614: mask = c;
615: break;
616:
617: default:
618: error_message = ": invalid resgiter #";
619: goto error;
620: }
621: /*
622: * Got the register, now figure out where
623: * it goes in the opcode.
624: */
625: switch (*args)
626: {
627:
628: case '1':
629: opcode |= mask << 14;
630: continue;
631:
632: case '2':
633: opcode |= mask;
634: continue;
635:
636: case 'd':
637: opcode |= mask << 25;
638: continue;
639:
640: case 'r':
641: opcode |= (mask << 25) | (mask << 14);
642: continue;
643:
644: case 'u':
645: opcode |= (mask << 25) | mask;
646: continue;
647: }
648: }
649: break;
650:
651: case 'e': /* next operand is a floating point register */
652: case 'v':
653: case 'V':
654:
655: case 'f':
656: case 'B':
657: case 'R':
658:
659: case 'g':
660: case 'H':
661: case 'J':
662: {
663: char format;
664:
665: if (*s++ == '%'
666: && ((format = *s) == 'f')
667: && isdigit (*++s))
668: {
669: for (mask = 0; isdigit (*s); ++s)
670: {
671: mask = 10 * mask + (*s - '0');
672: } /* read the number */
673:
674: if ((*args == 'v'
675: || *args == 'B'
676: || *args == 'H')
677: && (mask & 1))
678: {
679: break;
680: } /* register must be even numbered */
681:
682: if ((*args == 'V'
683: || *args == 'R'
684: || *args == 'J')
685: && (mask & 3))
686: {
687: break;
688: } /* register must be multiple of 4 */
689:
690: if (mask >= 32)
691: {
692: error_message = ": There are only 32 f registers; [0-31]";
693: goto error;
694: } /* on error */
695: }
696: else
697: {
698: break;
699: } /* if not an 'f' register. */
700:
701: switch (*args)
702: {
703:
704: case 'v':
705: case 'V':
706: case 'e':
707: opcode |= RS1 (mask);
708: continue;
709:
710:
711: case 'f':
712: case 'B':
713: case 'R':
714: opcode |= RS2 (mask);
715: continue;
716:
717: case 'g':
718: case 'H':
719: case 'J':
720: opcode |= RD (mask);
721: continue;
722: } /* pack it in. */
723:
724: know (0);
725: break;
726: } /* float arg */
727:
728: case 'F':
729: if (strncmp (s, "%fsr", 4) == 0)
730: {
731: s += 4;
732: continue;
733: }
734: break;
735:
736: case 'h': /* high 22 bits */
737: the_insn.reloc = SPARC_RELOC_HI22;
738: goto immediate;
739:
740: case 'l': /* 22 bit PC relative immediate */
741: the_insn.reloc = SPARC_RELOC_WDISP22;
742: the_insn.pcrel = 1;
743: goto immediate;
744:
745: case 'L': /* 30 bit immediate for call insn */
746: the_insn.reloc = SPARC_RELOC_WDISP30;
747: the_insn.pcrel = 1;
748: goto immediate;
749:
750: case 'n': /* 22 bit immediate */
751: the_insn.reloc = SPARC_RELOC_22;
752: goto immediate;
753:
754: case 'i': /* 13 bit immediate */
755: /* What's the difference between base13 and 13?
756: 13-bit immediate and 13-bit immediate+register */
757: the_insn.reloc = SPARC_RELOC_13;
758: immediate_max = 0x1FFF;
759:
760: /*FALLTHROUGH */
761:
762: immediate:
763: if (*s == ' ')
764: s++;
765: if (*s == '%')
766: {
767: if ((c = s[1]) == 'h' && s[2] == 'i')
768: {
769: the_insn.reloc = SPARC_RELOC_HI22;
770: s += 3;
771: }
772: else if (c == 'l' && s[2] == 'o')
773: {
774: the_insn.reloc = SPARC_RELOC_LO10;
775: s += 3;
776: }
777: else
778: break;
779: }
780: /* Note that if the getExpression() fails, we will still
781: have created U entries in the symbol table for the
782: 'symbols' in the input string. Try not to create U
783: symbols for registers, etc. */
784: {
785: /* This stuff checks to see if the expression ends in
786: +%reg. If it does, it removes the register from
787: the expression, and re-sets 's' to point to the
788: right place. */
789:
790: char *s1;
791:
792: for (s1 = s; *s1 && *s1 != ',' && *s1 != ']'; s1++);
793:
794: if (s1 != s && isdigit (s1[-1]))
795: {
796: if (s1[-2] == '%' && s1[-3] == '+')
797: {
798: s1 -= 3;
799: *s1 = '\0';
800: (void) getExpression (s);
801: *s1 = '+';
802: s = s1;
803: continue;
804: }
805: else if (strchr ("goli0123456789",
806: s1[-2]) && s1[-3] == '%' && s1[-4] == '+')
807: {
808: s1 -= 4;
809: *s1 = '\0';
810: (void) getExpression (s);
811: *s1 = '+';
812: s = s1;
813: continue;
814: }
815: }
816: }
817: (void) getExpression (s);
818: s = expr_end;
819: /* The Next linker has the ability to scatter blocks of sections between
820: * labels. This requires that branches to labels that survive to the
821: * link phase be relocatable. These labels are those that are not L*
822: */
823: if (the_insn.exp.X_add_symbol != NULL && !flagseen['L']
824: && the_insn.exp.X_add_symbol->sy_nlist.n_un.n_name[0] == 'L') {
825: /* local symbol which will be thrown away. Don't bother
826: * to reloc it.
827: */
828: the_insn.pcrel_reloc = 0;
829: }
830:
831: if ((the_insn.exp.X_seg == SEG_ABSOLUTE ||
832: the_insn.exp.X_seg == SEG_BIG)
833: && the_insn.exp.X_add_symbol == 0)
834: {
835:
836: /* Check for invalid constant values. Don't warn if
837: constant was inside %hi or %lo, since these
838: truncate the constant to fit. */
839: if (immediate_max != 0
840: && the_insn.reloc != SPARC_RELOC_LO10
841: && the_insn.reloc != SPARC_RELOC_HI22
842: && (the_insn.exp.X_add_number > immediate_max
843: || the_insn.exp.X_add_number < ~immediate_max))
844: as_bad ("constant value must be between %ld and %ld",
845: ~immediate_max, immediate_max);
846:
847: if ((the_insn.reloc == SPARC_RELOC_WDISP22 ||
848: the_insn.reloc == SPARC_RELOC_WDISP30) &&
849: the_insn.exp.X_add_number & 3)
850: as_bad ("displacement is not long aligned");
851:
852: /* plug absolutes directly into opcode */
853:
854: switch(the_insn.reloc) {
855: case SPARC_RELOC_13:
856: if (the_insn.exp.X_seg == SEG_BIG)
857: opcode |= (*(int *) generic_bignum) & 0x1fff;
858: else
859: opcode |= the_insn.exp.X_add_number & 0x1fff;
860: the_insn.reloc = SPARC_RELOC_NONE;
861: break;
862: case SPARC_RELOC_22:
863: if (the_insn.exp.X_seg == SEG_BIG)
864: opcode |= (*(int *) generic_bignum) & 0x3fffff;
865: else
866: opcode |= the_insn.exp.X_add_number & 0x3fffff;
867: the_insn.reloc = SPARC_RELOC_NONE;
868: break;
869: case SPARC_RELOC_HI22:
870: /* extract upper 22 bits from constant */
871: opcode |= (the_insn.exp.X_add_number >> 10) & 0x3fffff;
872: the_insn.reloc = SPARC_RELOC_NONE;
873: break;
874: case SPARC_RELOC_LO10:
875: opcode |= the_insn.exp.X_add_number & 0x3ff;
876: break;
877:
878: /* the PC relative displacements are plugged in
879: if the argument is absolute, but retain
880: relocatability */
881: case SPARC_RELOC_WDISP22:
882: opcode |= (the_insn.exp.X_add_number >> 2) & 0x3fffff;
883: break;
884: case SPARC_RELOC_WDISP30:
885: opcode |= (the_insn.exp.X_add_number >> 2) & 0x3fffffff;
886: break;
887: default:
888: printf("Unknown reloc entry\n");
889: }
890: }
891:
892: /* Reset to prevent extraneous range check. */
893: immediate_max = 0;
894:
895: continue;
896:
897: case 'a':
898: if (*s++ == 'a')
899: {
900: opcode |= ANNUL;
901: continue;
902: }
903: break;
904:
905: case 'A':
906: {
907: char *push = input_line_pointer;
908: expressionS e;
909:
910: input_line_pointer = s;
911:
912: expression (&e);
913:
914: if (e.X_seg == SEG_ABSOLUTE)
915: {
916: opcode |= e.X_add_number << 5;
917: s = input_line_pointer;
918: input_line_pointer = push;
919: continue;
920: } /* if absolute */
921:
922: break;
923: } /* alternate space */
924:
925: case 'p':
926: if (strncmp (s, "%psr", 4) == 0)
927: {
928: s += 4;
929: continue;
930: }
931: break;
932:
933: case 'q': /* floating point queue */
934: if (strncmp (s, "%fq", 3) == 0)
935: {
936: s += 3;
937: continue;
938: }
939: break;
940:
941: case 'Q': /* coprocessor queue */
942: if (strncmp (s, "%cq", 3) == 0)
943: {
944: s += 3;
945: continue;
946: }
947: break;
948:
949: case 'S':
950: if (strcmp (str, "set") == 0)
951: {
952: special_case_set = 1;
953: continue;
954: }
955: break;
956:
957:
958: case 't':
959: if (strncmp (s, "%tbr", 4) != 0)
960: break;
961: s += 4;
962: continue;
963:
964: case 'w':
965: if (strncmp (s, "%wim", 4) != 0)
966: break;
967: s += 4;
968: continue;
969:
970: case 'y':
971: if (strncmp (s, "%y", 2) != 0)
972: break;
973: s += 2;
974: continue;
975:
976: default:
977: as_fatal ("failed sanity check.");
978: } /* switch on arg code */
979: break;
980: } /* for each arg that we expect */
981: error:
982: if (match == 0)
983: {
984: /* Args don't match. */
985: if (((unsigned) (&insn[1] - sparc_opcodes)) < NUMOPCODES
986: && !strcmp (insn->name, insn[1].name))
987: {
988: ++insn;
989: s = argsStart;
990: continue;
991: }
992: else
993: {
994: as_bad ("Illegal operands%s", error_message);
995: return;
996: }
997: }
998: else
999: {
1000: if (insn->architecture > current_architecture)
1001: {
1002: if ((!architecture_requested || warn_on_bump)
1003: &&
1004: 1
1005: )
1006: {
1007: if (warn_on_bump)
1008: {
1009: as_warn ("architecture bumped from \"%s\" to \"%s\" on \"%s\"",
1010: architecture_pname[current_architecture],
1011: architecture_pname[insn->architecture],
1012: str);
1013: } /* if warning */
1014:
1015: current_architecture = insn->architecture;
1016: }
1017: else
1018: {
1019: as_bad ("architecture mismatch on \"%s\" (\"%s\"). current architecture is \"%s\"",
1020: str,
1021: architecture_pname[insn->architecture],
1022: architecture_pname[current_architecture]);
1023: return;
1024: } /* if bump ok else error */
1025: } /* if architecture higher */
1026: } /* if no match */
1027:
1028: break;
1029: } /* forever looking for a match */
1030:
1031: the_insn.opcode = opcode;
1032: }
1033:
1034: static int
1035: getExpression (str)
1036: char *str;
1037: {
1038: char *save_in;
1039: segT seg;
1040:
1041: save_in = input_line_pointer;
1042: input_line_pointer = str;
1043: seg = expression (&the_insn.exp);
1044:
1045: if (seg != SEG_ABSOLUTE
1046: && seg != SEG_SECT
1047: && seg != SEG_DIFFSECT
1048: && seg != SEG_UNKNOWN
1049: && seg != SEG_NONE
1050: && seg != SEG_BIG) {
1051: the_insn.error = "bad segment";
1052: expr_end = input_line_pointer;
1053: input_line_pointer = save_in;
1054: return 1;
1055: }
1056: expr_end = input_line_pointer;
1057: input_line_pointer = save_in;
1058: return 0;
1059: } /* getExpression() */
1060:
1061:
1062: /*
1063: This is identical to the md_atof in m68k.c. I think this is right,
1064: but I'm not sure.
1065:
1066: Turn a string in input_line_pointer into a floating point constant of type
1067: type, and store the appropriate bytes in *litP. The number of LITTLENUMS
1068: emitted is stored in *sizeP . An error message is returned, or NULL on OK.
1069: */
1070:
1071: /* Equal to MAX_PRECISION in atof-ieee.c */
1072: #define MAX_LITTLENUMS 6
1073:
1074: char *
1075: md_atof (type, litP, sizeP)
1076: char type;
1077: char *litP;
1078: int *sizeP;
1079: {
1080: int prec;
1081: LITTLENUM_TYPE words[MAX_LITTLENUMS];
1082: LITTLENUM_TYPE *wordP;
1083: char *t;
1084: char *atof_ieee ();
1085:
1086: switch (type)
1087: {
1088: case 'f':
1089: case 'F':
1090: case 's':
1091: case 'S':
1092: prec = 2;
1093: break;
1094:
1095: case 'd':
1096: case 'D':
1097: case 'r':
1098: case 'R':
1099: prec = 4;
1100: break;
1101:
1102: case 'x':
1103: case 'X':
1104: prec = 6;
1105: break;
1106:
1107: case 'p':
1108: case 'P':
1109: prec = 6;
1110: break;
1111:
1112: default:
1113: *sizeP = 0;
1114: return "Bad call to MD_ATOF()";
1115: }
1116: t = atof_ieee (input_line_pointer, type, words);
1117: if (t)
1118: input_line_pointer = t;
1119: *sizeP = prec * sizeof (LITTLENUM_TYPE);
1120: for (wordP = words; prec--;)
1121: {
1122: md_number_to_chars (litP, (valueT) (*wordP++), sizeof (LITTLENUM_TYPE));
1123: litP += sizeof (LITTLENUM_TYPE);
1124: }
1125: return "";
1126: }
1127:
1128: /*
1129: * Write out big-endian.
1130: */
1131: void
1132: md_number_to_chars (buf, val, n)
1133: char *buf;
1134: long val;
1135: int n;
1136: {
1137: // sigh, all architectures do this..,
1138: switch(n) {
1139:
1140: case 4:
1141: *buf++ = val >> 24;
1142: *buf++ = val >> 16;
1143: case 2:
1144: *buf++ = val >> 8;
1145: case 1:
1146: *buf = val;
1147: break;
1148:
1149: default:
1150: abort();
1151: }
1152: }
1153:
1154: /* Apply a fixS to the frags, now that we know the value it ought to
1155: hold. */
1156:
1157:
1158: void
1159: md_number_to_imm(unsigned char *buf, long val, int size, fixS *fixP, int nsect)
1160: {
1161:
1162: /* handle the most common case quickly */
1163: if ((fixP->fx_r_type == NO_RELOC) ||
1164: (fixP->fx_r_type == SPARC_RELOC_NONE) ||
1165: (fixP->fx_r_type == SPARC_RELOC_VANILLA)) {
1166: switch(size){
1167: case 4:
1168: *buf++ = val >> 24;
1169: *buf++ = val >> 16;
1170: case 2:
1171: *buf++ = val >> 8;
1172: case 1:
1173: *buf = val;
1174: break;
1175: default:
1176: abort();
1177: }
1178: return;
1179: }
1180:
1181: switch (fixP->fx_r_type) {
1182: case SPARC_RELOC_WDISP30:
1183: val = (val >> 2) + 1; /* adjust for word displacement */
1184: buf[0] |= (val >> 24) & 0x3f;
1185: buf[1] = (val >> 16);
1186: buf[2] = val >> 8;
1187: buf[3] = val;
1188: break;
1189: case SPARC_RELOC_WDISP22:
1190: val = (val >>= 2) + 1;
1191: buf[1] |= (val >> 16) & 0x3f;
1192: buf[2] = val >> 8;
1193: buf[3] = val;
1194: break;
1195: case SPARC_RELOC_HI22:
1196: buf[1] |= (val >> 26) & 0x3f;
1197: buf[2] = val >> 18;
1198: buf[3] = val >> 10;
1199: break;
1200: case SPARC_RELOC_LO10:
1201: buf[2] |= (val >> 8) & 0x03;
1202: buf[3] = val;
1203: break;
1204:
1205: /* special cases that need to be handled internally by the as */
1206: case SPARC_RELOC_22:
1207: if (!fixP->fx_addsy) {
1208: if (val & ~0x003fffff) {
1209: as_bad ("relocation overflow");
1210: } /* on overflow */
1211: buf[1] |= (val >> 16) & 0x3f;
1212: buf[2] = val >> 8;
1213: buf[3] = val & 0xff;
1214: } else
1215: as_bad ("Undefined symbolic 22-bit immediate reference: %s",
1216: fixP->fx_addsy->sy_name);
1217: break;
1218: case SPARC_RELOC_13:
1219: if (!fixP->fx_addsy) {
1220: if (((val > 0) && (val & ~(offsetT)0x00001fff))
1221: || ((val < 0) && (~(val - 1) & ~(offsetT)0x00001fff))) {
1222: as_bad ("relocation overflow");
1223: }
1224: buf[2] |= (val >> 8) & 0x1f;
1225: buf[3] = val;
1226: } else
1227: as_bad ("Undefined symbolic 13-bit immediate reference: %s",
1228: fixP->fx_addsy->sy_name);
1229: break;
1230: case SPARC_RELOC_NONE:
1231: default:
1232: as_bad ("bad or unhandled relocation type: 0x%02x", fixP->fx_r_type);
1233: break;
1234: }
1235: }
1236:
1237:
1238: /*
1239: * md_parse_option
1240: * Invocation line includes a switch not recognized by the base assembler.
1241: * See if it's a processor-specific option. These are:
1242: *
1243: * -bump
1244: * Warn on architecture bumps. See also -A.
1245: *
1246: * -Av6, -Av7, -Av8, -Asparclite
1247: * Select the architecture. Instructions or features not
1248: * supported by the selected architecture cause fatal errors.
1249: *
1250: * The default is to start at v6, and bump the architecture up
1251: * whenever an instruction is seen at a higher level.
1252: *
1253: * If -bump is specified, a warning is printing when bumping to
1254: * higher levels.
1255: *
1256: * If an architecture is specified, all instructions must match
1257: * that architecture. Any higher level instructions are flagged
1258: * as errors.
1259: *
1260: * if both an architecture and -bump are specified, the
1261: * architecture starts at the specified level, but bumps are
1262: * warnings.
1263: *
1264: */
1265:
1266: int
1267: md_parse_option (argP, cntP, vecP)
1268: char **argP;
1269: int *cntP;
1270: char ***vecP;
1271: {
1272: char *p;
1273: const char **arch;
1274:
1275: if (!strcmp (*argP, "bump"))
1276: {
1277: warn_on_bump = 1;
1278: }
1279: else if (**argP == 'A')
1280: {
1281: p = (*argP) + 1;
1282:
1283: for (arch = architecture_pname; *arch != NULL; ++arch)
1284: {
1285: if (strcmp (p, *arch) == 0)
1286: {
1287: break;
1288: } /* found a match */
1289: } /* walk the pname table */
1290:
1291: if (*arch == NULL)
1292: {
1293: as_bad ("unknown architecture: %s", p);
1294: }
1295: else
1296: {
1297: current_architecture = (enum sparc_architecture) (arch - architecture_pname);
1298: architecture_requested = 1;
1299: }
1300: }
1301: #ifndef NeXT
1302: #ifdef OBJ_ELF
1303: else if (**argP == 'V')
1304: {
1305: print_version_id ();
1306: }
1307: else if (**argP == 'Q')
1308: {
1309: /* Qy - do emit .comment
1310: Qn - do not emit .comment */
1311: }
1312: else if (**argP == 's')
1313: {
1314: /* use .stab instead of .stab.excl */
1315: }
1316: #endif
1317: else if (strcmp (*argP, "sparc") == 0)
1318: {
1319: /* Ignore -sparc, used by SunOS make default .s.o rule. */
1320: }
1321: #endif /* NeXT */
1322: else
1323: {
1324: /* Unknown option */
1325: (*argP)++;
1326: return 0;
1327: }
1328: **argP = '\0'; /* Done parsing this switch */
1329: return 1;
1330: } /* md_parse_option() */
1331:
1332:
1333: int
1334: md_estimate_size_before_relax(
1335: fragS *fragP,
1336: int segment_type)
1337: {
1338: as_fatal("internal error: Relaxation should never occur");
1339: return(0);
1340: }
1341:
1342: void
1343: md_convert_frag(
1344: fragS *fragP)
1345: {
1346: as_fatal("internal error: Relaxation should never occur");
1347: }
1348:
1349:
1350: #ifdef DEBUGINSN
1351:
1352: char *
1353: S_GET_NAME(sym)
1354: symbolS *sym;
1355: {
1356: return (sym->sy_nlist.n_un.n_name);
1357: }
1358:
1359: /* for debugging only */
1360: static void
1361: print_insn (insn)
1362: struct sparc_it *insn;
1363: {
1364: const char *const Reloc[] = {
1365: "VANILLA",
1366: "PAIR",
1367: "HI22",
1368: "LO10",
1369: "DISP22",
1370: "PCREL",
1371: "22",
1372: "13",
1373: "SECTDIFF",
1374: "HI22_SECTDIFF",
1375: "LO10_SECTDIFF",
1376: "NONE",
1377: "UNUSED"
1378:
1379: };
1380:
1381: if (insn->error)
1382: fprintf (stderr, "ERROR: %s\n", insn->error);
1383: fprintf (stderr, "opcode=0x%08x\n", (unsigned int)insn->opcode);
1384: fprintf (stderr, "reloc = %s\n", Reloc[insn->reloc]);
1385: fprintf (stderr, "X_add_number = 0x%x\n",
1386: insn->exp.X_add_number);
1387:
1388: if (insn->exp.X_add_symbol != NULL)
1389: fprintf(stderr, "Add symbol: %s\n", S_GET_NAME(insn->exp.X_add_symbol));
1390: if (insn->exp.X_subtract_symbol != NULL)
1391: fprintf(stderr, "Subtract symbol: %s\n", S_GET_NAME(insn->exp.X_subtract_symbol));
1392: }
1393: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.