1 /* tc-a29k.c -- Assemble for the AMD 29000.
2 Copyright (C) 1989, 1990, 1991, 1992 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 */
64 /* static int getExpression(char *str); */
65 static void machine_ip (char *str
);
66 /* static void print_insn(struct machine_it *insn); */
67 static void s_data1 (void);
68 static void s_use (void);
70 #else /* not __STDC__ */
72 /* static int getExpression(); */
73 static void machine_ip ();
74 /* static void print_insn(); */
75 static void s_data1 ();
78 #endif /* not __STDC__ */
83 {"align", s_align_bytes
, 4},
84 {"block", s_space
, 0},
85 {"cputype", s_ignore
, 0}, /* CPU as 29000 or 29050 */
86 {"reg", s_lsym
, 0}, /* Register equate, same as equ */
87 {"space", s_ignore
, 0}, /* Listing control */
88 {"sect", s_ignore
, 0}, /* Creation of coff sections */
90 /* We can do this right with coff */
97 int md_short_jump_size
= 4;
98 int md_long_jump_size
= 4;
99 #if defined(BFD_HEADERS)
101 const int md_reloc_size
= RELSZ
; /* Coff headers */
103 const int md_reloc_size
= 12; /* something else headers */
106 const int md_reloc_size
= 12; /* Not bfdized*/
109 /* This array holds the chars that always start a comment. If the
110 pre-processor is disabled, these aren't very useful */
111 const char comment_chars
[] = ";";
113 /* This array holds the chars that only start a comment at the beginning of
114 a line. If the line seems to have the form '# 123 filename'
115 .line and .file directives will appear in the pre-processed output */
116 /* Note that input_file.c hand checks for '#' at the beginning of the
117 first line of the input file. This is because the compiler outputs
118 #NO_APP at the beginning of its output. */
119 /* Also note that comments like this one will always work */
120 const char line_comment_chars
[] = "#";
122 /* We needed an unused char for line separation to work around the
123 lack of macros, using sed and such. */
124 const char line_separator_chars
[] = "@";
126 /* Chars that can be used to separate mant from exp in floating point nums */
127 const char EXP_CHARS
[] = "eE";
129 /* Chars that mean this number is a floating point constant */
132 const char FLT_CHARS
[] = "rRsSfFdDxXpP";
134 /* Also be aware that MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT may have to be
135 changed in read.c . Ideally it shouldn't have to know about it at all,
136 but nothing is ideal around here.
139 static unsigned char octal
[256];
140 #define isoctal(c) octal[c]
141 static unsigned char toHex
[256];
144 * anull bit - causes the branch delay slot instructions to not be executed
146 #define ANNUL (1 << 29)
152 if (strncmp (input_line_pointer
, ".text", 5) == 0)
154 input_line_pointer
+= 5;
158 if (strncmp (input_line_pointer
, ".data", 5) == 0)
160 input_line_pointer
+= 5;
164 if (strncmp (input_line_pointer
, ".data1", 6) == 0)
166 input_line_pointer
+= 6;
170 /* Literals can't go in the text segment because you can't read
171 from instruction memory on some 29k's. So, into initialized data. */
172 if (strncmp (input_line_pointer
, ".lit", 4) == 0)
174 input_line_pointer
+= 4;
175 subseg_new (SEG_DATA
, 200);
176 demand_empty_rest_of_line ();
180 as_bad ("Unknown segment type");
181 demand_empty_rest_of_line ();
188 subseg_new (SEG_DATA
, 1);
189 demand_empty_rest_of_line ();
193 /* Install symbol definition that maps REGNAME to REGNO.
194 FIXME-SOON: These are not recognized in mixed case. */
197 insert_sreg (regname
, regnum
)
201 /* FIXME-SOON, put something in these syms so they won't be output to the symbol
202 table of the resulting object file. */
204 /* Must be large enough to hold the names of the special registers. */
208 symbol_table_insert (symbol_new (regname
, SEG_REGISTER
, regnum
, &zero_address_frag
));
209 for (i
= 0; regname
[i
]; i
++)
210 buf
[i
] = islower (regname
[i
]) ? toupper (regname
[i
]) : regname
[i
];
213 symbol_table_insert (symbol_new (buf
, SEG_REGISTER
, regnum
, &zero_address_frag
));
214 } /* insert_sreg() */
216 /* Install symbol definitions for assorted special registers.
217 See ASM29K Ref page 2-9. */
224 /* Protected special-purpose register names */
225 insert_sreg ("vab", SREG
+ 0);
226 insert_sreg ("ops", SREG
+ 1);
227 insert_sreg ("cps", SREG
+ 2);
228 insert_sreg ("cfg", SREG
+ 3);
229 insert_sreg ("cha", SREG
+ 4);
230 insert_sreg ("chd", SREG
+ 5);
231 insert_sreg ("chc", SREG
+ 6);
232 insert_sreg ("rbp", SREG
+ 7);
233 insert_sreg ("tmc", SREG
+ 8);
234 insert_sreg ("tmr", SREG
+ 9);
235 insert_sreg ("pc0", SREG
+ 10);
236 insert_sreg ("pc1", SREG
+ 11);
237 insert_sreg ("pc2", SREG
+ 12);
238 insert_sreg ("mmu", SREG
+ 13);
239 insert_sreg ("lru", SREG
+ 14);
241 /* Additional protected special-purpose registers for the 29050 */
242 insert_sreg ("rsn", SREG
+ 15);
243 insert_sreg ("rma0", SREG
+ 16);
244 insert_sreg ("rmc0", SREG
+ 17);
245 insert_sreg ("rma1", SREG
+ 18);
246 insert_sreg ("rmc1", SREG
+ 19);
247 insert_sreg ("spc0", SREG
+ 20);
248 insert_sreg ("spc1", SREG
+ 21);
249 insert_sreg ("spc2", SREG
+ 22);
250 insert_sreg ("iba0", SREG
+ 23);
251 insert_sreg ("ibc0", SREG
+ 24);
252 insert_sreg ("iba1", SREG
+ 25);
253 insert_sreg ("ibc1", SREG
+ 26);
255 /* Unprotected special-purpose register names */
256 insert_sreg ("ipc", SREG
+ 128);
257 insert_sreg ("ipa", SREG
+ 129);
258 insert_sreg ("ipb", SREG
+ 130);
259 insert_sreg ("q", SREG
+ 131);
260 insert_sreg ("alu", SREG
+ 132);
261 insert_sreg ("bp", SREG
+ 133);
262 insert_sreg ("fc", SREG
+ 134);
263 insert_sreg ("cr", SREG
+ 135);
264 insert_sreg ("fpe", SREG
+ 160);
265 insert_sreg ("inte", SREG
+ 161);
266 insert_sreg ("fps", SREG
+ 162);
267 /* "", SREG+163); Reserved */
268 insert_sreg ("exop", SREG
+ 164);
269 } /* define_some_regs() */
271 /* This function is called once, at assembler startup time. It should
272 set up all the tables, etc. that the MD part of the assembler will need. */
276 register char *retval
= NULL
;
278 register int skipnext
= 0;
279 register unsigned int i
;
280 register char *strend
, *strend2
;
282 /* Hash up all the opcodes for fast use later. */
284 op_hash
= hash_new ();
286 as_fatal ("Virtual memory exhausted");
288 for (i
= 0; i
< num_opcodes
; i
++)
290 const char *name
= machine_opcodes
[i
].name
;
298 /* Hack to avoid multiple opcode entries. We pre-locate all the
299 variations (b/i field and P/A field) and handle them. */
301 if (!strcmp (name
, machine_opcodes
[i
+ 1].name
))
303 if ((machine_opcodes
[i
].opcode
^ machine_opcodes
[i
+ 1].opcode
)
306 strend
= machine_opcodes
[i
].args
+ strlen (machine_opcodes
[i
].args
) - 1;
307 strend2
= machine_opcodes
[i
+ 1].args
+ strlen (machine_opcodes
[i
+ 1].args
) - 1;
328 fprintf (stderr
, "internal error: can't handle opcode %s\n", name
);
332 /* OK, this is an i/b or A/P pair. We skip the higher-valued one,
333 and let the code for operand checking handle OR-ing in the bit. */
334 if (machine_opcodes
[i
].opcode
& 1)
340 retval
= hash_insert (op_hash
, name
, &machine_opcodes
[i
]);
341 if (retval
!= NULL
&& *retval
!= '\0')
343 fprintf (stderr
, "internal error: can't hash `%s': %s\n",
344 machine_opcodes
[i
].name
, retval
);
350 as_fatal ("Broken assembler. No assembly attempted.");
352 for (i
= '0'; i
< '8'; ++i
)
354 for (i
= '0'; i
<= '9'; ++i
)
356 for (i
= 'a'; i
<= 'f'; ++i
)
357 toHex
[i
] = i
+ 10 - 'a';
358 for (i
= 'A'; i
<= 'F'; ++i
)
359 toHex
[i
] = i
+ 10 - 'A';
370 /* Assemble a single instruction. Its label has already been handled
371 by the generic front end. We just parse opcode and operands, and
372 produce the bytes of data and relocation. */
384 /* put out the opcode */
385 md_number_to_chars (toP
, the_insn
.opcode
, 4);
387 /* put out the symbol-dependent stuff */
388 if (the_insn
.reloc
!= NO_RELOC
)
391 frag_now
, /* which frag */
392 (toP
- frag_now
->fr_literal
+ the_insn
.reloc_offset
), /* where */
394 the_insn
.exp
.X_add_symbol
,
395 the_insn
.exp
.X_subtract_symbol
,
396 the_insn
.exp
.X_add_number
,
404 parse_operand (s
, operandp
)
406 expressionS
*operandp
;
408 char *save
= input_line_pointer
;
412 input_line_pointer
= s
;
413 seg
= expr (0, operandp
);
414 new = input_line_pointer
;
415 input_line_pointer
= save
;
417 if (seg
== SEG_ABSENT
)
418 as_bad ("Missing operand");
422 /* Instruction parsing. Takes a string containing the opcode.
423 Operands are at input_line_pointer. Output is in the_insn.
424 Warnings or errors are generated. */
433 /* !!!! unsigned long i; */
434 struct machine_opcode
*insn
;
436 unsigned long opcode
;
437 /* !!!! unsigned int mask; */
438 expressionS the_operand
;
439 expressionS
*operand
= &the_operand
;
442 /* Must handle `div0' opcode. */
445 for (; isalnum (*s
); ++s
)
454 case ' ': /* FIXME-SOMEDAY more whitespace */
459 as_bad ("Unknown opcode: `%s'", str
);
462 if ((insn
= (struct machine_opcode
*) hash_find (op_hash
, str
)) == NULL
)
464 as_bad ("Unknown opcode `%s'.", str
);
468 opcode
= insn
->opcode
;
469 memset (&the_insn
, '\0', sizeof (the_insn
));
470 the_insn
.reloc
= NO_RELOC
;
473 * Build the opcode, checking as we go to make
474 * sure that the operands match.
476 * If an operand matches, we modify the_insn or opcode appropriately,
477 * and do a "continue". If an operand fails to match, we "break".
479 if (insn
->args
[0] != '\0')
480 s
= parse_operand (s
, operand
); /* Prime the pump */
482 for (args
= insn
->args
;; ++args
)
487 case '\0': /* end of args */
490 /* We are truly done. */
491 the_insn
.opcode
= opcode
;
494 as_bad ("Too many operands: %s", s
);
497 case ',': /* Must match a comma */
500 s
= parse_operand (s
, operand
); /* Parse next opnd */
505 case 'v': /* Trap numbers (immediate field) */
506 if (operand
->X_seg
== SEG_ABSOLUTE
)
508 if (operand
->X_add_number
< 256)
510 opcode
|= (operand
->X_add_number
<< 16);
515 as_bad ("Immediate value of %d is too large",
516 operand
->X_add_number
);
520 the_insn
.reloc
= RELOC_8
;
521 the_insn
.reloc_offset
= 1; /* BIG-ENDIAN Byte 1 of insn */
522 the_insn
.exp
= *operand
;
525 case 'b': /* A general register or 8-bit immediate */
527 /* We treat the two cases identically since we mashed
528 them together in the opcode table. */
529 if (operand
->X_seg
== SEG_REGISTER
)
532 opcode
|= IMMEDIATE_BIT
;
533 if (operand
->X_seg
== SEG_ABSOLUTE
)
535 if (operand
->X_add_number
< 256)
537 opcode
|= operand
->X_add_number
;
542 as_bad ("Immediate value of %d is too large",
543 operand
->X_add_number
);
547 the_insn
.reloc
= RELOC_8
;
548 the_insn
.reloc_offset
= 3; /* BIG-ENDIAN Byte 3 of insn */
549 the_insn
.exp
= *operand
;
552 case 'a': /* next operand must be a register */
555 /* lrNNN or grNNN or %%expr or a user-def register name */
556 if (operand
->X_seg
!= SEG_REGISTER
)
557 break; /* Only registers */
558 know (operand
->X_add_symbol
== 0);
559 know (operand
->X_subtract_symbol
== 0);
560 reg
= operand
->X_add_number
;
562 break; /* No special registers */
565 * Got the register, now figure out where
566 * it goes in the opcode.
583 as_fatal ("failed sanity check.");
586 case 'x': /* 16 bit constant, zero-extended */
587 case 'X': /* 16 bit constant, one-extended */
588 if (operand
->X_seg
== SEG_ABSOLUTE
)
590 opcode
|= (operand
->X_add_number
& 0xFF) << 0 |
591 ((operand
->X_add_number
& 0xFF00) << 8);
594 the_insn
.reloc
= RELOC_CONST
;
595 the_insn
.exp
= *operand
;
599 if (operand
->X_seg
== SEG_ABSOLUTE
)
601 opcode
|= (operand
->X_add_number
& 0x00FF0000) >> 16 |
602 (((unsigned long) operand
->X_add_number
603 /* avoid sign ext */ & 0xFF000000) >> 8);
606 the_insn
.reloc
= RELOC_CONSTH
;
607 the_insn
.exp
= *operand
;
610 case 'P': /* PC-relative jump address */
611 case 'A': /* Absolute jump address */
612 /* These two are treated together since we folded the
613 opcode table entries together. */
614 if (operand
->X_seg
== SEG_ABSOLUTE
)
616 opcode
|= ABSOLUTE_BIT
|
617 (operand
->X_add_number
& 0x0003FC00) << 6 |
618 ((operand
->X_add_number
& 0x000003FC) >> 2);
621 the_insn
.reloc
= RELOC_JUMPTARG
;
622 the_insn
.exp
= *operand
;
623 the_insn
.pcrel
= 1; /* Assume PC-relative jump */
624 /* FIXME-SOON, Do we figure out whether abs later, after know sym val? */
627 case 'e': /* Coprocessor enable bit for LOAD/STORE insn */
628 if (operand
->X_seg
== SEG_ABSOLUTE
)
630 if (operand
->X_add_number
== 0)
632 if (operand
->X_add_number
== 1)
640 case 'n': /* Control bits for LOAD/STORE instructions */
641 if (operand
->X_seg
== SEG_ABSOLUTE
&&
642 operand
->X_add_number
< 128)
644 opcode
|= (operand
->X_add_number
<< 16);
649 case 's': /* Special register number */
650 if (operand
->X_seg
!= SEG_REGISTER
)
651 break; /* Only registers */
652 if (operand
->X_add_number
< SREG
)
653 break; /* Not a special register */
654 opcode
|= (operand
->X_add_number
& 0xFF) << 8;
657 case 'u': /* UI bit of CONVERT */
658 if (operand
->X_seg
== SEG_ABSOLUTE
)
660 if (operand
->X_add_number
== 0)
662 if (operand
->X_add_number
== 1)
670 case 'r': /* RND bits of CONVERT */
671 if (operand
->X_seg
== SEG_ABSOLUTE
&&
672 operand
->X_add_number
< 8)
674 opcode
|= operand
->X_add_number
<< 4;
679 case 'd': /* FD bits of CONVERT */
680 if (operand
->X_seg
== SEG_ABSOLUTE
&&
681 operand
->X_add_number
< 4)
683 opcode
|= operand
->X_add_number
<< 2;
689 case 'f': /* FS bits of CONVERT */
690 if (operand
->X_seg
== SEG_ABSOLUTE
&&
691 operand
->X_add_number
< 4)
693 opcode
|= operand
->X_add_number
<< 0;
699 if (operand
->X_seg
== SEG_ABSOLUTE
&&
700 operand
->X_add_number
< 4)
702 opcode
|= operand
->X_add_number
<< 16;
708 if (operand
->X_seg
== SEG_ABSOLUTE
&&
709 operand
->X_add_number
< 16)
711 opcode
|= operand
->X_add_number
<< 18;
719 /* Types or values of args don't match. */
720 as_bad ("Invalid operands");
726 This is identical to the md_atof in m68k.c. I think this is right,
729 Turn a string in input_line_pointer into a floating point constant of type
730 type, and store the appropriate bytes in *litP. The number of LITTLENUMS
731 emitted is stored in *sizeP . An error message is returned, or NULL on OK.
734 /* Equal to MAX_PRECISION in atof-ieee.c */
735 #define MAX_LITTLENUMS 6
738 md_atof (type
, litP
, sizeP
)
744 LITTLENUM_TYPE words
[MAX_LITTLENUMS
];
745 LITTLENUM_TYPE
*wordP
;
777 return "Bad call to MD_ATOF()";
779 t
= atof_ieee (input_line_pointer
, type
, words
);
781 input_line_pointer
= t
;
782 *sizeP
= prec
* sizeof (LITTLENUM_TYPE
);
783 for (wordP
= words
; prec
--;)
785 md_number_to_chars (litP
, (long) (*wordP
++), sizeof (LITTLENUM_TYPE
));
786 litP
+= sizeof (LITTLENUM_TYPE
);
788 return ""; /* Someone should teach Dean about null pointers */
792 * Write out big-endian.
795 md_number_to_chars (buf
, val
, n
)
814 as_fatal ("failed sanity check.");
820 md_apply_fix (fixP
, val
)
824 char *buf
= fixP
->fx_where
+ fixP
->fx_frag
->fr_literal
;
826 fixP
->fx_addnumber
= val
; /* Remember value for emit_reloc */
829 know (fixP
->fx_size
== 4);
830 know (fixP
->fx_r_type
< NO_RELOC
);
833 * This is a hack. There should be a better way to
836 if (fixP
->fx_r_type
== RELOC_WDISP30
&& fixP
->fx_addsy
)
838 val
+= fixP
->fx_where
+ fixP
->fx_frag
->fr_address
;
841 switch (fixP
->fx_r_type
)
856 val
= (val
>>= 2) + 1;
857 buf
[0] |= (val
>> 24) & 0x3f;
858 buf
[1] = (val
>> 16);
864 buf
[1] |= (val
>> 26) & 0x3f;
870 buf
[2] |= (val
>> 8) & 0x03;
875 buf
[2] |= (val
>> 8) & 0x1f;
880 val
= (val
>>= 2) + 1;
883 buf
[1] |= (val
>> 16) & 0x3f;
897 case RELOC_JUMPTARG
: /* 00XX00XX pattern in a word */
898 buf
[1] = val
>> 10; /* Holds bits 0003FFFC of address */
902 case RELOC_CONST
: /* 00XX00XX pattern in a word */
903 buf
[1] = val
>> 8; /* Holds bits 0000XXXX */
907 case RELOC_CONSTH
: /* 00XX00XX pattern in a word */
908 buf
[1] = val
>> 24; /* Holds bits XXXX0000 */
914 as_bad ("bad relocation type: 0x%02x", fixP
->fx_r_type
);
922 tc_coff_fix2rtype (fixP
)
926 switch (fixP
->fx_r_type
)
939 printf ("need %o3\n", fixP
->fx_r_type
);
941 } /* switch on type */
944 } /* tc_coff_fix2rtype() */
946 #endif /* OBJ_COFF */
948 /* should never be called for sparc */
950 md_create_short_jump (ptr
, from_addr
, to_addr
, frag
, to_symbol
)
952 long from_addr
, to_addr
;
956 as_fatal ("a29k_create_short_jmp\n");
959 /* should never be called for 29k */
961 md_convert_frag (headers
, fragP
)
962 object_headers
*headers
;
963 register fragS
*fragP
;
965 as_fatal ("sparc_convert_frag\n");
968 /* should never be called for 29k */
970 md_create_long_jump (ptr
, from_addr
, to_addr
, frag
, to_symbol
)
977 as_fatal ("sparc_create_long_jump\n");
980 /* should never be called for a29k */
982 md_estimate_size_before_relax (fragP
, segtype
)
983 register fragS
*fragP
;
986 as_fatal ("sparc_estimate_size_before_relax\n");
991 /* for debugging only */
994 struct machine_it
*insn
;
1027 fprintf (stderr
, "ERROR: %s\n");
1029 fprintf (stderr
, "opcode=0x%08x\n", insn
->opcode
);
1030 fprintf (stderr
, "reloc = %s\n", Reloc
[insn
->reloc
]);
1031 fprintf (stderr
, "exp = {\n");
1032 fprintf (stderr
, "\t\tX_add_symbol = %s\n",
1033 insn
->exp
.X_add_symbol
?
1034 (S_GET_NAME (insn
->exp
.X_add_symbol
) ?
1035 S_GET_NAME (insn
->exp
.X_add_symbol
) : "???") : "0");
1036 fprintf (stderr
, "\t\tX_sub_symbol = %s\n",
1037 insn
->exp
.X_subtract_symbol
?
1038 (S_GET_NAME (insn
->exp
.X_subtract_symbol
) ?
1039 S_GET_NAME (insn
->exp
.X_subtract_symbol
) : "???") : "0");
1040 fprintf (stderr
, "\t\tX_add_number = %d\n",
1041 insn
->exp
.X_add_number
);
1042 fprintf (stderr
, "}\n");
1048 /* Translate internal representation of relocation info to target format.
1050 On sparc/29k: first 4 bytes are normal unsigned long address, next three
1051 bytes are index, most sig. byte first. Byte 7 is broken up with
1052 bit 7 as external, bits 6 & 5 unused, and the lower
1053 five bits as relocation type. Next 4 bytes are long addend. */
1054 /* Thanx and a tip of the hat to Michael Bloom, mb@ttidca.tti.com */
1059 tc_aout_fix_to_chars (where
, fixP
, segment_address_in_file
)
1062 relax_addressT segment_address_in_file
;
1066 know (fixP
->fx_r_type
< NO_RELOC
);
1067 know (fixP
->fx_addsy
!= NULL
);
1069 md_number_to_chars (where
,
1070 fixP
->fx_frag
->fr_address
+ fixP
->fx_where
- segment_address_in_file
,
1073 r_symbolnum
= (S_IS_DEFINED (fixP
->fx_addsy
)
1074 ? S_GET_TYPE (fixP
->fx_addsy
)
1075 : fixP
->fx_addsy
->sy_number
);
1077 where
[4] = (r_symbolnum
>> 16) & 0x0ff;
1078 where
[5] = (r_symbolnum
>> 8) & 0x0ff;
1079 where
[6] = r_symbolnum
& 0x0ff;
1080 where
[7] = (((!S_IS_DEFINED (fixP
->fx_addsy
)) << 7) & 0x80) | (0 & 0x60) | (fixP
->fx_r_type
& 0x1F);
1082 md_number_to_chars (&where
[8], fixP
->fx_addnumber
, 4);
1085 } /* tc_aout_fix_to_chars() */
1087 #endif /* OBJ_AOUT */
1090 md_parse_option (argP
, cntP
, vecP
)
1099 /* Default the values of symbols known that should be "predefined". We
1100 don't bother to predefine them unless you actually use one, since there
1101 are a lot of them. */
1104 md_undefined_symbol (name
)
1108 char testbuf
[5 + /*SLOP*/ 5];
1110 if (name
[0] == 'g' || name
[0] == 'G' || name
[0] == 'l' || name
[0] == 'L')
1112 /* Perhaps a global or local register name */
1113 if (name
[1] == 'r' || name
[1] == 'R')
1115 /* Parse the number, make sure it has no extra zeroes or trailing
1117 regnum
= atol (&name
[2]);
1120 sprintf (testbuf
, "%ld", regnum
);
1121 if (strcmp (testbuf
, &name
[2]) != 0)
1122 return 0; /* gr007 or lr7foo or whatever */
1124 /* We have a wiener! Define and return a new symbol for it. */
1125 if (name
[0] == 'l' || name
[0] == 'L')
1127 return (symbol_new (name
, SEG_REGISTER
, regnum
, &zero_address_frag
));
1134 /* Parse an operand that is machine-specific. */
1137 md_operand (expressionP
)
1138 expressionS
*expressionP
;
1141 if (input_line_pointer
[0] == '%' && input_line_pointer
[1] == '%')
1143 /* We have a numeric register expression. No biggy. */
1144 input_line_pointer
+= 2; /* Skip %% */
1145 (void) expression (expressionP
);
1146 if (expressionP
->X_seg
!= SEG_ABSOLUTE
1147 || expressionP
->X_add_number
> 255)
1148 as_bad ("Invalid expression after %%%%\n");
1149 expressionP
->X_seg
= SEG_REGISTER
;
1151 else if (input_line_pointer
[0] == '&')
1153 /* We are taking the 'address' of a register...this one is not
1154 in the manual, but it *is* in traps/fpsymbol.h! What they
1155 seem to want is the register number, as an absolute number. */
1156 input_line_pointer
++; /* Skip & */
1157 (void) expression (expressionP
);
1158 if (expressionP
->X_seg
!= SEG_REGISTER
)
1159 as_bad ("Invalid register in & expression");
1161 expressionP
->X_seg
= SEG_ABSOLUTE
;
1165 /* Round up a section size to the appropriate boundary. */
1167 md_section_align (segment
, size
)
1171 return size
; /* Byte alignment is fine */
1174 /* Exactly what point is a PC-relative offset relative TO?
1175 On the 29000, they're relative to the address of the instruction,
1176 which we have set up as the address of the fixup too. */
1178 md_pcrel_from (fixP
)
1181 return fixP
->fx_where
+ fixP
->fx_frag
->fr_address
;
1190 /* end of tc-a29k.c */