1 /* tc-a29k.c -- Assemble for the AMD 29000.
2 Copyright (C) 1989, 1990, 1991, 1992, 1993 Free Software Foundation, Inc.
4 This file is part of GAS, the GNU Assembler.
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)
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.
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. */
20 /* John Gilmore has reorganized this module somewhat, to make it easier
21 to convert it to new machines' assemblers as desired. There was too
22 much bloody rewriting required before. There still probably is. */
27 #include "opcode/a29k.h"
29 /* Make it easier to clone this machine desc into another one. */
30 #define machine_opcode a29k_opcode
31 #define machine_opcodes a29k_opcodes
32 #define machine_ip a29k_ip
33 #define machine_it a29k_it
35 const relax_typeS md_relax_table
[] =
38 #define IMMEDIATE_BIT 0x01000000 /* Turns RB into Immediate */
39 #define ABSOLUTE_BIT 0x01000000 /* Turns PC-relative to Absolute */
40 #define CE_BIT 0x00800000 /* Coprocessor enable in LOAD */
41 #define UI_BIT 0x00000080 /* Unsigned integer in CONVERT */
43 /* handle of the OPCODE hash table */
44 static struct hash_control
*op_hash
= NULL
;
53 int reloc_offset
; /* Offset of reloc within insn */
62 static void machine_ip
PARAMS ((char *str
));
63 /* static void print_insn PARAMS ((struct machine_it *insn)); */
64 static void s_data1
PARAMS ((void));
65 static void s_use
PARAMS ((void));
70 {"align", s_align_bytes
, 4},
71 {"block", s_space
, 0},
72 {"cputype", s_ignore
, 0}, /* CPU as 29000 or 29050 */
73 {"reg", s_lsym
, 0}, /* Register equate, same as equ */
74 {"space", s_ignore
, 0}, /* Listing control */
75 {"sect", s_ignore
, 0}, /* Creation of coff sections */
77 /* We can do this right with coff */
84 int md_short_jump_size
= 4;
85 int md_long_jump_size
= 4;
86 #if defined(BFD_HEADERS)
88 const int md_reloc_size
= RELSZ
; /* Coff headers */
90 const int md_reloc_size
= 12; /* something else headers */
93 const int md_reloc_size
= 12; /* Not bfdized*/
96 /* This array holds the chars that always start a comment. If the
97 pre-processor is disabled, these aren't very useful */
98 const char comment_chars
[] = ";";
100 /* This array holds the chars that only start a comment at the beginning of
101 a line. If the line seems to have the form '# 123 filename'
102 .line and .file directives will appear in the pre-processed output */
103 /* Note that input_file.c hand checks for '#' at the beginning of the
104 first line of the input file. This is because the compiler outputs
105 #NO_APP at the beginning of its output. */
106 /* Also note that comments like this one will always work */
107 const char line_comment_chars
[] = "#";
109 /* We needed an unused char for line separation to work around the
110 lack of macros, using sed and such. */
111 const char line_separator_chars
[] = "@";
113 /* Chars that can be used to separate mant from exp in floating point nums */
114 const char EXP_CHARS
[] = "eE";
116 /* Chars that mean this number is a floating point constant */
119 const char FLT_CHARS
[] = "rRsSfFdDxXpP";
121 /* Also be aware that MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT may have to be
122 changed in read.c . Ideally it shouldn't have to know about it at all,
123 but nothing is ideal around here.
126 static unsigned char octal
[256];
127 #define isoctal(c) octal[c]
128 static unsigned char toHex
[256];
131 * anull bit - causes the branch delay slot instructions to not be executed
133 #define ANNUL (1 << 29)
139 if (strncmp (input_line_pointer
, ".text", 5) == 0)
141 input_line_pointer
+= 5;
145 if (strncmp (input_line_pointer
, ".data", 5) == 0)
147 input_line_pointer
+= 5;
151 if (strncmp (input_line_pointer
, ".data1", 6) == 0)
153 input_line_pointer
+= 6;
157 /* Literals can't go in the text segment because you can't read
158 from instruction memory on some 29k's. So, into initialized data. */
159 if (strncmp (input_line_pointer
, ".lit", 4) == 0)
161 input_line_pointer
+= 4;
162 subseg_new (SEG_DATA
, 200);
163 demand_empty_rest_of_line ();
167 as_bad ("Unknown segment type");
168 demand_empty_rest_of_line ();
175 subseg_new (SEG_DATA
, 1);
176 demand_empty_rest_of_line ();
180 /* Install symbol definition that maps REGNAME to REGNO.
181 FIXME-SOON: These are not recognized in mixed case. */
184 insert_sreg (regname
, regnum
)
188 /* FIXME-SOON, put something in these syms so they won't be output to the symbol
189 table of the resulting object file. */
191 /* Must be large enough to hold the names of the special registers. */
195 symbol_table_insert (symbol_new (regname
, SEG_REGISTER
, regnum
, &zero_address_frag
));
196 for (i
= 0; regname
[i
]; i
++)
197 buf
[i
] = islower (regname
[i
]) ? toupper (regname
[i
]) : regname
[i
];
200 symbol_table_insert (symbol_new (buf
, SEG_REGISTER
, regnum
, &zero_address_frag
));
201 } /* insert_sreg() */
203 /* Install symbol definitions for assorted special registers.
204 See ASM29K Ref page 2-9. */
211 /* Protected special-purpose register names */
212 insert_sreg ("vab", SREG
+ 0);
213 insert_sreg ("ops", SREG
+ 1);
214 insert_sreg ("cps", SREG
+ 2);
215 insert_sreg ("cfg", SREG
+ 3);
216 insert_sreg ("cha", SREG
+ 4);
217 insert_sreg ("chd", SREG
+ 5);
218 insert_sreg ("chc", SREG
+ 6);
219 insert_sreg ("rbp", SREG
+ 7);
220 insert_sreg ("tmc", SREG
+ 8);
221 insert_sreg ("tmr", SREG
+ 9);
222 insert_sreg ("pc0", SREG
+ 10);
223 insert_sreg ("pc1", SREG
+ 11);
224 insert_sreg ("pc2", SREG
+ 12);
225 insert_sreg ("mmu", SREG
+ 13);
226 insert_sreg ("lru", SREG
+ 14);
228 /* Additional protected special-purpose registers for the 29050 */
229 insert_sreg ("rsn", SREG
+ 15);
230 insert_sreg ("rma0", SREG
+ 16);
231 insert_sreg ("rmc0", SREG
+ 17);
232 insert_sreg ("rma1", SREG
+ 18);
233 insert_sreg ("rmc1", SREG
+ 19);
234 insert_sreg ("spc0", SREG
+ 20);
235 insert_sreg ("spc1", SREG
+ 21);
236 insert_sreg ("spc2", SREG
+ 22);
237 insert_sreg ("iba0", SREG
+ 23);
238 insert_sreg ("ibc0", SREG
+ 24);
239 insert_sreg ("iba1", SREG
+ 25);
240 insert_sreg ("ibc1", SREG
+ 26);
242 /* Unprotected special-purpose register names */
243 insert_sreg ("ipc", SREG
+ 128);
244 insert_sreg ("ipa", SREG
+ 129);
245 insert_sreg ("ipb", SREG
+ 130);
246 insert_sreg ("q", SREG
+ 131);
247 insert_sreg ("alu", SREG
+ 132);
248 insert_sreg ("bp", SREG
+ 133);
249 insert_sreg ("fc", SREG
+ 134);
250 insert_sreg ("cr", SREG
+ 135);
251 insert_sreg ("fpe", SREG
+ 160);
252 insert_sreg ("inte", SREG
+ 161);
253 insert_sreg ("fps", SREG
+ 162);
254 /* "", SREG+163); Reserved */
255 insert_sreg ("exop", SREG
+ 164);
256 } /* define_some_regs() */
258 /* This function is called once, at assembler startup time. It should
259 set up all the tables, etc. that the MD part of the assembler will need. */
263 register char *retval
= NULL
;
265 register int skipnext
= 0;
266 register unsigned int i
;
267 register char *strend
, *strend2
;
269 /* Hash up all the opcodes for fast use later. */
271 op_hash
= hash_new ();
273 for (i
= 0; i
< num_opcodes
; i
++)
275 const char *name
= machine_opcodes
[i
].name
;
283 /* Hack to avoid multiple opcode entries. We pre-locate all the
284 variations (b/i field and P/A field) and handle them. */
286 if (!strcmp (name
, machine_opcodes
[i
+ 1].name
))
288 if ((machine_opcodes
[i
].opcode
^ machine_opcodes
[i
+ 1].opcode
)
291 strend
= machine_opcodes
[i
].args
+ strlen (machine_opcodes
[i
].args
) - 1;
292 strend2
= machine_opcodes
[i
+ 1].args
+ strlen (machine_opcodes
[i
+ 1].args
) - 1;
313 fprintf (stderr
, "internal error: can't handle opcode %s\n", name
);
317 /* OK, this is an i/b or A/P pair. We skip the higher-valued one,
318 and let the code for operand checking handle OR-ing in the bit. */
319 if (machine_opcodes
[i
].opcode
& 1)
325 retval
= hash_insert (op_hash
, name
, &machine_opcodes
[i
]);
326 if (retval
!= NULL
&& *retval
!= '\0')
328 fprintf (stderr
, "internal error: can't hash `%s': %s\n",
329 machine_opcodes
[i
].name
, retval
);
335 as_fatal ("Broken assembler. No assembly attempted.");
337 for (i
= '0'; i
< '8'; ++i
)
339 for (i
= '0'; i
<= '9'; ++i
)
341 for (i
= 'a'; i
<= 'f'; ++i
)
342 toHex
[i
] = i
+ 10 - 'a';
343 for (i
= 'A'; i
<= 'F'; ++i
)
344 toHex
[i
] = i
+ 10 - 'A';
355 /* Assemble a single instruction. Its label has already been handled
356 by the generic front end. We just parse opcode and operands, and
357 produce the bytes of data and relocation. */
369 /* put out the opcode */
370 md_number_to_chars (toP
, the_insn
.opcode
, 4);
372 /* put out the symbol-dependent stuff */
373 if (the_insn
.reloc
!= NO_RELOC
)
375 fix_new_exp (frag_now
,
376 (toP
- frag_now
->fr_literal
+ the_insn
.reloc_offset
),
385 parse_operand (s
, operandp
)
387 expressionS
*operandp
;
389 char *save
= input_line_pointer
;
392 input_line_pointer
= s
;
393 expression (operandp
);
394 if (operandp
->X_op
== O_absent
)
395 as_bad ("missing operand");
396 new = input_line_pointer
;
397 input_line_pointer
= save
;
401 /* Instruction parsing. Takes a string containing the opcode.
402 Operands are at input_line_pointer. Output is in the_insn.
403 Warnings or errors are generated. */
412 /* !!!! unsigned long i; */
413 struct machine_opcode
*insn
;
415 unsigned long opcode
;
416 /* !!!! unsigned int mask; */
417 expressionS the_operand
;
418 expressionS
*operand
= &the_operand
;
421 /* Must handle `div0' opcode. */
424 for (; isalnum (*s
); ++s
)
433 case ' ': /* FIXME-SOMEDAY more whitespace */
438 as_bad ("Unknown opcode: `%s'", str
);
441 if ((insn
= (struct machine_opcode
*) hash_find (op_hash
, str
)) == NULL
)
443 as_bad ("Unknown opcode `%s'.", str
);
447 opcode
= insn
->opcode
;
448 memset (&the_insn
, '\0', sizeof (the_insn
));
449 the_insn
.reloc
= NO_RELOC
;
452 * Build the opcode, checking as we go to make
453 * sure that the operands match.
455 * If an operand matches, we modify the_insn or opcode appropriately,
456 * and do a "continue". If an operand fails to match, we "break".
458 if (insn
->args
[0] != '\0')
459 s
= parse_operand (s
, operand
); /* Prime the pump */
461 for (args
= insn
->args
;; ++args
)
466 case '\0': /* end of args */
469 /* We are truly done. */
470 the_insn
.opcode
= opcode
;
473 as_bad ("Too many operands: %s", s
);
476 case ',': /* Must match a comma */
479 s
= parse_operand (s
, operand
); /* Parse next opnd */
484 case 'v': /* Trap numbers (immediate field) */
485 if (operand
->X_op
== O_constant
)
487 if (operand
->X_add_number
< 256)
489 opcode
|= (operand
->X_add_number
<< 16);
494 as_bad ("Immediate value of %d is too large",
495 operand
->X_add_number
);
499 the_insn
.reloc
= RELOC_8
;
500 the_insn
.reloc_offset
= 1; /* BIG-ENDIAN Byte 1 of insn */
501 the_insn
.exp
= *operand
;
504 case 'b': /* A general register or 8-bit immediate */
506 /* We treat the two cases identically since we mashed
507 them together in the opcode table. */
508 if (operand
->X_op
== O_register
)
511 opcode
|= IMMEDIATE_BIT
;
512 if (operand
->X_op
== O_constant
)
514 if (operand
->X_add_number
< 256)
516 opcode
|= operand
->X_add_number
;
521 as_bad ("Immediate value of %d is too large",
522 operand
->X_add_number
);
526 the_insn
.reloc
= RELOC_8
;
527 the_insn
.reloc_offset
= 3; /* BIG-ENDIAN Byte 3 of insn */
528 the_insn
.exp
= *operand
;
531 case 'a': /* next operand must be a register */
534 /* lrNNN or grNNN or %%expr or a user-def register name */
535 if (operand
->X_op
!= O_register
)
536 break; /* Only registers */
537 know (operand
->X_add_symbol
== 0);
538 know (operand
->X_op_symbol
== 0);
539 reg
= operand
->X_add_number
;
541 break; /* No special registers */
544 * Got the register, now figure out where
545 * it goes in the opcode.
562 as_fatal ("failed sanity check.");
565 case 'x': /* 16 bit constant, zero-extended */
566 case 'X': /* 16 bit constant, one-extended */
567 if (operand
->X_op
== O_constant
)
569 opcode
|= (operand
->X_add_number
& 0xFF) << 0 |
570 ((operand
->X_add_number
& 0xFF00) << 8);
573 the_insn
.reloc
= RELOC_CONST
;
574 the_insn
.exp
= *operand
;
578 if (operand
->X_op
== O_constant
)
580 opcode
|= (operand
->X_add_number
& 0x00FF0000) >> 16 |
581 (((unsigned long) operand
->X_add_number
582 /* avoid sign ext */ & 0xFF000000) >> 8);
585 the_insn
.reloc
= RELOC_CONSTH
;
586 the_insn
.exp
= *operand
;
589 case 'P': /* PC-relative jump address */
590 case 'A': /* Absolute jump address */
591 /* These two are treated together since we folded the
592 opcode table entries together. */
593 if (operand
->X_op
== O_constant
)
595 opcode
|= ABSOLUTE_BIT
|
596 (operand
->X_add_number
& 0x0003FC00) << 6 |
597 ((operand
->X_add_number
& 0x000003FC) >> 2);
600 the_insn
.reloc
= RELOC_JUMPTARG
;
601 the_insn
.exp
= *operand
;
602 the_insn
.pcrel
= 1; /* Assume PC-relative jump */
603 /* FIXME-SOON, Do we figure out whether abs later, after know sym val? */
606 case 'e': /* Coprocessor enable bit for LOAD/STORE insn */
607 if (operand
->X_op
== O_constant
)
609 if (operand
->X_add_number
== 0)
611 if (operand
->X_add_number
== 1)
619 case 'n': /* Control bits for LOAD/STORE instructions */
620 if (operand
->X_op
== O_constant
&&
621 operand
->X_add_number
< 128)
623 opcode
|= (operand
->X_add_number
<< 16);
628 case 's': /* Special register number */
629 if (operand
->X_op
!= O_register
)
630 break; /* Only registers */
631 if (operand
->X_add_number
< SREG
)
632 break; /* Not a special register */
633 opcode
|= (operand
->X_add_number
& 0xFF) << 8;
636 case 'u': /* UI bit of CONVERT */
637 if (operand
->X_op
== O_constant
)
639 if (operand
->X_add_number
== 0)
641 if (operand
->X_add_number
== 1)
649 case 'r': /* RND bits of CONVERT */
650 if (operand
->X_op
== O_constant
&&
651 operand
->X_add_number
< 8)
653 opcode
|= operand
->X_add_number
<< 4;
658 case 'd': /* FD bits of CONVERT */
659 if (operand
->X_op
== O_constant
&&
660 operand
->X_add_number
< 4)
662 opcode
|= operand
->X_add_number
<< 2;
668 case 'f': /* FS bits of CONVERT */
669 if (operand
->X_op
== O_constant
&&
670 operand
->X_add_number
< 4)
672 opcode
|= operand
->X_add_number
<< 0;
678 if (operand
->X_op
== O_constant
&&
679 operand
->X_add_number
< 4)
681 opcode
|= operand
->X_add_number
<< 16;
687 if (operand
->X_op
== O_constant
&&
688 operand
->X_add_number
< 16)
690 opcode
|= operand
->X_add_number
<< 18;
698 /* Types or values of args don't match. */
699 as_bad ("Invalid operands");
705 This is identical to the md_atof in m68k.c. I think this is right,
708 Turn a string in input_line_pointer into a floating point constant of type
709 type, and store the appropriate bytes in *litP. The number of LITTLENUMS
710 emitted is stored in *sizeP . An error message is returned, or NULL on OK.
713 /* Equal to MAX_PRECISION in atof-ieee.c */
714 #define MAX_LITTLENUMS 6
717 md_atof (type
, litP
, sizeP
)
723 LITTLENUM_TYPE words
[MAX_LITTLENUMS
];
724 LITTLENUM_TYPE
*wordP
;
756 return "Bad call to MD_ATOF()";
758 t
= atof_ieee (input_line_pointer
, type
, words
);
760 input_line_pointer
= t
;
761 *sizeP
= prec
* sizeof (LITTLENUM_TYPE
);
762 for (wordP
= words
; prec
--;)
764 md_number_to_chars (litP
, (long) (*wordP
++), sizeof (LITTLENUM_TYPE
));
765 litP
+= sizeof (LITTLENUM_TYPE
);
767 return ""; /* Someone should teach Dean about null pointers */
771 * Write out big-endian.
774 md_number_to_chars (buf
, val
, n
)
793 as_fatal ("failed sanity check.");
799 md_apply_fix (fixP
, val
)
803 char *buf
= fixP
->fx_where
+ fixP
->fx_frag
->fr_literal
;
805 fixP
->fx_addnumber
= val
; /* Remember value for emit_reloc */
808 know (fixP
->fx_size
== 4);
809 know (fixP
->fx_r_type
< NO_RELOC
);
812 * This is a hack. There should be a better way to
815 if (fixP
->fx_r_type
== RELOC_WDISP30
&& fixP
->fx_addsy
)
817 val
+= fixP
->fx_where
+ fixP
->fx_frag
->fr_address
;
820 switch (fixP
->fx_r_type
)
835 val
= (val
>>= 2) + 1;
836 buf
[0] |= (val
>> 24) & 0x3f;
837 buf
[1] = (val
>> 16);
843 buf
[1] |= (val
>> 26) & 0x3f;
849 buf
[2] |= (val
>> 8) & 0x03;
854 buf
[2] |= (val
>> 8) & 0x1f;
859 val
= (val
>>= 2) + 1;
862 buf
[1] |= (val
>> 16) & 0x3f;
876 case RELOC_JUMPTARG
: /* 00XX00XX pattern in a word */
877 buf
[1] = val
>> 10; /* Holds bits 0003FFFC of address */
881 case RELOC_CONST
: /* 00XX00XX pattern in a word */
882 buf
[1] = val
>> 8; /* Holds bits 0000XXXX */
886 case RELOC_CONSTH
: /* 00XX00XX pattern in a word */
887 buf
[1] = val
>> 24; /* Holds bits XXXX0000 */
893 as_bad ("bad relocation type: 0x%02x", fixP
->fx_r_type
);
901 tc_coff_fix2rtype (fixP
)
905 switch (fixP
->fx_r_type
)
918 printf ("need %o3\n", fixP
->fx_r_type
);
920 } /* switch on type */
923 } /* tc_coff_fix2rtype() */
925 #endif /* OBJ_COFF */
927 /* should never be called for sparc */
929 md_create_short_jump (ptr
, from_addr
, to_addr
, frag
, to_symbol
)
931 addressT from_addr
, to_addr
;
935 as_fatal ("a29k_create_short_jmp\n");
938 /* should never be called for 29k */
940 md_convert_frag (headers
, fragP
)
941 object_headers
*headers
;
942 register fragS
*fragP
;
944 as_fatal ("sparc_convert_frag\n");
947 /* should never be called for 29k */
949 md_create_long_jump (ptr
, from_addr
, to_addr
, frag
, to_symbol
)
956 as_fatal ("sparc_create_long_jump\n");
959 /* should never be called for a29k */
961 md_estimate_size_before_relax (fragP
, segtype
)
962 register fragS
*fragP
;
965 as_fatal ("sparc_estimate_size_before_relax\n");
970 /* for debugging only */
973 struct machine_it
*insn
;
1006 fprintf (stderr
, "ERROR: %s\n");
1008 fprintf (stderr
, "opcode=0x%08x\n", insn
->opcode
);
1009 fprintf (stderr
, "reloc = %s\n", Reloc
[insn
->reloc
]);
1010 fprintf (stderr
, "exp = {\n");
1011 fprintf (stderr
, "\t\tX_add_symbol = %s\n",
1012 insn
->exp
.X_add_symbol
?
1013 (S_GET_NAME (insn
->exp
.X_add_symbol
) ?
1014 S_GET_NAME (insn
->exp
.X_add_symbol
) : "???") : "0");
1015 fprintf (stderr
, "\t\tX_op_symbol = %s\n",
1016 insn
->exp
.X_op_symbol
?
1017 (S_GET_NAME (insn
->exp
.X_op_symbol
) ?
1018 S_GET_NAME (insn
->exp
.X_op_symbol
) : "???") : "0");
1019 fprintf (stderr
, "\t\tX_add_number = %d\n",
1020 insn
->exp
.X_add_number
);
1021 fprintf (stderr
, "}\n");
1027 /* Translate internal representation of relocation info to target format.
1029 On sparc/29k: first 4 bytes are normal unsigned long address, next three
1030 bytes are index, most sig. byte first. Byte 7 is broken up with
1031 bit 7 as external, bits 6 & 5 unused, and the lower
1032 five bits as relocation type. Next 4 bytes are long addend. */
1033 /* Thanx and a tip of the hat to Michael Bloom, mb@ttidca.tti.com */
1038 tc_aout_fix_to_chars (where
, fixP
, segment_address_in_file
)
1041 relax_addressT segment_address_in_file
;
1045 know (fixP
->fx_r_type
< NO_RELOC
);
1046 know (fixP
->fx_addsy
!= NULL
);
1048 md_number_to_chars (where
,
1049 fixP
->fx_frag
->fr_address
+ fixP
->fx_where
- segment_address_in_file
,
1052 r_symbolnum
= (S_IS_DEFINED (fixP
->fx_addsy
)
1053 ? S_GET_TYPE (fixP
->fx_addsy
)
1054 : fixP
->fx_addsy
->sy_number
);
1056 where
[4] = (r_symbolnum
>> 16) & 0x0ff;
1057 where
[5] = (r_symbolnum
>> 8) & 0x0ff;
1058 where
[6] = r_symbolnum
& 0x0ff;
1059 where
[7] = (((!S_IS_DEFINED (fixP
->fx_addsy
)) << 7) & 0x80) | (0 & 0x60) | (fixP
->fx_r_type
& 0x1F);
1061 md_number_to_chars (&where
[8], fixP
->fx_addnumber
, 4);
1064 } /* tc_aout_fix_to_chars() */
1066 #endif /* OBJ_AOUT */
1069 md_parse_option (argP
, cntP
, vecP
)
1078 /* Default the values of symbols known that should be "predefined". We
1079 don't bother to predefine them unless you actually use one, since there
1080 are a lot of them. */
1083 md_undefined_symbol (name
)
1087 char testbuf
[5 + /*SLOP*/ 5];
1089 if (name
[0] == 'g' || name
[0] == 'G' || name
[0] == 'l' || name
[0] == 'L')
1091 /* Perhaps a global or local register name */
1092 if (name
[1] == 'r' || name
[1] == 'R')
1094 /* Parse the number, make sure it has no extra zeroes or trailing
1096 regnum
= atol (&name
[2]);
1099 sprintf (testbuf
, "%ld", regnum
);
1100 if (strcmp (testbuf
, &name
[2]) != 0)
1101 return 0; /* gr007 or lr7foo or whatever */
1103 /* We have a wiener! Define and return a new symbol for it. */
1104 if (name
[0] == 'l' || name
[0] == 'L')
1106 return (symbol_new (name
, SEG_REGISTER
, regnum
, &zero_address_frag
));
1113 /* Parse an operand that is machine-specific. */
1116 md_operand (expressionP
)
1117 expressionS
*expressionP
;
1120 if (input_line_pointer
[0] == '%' && input_line_pointer
[1] == '%')
1122 /* We have a numeric register expression. No biggy. */
1123 input_line_pointer
+= 2; /* Skip %% */
1124 (void) expression (expressionP
);
1125 if (expressionP
->X_op
!= O_constant
1126 || expressionP
->X_add_number
> 255)
1127 as_bad ("Invalid expression after %%%%\n");
1128 expressionP
->X_op
= O_register
;
1130 else if (input_line_pointer
[0] == '&')
1132 /* We are taking the 'address' of a register...this one is not
1133 in the manual, but it *is* in traps/fpsymbol.h! What they
1134 seem to want is the register number, as an absolute number. */
1135 input_line_pointer
++; /* Skip & */
1136 (void) expression (expressionP
);
1137 if (expressionP
->X_op
!= O_register
)
1138 as_bad ("Invalid register in & expression");
1140 expressionP
->X_op
= O_constant
;
1144 /* Round up a section size to the appropriate boundary. */
1146 md_section_align (segment
, size
)
1150 return size
; /* Byte alignment is fine */
1153 /* Exactly what point is a PC-relative offset relative TO?
1154 On the 29000, they're relative to the address of the instruction,
1155 which we have set up as the address of the fixup too. */
1157 md_pcrel_from (fixP
)
1160 return fixP
->fx_where
+ fixP
->fx_frag
->fr_address
;
1169 /* end of tc-a29k.c */