1 /* tc-a29k.c -- Assemble for the AMD 29000.
2 Copyright 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1998, 2000, 2001
3 Free Software Foundation, Inc.
5 This file is part of GAS, the GNU Assembler.
7 GAS is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GAS is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GAS; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
22 /* John Gilmore has reorganized this module somewhat, to make it easier
23 to convert it to new machines' assemblers as desired. There was too
24 much bloody rewriting required before. There still probably is. */
27 #include "safe-ctype.h"
29 #include "opcode/a29k.h"
31 /* Make it easier to clone this machine desc into another one. */
32 #define machine_opcode a29k_opcode
33 #define machine_opcodes a29k_opcodes
34 #define machine_ip a29k_ip
35 #define machine_it a29k_it
37 #define IMMEDIATE_BIT 0x01000000 /* Turns RB into Immediate */
38 #define ABSOLUTE_BIT 0x01000000 /* Turns PC-relative to Absolute */
39 #define CE_BIT 0x00800000 /* Coprocessor enable in LOAD */
40 #define UI_BIT 0x00000080 /* Unsigned integer in CONVERT */
42 /* handle of the OPCODE hash table */
43 static struct hash_control *op_hash = NULL;
52 int reloc_offset; /* Offset of reloc within insn */
58 static void machine_ip PARAMS ((char *str));
59 /* static void print_insn PARAMS ((struct machine_it *insn)); */
61 static void s_data1 PARAMS ((void));
62 static void s_use PARAMS ((int));
68 {"align", s_align_bytes, 4},
69 {"block", s_space, 0},
70 {"cputype", s_ignore, 0}, /* CPU as 29000 or 29050 */
71 {"reg", s_lsym, 0}, /* Register equate, same as equ */
72 {"space", s_ignore, 0}, /* Listing control */
73 {"sect", s_ignore, 0}, /* Creation of coff sections */
75 /* We can do this right with coff. */
82 #if defined(BFD_HEADERS)
84 const int md_reloc_size = RELSZ; /* Coff headers */
86 const int md_reloc_size = 12; /* something else headers */
89 const int md_reloc_size = 12; /* Not bfdized*/
92 /* This array holds the chars that always start a comment. If the
93 pre-processor is disabled, these aren't very useful */
94 const char comment_chars[] = ";";
96 /* This array holds the chars that only start a comment at the beginning of
97 a line. If the line seems to have the form '# 123 filename'
98 .line and .file directives will appear in the pre-processed output */
99 /* Note that input_file.c hand checks for '#' at the beginning of the
100 first line of the input file. This is because the compiler outputs
101 #NO_APP at the beginning of its output. */
102 /* Also note that comments like this one will always work */
103 const char line_comment_chars[] = "#";
105 /* We needed an unused char for line separation to work around the
106 lack of macros, using sed and such. */
107 const char line_separator_chars[] = "@";
109 /* Chars that can be used to separate mant from exp in floating point nums */
110 const char EXP_CHARS[] = "eE";
112 /* Chars that mean this number is a floating point constant */
115 const char FLT_CHARS[] = "rRsSfFdDxXpP";
117 /* Also be aware that MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT may have to be
118 changed in read.c. Ideally it shouldn't have to know about it at
119 all, but nothing is ideal around here. */
122 * anull bit - causes the branch delay slot instructions to not be executed
124 #define ANNUL (1 << 29)
132 if (strncmp (input_line_pointer, ".text", 5) == 0)
134 input_line_pointer += 5;
138 if (strncmp (input_line_pointer, ".data", 5) == 0)
140 input_line_pointer += 5;
144 if (strncmp (input_line_pointer, ".data1", 6) == 0)
146 input_line_pointer += 6;
150 /* Literals can't go in the text segment because you can't read from
151 instruction memory on some 29k's. So, into initialized data. */
152 if (strncmp (input_line_pointer, ".lit", 4) == 0)
154 input_line_pointer += 4;
155 subseg_set (SEG_DATA, 200);
156 demand_empty_rest_of_line ();
160 as_bad (_("Unknown segment type"));
161 demand_empty_rest_of_line ();
167 subseg_set (SEG_DATA, 1);
168 demand_empty_rest_of_line ();
171 #endif /* OBJ_COFF */
173 /* Install symbol definition that maps REGNAME to REGNO.
174 FIXME-SOON: These are not recognized in mixed case. */
177 insert_sreg (regname, regnum)
181 /* FIXME-SOON, put something in these syms so they won't be output
182 to the symbol table of the resulting object file. */
184 /* Must be large enough to hold the names of the special registers. */
188 symbol_table_insert (symbol_new (regname, SEG_REGISTER, (valueT) regnum,
189 &zero_address_frag));
190 for (i = 0; regname[i]; i++)
191 buf[i] = TOUPPER (regname[i]);
194 symbol_table_insert (symbol_new (buf, SEG_REGISTER, (valueT) regnum,
195 &zero_address_frag));
198 /* Install symbol definitions for assorted special registers.
199 See ASM29K Ref page 2-9. */
206 /* Protected special-purpose register names */
207 insert_sreg ("vab", SREG + 0);
208 insert_sreg ("ops", SREG + 1);
209 insert_sreg ("cps", SREG + 2);
210 insert_sreg ("cfg", SREG + 3);
211 insert_sreg ("cha", SREG + 4);
212 insert_sreg ("chd", SREG + 5);
213 insert_sreg ("chc", SREG + 6);
214 insert_sreg ("rbp", SREG + 7);
215 insert_sreg ("tmc", SREG + 8);
216 insert_sreg ("tmr", SREG + 9);
217 insert_sreg ("pc0", SREG + 10);
218 insert_sreg ("pc1", SREG + 11);
219 insert_sreg ("pc2", SREG + 12);
220 insert_sreg ("mmu", SREG + 13);
221 insert_sreg ("lru", SREG + 14);
223 /* Additional protected special-purpose registers for the 29050 */
224 insert_sreg ("rsn", SREG + 15);
225 insert_sreg ("rma0", SREG + 16);
226 insert_sreg ("rmc0", SREG + 17);
227 insert_sreg ("rma1", SREG + 18);
228 insert_sreg ("rmc1", SREG + 19);
229 insert_sreg ("spc0", SREG + 20);
230 insert_sreg ("spc1", SREG + 21);
231 insert_sreg ("spc2", SREG + 22);
232 insert_sreg ("iba0", SREG + 23);
233 insert_sreg ("ibc0", SREG + 24);
234 insert_sreg ("iba1", SREG + 25);
235 insert_sreg ("ibc1", SREG + 26);
237 /* Additional registers for the 29040. */
238 insert_sreg ("dba", SREG + 27);
239 insert_sreg ("dbc", SREG + 28);
240 insert_sreg ("cir", SREG + 29);
241 insert_sreg ("cdr", SREG + 30);
243 /* Unprotected special-purpose register names */
244 insert_sreg ("ipc", SREG + 128);
245 insert_sreg ("ipa", SREG + 129);
246 insert_sreg ("ipb", SREG + 130);
247 insert_sreg ("q", SREG + 131);
248 insert_sreg ("alu", SREG + 132);
249 insert_sreg ("bp", SREG + 133);
250 insert_sreg ("fc", SREG + 134);
251 insert_sreg ("cr", SREG + 135);
252 insert_sreg ("fpe", SREG + 160);
253 insert_sreg ("inte", SREG + 161);
254 insert_sreg ("fps", SREG + 162);
255 /* "", SREG+163); Reserved */
256 insert_sreg ("exop", SREG + 164);
259 /* This function is called once, at assembler startup time. It should
260 set up all the tables, etc., that the MD part of the assembler will
265 register const char *retval = NULL;
267 register int skipnext = 0;
268 register unsigned int i;
269 register char *strend, *strend2;
271 /* Hash up all the opcodes for fast use later. */
273 op_hash = hash_new ();
275 for (i = 0; i < num_opcodes; i++)
277 const char *name = machine_opcodes[i].name;
285 /* Hack to avoid multiple opcode entries. We pre-locate all the
286 variations (b/i field and P/A field) and handle them. */
288 if (!strcmp (name, machine_opcodes[i + 1].name))
290 if ((machine_opcodes[i].opcode & 0x01000000) != 0
291 || (machine_opcodes[i + 1].opcode & 0x01000000) == 0
292 || ((machine_opcodes[i].opcode | 0x01000000)
293 != machine_opcodes[i + 1].opcode))
295 strend = machine_opcodes[i].args + strlen (machine_opcodes[i].args) - 1;
296 strend2 = machine_opcodes[i + 1].args + strlen (machine_opcodes[i + 1].args) - 1;
309 fprintf (stderr, "internal error: can't handle opcode %s\n",
314 /* OK, this is an i/b or A/P pair. We skip the
315 higher-valued one, and let the code for operand checking
316 handle OR-ing in the bit. */
320 retval = hash_insert (op_hash, name, (PTR) &machine_opcodes[i]);
323 fprintf (stderr, "internal error: can't hash `%s': %s\n",
324 machine_opcodes[i].name, retval);
330 as_fatal (_("Broken assembler. No assembly attempted."));
335 /* Assemble a single instruction. Its label has already been handled
336 by the generic front end. We just parse opcode and operands, and
337 produce the bytes of data and relocation. */
348 /* put out the opcode */
349 md_number_to_chars (toP, the_insn.opcode, 4);
351 /* put out the symbol-dependent stuff */
352 if (the_insn.reloc != NO_RELOC)
354 fix_new_exp (frag_now,
355 (toP - frag_now->fr_literal + the_insn.reloc_offset),
364 parse_operand (s, operandp, opt)
366 expressionS *operandp;
369 char *save = input_line_pointer;
372 input_line_pointer = s;
373 expression (operandp);
374 if (operandp->X_op == O_absent && ! opt)
375 as_bad (_("missing operand"));
376 new = input_line_pointer;
377 input_line_pointer = save;
381 /* Instruction parsing. Takes a string containing the opcode.
382 Operands are at input_line_pointer. Output is in the_insn.
383 Warnings or errors are generated. */
391 struct machine_opcode *insn;
393 unsigned long opcode;
394 expressionS the_operand;
395 expressionS *operand = &the_operand;
398 /* Must handle `div0' opcode. */
401 for (; ISALNUM (*s); ++s)
409 case ' ': /* FIXME-SOMEDAY more whitespace */
414 as_bad (_("Unknown opcode: `%s'"), str);
417 if ((insn = (struct machine_opcode *) hash_find (op_hash, str)) == NULL)
419 as_bad (_("Unknown opcode `%s'."), str);
423 opcode = insn->opcode;
424 memset (&the_insn, '\0', sizeof (the_insn));
425 the_insn.reloc = NO_RELOC;
427 /* Build the opcode, checking as we go to make sure that the
430 If an operand matches, we modify the_insn or opcode appropriately,
431 and do a "continue". If an operand fails to match, we "break". */
433 if (insn->args[0] != '\0')
435 /* Prime the pump. */
436 s = parse_operand (s, operand, insn->args[0] == 'I');
439 for (args = insn->args;; ++args)
444 case '\0': /* end of args */
447 /* We are truly done. */
448 the_insn.opcode = opcode;
451 as_bad (_("Too many operands: %s"), s);
454 case ',': /* Must match a comma */
457 /* Parse next operand. */
458 s = parse_operand (s, operand, args[1] == 'I');
463 case 'v': /* Trap numbers (immediate field) */
464 if (operand->X_op == O_constant)
466 if (operand->X_add_number < 256)
468 opcode |= (operand->X_add_number << 16);
473 as_bad (_("Immediate value of %ld is too large"),
474 (long) operand->X_add_number);
478 the_insn.reloc = RELOC_8;
479 the_insn.reloc_offset = 1; /* BIG-ENDIAN Byte 1 of insn */
480 the_insn.exp = *operand;
483 case 'b': /* A general register or 8-bit immediate */
485 /* We treat the two cases identically since we mashed
486 them together in the opcode table. */
487 if (operand->X_op == O_register)
490 /* Make sure the 'i' case really exists. */
491 if ((insn->opcode | IMMEDIATE_BIT) != (insn + 1)->opcode)
494 opcode |= IMMEDIATE_BIT;
495 if (operand->X_op == O_constant)
497 if (operand->X_add_number < 256)
499 opcode |= operand->X_add_number;
504 as_bad (_("Immediate value of %ld is too large"),
505 (long) operand->X_add_number);
509 the_insn.reloc = RELOC_8;
510 the_insn.reloc_offset = 3; /* BIG-ENDIAN Byte 3 of insn */
511 the_insn.exp = *operand;
514 case 'a': /* next operand must be a register */
517 /* lrNNN or grNNN or %%expr or a user-def register name */
518 if (operand->X_op != O_register)
519 break; /* Only registers */
520 know (operand->X_add_symbol == 0);
521 know (operand->X_op_symbol == 0);
522 reg = operand->X_add_number;
524 break; /* No special registers */
526 /* Got the register, now figure out where it goes in the
543 as_fatal (_("failed sanity check."));
546 case 'x': /* 16 bit constant, zero-extended */
547 case 'X': /* 16 bit constant, one-extended */
548 if (operand->X_op == O_constant)
550 opcode |= (operand->X_add_number & 0xFF) << 0 |
551 ((operand->X_add_number & 0xFF00) << 8);
554 the_insn.reloc = RELOC_CONST;
555 the_insn.exp = *operand;
559 if (operand->X_op == O_constant)
561 opcode |= (operand->X_add_number & 0x00FF0000) >> 16 |
562 (((unsigned long) operand->X_add_number
563 /* avoid sign ext */ & 0xFF000000) >> 8);
566 the_insn.reloc = RELOC_CONSTH;
567 the_insn.exp = *operand;
570 case 'P': /* PC-relative jump address */
571 case 'A': /* Absolute jump address */
572 /* These two are treated together since we folded the
573 opcode table entries together. */
574 if (operand->X_op == O_constant)
576 /* Make sure the 'A' case really exists. */
577 if ((insn->opcode | ABSOLUTE_BIT) != (insn + 1)->opcode)
582 v = operand->X_add_number & ~ mask;
584 as_bad ("call/jmp target out of range");
586 opcode |= ABSOLUTE_BIT |
587 (operand->X_add_number & 0x0003FC00) << 6 |
588 ((operand->X_add_number & 0x000003FC) >> 2);
591 the_insn.reloc = RELOC_JUMPTARG;
592 the_insn.exp = *operand;
593 the_insn.pcrel = 1; /* Assume PC-relative jump */
594 /* FIXME-SOON, Do we figure out whether abs later, after
598 case 'e': /* Coprocessor enable bit for LOAD/STORE insn */
599 if (operand->X_op == O_constant)
601 if (operand->X_add_number == 0)
603 if (operand->X_add_number == 1)
611 case 'n': /* Control bits for LOAD/STORE instructions */
612 if (operand->X_op == O_constant &&
613 operand->X_add_number < 128)
615 opcode |= (operand->X_add_number << 16);
620 case 's': /* Special register number */
621 if (operand->X_op != O_register)
622 break; /* Only registers */
623 if (operand->X_add_number < SREG)
624 break; /* Not a special register */
625 opcode |= (operand->X_add_number & 0xFF) << 8;
628 case 'u': /* UI bit of CONVERT */
629 if (operand->X_op == O_constant)
631 if (operand->X_add_number == 0)
633 if (operand->X_add_number == 1)
641 case 'r': /* RND bits of CONVERT */
642 if (operand->X_op == O_constant &&
643 operand->X_add_number < 8)
645 opcode |= operand->X_add_number << 4;
650 case 'I': /* ID bits of INV and IRETINV. */
651 /* This operand is optional. */
652 if (operand->X_op == O_absent)
654 else if (operand->X_op == O_constant
655 && operand->X_add_number < 4)
657 opcode |= operand->X_add_number << 16;
662 case 'd': /* FD bits of CONVERT */
663 if (operand->X_op == O_constant &&
664 operand->X_add_number < 4)
666 opcode |= operand->X_add_number << 2;
671 case 'f': /* FS bits of CONVERT */
672 if (operand->X_op == O_constant &&
673 operand->X_add_number < 4)
675 opcode |= operand->X_add_number << 0;
681 if (operand->X_op == O_constant &&
682 operand->X_add_number < 4)
684 opcode |= operand->X_add_number << 16;
690 if (operand->X_op == O_constant &&
691 operand->X_add_number < 16)
693 opcode |= operand->X_add_number << 18;
701 /* Types or values of args don't match. */
702 as_bad ("Invalid operands");
707 /* This is identical to the md_atof in m68k.c. I think this is right,
710 Turn a string in input_line_pointer into a floating point constant
711 of type TYPE, and store the appropriate bytes in *LITP. The number
712 of LITTLENUMS emitted is stored in *SIZEP. An error message is
713 returned, or NULL on OK. */
715 /* Equal to MAX_PRECISION in atof-ieee.c */
716 #define MAX_LITTLENUMS 6
719 md_atof (type, litP, sizeP)
725 LITTLENUM_TYPE words[MAX_LITTLENUMS];
726 LITTLENUM_TYPE *wordP;
758 return "Bad call to MD_ATOF()";
760 t = atof_ieee (input_line_pointer, type, words);
762 input_line_pointer = t;
763 *sizeP = prec * sizeof (LITTLENUM_TYPE);
764 for (wordP = words; prec--;)
766 md_number_to_chars (litP, (valueT) (*wordP++), sizeof (LITTLENUM_TYPE));
767 litP += sizeof (LITTLENUM_TYPE);
773 * Write out big-endian.
776 md_number_to_chars (buf, val, n)
781 number_to_chars_bigendian (buf, val, n);
785 md_apply_fix (fixP, val)
789 char *buf = fixP->fx_where + fixP->fx_frag->fr_literal;
791 fixP->fx_addnumber = val; /* Remember value for emit_reloc */
793 know (fixP->fx_size == 4);
794 know (fixP->fx_r_type < NO_RELOC);
796 /* This is a hack. There should be a better way to handle this. */
797 if (fixP->fx_r_type == RELOC_WDISP30 && fixP->fx_addsy)
799 val += fixP->fx_where + fixP->fx_frag->fr_address;
802 switch (fixP->fx_r_type)
817 val = (val >>= 2) + 1;
818 buf[0] |= (val >> 24) & 0x3f;
819 buf[1] = (val >> 16);
825 buf[1] |= (val >> 26) & 0x3f;
831 buf[2] |= (val >> 8) & 0x03;
836 buf[2] |= (val >> 8) & 0x1f;
841 val = (val >>= 2) + 1;
844 buf[1] |= (val >> 16) & 0x3f;
849 case RELOC_JUMPTARG: /* 00XX00XX pattern in a word */
852 /* The linker tries to support both AMD and old GNU style
853 R_IREL relocs. That means that if the addend is exactly
854 the negative of the address within the section, the
855 linker will not handle it correctly. */
858 && val == - (fixP->fx_frag->fr_address + fixP->fx_where))
860 (fixP->fx_file, fixP->fx_line,
861 "the linker will not handle this relocation correctly");
863 else if (fixP->fx_pcrel)
866 if (v != 0 && v != -1)
867 as_bad_where (fixP->fx_file, fixP->fx_line,
868 "call/jmp target out of range");
871 /* this case was supposed to be handled in machine_ip */
873 buf[1] = val >> 10; /* Holds bits 0003FFFC of address */
877 case RELOC_CONST: /* 00XX00XX pattern in a word */
878 buf[1] = val >> 8; /* Holds bits 0000XXXX */
882 case RELOC_CONSTH: /* 00XX00XX pattern in a word */
883 buf[1] = val >> 24; /* Holds bits XXXX0000 */
889 as_bad (_("bad relocation type: 0x%02x"), fixP->fx_r_type);
896 tc_coff_fix2rtype (fixP)
900 switch (fixP->fx_r_type)
913 printf (_("need %o3\n"), fixP->fx_r_type);
915 } /* switch on type */
920 #endif /* OBJ_COFF */
922 /* should never be called for 29k */
924 md_convert_frag (headers, seg, fragP)
925 object_headers *headers;
927 register fragS *fragP;
929 as_fatal (_("a29k_convert_frag\n"));
932 /* should never be called for a29k */
934 md_estimate_size_before_relax (fragP, segtype)
935 register fragS *fragP;
938 as_fatal (_("a29k_estimate_size_before_relax\n"));
943 /* for debugging only */
946 struct machine_it *insn;
979 fprintf (stderr, "ERROR: %s\n");
981 fprintf (stderr, "opcode=0x%08x\n", insn->opcode);
982 fprintf (stderr, "reloc = %s\n", Reloc[insn->reloc]);
983 fprintf (stderr, "exp = {\n");
984 fprintf (stderr, "\t\tX_add_symbol = %s\n",
985 insn->exp.X_add_symbol ?
986 (S_GET_NAME (insn->exp.X_add_symbol) ?
987 S_GET_NAME (insn->exp.X_add_symbol) : "???") : "0");
988 fprintf (stderr, "\t\tX_op_symbol = %s\n",
989 insn->exp.X_op_symbol ?
990 (S_GET_NAME (insn->exp.X_op_symbol) ?
991 S_GET_NAME (insn->exp.X_op_symbol) : "???") : "0");
992 fprintf (stderr, "\t\tX_add_number = %d\n",
993 insn->exp.X_add_number);
994 fprintf (stderr, "}\n");
999 /* Translate internal representation of relocation info to target format.
1001 On sparc/29k: first 4 bytes are normal unsigned long address, next three
1002 bytes are index, most sig. byte first. Byte 7 is broken up with
1003 bit 7 as external, bits 6 & 5 unused, and the lower
1004 five bits as relocation type. Next 4 bytes are long addend. */
1005 /* Thanx and a tip of the hat to Michael Bloom, mb@ttidca.tti.com */
1010 tc_aout_fix_to_chars (where, fixP, segment_address_in_file)
1013 relax_addressT segment_address_in_file;
1017 know (fixP->fx_r_type < NO_RELOC);
1018 know (fixP->fx_addsy != NULL);
1020 md_number_to_chars (where,
1021 fixP->fx_frag->fr_address + fixP->fx_where - segment_address_in_file,
1024 r_symbolnum = (S_IS_DEFINED (fixP->fx_addsy)
1025 ? S_GET_TYPE (fixP->fx_addsy)
1026 : fixP->fx_addsy->sy_number);
1028 where[4] = (r_symbolnum >> 16) & 0x0ff;
1029 where[5] = (r_symbolnum >> 8) & 0x0ff;
1030 where[6] = r_symbolnum & 0x0ff;
1031 where[7] = (((!S_IS_DEFINED (fixP->fx_addsy)) << 7) & 0x80) | (0 & 0x60) | (fixP->fx_r_type & 0x1F);
1033 md_number_to_chars (&where[8], fixP->fx_addnumber, 4);
1036 #endif /* OBJ_AOUT */
1038 CONST char *md_shortopts = "";
1039 struct option md_longopts[] = {
1040 {NULL, no_argument, NULL, 0}
1042 size_t md_longopts_size = sizeof (md_longopts);
1045 md_parse_option (c, arg)
1053 md_show_usage (stream)
1058 /* This is called when a line is unrecognized. This is used to handle
1059 definitions of a29k style local labels. */
1062 a29k_unrecognized_line (c)
1069 || ! ISDIGIT (input_line_pointer[0]))
1072 s = input_line_pointer;
1075 while (ISDIGIT (*s))
1077 lab = lab * 10 + *s - '0';
1083 /* Not a label definition. */
1087 if (dollar_label_defined (lab))
1089 as_bad (_("label \"$%d\" redefined"), lab);
1093 define_dollar_label (lab);
1094 colon (dollar_label_name (lab, 0));
1095 input_line_pointer = s + 1;
1100 /* Default the values of symbols known that should be "predefined". We
1101 don't bother to predefine them unless you actually use one, since there
1102 are a lot of them. */
1105 md_undefined_symbol (name)
1109 char testbuf[5 + /*SLOP*/ 5];
1111 if (name[0] == 'g' || name[0] == 'G'
1112 || name[0] == 'l' || name[0] == 'L'
1113 || name[0] == 's' || name[0] == 'S')
1115 /* Perhaps a global or local register name */
1116 if (name[1] == 'r' || name[1] == 'R')
1120 /* Parse the number, make sure it has no extra zeroes or
1122 regnum = atol (&name[2]);
1124 if (name[0] == 's' || name[0] == 'S')
1128 if (regnum > maxreg)
1131 sprintf (testbuf, "%ld", regnum);
1132 if (strcmp (testbuf, &name[2]) != 0)
1133 return NULL; /* gr007 or lr7foo or whatever */
1135 /* We have a wiener! Define and return a new symbol for it. */
1136 if (name[0] == 'l' || name[0] == 'L')
1138 else if (name[0] == 's' || name[0] == 'S')
1140 return (symbol_new (name, SEG_REGISTER, (valueT) regnum,
1141 &zero_address_frag));
1148 /* Parse an operand that is machine-specific. */
1151 md_operand (expressionP)
1152 expressionS *expressionP;
1155 if (input_line_pointer[0] == '%' && input_line_pointer[1] == '%')
1157 /* We have a numeric register expression. No biggy. */
1158 input_line_pointer += 2; /* Skip %% */
1159 (void) expression (expressionP);
1160 if (expressionP->X_op != O_constant
1161 || expressionP->X_add_number > 255)
1162 as_bad (_("Invalid expression after %%%%\n"));
1163 expressionP->X_op = O_register;
1165 else if (input_line_pointer[0] == '&')
1167 /* We are taking the 'address' of a register...this one is not
1168 in the manual, but it *is* in traps/fpsymbol.h! What they
1169 seem to want is the register number, as an absolute number. */
1170 input_line_pointer++; /* Skip & */
1171 (void) expression (expressionP);
1172 if (expressionP->X_op != O_register)
1173 as_bad (_("Invalid register in & expression"));
1175 expressionP->X_op = O_constant;
1177 else if (input_line_pointer[0] == '$'
1178 && ISDIGIT (input_line_pointer[1]))
1184 /* This is a local label. */
1185 ++input_line_pointer;
1186 lab = (long) get_absolute_expression ();
1187 if (dollar_label_defined (lab))
1189 name = dollar_label_name (lab, 0);
1190 sym = symbol_find (name);
1194 name = dollar_label_name (lab, 1);
1195 sym = symbol_find_or_make (name);
1198 expressionP->X_op = O_symbol;
1199 expressionP->X_add_symbol = sym;
1200 expressionP->X_add_number = 0;
1202 else if (input_line_pointer[0] == '$')
1206 int fieldnum, fieldlimit;
1207 LITTLENUM_TYPE floatbuf[8];
1209 /* $float(), $doubleN(), or $extendN() convert floating values
1212 s = input_line_pointer;
1217 if (strncmp (s, "double", sizeof "double" - 1) == 0)
1219 s += sizeof "double" - 1;
1223 else if (strncmp (s, "float", sizeof "float" - 1) == 0)
1225 s += sizeof "float" - 1;
1229 else if (strncmp (s, "extend", sizeof "extend" - 1) == 0)
1231 s += sizeof "extend" - 1;
1242 fieldnum = *s - '0';
1245 if (fieldnum >= fieldlimit)
1254 s = atof_ieee (s, type, floatbuf);
1265 input_line_pointer = s;
1266 expressionP->X_op = O_constant;
1267 expressionP->X_unsigned = 1;
1268 expressionP->X_add_number = ((floatbuf[fieldnum * 2]
1269 << LITTLENUM_NUMBER_OF_BITS)
1270 + floatbuf[fieldnum * 2 + 1]);
1274 /* Round up a section size to the appropriate boundary. */
1276 md_section_align (segment, size)
1280 return size; /* Byte alignment is fine */
1283 /* Exactly what point is a PC-relative offset relative TO?
1284 On the 29000, they're relative to the address of the instruction,
1285 which we have set up as the address of the fixup too. */
1287 md_pcrel_from (fixP)
1290 return fixP->fx_where + fixP->fx_frag->fr_address;