1 /* tc-vax.c - vax-specific -
2 Copyright (C) 1987, 1991, 1992 Free Software Foundation, Inc.
4 This file is part of GAS, the GNU Assembler.
6 GAS is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 GAS is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GAS; see the file COPYING. If not, write to
18 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
20 /* JF I moved almost all the vax specific stuff into this one file 'cuz RMS
21 seems to think its a good idea. I hope I managed to get all the VAX-isms */
28 #include "obstack.h" /* For FRAG_APPEND_1_CHAR macro in "frags.h" */
30 /* These chars start a comment anywhere in a source file (except inside
32 const char comment_chars
[] = "#";
34 /* These chars only start a comment at the beginning of a line. */
35 /* Note that for the VAX the are the same as comment_chars above. */
36 const char line_comment_chars
[] = "#";
38 const char line_separator_chars
[] = "";
40 /* Chars that can be used to separate mant from exp in floating point nums */
41 const char EXP_CHARS
[] = "eE";
43 /* Chars that mean this number is a floating point constant */
45 /* or 0H1.234E-12 (see exp chars above) */
46 const char FLT_CHARS
[] = "dDfFgGhH";
48 /* Also be aware that MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT may have to be
49 changed in read.c . Ideally it shouldn't have to know about it at all,
50 but nothing is ideal around here.
53 static expressionS
/* Hold details of an operand expression */
54 exp_of_operand
[VIT_MAX_OPERANDS
];
57 v
; /* A vax instruction after decoding. */
59 LITTLENUM_TYPE big_operand_bits
[VIT_MAX_OPERANDS
][SIZE_OF_LARGE_NUMBER
];
60 /* Hold details of big operands. */
61 FLONUM_TYPE float_operand
[VIT_MAX_OPERANDS
];
62 /* Above is made to point into */
63 /* big_operand_bits by md_begin(). */
66 * For VAX, relative addresses of "just the right length" are easy.
67 * The branch displacement is always the last operand, even in
68 * synthetic instructions.
69 * For VAX, we encode the relax_substateTs (in e.g. fr_substate) as:
71 * 4 3 2 1 0 bit number
72 * ---/ /--+-------+-------+-------+-------+-------+
73 * | what state ? | how long ? |
74 * ---/ /--+-------+-------+-------+-------+-------+
76 * The "how long" bits are 00=byte, 01=word, 10=long.
77 * This is a Un*x convention.
78 * Not all lengths are legit for a given value of (what state).
79 * The "how long" refers merely to the displacement length.
80 * The address usually has some constant bytes in it as well.
83 groups for VAX address relaxing.
86 length of byte, word, long
88 2a. J<cond> where <cond> is a simple flag test.
89 length of byte, word, long.
90 VAX opcodes are: (Hex)
103 Always, you complement 0th bit to reverse condition.
104 Always, 1-byte opcode, then 1-byte displacement.
106 2b. J<cond> where cond tests a memory bit.
107 length of byte, word, long.
108 Vax opcodes are: (Hex)
117 Always, you complement 0th bit to reverse condition.
118 Always, 1-byte opcde, longword-address, byte-address, 1-byte-displacement
120 2c. J<cond> where cond tests low-order memory bit
121 length of byte,word,long.
122 Vax opcodes are: (Hex)
125 Always, you complement 0th bit to reverse condition.
126 Always, 1-byte opcode, longword-address, 1-byte displacement.
129 length of byte,word,long.
130 Vax opcodes are: (Hex)
133 These are like (2) but there is no condition to reverse.
134 Always, 1 byte opcode, then displacement/absolute.
137 length of word, long.
138 Vax opcodes are: (Hex)
146 Always, we cannot reverse the sense of the branch; we have a word
148 The double-byte op-codes don't hurt: we never want to modify the
149 opcode, so we don't care how many bytes are between the opcode and
153 length of long, long, byte.
154 Vax opcodes are: (Hex)
159 Always, we cannot reverse the sense of the branch; we have a byte
162 The only time we need to modify the opcode is for class 2 instructions.
163 After relax() we may complement the lowest order bit of such instruction
164 to reverse sense of branch.
166 For class 2 instructions, we store context of "where is the opcode literal".
167 We can change an opcode's lowest order bit without breaking anything else.
169 We sometimes store context in the operand literal. This way we can figure out
170 after relax() what the original addressing mode was.
173 /* These displacements are relative to */
174 /* the start address of the displacement. */
175 /* The first letter is Byte, Word. */
176 /* 2nd letter is Forward, Backward. */
179 #define WF (2+ 32767)
180 #define WB (2+-32768)
181 /* Dont need LF, LB because they always */
182 /* reach. [They are coded as 0.] */
185 #define C(a,b) ENCODE_RELAX(a,b)
186 /* This macro has no side-effects. */
187 #define ENCODE_RELAX(what,length) (((what) << 2) + (length))
192 {1, 1, 0, 0}, /* error sentinel 0,0 */
193 {1, 1, 0, 0}, /* unused 0,1 */
194 {1, 1, 0, 0}, /* unused 0,2 */
195 {1, 1, 0, 0}, /* unused 0,3 */
196 {BF
+ 1, BB
+ 1, 2, C (1, 1)},/* B^"foo" 1,0 */
197 {WF
+ 1, WB
+ 1, 3, C (1, 2)},/* W^"foo" 1,1 */
198 {0, 0, 5, 0}, /* L^"foo" 1,2 */
199 {1, 1, 0, 0}, /* unused 1,3 */
200 {BF
, BB
, 1, C (2, 1)}, /* b<cond> B^"foo" 2,0 */
201 {WF
+ 2, WB
+ 2, 4, C (2, 2)},/* br.+? brw X 2,1 */
202 {0, 0, 7, 0}, /* br.+? jmp X 2,2 */
203 {1, 1, 0, 0}, /* unused 2,3 */
204 {BF
, BB
, 1, C (3, 1)}, /* brb B^foo 3,0 */
205 {WF
, WB
, 2, C (3, 2)}, /* brw W^foo 3,1 */
206 {0, 0, 5, 0}, /* Jmp L^foo 3,2 */
207 {1, 1, 0, 0}, /* unused 3,3 */
208 {1, 1, 0, 0}, /* unused 4,0 */
209 {WF
, WB
, 2, C (4, 2)}, /* acb_ ^Wfoo 4,1 */
210 {0, 0, 10, 0}, /* acb_,br,jmp L^foo4,2 */
211 {1, 1, 0, 0}, /* unused 4,3 */
212 {BF
, BB
, 1, C (5, 1)}, /* Xob___,,foo 5,0 */
213 {WF
+ 4, WB
+ 4, 6, C (5, 2)},/* Xob.+2,brb.+3,brw5,1 */
214 {0, 0, 9, 0}, /* Xob.+2,brb.+6,jmp5,2 */
225 const pseudo_typeS md_pseudo_table
[] =
227 {"dfloat", float_cons
, 'd'},
228 {"ffloat", float_cons
, 'f'},
229 {"gfloat", float_cons
, 'g'},
230 {"hfloat", float_cons
, 'h'},
234 #define STATE_PC_RELATIVE (1)
235 #define STATE_CONDITIONAL_BRANCH (2)
236 #define STATE_ALWAYS_BRANCH (3) /* includes BSB... */
237 #define STATE_COMPLEX_BRANCH (4)
238 #define STATE_COMPLEX_HOP (5)
240 #define STATE_BYTE (0)
241 #define STATE_WORD (1)
242 #define STATE_LONG (2)
243 #define STATE_UNDF (3) /* Symbol undefined in pass1 */
246 #define min(a, b) ((a) < (b) ? (a) : (b))
250 int flonum_gen2vax (char format_letter
, FLONUM_TYPE
* f
, LITTLENUM_TYPE
* words
);
251 static void vip_end (void);
252 static void vip_op_defaults (char *immediate
, char *indirect
, char *displen
);
254 #else /* not __STDC__ */
256 int flonum_gen2vax ();
257 static void vip_end ();
258 static void vip_op_defaults ();
260 #endif /* not __STDC__ */
270 if (*(errtxt
= vip_begin (1, "$", "*", "`")))
272 as_fatal ("VIP_BEGIN error:%s", errtxt
);
275 for (i
= 0, fP
= float_operand
;
276 fP
< float_operand
+ VIT_MAX_OPERANDS
;
279 fP
->low
= &big_operand_bits
[i
][0];
280 fP
->high
= &big_operand_bits
[i
][SIZE_OF_LARGE_NUMBER
- 1];
290 void /* Knows about order of bytes in address. */
291 md_number_to_chars (con
, value
, nbytes
)
292 char con
[]; /* Return 'nbytes' of chars here. */
293 long value
; /* The value of the bits. */
294 int nbytes
; /* Number of bytes in the output. */
303 *con
++ = value
; /* Lint wants & MASK_CHAR. */
304 value
>>= BITS_PER_CHAR
;
306 /* XXX line number probably botched for this warning message. */
307 if (value
!= 0 && value
!= -1)
308 as_bad ("Displacement (%ld) long for instruction field length (%d).", v
, n
);
311 /* Fix up some data or instructions after we find out the value of a symbol
312 that they reference. */
314 void /* Knows about order of bytes in address. */
315 md_apply_fix (fixP
, value
)
316 fixS
*fixP
; /* Fixup struct pointer */
317 long value
; /* The value of the bits. */
319 char *buf
= fixP
->fx_where
+ fixP
->fx_frag
->fr_literal
;
320 int nbytes
; /* Number of bytes in the output. */
322 nbytes
= fixP
->fx_size
;
325 *buf
++ = value
; /* Lint wants & MASK_CHAR. */
326 value
>>= BITS_PER_CHAR
;
330 long /* Knows about the byte order in a word. */
331 md_chars_to_number (con
, nbytes
)
332 unsigned char con
[]; /* Low order byte 1st. */
333 int nbytes
; /* Number of bytes in the input. */
336 for (retval
= 0, con
+= nbytes
- 1; nbytes
--; con
--)
338 retval
<<= BITS_PER_CHAR
;
344 /* vax:md_assemble() emit frags for 1 instruction */
347 md_assemble (instruction_string
)
348 char *instruction_string
; /* A string: assemble 1 instruction. */
350 /* We saw no errors in any operands - try to make frag(s) */
351 int is_undefined
; /* 1 if operand expression's */
352 /* segment not known yet. */
356 register struct vop
*operandP
;/* An operand. Scans all operands. */
357 char *save_input_line_pointer
;
358 char c_save
; /* What used to live after an expression. */
360 /* struct frag *fragP; *//* Fragment of code we just made. */
361 register int goofed
; /* 1: instruction_string bad for all passes. */
362 register struct vop
*end_operandP
; /* -> slot just after last operand */
363 /* Limit of the for (each operand). */
364 register expressionS
*expP
; /* -> expression values for this operand */
366 /* These refer to an instruction operand expression. */
367 segT to_seg
; /* Target segment of the address. */
368 register valueT this_add_number
;
369 register struct symbol
*this_add_symbol
; /* +ve (minuend) symbol. */
370 register struct symbol
*this_subtract_symbol
; /* -ve(subtrahend) symbol. */
372 long opcode_as_number
; /* As a number. */
373 char *opcode_as_chars
; /* Least significant byte 1st. */
374 /* As an array of characters. */
375 char *opcode_low_byteP
; /* Least significant byte 1st */
376 /* richfix: unused? */
377 /* struct details *detP; *//* The details of an ADxxx frag. */
378 int length
; /* length (bytes) meant by vop_short. */
379 int at
; /* 0, or 1 if '@' is in addressing mode. */
380 int nbytes
; /* From vop_nbytes: vax_operand_width (in bytes) */
383 LITTLENUM_TYPE literal_float
[8];
384 /* Big enough for any floating point literal. */
386 if (*(p
= vip (&v
, instruction_string
)))
388 as_fatal ("vax_assemble\"%s\" in=\"%s\"", p
, instruction_string
);
391 * Now we try to find as many as_warn()s as we can. If we do any as_warn()s
392 * then goofed=1. Notice that we don't make any frags yet.
393 * Should goofed be 1, then this instruction will wedge in any pass,
394 * and we can safely flush it, without causing interpass symbol phase
395 * errors. That is, without changing label values in different passes.
397 if (goofed
= (*v
.vit_error
))
399 as_warn ("Ignoring statement due to \"%s\"", v
.vit_error
);
402 * We need to use expression() and friends, which require us to diddle
403 * input_line_pointer. So we save it and restore it later.
405 save_input_line_pointer
= input_line_pointer
;
406 for (operandP
= v
.vit_operand
,
407 expP
= exp_of_operand
,
408 floatP
= float_operand
,
409 end_operandP
= v
.vit_operand
+ v
.vit_operands
;
411 operandP
< end_operandP
;
413 operandP
++, expP
++, floatP
++)
414 { /* for each operand */
415 if (*(operandP
->vop_error
))
417 as_warn ("Ignoring statement because \"%s\"", (operandP
->vop_error
));
421 { /* statement has no syntax goofs: lets sniff the expression */
422 int can_be_short
= 0; /* 1 if a bignum can be reduced to a short literal. */
424 input_line_pointer
= operandP
->vop_expr_begin
;
425 c_save
= operandP
->vop_expr_end
[1];
426 operandP
->vop_expr_end
[1] = '\0';
427 /* If to_seg == SEG_PASS1, expression() will have set need_pass_2 = 1. */
428 switch (to_seg
= expression (expP
))
431 /* for BSD4.2 compatibility, missing expression is absolute 0 */
432 to_seg
= expP
->X_seg
= SEG_ABSOLUTE
;
433 expP
->X_add_number
= 0;
434 /* for SEG_ABSOLUTE, we shouldnt need to set X_subtract_symbol, X_add_symbol to any
435 particular value. But, we will program defensively. Since this situation occurs rarely
436 so it costs us little to do, and stops Dean worrying about the origin of random bits in
438 expP
->X_add_symbol
= NULL
;
439 expP
->X_subtract_symbol
= NULL
;
450 * Major bug. We can't handle the case of a
451 * SEG_DIFFERENCE expression in a VIT_OPCODE_SYNTHETIC
452 * variable-length instruction.
453 * We don't have a frag type that is smart enough to
454 * relax a SEG_DIFFERENCE, and so we just force all
455 * SEG_DIFFERENCEs to behave like SEG_PASS1s.
456 * Clearly, if there is a demand we can invent a new or
457 * modified frag type and then coding up a frag for this
458 * case will be easy. SEG_DIFFERENCE was invented for the
459 * .words after a CASE opcode, and was never intended for
460 * instruction operands.
463 as_warn ("Can't relocate expression");
467 /* Preserve the bits. */
468 if (expP
->X_add_number
> 0)
470 bignum_copy (generic_bignum
, expP
->X_add_number
,
471 floatP
->low
, SIZE_OF_LARGE_NUMBER
);
475 know (expP
->X_add_number
< 0);
476 flonum_copy (&generic_floating_point_number
,
478 if (strchr ("s i", operandP
->vop_short
))
479 { /* Could possibly become S^# */
480 flonum_gen2vax (-expP
->X_add_number
, floatP
, literal_float
);
481 switch (-expP
->X_add_number
)
485 (literal_float
[0] & 0xFC0F) == 0x4000
486 && literal_float
[1] == 0;
491 (literal_float
[0] & 0xFC0F) == 0x4000
492 && literal_float
[1] == 0
493 && literal_float
[2] == 0
494 && literal_float
[3] == 0;
499 (literal_float
[0] & 0xFF81) == 0x4000
500 && literal_float
[1] == 0
501 && literal_float
[2] == 0
502 && literal_float
[3] == 0;
506 can_be_short
= ((literal_float
[0] & 0xFFF8) == 0x4000
507 && (literal_float
[1] & 0xE000) == 0
508 && literal_float
[2] == 0
509 && literal_float
[3] == 0
510 && literal_float
[4] == 0
511 && literal_float
[5] == 0
512 && literal_float
[6] == 0
513 && literal_float
[7] == 0);
517 BAD_CASE (-expP
->X_add_number
);
519 } /* switch (float type) */
520 } /* if (could want to become S^#...) */
521 } /* bignum or flonum ? */
523 if (operandP
->vop_short
== 's'
524 || operandP
->vop_short
== 'i'
525 || (operandP
->vop_short
== ' '
526 && operandP
->vop_reg
== 0xF
527 && (operandP
->vop_mode
& 0xE) == 0x8))
530 if (operandP
->vop_short
== ' ')
531 { /* We must chose S^ or I^. */
532 if (expP
->X_add_number
> 0)
533 { /* Bignum: Short literal impossible. */
534 operandP
->vop_short
= 'i';
535 operandP
->vop_mode
= 8;
536 operandP
->vop_reg
= 0xF; /* VAX PC. */
539 { /* Flonum: Try to do it. */
542 operandP
->vop_short
= 's';
543 operandP
->vop_mode
= 0;
544 operandP
->vop_ndx
= -1;
545 operandP
->vop_reg
= -1;
546 /* JF hope this is the right thing */
547 expP
->X_seg
= SEG_ABSOLUTE
;
551 operandP
->vop_short
= 'i';
552 operandP
->vop_mode
= 8;
553 operandP
->vop_reg
= 0xF; /* VAX PC */
555 } /* bignum or flonum ? */
556 } /* if #, but no S^ or I^ seen. */
557 /* No more ' ' case: either 's' or 'i'. */
558 if (operandP
->vop_short
== 's')
560 /* Wants to be a short literal. */
561 if (expP
->X_add_number
> 0)
563 as_warn ("Bignum not permitted in short literal. Immediate mode assumed.");
564 operandP
->vop_short
= 'i';
565 operandP
->vop_mode
= 8;
566 operandP
->vop_reg
= 0xF; /* VAX PC. */
572 as_warn ("Can't do flonum short literal: immediate mode used.");
573 operandP
->vop_short
= 'i';
574 operandP
->vop_mode
= 8;
575 operandP
->vop_reg
= 0xF; /* VAX PC. */
578 { /* Encode short literal now. */
581 switch (-expP
->X_add_number
)
585 temp
= literal_float
[0] >> 4;
589 temp
= literal_float
[0] >> 1;
593 temp
= ((literal_float
[0] << 3) & 070)
594 | ((literal_float
[1] >> 13) & 07);
598 BAD_CASE (-expP
->X_add_number
);
602 floatP
->low
[0] = temp
& 077;
604 } /* if can be short literal float */
605 } /* flonum or bignum ? */
608 { /* I^# seen: set it up if float. */
609 if (expP
->X_add_number
< 0)
611 memcpy (floatP
->low
, literal_float
, sizeof (literal_float
));
617 as_warn ("A bignum/flonum may not be a displacement: 0x%x used",
618 expP
->X_add_number
= 0x80000000);
619 /* Chosen so luser gets the most offset bits to patch later. */
621 expP
->X_add_number
= floatP
->low
[0]
622 | ((LITTLENUM_MASK
& (floatP
->low
[1])) << LITTLENUM_NUMBER_OF_BITS
);
624 * For the SEG_BIG case we have:
625 * If vop_short == 's' then a short floating literal is in the
626 * lowest 6 bits of floatP -> low [0], which is
627 * big_operand_bits [---] [0].
628 * If vop_short == 'i' then the appropriate number of elements
629 * of big_operand_bits [---] [...] are set up with the correct
631 * Also, just in case width is byte word or long, we copy the lowest
632 * 32 bits of the number to X_add_number.
640 if (input_line_pointer
!= operandP
->vop_expr_end
+ 1)
642 as_warn ("Junk at end of expression \"%s\"", input_line_pointer
);
645 operandP
->vop_expr_end
[1] = c_save
;
647 } /* for(each operand) */
649 input_line_pointer
= save_input_line_pointer
;
651 if (need_pass_2
|| goofed
)
658 /* Remember where it is, in case we want to modify the op-code later. */
659 opcode_low_byteP
= frag_more (v
.vit_opcode_nbytes
);
660 memcpy (opcode_low_byteP
, v
.vit_opcode
, v
.vit_opcode_nbytes
);
661 opcode_as_number
= md_chars_to_number (opcode_as_chars
= v
.vit_opcode
, 4);
662 for (operandP
= v
.vit_operand
,
663 expP
= exp_of_operand
,
664 floatP
= float_operand
,
665 end_operandP
= v
.vit_operand
+ v
.vit_operands
;
667 operandP
< end_operandP
;
672 { /* for each operand */
673 if (operandP
->vop_ndx
>= 0)
675 /* indexed addressing byte */
676 /* Legality of indexed mode already checked: it is OK */
677 FRAG_APPEND_1_CHAR (0x40 + operandP
->vop_ndx
);
678 } /* if(vop_ndx>=0) */
680 /* Here to make main operand frag(s). */
681 this_add_number
= expP
->X_add_number
;
682 this_add_symbol
= expP
->X_add_symbol
;
683 this_subtract_symbol
= expP
->X_subtract_symbol
;
684 to_seg
= expP
->X_seg
;
685 is_undefined
= (to_seg
== SEG_UNKNOWN
);
686 know (to_seg
== SEG_UNKNOWN
687 || to_seg
== SEG_ABSOLUTE
688 || to_seg
== SEG_DATA
689 || to_seg
== SEG_TEXT
691 || to_seg
== SEG_BIG
);
692 at
= operandP
->vop_mode
& 1;
693 length
= (operandP
->vop_short
== 'b'
694 ? 1 : (operandP
->vop_short
== 'w'
695 ? 2 : (operandP
->vop_short
== 'l'
697 nbytes
= operandP
->vop_nbytes
;
698 if (operandP
->vop_access
== 'b')
700 if (to_seg
== now_seg
|| is_undefined
)
702 /* If is_undefined, then it might BECOME now_seg. */
705 p
= frag_more (nbytes
);
706 fix_new (frag_now
, p
- frag_now
->fr_literal
, nbytes
,
707 this_add_symbol
, 0, this_add_number
, 1, NO_RELOC
);
710 { /* to_seg==now_seg || to_seg == SEG_UNKNOWN */
712 length_code
= is_undefined
? STATE_UNDF
: STATE_BYTE
;
713 if (opcode_as_number
& VIT_OPCODE_SPECIAL
)
715 if (operandP
->vop_width
== VAX_WIDTH_UNCONDITIONAL_JUMP
)
718 frag_var (rs_machine_dependent
, 5, 1,
719 ENCODE_RELAX (STATE_ALWAYS_BRANCH
, length_code
),
720 this_add_symbol
, this_add_number
,
725 if (operandP
->vop_width
== VAX_WIDTH_WORD_JUMP
)
727 length_code
= STATE_WORD
;
728 /* JF: There is no state_byte for this one! */
729 frag_var (rs_machine_dependent
, 10, 2,
730 ENCODE_RELAX (STATE_COMPLEX_BRANCH
, length_code
),
731 this_add_symbol
, this_add_number
,
736 know (operandP
->vop_width
== VAX_WIDTH_BYTE_JUMP
);
737 frag_var (rs_machine_dependent
, 9, 1,
738 ENCODE_RELAX (STATE_COMPLEX_HOP
, length_code
),
739 this_add_symbol
, this_add_number
,
746 know (operandP
->vop_width
== VAX_WIDTH_CONDITIONAL_JUMP
);
747 frag_var (rs_machine_dependent
, 7, 1,
748 ENCODE_RELAX (STATE_CONDITIONAL_BRANCH
, length_code
),
749 this_add_symbol
, this_add_number
,
755 { /* to_seg != now_seg && to_seg != SEG_UNKNOWN */
757 * --- SEG FLOAT MAY APPEAR HERE ----
759 if (to_seg
== SEG_ABSOLUTE
)
763 know (!(opcode_as_number
& VIT_OPCODE_SYNTHETIC
));
764 p
= frag_more (nbytes
);
765 /* Conventional relocation. */
766 fix_new (frag_now
, p
- frag_now
->fr_literal
,
767 nbytes
, &abs_symbol
, 0, this_add_number
, 1, NO_RELOC
);
771 know (opcode_as_number
& VIT_OPCODE_SYNTHETIC
);
772 if (opcode_as_number
& VIT_OPCODE_SPECIAL
)
774 if (operandP
->vop_width
== VAX_WIDTH_UNCONDITIONAL_JUMP
)
777 *opcode_low_byteP
= opcode_as_chars
[0] + VAX_WIDEN_LONG
;
778 know (opcode_as_chars
[1] == 0);
780 p
[0] = VAX_ABSOLUTE_MODE
; /* @#... */
781 md_number_to_chars (p
+ 1, this_add_number
, 4);
782 /* Now (eg) JMP @#foo or JSB @#foo. */
786 if (operandP
->vop_width
== VAX_WIDTH_WORD_JUMP
)
794 p
[5] = VAX_ABSOLUTE_MODE
; /* @#... */
795 md_number_to_chars (p
+ 6, this_add_number
, 4);
805 know (operandP
->vop_width
== VAX_WIDTH_BYTE_JUMP
);
811 p
[4] = VAX_PC_RELATIVE_MODE
+ 1; /* @#... */
812 md_number_to_chars (p
+ 5, this_add_number
, 4);
825 *opcode_low_byteP
^= 1;
826 /* To reverse the condition in a VAX branch, complement the lowest order
831 p
[2] = VAX_ABSOLUTE_MODE
; /* @#... */
832 md_number_to_chars (p
+ 3, this_add_number
, 4);
842 { /* to_seg != now_seg && to_seg != SEG_UNKNOWN && to_Seg != SEG_ABSOLUTE */
845 /* Pc-relative. Conventional relocation. */
846 know (!(opcode_as_number
& VIT_OPCODE_SYNTHETIC
));
847 p
= frag_more (nbytes
);
848 fix_new (frag_now
, p
- frag_now
->fr_literal
,
849 nbytes
, &abs_symbol
, 0, this_add_number
, 1, NO_RELOC
);
853 know (opcode_as_number
& VIT_OPCODE_SYNTHETIC
);
854 if (opcode_as_number
& VIT_OPCODE_SPECIAL
)
856 if (operandP
->vop_width
== VAX_WIDTH_UNCONDITIONAL_JUMP
)
859 know (opcode_as_chars
[1] == 0);
860 *opcode_low_byteP
= opcode_as_chars
[0] + VAX_WIDEN_LONG
;
862 p
[0] = VAX_PC_RELATIVE_MODE
;
864 p
+ 1 - frag_now
->fr_literal
, 4,
866 this_add_number
, 1, NO_RELOC
);
867 /* Now eg JMP foo or JSB foo. */
871 if (operandP
->vop_width
== VAX_WIDTH_WORD_JUMP
)
879 p
[5] = VAX_PC_RELATIVE_MODE
;
881 p
+ 6 - frag_now
->fr_literal
, 4,
883 this_add_number
, 1, NO_RELOC
);
893 know (operandP
->vop_width
== VAX_WIDTH_BYTE_JUMP
);
899 p
[4] = VAX_PC_RELATIVE_MODE
;
901 p
+ 5 - frag_now
->fr_literal
,
902 4, this_add_symbol
, 0,
903 this_add_number
, 1, NO_RELOC
);
915 know (operandP
->vop_width
== VAX_WIDTH_CONDITIONAL_JUMP
);
916 *opcode_low_byteP
^= 1; /* Reverse branch condition. */
920 p
[2] = VAX_PC_RELATIVE_MODE
;
921 fix_new (frag_now
, p
+ 3 - frag_now
->fr_literal
,
922 4, this_add_symbol
, 0,
923 this_add_number
, 1, NO_RELOC
);
931 know (operandP
->vop_access
!= 'b'); /* So it is ordinary operand. */
932 know (operandP
->vop_access
!= ' '); /* ' ' target-independent: elsewhere. */
933 know (operandP
->vop_access
== 'a'
934 || operandP
->vop_access
== 'm'
935 || operandP
->vop_access
== 'r'
936 || operandP
->vop_access
== 'v'
937 || operandP
->vop_access
== 'w');
938 if (operandP
->vop_short
== 's')
940 if (to_seg
== SEG_ABSOLUTE
)
942 if (this_add_number
< 0 || this_add_number
>= 64)
944 as_warn ("Short literal overflow(%d.), immediate mode assumed.", this_add_number
);
945 operandP
->vop_short
= 'i';
946 operandP
->vop_mode
= 8;
947 operandP
->vop_reg
= 0xF;
952 as_warn ("Forced short literal to immediate mode. now_seg=%s to_seg=%s",
953 segment_name (now_seg
), segment_name (to_seg
));
954 operandP
->vop_short
= 'i';
955 operandP
->vop_mode
= 8;
956 operandP
->vop_reg
= 0xF;
959 if (operandP
->vop_reg
>= 0 && (operandP
->vop_mode
< 8
960 || (operandP
->vop_reg
!= 0xF && operandP
->vop_mode
< 10)))
962 /* One byte operand. */
963 know (operandP
->vop_mode
> 3);
964 FRAG_APPEND_1_CHAR (operandP
->vop_mode
<< 4 | operandP
->vop_reg
);
965 /* All 1-bytes except S^# happen here. */
968 { /* {@}{q^}foo{(Rn)} or S^#foo */
969 if (operandP
->vop_reg
== -1 && operandP
->vop_short
!= 's')
972 if (to_seg
== now_seg
)
976 know (operandP
->vop_short
== ' ');
977 p
= frag_var (rs_machine_dependent
, 10, 2,
978 ENCODE_RELAX (STATE_PC_RELATIVE
, STATE_BYTE
),
979 this_add_symbol
, this_add_number
,
981 know (operandP
->vop_mode
== 10 + at
);
983 /* At is the only context we need to carry to */
984 /* other side of relax() process. */
985 /* Must be in the correct bit position of VAX */
986 /* operand spec. byte. */
991 know (operandP
->vop_short
!= ' ');
992 p
= frag_more (length
+ 1);
993 /* JF is this array stuff really going to work? */
994 p
[0] = 0xF | ((at
+ "?\12\14?\16"[length
]) << 4);
995 fix_new (frag_now
, p
+ 1 - frag_now
->fr_literal
,
996 length
, this_add_symbol
, 0,
997 this_add_number
, 1, NO_RELOC
);
1001 { /* to_seg != now_seg */
1002 if (this_add_symbol
== NULL
)
1004 know (to_seg
== SEG_ABSOLUTE
);
1005 /* Do @#foo: simpler relocation than foo-.(pc) anyway. */
1007 p
[0] = VAX_ABSOLUTE_MODE
; /* @#... */
1008 md_number_to_chars (p
+ 1, this_add_number
, 4);
1009 if (length
&& length
!= 4)
1011 as_warn ("Length specification ignored. Address mode 9F used");
1016 /* {@}{q^}other_seg */
1017 know ((length
== 0 && operandP
->vop_short
== ' ')
1018 || (length
> 0 && operandP
->vop_short
!= ' '));
1022 * We have a SEG_UNKNOWN symbol. It might
1023 * turn out to be in the same segment as
1024 * the instruction, permitting relaxation.
1026 p
= frag_var (rs_machine_dependent
, 5, 2,
1027 ENCODE_RELAX (STATE_PC_RELATIVE
, STATE_UNDF
),
1028 this_add_symbol
, this_add_number
,
1036 know (operandP
->vop_short
== ' ');
1037 length
= 4; /* Longest possible. */
1039 p
= frag_more (length
+ 1);
1040 p
[0] = 0xF | ((at
+ "?\12\14?\16"[length
]) << 4);
1041 md_number_to_chars (p
+ 1, this_add_number
, length
);
1043 p
+ 1 - frag_now
->fr_literal
,
1044 length
, this_add_symbol
, 0,
1045 this_add_number
, 1, NO_RELOC
);
1051 { /* {@}{q^}foo(Rn) or S^# or I^# or # */
1052 if (operandP
->vop_mode
< 0xA)
1053 { /* # or S^# or I^# */
1054 /* know( (length == 0 && operandP->vop_short == ' ')
1055 || (length > 0 && operandP->vop_short != ' ')); */
1057 && to_seg
== SEG_ABSOLUTE
1058 && operandP
->vop_mode
== 8 /* No '@'. */
1059 && this_add_number
< 64
1060 && this_add_number
>= 0)
1062 operandP
->vop_short
= 's';
1064 if (operandP
->vop_short
== 's')
1066 FRAG_APPEND_1_CHAR (this_add_number
);
1071 p
= frag_more (nbytes
+ 1);
1072 know (operandP
->vop_reg
== 0xF);
1073 p
[0] = (operandP
->vop_mode
<< 4) | 0xF;
1074 if (to_seg
== SEG_ABSOLUTE
)
1077 * If nbytes > 4, then we are scrod. We don't know if the
1078 * high order bytes are to be 0xFF or 0x00.
1079 * BSD4.2 & RMS say use 0x00. OK --- but this
1080 * assembler needs ANOTHER rewrite to
1081 * cope properly with this bug.
1083 md_number_to_chars (p
+ 1, this_add_number
, min (4, nbytes
));
1086 memset (p
+ 5, '\0', nbytes
- 4);
1091 if (to_seg
== SEG_BIG
)
1094 * Problem here is to get the bytes in the right order.
1095 * We stored our constant as LITTLENUMs, not bytes.
1107 for (p
++; nbytes
; nbytes
-= 2, p
+= 2, lP
++)
1109 md_number_to_chars (p
, *lP
, 2);
1115 fix_new (frag_now
, p
+ 1 - frag_now
->fr_literal
,
1116 nbytes
, this_add_symbol
, 0,
1117 this_add_number
, 0, NO_RELOC
);
1123 { /* {@}{q^}foo(Rn) */
1124 know ((length
== 0 && operandP
->vop_short
== ' ')
1125 || (length
> 0 && operandP
->vop_short
!= ' '));
1128 if (to_seg
== SEG_ABSOLUTE
)
1132 test
= this_add_number
;
1137 length
= test
& 0xffff8000 ? 4
1138 : test
& 0xffffff80 ? 2
1146 p
= frag_more (1 + length
);
1147 know (operandP
->vop_reg
>= 0);
1148 p
[0] = operandP
->vop_reg
1149 | ((at
| "?\12\14?\16"[length
]) << 4);
1150 if (to_seg
== SEG_ABSOLUTE
)
1152 md_number_to_chars (p
+ 1, this_add_number
, length
);
1156 fix_new (frag_now
, p
+ 1 - frag_now
->fr_literal
,
1157 length
, this_add_symbol
, 0,
1158 this_add_number
, 0, NO_RELOC
);
1162 } /* if(single-byte-operand) */
1164 } /* for(operandP) */
1165 } /* vax_assemble() */
1168 * md_estimate_size_before_relax()
1170 * Called just before relax().
1171 * Any symbol that is now undefined will not become defined.
1172 * Return the correct fr_subtype in the frag.
1173 * Return the initial "guess for fr_var" to caller.
1174 * The guess for fr_var is ACTUALLY the growth beyond fr_fix.
1175 * Whatever we do to grow fr_fix or fr_var contributes to our returned value.
1176 * Although it may not be explicit in the frag, pretend fr_var starts with a
1180 md_estimate_size_before_relax (fragP
, segment
)
1181 register fragS
*fragP
;
1182 register segT segment
;
1185 register int old_fr_fix
;
1187 old_fr_fix
= fragP
->fr_fix
;
1188 switch (fragP
->fr_subtype
)
1190 case ENCODE_RELAX (STATE_PC_RELATIVE
, STATE_UNDF
):
1191 if (S_GET_SEGMENT (fragP
->fr_symbol
) == segment
)
1192 { /* A relaxable case. */
1193 fragP
->fr_subtype
= ENCODE_RELAX (STATE_PC_RELATIVE
, STATE_BYTE
);
1197 p
= fragP
->fr_literal
+ old_fr_fix
;
1198 p
[0] |= VAX_PC_RELATIVE_MODE
; /* Preserve @ bit. */
1199 fragP
->fr_fix
+= 1 + 4;
1200 fix_new (fragP
, old_fr_fix
+ 1, 4, fragP
->fr_symbol
, 0,
1201 fragP
->fr_offset
, 1, NO_RELOC
);
1206 case ENCODE_RELAX (STATE_CONDITIONAL_BRANCH
, STATE_UNDF
):
1207 if (S_GET_SEGMENT (fragP
->fr_symbol
) == segment
)
1209 fragP
->fr_subtype
= ENCODE_RELAX (STATE_CONDITIONAL_BRANCH
, STATE_BYTE
);
1213 p
= fragP
->fr_literal
+ old_fr_fix
;
1214 *fragP
->fr_opcode
^= 1; /* Reverse sense of branch. */
1217 p
[2] = VAX_PC_RELATIVE_MODE
; /* ...(PC) */
1218 fragP
->fr_fix
+= 1 + 1 + 1 + 4;
1219 fix_new (fragP
, old_fr_fix
+ 3, 4, fragP
->fr_symbol
, 0,
1220 fragP
->fr_offset
, 1, NO_RELOC
);
1225 case ENCODE_RELAX (STATE_COMPLEX_BRANCH
, STATE_UNDF
):
1226 if (S_GET_SEGMENT (fragP
->fr_symbol
) == segment
)
1228 fragP
->fr_subtype
= ENCODE_RELAX (STATE_COMPLEX_BRANCH
, STATE_WORD
);
1232 p
= fragP
->fr_literal
+ old_fr_fix
;
1238 p
[5] = VAX_PC_RELATIVE_MODE
; /* ...(pc) */
1239 fragP
->fr_fix
+= 2 + 2 + 1 + 1 + 4;
1240 fix_new (fragP
, old_fr_fix
+ 6, 4, fragP
->fr_symbol
, 0,
1241 fragP
->fr_offset
, 1, NO_RELOC
);
1246 case ENCODE_RELAX (STATE_COMPLEX_HOP
, STATE_UNDF
):
1247 if (S_GET_SEGMENT (fragP
->fr_symbol
) == segment
)
1249 fragP
->fr_subtype
= ENCODE_RELAX (STATE_COMPLEX_HOP
, STATE_BYTE
);
1253 p
= fragP
->fr_literal
+ old_fr_fix
;
1258 p
[4] = VAX_PC_RELATIVE_MODE
; /* ...(pc) */
1259 fragP
->fr_fix
+= 1 + 2 + 1 + 1 + 4;
1260 fix_new (fragP
, old_fr_fix
+ 5, 4, fragP
->fr_symbol
, 0,
1261 fragP
->fr_offset
, 1, NO_RELOC
);
1266 case ENCODE_RELAX (STATE_ALWAYS_BRANCH
, STATE_UNDF
):
1267 if (S_GET_SEGMENT (fragP
->fr_symbol
) == segment
)
1269 fragP
->fr_subtype
= ENCODE_RELAX (STATE_ALWAYS_BRANCH
, STATE_BYTE
);
1273 p
= fragP
->fr_literal
+ old_fr_fix
;
1274 *fragP
->fr_opcode
+= VAX_WIDEN_LONG
;
1275 p
[0] = VAX_PC_RELATIVE_MODE
; /* ...(PC) */
1276 fragP
->fr_fix
+= 1 + 4;
1277 fix_new (fragP
, old_fr_fix
+ 1, 4, fragP
->fr_symbol
, 0,
1278 fragP
->fr_offset
, 1, NO_RELOC
);
1286 return (fragP
->fr_var
+ fragP
->fr_fix
- old_fr_fix
);
1287 } /* md_estimate_size_before_relax() */
1290 * md_convert_frag();
1292 * Called after relax() is finished.
1293 * In: Address of frag.
1294 * fr_type == rs_machine_dependent.
1295 * fr_subtype is what the address relaxed to.
1297 * Out: Any fixSs and constants are set up.
1298 * Caller will turn frag into a ".space 0".
1301 md_convert_frag (headers
, fragP
)
1302 object_headers
*headers
;
1303 register fragS
*fragP
;
1305 char *addressP
; /* -> _var to change. */
1306 char *opcodeP
; /* -> opcode char(s) to change. */
1307 short int length_code
; /* 2=long 1=word 0=byte */
1308 short int extension
= 0; /* Size of relaxed address. */
1309 /* Added to fr_fix: incl. ALL var chars. */
1312 long address_of_var
;
1313 /* Where, in file space, is _var of *fragP? */
1314 long target_address
= 0;
1315 /* Where, in file space, does addr point? */
1317 know (fragP
->fr_type
== rs_machine_dependent
);
1318 length_code
= fragP
->fr_subtype
& 3; /* depends on ENCODE_RELAX() */
1319 know (length_code
>= 0 && length_code
< 3);
1320 where
= fragP
->fr_fix
;
1321 addressP
= fragP
->fr_literal
+ where
;
1322 opcodeP
= fragP
->fr_opcode
;
1323 symbolP
= fragP
->fr_symbol
;
1325 target_address
= S_GET_VALUE (symbolP
) + fragP
->fr_offset
;
1326 address_of_var
= fragP
->fr_address
+ where
;
1328 switch (fragP
->fr_subtype
)
1331 case ENCODE_RELAX (STATE_PC_RELATIVE
, STATE_BYTE
):
1332 know (*addressP
== 0 || *addressP
== 0x10); /* '@' bit. */
1333 addressP
[0] |= 0xAF; /* Byte displacement. */
1334 addressP
[1] = target_address
- (address_of_var
+ 2);
1338 case ENCODE_RELAX (STATE_PC_RELATIVE
, STATE_WORD
):
1339 know (*addressP
== 0 || *addressP
== 0x10); /* '@' bit. */
1340 addressP
[0] |= 0xCF; /* Word displacement. */
1341 md_number_to_chars (addressP
+ 1, target_address
- (address_of_var
+ 3), 2);
1345 case ENCODE_RELAX (STATE_PC_RELATIVE
, STATE_LONG
):
1346 know (*addressP
== 0 || *addressP
== 0x10); /* '@' bit. */
1347 addressP
[0] |= 0xEF; /* Long word displacement. */
1348 md_number_to_chars (addressP
+ 1, target_address
- (address_of_var
+ 5), 4);
1352 case ENCODE_RELAX (STATE_CONDITIONAL_BRANCH
, STATE_BYTE
):
1353 addressP
[0] = target_address
- (address_of_var
+ 1);
1357 case ENCODE_RELAX (STATE_CONDITIONAL_BRANCH
, STATE_WORD
):
1358 opcodeP
[0] ^= 1; /* Reverse sense of test. */
1360 addressP
[1] = VAX_BRB
+ VAX_WIDEN_WORD
;
1361 md_number_to_chars (addressP
+ 2, target_address
- (address_of_var
+ 4), 2);
1365 case ENCODE_RELAX (STATE_CONDITIONAL_BRANCH
, STATE_LONG
):
1366 opcodeP
[0] ^= 1; /* Reverse sense of test. */
1368 addressP
[1] = VAX_JMP
;
1369 addressP
[2] = VAX_PC_RELATIVE_MODE
;
1370 md_number_to_chars (addressP
+ 3, target_address
, 4);
1374 case ENCODE_RELAX (STATE_ALWAYS_BRANCH
, STATE_BYTE
):
1375 addressP
[0] = target_address
- (address_of_var
+ 1);
1379 case ENCODE_RELAX (STATE_ALWAYS_BRANCH
, STATE_WORD
):
1380 opcodeP
[0] += VAX_WIDEN_WORD
; /* brb -> brw, bsbb -> bsbw */
1381 md_number_to_chars (addressP
, target_address
- (address_of_var
+ 2), 2);
1385 case ENCODE_RELAX (STATE_ALWAYS_BRANCH
, STATE_LONG
):
1386 opcodeP
[0] += VAX_WIDEN_LONG
; /* brb -> jmp, bsbb -> jsb */
1387 addressP
[0] = VAX_PC_RELATIVE_MODE
;
1388 md_number_to_chars (addressP
+ 1, target_address
- (address_of_var
+ 5), 4);
1392 case ENCODE_RELAX (STATE_COMPLEX_BRANCH
, STATE_WORD
):
1393 md_number_to_chars (addressP
, target_address
- (address_of_var
+ 2), 2);
1397 case ENCODE_RELAX (STATE_COMPLEX_BRANCH
, STATE_LONG
):
1400 addressP
[2] = VAX_BRB
;
1402 addressP
[4] = VAX_JMP
;
1403 addressP
[5] = VAX_PC_RELATIVE_MODE
;
1404 md_number_to_chars (addressP
+ 6, target_address
, 4);
1408 case ENCODE_RELAX (STATE_COMPLEX_HOP
, STATE_BYTE
):
1409 addressP
[0] = target_address
- (address_of_var
+ 1);
1413 case ENCODE_RELAX (STATE_COMPLEX_HOP
, STATE_WORD
):
1415 addressP
[1] = VAX_BRB
;
1417 addressP
[3] = VAX_BRW
;
1418 md_number_to_chars (addressP
+ 4, target_address
- (address_of_var
+ 6), 2);
1422 case ENCODE_RELAX (STATE_COMPLEX_HOP
, STATE_LONG
):
1424 addressP
[1] = VAX_BRB
;
1426 addressP
[3] = VAX_JMP
;
1427 addressP
[4] = VAX_PC_RELATIVE_MODE
;
1428 md_number_to_chars (addressP
+ 5, target_address
, 4);
1433 BAD_CASE (fragP
->fr_subtype
);
1436 fragP
->fr_fix
+= extension
;
1437 } /* md_convert_frag() */
1439 /* Translate internal format of relocation info into target format.
1441 On vax: first 4 bytes are normal unsigned long, next three bytes
1442 are symbolnum, least sig. byte first. Last byte is broken up with
1443 the upper nibble as nuthin, bit 3 as extern, bits 2 & 1 as length, and
1447 md_ri_to_chars (the_bytes
, ri
)
1449 struct reloc_info_generic ri
;
1452 md_number_to_chars (the_bytes
, ri
.r_address
, sizeof (ri
.r_address
));
1453 /* now the fun stuff */
1454 the_bytes
[6] = (ri
.r_symbolnum
>> 16) & 0x0ff;
1455 the_bytes
[5] = (ri
.r_symbolnum
>> 8) & 0x0ff;
1456 the_bytes
[4] = ri
.r_symbolnum
& 0x0ff;
1457 the_bytes
[7] = (((ri
.r_extern
<< 3) & 0x08) | ((ri
.r_length
<< 1) & 0x06) |
1458 ((ri
.r_pcrel
<< 0) & 0x01)) & 0x0F;
1461 #endif /* comment */
1464 tc_aout_fix_to_chars (where
, fixP
, segment_address_in_file
)
1467 relax_addressT segment_address_in_file
;
1470 * In: length of relocation (or of address) in chars: 1, 2 or 4.
1471 * Out: GNU LD relocation length code: 0, 1, or 2.
1474 static unsigned char nbytes_r_length
[] =
1478 know (fixP
->fx_addsy
!= NULL
);
1480 md_number_to_chars (where
,
1481 fixP
->fx_frag
->fr_address
+ fixP
->fx_where
- segment_address_in_file
,
1484 r_symbolnum
= (S_IS_DEFINED (fixP
->fx_addsy
)
1485 ? S_GET_TYPE (fixP
->fx_addsy
)
1486 : fixP
->fx_addsy
->sy_number
);
1488 where
[6] = (r_symbolnum
>> 16) & 0x0ff;
1489 where
[5] = (r_symbolnum
>> 8) & 0x0ff;
1490 where
[4] = r_symbolnum
& 0x0ff;
1491 where
[7] = ((((!S_IS_DEFINED (fixP
->fx_addsy
)) << 3) & 0x08)
1492 | ((nbytes_r_length
[fixP
->fx_size
] << 1) & 0x06)
1493 | (((fixP
->fx_pcrel
<< 0) & 0x01) & 0x0f));
1496 } /* tc_aout_fix_to_chars() */
1499 * BUGS, GRIPES, APOLOGIA, etc.
1501 * The opcode table 'votstrs' needs to be sorted on opcode frequency.
1502 * That is, AFTER we hash it with hash_...(), we want most-used opcodes
1503 * to come out of the hash table faster.
1505 * I am sorry to inflict
1506 * yet another VAX assembler on the world, but RMS says we must
1507 * do everything from scratch, to prevent pin-heads restricting
1512 * This is a vaguely modular set of routines in C to parse VAX
1513 * assembly code using DEC mnemonics. It is NOT un*x specific.
1515 * The idea here is that the assembler has taken care of all:
1522 * condensing any whitespace down to exactly one space
1523 * and all we have to do is parse 1 line into a vax instruction
1524 * partially formed. We will accept a line, and deliver:
1525 * an error message (hopefully empty)
1526 * a skeleton VAX instruction (tree structure)
1527 * textual pointers to all the operand expressions
1528 * a warning message that notes a silly operand (hopefully empty)
1532 * E D I T H I S T O R Y
1534 * 17may86 Dean Elsner. Bug if line ends immediately after opcode.
1535 * 30apr86 Dean Elsner. New vip_op() uses arg block so change call.
1536 * 6jan86 Dean Elsner. Crock vip_begin() to call vip_op_defaults().
1537 * 2jan86 Dean Elsner. Invent synthetic opcodes.
1538 * Widen vax_opcodeT to 32 bits. Use a bit for VIT_OPCODE_SYNTHETIC,
1539 * which means this is not a real opcode, it is like a macro; it will
1540 * be relax()ed into 1 or more instructions.
1541 * Use another bit for VIT_OPCODE_SPECIAL if the op-code is not optimised
1542 * like a regular branch instruction. Option added to vip_begin():
1543 * exclude synthetic opcodes. Invent synthetic_votstrs[].
1544 * 31dec85 Dean Elsner. Invent vit_opcode_nbytes.
1545 * Also make vit_opcode into a char[]. We now have n-byte vax opcodes,
1546 * so caller's don't have to know the difference between a 1-byte & a
1547 * 2-byte op-code. Still need vax_opcodeT concept, so we know how
1548 * big an object must be to hold an op.code.
1549 * 30dec85 Dean Elsner. Widen typedef vax_opcodeT in "vax-inst.h"
1550 * because vax opcodes may be 16 bits. Our crufty C compiler was
1551 * happily initialising 8-bit vot_codes with 16-bit numbers!
1552 * (Wouldn't the 'phone company like to compress data so easily!)
1553 * 29dec85 Dean Elsner. New static table vax_operand_width_size[].
1554 * Invented so we know hw many bytes a "I^#42" needs in its immediate
1555 * operand. Revised struct vop in "vax-inst.h": explicitly include
1556 * byte length of each operand, and it's letter-code datum type.
1557 * 17nov85 Dean Elsner. Name Change.
1558 * Due to ar(1) truncating names, we learned the hard way that
1559 * "vax-inst-parse.c" -> "vax-inst-parse." dropping the "o" off
1560 * the archived object name. SO... we shortened the name of this
1561 * source file, and changed the makefile.
1564 static struct hash_control
*op_hash
= NULL
; /* handle of the OPCODE hash table */
1565 /* NULL means any use before vip_begin() */
1569 * In: 1 character, from "bdfghloqpw" being the data-type of an operand
1570 * of a vax instruction.
1572 * Out: the length of an operand of that type, in bytes.
1573 * Special branch operands types "-?!" have length 0.
1576 static const short int vax_operand_width_size
[256] =
1580 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
,
1581 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
,
1582 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
,
1583 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
,
1584 _
, _
, 1, _
, 8, _
, 4, 8, 16, _
, _
, _
, 4, _
, _
, 16, /* ..b.d.fgh...l..o */
1585 _
, 8, _
, _
, _
, _
, _
, 2, _
, _
, _
, _
, _
, _
, _
, _
, /* .q.....w........ */
1586 _
, _
, 1, _
, 8, _
, 4, 8, 16, _
, _
, _
, 4, _
, _
, 16, /* ..b.d.fgh...l..o */
1587 _
, 8, _
, _
, _
, _
, _
, 2, _
, _
, _
, _
, _
, _
, _
, _
, /* .q.....w........ */
1588 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
,
1589 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
,
1590 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
,
1591 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
,
1592 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
,
1593 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
,
1594 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
,
1595 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
};
1599 * This perversion encodes all the vax opcodes as a bunch of strings.
1600 * RMS says we should build our hash-table at run-time. Hmm.
1601 * Please would someone arrange these in decreasing frequency of opcode?
1602 * Because of the way hash_...() works, the most frequently used opcode
1603 * should be textually first and so on.
1605 * Input for this table was 'vax.opcodes', awk(1)ed by 'vax.opcodes.c.awk' .
1606 * So change 'vax.opcodes', then re-generate this table.
1609 #include "opcode/vax.h"
1612 * This is a table of optional op-codes. All of them represent
1613 * 'synthetic' instructions that seem popular.
1615 * Here we make some pseudo op-codes. Every code has a bit set to say
1616 * it is synthetic. This lets you catch them if you want to
1617 * ban these opcodes. They are mnemonics for "elastic" instructions
1618 * that are supposed to assemble into the fewest bytes needed to do a
1619 * branch, or to do a conditional branch, or whatever.
1621 * The opcode is in the usual place [low-order n*8 bits]. This means
1622 * that if you mask off the bucky bits, the usual rules apply about
1623 * how long the opcode is.
1625 * All VAX branch displacements come at the end of the instruction.
1626 * For simple branches (1-byte opcode + 1-byte displacement) the last
1627 * operand is coded 'b?' where the "data type" '?' is a clue that we
1628 * may reverse the sense of the branch (complement lowest order bit)
1629 * and branch around a jump. This is by far the most common case.
1630 * That is why the VIT_OPCODE_SYNTHETIC bit is set: it says this is
1631 * a 0-byte op-code followed by 2 or more bytes of operand address.
1633 * If the op-code has VIT_OPCODE_SPECIAL set, then we have a more unusual
1636 * For JBSB & JBR the treatment is the similar, except (1) we have a 'bw'
1637 * option before (2) we can directly JSB/JMP because there is no condition.
1638 * These operands have 'b-' as their access/data type.
1640 * That leaves a bunch of random opcodes: JACBx, JxOBxxx. In these
1641 * cases, we do the same idea. JACBxxx are all marked with a 'b!'
1642 * JAOBxxx & JSOBxxx are marked with a 'b:'.
1645 #if (VIT_OPCODE_SYNTHETIC != 0x80000000)
1646 You have just broken the encoding below
, which assumes the sign bit
1647 means
'I am an imaginary instruction'.
1650 #if (VIT_OPCODE_SPECIAL != 0x40000000)
1651 You have just broken the encoding below
, which assumes the
0x40 M bit means
1652 'I am not to be "optimised" the way normal branches are'.
1655 static const struct vot
1656 synthetic_votstrs
[] =
1658 {"jbsb", {"b-", 0xC0000010}}, /* BSD 4.2 */
1659 /* jsb used already */
1660 {"jbr", {"b-", 0xC0000011}}, /* BSD 4.2 */
1661 {"jr", {"b-", 0xC0000011}}, /* consistent */
1662 {"jneq", {"b?", 0x80000012}},
1663 {"jnequ", {"b?", 0x80000012}},
1664 {"jeql", {"b?", 0x80000013}},
1665 {"jeqlu", {"b?", 0x80000013}},
1666 {"jgtr", {"b?", 0x80000014}},
1667 {"jleq", {"b?", 0x80000015}},
1668 /* un-used opcodes here */
1669 {"jgeq", {"b?", 0x80000018}},
1670 {"jlss", {"b?", 0x80000019}},
1671 {"jgtru", {"b?", 0x8000001a}},
1672 {"jlequ", {"b?", 0x8000001b}},
1673 {"jvc", {"b?", 0x8000001c}},
1674 {"jvs", {"b?", 0x8000001d}},
1675 {"jgequ", {"b?", 0x8000001e}},
1676 {"jcc", {"b?", 0x8000001e}},
1677 {"jlssu", {"b?", 0x8000001f}},
1678 {"jcs", {"b?", 0x8000001f}},
1680 {"jacbw", {"rwrwmwb!", 0xC000003d}},
1681 {"jacbf", {"rfrfmfb!", 0xC000004f}},
1682 {"jacbd", {"rdrdmdb!", 0xC000006f}},
1683 {"jacbb", {"rbrbmbb!", 0xC000009d}},
1684 {"jacbl", {"rlrlmlb!", 0xC00000f1}},
1685 {"jacbg", {"rgrgmgb!", 0xC0004ffd}},
1686 {"jacbh", {"rhrhmhb!", 0xC0006ffd}},
1688 {"jbs", {"rlvbb?", 0x800000e0}},
1689 {"jbc", {"rlvbb?", 0x800000e1}},
1690 {"jbss", {"rlvbb?", 0x800000e2}},
1691 {"jbcs", {"rlvbb?", 0x800000e3}},
1692 {"jbsc", {"rlvbb?", 0x800000e4}},
1693 {"jbcc", {"rlvbb?", 0x800000e5}},
1694 {"jbssi", {"rlvbb?", 0x800000e6}},
1695 {"jbcci", {"rlvbb?", 0x800000e7}},
1696 {"jlbs", {"rlb?", 0x800000e8}}, /* JF changed from rlvbb? */
1697 {"jlbc", {"rlb?", 0x800000e9}}, /* JF changed from rlvbb? */
1699 {"jaoblss", {"rlmlb:", 0xC00000f2}},
1700 {"jaobleq", {"rlmlb:", 0xC00000f3}},
1701 {"jsobgeq", {"mlb:", 0xC00000f4}}, /* JF was rlmlb: */
1702 {"jsobgtr", {"mlb:", 0xC00000f5}}, /* JF was rlmlb: */
1704 /* CASEx has no branch addresses in our conception of it. */
1705 /* You should use ".word ..." statements after the "case ...". */
1707 {"", ""} /* empty is end sentinel */
1709 }; /* synthetic_votstrs */
1712 * v i p _ b e g i n ( )
1714 * Call me once before you decode any lines.
1715 * I decode votstrs into a hash table at op_hash (which I create).
1716 * I return an error text: hopefully "".
1717 * If you want, I will include the 'synthetic' jXXX instructions in the
1718 * instruction table.
1719 * You must nominate metacharacters for eg DEC's "#", "@", "^".
1723 vip_begin (synthetic_too
, immediate
, indirect
, displen
)
1724 int synthetic_too
; /* 1 means include jXXX op-codes. */
1725 char *immediate
, *indirect
, *displen
;
1727 const struct vot
*vP
; /* scan votstrs */
1728 char *retval
; /* error text */
1730 if ((op_hash
= hash_new ()))
1732 retval
= ""; /* OK so far */
1733 for (vP
= votstrs
; *vP
->vot_name
&& !*retval
; vP
++)
1735 retval
= hash_insert (op_hash
, vP
->vot_name
, &vP
->vot_detail
);
1739 for (vP
= synthetic_votstrs
; *vP
->vot_name
&& !*retval
; vP
++)
1741 retval
= hash_insert (op_hash
, vP
->vot_name
, &vP
->vot_detail
);
1747 retval
= "virtual memory exceeded";
1750 vip_op_defaults (immediate
, indirect
, displen
);
1760 * Call me once after you have decoded all lines.
1761 * I do any cleaning-up needed.
1763 * We don't have to do any cleanup ourselves: all of our operand
1764 * symbol table is static, and free()ing it is naughty.
1774 * This converts a string into a vax instruction.
1775 * The string must be a bare single instruction in dec-vax (with BSD4 frobs)
1777 * It provides some error messages: at most one fatal error message (which
1778 * stops the scan) and at most one warning message for each operand.
1779 * The vax instruction is returned in exploded form, since we have no
1780 * knowledge of how you parse (or evaluate) your expressions.
1781 * We do however strip off and decode addressing modes and operation
1784 * The exploded instruction is returned to a struct vit of your choice.
1785 * #include "vax-inst.h" to know what a struct vit is.
1787 * This function's value is a string. If it is not "" then an internal
1788 * logic error was found: read this code to assign meaning to the string.
1789 * No argument string should generate such an error string:
1790 * it means a bug in our code, not in the user's text.
1792 * You MUST have called vip_begin() once and vip_end() never before using
1796 char * /* "" or bug string */
1797 vip (vitP
, instring
)
1798 struct vit
*vitP
; /* We build an exploded instruction here. */
1799 char *instring
; /* Text of a vax instruction: we modify. */
1801 register struct vot_wot
*vwP
; /* How to bit-encode this opcode. */
1802 register char *p
; /* 1/skip whitespace.2/scan vot_how */
1803 register char *q
; /* */
1804 register char *bug
; /* "" or program logic error */
1805 register unsigned char count
; /* counts number of operands seen */
1806 register struct vop
*operandp
;/* scan operands in struct vit */
1807 register char *alloperr
; /* error over all operands */
1808 register char c
; /* Remember char, (we clobber it */
1809 /* with '\0' temporarily). */
1810 register vax_opcodeT oc
; /* Op-code of this instruction. */
1815 if (*instring
== ' ')
1816 ++instring
; /* Skip leading whitespace. */
1817 for (p
= instring
; *p
&& *p
!= ' '; p
++);; /* MUST end in end-of-string or exactly 1 space. */
1818 /* Scanned up to end of operation-code. */
1819 /* Operation-code is ended with whitespace. */
1820 if (p
- instring
== 0)
1822 vitP
->vit_error
= "No operator";
1824 memset (vitP
->vit_opcode
, '\0', sizeof (vitP
->vit_opcode
));
1831 * Here with instring pointing to what better be an op-name, and p
1832 * pointing to character just past that.
1833 * We trust instring points to an op-name, with no whitespace.
1835 vwP
= (struct vot_wot
*) hash_find (op_hash
, instring
);
1836 *p
= c
; /* Restore char after op-code. */
1839 vitP
->vit_error
= "Unknown operator";
1841 memset (vitP
->vit_opcode
, '\0', sizeof (vitP
->vit_opcode
));
1846 * We found a match! So lets pick up as many operands as the
1847 * instruction wants, and even gripe if there are too many.
1848 * We expect comma to seperate each operand.
1849 * We let instring track the text, while p tracks a part of the
1853 * The lines below know about 2-byte opcodes starting FD,FE or FF.
1854 * They also understand synthetic opcodes. Note:
1855 * we return 32 bits of opcode, including bucky bits, BUT
1856 * an opcode length is either 8 or 16 bits for vit_opcode_nbytes.
1858 oc
= vwP
->vot_code
; /* The op-code. */
1859 vitP
->vit_opcode_nbytes
= (oc
& 0xFF) >= 0xFD ? 2 : 1;
1860 md_number_to_chars (vitP
->vit_opcode
, oc
, 4);
1861 count
= 0; /* no operands seen yet */
1862 instring
= p
; /* point just past operation code */
1864 for (p
= vwP
->vot_how
, operandp
= vitP
->vit_operand
;
1865 !*alloperr
&& !*bug
&& *p
;
1870 * Here to parse one operand. Leave instring pointing just
1871 * past any one ',' that marks the end of this operand.
1874 bug
= "p"; /* ODD(!!) number of bytes in vot_how?? */
1877 for (q
= instring
; (c
= *q
) && c
!= ','; q
++)
1880 * Q points to ',' or '\0' that ends argument. C is that
1884 operandp
->vop_width
= p
[1];
1885 operandp
->vop_nbytes
= vax_operand_width_size
[p
[1]];
1886 operandp
->vop_access
= p
[0];
1887 bug
= vip_op (instring
, operandp
);
1888 *q
= c
; /* Restore input text. */
1889 if (*(operandp
->vop_error
))
1890 alloperr
= "Bad operand";
1891 instring
= q
+ (c
? 1 : 0); /* next operand (if any) */
1892 count
++; /* won another argument, may have an operr */
1895 alloperr
= "Not enough operands";
1899 if (*instring
== ' ')
1900 instring
++; /* Skip whitespace. */
1902 alloperr
= "Too many operands";
1904 vitP
->vit_error
= alloperr
;
1907 vitP
->vit_operands
= count
;
1914 * Test program for above.
1917 struct vit myvit
; /* build an exploded vax instruction here */
1918 char answer
[100]; /* human types a line of vax assembler here */
1919 char *mybug
; /* "" or an internal logic diagnostic */
1920 int mycount
; /* number of operands */
1921 struct vop
*myvop
; /* scan operands from myvit */
1922 int mysynth
; /* 1 means want synthetic opcodes. */
1923 char my_immediate
[200];
1924 char my_indirect
[200];
1925 char my_displen
[200];
1934 printf ("0 means no synthetic instructions. ");
1935 printf ("Value for vip_begin? ");
1937 sscanf (answer
, "%d", &mysynth
);
1938 printf ("Synthetic opcodes %s be included.\n", mysynth
? "will" : "will not");
1939 printf ("enter immediate symbols eg enter # ");
1940 gets (my_immediate
);
1941 printf ("enter indirect symbols eg enter @ ");
1943 printf ("enter displen symbols eg enter ^ ");
1945 if (*(p
= vip_begin (mysynth
, my_immediate
, my_indirect
, my_displen
)))
1947 error ("vip_begin=%s", p
);
1949 printf ("An empty input line will quit you from the vax instruction parser\n");
1952 printf ("vax instruction: ");
1957 break; /* out of for each input text loop */
1959 mybug
= vip (&myvit
, answer
);
1962 printf ("BUG:\"%s\"\n", mybug
);
1964 if (*myvit
.vit_error
)
1966 printf ("ERR:\"%s\"\n", myvit
.vit_error
);
1969 for (mycount
= myvit
.vit_opcode_nbytes
, p
= myvit
.vit_opcode
;
1974 printf ("%02x ", *p
& 0xFF);
1976 printf (" operand count=%d.\n", mycount
= myvit
.vit_operands
);
1977 for (myvop
= myvit
.vit_operand
; mycount
; mycount
--, myvop
++)
1979 printf ("mode=%xx reg=%xx ndx=%xx len='%c'=%c%c%d. expr=\"",
1980 myvop
->vop_mode
, myvop
->vop_reg
, myvop
->vop_ndx
,
1981 myvop
->vop_short
, myvop
->vop_access
, myvop
->vop_width
,
1983 for (p
= myvop
->vop_expr_begin
; p
<= myvop
->vop_expr_end
; p
++)
1988 if (*myvop
->vop_error
)
1990 printf (" err:\"%s\"\n", myvop
->vop_error
);
1992 if (*myvop
->vop_warn
)
1994 printf (" wrn:\"%s\"\n", myvop
->vop_warn
);
2002 #endif /* #ifdef test */
2004 /* end of vax_ins_parse.c */
2006 /* JF this used to be a separate file also */
2007 /* vax_reg_parse.c - convert a VAX register name to a number */
2009 /* Copyright (C) 1987 Free Software Foundation, Inc. A part of GNU. */
2012 * v a x _ r e g _ p a r s e ( )
2014 * Take 3 char.s, the last of which may be `\0` (non-existent)
2015 * and return the VAX register number that they represent.
2017 * Return -1 if they don't form a register name. Good names return
2018 * a number from 0:15 inclusive.
2020 * Case is not important in a name.
2022 * Register names understood are:
2049 int /* return -1 or 0:15 */
2050 vax_reg_parse (c1
, c2
, c3
) /* 3 chars of register name */
2051 char c1
, c2
, c3
; /* c3 == 0 if 2-character reg name */
2053 register int retval
; /* return -1:15 */
2061 if (isdigit (c2
) && c1
== 'r')
2066 retval
= retval
* 10 + c3
- '0';
2067 retval
= (retval
> 15) ? -1 : retval
;
2068 /* clamp the register value to 1 hex digit */
2071 retval
= -1; /* c3 must be '\0' or a digit */
2073 else if (c3
) /* There are no three letter regs */
2092 else if (c1
== 'p' && c2
== 'c')
2102 * Parse a vax operand in DEC assembler notation.
2103 * For speed, expect a string of whitespace to be reduced to a single ' '.
2104 * This is the case for GNU AS, and is easy for other DEC-compatible
2107 * Knowledge about DEC VAX assembler operand notation lives here.
2108 * This doesn't even know what a register name is, except it believes
2109 * all register names are 2 or 3 characters, and lets vax_reg_parse() say
2110 * what number each name represents.
2111 * It does, however, know that PC, SP etc are special registers so it can
2112 * detect addressing modes that are silly for those registers.
2114 * Where possible, it delivers 1 fatal or 1 warning message if the operand
2115 * is suspect. Exactly what we test for is still evolving.
2123 * There were a number of 'mismatched argument type' bugs to vip_op.
2124 * The most general solution is to typedef each (of many) arguments.
2125 * We used instead a typedef'd argument block. This is less modular
2126 * than using seperate return pointers for each result, but runs faster
2127 * on most engines, and seems to keep programmers happy. It will have
2128 * to be done properly if we ever want to use vip_op as a general-purpose
2129 * module (it was designed to be).
2133 * Doesn't support DEC "G^" format operands. These always take 5 bytes
2134 * to express, and code as modes 8F or 9F. Reason: "G^" deprives you of
2135 * optimising to (say) a "B^" if you are lucky in the way you link.
2136 * When someone builds a linker smart enough to convert "G^" to "B^", "W^"
2137 * whenever possible, then we should implement it.
2138 * If there is some other use for "G^", feel free to code it in!
2143 * If I nested if()s more, I could avoid testing (*err) which would save
2144 * time, space and page faults. I didn't nest all those if()s for clarity
2145 * and because I think the mode testing can be re-arranged 1st to test the
2146 * commoner constructs 1st. Does anybody have statistics on this?
2152 * In future, we should be able to 'compose' error messages in a scratch area
2153 * and give the user MUCH more informative error messages. Although this takes
2154 * a little more code at run-time, it will make this module much more self-
2155 * documenting. As an example of what sucks now: most error messages have
2156 * hardwired into them the DEC VAX metacharacters "#^@" which are nothing like
2157 * the Un*x characters "$`*", that most users will expect from this AS.
2161 * The input is a string, ending with '\0'.
2163 * We also require a 'hint' of what kind of operand is expected: so
2164 * we can remind caller not to write into literals for instance.
2166 * The output is a skeletal instruction.
2168 * The algorithm has two parts.
2169 * 1. extract the syntactic features (parse off all the @^#-()+[] mode crud);
2170 * 2. express the @^#-()+[] as some parameters suited to further analysis.
2172 * 2nd step is where we detect the googles of possible invalid combinations
2173 * a human (or compiler) might write. Note that if we do a half-way
2174 * decent assembler, we don't know how long to make (eg) displacement
2175 * fields when we first meet them (because they may not have defined values).
2176 * So we must wait until we know how many bits are needed for each address,
2177 * then we can know both length and opcodes of instructions.
2178 * For reason(s) above, we will pass to our caller a 'broken' instruction
2179 * of these major components, from which our caller can generate instructions:
2180 * - displacement length I^ S^ L^ B^ W^ unspecified
2182 * - register R0-R15 or absent
2183 * - index register R0-R15 or absent
2184 * - expression text what we don't parse
2185 * - error text(s) why we couldn't understand the operand
2189 * To decode output of this, test errtxt. If errtxt[0] == '\0', then
2190 * we had no errors that prevented parsing. Also, if we ever report
2191 * an internal bug, errtxt[0] is set non-zero. So one test tells you
2192 * if the other outputs are to be taken seriously.
2196 /* vax registers we need to know */
2197 /* JF #define SP (14) */
2198 /* JF for one big happy file #define PC (15) */
2201 * Because this module is useful for both VMS and UN*X style assemblers
2202 * and because of the variety of UN*X assemblers we must recognise
2203 * the different conventions for assembler operand notation. For example
2204 * VMS says "#42" for immediate mode, while most UN*X say "$42".
2205 * We permit arbitrary sets of (single) characters to represent the
2206 * 3 concepts that DEC writes '#', '@', '^'.
2209 /* character tests */
2210 #define VIP_IMMEDIATE 01 /* Character is like DEC # */
2211 #define VIP_INDIRECT 02 /* Char is like DEC @ */
2212 #define VIP_DISPLEN 04 /* Char is like DEC ^ */
2214 #define IMMEDIATEP(c) (vip_metacharacters [(c)&0xff]&VIP_IMMEDIATE)
2215 #define INDIRECTP(c) (vip_metacharacters [(c)&0xff]&VIP_INDIRECT)
2216 #define DISPLENP(c) (vip_metacharacters [(c)&0xff]&VIP_DISPLEN)
2218 /* We assume 8 bits per byte. Use vip_op_defaults() to set these up BEFORE we
2222 #if defined(CONST_TABLE)
2224 #define I VIP_IMMEDIATE,
2225 #define S VIP_INDIRECT,
2226 #define D VIP_DISPLEN,
2228 vip_metacharacters
[256] =
2230 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
/* ^@ ^A ^B ^C ^D ^E ^F ^G ^H ^I ^J ^K ^L ^M ^N ^O*/
2231 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
/* ^P ^Q ^R ^S ^T ^U ^V ^W ^X ^Y ^Z ^[ ^\ ^] ^^ ^_ */
2232 _ _ _ _ I _ _ _ _ _ S _ _ _ _ _
/* sp ! " # $ % & ' ( ) * + , - . / */
2233 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
/*0 1 2 3 4 5 6 7 8 9 : ; < = > ?*/
2234 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
/*@ A B C D E F G H I J K L M N O*/
2235 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
/*P Q R S T U V W X Y Z [ \ ] ^ _*/
2236 D _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
/*` a b c d e f g h i j k l m n o*/
2237 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
/*p q r s t u v w x y z { | } ~ ^?*/
2239 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
2240 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
2241 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
2242 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
2243 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
2244 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
2245 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
2246 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
2253 static char vip_metacharacters
[256];
2255 /* Macro is faster under GCC; The constant table is faster yet, but only works with ASCII */
2262 vip_op_1 (bit
, syms
)
2269 vip_metacharacters
[t
] |= bit
;
2273 #define vip_op_1(bit,syms) { \
2275 char *table=vip_metacharacters; \
2282 vip_op_defaults (immediate
, indirect
, displen
) /* can be called any time */
2283 char *immediate
; /* Strings of characters for each job. */
2285 char *displen
; /* more arguments may appear in future! */
2287 vip_op_1 (VIP_IMMEDIATE
, immediate
);
2288 vip_op_1 (VIP_INDIRECT
, indirect
);
2289 vip_op_1 (VIP_DISPLEN
, displen
);
2298 * Dec defines the semantics of address modes (and values)
2299 * by a two-letter code, explained here.
2301 * letter 1: access type
2303 * a address calculation - no data access, registers forbidden
2304 * b branch displacement
2305 * m read - let go of bus - write back "modify"
2307 * v bit field address: like 'a' but registers are OK
2309 * space no operator (eg ".long foo") [our convention]
2311 * letter 2: data type (i.e. width, alignment)
2314 * d double precision floating point (D format)
2315 * f single precision floating point (F format)
2316 * g G format floating
2317 * h H format floating
2322 * ? simple synthetic branch operand
2323 * - unconditional synthetic JSB/JSR operand
2324 * ! complex synthetic branch operand
2326 * The '-?!' letter 2's are not for external consumption. They are used
2327 * for various assemblers. Generally, all unknown widths are assumed 0.
2328 * We don't limit your choice of width character.
2330 * DEC operands are hard work to parse. For example, '@' as the first
2331 * character means indirect (deferred) mode but elswhere it is a shift
2333 * The long-winded explanation of how this is supposed to work is
2334 * cancelled. Read a DEC vax manual.
2335 * We try hard not to parse anything that MIGHT be part of the expression
2336 * buried in that syntax. For example if we see @...(Rn) we don't check
2337 * for '-' before the '(' because mode @-(Rn) does not exist.
2339 * After parsing we have:
2341 * at 1 if leading '@' (or Un*x '*')
2342 * len takes one value from " bilsw". eg B^ -> 'b'.
2343 * hash 1 if leading '#' (or Un*x '$')
2344 * expr_begin, expr_end the expression we did not parse
2345 * even though we don't interpret it, we make use
2346 * of its presence or absence.
2347 * sign -1: -(Rn) 0: absent +1: (Rn)+
2348 * paren 1 if () are around register
2349 * reg major register number 0:15 -1 means absent
2350 * ndx index register number 0:15 -1 means absent
2352 * Again, I dare not explain it: just trace ALL the code!
2355 char * /* (code here) bug message, "" = OK */
2356 /* our code bug, NOT bad assembly language */
2357 vip_op (optext
, vopP
)
2358 char *optext
; /* user's input string e.g.: */
2359 /* "@B^foo@bar(AP)[FP]:" */
2360 struct vop
*vopP
; /* In: vop_access, vop_width. */
2361 /* Out: _ndx, _reg, _mode, _short, _warn, */
2362 /* _error _expr_begin, _expr_end, _nbytes. */
2363 /* vop_nbytes : number of bytes in a datum. */
2365 char *p
; /* track operand text forward */
2366 char *q
; /* track operand text backward */
2367 int at
; /* 1 if leading '@' ('*') seen */
2368 char len
; /* one of " bilsw" */
2369 int hash
; /* 1 if leading '#' ('$') seen */
2370 int sign
= 0; /* -1, 0 or +1 */
2371 int paren
= 0; /* 1 if () surround register */
2372 int reg
= 0; /* register number, -1:absent */
2373 int ndx
= 0; /* index register number -1:absent */
2374 char *bug
; /* report any logic error in here, ""==OK */
2375 char *err
; /* report illegal operand, ""==OK */
2376 /* " " is a FAKE error: means we won */
2377 /* ANY err that begins with ' ' is a fake. */
2378 /* " " is converted to "" before return */
2379 char *wrn
; /* warn about weird modes pf address */
2380 char *oldq
= NULL
; /* preserve q in case we backup */
2381 int mode
= 0; /* build up 4-bit operand mode here */
2382 /* note: index mode is in ndx, this is */
2383 /* the major mode of operand address */
2385 * Notice how we move wrong-arg-type bugs INSIDE this module: if we
2386 * get the types wrong below, we lose at compile time rather than at
2389 char access
; /* vop_access. */
2390 char width
; /* vop_width. */
2392 int vax_reg_parse (); /* returns 0:15 or -1 if not a register */
2394 access
= vopP
->vop_access
;
2395 width
= vopP
->vop_width
;
2396 bug
= /* none of our code bugs (yet) */
2397 err
= /* no user text errors */
2398 wrn
= ""; /* no warnings even */
2402 if (*p
== ' ') /* Expect all whitespace reduced to ' '. */
2403 p
++; /* skip over whitespace */
2405 if (at
= INDIRECTP (*p
))
2406 { /* 1 if *p=='@'(or '*' for Un*x) */
2407 p
++; /* at is determined */
2408 if (*p
== ' ') /* Expect all whitespace reduced to ' '. */
2409 p
++; /* skip over whitespace */
2413 * This code is subtle. It tries to detect all legal (letter)'^'
2414 * but it doesn't waste time explicitly testing for premature '\0' because
2415 * this case is rejected as a mismatch against either (letter) or '^'.
2423 if (DISPLENP (p
[1]) && strchr ("bilws", len
= c
))
2424 p
+= 2; /* skip (letter) '^' */
2425 else /* no (letter) '^' seen */
2426 len
= ' '; /* len is determined */
2429 if (*p
== ' ') /* Expect all whitespace reduced to ' '. */
2430 p
++; /* skip over whitespace */
2432 if (hash
= IMMEDIATEP (*p
)) /* 1 if *p=='#' ('$' for Un*x) */
2433 p
++; /* hash is determined */
2436 * p points to what may be the beginning of an expression.
2437 * We have peeled off the front all that is peelable.
2438 * We know at, len, hash.
2440 * Lets point q at the end of the text and parse that (backwards).
2443 for (q
= p
; *q
; q
++)
2445 q
--; /* now q points at last char of text */
2447 if (*q
== ' ' && q
>= p
) /* Expect all whitespace reduced to ' '. */
2449 /* reverse over whitespace, but don't */
2450 /* run back over *p */
2453 * As a matter of policy here, we look for [Rn], although both Rn and S^#
2454 * forbid [Rn]. This is because it is easy, and because only a sick
2455 * cyborg would have [...] trailing an expression in a VAX-like assembler.
2456 * A meticulous parser would first check for Rn followed by '(' or '['
2457 * and not parse a trailing ']' if it found another. We just ban expressions
2462 while (q
>= p
&& *q
!= '[')
2464 /* either q<p or we got matching '[' */
2466 err
= "no '[' to match ']'";
2470 * Confusers like "[]" will eventually lose with a bad register
2471 * name error. So again we don't need to check for early '\0'.
2474 ndx
= vax_reg_parse (q
[1], q
[2], 0);
2475 else if (q
[4] == ']')
2476 ndx
= vax_reg_parse (q
[1], q
[2], q
[3]);
2480 * Since we saw a ']' we will demand a register name in the [].
2481 * If luser hasn't given us one: be rude.
2484 err
= "bad register in []";
2486 err
= "[PC] index banned";
2488 q
--; /* point q just before "[...]" */
2492 ndx
= -1; /* no ']', so no iNDeX register */
2495 * If err = "..." then we lost: run away.
2496 * Otherwise ndx == -1 if there was no "[...]".
2497 * Otherwise, ndx is index register number, and q points before "[...]".
2500 if (*q
== ' ' && q
>= p
) /* Expect all whitespace reduced to ' '. */
2502 /* reverse over whitespace, but don't */
2503 /* run back over *p */
2506 sign
= 0; /* no ()+ or -() seen yet */
2508 if (q
> p
+ 3 && *q
== '+' && q
[-1] == ')')
2510 sign
= 1; /* we saw a ")+" */
2511 q
--; /* q points to ')' */
2514 if (*q
== ')' && q
> p
+ 2)
2516 paren
= 1; /* assume we have "(...)" */
2517 while (q
>= p
&& *q
!= '(')
2519 /* either q<p or we got matching '(' */
2521 err
= "no '(' to match ')'";
2525 * Confusers like "()" will eventually lose with a bad register
2526 * name error. So again we don't need to check for early '\0'.
2529 reg
= vax_reg_parse (q
[1], q
[2], 0);
2530 else if (q
[4] == ')')
2531 reg
= vax_reg_parse (q
[1], q
[2], q
[3]);
2535 * Since we saw a ')' we will demand a register name in the ')'.
2536 * This is nasty: why can't our hypothetical assembler permit
2537 * parenthesised expressions? BECAUSE I AM LAZY! That is why.
2538 * Abuse luser if we didn't spy a register name.
2542 /* JF allow parenthasized expressions. I hope this works */
2546 /* err = "unknown register in ()"; */
2549 q
--; /* point just before '(' of "(...)" */
2551 * If err == "..." then we lost. Run away.
2552 * Otherwise if reg >= 0 then we saw (Rn).
2556 * If err == "..." then we lost.
2557 * Otherwise paren==1 and reg = register in "()".
2563 * If err == "..." then we lost.
2564 * Otherwise, q points just before "(Rn)", if any.
2565 * If there was a "(...)" then paren==1, and reg is the register.
2569 * We should only seek '-' of "-(...)" if:
2570 * we saw "(...)" paren == 1
2571 * we have no errors so far ! *err
2572 * we did not see '+' of "(...)+" sign < 1
2573 * We don't check len. We want a specific error message later if
2574 * user tries "x^...-(Rn)". This is a feature not a bug.
2578 if (paren
&& sign
< 1)/* !sign is adequate test */
2587 * We have back-tracked over most
2588 * of the crud at the end of an operand.
2589 * Unless err, we know: sign, paren. If paren, we know reg.
2590 * The last case is of an expression "Rn".
2591 * This is worth hunting for if !err, !paren.
2592 * We wouldn't be here if err.
2593 * We remember to save q, in case we didn't want "Rn" anyway.
2597 if (*q
== ' ' && q
>= p
) /* Expect all whitespace reduced to ' '. */
2599 /* reverse over whitespace, but don't */
2600 /* run back over *p */
2601 if (q
> p
&& q
< p
+ 3) /* room for Rn or Rnn exactly? */
2602 reg
= vax_reg_parse (p
[0], p
[1], q
< p
+ 2 ? 0 : p
[2]);
2604 reg
= -1; /* always comes here if no register at all */
2606 * Here with a definitive reg value.
2617 * have reg. -1:absent; else 0:15
2621 * We have: err, at, len, hash, ndx, sign, paren, reg.
2622 * Also, any remaining expression is from *p through *q inclusive.
2623 * Should there be no expression, q==p-1. So expression length = q-p+1.
2624 * This completes the first part: parsing the operand text.
2628 * We now want to boil the data down, checking consistency on the way.
2629 * We want: len, mode, reg, ndx, err, p, q, wrn, bug.
2630 * We will deliver a 4-bit reg, and a 4-bit mode.
2634 * Case of branch operand. Different. No L^B^W^I^S^ allowed for instance.
2648 * p:q whatever was input
2650 * err " " or error message, and other outputs trashed
2652 /* branch operands have restricted forms */
2653 if (!*err
&& access
== 'b')
2655 if (at
|| hash
|| sign
|| paren
|| ndx
>= 0 || reg
>= 0 || len
!= ' ')
2656 err
= "invalid branch operand";
2661 /* Since nobody seems to use it: comment this 'feature'(?) out for now. */
2664 * Case of stand-alone operand. e.g. ".long foo"
2678 * p:q whatever was input
2680 * err " " or error message, and other outputs trashed
2685 { /* addresses have restricted forms */
2687 err
= "address prohibits @";
2691 err
= "address prohibits #";
2697 err
= "address prohibits -()";
2699 err
= "address prohibits ()+";
2704 err
= "address prohibits ()";
2708 err
= "address prohibits []";
2712 err
= "address prohibits register";
2716 err
= "address prohibits displacement length specifier";
2719 err
= " "; /* succeed */
2730 #endif /*#Ifdef NEVER*/
2736 * len 's' definition
2738 * p:q demand not empty
2739 * sign 0 by paren==0
2740 * paren 0 by "()" scan logic because "S^" seen
2741 * reg -1 or nn by mistake
2750 if (!*err
&& len
== 's')
2752 if (!hash
|| paren
|| at
|| ndx
>= 0)
2753 err
= "invalid operand of S^#";
2759 * SHIT! we saw S^#Rnn ! put the Rnn back in
2760 * expression. KLUDGE! Use oldq so we don't
2761 * need to know exact length of reg name.
2767 * We have all the expression we will ever get.
2770 err
= "S^# needs expression";
2771 else if (access
== 'r')
2773 err
= " "; /* WIN! */
2777 err
= "S^# may only read-access";
2782 * Case of -(Rn), which is weird case.
2788 * sign -1 by definition
2789 * paren 1 by definition
2790 * reg present by definition
2796 * exp "" enforce empty expression
2797 * ndx optional warn if same as reg
2799 if (!*err
&& sign
< 0)
2801 if (len
!= ' ' || hash
|| at
|| p
<= q
)
2802 err
= "invalid operand of -()";
2805 err
= " "; /* win */
2808 wrn
= "-(PC) unpredictable";
2809 else if (reg
== ndx
)
2810 wrn
= "[]index same as -()register: unpredictable";
2815 * We convert "(Rn)" to "@Rn" for our convenience.
2816 * (I hope this is convenient: has someone got a better way to parse this?)
2817 * A side-effect of this is that "@Rn" is a valid operand.
2819 if (paren
&& !sign
&& !hash
&& !at
&& len
== ' ' && p
> q
)
2826 * Case of (Rn)+, which is slightly different.
2832 * sign +1 by definition
2833 * paren 1 by definition
2834 * reg present by definition
2840 * exp "" enforce empty expression
2841 * ndx optional warn if same as reg
2843 if (!*err
&& sign
> 0)
2845 if (len
!= ' ' || hash
|| p
<= q
)
2846 err
= "invalid operand of ()+";
2849 err
= " "; /* win */
2850 mode
= 8 + (at
? 1 : 0);
2852 wrn
= "(PC)+ unpredictable";
2853 else if (reg
== ndx
)
2854 wrn
= "[]index same as ()+register: unpredictable";
2859 * Case of #, without S^.
2863 * hash 1 by definition
2878 if (len
!= 'i' && len
!= ' ')
2879 err
= "# conflicts length";
2881 err
= "# bars register";
2887 * SHIT! we saw #Rnn! Put the Rnn back into the expression.
2888 * By using oldq, we don't need to know how long Rnn was.
2892 reg
= -1; /* no register any more */
2894 err
= " "; /* win */
2896 /* JF a bugfix, I think! */
2897 if (at
&& access
== 'a')
2898 vopP
->vop_nbytes
= 4;
2900 mode
= (at
? 9 : 8);
2902 if ((access
== 'm' || access
== 'w') && !at
)
2903 wrn
= "writing or modifying # is unpredictable";
2907 * If !*err, then sign == 0
2912 * Case of Rn. We seperate this one because it has a few special
2913 * errors the remaining modes lack.
2917 * hash 0 by program logic
2919 * sign 0 by program logic
2920 * paren 0 by definition
2921 * reg present by definition
2926 * len ' ' enforce no length
2927 * exp "" enforce empty expression
2928 * ndx optional warn if same as reg
2930 if (!*err
&& !paren
&& reg
>= 0)
2933 err
= "length not needed";
2936 err
= " "; /* win */
2940 err
= "can't []index a register, because it has no address";
2941 else if (access
== 'a')
2942 err
= "a register has no address";
2946 * Idea here is to detect from length of datum
2947 * and from register number if we will touch PC.
2949 * vop_nbytes is number of bytes in operand.
2950 * Compute highest byte affected, compare to PC0.
2952 if ((vopP
->vop_nbytes
+ reg
* 4) > 60)
2953 wrn
= "PC part of operand unpredictable";
2954 err
= " "; /* win */
2959 * If !*err, sign == 0
2961 * paren == 1 OR reg==-1
2965 * Rest of cases fit into one bunch.
2968 * len ' ' or 'b' or 'w' or 'l'
2969 * hash 0 by program logic
2970 * p:q expected (empty is not an error)
2971 * sign 0 by program logic
2976 * out: mode 10 + @ + len
2978 * len ' ' or 'b' or 'w' or 'l'
2980 * ndx optional warn if same as reg
2984 err
= " "; /* win (always) */
2985 mode
= 10 + (at
? 1 : 0);
2992 case ' ': /* assumed B^ until our caller changes it */
2999 * here with completely specified mode
3007 err
= ""; /* " " is no longer an error */
3009 vopP
->vop_mode
= mode
;
3010 vopP
->vop_reg
= reg
;
3011 vopP
->vop_short
= len
;
3012 vopP
->vop_expr_begin
= p
;
3013 vopP
->vop_expr_end
= q
;
3014 vopP
->vop_ndx
= ndx
;
3015 vopP
->vop_error
= err
;
3016 vopP
->vop_warn
= wrn
;
3023 Summary of vip_op outputs.
3027 {@}Rn 5+@ n ' ' optional
3028 branch operand 0 -1 ' ' -1
3030 -(Rn) 7 n ' ' optional
3031 {@}(Rn)+ 8+@ n ' ' optional
3032 {@}#foo, no S^ 8+@ PC " i" optional
3033 {@}{q^}{(Rn)} 10+@+q option " bwl" optional
3037 #ifdef TEST /* #Define to use this testbed. */
3040 * Follows a test program for this function.
3041 * We declare arrays non-local in case some of our tiny-minded machines
3042 * default to small stacks. Also, helps with some debuggers.
3047 char answer
[100]; /* human types into here */
3060 int my_operand_length
;
3061 char my_immediate
[200];
3062 char my_indirect
[200];
3063 char my_displen
[200];
3067 char *vip_op (); /* make cc happy */
3069 printf ("enter immediate symbols eg enter # ");
3070 gets (my_immediate
);
3071 printf ("enter indirect symbols eg enter @ ");
3073 printf ("enter displen symbols eg enter ^ ");
3075 vip_op_defaults (my_immediate
, my_indirect
, my_displen
);
3078 printf ("access,width (eg 'ab' or 'wh') [empty line to quit] : ");
3083 myaccess
= answer
[0];
3084 mywidth
= answer
[1];
3088 my_operand_length
= 1;
3091 my_operand_length
= 8;
3094 my_operand_length
= 4;
3097 my_operand_length
= 16;
3100 my_operand_length
= 32;
3103 my_operand_length
= 4;
3106 my_operand_length
= 16;
3109 my_operand_length
= 8;
3112 my_operand_length
= 2;
3117 my_operand_length
= 0;
3121 my_operand_length
= 2;
3122 printf ("I dn't understand access width %c\n", mywidth
);
3125 printf ("VAX assembler instruction operand: ");
3128 mybug
= vip_op (answer
, myaccess
, mywidth
, my_operand_length
,
3129 &mymode
, &myreg
, &mylen
, &myleft
, &myright
, &myndx
,
3133 printf ("error: \"%s\"\n", myerr
);
3135 printf (" bug: \"%s\"\n", mybug
);
3140 printf ("warning: \"%s\"\n", mywrn
);
3141 mumble ("mode", mymode
);
3142 mumble ("register", myreg
);
3143 mumble ("index", myndx
);
3144 printf ("width:'%c' ", mylen
);
3145 printf ("expression: \"");
3146 while (myleft
<= myright
)
3147 putchar (*myleft
++);
3153 mumble (text
, value
)
3157 printf ("%s:", text
);
3159 printf ("%xx", value
);
3165 #endif /* ifdef TEST */
3169 const int md_short_jump_size
= 3;
3170 const int md_long_jump_size
= 6;
3171 const int md_reloc_size
= 8; /* Size of relocation record */
3174 md_create_short_jump (ptr
, from_addr
, to_addr
, frag
, to_symbol
)
3176 long from_addr
, to_addr
;
3182 offset
= to_addr
- (from_addr
+ 1);
3184 md_number_to_chars (ptr
, offset
, 2);
3188 md_create_long_jump (ptr
, from_addr
, to_addr
, frag
, to_symbol
)
3190 long from_addr
, to_addr
;
3196 offset
= to_addr
- S_GET_VALUE (to_symbol
);
3199 md_number_to_chars (ptr
, offset
, 4);
3200 fix_new (frag
, ptr
- frag
->fr_literal
, 4, to_symbol
, (symbolS
*) 0, (long) 0, 0, NO_RELOC
);
3204 md_parse_option (argP
, cntP
, vecP
)
3209 char *temp_name
; /* name for -t or -d options */
3215 /* as_warn ("I can do better than -J!"); */
3219 as_warn ("SYMBOL TABLE not implemented");
3220 break; /* SYMBOL TABLE not implemented */
3223 as_warn ("TOKEN TRACE not implemented");
3224 break; /* TOKEN TRACE not implemented */
3230 { /* Rest of argument is filename. */
3240 temp_name
= *++(*vecP
);
3241 **vecP
= NULL
; /* Remember this is not a file-name. */
3245 as_warn ("I expected a filename after -%c.", opt
);
3246 temp_name
= "{absent}";
3250 as_warn ("Displacement length %s ignored!", temp_name
);
3252 as_warn ("I don't need or use temp. file \"%s\".", temp_name
);
3256 as_warn ("I don't use an interpass file! -V ignored");
3260 case '+': /* For g++ */
3263 case 'h': /* No hashing of mixed-case names */
3266 case 'H': /* Show new symbol after hash truncation */
3277 /* We have no need to default values of symbols. */
3281 md_undefined_symbol (name
)
3287 /* Parse an operand that is machine-specific.
3288 We just return without modifying the expression if we have nothing
3293 md_operand (expressionP
)
3294 expressionS
*expressionP
;
3298 /* Round up a section size to the appropriate boundary. */
3300 md_section_align (segment
, size
)
3304 return size
; /* Byte alignment is fine */
3307 /* Exactly what point is a PC-relative offset relative TO?
3308 On the vax, they're relative to the address of the offset, plus
3309 its size. (??? Is this right? FIXME-SOON) */
3311 md_pcrel_from (fixP
)
3314 return fixP
->fx_size
+ fixP
->fx_where
+ fixP
->fx_frag
->fr_address
;
3317 /* end of tc-vax.c */