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 "a29k-opcode.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 { "file", s_ignore
, 0 }, /* COFF File name for debug info? */
80 { "line", s_ignore
, 0 }, /* Line number of coff symbol */
81 { "reg", s_lsym
, 0 }, /* Register equate, same as equ */
82 { "space", s_ignore
, 0 }, /* Listing control */
83 { "sect", s_ignore
, 0 }, /* Creation of coff sections */
89 int md_short_jump_size
= 4;
90 int md_long_jump_size
= 4;
91 #if defined(BFD_HEADERS)
93 int md_reloc_size
= RELSZ
; /* Coff headers */
95 int md_reloc_size
= 12; /* something else headers */
98 int md_reloc_size
= 12; /* Not bfdized*/
101 /* This array holds the chars that always start a comment. If the
102 pre-processor is disabled, these aren't very useful */
103 char comment_chars
[] = ";";
105 /* This array holds the chars that only start a comment at the beginning of
106 a line. If the line seems to have the form '# 123 filename'
107 .line and .file directives will appear in the pre-processed output */
108 /* Note that input_file.c hand checks for '#' at the beginning of the
109 first line of the input file. This is because the compiler outputs
110 #NO_APP at the beginning of its output. */
111 /* Also note that comments like this one will always work */
112 char line_comment_chars
[] = "#";
114 /* We needed an unused char for line separation to work around the
115 lack of macros, using sed and such. */
116 char line_separator_chars
[] = "@";
118 /* Chars that can be used to separate mant from exp in floating point nums */
119 char EXP_CHARS
[] = "eE";
121 /* Chars that mean this number is a floating point constant */
124 char FLT_CHARS
[] = "rRsSfFdDxXpP";
126 /* Also be aware that MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT may have to be
127 changed in read.c . Ideally it shouldn't have to know about it at all,
128 but nothing is ideal around here.
131 static unsigned char octal
[256];
132 #define isoctal(c) octal[c]
133 static unsigned char toHex
[256];
136 * anull bit - causes the branch delay slot instructions to not be executed
138 #define ANNUL (1 << 29)
144 if (strncmp(input_line_pointer
, ".text", 5) == 0) {
145 input_line_pointer
+= 5;
149 if (strncmp(input_line_pointer
, ".data", 5) == 0) {
150 input_line_pointer
+= 5;
154 if (strncmp(input_line_pointer
, ".data1", 6) == 0) {
155 input_line_pointer
+= 6;
159 /* Literals can't go in the text segment because you can't read
160 from instruction memory on some 29k's. So, into initialized data. */
161 if (strncmp(input_line_pointer
, ".lit", 4) == 0) {
162 input_line_pointer
+= 4;
163 subseg_new(SEG_DATA
, 200);
164 demand_empty_rest_of_line();
168 as_bad("Unknown segment type");
169 demand_empty_rest_of_line();
176 subseg_new(SEG_DATA
, 1);
177 demand_empty_rest_of_line();
181 /* Install symbol definition that maps REGNAME to REGNO.
182 FIXME-SOON: These are not recognized in mixed case. */
185 insert_sreg (regname
, regnum
)
189 /* FIXME-SOON, put something in these syms so they won't be output to the symbol
190 table of the resulting object file. */
192 /* Must be large enough to hold the names of the special registers. */
196 symbol_table_insert(symbol_new(regname
, SEG_REGISTER
, regnum
, &zero_address_frag
));
197 for (i
= 0; regname
[i
]; i
++)
198 buf
[i
] = islower (regname
[i
]) ? toupper (regname
[i
]) : regname
[i
];
201 symbol_table_insert(symbol_new(buf
, SEG_REGISTER
, regnum
, &zero_address_frag
));
202 } /* insert_sreg() */
204 /* Install symbol definitions for assorted special registers.
205 See ASM29K Ref page 2-9. */
207 void define_some_regs() {
210 /* Protected special-purpose register names */
211 insert_sreg ("vab", SREG
+0);
212 insert_sreg ("ops", SREG
+1);
213 insert_sreg ("cps", SREG
+2);
214 insert_sreg ("cfg", SREG
+3);
215 insert_sreg ("cha", SREG
+4);
216 insert_sreg ("chd", SREG
+5);
217 insert_sreg ("chc", SREG
+6);
218 insert_sreg ("rbp", SREG
+7);
219 insert_sreg ("tmc", SREG
+8);
220 insert_sreg ("tmr", SREG
+9);
221 insert_sreg ("pc0", SREG
+10);
222 insert_sreg ("pc1", SREG
+11);
223 insert_sreg ("pc2", SREG
+12);
224 insert_sreg ("mmu", SREG
+13);
225 insert_sreg ("lru", SREG
+14);
227 /* Unprotected special-purpose register names */
228 insert_sreg ("ipc", SREG
+128);
229 insert_sreg ("ipa", SREG
+129);
230 insert_sreg ("ipb", SREG
+130);
231 insert_sreg ("q", SREG
+131);
232 insert_sreg ("alu", SREG
+132);
233 insert_sreg ("bp", SREG
+133);
234 insert_sreg ("fc", SREG
+134);
235 insert_sreg ("cr", SREG
+135);
236 insert_sreg ("fpe", SREG
+160);
237 insert_sreg ("inte",SREG
+161);
238 insert_sreg ("fps", SREG
+162);
239 /* "", SREG+163); Reserved */
240 insert_sreg ("exop",SREG
+164);
241 } /* define_some_regs() */
243 /* This function is called once, at assembler startup time. It should
244 set up all the tables, etc. that the MD part of the assembler will need. */
248 register char *retval
= NULL
;
250 register int skipnext
= 0;
251 register unsigned int i
;
252 register char *strend
, *strend2
;
254 /* Hash up all the opcodes for fast use later. */
256 op_hash
= hash_new();
258 as_fatal("Virtual memory exhausted");
260 for (i
= 0; i
< num_opcodes
; i
++)
262 const char *name
= machine_opcodes
[i
].name
;
269 /* Hack to avoid multiple opcode entries. We pre-locate all the
270 variations (b/i field and P/A field) and handle them. */
272 if (!strcmp (name
, machine_opcodes
[i
+1].name
)) {
273 if ((machine_opcodes
[i
].opcode
^ machine_opcodes
[i
+1].opcode
)
276 strend
= machine_opcodes
[i
].args
+strlen(machine_opcodes
[i
].args
)-1;
277 strend2
= machine_opcodes
[i
+1].args
+strlen(machine_opcodes
[i
+1].args
)-1;
280 if (*strend2
!= 'i') goto bad_table
;
283 if (*strend2
!= 'b') goto bad_table
;
286 if (*strend2
!= 'A') goto bad_table
;
289 if (*strend2
!= 'P') goto bad_table
;
293 fprintf (stderr
, "internal error: can't handle opcode %s\n", name
);
297 /* OK, this is an i/b or A/P pair. We skip the higher-valued one,
298 and let the code for operand checking handle OR-ing in the bit. */
299 if (machine_opcodes
[i
].opcode
& 1)
305 retval
= hash_insert (op_hash
, name
, &machine_opcodes
[i
]);
306 if (retval
!= NULL
&& *retval
!= '\0')
308 fprintf (stderr
, "internal error: can't hash `%s': %s\n",
309 machine_opcodes
[i
].name
, retval
);
315 as_fatal("Broken assembler. No assembly attempted.");
317 for (i
= '0'; i
< '8'; ++i
)
319 for (i
= '0'; i
<= '9'; ++i
)
321 for (i
= 'a'; i
<= 'f'; ++i
)
322 toHex
[i
] = i
+ 10 - 'a';
323 for (i
= 'A'; i
<= 'F'; ++i
)
324 toHex
[i
] = i
+ 10 - 'A';
333 /* Assemble a single instruction. Its label has already been handled
334 by the generic front end. We just parse opcode and operands, and
335 produce the bytes of data and relocation. */
337 void md_assemble(str
)
346 /* put out the opcode */
347 md_number_to_chars(toP
, the_insn
.opcode
, 4);
349 /* put out the symbol-dependent stuff */
350 if (the_insn
.reloc
!= NO_RELOC
) {
352 frag_now
, /* which frag */
353 (toP
- frag_now
->fr_literal
+ the_insn
.reloc_offset
), /* where */
355 the_insn
.exp
.X_add_symbol
,
356 the_insn
.exp
.X_subtract_symbol
,
357 the_insn
.exp
.X_add_number
,
365 parse_operand (s
, operandp
)
367 expressionS
*operandp
;
369 char *save
= input_line_pointer
;
373 input_line_pointer
= s
;
374 seg
= expr (0, operandp
);
375 new = input_line_pointer
;
376 input_line_pointer
= save
;
390 as_bad("Missing operand");
394 as_bad("Don't understand operand of type %s", segment_name (seg
));
399 /* Instruction parsing. Takes a string containing the opcode.
400 Operands are at input_line_pointer. Output is in the_insn.
401 Warnings or errors are generated. */
410 /* !!!! unsigned long i; */
411 struct machine_opcode
*insn
;
413 unsigned long opcode
;
414 /* !!!! unsigned int mask; */
415 expressionS the_operand
;
416 expressionS
*operand
= &the_operand
;
419 /* Must handle `div0' opcode. */
422 for (; isalnum(*s
); ++s
)
430 case ' ': /* FIXME-SOMEDAY more whitespace */
435 as_bad("Unknown opcode: `%s'", str
);
438 if ((insn
= (struct machine_opcode
*) hash_find(op_hash
, str
)) == NULL
) {
439 as_bad("Unknown opcode `%s'.", str
);
443 opcode
= insn
->opcode
;
444 bzero(&the_insn
, sizeof(the_insn
));
445 the_insn
.reloc
= NO_RELOC
;
448 * Build the opcode, checking as we go to make
449 * sure that the operands match.
451 * If an operand matches, we modify the_insn or opcode appropriately,
452 * and do a "continue". If an operand fails to match, we "break".
454 if (insn
->args
[0] != '\0')
455 s
= parse_operand (s
, operand
); /* Prime the pump */
457 for (args
= insn
->args
; ; ++args
) {
460 case '\0': /* end of args */
462 /* We are truly done. */
463 the_insn
.opcode
= opcode
;
466 as_bad("Too many operands: %s", s
);
469 case ',': /* Must match a comma */
471 s
= parse_operand (s
, operand
); /* Parse next opnd */
476 case 'v': /* Trap numbers (immediate field) */
477 if (operand
->X_seg
== SEG_ABSOLUTE
) {
478 if (operand
->X_add_number
< 256) {
479 opcode
|= (operand
->X_add_number
<< 16);
482 as_bad("Immediate value of %d is too large",
483 operand
->X_add_number
);
487 the_insn
.reloc
= RELOC_8
;
488 the_insn
.reloc_offset
= 1; /* BIG-ENDIAN Byte 1 of insn */
489 the_insn
.exp
= *operand
;
492 case 'b': /* A general register or 8-bit immediate */
494 /* We treat the two cases identically since we mashed
495 them together in the opcode table. */
496 if (operand
->X_seg
== SEG_REGISTER
)
499 opcode
|= IMMEDIATE_BIT
;
500 if (operand
->X_seg
== SEG_ABSOLUTE
) {
501 if (operand
->X_add_number
< 256) {
502 opcode
|= operand
->X_add_number
;
505 as_bad("Immediate value of %d is too large",
506 operand
->X_add_number
);
510 the_insn
.reloc
= RELOC_8
;
511 the_insn
.reloc_offset
= 3; /* BIG-ENDIAN Byte 3 of insn */
512 the_insn
.exp
= *operand
;
515 case 'a': /* next operand must be a register */
518 /* lrNNN or grNNN or %%expr or a user-def register name */
519 if (operand
->X_seg
!= SEG_REGISTER
)
520 break; /* Only registers */
521 know (operand
->X_add_symbol
== 0);
522 know (operand
->X_subtract_symbol
== 0);
523 reg
= operand
->X_add_number
;
525 break; /* No special registers */
528 * Got the register, now figure out where
529 * it goes in the opcode.
545 as_fatal("failed sanity check.");
548 case 'x': /* 16 bit constant, zero-extended */
549 case 'X': /* 16 bit constant, one-extended */
550 if (operand
->X_seg
== SEG_ABSOLUTE
) {
551 opcode
|= (operand
->X_add_number
& 0xFF) << 0 |
552 ((operand
->X_add_number
& 0xFF00) << 8);
555 the_insn
.reloc
= RELOC_CONST
;
556 the_insn
.exp
= *operand
;
560 if (operand
->X_seg
== SEG_ABSOLUTE
) {
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_seg
== SEG_ABSOLUTE
) {
575 opcode
|= ABSOLUTE_BIT
|
576 (operand
->X_add_number
& 0x0003FC00) << 6 |
577 ((operand
->X_add_number
& 0x000003FC) >> 2);
580 the_insn
.reloc
= RELOC_JUMPTARG
;
581 the_insn
.exp
= *operand
;
582 the_insn
.pcrel
= 1; /* Assume PC-relative jump */
583 /* FIXME-SOON, Do we figure out whether abs later, after know sym val? */
586 case 'e': /* Coprocessor enable bit for LOAD/STORE insn */
587 if (operand
->X_seg
== SEG_ABSOLUTE
) {
588 if (operand
->X_add_number
== 0)
590 if (operand
->X_add_number
== 1) {
597 case 'n': /* Control bits for LOAD/STORE instructions */
598 if (operand
->X_seg
== SEG_ABSOLUTE
&&
599 operand
->X_add_number
< 128) {
600 opcode
|= (operand
->X_add_number
<< 16);
605 case 's': /* Special register number */
606 if (operand
->X_seg
!= SEG_REGISTER
)
607 break; /* Only registers */
608 if (operand
->X_add_number
< SREG
)
609 break; /* Not a special register */
610 opcode
|= (operand
->X_add_number
& 0xFF) << 8;
613 case 'u': /* UI bit of CONVERT */
614 if (operand
->X_seg
== SEG_ABSOLUTE
) {
615 if (operand
->X_add_number
== 0)
617 if (operand
->X_add_number
== 1) {
624 case 'r': /* RND bits of CONVERT */
625 if (operand
->X_seg
== SEG_ABSOLUTE
&&
626 operand
->X_add_number
< 8) {
627 opcode
|= operand
->X_add_number
<< 4;
632 case 'd': /* FD bits of CONVERT */
633 if (operand
->X_seg
== SEG_ABSOLUTE
&&
634 operand
->X_add_number
< 4) {
635 opcode
|= operand
->X_add_number
<< 2;
641 case 'f': /* FS bits of CONVERT */
642 if (operand
->X_seg
== SEG_ABSOLUTE
&&
643 operand
->X_add_number
< 4) {
644 opcode
|= operand
->X_add_number
<< 0;
650 if (operand
->X_seg
== SEG_ABSOLUTE
&&
651 operand
->X_add_number
< 4) {
652 opcode
|= operand
->X_add_number
<< 16;
658 if (operand
->X_seg
== SEG_ABSOLUTE
&&
659 operand
->X_add_number
< 16) {
660 opcode
|= operand
->X_add_number
<< 18;
668 /* Types or values of args don't match. */
669 as_bad("Invalid operands");
675 This is identical to the md_atof in m68k.c. I think this is right,
678 Turn a string in input_line_pointer into a floating point constant of type
679 type, and store the appropriate bytes in *litP. The number of LITTLENUMS
680 emitted is stored in *sizeP . An error message is returned, or NULL on OK.
683 /* Equal to MAX_PRECISION in atof-ieee.c */
684 #define MAX_LITTLENUMS 6
687 md_atof(type
,litP
,sizeP
)
693 LITTLENUM_TYPE words
[MAX_LITTLENUMS
];
694 LITTLENUM_TYPE
*wordP
;
725 return "Bad call to MD_ATOF()";
727 t
=atof_ieee(input_line_pointer
,type
,words
);
729 input_line_pointer
=t
;
730 *sizeP
=prec
* sizeof(LITTLENUM_TYPE
);
731 for(wordP
=words
;prec
--;) {
732 md_number_to_chars(litP
,(long)(*wordP
++),sizeof(LITTLENUM_TYPE
));
733 litP
+=sizeof(LITTLENUM_TYPE
);
735 return ""; /* Someone should teach Dean about null pointers */
739 * Write out big-endian.
742 md_number_to_chars(buf
,val
,n
)
760 as_fatal("failed sanity check.");
765 void md_apply_fix(fixP
, val
)
769 char *buf
= fixP
->fx_where
+ fixP
->fx_frag
->fr_literal
;
771 fixP
->fx_addnumber
= val
; /* Remember value for emit_reloc */
773 if (fixP
->fx_r_type
== NO_RELOC
) {
774 as_fatal("failed sanity check."); /* FIXME-SOON, if this is never used, remove */
775 switch (fixP
->fx_size
) {
790 as_fatal("failed sanity check.");
795 know(fixP
->fx_size
== 4);
796 know(fixP
->fx_r_type
< NO_RELOC
);
799 * This is a hack. There should be a better way to
802 if (fixP
->fx_r_type
== RELOC_WDISP30
&& fixP
->fx_addsy
) {
803 val
+= fixP
->fx_where
+ fixP
->fx_frag
->fr_address
;
806 switch (fixP
->fx_r_type
) {
820 val
= (val
>>= 2) + 1;
821 buf
[0] |= (val
>> 24) & 0x3f;
828 buf
[1] |= (val
>> 26) & 0x3f;
834 buf
[2] |= (val
>> 8) & 0x03;
839 buf
[2] |= (val
>> 8) & 0x1f;
844 val
= (val
>>= 2) + 1;
847 buf
[1] |= (val
>> 16) & 0x3f;
861 case RELOC_JUMPTARG
: /* 00XX00XX pattern in a word */
862 buf
[1] = val
>> 10; /* Holds bits 0003FFFC of address */
866 case RELOC_CONST
: /* 00XX00XX pattern in a word */
867 buf
[1] = val
>> 8; /* Holds bits 0000XXXX */
871 case RELOC_CONSTH
: /* 00XX00XX pattern in a word */
872 buf
[1] = val
>> 24; /* Holds bits XXXX0000 */
878 as_bad("bad relocation type: 0x%02x", fixP
->fx_r_type
);
885 short tc_coff_fix2rtype(fixP
)
889 /* FIXME-NOW: relocation type handling is not yet written for
893 switch (fixP
->fx_r_type
) {
894 case RELOC_32
: return(R_WORD
);
895 case RELOC_8
: return(R_BYTE
);
896 case RELOC_CONST
: return (R_ILOHALF
);
897 case RELOC_CONSTH
: return (R_IHIHALF
);
898 case RELOC_JUMPTARG
: return (R_IREL
);
899 default: printf("need %o3\n", fixP
->fx_r_type
);
901 } /* switch on type */
904 } /* tc_coff_fix2rtype() */
905 #endif /* OBJ_COFF */
907 /* should never be called for sparc */
908 void md_create_short_jump(ptr
, from_addr
, to_addr
, frag
, to_symbol
)
910 long from_addr
, to_addr
;
914 as_fatal("a29k_create_short_jmp\n");
917 /* should never be called for 29k */
918 void md_convert_frag(headers
, fragP
)
919 object_headers
*headers
;
920 register fragS
*fragP
;
922 as_fatal("sparc_convert_frag\n");
925 /* should never be called for 29k */
926 void md_create_long_jump(ptr
, from_addr
, to_addr
, frag
, to_symbol
)
933 as_fatal("sparc_create_long_jump\n");
936 /* should never be called for sparc */
937 int md_estimate_size_before_relax(fragP
, segtype
)
938 register fragS
*fragP
;
941 as_fatal("sparc_estimate_size_before_relax\n");
945 /* for debugging only */
948 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_sub_symbol = %s\n",
989 insn
->exp
.X_subtract_symbol
?
990 (S_GET_NAME(insn
->exp
.X_subtract_symbol
) ?
991 S_GET_NAME(insn
->exp
.X_subtract_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 */
1009 void tc_aout_fix_to_chars(where
, fixP
, segment_address_in_file
)
1012 relax_addressT segment_address_in_file
;
1016 know(fixP
->fx_r_type
< NO_RELOC
);
1017 know(fixP
->fx_addsy
!= NULL
);
1019 r_index
= (S_IS_DEFINED(fixP
->fx_addsy
)
1020 ? S_GET_TYPE(fixP
->fx_addsy
)
1021 : fixP
->fx_addsy
->sy_number
);
1024 md_number_to_chars(where
,
1025 fixP
->fx_frag
->fr_address
+ fixP
->fx_where
- segment_address_in_file
,
1028 /* now the fun stuff */
1029 where
[4] = (r_index
>> 16) & 0x0ff;
1030 where
[5] = (r_index
>> 8) & 0x0ff;
1031 where
[6] = r_index
& 0x0ff;
1032 where
[7] = (((!S_IS_DEFINED(fixP
->fx_addsy
)) << 7) & 0x80) | (0 & 0x60) | (fixP
->fx_r_type
& 0x1F);
1034 md_number_to_chars(&where
[8], fixP
->fx_addnumber
, 4);
1037 } /* tc_aout_fix_to_chars() */
1039 #endif /* OBJ_AOUT */
1042 md_parse_option(argP
,cntP
,vecP
)
1051 /* Default the values of symbols known that should be "predefined". We
1052 don't bother to predefine them unless you actually use one, since there
1053 are a lot of them. */
1055 symbolS
*md_undefined_symbol (name
)
1059 char testbuf
[5+ /*SLOP*/ 5];
1061 if (name
[0] == 'g' || name
[0] == 'G' || name
[0] == 'l' || name
[0] == 'L')
1063 /* Perhaps a global or local register name */
1064 if (name
[1] == 'r' || name
[1] == 'R')
1066 /* Parse the number, make sure it has no extra zeroes or trailing
1068 regnum
= atol(&name
[2]);
1071 sprintf(testbuf
, "%ld", regnum
);
1072 if (strcmp (testbuf
, &name
[2]) != 0)
1073 return 0; /* gr007 or lr7foo or whatever */
1075 /* We have a wiener! Define and return a new symbol for it. */
1076 if (name
[0] == 'l' || name
[0] == 'L')
1078 return(symbol_new(name
, SEG_REGISTER
, regnum
, &zero_address_frag
));
1085 /* Parse an operand that is machine-specific. */
1087 void md_operand(expressionP
)
1088 expressionS
*expressionP
;
1091 if (input_line_pointer
[0] == '%' && input_line_pointer
[1] == '%')
1093 /* We have a numeric register expression. No biggy. */
1094 input_line_pointer
+= 2; /* Skip %% */
1095 (void)expression (expressionP
);
1096 if (expressionP
->X_seg
!= SEG_ABSOLUTE
1097 || expressionP
->X_add_number
> 255)
1098 as_bad("Invalid expression after %%%%\n");
1099 expressionP
->X_seg
= SEG_REGISTER
;
1101 else if (input_line_pointer
[0] == '&')
1103 /* We are taking the 'address' of a register...this one is not
1104 in the manual, but it *is* in traps/fpsymbol.h! What they
1105 seem to want is the register number, as an absolute number. */
1106 input_line_pointer
++; /* Skip & */
1107 (void)expression (expressionP
);
1108 if (expressionP
->X_seg
!= SEG_REGISTER
)
1109 as_bad("Invalid register in & expression");
1111 expressionP
->X_seg
= SEG_ABSOLUTE
;
1115 /* Round up a section size to the appropriate boundary. */
1117 md_section_align (segment
, size
)
1121 return size
; /* Byte alignment is fine */
1124 /* Exactly what point is a PC-relative offset relative TO?
1125 On the 29000, they're relative to the address of the instruction,
1126 which we have set up as the address of the fixup too. */
1127 long md_pcrel_from (fixP
)
1130 return fixP
->fx_where
+ fixP
->fx_frag
->fr_address
;
1139 /* end of tc-a29k.c */