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. */
126 static unsigned char octal
[256];
127 #define isoctal(c) octal[c]
128 static unsigned char toHex
[256];
131 * anull bit - causes the branch delay slot instructions to not be executed
133 #define ANNUL (1 << 29)
141 if (strncmp (input_line_pointer
, ".text", 5) == 0)
143 input_line_pointer
+= 5;
147 if (strncmp (input_line_pointer
, ".data", 5) == 0)
149 input_line_pointer
+= 5;
153 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 from
160 instruction memory on some 29k's. So, into initialized data. */
161 if (strncmp (input_line_pointer
, ".lit", 4) == 0)
163 input_line_pointer
+= 4;
164 subseg_set (SEG_DATA
, 200);
165 demand_empty_rest_of_line ();
169 as_bad ("Unknown segment type");
170 demand_empty_rest_of_line ();
176 subseg_set (SEG_DATA
, 1);
177 demand_empty_rest_of_line ();
180 #endif /* OBJ_COFF */
182 /* Install symbol definition that maps REGNAME to REGNO.
183 FIXME-SOON: These are not recognized in mixed case. */
186 insert_sreg (regname
, regnum
)
190 /* FIXME-SOON, put something in these syms so they won't be output
191 to the symbol table of the resulting object file. */
193 /* Must be large enough to hold the names of the special registers. */
197 symbol_table_insert (symbol_new (regname
, SEG_REGISTER
, (valueT
) regnum
,
198 &zero_address_frag
));
199 for (i
= 0; regname
[i
]; i
++)
200 buf
[i
] = islower (regname
[i
]) ? toupper (regname
[i
]) : regname
[i
];
203 symbol_table_insert (symbol_new (buf
, SEG_REGISTER
, (valueT
) regnum
,
204 &zero_address_frag
));
207 /* Install symbol definitions for assorted special registers.
208 See ASM29K Ref page 2-9. */
215 /* Protected special-purpose register names */
216 insert_sreg ("vab", SREG
+ 0);
217 insert_sreg ("ops", SREG
+ 1);
218 insert_sreg ("cps", SREG
+ 2);
219 insert_sreg ("cfg", SREG
+ 3);
220 insert_sreg ("cha", SREG
+ 4);
221 insert_sreg ("chd", SREG
+ 5);
222 insert_sreg ("chc", SREG
+ 6);
223 insert_sreg ("rbp", SREG
+ 7);
224 insert_sreg ("tmc", SREG
+ 8);
225 insert_sreg ("tmr", SREG
+ 9);
226 insert_sreg ("pc0", SREG
+ 10);
227 insert_sreg ("pc1", SREG
+ 11);
228 insert_sreg ("pc2", SREG
+ 12);
229 insert_sreg ("mmu", SREG
+ 13);
230 insert_sreg ("lru", SREG
+ 14);
232 /* Additional protected special-purpose registers for the 29050 */
233 insert_sreg ("rsn", SREG
+ 15);
234 insert_sreg ("rma0", SREG
+ 16);
235 insert_sreg ("rmc0", SREG
+ 17);
236 insert_sreg ("rma1", SREG
+ 18);
237 insert_sreg ("rmc1", SREG
+ 19);
238 insert_sreg ("spc0", SREG
+ 20);
239 insert_sreg ("spc1", SREG
+ 21);
240 insert_sreg ("spc2", SREG
+ 22);
241 insert_sreg ("iba0", SREG
+ 23);
242 insert_sreg ("ibc0", SREG
+ 24);
243 insert_sreg ("iba1", SREG
+ 25);
244 insert_sreg ("ibc1", SREG
+ 26);
246 /* Additional registers for the 29040. */
247 insert_sreg ("dba", SREG
+ 27);
248 insert_sreg ("dbc", SREG
+ 28);
249 insert_sreg ("cir", SREG
+ 29);
250 insert_sreg ("cdr", SREG
+ 30);
252 /* Unprotected special-purpose register names */
253 insert_sreg ("ipc", SREG
+ 128);
254 insert_sreg ("ipa", SREG
+ 129);
255 insert_sreg ("ipb", SREG
+ 130);
256 insert_sreg ("q", SREG
+ 131);
257 insert_sreg ("alu", SREG
+ 132);
258 insert_sreg ("bp", SREG
+ 133);
259 insert_sreg ("fc", SREG
+ 134);
260 insert_sreg ("cr", SREG
+ 135);
261 insert_sreg ("fpe", SREG
+ 160);
262 insert_sreg ("inte", SREG
+ 161);
263 insert_sreg ("fps", SREG
+ 162);
264 /* "", SREG+163); Reserved */
265 insert_sreg ("exop", SREG
+ 164);
268 /* This function is called once, at assembler startup time. It should
269 set up all the tables, etc., that the MD part of the assembler will
274 register const char *retval
= NULL
;
276 register int skipnext
= 0;
277 register unsigned int i
;
278 register char *strend
, *strend2
;
280 /* Hash up all the opcodes for fast use later. */
282 op_hash
= hash_new ();
284 for (i
= 0; i
< num_opcodes
; i
++)
286 const char *name
= machine_opcodes
[i
].name
;
294 /* Hack to avoid multiple opcode entries. We pre-locate all the
295 variations (b/i field and P/A field) and handle them. */
297 if (!strcmp (name
, machine_opcodes
[i
+ 1].name
))
299 if ((machine_opcodes
[i
].opcode
& 0x01000000) != 0
300 || (machine_opcodes
[i
+ 1].opcode
& 0x01000000) == 0
301 || ((machine_opcodes
[i
].opcode
| 0x01000000)
302 != machine_opcodes
[i
+ 1].opcode
))
304 strend
= machine_opcodes
[i
].args
+ strlen (machine_opcodes
[i
].args
) - 1;
305 strend2
= machine_opcodes
[i
+ 1].args
+ strlen (machine_opcodes
[i
+ 1].args
) - 1;
318 fprintf (stderr
, "internal error: can't handle opcode %s\n",
323 /* OK, this is an i/b or A/P pair. We skip the
324 higher-valued one, and let the code for operand checking
325 handle OR-ing in the bit. */
329 retval
= hash_insert (op_hash
, name
, (PTR
) &machine_opcodes
[i
]);
332 fprintf (stderr
, "internal error: can't hash `%s': %s\n",
333 machine_opcodes
[i
].name
, retval
);
339 as_fatal ("Broken assembler. No assembly attempted.");
341 for (i
= '0'; i
< '8'; ++i
)
343 for (i
= '0'; i
<= '9'; ++i
)
345 for (i
= 'a'; i
<= 'f'; ++i
)
346 toHex
[i
] = i
+ 10 - 'a';
347 for (i
= 'A'; i
<= 'F'; ++i
)
348 toHex
[i
] = i
+ 10 - 'A';
353 /* Assemble a single instruction. Its label has already been handled
354 by the generic front end. We just parse opcode and operands, and
355 produce the bytes of data and relocation. */
366 /* put out the opcode */
367 md_number_to_chars (toP
, the_insn
.opcode
, 4);
369 /* put out the symbol-dependent stuff */
370 if (the_insn
.reloc
!= NO_RELOC
)
372 fix_new_exp (frag_now
,
373 (toP
- frag_now
->fr_literal
+ the_insn
.reloc_offset
),
382 parse_operand (s
, operandp
, opt
)
384 expressionS
*operandp
;
387 char *save
= input_line_pointer
;
390 input_line_pointer
= s
;
391 expression (operandp
);
392 if (operandp
->X_op
== O_absent
&& ! opt
)
393 as_bad ("missing operand");
394 new = input_line_pointer
;
395 input_line_pointer
= save
;
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. */
409 struct machine_opcode
*insn
;
411 unsigned long opcode
;
412 expressionS the_operand
;
413 expressionS
*operand
= &the_operand
;
416 /* Must handle `div0' opcode. */
419 for (; isalnum (*s
); ++s
)
428 case ' ': /* FIXME-SOMEDAY more whitespace */
433 as_bad ("Unknown opcode: `%s'", str
);
436 if ((insn
= (struct machine_opcode
*) hash_find (op_hash
, str
)) == NULL
)
438 as_bad ("Unknown opcode `%s'.", str
);
442 opcode
= insn
->opcode
;
443 memset (&the_insn
, '\0', sizeof (the_insn
));
444 the_insn
.reloc
= NO_RELOC
;
446 /* Build the opcode, checking as we go to make sure that the
449 If an operand matches, we modify the_insn or opcode appropriately,
450 and do a "continue". If an operand fails to match, we "break". */
452 if (insn
->args
[0] != '\0')
454 /* Prime the pump. */
455 s
= parse_operand (s
, operand
, insn
->args
[0] == 'I');
458 for (args
= insn
->args
;; ++args
)
463 case '\0': /* end of args */
466 /* We are truly done. */
467 the_insn
.opcode
= opcode
;
470 as_bad ("Too many operands: %s", s
);
473 case ',': /* Must match a comma */
476 /* Parse next operand. */
477 s
= parse_operand (s
, operand
, args
[1] == 'I');
482 case 'v': /* Trap numbers (immediate field) */
483 if (operand
->X_op
== O_constant
)
485 if (operand
->X_add_number
< 256)
487 opcode
|= (operand
->X_add_number
<< 16);
492 as_bad ("Immediate value of %ld is too large",
493 (long) operand
->X_add_number
);
497 the_insn
.reloc
= RELOC_8
;
498 the_insn
.reloc_offset
= 1; /* BIG-ENDIAN Byte 1 of insn */
499 the_insn
.exp
= *operand
;
502 case 'b': /* A general register or 8-bit immediate */
504 /* We treat the two cases identically since we mashed
505 them together in the opcode table. */
506 if (operand
->X_op
== O_register
)
509 /* Make sure the 'i' case really exists. */
510 if ((insn
->opcode
| IMMEDIATE_BIT
) != (insn
+ 1)->opcode
)
513 opcode
|= IMMEDIATE_BIT
;
514 if (operand
->X_op
== O_constant
)
516 if (operand
->X_add_number
< 256)
518 opcode
|= operand
->X_add_number
;
523 as_bad ("Immediate value of %ld is too large",
524 (long) operand
->X_add_number
);
528 the_insn
.reloc
= RELOC_8
;
529 the_insn
.reloc_offset
= 3; /* BIG-ENDIAN Byte 3 of insn */
530 the_insn
.exp
= *operand
;
533 case 'a': /* next operand must be a register */
536 /* lrNNN or grNNN or %%expr or a user-def register name */
537 if (operand
->X_op
!= O_register
)
538 break; /* Only registers */
539 know (operand
->X_add_symbol
== 0);
540 know (operand
->X_op_symbol
== 0);
541 reg
= operand
->X_add_number
;
543 break; /* No special registers */
545 /* Got the register, now figure out where it goes in the
562 as_fatal ("failed sanity check.");
565 case 'x': /* 16 bit constant, zero-extended */
566 case 'X': /* 16 bit constant, one-extended */
567 if (operand
->X_op
== O_constant
)
569 opcode
|= (operand
->X_add_number
& 0xFF) << 0 |
570 ((operand
->X_add_number
& 0xFF00) << 8);
573 the_insn
.reloc
= RELOC_CONST
;
574 the_insn
.exp
= *operand
;
578 if (operand
->X_op
== O_constant
)
580 opcode
|= (operand
->X_add_number
& 0x00FF0000) >> 16 |
581 (((unsigned long) operand
->X_add_number
582 /* avoid sign ext */ & 0xFF000000) >> 8);
585 the_insn
.reloc
= RELOC_CONSTH
;
586 the_insn
.exp
= *operand
;
589 case 'P': /* PC-relative jump address */
590 case 'A': /* Absolute jump address */
591 /* These two are treated together since we folded the
592 opcode table entries together. */
593 if (operand
->X_op
== O_constant
)
595 /* Make sure the 'A' case really exists. */
596 if ((insn
->opcode
| ABSOLUTE_BIT
) != (insn
+ 1)->opcode
)
598 opcode
|= ABSOLUTE_BIT
|
599 (operand
->X_add_number
& 0x0003FC00) << 6 |
600 ((operand
->X_add_number
& 0x000003FC) >> 2);
603 the_insn
.reloc
= RELOC_JUMPTARG
;
604 the_insn
.exp
= *operand
;
605 the_insn
.pcrel
= 1; /* Assume PC-relative jump */
606 /* FIXME-SOON, Do we figure out whether abs later, after
610 case 'e': /* Coprocessor enable bit for LOAD/STORE insn */
611 if (operand
->X_op
== O_constant
)
613 if (operand
->X_add_number
== 0)
615 if (operand
->X_add_number
== 1)
623 case 'n': /* Control bits for LOAD/STORE instructions */
624 if (operand
->X_op
== O_constant
&&
625 operand
->X_add_number
< 128)
627 opcode
|= (operand
->X_add_number
<< 16);
632 case 's': /* Special register number */
633 if (operand
->X_op
!= O_register
)
634 break; /* Only registers */
635 if (operand
->X_add_number
< SREG
)
636 break; /* Not a special register */
637 opcode
|= (operand
->X_add_number
& 0xFF) << 8;
640 case 'u': /* UI bit of CONVERT */
641 if (operand
->X_op
== O_constant
)
643 if (operand
->X_add_number
== 0)
645 if (operand
->X_add_number
== 1)
653 case 'r': /* RND bits of CONVERT */
654 if (operand
->X_op
== O_constant
&&
655 operand
->X_add_number
< 8)
657 opcode
|= operand
->X_add_number
<< 4;
662 case 'I': /* ID bits of INV and IRETINV. */
663 /* This operand is optional. */
664 if (operand
->X_op
== O_absent
)
666 else if (operand
->X_op
== O_constant
667 && operand
->X_add_number
< 4)
669 opcode
|= operand
->X_add_number
<< 16;
674 case 'd': /* FD bits of CONVERT */
675 if (operand
->X_op
== O_constant
&&
676 operand
->X_add_number
< 4)
678 opcode
|= operand
->X_add_number
<< 2;
684 case 'f': /* FS bits of CONVERT */
685 if (operand
->X_op
== O_constant
&&
686 operand
->X_add_number
< 4)
688 opcode
|= operand
->X_add_number
<< 0;
694 if (operand
->X_op
== O_constant
&&
695 operand
->X_add_number
< 4)
697 opcode
|= operand
->X_add_number
<< 16;
703 if (operand
->X_op
== O_constant
&&
704 operand
->X_add_number
< 16)
706 opcode
|= operand
->X_add_number
<< 18;
714 /* Types or values of args don't match. */
715 as_bad ("Invalid operands");
720 /* This is identical to the md_atof in m68k.c. I think this is right,
723 Turn a string in input_line_pointer into a floating point constant
724 of type type, and store the appropriate bytes in *litP. The number
725 of LITTLENUMS emitted is stored in *sizeP . An error message is
726 returned, or NULL on OK. */
728 /* Equal to MAX_PRECISION in atof-ieee.c */
729 #define MAX_LITTLENUMS 6
732 md_atof (type
, litP
, sizeP
)
738 LITTLENUM_TYPE words
[MAX_LITTLENUMS
];
739 LITTLENUM_TYPE
*wordP
;
771 return "Bad call to MD_ATOF()";
773 t
= atof_ieee (input_line_pointer
, type
, words
);
775 input_line_pointer
= t
;
776 *sizeP
= prec
* sizeof (LITTLENUM_TYPE
);
777 for (wordP
= words
; prec
--;)
779 md_number_to_chars (litP
, (valueT
) (*wordP
++), sizeof (LITTLENUM_TYPE
));
780 litP
+= sizeof (LITTLENUM_TYPE
);
786 * Write out big-endian.
789 md_number_to_chars (buf
, val
, n
)
794 number_to_chars_bigendian (buf
, val
, n
);
798 md_apply_fix (fixP
, val
)
802 char *buf
= fixP
->fx_where
+ fixP
->fx_frag
->fr_literal
;
804 fixP
->fx_addnumber
= val
; /* Remember value for emit_reloc */
807 know (fixP
->fx_size
== 4);
808 know (fixP
->fx_r_type
< NO_RELOC
);
810 /* This is a hack. There should be a better way to handle this. */
811 if (fixP
->fx_r_type
== RELOC_WDISP30
&& fixP
->fx_addsy
)
813 val
+= fixP
->fx_where
+ fixP
->fx_frag
->fr_address
;
816 switch (fixP
->fx_r_type
)
831 val
= (val
>>= 2) + 1;
832 buf
[0] |= (val
>> 24) & 0x3f;
833 buf
[1] = (val
>> 16);
839 buf
[1] |= (val
>> 26) & 0x3f;
845 buf
[2] |= (val
>> 8) & 0x03;
850 buf
[2] |= (val
>> 8) & 0x1f;
855 val
= (val
>>= 2) + 1;
858 buf
[1] |= (val
>> 16) & 0x3f;
872 case RELOC_JUMPTARG
: /* 00XX00XX pattern in a word */
873 buf
[1] = val
>> 10; /* Holds bits 0003FFFC of address */
877 case RELOC_CONST
: /* 00XX00XX pattern in a word */
878 buf
[1] = val
>> 8; /* Holds bits 0000XXXX */
882 case RELOC_CONSTH
: /* 00XX00XX pattern in a word */
883 buf
[1] = val
>> 24; /* Holds bits XXXX0000 */
889 as_bad ("bad relocation type: 0x%02x", fixP
->fx_r_type
);
896 tc_coff_fix2rtype (fixP
)
900 switch (fixP
->fx_r_type
)
913 printf ("need %o3\n", fixP
->fx_r_type
);
915 } /* switch on type */
920 #endif /* OBJ_COFF */
922 /* should never be called for 29k */
924 md_create_short_jump (ptr
, from_addr
, to_addr
, frag
, to_symbol
)
926 addressT from_addr
, to_addr
;
930 as_fatal ("a29k_create_short_jmp\n");
933 /* should never be called for 29k */
935 md_convert_frag (headers
, fragP
)
936 object_headers
*headers
;
937 register fragS
*fragP
;
939 as_fatal ("a29k_convert_frag\n");
942 /* should never be called for 29k */
944 md_create_long_jump (ptr
, from_addr
, to_addr
, frag
, to_symbol
)
951 as_fatal ("a29k_create_long_jump\n");
954 /* should never be called for a29k */
956 md_estimate_size_before_relax (fragP
, segtype
)
957 register fragS
*fragP
;
960 as_fatal ("a29k_estimate_size_before_relax\n");
965 /* for debugging only */
968 struct machine_it
*insn
;
1001 fprintf (stderr
, "ERROR: %s\n");
1003 fprintf (stderr
, "opcode=0x%08x\n", insn
->opcode
);
1004 fprintf (stderr
, "reloc = %s\n", Reloc
[insn
->reloc
]);
1005 fprintf (stderr
, "exp = {\n");
1006 fprintf (stderr
, "\t\tX_add_symbol = %s\n",
1007 insn
->exp
.X_add_symbol
?
1008 (S_GET_NAME (insn
->exp
.X_add_symbol
) ?
1009 S_GET_NAME (insn
->exp
.X_add_symbol
) : "???") : "0");
1010 fprintf (stderr
, "\t\tX_op_symbol = %s\n",
1011 insn
->exp
.X_op_symbol
?
1012 (S_GET_NAME (insn
->exp
.X_op_symbol
) ?
1013 S_GET_NAME (insn
->exp
.X_op_symbol
) : "???") : "0");
1014 fprintf (stderr
, "\t\tX_add_number = %d\n",
1015 insn
->exp
.X_add_number
);
1016 fprintf (stderr
, "}\n");
1021 /* Translate internal representation of relocation info to target format.
1023 On sparc/29k: first 4 bytes are normal unsigned long address, next three
1024 bytes are index, most sig. byte first. Byte 7 is broken up with
1025 bit 7 as external, bits 6 & 5 unused, and the lower
1026 five bits as relocation type. Next 4 bytes are long addend. */
1027 /* Thanx and a tip of the hat to Michael Bloom, mb@ttidca.tti.com */
1032 tc_aout_fix_to_chars (where
, fixP
, segment_address_in_file
)
1035 relax_addressT segment_address_in_file
;
1039 know (fixP
->fx_r_type
< NO_RELOC
);
1040 know (fixP
->fx_addsy
!= NULL
);
1042 md_number_to_chars (where
,
1043 fixP
->fx_frag
->fr_address
+ fixP
->fx_where
- segment_address_in_file
,
1046 r_symbolnum
= (S_IS_DEFINED (fixP
->fx_addsy
)
1047 ? S_GET_TYPE (fixP
->fx_addsy
)
1048 : fixP
->fx_addsy
->sy_number
);
1050 where
[4] = (r_symbolnum
>> 16) & 0x0ff;
1051 where
[5] = (r_symbolnum
>> 8) & 0x0ff;
1052 where
[6] = r_symbolnum
& 0x0ff;
1053 where
[7] = (((!S_IS_DEFINED (fixP
->fx_addsy
)) << 7) & 0x80) | (0 & 0x60) | (fixP
->fx_r_type
& 0x1F);
1055 md_number_to_chars (&where
[8], fixP
->fx_addnumber
, 4);
1058 #endif /* OBJ_AOUT */
1060 CONST
char *md_shortopts
= "";
1061 struct option md_longopts
[] = {
1062 {NULL
, no_argument
, NULL
, 0}
1064 size_t md_longopts_size
= sizeof(md_longopts
);
1067 md_parse_option (c
, arg
)
1075 md_show_usage (stream
)
1080 /* Default the values of symbols known that should be "predefined". We
1081 don't bother to predefine them unless you actually use one, since there
1082 are a lot of them. */
1085 md_undefined_symbol (name
)
1089 char testbuf
[5 + /*SLOP*/ 5];
1091 if (name
[0] == 'g' || name
[0] == 'G'
1092 || name
[0] == 'l' || name
[0] == 'L'
1093 || name
[0] == 's' || name
[0] == 'S')
1095 /* Perhaps a global or local register name */
1096 if (name
[1] == 'r' || name
[1] == 'R')
1100 /* Parse the number, make sure it has no extra zeroes or
1102 regnum
= atol (&name
[2]);
1104 if (name
[0] == 's' || name
[0] == 'S')
1108 if (regnum
> maxreg
)
1111 sprintf (testbuf
, "%ld", regnum
);
1112 if (strcmp (testbuf
, &name
[2]) != 0)
1113 return NULL
; /* gr007 or lr7foo or whatever */
1115 /* We have a wiener! Define and return a new symbol for it. */
1116 if (name
[0] == 'l' || name
[0] == 'L')
1118 else if (name
[0] == 's' || name
[0] == 'S')
1120 return (symbol_new (name
, SEG_REGISTER
, (valueT
) regnum
,
1121 &zero_address_frag
));
1128 /* Parse an operand that is machine-specific. */
1131 md_operand (expressionP
)
1132 expressionS
*expressionP
;
1135 if (input_line_pointer
[0] == '%' && input_line_pointer
[1] == '%')
1137 /* We have a numeric register expression. No biggy. */
1138 input_line_pointer
+= 2; /* Skip %% */
1139 (void) expression (expressionP
);
1140 if (expressionP
->X_op
!= O_constant
1141 || expressionP
->X_add_number
> 255)
1142 as_bad ("Invalid expression after %%%%\n");
1143 expressionP
->X_op
= O_register
;
1145 else if (input_line_pointer
[0] == '&')
1147 /* We are taking the 'address' of a register...this one is not
1148 in the manual, but it *is* in traps/fpsymbol.h! What they
1149 seem to want is the register number, as an absolute number. */
1150 input_line_pointer
++; /* Skip & */
1151 (void) expression (expressionP
);
1152 if (expressionP
->X_op
!= O_register
)
1153 as_bad ("Invalid register in & expression");
1155 expressionP
->X_op
= O_constant
;
1159 /* Round up a section size to the appropriate boundary. */
1161 md_section_align (segment
, size
)
1165 return size
; /* Byte alignment is fine */
1168 /* Exactly what point is a PC-relative offset relative TO?
1169 On the 29000, they're relative to the address of the instruction,
1170 which we have set up as the address of the fixup too. */
1172 md_pcrel_from (fixP
)
1175 return fixP
->fx_where
+ fixP
->fx_frag
->fr_address
;
1178 /* end of tc-a29k.c */