1 /* tc-vax.c - vax-specific -
2 Copyright (C) 1987, 1991, 1992 Free Software Foundation, Inc.
4 This file is part of GAS, the GNU Assembler.
6 GAS is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 GAS is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GAS; see the file COPYING. If not, write to
18 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
20 /* JF I moved almost all the vax specific stuff into this one file 'cuz RMS
21 seems to think its a good idea. I hope I managed to get all the VAX-isms */
28 #include "obstack.h" /* For FRAG_APPEND_1_CHAR macro in "frags.h" */
30 /* These chars start a comment anywhere in a source file (except inside
32 const char comment_chars[] = "#";
34 /* These chars only start a comment at the beginning of a line. */
35 /* Note that for the VAX the are the same as comment_chars above. */
36 const char line_comment_chars[] = "#";
38 /* Chars that can be used to separate mant from exp in floating point nums */
39 const char EXP_CHARS[] = "eE";
41 /* Chars that mean this number is a floating point constant */
43 /* or 0H1.234E-12 (see exp chars above) */
44 const char FLT_CHARS[] = "dDfFgGhH";
46 /* Also be aware that MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT may have to be
47 changed in read.c. Ideally it shouldn't have to know about it at all,
48 but nothing is ideal around here.
51 static expressionS /* Hold details of an operand expression */
52 exp_of_operand[VIT_MAX_OPERANDS];
55 v; /* A vax instruction after decoding. */
57 LITTLENUM_TYPE big_operand_bits[VIT_MAX_OPERANDS][SIZE_OF_LARGE_NUMBER];
58 /* Hold details of big operands. */
59 FLONUM_TYPE float_operand[VIT_MAX_OPERANDS];
60 /* Above is made to point into */
61 /* big_operand_bits by md_begin(). */
64 * For VAX, relative addresses of "just the right length" are easy.
65 * The branch displacement is always the last operand, even in
66 * synthetic instructions.
67 * For VAX, we encode the relax_substateTs (in e.g. fr_substate) as:
69 * 4 3 2 1 0 bit number
70 * ---/ /--+-------+-------+-------+-------+-------+
71 * | what state ? | how long ? |
72 * ---/ /--+-------+-------+-------+-------+-------+
74 * The "how long" bits are 00=byte, 01=word, 10=long.
75 * This is a Un*x convention.
76 * Not all lengths are legit for a given value of (what state).
77 * The "how long" refers merely to the displacement length.
78 * The address usually has some constant bytes in it as well.
81 groups for VAX address relaxing.
84 length of byte, word, long
86 2a. J<cond> where <cond> is a simple flag test.
87 length of byte, word, long.
88 VAX opcodes are: (Hex)
101 Always, you complement 0th bit to reverse condition.
102 Always, 1-byte opcode, then 1-byte displacement.
104 2b. J<cond> where cond tests a memory bit.
105 length of byte, word, long.
106 Vax opcodes are: (Hex)
115 Always, you complement 0th bit to reverse condition.
116 Always, 1-byte opcde, longword-address, byte-address, 1-byte-displacement
118 2c. J<cond> where cond tests low-order memory bit
119 length of byte,word,long.
120 Vax opcodes are: (Hex)
123 Always, you complement 0th bit to reverse condition.
124 Always, 1-byte opcode, longword-address, 1-byte displacement.
127 length of byte,word,long.
128 Vax opcodes are: (Hex)
131 These are like (2) but there is no condition to reverse.
132 Always, 1 byte opcode, then displacement/absolute.
135 length of word, long.
136 Vax opcodes are: (Hex)
144 Always, we cannot reverse the sense of the branch; we have a word
146 The double-byte op-codes don't hurt: we never want to modify the
147 opcode, so we don't care how many bytes are between the opcode and
151 length of long, long, byte.
152 Vax opcodes are: (Hex)
157 Always, we cannot reverse the sense of the branch; we have a byte
160 The only time we need to modify the opcode is for class 2 instructions.
161 After relax() we may complement the lowest order bit of such instruction
162 to reverse sense of branch.
164 For class 2 instructions, we store context of "where is the opcode literal".
165 We can change an opcode's lowest order bit without breaking anything else.
167 We sometimes store context in the operand literal. This way we can figure out
168 after relax() what the original addressing mode was.
171 /* These displacements are relative to */
172 /* the start address of the displacement. */
173 /* The first letter is Byte, Word. */
174 /* 2nd letter is Forward, Backward. */
177 #define WF (2+ 32767)
178 #define WB (2+-32768)
179 /* Dont need LF, LB because they always */
180 /* reach. [They are coded as 0.] */
183 #define C(a,b) ENCODE_RELAX(a,b)
184 /* This macro has no side-effects. */
185 #define ENCODE_RELAX(what,length) (((what) << 2) + (length))
190 { 1, 1, 0, 0 }, /* error sentinel 0,0 */
191 { 1, 1, 0, 0 }, /* unused 0,1 */
192 { 1, 1, 0, 0 }, /* unused 0,2 */
193 { 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 */
198 { BF, BB, 1, C(2, 1) }, /* b<cond> B^"foo" 2,0 */
199 { WF + 2, WB + 2, 4, C (2, 2) }, /* br.+? brw X 2,1 */
200 { 0, 0, 7, 0 }, /* br.+? jmp X 2,2 */
201 { 1, 1, 0, 0 }, /* unused 2,3 */
202 { BF, BB, 1, C (3, 1) }, /* brb B^foo 3,0 */
203 { WF, WB, 2, C (3, 2) }, /* brw W^foo 3,1 */
204 { 0, 0, 5, 0 }, /* Jmp L^foo 3,2 */
205 { 1, 1, 0, 0 }, /* unused 3,3 */
206 { 1, 1, 0, 0 }, /* unused 4,0 */
207 { WF, WB, 2, C (4, 2) }, /* acb_ ^Wfoo 4,1 */
208 { 0, 0, 10, 0 }, /* acb_,br,jmp L^foo4,2 */
209 { 1, 1, 0, 0 }, /* unused 4,3 */
210 { BF, BB, 1, C (5, 1) }, /* Xob___,,foo 5,0 */
211 { WF + 4, WB + 4, 6, C (5, 2) }, /* Xob.+2,brb.+3,brw5,1 */
212 { 0, 0, 9, 0 }, /* Xob.+2,brb.+6,jmp5,2 */
223 const pseudo_typeS md_pseudo_table[] = {
224 {"dfloat", float_cons, 'd'},
225 {"ffloat", float_cons, 'f'},
226 {"gfloat", float_cons, 'g'},
227 {"hfloat", float_cons, 'h'},
231 #define STATE_PC_RELATIVE (1)
232 #define STATE_CONDITIONAL_BRANCH (2)
233 #define STATE_ALWAYS_BRANCH (3) /* includes BSB... */
234 #define STATE_COMPLEX_BRANCH (4)
235 #define STATE_COMPLEX_HOP (5)
237 #define STATE_BYTE (0)
238 #define STATE_WORD (1)
239 #define STATE_LONG (2)
240 #define STATE_UNDF (3) /* Symbol undefined in pass1 */
243 #define min(a, b) ((a) < (b) ? (a) : (b))
247 int flonum_gen2vax(char format_letter, FLONUM_TYPE *f, LITTLENUM_TYPE *words);
248 static void vip_end(void);
249 static void vip_op_defaults(char *immediate, char *indirect, char *displen);
251 #else /* not __STDC__ */
253 int flonum_gen2vax();
254 static void vip_end();
255 static void vip_op_defaults();
257 #endif /* not __STDC__ */
267 if (*(errtxt = vip_begin (1, "$", "*", "`"))) {
268 as_fatal("VIP_BEGIN error:%s", errtxt);
271 for (i = 0, fP = float_operand;
272 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];
285 void /* Knows about order of bytes in address. */
286 md_number_to_chars(con, value, nbytes)
287 char con[]; /* Return 'nbytes' of chars here. */
288 long value; /* The value of the bits. */
289 int nbytes; /* Number of bytes in the output. */
297 *con++ = value; /* Lint wants & MASK_CHAR. */
298 value >>= BITS_PER_CHAR;
300 /* XXX line number probably botched for this warning message. */
301 if (value != 0 && value != -1)
302 as_bad("Displacement (%ld) long for instruction field length (%d).", v, n);
305 /* Fix up some data or instructions after we find out the value of a symbol
306 that they reference. */
308 void /* Knows about order of bytes in address. */
309 md_apply_fix(fixP, value)
310 fixS *fixP; /* Fixup struct pointer */
311 long value; /* The value of the bits. */
313 char *buf = fixP->fx_where + fixP->fx_frag->fr_literal;
314 int nbytes; /* Number of bytes in the output. */
316 nbytes = fixP->fx_size;
318 *buf++ = value; /* Lint wants & MASK_CHAR. */
319 value >>= BITS_PER_CHAR;
323 long /* Knows about the byte order in a word. */
324 md_chars_to_number (con, nbytes)
325 unsigned char con[]; /* Low order byte 1st. */
326 int nbytes; /* Number of bytes in the input. */
329 for (retval = 0, con += nbytes - 1; nbytes--; con--) {
330 retval <<= BITS_PER_CHAR;
336 /* vax:md_assemble() emit frags for 1 instruction */
339 md_assemble (instruction_string)
340 char *instruction_string; /* A string: assemble 1 instruction. */
342 /* We saw no errors in any operands - try to make frag(s) */
343 int is_undefined; /* 1 if operand expression's */
344 /* segment not known yet. */
348 register struct vop *operandP;/* An operand. Scans all operands. */
349 char *save_input_line_pointer;
350 char c_save; /* What used to live after an expression. */
352 /* struct frag *fragP; */ /* Fragment of code we just made. */
353 register int goofed; /* 1: instruction_string bad for all passes. */
354 register struct vop *end_operandP; /* -> slot just after last operand */
355 /* Limit of the for (each operand). */
356 register expressionS *expP; /* -> expression values for this operand */
358 /* These refer to an instruction operand expression. */
359 segT to_seg; /* Target segment of the address. */
360 register valueT this_add_number;
361 register struct symbol *this_add_symbol; /* +ve (minuend) symbol. */
362 register struct symbol *this_subtract_symbol; /* -ve(subtrahend) symbol. */
364 long opcode_as_number; /* As a number. */
365 char *opcode_as_chars; /* Least significant byte 1st. */
366 /* As an array of characters. */
367 char *opcode_low_byteP; /* Least significant byte 1st */
368 /* richfix: unused? */
369 /* struct details *detP; */ /* The details of an ADxxx frag. */
370 int length; /* length (bytes) meant by vop_short. */
371 int at; /* 0, or 1 if '@' is in addressing mode. */
372 int nbytes; /* From vop_nbytes: vax_operand_width (in bytes) */
375 LITTLENUM_TYPE literal_float[8];
376 /* Big enough for any floating point literal. */
378 if (*(p = vip (&v, instruction_string))) {
379 as_fatal("vax_assemble\"%s\" in=\"%s\"", p, instruction_string);
382 * Now we try to find as many as_warn()s as we can. If we do any as_warn()s
383 * then goofed=1. Notice that we don't make any frags yet.
384 * Should goofed be 1, then this instruction will wedge in any pass,
385 * and we can safely flush it, without causing interpass symbol phase
386 * errors. That is, without changing label values in different passes.
388 if (goofed = (*v.vit_error)) {
389 as_warn ("Ignoring statement due to \"%s\"", v.vit_error);
392 * We need to use expression() and friends, which require us to diddle
393 * input_line_pointer. So we save it and restore it later.
395 save_input_line_pointer = input_line_pointer;
396 for (operandP = v.vit_operand,
397 expP = exp_of_operand,
398 floatP = float_operand,
399 end_operandP = v.vit_operand + v.vit_operands;
401 operandP < end_operandP;
403 operandP++, expP++, floatP++) { /* for each operand */
404 if (*(operandP->vop_error)) {
405 as_warn ("Ignoring statement because \"%s\"", (operandP->vop_error));
407 } else { /* statement has no syntax goofs: lets sniff the expression */
408 int can_be_short = 0; /* 1 if a bignum can be reduced to a short literal. */
410 input_line_pointer = operandP->vop_expr_begin;
411 c_save = operandP->vop_expr_end[1];
412 operandP->vop_expr_end[1] = '\0';
413 /* If to_seg == SEG_PASS1, expression() will have set need_pass_2 = 1. */
414 switch (to_seg = expression (expP)) {
416 /* for BSD4.2 compatibility, missing expression is absolute 0 */
417 to_seg = expP->X_seg = SEG_ABSOLUTE;
418 expP->X_add_number = 0;
419 /* for SEG_ABSOLUTE, we shouldnt need to set X_subtract_symbol, X_add_symbol to any
420 particular value. But, we will program defensively. Since this situation occurs rarely
421 so it costs us little to do, and stops Dean worrying about the origin of random bits in
423 expP->X_add_symbol = NULL;
424 expP->X_subtract_symbol = NULL;
435 * Major bug. We can't handle the case of a
436 * SEG_DIFFERENCE expression in a VIT_OPCODE_SYNTHETIC
437 * variable-length instruction.
438 * We don't have a frag type that is smart enough to
439 * relax a SEG_DIFFERENCE, and so we just force all
440 * SEG_DIFFERENCEs to behave like SEG_PASS1s.
441 * Clearly, if there is a demand we can invent a new or
442 * modified frag type and then coding up a frag for this
443 * case will be easy. SEG_DIFFERENCE was invented for the
444 * .words after a CASE opcode, and was never intended for
445 * instruction operands.
448 as_warn("Can't relocate expression");
452 /* Preserve the bits. */
453 if (expP->X_add_number > 0) {
454 bignum_copy(generic_bignum, expP->X_add_number,
455 floatP->low, SIZE_OF_LARGE_NUMBER);
457 know(expP->X_add_number < 0);
458 flonum_copy (&generic_floating_point_number,
460 if (strchr("s i", operandP->vop_short)) { /* Could possibly become S^# */
461 flonum_gen2vax(-expP->X_add_number, floatP, literal_float);
462 switch (-expP->X_add_number) {
465 (literal_float[0] & 0xFC0F) == 0x4000
466 && literal_float[1] == 0;
471 (literal_float[0] & 0xFC0F) == 0x4000
472 && literal_float[1] == 0
473 && literal_float[2] == 0
474 && literal_float[3] == 0;
479 (literal_float[0] & 0xFF81) == 0x4000
480 && literal_float[1] == 0
481 && literal_float[2] == 0
482 && literal_float[3] == 0;
486 can_be_short = ((literal_float[0] & 0xFFF8) == 0x4000
487 && (literal_float[1] & 0xE000) == 0
488 && literal_float[2] == 0
489 && literal_float[3] == 0
490 && literal_float[4] == 0
491 && literal_float[5] == 0
492 && literal_float[6] == 0
493 && literal_float[7] == 0);
497 BAD_CASE(-expP->X_add_number);
499 } /* switch (float type) */
500 } /* if (could want to become S^#...) */
501 } /* bignum or flonum ? */
503 if (operandP->vop_short == 's'
504 || operandP->vop_short == 'i'
505 || (operandP->vop_short == ' '
506 && operandP->vop_reg == 0xF
507 && (operandP->vop_mode & 0xE) == 0x8)) {
509 if (operandP->vop_short == ' ') { /* We must chose S^ or I^. */
510 if (expP->X_add_number > 0) { /* Bignum: Short literal impossible. */
511 operandP->vop_short = 'i';
512 operandP->vop_mode = 8;
513 operandP->vop_reg = 0xF; /* VAX PC. */
514 } else { /* Flonum: Try to do it. */
517 operandP->vop_short = 's';
518 operandP->vop_mode = 0;
519 operandP->vop_ndx = -1;
520 operandP->vop_reg = -1;
521 /* JF hope this is the right thing */
522 expP->X_seg = SEG_ABSOLUTE;
524 operandP->vop_short = 'i';
525 operandP->vop_mode = 8;
526 operandP->vop_reg = 0xF; /* VAX PC */
528 } /* bignum or flonum ? */
529 } /* if #, but no S^ or I^ seen. */
530 /* No more ' ' case: either 's' or 'i'. */
531 if (operandP->vop_short == 's') {
532 /* Wants to be a short literal. */
533 if (expP->X_add_number > 0) {
534 as_warn ("Bignum not permitted in short literal. Immediate mode assumed.");
535 operandP->vop_short = 'i';
536 operandP->vop_mode = 8;
537 operandP->vop_reg = 0xF; /* VAX PC. */
540 as_warn ("Can't do flonum short literal: immediate mode used.");
541 operandP->vop_short = 'i';
542 operandP->vop_mode = 8;
543 operandP->vop_reg = 0xF; /* VAX PC. */
544 } else { /* Encode short literal now. */
547 switch (-expP->X_add_number) {
550 temp = literal_float[0] >> 4;
554 temp = literal_float[0] >> 1;
558 temp = ((literal_float[0] << 3) & 070)
559 | ((literal_float[1] >> 13) & 07);
563 BAD_CASE(-expP->X_add_number);
567 floatP->low[0] = temp & 077;
569 } /* if can be short literal float */
570 } /* flonum or bignum ? */
571 } else { /* I^# seen: set it up if float. */
572 if (expP->X_add_number < 0) {
573 memcpy(floatP->low, literal_float, sizeof(literal_float));
577 as_warn ("A bignum/flonum may not be a displacement: 0x%x used",
578 expP->X_add_number = 0x80000000);
579 /* Chosen so luser gets the most offset bits to patch later. */
581 expP->X_add_number = floatP->low[0]
582 | ((LITTLENUM_MASK & (floatP->low[1])) << LITTLENUM_NUMBER_OF_BITS);
584 * For the SEG_BIG case we have:
585 * If vop_short == 's' then a short floating literal is in the
586 * lowest 6 bits of floatP->low [0], which is
587 * big_operand_bits [---] [0].
588 * If vop_short == 'i' then the appropriate number of elements
589 * of big_operand_bits [---] [...] are set up with the correct
591 * Also, just in case width is byte word or long, we copy the lowest
592 * 32 bits of the number to X_add_number.
600 if (input_line_pointer != operandP->vop_expr_end + 1) {
601 as_warn ("Junk at end of expression \"%s\"", input_line_pointer);
604 operandP->vop_expr_end[1] = c_save;
606 } /* for (each operand) */
608 input_line_pointer = save_input_line_pointer;
610 if (need_pass_2 || goofed) {
616 /* Remember where it is, in case we want to modify the op-code later. */
617 opcode_low_byteP = frag_more (v.vit_opcode_nbytes);
618 memcpy(opcode_low_byteP, v.vit_opcode, v.vit_opcode_nbytes);
619 opcode_as_number = md_chars_to_number (opcode_as_chars = v.vit_opcode, 4);
620 for (operandP = v.vit_operand,
621 expP = exp_of_operand,
622 floatP = float_operand,
623 end_operandP = v.vit_operand + v.vit_operands;
625 operandP < end_operandP;
629 expP++) { /* for each operand */
630 if (operandP->vop_ndx >= 0) {
631 /* indexed addressing byte */
632 /* Legality of indexed mode already checked: it is OK */
633 FRAG_APPEND_1_CHAR (0x40 + operandP->vop_ndx);
634 } /* if (vop_ndx >= 0) */
636 /* Here to make main operand frag(s). */
637 this_add_number = expP->X_add_number;
638 this_add_symbol = expP->X_add_symbol;
639 this_subtract_symbol = expP->X_subtract_symbol;
640 to_seg = expP->X_seg;
641 is_undefined = (to_seg == SEG_UNKNOWN);
642 know(to_seg == SEG_UNKNOWN
643 || to_seg == SEG_ABSOLUTE
644 || to_seg == SEG_DATA
645 || to_seg == SEG_TEXT
647 || to_seg == SEG_BIG);
648 at = operandP->vop_mode & 1;
649 length = (operandP->vop_short == 'b'
650 ? 1 : (operandP->vop_short == 'w'
651 ? 2 : (operandP->vop_short == 'l'
653 nbytes = operandP->vop_nbytes;
654 if (operandP->vop_access == 'b') {
655 if (to_seg == now_seg || is_undefined) {
656 /* If is_undefined, then it might BECOME now_seg. */
658 p = frag_more(nbytes);
659 fix_new(frag_now, p - frag_now->fr_literal, nbytes,
660 this_add_symbol, 0, this_add_number, 1, NO_RELOC);
661 } else { /* to_seg == now_seg || to_seg == SEG_UNKNOWN */
663 length_code = is_undefined ? STATE_UNDF : STATE_BYTE;
664 if (opcode_as_number & VIT_OPCODE_SPECIAL) {
665 if (operandP->vop_width == VAX_WIDTH_UNCONDITIONAL_JUMP) {
667 frag_var(rs_machine_dependent, 5, 1,
668 ENCODE_RELAX (STATE_ALWAYS_BRANCH, length_code),
669 this_add_symbol, this_add_number,
672 if (operandP->vop_width == VAX_WIDTH_WORD_JUMP) {
673 length_code = STATE_WORD;
674 /* JF: There is no state_byte for this one! */
675 frag_var(rs_machine_dependent, 10, 2,
676 ENCODE_RELAX (STATE_COMPLEX_BRANCH, length_code),
677 this_add_symbol, this_add_number,
680 know(operandP->vop_width == VAX_WIDTH_BYTE_JUMP);
681 frag_var(rs_machine_dependent, 9, 1,
682 ENCODE_RELAX (STATE_COMPLEX_HOP, length_code),
683 this_add_symbol, this_add_number,
688 know(operandP->vop_width == VAX_WIDTH_CONDITIONAL_JUMP);
689 frag_var(rs_machine_dependent, 7, 1,
690 ENCODE_RELAX (STATE_CONDITIONAL_BRANCH, length_code),
691 this_add_symbol, this_add_number,
695 } else { /* to_seg != now_seg && to_seg != SEG_UNKNOWN */
697 * --- SEG FLOAT MAY APPEAR HERE ----
699 if (to_seg == SEG_ABSOLUTE) {
701 know(!(opcode_as_number & VIT_OPCODE_SYNTHETIC));
702 p = frag_more (nbytes);
703 /* Conventional relocation. */
704 fix_new(frag_now, p - frag_now->fr_literal,
705 nbytes, &abs_symbol, 0, this_add_number, 1, NO_RELOC);
707 know(opcode_as_number & VIT_OPCODE_SYNTHETIC);
708 if (opcode_as_number & VIT_OPCODE_SPECIAL) {
709 if (operandP->vop_width == VAX_WIDTH_UNCONDITIONAL_JUMP) {
711 *opcode_low_byteP = opcode_as_chars[0] + VAX_WIDEN_LONG;
712 know(opcode_as_chars[1] == 0);
714 p[0] = VAX_ABSOLUTE_MODE; /* @#... */
715 md_number_to_chars(p + 1, this_add_number, 4);
716 /* Now (eg) JMP @#foo or JSB @#foo. */
718 if (operandP->vop_width == VAX_WIDTH_WORD_JUMP) {
725 p[5] = VAX_ABSOLUTE_MODE; /* @#... */
726 md_number_to_chars(p + 6, this_add_number, 4);
734 know(operandP->vop_width == VAX_WIDTH_BYTE_JUMP);
740 p[4] = VAX_PC_RELATIVE_MODE + 1; /* @#... */
741 md_number_to_chars(p + 5, this_add_number, 4);
752 *opcode_low_byteP ^= 1;
753 /* To reverse the condition in a VAX branch, complement the lowest order
758 p[2] = VAX_ABSOLUTE_MODE; /* @#... */
759 md_number_to_chars(p + 3, this_add_number, 4);
767 } else { /* to_seg != now_seg && to_seg != SEG_UNKNOWN && to_Seg != SEG_ABSOLUTE */
769 /* Pc-relative. Conventional relocation. */
770 know(!(opcode_as_number & VIT_OPCODE_SYNTHETIC));
771 p = frag_more (nbytes);
772 fix_new(frag_now, p - frag_now->fr_literal,
773 nbytes, &abs_symbol, 0, this_add_number, 1, NO_RELOC);
775 know(opcode_as_number & VIT_OPCODE_SYNTHETIC);
776 if (opcode_as_number & VIT_OPCODE_SPECIAL) {
777 if (operandP->vop_width == VAX_WIDTH_UNCONDITIONAL_JUMP) {
779 know(opcode_as_chars[1] == 0);
780 *opcode_low_byteP = opcode_as_chars[0] + VAX_WIDEN_LONG;
782 p[0] = VAX_PC_RELATIVE_MODE;
784 p + 1 - frag_now->fr_literal, 4,
786 this_add_number, 1, NO_RELOC);
787 /* Now eg JMP foo or JSB foo. */
789 if (operandP->vop_width == VAX_WIDTH_WORD_JUMP) {
796 p[5] = VAX_PC_RELATIVE_MODE;
798 p + 6 - frag_now->fr_literal, 4,
800 this_add_number, 1, NO_RELOC);
808 know(operandP->vop_width == VAX_WIDTH_BYTE_JUMP);
814 p[4] = VAX_PC_RELATIVE_MODE;
816 p + 5 - frag_now->fr_literal,
817 4, this_add_symbol, 0,
818 this_add_number, 1, NO_RELOC);
828 know(operandP->vop_width == VAX_WIDTH_CONDITIONAL_JUMP);
829 *opcode_low_byteP ^= 1; /* Reverse branch condition. */
833 p[2] = VAX_PC_RELATIVE_MODE;
834 fix_new(frag_now, p + 3 - frag_now->fr_literal,
835 4, this_add_symbol, 0,
836 this_add_number, 1, NO_RELOC);
842 know(operandP->vop_access != 'b'); /* So it is ordinary operand. */
843 know(operandP->vop_access != ' '); /* ' ' target-independent: elsewhere. */
844 know(operandP->vop_access == 'a'
845 || operandP->vop_access == 'm'
846 || operandP->vop_access == 'r'
847 || operandP->vop_access == 'v'
848 || operandP->vop_access == 'w');
849 if (operandP->vop_short == 's') {
850 if (to_seg == SEG_ABSOLUTE) {
851 if (this_add_number < 0 || this_add_number >= 64) {
852 as_warn("Short literal overflow(%d.), immediate mode assumed.", this_add_number);
853 operandP->vop_short = 'i';
854 operandP->vop_mode = 8;
855 operandP->vop_reg = 0xF;
858 as_warn ("Forced short literal to immediate mode. now_seg=%s to_seg=%s",
859 segment_name(now_seg), segment_name(to_seg));
860 operandP->vop_short = 'i';
861 operandP->vop_mode = 8;
862 operandP->vop_reg = 0xF;
865 if (operandP->vop_reg >= 0 && (operandP->vop_mode < 8
866 || (operandP->vop_reg != 0xF && operandP->vop_mode < 10))) {
867 /* One byte operand. */
868 know(operandP->vop_mode > 3);
869 FRAG_APPEND_1_CHAR (operandP->vop_mode << 4 | operandP->vop_reg);
870 /* All 1-bytes except S^# happen here. */
871 } else { /* {@}{q^}foo{(Rn)} or S^#foo */
872 if (operandP->vop_reg == -1 && operandP->vop_short != 's') {
874 if (to_seg == now_seg) {
876 know(operandP->vop_short == ' ');
877 p = frag_var(rs_machine_dependent, 10, 2,
878 ENCODE_RELAX (STATE_PC_RELATIVE, STATE_BYTE),
879 this_add_symbol, this_add_number,
881 know(operandP->vop_mode == 10 + at);
883 /* At is the only context we need to carry to */
884 /* other side of relax() process. */
885 /* Must be in the correct bit position of VAX */
886 /* operand spec. byte. */
889 know(operandP->vop_short != ' ');
890 p = frag_more (length + 1);
891 /* JF is this array stuff really going to work? */
892 p[0] = 0xF | ((at + "?\12\14?\16"[length]) << 4);
893 fix_new(frag_now, p + 1 - frag_now->fr_literal,
894 length, this_add_symbol, 0,
895 this_add_number, 1, NO_RELOC);
897 } else { /* to_seg != now_seg */
898 if (this_add_symbol == NULL) {
899 know(to_seg == SEG_ABSOLUTE);
900 /* Do @#foo: simpler relocation than foo-.(pc) anyway. */
902 p[0] = VAX_ABSOLUTE_MODE; /* @#... */
903 md_number_to_chars(p + 1, this_add_number, 4);
904 if (length && length != 4)
906 as_warn ("Length specification ignored. Address mode 9F used");
909 /* {@}{q^}other_seg */
910 know((length == 0 && operandP->vop_short == ' ')
911 ||(length > 0 && operandP->vop_short != ' '));
914 * We have a SEG_UNKNOWN symbol. It might
915 * turn out to be in the same segment as
916 * the instruction, permitting relaxation.
918 p = frag_var(rs_machine_dependent, 5, 2,
919 ENCODE_RELAX (STATE_PC_RELATIVE, STATE_UNDF),
920 this_add_symbol, this_add_number,
925 know(operandP->vop_short == ' ');
926 length = 4; /* Longest possible. */
928 p = frag_more (length + 1);
929 p[0] = 0xF | ((at + "?\12\14?\16"[length]) << 4);
930 md_number_to_chars(p + 1, this_add_number, length);
932 p + 1 - frag_now->fr_literal,
933 length, this_add_symbol, 0,
934 this_add_number, 1, NO_RELOC);
938 } else { /* {@}{q^}foo(Rn) or S^# or I^# or # */
939 if (operandP->vop_mode < 0xA) { /* # or S^# or I^# */
940 /* know( (length == 0 && operandP->vop_short == ' ')
941 || (length > 0 && operandP->vop_short != ' ')); */
943 && to_seg == SEG_ABSOLUTE
944 && operandP->vop_mode == 8 /* No '@'. */
945 && this_add_number < 64
946 && this_add_number >= 0) {
947 operandP->vop_short = 's';
949 if (operandP->vop_short == 's') {
950 FRAG_APPEND_1_CHAR (this_add_number);
951 } else { /* I^#... */
953 p = frag_more (nbytes + 1);
954 know(operandP->vop_reg == 0xF);
955 p[0] = (operandP->vop_mode << 4) | 0xF;
956 if (to_seg == SEG_ABSOLUTE) {
958 * If nbytes > 4, then we are scrod. We don't know if the
959 * high order bytes are to be 0xFF or 0x00.
960 * BSD4.2 & RMS say use 0x00. OK --- but this
961 * assembler needs ANOTHER rewrite to
962 * cope properly with this bug.
964 md_number_to_chars(p + 1, this_add_number, min (4, nbytes));
967 memset(p + 5, '\0', nbytes - 4);
970 if (to_seg == SEG_BIG) {
972 * Problem here is to get the bytes in the right order.
973 * We stored our constant as LITTLENUMs, not bytes.
982 for (p++; nbytes; nbytes -= 2, p += 2, lP++)
984 md_number_to_chars(p, *lP, 2);
988 fix_new(frag_now, p + 1 - frag_now->fr_literal,
989 nbytes, this_add_symbol, 0,
990 this_add_number, 0, NO_RELOC);
994 } else { /* {@}{q^}foo(Rn) */
995 know((length == 0 && operandP->vop_short == ' ')
996 ||(length > 0 && operandP->vop_short != ' '));
998 if (to_seg == SEG_ABSOLUTE) {
1001 test = this_add_number;
1006 length = test & 0xffff8000 ? 4
1007 : test & 0xffffff80 ? 2
1013 p = frag_more (1 + length);
1014 know(operandP->vop_reg >= 0);
1015 p[0] = operandP->vop_reg
1016 | ((at | "?\12\14?\16"[length]) << 4);
1017 if (to_seg == SEG_ABSOLUTE) {
1018 md_number_to_chars(p + 1, this_add_number, length);
1020 fix_new(frag_now, p + 1 - frag_now->fr_literal,
1021 length, this_add_symbol, 0,
1022 this_add_number, 0, NO_RELOC);
1026 } /* if (single-byte-operand) */
1028 } /* for (operandP) */
1029 } /* vax_assemble() */
1032 * md_estimate_size_before_relax()
1034 * Called just before relax().
1035 * Any symbol that is now undefined will not become defined.
1036 * Return the correct fr_subtype in the frag.
1037 * Return the initial "guess for fr_var" to caller.
1038 * The guess for fr_var is ACTUALLY the growth beyond fr_fix.
1039 * Whatever we do to grow fr_fix or fr_var contributes to our returned value.
1040 * Although it may not be explicit in the frag, pretend fr_var starts with a
1044 md_estimate_size_before_relax (fragP, segment)
1045 register fragS *fragP;
1046 register segT segment;
1049 register int old_fr_fix;
1051 old_fr_fix = fragP->fr_fix;
1052 switch (fragP->fr_subtype) {
1053 case ENCODE_RELAX (STATE_PC_RELATIVE, STATE_UNDF):
1054 if (S_GET_SEGMENT(fragP->fr_symbol) == segment) { /* A relaxable case. */
1055 fragP->fr_subtype = ENCODE_RELAX (STATE_PC_RELATIVE, STATE_BYTE);
1057 p = fragP->fr_literal + old_fr_fix;
1058 p[0] |= VAX_PC_RELATIVE_MODE; /* Preserve @ bit. */
1059 fragP->fr_fix += 1 + 4;
1060 fix_new(fragP, old_fr_fix + 1, 4, fragP->fr_symbol, 0,
1061 fragP->fr_offset, 1, NO_RELOC);
1066 case ENCODE_RELAX (STATE_CONDITIONAL_BRANCH, STATE_UNDF):
1067 if (S_GET_SEGMENT(fragP->fr_symbol) == segment) {
1068 fragP->fr_subtype = ENCODE_RELAX (STATE_CONDITIONAL_BRANCH, STATE_BYTE);
1070 p = fragP->fr_literal + old_fr_fix;
1071 *fragP->fr_opcode ^= 1; /* Reverse sense of branch. */
1074 p[2] = VAX_PC_RELATIVE_MODE; /* ...(PC) */
1075 fragP->fr_fix += 1 + 1 + 1 + 4;
1076 fix_new(fragP, old_fr_fix + 3, 4, fragP->fr_symbol, 0,
1077 fragP->fr_offset, 1, NO_RELOC);
1082 case ENCODE_RELAX (STATE_COMPLEX_BRANCH, STATE_UNDF):
1083 if (S_GET_SEGMENT(fragP->fr_symbol) == segment) {
1084 fragP->fr_subtype = ENCODE_RELAX (STATE_COMPLEX_BRANCH, STATE_WORD);
1086 p = fragP->fr_literal + old_fr_fix;
1092 p[5] = VAX_PC_RELATIVE_MODE; /* ...(pc) */
1093 fragP->fr_fix += 2 + 2 + 1 + 1 + 4;
1094 fix_new(fragP, old_fr_fix + 6, 4, fragP->fr_symbol, 0,
1095 fragP->fr_offset, 1, NO_RELOC);
1100 case ENCODE_RELAX (STATE_COMPLEX_HOP, STATE_UNDF):
1101 if (S_GET_SEGMENT(fragP->fr_symbol) == segment) {
1102 fragP->fr_subtype = ENCODE_RELAX (STATE_COMPLEX_HOP, STATE_BYTE);
1104 p = fragP->fr_literal + old_fr_fix;
1109 p[4] = VAX_PC_RELATIVE_MODE; /* ...(pc) */
1110 fragP->fr_fix += 1 + 2 + 1 + 1 + 4;
1111 fix_new(fragP, old_fr_fix + 5, 4, fragP->fr_symbol, 0,
1112 fragP->fr_offset, 1, NO_RELOC);
1117 case ENCODE_RELAX (STATE_ALWAYS_BRANCH, STATE_UNDF):
1118 if (S_GET_SEGMENT(fragP->fr_symbol) == segment) {
1119 fragP->fr_subtype = ENCODE_RELAX (STATE_ALWAYS_BRANCH, STATE_BYTE);
1121 p = fragP->fr_literal + old_fr_fix;
1122 *fragP->fr_opcode += VAX_WIDEN_LONG;
1123 p[0] = VAX_PC_RELATIVE_MODE; /* ...(PC) */
1124 fragP->fr_fix += 1 + 4;
1125 fix_new(fragP, old_fr_fix + 1, 4, fragP->fr_symbol, 0,
1126 fragP->fr_offset, 1, NO_RELOC);
1134 return (fragP->fr_var + fragP->fr_fix - old_fr_fix);
1135 } /* md_estimate_size_before_relax() */
1138 * md_convert_frag();
1140 * Called after relax() is finished.
1141 * In: Address of frag.
1142 * fr_type == rs_machine_dependent.
1143 * fr_subtype is what the address relaxed to.
1145 * Out: Any fixSs and constants are set up.
1146 * Caller will turn frag into a ".space 0".
1149 md_convert_frag (headers, fragP)
1150 object_headers *headers;
1151 register fragS *fragP;
1153 char *addressP; /* -> _var to change. */
1154 char *opcodeP; /* -> opcode char(s) to change. */
1155 short int length_code; /* 2=long 1=word 0=byte */
1156 short int extension = 0; /* Size of relaxed address. */
1157 /* Added to fr_fix: incl. ALL var chars. */
1160 long address_of_var;
1161 /* Where, in file space, is _var of *fragP? */
1162 long target_address = 0;
1163 /* Where, in file space, does addr point? */
1165 know(fragP->fr_type == rs_machine_dependent);
1166 length_code = fragP->fr_subtype & 3; /* depends on ENCODE_RELAX() */
1167 know(length_code >= 0 && length_code < 3);
1168 where = fragP->fr_fix;
1169 addressP = fragP->fr_literal + where;
1170 opcodeP = fragP->fr_opcode;
1171 symbolP = fragP->fr_symbol;
1173 target_address = S_GET_VALUE(symbolP) + fragP->fr_offset;
1174 address_of_var = fragP->fr_address + where;
1176 switch (fragP->fr_subtype) {
1178 case ENCODE_RELAX(STATE_PC_RELATIVE, STATE_BYTE):
1179 know(*addressP == 0 || *addressP == 0x10); /* '@' bit. */
1180 addressP[0] |= 0xAF; /* Byte displacement. */
1181 addressP[1] = target_address - (address_of_var + 2);
1185 case ENCODE_RELAX(STATE_PC_RELATIVE, STATE_WORD):
1186 know(*addressP == 0 || *addressP == 0x10); /* '@' bit. */
1187 addressP[0] |= 0xCF; /* Word displacement. */
1188 md_number_to_chars(addressP + 1, target_address - (address_of_var + 3), 2);
1192 case ENCODE_RELAX(STATE_PC_RELATIVE, STATE_LONG):
1193 know(*addressP == 0 || *addressP == 0x10); /* '@' bit. */
1194 addressP[0] |= 0xEF; /* Long word displacement. */
1195 md_number_to_chars(addressP + 1, target_address - (address_of_var + 5), 4);
1199 case ENCODE_RELAX(STATE_CONDITIONAL_BRANCH, STATE_BYTE):
1200 addressP[0] = target_address - (address_of_var + 1);
1204 case ENCODE_RELAX(STATE_CONDITIONAL_BRANCH, STATE_WORD):
1205 opcodeP[0] ^= 1; /* Reverse sense of test. */
1207 addressP[1] = VAX_BRB + VAX_WIDEN_WORD;
1208 md_number_to_chars(addressP + 2, target_address - (address_of_var + 4), 2);
1212 case ENCODE_RELAX(STATE_CONDITIONAL_BRANCH, STATE_LONG):
1213 opcodeP[0] ^= 1; /* Reverse sense of test. */
1215 addressP[1] = VAX_JMP;
1216 addressP[2] = VAX_PC_RELATIVE_MODE;
1217 md_number_to_chars(addressP + 3, target_address, 4);
1221 case ENCODE_RELAX(STATE_ALWAYS_BRANCH, STATE_BYTE):
1222 addressP[0] = target_address - (address_of_var + 1);
1226 case ENCODE_RELAX(STATE_ALWAYS_BRANCH, STATE_WORD):
1227 opcodeP[0] += VAX_WIDEN_WORD; /* brb -> brw, bsbb -> bsbw */
1228 md_number_to_chars(addressP, target_address - (address_of_var + 2), 2);
1232 case ENCODE_RELAX(STATE_ALWAYS_BRANCH, STATE_LONG):
1233 opcodeP[0] += VAX_WIDEN_LONG; /* brb -> jmp, bsbb -> jsb */
1234 addressP[0] = VAX_PC_RELATIVE_MODE;
1235 md_number_to_chars(addressP + 1, target_address - (address_of_var + 5), 4);
1239 case ENCODE_RELAX(STATE_COMPLEX_BRANCH, STATE_WORD):
1240 md_number_to_chars(addressP, target_address - (address_of_var + 2), 2);
1244 case ENCODE_RELAX(STATE_COMPLEX_BRANCH, STATE_LONG):
1247 addressP[2] = VAX_BRB;
1249 addressP[4] = VAX_JMP;
1250 addressP[5] = VAX_PC_RELATIVE_MODE;
1251 md_number_to_chars(addressP + 6, target_address, 4);
1255 case ENCODE_RELAX(STATE_COMPLEX_HOP, STATE_BYTE):
1256 addressP[0] = target_address - (address_of_var + 1);
1260 case ENCODE_RELAX(STATE_COMPLEX_HOP, STATE_WORD):
1262 addressP[1] = VAX_BRB;
1264 addressP[3] = VAX_BRW;
1265 md_number_to_chars(addressP + 4, target_address - (address_of_var + 6), 2);
1269 case ENCODE_RELAX(STATE_COMPLEX_HOP, STATE_LONG):
1271 addressP[1] = VAX_BRB;
1273 addressP[3] = VAX_JMP;
1274 addressP[4] = VAX_PC_RELATIVE_MODE;
1275 md_number_to_chars(addressP + 5, target_address, 4);
1280 BAD_CASE(fragP->fr_subtype);
1283 fragP->fr_fix += extension;
1284 } /* md_convert_frag() */
1286 /* Translate internal format of relocation info into target format.
1288 On vax: first 4 bytes are normal unsigned long, next three bytes
1289 are symbolnum, least sig. byte first. Last byte is broken up with
1290 the upper nibble as nuthin, bit 3 as extern, bits 2 & 1 as length, and
1294 md_ri_to_chars (the_bytes, ri)
1296 struct reloc_info_generic ri;
1299 md_number_to_chars(the_bytes, ri.r_address, sizeof (ri.r_address));
1300 /* now the fun stuff */
1301 the_bytes[6] = (ri.r_symbolnum >> 16) & 0x0ff;
1302 the_bytes[5] = (ri.r_symbolnum >> 8) & 0x0ff;
1303 the_bytes[4] = ri.r_symbolnum & 0x0ff;
1304 the_bytes[7] = (((ri.r_extern << 3) & 0x08) | ((ri.r_length << 1) & 0x06) |
1305 ((ri.r_pcrel << 0) & 0x01)) & 0x0F;
1307 #endif /* comment */
1309 void tc_aout_fix_to_chars(where, fixP, segment_address_in_file)
1312 relax_addressT segment_address_in_file;
1315 * In: length of relocation (or of address) in chars: 1, 2 or 4.
1316 * Out: GNU LD relocation length code: 0, 1, or 2.
1319 static unsigned char nbytes_r_length[] = { 42, 0, 1, 42, 2 };
1322 know(fixP->fx_addsy != NULL);
1324 md_number_to_chars(where,
1325 fixP->fx_frag->fr_address + fixP->fx_where - segment_address_in_file,
1328 r_symbolnum = (S_IS_DEFINED(fixP->fx_addsy)
1329 ? S_GET_TYPE(fixP->fx_addsy)
1330 : fixP->fx_addsy->sy_number);
1332 where[6] = (r_symbolnum >> 16) & 0x0ff;
1333 where[5] = (r_symbolnum >> 8) & 0x0ff;
1334 where[4] = r_symbolnum & 0x0ff;
1335 where[7] = ((((!S_IS_DEFINED(fixP->fx_addsy)) << 3) & 0x08)
1336 | ((nbytes_r_length[fixP->fx_size] << 1) & 0x06)
1337 | (((fixP->fx_pcrel << 0) & 0x01) & 0x0f));
1340 } /* tc_aout_fix_to_chars() */
1342 * BUGS, GRIPES, APOLOGIA, etc.
1344 * The opcode table 'votstrs' needs to be sorted on opcode frequency.
1345 * That is, AFTER we hash it with hash_...(), we want most-used opcodes
1346 * to come out of the hash table faster.
1348 * I am sorry to inflict
1349 * yet another VAX assembler on the world, but RMS says we must
1350 * do everything from scratch, to prevent pin-heads restricting
1355 * This is a vaguely modular set of routines in C to parse VAX
1356 * assembly code using DEC mnemonics. It is NOT un*x specific.
1358 * The idea here is that the assembler has taken care of all:
1365 * condensing any whitespace down to exactly one space
1366 * and all we have to do is parse 1 line into a vax instruction
1367 * partially formed. We will accept a line, and deliver:
1368 * an error message (hopefully empty)
1369 * a skeleton VAX instruction (tree structure)
1370 * textual pointers to all the operand expressions
1371 * a warning message that notes a silly operand (hopefully empty)
1375 * E D I T H I S T O R Y
1377 * 17may86 Dean Elsner. Bug if line ends immediately after opcode.
1378 * 30apr86 Dean Elsner. New vip_op() uses arg block so change call.
1379 * 6jan86 Dean Elsner. Crock vip_begin() to call vip_op_defaults().
1380 * 2jan86 Dean Elsner. Invent synthetic opcodes.
1381 * Widen vax_opcodeT to 32 bits. Use a bit for VIT_OPCODE_SYNTHETIC,
1382 * which means this is not a real opcode, it is like a macro; it will
1383 * be relax()ed into 1 or more instructions.
1384 * Use another bit for VIT_OPCODE_SPECIAL if the op-code is not optimised
1385 * like a regular branch instruction. Option added to vip_begin():
1386 * exclude synthetic opcodes. Invent synthetic_votstrs[].
1387 * 31dec85 Dean Elsner. Invent vit_opcode_nbytes.
1388 * Also make vit_opcode into a char[]. We now have n-byte vax opcodes,
1389 * so caller's don't have to know the difference between a 1-byte & a
1390 * 2-byte op-code. Still need vax_opcodeT concept, so we know how
1391 * big an object must be to hold an op.code.
1392 * 30dec85 Dean Elsner. Widen typedef vax_opcodeT in "vax-inst.h"
1393 * because vax opcodes may be 16 bits. Our crufty C compiler was
1394 * happily initialising 8-bit vot_codes with 16-bit numbers!
1395 * (Wouldn't the 'phone company like to compress data so easily!)
1396 * 29dec85 Dean Elsner. New static table vax_operand_width_size[].
1397 * Invented so we know hw many bytes a "I^#42" needs in its immediate
1398 * operand. Revised struct vop in "vax-inst.h": explicitly include
1399 * byte length of each operand, and it's letter-code datum type.
1400 * 17nov85 Dean Elsner. Name Change.
1401 * Due to ar(1) truncating names, we learned the hard way that
1402 * "vax-inst-parse.c" -> "vax-inst-parse." dropping the "o" off
1403 * the archived object name. SO... we shortened the name of this
1404 * source file, and changed the makefile.
1407 static struct hash_control *op_hash = NULL; /* handle of the OPCODE hash table */
1408 /* NULL means any use before vip_begin() */
1412 * In: 1 character, from "bdfghloqpw" being the data-type of an operand
1413 * of a vax instruction.
1415 * Out: the length of an operand of that type, in bytes.
1416 * Special branch operands types "-?!" have length 0.
1419 static const short int vax_operand_width_size[256] =
1423 _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _,
1424 _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _,
1425 _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _,
1426 _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _,
1427 _, _, 1, _, 8, _, 4, 8, 16, _, _, _, 4, _, _, 16, /* ..b.d.fgh...l..o */
1428 _, 8, _, _, _, _, _, 2, _, _, _, _, _, _, _, _, /* .q.....w........ */
1429 _, _, 1, _, 8, _, 4, 8, 16, _, _, _, 4, _, _, 16, /* ..b.d.fgh...l..o */
1430 _, 8, _, _, _, _, _, 2, _, _, _, _, _, _, _, _, /* .q.....w........ */
1431 _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _,
1432 _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _,
1433 _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _,
1434 _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _,
1435 _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _,
1436 _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _,
1437 _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _,
1438 _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _};
1442 * This perversion encodes all the vax opcodes as a bunch of strings.
1443 * RMS says we should build our hash-table at run-time. Hmm.
1444 * Please would someone arrange these in decreasing frequency of opcode?
1445 * Because of the way hash_...() works, the most frequently used opcode
1446 * should be textually first and so on.
1448 * Input for this table was 'vax.opcodes', awk(1)ed by 'vax.opcodes.c.awk' .
1449 * So change 'vax.opcodes', then re-generate this table.
1452 #include "opcode/vax.h"
1455 * This is a table of optional op-codes. All of them represent
1456 * 'synthetic' instructions that seem popular.
1458 * Here we make some pseudo op-codes. Every code has a bit set to say
1459 * it is synthetic. This lets you catch them if you want to
1460 * ban these opcodes. They are mnemonics for "elastic" instructions
1461 * that are supposed to assemble into the fewest bytes needed to do a
1462 * branch, or to do a conditional branch, or whatever.
1464 * The opcode is in the usual place [low-order n*8 bits]. This means
1465 * that if you mask off the bucky bits, the usual rules apply about
1466 * how long the opcode is.
1468 * All VAX branch displacements come at the end of the instruction.
1469 * For simple branches (1-byte opcode + 1-byte displacement) the last
1470 * operand is coded 'b?' where the "data type" '?' is a clue that we
1471 * may reverse the sense of the branch (complement lowest order bit)
1472 * and branch around a jump. This is by far the most common case.
1473 * That is why the VIT_OPCODE_SYNTHETIC bit is set: it says this is
1474 * a 0-byte op-code followed by 2 or more bytes of operand address.
1476 * If the op-code has VIT_OPCODE_SPECIAL set, then we have a more unusual
1479 * For JBSB & JBR the treatment is the similar, except (1) we have a 'bw'
1480 * option before (2) we can directly JSB/JMP because there is no condition.
1481 * These operands have 'b-' as their access/data type.
1483 * That leaves a bunch of random opcodes: JACBx, JxOBxxx. In these
1484 * cases, we do the same idea. JACBxxx are all marked with a 'b!'
1485 * JAOBxxx & JSOBxxx are marked with a 'b:'.
1488 #if (VIT_OPCODE_SYNTHETIC != 0x80000000)
1489 You have just broken the encoding below, which assumes the sign bit
1490 means 'I am an imaginary instruction'.
1493 #if (VIT_OPCODE_SPECIAL != 0x40000000)
1494 You have just broken the encoding below, which assumes the 0x40 M bit means
1495 'I am not to be "optimised" the way normal branches are'.
1498 static const struct vot
1499 synthetic_votstrs[] =
1501 {"jbsb", {"b-", 0xC0000010}}, /* BSD 4.2 */
1502 /* jsb used already */
1503 {"jbr", {"b-", 0xC0000011}}, /* BSD 4.2 */
1504 {"jr", {"b-", 0xC0000011}}, /* consistent */
1505 {"jneq", {"b?", 0x80000012}},
1506 {"jnequ", {"b?", 0x80000012}},
1507 {"jeql", {"b?", 0x80000013}},
1508 {"jeqlu", {"b?", 0x80000013}},
1509 {"jgtr", {"b?", 0x80000014}},
1510 {"jleq", {"b?", 0x80000015}},
1511 /* un-used opcodes here */
1512 {"jgeq", {"b?", 0x80000018}},
1513 {"jlss", {"b?", 0x80000019}},
1514 {"jgtru", {"b?", 0x8000001a}},
1515 {"jlequ", {"b?", 0x8000001b}},
1516 {"jvc", {"b?", 0x8000001c}},
1517 {"jvs", {"b?", 0x8000001d}},
1518 {"jgequ", {"b?", 0x8000001e}},
1519 {"jcc", {"b?", 0x8000001e}},
1520 {"jlssu", {"b?", 0x8000001f}},
1521 {"jcs", {"b?", 0x8000001f}},
1523 {"jacbw", {"rwrwmwb!", 0xC000003d}},
1524 {"jacbf", {"rfrfmfb!", 0xC000004f}},
1525 {"jacbd", {"rdrdmdb!", 0xC000006f}},
1526 {"jacbb", {"rbrbmbb!", 0xC000009d}},
1527 {"jacbl", {"rlrlmlb!", 0xC00000f1}},
1528 {"jacbg", {"rgrgmgb!", 0xC0004ffd}},
1529 {"jacbh", {"rhrhmhb!", 0xC0006ffd}},
1531 {"jbs", {"rlvbb?", 0x800000e0}},
1532 {"jbc", {"rlvbb?", 0x800000e1}},
1533 {"jbss", {"rlvbb?", 0x800000e2}},
1534 {"jbcs", {"rlvbb?", 0x800000e3}},
1535 {"jbsc", {"rlvbb?", 0x800000e4}},
1536 {"jbcc", {"rlvbb?", 0x800000e5}},
1537 {"jbssi", {"rlvbb?", 0x800000e6}},
1538 {"jbcci", {"rlvbb?", 0x800000e7}},
1539 {"jlbs", {"rlb?", 0x800000e8}}, /* JF changed from rlvbb? */
1540 {"jlbc", {"rlb?", 0x800000e9}}, /* JF changed from rlvbb? */
1542 {"jaoblss", {"rlmlb:", 0xC00000f2}},
1543 {"jaobleq", {"rlmlb:", 0xC00000f3}},
1544 {"jsobgeq", {"mlb:", 0xC00000f4}}, /* JF was rlmlb: */
1545 {"jsobgtr", {"mlb:", 0xC00000f5}}, /* JF was rlmlb: */
1547 /* CASEx has no branch addresses in our conception of it. */
1548 /* You should use ".word ..." statements after the "case ...". */
1550 {"", ""} /* empty is end sentinel */
1552 }; /* synthetic_votstrs */
1555 * v i p _ b e g i n ( )
1557 * Call me once before you decode any lines.
1558 * I decode votstrs into a hash table at op_hash (which I create).
1559 * I return an error text: hopefully "".
1560 * If you want, I will include the 'synthetic' jXXX instructions in the
1561 * instruction table.
1562 * You must nominate metacharacters for eg DEC's "#", "@", "^".
1566 vip_begin (synthetic_too, immediate, indirect, displen)
1567 int synthetic_too; /* 1 means include jXXX op-codes. */
1568 char *immediate, *indirect, *displen;
1570 const struct vot *vP; /* scan votstrs */
1571 char *retval; /* error text */
1573 if ((op_hash = hash_new())) {
1574 retval = ""; /* OK so far */
1575 for (vP = votstrs; *vP->vot_name && !*retval; vP++) {
1576 retval = hash_insert(op_hash, vP->vot_name, &vP->vot_detail);
1578 if (synthetic_too) {
1579 for (vP = synthetic_votstrs; *vP->vot_name && !*retval; vP++) {
1580 retval = hash_insert(op_hash, vP->vot_name, &vP->vot_detail);
1584 retval = "virtual memory exceeded";
1587 vip_op_defaults(immediate, indirect, displen);
1597 * Call me once after you have decoded all lines.
1598 * I do any cleaning-up needed.
1600 * We don't have to do any cleanup ourselves: all of our operand
1601 * symbol table is static, and free()ing it is naughty.
1603 static void vip_end () { }
1608 * This converts a string into a vax instruction.
1609 * The string must be a bare single instruction in dec-vax (with BSD4 frobs)
1611 * It provides some error messages: at most one fatal error message (which
1612 * stops the scan) and at most one warning message for each operand.
1613 * The vax instruction is returned in exploded form, since we have no
1614 * knowledge of how you parse (or evaluate) your expressions.
1615 * We do however strip off and decode addressing modes and operation
1618 * The exploded instruction is returned to a struct vit of your choice.
1619 * #include "vax-inst.h" to know what a struct vit is.
1621 * This function's value is a string. If it is not "" then an internal
1622 * logic error was found: read this code to assign meaning to the string.
1623 * No argument string should generate such an error string:
1624 * it means a bug in our code, not in the user's text.
1626 * You MUST have called vip_begin() once and vip_end() never before using
1630 char * /* "" or bug string */
1631 vip (vitP, instring)
1632 struct vit *vitP; /* We build an exploded instruction here. */
1633 char *instring; /* Text of a vax instruction: we modify. */
1635 register struct vot_wot *vwP; /* How to bit-encode this opcode. */
1636 register char *p; /* 1/skip whitespace.2/scan vot_how */
1637 register char *q; /* */
1638 register char *bug; /* "" or program logic error */
1639 register unsigned char count; /* counts number of operands seen */
1640 register struct vop *operandp;/* scan operands in struct vit */
1641 register char *alloperr; /* error over all operands */
1642 register char c; /* Remember char, (we clobber it */
1643 /* with '\0' temporarily). */
1644 register vax_opcodeT oc; /* Op-code of this instruction. */
1649 if (*instring == ' ')
1650 ++instring; /* Skip leading whitespace. */
1651 for (p = instring; *p && *p != ' '; p++) ;; /* MUST end in end-of-string or exactly 1 space. */
1652 /* Scanned up to end of operation-code. */
1653 /* Operation-code is ended with whitespace. */
1654 if (p - instring == 0) {
1655 vitP->vit_error = "No operator";
1657 memset(vitP->vit_opcode, '\0', sizeof(vitP->vit_opcode));
1662 * Here with instring pointing to what better be an op-name, and p
1663 * pointing to character just past that.
1664 * We trust instring points to an op-name, with no whitespace.
1666 vwP = (struct vot_wot *) hash_find(op_hash, instring);
1667 *p = c; /* Restore char after op-code. */
1669 vitP->vit_error = "Unknown operator";
1671 memset(vitP->vit_opcode, '\0', sizeof(vitP->vit_opcode));
1674 * We found a match! So lets pick up as many operands as the
1675 * instruction wants, and even gripe if there are too many.
1676 * We expect comma to seperate each operand.
1677 * We let instring track the text, while p tracks a part of the
1681 * The lines below know about 2-byte opcodes starting FD,FE or FF.
1682 * They also understand synthetic opcodes. Note:
1683 * we return 32 bits of opcode, including bucky bits, BUT
1684 * an opcode length is either 8 or 16 bits for vit_opcode_nbytes.
1686 oc = vwP->vot_code; /* The op-code. */
1687 vitP->vit_opcode_nbytes = (oc & 0xFF) >= 0xFD ? 2 : 1;
1688 md_number_to_chars(vitP->vit_opcode, oc, 4);
1689 count = 0; /* no operands seen yet */
1690 instring = p; /* point just past operation code */
1692 for (p = vwP->vot_how, operandp = vitP->vit_operand;
1693 !*alloperr && !*bug && *p;
1697 * Here to parse one operand. Leave instring pointing just
1698 * past any one ',' that marks the end of this operand.
1701 bug = "p"; /* ODD(!!) number of bytes in vot_how?? */
1702 else if (*instring) {
1703 for (q = instring; (c = *q) && c != ','; q++)
1706 * Q points to ',' or '\0' that ends argument. C is that
1710 operandp->vop_width = p[1];
1711 operandp->vop_nbytes = vax_operand_width_size[p[1]];
1712 operandp->vop_access = p[0];
1713 bug = vip_op (instring, operandp);
1714 *q = c; /* Restore input text. */
1715 if (*(operandp->vop_error))
1716 alloperr = "Bad operand";
1717 instring = q + (c ? 1 : 0); /* next operand (if any) */
1718 count++; /* won another argument, may have an operr */
1720 alloperr = "Not enough operands";
1723 if (*instring == ' ')
1724 instring++; /* Skip whitespace. */
1726 alloperr = "Too many operands";
1728 vitP->vit_error = alloperr;
1731 vitP->vit_operands = count;
1738 * Test program for above.
1741 struct vit myvit; /* build an exploded vax instruction here */
1742 char answer[100]; /* human types a line of vax assembler here */
1743 char *mybug; /* "" or an internal logic diagnostic */
1744 int mycount; /* number of operands */
1745 struct vop *myvop; /* scan operands from myvit */
1746 int mysynth; /* 1 means want synthetic opcodes. */
1747 char my_immediate[200];
1748 char my_indirect[200];
1749 char my_displen[200];
1758 printf ("0 means no synthetic instructions. ");
1759 printf ("Value for vip_begin? ");
1761 sscanf (answer, "%d", &mysynth);
1762 printf ("Synthetic opcodes %s be included.\n", mysynth ? "will" : "will not");
1763 printf ("enter immediate symbols eg enter # ");
1764 gets (my_immediate);
1765 printf ("enter indirect symbols eg enter @ ");
1767 printf ("enter displen symbols eg enter ^ ");
1769 if (*(p = vip_begin (mysynth, my_immediate, my_indirect, my_displen))) {
1770 error ("vip_begin=%s", p);
1772 printf ("An empty input line will quit you from the vax instruction parser\n");
1774 printf ("vax instruction: ");
1778 break; /* out of for each input text loop */
1780 mybug = vip (&myvit, answer);
1782 printf ("BUG:\"%s\"\n", mybug);
1784 if (*myvit.vit_error) {
1785 printf ("ERR:\"%s\"\n", myvit.vit_error);
1788 for (mycount = myvit.vit_opcode_nbytes, p = myvit.vit_opcode;
1792 printf ("%02x ", *p & 0xFF);
1794 printf (" operand count=%d.\n", mycount = myvit.vit_operands);
1795 for (myvop = myvit.vit_operand; mycount; mycount--, myvop++) {
1796 printf ("mode=%xx reg=%xx ndx=%xx len='%c'=%c%c%d. expr=\"",
1797 myvop->vop_mode, myvop->vop_reg, myvop->vop_ndx,
1798 myvop->vop_short, myvop->vop_access, myvop->vop_width,
1800 for (p = myvop->vop_expr_begin; p <= myvop->vop_expr_end; p++) {
1804 if (*myvop->vop_error) {
1805 printf (" err:\"%s\"\n", myvop->vop_error);
1807 if (*myvop->vop_warn) {
1808 printf (" wrn:\"%s\"\n", myvop->vop_warn);
1816 #endif /* #ifdef test */
1818 /* end of vax_ins_parse.c */
1820 /* JF this used to be a separate file also */
1821 /* vax_reg_parse.c - convert a VAX register name to a number */
1823 /* Copyright (C) 1987 Free Software Foundation, Inc. A part of GNU. */
1826 * v a x _ r e g _ p a r s e ( )
1828 * Take 3 char.s, the last of which may be `\0` (non-existent)
1829 * and return the VAX register number that they represent.
1831 * Return -1 if they don't form a register name. Good names return
1832 * a number from 0:15 inclusive.
1834 * Case is not important in a name.
1836 * Register names understood are:
1863 int /* return -1 or 0:15 */
1864 vax_reg_parse (c1, c2, c3) /* 3 chars of register name */
1865 char c1, c2, c3; /* c3 == 0 if 2-character reg name */
1867 register int retval; /* return -1:15 */
1875 if (isdigit (c2) && c1 == 'r') {
1878 retval = retval * 10 + c3 - '0';
1879 retval = (retval > 15) ? -1 : retval;
1880 /* clamp the register value to 1 hex digit */
1882 retval = -1; /* c3 must be '\0' or a digit */
1883 } else if (c3) /* There are no three letter regs */
1885 else if (c2 == 'p') {
1899 } else if (c1 == 'p' && c2 == 'c')
1909 * Parse a vax operand in DEC assembler notation.
1910 * For speed, expect a string of whitespace to be reduced to a single ' '.
1911 * This is the case for GNU AS, and is easy for other DEC-compatible
1914 * Knowledge about DEC VAX assembler operand notation lives here.
1915 * This doesn't even know what a register name is, except it believes
1916 * all register names are 2 or 3 characters, and lets vax_reg_parse() say
1917 * what number each name represents.
1918 * It does, however, know that PC, SP etc are special registers so it can
1919 * detect addressing modes that are silly for those registers.
1921 * Where possible, it delivers 1 fatal or 1 warning message if the operand
1922 * is suspect. Exactly what we test for is still evolving.
1930 * There were a number of 'mismatched argument type' bugs to vip_op.
1931 * The most general solution is to typedef each (of many) arguments.
1932 * We used instead a typedef'd argument block. This is less modular
1933 * than using seperate return pointers for each result, but runs faster
1934 * on most engines, and seems to keep programmers happy. It will have
1935 * to be done properly if we ever want to use vip_op as a general-purpose
1936 * module (it was designed to be).
1940 * Doesn't support DEC "G^" format operands. These always take 5 bytes
1941 * to express, and code as modes 8F or 9F. Reason: "G^" deprives you of
1942 * optimising to (say) a "B^" if you are lucky in the way you link.
1943 * When someone builds a linker smart enough to convert "G^" to "B^", "W^"
1944 * whenever possible, then we should implement it.
1945 * If there is some other use for "G^", feel free to code it in!
1950 * If I nested if ()s more, I could avoid testing (*err) which would save
1951 * time, space and page faults. I didn't nest all those if ()s for clarity
1952 * and because I think the mode testing can be re-arranged 1st to test the
1953 * commoner constructs 1st. Does anybody have statistics on this?
1959 * In future, we should be able to 'compose' error messages in a scratch area
1960 * and give the user MUCH more informative error messages. Although this takes
1961 * a little more code at run-time, it will make this module much more self-
1962 * documenting. As an example of what sucks now: most error messages have
1963 * hardwired into them the DEC VAX metacharacters "#^@" which are nothing like
1964 * the Un*x characters "$`*", that most users will expect from this AS.
1968 * The input is a string, ending with '\0'.
1970 * We also require a 'hint' of what kind of operand is expected: so
1971 * we can remind caller not to write into literals for instance.
1973 * The output is a skeletal instruction.
1975 * The algorithm has two parts.
1976 * 1. extract the syntactic features (parse off all the @^#-()+[] mode crud);
1977 * 2. express the @^#-()+[] as some parameters suited to further analysis.
1979 * 2nd step is where we detect the googles of possible invalid combinations
1980 * a human (or compiler) might write. Note that if we do a half-way
1981 * decent assembler, we don't know how long to make (eg) displacement
1982 * fields when we first meet them (because they may not have defined values).
1983 * So we must wait until we know how many bits are needed for each address,
1984 * then we can know both length and opcodes of instructions.
1985 * For reason(s) above, we will pass to our caller a 'broken' instruction
1986 * of these major components, from which our caller can generate instructions:
1987 * - displacement length I^ S^ L^ B^ W^ unspecified
1989 * - register R0-R15 or absent
1990 * - index register R0-R15 or absent
1991 * - expression text what we don't parse
1992 * - error text(s) why we couldn't understand the operand
1996 * To decode output of this, test errtxt. If errtxt[0] == '\0', then
1997 * we had no errors that prevented parsing. Also, if we ever report
1998 * an internal bug, errtxt[0] is set non-zero. So one test tells you
1999 * if the other outputs are to be taken seriously.
2003 /* vax registers we need to know */
2004 /* JF #define SP (14) */
2005 /* JF for one big happy file #define PC (15) */
2008 * Because this module is useful for both VMS and UN*X style assemblers
2009 * and because of the variety of UN*X assemblers we must recognise
2010 * the different conventions for assembler operand notation. For example
2011 * VMS says "#42" for immediate mode, while most UN*X say "$42".
2012 * We permit arbitrary sets of (single) characters to represent the
2013 * 3 concepts that DEC writes '#', '@', '^'.
2016 /* character tests */
2017 #define VIP_IMMEDIATE 01 /* Character is like DEC # */
2018 #define VIP_INDIRECT 02 /* Char is like DEC @ */
2019 #define VIP_DISPLEN 04 /* Char is like DEC ^ */
2021 #define IMMEDIATEP(c) (vip_metacharacters[(c)&0xff]&VIP_IMMEDIATE)
2022 #define INDIRECTP(c) (vip_metacharacters[(c)&0xff]&VIP_INDIRECT)
2023 #define DISPLENP(c) (vip_metacharacters[(c)&0xff]&VIP_DISPLEN)
2025 /* We assume 8 bits per byte. Use vip_op_defaults() to set these up BEFORE we
2029 #if defined(CONST_TABLE)
2031 #define I VIP_IMMEDIATE,
2032 #define S VIP_INDIRECT,
2033 #define D VIP_DISPLEN,
2035 vip_metacharacters[256] = {
2036 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _/* ^@ ^A ^B ^C ^D ^E ^F ^G ^H ^I ^J ^K ^L ^M ^N ^O*/
2037 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _/* ^P ^Q ^R ^S ^T ^U ^V ^W ^X ^Y ^Z ^[ ^\ ^] ^^ ^_ */
2038 _ _ _ _ I _ _ _ _ _ S _ _ _ _ _/* sp ! " # $ % & ' ( ) * + , - . / */
2039 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _/*0 1 2 3 4 5 6 7 8 9 : ; < = > ?*/
2040 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _/*@ A B C D E F G H I J K L M N O*/
2041 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _/*P Q R S T U V W X Y Z [ \ ] ^ _*/
2042 D _ _ _ _ _ _ _ _ _ _ _ _ _ _ _/*` a b c d e f g h i j k l m n o*/
2043 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _/*p q r s t u v w x y z { | } ~ ^?*/
2045 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
2046 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
2047 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
2048 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
2049 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
2050 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
2051 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
2052 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
2059 static char vip_metacharacters[256];
2061 /* Macro is faster under GCC; The constant table is faster yet, but only works with ASCII */
2075 vip_metacharacters[t]|=bit;
2078 #define vip_op_1(bit,syms) { \
2080 char *table=vip_metacharacters; \
2081 while (t= *syms++) \
2086 static void vip_op_defaults(immediate, indirect, displen) /* can be called any time */
2087 char *immediate; /* Strings of characters for each job. */
2089 char *displen; /* more arguments may appear in future! */
2091 vip_op_1 (VIP_IMMEDIATE, immediate);
2092 vip_op_1 (VIP_INDIRECT, indirect);
2093 vip_op_1 (VIP_DISPLEN, displen);
2101 * Dec defines the semantics of address modes (and values)
2102 * by a two-letter code, explained here.
2104 * letter 1: access type
2106 * a address calculation - no data access, registers forbidden
2107 * b branch displacement
2108 * m read - let go of bus - write back "modify"
2110 * v bit field address: like 'a' but registers are OK
2112 * space no operator (eg ".long foo") [our convention]
2114 * letter 2: data type (i.e. width, alignment)
2117 * d double precision floating point (D format)
2118 * f single precision floating point (F format)
2119 * g G format floating
2120 * h H format floating
2125 * ? simple synthetic branch operand
2126 * - unconditional synthetic JSB/JSR operand
2127 * ! complex synthetic branch operand
2129 * The '-?!' letter 2's are not for external consumption. They are used
2130 * for various assemblers. Generally, all unknown widths are assumed 0.
2131 * We don't limit your choice of width character.
2133 * DEC operands are hard work to parse. For example, '@' as the first
2134 * character means indirect (deferred) mode but elswhere it is a shift
2136 * The long-winded explanation of how this is supposed to work is
2137 * cancelled. Read a DEC vax manual.
2138 * We try hard not to parse anything that MIGHT be part of the expression
2139 * buried in that syntax. For example if we see @...(Rn) we don't check
2140 * for '-' before the '(' because mode @-(Rn) does not exist.
2142 * After parsing we have:
2144 * at 1 if leading '@' (or Un*x '*')
2145 * len takes one value from " bilsw". eg B^ -> 'b'.
2146 * hash 1 if leading '#' (or Un*x '$')
2147 * expr_begin, expr_end the expression we did not parse
2148 * even though we don't interpret it, we make use
2149 * of its presence or absence.
2150 * sign -1: -(Rn) 0: absent +1: (Rn)+
2151 * paren 1 if () are around register
2152 * reg major register number 0:15 -1 means absent
2153 * ndx index register number 0:15 -1 means absent
2155 * Again, I dare not explain it: just trace ALL the code!
2158 char * /* (code here) bug message, "" = OK */
2159 /* our code bug, NOT bad assembly language */
2160 vip_op (optext, vopP)
2161 char *optext; /* user's input string e.g.: */
2162 /* "@B^foo@bar(AP)[FP]:" */
2163 struct vop *vopP; /* In: vop_access, vop_width. */
2164 /* Out: _ndx, _reg, _mode, _short, _warn, */
2165 /* _error _expr_begin, _expr_end, _nbytes. */
2166 /* vop_nbytes : number of bytes in a datum. */
2168 char *p; /* track operand text forward */
2169 char *q; /* track operand text backward */
2170 int at; /* 1 if leading '@' ('*') seen */
2171 char len; /* one of " bilsw" */
2172 int hash; /* 1 if leading '#' ('$') seen */
2173 int sign = 0; /* -1, 0 or +1 */
2174 int paren = 0; /* 1 if () surround register */
2175 int reg = 0; /* register number, -1:absent */
2176 int ndx = 0; /* index register number -1:absent */
2177 char *bug; /* report any logic error in here, "" == OK */
2178 char *err; /* report illegal operand, "" == OK */
2179 /* " " is a FAKE error: means we won */
2180 /* ANY err that begins with ' ' is a fake. */
2181 /* " " is converted to "" before return */
2182 char *wrn; /* warn about weird modes pf address */
2183 char *oldq = NULL; /* preserve q in case we backup */
2184 int mode = 0; /* build up 4-bit operand mode here */
2185 /* note: index mode is in ndx, this is */
2186 /* the major mode of operand address */
2188 * Notice how we move wrong-arg-type bugs INSIDE this module: if we
2189 * get the types wrong below, we lose at compile time rather than at
2192 char access; /* vop_access. */
2193 char width; /* vop_width. */
2195 int vax_reg_parse (); /* returns 0:15 or -1 if not a register */
2197 access = vopP->vop_access;
2198 width = vopP->vop_width;
2199 bug = /* none of our code bugs (yet) */
2200 err = /* no user text errors */
2201 wrn = ""; /* no warnings even */
2205 if (*p == ' ') /* Expect all whitespace reduced to ' '. */
2206 p++; /* skip over whitespace */
2208 if (at = INDIRECTP (*p)) { /* 1 if *p == '@'(or '*' for Un*x) */
2209 p++; /* at is determined */
2210 if (*p == ' ') /* Expect all whitespace reduced to ' '. */
2211 p++; /* skip over whitespace */
2215 * This code is subtle. It tries to detect all legal (letter)'^'
2216 * but it doesn't waste time explicitly testing for premature '\0' because
2217 * this case is rejected as a mismatch against either (letter) or '^'.
2225 if (DISPLENP (p[1]) && strchr ("bilws", len = c))
2226 p += 2; /* skip (letter) '^' */
2227 else /* no (letter) '^' seen */
2228 len = ' '; /* len is determined */
2231 if (*p == ' ') /* Expect all whitespace reduced to ' '. */
2232 p++; /* skip over whitespace */
2234 if (hash = IMMEDIATEP (*p)) /* 1 if *p == '#' ('$' for Un*x) */
2235 p++; /* hash is determined */
2238 * p points to what may be the beginning of an expression.
2239 * We have peeled off the front all that is peelable.
2240 * We know at, len, hash.
2242 * Lets point q at the end of the text and parse that (backwards).
2245 for (q = p; *q; q++)
2247 q--; /* now q points at last char of text */
2249 if (*q == ' ' && q >= p) /* Expect all whitespace reduced to ' '. */
2251 /* reverse over whitespace, but don't */
2252 /* run back over *p */
2255 * As a matter of policy here, we look for [Rn], although both Rn and S^#
2256 * forbid [Rn]. This is because it is easy, and because only a sick
2257 * cyborg would have [...] trailing an expression in a VAX-like assembler.
2258 * A meticulous parser would first check for Rn followed by '(' or '['
2259 * and not parse a trailing ']' if it found another. We just ban expressions
2263 while (q >= p && *q != '[')
2265 /* either q<p or we got matching '[' */
2267 err = "no '[' to match ']'";
2270 * Confusers like "[]" will eventually lose with a bad register
2271 * name error. So again we don't need to check for early '\0'.
2274 ndx = vax_reg_parse (q[1], q[2], 0);
2275 else if (q[4] == ']')
2276 ndx = vax_reg_parse (q[1], q[2], q[3]);
2280 * Since we saw a ']' we will demand a register name in the [].
2281 * If luser hasn't given us one: be rude.
2284 err = "bad register in []";
2286 err = "[PC] index banned";
2288 q--; /* point q just before "[...]" */
2291 ndx = -1; /* no ']', so no iNDeX register */
2294 * If err = "..." then we lost: run away.
2295 * Otherwise ndx == -1 if there was no "[...]".
2296 * Otherwise, ndx is index register number, and q points before "[...]".
2299 if (*q == ' ' && q >= p) /* Expect all whitespace reduced to ' '. */
2301 /* reverse over whitespace, but don't */
2302 /* run back over *p */
2304 sign = 0; /* no ()+ or -() seen yet */
2306 if (q > p + 3 && *q == '+' && q[-1] == ')') {
2307 sign = 1; /* we saw a ")+" */
2308 q--; /* q points to ')' */
2311 if (*q == ')' && q > p + 2) {
2312 paren = 1; /* assume we have "(...)" */
2313 while (q >= p && *q != '(')
2315 /* either q<p or we got matching '(' */
2317 err = "no '(' to match ')'";
2320 * Confusers like "()" will eventually lose with a bad register
2321 * name error. So again we don't need to check for early '\0'.
2324 reg = vax_reg_parse (q[1], q[2], 0);
2325 else if (q[4] == ')')
2326 reg = vax_reg_parse (q[1], q[2], q[3]);
2330 * Since we saw a ')' we will demand a register name in the ')'.
2331 * This is nasty: why can't our hypothetical assembler permit
2332 * parenthesised expressions? BECAUSE I AM LAZY! That is why.
2333 * Abuse luser if we didn't spy a register name.
2336 /* JF allow parenthasized expressions. I hope this works */
2340 /* err = "unknown register in ()"; */
2342 q--; /* point just before '(' of "(...)" */
2344 * If err == "..." then we lost. Run away.
2345 * Otherwise if reg >= 0 then we saw (Rn).
2349 * If err == "..." then we lost.
2350 * Otherwise paren == 1 and reg = register in "()".
2355 * If err == "..." then we lost.
2356 * Otherwise, q points just before "(Rn)", if any.
2357 * If there was a "(...)" then paren == 1, and reg is the register.
2361 * We should only seek '-' of "-(...)" if:
2362 * we saw "(...)" paren == 1
2363 * we have no errors so far ! *err
2364 * we did not see '+' of "(...)+" sign < 1
2365 * We don't check len. We want a specific error message later if
2366 * user tries "x^...-(Rn)". This is a feature not a bug.
2369 if (paren && sign < 1)/* !sign is adequate test */ {
2376 * We have back-tracked over most
2377 * of the crud at the end of an operand.
2378 * Unless err, we know: sign, paren. If paren, we know reg.
2379 * The last case is of an expression "Rn".
2380 * This is worth hunting for if !err, !paren.
2381 * We wouldn't be here if err.
2382 * We remember to save q, in case we didn't want "Rn" anyway.
2385 if (*q == ' ' && q >= p) /* Expect all whitespace reduced to ' '. */
2387 /* reverse over whitespace, but don't */
2388 /* run back over *p */
2389 if (q > p && q < p + 3) /* room for Rn or Rnn exactly? */
2390 reg = vax_reg_parse (p[0], p[1], q < p + 2 ? 0 : p[2]);
2392 reg = -1; /* always comes here if no register at all */
2394 * Here with a definitive reg value.
2404 * have reg. -1:absent; else 0:15
2408 * We have: err, at, len, hash, ndx, sign, paren, reg.
2409 * Also, any remaining expression is from *p through *q inclusive.
2410 * Should there be no expression, q == p-1. So expression length = q-p+1.
2411 * This completes the first part: parsing the operand text.
2415 * We now want to boil the data down, checking consistency on the way.
2416 * We want: len, mode, reg, ndx, err, p, q, wrn, bug.
2417 * We will deliver a 4-bit reg, and a 4-bit mode.
2421 * Case of branch operand. Different. No L^B^W^I^S^ allowed for instance.
2435 * p:q whatever was input
2437 * err " " or error message, and other outputs trashed
2439 /* branch operands have restricted forms */
2440 if (!*err && access == 'b') {
2441 if (at || hash || sign || paren || ndx >= 0 || reg >= 0 || len != ' ')
2442 err = "invalid branch operand";
2447 /* Since nobody seems to use it: comment this 'feature'(?) out for now. */
2450 * Case of stand-alone operand. e.g. ".long foo"
2464 * p:q whatever was input
2466 * err " " or error message, and other outputs trashed
2469 if (access == ' ') { /* addresses have restricted forms */
2471 err = "address prohibits @";
2474 err = "address prohibits #";
2478 err = "address prohibits -()";
2480 err = "address prohibits ()+";
2483 err = "address prohibits ()";
2486 err = "address prohibits []";
2489 err = "address prohibits register";
2492 err = "address prohibits displacement length specifier";
2494 err = " "; /* succeed */
2505 #endif /*#Ifdef NEVER*/
2511 * len 's' definition
2513 * p:q demand not empty
2514 * sign 0 by paren == 0
2515 * paren 0 by "()" scan logic because "S^" seen
2516 * reg -1 or nn by mistake
2525 if (!*err && len == 's') {
2526 if (!hash || paren || at || ndx >= 0)
2527 err = "invalid operand of S^#";
2531 * SHIT! we saw S^#Rnn ! put the Rnn back in
2532 * expression. KLUDGE! Use oldq so we don't
2533 * need to know exact length of reg name.
2539 * We have all the expression we will ever get.
2542 err = "S^# needs expression";
2543 else if (access == 'r') {
2544 err = " "; /* WIN! */
2547 err = "S^# may only read-access";
2552 * Case of -(Rn), which is weird case.
2558 * sign -1 by definition
2559 * paren 1 by definition
2560 * reg present by definition
2566 * exp "" enforce empty expression
2567 * ndx optional warn if same as reg
2569 if (!*err && sign < 0) {
2570 if (len != ' ' || hash || at || p <= q)
2571 err = "invalid operand of -()";
2573 err = " "; /* win */
2576 wrn = "-(PC) unpredictable";
2577 else if (reg == ndx)
2578 wrn = "[]index same as -()register: unpredictable";
2583 * We convert "(Rn)" to "@Rn" for our convenience.
2584 * (I hope this is convenient: has someone got a better way to parse this?)
2585 * A side-effect of this is that "@Rn" is a valid operand.
2587 if (paren && !sign && !hash && !at && len == ' ' && p > q) {
2593 * Case of (Rn)+, which is slightly different.
2599 * sign +1 by definition
2600 * paren 1 by definition
2601 * reg present by definition
2607 * exp "" enforce empty expression
2608 * ndx optional warn if same as reg
2610 if (!*err && sign > 0) {
2611 if (len != ' ' || hash || p <= q)
2612 err = "invalid operand of ()+";
2614 err = " "; /* win */
2615 mode = 8 + (at ? 1 : 0);
2617 wrn = "(PC)+ unpredictable";
2618 else if (reg == ndx)
2619 wrn = "[]index same as ()+register: unpredictable";
2624 * Case of #, without S^.
2628 * hash 1 by definition
2641 if (!*err && hash) {
2642 if (len != 'i' && len != ' ')
2643 err = "# conflicts length";
2645 err = "# bars register";
2649 * SHIT! we saw #Rnn! Put the Rnn back into the expression.
2650 * By using oldq, we don't need to know how long Rnn was.
2654 reg = -1; /* no register any more */
2656 err = " "; /* win */
2658 /* JF a bugfix, I think! */
2659 if (at && access == 'a')
2662 mode = (at ? 9 : 8);
2664 if ((access == 'm' || access == 'w') && !at)
2665 wrn = "writing or modifying # is unpredictable";
2669 * If !*err, then sign == 0
2674 * Case of Rn. We seperate this one because it has a few special
2675 * errors the remaining modes lack.
2679 * hash 0 by program logic
2681 * sign 0 by program logic
2682 * paren 0 by definition
2683 * reg present by definition
2688 * len ' ' enforce no length
2689 * exp "" enforce empty expression
2690 * ndx optional warn if same as reg
2692 if (!*err && !paren && reg >= 0) {
2694 err = "length not needed";
2696 err = " "; /* win */
2698 } else if (ndx >= 0)
2699 err = "can't []index a register, because it has no address";
2700 else if (access == 'a')
2701 err = "a register has no address";
2704 * Idea here is to detect from length of datum
2705 * and from register number if we will touch PC.
2707 * vop_nbytes is number of bytes in operand.
2708 * Compute highest byte affected, compare to PC0.
2710 if ((vopP->vop_nbytes + reg * 4) > 60)
2711 wrn = "PC part of operand unpredictable";
2712 err = " "; /* win */
2717 * If !*err, sign == 0
2719 * paren == 1 OR reg == -1
2723 * Rest of cases fit into one bunch.
2726 * len ' ' or 'b' or 'w' or 'l'
2727 * hash 0 by program logic
2728 * p:q expected (empty is not an error)
2729 * sign 0 by program logic
2734 * out: mode 10 + @ + len
2736 * len ' ' or 'b' or 'w' or 'l'
2738 * ndx optional warn if same as reg
2741 err = " "; /* win (always) */
2742 mode = 10 + (at ? 1 : 0);
2748 case ' ': /* assumed B^ until our caller changes it */
2755 * here with completely specified mode
2763 err = ""; /* " " is no longer an error */
2765 vopP->vop_mode = mode;
2766 vopP->vop_reg = reg;
2767 vopP->vop_short = len;
2768 vopP->vop_expr_begin = p;
2769 vopP->vop_expr_end = q;
2770 vopP->vop_ndx = ndx;
2771 vopP->vop_error = err;
2772 vopP->vop_warn = wrn;
2779 Summary of vip_op outputs.
2783 {@}Rn 5+@ n ' ' optional
2784 branch operand 0 -1 ' ' -1
2786 -(Rn) 7 n ' ' optional
2787 {@}(Rn)+ 8+@ n ' ' optional
2788 {@}#foo, no S^ 8+@ PC " i" optional
2789 {@}{q^}{(Rn)} 10+@+q option " bwl" optional
2793 #ifdef TEST /* #Define to use this testbed. */
2796 * Follows a test program for this function.
2797 * We declare arrays non-local in case some of our tiny-minded machines
2798 * default to small stacks. Also, helps with some debuggers.
2803 char answer[100]; /* human types into here */
2816 int my_operand_length;
2817 char my_immediate[200];
2818 char my_indirect[200];
2819 char my_displen[200];
2823 char *vip_op (); /* make cc happy */
2825 printf ("enter immediate symbols eg enter # ");
2826 gets (my_immediate);
2827 printf ("enter indirect symbols eg enter @ ");
2829 printf ("enter displen symbols eg enter ^ ");
2831 vip_op_defaults (my_immediate, my_indirect, my_displen);
2833 printf ("access,width (eg 'ab' or 'wh') [empty line to quit] : ");
2838 myaccess = answer[0];
2839 mywidth = answer[1];
2842 my_operand_length = 1;
2845 my_operand_length = 8;
2848 my_operand_length = 4;
2851 my_operand_length = 16;
2854 my_operand_length = 32;
2857 my_operand_length = 4;
2860 my_operand_length = 16;
2863 my_operand_length = 8;
2866 my_operand_length = 2;
2871 my_operand_length = 0;
2875 my_operand_length = 2;
2876 printf ("I dn't understand access width %c\n", mywidth);
2879 printf ("VAX assembler instruction operand: ");
2882 mybug = vip_op (answer, myaccess, mywidth, my_operand_length,
2883 &mymode, &myreg, &mylen, &myleft, &myright, &myndx,
2886 printf ("error: \"%s\"\n", myerr);
2888 printf (" bug: \"%s\"\n", mybug);
2891 printf ("warning: \"%s\"\n", mywrn);
2892 mumble ("mode", mymode);
2893 mumble ("register", myreg);
2894 mumble ("index", myndx);
2895 printf ("width:'%c' ", mylen);
2896 printf ("expression: \"");
2897 while (myleft <= myright)
2898 putchar (*myleft++);
2904 mumble (text, value)
2908 printf ("%s:", text);
2910 printf ("%xx", value);
2916 #endif /* ifdef TEST */
2920 const int md_short_jump_size = 3;
2921 const int md_long_jump_size = 6;
2922 const int md_reloc_size = 8; /* Size of relocation record */
2925 md_create_short_jump (ptr, from_addr, to_addr, frag, to_symbol)
2927 long from_addr, to_addr;
2933 offset = to_addr - (from_addr + 1);
2935 md_number_to_chars(ptr, offset, 2);
2939 md_create_long_jump (ptr, from_addr, to_addr, frag, to_symbol)
2941 long from_addr, to_addr;
2947 offset = to_addr - S_GET_VALUE(to_symbol);
2950 md_number_to_chars(ptr, offset, 4);
2951 fix_new(frag, ptr - frag->fr_literal, 4, to_symbol, (symbolS *) 0, (long) 0, 0, NO_RELOC);
2955 extern char vms_name_mapping;
2959 md_parse_option (argP, cntP, vecP)
2964 char *temp_name; /* name for -t or -d options */
2969 /* as_warn ("I can do better than -J!"); */
2973 as_warn ("SYMBOL TABLE not implemented");
2974 break; /* SYMBOL TABLE not implemented */
2977 as_warn ("TOKEN TRACE not implemented");
2978 break; /* TOKEN TRACE not implemented */
2983 if (**argP) { /* Rest of argument is filename. */
2991 temp_name = *++(*vecP);
2992 **vecP = NULL; /* Remember this is not a file-name. */
2994 as_warn ("I expected a filename after -%c.",opt);
2995 temp_name = "{absent}";
2999 as_warn ("Displacement length %s ignored!", temp_name);
3001 as_warn ("I don't need or use temp. file \"%s\".", temp_name);
3005 as_warn ("I don't use an interpass file! -V ignored");
3009 case '+': /* For g++ */
3012 case '1': /* For backward compatibility */
3015 case 'h': /* No hashing of mixed-case names */
3016 vms_name_mapping = 0;
3018 if (**argP) vms_name_mapping = *((*argP)++) - '0';
3022 case 'H': /* Show new symbol after hash truncation */
3033 /* We have no need to default values of symbols. */
3037 md_undefined_symbol (name)
3043 /* Parse an operand that is machine-specific.
3044 We just return without modifying the expression if we have nothing
3049 md_operand (expressionP)
3050 expressionS *expressionP;
3054 /* Round up a section size to the appropriate boundary. */
3056 md_section_align (segment, size)
3060 return size; /* Byte alignment is fine */
3063 /* Exactly what point is a PC-relative offset relative TO?
3064 On the vax, they're relative to the address of the offset, plus
3065 its size. (??? Is this right? FIXME-SOON) */
3067 md_pcrel_from (fixP)
3070 return fixP->fx_size + fixP->fx_where + fixP->fx_frag->fr_address;
3073 /* end of tc-vax.c */
projects / dragonfly.git / blob