1 /* tc-a29k.c -- Assemble for the AMD 29000.
2 Copyright (C) 1989, 1990, 1991 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. */
26 #include "opcode/a29k.h"
28 /* Make it easier to clone this machine desc into another one. */
29 #define machine_opcode a29k_opcode
30 #define machine_opcodes a29k_opcodes
31 #define machine_ip a29k_ip
32 #define machine_it a29k_it
34 const relax_typeS md_relax_table
[] = { 0 };
36 #define IMMEDIATE_BIT 0x01000000 /* Turns RB into Immediate */
37 #define ABSOLUTE_BIT 0x01000000 /* Turns PC-relative to Absolute */
38 #define CE_BIT 0x00800000 /* Coprocessor enable in LOAD */
39 #define UI_BIT 0x00000080 /* Unsigned integer in CONVERT */
41 /* handle of the OPCODE hash table */
42 static struct hash_control
*op_hash
= NULL
;
50 int reloc_offset
; /* Offset of reloc within insn */
51 enum reloc_type reloc
;
56 /* static int getExpression(char *str); */
57 static void machine_ip(char *str
);
58 /* static void print_insn(struct machine_it *insn); */
59 static void s_data1(void);
60 static void s_use(void);
64 /* static int getExpression(); */
65 static void machine_ip();
66 /* static void print_insn(); */
67 static void s_data1();
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 */
85 int md_short_jump_size
= 4;
86 int md_long_jump_size
= 4;
87 #if defined(BFD_HEADERS)
89 int md_reloc_size
= RELSZ
; /* Coff headers */
91 int md_reloc_size
= 12; /* something else headers */
94 int md_reloc_size
= 12; /* Not bfdized*/
97 /* This array holds the chars that always start a comment. If the
98 pre-processor is disabled, these aren't very useful */
99 char comment_chars
[] = ";";
101 /* This array holds the chars that only start a comment at the beginning of
102 a line. If the line seems to have the form '# 123 filename'
103 .line and .file directives will appear in the pre-processed output */
104 /* Note that input_file.c hand checks for '#' at the beginning of the
105 first line of the input file. This is because the compiler outputs
106 #NO_APP at the beginning of its output. */
107 /* Also note that comments like this one will always work */
108 char line_comment_chars
[] = "#";
110 /* We needed an unused char for line separation to work around the
111 lack of macros, using sed and such. */
112 char line_separator_chars
[] = "@";
114 /* Chars that can be used to separate mant from exp in floating point nums */
115 char EXP_CHARS
[] = "eE";
117 /* Chars that mean this number is a floating point constant */
120 char FLT_CHARS
[] = "rRsSfFdDxXpP";
122 /* Also be aware that MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT may have to be
123 changed in read.c . Ideally it shouldn't have to know about it at all,
124 but nothing is ideal around here.
127 static unsigned char octal
[256];
128 #define isoctal(c) octal[c]
129 static unsigned char toHex
[256];
132 * anull bit - causes the branch delay slot instructions to not be executed
134 #define ANNUL (1 << 29)
140 if (strncmp(input_line_pointer
, ".text", 5) == 0) {
141 input_line_pointer
+= 5;
145 if (strncmp(input_line_pointer
, ".data", 5) == 0) {
146 input_line_pointer
+= 5;
150 if (strncmp(input_line_pointer
, ".data1", 6) == 0) {
151 input_line_pointer
+= 6;
155 /* Literals can't go in the text segment because you can't read
156 from instruction memory on some 29k's. So, into initialized data. */
157 if (strncmp(input_line_pointer
, ".lit", 4) == 0) {
158 input_line_pointer
+= 4;
159 subseg_new(SEG_DATA
, 200);
160 demand_empty_rest_of_line();
164 as_bad("Unknown segment type");
165 demand_empty_rest_of_line();
172 subseg_new(SEG_DATA
, 1);
173 demand_empty_rest_of_line();
177 /* Install symbol definition that maps REGNAME to REGNO.
178 FIXME-SOON: These are not recognized in mixed case. */
181 insert_sreg (regname
, regnum
)
185 /* FIXME-SOON, put something in these syms so they won't be output to the symbol
186 table of the resulting object file. */
188 /* Must be large enough to hold the names of the special registers. */
192 symbol_table_insert(symbol_new(regname
, SEG_REGISTER
, regnum
, &zero_address_frag
));
193 for (i
= 0; regname
[i
]; i
++)
194 buf
[i
] = islower (regname
[i
]) ? toupper (regname
[i
]) : regname
[i
];
197 symbol_table_insert(symbol_new(buf
, SEG_REGISTER
, regnum
, &zero_address_frag
));
198 } /* insert_sreg() */
200 /* Install symbol definitions for assorted special registers.
201 See ASM29K Ref page 2-9. */
203 void define_some_regs() {
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 /* Unprotected special-purpose register names */
224 insert_sreg ("ipc", SREG
+128);
225 insert_sreg ("ipa", SREG
+129);
226 insert_sreg ("ipb", SREG
+130);
227 insert_sreg ("q", SREG
+131);
228 insert_sreg ("alu", SREG
+132);
229 insert_sreg ("bp", SREG
+133);
230 insert_sreg ("fc", SREG
+134);
231 insert_sreg ("cr", SREG
+135);
232 insert_sreg ("fpe", SREG
+160);
233 insert_sreg ("inte",SREG
+161);
234 insert_sreg ("fps", SREG
+162);
235 /* "", SREG+163); Reserved */
236 insert_sreg ("exop",SREG
+164);
237 } /* define_some_regs() */
239 /* This function is called once, at assembler startup time. It should
240 set up all the tables, etc. that the MD part of the assembler will need. */
244 register char *retval
= NULL
;
246 register int skipnext
= 0;
247 register unsigned int i
;
248 register char *strend
, *strend2
;
250 /* Hash up all the opcodes for fast use later. */
252 op_hash
= hash_new();
254 as_fatal("Virtual memory exhausted");
256 for (i
= 0; i
< num_opcodes
; i
++)
258 const char *name
= machine_opcodes
[i
].name
;
265 /* Hack to avoid multiple opcode entries. We pre-locate all the
266 variations (b/i field and P/A field) and handle them. */
268 if (!strcmp (name
, machine_opcodes
[i
+1].name
)) {
269 if ((machine_opcodes
[i
].opcode
^ machine_opcodes
[i
+1].opcode
)
272 strend
= machine_opcodes
[i
].args
+strlen(machine_opcodes
[i
].args
)-1;
273 strend2
= machine_opcodes
[i
+1].args
+strlen(machine_opcodes
[i
+1].args
)-1;
276 if (*strend2
!= 'i') goto bad_table
;
279 if (*strend2
!= 'b') goto bad_table
;
282 if (*strend2
!= 'A') goto bad_table
;
285 if (*strend2
!= 'P') goto bad_table
;
289 fprintf (stderr
, "internal error: can't handle opcode %s\n", name
);
293 /* OK, this is an i/b or A/P pair. We skip the higher-valued one,
294 and let the code for operand checking handle OR-ing in the bit. */
295 if (machine_opcodes
[i
].opcode
& 1)
301 retval
= hash_insert (op_hash
, name
, &machine_opcodes
[i
]);
302 if (retval
!= NULL
&& *retval
!= '\0')
304 fprintf (stderr
, "internal error: can't hash `%s': %s\n",
305 machine_opcodes
[i
].name
, retval
);
311 as_fatal("Broken assembler. No assembly attempted.");
313 for (i
= '0'; i
< '8'; ++i
)
315 for (i
= '0'; i
<= '9'; ++i
)
317 for (i
= 'a'; i
<= 'f'; ++i
)
318 toHex
[i
] = i
+ 10 - 'a';
319 for (i
= 'A'; i
<= 'F'; ++i
)
320 toHex
[i
] = i
+ 10 - 'A';
329 /* Assemble a single instruction. Its label has already been handled
330 by the generic front end. We just parse opcode and operands, and
331 produce the bytes of data and relocation. */
333 void md_assemble(str
)
342 /* put out the opcode */
343 md_number_to_chars(toP
, the_insn
.opcode
, 4);
345 /* put out the symbol-dependent stuff */
346 if (the_insn
.reloc
!= NO_RELOC
) {
348 frag_now
, /* which frag */
349 (toP
- frag_now
->fr_literal
+ the_insn
.reloc_offset
), /* where */
351 the_insn
.exp
.X_add_symbol
,
352 the_insn
.exp
.X_subtract_symbol
,
353 the_insn
.exp
.X_add_number
,
361 parse_operand (s
, operandp
)
363 expressionS
*operandp
;
365 char *save
= input_line_pointer
;
369 input_line_pointer
= s
;
370 seg
= expr (0, operandp
);
371 new = input_line_pointer
;
372 input_line_pointer
= save
;
386 as_bad("Missing operand");
390 as_bad("Don't understand operand of type %s", segment_name (seg
));
395 /* Instruction parsing. Takes a string containing the opcode.
396 Operands are at input_line_pointer. Output is in the_insn.
397 Warnings or errors are generated. */
406 /* !!!! unsigned long i; */
407 struct machine_opcode
*insn
;
409 unsigned long opcode
;
410 /* !!!! unsigned int mask; */
411 expressionS the_operand
;
412 expressionS
*operand
= &the_operand
;
415 /* Must handle `div0' opcode. */
418 for (; isalnum(*s
); ++s
)
426 case ' ': /* FIXME-SOMEDAY more whitespace */
431 as_bad("Unknown opcode: `%s'", str
);
434 if ((insn
= (struct machine_opcode
*) hash_find(op_hash
, str
)) == NULL
) {
435 as_bad("Unknown opcode `%s'.", str
);
439 opcode
= insn
->opcode
;
440 bzero(&the_insn
, sizeof(the_insn
));
441 the_insn
.reloc
= NO_RELOC
;
444 * Build the opcode, checking as we go to make
445 * sure that the operands match.
447 * If an operand matches, we modify the_insn or opcode appropriately,
448 * and do a "continue". If an operand fails to match, we "break".
450 if (insn
->args
[0] != '\0')
451 s
= parse_operand (s
, operand
); /* Prime the pump */
453 for (args
= insn
->args
; ; ++args
) {
456 case '\0': /* end of args */
458 /* We are truly done. */
459 the_insn
.opcode
= opcode
;
462 as_bad("Too many operands: %s", s
);
465 case ',': /* Must match a comma */
467 s
= parse_operand (s
, operand
); /* Parse next opnd */
472 case 'v': /* Trap numbers (immediate field) */
473 if (operand
->X_seg
== SEG_ABSOLUTE
) {
474 if (operand
->X_add_number
< 256) {
475 opcode
|= (operand
->X_add_number
<< 16);
478 as_bad("Immediate value of %d is too large",
479 operand
->X_add_number
);
483 the_insn
.reloc
= RELOC_8
;
484 the_insn
.reloc_offset
= 1; /* BIG-ENDIAN Byte 1 of insn */
485 the_insn
.exp
= *operand
;
488 case 'b': /* A general register or 8-bit immediate */
490 /* We treat the two cases identically since we mashed
491 them together in the opcode table. */
492 if (operand
->X_seg
== SEG_REGISTER
)
495 opcode
|= IMMEDIATE_BIT
;
496 if (operand
->X_seg
== SEG_ABSOLUTE
) {
497 if (operand
->X_add_number
< 256) {
498 opcode
|= operand
->X_add_number
;
501 as_bad("Immediate value of %d is too large",
502 operand
->X_add_number
);
506 the_insn
.reloc
= RELOC_8
;
507 the_insn
.reloc_offset
= 3; /* BIG-ENDIAN Byte 3 of insn */
508 the_insn
.exp
= *operand
;
511 case 'a': /* next operand must be a register */
514 /* lrNNN or grNNN or %%expr or a user-def register name */
515 if (operand
->X_seg
!= SEG_REGISTER
)
516 break; /* Only registers */
517 know (operand
->X_add_symbol
== 0);
518 know (operand
->X_subtract_symbol
== 0);
519 reg
= operand
->X_add_number
;
521 break; /* No special registers */
524 * Got the register, now figure out where
525 * it goes in the opcode.
541 as_fatal("failed sanity check.");
544 case 'x': /* 16 bit constant, zero-extended */
545 case 'X': /* 16 bit constant, one-extended */
546 if (operand
->X_seg
== SEG_ABSOLUTE
) {
547 opcode
|= (operand
->X_add_number
& 0xFF) << 0 |
548 ((operand
->X_add_number
& 0xFF00) << 8);
551 the_insn
.reloc
= RELOC_CONST
;
552 the_insn
.exp
= *operand
;
556 if (operand
->X_seg
== SEG_ABSOLUTE
) {
557 opcode
|= (operand
->X_add_number
& 0x00FF0000) >> 16 |
558 (((unsigned long)operand
->X_add_number
559 /* avoid sign ext */ & 0xFF000000) >> 8);
562 the_insn
.reloc
= RELOC_CONSTH
;
563 the_insn
.exp
= *operand
;
566 case 'P': /* PC-relative jump address */
567 case 'A': /* Absolute jump address */
568 /* These two are treated together since we folded the
569 opcode table entries together. */
570 if (operand
->X_seg
== SEG_ABSOLUTE
) {
571 opcode
|= ABSOLUTE_BIT
|
572 (operand
->X_add_number
& 0x0003FC00) << 6 |
573 ((operand
->X_add_number
& 0x000003FC) >> 2);
576 the_insn
.reloc
= RELOC_JUMPTARG
;
577 the_insn
.exp
= *operand
;
578 the_insn
.pcrel
= 1; /* Assume PC-relative jump */
579 /* FIXME-SOON, Do we figure out whether abs later, after know sym val? */
582 case 'e': /* Coprocessor enable bit for LOAD/STORE insn */
583 if (operand
->X_seg
== SEG_ABSOLUTE
) {
584 if (operand
->X_add_number
== 0)
586 if (operand
->X_add_number
== 1) {
593 case 'n': /* Control bits for LOAD/STORE instructions */
594 if (operand
->X_seg
== SEG_ABSOLUTE
&&
595 operand
->X_add_number
< 128) {
596 opcode
|= (operand
->X_add_number
<< 16);
601 case 's': /* Special register number */
602 if (operand
->X_seg
!= SEG_REGISTER
)
603 break; /* Only registers */
604 if (operand
->X_add_number
< SREG
)
605 break; /* Not a special register */
606 opcode
|= (operand
->X_add_number
& 0xFF) << 8;
609 case 'u': /* UI bit of CONVERT */
610 if (operand
->X_seg
== SEG_ABSOLUTE
) {
611 if (operand
->X_add_number
== 0)
613 if (operand
->X_add_number
== 1) {
620 case 'r': /* RND bits of CONVERT */
621 if (operand
->X_seg
== SEG_ABSOLUTE
&&
622 operand
->X_add_number
< 8) {
623 opcode
|= operand
->X_add_number
<< 4;
628 case 'd': /* FD bits of CONVERT */
629 if (operand
->X_seg
== SEG_ABSOLUTE
&&
630 operand
->X_add_number
< 4) {
631 opcode
|= operand
->X_add_number
<< 2;
637 case 'f': /* FS bits of CONVERT */
638 if (operand
->X_seg
== SEG_ABSOLUTE
&&
639 operand
->X_add_number
< 4) {
640 opcode
|= operand
->X_add_number
<< 0;
646 if (operand
->X_seg
== SEG_ABSOLUTE
&&
647 operand
->X_add_number
< 4) {
648 opcode
|= operand
->X_add_number
<< 16;
654 if (operand
->X_seg
== SEG_ABSOLUTE
&&
655 operand
->X_add_number
< 16) {
656 opcode
|= operand
->X_add_number
<< 18;
664 /* Types or values of args don't match. */
665 as_bad("Invalid operands");
671 This is identical to the md_atof in m68k.c. I think this is right,
674 Turn a string in input_line_pointer into a floating point constant of type
675 type, and store the appropriate bytes in *litP. The number of LITTLENUMS
676 emitted is stored in *sizeP . An error message is returned, or NULL on OK.
679 /* Equal to MAX_PRECISION in atof-ieee.c */
680 #define MAX_LITTLENUMS 6
683 md_atof(type
,litP
,sizeP
)
689 LITTLENUM_TYPE words
[MAX_LITTLENUMS
];
690 LITTLENUM_TYPE
*wordP
;
721 return "Bad call to MD_ATOF()";
723 t
=atof_ieee(input_line_pointer
,type
,words
);
725 input_line_pointer
=t
;
726 *sizeP
=prec
* sizeof(LITTLENUM_TYPE
);
727 for(wordP
=words
;prec
--;) {
728 md_number_to_chars(litP
,(long)(*wordP
++),sizeof(LITTLENUM_TYPE
));
729 litP
+=sizeof(LITTLENUM_TYPE
);
731 return ""; /* Someone should teach Dean about null pointers */
735 * Write out big-endian.
738 md_number_to_chars(buf
,val
,n
)
756 as_fatal("failed sanity check.");
761 void md_apply_fix(fixP
, val
)
765 char *buf
= fixP
->fx_where
+ fixP
->fx_frag
->fr_literal
;
767 fixP
->fx_addnumber
= val
; /* Remember value for emit_reloc */
770 know(fixP
->fx_size
== 4);
771 know(fixP
->fx_r_type
< NO_RELOC
);
774 * This is a hack. There should be a better way to
777 if (fixP
->fx_r_type
== RELOC_WDISP30
&& fixP
->fx_addsy
) {
778 val
+= fixP
->fx_where
+ fixP
->fx_frag
->fr_address
;
781 switch (fixP
->fx_r_type
) {
795 val
= (val
>>= 2) + 1;
796 buf
[0] |= (val
>> 24) & 0x3f;
803 buf
[1] |= (val
>> 26) & 0x3f;
809 buf
[2] |= (val
>> 8) & 0x03;
814 buf
[2] |= (val
>> 8) & 0x1f;
819 val
= (val
>>= 2) + 1;
822 buf
[1] |= (val
>> 16) & 0x3f;
836 case RELOC_JUMPTARG
: /* 00XX00XX pattern in a word */
837 buf
[1] = val
>> 10; /* Holds bits 0003FFFC of address */
841 case RELOC_CONST
: /* 00XX00XX pattern in a word */
842 buf
[1] = val
>> 8; /* Holds bits 0000XXXX */
846 case RELOC_CONSTH
: /* 00XX00XX pattern in a word */
847 buf
[1] = val
>> 24; /* Holds bits XXXX0000 */
853 as_bad("bad relocation type: 0x%02x", fixP
->fx_r_type
);
860 short tc_coff_fix2rtype(fixP
)
864 /* FIXME-NOW: relocation type handling is not yet written for
868 switch (fixP
->fx_r_type
) {
869 case RELOC_32
: return(R_WORD
);
870 case RELOC_8
: return(R_BYTE
);
871 case RELOC_CONST
: return (R_ILOHALF
);
872 case RELOC_CONSTH
: return (R_IHIHALF
);
873 case RELOC_JUMPTARG
: return (R_IREL
);
874 default: printf("need %o3\n", fixP
->fx_r_type
);
876 } /* switch on type */
879 } /* tc_coff_fix2rtype() */
880 #endif /* OBJ_COFF */
882 /* should never be called for sparc */
883 void md_create_short_jump(ptr
, from_addr
, to_addr
, frag
, to_symbol
)
885 long from_addr
, to_addr
;
889 as_fatal("a29k_create_short_jmp\n");
892 /* should never be called for 29k */
893 void md_convert_frag(headers
, fragP
)
894 object_headers
*headers
;
895 register fragS
*fragP
;
897 as_fatal("sparc_convert_frag\n");
900 /* should never be called for 29k */
901 void md_create_long_jump(ptr
, from_addr
, to_addr
, frag
, to_symbol
)
908 as_fatal("sparc_create_long_jump\n");
911 /* should never be called for sparc */
912 int md_estimate_size_before_relax(fragP
, segtype
)
913 register fragS
*fragP
;
916 as_fatal("sparc_estimate_size_before_relax\n");
920 /* for debugging only */
923 struct machine_it
*insn
;
954 fprintf(stderr
, "ERROR: %s\n");
956 fprintf(stderr
, "opcode=0x%08x\n", insn
->opcode
);
957 fprintf(stderr
, "reloc = %s\n", Reloc
[insn
->reloc
]);
958 fprintf(stderr
, "exp = {\n");
959 fprintf(stderr
, "\t\tX_add_symbol = %s\n",
960 insn
->exp
.X_add_symbol
?
961 (S_GET_NAME(insn
->exp
.X_add_symbol
) ?
962 S_GET_NAME(insn
->exp
.X_add_symbol
) : "???") : "0");
963 fprintf(stderr
, "\t\tX_sub_symbol = %s\n",
964 insn
->exp
.X_subtract_symbol
?
965 (S_GET_NAME(insn
->exp
.X_subtract_symbol
) ?
966 S_GET_NAME(insn
->exp
.X_subtract_symbol
) : "???") : "0");
967 fprintf(stderr
, "\t\tX_add_number = %d\n",
968 insn
->exp
.X_add_number
);
969 fprintf(stderr
, "}\n");
974 /* Translate internal representation of relocation info to target format.
976 On sparc/29k: first 4 bytes are normal unsigned long address, next three
977 bytes are index, most sig. byte first. Byte 7 is broken up with
978 bit 7 as external, bits 6 & 5 unused, and the lower
979 five bits as relocation type. Next 4 bytes are long addend. */
980 /* Thanx and a tip of the hat to Michael Bloom, mb@ttidca.tti.com */
984 void tc_aout_fix_to_chars(where
, fixP
, segment_address_in_file
)
987 relax_addressT segment_address_in_file
;
991 know(fixP
->fx_r_type
< NO_RELOC
);
992 know(fixP
->fx_addsy
!= NULL
);
994 r_index
= (S_IS_DEFINED(fixP
->fx_addsy
)
995 ? S_GET_TYPE(fixP
->fx_addsy
)
996 : fixP
->fx_addsy
->sy_number
);
999 md_number_to_chars(where
,
1000 fixP
->fx_frag
->fr_address
+ fixP
->fx_where
- segment_address_in_file
,
1003 /* now the fun stuff */
1004 where
[4] = (r_index
>> 16) & 0x0ff;
1005 where
[5] = (r_index
>> 8) & 0x0ff;
1006 where
[6] = r_index
& 0x0ff;
1007 where
[7] = (((!S_IS_DEFINED(fixP
->fx_addsy
)) << 7) & 0x80) | (0 & 0x60) | (fixP
->fx_r_type
& 0x1F);
1009 md_number_to_chars(&where
[8], fixP
->fx_addnumber
, 4);
1012 } /* tc_aout_fix_to_chars() */
1014 #endif /* OBJ_AOUT */
1017 md_parse_option(argP
,cntP
,vecP
)
1026 /* Default the values of symbols known that should be "predefined". We
1027 don't bother to predefine them unless you actually use one, since there
1028 are a lot of them. */
1030 symbolS
*md_undefined_symbol (name
)
1034 char testbuf
[5+ /*SLOP*/ 5];
1036 if (name
[0] == 'g' || name
[0] == 'G' || name
[0] == 'l' || name
[0] == 'L')
1038 /* Perhaps a global or local register name */
1039 if (name
[1] == 'r' || name
[1] == 'R')
1041 /* Parse the number, make sure it has no extra zeroes or trailing
1043 regnum
= atol(&name
[2]);
1046 sprintf(testbuf
, "%ld", regnum
);
1047 if (strcmp (testbuf
, &name
[2]) != 0)
1048 return 0; /* gr007 or lr7foo or whatever */
1050 /* We have a wiener! Define and return a new symbol for it. */
1051 if (name
[0] == 'l' || name
[0] == 'L')
1053 return(symbol_new(name
, SEG_REGISTER
, regnum
, &zero_address_frag
));
1060 /* Parse an operand that is machine-specific. */
1062 void md_operand(expressionP
)
1063 expressionS
*expressionP
;
1066 if (input_line_pointer
[0] == '%' && input_line_pointer
[1] == '%')
1068 /* We have a numeric register expression. No biggy. */
1069 input_line_pointer
+= 2; /* Skip %% */
1070 (void)expression (expressionP
);
1071 if (expressionP
->X_seg
!= SEG_ABSOLUTE
1072 || expressionP
->X_add_number
> 255)
1073 as_bad("Invalid expression after %%%%\n");
1074 expressionP
->X_seg
= SEG_REGISTER
;
1076 else if (input_line_pointer
[0] == '&')
1078 /* We are taking the 'address' of a register...this one is not
1079 in the manual, but it *is* in traps/fpsymbol.h! What they
1080 seem to want is the register number, as an absolute number. */
1081 input_line_pointer
++; /* Skip & */
1082 (void)expression (expressionP
);
1083 if (expressionP
->X_seg
!= SEG_REGISTER
)
1084 as_bad("Invalid register in & expression");
1086 expressionP
->X_seg
= SEG_ABSOLUTE
;
1090 /* Round up a section size to the appropriate boundary. */
1092 md_section_align (segment
, size
)
1096 return size
; /* Byte alignment is fine */
1099 /* Exactly what point is a PC-relative offset relative TO?
1100 On the 29000, they're relative to the address of the instruction,
1101 which we have set up as the address of the fixup too. */
1102 long md_pcrel_from (fixP
)
1105 return fixP
->fx_where
+ fixP
->fx_frag
->fr_address
;
1114 /* end of tc-a29k.c */