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
[] =
40 #define IMMEDIATE_BIT 0x01000000 /* Turns RB into Immediate */
41 #define ABSOLUTE_BIT 0x01000000 /* Turns PC-relative to Absolute */
42 #define CE_BIT 0x00800000 /* Coprocessor enable in LOAD */
43 #define UI_BIT 0x00000080 /* Unsigned integer in CONVERT */
45 /* handle of the OPCODE hash table */
46 static struct hash_control
*op_hash
= NULL
;
55 int reloc_offset
; /* Offset of reloc within insn */
64 static void machine_ip
PARAMS ((char *str
));
65 /* static void print_insn PARAMS ((struct machine_it *insn)); */
67 static void s_data1
PARAMS ((void));
68 static void s_use
PARAMS ((int));
74 {"align", s_align_bytes
, 4},
75 {"block", s_space
, 0},
76 {"cputype", s_ignore
, 0}, /* CPU as 29000 or 29050 */
77 {"reg", s_lsym
, 0}, /* Register equate, same as equ */
78 {"space", s_ignore
, 0}, /* Listing control */
79 {"sect", s_ignore
, 0}, /* Creation of coff sections */
81 /* We can do this right with coff */
88 int md_short_jump_size
= 4;
89 int md_long_jump_size
= 4;
90 #if defined(BFD_HEADERS)
92 const int md_reloc_size
= RELSZ
; /* Coff headers */
94 const int md_reloc_size
= 12; /* something else headers */
97 const int md_reloc_size
= 12; /* Not bfdized*/
100 /* This array holds the chars that always start a comment. If the
101 pre-processor is disabled, these aren't very useful */
102 const char comment_chars
[] = ";";
104 /* This array holds the chars that only start a comment at the beginning of
105 a line. If the line seems to have the form '# 123 filename'
106 .line and .file directives will appear in the pre-processed output */
107 /* Note that input_file.c hand checks for '#' at the beginning of the
108 first line of the input file. This is because the compiler outputs
109 #NO_APP at the beginning of its output. */
110 /* Also note that comments like this one will always work */
111 const char line_comment_chars
[] = "#";
113 /* We needed an unused char for line separation to work around the
114 lack of macros, using sed and such. */
115 const char line_separator_chars
[] = "@";
117 /* Chars that can be used to separate mant from exp in floating point nums */
118 const char EXP_CHARS
[] = "eE";
120 /* Chars that mean this number is a floating point constant */
123 const char FLT_CHARS
[] = "rRsSfFdDxXpP";
125 /* Also be aware that MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT may have to be
126 changed in read.c . Ideally it shouldn't have to know about it at all,
127 but nothing is ideal around here.
130 static unsigned char octal
[256];
131 #define isoctal(c) octal[c]
132 static unsigned char toHex
[256];
135 * anull bit - causes the branch delay slot instructions to not be executed
137 #define ANNUL (1 << 29)
146 if (strncmp (input_line_pointer
, ".text", 5) == 0)
148 input_line_pointer
+= 5;
152 if (strncmp (input_line_pointer
, ".data", 5) == 0)
154 input_line_pointer
+= 5;
158 if (strncmp (input_line_pointer
, ".data1", 6) == 0)
160 input_line_pointer
+= 6;
164 /* Literals can't go in the text segment because you can't read
165 from instruction memory on some 29k's. So, into initialized data. */
166 if (strncmp (input_line_pointer
, ".lit", 4) == 0)
168 input_line_pointer
+= 4;
169 subseg_set (SEG_DATA
, 200);
170 demand_empty_rest_of_line ();
174 as_bad ("Unknown segment type");
175 demand_empty_rest_of_line ();
182 subseg_set (SEG_DATA
, 1);
183 demand_empty_rest_of_line ();
187 #endif /* OBJ_COFF */
189 /* Install symbol definition that maps REGNAME to REGNO.
190 FIXME-SOON: These are not recognized in mixed case. */
193 insert_sreg (regname
, regnum
)
197 /* FIXME-SOON, put something in these syms so they won't be output to the symbol
198 table of the resulting object file. */
200 /* Must be large enough to hold the names of the special registers. */
204 symbol_table_insert (symbol_new (regname
, SEG_REGISTER
, (valueT
) regnum
,
205 &zero_address_frag
));
206 for (i
= 0; regname
[i
]; i
++)
207 buf
[i
] = islower (regname
[i
]) ? toupper (regname
[i
]) : regname
[i
];
210 symbol_table_insert (symbol_new (buf
, SEG_REGISTER
, (valueT
) regnum
,
211 &zero_address_frag
));
212 } /* insert_sreg() */
214 /* Install symbol definitions for assorted special registers.
215 See ASM29K Ref page 2-9. */
222 /* Protected special-purpose register names */
223 insert_sreg ("vab", SREG
+ 0);
224 insert_sreg ("ops", SREG
+ 1);
225 insert_sreg ("cps", SREG
+ 2);
226 insert_sreg ("cfg", SREG
+ 3);
227 insert_sreg ("cha", SREG
+ 4);
228 insert_sreg ("chd", SREG
+ 5);
229 insert_sreg ("chc", SREG
+ 6);
230 insert_sreg ("rbp", SREG
+ 7);
231 insert_sreg ("tmc", SREG
+ 8);
232 insert_sreg ("tmr", SREG
+ 9);
233 insert_sreg ("pc0", SREG
+ 10);
234 insert_sreg ("pc1", SREG
+ 11);
235 insert_sreg ("pc2", SREG
+ 12);
236 insert_sreg ("mmu", SREG
+ 13);
237 insert_sreg ("lru", SREG
+ 14);
239 /* Additional protected special-purpose registers for the 29050 */
240 insert_sreg ("rsn", SREG
+ 15);
241 insert_sreg ("rma0", SREG
+ 16);
242 insert_sreg ("rmc0", SREG
+ 17);
243 insert_sreg ("rma1", SREG
+ 18);
244 insert_sreg ("rmc1", SREG
+ 19);
245 insert_sreg ("spc0", SREG
+ 20);
246 insert_sreg ("spc1", SREG
+ 21);
247 insert_sreg ("spc2", SREG
+ 22);
248 insert_sreg ("iba0", SREG
+ 23);
249 insert_sreg ("ibc0", SREG
+ 24);
250 insert_sreg ("iba1", SREG
+ 25);
251 insert_sreg ("ibc1", SREG
+ 26);
253 /* Unprotected special-purpose register names */
254 insert_sreg ("ipc", SREG
+ 128);
255 insert_sreg ("ipa", SREG
+ 129);
256 insert_sreg ("ipb", SREG
+ 130);
257 insert_sreg ("q", SREG
+ 131);
258 insert_sreg ("alu", SREG
+ 132);
259 insert_sreg ("bp", SREG
+ 133);
260 insert_sreg ("fc", SREG
+ 134);
261 insert_sreg ("cr", SREG
+ 135);
262 insert_sreg ("fpe", SREG
+ 160);
263 insert_sreg ("inte", SREG
+ 161);
264 insert_sreg ("fps", SREG
+ 162);
265 /* "", SREG+163); Reserved */
266 insert_sreg ("exop", SREG
+ 164);
267 } /* define_some_regs() */
269 /* This function is called once, at assembler startup time. It should
270 set up all the tables, etc. that the MD part of the assembler will need. */
274 register const char *retval
= NULL
;
276 register int skipnext
= 0;
277 register unsigned int i
;
278 register char *strend
, *strend2
;
280 /* Hash up all the opcodes for fast use later. */
282 op_hash
= hash_new ();
284 for (i
= 0; i
< num_opcodes
; i
++)
286 const char *name
= machine_opcodes
[i
].name
;
294 /* Hack to avoid multiple opcode entries. We pre-locate all the
295 variations (b/i field and P/A field) and handle them. */
297 if (!strcmp (name
, machine_opcodes
[i
+ 1].name
))
299 if ((machine_opcodes
[i
].opcode
^ machine_opcodes
[i
+ 1].opcode
)
302 strend
= machine_opcodes
[i
].args
+ strlen (machine_opcodes
[i
].args
) - 1;
303 strend2
= machine_opcodes
[i
+ 1].args
+ strlen (machine_opcodes
[i
+ 1].args
) - 1;
324 fprintf (stderr
, "internal error: can't handle opcode %s\n", name
);
328 /* OK, this is an i/b or A/P pair. We skip the higher-valued one,
329 and let the code for operand checking handle OR-ing in the bit. */
330 if (machine_opcodes
[i
].opcode
& 1)
336 retval
= hash_insert (op_hash
, name
, (PTR
) &machine_opcodes
[i
]);
337 if (retval
!= NULL
&& *retval
!= '\0')
339 fprintf (stderr
, "internal error: can't hash `%s': %s\n",
340 machine_opcodes
[i
].name
, retval
);
346 as_fatal ("Broken assembler. No assembly attempted.");
348 for (i
= '0'; i
< '8'; ++i
)
350 for (i
= '0'; i
<= '9'; ++i
)
352 for (i
= 'a'; i
<= 'f'; ++i
)
353 toHex
[i
] = i
+ 10 - 'a';
354 for (i
= 'A'; i
<= 'F'; ++i
)
355 toHex
[i
] = i
+ 10 - 'A';
366 /* Assemble a single instruction. Its label has already been handled
367 by the generic front end. We just parse opcode and operands, and
368 produce the bytes of data and relocation. */
380 /* put out the opcode */
381 md_number_to_chars (toP
, the_insn
.opcode
, 4);
383 /* put out the symbol-dependent stuff */
384 if (the_insn
.reloc
!= NO_RELOC
)
386 fix_new_exp (frag_now
,
387 (toP
- frag_now
->fr_literal
+ the_insn
.reloc_offset
),
396 parse_operand (s
, operandp
)
398 expressionS
*operandp
;
400 char *save
= input_line_pointer
;
403 input_line_pointer
= s
;
404 expression (operandp
);
405 if (operandp
->X_op
== O_absent
)
406 as_bad ("missing operand");
407 new = input_line_pointer
;
408 input_line_pointer
= save
;
412 /* Instruction parsing. Takes a string containing the opcode.
413 Operands are at input_line_pointer. Output is in the_insn.
414 Warnings or errors are generated. */
423 /* !!!! unsigned long i; */
424 struct machine_opcode
*insn
;
426 unsigned long opcode
;
427 /* !!!! unsigned int mask; */
428 expressionS the_operand
;
429 expressionS
*operand
= &the_operand
;
432 /* Must handle `div0' opcode. */
435 for (; isalnum (*s
); ++s
)
444 case ' ': /* FIXME-SOMEDAY more whitespace */
449 as_bad ("Unknown opcode: `%s'", str
);
452 if ((insn
= (struct machine_opcode
*) hash_find (op_hash
, str
)) == NULL
)
454 as_bad ("Unknown opcode `%s'.", str
);
458 opcode
= insn
->opcode
;
459 memset (&the_insn
, '\0', sizeof (the_insn
));
460 the_insn
.reloc
= NO_RELOC
;
463 * Build the opcode, checking as we go to make
464 * sure that the operands match.
466 * If an operand matches, we modify the_insn or opcode appropriately,
467 * and do a "continue". If an operand fails to match, we "break".
469 if (insn
->args
[0] != '\0')
470 s
= parse_operand (s
, operand
); /* Prime the pump */
472 for (args
= insn
->args
;; ++args
)
477 case '\0': /* end of args */
480 /* We are truly done. */
481 the_insn
.opcode
= opcode
;
484 as_bad ("Too many operands: %s", s
);
487 case ',': /* Must match a comma */
490 s
= parse_operand (s
, operand
); /* Parse next opnd */
495 case 'v': /* Trap numbers (immediate field) */
496 if (operand
->X_op
== O_constant
)
498 if (operand
->X_add_number
< 256)
500 opcode
|= (operand
->X_add_number
<< 16);
505 as_bad ("Immediate value of %ld is too large",
506 (long) operand
->X_add_number
);
510 the_insn
.reloc
= RELOC_8
;
511 the_insn
.reloc_offset
= 1; /* BIG-ENDIAN Byte 1 of insn */
512 the_insn
.exp
= *operand
;
515 case 'b': /* A general register or 8-bit immediate */
517 /* We treat the two cases identically since we mashed
518 them together in the opcode table. */
519 if (operand
->X_op
== O_register
)
522 opcode
|= IMMEDIATE_BIT
;
523 if (operand
->X_op
== O_constant
)
525 if (operand
->X_add_number
< 256)
527 opcode
|= operand
->X_add_number
;
532 as_bad ("Immediate value of %ld is too large",
533 (long) operand
->X_add_number
);
537 the_insn
.reloc
= RELOC_8
;
538 the_insn
.reloc_offset
= 3; /* BIG-ENDIAN Byte 3 of insn */
539 the_insn
.exp
= *operand
;
542 case 'a': /* next operand must be a register */
545 /* lrNNN or grNNN or %%expr or a user-def register name */
546 if (operand
->X_op
!= O_register
)
547 break; /* Only registers */
548 know (operand
->X_add_symbol
== 0);
549 know (operand
->X_op_symbol
== 0);
550 reg
= operand
->X_add_number
;
552 break; /* No special registers */
555 * Got the register, now figure out where
556 * it goes in the opcode.
573 as_fatal ("failed sanity check.");
576 case 'x': /* 16 bit constant, zero-extended */
577 case 'X': /* 16 bit constant, one-extended */
578 if (operand
->X_op
== O_constant
)
580 opcode
|= (operand
->X_add_number
& 0xFF) << 0 |
581 ((operand
->X_add_number
& 0xFF00) << 8);
584 the_insn
.reloc
= RELOC_CONST
;
585 the_insn
.exp
= *operand
;
589 if (operand
->X_op
== O_constant
)
591 opcode
|= (operand
->X_add_number
& 0x00FF0000) >> 16 |
592 (((unsigned long) operand
->X_add_number
593 /* avoid sign ext */ & 0xFF000000) >> 8);
596 the_insn
.reloc
= RELOC_CONSTH
;
597 the_insn
.exp
= *operand
;
600 case 'P': /* PC-relative jump address */
601 case 'A': /* Absolute jump address */
602 /* These two are treated together since we folded the
603 opcode table entries together. */
604 if (operand
->X_op
== O_constant
)
606 opcode
|= ABSOLUTE_BIT
|
607 (operand
->X_add_number
& 0x0003FC00) << 6 |
608 ((operand
->X_add_number
& 0x000003FC) >> 2);
611 the_insn
.reloc
= RELOC_JUMPTARG
;
612 the_insn
.exp
= *operand
;
613 the_insn
.pcrel
= 1; /* Assume PC-relative jump */
614 /* FIXME-SOON, Do we figure out whether abs later, after know sym val? */
617 case 'e': /* Coprocessor enable bit for LOAD/STORE insn */
618 if (operand
->X_op
== O_constant
)
620 if (operand
->X_add_number
== 0)
622 if (operand
->X_add_number
== 1)
630 case 'n': /* Control bits for LOAD/STORE instructions */
631 if (operand
->X_op
== O_constant
&&
632 operand
->X_add_number
< 128)
634 opcode
|= (operand
->X_add_number
<< 16);
639 case 's': /* Special register number */
640 if (operand
->X_op
!= O_register
)
641 break; /* Only registers */
642 if (operand
->X_add_number
< SREG
)
643 break; /* Not a special register */
644 opcode
|= (operand
->X_add_number
& 0xFF) << 8;
647 case 'u': /* UI bit of CONVERT */
648 if (operand
->X_op
== O_constant
)
650 if (operand
->X_add_number
== 0)
652 if (operand
->X_add_number
== 1)
660 case 'r': /* RND bits of CONVERT */
661 if (operand
->X_op
== O_constant
&&
662 operand
->X_add_number
< 8)
664 opcode
|= operand
->X_add_number
<< 4;
669 case 'd': /* FD bits of CONVERT */
670 if (operand
->X_op
== O_constant
&&
671 operand
->X_add_number
< 4)
673 opcode
|= operand
->X_add_number
<< 2;
679 case 'f': /* FS bits of CONVERT */
680 if (operand
->X_op
== O_constant
&&
681 operand
->X_add_number
< 4)
683 opcode
|= operand
->X_add_number
<< 0;
689 if (operand
->X_op
== O_constant
&&
690 operand
->X_add_number
< 4)
692 opcode
|= operand
->X_add_number
<< 16;
698 if (operand
->X_op
== O_constant
&&
699 operand
->X_add_number
< 16)
701 opcode
|= operand
->X_add_number
<< 18;
709 /* Types or values of args don't match. */
710 as_bad ("Invalid operands");
716 This is identical to the md_atof in m68k.c. I think this is right,
719 Turn a string in input_line_pointer into a floating point constant of type
720 type, and store the appropriate bytes in *litP. The number of LITTLENUMS
721 emitted is stored in *sizeP . An error message is returned, or NULL on OK.
724 /* Equal to MAX_PRECISION in atof-ieee.c */
725 #define MAX_LITTLENUMS 6
728 md_atof (type
, litP
, sizeP
)
734 LITTLENUM_TYPE words
[MAX_LITTLENUMS
];
735 LITTLENUM_TYPE
*wordP
;
767 return "Bad call to MD_ATOF()";
769 t
= atof_ieee (input_line_pointer
, type
, words
);
771 input_line_pointer
= t
;
772 *sizeP
= prec
* sizeof (LITTLENUM_TYPE
);
773 for (wordP
= words
; prec
--;)
775 md_number_to_chars (litP
, (valueT
) (*wordP
++), sizeof (LITTLENUM_TYPE
));
776 litP
+= sizeof (LITTLENUM_TYPE
);
778 return ""; /* Someone should teach Dean about null pointers */
782 * Write out big-endian.
785 md_number_to_chars (buf
, val
, n
)
804 as_fatal ("failed sanity check.");
810 md_apply_fix (fixP
, val
)
814 char *buf
= fixP
->fx_where
+ fixP
->fx_frag
->fr_literal
;
816 fixP
->fx_addnumber
= val
; /* Remember value for emit_reloc */
819 know (fixP
->fx_size
== 4);
820 know (fixP
->fx_r_type
< NO_RELOC
);
823 * This is a hack. There should be a better way to
826 if (fixP
->fx_r_type
== RELOC_WDISP30
&& fixP
->fx_addsy
)
828 val
+= fixP
->fx_where
+ fixP
->fx_frag
->fr_address
;
831 switch (fixP
->fx_r_type
)
846 val
= (val
>>= 2) + 1;
847 buf
[0] |= (val
>> 24) & 0x3f;
848 buf
[1] = (val
>> 16);
854 buf
[1] |= (val
>> 26) & 0x3f;
860 buf
[2] |= (val
>> 8) & 0x03;
865 buf
[2] |= (val
>> 8) & 0x1f;
870 val
= (val
>>= 2) + 1;
873 buf
[1] |= (val
>> 16) & 0x3f;
887 case RELOC_JUMPTARG
: /* 00XX00XX pattern in a word */
888 buf
[1] = val
>> 10; /* Holds bits 0003FFFC of address */
892 case RELOC_CONST
: /* 00XX00XX pattern in a word */
893 buf
[1] = val
>> 8; /* Holds bits 0000XXXX */
897 case RELOC_CONSTH
: /* 00XX00XX pattern in a word */
898 buf
[1] = val
>> 24; /* Holds bits XXXX0000 */
904 as_bad ("bad relocation type: 0x%02x", fixP
->fx_r_type
);
912 tc_coff_fix2rtype (fixP
)
916 switch (fixP
->fx_r_type
)
929 printf ("need %o3\n", fixP
->fx_r_type
);
931 } /* switch on type */
934 } /* tc_coff_fix2rtype() */
936 #endif /* OBJ_COFF */
938 /* should never be called for sparc */
940 md_create_short_jump (ptr
, from_addr
, to_addr
, frag
, to_symbol
)
942 addressT from_addr
, to_addr
;
946 as_fatal ("a29k_create_short_jmp\n");
949 /* should never be called for 29k */
951 md_convert_frag (headers
, fragP
)
952 object_headers
*headers
;
953 register fragS
*fragP
;
955 as_fatal ("sparc_convert_frag\n");
958 /* should never be called for 29k */
960 md_create_long_jump (ptr
, from_addr
, to_addr
, frag
, to_symbol
)
967 as_fatal ("sparc_create_long_jump\n");
970 /* should never be called for a29k */
972 md_estimate_size_before_relax (fragP
, segtype
)
973 register fragS
*fragP
;
976 as_fatal ("sparc_estimate_size_before_relax\n");
981 /* for debugging only */
984 struct machine_it
*insn
;
1017 fprintf (stderr
, "ERROR: %s\n");
1019 fprintf (stderr
, "opcode=0x%08x\n", insn
->opcode
);
1020 fprintf (stderr
, "reloc = %s\n", Reloc
[insn
->reloc
]);
1021 fprintf (stderr
, "exp = {\n");
1022 fprintf (stderr
, "\t\tX_add_symbol = %s\n",
1023 insn
->exp
.X_add_symbol
?
1024 (S_GET_NAME (insn
->exp
.X_add_symbol
) ?
1025 S_GET_NAME (insn
->exp
.X_add_symbol
) : "???") : "0");
1026 fprintf (stderr
, "\t\tX_op_symbol = %s\n",
1027 insn
->exp
.X_op_symbol
?
1028 (S_GET_NAME (insn
->exp
.X_op_symbol
) ?
1029 S_GET_NAME (insn
->exp
.X_op_symbol
) : "???") : "0");
1030 fprintf (stderr
, "\t\tX_add_number = %d\n",
1031 insn
->exp
.X_add_number
);
1032 fprintf (stderr
, "}\n");
1038 /* Translate internal representation of relocation info to target format.
1040 On sparc/29k: first 4 bytes are normal unsigned long address, next three
1041 bytes are index, most sig. byte first. Byte 7 is broken up with
1042 bit 7 as external, bits 6 & 5 unused, and the lower
1043 five bits as relocation type. Next 4 bytes are long addend. */
1044 /* Thanx and a tip of the hat to Michael Bloom, mb@ttidca.tti.com */
1049 tc_aout_fix_to_chars (where
, fixP
, segment_address_in_file
)
1052 relax_addressT segment_address_in_file
;
1056 know (fixP
->fx_r_type
< NO_RELOC
);
1057 know (fixP
->fx_addsy
!= NULL
);
1059 md_number_to_chars (where
,
1060 fixP
->fx_frag
->fr_address
+ fixP
->fx_where
- segment_address_in_file
,
1063 r_symbolnum
= (S_IS_DEFINED (fixP
->fx_addsy
)
1064 ? S_GET_TYPE (fixP
->fx_addsy
)
1065 : fixP
->fx_addsy
->sy_number
);
1067 where
[4] = (r_symbolnum
>> 16) & 0x0ff;
1068 where
[5] = (r_symbolnum
>> 8) & 0x0ff;
1069 where
[6] = r_symbolnum
& 0x0ff;
1070 where
[7] = (((!S_IS_DEFINED (fixP
->fx_addsy
)) << 7) & 0x80) | (0 & 0x60) | (fixP
->fx_r_type
& 0x1F);
1072 md_number_to_chars (&where
[8], fixP
->fx_addnumber
, 4);
1075 } /* tc_aout_fix_to_chars() */
1077 #endif /* OBJ_AOUT */
1080 md_parse_option (argP
, cntP
, vecP
)
1089 /* Default the values of symbols known that should be "predefined". We
1090 don't bother to predefine them unless you actually use one, since there
1091 are a lot of them. */
1094 md_undefined_symbol (name
)
1098 char testbuf
[5 + /*SLOP*/ 5];
1100 if (name
[0] == 'g' || name
[0] == 'G' || name
[0] == 'l' || name
[0] == 'L')
1102 /* Perhaps a global or local register name */
1103 if (name
[1] == 'r' || name
[1] == 'R')
1105 /* Parse the number, make sure it has no extra zeroes or trailing
1107 regnum
= atol (&name
[2]);
1110 sprintf (testbuf
, "%ld", regnum
);
1111 if (strcmp (testbuf
, &name
[2]) != 0)
1112 return 0; /* gr007 or lr7foo or whatever */
1114 /* We have a wiener! Define and return a new symbol for it. */
1115 if (name
[0] == 'l' || name
[0] == 'L')
1117 return (symbol_new (name
, SEG_REGISTER
, (valueT
) regnum
,
1118 &zero_address_frag
));
1125 /* Parse an operand that is machine-specific. */
1128 md_operand (expressionP
)
1129 expressionS
*expressionP
;
1132 if (input_line_pointer
[0] == '%' && input_line_pointer
[1] == '%')
1134 /* We have a numeric register expression. No biggy. */
1135 input_line_pointer
+= 2; /* Skip %% */
1136 (void) expression (expressionP
);
1137 if (expressionP
->X_op
!= O_constant
1138 || expressionP
->X_add_number
> 255)
1139 as_bad ("Invalid expression after %%%%\n");
1140 expressionP
->X_op
= O_register
;
1142 else if (input_line_pointer
[0] == '&')
1144 /* We are taking the 'address' of a register...this one is not
1145 in the manual, but it *is* in traps/fpsymbol.h! What they
1146 seem to want is the register number, as an absolute number. */
1147 input_line_pointer
++; /* Skip & */
1148 (void) expression (expressionP
);
1149 if (expressionP
->X_op
!= O_register
)
1150 as_bad ("Invalid register in & expression");
1152 expressionP
->X_op
= O_constant
;
1156 /* Round up a section size to the appropriate boundary. */
1158 md_section_align (segment
, size
)
1162 return size
; /* Byte alignment is fine */
1165 /* Exactly what point is a PC-relative offset relative TO?
1166 On the 29000, they're relative to the address of the instruction,
1167 which we have set up as the address of the fixup too. */
1169 md_pcrel_from (fixP
)
1172 return fixP
->fx_where
+ fixP
->fx_frag
->fr_address
;
1181 /* end of tc-a29k.c */