![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to m88k.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 m88k.c CVS log | Up to [Apple XNU] / GNUtools / cctools / as |
1.1 root 1: /* m88k.c -- Assemble for the 88100
2: Copyright (C) 1989 Free Software Foundation, Inc.
3:
4: This file is not yet 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 1, 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: #include <ctype.h>
21: #include <string.h>
22: #include <mach-o/m88k/reloc.h>
23: #include "m88k-opcode.h"
24: #include "as.h"
25: #include "flonum.h"
26: #include "expr.h"
27: #include "hash.h"
28: #include "frags.h"
29: #include "fixes.h"
30: #include "read.h"
31: #include "md.h"
32: #include "obstack.h"
33: #include "symbols.h"
34: #include "messages.h"
35: #include "input-scrub.h"
36: #include "sections.h"
37:
38: /*
39: * These are the default cputype and cpusubtype for the m88k architecture.
40: */
41: const cpu_type_t md_cputype = CPU_TYPE_MC88000;
42: cpu_subtype_t md_cpusubtype = CPU_SUBTYPE_MC88000_ALL;
43:
44: /* This is the byte sex for the m88k architecture */
45: const enum byte_sex md_target_byte_sex = BIG_ENDIAN_BYTE_SEX;
46:
47: #ifdef NeXT
48: static long in_delay_slot = 0;
49: #endif
50:
51: static char *cmpslot[] = { "**", "**", "eq", "ne", "gt", "le", "lt", "ge",
52: "hi", "ls", "lo", "hs",
53: #ifdef m88110
54: "be", "nb", "he", "nh",
55: #endif m88110
56: NULL };
57:
58: static struct {
59: char *name;
60: unsigned int num;
61:
62: } cndmsk[] = {
63: "eq0", 0x02,
64: "ne0", 0x0d,
65: "gt0", 0x01,
66: "lt0", 0x0c,
67: "ge0", 0x03,
68: "le0", 0x0e,
69: NULL, 0x00,
70: };
71:
72: struct m88k_insn {
73: unsigned long opcode;
74: expressionS exp;
75: #ifdef NeXT
76: enum reloc_type_m88k reloc;
77: #else
78: enum reloc_type reloc;
79: #endif
80: };
81:
82: static struct hash_control *op_hash = NULL;
83:
84: /* These chars start a comment anywhere in a source file (except inside
85: another comment */
86: const char md_comment_chars[] = ";";
87:
88: /* These chars only start a comment at the beginning of a line. */
89: const char md_line_comment_chars[] = "#";
90:
91: /* Chars that can be used to separate mant from exp in floating point nums */
92: const char md_EXP_CHARS[] = "eE";
93:
94: /* Chars that mean this number is a floating point constant */
95: /* as in 0f123.456 */
96: /* or 0H1.234E-12 (see exp chars above) */
97: const char md_FLT_CHARS[] = "dDfF";
98:
99: static int calcop(
100: struct m88k_opcode *format,
101: char *param,
102: struct m88k_insn *insn);
103: static char * parse_reg(
104: char *param,
105: struct m88k_insn *insn,
106: struct m88k_opcode *format,
107: int parcnt);
108: #ifdef m88110
109: static char *parse_ereg(
110: char *param,
111: struct m88k_insn *insn,
112: struct m88k_opcode *format,
113: int parcnt);
114: static char *parse_e4rot(
115: char *param,
116: struct m88k_insn *insn,
117: struct m88k_opcode *format,
118: int parcnt);
119: static char *parse_xreg(
120: char *param,
121: struct m88k_insn *insn,
122: struct m88k_opcode *format,
123: int parcnt);
124: #endif m88110
125: static char *parse_pcr(
126: char *param,
127: struct m88k_insn *insn,
128: struct m88k_opcode *format,
129: int parcnt);
130: static char *parse_cmp(
131: char *param,
132: struct m88k_insn *insn,
133: struct m88k_opcode *format,
134: int parcnt);
135: static char *parse_cnd(
136: char *param,
137: struct m88k_insn *insn,
138: struct m88k_opcode *format,
139: int parcnt);
140: static char *parse_bf(
141: char *param,
142: struct m88k_insn *insn,
143: struct m88k_opcode *format,
144: int parcnt);
145: static char *parse_rot(
146: char *param,
147: struct m88k_insn *insn,
148: struct m88k_opcode *format,
149: int parcnt);
150: static char *parse_rsc(
151: char *param,
152: struct m88k_insn *insn,
153: struct m88k_opcode *format,
154: int parcnt);
155: static char *parse_cr(
156: char *param,
157: struct m88k_insn *insn,
158: struct m88k_opcode *format,
159: int parcnt);
160: static char *parse_fcr(
161: char *param,
162: struct m88k_insn *insn,
163: struct m88k_opcode *format,
164: int parcnt);
165: static char *parse_cst(
166: char *param,
167: struct m88k_insn *insn,
168: struct m88k_opcode *format,
169: int parcnt);
170: static char *getval(
171: char *param,
172: unsigned int *val);
173: #ifdef NeXT
174: static void s_reg(
175: int reg);
176: static void s_scaled(
177: int value);
178: static void s_m88k_abs(
179: int value);
180: static void s_no_delay(
181: int value);
182: static void s_dot(
183: int value);
184: #endif /* NeXT */
185:
186: const pseudo_typeS md_pseudo_table[] =
187: {
188: #ifdef NeXT
189: {"greg", s_reg, 'r' },
190: {"xreg", s_reg, 'x' },
191: {"scaled", s_scaled, 0},
192: {"abs", s_m88k_abs, 0},
193: {"no_delay", s_no_delay, 0},
194: {"dot", s_dot, 0},
195: #endif
196: #ifndef NeXT
197: /* At NeXT we don't allow these */
198: {"dfloat", float_cons, 'd'},
199: {"ffloat", float_cons, 'f'},
200: {"global", s_globl, 0},
201: {"half", cons, 2 },
202: {"ln", s_line, 0},
203: {"zero", s_space, 0},
204: {"word", cons, 4 },
205: #endif
206: {0}
207: };
208:
209: #ifdef NeXT
210: static
211: void
212: s_dot(
213: int value)
214: {
215: char *name, *end_name, delim;
216: symbolS *symbolP;
217:
218: if( * input_line_pointer == '"')
219: name = input_line_pointer + 1;
220: else
221: name = input_line_pointer;
222: delim = get_symbol_end();
223: end_name = input_line_pointer;
224: *end_name = 0;
225:
226: symbolP = symbol_find_or_make (name);
227: symbolP -> sy_type = N_ABS;
228: symbolP -> sy_other = 0; /* NO_SECT */
229: symbolP -> sy_value = obstack_next_free(&frags) - frag_now->fr_literal;
230: symbolP -> sy_frag = &zero_address_frag;
231:
232: *end_name = delim;
233: totally_ignore_line();
234: }
235: /*
236: * s_reg() is used to implement ".greg symbol,exp" and ".xreg symbol,exp"
237: * which set symbol to 1 or 0 depending on if the expression is a general
238: * register or extended register respectfully. These are intended for use in
239: * macros.
240: */
241: static
242: void
243: s_reg(
244: int reg)
245: {
246: char *name, *end_name, delim;
247: symbolS *symbolP;
248: unsigned long n_value, val;
249:
250: if( * input_line_pointer == '"')
251: name = input_line_pointer + 1;
252: else
253: name = input_line_pointer;
254: delim = get_symbol_end();
255: end_name = input_line_pointer;
256: *end_name = delim;
257: SKIP_WHITESPACE();
258: if ( * input_line_pointer != ',' ) {
259: *end_name = 0;
260: as_warn("Expected comma after name \"%s\"", name);
261: *end_name = delim;
262: ignore_rest_of_line();
263: return;
264: }
265: input_line_pointer ++;
266: *end_name = 0;
267:
268: SKIP_WHITESPACE();
269: n_value = 0;
270: if (*input_line_pointer == reg || *input_line_pointer == toupper(reg)){
271: input_line_pointer++;
272: if(isdigit(*input_line_pointer)){
273: val = 0;
274: while (isdigit(*input_line_pointer)){
275: if ((val = val * 10 + *input_line_pointer++ - '0') > 31)
276: break;
277: }
278: SKIP_WHITESPACE();
279: if(val <= 31 &&
280: (*input_line_pointer == '\n' || *input_line_pointer == '@'))
281: n_value = 1;
282: }
283: }
284:
285: symbolP = symbol_find_or_make (name);
286: symbolP -> sy_type = N_ABS;
287: symbolP -> sy_other = 0; /* NO_SECT */
288: symbolP -> sy_value = n_value;
289: symbolP -> sy_frag = &zero_address_frag;
290:
291: *end_name = delim;
292: totally_ignore_line();
293: }
294:
295: /*
296: * s_scaled() is used to implement ".scaled symbol,exp" which sets symbol to 1
297: * or 0 depending on if the expression is a scaled general register expression
298: * "r1[r2]" or not respectfully. This is intended for use in macros.
299: */
300: static
301: void
302: s_scaled(
303: int value)
304: {
305: char *name, *end_name, delim;
306: symbolS *symbolP;
307: unsigned long n_value, val;
308:
309: if( * input_line_pointer == '"')
310: name = input_line_pointer + 1;
311: else
312: name = input_line_pointer;
313: delim = get_symbol_end();
314: end_name = input_line_pointer;
315: *end_name = delim;
316: SKIP_WHITESPACE();
317: if ( * input_line_pointer != ',' ) {
318: *end_name = 0;
319: as_warn("Expected comma after name \"%s\"", name);
320: *end_name = delim;
321: ignore_rest_of_line();
322: return;
323: }
324: input_line_pointer ++;
325: *end_name = 0;
326:
327: SKIP_WHITESPACE();
328: n_value = 0;
329: if (*input_line_pointer == 'r' || *input_line_pointer == 'R'){
330: input_line_pointer++;
331: if(isdigit(*input_line_pointer)){
332: val = 0;
333: while (isdigit(*input_line_pointer)){
334: if ((val = val * 10 + *input_line_pointer++ - '0') > 31)
335: break;
336: }
337: SKIP_WHITESPACE();
338: if(val <= 31 && *input_line_pointer == '['){
339: input_line_pointer++;
340: if (*input_line_pointer == 'r' ||
341: *input_line_pointer == 'R'){
342: input_line_pointer++;
343: if(isdigit(*input_line_pointer)){
344: val = 0;
345: while (isdigit(*input_line_pointer)){
346: if ((val = val * 10 +
347: *input_line_pointer++ - '0') > 31)
348: break;
349: }
350: if(val <= 31 && *input_line_pointer == ']'){
351: input_line_pointer++;
352: SKIP_WHITESPACE();
353: if(*input_line_pointer == '\n' ||
354: *input_line_pointer == '@')
355: n_value = 1;
356: }
357: }
358: }
359: }
360: }
361: }
362:
363: symbolP = symbol_find_or_make (name);
364: symbolP -> sy_type = N_ABS;
365: symbolP -> sy_other = 0; /* NO_SECT */
366: symbolP -> sy_value = n_value;
367: symbolP -> sy_frag = & zero_address_frag;
368:
369: *end_name = delim;
370: totally_ignore_line();
371: }
372:
373: /*
374: * s_m88k_abs() is used to implement ".abs symbol,exp" which sets symbol to 1
375: * or 0 depending on if the expression is an absolute expression or not
376: * respectfully. This is intended for use in macros.
377: */
378: static
379: void
380: s_m88k_abs(
381: int value)
382: {
383: char *name, *end_name, delim, *start;
384: symbolS *symbolP;
385: unsigned long n_value, val, is_reg_exp;
386:
387: start = input_line_pointer;
388: if( * input_line_pointer == '"')
389: name = input_line_pointer + 1;
390: else
391: name = input_line_pointer;
392: delim = get_symbol_end();
393: end_name = input_line_pointer;
394: *end_name = delim;
395: SKIP_WHITESPACE();
396: if ( * input_line_pointer != ',' ) {
397: *end_name = 0;
398: as_warn("Expected comma after name \"%s\"", name);
399: *end_name = delim;
400: ignore_rest_of_line();
401: return;
402: }
403: input_line_pointer ++;
404: *end_name = 0;
405:
406: SKIP_WHITESPACE();
407: is_reg_exp = 0;
408: n_value = 0;
409: if(*input_line_pointer == 'r' || *input_line_pointer == 'R'){
410: input_line_pointer++;
411: if(isdigit(*input_line_pointer)){
412: val = 0;
413: while (isdigit(*input_line_pointer)){
414: if ((val = val * 10 + *input_line_pointer++ - '0') > 31)
415: break;
416: }
417: SKIP_WHITESPACE();
418: if(val <= 31)
419: is_reg_exp = 1;
420: }
421: }
422: if(is_reg_exp == 0){
423: *end_name = delim;
424: input_line_pointer = start;
425: s_abs(value);
426: return;
427: }
428:
429: symbolP = symbol_find_or_make (name);
430: symbolP -> sy_type = N_ABS;
431: symbolP -> sy_other = 0; /* NO_SECT */
432: symbolP -> sy_value = n_value;
433: symbolP -> sy_frag = & zero_address_frag;
434: *end_name = delim;
435:
436: totally_ignore_line();
437: }
438:
439: /*
440: * s_no_delay() is used to implement ".no_delay string" which will abort and
441: * print the string if the last instruction assembled has a delay slot.
442: * This is intended for use in macros that expand to more than one instruction
443: * that could be put in delay slots. This is not really correct in it's
444: * operation in that it is not per-section and does not take into account
445: * anything other than assembled instructions.
446: */
447: static
448: void
449: s_no_delay(
450: int value)
451: {
452: char *p, c;
453:
454: p = input_line_pointer;
455: while(*p != '\n' && *p != '@' && *p != '\0')
456: p++;
457: c = *p;
458: *p = '\0';
459:
460: if(in_delay_slot)
461: as_fatal("delay slot abort %s detected. Assembly stopping.",
462: input_line_pointer);
463: input_line_pointer = p;
464: *p = c;
465: }
466: #endif /* NeXT */
467:
468: void
469: md_begin(
470: void)
471: {
472: register char *retval = NULL;
473: register unsigned int i = 0;
474:
475: /* initialize hash table */
476:
477: op_hash = hash_new();
478: if (op_hash == NULL)
479: as_fatal("Could not initialize hash table");
480:
481: /* loop until you see the end of the list */
482:
483: while (*m88k_opcodes[i].name) {
484: char *name = m88k_opcodes[i].name;
485:
486: /* hash each mnemonic and record its position */
487:
488: retval = hash_insert(op_hash, name, (char *)&m88k_opcodes[i]);
489:
490: if (retval != NULL && *retval != '\0')
491: as_fatal("Can't hash instruction '%s':%s",
492: m88k_opcodes[i].name, retval);
493:
494: /* skip to next unique mnemonic or end of list */
495:
496: for (i++; !strcmp(m88k_opcodes[i].name, name); i++);
497: }
498: }
499:
500: int
501: md_parse_option(
502: char **argP,
503: int *cntP,
504: char ***vecP)
505: {
506: return (1);
507: }
508:
509: void
510: md_assemble(
511: char *op)
512: {
513: char *param, *thisfrag;
514: struct m88k_opcode *format;
515: struct m88k_insn insn;
516: #ifdef NeXT
517: long pcrel_reloc;
518: #endif
519:
520: assert(op);
521:
522: /* skip over instruction to find parameters */
523:
524: /* *param != '\0' is need for instructions that have no parameters
525: like rte */
526: for (param = op; !isspace(*param) && *param != '\0' ; param++);
527: *param++ = '\0';
528:
529: /* try to find the instruction in the hash table */
530:
531: if ((format = (struct m88k_opcode *) hash_find(op_hash, op)) == NULL) {
532: as_warn("Invalid mnemonic '%s'", op);
533: return;
534: }
535:
536: /* try parsing this instruction into insn */
537:
538: while (!calcop(format,param,&insn))
539:
540: /* if it doesn't parse try the next instruction */
541:
542: if (!strcmp(format->name, format[1].name))
543: format++;
544: else {
545: as_warn("Parameter syntax error");
546: return;
547: }
548:
549: /* grow the current frag and plop in the opcode */
550:
551: thisfrag = frag_more(4);
552: md_number_to_chars(thisfrag, insn.opcode, 4);
553: #ifdef NeXT
554: in_delay_slot = format->delay_slot;
555: #endif
556: #ifdef NeXT /* generate stabs for debugging assembly code */
557: /*
558: * If the -g flag is present generate a line number stab for the
559: * instruction.
560: *
561: * See the detailed comments about stabs in read_a_source_file() for a
562: * description of what is going on here.
563: */
564: if(flagseen['g'] && frchain_now->frch_nsect == text_nsect){
565: (void)symbol_new(
566: "",
567: 68 /* N_SLINE */,
568: text_nsect,
569: logical_input_line /* n_desc, line number */,
570: obstack_next_free(&frags) - frag_now->fr_literal,
571: frag_now);
572: }
573: #endif /* NeXT */
574:
575: #ifdef NeXT
576: pcrel_reloc = 0;
577: if (insn.reloc == M88K_RELOC_PC16 || insn.reloc == M88K_RELOC_PC26){
578: /*
579: * The NeXT linker has the ability to scatter blocks of
580: * sections between labels. This requires that brances to
581: * labels that survive to the link phase must be able to
582: * be relocated.
583: */
584: if(insn.exp.X_add_symbol != NULL &&
585: (insn.exp.X_add_symbol->sy_name[0] != 'L' || flagseen ['L']))
586: pcrel_reloc = 1;
587: else
588: pcrel_reloc = 0;
589: }
590: #endif /* NeXT */
591:
592: /* if this instruction requires labels mark it for later */
593: switch (insn.reloc) {
594:
595: case NO_RELOC:
596: break;
597:
598: case M88K_RELOC_LO16:
599: case M88K_RELOC_HI16:
600: fix_new(
601: frag_now,
602: #ifdef NeXT
603: thisfrag - frag_now->fr_literal,
604: 4,
605: #else
606: thisfrag - frag_now->fr_literal + 2,
607: 2,
608: #endif
609: insn.exp.X_add_symbol,
610: insn.exp.X_subtract_symbol,
611: insn.exp.X_add_number,
612: 0, 0,
613: insn.reloc
614: );
615: break;
616:
617: #ifndef NeXT
618: case M88K_RELOC_IW16:
619: fix_new(
620: frag_now,
621: thisfrag - frag_now->fr_literal,
622: 4,
623: insn.exp.X_add_symbol,
624: insn.exp.X_subtract_symbol,
625: insn.exp.X_add_number,
626: 0, 0,
627: insn.reloc
628: );
629: break;
630: #endif /* !defined(NeXT) */
631:
632: case M88K_RELOC_PC16:
633: fix_new(
634: frag_now,
635: #ifdef NeXT
636: thisfrag - frag_now->fr_literal,
637: 4,
638: #else
639: thisfrag - frag_now->fr_literal + 2,
640: 2,
641: #endif
642: insn.exp.X_add_symbol,
643: insn.exp.X_subtract_symbol,
644: insn.exp.X_add_number,
645: 1, pcrel_reloc,
646: insn.reloc
647: );
648: break;
649:
650: case M88K_RELOC_PC26:
651: fix_new(
652: frag_now,
653: thisfrag - frag_now->fr_literal,
654: 4,
655: insn.exp.X_add_symbol,
656: insn.exp.X_subtract_symbol,
657: insn.exp.X_add_number,
658: 1, pcrel_reloc,
659: insn.reloc
660: );
661: break;
662:
663: default:
664: as_warn("Unknown relocation type");
665: break;
666: }
667: }
668:
669: static
670: int
671: calcop(
672: struct m88k_opcode *format,
673: char *param,
674: struct m88k_insn *insn)
675: {
676: int parcnt;
677:
678: /* initial the passed structure */
679:
680: memset(insn, '\0', sizeof(*insn));
681: insn->reloc = NO_RELOC;
682: insn->opcode = format->opcode;
683:
684: /* parse all parameters */
685:
686: for (parcnt=0; parcnt<3 && format->op[parcnt].type != NIL; parcnt++) {
687:
688: switch (format->op[parcnt].type) {
689:
690: case CNST:
691: param = parse_cst(param, insn, format, parcnt);
692: break;
693:
694: case REG:
695: param = parse_reg(param, insn, format, parcnt);
696: break;
697: #ifdef m88110
698: case EREG:
699: param = parse_ereg(param, insn, format, parcnt);
700: break;
701:
702: case E4ROT:
703: param = parse_e4rot(param, insn, format,parcnt);
704: break;
705:
706: case XREG:
707: param = parse_xreg(param, insn, format, parcnt);
708: break;
709: #endif m88110
710: case BF:
711: param = parse_bf(param, insn, format, parcnt);
712: break;
713:
714: case ROT:
715: param = parse_rot(param, insn, format, parcnt);
716: break;
717:
718: case REGSC:
719: param = parse_rsc(param, insn, format, parcnt);
720: break;
721:
722: case CRREG:
723: param = parse_cr(param, insn, format, parcnt);
724: break;
725:
726: case FCRREG:
727: param = parse_fcr(param, insn, format, parcnt);
728: break;
729:
730: case PCREL:
731: param = parse_pcr(param, insn, format, parcnt);
732: break;
733:
734: case CONDMASK:
735: param = parse_cnd(param, insn, format, parcnt);
736: break;
737:
738: case CMPRSLT:
739: param = parse_cmp(param, insn, format, parcnt);
740: break;
741:
742: default:
743: as_fatal("Unknown parameter type");
744: }
745:
746: /* see if parser failed or not */
747:
748: if (param == NULL)
749: return 0;
750: }
751:
752: return 1;
753: }
754:
755: static
756: char *
757: parse_pcr(
758: char *param,
759: struct m88k_insn *insn,
760: struct m88k_opcode *format,
761: int parcnt)
762: {
763: char *saveptr, *saveparam;
764: segT seg;
765:
766: saveptr = input_line_pointer;
767: input_line_pointer = param;
768:
769: seg = expression(&insn->exp);
770:
771: saveparam = input_line_pointer;
772: input_line_pointer = saveptr;
773:
774: switch (format->op[parcnt].width) {
775:
776: case 16: insn->reloc = M88K_RELOC_PC16;
777: break;
778:
779: case 26: insn->reloc = M88K_RELOC_PC26;
780: break;
781:
782: default: as_warn("Strange PC relative width %d",
783: format->op[parcnt].width);
784: break;
785: }
786:
787: return saveparam;
788: }
789:
790: static
791: char *
792: parse_reg(
793: char *param,
794: struct m88k_insn *insn,
795: struct m88k_opcode *format,
796: int parcnt)
797: {
798: unsigned int val = 0;
799:
800: if (*param != 'r' && *param != 'R')
801: return NULL;
802:
803: param++;
804:
805: if (!isdigit(*param))
806: return NULL;
807:
808: while (isdigit(*param))
809: if ((val = val * 10 + *param++ - '0') > 31)
810: return NULL;
811:
812: insn->opcode |= val << format->op[parcnt].offset;
813:
814: switch (*param) {
815:
816: case '\0' :
817: if (parcnt == 2 || format->op[parcnt+1].type == NIL)
818: return param;
819: else
820: return NULL;
821:
822: case '[' :
823: if (parcnt != 2 && format->op[parcnt+1].type == REGSC)
824: return param+1;
825: else
826: return NULL;
827:
828: case ',' :
829: if (parcnt != 2 && format->op[parcnt+1].type != NIL)
830: return param+1;
831: else
832: return NULL;
833: }
834:
835: return NULL;
836: }
837:
838: #ifdef m88110
839: static
840: char *
841: parse_ereg(
842: char *param,
843: struct m88k_insn *insn,
844: struct m88k_opcode *format,
845: int parcnt)
846: {
847: unsigned int val = 0;
848:
849: if (*param != 'r' && *param != 'R')
850: return NULL;
851:
852: param++;
853:
854: if (!isdigit(*param))
855: return NULL;
856:
857: while (isdigit(*param))
858: if ((val = val * 10 + *param++ - '0') > 31)
859: return NULL;
860:
861: if((val & 0x1) != 0)
862: return NULL;
863:
864: insn->opcode |= val << format->op[parcnt].offset;
865:
866: switch (*param) {
867:
868: case '\0' :
869: if (parcnt == 2 || format->op[parcnt+1].type == NIL)
870: return param;
871: else
872: return NULL;
873:
874: case '[' :
875: if (parcnt != 2 && format->op[parcnt+1].type == REGSC)
876: return param+1;
877: else
878: return NULL;
879:
880: case ',' :
881: if (parcnt != 2 && format->op[parcnt+1].type != NIL)
882: return param+1;
883: else
884: return NULL;
885: }
886:
887: return NULL;
888: }
889:
890: static
891: char *
892: parse_e4rot(
893: char *param,
894: struct m88k_insn *insn,
895: struct m88k_opcode *format,
896: int parcnt)
897: {
898: int val;
899: char *saveptr, save_c, *offset_ptr;
900: expressionS exp;
901: segT seg;
902:
903: /* Now step over the '<' and look for the offset expression before a
904: '>' and the end of line (which is a '\0' when we get here). We
905: know there is a '\0' where the end of line was because that is
906: what parse_a_buffer() in read.c does before calling md_assemble */
907: if (*param++ != '<')
908: return NULL;
909: offset_ptr = param;
910: while(*param != '\0')
911: param++;
912: if(param == offset_ptr || param[-1] != '>')
913: return NULL;
914: param--;
915: save_c = *param;
916: *param = '\0';
917: saveptr = input_line_pointer;
918: input_line_pointer = offset_ptr;
919: seg = expression(&exp);
920: *param = save_c;
921: input_line_pointer = saveptr;
922: val = exp.X_add_number;
923: if(seg != SEG_ABSOLUTE || val > 60 || (val & 0x3) != 0)
924: return NULL;
925:
926: val >>= 2;
927: insn->opcode |= val << format->op[parcnt].offset;
928:
929: return param+1;
930: }
931:
932: static
933: char *
934: parse_xreg(
935: char *param,
936: struct m88k_insn *insn,
937: struct m88k_opcode *format,
938: int parcnt)
939: {
940: unsigned int val = 0;
941:
942: if (*param != 'x' && *param != 'X')
943: return NULL;
944:
945: param++;
946:
947: if (!isdigit(*param))
948: return NULL;
949:
950: while (isdigit(*param))
951: if ((val = val * 10 + *param++ - '0') > 31)
952: return NULL;
953:
954: insn->opcode |= val << format->op[parcnt].offset;
955:
956: switch (*param) {
957:
958: case '\0' :
959: if (parcnt == 2 || format->op[parcnt+1].type == NIL)
960: return param;
961: else
962: return NULL;
963:
964: case '[' :
965: if (parcnt != 2 && format->op[parcnt+1].type == REGSC)
966: return param+1;
967: else
968: return NULL;
969:
970: case ',' :
971: if (parcnt != 2 && format->op[parcnt+1].type != NIL)
972: return param+1;
973: else
974: return NULL;
975: }
976:
977: return NULL;
978: }
979: #endif m88110
980:
981: static
982: char *
983: parse_cmp(
984: char *param,
985: struct m88k_insn *insn,
986: struct m88k_opcode *format,
987: int parcnt)
988: {
989: int val;
990: char *saveptr, save_c, *offset_ptr, c;
991: expressionS exp;
992: segT seg;
993:
994: /* look for the offset expression before a ',' */
995: c = *param;
996: if (isdigit(c) || c == '(' || c == '-' || c == '+' || c == '!' ||
997: c == '~'){
998: offset_ptr = param;
999: while(*param != ',')
1000: param++;
1001: if(param == offset_ptr || *param != ',')
1002: return NULL;
1003: save_c = *param;
1004: *param = '\0';
1005: saveptr = input_line_pointer;
1006: input_line_pointer = offset_ptr;
1007: seg = expression(&exp);
1008: *param = save_c;
1009: input_line_pointer = saveptr;
1010: val = exp.X_add_number;
1011: if(seg != SEG_ABSOLUTE ||
1012: val > (1 << format->op[parcnt].width) || val < 0)
1013: return NULL;
1014: } else {
1015: if (isupper(*param))
1016: *param = tolower(*param);
1017:
1018: if (isupper(*(param+1)))
1019: *(param+1) = tolower(*(param+1));
1020:
1021: for (val=0; cmpslot[val] != NULL; val++)
1022: if (!strncmp(param,cmpslot[val],2))
1023: break;
1024:
1025: if (cmpslot[val] == NULL)
1026: return NULL;
1027:
1028: param += 2;
1029: }
1030:
1031: if (*param++ != ',')
1032: return NULL;
1033:
1034: insn->opcode |= val << format->op[parcnt].offset;
1035:
1036: return param;
1037: }
1038:
1039: static
1040: char *
1041: parse_cnd(
1042: char *param,
1043: struct m88k_insn *insn,
1044: struct m88k_opcode *format,
1045: int parcnt)
1046: {
1047: int val;
1048: char *saveptr, save_c, *offset_ptr, c;
1049: expressionS exp;
1050: segT seg;
1051:
1052: /* look for the offset expression before a ',' */
1053: c = *param;
1054: if (isdigit(c) || c == '(' || c == '-' || c == '+' || c == '!' ||
1055: c == '~'){
1056: offset_ptr = param;
1057: while(*param != ',')
1058: param++;
1059: if(param == offset_ptr || *param != ',')
1060: return NULL;
1061: save_c = *param;
1062: *param = '\0';
1063: saveptr = input_line_pointer;
1064: input_line_pointer = offset_ptr;
1065: seg = expression(&exp);
1066: *param = save_c;
1067: input_line_pointer = saveptr;
1068: val = exp.X_add_number;
1069: if(seg != SEG_ABSOLUTE ||
1070: val > (1 << format->op[parcnt].width) || val < 0)
1071: return NULL;
1072: } else {
1073: if (isupper(*param))
1074: *param = tolower(*param);
1075:
1076: if (isupper(*(param+1)))
1077: *(param+1) = tolower(*(param+1));
1078:
1079: for (val=0; cndmsk[val].name != NULL; val++)
1080: if (!strncmp(param,cndmsk[val].name,3))
1081: break;
1082:
1083: if (cndmsk[val].name == NULL)
1084: return NULL;
1085:
1086: val = cndmsk[val].num;
1087:
1088: param += 3;
1089: }
1090:
1091: if (*param++ != ',')
1092: return NULL;
1093:
1094: insn->opcode |= val << format->op[parcnt].offset;
1095:
1096: return param;
1097: }
1098:
1099: static
1100: char *
1101: parse_bf(
1102: char *param,
1103: struct m88k_insn *insn,
1104: struct m88k_opcode *format,
1105: int parcnt)
1106: {
1107: int val, width;
1108: char *saveptr, save_c, *offset_ptr, c;
1109: expressionS exp;
1110: segT seg;
1111:
1112: /* We know there is a '\0' where the end of line was because that is
1113: what parse_a_buffer() in read.c does before calling md_assemble */
1114:
1115: /* First look for the width expression before a '<' */
1116: saveptr = input_line_pointer;
1117: input_line_pointer = param;
1118: while(*param != '<' && *param != '\0')
1119: param++;
1120: if(*param == '\0'){
1121: input_line_pointer = saveptr;
1122: return NULL;
1123: }
1124: save_c = *param;
1125: *param = '\0';
1126: seg = expression(&exp);
1127: *param = save_c;
1128: input_line_pointer = saveptr;
1129: width = exp.X_add_number;
1130: if(seg != SEG_ABSOLUTE || width > 32 || width < 0)
1131: return NULL;
1132:
1133: /* Now step over the '<' and look for the offset expression before a
1134: '>' and the end of line (which is a '\0' when we get here) */
1135: param++;
1136: c = *param;
1137: if (isdigit(c) || c == '(' || c == '-' || c == '+' || c == '!' ||
1138: c == '~'){
1139: offset_ptr = param;
1140: while(*param != '\0')
1141: param++;
1142: if(param != offset_ptr && param[-1] != '>')
1143: return NULL;
1144: param--;
1145: save_c = *param;
1146: *param = '\0';
1147: saveptr = input_line_pointer;
1148: input_line_pointer = offset_ptr;
1149: seg = expression(&exp);
1150: *param = save_c;
1151: input_line_pointer = saveptr;
1152: val = exp.X_add_number;
1153: if(seg != SEG_ABSOLUTE || val > 32 || val < 0)
1154: return NULL;
1155: }
1156: else {
1157: if (isupper(*param))
1158: *param = tolower(*param);
1159:
1160: if (isupper(*(param+1)))
1161: *(param+1) = tolower(*(param+1));
1162:
1163: for (val=0; cmpslot[val] != NULL; val++)
1164: if (!strncmp(param,cmpslot[val],2))
1165: break;
1166:
1167: if (cmpslot[val] == NULL)
1168: return NULL;
1169:
1170: param += 2;
1171: }
1172: if (*param != '>')
1173: return NULL;
1174: insn->opcode |= width << 5;
1175: insn->opcode |= val;
1176:
1177: return param+1;
1178: }
1179:
1180: static
1181: char *
1182: parse_rot(
1183: char *param,
1184: struct m88k_insn *insn,
1185: struct m88k_opcode *format,
1186: int parcnt)
1187: {
1188: int val;
1189: char *saveptr, save_c, *offset_ptr;
1190: expressionS exp;
1191: segT seg;
1192:
1193: /* Now step over the '<' and look for the offset expression before a
1194: '>' and the end of line (which is a '\0' when we get here). We
1195: know there is a '\0' where the end of line was because that is
1196: what parse_a_buffer() in read.c does before calling md_assemble */
1197: if (*param++ != '<')
1198: return NULL;
1199: offset_ptr = param;
1200: while(*param != '\0')
1201: param++;
1202: if(param != offset_ptr && param[-1] != '>')
1203: return NULL;
1204: param--;
1205: save_c = *param;
1206: *param = '\0';
1207: saveptr = input_line_pointer;
1208: input_line_pointer = offset_ptr;
1209: seg = expression(&exp);
1210: *param = save_c;
1211: input_line_pointer = saveptr;
1212: val = exp.X_add_number;
1213: if(seg != SEG_ABSOLUTE && (val > 32 || val < 0))
1214: return NULL;
1215:
1216: insn->opcode |= val;
1217:
1218: return param+1;
1219: }
1220:
1221: static
1222: char *
1223: parse_rsc(
1224: char *param,
1225: struct m88k_insn *insn,
1226: struct m88k_opcode *format,
1227: int parcnt)
1228: {
1229: unsigned int val = 0;
1230:
1231: if (*param != 'r' && *param != 'R')
1232: return NULL;
1233:
1234: param++;
1235:
1236: if (!isdigit(*param))
1237: return NULL;
1238:
1239: while (isdigit(*param))
1240: if ((val = val * 10 + *param++ - '0') > 31)
1241: return NULL;
1242:
1243: insn->opcode |= val << format->op[parcnt].offset;
1244:
1245: if (*param != ']' || *(param+1) != '\0')
1246: return NULL;
1247:
1248: return param+1;
1249: }
1250:
1251: static
1252: char *
1253: parse_cr(
1254: char *param,
1255: struct m88k_insn *insn,
1256: struct m88k_opcode *format,
1257: int parcnt)
1258: {
1259: unsigned int val = 0;
1260:
1261: if (strncmp(param, "cr", 2))
1262: return NULL;
1263:
1264: param += 2;
1265:
1266: if (!isdigit(*param))
1267: return NULL;
1268:
1269: while (isdigit(*param))
1270: if ((val = val * 10 + *param++ - '0') > 63)
1271: return NULL;
1272:
1273: /*
1274: * the following fix is not as generic as I'd like, but the
1275: * hardware is real picky about this. - [email protected]
1276: * This fix is to make sure the S1 and S2 fields are the same.
1277: */
1278: insn->opcode |= (insn->opcode & 0x001f0000) >> 16;
1279:
1280: insn->opcode |= val << format->op[parcnt].offset;
1281:
1282: if (*param != '\0')
1283: return NULL;
1284:
1285: return param;
1286: }
1287:
1288: static
1289: char *
1290: parse_fcr(
1291: char *param,
1292: struct m88k_insn *insn,
1293: struct m88k_opcode *format,
1294: int parcnt)
1295: {
1296: unsigned int val = 0;
1297:
1298: if (strncmp(param, "fcr", 3))
1299: return NULL;
1300:
1301: param += 3;
1302:
1303: if (!isdigit(*param))
1304: return NULL;
1305:
1306: while (isdigit(*param))
1307: if ((val = val * 10 + *param++ - '0') > 63)
1308: return NULL;
1309:
1310: /*
1311: * This is to make sure the S1 and S2 fields are the same.
1312: */
1313: insn->opcode |= (insn->opcode & 0x001f0000) >> 16;
1314:
1315: insn->opcode |= val << format->op[parcnt].offset;
1316:
1317: if (*param != '\0')
1318: return NULL;
1319:
1320: return param;
1321: }
1322:
1323: static
1324: char *
1325: parse_cst(
1326: char *param,
1327: struct m88k_insn *insn,
1328: struct m88k_opcode *format,
1329: int parcnt)
1330: {
1331: char c, *saveptr, *saveparam;
1332: unsigned int val, nohilo = 0;
1333: segT seg;
1334: expressionS exp;
1335:
1336: c = *param;
1337: if (isdigit(c) || c == '(' || c == '-' || c == '+' || c == '!' ||
1338: c == '~'){
1339: saveptr = input_line_pointer;
1340: input_line_pointer = param;
1341: while(*param != '\0')
1342: param++;
1343: seg = expression(&exp);
1344: input_line_pointer = saveptr;
1345: val = exp.X_add_number;
1346: if(seg != SEG_ABSOLUTE || val > (1 << format->op[parcnt].width))
1347: return NULL;
1348: }
1349: else if (!strncmp(param,"hi16(",5))
1350:
1351: if (isdigit(*(param+5))) {
1352: param = getval(param+5,&val);
1353: val = (val & 0xffff0000) >> 16;
1354: if (*param++ != ')')
1355: return NULL;
1356:
1357: } else
1358: insn->reloc = M88K_RELOC_HI16;
1359: else if (!strncmp(param,"lo16(",5))
1360:
1361: if (isdigit(*(param+5))) {
1362: param = getval(param+5,&val);
1363: val &= 0x0000ffff;
1364: if (*param++ != ')')
1365: return NULL;
1366:
1367: } else
1368: insn->reloc = M88K_RELOC_LO16;
1369:
1370: #ifndef NeXT
1371: else if (!strncmp(param,"iw16(",5))
1372:
1373: if (isdigit(*(param+5))) {
1374: param = getval(param+5,&val);
1375: val &= 0x0000ffff;
1376: if (*param++ != ')')
1377: return NULL;
1378:
1379: } else
1380: insn->reloc = M88K_RELOC_IW16;
1381: #endif /* !defined(NeXT) */
1382:
1383: else if (*param == 'r' && isdigit(*(param+1)))
1384:
1385: return NULL;
1386:
1387: else {
1388: insn->reloc = M88K_RELOC_LO16;
1389: nohilo = 1;
1390: }
1391:
1392: if (insn->reloc != NO_RELOC) {
1393:
1394: saveptr = input_line_pointer;
1395: input_line_pointer = param + (nohilo ? 0 : 5);
1396:
1397: seg = expression(&insn->exp);
1398:
1399: saveparam = input_line_pointer;
1400: input_line_pointer = saveptr;
1401:
1402: if (nohilo) {
1403:
1404: if (*saveparam != '\0')
1405: return NULL;
1406:
1407: return saveparam;
1408: }
1409:
1410: if (*saveparam != ')')
1411: return NULL;
1412:
1413: return saveparam+1;
1414: }
1415:
1416: if ((1 << format->op[parcnt].width) <= val)
1417: return NULL;
1418:
1419: insn->opcode |= val << format->op[parcnt].offset;
1420:
1421: if (*param != '\0')
1422: return NULL;
1423:
1424: return param;
1425: }
1426:
1427: #define isoct(z) (z >= '0' && z <= '7')
1428: #define ishex(z) ((z >= '0' && z <= '9') || (z >= 'a' && z <= 'f') || (z >= 'A' && z <= 'F'))
1429: #define hexval(z) \
1430: (isdigit(z) ? (z) - '0' : \
1431: islower(z) ? (z) - 'a' + 10 : \
1432: (z) - 'A' + 10)
1433:
1434: static
1435: char *
1436: getval(
1437: char *param,
1438: unsigned int *val)
1439: {
1440: *val = 0;
1441:
1442: if (*param == '0' && (*(param+1) == 'x' || *(param+1) == 'X'))
1443:
1444: for (param += 2; ishex(*param); param++)
1445:
1446: if (*val > 0x0fffffff)
1447: return param;
1448: else
1449: *val = *val * 16 + hexval(*param);
1450:
1451: else if (*param == '0')
1452:
1453: for (param++; isoct(*param); param++)
1454:
1455: if (*val > 0x1fffffff)
1456: return param;
1457: else
1458: *val = *val * 8 + *param - '0';
1459:
1460: else
1461:
1462: for (; isdigit(*param); param++)
1463:
1464: *val = *val * 10 + *param - '0';
1465:
1466: return param;
1467: }
1468:
1469: void
1470: md_number_to_chars(
1471: char *buf,
1472: long val,
1473: int nbytes)
1474: {
1475: switch(nbytes) {
1476:
1477: case 4:
1478: *buf++ = val >> 24;
1479: *buf++ = val >> 16;
1480: case 2:
1481: *buf++ = val >> 8;
1482: case 1:
1483: *buf = val;
1484: break;
1485:
1486: default:
1487: abort();
1488: }
1489: }
1490:
1491: void
1492: md_number_to_imm(
1493: unsigned char *buf,
1494: long val,
1495: int nbytes,
1496: fixS *fixP,
1497: int nsect)
1498: {
1499: if(fixP->fx_r_type == NO_RELOC ||
1500: fixP->fx_r_type == M88K_RELOC_VANILLA) {
1501: switch (nbytes) {
1502: case 4:
1503: *buf++ = val >> 24;
1504: *buf++ = val >> 16;
1505: case 2:
1506: *buf++ = val >> 8;
1507: case 1:
1508: *buf = val;
1509: break;
1510:
1511: default:
1512: abort();
1513: }
1514: return;
1515: }
1516:
1517: switch (fixP->fx_r_type) {
1518: #ifdef NeXT
1519: case M88K_RELOC_LO16:
1520: buf[2] = val >> 8;
1521: buf[3] = val;
1522: break;
1523: case M88K_RELOC_HI16:
1524: buf[2] = val >> 24;
1525: buf[3] = val >> 16;
1526: break;
1527:
1528: case M88K_RELOC_PC16:
1529: val += 4;
1530: buf[2] = val >> 10;
1531: buf[3] = val >> 2;
1532: break;
1533:
1534: case M88K_RELOC_PC26:
1535: val += 4;
1536: buf[0] |= (val >> 26) & 0x03;
1537: buf[1] = val >> 18;
1538: buf[2] = val >> 10;
1539: buf[3] = val >> 2;
1540: break;
1541: #else /* !defined NeXT */
1542: case M88K_RELOC_LO16:
1543: buf[0] = val >> 8;
1544: buf[1] = val;
1545: break;
1546:
1547: case M88K_RELOC_IW16:
1548: buf[2] = val >> 8;
1549: buf[3] = val;
1550: break;
1551:
1552: case M88K_RELOC_HI16:
1553: buf[0] = val >> 24;
1554: buf[1] = val >> 16;
1555: break;
1556:
1557: case M88K_RELOC_PC16:
1558: val += 4;
1559: buf[0] = val >> 10;
1560: buf[1] = val >> 2;
1561: break;
1562:
1563: case M88K_RELOC_PC26:
1564: val += 4;
1565: buf[0] |= (val >> 26) & 0x03;
1566: buf[1] = val >> 18;
1567: buf[2] = val >> 10;
1568: buf[3] = val >> 2;
1569: break;
1570:
1571: case M88K_RELOC_32:
1572: buf[0] = val >> 24;
1573: buf[1] = val >> 16;
1574: buf[2] = val >> 8;
1575: buf[3] = val;
1576: break;
1577: #endif /* !defined(NeXT) */
1578:
1579: default:
1580: as_warn("Bad relocation type");
1581: break;
1582: }
1583: }
1584:
1585: #define MAX_LITTLENUMS 6
1586:
1587: /* Turn a string in input_line_pointer into a floating point constant of type
1588: type, and store the appropriate bytes in *litP. The number of LITTLENUMS
1589: emitted is stored in *sizeP . An error message is returned, or NULL on OK.
1590: */
1591: char *
1592: md_atof(
1593: int type,
1594: char *litP,
1595: int *sizeP)
1596: {
1597: int prec;
1598: LITTLENUM_TYPE words[MAX_LITTLENUMS];
1599: LITTLENUM_TYPE *wordP;
1600: char *t;
1601: char *atof_ieee();
1602:
1603: switch(type) {
1604: case 'f':
1605: case 'F':
1606: case 's':
1607: case 'S':
1608: prec = 2;
1609: break;
1610:
1611: case 'd':
1612: case 'D':
1613: case 'r':
1614: case 'R':
1615: prec = 4;
1616: break;
1617:
1618: case 'x':
1619: case 'X':
1620: prec = 6;
1621: break;
1622:
1623: case 'p':
1624: case 'P':
1625: prec = 6;
1626: break;
1627:
1628: default:
1629: *sizeP=0;
1630: return "Bad call to MD_ATOF()";
1631: }
1632: t=atof_ieee(input_line_pointer,type,words);
1633: if(t)
1634: input_line_pointer=t;
1635:
1636: *sizeP=prec * sizeof(LITTLENUM_TYPE);
1637: for(wordP=words;prec--;) {
1638: md_number_to_chars(litP,(long)(*wordP++),sizeof(LITTLENUM_TYPE));
1639: litP+=sizeof(LITTLENUM_TYPE);
1640: }
1641: return ""; /* Someone should teach Dean about null pointers */
1642: }
1643:
1644: const relax_typeS md_relax_table[] = {0};
1645:
1646: int
1647: md_estimate_size_before_relax(
1648: fragS *fragP,
1649: int segment_type)
1650: {
1651: as_fatal("internal error: Relaxation should never occur");
1652: return(0);
1653: }
1654:
1655: void
1656: md_convert_frag(
1657: fragS *fragP)
1658: {
1659: as_fatal("internal error: Relaxation should never occur");
1660: }
1661:
1662: void
1663: md_end(
1664: void)
1665: {
1666: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.