2 Not part of GAS yet. */
7 /* this bit glommed from tahoe-inst.h */
9 typedef unsigned char byte
;
10 typedef byte tahoe_opcodeT
;
13 * This is part of tahoe-ins-parse.c & friends.
14 * We want to parse a tahoe instruction text into a tree defined here.
17 #define TIT_MAX_OPERANDS (4) /* maximum number of operands in one
18 single tahoe instruction */
20 struct top
/* tahoe instruction operand */
22 int top_ndx
; /* -1, or index register. eg 7=[R7] */
23 int top_reg
; /* -1, or register number. eg 7 = R7 or (R7) */
24 byte top_mode
; /* Addressing mode byte. This byte, defines
25 which of the 11 modes opcode is. */
27 char top_access
; /* Access type wanted for this opperand
28 'b'branch ' 'no-instruction 'amrvw' */
29 char top_width
; /* Operand width expected, one of "bwlq?-:!" */
31 char *top_error
; /* Say if operand is inappropriate */
33 segT seg_of_operand
; /* segment as returned by expression()*/
35 expressionS exp_of_operand
; /* The expression as parsed by expression()*/
37 byte top_dispsize
; /* Number of bytes in the displacement if we
41 /* The addressing modes for an operand. These numbers are the acutal values
42 for certain modes, so be carefull if you screw with them. */
43 #define TAHOE_DIRECT_REG (0x50)
44 #define TAHOE_REG_DEFERRED (0x60)
46 #define TAHOE_REG_DISP (0xE0)
47 #define TAHOE_REG_DISP_DEFERRED (0xF0)
49 #define TAHOE_IMMEDIATE (0x8F)
50 #define TAHOE_IMMEDIATE_BYTE (0x88)
51 #define TAHOE_IMMEDIATE_WORD (0x89)
52 #define TAHOE_IMMEDIATE_LONGWORD (0x8F)
53 #define TAHOE_ABSOLUTE_ADDR (0x9F)
55 #define TAHOE_DISPLACED_RELATIVE (0xEF)
56 #define TAHOE_DISP_REL_DEFERRED (0xFF)
58 #define TAHOE_AUTO_DEC (0x7E)
59 #define TAHOE_AUTO_INC (0x8E)
60 #define TAHOE_AUTO_INC_DEFERRED (0x9E)
61 /* INDEXED_REG is decided by the existance or lack of a [reg] */
63 /* These are encoded into top_width when top_access=='b'
64 and it's a psuedo op.*/
65 #define TAHOE_WIDTH_ALWAYS_JUMP '-'
66 #define TAHOE_WIDTH_CONDITIONAL_JUMP '?'
67 #define TAHOE_WIDTH_BIG_REV_JUMP '!'
68 #define TAHOE_WIDTH_BIG_NON_REV_JUMP ':'
70 /* The hex code for certain tahoe commands and modes.
71 This is just for readability. */
72 #define TAHOE_JMP (0x71)
73 #define TAHOE_PC_REL_LONG (0xEF)
74 #define TAHOE_BRB (0x11)
75 #define TAHOE_BRW (0x13)
76 /* These, when 'ored' with, or added to, a register number,
77 set up the number for the displacement mode. */
78 #define TAHOE_PC_OR_BYTE (0xA0)
79 #define TAHOE_PC_OR_WORD (0xC0)
80 #define TAHOE_PC_OR_LONG (0xE0)
82 struct tit
/* get it out of the sewer, it stands for
83 tahoe instruction tree (Geeze!) */
85 tahoe_opcodeT tit_opcode
; /* The opcode. */
86 byte tit_operands
; /* How many operands are here. */
87 struct top tit_operand
[TIT_MAX_OPERANDS
]; /* Operands */
88 char *tit_error
; /* "" or fatal error text */
91 /* end: tahoe-inst.h */
93 /* tahoe.c - tahoe-specific -
97 #include "opcode/tahoe.h"
99 /* This is the number to put at the beginning of the a.out file */
100 long omagic
= OMAGIC
;
102 /* These chars start a comment anywhere in a source file (except inside
103 another comment or a quoted string. */
104 const char comment_chars
[] = "#;";
106 /* These chars only start a comment at the beginning of a line. */
107 const char line_comment_chars
[] = "#";
109 /* Chars that can be used to separate mant from exp in floating point nums */
110 const char EXP_CHARS
[] = "eE";
112 /* Chars that mean this number is a floating point constant
114 or 0d1.234E-12 (see exp chars above)
115 Note: The Tahoe port doesn't support floating point constants. This is
116 consistant with 'as' If it's needed, I can always add it later. */
117 const char FLT_CHARS
[] = "df";
119 /* Also be aware that MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT may have to be
120 changed in read.c . Ideally it shouldn't have to know about it at all,
121 but nothing is ideal around here.
122 (The tahoe has plenty of room, so the change currently isn't needed.)
125 static struct tit t
; /* A tahoe instruction after decoding. */
128 /* A table of pseudo ops (sans .), the function called, and an integer op
129 that the function is called with. */
131 const pseudo_typeS md_pseudo_table
[] =
133 {"dfloat", float_cons
, 'd'},
134 {"ffloat", float_cons
, 'f'},
139 * For Tahoe, relative addresses of "just the right length" are pretty easy.
140 * The branch displacement is always the last operand, even in
141 * synthetic instructions.
142 * For Tahoe, we encode the relax_substateTs (in e.g. fr_substate) as:
144 * 4 3 2 1 0 bit number
145 * ---/ /--+-------+-------+-------+-------+-------+
146 * | what state ? | how long ? |
147 * ---/ /--+-------+-------+-------+-------+-------+
149 * The "how long" bits are 00=byte, 01=word, 10=long.
150 * This is a Un*x convention.
151 * Not all lengths are legit for a given value of (what state).
152 * The four states are listed below.
153 * The "how long" refers merely to the displacement length.
154 * The address usually has some constant bytes in it as well.
157 States for Tahoe address relaxing.
158 1. TAHOE_WIDTH_ALWAYS_JUMP (-)
160 Tahoe opcodes are: (Hex)
164 Always, 1 byte opcode, then displacement/absolute.
165 If word or longword, change opcode to brw or jmp.
168 2. TAHOE_WIDTH_CONDITIONAL_JUMP (?)
169 J<cond> where <cond> is a simple flag test.
171 Tahoe opcodes are: (Hex)
184 Always, you complement 4th bit to reverse the condition.
185 Always, 1-byte opcode, then 1-byte displacement.
187 3. TAHOE_WIDTH_BIG_REV_JUMP (!)
188 Jbc/Jbs where cond tests a memory bit.
190 Tahoe opcodes are: (Hex)
193 Always, you complement 4th bit to reverse the condition.
194 Always, 1-byte opcde, longword, longword-address, 1-word-displacement
196 4. TAHOE_WIDTH_BIG_NON_REV_JUMP (:)
199 Tahoe opcodes are: (Hex)
205 Always, we cannot reverse the sense of the branch; we have a word
208 We need to modify the opcode is for class 1, 2 and 3 instructions.
209 After relax() we may complement the 4th bit of 2 or 3 to reverse sense of
212 We sometimes store context in the operand literal. This way we can figure out
213 after relax() what the original addressing mode was. (Was is pc_rel, or
214 pc_rel_disp? That sort of thing.) */
216 /* These displacements are relative to the START address of the
217 displacement which is at the start of the displacement, not the end of
218 the instruction. The hardware pc_rel is at the end of the instructions.
219 That's why all the displacements have the length of the displacement added
220 to them. (WF + length(word))
222 The first letter is Byte, Word.
223 2nd letter is Forward, Backward. */
226 #define WF (2+ 32767)
227 #define WB (2+-32768)
228 /* Dont need LF, LB because they always reach. [They are coded as 0.] */
230 #define C(a,b) ENCODE_RELAX(a,b)
231 /* This macro has no side-effects. */
232 #define ENCODE_RELAX(what,length) (((what) << 2) + (length))
233 #define RELAX_STATE(what) ((what) >> 2)
234 #define RELAX_LENGTH(length) ((length) && 3)
236 #define STATE_ALWAYS_BRANCH (1)
237 #define STATE_CONDITIONAL_BRANCH (2)
238 #define STATE_BIG_REV_BRANCH (3)
239 #define STATE_BIG_NON_REV_BRANCH (4)
240 #define STATE_PC_RELATIVE (5)
242 #define STATE_BYTE (0)
243 #define STATE_WORD (1)
244 #define STATE_LONG (2)
245 #define STATE_UNDF (3) /* Symbol undefined in pass1 */
247 /* This is the table used by gas to figure out relaxing modes. The fields are
248 forward_branch reach, backward_branch reach, number of bytes it would take,
249 where the next biggest branch is. */
250 const relax_typeS md_relax_table
[] =
254 }, /* error sentinel 0,0 */
264 /* Unconditional branch cases "jrb"
265 The relax part is the actual displacement */
268 }, /* brb B`foo 1,0 */
271 }, /* brw W`foo 1,1 */
274 }, /* Jmp L`foo 1,2 */
278 /* Reversible Conditional Branch. If the branch won't reach, reverse
279 it, and jump over a brw or a jmp that will reach. The relax part is the
283 }, /* b<cond> B`foo 2,0 */
285 WF
+ 2, WB
+ 2, 4, C (2, 2)
286 }, /* brev over, brw W`foo, over: 2,1 */
289 }, /* brev over, jmp L`foo, over: 2,2 */
293 /* Another type of reversable branch. But this only has a word
300 }, /* jbX W`foo 3,1 */
303 }, /* jrevX over, jmp L`foo, over: 3,2 */
307 /* These are the non reversable branches, all of which have a word
308 displacement. If I can't reach, branch over a byte branch, to a
309 jump that will reach. The jumped branch jumps over the reaching
310 branch, to continue with the flow of the program. It's like playing
317 }, /* aobl_ W`foo 4,1 */
320 }, /*aobl_ W`hop,br over,hop: jmp L^foo,over 4,2*/
324 /* Normal displacement mode, no jumping or anything like that.
325 The relax points to one byte before the address, thats why all
326 the numbers are up by one. */
328 BF
+ 1, BB
+ 1, 2, C (5, 1)
331 WF
+ 1, WB
+ 1, 3, C (5, 2)
346 /* End relax stuff */
348 /* Handle of the OPCODE hash table. NULL means any use before
349 md_begin() will crash. */
350 static struct hash_control
*op_hash
;
352 /* Init function. Build the hash table. */
358 int synthetic_too
= 1; /* If 0, just use real opcodes. */
360 op_hash
= hash_new ();
362 for (tP
= totstrs
; *tP
->name
&& !errorval
; tP
++)
363 errorval
= hash_insert (op_hash
, tP
->name
, &tP
->detail
);
366 for (tP
= synthetic_totstrs
; *tP
->name
&& !errorval
; tP
++)
367 errorval
= hash_insert (op_hash
, tP
->name
, &tP
->detail
);
373 CONST
char *md_shortopts
= "ad:STt:V";
374 struct option md_longopts
[] = {
375 {NULL
, no_argument
, NULL
, 0}
377 size_t md_longopts_size
= sizeof(md_longopts
);
380 md_parse_option (c
, arg
)
387 as_warn ("The -a option doesn't exist. (Despite what the man page says!");
391 as_warn ("Displacement length %s ignored!", arg
);
395 as_warn ("SYMBOL TABLE not implemented");
399 as_warn ("TOKEN TRACE not implemented");
403 as_warn ("I don't need or use temp. file \"%s\".", arg
);
407 as_warn ("I don't use an interpass file! -V ignored");
418 md_show_usage (stream
)
432 /* The functions in this section take numbers in the machine format, and
433 munges them into Tahoe byte order.
434 They exist primarily for cross assembly purpose. */
435 void /* Knows about order of bytes in address. */
436 md_number_to_chars (con
, value
, nbytes
)
437 char con
[]; /* Return 'nbytes' of chars here. */
438 valueT value
; /* The value of the bits. */
439 int nbytes
; /* Number of bytes in the output. */
441 number_to_chars_bigendian (con
, value
, nbytes
);
445 void /* Knows about order of bytes in address. */
446 md_number_to_imm (con
, value
, nbytes
)
447 char con
[]; /* Return 'nbytes' of chars here. */
448 long int value
; /* The value of the bits. */
449 int nbytes
; /* Number of bytes in the output. */
451 md_number_to_chars (con
, value
, nbytes
);
457 tc_apply_fix (fixP
, val
)
461 /* should never be called */
465 void /* Knows about order of bytes in address. */
466 md_number_to_disp (con
, value
, nbytes
)
467 char con
[]; /* Return 'nbytes' of chars here. */
468 long int value
; /* The value of the bits. */
469 int nbytes
; /* Number of bytes in the output. */
471 md_number_to_chars (con
, value
, nbytes
);
474 void /* Knows about order of bytes in address. */
475 md_number_to_field (con
, value
, nbytes
)
476 char con
[]; /* Return 'nbytes' of chars here. */
477 long int value
; /* The value of the bits. */
478 int nbytes
; /* Number of bytes in the output. */
480 md_number_to_chars (con
, value
, nbytes
);
483 /* Put the bits in an order that a tahoe will understand, despite the ordering
484 of the native machine.
485 On Tahoe: first 4 bytes are normal unsigned big endian long,
486 next three bytes are symbolnum, in kind of 3 byte big endian (least sig. byte last).
487 The last byte is broken up with bit 7 as pcrel,
488 bits 6 & 5 as length,
489 bit 4 as extern and the last nibble as 'undefined'. */
493 md_ri_to_chars (ri_p
, ri
)
494 struct relocation_info
*ri_p
, ri
;
496 byte the_bytes
[sizeof (struct relocation_info
)];
497 /* The reason I can't just encode these directly into ri_p is that
498 ri_p may point to ri. */
501 md_number_to_chars (the_bytes
, ri
.r_address
, sizeof (ri
.r_address
));
503 /* now the fun stuff */
504 the_bytes
[4] = (ri
.r_symbolnum
>> 16) & 0x0ff;
505 the_bytes
[5] = (ri
.r_symbolnum
>> 8) & 0x0ff;
506 the_bytes
[6] = ri
.r_symbolnum
& 0x0ff;
507 the_bytes
[7] = (((ri
.r_extern
<< 4) & 0x10) | ((ri
.r_length
<< 5) & 0x60) |
508 ((ri
.r_pcrel
<< 7) & 0x80)) & 0xf0;
510 bcopy (the_bytes
, (char *) ri_p
, sizeof (struct relocation_info
));
515 /* Put the bits in an order that a tahoe will understand, despite the ordering
516 of the native machine.
517 On Tahoe: first 4 bytes are normal unsigned big endian long,
518 next three bytes are symbolnum, in kind of 3 byte big endian (least sig. byte last).
519 The last byte is broken up with bit 7 as pcrel,
520 bits 6 & 5 as length,
521 bit 4 as extern and the last nibble as 'undefined'. */
524 tc_aout_fix_to_chars (where
, fixP
, segment_address_in_file
)
527 relax_addressT segment_address_in_file
;
531 know (fixP
->fx_addsy
!= NULL
);
533 md_number_to_chars (where
,
534 fixP
->fx_frag
->fr_address
+ fixP
->fx_where
- segment_address_in_file
,
537 r_symbolnum
= (S_IS_DEFINED (fixP
->fx_addsy
)
538 ? S_GET_TYPE (fixP
->fx_addsy
)
539 : fixP
->fx_addsy
->sy_number
);
541 where
[4] = (r_symbolnum
>> 16) & 0x0ff;
542 where
[5] = (r_symbolnum
>> 8) & 0x0ff;
543 where
[6] = r_symbolnum
& 0x0ff;
544 where
[7] = (((is_pcrel (fixP
) << 7) & 0x80)
545 | ((((fixP
->fx_type
== FX_8
|| fixP
->fx_type
== FX_PCREL8
547 : (fixP
->fx_type
== FX_16
|| fixP
->fx_type
== FX_PCREL16
549 : (fixP
->fx_type
== FX_32
|| fixP
->fx_type
== FX_PCREL32
551 : 42)))) << 5) & 0x60)
552 | ((!S_IS_DEFINED (fixP
->fx_addsy
) << 4) & 0x10));
555 /* Relocate byte stuff */
557 /* This is for broken word. */
558 const int md_short_jump_size
= 3;
561 md_create_short_jump (ptr
, from_addr
, to_addr
, frag
, to_symbol
)
563 addressT from_addr
, to_addr
;
569 offset
= to_addr
- (from_addr
+ 1);
571 md_number_to_chars (ptr
, offset
, 2);
574 const int md_long_jump_size
= 6;
575 const int md_reloc_size
= 8; /* Size of relocation record */
578 md_create_long_jump (ptr
, from_addr
, to_addr
, frag
, to_symbol
)
580 addressT from_addr
, to_addr
;
586 offset
= to_addr
- (from_addr
+ 4);
588 *ptr
++ = TAHOE_PC_REL_LONG
;
589 md_number_to_chars (ptr
, offset
, 4);
593 * md_estimate_size_before_relax()
595 * Called just before relax().
596 * Any symbol that is now undefined will not become defined, so we assumed
597 * that it will be resolved by the linker.
598 * Return the correct fr_subtype in the frag, for relax()
599 * Return the initial "guess for fr_var" to caller. (How big I think this
601 * The guess for fr_var is ACTUALLY the growth beyond fr_fix.
602 * Whatever we do to grow fr_fix or fr_var contributes to our returned value.
603 * Although it may not be explicit in the frag, pretend fr_var starts with a
607 md_estimate_size_before_relax (fragP
, segment_type
)
608 register fragS
*fragP
;
609 segT segment_type
; /* N_DATA or N_TEXT. */
612 register int old_fr_fix
;
613 /* int pc_rel; FIXME: remove this */
615 old_fr_fix
= fragP
->fr_fix
;
616 switch (fragP
->fr_subtype
)
618 case ENCODE_RELAX (STATE_PC_RELATIVE
, STATE_UNDF
):
619 if (S_GET_SEGMENT (fragP
->fr_symbol
) == segment_type
)
621 /* The symbol was in the same segment as the opcode, and it's
622 a real pc_rel case so it's a relaxable case. */
623 fragP
->fr_subtype
= ENCODE_RELAX (STATE_PC_RELATIVE
, STATE_BYTE
);
627 /* This case is still undefined, so asume it's a long word for the
629 p
= fragP
->fr_literal
+ old_fr_fix
;
630 *p
|= TAHOE_PC_OR_LONG
;
631 /* We now know how big it will be, one long word. */
632 fragP
->fr_fix
+= 1 + 4;
633 fix_new (fragP
, old_fr_fix
+ 1, fragP
->fr_symbol
,
634 fragP
->fr_offset
, FX_PCREL32
, NULL
);
639 case ENCODE_RELAX (STATE_CONDITIONAL_BRANCH
, STATE_UNDF
):
640 if (S_GET_SEGMENT (fragP
->fr_symbol
) == segment_type
)
642 fragP
->fr_subtype
= ENCODE_RELAX (STATE_CONDITIONAL_BRANCH
, STATE_BYTE
);
646 p
= fragP
->fr_literal
+ old_fr_fix
;
647 *fragP
->fr_opcode
^= 0x10; /* Reverse sense of branch. */
650 *p
++ = TAHOE_PC_REL_LONG
;
651 fragP
->fr_fix
+= 1 + 1 + 1 + 4;
652 fix_new (fragP
, old_fr_fix
+ 3, fragP
->fr_symbol
,
653 fragP
->fr_offset
, FX_PCREL32
, NULL
);
658 case ENCODE_RELAX (STATE_BIG_REV_BRANCH
, STATE_UNDF
):
659 if (S_GET_SEGMENT (fragP
->fr_symbol
) == segment_type
)
662 ENCODE_RELAX (STATE_BIG_REV_BRANCH
, STATE_WORD
);
666 p
= fragP
->fr_literal
+ old_fr_fix
;
667 *fragP
->fr_opcode
^= 0x10; /* Reverse sense of branch. */
671 *p
++ = TAHOE_PC_REL_LONG
;
672 fragP
->fr_fix
+= 2 + 2 + 4;
673 fix_new (fragP
, old_fr_fix
+ 4, fragP
->fr_symbol
,
674 fragP
->fr_offset
, FX_PCREL32
, NULL
);
679 case ENCODE_RELAX (STATE_BIG_NON_REV_BRANCH
, STATE_UNDF
):
680 if (S_GET_SEGMENT (fragP
->fr_symbol
) == segment_type
)
682 fragP
->fr_subtype
= ENCODE_RELAX (STATE_BIG_NON_REV_BRANCH
, STATE_WORD
);
686 p
= fragP
->fr_literal
+ old_fr_fix
;
692 *p
++ = TAHOE_PC_REL_LONG
;
693 fragP
->fr_fix
+= 2 + 2 + 2 + 4;
694 fix_new (fragP
, old_fr_fix
+ 6, fragP
->fr_symbol
,
695 fragP
->fr_offset
, FX_PCREL32
, NULL
);
700 case ENCODE_RELAX (STATE_ALWAYS_BRANCH
, STATE_UNDF
):
701 if (S_GET_SEGMENT (fragP
->fr_symbol
) == segment_type
)
703 fragP
->fr_subtype
= ENCODE_RELAX (STATE_ALWAYS_BRANCH
, STATE_BYTE
);
707 p
= fragP
->fr_literal
+ old_fr_fix
;
708 *fragP
->fr_opcode
= TAHOE_JMP
;
709 *p
++ = TAHOE_PC_REL_LONG
;
710 fragP
->fr_fix
+= 1 + 4;
711 fix_new (fragP
, old_fr_fix
+ 1, fragP
->fr_symbol
,
712 fragP
->fr_offset
, FX_PCREL32
, NULL
);
720 return (fragP
->fr_var
+ fragP
->fr_fix
- old_fr_fix
);
721 } /* md_estimate_size_before_relax() */
726 * Called after relax() is finished.
727 * In: Address of frag.
728 * fr_type == rs_machine_dependent.
729 * fr_subtype is what the address relaxed to.
731 * Out: Any fixSs and constants are set up.
732 * Caller will turn frag into a ".space 0".
735 md_convert_frag (headers
, fragP
)
736 object_headers
*headers
;
737 register fragS
*fragP
;
739 register char *addressP
; /* -> _var to change. */
740 register char *opcodeP
; /* -> opcode char(s) to change. */
741 register short int length_code
; /* 2=long 1=word 0=byte */
742 register short int extension
= 0; /* Size of relaxed address.
743 Added to fr_fix: incl. ALL var chars. */
744 register symbolS
*symbolP
;
745 register long int where
;
746 register long int address_of_var
;
747 /* Where, in file space, is _var of *fragP? */
748 register long int target_address
;
749 /* Where, in file space, does addr point? */
751 know (fragP
->fr_type
== rs_machine_dependent
);
752 length_code
= RELAX_LENGTH (fragP
->fr_subtype
);
753 know (length_code
>= 0 && length_code
< 3);
754 where
= fragP
->fr_fix
;
755 addressP
= fragP
->fr_literal
+ where
;
756 opcodeP
= fragP
->fr_opcode
;
757 symbolP
= fragP
->fr_symbol
;
759 target_address
= S_GET_VALUE (symbolP
) + fragP
->fr_offset
;
760 address_of_var
= fragP
->fr_address
+ where
;
761 switch (fragP
->fr_subtype
)
763 case ENCODE_RELAX (STATE_PC_RELATIVE
, STATE_BYTE
):
764 /* *addressP holds the registers number, plus 0x10, if it's deferred
765 mode. To set up the right mode, just OR the size of this displacement */
766 /* Byte displacement. */
767 *addressP
++ |= TAHOE_PC_OR_BYTE
;
768 *addressP
= target_address
- (address_of_var
+ 2);
772 case ENCODE_RELAX (STATE_PC_RELATIVE
, STATE_WORD
):
773 /* Word displacement. */
774 *addressP
++ |= TAHOE_PC_OR_WORD
;
775 md_number_to_chars (addressP
, target_address
- (address_of_var
+ 3), 2);
779 case ENCODE_RELAX (STATE_PC_RELATIVE
, STATE_LONG
):
780 /* Long word displacement. */
781 *addressP
++ |= TAHOE_PC_OR_LONG
;
782 md_number_to_chars (addressP
, target_address
- (address_of_var
+ 5), 4);
786 case ENCODE_RELAX (STATE_CONDITIONAL_BRANCH
, STATE_BYTE
):
787 *addressP
= target_address
- (address_of_var
+ 1);
791 case ENCODE_RELAX (STATE_CONDITIONAL_BRANCH
, STATE_WORD
):
792 *opcodeP
^= 0x10; /* Reverse sense of test. */
793 *addressP
++ = 3; /* Jump over word branch */
794 *addressP
++ = TAHOE_BRW
;
795 md_number_to_chars (addressP
, target_address
- (address_of_var
+ 4), 2);
799 case ENCODE_RELAX (STATE_CONDITIONAL_BRANCH
, STATE_LONG
):
800 *opcodeP
^= 0x10; /* Reverse sense of test. */
802 *addressP
++ = TAHOE_JMP
;
803 *addressP
++ = TAHOE_PC_REL_LONG
;
804 md_number_to_chars (addressP
, target_address
, 4);
808 case ENCODE_RELAX (STATE_ALWAYS_BRANCH
, STATE_BYTE
):
809 *addressP
= target_address
- (address_of_var
+ 1);
813 case ENCODE_RELAX (STATE_ALWAYS_BRANCH
, STATE_WORD
):
814 *opcodeP
= TAHOE_BRW
;
815 md_number_to_chars (addressP
, target_address
- (address_of_var
+ 2), 2);
819 case ENCODE_RELAX (STATE_ALWAYS_BRANCH
, STATE_LONG
):
820 *opcodeP
= TAHOE_JMP
;
821 *addressP
++ = TAHOE_PC_REL_LONG
;
822 md_number_to_chars (addressP
, target_address
- (address_of_var
+ 5), 4);
826 case ENCODE_RELAX (STATE_BIG_REV_BRANCH
, STATE_WORD
):
827 md_number_to_chars (addressP
, target_address
- (address_of_var
+ 2), 2);
831 case ENCODE_RELAX (STATE_BIG_REV_BRANCH
, STATE_LONG
):
835 *addressP
++ = TAHOE_JMP
;
836 *addressP
++ = TAHOE_PC_REL_LONG
;
837 md_number_to_chars (addressP
, target_address
, 4);
841 case ENCODE_RELAX (STATE_BIG_NON_REV_BRANCH
, STATE_WORD
):
842 md_number_to_chars (addressP
, target_address
- (address_of_var
+ 2), 2);
846 case ENCODE_RELAX (STATE_BIG_NON_REV_BRANCH
, STATE_LONG
):
849 *addressP
++ = TAHOE_BRB
;
851 *addressP
++ = TAHOE_JMP
;
852 *addressP
++ = TAHOE_PC_REL_LONG
;
853 md_number_to_chars (addressP
, target_address
, 4);
858 BAD_CASE (fragP
->fr_subtype
);
861 fragP
->fr_fix
+= extension
;
862 } /* md_convert_frag */
865 /* This is the stuff for md_assemble. */
869 #define BIGGESTREG PC_REG
872 * Parse the string pointed to by START
873 * If it represents a valid register, point START to the character after
874 * the last valid register char, and return the register number (0-15).
875 * If invalid, leave START alone, return -1.
876 * The format has to be exact. I don't do things like eat leading zeros
878 * Note: This doesn't check for the next character in the string making
879 * this invalid. Ex: R123 would return 12, it's the callers job to check
880 * what start is point to apon return.
882 * Valid registers are R1-R15, %1-%15, FP (13), SP (14), PC (15)
883 * Case doesn't matter.
886 tahoe_reg_parse (start
)
887 char **start
; /* A pointer to the string to parse. */
889 register char *regpoint
= *start
;
890 register int regnum
= -1;
894 case '%': /* Registers can start with a %,
895 R or r, and then a number. */
898 if (isdigit (*regpoint
))
900 /* Got the first digit. */
901 regnum
= *regpoint
++ - '0';
902 if ((regnum
== 1) && isdigit (*regpoint
))
904 /* Its a two digit number. */
905 regnum
= 10 + (*regpoint
++ - '0');
906 if (regnum
> BIGGESTREG
)
907 { /* Number too big? */
913 case 'F': /* Is it the FP */
922 case 's': /* How about the SP */
931 case 'p': /* OR the PC even */
943 { /* No error, so move string pointer */
946 return regnum
; /* Return results */
947 } /* tahoe_reg_parse */
950 * This chops up an operand and figures out its modes and stuff.
951 * It's a little touchy about extra characters.
952 * Optex to start with one extra character so it can be overwritten for
953 * the backward part of the parsing.
954 * You can't put a bunch of extra characters in side to
955 * make the command look cute. ie: * foo ( r1 ) [ r0 ]
956 * If you like doing a lot of typing, try COBOL!
957 * Actually, this parser is a little weak all around. It's designed to be
958 * used with compliers, so I emphisise correct decoding of valid code quickly
959 * rather that catching every possable error.
960 * Note: This uses the expression function, so save input_line_pointer before
963 * Sperry defines the semantics of address modes (and values)
964 * by a two-letter code, explained here.
966 * letter 1: access type
968 * a address calculation - no data access, registers forbidden
969 * b branch displacement
970 * m read - let go of bus - write back "modify"
973 * v bit field address: like 'a' but registers are OK
975 * letter 2: data type (i.e. width, alignment)
980 * q quadword (Even regs < 14 allowed) (if 12, you get a warning)
981 * - unconditional synthetic jbr operand
982 * ? simple synthetic reversable branch operand
983 * ! complex synthetic reversable branch operand
984 * : complex synthetic non-reversable branch operand
986 * The '-?!:' letter 2's are not for external consumption. They are used
987 * by GAS for psuedo ops relaxing code.
989 * After parsing topP has:
991 * top_ndx: -1, or the index register. eg 7=[R7]
992 * top_reg: -1, or register number. eg 7 = R7 or (R7)
993 * top_mode: The addressing mode byte. This byte, defines which of
994 * the 11 modes opcode is.
995 * top_access: Access type wanted for this opperand 'b'branch ' '
996 * no-instruction 'amrvw'
997 * top_width: Operand width expected, one of "bwlq?-:!"
998 * exp_of_operand: The expression as parsed by expression()
999 * top_dispsize: Number of bytes in the displacement if we can figure it
1000 * out and it's relavent.
1002 * Need syntax checks built.
1006 tip_op (optex
, topP
)
1007 char *optex
; /* The users text input, with one leading character */
1008 struct top
*topP
; /* The tahoe instruction with some fields already set:
1010 out: ndx, reg, mode, error, dispsize */
1013 int mode
= 0; /* This operand's mode. */
1014 char segfault
= *optex
; /* To keep the back parsing from freaking. */
1015 char *point
= optex
+ 1; /* Parsing from front to back. */
1016 char *end
; /* Parsing from back to front. */
1017 int reg
= -1; /* major register, -1 means absent */
1018 int imreg
= -1; /* Major register in immediate mode */
1019 int ndx
= -1; /* index register number, -1 means absent */
1020 char dec_inc
= ' '; /* Is the SP auto-incremented '+' or
1021 auto-decremented '-' or neither ' '. */
1022 int immediate
= 0; /* 1 if '$' immediate mode */
1023 int call_width
= 0; /* If the caller casts the displacement */
1024 int abs_width
= 0; /* The width of the absolute displacment */
1025 int com_width
= 0; /* Displacement width required by branch */
1026 int deferred
= 0; /* 1 if '*' deferral is used */
1027 byte disp_size
= 0; /* How big is this operand. 0 == don't know */
1028 char *op_bad
= ""; /* Bad operand error */
1030 char *tp
, *temp
, c
; /* Temporary holders */
1032 char access
= topP
->top_access
; /* Save on a deref. */
1033 char width
= topP
->top_width
;
1035 int really_none
= 0; /* Empty expressions evaluate to 0
1036 but I need to know if it's there or not */
1037 expressionS
*expP
; /* -> expression values for this operand */
1039 /* Does this command restrict the displacement size. */
1041 com_width
= (width
== 'b' ? 1 :
1043 (width
== 'l' ? 4 : 0)));
1045 *optex
= '\0'; /* This is kind of a back stop for all
1046 the searches to fail on if needed.*/
1048 { /* A dereference? */
1053 /* Force words into a certain mode */
1054 /* Bitch, Bitch, Bitch! */
1056 * Using the ^ operator is ambigous. If I have an absolute label
1057 * called 'w' set to, say 2, and I have the expression 'w^1', do I get
1058 * 1, forced to be in word displacement mode, or do I get the value of
1059 * 'w' or'ed with 1 (3 in this case).
1060 * The default is 'w' as an offset, so that's what I use.
1061 * Stick with `, it does the same, and isn't ambig.
1064 if (*point
!= '\0' && ((point
[1] == '^') || (point
[1] == '`')))
1074 as_warn ("Casting a branch displacement is bad form, and is ignored.");
1077 c
= (isupper (*point
) ? tolower (*point
) : *point
);
1078 call_width
= ((c
== 'b') ? 1 :
1079 ((c
== 'w') ? 2 : 4));
1085 /* Setting immediate mode */
1093 * I've pulled off all the easy stuff off the front, move to the end and
1097 for (end
= point
; *end
!= '\0'; end
++) /* Move to the end. */
1100 if (end
!= point
) /* Null string? */
1103 if (end
> point
&& *end
== ' ' && end
[-1] != '\'')
1104 end
--; /* Hop white space */
1106 /* Is this an index reg. */
1107 if ((*end
== ']') && (end
[-1] != '\''))
1111 /* Find opening brace. */
1112 for (--end
; (*end
!= '[' && end
!= point
); end
--)
1115 /* If I found the opening brace, get the index register number. */
1118 tp
= end
+ 1; /* tp should point to the start of a reg. */
1119 ndx
= tahoe_reg_parse (&tp
);
1121 { /* Reg. parse error. */
1126 end
--; /* Found it, move past brace. */
1130 op_bad
= "Couldn't parse the [index] in this operand.";
1131 end
= point
; /* Force all the rest of the tests to fail. */
1136 op_bad
= "Couldn't find the opening '[' for the index of this operand.";
1137 end
= point
; /* Force all the rest of the tests to fail. */
1141 /* Post increment? */
1149 /* register in parens? */
1150 if ((*end
== ')') && (end
[-1] != '\''))
1154 /* Find opening paren. */
1155 for (--end
; (*end
!= '(' && end
!= point
); end
--)
1158 /* If I found the opening paren, get the register number. */
1162 reg
= tahoe_reg_parse (&tp
);
1165 /* Not a register, but could be part of the expression. */
1167 end
= temp
; /* Rest the pointer back */
1171 end
--; /* Found the reg. move before opening paren. */
1176 op_bad
= "Couldn't find the opening '(' for the deref of this operand.";
1177 end
= point
; /* Force all the rest of the tests to fail. */
1181 /* Pre decrement? */
1186 op_bad
= "Operand can't be both pre-inc and post-dec.";
1198 * Everything between point and end is the 'expression', unless it's
1206 imreg
= tahoe_reg_parse (&point
); /* Get the immediate register
1210 /* If there is junk after point, then the it's not immediate reg. */
1215 if (imreg
!= -1 && reg
!= -1)
1216 op_bad
= "I parsed 2 registers in this operand.";
1219 * Evaluate whats left of the expression to see if it's valid.
1220 * Note again: This assumes that the calling expression has saved
1221 * input_line_pointer. (Nag, nag, nag!)
1224 if (*op_bad
== '\0')
1226 /* statement has no syntax goofs yet: lets sniff the expression */
1227 input_line_pointer
= point
;
1228 expP
= &(topP
->exp_of_operand
);
1229 topP
->seg_of_operand
= expression (expP
);
1233 /* No expression. For BSD4.2 compatibility, missing expression is
1235 expP
->X_op
= O_constant
;
1236 expP
->X_add_number
= 0;
1239 /* for SEG_ABSOLUTE, we shouldnt need to set X_op_symbol,
1240 X_add_symbol to any particular value. */
1241 /* But, we will program defensively. Since this situation occurs
1242 rarely so it costs us little to do so. */
1243 expP
->X_add_symbol
= NULL
;
1244 expP
->X_op_symbol
= NULL
;
1245 /* How many bytes are needed to express this abs value? */
1247 ((((expP
->X_add_number
& 0xFFFFFF80) == 0) ||
1248 ((expP
->X_add_number
& 0xFFFFFF80) == 0xFFFFFF80)) ? 1 :
1249 (((expP
->X_add_number
& 0xFFFF8000) == 0) ||
1250 ((expP
->X_add_number
& 0xFFFF8000) == 0xFFFF8000)) ? 2 : 4);
1257 * Major bug. We can't handle the case of a operator
1258 * expression in a synthetic opcode variable-length
1259 * instruction. We don't have a frag type that is smart
1260 * enough to relax a operator, and so we just force all
1261 * operators to behave like SEG_PASS1s. Clearly, if there is
1262 * a demand we can invent a new or modified frag type and
1263 * then coding up a frag for this case will be easy.
1266 op_bad
= "Can't relocate expression error.";
1270 /* This is an error. Tahoe doesn't allow any expressions
1271 bigger that a 32 bit long word. Any bigger has to be referenced
1273 op_bad
= "Expression is too large for a 32 bits.";
1276 if (*input_line_pointer
!= '\0')
1278 op_bad
= "Junk at end of expression.";
1284 /* I'm done, so restore optex */
1289 * At this point in the game, we (in theory) have all the components of
1290 * the operand at least parsed. Now it's time to check for syntax/semantic
1291 * errors, and build the mode.
1292 * This is what I have:
1293 * deferred = 1 if '*'
1294 * call_width = 0,1,2,4
1295 * abs_width = 0,1,2,4
1296 * com_width = 0,1,2,4
1297 * immediate = 1 if '$'
1298 * ndx = -1 or reg num
1299 * dec_inc = '-' or '+' or ' '
1300 * reg = -1 or reg num
1301 * imreg = -1 or reg num
1302 * topP->exp_of_operand
1305 /* Is there a displacement size? */
1306 disp_size
= (call_width
? call_width
:
1307 (com_width
? com_width
:
1308 abs_width
? abs_width
: 0));
1310 if (*op_bad
== '\0')
1315 mode
= TAHOE_DIRECT_REG
;
1316 if (deferred
|| immediate
|| (dec_inc
!= ' ') ||
1317 (reg
!= -1) || !really_none
)
1318 op_bad
= "Syntax error in direct register mode.";
1320 op_bad
= "You can't index a register in direct register mode.";
1321 else if (imreg
== SP_REG
&& access
== 'r')
1323 "SP can't be the source operand with direct register addressing.";
1324 else if (access
== 'a')
1325 op_bad
= "Can't take the address of a register.";
1326 else if (access
== 'b')
1327 op_bad
= "Direct Register can't be used in a branch.";
1328 else if (width
== 'q' && ((imreg
% 2) || (imreg
> 13)))
1329 op_bad
= "For quad access, the register must be even and < 14.";
1330 else if (call_width
)
1331 op_bad
= "You can't cast a direct register.";
1333 if (*op_bad
== '\0')
1335 /* No errors, check for warnings */
1336 if (width
== 'q' && imreg
== 12)
1337 as_warn ("Using reg 14 for quadwords can tromp the FP register.");
1342 /* We know: imm = -1 */
1344 else if (dec_inc
== '-')
1347 mode
= TAHOE_AUTO_DEC
;
1348 if (deferred
|| immediate
|| !really_none
)
1349 op_bad
= "Syntax error in auto-dec mode.";
1351 op_bad
= "You can't have an index auto dec mode.";
1352 else if (access
== 'r')
1353 op_bad
= "Auto dec mode cant be used for reading.";
1354 else if (reg
!= SP_REG
)
1355 op_bad
= "Auto dec only works of the SP register.";
1356 else if (access
== 'b')
1357 op_bad
= "Auto dec can't be used in a branch.";
1358 else if (width
== 'q')
1359 op_bad
= "Auto dec won't work with quadwords.";
1361 /* We know: imm = -1, dec_inc != '-' */
1363 else if (dec_inc
== '+')
1365 if (immediate
|| !really_none
)
1366 op_bad
= "Syntax error in one of the auto-inc modes.";
1370 mode
= TAHOE_AUTO_INC_DEFERRED
;
1372 op_bad
= "Auto inc deferred only works of the SP register.";
1374 op_bad
= "You can't have an index auto inc deferred mode.";
1375 else if (access
== 'b')
1376 op_bad
= "Auto inc can't be used in a branch.";
1381 mode
= TAHOE_AUTO_INC
;
1382 if (access
== 'm' || access
== 'w')
1383 op_bad
= "You can't write to an auto inc register.";
1384 else if (reg
!= SP_REG
)
1385 op_bad
= "Auto inc only works of the SP register.";
1386 else if (access
== 'b')
1387 op_bad
= "Auto inc can't be used in a branch.";
1388 else if (width
== 'q')
1389 op_bad
= "Auto inc won't work with quadwords.";
1391 op_bad
= "You can't have an index in auto inc mode.";
1394 /* We know: imm = -1, dec_inc == ' ' */
1398 if ((ndx
!= -1) && (reg
== SP_REG
))
1399 op_bad
= "You can't index the sp register.";
1403 mode
= TAHOE_REG_DISP_DEFERRED
;
1405 op_bad
= "Syntax error in register displaced mode.";
1407 else if (really_none
)
1410 mode
= TAHOE_REG_DEFERRED
;
1411 /* if reg = SP then cant be indexed */
1416 mode
= TAHOE_REG_DISP
;
1419 /* We know: imm = -1, dec_inc == ' ', Reg = -1 */
1424 op_bad
= "An offest is needed for this operand.";
1425 if (deferred
&& immediate
)
1428 mode
= TAHOE_ABSOLUTE_ADDR
;
1434 mode
= TAHOE_IMMEDIATE
;
1436 op_bad
= "You can't index a register in immediate mode.";
1438 op_bad
= "Immediate access can't be used as an address.";
1439 /* ponder the wisdom of a cast because it doesn't do any good. */
1444 mode
= TAHOE_DISP_REL_DEFERRED
;
1449 mode
= TAHOE_DISPLACED_RELATIVE
;
1455 * At this point, all the errors we can do have be checked for.
1456 * We can build the 'top'. */
1458 topP
->top_ndx
= ndx
;
1459 topP
->top_reg
= reg
;
1460 topP
->top_mode
= mode
;
1461 topP
->top_error
= op_bad
;
1462 topP
->top_dispsize
= disp_size
;
1468 * This converts a string into a tahoe instruction.
1469 * The string must be a bare single instruction in tahoe (with BSD4 frobs)
1471 * It provides at most one fatal error message (which stops the scan)
1472 * some warning messages as it finds them.
1473 * The tahoe instruction is returned in exploded form.
1475 * The exploded instruction is returned to a struct tit of your choice.
1476 * #include "tahoe-inst.h" to know what a struct tit is.
1481 tip (titP
, instring
)
1482 struct tit
*titP
; /* We build an exploded instruction here. */
1483 char *instring
; /* Text of a vax instruction: we modify. */
1485 register struct tot_wot
*twP
= NULL
; /* How to bit-encode this opcode. */
1486 register char *p
; /* 1/skip whitespace.2/scan vot_how */
1487 register char *q
; /* */
1488 register unsigned char count
; /* counts number of operands seen */
1489 register struct top
*operandp
;/* scan operands in struct tit */
1490 register char *alloperr
= ""; /* error over all operands */
1491 register char c
; /* Remember char, (we clobber it
1492 with '\0' temporarily). */
1493 char *save_input_line_pointer
;
1495 if (*instring
== ' ')
1496 ++instring
; /* Skip leading whitespace. */
1497 for (p
= instring
; *p
&& *p
!= ' '; p
++)
1498 ; /* MUST end in end-of-string or
1500 /* Scanned up to end of operation-code. */
1501 /* Operation-code is ended with whitespace. */
1504 titP
->tit_error
= "No operator";
1506 titP
->tit_opcode
= 0;
1513 * Here with instring pointing to what better be an op-name, and p
1514 * pointing to character just past that.
1515 * We trust instring points to an op-name, with no whitespace.
1517 twP
= (struct tot_wot
*) hash_find (op_hash
, instring
);
1518 *p
= c
; /* Restore char after op-code. */
1521 titP
->tit_error
= "Unknown operator";
1523 titP
->tit_opcode
= 0;
1528 * We found a match! So lets pick up as many operands as the
1529 * instruction wants, and even gripe if there are too many.
1530 * We expect comma to seperate each operand.
1531 * We let instring track the text, while p tracks a part of the
1535 count
= 0; /* no operands seen yet */
1536 instring
= p
+ (*p
!= '\0'); /* point past the operation code */
1537 /* tip_op() screws with the input_line_pointer, so save it before
1539 save_input_line_pointer
= input_line_pointer
;
1540 for (p
= twP
->args
, operandp
= titP
->tit_operand
;
1545 * Here to parse one operand. Leave instring pointing just
1546 * past any one ',' that marks the end of this operand.
1549 as_fatal ("Compiler bug: ODD number of bytes in arg structure %s.",
1553 for (q
= instring
; (*q
!= ',' && *q
!= '\0'); q
++)
1555 if (*q
== '\'' && q
[1] != '\0') /* Jump quoted characters */
1560 * Q points to ',' or '\0' that ends argument. C is that
1564 operandp
->top_access
= p
[0];
1565 operandp
->top_width
= p
[1];
1566 tip_op (instring
- 1, operandp
);
1567 *q
= c
; /* Restore input text. */
1568 if (*(operandp
->top_error
))
1570 alloperr
= operandp
->top_error
;
1572 instring
= q
+ (c
? 1 : 0); /* next operand (if any) */
1573 count
++; /* won another argument, may have an operr */
1576 alloperr
= "Not enough operands";
1578 /* Restore the pointer. */
1579 input_line_pointer
= save_input_line_pointer
;
1583 if (*instring
== ' ')
1584 instring
++; /* Skip whitespace. */
1586 alloperr
= "Too many operands";
1588 titP
->tit_error
= alloperr
;
1592 titP
->tit_opcode
= twP
->code
; /* The op-code. */
1593 titP
->tit_operands
= count
;
1596 /* md_assemble() emit frags for 1 instruction */
1598 md_assemble (instruction_string
)
1599 char *instruction_string
; /* A string: assemble 1 instruction. */
1602 register struct top
*operandP
;/* An operand. Scans all operands. */
1603 /* char c_save; fixme: remove this line *//* What used to live after an expression. */
1604 /* struct frag *fragP; fixme: remove this line *//* Fragment of code we just made. */
1605 /* register struct top *end_operandP; fixme: remove this line *//* -> slot just after last operand
1606 Limit of the for (each operand). */
1607 register expressionS
*expP
; /* -> expression values for this operand */
1609 /* These refer to an instruction operand expression. */
1610 segT to_seg
; /* Target segment of the address. */
1612 register valueT this_add_number
;
1613 register struct symbol
*this_add_symbol
; /* +ve (minuend) symbol. */
1615 /* tahoe_opcodeT opcode_as_number; fixme: remove this line *//* The opcode as a number. */
1616 char *opcodeP
; /* Where it is in a frag. */
1617 /* char *opmodeP; fixme: remove this line *//* Where opcode type is, in a frag. */
1619 int dispsize
; /* From top_dispsize: tahoe_operand_width
1621 int is_undefined
; /* 1 if operand expression's
1622 segment not known yet. */
1623 int pc_rel
; /* Is this operand pc relative? */
1625 /* Decode the operand. */
1626 tip (&t
, instruction_string
);
1629 * Check to see if this operand decode properly.
1630 * Notice that we haven't made any frags yet.
1631 * If it goofed, then this instruction will wedge in any pass,
1632 * and we can safely flush it, without causing interpass symbol phase
1633 * errors. That is, without changing label values in different passes.
1637 as_warn ("Ignoring statement due to \"%s\"", t
.tit_error
);
1641 /* We saw no errors in any operands - try to make frag(s) */
1643 /* Remember where it is, in case we want to modify the op-code later. */
1644 opcodeP
= frag_more (1);
1645 *opcodeP
= t
.tit_opcode
;
1646 /* Now do each operand. */
1647 for (operandP
= t
.tit_operand
;
1648 operandP
< t
.tit_operand
+ t
.tit_operands
;
1650 { /* for each operand */
1651 expP
= &(operandP
->exp_of_operand
);
1652 if (operandP
->top_ndx
>= 0)
1654 /* Indexed addressing byte
1655 Legality of indexed mode already checked: it is OK */
1656 FRAG_APPEND_1_CHAR (0x40 + operandP
->top_ndx
);
1657 } /* if(top_ndx>=0) */
1659 /* Here to make main operand frag(s). */
1660 this_add_number
= expP
->X_add_number
;
1661 this_add_symbol
= expP
->X_add_symbol
;
1662 to_seg
= operandP
->seg_of_operand
;
1663 know (to_seg
== SEG_UNKNOWN
|| \
1664 to_seg
== SEG_ABSOLUTE
|| \
1665 to_seg
== SEG_DATA
|| \
1666 to_seg
== SEG_TEXT
|| \
1668 is_undefined
= (to_seg
== SEG_UNKNOWN
);
1669 /* Do we know how big this opperand is? */
1670 dispsize
= operandP
->top_dispsize
;
1672 /* Deal with the branch possabilities. (Note, this doesn't include
1674 if (operandP
->top_access
== 'b')
1676 /* Branches must be expressions. A psuedo branch can also jump to
1677 an absolute address. */
1678 if (to_seg
== now_seg
|| is_undefined
)
1680 /* If is_undefined, then it might BECOME now_seg by relax time. */
1683 /* I know how big the branch is supposed to be (it's a normal
1684 branch), so I set up the frag, and let GAS do the rest. */
1685 p
= frag_more (dispsize
);
1686 fix_new (frag_now
, p
- frag_now
->fr_literal
,
1687 this_add_symbol
, this_add_number
,
1688 size_to_fx (dispsize
, 1),
1693 /* (to_seg==now_seg || to_seg == SEG_UNKNOWN) && dispsize==0 */
1694 /* If we don't know how big it is, then its a synthetic branch,
1695 so we set up a simple relax state. */
1696 switch (operandP
->top_width
)
1698 case TAHOE_WIDTH_CONDITIONAL_JUMP
:
1699 /* Simple (conditional) jump. I may have to reverse the
1700 condition of opcodeP, and then jump to my destination.
1701 I set 1 byte aside for the branch off set, and could need 6
1702 more bytes for the pc_rel jump */
1703 frag_var (rs_machine_dependent
, 7, 1,
1704 ENCODE_RELAX (STATE_CONDITIONAL_BRANCH
,
1705 is_undefined
? STATE_UNDF
: STATE_BYTE
),
1706 this_add_symbol
, this_add_number
, opcodeP
);
1708 case TAHOE_WIDTH_ALWAYS_JUMP
:
1709 /* Simple (unconditional) jump. I may have to convert this to
1710 a word branch, or an absolute jump. */
1711 frag_var (rs_machine_dependent
, 5, 1,
1712 ENCODE_RELAX (STATE_ALWAYS_BRANCH
,
1713 is_undefined
? STATE_UNDF
: STATE_BYTE
),
1714 this_add_symbol
, this_add_number
, opcodeP
);
1716 /* The smallest size for the next 2 cases is word. */
1717 case TAHOE_WIDTH_BIG_REV_JUMP
:
1718 frag_var (rs_machine_dependent
, 8, 2,
1719 ENCODE_RELAX (STATE_BIG_REV_BRANCH
,
1720 is_undefined
? STATE_UNDF
: STATE_WORD
),
1721 this_add_symbol
, this_add_number
,
1724 case TAHOE_WIDTH_BIG_NON_REV_JUMP
:
1725 frag_var (rs_machine_dependent
, 10, 2,
1726 ENCODE_RELAX (STATE_BIG_NON_REV_BRANCH
,
1727 is_undefined
? STATE_UNDF
: STATE_WORD
),
1728 this_add_symbol
, this_add_number
,
1732 as_fatal ("Compliler bug: Got a case (%d) I wasn't expecting.",
1733 operandP
->top_width
);
1739 /* to_seg != now_seg && to_seg != seg_unknown (still in branch)
1740 In other words, I'm jumping out of my segment so extend the
1741 branches to jumps, and let GAS fix them. */
1743 /* These are "branches" what will always be branches around a jump
1744 to the correct addresss in real life.
1745 If to_seg is SEG_ABSOLUTE, just encode the branch in,
1746 else let GAS fix the address. */
1748 switch (operandP
->top_width
)
1751 For SEG_ABSOLUTE, then mode is ABSOLUTE_ADDR, jump
1752 to that addresss (not pc_rel).
1753 For other segs, address is a long word PC rel jump. */
1754 case TAHOE_WIDTH_CONDITIONAL_JUMP
:
1756 /* To reverse the condition in a TAHOE branch,
1762 *p
++ = (operandP
->top_mode
==
1763 TAHOE_ABSOLUTE_ADDR
? TAHOE_ABSOLUTE_ADDR
:
1765 fix_new (frag_now
, p
- frag_now
->fr_literal
,
1766 this_add_symbol
, this_add_number
,
1767 (to_seg
!= SEG_ABSOLUTE
) ? FX_PCREL32
: FX_32
, NULL
);
1774 case TAHOE_WIDTH_ALWAYS_JUMP
:
1775 /* br, just turn it into a jump */
1776 *opcodeP
= TAHOE_JMP
;
1778 *p
++ = (operandP
->top_mode
==
1779 TAHOE_ABSOLUTE_ADDR
? TAHOE_ABSOLUTE_ADDR
:
1781 fix_new (frag_now
, p
- frag_now
->fr_literal
,
1782 this_add_symbol
, this_add_number
,
1783 (to_seg
!= SEG_ABSOLUTE
) ? FX_PCREL32
: FX_32
, NULL
);
1784 /* Now (eg) JMP foo */
1786 case TAHOE_WIDTH_BIG_REV_JUMP
:
1792 *p
++ = (operandP
->top_mode
==
1793 TAHOE_ABSOLUTE_ADDR
? TAHOE_ABSOLUTE_ADDR
:
1795 fix_new (frag_now
, p
- frag_now
->fr_literal
,
1796 this_add_symbol
, this_add_number
,
1797 (to_seg
!= SEG_ABSOLUTE
) ? FX_PCREL32
: FX_32
, NULL
);
1804 case TAHOE_WIDTH_BIG_NON_REV_JUMP
:
1811 *p
++ = (operandP
->top_mode
==
1812 TAHOE_ABSOLUTE_ADDR
? TAHOE_ABSOLUTE_ADDR
:
1814 fix_new (frag_now
, p
- frag_now
->fr_literal
,
1815 this_add_symbol
, this_add_number
,
1816 (to_seg
!= SEG_ABSOLUTE
) ? FX_PCREL32
: FX_32
, NULL
);
1818 * Now (eg) xOBxxx 1f
1826 as_warn ("Real branch displacements must be expressions.");
1829 as_fatal ("Complier error: I got an unknown synthetic branch :%c",
1830 operandP
->top_width
);
1837 /* It ain't a branch operand. */
1838 switch (operandP
->top_mode
)
1840 /* Auto-foo access, only works for one reg (SP)
1841 so the only thing needed is the mode. */
1842 case TAHOE_AUTO_DEC
:
1843 case TAHOE_AUTO_INC
:
1844 case TAHOE_AUTO_INC_DEFERRED
:
1845 FRAG_APPEND_1_CHAR (operandP
->top_mode
);
1848 /* Numbered Register only access. Only thing needed is the
1849 mode + Register number */
1850 case TAHOE_DIRECT_REG
:
1851 case TAHOE_REG_DEFERRED
:
1852 FRAG_APPEND_1_CHAR (operandP
->top_mode
+ operandP
->top_reg
);
1855 /* An absolute address. It's size is always 5 bytes.
1856 (mode_type + 4 byte address). */
1857 case TAHOE_ABSOLUTE_ADDR
:
1858 know ((this_add_symbol
== NULL
));
1860 *p
= TAHOE_ABSOLUTE_ADDR
;
1861 md_number_to_chars (p
+ 1, this_add_number
, 4);
1864 /* Immediate data. If the size isn't known, then it's an address
1865 + and offset, which is 4 bytes big. */
1866 case TAHOE_IMMEDIATE
:
1867 if (this_add_symbol
!= NULL
)
1870 *p
++ = TAHOE_IMMEDIATE_LONGWORD
;
1871 fix_new (frag_now
, p
- frag_now
->fr_literal
,
1872 this_add_symbol
, this_add_number
,
1877 /* It's a integer, and I know it's size. */
1878 if ((unsigned) this_add_number
< 0x40)
1880 /* Will it fit in a literal? */
1881 FRAG_APPEND_1_CHAR ((byte
) this_add_number
);
1885 p
= frag_more (dispsize
+ 1);
1889 *p
++ = TAHOE_IMMEDIATE_BYTE
;
1890 *p
= (byte
) this_add_number
;
1893 *p
++ = TAHOE_IMMEDIATE_WORD
;
1894 md_number_to_chars (p
, this_add_number
, 2);
1897 *p
++ = TAHOE_IMMEDIATE_LONGWORD
;
1898 md_number_to_chars (p
, this_add_number
, 4);
1905 /* Distance from the PC. If the size isn't known, we have to relax
1906 into it. The difference between this and disp(sp) is that
1907 this offset is pc_rel, and disp(sp) isn't.
1908 Note the drop through code. */
1910 case TAHOE_DISPLACED_RELATIVE
:
1911 case TAHOE_DISP_REL_DEFERRED
:
1912 operandP
->top_reg
= PC_REG
;
1915 /* Register, plus a displacement mode. Save the register number,
1916 and weather its deffered or not, and relax the size if it isn't
1918 case TAHOE_REG_DISP
:
1919 case TAHOE_REG_DISP_DEFERRED
:
1920 if (operandP
->top_mode
== TAHOE_DISP_REL_DEFERRED
||
1921 operandP
->top_mode
== TAHOE_REG_DISP_DEFERRED
)
1922 operandP
->top_reg
+= 0x10; /* deffered mode is always 0x10 higher
1923 than it's non-deffered sibling. */
1925 /* Is this a value out of this segment?
1926 The first part of this conditional is a cludge to make gas
1927 produce the same output as 'as' when there is a lable, in
1928 the current segment, displaceing a register. It's strange,
1929 and no one in their right mind would do it, but it's easy
1931 if ((dispsize
== 0 && !pc_rel
) ||
1932 (to_seg
!= now_seg
&& !is_undefined
&& to_seg
!= SEG_ABSOLUTE
))
1938 * We have a SEG_UNKNOWN symbol, or the size isn't cast.
1939 * It might turn out to be in the same segment as
1940 * the instruction, permitting relaxation.
1942 p
= frag_var (rs_machine_dependent
, 5, 2,
1943 ENCODE_RELAX (STATE_PC_RELATIVE
,
1944 is_undefined
? STATE_UNDF
: STATE_BYTE
),
1945 this_add_symbol
, this_add_number
, 0);
1946 *p
= operandP
->top_reg
;
1950 /* Either this is an abs, or a cast. */
1951 p
= frag_more (dispsize
+ 1);
1955 *p
= TAHOE_PC_OR_BYTE
+ operandP
->top_reg
;
1958 *p
= TAHOE_PC_OR_WORD
+ operandP
->top_reg
;
1961 *p
= TAHOE_PC_OR_LONG
+ operandP
->top_reg
;
1964 fix_new (frag_now
, p
+ 1 - frag_now
->fr_literal
,
1965 this_add_symbol
, this_add_number
,
1966 size_to_fx (dispsize
, pc_rel
), NULL
);
1970 as_fatal ("Barf, bad mode %x\n", operandP
->top_mode
);
1973 } /* for(operandP) */
1974 } /* if(!need_pass_2 && !goofed) */
1975 } /* tahoe_assemble() */
1978 /* We have no need to default values of symbols. */
1982 md_undefined_symbol (name
)
1986 } /* md_undefined_symbol() */
1988 /* Round up a section size to the appropriate boundary. */
1990 md_section_align (segment
, size
)
1994 return ((size
+ 7) & ~7); /* Round all sects to multiple of 8 */
1995 } /* md_section_align() */
1997 /* Exactly what point is a PC-relative offset relative TO?
1998 On the sparc, they're relative to the address of the offset, plus
1999 its size. This gets us to the following instruction.
2000 (??? Is this right? FIXME-SOON) */
2002 md_pcrel_from (fixP
)
2005 return (((fixP
->fx_type
== FX_8
2006 || fixP
->fx_type
== FX_PCREL8
)
2008 : ((fixP
->fx_type
== FX_16
2009 || fixP
->fx_type
== FX_PCREL16
)
2011 : ((fixP
->fx_type
== FX_32
2012 || fixP
->fx_type
== FX_PCREL32
)
2014 : 0))) + fixP
->fx_where
+ fixP
->fx_frag
->fr_address
);
2015 } /* md_pcrel_from() */
2021 /* should never be called */
2024 } /* tc_is_pcrel() */
2026 /* end of tc-tahoe.c */