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. */
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. */
28 #include "opcode/a29k.h"
30 /* Make it easier to clone this machine desc into another one. */
31 #define machine_opcode a29k_opcode
32 #define machine_opcodes a29k_opcodes
33 #define machine_ip a29k_ip
34 #define machine_it a29k_it
36 const relax_typeS md_relax_table
[] = { 0 };
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
;
52 int reloc_offset
; /* Offset of reloc within insn */
53 enum reloc_type reloc
;
58 /* static int getExpression(char *str); */
59 static void machine_ip(char *str
);
60 /* static void print_insn(struct machine_it *insn); */
61 static void s_data1(void);
62 static void s_use(void);
66 /* static int getExpression(); */
67 static void machine_ip();
68 /* static void print_insn(); */
69 static void s_data1();
76 { "align", s_align_bytes
, 4 },
77 { "block", s_space
, 0 },
78 { "cputype", s_ignore
, 0 }, /* CPU as 29000 or 29050 */
79 { "line", s_ignore
, 0 }, /* Line number of coff symbol */
80 { "reg", s_lsym
, 0 }, /* Register equate, same as equ */
81 { "space", s_ignore
, 0 }, /* Listing control */
82 { "sect", s_ignore
, 0 }, /* Creation of coff sections */
88 int md_short_jump_size
= 4;
89 int md_long_jump_size
= 4;
90 #if defined(BFD_HEADERS)
92 int md_reloc_size
= RELSZ
; /* Coff headers */
94 int md_reloc_size
= 12; /* something else headers */
97 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 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 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 char line_separator_chars
[] = "@";
117 /* Chars that can be used to separate mant from exp in floating point nums */
118 char EXP_CHARS
[] = "eE";
120 /* Chars that mean this number is a floating point constant */
123 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)
143 if (strncmp(input_line_pointer
, ".text", 5) == 0) {
144 input_line_pointer
+= 5;
148 if (strncmp(input_line_pointer
, ".data", 5) == 0) {
149 input_line_pointer
+= 5;
153 if (strncmp(input_line_pointer
, ".data1", 6) == 0) {
154 input_line_pointer
+= 6;
158 /* Literals can't go in the text segment because you can't read
159 from instruction memory on some 29k's. So, into initialized data. */
160 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. */
206 void define_some_regs() {
209 /* Protected special-purpose register names */
210 insert_sreg ("vab", SREG
+0);
211 insert_sreg ("ops", SREG
+1);
212 insert_sreg ("cps", SREG
+2);
213 insert_sreg ("cfg", SREG
+3);
214 insert_sreg ("cha", SREG
+4);
215 insert_sreg ("chd", SREG
+5);
216 insert_sreg ("chc", SREG
+6);
217 insert_sreg ("rbp", SREG
+7);
218 insert_sreg ("tmc", SREG
+8);
219 insert_sreg ("tmr", SREG
+9);
220 insert_sreg ("pc0", SREG
+10);
221 insert_sreg ("pc1", SREG
+11);
222 insert_sreg ("pc2", SREG
+12);
223 insert_sreg ("mmu", SREG
+13);
224 insert_sreg ("lru", SREG
+14);
226 /* Unprotected special-purpose register names */
227 insert_sreg ("ipc", SREG
+128);
228 insert_sreg ("ipa", SREG
+129);
229 insert_sreg ("ipb", SREG
+130);
230 insert_sreg ("q", SREG
+131);
231 insert_sreg ("alu", SREG
+132);
232 insert_sreg ("bp", SREG
+133);
233 insert_sreg ("fc", SREG
+134);
234 insert_sreg ("cr", SREG
+135);
235 insert_sreg ("fpe", SREG
+160);
236 insert_sreg ("inte",SREG
+161);
237 insert_sreg ("fps", SREG
+162);
238 /* "", SREG+163); Reserved */
239 insert_sreg ("exop",SREG
+164);
240 } /* define_some_regs() */
242 /* This function is called once, at assembler startup time. It should
243 set up all the tables, etc. that the MD part of the assembler will need. */
247 register char *retval
= NULL
;
249 register int skipnext
= 0;
250 register unsigned int i
;
251 register char *strend
, *strend2
;
253 /* Hash up all the opcodes for fast use later. */
255 op_hash
= hash_new();
257 as_fatal("Virtual memory exhausted");
259 for (i
= 0; i
< num_opcodes
; i
++)
261 const char *name
= machine_opcodes
[i
].name
;
268 /* Hack to avoid multiple opcode entries. We pre-locate all the
269 variations (b/i field and P/A field) and handle them. */
271 if (!strcmp (name
, machine_opcodes
[i
+1].name
)) {
272 if ((machine_opcodes
[i
].opcode
^ machine_opcodes
[i
+1].opcode
)
275 strend
= machine_opcodes
[i
].args
+strlen(machine_opcodes
[i
].args
)-1;
276 strend2
= machine_opcodes
[i
+1].args
+strlen(machine_opcodes
[i
+1].args
)-1;
279 if (*strend2
!= 'i') goto bad_table
;
282 if (*strend2
!= 'b') goto bad_table
;
285 if (*strend2
!= 'A') goto bad_table
;
288 if (*strend2
!= 'P') goto bad_table
;
292 fprintf (stderr
, "internal error: can't handle opcode %s\n", name
);
296 /* OK, this is an i/b or A/P pair. We skip the higher-valued one,
297 and let the code for operand checking handle OR-ing in the bit. */
298 if (machine_opcodes
[i
].opcode
& 1)
304 retval
= hash_insert (op_hash
, name
, &machine_opcodes
[i
]);
305 if (retval
!= NULL
&& *retval
!= '\0')
307 fprintf (stderr
, "internal error: can't hash `%s': %s\n",
308 machine_opcodes
[i
].name
, retval
);
314 as_fatal("Broken assembler. No assembly attempted.");
316 for (i
= '0'; i
< '8'; ++i
)
318 for (i
= '0'; i
<= '9'; ++i
)
320 for (i
= 'a'; i
<= 'f'; ++i
)
321 toHex
[i
] = i
+ 10 - 'a';
322 for (i
= 'A'; i
<= 'F'; ++i
)
323 toHex
[i
] = i
+ 10 - 'A';
332 /* Assemble a single instruction. Its label has already been handled
333 by the generic front end. We just parse opcode and operands, and
334 produce the bytes of data and relocation. */
336 void md_assemble(str
)
345 /* put out the opcode */
346 md_number_to_chars(toP
, the_insn
.opcode
, 4);
348 /* put out the symbol-dependent stuff */
349 if (the_insn
.reloc
!= NO_RELOC
) {
351 frag_now
, /* which frag */
352 (toP
- frag_now
->fr_literal
+ the_insn
.reloc_offset
), /* where */
354 the_insn
.exp
.X_add_symbol
,
355 the_insn
.exp
.X_subtract_symbol
,
356 the_insn
.exp
.X_add_number
,
364 parse_operand (s
, operandp
)
366 expressionS
*operandp
;
368 char *save
= input_line_pointer
;
372 input_line_pointer
= s
;
373 seg
= expr (0, operandp
);
374 new = input_line_pointer
;
375 input_line_pointer
= save
;
389 as_bad("Missing operand");
393 as_bad("Don't understand operand of type %s", segment_name (seg
));
398 /* Instruction parsing. Takes a string containing the opcode.
399 Operands are at input_line_pointer. Output is in the_insn.
400 Warnings or errors are generated. */
409 /* !!!! unsigned long i; */
410 struct machine_opcode
*insn
;
412 unsigned long opcode
;
413 /* !!!! unsigned int mask; */
414 expressionS the_operand
;
415 expressionS
*operand
= &the_operand
;
418 /* Must handle `div0' opcode. */
421 for (; isalnum(*s
); ++s
)
429 case ' ': /* FIXME-SOMEDAY more whitespace */
434 as_bad("Unknown opcode: `%s'", str
);
437 if ((insn
= (struct machine_opcode
*) hash_find(op_hash
, str
)) == NULL
) {
438 as_bad("Unknown opcode `%s'.", str
);
442 opcode
= insn
->opcode
;
443 bzero(&the_insn
, sizeof(the_insn
));
444 the_insn
.reloc
= NO_RELOC
;
447 * Build the opcode, checking as we go to make
448 * sure that the operands match.
450 * If an operand matches, we modify the_insn or opcode appropriately,
451 * and do a "continue". If an operand fails to match, we "break".
453 if (insn
->args
[0] != '\0')
454 s
= parse_operand (s
, operand
); /* Prime the pump */
456 for (args
= insn
->args
; ; ++args
) {
459 case '\0': /* end of args */
461 /* We are truly done. */
462 the_insn
.opcode
= opcode
;
465 as_bad("Too many operands: %s", s
);
468 case ',': /* Must match a comma */
470 s
= parse_operand (s
, operand
); /* Parse next opnd */
475 case 'v': /* Trap numbers (immediate field) */
476 if (operand
->X_seg
== SEG_ABSOLUTE
) {
477 if (operand
->X_add_number
< 256) {
478 opcode
|= (operand
->X_add_number
<< 16);
481 as_bad("Immediate value of %d is too large",
482 operand
->X_add_number
);
486 the_insn
.reloc
= RELOC_8
;
487 the_insn
.reloc_offset
= 1; /* BIG-ENDIAN Byte 1 of insn */
488 the_insn
.exp
= *operand
;
491 case 'b': /* A general register or 8-bit immediate */
493 /* We treat the two cases identically since we mashed
494 them together in the opcode table. */
495 if (operand
->X_seg
== SEG_REGISTER
)
498 opcode
|= IMMEDIATE_BIT
;
499 if (operand
->X_seg
== SEG_ABSOLUTE
) {
500 if (operand
->X_add_number
< 256) {
501 opcode
|= operand
->X_add_number
;
504 as_bad("Immediate value of %d is too large",
505 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_seg
!= SEG_REGISTER
)
519 break; /* Only registers */
520 know (operand
->X_add_symbol
== 0);
521 know (operand
->X_subtract_symbol
== 0);
522 reg
= operand
->X_add_number
;
524 break; /* No special registers */
527 * Got the register, now figure out where
528 * it goes in the opcode.
544 as_fatal("failed sanity check.");
547 case 'x': /* 16 bit constant, zero-extended */
548 case 'X': /* 16 bit constant, one-extended */
549 if (operand
->X_seg
== SEG_ABSOLUTE
) {
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_seg
== SEG_ABSOLUTE
) {
560 opcode
|= (operand
->X_add_number
& 0x00FF0000) >> 16 |
561 (((unsigned long)operand
->X_add_number
562 /* avoid sign ext */ & 0xFF000000) >> 8);
565 the_insn
.reloc
= RELOC_CONSTH
;
566 the_insn
.exp
= *operand
;
569 case 'P': /* PC-relative jump address */
570 case 'A': /* Absolute jump address */
571 /* These two are treated together since we folded the
572 opcode table entries together. */
573 if (operand
->X_seg
== SEG_ABSOLUTE
) {
574 opcode
|= ABSOLUTE_BIT
|
575 (operand
->X_add_number
& 0x0003FC00) << 6 |
576 ((operand
->X_add_number
& 0x000003FC) >> 2);
579 the_insn
.reloc
= RELOC_JUMPTARG
;
580 the_insn
.exp
= *operand
;
581 the_insn
.pcrel
= 1; /* Assume PC-relative jump */
582 /* FIXME-SOON, Do we figure out whether abs later, after know sym val? */
585 case 'e': /* Coprocessor enable bit for LOAD/STORE insn */
586 if (operand
->X_seg
== SEG_ABSOLUTE
) {
587 if (operand
->X_add_number
== 0)
589 if (operand
->X_add_number
== 1) {
596 case 'n': /* Control bits for LOAD/STORE instructions */
597 if (operand
->X_seg
== SEG_ABSOLUTE
&&
598 operand
->X_add_number
< 128) {
599 opcode
|= (operand
->X_add_number
<< 16);
604 case 's': /* Special register number */
605 if (operand
->X_seg
!= SEG_REGISTER
)
606 break; /* Only registers */
607 if (operand
->X_add_number
< SREG
)
608 break; /* Not a special register */
609 opcode
|= (operand
->X_add_number
& 0xFF) << 8;
612 case 'u': /* UI bit of CONVERT */
613 if (operand
->X_seg
== SEG_ABSOLUTE
) {
614 if (operand
->X_add_number
== 0)
616 if (operand
->X_add_number
== 1) {
623 case 'r': /* RND bits of CONVERT */
624 if (operand
->X_seg
== SEG_ABSOLUTE
&&
625 operand
->X_add_number
< 8) {
626 opcode
|= operand
->X_add_number
<< 4;
631 case 'd': /* FD bits of CONVERT */
632 if (operand
->X_seg
== SEG_ABSOLUTE
&&
633 operand
->X_add_number
< 4) {
634 opcode
|= operand
->X_add_number
<< 2;
640 case 'f': /* FS bits of CONVERT */
641 if (operand
->X_seg
== SEG_ABSOLUTE
&&
642 operand
->X_add_number
< 4) {
643 opcode
|= operand
->X_add_number
<< 0;
649 if (operand
->X_seg
== SEG_ABSOLUTE
&&
650 operand
->X_add_number
< 4) {
651 opcode
|= operand
->X_add_number
<< 16;
657 if (operand
->X_seg
== SEG_ABSOLUTE
&&
658 operand
->X_add_number
< 16) {
659 opcode
|= operand
->X_add_number
<< 18;
667 /* Types or values of args don't match. */
668 as_bad("Invalid operands");
674 This is identical to the md_atof in m68k.c. I think this is right,
677 Turn a string in input_line_pointer into a floating point constant of type
678 type, and store the appropriate bytes in *litP. The number of LITTLENUMS
679 emitted is stored in *sizeP . An error message is returned, or NULL on OK.
682 /* Equal to MAX_PRECISION in atof-ieee.c */
683 #define MAX_LITTLENUMS 6
686 md_atof(type
,litP
,sizeP
)
692 LITTLENUM_TYPE words
[MAX_LITTLENUMS
];
693 LITTLENUM_TYPE
*wordP
;
724 return "Bad call to MD_ATOF()";
726 t
=atof_ieee(input_line_pointer
,type
,words
);
728 input_line_pointer
=t
;
729 *sizeP
=prec
* sizeof(LITTLENUM_TYPE
);
730 for(wordP
=words
;prec
--;) {
731 md_number_to_chars(litP
,(long)(*wordP
++),sizeof(LITTLENUM_TYPE
));
732 litP
+=sizeof(LITTLENUM_TYPE
);
734 return ""; /* Someone should teach Dean about null pointers */
738 * Write out big-endian.
741 md_number_to_chars(buf
,val
,n
)
759 as_fatal("failed sanity check.");
764 void md_apply_fix(fixP
, val
)
768 char *buf
= fixP
->fx_where
+ fixP
->fx_frag
->fr_literal
;
770 fixP
->fx_addnumber
= val
; /* Remember value for emit_reloc */
773 know(fixP
->fx_size
== 4);
774 know(fixP
->fx_r_type
< NO_RELOC
);
777 * This is a hack. There should be a better way to
780 if (fixP
->fx_r_type
== RELOC_WDISP30
&& fixP
->fx_addsy
) {
781 val
+= fixP
->fx_where
+ fixP
->fx_frag
->fr_address
;
784 switch (fixP
->fx_r_type
) {
798 val
= (val
>>= 2) + 1;
799 buf
[0] |= (val
>> 24) & 0x3f;
806 buf
[1] |= (val
>> 26) & 0x3f;
812 buf
[2] |= (val
>> 8) & 0x03;
817 buf
[2] |= (val
>> 8) & 0x1f;
822 val
= (val
>>= 2) + 1;
825 buf
[1] |= (val
>> 16) & 0x3f;
839 case RELOC_JUMPTARG
: /* 00XX00XX pattern in a word */
840 buf
[1] = val
>> 10; /* Holds bits 0003FFFC of address */
844 case RELOC_CONST
: /* 00XX00XX pattern in a word */
845 buf
[1] = val
>> 8; /* Holds bits 0000XXXX */
849 case RELOC_CONSTH
: /* 00XX00XX pattern in a word */
850 buf
[1] = val
>> 24; /* Holds bits XXXX0000 */
856 as_bad("bad relocation type: 0x%02x", fixP
->fx_r_type
);
863 short tc_coff_fix2rtype(fixP
)
867 /* FIXME-NOW: relocation type handling is not yet written for
871 switch (fixP
->fx_r_type
) {
872 case RELOC_32
: return(R_WORD
);
873 case RELOC_8
: return(R_BYTE
);
874 case RELOC_CONST
: return (R_ILOHALF
);
875 case RELOC_CONSTH
: return (R_IHIHALF
);
876 case RELOC_JUMPTARG
: return (R_IREL
);
877 default: printf("need %o3\n", fixP
->fx_r_type
);
879 } /* switch on type */
882 } /* tc_coff_fix2rtype() */
883 #endif /* OBJ_COFF */
885 /* should never be called for sparc */
886 void md_create_short_jump(ptr
, from_addr
, to_addr
, frag
, to_symbol
)
888 long from_addr
, to_addr
;
892 as_fatal("a29k_create_short_jmp\n");
895 /* should never be called for 29k */
896 void md_convert_frag(headers
, fragP
)
897 object_headers
*headers
;
898 register fragS
*fragP
;
900 as_fatal("sparc_convert_frag\n");
903 /* should never be called for 29k */
904 void md_create_long_jump(ptr
, from_addr
, to_addr
, frag
, to_symbol
)
911 as_fatal("sparc_create_long_jump\n");
914 /* should never be called for sparc */
915 int md_estimate_size_before_relax(fragP
, segtype
)
916 register fragS
*fragP
;
919 as_fatal("sparc_estimate_size_before_relax\n");
923 /* for debugging only */
926 struct machine_it
*insn
;
957 fprintf(stderr
, "ERROR: %s\n");
959 fprintf(stderr
, "opcode=0x%08x\n", insn
->opcode
);
960 fprintf(stderr
, "reloc = %s\n", Reloc
[insn
->reloc
]);
961 fprintf(stderr
, "exp = {\n");
962 fprintf(stderr
, "\t\tX_add_symbol = %s\n",
963 insn
->exp
.X_add_symbol
?
964 (S_GET_NAME(insn
->exp
.X_add_symbol
) ?
965 S_GET_NAME(insn
->exp
.X_add_symbol
) : "???") : "0");
966 fprintf(stderr
, "\t\tX_sub_symbol = %s\n",
967 insn
->exp
.X_subtract_symbol
?
968 (S_GET_NAME(insn
->exp
.X_subtract_symbol
) ?
969 S_GET_NAME(insn
->exp
.X_subtract_symbol
) : "???") : "0");
970 fprintf(stderr
, "\t\tX_add_number = %d\n",
971 insn
->exp
.X_add_number
);
972 fprintf(stderr
, "}\n");
977 /* Translate internal representation of relocation info to target format.
979 On sparc/29k: first 4 bytes are normal unsigned long address, next three
980 bytes are index, most sig. byte first. Byte 7 is broken up with
981 bit 7 as external, bits 6 & 5 unused, and the lower
982 five bits as relocation type. Next 4 bytes are long addend. */
983 /* Thanx and a tip of the hat to Michael Bloom, mb@ttidca.tti.com */
987 void tc_aout_fix_to_chars(where
, fixP
, segment_address_in_file
)
990 relax_addressT segment_address_in_file
;
994 know(fixP
->fx_r_type
< NO_RELOC
);
995 know(fixP
->fx_addsy
!= NULL
);
997 r_index
= (S_IS_DEFINED(fixP
->fx_addsy
)
998 ? S_GET_TYPE(fixP
->fx_addsy
)
999 : fixP
->fx_addsy
->sy_number
);
1002 md_number_to_chars(where
,
1003 fixP
->fx_frag
->fr_address
+ fixP
->fx_where
- segment_address_in_file
,
1006 /* now the fun stuff */
1007 where
[4] = (r_index
>> 16) & 0x0ff;
1008 where
[5] = (r_index
>> 8) & 0x0ff;
1009 where
[6] = r_index
& 0x0ff;
1010 where
[7] = (((!S_IS_DEFINED(fixP
->fx_addsy
)) << 7) & 0x80) | (0 & 0x60) | (fixP
->fx_r_type
& 0x1F);
1012 md_number_to_chars(&where
[8], fixP
->fx_addnumber
, 4);
1015 } /* tc_aout_fix_to_chars() */
1017 #endif /* OBJ_AOUT */
1020 md_parse_option(argP
,cntP
,vecP
)
1029 /* Default the values of symbols known that should be "predefined". We
1030 don't bother to predefine them unless you actually use one, since there
1031 are a lot of them. */
1033 symbolS
*md_undefined_symbol (name
)
1037 char testbuf
[5+ /*SLOP*/ 5];
1039 if (name
[0] == 'g' || name
[0] == 'G' || name
[0] == 'l' || name
[0] == 'L')
1041 /* Perhaps a global or local register name */
1042 if (name
[1] == 'r' || name
[1] == 'R')
1044 /* Parse the number, make sure it has no extra zeroes or trailing
1046 regnum
= atol(&name
[2]);
1049 sprintf(testbuf
, "%ld", regnum
);
1050 if (strcmp (testbuf
, &name
[2]) != 0)
1051 return 0; /* gr007 or lr7foo or whatever */
1053 /* We have a wiener! Define and return a new symbol for it. */
1054 if (name
[0] == 'l' || name
[0] == 'L')
1056 return(symbol_new(name
, SEG_REGISTER
, regnum
, &zero_address_frag
));
1063 /* Parse an operand that is machine-specific. */
1065 void md_operand(expressionP
)
1066 expressionS
*expressionP
;
1069 if (input_line_pointer
[0] == '%' && input_line_pointer
[1] == '%')
1071 /* We have a numeric register expression. No biggy. */
1072 input_line_pointer
+= 2; /* Skip %% */
1073 (void)expression (expressionP
);
1074 if (expressionP
->X_seg
!= SEG_ABSOLUTE
1075 || expressionP
->X_add_number
> 255)
1076 as_bad("Invalid expression after %%%%\n");
1077 expressionP
->X_seg
= SEG_REGISTER
;
1079 else if (input_line_pointer
[0] == '&')
1081 /* We are taking the 'address' of a register...this one is not
1082 in the manual, but it *is* in traps/fpsymbol.h! What they
1083 seem to want is the register number, as an absolute number. */
1084 input_line_pointer
++; /* Skip & */
1085 (void)expression (expressionP
);
1086 if (expressionP
->X_seg
!= SEG_REGISTER
)
1087 as_bad("Invalid register in & expression");
1089 expressionP
->X_seg
= SEG_ABSOLUTE
;
1093 /* Round up a section size to the appropriate boundary. */
1095 md_section_align (segment
, size
)
1099 return size
; /* Byte alignment is fine */
1102 /* Exactly what point is a PC-relative offset relative TO?
1103 On the 29000, they're relative to the address of the instruction,
1104 which we have set up as the address of the fixup too. */
1105 long md_pcrel_from (fixP
)
1108 return fixP
->fx_where
+ fixP
->fx_frag
->fr_address
;
1117 /* end of tc-a29k.c */