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 */
61 static void machine_ip
PARAMS ((char *str
));
62 /* static void print_insn PARAMS ((struct machine_it *insn)); */
64 static void s_data1
PARAMS ((void));
65 static void s_use
PARAMS ((int));
71 {"align", s_align_bytes
, 4},
72 {"block", s_space
, 0},
73 {"cputype", s_ignore
, 0}, /* CPU as 29000 or 29050 */
74 {"reg", s_lsym
, 0}, /* Register equate, same as equ */
75 {"space", s_ignore
, 0}, /* Listing control */
76 {"sect", s_ignore
, 0}, /* Creation of coff sections */
78 /* We can do this right with coff. */
85 int md_short_jump_size
= 4;
86 int md_long_jump_size
= 4;
87 #if defined(BFD_HEADERS)
89 const int md_reloc_size
= RELSZ
; /* Coff headers */
91 const int md_reloc_size
= 12; /* something else headers */
94 const 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 const 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 const 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 const char line_separator_chars
[] = "@";
114 /* Chars that can be used to separate mant from exp in floating point nums */
115 const char EXP_CHARS
[] = "eE";
117 /* Chars that mean this number is a floating point constant */
120 const 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
124 all, but nothing is ideal around here. */
127 * anull bit - causes the branch delay slot instructions to not be executed
129 #define ANNUL (1 << 29)
137 if (strncmp (input_line_pointer
, ".text", 5) == 0)
139 input_line_pointer
+= 5;
143 if (strncmp (input_line_pointer
, ".data", 5) == 0)
145 input_line_pointer
+= 5;
149 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 from
156 instruction memory on some 29k's. So, into initialized data. */
157 if (strncmp (input_line_pointer
, ".lit", 4) == 0)
159 input_line_pointer
+= 4;
160 subseg_set (SEG_DATA
, 200);
161 demand_empty_rest_of_line ();
165 as_bad ("Unknown segment type");
166 demand_empty_rest_of_line ();
172 subseg_set (SEG_DATA
, 1);
173 demand_empty_rest_of_line ();
176 #endif /* OBJ_COFF */
178 /* Install symbol definition that maps REGNAME to REGNO.
179 FIXME-SOON: These are not recognized in mixed case. */
182 insert_sreg (regname
, regnum
)
186 /* FIXME-SOON, put something in these syms so they won't be output
187 to the symbol table of the resulting object file. */
189 /* Must be large enough to hold the names of the special registers. */
193 symbol_table_insert (symbol_new (regname
, SEG_REGISTER
, (valueT
) regnum
,
194 &zero_address_frag
));
195 for (i
= 0; regname
[i
]; i
++)
196 buf
[i
] = islower (regname
[i
]) ? toupper (regname
[i
]) : regname
[i
];
199 symbol_table_insert (symbol_new (buf
, SEG_REGISTER
, (valueT
) regnum
,
200 &zero_address_frag
));
203 /* Install symbol definitions for assorted special registers.
204 See ASM29K Ref page 2-9. */
211 /* Protected special-purpose register names */
212 insert_sreg ("vab", SREG
+ 0);
213 insert_sreg ("ops", SREG
+ 1);
214 insert_sreg ("cps", SREG
+ 2);
215 insert_sreg ("cfg", SREG
+ 3);
216 insert_sreg ("cha", SREG
+ 4);
217 insert_sreg ("chd", SREG
+ 5);
218 insert_sreg ("chc", SREG
+ 6);
219 insert_sreg ("rbp", SREG
+ 7);
220 insert_sreg ("tmc", SREG
+ 8);
221 insert_sreg ("tmr", SREG
+ 9);
222 insert_sreg ("pc0", SREG
+ 10);
223 insert_sreg ("pc1", SREG
+ 11);
224 insert_sreg ("pc2", SREG
+ 12);
225 insert_sreg ("mmu", SREG
+ 13);
226 insert_sreg ("lru", SREG
+ 14);
228 /* Additional protected special-purpose registers for the 29050 */
229 insert_sreg ("rsn", SREG
+ 15);
230 insert_sreg ("rma0", SREG
+ 16);
231 insert_sreg ("rmc0", SREG
+ 17);
232 insert_sreg ("rma1", SREG
+ 18);
233 insert_sreg ("rmc1", SREG
+ 19);
234 insert_sreg ("spc0", SREG
+ 20);
235 insert_sreg ("spc1", SREG
+ 21);
236 insert_sreg ("spc2", SREG
+ 22);
237 insert_sreg ("iba0", SREG
+ 23);
238 insert_sreg ("ibc0", SREG
+ 24);
239 insert_sreg ("iba1", SREG
+ 25);
240 insert_sreg ("ibc1", SREG
+ 26);
242 /* Additional registers for the 29040. */
243 insert_sreg ("dba", SREG
+ 27);
244 insert_sreg ("dbc", SREG
+ 28);
245 insert_sreg ("cir", SREG
+ 29);
246 insert_sreg ("cdr", SREG
+ 30);
248 /* Unprotected special-purpose register names */
249 insert_sreg ("ipc", SREG
+ 128);
250 insert_sreg ("ipa", SREG
+ 129);
251 insert_sreg ("ipb", SREG
+ 130);
252 insert_sreg ("q", SREG
+ 131);
253 insert_sreg ("alu", SREG
+ 132);
254 insert_sreg ("bp", SREG
+ 133);
255 insert_sreg ("fc", SREG
+ 134);
256 insert_sreg ("cr", SREG
+ 135);
257 insert_sreg ("fpe", SREG
+ 160);
258 insert_sreg ("inte", SREG
+ 161);
259 insert_sreg ("fps", SREG
+ 162);
260 /* "", SREG+163); Reserved */
261 insert_sreg ("exop", SREG
+ 164);
264 /* This function is called once, at assembler startup time. It should
265 set up all the tables, etc., that the MD part of the assembler will
270 register const char *retval
= NULL
;
272 register int skipnext
= 0;
273 register unsigned int i
;
274 register char *strend
, *strend2
;
276 /* Hash up all the opcodes for fast use later. */
278 op_hash
= hash_new ();
280 for (i
= 0; i
< num_opcodes
; i
++)
282 const char *name
= machine_opcodes
[i
].name
;
290 /* Hack to avoid multiple opcode entries. We pre-locate all the
291 variations (b/i field and P/A field) and handle them. */
293 if (!strcmp (name
, machine_opcodes
[i
+ 1].name
))
295 if ((machine_opcodes
[i
].opcode
& 0x01000000) != 0
296 || (machine_opcodes
[i
+ 1].opcode
& 0x01000000) == 0
297 || ((machine_opcodes
[i
].opcode
| 0x01000000)
298 != machine_opcodes
[i
+ 1].opcode
))
300 strend
= machine_opcodes
[i
].args
+ strlen (machine_opcodes
[i
].args
) - 1;
301 strend2
= machine_opcodes
[i
+ 1].args
+ strlen (machine_opcodes
[i
+ 1].args
) - 1;
314 fprintf (stderr
, "internal error: can't handle opcode %s\n",
319 /* OK, this is an i/b or A/P pair. We skip the
320 higher-valued one, and let the code for operand checking
321 handle OR-ing in the bit. */
325 retval
= hash_insert (op_hash
, name
, (PTR
) &machine_opcodes
[i
]);
328 fprintf (stderr
, "internal error: can't hash `%s': %s\n",
329 machine_opcodes
[i
].name
, retval
);
335 as_fatal ("Broken assembler. No assembly attempted.");
340 /* Assemble a single instruction. Its label has already been handled
341 by the generic front end. We just parse opcode and operands, and
342 produce the bytes of data and relocation. */
353 /* put out the opcode */
354 md_number_to_chars (toP
, the_insn
.opcode
, 4);
356 /* put out the symbol-dependent stuff */
357 if (the_insn
.reloc
!= NO_RELOC
)
359 fix_new_exp (frag_now
,
360 (toP
- frag_now
->fr_literal
+ the_insn
.reloc_offset
),
369 parse_operand (s
, operandp
, opt
)
371 expressionS
*operandp
;
374 char *save
= input_line_pointer
;
377 input_line_pointer
= s
;
378 expression (operandp
);
379 if (operandp
->X_op
== O_absent
&& ! opt
)
380 as_bad ("missing operand");
381 new = input_line_pointer
;
382 input_line_pointer
= save
;
386 /* Instruction parsing. Takes a string containing the opcode.
387 Operands are at input_line_pointer. Output is in the_insn.
388 Warnings or errors are generated. */
396 struct machine_opcode
*insn
;
398 unsigned long opcode
;
399 expressionS the_operand
;
400 expressionS
*operand
= &the_operand
;
403 /* Must handle `div0' opcode. */
406 for (; isalnum (*s
); ++s
)
415 case ' ': /* FIXME-SOMEDAY more whitespace */
420 as_bad ("Unknown opcode: `%s'", str
);
423 if ((insn
= (struct machine_opcode
*) hash_find (op_hash
, str
)) == NULL
)
425 as_bad ("Unknown opcode `%s'.", str
);
429 opcode
= insn
->opcode
;
430 memset (&the_insn
, '\0', sizeof (the_insn
));
431 the_insn
.reloc
= NO_RELOC
;
433 /* Build the opcode, checking as we go to make sure that the
436 If an operand matches, we modify the_insn or opcode appropriately,
437 and do a "continue". If an operand fails to match, we "break". */
439 if (insn
->args
[0] != '\0')
441 /* Prime the pump. */
442 s
= parse_operand (s
, operand
, insn
->args
[0] == 'I');
445 for (args
= insn
->args
;; ++args
)
450 case '\0': /* end of args */
453 /* We are truly done. */
454 the_insn
.opcode
= opcode
;
457 as_bad ("Too many operands: %s", s
);
460 case ',': /* Must match a comma */
463 /* Parse next operand. */
464 s
= parse_operand (s
, operand
, args
[1] == 'I');
469 case 'v': /* Trap numbers (immediate field) */
470 if (operand
->X_op
== O_constant
)
472 if (operand
->X_add_number
< 256)
474 opcode
|= (operand
->X_add_number
<< 16);
479 as_bad ("Immediate value of %ld is too large",
480 (long) operand
->X_add_number
);
484 the_insn
.reloc
= RELOC_8
;
485 the_insn
.reloc_offset
= 1; /* BIG-ENDIAN Byte 1 of insn */
486 the_insn
.exp
= *operand
;
489 case 'b': /* A general register or 8-bit immediate */
491 /* We treat the two cases identically since we mashed
492 them together in the opcode table. */
493 if (operand
->X_op
== O_register
)
496 /* Make sure the 'i' case really exists. */
497 if ((insn
->opcode
| IMMEDIATE_BIT
) != (insn
+ 1)->opcode
)
500 opcode
|= IMMEDIATE_BIT
;
501 if (operand
->X_op
== O_constant
)
503 if (operand
->X_add_number
< 256)
505 opcode
|= operand
->X_add_number
;
510 as_bad ("Immediate value of %ld is too large",
511 (long) operand
->X_add_number
);
515 the_insn
.reloc
= RELOC_8
;
516 the_insn
.reloc_offset
= 3; /* BIG-ENDIAN Byte 3 of insn */
517 the_insn
.exp
= *operand
;
520 case 'a': /* next operand must be a register */
523 /* lrNNN or grNNN or %%expr or a user-def register name */
524 if (operand
->X_op
!= O_register
)
525 break; /* Only registers */
526 know (operand
->X_add_symbol
== 0);
527 know (operand
->X_op_symbol
== 0);
528 reg
= operand
->X_add_number
;
530 break; /* No special registers */
532 /* Got the register, now figure out where it goes in the
549 as_fatal ("failed sanity check.");
552 case 'x': /* 16 bit constant, zero-extended */
553 case 'X': /* 16 bit constant, one-extended */
554 if (operand
->X_op
== O_constant
)
556 opcode
|= (operand
->X_add_number
& 0xFF) << 0 |
557 ((operand
->X_add_number
& 0xFF00) << 8);
560 the_insn
.reloc
= RELOC_CONST
;
561 the_insn
.exp
= *operand
;
565 if (operand
->X_op
== O_constant
)
567 opcode
|= (operand
->X_add_number
& 0x00FF0000) >> 16 |
568 (((unsigned long) operand
->X_add_number
569 /* avoid sign ext */ & 0xFF000000) >> 8);
572 the_insn
.reloc
= RELOC_CONSTH
;
573 the_insn
.exp
= *operand
;
576 case 'P': /* PC-relative jump address */
577 case 'A': /* Absolute jump address */
578 /* These two are treated together since we folded the
579 opcode table entries together. */
580 if (operand
->X_op
== O_constant
)
582 /* Make sure the 'A' case really exists. */
583 if ((insn
->opcode
| ABSOLUTE_BIT
) != (insn
+ 1)->opcode
)
588 v
= operand
->X_add_number
& ~ mask
;
590 as_bad ("call/jmp target out of range");
592 opcode
|= ABSOLUTE_BIT
|
593 (operand
->X_add_number
& 0x0003FC00) << 6 |
594 ((operand
->X_add_number
& 0x000003FC) >> 2);
597 the_insn
.reloc
= RELOC_JUMPTARG
;
598 the_insn
.exp
= *operand
;
599 the_insn
.pcrel
= 1; /* Assume PC-relative jump */
600 /* FIXME-SOON, Do we figure out whether abs later, after
604 case 'e': /* Coprocessor enable bit for LOAD/STORE insn */
605 if (operand
->X_op
== O_constant
)
607 if (operand
->X_add_number
== 0)
609 if (operand
->X_add_number
== 1)
617 case 'n': /* Control bits for LOAD/STORE instructions */
618 if (operand
->X_op
== O_constant
&&
619 operand
->X_add_number
< 128)
621 opcode
|= (operand
->X_add_number
<< 16);
626 case 's': /* Special register number */
627 if (operand
->X_op
!= O_register
)
628 break; /* Only registers */
629 if (operand
->X_add_number
< SREG
)
630 break; /* Not a special register */
631 opcode
|= (operand
->X_add_number
& 0xFF) << 8;
634 case 'u': /* UI bit of CONVERT */
635 if (operand
->X_op
== O_constant
)
637 if (operand
->X_add_number
== 0)
639 if (operand
->X_add_number
== 1)
647 case 'r': /* RND bits of CONVERT */
648 if (operand
->X_op
== O_constant
&&
649 operand
->X_add_number
< 8)
651 opcode
|= operand
->X_add_number
<< 4;
656 case 'I': /* ID bits of INV and IRETINV. */
657 /* This operand is optional. */
658 if (operand
->X_op
== O_absent
)
660 else if (operand
->X_op
== O_constant
661 && operand
->X_add_number
< 4)
663 opcode
|= operand
->X_add_number
<< 16;
668 case 'd': /* FD bits of CONVERT */
669 if (operand
->X_op
== O_constant
&&
670 operand
->X_add_number
< 4)
672 opcode
|= operand
->X_add_number
<< 2;
678 case 'f': /* FS bits of CONVERT */
679 if (operand
->X_op
== O_constant
&&
680 operand
->X_add_number
< 4)
682 opcode
|= operand
->X_add_number
<< 0;
688 if (operand
->X_op
== O_constant
&&
689 operand
->X_add_number
< 4)
691 opcode
|= operand
->X_add_number
<< 16;
697 if (operand
->X_op
== O_constant
&&
698 operand
->X_add_number
< 16)
700 opcode
|= operand
->X_add_number
<< 18;
708 /* Types or values of args don't match. */
709 as_bad ("Invalid operands");
714 /* This is identical to the md_atof in m68k.c. I think this is right,
717 Turn a string in input_line_pointer into a floating point constant
718 of type type, and store the appropriate bytes in *litP. The number
719 of LITTLENUMS emitted is stored in *sizeP . An error message is
720 returned, or NULL on OK. */
722 /* Equal to MAX_PRECISION in atof-ieee.c */
723 #define MAX_LITTLENUMS 6
726 md_atof (type
, litP
, sizeP
)
732 LITTLENUM_TYPE words
[MAX_LITTLENUMS
];
733 LITTLENUM_TYPE
*wordP
;
765 return "Bad call to MD_ATOF()";
767 t
= atof_ieee (input_line_pointer
, type
, words
);
769 input_line_pointer
= t
;
770 *sizeP
= prec
* sizeof (LITTLENUM_TYPE
);
771 for (wordP
= words
; prec
--;)
773 md_number_to_chars (litP
, (valueT
) (*wordP
++), sizeof (LITTLENUM_TYPE
));
774 litP
+= sizeof (LITTLENUM_TYPE
);
780 * Write out big-endian.
783 md_number_to_chars (buf
, val
, n
)
788 number_to_chars_bigendian (buf
, val
, n
);
792 md_apply_fix (fixP
, val
)
796 char *buf
= fixP
->fx_where
+ fixP
->fx_frag
->fr_literal
;
798 fixP
->fx_addnumber
= val
; /* Remember value for emit_reloc */
801 know (fixP
->fx_size
== 4);
802 know (fixP
->fx_r_type
< NO_RELOC
);
804 /* This is a hack. There should be a better way to handle this. */
805 if (fixP
->fx_r_type
== RELOC_WDISP30
&& fixP
->fx_addsy
)
807 val
+= fixP
->fx_where
+ fixP
->fx_frag
->fr_address
;
810 switch (fixP
->fx_r_type
)
825 val
= (val
>>= 2) + 1;
826 buf
[0] |= (val
>> 24) & 0x3f;
827 buf
[1] = (val
>> 16);
833 buf
[1] |= (val
>> 26) & 0x3f;
839 buf
[2] |= (val
>> 8) & 0x03;
844 buf
[2] |= (val
>> 8) & 0x1f;
849 val
= (val
>>= 2) + 1;
852 buf
[1] |= (val
>> 16) & 0x3f;
857 case RELOC_JUMPTARG
: /* 00XX00XX pattern in a word */
859 /* let linker deal */
861 else if (fixP
->fx_pcrel
)
864 if (v
!= 0 && v
!= -1)
865 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
866 "call/jmp target out of range");
869 /* this case was supposed to be handled in machine_ip */
871 buf
[1] = val
>> 10; /* Holds bits 0003FFFC of address */
875 case RELOC_CONST
: /* 00XX00XX pattern in a word */
876 buf
[1] = val
>> 8; /* Holds bits 0000XXXX */
880 case RELOC_CONSTH
: /* 00XX00XX pattern in a word */
881 buf
[1] = val
>> 24; /* Holds bits XXXX0000 */
887 as_bad ("bad relocation type: 0x%02x", fixP
->fx_r_type
);
894 tc_coff_fix2rtype (fixP
)
898 switch (fixP
->fx_r_type
)
911 printf ("need %o3\n", fixP
->fx_r_type
);
913 } /* switch on type */
918 #endif /* OBJ_COFF */
920 /* should never be called for 29k */
922 md_create_short_jump (ptr
, from_addr
, to_addr
, frag
, to_symbol
)
924 addressT from_addr
, to_addr
;
928 as_fatal ("a29k_create_short_jmp\n");
931 /* should never be called for 29k */
933 md_convert_frag (headers
, fragP
)
934 object_headers
*headers
;
935 register fragS
*fragP
;
937 as_fatal ("a29k_convert_frag\n");
940 /* should never be called for 29k */
942 md_create_long_jump (ptr
, from_addr
, to_addr
, frag
, to_symbol
)
949 as_fatal ("a29k_create_long_jump\n");
952 /* should never be called for a29k */
954 md_estimate_size_before_relax (fragP
, segtype
)
955 register fragS
*fragP
;
958 as_fatal ("a29k_estimate_size_before_relax\n");
963 /* for debugging only */
966 struct machine_it
*insn
;
999 fprintf (stderr
, "ERROR: %s\n");
1001 fprintf (stderr
, "opcode=0x%08x\n", insn
->opcode
);
1002 fprintf (stderr
, "reloc = %s\n", Reloc
[insn
->reloc
]);
1003 fprintf (stderr
, "exp = {\n");
1004 fprintf (stderr
, "\t\tX_add_symbol = %s\n",
1005 insn
->exp
.X_add_symbol
?
1006 (S_GET_NAME (insn
->exp
.X_add_symbol
) ?
1007 S_GET_NAME (insn
->exp
.X_add_symbol
) : "???") : "0");
1008 fprintf (stderr
, "\t\tX_op_symbol = %s\n",
1009 insn
->exp
.X_op_symbol
?
1010 (S_GET_NAME (insn
->exp
.X_op_symbol
) ?
1011 S_GET_NAME (insn
->exp
.X_op_symbol
) : "???") : "0");
1012 fprintf (stderr
, "\t\tX_add_number = %d\n",
1013 insn
->exp
.X_add_number
);
1014 fprintf (stderr
, "}\n");
1019 /* Translate internal representation of relocation info to target format.
1021 On sparc/29k: first 4 bytes are normal unsigned long address, next three
1022 bytes are index, most sig. byte first. Byte 7 is broken up with
1023 bit 7 as external, bits 6 & 5 unused, and the lower
1024 five bits as relocation type. Next 4 bytes are long addend. */
1025 /* Thanx and a tip of the hat to Michael Bloom, mb@ttidca.tti.com */
1030 tc_aout_fix_to_chars (where
, fixP
, segment_address_in_file
)
1033 relax_addressT segment_address_in_file
;
1037 know (fixP
->fx_r_type
< NO_RELOC
);
1038 know (fixP
->fx_addsy
!= NULL
);
1040 md_number_to_chars (where
,
1041 fixP
->fx_frag
->fr_address
+ fixP
->fx_where
- segment_address_in_file
,
1044 r_symbolnum
= (S_IS_DEFINED (fixP
->fx_addsy
)
1045 ? S_GET_TYPE (fixP
->fx_addsy
)
1046 : fixP
->fx_addsy
->sy_number
);
1048 where
[4] = (r_symbolnum
>> 16) & 0x0ff;
1049 where
[5] = (r_symbolnum
>> 8) & 0x0ff;
1050 where
[6] = r_symbolnum
& 0x0ff;
1051 where
[7] = (((!S_IS_DEFINED (fixP
->fx_addsy
)) << 7) & 0x80) | (0 & 0x60) | (fixP
->fx_r_type
& 0x1F);
1053 md_number_to_chars (&where
[8], fixP
->fx_addnumber
, 4);
1056 #endif /* OBJ_AOUT */
1058 CONST
char *md_shortopts
= "";
1059 struct option md_longopts
[] = {
1060 {NULL
, no_argument
, NULL
, 0}
1062 size_t md_longopts_size
= sizeof(md_longopts
);
1065 md_parse_option (c
, arg
)
1073 md_show_usage (stream
)
1078 /* Default the values of symbols known that should be "predefined". We
1079 don't bother to predefine them unless you actually use one, since there
1080 are a lot of them. */
1083 md_undefined_symbol (name
)
1087 char testbuf
[5 + /*SLOP*/ 5];
1089 if (name
[0] == 'g' || name
[0] == 'G'
1090 || name
[0] == 'l' || name
[0] == 'L'
1091 || name
[0] == 's' || name
[0] == 'S')
1093 /* Perhaps a global or local register name */
1094 if (name
[1] == 'r' || name
[1] == 'R')
1098 /* Parse the number, make sure it has no extra zeroes or
1100 regnum
= atol (&name
[2]);
1102 if (name
[0] == 's' || name
[0] == 'S')
1106 if (regnum
> maxreg
)
1109 sprintf (testbuf
, "%ld", regnum
);
1110 if (strcmp (testbuf
, &name
[2]) != 0)
1111 return NULL
; /* gr007 or lr7foo or whatever */
1113 /* We have a wiener! Define and return a new symbol for it. */
1114 if (name
[0] == 'l' || name
[0] == 'L')
1116 else if (name
[0] == 's' || name
[0] == 'S')
1118 return (symbol_new (name
, SEG_REGISTER
, (valueT
) regnum
,
1119 &zero_address_frag
));
1126 /* Parse an operand that is machine-specific. */
1129 md_operand (expressionP
)
1130 expressionS
*expressionP
;
1133 if (input_line_pointer
[0] == '%' && input_line_pointer
[1] == '%')
1135 /* We have a numeric register expression. No biggy. */
1136 input_line_pointer
+= 2; /* Skip %% */
1137 (void) expression (expressionP
);
1138 if (expressionP
->X_op
!= O_constant
1139 || expressionP
->X_add_number
> 255)
1140 as_bad ("Invalid expression after %%%%\n");
1141 expressionP
->X_op
= O_register
;
1143 else if (input_line_pointer
[0] == '&')
1145 /* We are taking the 'address' of a register...this one is not
1146 in the manual, but it *is* in traps/fpsymbol.h! What they
1147 seem to want is the register number, as an absolute number. */
1148 input_line_pointer
++; /* Skip & */
1149 (void) expression (expressionP
);
1150 if (expressionP
->X_op
!= O_register
)
1151 as_bad ("Invalid register in & expression");
1153 expressionP
->X_op
= O_constant
;
1157 /* Round up a section size to the appropriate boundary. */
1159 md_section_align (segment
, size
)
1163 return size
; /* Byte alignment is fine */
1166 /* Exactly what point is a PC-relative offset relative TO?
1167 On the 29000, they're relative to the address of the instruction,
1168 which we have set up as the address of the fixup too. */
1170 md_pcrel_from (fixP
)
1173 return fixP
->fx_where
+ fixP
->fx_frag
->fr_address
;
1176 /* end of tc-a29k.c */