1 /* vax.c - vax-specific -
2 Copyright (C) 1987, 1991 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. */
22 /* JF I moved almost all the vax specific stuff into this one file 'cuz RMS
23 seems to think its a good idea. I hope I managed to get all the VAX-isms */
31 #include "obstack.h" /* For FRAG_APPEND_1_CHAR macro in "frags.h" */
36 /* These chars start a comment anywhere in a source file (except inside
38 const char comment_chars
[] = "#";
40 /* These chars only start a comment at the beginning of a line. */
41 /* Note that for the VAX the are the same as comment_chars above. */
42 const char line_comment_chars
[] = "#";
44 /* Chars that can be used to separate mant from exp in floating point nums */
45 const char EXP_CHARS
[] = "eE";
47 /* Chars that mean this number is a floating point constant */
49 /* or 0H1.234E-12 (see exp chars above) */
50 const char FLT_CHARS
[] = "dDfFgGhH";
52 /* Also be aware that MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT may have to be
53 changed in read.c . Ideally it shouldn't have to know about it at all,
54 but nothing is ideal around here.
57 static expressionS
/* Hold details of an operand expression */
58 exp_of_operand
[VIT_MAX_OPERANDS
];
61 v
; /* A vax instruction after decoding. */
63 LITTLENUM_TYPE big_operand_bits
[VIT_MAX_OPERANDS
][SIZE_OF_LARGE_NUMBER
];
64 /* Hold details of big operands. */
65 FLONUM_TYPE float_operand
[VIT_MAX_OPERANDS
];
66 /* Above is made to point into */
67 /* big_operand_bits by md_begin(). */
70 * For VAX, relative addresses of "just the right length" are easy.
71 * The branch displacement is always the last operand, even in
72 * synthetic instructions.
73 * For VAX, we encode the relax_substateTs (in e.g. fr_substate) as:
75 * 4 3 2 1 0 bit number
76 * ---/ /--+-------+-------+-------+-------+-------+
77 * | what state ? | how long ? |
78 * ---/ /--+-------+-------+-------+-------+-------+
80 * The "how long" bits are 00=byte, 01=word, 10=long.
81 * This is a Un*x convention.
82 * Not all lengths are legit for a given value of (what state).
83 * The "how long" refers merely to the displacement length.
84 * The address usually has some constant bytes in it as well.
87 groups for VAX address relaxing.
90 length of byte, word, long
92 2a. J<cond> where <cond> is a simple flag test.
93 length of byte, word, long.
94 VAX opcodes are: (Hex)
107 Always, you complement 0th bit to reverse condition.
108 Always, 1-byte opcode, then 1-byte displacement.
110 2b. J<cond> where cond tests a memory bit.
111 length of byte, word, long.
112 Vax opcodes are: (Hex)
121 Always, you complement 0th bit to reverse condition.
122 Always, 1-byte opcde, longword-address, byte-address, 1-byte-displacement
124 2c. J<cond> where cond tests low-order memory bit
125 length of byte,word,long.
126 Vax opcodes are: (Hex)
129 Always, you complement 0th bit to reverse condition.
130 Always, 1-byte opcode, longword-address, 1-byte displacement.
133 length of byte,word,long.
134 Vax opcodes are: (Hex)
137 These are like (2) but there is no condition to reverse.
138 Always, 1 byte opcode, then displacement/absolute.
141 length of word, long.
142 Vax opcodes are: (Hex)
150 Always, we cannot reverse the sense of the branch; we have a word
152 The double-byte op-codes don't hurt: we never want to modify the
153 opcode, so we don't care how many bytes are between the opcode and
157 length of long, long, byte.
158 Vax opcodes are: (Hex)
163 Always, we cannot reverse the sense of the branch; we have a byte
166 The only time we need to modify the opcode is for class 2 instructions.
167 After relax() we may complement the lowest order bit of such instruction
168 to reverse sense of branch.
170 For class 2 instructions, we store context of "where is the opcode literal".
171 We can change an opcode's lowest order bit without breaking anything else.
173 We sometimes store context in the operand literal. This way we can figure out
174 after relax() what the original addressing mode was.
177 /* These displacements are relative to */
178 /* the start address of the displacement. */
179 /* The first letter is Byte, Word. */
180 /* 2nd letter is Forward, Backward. */
183 #define WF (2+ 32767)
184 #define WB (2+-32768)
185 /* Dont need LF, LB because they always */
186 /* reach. [They are coded as 0.] */
189 #define C(a,b) ENCODE_RELAX(a,b)
190 /* This macro has no side-effects. */
191 #define ENCODE_RELAX(what,length) (((what) << 2) + (length))
198 }, /* error sentinel 0,0 */
209 BF
+ 1, BB
+ 1, 2, C (1, 1)
212 WF
+ 1, WB
+ 1, 3, C (1, 2)
222 }, /* b<cond> B^"foo" 2,0 */
224 WF
+ 2, WB
+ 2, 4, C (2, 2)
225 }, /* br.+? brw X 2,1 */
228 }, /* br.+? jmp X 2,2 */
234 }, /* brb B^foo 3,0 */
237 }, /* brw W^foo 3,1 */
240 }, /* Jmp L^foo 3,2 */
249 }, /* acb_ ^Wfoo 4,1 */
252 }, /* acb_,br,jmp L^foo4,2 */
258 }, /* Xob___,,foo 5,0 */
260 WF
+ 4, WB
+ 4, 6, C (5, 2)
261 }, /* Xob.+2,brb.+3,brw5,1 */
264 }, /* Xob.+2,brb.+6,jmp5,2 */
275 const pseudo_typeS md_pseudo_table
[] =
277 {"dfloat", float_cons
, 'd'},
278 {"ffloat", float_cons
, 'f'},
279 {"gfloat", float_cons
, 'g'},
280 {"hfloat", float_cons
, 'h'},
284 #define STATE_PC_RELATIVE (1)
285 #define STATE_CONDITIONAL_BRANCH (2)
286 #define STATE_ALWAYS_BRANCH (3) /* includes BSB... */
287 #define STATE_COMPLEX_BRANCH (4)
288 #define STATE_COMPLEX_HOP (5)
290 #define STATE_BYTE (0)
291 #define STATE_WORD (1)
292 #define STATE_LONG (2)
293 #define STATE_UNDF (3) /* Symbol undefined in pass1 */
296 #define min(a, b) ((a) < (b) ? (a) : (b))
307 if (*(errtxt
= vip_begin (TRUE
, "$", "*", "`")))
309 as_fatal("VIP_BEGIN error:%s", errtxt
);
312 for (i
= 0, fP
= float_operand
;
313 fP
< float_operand
+ VIT_MAX_OPERANDS
;
316 fP
->low
= &big_operand_bits
[i
][0];
317 fP
->high
= &big_operand_bits
[i
][SIZE_OF_LARGE_NUMBER
- 1];
327 void /* Knows about order of bytes in address. */
328 md_number_to_chars (con
, value
, nbytes
)
329 char con
[]; /* Return 'nbytes' of chars here. */
330 long value
; /* The value of the bits. */
331 int nbytes
; /* Number of bytes in the output. */
340 *con
++ = value
; /* Lint wants & MASK_CHAR. */
341 value
>>= BITS_PER_CHAR
;
343 /* XXX line number probably botched for this warning message. */
344 if (value
!= 0 && value
!= -1)
345 as_bad("Displacement (%ld) long for instruction field length (%d).", v
, n
);
348 /* Fix up some data or instructions after we find out the value of a symbol
349 that they reference. */
351 void /* Knows about order of bytes in address. */
352 md_apply_fix(fixP
, value
)
353 fixS
*fixP
; /* Fixup struct pointer */
354 long value
; /* The value of the bits. */
356 char *buf
= fixP
->fx_where
+ fixP
->fx_frag
->fr_literal
;
357 int nbytes
; /* Number of bytes in the output. */
359 nbytes
= fixP
->fx_size
;
362 *buf
++ = value
; /* Lint wants & MASK_CHAR. */
363 value
>>= BITS_PER_CHAR
;
367 long /* Knows about the byte order in a word. */
368 md_chars_to_number (con
, nbytes
)
369 unsigned char con
[]; /* Low order byte 1st. */
370 int nbytes
; /* Number of bytes in the input. */
373 for (retval
= 0, con
+= nbytes
- 1; nbytes
--; con
--)
375 retval
<<= BITS_PER_CHAR
;
381 /* vax:md_assemble() emit frags for 1 instruction */
384 md_assemble (instruction_string
)
385 char *instruction_string
; /* A string: assemble 1 instruction. */
388 register struct vop
*operandP
;/* An operand. Scans all operands. */
389 char *save_input_line_pointer
;
390 char c_save
; /* What used to live after an expression. */
391 struct frag
*fragP
; /* Fragment of code we just made. */
392 register int goofed
; /* TRUE: instruction_string bad for all passes. */
393 register struct vop
*end_operandP
; /* -> slot just after last operand */
394 /* Limit of the for (each operand). */
395 register expressionS
*expP
; /* -> expression values for this operand */
397 /* These refer to an instruction operand expression. */
398 segT to_seg
; /* Target segment of the address. */
399 register valueT this_add_number
;
400 register struct symbol
*this_add_symbol
; /* +ve (minuend) symbol. */
401 register struct symbol
*this_subtract_symbol
; /* -ve(subtrahend) symbol. */
403 long opcode_as_number
; /* As a number. */
404 char *opcode_as_chars
; /* Least significant byte 1st. */
405 /* As an array of characters. */
406 char *opcode_low_byteP
; /* Least significant byte 1st */
407 struct details
*detP
; /* The details of an ADxxx frag. */
408 int length
; /* length (bytes) meant by vop_short. */
409 int at
; /* 0, or 1 if '@' is in addressing mode. */
410 int nbytes
; /* From vop_nbytes: vax_operand_width (in bytes) */
413 LITTLENUM_TYPE literal_float
[8];
414 /* Big enough for any floating point literal. */
416 if (*(p
= vip (&v
, instruction_string
)))
418 as_fatal("vax_assemble\"%s\" in=\"%s\"", p
, instruction_string
);
421 * Now we try to find as many as_warn()s as we can. If we do any as_warn()s
422 * then goofed=TRUE. Notice that we don't make any frags yet.
423 * Should goofed be TRUE, then this instruction will wedge in any pass,
424 * and we can safely flush it, without causing interpass symbol phase
425 * errors. That is, without changing label values in different passes.
427 if (goofed
= (*v
.vit_error
))
429 as_warn ("Ignoring statement due to \"%s\"", v
.vit_error
);
432 * We need to use expression() and friends, which require us to diddle
433 * input_line_pointer. So we save it and restore it later.
435 save_input_line_pointer
= input_line_pointer
;
436 for (operandP
= v
.vit_operand
,
437 expP
= exp_of_operand
,
438 floatP
= float_operand
,
439 end_operandP
= v
.vit_operand
+ v
.vit_operands
;
441 operandP
< end_operandP
;
446 ) /* for each operand */
448 if (*(operandP
->vop_error
))
450 as_warn ("Ignoring statement because \"%s\"", (operandP
->vop_error
));
454 { /* statement has no syntax goofs: lets sniff the expression */
455 int can_be_short
; /* TRUE if a bignum can be reduced to a short literal. */
457 input_line_pointer
= operandP
->vop_expr_begin
;
458 c_save
= operandP
->vop_expr_end
[1];
459 operandP
->vop_expr_end
[1] = '\0';
460 /* If to_seg == SEG_PASS1, expression() will have set need_pass_2 = TRUE. */
461 switch (to_seg
= expression (expP
))
464 /* for BSD4.2 compatibility, missing expression is absolute 0 */
465 to_seg
= expP
->X_seg
= SEG_ABSOLUTE
;
466 expP
->X_add_number
= 0;
467 /* for SEG_ABSOLUTE, we shouldnt need to set X_subtract_symbol, X_add_symbol to any particular value. */
468 /* But, we will program defensively. Since this situation occurs */
469 /* rarely so it costs us little to do, and stops Dean */
470 /* worrying about the origin of random bits in expressionS's. */
471 expP
->X_add_symbol
= NULL
;
472 expP
->X_subtract_symbol
= NULL
;
483 * Major bug. We can't handle the case of a
484 * SEG_DIFFERENCE expression in a VIT_OPCODE_SYNTHETIC
485 * variable-length instruction.
486 * We don't have a frag type that is smart enough to
487 * relax a SEG_DIFFERENCE, and so we just force all
488 * SEG_DIFFERENCEs to behave like SEG_PASS1s.
489 * Clearly, if there is a demand we can invent a new or
490 * modified frag type and then coding up a frag for this
491 * case will be easy. SEG_DIFFERENCE was invented for the
492 * .words after a CASE opcode, and was never intended for
493 * instruction operands.
496 as_warn("Can't relocate expression");
500 /* Preserve the bits. */
501 if (expP
->X_add_number
> 0)
503 bignum_copy (generic_bignum
, expP
->X_add_number
,
504 floatP
->low
, SIZE_OF_LARGE_NUMBER
);
508 know (expP
->X_add_number
< 0);
509 flonum_copy (&generic_floating_point_number
,
511 if (strchr ("s i", operandP
->vop_short
))
512 { /* Could possibly become S^# */
513 flonum_gen2vax (-expP
->X_add_number
, floatP
, literal_float
);
514 switch (-expP
->X_add_number
)
518 (literal_float
[0] & 0xFC0F) == 0x4000
519 && literal_float
[1] == 0;
524 (literal_float
[0] & 0xFC0F) == 0x4000
525 && literal_float
[1] == 0
526 && literal_float
[2] == 0
527 && literal_float
[3] == 0;
532 (literal_float
[0] & 0xFF81) == 0x4000
533 && literal_float
[1] == 0
534 && literal_float
[2] == 0
535 && literal_float
[3] == 0;
540 (literal_float
[0] & 0xFFF8) == 0x4000
541 && (literal_float
[1] & 0xE000) == 0
542 && literal_float
[2] == 0
543 && literal_float
[3] == 0
544 && literal_float
[4] == 0
545 && literal_float
[5] == 0
546 && literal_float
[6] == 0
547 && literal_float
[7] == 0;
551 BAD_CASE (-expP
->X_add_number
);
553 } /* switch (float type) */
554 } /* if (could want to become S^#...) */
555 } /* bignum or flonum ? */
557 if (operandP
->vop_short
== 's'
558 || operandP
->vop_short
== 'i'
559 || (operandP
->vop_short
== ' '
560 && operandP
->vop_reg
== 0xF
561 && (operandP
->vop_mode
& 0xE) == 0x8))
564 if (operandP
->vop_short
== ' ')
565 { /* We must chose S^ or I^. */
566 if (expP
->X_add_number
> 0)
567 { /* Bignum: Short literal impossible. */
568 operandP
->vop_short
= 'i';
569 operandP
->vop_mode
= 8;
570 operandP
->vop_reg
= 0xF; /* VAX PC. */
573 { /* Flonum: Try to do it. */
576 operandP
->vop_short
= 's';
577 operandP
->vop_mode
= 0;
578 operandP
->vop_ndx
= -1;
579 operandP
->vop_reg
= -1;
580 /* JF hope this is the right thing */
581 expP
->X_seg
= SEG_ABSOLUTE
;
585 operandP
->vop_short
= 'i';
586 operandP
->vop_mode
= 8;
587 operandP
->vop_reg
= 0xF; /* VAX PC */
589 } /* bignum or flonum ? */
590 } /* if #, but no S^ or I^ seen. */
591 /* No more ' ' case: either 's' or 'i'. */
592 if (operandP
->vop_short
== 's')
594 /* Wants to be a short literal. */
595 if (expP
->X_add_number
> 0)
597 as_warn ("Bignum not permitted in short literal. Immediate mode assumed.");
598 operandP
->vop_short
= 'i';
599 operandP
->vop_mode
= 8;
600 operandP
->vop_reg
= 0xF; /* VAX PC. */
606 as_warn ("Can't do flonum short literal: immediate mode used.");
607 operandP
->vop_short
= 'i';
608 operandP
->vop_mode
= 8;
609 operandP
->vop_reg
= 0xF; /* VAX PC. */
612 { /* Encode short literal now. */
615 switch (-expP
->X_add_number
)
619 temp
= literal_float
[0] >> 4;
623 temp
= literal_float
[0] >> 1;
627 temp
= ((literal_float
[0] << 3) & 070)
628 | ((literal_float
[1] >> 13) & 07);
632 BAD_CASE (-expP
->X_add_number
);
636 floatP
->low
[0] = temp
& 077;
638 } /* if can be short literal float */
639 } /* flonum or bignum ? */
642 { /* I^# seen: set it up if float. */
643 if (expP
->X_add_number
< 0)
645 bcopy (literal_float
, floatP
->low
, sizeof (literal_float
));
651 as_warn ("A bignum/flonum may not be a displacement: 0x%x used",
652 expP
->X_add_number
= 0x80000000);
653 /* Chosen so luser gets the most offset bits to patch later. */
655 expP
->X_add_number
= floatP
->low
[0]
656 | ((LITTLENUM_MASK
& (floatP
->low
[1])) << LITTLENUM_NUMBER_OF_BITS
);
658 * For the SEG_BIG case we have:
659 * If vop_short == 's' then a short floating literal is in the
660 * lowest 6 bits of floatP -> low [0], which is
661 * big_operand_bits [---] [0].
662 * If vop_short == 'i' then the appropriate number of elements
663 * of big_operand_bits [---] [...] are set up with the correct
665 * Also, just in case width is byte word or long, we copy the lowest
666 * 32 bits of the number to X_add_number.
674 if (input_line_pointer
!= operandP
->vop_expr_end
+ 1)
676 as_warn ("Junk at end of expression \"%s\"", input_line_pointer
);
679 operandP
->vop_expr_end
[1] = c_save
;
681 } /* for(each operand) */
682 input_line_pointer
= save_input_line_pointer
;
684 if (!need_pass_2
&& !goofed
)
686 /* We saw no errors in any operands - try to make frag(s) */
687 int is_undefined
; /* True if operand expression's */
688 /* segment not known yet. */
692 /* Remember where it is, in case we want to modify the op-code later. */
693 opcode_low_byteP
= frag_more (v
.vit_opcode_nbytes
);
694 bcopy (v
.vit_opcode
, opcode_low_byteP
, v
.vit_opcode_nbytes
);
695 opcode_as_number
= md_chars_to_number (opcode_as_chars
= v
.vit_opcode
, 4);
696 for (operandP
= v
.vit_operand
,
697 expP
= exp_of_operand
,
698 floatP
= float_operand
,
699 end_operandP
= v
.vit_operand
+ v
.vit_operands
;
701 operandP
< end_operandP
;
706 ) /* for each operand */
708 if (operandP
->vop_ndx
>= 0)
710 /* indexed addressing byte */
711 /* Legality of indexed mode already checked: it is OK */
712 FRAG_APPEND_1_CHAR (0x40 + operandP
->vop_ndx
);
713 } /* if(vop_ndx>=0) */
715 /* Here to make main operand frag(s). */
716 this_add_number
= expP
->X_add_number
;
717 this_add_symbol
= expP
->X_add_symbol
;
718 this_subtract_symbol
= expP
->X_subtract_symbol
;
719 to_seg
= expP
->X_seg
;
720 is_undefined
= (to_seg
== SEG_UNKNOWN
);
721 know (to_seg
== SEG_UNKNOWN
722 ||to_seg
== SEG_ABSOLUTE
728 at
= operandP
->vop_mode
& 1;
729 length
= operandP
->vop_short
== 'b' ? 1 : operandP
->vop_short
== 'w' ? 2 : operandP
->vop_short
== 'l' ? 4 : 0;
730 nbytes
= operandP
->vop_nbytes
;
731 if (operandP
->vop_access
== 'b')
733 if (to_seg
== now_seg
|| is_undefined
)
734 { /* If is_undefined, then it might BECOME now_seg. */
737 p
= frag_more (nbytes
);
738 fix_new (frag_now
, p
- frag_now
->fr_literal
, nbytes
,
739 this_add_symbol
, 0, this_add_number
, 1);
742 { /* to_seg==now_seg || to_seg == SEG_UNKNOWN */
744 length_code
= is_undefined
? STATE_UNDF
: STATE_BYTE
;
745 if (opcode_as_number
& VIT_OPCODE_SPECIAL
)
747 if (operandP
->vop_width
== VAX_WIDTH_UNCONDITIONAL_JUMP
)
750 frag_var (rs_machine_dependent
, 5, 1,
751 ENCODE_RELAX (STATE_ALWAYS_BRANCH
, length_code
),
752 this_add_symbol
, this_add_number
,
757 if (operandP
->vop_width
== VAX_WIDTH_WORD_JUMP
)
759 length_code
= STATE_WORD
; /* JF: There is no state_byte for this one! */
760 frag_var (rs_machine_dependent
, 10, 2,
761 ENCODE_RELAX (STATE_COMPLEX_BRANCH
, length_code
),
762 this_add_symbol
, this_add_number
,
767 know (operandP
->vop_width
== VAX_WIDTH_BYTE_JUMP
);
768 frag_var (rs_machine_dependent
, 9, 1,
769 ENCODE_RELAX (STATE_COMPLEX_HOP
, length_code
),
770 this_add_symbol
, this_add_number
,
777 know (operandP
->vop_width
== VAX_WIDTH_CONDITIONAL_JUMP
);
778 frag_var (rs_machine_dependent
, 7, 1,
779 ENCODE_RELAX (STATE_CONDITIONAL_BRANCH
, length_code
),
780 this_add_symbol
, this_add_number
,
786 { /* to_seg != now_seg && to_seg != SEG_UNKNOWN */
788 * --- SEG FLOAT MAY APPEAR HERE ----
790 if (to_seg
== SEG_ABSOLUTE
)
794 know (!(opcode_as_number
& VIT_OPCODE_SYNTHETIC
));
795 p
= frag_more (nbytes
);
796 /* Conventional relocation. */
797 fix_new (frag_now
, p
- frag_now
->fr_literal
,
798 nbytes
, &abs_symbol
, 0, this_add_number
, 1);
802 know (opcode_as_number
& VIT_OPCODE_SYNTHETIC
);
803 if (opcode_as_number
& VIT_OPCODE_SPECIAL
)
805 if (operandP
->vop_width
== VAX_WIDTH_UNCONDITIONAL_JUMP
)
808 *opcode_low_byteP
= opcode_as_chars
[0] + VAX_WIDEN_LONG
;
809 know (opcode_as_chars
[1] == 0);
811 p
[0] = VAX_ABSOLUTE_MODE
; /* @#... */
812 md_number_to_chars (p
+ 1, this_add_number
, 4);
813 /* Now (eg) JMP @#foo or JSB @#foo. */
817 if (operandP
->vop_width
== VAX_WIDTH_WORD_JUMP
)
825 p
[5] = VAX_ABSOLUTE_MODE
; /* @#... */
826 md_number_to_chars (p
+ 6, this_add_number
, 4);
836 know (operandP
->vop_width
== VAX_WIDTH_BYTE_JUMP
);
842 p
[4] = VAX_PC_RELATIVE_MODE
+ 1; /* @#... */
843 md_number_to_chars (p
+ 5, this_add_number
, 4);
856 *opcode_low_byteP
^= 1; /* To reverse the condition in a VAX branch, complement the lowest order bit. */
860 p
[2] = VAX_ABSOLUTE_MODE
; /* @#... */
861 md_number_to_chars (p
+ 3, this_add_number
, 4);
871 { /* to_seg != now_seg && to_seg != SEG_UNKNOWN && to_Seg != SEG_ABSOLUTE */
874 /* Pc-relative. Conventional relocation. */
875 know (!(opcode_as_number
& VIT_OPCODE_SYNTHETIC
));
876 p
= frag_more (nbytes
);
877 fix_new (frag_now
, p
- frag_now
->fr_literal
,
878 nbytes
, &abs_symbol
, 0, this_add_number
, 1);
882 know (opcode_as_number
& VIT_OPCODE_SYNTHETIC
);
883 if (opcode_as_number
& VIT_OPCODE_SPECIAL
)
885 if (operandP
->vop_width
== VAX_WIDTH_UNCONDITIONAL_JUMP
)
888 know (opcode_as_chars
[1] == 0);
889 *opcode_low_byteP
= opcode_as_chars
[0] + VAX_WIDEN_LONG
;
891 p
[0] = VAX_PC_RELATIVE_MODE
;
893 p
+ 1 - frag_now
->fr_literal
, 4,
896 /* Now eg JMP foo or JSB foo. */
900 if (operandP
->vop_width
== VAX_WIDTH_WORD_JUMP
)
908 p
[5] = VAX_PC_RELATIVE_MODE
;
910 p
+ 6 - frag_now
->fr_literal
, 4,
922 know (operandP
->vop_width
== VAX_WIDTH_BYTE_JUMP
);
928 p
[4] = VAX_PC_RELATIVE_MODE
;
930 p
+ 5 - frag_now
->fr_literal
,
931 4, this_add_symbol
, 0,
944 know (operandP
->vop_width
== VAX_WIDTH_CONDITIONAL_JUMP
);
945 *opcode_low_byteP
^= 1; /* Reverse branch condition. */
949 p
[2] = VAX_PC_RELATIVE_MODE
;
950 fix_new (frag_now
, p
+ 3 - frag_now
->fr_literal
,
951 4, this_add_symbol
, 0,
960 know (operandP
->vop_access
!= 'b'); /* So it is ordinary operand. */
961 know (operandP
->vop_access
!= ' '); /* ' ' target-independent: elsewhere. */
962 know (operandP
->vop_access
== 'a' || operandP
->vop_access
== 'm' || operandP
->vop_access
== 'r' || operandP
->vop_access
== 'v' || operandP
->vop_access
== 'w');
963 if (operandP
->vop_short
== 's')
965 if (to_seg
== SEG_ABSOLUTE
)
967 if (this_add_number
< 0 || this_add_number
>= 64)
969 as_warn ("Short literal overflow(%d.), immediate mode assumed.", this_add_number
);
970 operandP
->vop_short
= 'i';
971 operandP
->vop_mode
= 8;
972 operandP
->vop_reg
= 0xF;
977 as_warn ("Forced short literal to immediate mode. now_seg=%s to_seg=%s", segment_name(now_seg
), segment_name(to_seg
));
978 operandP
->vop_short
= 'i';
979 operandP
->vop_mode
= 8;
980 operandP
->vop_reg
= 0xF;
983 if (operandP
->vop_reg
>= 0 && (operandP
->vop_mode
< 8 || (operandP
->vop_reg
!= 0xF && operandP
->vop_mode
< 10)))
984 { /* One byte operand. */
985 know (operandP
->vop_mode
> 3);
986 FRAG_APPEND_1_CHAR (operandP
->vop_mode
<< 4 | operandP
->vop_reg
);
987 /* All 1-bytes except S^# happen here. */
990 { /* {@}{q^}foo{(Rn)} or S^#foo */
991 if (operandP
->vop_reg
== -1 && operandP
->vop_short
!= 's')
993 if (to_seg
== now_seg
)
997 know (operandP
->vop_short
== ' ');
998 p
= frag_var (rs_machine_dependent
, 10, 2,
999 ENCODE_RELAX (STATE_PC_RELATIVE
, STATE_BYTE
),
1000 this_add_symbol
, this_add_number
,
1002 know (operandP
->vop_mode
== 10 + at
);
1004 /* At is the only context we need to carry to */
1005 /* other side of relax() process. */
1006 /* Must be in the correct bit position of VAX */
1007 /* operand spec. byte. */
1012 know (operandP
->vop_short
!= ' ');
1013 p
= frag_more (length
+ 1);
1014 /* JF is this array stuff really going to work? */
1015 p
[0] = 0xF | ((at
+ "?\12\14?\16"[length
]) << 4);
1016 fix_new (frag_now
, p
+ 1 - frag_now
->fr_literal
,
1017 length
, this_add_symbol
, 0,
1018 this_add_number
, 1);
1022 { /* to_seg != now_seg */
1023 if (this_add_symbol
== NULL
)
1025 know (to_seg
== SEG_ABSOLUTE
);
1026 /* Do @#foo: simpler relocation than foo-.(pc) anyway. */
1028 p
[0] = VAX_ABSOLUTE_MODE
; /* @#... */
1029 md_number_to_chars (p
+ 1, this_add_number
, 4);
1030 if (length
&& length
!= 4)
1032 as_warn ("Length specification ignored. Address mode 9F used");
1037 /* {@}{q^}other_seg */
1038 know ((length
== 0 && operandP
->vop_short
== ' ')
1039 ||(length
> 0 && operandP
->vop_short
!= ' '));
1043 * We have a SEG_UNKNOWN symbol. It might
1044 * turn out to be in the same segment as
1045 * the instruction, permitting relaxation.
1047 p
= frag_var (rs_machine_dependent
, 5, 2,
1048 ENCODE_RELAX (STATE_PC_RELATIVE
, STATE_UNDF
),
1049 this_add_symbol
, this_add_number
,
1057 know (operandP
->vop_short
== ' ');
1058 length
= 4; /* Longest possible. */
1060 p
= frag_more (length
+ 1);
1061 p
[0] = 0xF | ((at
+ "?\12\14?\16"[length
]) << 4);
1062 md_number_to_chars (p
+ 1, this_add_number
, length
);
1064 p
+ 1 - frag_now
->fr_literal
,
1065 length
, this_add_symbol
, 0,
1066 this_add_number
, 1);
1072 { /* {@}{q^}foo(Rn) or S^# or I^# or # */
1073 if (operandP
->vop_mode
< 0xA)
1074 { /* # or S^# or I^# */
1075 /* know( (length == 0 && operandP->vop_short == ' ')
1076 || (length > 0 && operandP->vop_short != ' ')); */
1078 && to_seg
== SEG_ABSOLUTE
1079 && operandP
->vop_mode
== 8 /* No '@'. */
1080 && this_add_number
< 64
1081 && this_add_number
>= 0)
1083 operandP
->vop_short
= 's';
1085 if (operandP
->vop_short
== 's')
1087 FRAG_APPEND_1_CHAR (this_add_number
);
1092 p
= frag_more (nbytes
+ 1);
1093 know (operandP
->vop_reg
== 0xF);
1094 p
[0] = (operandP
->vop_mode
<< 4) | 0xF;
1095 if (to_seg
== SEG_ABSOLUTE
)
1098 * If nbytes > 4, then we are scrod. We don't know if the
1099 * high order bytes are to be 0xFF or 0x00.
1100 * BSD4.2 & RMS say use 0x00. OK --- but this
1101 * assembler needs ANOTHER rewrite to
1102 * cope properly with this bug.
1104 md_number_to_chars (p
+ 1, this_add_number
, min (4, nbytes
));
1107 bzero (p
+ 5, nbytes
- 4);
1112 if (to_seg
== SEG_BIG
)
1115 * Problem here is to get the bytes in the right order.
1116 * We stored our constant as LITTLENUMs, not bytes.
1128 for (p
++; nbytes
; nbytes
-= 2, p
+= 2, lP
++)
1130 md_number_to_chars (p
, *lP
, 2);
1136 fix_new (frag_now
, p
+ 1 - frag_now
->fr_literal
,
1137 nbytes
, this_add_symbol
, 0,
1138 this_add_number
, 0);
1144 { /* {@}{q^}foo(Rn) */
1145 know ((length
== 0 && operandP
->vop_short
== ' ')
1146 ||(length
> 0 && operandP
->vop_short
!= ' '));
1149 if (to_seg
== SEG_ABSOLUTE
)
1153 test
= this_add_number
;
1158 length
= test
& 0xffff8000 ? 4
1159 : test
& 0xffffff80 ? 2
1167 p
= frag_more (1 + length
);
1168 know (operandP
->vop_reg
>= 0);
1169 p
[0] = operandP
->vop_reg
1170 | ((at
| "?\12\14?\16"[length
]) << 4);
1171 if (to_seg
== SEG_ABSOLUTE
)
1173 md_number_to_chars (p
+ 1, this_add_number
, length
);
1177 fix_new (frag_now
, p
+ 1 - frag_now
->fr_literal
,
1178 length
, this_add_symbol
, 0,
1179 this_add_number
, 0);
1183 } /* if(single-byte-operand) */
1185 } /* for(operandP) */
1186 } /* if(!need_pass_2&&!goofed) */
1187 } /* vax_assemble() */
1190 * md_estimate_size_before_relax()
1192 * Called just before relax().
1193 * Any symbol that is now undefined will not become defined.
1194 * Return the correct fr_subtype in the frag.
1195 * Return the initial "guess for fr_var" to caller.
1196 * The guess for fr_var is ACTUALLY the growth beyond fr_fix.
1197 * Whatever we do to grow fr_fix or fr_var contributes to our returned value.
1198 * Although it may not be explicit in the frag, pretend fr_var starts with a
1202 md_estimate_size_before_relax (fragP
, segment
)
1203 register fragS
*fragP
;
1204 register segT segment
;
1207 register int old_fr_fix
;
1209 old_fr_fix
= fragP
->fr_fix
;
1210 switch (fragP
->fr_subtype
)
1212 case ENCODE_RELAX (STATE_PC_RELATIVE
, STATE_UNDF
):
1213 if (S_GET_SEGMENT(fragP
->fr_symbol
) == segment
)
1214 { /* A relaxable case. */
1215 fragP
->fr_subtype
= ENCODE_RELAX (STATE_PC_RELATIVE
, STATE_BYTE
);
1219 p
= fragP
->fr_literal
+ old_fr_fix
;
1220 p
[0] |= VAX_PC_RELATIVE_MODE
; /* Preserve @ bit. */
1221 fragP
->fr_fix
+= 1 + 4;
1222 fix_new (fragP
, old_fr_fix
+ 1, 4, fragP
->fr_symbol
, 0,
1223 fragP
->fr_offset
, 1);
1228 case ENCODE_RELAX (STATE_CONDITIONAL_BRANCH
, STATE_UNDF
):
1229 if (S_GET_SEGMENT(fragP
->fr_symbol
) == segment
)
1231 fragP
->fr_subtype
= ENCODE_RELAX (STATE_CONDITIONAL_BRANCH
, STATE_BYTE
);
1235 p
= fragP
->fr_literal
+ old_fr_fix
;
1236 *fragP
->fr_opcode
^= 1; /* Reverse sense of branch. */
1239 p
[2] = VAX_PC_RELATIVE_MODE
; /* ...(PC) */
1240 fragP
->fr_fix
+= 1 + 1 + 1 + 4;
1241 fix_new (fragP
, old_fr_fix
+ 3, 4, fragP
->fr_symbol
, 0,
1242 fragP
->fr_offset
, 1);
1247 case ENCODE_RELAX (STATE_COMPLEX_BRANCH
, STATE_UNDF
):
1248 if (S_GET_SEGMENT(fragP
->fr_symbol
) == segment
)
1250 fragP
->fr_subtype
= ENCODE_RELAX (STATE_COMPLEX_BRANCH
, STATE_WORD
);
1254 p
= fragP
->fr_literal
+ old_fr_fix
;
1260 p
[5] = VAX_PC_RELATIVE_MODE
; /* ...(pc) */
1261 fragP
->fr_fix
+= 2 + 2 + 1 + 1 + 4;
1262 fix_new (fragP
, old_fr_fix
+ 6, 4, fragP
->fr_symbol
, 0,
1263 fragP
->fr_offset
, 1);
1268 case ENCODE_RELAX (STATE_COMPLEX_HOP
, STATE_UNDF
):
1269 if (S_GET_SEGMENT(fragP
->fr_symbol
) == segment
)
1271 fragP
->fr_subtype
= ENCODE_RELAX (STATE_COMPLEX_HOP
, STATE_BYTE
);
1275 p
= fragP
->fr_literal
+ old_fr_fix
;
1280 p
[4] = VAX_PC_RELATIVE_MODE
; /* ...(pc) */
1281 fragP
->fr_fix
+= 1 + 2 + 1 + 1 + 4;
1282 fix_new (fragP
, old_fr_fix
+ 5, 4, fragP
->fr_symbol
, 0,
1283 fragP
->fr_offset
, 1);
1288 case ENCODE_RELAX (STATE_ALWAYS_BRANCH
, STATE_UNDF
):
1289 if (S_GET_SEGMENT(fragP
->fr_symbol
) == segment
)
1291 fragP
->fr_subtype
= ENCODE_RELAX (STATE_ALWAYS_BRANCH
, STATE_BYTE
);
1295 p
= fragP
->fr_literal
+ old_fr_fix
;
1296 *fragP
->fr_opcode
+= VAX_WIDEN_LONG
;
1297 p
[0] = VAX_PC_RELATIVE_MODE
; /* ...(PC) */
1298 fragP
->fr_fix
+= 1 + 4;
1299 fix_new (fragP
, old_fr_fix
+ 1, 4, fragP
->fr_symbol
, 0,
1300 fragP
->fr_offset
, 1);
1308 return (fragP
->fr_var
+ fragP
->fr_fix
- old_fr_fix
);
1309 } /* md_estimate_size_before_relax() */
1312 * md_convert_frag();
1314 * Called after relax() is finished.
1315 * In: Address of frag.
1316 * fr_type == rs_machine_dependent.
1317 * fr_subtype is what the address relaxed to.
1319 * Out: Any fixSs and constants are set up.
1320 * Caller will turn frag into a ".space 0".
1323 md_convert_frag (headers
, fragP
)
1324 object_headers
*headers
;
1325 register fragS
*fragP
;
1327 register char *addressP
; /* -> _var to change. */
1328 register char *opcodeP
; /* -> opcode char(s) to change. */
1329 register short int length_code
; /* 2=long 1=word 0=byte */
1330 register short int extension
; /* Size of relaxed address. */
1331 /* Added to fr_fix: incl. ALL var chars. */
1332 register symbolS
*symbolP
;
1333 register long where
;
1334 register long address_of_var
;
1335 /* Where, in file space, is _var of *fragP? */
1336 register long target_address
;
1337 /* Where, in file space, does addr point? */
1339 know (fragP
->fr_type
== rs_machine_dependent
);
1340 length_code
= fragP
->fr_subtype
& 3; /* depends on ENCODE_RELAX() */
1341 know (length_code
>= 0 && length_code
< 3);
1342 where
= fragP
->fr_fix
;
1343 addressP
= fragP
->fr_literal
+ where
;
1344 opcodeP
= fragP
->fr_opcode
;
1345 symbolP
= fragP
->fr_symbol
;
1347 target_address
= symbolP
->sy_value
+ fragP
->fr_offset
;
1348 address_of_var
= fragP
->fr_address
+ where
;
1349 switch (fragP
->fr_subtype
)
1351 case ENCODE_RELAX (STATE_PC_RELATIVE
, STATE_BYTE
):
1352 know (*addressP
== 0 || *addressP
== 0x10); /* '@' bit. */
1353 addressP
[0] |= 0xAF; /* Byte displacement. */
1354 addressP
[1] = target_address
- (address_of_var
+ 2);
1358 case ENCODE_RELAX (STATE_PC_RELATIVE
, STATE_WORD
):
1359 know (*addressP
== 0 || *addressP
== 0x10); /* '@' bit. */
1360 addressP
[0] |= 0xCF; /* Word displacement. */
1361 md_number_to_chars (addressP
+ 1, target_address
- (address_of_var
+ 3), 2);
1365 case ENCODE_RELAX (STATE_PC_RELATIVE
, STATE_LONG
):
1366 know (*addressP
== 0 || *addressP
== 0x10); /* '@' bit. */
1367 addressP
[0] |= 0xEF; /* Long word displacement. */
1368 md_number_to_chars (addressP
+ 1, target_address
- (address_of_var
+ 5), 4);
1372 case ENCODE_RELAX (STATE_CONDITIONAL_BRANCH
, STATE_BYTE
):
1373 addressP
[0] = target_address
- (address_of_var
+ 1);
1377 case ENCODE_RELAX (STATE_CONDITIONAL_BRANCH
, STATE_WORD
):
1378 opcodeP
[0] ^= 1; /* Reverse sense of test. */
1380 addressP
[1] = VAX_BRB
+ VAX_WIDEN_WORD
;
1381 md_number_to_chars (addressP
+ 2, target_address
- (address_of_var
+ 4), 2);
1385 case ENCODE_RELAX (STATE_CONDITIONAL_BRANCH
, STATE_LONG
):
1386 opcodeP
[0] ^= 1; /* Reverse sense of test. */
1388 addressP
[1] = VAX_JMP
;
1389 addressP
[2] = VAX_PC_RELATIVE_MODE
;
1390 md_number_to_chars (addressP
+ 3, target_address
, 4);
1394 case ENCODE_RELAX (STATE_ALWAYS_BRANCH
, STATE_BYTE
):
1395 addressP
[0] = target_address
- (address_of_var
+ 1);
1399 case ENCODE_RELAX (STATE_ALWAYS_BRANCH
, STATE_WORD
):
1400 opcodeP
[0] += VAX_WIDEN_WORD
; /* brb -> brw, bsbb -> bsbw */
1401 md_number_to_chars (addressP
, target_address
- (address_of_var
+ 2), 2);
1405 case ENCODE_RELAX (STATE_ALWAYS_BRANCH
, STATE_LONG
):
1406 opcodeP
[0] += VAX_WIDEN_LONG
; /* brb -> jmp, bsbb -> jsb */
1407 addressP
[0] = VAX_PC_RELATIVE_MODE
;
1408 md_number_to_chars (addressP
+ 1, target_address
- (address_of_var
+ 5), 4);
1412 case ENCODE_RELAX (STATE_COMPLEX_BRANCH
, STATE_WORD
):
1413 md_number_to_chars (addressP
, target_address
- (address_of_var
+ 2), 2);
1417 case ENCODE_RELAX (STATE_COMPLEX_BRANCH
, STATE_LONG
):
1420 addressP
[2] = VAX_BRB
;
1422 addressP
[4] = VAX_JMP
;
1423 addressP
[5] = VAX_PC_RELATIVE_MODE
;
1424 md_number_to_chars (addressP
+ 6, target_address
, 4);
1428 case ENCODE_RELAX (STATE_COMPLEX_HOP
, STATE_BYTE
):
1429 addressP
[0] = target_address
- (address_of_var
+ 1);
1433 case ENCODE_RELAX (STATE_COMPLEX_HOP
, STATE_WORD
):
1435 addressP
[1] = VAX_BRB
;
1437 addressP
[3] = VAX_BRW
;
1438 md_number_to_chars (addressP
+ 4, target_address
- (address_of_var
+ 6), 2);
1442 case ENCODE_RELAX (STATE_COMPLEX_HOP
, STATE_LONG
):
1444 addressP
[1] = VAX_BRB
;
1446 addressP
[3] = VAX_JMP
;
1447 addressP
[4] = VAX_PC_RELATIVE_MODE
;
1448 md_number_to_chars (addressP
+ 5, target_address
, 4);
1453 BAD_CASE (fragP
->fr_subtype
);
1456 fragP
->fr_fix
+= extension
;
1459 /* Translate internal format of relocation info into target format.
1461 On vax: first 4 bytes are normal unsigned long, next three bytes
1462 are symbolnum, least sig. byte first. Last byte is broken up with
1463 the upper nibble as nuthin, bit 3 as extern, bits 2 & 1 as length, and
1466 md_ri_to_chars (the_bytes
, ri
)
1468 struct reloc_info_generic ri
;
1471 md_number_to_chars (the_bytes
, ri
.r_address
, sizeof (ri
.r_address
));
1472 /* now the fun stuff */
1473 the_bytes
[6] = (ri
.r_symbolnum
>> 16) & 0x0ff;
1474 the_bytes
[5] = (ri
.r_symbolnum
>> 8) & 0x0ff;
1475 the_bytes
[4] = ri
.r_symbolnum
& 0x0ff;
1476 the_bytes
[7] = (((ri
.r_extern
<< 3) & 0x08) | ((ri
.r_length
<< 1) & 0x06) |
1477 ((ri
.r_pcrel
<< 0) & 0x01)) & 0x0F;
1481 * BUGS, GRIPES, APOLOGIA, etc.
1483 * The opcode table 'votstrs' needs to be sorted on opcode frequency.
1484 * That is, AFTER we hash it with hash_...(), we want most-used opcodes
1485 * to come out of the hash table faster.
1487 * I am sorry to inflict
1488 * yet another VAX assembler on the world, but RMS says we must
1489 * do everything from scratch, to prevent pin-heads restricting
1494 * This is a vaguely modular set of routines in C to parse VAX
1495 * assembly code using DEC mnemonics. It is NOT un*x specific.
1497 * The idea here is that the assembler has taken care of all:
1504 * condensing any whitespace down to exactly one space
1505 * and all we have to do is parse 1 line into a vax instruction
1506 * partially formed. We will accept a line, and deliver:
1507 * an error message (hopefully empty)
1508 * a skeleton VAX instruction (tree structure)
1509 * textual pointers to all the operand expressions
1510 * a warning message that notes a silly operand (hopefully empty)
1514 * E D I T H I S T O R Y
1516 * 17may86 Dean Elsner. Bug if line ends immediately after opcode.
1517 * 30apr86 Dean Elsner. New vip_op() uses arg block so change call.
1518 * 6jan86 Dean Elsner. Crock vip_begin() to call vip_op_defaults().
1519 * 2jan86 Dean Elsner. Invent synthetic opcodes.
1520 * Widen vax_opcodeT to 32 bits. Use a bit for VIT_OPCODE_SYNTHETIC,
1521 * which means this is not a real opcode, it is like a macro; it will
1522 * be relax()ed into 1 or more instructions.
1523 * Use another bit for VIT_OPCODE_SPECIAL if the op-code is not optimised
1524 * like a regular branch instruction. Option added to vip_begin():
1525 * exclude synthetic opcodes. Invent synthetic_votstrs[].
1526 * 31dec85 Dean Elsner. Invent vit_opcode_nbytes.
1527 * Also make vit_opcode into a char[]. We now have n-byte vax opcodes,
1528 * so caller's don't have to know the difference between a 1-byte & a
1529 * 2-byte op-code. Still need vax_opcodeT concept, so we know how
1530 * big an object must be to hold an op.code.
1531 * 30dec85 Dean Elsner. Widen typedef vax_opcodeT in "vax-inst.h"
1532 * because vax opcodes may be 16 bits. Our crufty C compiler was
1533 * happily initialising 8-bit vot_codes with 16-bit numbers!
1534 * (Wouldn't the 'phone company like to compress data so easily!)
1535 * 29dec85 Dean Elsner. New static table vax_operand_width_size[].
1536 * Invented so we know hw many bytes a "I^#42" needs in its immediate
1537 * operand. Revised struct vop in "vax-inst.h": explicitly include
1538 * byte length of each operand, and it's letter-code datum type.
1539 * 17nov85 Dean Elsner. Name Change.
1540 * Due to ar(1) truncating names, we learned the hard way that
1541 * "vax-inst-parse.c" -> "vax-inst-parse." dropping the "o" off
1542 * the archived object name. SO... we shortened the name of this
1543 * source file, and changed the makefile.
1546 static char *op_hash
= NULL
; /* handle of the OPCODE hash table */
1547 /* NULL means any use before vip_begin() */
1551 * In: 1 character, from "bdfghloqpw" being the data-type of an operand
1552 * of a vax instruction.
1554 * Out: the length of an operand of that type, in bytes.
1555 * Special branch operands types "-?!" have length 0.
1558 static const short int vax_operand_width_size
[256] =
1562 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
,
1563 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
,
1564 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
,
1565 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
,
1566 _
, _
, 1, _
, 8, _
, 4, 8, 16, _
, _
, _
, 4, _
, _
, 16, /* ..b.d.fgh...l..o */
1567 _
, 8, _
, _
, _
, _
, _
, 2, _
, _
, _
, _
, _
, _
, _
, _
, /* .q.....w........ */
1568 _
, _
, 1, _
, 8, _
, 4, 8, 16, _
, _
, _
, 4, _
, _
, 16, /* ..b.d.fgh...l..o */
1569 _
, 8, _
, _
, _
, _
, _
, 2, _
, _
, _
, _
, _
, _
, _
, _
, /* .q.....w........ */
1570 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
,
1571 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
,
1572 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
,
1573 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
,
1574 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
,
1575 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
,
1576 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
,
1577 _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
, _
};
1581 * This perversion encodes all the vax opcodes as a bunch of strings.
1582 * RMS says we should build our hash-table at run-time. Hmm.
1583 * Please would someone arrange these in decreasing frequency of opcode?
1584 * Because of the way hash_...() works, the most frequently used opcode
1585 * should be textually first and so on.
1587 * Input for this table was 'vax.opcodes', awk(1)ed by 'vax.opcodes.c.awk' .
1588 * So change 'vax.opcodes', then re-generate this table.
1591 #include "opcode/vax.h"
1594 * This is a table of optional op-codes. All of them represent
1595 * 'synthetic' instructions that seem popular.
1597 * Here we make some pseudo op-codes. Every code has a bit set to say
1598 * it is synthetic. This lets you catch them if you want to
1599 * ban these opcodes. They are mnemonics for "elastic" instructions
1600 * that are supposed to assemble into the fewest bytes needed to do a
1601 * branch, or to do a conditional branch, or whatever.
1603 * The opcode is in the usual place [low-order n*8 bits]. This means
1604 * that if you mask off the bucky bits, the usual rules apply about
1605 * how long the opcode is.
1607 * All VAX branch displacements come at the end of the instruction.
1608 * For simple branches (1-byte opcode + 1-byte displacement) the last
1609 * operand is coded 'b?' where the "data type" '?' is a clue that we
1610 * may reverse the sense of the branch (complement lowest order bit)
1611 * and branch around a jump. This is by far the most common case.
1612 * That is why the VIT_OPCODE_SYNTHETIC bit is set: it says this is
1613 * a 0-byte op-code followed by 2 or more bytes of operand address.
1615 * If the op-code has VIT_OPCODE_SPECIAL set, then we have a more unusual
1618 * For JBSB & JBR the treatment is the similar, except (1) we have a 'bw'
1619 * option before (2) we can directly JSB/JMP because there is no condition.
1620 * These operands have 'b-' as their access/data type.
1622 * That leaves a bunch of random opcodes: JACBx, JxOBxxx. In these
1623 * cases, we do the same idea. JACBxxx are all marked with a 'b!'
1624 * JAOBxxx & JSOBxxx are marked with a 'b:'.
1627 #if (VIT_OPCODE_SYNTHETIC != 0x80000000)
1628 You have just broken the encoding below
, which assumes the sign bit
1629 means
'I am an imaginary instruction'.
1632 #if (VIT_OPCODE_SPECIAL != 0x40000000)
1633 You have just broken the encoding below
, which assumes the
0x40 M bit means
1634 'I am not to be "optimised" the way normal branches are'.
1637 static const struct vot
1638 synthetic_votstrs
[] =
1641 {"b-", 0xC0000010}}, /* BSD 4.2 */
1642 /* jsb used already */
1644 {"b-", 0xC0000011}}, /* BSD 4.2 */
1646 {"b-", 0xC0000011}}, /* consistent */
1648 {"b?", 0x80000012}},
1650 {"b?", 0x80000012}},
1652 {"b?", 0x80000013}},
1654 {"b?", 0x80000013}},
1656 {"b?", 0x80000014}},
1658 {"b?", 0x80000015}},
1659 /* un-used opcodes here */
1661 {"b?", 0x80000018}},
1663 {"b?", 0x80000019}},
1665 {"b?", 0x8000001a}},
1667 {"b?", 0x8000001b}},
1669 {"b?", 0x8000001c}},
1671 {"b?", 0x8000001d}},
1673 {"b?", 0x8000001e}},
1675 {"b?", 0x8000001e}},
1677 {"b?", 0x8000001f}},
1679 {"b?", 0x8000001f}},
1682 {"rwrwmwb!", 0xC000003d}},
1684 {"rfrfmfb!", 0xC000004f}},
1686 {"rdrdmdb!", 0xC000006f}},
1688 {"rbrbmbb!", 0xC000009d}},
1690 {"rlrlmlb!", 0xC00000f1}},
1692 {"rgrgmgb!", 0xC0004ffd}},
1694 {"rhrhmhb!", 0xC0006ffd}},
1697 {"rlvbb?", 0x800000e0}},
1699 {"rlvbb?", 0x800000e1}},
1701 {"rlvbb?", 0x800000e2}},
1703 {"rlvbb?", 0x800000e3}},
1705 {"rlvbb?", 0x800000e4}},
1707 {"rlvbb?", 0x800000e5}},
1709 {"rlvbb?", 0x800000e6}},
1711 {"rlvbb?", 0x800000e7}},
1713 {"rlb?", 0x800000e8}}, /* JF changed from rlvbb? */
1715 {"rlb?", 0x800000e9}}, /* JF changed from rlvbb? */
1718 {"rlmlb:", 0xC00000f2}},
1720 {"rlmlb:", 0xC00000f3}},
1722 {"mlb:", 0xC00000f4}}, /* JF was rlmlb: */
1724 {"mlb:", 0xC00000f5}}, /* JF was rlmlb: */
1726 /* CASEx has no branch addresses in our conception of it. */
1727 /* You should use ".word ..." statements after the "case ...". */
1729 {"", ""} /* empty is end sentinel */
1731 }; /* synthetic_votstrs */
1734 * v i p _ b e g i n ( )
1736 * Call me once before you decode any lines.
1737 * I decode votstrs into a hash table at op_hash (which I create).
1738 * I return an error text: hopefully "".
1739 * If you want, I will include the 'synthetic' jXXX instructions in the
1740 * instruction table.
1741 * You must nominate metacharacters for eg DEC's "#", "@", "^".
1745 vip_begin (synthetic_too
, immediate
, indirect
, displen
)
1746 int synthetic_too
; /* TRUE means include jXXX op-codes. */
1747 char *immediate
, *indirect
, *displen
;
1749 register const struct vot
*vP
; /* scan votstrs */
1750 register char *retval
; /* error text */
1752 char *hash_insert (); /* */
1753 char *hash_new (); /* lies */
1755 if ((op_hash
= hash_new ()))
1757 retval
= ""; /* OK so far */
1758 for (vP
= votstrs
; *vP
->vot_name
&& !*retval
; vP
++)
1760 retval
= hash_insert (op_hash
, vP
->vot_name
, &vP
->vot_detail
);
1764 for (vP
= synthetic_votstrs
; *vP
->vot_name
&& !*retval
; vP
++)
1766 retval
= hash_insert (op_hash
, vP
->vot_name
, &vP
->vot_detail
);
1772 retval
= "virtual memory exceeded";
1775 vip_op_defaults (immediate
, indirect
, displen
);
1785 * Call me once after you have decoded all lines.
1786 * I do any cleaning-up needed.
1788 * We don't have to do any cleanup ourselves: all of our operand
1789 * symbol table is static, and free()ing it is naughty.
1798 * This converts a string into a vax instruction.
1799 * The string must be a bare single instruction in dec-vax (with BSD4 frobs)
1801 * It provides some error messages: at most one fatal error message (which
1802 * stops the scan) and at most one warning message for each operand.
1803 * The vax instruction is returned in exploded form, since we have no
1804 * knowledge of how you parse (or evaluate) your expressions.
1805 * We do however strip off and decode addressing modes and operation
1808 * The exploded instruction is returned to a struct vit of your choice.
1809 * #include "vax-inst.h" to know what a struct vit is.
1811 * This function's value is a string. If it is not "" then an internal
1812 * logic error was found: read this code to assign meaning to the string.
1813 * No argument string should generate such an error string:
1814 * it means a bug in our code, not in the user's text.
1816 * You MUST have called vip_begin() once and vip_end() never before using
1820 char * /* "" or bug string */
1821 vip (vitP
, instring
)
1822 struct vit
*vitP
; /* We build an exploded instruction here. */
1823 char *instring
; /* Text of a vax instruction: we modify. */
1825 register struct vot_wot
*vwP
; /* How to bit-encode this opcode. */
1826 register char *p
; /* 1/skip whitespace.2/scan vot_how */
1827 register char *q
; /* */
1828 register char *bug
; /* "" or program logic error */
1829 register unsigned char count
; /* counts number of operands seen */
1830 register struct vop
*operandp
;/* scan operands in struct vit */
1831 register char *alloperr
; /* error over all operands */
1832 register char c
; /* Remember char, (we clobber it */
1833 /* with '\0' temporarily). */
1834 register vax_opcodeT oc
; /* Op-code of this instruction. */
1836 struct vot_wot
*hash_find ();
1840 if (*instring
== ' ')
1841 ++instring
; /* Skip leading whitespace. */
1842 for (p
= instring
; *p
&& *p
!= ' '; p
++)
1843 ; /* MUST end in end-of-string or exactly 1 space. */
1844 /* Scanned up to end of operation-code. */
1845 /* Operation-code is ended with whitespace. */
1846 if (p
- instring
== 0)
1848 vitP
->vit_error
= "No operator";
1850 bzero (vitP
->vit_opcode
, sizeof (vitP
->vit_opcode
));
1857 * Here with instring pointing to what better be an op-name, and p
1858 * pointing to character just past that.
1859 * We trust instring points to an op-name, with no whitespace.
1861 vwP
= hash_find (op_hash
, instring
);
1862 *p
= c
; /* Restore char after op-code. */
1865 vitP
->vit_error
= "Unknown operator";
1867 bzero (vitP
->vit_opcode
, sizeof (vitP
->vit_opcode
));
1872 * We found a match! So lets pick up as many operands as the
1873 * instruction wants, and even gripe if there are too many.
1874 * We expect comma to seperate each operand.
1875 * We let instring track the text, while p tracks a part of the
1879 * The lines below know about 2-byte opcodes starting FD,FE or FF.
1880 * They also understand synthetic opcodes. Note:
1881 * we return 32 bits of opcode, including bucky bits, BUT
1882 * an opcode length is either 8 or 16 bits for vit_opcode_nbytes.
1884 oc
= vwP
->vot_code
; /* The op-code. */
1885 vitP
->vit_opcode_nbytes
= (oc
& 0xFF) >= 0xFD ? 2 : 1;
1886 md_number_to_chars (vitP
->vit_opcode
, oc
, 4);
1887 count
= 0; /* no operands seen yet */
1888 instring
= p
; /* point just past operation code */
1890 for (p
= vwP
->vot_how
, operandp
= vitP
->vit_operand
;
1891 !*alloperr
&& !*bug
&& *p
;
1896 * Here to parse one operand. Leave instring pointing just
1897 * past any one ',' that marks the end of this operand.
1900 bug
= "p"; /* ODD(!!) number of bytes in vot_how?? */
1903 for (q
= instring
; (c
= *q
) && c
!= ','; q
++)
1906 * Q points to ',' or '\0' that ends argument. C is that
1910 operandp
->vop_width
= p
[1];
1911 operandp
->vop_nbytes
= vax_operand_width_size
[p
[1]];
1912 operandp
->vop_access
= p
[0];
1913 bug
= vip_op (instring
, operandp
);
1914 *q
= c
; /* Restore input text. */
1915 if (*(operandp
->vop_error
))
1916 alloperr
= "Bad operand";
1917 instring
= q
+ (c
? 1 : 0); /* next operand (if any) */
1918 count
++; /* won another argument, may have an operr */
1921 alloperr
= "Not enough operands";
1925 if (*instring
== ' ')
1926 instring
++; /* Skip whitespace. */
1928 alloperr
= "Too many operands";
1930 vitP
->vit_error
= alloperr
;
1933 vitP
->vit_operands
= count
;
1940 * Test program for above.
1943 struct vit myvit
; /* build an exploded vax instruction here */
1944 char answer
[100]; /* human types a line of vax assembler here */
1945 char *mybug
; /* "" or an internal logic diagnostic */
1946 int mycount
; /* number of operands */
1947 struct vop
*myvop
; /* scan operands from myvit */
1948 int mysynth
; /* TRUE means want synthetic opcodes. */
1949 char my_immediate
[200];
1950 char my_indirect
[200];
1951 char my_displen
[200];
1960 printf ("0 means no synthetic instructions. ");
1961 printf ("Value for vip_begin? ");
1963 sscanf (answer
, "%d", &mysynth
);
1964 printf ("Synthetic opcodes %s be included.\n", mysynth
? "will" : "will not");
1965 printf ("enter immediate symbols eg enter # ");
1966 gets (my_immediate
);
1967 printf ("enter indirect symbols eg enter @ ");
1969 printf ("enter displen symbols eg enter ^ ");
1971 if (*(p
= vip_begin (mysynth
, my_immediate
, my_indirect
, my_displen
)))
1973 error ("vip_begin=%s", p
);
1975 printf ("An empty input line will quit you from the vax instruction parser\n");
1978 printf ("vax instruction: ");
1983 break; /* out of for each input text loop */
1985 mybug
= vip (&myvit
, answer
);
1988 printf ("BUG:\"%s\"\n", mybug
);
1990 if (*myvit
.vit_error
)
1992 printf ("ERR:\"%s\"\n", myvit
.vit_error
);
1995 for (mycount
= myvit
.vit_opcode_nbytes
, p
= myvit
.vit_opcode
;
2000 printf ("%02x ", *p
& 0xFF);
2002 printf (" operand count=%d.\n", mycount
= myvit
.vit_operands
);
2003 for (myvop
= myvit
.vit_operand
; mycount
; mycount
--, myvop
++)
2005 printf ("mode=%xx reg=%xx ndx=%xx len='%c'=%c%c%d. expr=\"",
2006 myvop
->vop_mode
, myvop
->vop_reg
, myvop
->vop_ndx
,
2007 myvop
->vop_short
, myvop
->vop_access
, myvop
->vop_width
,
2009 for (p
= myvop
->vop_expr_begin
; p
<= myvop
->vop_expr_end
; p
++)
2014 if (*myvop
->vop_error
)
2016 printf (" err:\"%s\"\n", myvop
->vop_error
);
2018 if (*myvop
->vop_warn
)
2020 printf (" wrn:\"%s\"\n", myvop
->vop_warn
);
2028 #endif /* #ifdef test */
2030 /* end of vax_ins_parse.c */
2032 /* JF this used to be a separate file also */
2033 /* vax_reg_parse.c - convert a VAX register name to a number */
2035 /* Copyright (C) 1987 Free Software Foundation, Inc. A part of GNU. */
2038 * v a x _ r e g _ p a r s e ( )
2040 * Take 3 char.s, the last of which may be `\0` (non-existent)
2041 * and return the VAX register number that they represent.
2043 * Return -1 if they don't form a register name. Good names return
2044 * a number from 0:15 inclusive.
2046 * Case is not important in a name.
2048 * Register names understood are:
2075 int /* return -1 or 0:15 */
2076 vax_reg_parse (c1
, c2
, c3
) /* 3 chars of register name */
2077 char c1
, c2
, c3
; /* c3 == 0 if 2-character reg name */
2079 register int retval
; /* return -1:15 */
2087 if (isdigit (c2
) && c1
== 'r')
2092 retval
= retval
* 10 + c3
- '0';
2093 retval
= (retval
> 15) ? -1 : retval
;
2094 /* clamp the register value to 1 hex digit */
2097 retval
= -1; /* c3 must be '\0' or a digit */
2099 else if (c3
) /* There are no three letter regs */
2118 else if (c1
== 'p' && c2
== 'c')
2128 * Parse a vax operand in DEC assembler notation.
2129 * For speed, expect a string of whitespace to be reduced to a single ' '.
2130 * This is the case for GNU AS, and is easy for other DEC-compatible
2133 * Knowledge about DEC VAX assembler operand notation lives here.
2134 * This doesn't even know what a register name is, except it believes
2135 * all register names are 2 or 3 characters, and lets vax_reg_parse() say
2136 * what number each name represents.
2137 * It does, however, know that PC, SP etc are special registers so it can
2138 * detect addressing modes that are silly for those registers.
2140 * Where possible, it delivers 1 fatal or 1 warning message if the operand
2141 * is suspect. Exactly what we test for is still evolving.
2149 * There were a number of 'mismatched argument type' bugs to vip_op.
2150 * The most general solution is to typedef each (of many) arguments.
2151 * We used instead a typedef'd argument block. This is less modular
2152 * than using seperate return pointers for each result, but runs faster
2153 * on most engines, and seems to keep programmers happy. It will have
2154 * to be done properly if we ever want to use vip_op as a general-purpose
2155 * module (it was designed to be).
2159 * Doesn't support DEC "G^" format operands. These always take 5 bytes
2160 * to express, and code as modes 8F or 9F. Reason: "G^" deprives you of
2161 * optimising to (say) a "B^" if you are lucky in the way you link.
2162 * When someone builds a linker smart enough to convert "G^" to "B^", "W^"
2163 * whenever possible, then we should implement it.
2164 * If there is some other use for "G^", feel free to code it in!
2169 * If I nested if()s more, I could avoid testing (*err) which would save
2170 * time, space and page faults. I didn't nest all those if()s for clarity
2171 * and because I think the mode testing can be re-arranged 1st to test the
2172 * commoner constructs 1st. Does anybody have statistics on this?
2178 * In future, we should be able to 'compose' error messages in a scratch area
2179 * and give the user MUCH more informative error messages. Although this takes
2180 * a little more code at run-time, it will make this module much more self-
2181 * documenting. As an example of what sucks now: most error messages have
2182 * hardwired into them the DEC VAX metacharacters "#^@" which are nothing like
2183 * the Un*x characters "$`*", that most users will expect from this AS.
2187 * The input is a string, ending with '\0'.
2189 * We also require a 'hint' of what kind of operand is expected: so
2190 * we can remind caller not to write into literals for instance.
2192 * The output is a skeletal instruction.
2194 * The algorithm has two parts.
2195 * 1. extract the syntactic features (parse off all the @^#-()+[] mode crud);
2196 * 2. express the @^#-()+[] as some parameters suited to further analysis.
2198 * 2nd step is where we detect the googles of possible invalid combinations
2199 * a human (or compiler) might write. Note that if we do a half-way
2200 * decent assembler, we don't know how long to make (eg) displacement
2201 * fields when we first meet them (because they may not have defined values).
2202 * So we must wait until we know how many bits are needed for each address,
2203 * then we can know both length and opcodes of instructions.
2204 * For reason(s) above, we will pass to our caller a 'broken' instruction
2205 * of these major components, from which our caller can generate instructions:
2206 * - displacement length I^ S^ L^ B^ W^ unspecified
2208 * - register R0-R15 or absent
2209 * - index register R0-R15 or absent
2210 * - expression text what we don't parse
2211 * - error text(s) why we couldn't understand the operand
2215 * To decode output of this, test errtxt. If errtxt[0] == '\0', then
2216 * we had no errors that prevented parsing. Also, if we ever report
2217 * an internal bug, errtxt[0] is set non-zero. So one test tells you
2218 * if the other outputs are to be taken seriously.
2222 /* vax registers we need to know */
2223 /* JF #define SP (14)
2224 /* JF for one big happy file #define PC (15) */
2227 /* #define TRUE (1) */
2228 /* #define FALSE (0) */
2231 * Because this module is useful for both VMS and UN*X style assemblers
2232 * and because of the variety of UN*X assemblers we must recognise
2233 * the different conventions for assembler operand notation. For example
2234 * VMS says "#42" for immediate mode, while most UN*X say "$42".
2235 * We permit arbitrary sets of (single) characters to represent the
2236 * 3 concepts that DEC writes '#', '@', '^'.
2239 /* character tests */
2240 #define VIP_IMMEDIATE 01 /* Character is like DEC # */
2241 #define VIP_INDIRECT 02 /* Char is like DEC @ */
2242 #define VIP_DISPLEN 04 /* Char is like DEC ^ */
2244 #define IMMEDIATEP(c) (vip_metacharacters [(c)&0xff]&VIP_IMMEDIATE)
2245 #define INDIRECTP(c) (vip_metacharacters [(c)&0xff]&VIP_INDIRECT)
2246 #define DISPLENP(c) (vip_metacharacters [(c)&0xff]&VIP_DISPLEN)
2248 /* We assume 8 bits per byte. Use vip_op_defaults() to set these up BEFORE we
2252 #if defined(CONST_TABLE)
2254 #define I VIP_IMMEDIATE,
2255 #define S VIP_INDIRECT,
2256 #define D VIP_DISPLEN,
2258 vip_metacharacters
[256] = {
2259 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
/*^@ ^A ^B ^C ^D ^E ^F ^G ^H ^I ^J ^K ^L ^M ^N ^O*/
2260 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
/*^P ^Q ^R ^S ^T ^U ^V ^W ^X ^Y ^Z ^[ ^\ ^] ^^ ^_*/
2261 _ _ _ _ I _ _ _ _ _ S _ _ _ _ _
/*sp ! " # $ % & ' ( ) * + , - . /*/
2262 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _/*0 1 2 3 4 5 6 7 8 9 : ; < = > ?*/
2263 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
/*@ A B C D E F G H I J K L M N O*/
2264 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
/*P Q R S T U V W X Y Z [ \ ] ^ _*/
2265 D _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
/*` a b c d e f g h i j k l m n o*/
2266 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
/*p q r s t u v w x y z { | } ~ ^?*/
2268 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
2269 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
2270 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
2271 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
2272 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
2273 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
2274 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
2275 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
2282 static char vip_metacharacters
[256];
2284 /* Macro is faster under GCC; The constant table is faster yet, but only works with ASCII */
2298 vip_metacharacters
[t
]|=bit
;
2301 #define vip_op_1(bit,syms) { \
2303 char *table=vip_metacharacters; \
2309 vip_op_defaults (immediate
, indirect
, displen
) /* can be called any time */
2310 char *immediate
, /* Strings of characters for each job. */
2311 *indirect
, *displen
; /* more arguments may appear in future! */
2313 vip_op_1 (VIP_IMMEDIATE
, immediate
);
2314 vip_op_1 (VIP_INDIRECT
, indirect
);
2315 vip_op_1 (VIP_DISPLEN
, displen
);
2321 * Dec defines the semantics of address modes (and values)
2322 * by a two-letter code, explained here.
2324 * letter 1: access type
2326 * a address calculation - no data access, registers forbidden
2327 * b branch displacement
2328 * m read - let go of bus - write back "modify"
2330 * v bit field address: like 'a' but registers are OK
2332 * space no operator (eg ".long foo") [our convention]
2334 * letter 2: data type (i.e. width, alignment)
2337 * d double precision floating point (D format)
2338 * f single precision floating point (F format)
2339 * g G format floating
2340 * h H format floating
2345 * ? simple synthetic branch operand
2346 * - unconditional synthetic JSB/JSR operand
2347 * ! complex synthetic branch operand
2349 * The '-?!' letter 2's are not for external consumption. They are used
2350 * for various assemblers. Generally, all unknown widths are assumed 0.
2351 * We don't limit your choice of width character.
2353 * DEC operands are hard work to parse. For example, '@' as the first
2354 * character means indirect (deferred) mode but elswhere it is a shift
2356 * The long-winded explanation of how this is supposed to work is
2357 * cancelled. Read a DEC vax manual.
2358 * We try hard not to parse anything that MIGHT be part of the expression
2359 * buried in that syntax. For example if we see @...(Rn) we don't check
2360 * for '-' before the '(' because mode @-(Rn) does not exist.
2362 * After parsing we have:
2364 * at TRUE if leading '@' (or Un*x '*')
2365 * len takes one value from " bilsw". eg B^ -> 'b'.
2366 * hash TRUE if leading '#' (or Un*x '$')
2367 * expr_begin, expr_end the expression we did not parse
2368 * even though we don't interpret it, we make use
2369 * of its presence or absence.
2370 * sign -1: -(Rn) 0: absent +1: (Rn)+
2371 * paren TRUE if () are around register
2372 * reg major register number 0:15 -1 means absent
2373 * ndx index register number 0:15 -1 means absent
2375 * Again, I dare not explain it: just trace ALL the code!
2378 char * /* (code here) bug message, "" = OK */
2379 /* our code bug, NOT bad assembly language */
2380 vip_op (optext
, vopP
)
2381 char *optext
; /* user's input string e.g.: */
2382 /* "@B^foo@bar(AP)[FP]:" */
2383 struct vop
*vopP
; /* In: vop_access, vop_width. */
2384 /* Out: _ndx, _reg, _mode, _short, _warn, */
2385 /* _error _expr_begin, _expr_end, _nbytes. */
2386 /* vop_nbytes : number of bytes in a datum. */
2388 char *p
; /* track operand text forward */
2389 char *q
; /* track operand text backward */
2390 int at
; /* TRUE if leading '@' ('*') seen */
2391 char len
; /* one of " bilsw" */
2392 int hash
; /* TRUE if leading '#' ('$') seen */
2393 int sign
; /* -1, 0 or +1 */
2394 int paren
; /* TRUE if () surround register */
2395 int reg
; /* register number, -1:absent */
2396 int ndx
; /* index register number -1:absent */
2397 char *bug
; /* report any logic error in here, ""==OK */
2398 char *err
; /* report illegal operand, ""==OK */
2399 /* " " is a FAKE error: means we won */
2400 /* ANY err that begins with ' ' is a fake. */
2401 /* " " is converted to "" before return */
2402 char *wrn
; /* warn about weird modes pf address */
2403 char *oldq
; /* preserve q in case we backup */
2404 int mode
; /* build up 4-bit operand mode here */
2405 /* note: index mode is in ndx, this is */
2406 /* the major mode of operand address */
2408 * Notice how we move wrong-arg-type bugs INSIDE this module: if we
2409 * get the types wrong below, we lose at compile time rather than at
2412 char access
; /* vop_access. */
2413 char width
; /* vop_width. */
2415 int vax_reg_parse (); /* returns 0:15 or -1 if not a register */
2417 access
= vopP
->vop_access
;
2418 width
= vopP
->vop_width
;
2419 bug
= /* none of our code bugs (yet) */
2420 err
= /* no user text errors */
2421 wrn
= ""; /* no warnings even */
2425 if (*p
== ' ') /* Expect all whitespace reduced to ' '. */
2426 p
++; /* skip over whitespace */
2428 if (at
= INDIRECTP (*p
))
2429 { /* TRUE if *p=='@'(or '*' for Un*x) */
2430 p
++; /* at is determined */
2431 if (*p
== ' ') /* Expect all whitespace reduced to ' '. */
2432 p
++; /* skip over whitespace */
2436 * This code is subtle. It tries to detect all legal (letter)'^'
2437 * but it doesn't waste time explicitly testing for premature '\0' because
2438 * this case is rejected as a mismatch against either (letter) or '^'.
2446 if (DISPLENP (p
[1]) && strchr ("bilws", len
= c
))
2447 p
+= 2; /* skip (letter) '^' */
2448 else /* no (letter) '^' seen */
2449 len
= ' '; /* len is determined */
2452 if (*p
== ' ') /* Expect all whitespace reduced to ' '. */
2453 p
++; /* skip over whitespace */
2455 if (hash
= IMMEDIATEP (*p
)) /* TRUE if *p=='#' ('$' for Un*x) */
2456 p
++; /* hash is determined */
2459 * p points to what may be the beginning of an expression.
2460 * We have peeled off the front all that is peelable.
2461 * We know at, len, hash.
2463 * Lets point q at the end of the text and parse that (backwards).
2466 for (q
= p
; *q
; q
++)
2468 q
--; /* now q points at last char of text */
2470 if (*q
== ' ' && q
>= p
) /* Expect all whitespace reduced to ' '. */
2472 /* reverse over whitespace, but don't */
2473 /* run back over *p */
2476 * As a matter of policy here, we look for [Rn], although both Rn and S^#
2477 * forbid [Rn]. This is because it is easy, and because only a sick
2478 * cyborg would have [...] trailing an expression in a VAX-like assembler.
2479 * A meticulous parser would first check for Rn followed by '(' or '['
2480 * and not parse a trailing ']' if it found another. We just ban expressions
2485 while (q
>= p
&& *q
!= '[')
2487 /* either q<p or we got matching '[' */
2489 err
= "no '[' to match ']'";
2493 * Confusers like "[]" will eventually lose with a bad register
2494 * name error. So again we don't need to check for early '\0'.
2497 ndx
= vax_reg_parse (q
[1], q
[2], 0);
2498 else if (q
[4] == ']')
2499 ndx
= vax_reg_parse (q
[1], q
[2], q
[3]);
2503 * Since we saw a ']' we will demand a register name in the [].
2504 * If luser hasn't given us one: be rude.
2507 err
= "bad register in []";
2509 err
= "[PC] index banned";
2511 q
--; /* point q just before "[...]" */
2515 ndx
= -1; /* no ']', so no iNDeX register */
2518 * If err = "..." then we lost: run away.
2519 * Otherwise ndx == -1 if there was no "[...]".
2520 * Otherwise, ndx is index register number, and q points before "[...]".
2523 if (*q
== ' ' && q
>= p
) /* Expect all whitespace reduced to ' '. */
2525 /* reverse over whitespace, but don't */
2526 /* run back over *p */
2529 sign
= 0; /* no ()+ or -() seen yet */
2531 if (q
> p
+ 3 && *q
== '+' && q
[-1] == ')')
2533 sign
= 1; /* we saw a ")+" */
2534 q
--; /* q points to ')' */
2537 if (*q
== ')' && q
> p
+ 2)
2539 paren
= TRUE
; /* assume we have "(...)" */
2540 while (q
>= p
&& *q
!= '(')
2542 /* either q<p or we got matching '(' */
2544 err
= "no '(' to match ')'";
2548 * Confusers like "()" will eventually lose with a bad register
2549 * name error. So again we don't need to check for early '\0'.
2552 reg
= vax_reg_parse (q
[1], q
[2], 0);
2553 else if (q
[4] == ')')
2554 reg
= vax_reg_parse (q
[1], q
[2], q
[3]);
2558 * Since we saw a ')' we will demand a register name in the ')'.
2559 * This is nasty: why can't our hypothetical assembler permit
2560 * parenthesised expressions? BECAUSE I AM LAZY! That is why.
2561 * Abuse luser if we didn't spy a register name.
2565 /* JF allow parenthasized expressions. I hope this works */
2569 /* err = "unknown register in ()"; */
2572 q
--; /* point just before '(' of "(...)" */
2574 * If err == "..." then we lost. Run away.
2575 * Otherwise if reg >= 0 then we saw (Rn).
2579 * If err == "..." then we lost.
2580 * Otherwise paren==TRUE and reg = register in "()".
2586 * If err == "..." then we lost.
2587 * Otherwise, q points just before "(Rn)", if any.
2588 * If there was a "(...)" then paren==TRUE, and reg is the register.
2592 * We should only seek '-' of "-(...)" if:
2593 * we saw "(...)" paren == TRUE
2594 * we have no errors so far ! *err
2595 * we did not see '+' of "(...)+" sign < 1
2596 * We don't check len. We want a specific error message later if
2597 * user tries "x^...-(Rn)". This is a feature not a bug.
2601 if (paren
&& sign
< 1)/* !sign is adequate test */
2610 * We have back-tracked over most
2611 * of the crud at the end of an operand.
2612 * Unless err, we know: sign, paren. If paren, we know reg.
2613 * The last case is of an expression "Rn".
2614 * This is worth hunting for if !err, !paren.
2615 * We wouldn't be here if err.
2616 * We remember to save q, in case we didn't want "Rn" anyway.
2620 if (*q
== ' ' && q
>= p
) /* Expect all whitespace reduced to ' '. */
2622 /* reverse over whitespace, but don't */
2623 /* run back over *p */
2624 if (q
> p
&& q
< p
+ 3) /* room for Rn or Rnn exactly? */
2625 reg
= vax_reg_parse (p
[0], p
[1], q
< p
+ 2 ? 0 : p
[2]);
2627 reg
= -1; /* always comes here if no register at all */
2629 * Here with a definitive reg value.
2640 * have reg. -1:absent; else 0:15
2644 * We have: err, at, len, hash, ndx, sign, paren, reg.
2645 * Also, any remaining expression is from *p through *q inclusive.
2646 * Should there be no expression, q==p-1. So expression length = q-p+1.
2647 * This completes the first part: parsing the operand text.
2651 * We now want to boil the data down, checking consistency on the way.
2652 * We want: len, mode, reg, ndx, err, p, q, wrn, bug.
2653 * We will deliver a 4-bit reg, and a 4-bit mode.
2657 * Case of branch operand. Different. No L^B^W^I^S^ allowed for instance.
2671 * p:q whatever was input
2673 * err " " or error message, and other outputs trashed
2675 /* branch operands have restricted forms */
2676 if (!*err
&& access
== 'b')
2678 if (at
|| hash
|| sign
|| paren
|| ndx
>= 0 || reg
>= 0 || len
!= ' ')
2679 err
= "invalid branch operand";
2684 /* Since nobody seems to use it: comment this 'feature'(?) out for now. */
2687 * Case of stand-alone operand. e.g. ".long foo"
2701 * p:q whatever was input
2703 * err " " or error message, and other outputs trashed
2708 { /* addresses have restricted forms */
2710 err
= "address prohibits @";
2714 err
= "address prohibits #";
2720 err
= "address prohibits -()";
2722 err
= "address prohibits ()+";
2727 err
= "address prohibits ()";
2731 err
= "address prohibits []";
2735 err
= "address prohibits register";
2739 err
= "address prohibits displacement length specifier";
2742 err
= " "; /* succeed */
2753 #endif /*#Ifdef NEVER*/
2759 * len 's' definition
2761 * p:q demand not empty
2762 * sign 0 by paren==FALSE
2763 * paren FALSE by "()" scan logic because "S^" seen
2764 * reg -1 or nn by mistake
2773 if (!*err
&& len
== 's')
2775 if (!hash
|| paren
|| at
|| ndx
>= 0)
2776 err
= "invalid operand of S^#";
2782 * SHIT! we saw S^#Rnn ! put the Rnn back in
2783 * expression. KLUDGE! Use oldq so we don't
2784 * need to know exact length of reg name.
2790 * We have all the expression we will ever get.
2793 err
= "S^# needs expression";
2794 else if (access
== 'r')
2796 err
= " "; /* WIN! */
2800 err
= "S^# may only read-access";
2805 * Case of -(Rn), which is weird case.
2811 * sign -1 by definition
2812 * paren TRUE by definition
2813 * reg present by definition
2819 * exp "" enforce empty expression
2820 * ndx optional warn if same as reg
2822 if (!*err
&& sign
< 0)
2824 if (len
!= ' ' || hash
|| at
|| p
<= q
)
2825 err
= "invalid operand of -()";
2828 err
= " "; /* win */
2831 wrn
= "-(PC) unpredictable";
2832 else if (reg
== ndx
)
2833 wrn
= "[]index same as -()register: unpredictable";
2838 * We convert "(Rn)" to "@Rn" for our convenience.
2839 * (I hope this is convenient: has someone got a better way to parse this?)
2840 * A side-effect of this is that "@Rn" is a valid operand.
2842 if (paren
&& !sign
&& !hash
&& !at
&& len
== ' ' && p
> q
)
2849 * Case of (Rn)+, which is slightly different.
2855 * sign +1 by definition
2856 * paren TRUE by definition
2857 * reg present by definition
2863 * exp "" enforce empty expression
2864 * ndx optional warn if same as reg
2866 if (!*err
&& sign
> 0)
2868 if (len
!= ' ' || hash
|| p
<= q
)
2869 err
= "invalid operand of ()+";
2872 err
= " "; /* win */
2873 mode
= 8 + (at
? 1 : 0);
2875 wrn
= "(PC)+ unpredictable";
2876 else if (reg
== ndx
)
2877 wrn
= "[]index same as ()+register: unpredictable";
2882 * Case of #, without S^.
2886 * hash TRUE by definition
2901 if (len
!= 'i' && len
!= ' ')
2902 err
= "# conflicts length";
2904 err
= "# bars register";
2910 * SHIT! we saw #Rnn! Put the Rnn back into the expression.
2911 * By using oldq, we don't need to know how long Rnn was.
2915 reg
= -1; /* no register any more */
2917 err
= " "; /* win */
2919 /* JF a bugfix, I think! */
2920 if(at
&& access
=='a')
2923 mode
= (at
? 9 : 8);
2925 if ((access
== 'm' || access
== 'w') && !at
)
2926 wrn
= "writing or modifying # is unpredictable";
2930 * If !*err, then sign == 0
2935 * Case of Rn. We seperate this one because it has a few special
2936 * errors the remaining modes lack.
2940 * hash FALSE by program logic
2942 * sign 0 by program logic
2943 * paren FALSE by definition
2944 * reg present by definition
2949 * len ' ' enforce no length
2950 * exp "" enforce empty expression
2951 * ndx optional warn if same as reg
2953 if (!*err
&& !paren
&& reg
>= 0)
2956 err
= "length not needed";
2959 err
= " "; /* win */
2963 err
= "can't []index a register, because it has no address";
2964 else if (access
== 'a')
2965 err
= "a register has no address";
2969 * Idea here is to detect from length of datum
2970 * and from register number if we will touch PC.
2972 * vop_nbytes is number of bytes in operand.
2973 * Compute highest byte affected, compare to PC0.
2975 if ((vopP
->vop_nbytes
+ reg
* 4) > 60)
2976 wrn
= "PC part of operand unpredictable";
2977 err
= " "; /* win */
2982 * If !*err, sign == 0
2984 * paren == TRUE OR reg==-1
2988 * Rest of cases fit into one bunch.
2991 * len ' ' or 'b' or 'w' or 'l'
2992 * hash FALSE by program logic
2993 * p:q expected (empty is not an error)
2994 * sign 0 by program logic
2999 * out: mode 10 + @ + len
3001 * len ' ' or 'b' or 'w' or 'l'
3003 * ndx optional warn if same as reg
3007 err
= " "; /* win (always) */
3008 mode
= 10 + (at
? 1 : 0);
3015 case ' ': /* assumed B^ until our caller changes it */
3022 * here with completely specified mode
3030 err
= ""; /* " " is no longer an error */
3032 vopP
->vop_mode
= mode
;
3033 vopP
->vop_reg
= reg
;
3034 vopP
->vop_short
= len
;
3035 vopP
->vop_expr_begin
= p
;
3036 vopP
->vop_expr_end
= q
;
3037 vopP
->vop_ndx
= ndx
;
3038 vopP
->vop_error
= err
;
3039 vopP
->vop_warn
= wrn
;
3046 Summary of vip_op outputs.
3050 {@}Rn 5+@ n ' ' optional
3051 branch operand 0 -1 ' ' -1
3053 -(Rn) 7 n ' ' optional
3054 {@}(Rn)+ 8+@ n ' ' optional
3055 {@}#foo, no S^ 8+@ PC " i" optional
3056 {@}{q^}{(Rn)} 10+@+q option " bwl" optional
3060 #ifdef TEST /* #Define to use this testbed. */
3063 * Follows a test program for this function.
3064 * We declare arrays non-local in case some of our tiny-minded machines
3065 * default to small stacks. Also, helps with some debuggers.
3070 char answer
[100]; /* human types into here */
3083 int my_operand_length
;
3084 char my_immediate
[200];
3085 char my_indirect
[200];
3086 char my_displen
[200];
3090 char *vip_op (); /* make cc happy */
3092 printf ("enter immediate symbols eg enter # ");
3093 gets (my_immediate
);
3094 printf ("enter indirect symbols eg enter @ ");
3096 printf ("enter displen symbols eg enter ^ ");
3098 vip_op_defaults (my_immediate
, my_indirect
, my_displen
);
3101 printf ("access,width (eg 'ab' or 'wh') [empty line to quit] : ");
3106 myaccess
= answer
[0];
3107 mywidth
= answer
[1];
3111 my_operand_length
= 1;
3114 my_operand_length
= 8;
3117 my_operand_length
= 4;
3120 my_operand_length
= 16;
3123 my_operand_length
= 32;
3126 my_operand_length
= 4;
3129 my_operand_length
= 16;
3132 my_operand_length
= 8;
3135 my_operand_length
= 2;
3140 my_operand_length
= 0;
3144 my_operand_length
= 2;
3145 printf ("I dn't understand access width %c\n", mywidth
);
3148 printf ("VAX assembler instruction operand: ");
3151 mybug
= vip_op (answer
, myaccess
, mywidth
, my_operand_length
,
3152 &mymode
, &myreg
, &mylen
, &myleft
, &myright
, &myndx
,
3156 printf ("error: \"%s\"\n", myerr
);
3158 printf (" bug: \"%s\"\n", mybug
);
3163 printf ("warning: \"%s\"\n", mywrn
);
3164 mumble ("mode", mymode
);
3165 mumble ("register", myreg
);
3166 mumble ("index", myndx
);
3167 printf ("width:'%c' ", mylen
);
3168 printf ("expression: \"");
3169 while (myleft
<= myright
)
3170 putchar (*myleft
++);
3176 mumble (text
, value
)
3180 printf ("%s:", text
);
3182 printf ("%xx", value
);
3188 #endif /* ifdef TEST */
3192 const int md_short_jump_size
= 3;
3193 const int md_long_jump_size
= 6;
3194 const int md_reloc_size
= 8; /* Size of relocation record */
3197 md_create_short_jump (ptr
, from_addr
, to_addr
, frag
, to_symbol
)
3199 long from_addr
, to_addr
;
3205 offset
= to_addr
- (from_addr
+ 1);
3207 md_number_to_chars (ptr
, offset
, 2);
3211 md_create_long_jump (ptr
, from_addr
, to_addr
, frag
, to_symbol
)
3213 long from_addr
, to_addr
;
3219 offset
= to_addr
- to_symbol
->sy_value
;
3222 md_number_to_chars (ptr
, offset
, 4);
3223 fix_new (frag
, ptr
- frag
->fr_literal
, 4, to_symbol
, (symbolS
*) 0, (long) 0, 0);
3227 md_parse_option (argP
, cntP
, vecP
)
3232 char *temp_name
; /* name for -t or -d options */
3238 /* as_warn ("I can do better than -J!"); */
3242 as_warn ("SYMBOL TABLE not implemented");
3243 break; /* SYMBOL TABLE not implemented */
3246 as_warn ("TOKEN TRACE not implemented");
3247 break; /* TOKEN TRACE not implemented */
3253 { /* Rest of argument is filename. */
3263 temp_name
= *++(*vecP
);
3264 **vecP
= NULL
; /* Remember this is not a file-name. */
3268 as_warn ("I expected a filename after -%c.",opt
);
3269 temp_name
= "{absent}";
3273 as_warn ("Displacement length %s ignored!", temp_name
);
3275 as_warn ("I don't need or use temp. file \"%s\".", temp_name
);
3279 as_warn ("I don't use an interpass file! -V ignored");
3283 case '+': /* For g++ */
3286 case 'h': /* No hashing of mixed-case names */
3289 case 'H': /* Show new symbol after hash truncation */
3300 /* We have no need to default values of symbols. */
3304 md_undefined_symbol (name
)
3310 /* Parse an operand that is machine-specific.
3311 We just return without modifying the expression if we have nothing
3316 md_operand (expressionP
)
3317 expressionS
*expressionP
;
3321 /* Round up a section size to the appropriate boundary. */
3323 md_section_align (segment
, size
)
3327 return size
; /* Byte alignment is fine */
3330 /* Exactly what point is a PC-relative offset relative TO?
3331 On the vax, they're relative to the address of the offset, plus
3332 its size. (??? Is this right? FIXME-SOON) */
3334 md_pcrel_from (fixP
)
3337 return fixP
->fx_size
+ fixP
->fx_where
+ fixP
->fx_frag
->fr_address
;