1 /* tc-vax.c - vax-specific -
2 Copyright 1987, 1991, 1992, 1993, 1994, 1995, 1998, 2000, 2001
3 Free Software Foundation, Inc.
5 This file is part of GAS, the GNU Assembler.
7 GAS is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GAS is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GAS; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
25 #include "obstack.h" /* For FRAG_APPEND_1_CHAR macro in "frags.h" */
27 /* These chars start a comment anywhere in a source file (except inside
29 const char comment_chars[] = "#";
31 /* These chars only start a comment at the beginning of a line. */
32 /* Note that for the VAX the are the same as comment_chars above. */
33 const char line_comment_chars[] = "#";
35 const char line_separator_chars[] = ";";
37 /* Chars that can be used to separate mant from exp in floating point nums */
38 const char EXP_CHARS[] = "eE";
40 /* Chars that mean this number is a floating point constant */
42 /* or 0H1.234E-12 (see exp chars above) */
43 const char FLT_CHARS[] = "dDfFgGhH";
45 /* Also be aware that MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT may have to be
46 changed in read.c . Ideally it shouldn't have to know about it at all,
47 but nothing is ideal around here. */
49 /* Hold details of an operand expression */
50 static expressionS exp_of_operand[VIT_MAX_OPERANDS];
51 static segT seg_of_operand[VIT_MAX_OPERANDS];
53 /* A vax instruction after decoding. */
56 /* Hold details of big operands. */
57 LITTLENUM_TYPE big_operand_bits[VIT_MAX_OPERANDS][SIZE_OF_LARGE_NUMBER];
58 FLONUM_TYPE float_operand[VIT_MAX_OPERANDS];
59 /* Above is made to point into big_operand_bits by md_begin(). */
61 int flag_hash_long_names; /* -+ */
62 int flag_one; /* -1 */
63 int flag_show_after_trunc; /* -H */
64 int flag_no_hash_mixed_case; /* -h NUM */
67 * For VAX, relative addresses of "just the right length" are easy.
68 * The branch displacement is always the last operand, even in
69 * synthetic instructions.
70 * For VAX, we encode the relax_substateTs (in e.g. fr_substate) as:
72 * 4 3 2 1 0 bit number
73 * ---/ /--+-------+-------+-------+-------+-------+
74 * | what state ? | how long ? |
75 * ---/ /--+-------+-------+-------+-------+-------+
77 * The "how long" bits are 00=byte, 01=word, 10=long.
78 * This is a Un*x convention.
79 * Not all lengths are legit for a given value of (what state).
80 * The "how long" refers merely to the displacement length.
81 * The address usually has some constant bytes in it as well.
84 groups for VAX address relaxing.
87 length of byte, word, long
89 2a. J<cond> where <cond> is a simple flag test.
90 length of byte, word, long.
91 VAX opcodes are: (Hex)
104 Always, you complement 0th bit to reverse condition.
105 Always, 1-byte opcode, then 1-byte displacement.
107 2b. J<cond> where cond tests a memory bit.
108 length of byte, word, long.
109 Vax opcodes are: (Hex)
116 Always, you complement 0th bit to reverse condition.
117 Always, 1-byte opcde, longword-address, byte-address, 1-byte-displacement
119 2c. J<cond> where cond tests low-order memory bit
120 length of byte,word,long.
121 Vax opcodes are: (Hex)
124 Always, you complement 0th bit to reverse condition.
125 Always, 1-byte opcode, longword-address, 1-byte displacement.
128 length of byte,word,long.
129 Vax opcodes are: (Hex)
132 These are like (2) but there is no condition to reverse.
133 Always, 1 byte opcode, then displacement/absolute.
136 length of word, long.
137 Vax opcodes are: (Hex)
145 Always, we cannot reverse the sense of the branch; we have a word
147 The double-byte op-codes don't hurt: we never want to modify the
148 opcode, so we don't care how many bytes are between the opcode and
152 length of long, long, byte.
153 Vax opcodes are: (Hex)
158 Always, we cannot reverse the sense of the branch; we have a byte
161 The only time we need to modify the opcode is for class 2 instructions.
162 After relax() we may complement the lowest order bit of such instruction
163 to reverse sense of branch.
165 For class 2 instructions, we store context of "where is the opcode literal".
166 We can change an opcode's lowest order bit without breaking anything else.
168 We sometimes store context in the operand literal. This way we can figure out
169 after relax() what the original addressing mode was.
172 /* These displacements are relative to the start address of the
173 displacement. The first letter is Byte, Word. 2nd letter is
174 Forward, Backward. */
177 #define WF (2+ 32767)
178 #define WB (2+-32768)
179 /* Dont need LF, LB because they always reach. [They are coded as 0.] */
181 #define C(a,b) ENCODE_RELAX(a,b)
182 /* This macro has no side-effects. */
183 #define ENCODE_RELAX(what,length) (((what) << 2) + (length))
184 #define RELAX_STATE(s) ((s) >> 2)
185 #define RELAX_LENGTH(s) ((s) & 3)
187 const relax_typeS md_relax_table[] =
189 {1, 1, 0, 0}, /* error sentinel 0,0 */
190 {1, 1, 0, 0}, /* unused 0,1 */
191 {1, 1, 0, 0}, /* unused 0,2 */
192 {1, 1, 0, 0}, /* unused 0,3 */
194 {BF + 1, BB + 1, 2, C (1, 1)},/* B^"foo" 1,0 */
195 {WF + 1, WB + 1, 3, C (1, 2)},/* W^"foo" 1,1 */
196 {0, 0, 5, 0}, /* L^"foo" 1,2 */
197 {1, 1, 0, 0}, /* unused 1,3 */
199 {BF, BB, 1, C (2, 1)}, /* b<cond> B^"foo" 2,0 */
200 {WF + 2, WB + 2, 4, C (2, 2)},/* br.+? brw X 2,1 */
201 {0, 0, 7, 0}, /* br.+? jmp X 2,2 */
202 {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 */
209 {1, 1, 0, 0}, /* unused 4,0 */
210 {WF, WB, 2, C (4, 2)}, /* acb_ ^Wfoo 4,1 */
211 {0, 0, 10, 0}, /* acb_,br,jmp L^foo4,2 */
212 {1, 1, 0, 0}, /* unused 4,3 */
214 {BF, BB, 1, C (5, 1)}, /* Xob___,,foo 5,0 */
215 {WF + 4, WB + 4, 6, C (5, 2)},/* Xob.+2,brb.+3,brw5,1 */
216 {0, 0, 9, 0}, /* Xob.+2,brb.+6,jmp5,2 */
217 {1, 1, 0, 0}, /* unused 5,3 */
228 const pseudo_typeS md_pseudo_table[] =
230 {"dfloat", float_cons, 'd'},
231 {"ffloat", float_cons, 'f'},
232 {"gfloat", float_cons, 'g'},
233 {"hfloat", float_cons, 'h'},
237 #define STATE_PC_RELATIVE (1)
238 #define STATE_CONDITIONAL_BRANCH (2)
239 #define STATE_ALWAYS_BRANCH (3) /* includes BSB... */
240 #define STATE_COMPLEX_BRANCH (4)
241 #define STATE_COMPLEX_HOP (5)
243 #define STATE_BYTE (0)
244 #define STATE_WORD (1)
245 #define STATE_LONG (2)
246 #define STATE_UNDF (3) /* Symbol undefined in pass1 */
248 #define min(a, b) ((a) < (b) ? (a) : (b))
250 int flonum_gen2vax PARAMS ((char format_letter, FLONUM_TYPE * f,
251 LITTLENUM_TYPE * words));
252 static const char *vip_begin PARAMS ((int, const char *, const char *,
254 static void vip_op_defaults PARAMS ((const char *, const char *, const char *));
255 static void vip_op PARAMS ((char *, struct vop *));
256 static void vip PARAMS ((struct vit *, char *));
265 if ((errtxt = vip_begin (1, "$", "*", "`")) != 0)
267 as_fatal (_("VIP_BEGIN error:%s"), errtxt);
270 for (i = 0, fP = float_operand;
271 fP < float_operand + VIT_MAX_OPERANDS;
274 fP->low = &big_operand_bits[i][0];
275 fP->high = &big_operand_bits[i][SIZE_OF_LARGE_NUMBER - 1];
280 md_number_to_chars (con, value, nbytes)
285 number_to_chars_littleendian (con, value, nbytes);
288 /* Fix up some data or instructions after we find out the value of a symbol
289 that they reference. */
291 void /* Knows about order of bytes in address. */
292 md_apply_fix (fixP, value)
296 number_to_chars_littleendian (fixP->fx_where + fixP->fx_frag->fr_literal,
297 (valueT) value, fixP->fx_size);
301 md_chars_to_number (con, nbytes)
302 unsigned char con[]; /* Low order byte 1st. */
303 int nbytes; /* Number of bytes in the input. */
306 for (retval = 0, con += nbytes - 1; nbytes--; con--)
308 retval <<= BITS_PER_CHAR;
314 /* vax:md_assemble() emit frags for 1 instruction */
317 md_assemble (instruction_string)
318 char *instruction_string; /* A string: assemble 1 instruction. */
320 /* Non-zero if operand expression's segment is not known yet. */
325 /* An operand. Scans all operands. */
326 struct vop *operandP;
327 char *save_input_line_pointer;
328 /* What used to live after an expression. */
330 /* 1: instruction_string bad for all passes. */
332 /* Points to slot just after last operand. */
333 struct vop *end_operandP;
334 /* Points to expression values for this operand. */
338 /* These refer to an instruction operand expression. */
339 /* Target segment of the address. */
341 valueT this_add_number;
342 /* Positive (minuend) symbol. */
343 symbolS *this_add_symbol;
345 long opcode_as_number;
346 /* Least significant byte 1st. */
347 char *opcode_as_chars;
348 /* As an array of characters. */
349 /* Least significant byte 1st */
350 char *opcode_low_byteP;
351 /* length (bytes) meant by vop_short. */
353 /* 0, or 1 if '@' is in addressing mode. */
355 /* From vop_nbytes: vax_operand_width (in bytes) */
358 LITTLENUM_TYPE literal_float[8];
359 /* Big enough for any floating point literal. */
361 vip (&v, instruction_string);
364 * Now we try to find as many as_warn()s as we can. If we do any as_warn()s
365 * then goofed=1. Notice that we don't make any frags yet.
366 * Should goofed be 1, then this instruction will wedge in any pass,
367 * and we can safely flush it, without causing interpass symbol phase
368 * errors. That is, without changing label values in different passes.
370 if ((goofed = (*v.vit_error)) != 0)
372 as_warn (_("Ignoring statement due to \"%s\""), v.vit_error);
375 * We need to use expression() and friends, which require us to diddle
376 * input_line_pointer. So we save it and restore it later.
378 save_input_line_pointer = input_line_pointer;
379 for (operandP = v.vit_operand,
380 expP = exp_of_operand,
381 segP = seg_of_operand,
382 floatP = float_operand,
383 end_operandP = v.vit_operand + v.vit_operands;
385 operandP < end_operandP;
387 operandP++, expP++, segP++, floatP++)
388 { /* for each operand */
389 if (operandP->vop_error)
391 as_warn (_("Ignoring statement because \"%s\""), operandP->vop_error);
396 /* Statement has no syntax goofs: let's sniff the expression. */
397 int can_be_short = 0; /* 1 if a bignum can be reduced to a short literal. */
399 input_line_pointer = operandP->vop_expr_begin;
400 c_save = operandP->vop_expr_end[1];
401 operandP->vop_expr_end[1] = '\0';
402 /* If to_seg == SEG_PASS1, expression() will have set need_pass_2 = 1. */
403 *segP = expression (expP);
407 /* for BSD4.2 compatibility, missing expression is absolute 0 */
408 expP->X_op = O_constant;
409 expP->X_add_number = 0;
410 /* For SEG_ABSOLUTE, we shouldn't need to set X_op_symbol,
411 X_add_symbol to any particular value. But, we will program
412 defensively. Since this situation occurs rarely so it costs
413 us little to do, and stops Dean worrying about the origin of
414 random bits in expressionS's. */
415 expP->X_add_symbol = NULL;
416 expP->X_op_symbol = NULL;
425 * Major bug. We can't handle the case of a
426 * SEG_OP expression in a VIT_OPCODE_SYNTHETIC
427 * variable-length instruction.
428 * We don't have a frag type that is smart enough to
429 * relax a SEG_OP, and so we just force all
430 * SEG_OPs to behave like SEG_PASS1s.
431 * Clearly, if there is a demand we can invent a new or
432 * modified frag type and then coding up a frag for this
433 * case will be easy. SEG_OP was invented for the
434 * .words after a CASE opcode, and was never intended for
435 * instruction operands.
438 as_warn (_("Can't relocate expression"));
442 /* Preserve the bits. */
443 if (expP->X_add_number > 0)
445 bignum_copy (generic_bignum, expP->X_add_number,
446 floatP->low, SIZE_OF_LARGE_NUMBER);
450 know (expP->X_add_number < 0);
451 flonum_copy (&generic_floating_point_number,
453 if (strchr ("s i", operandP->vop_short))
455 /* Could possibly become S^# */
456 flonum_gen2vax (-expP->X_add_number, floatP, literal_float);
457 switch (-expP->X_add_number)
461 (literal_float[0] & 0xFC0F) == 0x4000
462 && literal_float[1] == 0;
467 (literal_float[0] & 0xFC0F) == 0x4000
468 && literal_float[1] == 0
469 && literal_float[2] == 0
470 && literal_float[3] == 0;
475 (literal_float[0] & 0xFF81) == 0x4000
476 && literal_float[1] == 0
477 && literal_float[2] == 0
478 && literal_float[3] == 0;
482 can_be_short = ((literal_float[0] & 0xFFF8) == 0x4000
483 && (literal_float[1] & 0xE000) == 0
484 && literal_float[2] == 0
485 && literal_float[3] == 0
486 && literal_float[4] == 0
487 && literal_float[5] == 0
488 && literal_float[6] == 0
489 && literal_float[7] == 0);
493 BAD_CASE (-expP->X_add_number);
495 } /* switch (float type) */
496 } /* if (could want to become S^#...) */
497 } /* bignum or flonum ? */
499 if (operandP->vop_short == 's'
500 || operandP->vop_short == 'i'
501 || (operandP->vop_short == ' '
502 && operandP->vop_reg == 0xF
503 && (operandP->vop_mode & 0xE) == 0x8))
506 if (operandP->vop_short == ' ')
508 /* We must chose S^ or I^. */
509 if (expP->X_add_number > 0)
511 /* Bignum: Short literal impossible. */
512 operandP->vop_short = 'i';
513 operandP->vop_mode = 8;
514 operandP->vop_reg = 0xF; /* VAX PC. */
518 /* Flonum: Try to do it. */
521 operandP->vop_short = 's';
522 operandP->vop_mode = 0;
523 operandP->vop_ndx = -1;
524 operandP->vop_reg = -1;
525 expP->X_op = O_constant;
529 operandP->vop_short = 'i';
530 operandP->vop_mode = 8;
531 operandP->vop_reg = 0xF; /* VAX PC */
533 } /* bignum or flonum ? */
534 } /* if #, but no S^ or I^ seen. */
535 /* No more ' ' case: either 's' or 'i'. */
536 if (operandP->vop_short == 's')
538 /* Wants to be a short literal. */
539 if (expP->X_add_number > 0)
541 as_warn (_("Bignum not permitted in short literal. Immediate mode assumed."));
542 operandP->vop_short = 'i';
543 operandP->vop_mode = 8;
544 operandP->vop_reg = 0xF; /* VAX PC. */
550 as_warn (_("Can't do flonum short literal: immediate mode used."));
551 operandP->vop_short = 'i';
552 operandP->vop_mode = 8;
553 operandP->vop_reg = 0xF; /* VAX PC. */
556 { /* Encode short literal now. */
559 switch (-expP->X_add_number)
563 temp = literal_float[0] >> 4;
567 temp = literal_float[0] >> 1;
571 temp = ((literal_float[0] << 3) & 070)
572 | ((literal_float[1] >> 13) & 07);
576 BAD_CASE (-expP->X_add_number);
580 floatP->low[0] = temp & 077;
582 } /* if can be short literal float */
583 } /* flonum or bignum ? */
586 { /* I^# seen: set it up if float. */
587 if (expP->X_add_number < 0)
589 memcpy (floatP->low, literal_float, sizeof (literal_float));
595 as_warn (_("A bignum/flonum may not be a displacement: 0x%lx used"),
596 (expP->X_add_number = 0x80000000L));
597 /* Chosen so luser gets the most offset bits to patch later. */
599 expP->X_add_number = floatP->low[0]
600 | ((LITTLENUM_MASK & (floatP->low[1])) << LITTLENUM_NUMBER_OF_BITS);
602 * For the O_big case we have:
603 * If vop_short == 's' then a short floating literal is in the
604 * lowest 6 bits of floatP -> low [0], which is
605 * big_operand_bits [---] [0].
606 * If vop_short == 'i' then the appropriate number of elements
607 * of big_operand_bits [---] [...] are set up with the correct
609 * Also, just in case width is byte word or long, we copy the lowest
610 * 32 bits of the number to X_add_number.
614 if (input_line_pointer != operandP->vop_expr_end + 1)
616 as_warn ("Junk at end of expression \"%s\"", input_line_pointer);
619 operandP->vop_expr_end[1] = c_save;
621 } /* for(each operand) */
623 input_line_pointer = save_input_line_pointer;
625 if (need_pass_2 || goofed)
631 /* Remember where it is, in case we want to modify the op-code later. */
632 opcode_low_byteP = frag_more (v.vit_opcode_nbytes);
633 memcpy (opcode_low_byteP, v.vit_opcode, v.vit_opcode_nbytes);
634 opcode_as_number = md_chars_to_number (opcode_as_chars = v.vit_opcode, 4);
635 for (operandP = v.vit_operand,
636 expP = exp_of_operand,
637 segP = seg_of_operand,
638 floatP = float_operand,
639 end_operandP = v.vit_operand + v.vit_operands;
641 operandP < end_operandP;
648 if (operandP->vop_ndx >= 0)
650 /* indexed addressing byte */
651 /* Legality of indexed mode already checked: it is OK */
652 FRAG_APPEND_1_CHAR (0x40 + operandP->vop_ndx);
653 } /* if(vop_ndx>=0) */
655 /* Here to make main operand frag(s). */
656 this_add_number = expP->X_add_number;
657 this_add_symbol = expP->X_add_symbol;
659 is_undefined = (to_seg == SEG_UNKNOWN);
660 at = operandP->vop_mode & 1;
661 length = (operandP->vop_short == 'b'
662 ? 1 : (operandP->vop_short == 'w'
663 ? 2 : (operandP->vop_short == 'l'
665 nbytes = operandP->vop_nbytes;
666 if (operandP->vop_access == 'b')
668 if (to_seg == now_seg || is_undefined)
670 /* If is_undefined, then it might BECOME now_seg. */
673 p = frag_more (nbytes);
674 fix_new (frag_now, p - frag_now->fr_literal, nbytes,
675 this_add_symbol, this_add_number, 1, NO_RELOC);
678 { /* to_seg==now_seg || to_seg == SEG_UNKNOWN */
680 length_code = is_undefined ? STATE_UNDF : STATE_BYTE;
681 if (opcode_as_number & VIT_OPCODE_SPECIAL)
683 if (operandP->vop_width == VAX_WIDTH_UNCONDITIONAL_JUMP)
686 frag_var (rs_machine_dependent, 5, 1,
687 ENCODE_RELAX (STATE_ALWAYS_BRANCH, length_code),
688 this_add_symbol, this_add_number,
693 if (operandP->vop_width == VAX_WIDTH_WORD_JUMP)
695 length_code = STATE_WORD;
696 /* JF: There is no state_byte for this one! */
697 frag_var (rs_machine_dependent, 10, 2,
698 ENCODE_RELAX (STATE_COMPLEX_BRANCH, length_code),
699 this_add_symbol, this_add_number,
704 know (operandP->vop_width == VAX_WIDTH_BYTE_JUMP);
705 frag_var (rs_machine_dependent, 9, 1,
706 ENCODE_RELAX (STATE_COMPLEX_HOP, length_code),
707 this_add_symbol, this_add_number,
714 know (operandP->vop_width == VAX_WIDTH_CONDITIONAL_JUMP);
715 frag_var (rs_machine_dependent, 7, 1,
716 ENCODE_RELAX (STATE_CONDITIONAL_BRANCH, length_code),
717 this_add_symbol, this_add_number,
724 /* to_seg != now_seg && to_seg != SEG_UNKNOWN */
726 * --- SEG FLOAT MAY APPEAR HERE ----
728 if (to_seg == SEG_ABSOLUTE)
732 know (!(opcode_as_number & VIT_OPCODE_SYNTHETIC));
733 p = frag_more (nbytes);
734 /* Conventional relocation. */
735 fix_new (frag_now, p - frag_now->fr_literal,
736 nbytes, &abs_symbol, this_add_number,
741 know (opcode_as_number & VIT_OPCODE_SYNTHETIC);
742 if (opcode_as_number & VIT_OPCODE_SPECIAL)
744 if (operandP->vop_width == VAX_WIDTH_UNCONDITIONAL_JUMP)
747 *opcode_low_byteP = opcode_as_chars[0] + VAX_WIDEN_LONG;
748 know (opcode_as_chars[1] == 0);
750 p[0] = VAX_ABSOLUTE_MODE; /* @#... */
751 md_number_to_chars (p + 1, this_add_number, 4);
752 /* Now (eg) JMP @#foo or JSB @#foo. */
756 if (operandP->vop_width == VAX_WIDTH_WORD_JUMP)
764 p[5] = VAX_ABSOLUTE_MODE; /* @#... */
765 md_number_to_chars (p + 6, this_add_number, 4);
775 know (operandP->vop_width == VAX_WIDTH_BYTE_JUMP);
781 p[4] = VAX_ABSOLUTE_MODE; /* @#... */
782 md_number_to_chars (p + 5, this_add_number, 4);
795 *opcode_low_byteP ^= 1;
796 /* To reverse the condition in a VAX branch,
797 complement the lowest order bit. */
801 p[2] = VAX_ABSOLUTE_MODE; /* @#... */
802 md_number_to_chars (p + 3, this_add_number, 4);
813 /* to_seg != now_seg && to_seg != SEG_UNKNOWN && to_Seg != SEG_ABSOLUTE */
816 /* Pc-relative. Conventional relocation. */
817 know (!(opcode_as_number & VIT_OPCODE_SYNTHETIC));
818 p = frag_more (nbytes);
819 fix_new (frag_now, p - frag_now->fr_literal,
820 nbytes, &abs_symbol, this_add_number,
825 know (opcode_as_number & VIT_OPCODE_SYNTHETIC);
826 if (opcode_as_number & VIT_OPCODE_SPECIAL)
828 if (operandP->vop_width == VAX_WIDTH_UNCONDITIONAL_JUMP)
831 know (opcode_as_chars[1] == 0);
832 *opcode_low_byteP = opcode_as_chars[0] + VAX_WIDEN_LONG;
834 p[0] = VAX_PC_RELATIVE_MODE;
836 p + 1 - frag_now->fr_literal, 4,
838 this_add_number, 1, NO_RELOC);
839 /* Now eg JMP foo or JSB foo. */
843 if (operandP->vop_width == VAX_WIDTH_WORD_JUMP)
851 p[5] = VAX_PC_RELATIVE_MODE;
853 p + 6 - frag_now->fr_literal, 4,
855 this_add_number, 1, NO_RELOC);
865 know (operandP->vop_width == VAX_WIDTH_BYTE_JUMP);
871 p[4] = VAX_PC_RELATIVE_MODE;
873 p + 5 - frag_now->fr_literal,
875 this_add_number, 1, NO_RELOC);
887 know (operandP->vop_width == VAX_WIDTH_CONDITIONAL_JUMP);
888 *opcode_low_byteP ^= 1; /* Reverse branch condition. */
892 p[2] = VAX_PC_RELATIVE_MODE;
893 fix_new (frag_now, p + 3 - frag_now->fr_literal,
895 this_add_number, 1, NO_RELOC);
903 know (operandP->vop_access != 'b'); /* So it is ordinary operand. */
904 know (operandP->vop_access != ' '); /* ' ' target-independent: elsewhere. */
905 know (operandP->vop_access == 'a'
906 || operandP->vop_access == 'm'
907 || operandP->vop_access == 'r'
908 || operandP->vop_access == 'v'
909 || operandP->vop_access == 'w');
910 if (operandP->vop_short == 's')
912 if (to_seg == SEG_ABSOLUTE)
914 if (this_add_number >= 64)
916 as_warn (_("Short literal overflow(%ld.), immediate mode assumed."),
917 (long) this_add_number);
918 operandP->vop_short = 'i';
919 operandP->vop_mode = 8;
920 operandP->vop_reg = 0xF;
925 as_warn (_("Forced short literal to immediate mode. now_seg=%s to_seg=%s"),
926 segment_name (now_seg), segment_name (to_seg));
927 operandP->vop_short = 'i';
928 operandP->vop_mode = 8;
929 operandP->vop_reg = 0xF;
932 if (operandP->vop_reg >= 0 && (operandP->vop_mode < 8
933 || (operandP->vop_reg != 0xF && operandP->vop_mode < 10)))
935 /* One byte operand. */
936 know (operandP->vop_mode > 3);
937 FRAG_APPEND_1_CHAR (operandP->vop_mode << 4 | operandP->vop_reg);
938 /* All 1-bytes except S^# happen here. */
942 /* {@}{q^}foo{(Rn)} or S^#foo */
943 if (operandP->vop_reg == -1 && operandP->vop_short != 's')
946 if (to_seg == now_seg)
950 know (operandP->vop_short == ' ');
951 p = frag_var (rs_machine_dependent, 10, 2,
952 ENCODE_RELAX (STATE_PC_RELATIVE, STATE_BYTE),
953 this_add_symbol, this_add_number,
955 know (operandP->vop_mode == 10 + at);
957 /* At is the only context we need to carry
958 to other side of relax() process. Must
959 be in the correct bit position of VAX
960 operand spec. byte. */
965 know (operandP->vop_short != ' ');
966 p = frag_more (length + 1);
967 p[0] = 0xF | ((at + "?\12\14?\16"[length]) << 4);
968 fix_new (frag_now, p + 1 - frag_now->fr_literal,
969 length, this_add_symbol,
970 this_add_number, 1, NO_RELOC);
974 { /* to_seg != now_seg */
975 if (this_add_symbol == NULL)
977 know (to_seg == SEG_ABSOLUTE);
978 /* Do @#foo: simpler relocation than foo-.(pc) anyway. */
980 p[0] = VAX_ABSOLUTE_MODE; /* @#... */
981 md_number_to_chars (p + 1, this_add_number, 4);
982 if (length && length != 4)
984 as_warn (_("Length specification ignored. Address mode 9F used"));
989 /* {@}{q^}other_seg */
990 know ((length == 0 && operandP->vop_short == ' ')
991 || (length > 0 && operandP->vop_short != ' '));
995 * We have a SEG_UNKNOWN symbol. It might
996 * turn out to be in the same segment as
997 * the instruction, permitting relaxation.
999 p = frag_var (rs_machine_dependent, 5, 2,
1000 ENCODE_RELAX (STATE_PC_RELATIVE, STATE_UNDF),
1001 this_add_symbol, this_add_number,
1009 know (operandP->vop_short == ' ');
1010 length = 4; /* Longest possible. */
1012 p = frag_more (length + 1);
1013 p[0] = 0xF | ((at + "?\12\14?\16"[length]) << 4);
1014 md_number_to_chars (p + 1, this_add_number, length);
1016 p + 1 - frag_now->fr_literal,
1017 length, this_add_symbol,
1018 this_add_number, 1, NO_RELOC);
1025 /* {@}{q^}foo(Rn) or S^# or I^# or # */
1026 if (operandP->vop_mode < 0xA)
1028 /* # or S^# or I^# */
1029 if (operandP->vop_access == 'v'
1030 || operandP->vop_access == 'a')
1032 if (operandP->vop_access == 'v')
1033 as_warn (_("Invalid operand: immediate value used as base address."));
1035 as_warn (_("Invalid operand: immediate value used as address."));
1036 /* gcc 2.6.3 is known to generate these in at least
1040 && to_seg == SEG_ABSOLUTE && (expP->X_op != O_big)
1041 && operandP->vop_mode == 8 /* No '@'. */
1042 && this_add_number < 64)
1044 operandP->vop_short = 's';
1046 if (operandP->vop_short == 's')
1048 FRAG_APPEND_1_CHAR (this_add_number);
1054 p = frag_more (nbytes + 1);
1055 know (operandP->vop_reg == 0xF);
1056 p[0] = (operandP->vop_mode << 4) | 0xF;
1057 if ((to_seg == SEG_ABSOLUTE) && (expP->X_op != O_big))
1060 * If nbytes > 4, then we are scrod. We
1061 * don't know if the high order bytes
1062 * are to be 0xFF or 0x00. BSD4.2 & RMS
1063 * say use 0x00. OK --- but this
1064 * assembler needs ANOTHER rewrite to
1065 * cope properly with this bug. */
1066 md_number_to_chars (p + 1, this_add_number, min (4, nbytes));
1069 memset (p + 5, '\0', nbytes - 4);
1074 if (expP->X_op == O_big)
1077 * Problem here is to get the bytes
1078 * in the right order. We stored
1079 * our constant as LITTLENUMs, not
1091 for (p++; nbytes; nbytes -= 2, p += 2, lP++)
1093 md_number_to_chars (p, *lP, 2);
1099 fix_new (frag_now, p + 1 - frag_now->fr_literal,
1100 nbytes, this_add_symbol,
1101 this_add_number, 0, NO_RELOC);
1107 { /* {@}{q^}foo(Rn) */
1108 know ((length == 0 && operandP->vop_short == ' ')
1109 || (length > 0 && operandP->vop_short != ' '));
1112 if (to_seg == SEG_ABSOLUTE)
1116 test = this_add_number;
1121 length = test & 0xffff8000 ? 4
1122 : test & 0xffffff80 ? 2
1130 p = frag_more (1 + length);
1131 know (operandP->vop_reg >= 0);
1132 p[0] = operandP->vop_reg
1133 | ((at | "?\12\14?\16"[length]) << 4);
1134 if (to_seg == SEG_ABSOLUTE)
1136 md_number_to_chars (p + 1, this_add_number, length);
1140 fix_new (frag_now, p + 1 - frag_now->fr_literal,
1141 length, this_add_symbol,
1142 this_add_number, 0, NO_RELOC);
1146 } /* if(single-byte-operand) */
1148 } /* for(operandP) */
1149 } /* vax_assemble() */
1151 /* md_estimate_size_before_relax(), called just before relax().
1152 Any symbol that is now undefined will not become defined.
1153 Return the correct fr_subtype in the frag and the growth beyond
1156 md_estimate_size_before_relax (fragP, segment)
1160 if (RELAX_LENGTH (fragP->fr_subtype) == STATE_UNDF)
1162 if (S_GET_SEGMENT (fragP->fr_symbol) != segment)
1164 /* Non-relaxable cases. */
1168 old_fr_fix = fragP->fr_fix;
1169 p = fragP->fr_literal + old_fr_fix;
1170 switch (RELAX_STATE (fragP->fr_subtype))
1172 case STATE_PC_RELATIVE:
1173 p[0] |= VAX_PC_RELATIVE_MODE; /* Preserve @ bit. */
1174 fragP->fr_fix += 1 + 4;
1175 fix_new (fragP, old_fr_fix + 1, 4, fragP->fr_symbol,
1176 fragP->fr_offset, 1, NO_RELOC);
1179 case STATE_CONDITIONAL_BRANCH:
1180 *fragP->fr_opcode ^= 1; /* Reverse sense of branch. */
1183 p[2] = VAX_PC_RELATIVE_MODE; /* ...(PC) */
1184 fragP->fr_fix += 1 + 1 + 1 + 4;
1185 fix_new (fragP, old_fr_fix + 3, 4, fragP->fr_symbol,
1186 fragP->fr_offset, 1, NO_RELOC);
1189 case STATE_COMPLEX_BRANCH:
1195 p[5] = VAX_PC_RELATIVE_MODE; /* ...(pc) */
1196 fragP->fr_fix += 2 + 2 + 1 + 1 + 4;
1197 fix_new (fragP, old_fr_fix + 6, 4, fragP->fr_symbol,
1198 fragP->fr_offset, 1, NO_RELOC);
1201 case STATE_COMPLEX_HOP:
1206 p[4] = VAX_PC_RELATIVE_MODE; /* ...(pc) */
1207 fragP->fr_fix += 1 + 2 + 1 + 1 + 4;
1208 fix_new (fragP, old_fr_fix + 5, 4, fragP->fr_symbol,
1209 fragP->fr_offset, 1, NO_RELOC);
1212 case STATE_ALWAYS_BRANCH:
1213 *fragP->fr_opcode += VAX_WIDEN_LONG;
1214 p[0] = VAX_PC_RELATIVE_MODE; /* ...(PC) */
1215 fragP->fr_fix += 1 + 4;
1216 fix_new (fragP, old_fr_fix + 1, 4, fragP->fr_symbol,
1217 fragP->fr_offset, 1, NO_RELOC);
1225 /* Return the growth in the fixed part of the frag. */
1226 return fragP->fr_fix - old_fr_fix;
1229 /* Relaxable cases. Set up the initial guess for the variable
1230 part of the frag. */
1231 switch (RELAX_STATE (fragP->fr_subtype))
1233 case STATE_PC_RELATIVE:
1234 fragP->fr_subtype = ENCODE_RELAX (STATE_PC_RELATIVE, STATE_BYTE);
1236 case STATE_CONDITIONAL_BRANCH:
1237 fragP->fr_subtype = ENCODE_RELAX (STATE_CONDITIONAL_BRANCH, STATE_BYTE);
1239 case STATE_COMPLEX_BRANCH:
1240 fragP->fr_subtype = ENCODE_RELAX (STATE_COMPLEX_BRANCH, STATE_WORD);
1242 case STATE_COMPLEX_HOP:
1243 fragP->fr_subtype = ENCODE_RELAX (STATE_COMPLEX_HOP, STATE_BYTE);
1245 case STATE_ALWAYS_BRANCH:
1246 fragP->fr_subtype = ENCODE_RELAX (STATE_ALWAYS_BRANCH, STATE_BYTE);
1251 if (fragP->fr_subtype >= sizeof (md_relax_table) / sizeof (md_relax_table[0]))
1254 /* Return the size of the variable part of the frag. */
1255 return md_relax_table[fragP->fr_subtype].rlx_length;
1259 * md_convert_frag();
1261 * Called after relax() is finished.
1262 * In: Address of frag.
1263 * fr_type == rs_machine_dependent.
1264 * fr_subtype is what the address relaxed to.
1266 * Out: Any fixSs and constants are set up.
1267 * Caller will turn frag into a ".space 0".
1270 md_convert_frag (headers, seg, fragP)
1271 object_headers *headers;
1275 char *addressP; /* -> _var to change. */
1276 char *opcodeP; /* -> opcode char(s) to change. */
1277 short int extension = 0; /* Size of relaxed address. */
1278 /* Added to fr_fix: incl. ALL var chars. */
1281 long address_of_var;
1282 /* Where, in file space, is _var of *fragP? */
1283 long target_address = 0;
1284 /* Where, in file space, does addr point? */
1286 know (fragP->fr_type == rs_machine_dependent);
1287 where = fragP->fr_fix;
1288 addressP = fragP->fr_literal + where;
1289 opcodeP = fragP->fr_opcode;
1290 symbolP = fragP->fr_symbol;
1292 target_address = S_GET_VALUE (symbolP) + fragP->fr_offset;
1293 address_of_var = fragP->fr_address + where;
1295 switch (fragP->fr_subtype)
1298 case ENCODE_RELAX (STATE_PC_RELATIVE, STATE_BYTE):
1299 know (*addressP == 0 || *addressP == 0x10); /* '@' bit. */
1300 addressP[0] |= 0xAF; /* Byte displacement. */
1301 addressP[1] = target_address - (address_of_var + 2);
1305 case ENCODE_RELAX (STATE_PC_RELATIVE, STATE_WORD):
1306 know (*addressP == 0 || *addressP == 0x10); /* '@' bit. */
1307 addressP[0] |= 0xCF; /* Word displacement. */
1308 md_number_to_chars (addressP + 1, target_address - (address_of_var + 3), 2);
1312 case ENCODE_RELAX (STATE_PC_RELATIVE, STATE_LONG):
1313 know (*addressP == 0 || *addressP == 0x10); /* '@' bit. */
1314 addressP[0] |= 0xEF; /* Long word displacement. */
1315 md_number_to_chars (addressP + 1, target_address - (address_of_var + 5), 4);
1319 case ENCODE_RELAX (STATE_CONDITIONAL_BRANCH, STATE_BYTE):
1320 addressP[0] = target_address - (address_of_var + 1);
1324 case ENCODE_RELAX (STATE_CONDITIONAL_BRANCH, STATE_WORD):
1325 opcodeP[0] ^= 1; /* Reverse sense of test. */
1327 addressP[1] = VAX_BRB + VAX_WIDEN_WORD;
1328 md_number_to_chars (addressP + 2, target_address - (address_of_var + 4), 2);
1332 case ENCODE_RELAX (STATE_CONDITIONAL_BRANCH, STATE_LONG):
1333 opcodeP[0] ^= 1; /* Reverse sense of test. */
1335 addressP[1] = VAX_JMP;
1336 addressP[2] = VAX_PC_RELATIVE_MODE;
1337 md_number_to_chars (addressP + 3, target_address - (address_of_var + 7), 4);
1341 case ENCODE_RELAX (STATE_ALWAYS_BRANCH, STATE_BYTE):
1342 addressP[0] = target_address - (address_of_var + 1);
1346 case ENCODE_RELAX (STATE_ALWAYS_BRANCH, STATE_WORD):
1347 opcodeP[0] += VAX_WIDEN_WORD; /* brb -> brw, bsbb -> bsbw */
1348 md_number_to_chars (addressP, target_address - (address_of_var + 2), 2);
1352 case ENCODE_RELAX (STATE_ALWAYS_BRANCH, STATE_LONG):
1353 opcodeP[0] += VAX_WIDEN_LONG; /* brb -> jmp, bsbb -> jsb */
1354 addressP[0] = VAX_PC_RELATIVE_MODE;
1355 md_number_to_chars (addressP + 1, target_address - (address_of_var + 5), 4);
1359 case ENCODE_RELAX (STATE_COMPLEX_BRANCH, STATE_WORD):
1360 md_number_to_chars (addressP, target_address - (address_of_var + 2), 2);
1364 case ENCODE_RELAX (STATE_COMPLEX_BRANCH, STATE_LONG):
1367 addressP[2] = VAX_BRB;
1369 addressP[4] = VAX_JMP;
1370 addressP[5] = VAX_PC_RELATIVE_MODE;
1371 md_number_to_chars (addressP + 6, target_address - (address_of_var + 10), 4);
1375 case ENCODE_RELAX (STATE_COMPLEX_HOP, STATE_BYTE):
1376 addressP[0] = target_address - (address_of_var + 1);
1380 case ENCODE_RELAX (STATE_COMPLEX_HOP, STATE_WORD):
1382 addressP[1] = VAX_BRB;
1384 addressP[3] = VAX_BRW;
1385 md_number_to_chars (addressP + 4, target_address - (address_of_var + 6), 2);
1389 case ENCODE_RELAX (STATE_COMPLEX_HOP, STATE_LONG):
1391 addressP[1] = VAX_BRB;
1393 addressP[3] = VAX_JMP;
1394 addressP[4] = VAX_PC_RELATIVE_MODE;
1395 md_number_to_chars (addressP + 5, target_address - (address_of_var + 9), 4);
1400 BAD_CASE (fragP->fr_subtype);
1403 fragP->fr_fix += extension;
1404 } /* md_convert_frag() */
1406 /* Translate internal format of relocation info into target format.
1408 On vax: first 4 bytes are normal unsigned long, next three bytes
1409 are symbolnum, least sig. byte first. Last byte is broken up with
1410 the upper nibble as nuthin, bit 3 as extern, bits 2 & 1 as length, and
1414 md_ri_to_chars (the_bytes, ri)
1416 struct reloc_info_generic ri;
1419 md_number_to_chars (the_bytes, ri.r_address, sizeof (ri.r_address));
1420 /* now the fun stuff */
1421 the_bytes[6] = (ri.r_symbolnum >> 16) & 0x0ff;
1422 the_bytes[5] = (ri.r_symbolnum >> 8) & 0x0ff;
1423 the_bytes[4] = ri.r_symbolnum & 0x0ff;
1424 the_bytes[7] = (((ri.r_extern << 3) & 0x08) | ((ri.r_length << 1) & 0x06) |
1425 ((ri.r_pcrel << 0) & 0x01)) & 0x0F;
1428 #endif /* comment */
1431 tc_aout_fix_to_chars (where, fixP, segment_address_in_file)
1434 relax_addressT segment_address_in_file;
1437 * In: length of relocation (or of address) in chars: 1, 2 or 4.
1438 * Out: GNU LD relocation length code: 0, 1, or 2.
1441 static const unsigned char nbytes_r_length[] = {42, 0, 1, 42, 2};
1444 know (fixP->fx_addsy != NULL);
1446 md_number_to_chars (where,
1447 fixP->fx_frag->fr_address + fixP->fx_where - segment_address_in_file,
1450 r_symbolnum = (S_IS_DEFINED (fixP->fx_addsy)
1451 ? S_GET_TYPE (fixP->fx_addsy)
1452 : fixP->fx_addsy->sy_number);
1454 where[6] = (r_symbolnum >> 16) & 0x0ff;
1455 where[5] = (r_symbolnum >> 8) & 0x0ff;
1456 where[4] = r_symbolnum & 0x0ff;
1457 where[7] = ((((!S_IS_DEFINED (fixP->fx_addsy)) << 3) & 0x08)
1458 | ((nbytes_r_length[fixP->fx_size] << 1) & 0x06)
1459 | (((fixP->fx_pcrel << 0) & 0x01) & 0x0f));
1463 * BUGS, GRIPES, APOLOGIA, etc.
1465 * The opcode table 'votstrs' needs to be sorted on opcode frequency.
1466 * That is, AFTER we hash it with hash_...(), we want most-used opcodes
1467 * to come out of the hash table faster.
1469 * I am sorry to inflict yet another VAX assembler on the world, but
1470 * RMS says we must do everything from scratch, to prevent pin-heads
1471 * restricting this software.
1475 * This is a vaguely modular set of routines in C to parse VAX
1476 * assembly code using DEC mnemonics. It is NOT un*x specific.
1478 * The idea here is that the assembler has taken care of all:
1485 * condensing any whitespace down to exactly one space
1486 * and all we have to do is parse 1 line into a vax instruction
1487 * partially formed. We will accept a line, and deliver:
1488 * an error message (hopefully empty)
1489 * a skeleton VAX instruction (tree structure)
1490 * textual pointers to all the operand expressions
1491 * a warning message that notes a silly operand (hopefully empty)
1495 * E D I T H I S T O R Y
1497 * 17may86 Dean Elsner. Bug if line ends immediately after opcode.
1498 * 30apr86 Dean Elsner. New vip_op() uses arg block so change call.
1499 * 6jan86 Dean Elsner. Crock vip_begin() to call vip_op_defaults().
1500 * 2jan86 Dean Elsner. Invent synthetic opcodes.
1501 * Widen vax_opcodeT to 32 bits. Use a bit for VIT_OPCODE_SYNTHETIC,
1502 * which means this is not a real opcode, it is like a macro; it will
1503 * be relax()ed into 1 or more instructions.
1504 * Use another bit for VIT_OPCODE_SPECIAL if the op-code is not optimised
1505 * like a regular branch instruction. Option added to vip_begin():
1506 * exclude synthetic opcodes. Invent synthetic_votstrs[].
1507 * 31dec85 Dean Elsner. Invent vit_opcode_nbytes.
1508 * Also make vit_opcode into a char[]. We now have n-byte vax opcodes,
1509 * so caller's don't have to know the difference between a 1-byte & a
1510 * 2-byte op-code. Still need vax_opcodeT concept, so we know how
1511 * big an object must be to hold an op.code.
1512 * 30dec85 Dean Elsner. Widen typedef vax_opcodeT in "vax-inst.h"
1513 * because vax opcodes may be 16 bits. Our crufty C compiler was
1514 * happily initialising 8-bit vot_codes with 16-bit numbers!
1515 * (Wouldn't the 'phone company like to compress data so easily!)
1516 * 29dec85 Dean Elsner. New static table vax_operand_width_size[].
1517 * Invented so we know hw many bytes a "I^#42" needs in its immediate
1518 * operand. Revised struct vop in "vax-inst.h": explicitly include
1519 * byte length of each operand, and it's letter-code datum type.
1520 * 17nov85 Dean Elsner. Name Change.
1521 * Due to ar(1) truncating names, we learned the hard way that
1522 * "vax-inst-parse.c" -> "vax-inst-parse." dropping the "o" off
1523 * the archived object name. SO... we shortened the name of this
1524 * source file, and changed the makefile.
1527 /* handle of the OPCODE hash table */
1528 static struct hash_control *op_hash;
1531 * In: 1 character, from "bdfghloqpw" being the data-type of an operand
1532 * of a vax instruction.
1534 * Out: the length of an operand of that type, in bytes.
1535 * Special branch operands types "-?!" have length 0.
1538 static const short int vax_operand_width_size[256] =
1540 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1541 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1542 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1543 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1544 0, 0, 1, 0, 8, 0, 4, 8, 16, 0, 0, 0, 4, 0, 0,16, /* ..b.d.fgh...l..o */
1545 0, 8, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, /* .q.....w........ */
1546 0, 0, 1, 0, 8, 0, 4, 8, 16, 0, 0, 0, 4, 0, 0,16, /* ..b.d.fgh...l..o */
1547 0, 8, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, /* .q.....w........ */
1548 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1549 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1550 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1551 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1552 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1553 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1554 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1555 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1559 * This perversion encodes all the vax opcodes as a bunch of strings.
1560 * RMS says we should build our hash-table at run-time. Hmm.
1561 * Please would someone arrange these in decreasing frequency of opcode?
1562 * Because of the way hash_...() works, the most frequently used opcode
1563 * should be textually first and so on.
1565 * Input for this table was 'vax.opcodes', awk(1)ed by 'vax.opcodes.c.awk' .
1566 * So change 'vax.opcodes', then re-generate this table.
1569 #include "opcode/vax.h"
1572 * This is a table of optional op-codes. All of them represent
1573 * 'synthetic' instructions that seem popular.
1575 * Here we make some pseudo op-codes. Every code has a bit set to say
1576 * it is synthetic. This lets you catch them if you want to
1577 * ban these opcodes. They are mnemonics for "elastic" instructions
1578 * that are supposed to assemble into the fewest bytes needed to do a
1579 * branch, or to do a conditional branch, or whatever.
1581 * The opcode is in the usual place [low-order n*8 bits]. This means
1582 * that if you mask off the bucky bits, the usual rules apply about
1583 * how long the opcode is.
1585 * All VAX branch displacements come at the end of the instruction.
1586 * For simple branches (1-byte opcode + 1-byte displacement) the last
1587 * operand is coded 'b?' where the "data type" '?' is a clue that we
1588 * may reverse the sense of the branch (complement lowest order bit)
1589 * and branch around a jump. This is by far the most common case.
1590 * That is why the VIT_OPCODE_SYNTHETIC bit is set: it says this is
1591 * a 0-byte op-code followed by 2 or more bytes of operand address.
1593 * If the op-code has VIT_OPCODE_SPECIAL set, then we have a more unusual
1596 * For JBSB & JBR the treatment is the similar, except (1) we have a 'bw'
1597 * option before (2) we can directly JSB/JMP because there is no condition.
1598 * These operands have 'b-' as their access/data type.
1600 * That leaves a bunch of random opcodes: JACBx, JxOBxxx. In these
1601 * cases, we do the same idea. JACBxxx are all marked with a 'b!'
1602 * JAOBxxx & JSOBxxx are marked with a 'b:'.
1605 #if (VIT_OPCODE_SYNTHETIC != 0x80000000)
1606 You have just broken the encoding below, which assumes the sign bit
1607 means 'I am an imaginary instruction'.
1610 #if (VIT_OPCODE_SPECIAL != 0x40000000)
1611 You have just broken the encoding below, which assumes the 0x40 M bit means
1612 'I am not to be "optimised" the way normal branches are'.
1615 static const struct vot
1616 synthetic_votstrs[] =
1618 {"jbsb", {"b-", 0xC0000010}}, /* BSD 4.2 */
1619 /* jsb used already */
1620 {"jbr", {"b-", 0xC0000011}}, /* BSD 4.2 */
1621 {"jr", {"b-", 0xC0000011}}, /* consistent */
1622 {"jneq", {"b?", 0x80000012}},
1623 {"jnequ", {"b?", 0x80000012}},
1624 {"jeql", {"b?", 0x80000013}},
1625 {"jeqlu", {"b?", 0x80000013}},
1626 {"jgtr", {"b?", 0x80000014}},
1627 {"jleq", {"b?", 0x80000015}},
1628 /* un-used opcodes here */
1629 {"jgeq", {"b?", 0x80000018}},
1630 {"jlss", {"b?", 0x80000019}},
1631 {"jgtru", {"b?", 0x8000001a}},
1632 {"jlequ", {"b?", 0x8000001b}},
1633 {"jvc", {"b?", 0x8000001c}},
1634 {"jvs", {"b?", 0x8000001d}},
1635 {"jgequ", {"b?", 0x8000001e}},
1636 {"jcc", {"b?", 0x8000001e}},
1637 {"jlssu", {"b?", 0x8000001f}},
1638 {"jcs", {"b?", 0x8000001f}},
1640 {"jacbw", {"rwrwmwb!", 0xC000003d}},
1641 {"jacbf", {"rfrfmfb!", 0xC000004f}},
1642 {"jacbd", {"rdrdmdb!", 0xC000006f}},
1643 {"jacbb", {"rbrbmbb!", 0xC000009d}},
1644 {"jacbl", {"rlrlmlb!", 0xC00000f1}},
1645 {"jacbg", {"rgrgmgb!", 0xC0004ffd}},
1646 {"jacbh", {"rhrhmhb!", 0xC0006ffd}},
1648 {"jbs", {"rlvbb?", 0x800000e0}},
1649 {"jbc", {"rlvbb?", 0x800000e1}},
1650 {"jbss", {"rlvbb?", 0x800000e2}},
1651 {"jbcs", {"rlvbb?", 0x800000e3}},
1652 {"jbsc", {"rlvbb?", 0x800000e4}},
1653 {"jbcc", {"rlvbb?", 0x800000e5}},
1654 {"jlbs", {"rlb?", 0x800000e8}},
1655 {"jlbc", {"rlb?", 0x800000e9}},
1657 {"jaoblss", {"rlmlb:", 0xC00000f2}},
1658 {"jaobleq", {"rlmlb:", 0xC00000f3}},
1659 {"jsobgeq", {"mlb:", 0xC00000f4}},
1660 {"jsobgtr", {"mlb:", 0xC00000f5}},
1662 /* CASEx has no branch addresses in our conception of it. */
1663 /* You should use ".word ..." statements after the "case ...". */
1665 {"", {"", 0}} /* empty is end sentinel */
1667 }; /* synthetic_votstrs */
1670 * v i p _ b e g i n ( )
1672 * Call me once before you decode any lines.
1673 * I decode votstrs into a hash table at op_hash (which I create).
1674 * I return an error text or null.
1675 * If you want, I will include the 'synthetic' jXXX instructions in the
1676 * instruction table.
1677 * You must nominate metacharacters for eg DEC's "#", "@", "^".
1681 vip_begin (synthetic_too, immediate, indirect, displen)
1682 int synthetic_too; /* 1 means include jXXX op-codes. */
1683 const char *immediate, *indirect, *displen;
1685 const struct vot *vP; /* scan votstrs */
1686 const char *retval = 0; /* error text */
1688 op_hash = hash_new ();
1690 for (vP = votstrs; *vP->vot_name && !retval; vP++)
1691 retval = hash_insert (op_hash, vP->vot_name, (PTR) &vP->vot_detail);
1694 for (vP = synthetic_votstrs; *vP->vot_name && !retval; vP++)
1695 retval = hash_insert (op_hash, vP->vot_name, (PTR) &vP->vot_detail);
1698 vip_op_defaults (immediate, indirect, displen);
1707 * This converts a string into a vax instruction.
1708 * The string must be a bare single instruction in dec-vax (with BSD4 frobs)
1710 * It provides some error messages: at most one fatal error message (which
1711 * stops the scan) and at most one warning message for each operand.
1712 * The vax instruction is returned in exploded form, since we have no
1713 * knowledge of how you parse (or evaluate) your expressions.
1714 * We do however strip off and decode addressing modes and operation
1717 * The exploded instruction is returned to a struct vit of your choice.
1718 * #include "vax-inst.h" to know what a struct vit is.
1720 * This function's value is a string. If it is not "" then an internal
1721 * logic error was found: read this code to assign meaning to the string.
1722 * No argument string should generate such an error string:
1723 * it means a bug in our code, not in the user's text.
1725 * You MUST have called vip_begin() once before using this function.
1729 vip (vitP, instring)
1730 struct vit *vitP; /* We build an exploded instruction here. */
1731 char *instring; /* Text of a vax instruction: we modify. */
1733 /* How to bit-encode this opcode. */
1734 struct vot_wot *vwP;
1735 /* 1/skip whitespace.2/scan vot_how */
1738 /* counts number of operands seen */
1739 unsigned char count;
1740 /* scan operands in struct vit */
1741 struct vop *operandp;
1742 /* error over all operands */
1743 const char *alloperr;
1744 /* Remember char, (we clobber it with '\0' temporarily). */
1746 /* Op-code of this instruction. */
1749 if (*instring == ' ')
1750 ++instring; /* Skip leading whitespace. */
1751 for (p = instring; *p && *p != ' '; p++);; /* MUST end in end-of-string or exactly 1 space. */
1752 /* Scanned up to end of operation-code. */
1753 /* Operation-code is ended with whitespace. */
1754 if (p - instring == 0)
1756 vitP->vit_error = _("No operator");
1758 memset (vitP->vit_opcode, '\0', sizeof (vitP->vit_opcode));
1765 * Here with instring pointing to what better be an op-name, and p
1766 * pointing to character just past that.
1767 * We trust instring points to an op-name, with no whitespace.
1769 vwP = (struct vot_wot *) hash_find (op_hash, instring);
1770 *p = c; /* Restore char after op-code. */
1773 vitP->vit_error = _("Unknown operator");
1775 memset (vitP->vit_opcode, '\0', sizeof (vitP->vit_opcode));
1780 * We found a match! So let's pick up as many operands as the
1781 * instruction wants, and even gripe if there are too many.
1782 * We expect comma to seperate each operand.
1783 * We let instring track the text, while p tracks a part of the
1788 * The lines below know about 2-byte opcodes starting FD,FE or FF.
1789 * They also understand synthetic opcodes. Note:
1790 * we return 32 bits of opcode, including bucky bits, BUT
1791 * an opcode length is either 8 or 16 bits for vit_opcode_nbytes.
1793 oc = vwP->vot_code; /* The op-code. */
1794 vitP->vit_opcode_nbytes = (oc & 0xFF) >= 0xFD ? 2 : 1;
1795 md_number_to_chars (vitP->vit_opcode, oc, 4);
1796 count = 0; /* no operands seen yet */
1797 instring = p; /* point just past operation code */
1799 for (howp = vwP->vot_how, operandp = vitP->vit_operand;
1800 !(alloperr && *alloperr) && *howp;
1801 operandp++, howp += 2)
1804 * Here to parse one operand. Leave instring pointing just
1805 * past any one ',' that marks the end of this operand.
1808 as_fatal (_("odd number of bytes in operand description"));
1811 for (q = instring; (c = *q) && c != ','; q++)
1814 * Q points to ',' or '\0' that ends argument. C is that
1818 operandp->vop_width = howp[1];
1819 operandp->vop_nbytes = vax_operand_width_size[(unsigned) howp[1]];
1820 operandp->vop_access = howp[0];
1821 vip_op (instring, operandp);
1822 *q = c; /* Restore input text. */
1823 if (operandp->vop_error)
1824 alloperr = _("Bad operand");
1825 instring = q + (c ? 1 : 0); /* next operand (if any) */
1826 count++; /* won another argument, may have an operr */
1829 alloperr = _("Not enough operands");
1833 if (*instring == ' ')
1834 instring++; /* Skip whitespace. */
1836 alloperr = _("Too many operands");
1838 vitP->vit_error = alloperr;
1841 vitP->vit_operands = count;
1847 * Test program for above.
1850 struct vit myvit; /* build an exploded vax instruction here */
1851 char answer[100]; /* human types a line of vax assembler here */
1852 char *mybug; /* "" or an internal logic diagnostic */
1853 int mycount; /* number of operands */
1854 struct vop *myvop; /* scan operands from myvit */
1855 int mysynth; /* 1 means want synthetic opcodes. */
1856 char my_immediate[200];
1857 char my_indirect[200];
1858 char my_displen[200];
1864 printf ("0 means no synthetic instructions. ");
1865 printf ("Value for vip_begin? ");
1867 sscanf (answer, "%d", &mysynth);
1868 printf ("Synthetic opcodes %s be included.\n", mysynth ? "will" : "will not");
1869 printf ("enter immediate symbols eg enter # ");
1870 gets (my_immediate);
1871 printf ("enter indirect symbols eg enter @ ");
1873 printf ("enter displen symbols eg enter ^ ");
1875 if (p = vip_begin (mysynth, my_immediate, my_indirect, my_displen))
1877 error ("vip_begin=%s", p);
1879 printf ("An empty input line will quit you from the vax instruction parser\n");
1882 printf ("vax instruction: ");
1887 break; /* out of for each input text loop */
1889 vip (&myvit, answer);
1890 if (*myvit.vit_error)
1892 printf ("ERR:\"%s\"\n", myvit.vit_error);
1895 for (mycount = myvit.vit_opcode_nbytes, p = myvit.vit_opcode;
1900 printf ("%02x ", *p & 0xFF);
1902 printf (" operand count=%d.\n", mycount = myvit.vit_operands);
1903 for (myvop = myvit.vit_operand; mycount; mycount--, myvop++)
1905 printf ("mode=%xx reg=%xx ndx=%xx len='%c'=%c%c%d. expr=\"",
1906 myvop->vop_mode, myvop->vop_reg, myvop->vop_ndx,
1907 myvop->vop_short, myvop->vop_access, myvop->vop_width,
1909 for (p = myvop->vop_expr_begin; p <= myvop->vop_expr_end; p++)
1914 if (myvop->vop_error)
1916 printf (" err:\"%s\"\n", myvop->vop_error);
1918 if (myvop->vop_warn)
1920 printf (" wrn:\"%s\"\n", myvop->vop_warn);
1925 exit (EXIT_SUCCESS);
1928 #endif /* #ifdef test */
1930 /* end of vax_ins_parse.c */
1932 /* vax_reg_parse.c - convert a VAX register name to a number */
1934 /* Copyright (C) 1987 Free Software Foundation, Inc. A part of GNU. */
1937 * v a x _ r e g _ p a r s e ( )
1939 * Take 3 char.s, the last of which may be `\0` (non-existent)
1940 * and return the VAX register number that they represent.
1942 * Return -1 if they don't form a register name. Good names return
1943 * a number from 0:15 inclusive.
1945 * Case is not important in a name.
1947 * Register names understood are:
1974 int /* return -1 or 0:15 */
1975 vax_reg_parse (c1, c2, c3) /* 3 chars of register name */
1976 char c1, c2, c3; /* c3 == 0 if 2-character reg name */
1978 int retval; /* return -1:15 */
1986 if (isdigit (c2) && c1 == 'r')
1991 retval = retval * 10 + c3 - '0';
1992 retval = (retval > 15) ? -1 : retval;
1993 /* clamp the register value to 1 hex digit */
1996 retval = -1; /* c3 must be '\0' or a digit */
1998 else if (c3) /* There are no three letter regs */
2017 else if (c1 == 'p' && c2 == 'c')
2027 * Parse a vax operand in DEC assembler notation.
2028 * For speed, expect a string of whitespace to be reduced to a single ' '.
2029 * This is the case for GNU AS, and is easy for other DEC-compatible
2032 * Knowledge about DEC VAX assembler operand notation lives here.
2033 * This doesn't even know what a register name is, except it believes
2034 * all register names are 2 or 3 characters, and lets vax_reg_parse() say
2035 * what number each name represents.
2036 * It does, however, know that PC, SP etc are special registers so it can
2037 * detect addressing modes that are silly for those registers.
2039 * Where possible, it delivers 1 fatal or 1 warning message if the operand
2040 * is suspect. Exactly what we test for is still evolving.
2048 * There were a number of 'mismatched argument type' bugs to vip_op.
2049 * The most general solution is to typedef each (of many) arguments.
2050 * We used instead a typedef'd argument block. This is less modular
2051 * than using seperate return pointers for each result, but runs faster
2052 * on most engines, and seems to keep programmers happy. It will have
2053 * to be done properly if we ever want to use vip_op as a general-purpose
2054 * module (it was designed to be).
2058 * Doesn't support DEC "G^" format operands. These always take 5 bytes
2059 * to express, and code as modes 8F or 9F. Reason: "G^" deprives you of
2060 * optimising to (say) a "B^" if you are lucky in the way you link.
2061 * When someone builds a linker smart enough to convert "G^" to "B^", "W^"
2062 * whenever possible, then we should implement it.
2063 * If there is some other use for "G^", feel free to code it in!
2068 * If I nested if()s more, I could avoid testing (*err) which would save
2069 * time, space and page faults. I didn't nest all those if()s for clarity
2070 * and because I think the mode testing can be re-arranged 1st to test the
2071 * commoner constructs 1st. Does anybody have statistics on this?
2077 * In future, we should be able to 'compose' error messages in a scratch area
2078 * and give the user MUCH more informative error messages. Although this takes
2079 * a little more code at run-time, it will make this module much more self-
2080 * documenting. As an example of what sucks now: most error messages have
2081 * hardwired into them the DEC VAX metacharacters "#^@" which are nothing like
2082 * the Un*x characters "$`*", that most users will expect from this AS.
2086 * The input is a string, ending with '\0'.
2088 * We also require a 'hint' of what kind of operand is expected: so
2089 * we can remind caller not to write into literals for instance.
2091 * The output is a skeletal instruction.
2093 * The algorithm has two parts.
2094 * 1. extract the syntactic features (parse off all the @^#-()+[] mode crud);
2095 * 2. express the @^#-()+[] as some parameters suited to further analysis.
2097 * 2nd step is where we detect the googles of possible invalid combinations
2098 * a human (or compiler) might write. Note that if we do a half-way
2099 * decent assembler, we don't know how long to make (eg) displacement
2100 * fields when we first meet them (because they may not have defined values).
2101 * So we must wait until we know how many bits are needed for each address,
2102 * then we can know both length and opcodes of instructions.
2103 * For reason(s) above, we will pass to our caller a 'broken' instruction
2104 * of these major components, from which our caller can generate instructions:
2105 * - displacement length I^ S^ L^ B^ W^ unspecified
2107 * - register R0-R15 or absent
2108 * - index register R0-R15 or absent
2109 * - expression text what we don't parse
2110 * - error text(s) why we couldn't understand the operand
2114 * To decode output of this, test errtxt. If errtxt[0] == '\0', then
2115 * we had no errors that prevented parsing. Also, if we ever report
2116 * an internal bug, errtxt[0] is set non-zero. So one test tells you
2117 * if the other outputs are to be taken seriously.
2121 * Because this module is useful for both VMS and UN*X style assemblers
2122 * and because of the variety of UN*X assemblers we must recognise
2123 * the different conventions for assembler operand notation. For example
2124 * VMS says "#42" for immediate mode, while most UN*X say "$42".
2125 * We permit arbitrary sets of (single) characters to represent the
2126 * 3 concepts that DEC writes '#', '@', '^'.
2129 /* character tests */
2130 #define VIP_IMMEDIATE 01 /* Character is like DEC # */
2131 #define VIP_INDIRECT 02 /* Char is like DEC @ */
2132 #define VIP_DISPLEN 04 /* Char is like DEC ^ */
2134 #define IMMEDIATEP(c) (vip_metacharacters [(c)&0xff]&VIP_IMMEDIATE)
2135 #define INDIRECTP(c) (vip_metacharacters [(c)&0xff]&VIP_INDIRECT)
2136 #define DISPLENP(c) (vip_metacharacters [(c)&0xff]&VIP_DISPLEN)
2138 /* We assume 8 bits per byte. Use vip_op_defaults() to set these up BEFORE we
2142 #if defined(CONST_TABLE)
2144 #define I VIP_IMMEDIATE,
2145 #define S VIP_INDIRECT,
2146 #define D VIP_DISPLEN,
2148 vip_metacharacters[256] =
2150 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ /* ^@ ^A ^B ^C ^D ^E ^F ^G ^H ^I ^J ^K ^L ^M ^N ^O*/
2151 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ /* ^P ^Q ^R ^S ^T ^U ^V ^W ^X ^Y ^Z ^[ ^\ ^] ^^ ^_ */
2152 _ _ _ _ I _ _ _ _ _ S _ _ _ _ _ /* sp ! " # $ % & ' ( ) * + , - . / */
2153 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ /*0 1 2 3 4 5 6 7 8 9 : ; < = > ?*/
2154 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ /*@ A B C D E F G H I J K L M N O*/
2155 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ /*P Q R S T U V W X Y Z [ \ ] ^ _*/
2156 D _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ /*` a b c d e f g h i j k l m n o*/
2157 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ /*p q r s t u v w x y z { | } ~ ^?*/
2159 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
2160 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
2161 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
2162 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
2163 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
2164 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
2165 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
2166 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
2173 static char vip_metacharacters[256];
2176 vip_op_1 (bit, syms)
2182 while ((t = *syms++) != 0)
2183 vip_metacharacters[t] |= bit;
2186 /* Can be called any time. More arguments may appear in future. */
2188 vip_op_defaults (immediate, indirect, displen)
2189 const char *immediate;
2190 const char *indirect;
2191 const char *displen;
2193 vip_op_1 (VIP_IMMEDIATE, immediate);
2194 vip_op_1 (VIP_INDIRECT, indirect);
2195 vip_op_1 (VIP_DISPLEN, displen);
2202 * Dec defines the semantics of address modes (and values)
2203 * by a two-letter code, explained here.
2205 * letter 1: access type
2207 * a address calculation - no data access, registers forbidden
2208 * b branch displacement
2209 * m read - let go of bus - write back "modify"
2211 * v bit field address: like 'a' but registers are OK
2213 * space no operator (eg ".long foo") [our convention]
2215 * letter 2: data type (i.e. width, alignment)
2218 * d double precision floating point (D format)
2219 * f single precision floating point (F format)
2220 * g G format floating
2221 * h H format floating
2226 * ? simple synthetic branch operand
2227 * - unconditional synthetic JSB/JSR operand
2228 * ! complex synthetic branch operand
2230 * The '-?!' letter 2's are not for external consumption. They are used
2231 * for various assemblers. Generally, all unknown widths are assumed 0.
2232 * We don't limit your choice of width character.
2234 * DEC operands are hard work to parse. For example, '@' as the first
2235 * character means indirect (deferred) mode but elswhere it is a shift
2237 * The long-winded explanation of how this is supposed to work is
2238 * cancelled. Read a DEC vax manual.
2239 * We try hard not to parse anything that MIGHT be part of the expression
2240 * buried in that syntax. For example if we see @...(Rn) we don't check
2241 * for '-' before the '(' because mode @-(Rn) does not exist.
2243 * After parsing we have:
2245 * at 1 if leading '@' (or Un*x '*')
2246 * len takes one value from " bilsw". eg B^ -> 'b'.
2247 * hash 1 if leading '#' (or Un*x '$')
2248 * expr_begin, expr_end the expression we did not parse
2249 * even though we don't interpret it, we make use
2250 * of its presence or absence.
2251 * sign -1: -(Rn) 0: absent +1: (Rn)+
2252 * paren 1 if () are around register
2253 * reg major register number 0:15 -1 means absent
2254 * ndx index register number 0:15 -1 means absent
2256 * Again, I dare not explain it: just trace ALL the code!
2260 vip_op (optext, vopP)
2261 /* user's input string e.g.: "@B^foo@bar(AP)[FP]:" */
2263 /* Input fields: vop_access, vop_width.
2264 Output fields: _ndx, _reg, _mode, _short, _warn,
2265 _error _expr_begin, _expr_end, _nbytes.
2266 vop_nbytes : number of bytes in a datum. */
2269 /* track operand text forward */
2271 /* track operand text backward */
2273 /* 1 if leading '@' ('*') seen */
2275 /* one of " bilsw" */
2277 /* 1 if leading '#' ('$') seen */
2281 /* 1 if () surround register */
2283 /* register number, -1:absent */
2285 /* index register number -1:absent */
2287 /* report illegal operand, ""==OK */
2288 /* " " is a FAKE error: means we won */
2289 /* ANY err that begins with ' ' is a fake. */
2290 /* " " is converted to "" before return */
2292 /* warn about weird modes pf address */
2294 /* preserve q in case we backup */
2296 /* build up 4-bit operand mode here */
2297 /* note: index mode is in ndx, this is */
2298 /* the major mode of operand address */
2301 * Notice how we move wrong-arg-type bugs INSIDE this module: if we
2302 * get the types wrong below, we lose at compile time rather than at
2305 char access_mode; /* vop_access. */
2306 char width; /* vop_width. */
2308 access_mode = vopP->vop_access;
2309 width = vopP->vop_width;
2310 /* None of our code bugs (yet), no user text errors, no warnings
2316 if (*p == ' ') /* Expect all whitespace reduced to ' '. */
2317 p++; /* skip over whitespace */
2319 if ((at = INDIRECTP (*p)) != 0)
2320 { /* 1 if *p=='@'(or '*' for Un*x) */
2321 p++; /* at is determined */
2322 if (*p == ' ') /* Expect all whitespace reduced to ' '. */
2323 p++; /* skip over whitespace */
2327 * This code is subtle. It tries to detect all legal (letter)'^'
2328 * but it doesn't waste time explicitly testing for premature '\0' because
2329 * this case is rejected as a mismatch against either (letter) or '^'.
2337 if (DISPLENP (p[1]) && strchr ("bilws", len = c))
2338 p += 2; /* skip (letter) '^' */
2339 else /* no (letter) '^' seen */
2340 len = ' '; /* len is determined */
2343 if (*p == ' ') /* Expect all whitespace reduced to ' '. */
2344 p++; /* skip over whitespace */
2346 if ((hash = IMMEDIATEP (*p)) != 0) /* 1 if *p=='#' ('$' for Un*x) */
2347 p++; /* hash is determined */
2350 * p points to what may be the beginning of an expression.
2351 * We have peeled off the front all that is peelable.
2352 * We know at, len, hash.
2354 * Lets point q at the end of the text and parse that (backwards).
2357 for (q = p; *q; q++)
2359 q--; /* now q points at last char of text */
2361 if (*q == ' ' && q >= p) /* Expect all whitespace reduced to ' '. */
2363 /* reverse over whitespace, but don't */
2364 /* run back over *p */
2367 * As a matter of policy here, we look for [Rn], although both Rn and S^#
2368 * forbid [Rn]. This is because it is easy, and because only a sick
2369 * cyborg would have [...] trailing an expression in a VAX-like assembler.
2370 * A meticulous parser would first check for Rn followed by '(' or '['
2371 * and not parse a trailing ']' if it found another. We just ban expressions
2376 while (q >= p && *q != '[')
2378 /* either q<p or we got matching '[' */
2380 err = _("no '[' to match ']'");
2384 * Confusers like "[]" will eventually lose with a bad register
2385 * name error. So again we don't need to check for early '\0'.
2388 ndx = vax_reg_parse (q[1], q[2], 0);
2389 else if (q[4] == ']')
2390 ndx = vax_reg_parse (q[1], q[2], q[3]);
2394 * Since we saw a ']' we will demand a register name in the [].
2395 * If luser hasn't given us one: be rude.
2398 err = _("bad register in []");
2400 err = _("[PC] index banned");
2402 q--; /* point q just before "[...]" */
2406 ndx = -1; /* no ']', so no iNDeX register */
2409 * If err = "..." then we lost: run away.
2410 * Otherwise ndx == -1 if there was no "[...]".
2411 * Otherwise, ndx is index register number, and q points before "[...]".
2414 if (*q == ' ' && q >= p) /* Expect all whitespace reduced to ' '. */
2416 /* reverse over whitespace, but don't */
2417 /* run back over *p */
2420 sign = 0; /* no ()+ or -() seen yet */
2422 if (q > p + 3 && *q == '+' && q[-1] == ')')
2424 sign = 1; /* we saw a ")+" */
2425 q--; /* q points to ')' */
2428 if (*q == ')' && q > p + 2)
2430 paren = 1; /* assume we have "(...)" */
2431 while (q >= p && *q != '(')
2433 /* either q<p or we got matching '(' */
2435 err = _("no '(' to match ')'");
2439 * Confusers like "()" will eventually lose with a bad register
2440 * name error. So again we don't need to check for early '\0'.
2443 reg = vax_reg_parse (q[1], q[2], 0);
2444 else if (q[4] == ')')
2445 reg = vax_reg_parse (q[1], q[2], q[3]);
2449 * Since we saw a ')' we will demand a register name in the ')'.
2450 * This is nasty: why can't our hypothetical assembler permit
2451 * parenthesised expressions? BECAUSE I AM LAZY! That is why.
2452 * Abuse luser if we didn't spy a register name.
2456 /* JF allow parenthasized expressions. I hope this works */
2460 /* err = "unknown register in ()"; */
2463 q--; /* point just before '(' of "(...)" */
2465 * If err == "..." then we lost. Run away.
2466 * Otherwise if reg >= 0 then we saw (Rn).
2470 * If err == "..." then we lost.
2471 * Otherwise paren==1 and reg = register in "()".
2477 * If err == "..." then we lost.
2478 * Otherwise, q points just before "(Rn)", if any.
2479 * If there was a "(...)" then paren==1, and reg is the register.
2483 * We should only seek '-' of "-(...)" if:
2484 * we saw "(...)" paren == 1
2485 * we have no errors so far ! *err
2486 * we did not see '+' of "(...)+" sign < 1
2487 * We don't check len. We want a specific error message later if
2488 * user tries "x^...-(Rn)". This is a feature not a bug.
2492 if (paren && sign < 1)/* !sign is adequate test */
2501 * We have back-tracked over most
2502 * of the crud at the end of an operand.
2503 * Unless err, we know: sign, paren. If paren, we know reg.
2504 * The last case is of an expression "Rn".
2505 * This is worth hunting for if !err, !paren.
2506 * We wouldn't be here if err.
2507 * We remember to save q, in case we didn't want "Rn" anyway.
2511 if (*q == ' ' && q >= p) /* Expect all whitespace reduced to ' '. */
2513 /* reverse over whitespace, but don't */
2514 /* run back over *p */
2515 if (q > p && q < p + 3) /* room for Rn or Rnn exactly? */
2516 reg = vax_reg_parse (p[0], p[1], q < p + 2 ? 0 : p[2]);
2518 reg = -1; /* always comes here if no register at all */
2520 * Here with a definitive reg value.
2531 * have reg. -1:absent; else 0:15
2535 * We have: err, at, len, hash, ndx, sign, paren, reg.
2536 * Also, any remaining expression is from *p through *q inclusive.
2537 * Should there be no expression, q==p-1. So expression length = q-p+1.
2538 * This completes the first part: parsing the operand text.
2542 * We now want to boil the data down, checking consistency on the way.
2543 * We want: len, mode, reg, ndx, err, p, q, wrn, bug.
2544 * We will deliver a 4-bit reg, and a 4-bit mode.
2548 * Case of branch operand. Different. No L^B^W^I^S^ allowed for instance.
2562 * p:q whatever was input
2564 * err " " or error message, and other outputs trashed
2566 /* branch operands have restricted forms */
2567 if ((!err || !*err) && access_mode == 'b')
2569 if (at || hash || sign || paren || ndx >= 0 || reg >= 0 || len != ' ')
2570 err = _("invalid branch operand");
2575 /* Since nobody seems to use it: comment this 'feature'(?) out for now. */
2578 * Case of stand-alone operand. e.g. ".long foo"
2592 * p:q whatever was input
2594 * err " " or error message, and other outputs trashed
2596 if ((!err || !*err) && access_mode == ' ')
2599 err = _("address prohibits @");
2601 err = _("address prohibits #");
2605 err = _("address prohibits -()");
2607 err = _("address prohibits ()+");
2610 err = _("address prohibits ()");
2612 err = _("address prohibits []");
2614 err = _("address prohibits register");
2615 else if (len != ' ')
2616 err = _("address prohibits displacement length specifier");
2619 err = " "; /* succeed */
2623 #endif /*#Ifdef NEVER*/
2629 * len 's' definition
2631 * p:q demand not empty
2632 * sign 0 by paren==0
2633 * paren 0 by "()" scan logic because "S^" seen
2634 * reg -1 or nn by mistake
2643 if ((!err || !*err) && len == 's')
2645 if (!hash || paren || at || ndx >= 0)
2646 err = _("invalid operand of S^#");
2652 * SHIT! we saw S^#Rnn ! put the Rnn back in
2653 * expression. KLUDGE! Use oldq so we don't
2654 * need to know exact length of reg name.
2660 * We have all the expression we will ever get.
2663 err = _("S^# needs expression");
2664 else if (access_mode == 'r')
2666 err = " "; /* WIN! */
2670 err = _("S^# may only read-access");
2675 * Case of -(Rn), which is weird case.
2681 * sign -1 by definition
2682 * paren 1 by definition
2683 * reg present by definition
2689 * exp "" enforce empty expression
2690 * ndx optional warn if same as reg
2692 if ((!err || !*err) && sign < 0)
2694 if (len != ' ' || hash || at || p <= q)
2695 err = _("invalid operand of -()");
2698 err = " "; /* win */
2701 wrn = _("-(PC) unpredictable");
2702 else if (reg == ndx)
2703 wrn = _("[]index same as -()register: unpredictable");
2708 * We convert "(Rn)" to "@Rn" for our convenience.
2709 * (I hope this is convenient: has someone got a better way to parse this?)
2710 * A side-effect of this is that "@Rn" is a valid operand.
2712 if (paren && !sign && !hash && !at && len == ' ' && p > q)
2719 * Case of (Rn)+, which is slightly different.
2725 * sign +1 by definition
2726 * paren 1 by definition
2727 * reg present by definition
2733 * exp "" enforce empty expression
2734 * ndx optional warn if same as reg
2736 if ((!err || !*err) && sign > 0)
2738 if (len != ' ' || hash || p <= q)
2739 err = _("invalid operand of ()+");
2742 err = " "; /* win */
2743 mode = 8 + (at ? 1 : 0);
2745 wrn = _("(PC)+ unpredictable");
2746 else if (reg == ndx)
2747 wrn = _("[]index same as ()+register: unpredictable");
2752 * Case of #, without S^.
2756 * hash 1 by definition
2769 if ((!err || !*err) && hash)
2771 if (len != 'i' && len != ' ')
2772 err = _("# conflicts length");
2774 err = _("# bars register");
2780 * SHIT! we saw #Rnn! Put the Rnn back into the expression.
2781 * By using oldq, we don't need to know how long Rnn was.
2785 reg = -1; /* no register any more */
2787 err = " "; /* win */
2789 /* JF a bugfix, I think! */
2790 if (at && access_mode == 'a')
2791 vopP->vop_nbytes = 4;
2793 mode = (at ? 9 : 8);
2795 if ((access_mode == 'm' || access_mode == 'w') && !at)
2796 wrn = _("writing or modifying # is unpredictable");
2800 * If !*err, then sign == 0
2805 * Case of Rn. We seperate this one because it has a few special
2806 * errors the remaining modes lack.
2810 * hash 0 by program logic
2812 * sign 0 by program logic
2813 * paren 0 by definition
2814 * reg present by definition
2819 * len ' ' enforce no length
2820 * exp "" enforce empty expression
2821 * ndx optional warn if same as reg
2823 if ((!err || !*err) && !paren && reg >= 0)
2826 err = _("length not needed");
2829 err = " "; /* win */
2833 err = _("can't []index a register, because it has no address");
2834 else if (access_mode == 'a')
2835 err = _("a register has no address");
2839 * Idea here is to detect from length of datum
2840 * and from register number if we will touch PC.
2842 * vop_nbytes is number of bytes in operand.
2843 * Compute highest byte affected, compare to PC0.
2845 if ((vopP->vop_nbytes + reg * 4) > 60)
2846 wrn = _("PC part of operand unpredictable");
2847 err = " "; /* win */
2852 * If !*err, sign == 0
2854 * paren == 1 OR reg==-1
2858 * Rest of cases fit into one bunch.
2861 * len ' ' or 'b' or 'w' or 'l'
2862 * hash 0 by program logic
2863 * p:q expected (empty is not an error)
2864 * sign 0 by program logic
2869 * out: mode 10 + @ + len
2871 * len ' ' or 'b' or 'w' or 'l'
2873 * ndx optional warn if same as reg
2877 err = " "; /* win (always) */
2878 mode = 10 + (at ? 1 : 0);
2885 case ' ': /* assumed B^ until our caller changes it */
2892 * here with completely specified mode
2900 err = 0; /* " " is no longer an error */
2902 vopP->vop_mode = mode;
2903 vopP->vop_reg = reg;
2904 vopP->vop_short = len;
2905 vopP->vop_expr_begin = p;
2906 vopP->vop_expr_end = q;
2907 vopP->vop_ndx = ndx;
2908 vopP->vop_error = err;
2909 vopP->vop_warn = wrn;
2914 Summary of vip_op outputs.
2918 {@}Rn 5+@ n ' ' optional
2919 branch operand 0 -1 ' ' -1
2921 -(Rn) 7 n ' ' optional
2922 {@}(Rn)+ 8+@ n ' ' optional
2923 {@}#foo, no S^ 8+@ PC " i" optional
2924 {@}{q^}{(Rn)} 10+@+q option " bwl" optional
2928 #ifdef TEST /* #Define to use this testbed. */
2931 * Follows a test program for this function.
2932 * We declare arrays non-local in case some of our tiny-minded machines
2933 * default to small stacks. Also, helps with some debuggers.
2938 char answer[100]; /* human types into here */
2951 int my_operand_length;
2952 char my_immediate[200];
2953 char my_indirect[200];
2954 char my_displen[200];
2958 printf ("enter immediate symbols eg enter # ");
2959 gets (my_immediate);
2960 printf ("enter indirect symbols eg enter @ ");
2962 printf ("enter displen symbols eg enter ^ ");
2964 vip_op_defaults (my_immediate, my_indirect, my_displen);
2967 printf ("access,width (eg 'ab' or 'wh') [empty line to quit] : ");
2971 exit (EXIT_SUCCESS);
2972 myaccess = answer[0];
2973 mywidth = answer[1];
2977 my_operand_length = 1;
2980 my_operand_length = 8;
2983 my_operand_length = 4;
2986 my_operand_length = 16;
2989 my_operand_length = 32;
2992 my_operand_length = 4;
2995 my_operand_length = 16;
2998 my_operand_length = 8;
3001 my_operand_length = 2;
3006 my_operand_length = 0;
3010 my_operand_length = 2;
3011 printf ("I dn't understand access width %c\n", mywidth);
3014 printf ("VAX assembler instruction operand: ");
3017 mybug = vip_op (answer, myaccess, mywidth, my_operand_length,
3018 &mymode, &myreg, &mylen, &myleft, &myright, &myndx,
3022 printf ("error: \"%s\"\n", myerr);
3024 printf (" bug: \"%s\"\n", mybug);
3029 printf ("warning: \"%s\"\n", mywrn);
3030 mumble ("mode", mymode);
3031 mumble ("register", myreg);
3032 mumble ("index", myndx);
3033 printf ("width:'%c' ", mylen);
3034 printf ("expression: \"");
3035 while (myleft <= myright)
3036 putchar (*myleft++);
3042 mumble (text, value)
3046 printf ("%s:", text);
3048 printf ("%xx", value);
3054 #endif /* ifdef TEST */
3058 const int md_short_jump_size = 3;
3059 const int md_long_jump_size = 6;
3060 const int md_reloc_size = 8; /* Size of relocation record */
3063 md_create_short_jump (ptr, from_addr, to_addr, frag, to_symbol)
3065 addressT from_addr, to_addr;
3071 /* This former calculation was off by two:
3072 offset = to_addr - (from_addr + 1);
3073 We need to account for the one byte instruction and also its
3074 two byte operand. */
3075 offset = to_addr - (from_addr + 1 + 2);
3076 *ptr++ = VAX_BRW; /* branch with word (16 bit) offset */
3077 md_number_to_chars (ptr, offset, 2);
3081 md_create_long_jump (ptr, from_addr, to_addr, frag, to_symbol)
3083 addressT from_addr, to_addr;
3089 offset = to_addr - S_GET_VALUE (to_symbol);
3090 *ptr++ = VAX_JMP; /* arbitrary jump */
3091 *ptr++ = VAX_ABSOLUTE_MODE;
3092 md_number_to_chars (ptr, offset, 4);
3093 fix_new (frag, ptr - frag->fr_literal, 4, to_symbol, (long) 0, 0, NO_RELOC);
3097 CONST char *md_shortopts = "d:STt:V+1h:Hv::";
3099 CONST char *md_shortopts = "d:STt:V";
3101 struct option md_longopts[] = {
3102 {NULL, no_argument, NULL, 0}
3104 size_t md_longopts_size = sizeof (md_longopts);
3107 md_parse_option (c, arg)
3114 as_warn (_("SYMBOL TABLE not implemented"));
3118 as_warn (_("TOKEN TRACE not implemented"));
3122 as_warn (_("Displacement length %s ignored!"), arg);
3126 as_warn (_("I don't need or use temp. file \"%s\"."), arg);
3130 as_warn (_("I don't use an interpass file! -V ignored"));
3134 case '+': /* For g++. Hash any name > 31 chars long. */
3135 flag_hash_long_names = 1;
3138 case '1': /* For backward compatibility */
3142 case 'H': /* Show new symbol after hash truncation */
3143 flag_show_after_trunc = 1;
3146 case 'h': /* No hashing of mixed-case names */
3148 extern char vms_name_mapping;
3149 vms_name_mapping = atoi (arg);
3150 flag_no_hash_mixed_case = 1;
3156 extern char *compiler_version_string;
3157 if (!arg || !*arg || access (arg, 0) == 0)
3158 return 0; /* have caller show the assembler version */
3159 compiler_version_string = arg;
3172 md_show_usage (stream)
3175 fprintf (stream, _("\
3177 -d LENGTH ignored\n\
3184 fprintf (stream, _("\
3186 -+ hash encode names longer than 31 characters\n\
3187 -1 `const' handling compatible with gcc 1.x\n\
3188 -H show new symbol after hash truncation\n\
3189 -h NUM don't hash mixed-case names, and adjust case:\n\
3190 0 = upper, 2 = lower, 3 = preserve case\n\
3191 -v\"VERSION\" code being assembled was produced by compiler \"VERSION\"\n"));
3195 /* We have no need to default values of symbols. */
3198 md_undefined_symbol (name)
3204 /* Round up a section size to the appropriate boundary. */
3206 md_section_align (segment, size)
3210 return size; /* Byte alignment is fine */
3213 /* Exactly what point is a PC-relative offset relative TO?
3214 On the vax, they're relative to the address of the offset, plus
3215 its size. (??? Is this right? FIXME-SOON) */
3217 md_pcrel_from (fixP)
3220 return fixP->fx_size + fixP->fx_where + fixP->fx_frag->fr_address;
3223 /* end of tc-vax.c */