1 /* tc-vax.c - vax-specific -
2 Copyright 1987, 1991, 1992, 1993, 1994, 1995, 1998, 2000, 2001, 2002
3 Free Software Foundation, Inc.
5 This file is part of GAS, the GNU Assembler.
7 GAS is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GAS is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GAS; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
25 #include "obstack.h" /* For FRAG_APPEND_1_CHAR macro in "frags.h" */
32 /* These chars start a comment anywhere in a source file (except inside
34 const char comment_chars[] = "#";
36 /* These chars only start a comment at the beginning of a line. */
37 /* Note that for the VAX the are the same as comment_chars above. */
38 const char line_comment_chars[] = "#";
40 const char line_separator_chars[] = ";";
42 /* Chars that can be used to separate mant from exp in floating point nums */
43 const char EXP_CHARS[] = "eE";
45 /* Chars that mean this number is a floating point constant */
47 /* or 0H1.234E-12 (see exp chars above) */
48 const char FLT_CHARS[] = "dDfFgGhH";
50 /* Also be aware that MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT may have to be
51 changed in read.c . Ideally it shouldn't have to know about it at all,
52 but nothing is ideal around here. */
54 /* Hold details of an operand expression */
55 static expressionS exp_of_operand[VIT_MAX_OPERANDS];
56 static segT seg_of_operand[VIT_MAX_OPERANDS];
58 /* A vax instruction after decoding. */
61 /* Hold details of big operands. */
62 LITTLENUM_TYPE big_operand_bits[VIT_MAX_OPERANDS][SIZE_OF_LARGE_NUMBER];
63 FLONUM_TYPE float_operand[VIT_MAX_OPERANDS];
64 /* Above is made to point into big_operand_bits by md_begin(). */
67 #define GLOBAL_OFFSET_TABLE_NAME "_GLOBAL_OFFSET_TABLE_"
68 #define PROCEDURE_LINKAGE_TABLE_NAME "_PROCEDURE_LINKAGE_TABLE_"
69 symbolS *GOT_symbol; /* Pre-defined "_GLOBAL_OFFSET_TABLE_" */
70 symbolS *PLT_symbol; /* Pre-defined "_PROCEDURE_LINKAGE_TABLE_" */
73 int flag_hash_long_names; /* -+ */
74 int flag_one; /* -1 */
75 int flag_show_after_trunc; /* -H */
76 int flag_no_hash_mixed_case; /* -h NUM */
78 int flag_want_pic; /* -k */
82 * For VAX, relative addresses of "just the right length" are easy.
83 * The branch displacement is always the last operand, even in
84 * synthetic instructions.
85 * For VAX, we encode the relax_substateTs (in e.g. fr_substate) as:
87 * 4 3 2 1 0 bit number
88 * ---/ /--+-------+-------+-------+-------+-------+
89 * | what state ? | how long ? |
90 * ---/ /--+-------+-------+-------+-------+-------+
92 * The "how long" bits are 00=byte, 01=word, 10=long.
93 * This is a Un*x convention.
94 * Not all lengths are legit for a given value of (what state).
95 * The "how long" refers merely to the displacement length.
96 * The address usually has some constant bytes in it as well.
99 groups for VAX address relaxing.
101 1. "foo" pc-relative.
102 length of byte, word, long
104 2a. J<cond> where <cond> is a simple flag test.
105 length of byte, word, long.
106 VAX opcodes are: (Hex)
119 Always, you complement 0th bit to reverse condition.
120 Always, 1-byte opcode, then 1-byte displacement.
122 2b. J<cond> where cond tests a memory bit.
123 length of byte, word, long.
124 Vax opcodes are: (Hex)
131 Always, you complement 0th bit to reverse condition.
132 Always, 1-byte opcde, longword-address, byte-address, 1-byte-displacement
134 2c. J<cond> where cond tests low-order memory bit
135 length of byte,word,long.
136 Vax opcodes are: (Hex)
139 Always, you complement 0th bit to reverse condition.
140 Always, 1-byte opcode, longword-address, 1-byte displacement.
143 length of byte,word,long.
144 Vax opcodes are: (Hex)
147 These are like (2) but there is no condition to reverse.
148 Always, 1 byte opcode, then displacement/absolute.
151 length of word, long.
152 Vax opcodes are: (Hex)
160 Always, we cannot reverse the sense of the branch; we have a word
162 The double-byte op-codes don't hurt: we never want to modify the
163 opcode, so we don't care how many bytes are between the opcode and
167 length of long, long, byte.
168 Vax opcodes are: (Hex)
173 Always, we cannot reverse the sense of the branch; we have a byte
176 The only time we need to modify the opcode is for class 2 instructions.
177 After relax() we may complement the lowest order bit of such instruction
178 to reverse sense of branch.
180 For class 2 instructions, we store context of "where is the opcode literal".
181 We can change an opcode's lowest order bit without breaking anything else.
183 We sometimes store context in the operand literal. This way we can figure out
184 after relax() what the original addressing mode was.
187 /* These displacements are relative to the start address of the
188 displacement. The first letter is Byte, Word. 2nd letter is
189 Forward, Backward. */
192 #define WF (2+ 32767)
193 #define WB (2+-32768)
194 /* Dont need LF, LB because they always reach. [They are coded as 0.] */
196 #define C(a,b) ENCODE_RELAX(a,b)
197 /* This macro has no side-effects. */
198 #define ENCODE_RELAX(what,length) (((what) << 2) + (length))
199 #define RELAX_STATE(s) ((s) >> 2)
200 #define RELAX_LENGTH(s) ((s) & 3)
202 const relax_typeS md_relax_table[] =
204 {1, 1, 0, 0}, /* error sentinel 0,0 */
205 {1, 1, 0, 0}, /* unused 0,1 */
206 {1, 1, 0, 0}, /* unused 0,2 */
207 {1, 1, 0, 0}, /* unused 0,3 */
209 {BF + 1, BB + 1, 2, C (1, 1)},/* B^"foo" 1,0 */
210 {WF + 1, WB + 1, 3, C (1, 2)},/* W^"foo" 1,1 */
211 {0, 0, 5, 0}, /* L^"foo" 1,2 */
212 {1, 1, 0, 0}, /* unused 1,3 */
214 {BF, BB, 1, C (2, 1)}, /* b<cond> B^"foo" 2,0 */
215 {WF + 2, WB + 2, 4, C (2, 2)},/* br.+? brw X 2,1 */
216 {0, 0, 7, 0}, /* br.+? jmp X 2,2 */
217 {1, 1, 0, 0}, /* unused 2,3 */
219 {BF, BB, 1, C (3, 1)}, /* brb B^foo 3,0 */
220 {WF, WB, 2, C (3, 2)}, /* brw W^foo 3,1 */
221 {0, 0, 5, 0}, /* Jmp L^foo 3,2 */
222 {1, 1, 0, 0}, /* unused 3,3 */
224 {1, 1, 0, 0}, /* unused 4,0 */
225 {WF, WB, 2, C (4, 2)}, /* acb_ ^Wfoo 4,1 */
226 {0, 0, 10, 0}, /* acb_,br,jmp L^foo4,2 */
227 {1, 1, 0, 0}, /* unused 4,3 */
229 {BF, BB, 1, C (5, 1)}, /* Xob___,,foo 5,0 */
230 {WF + 4, WB + 4, 6, C (5, 2)},/* Xob.+2,brb.+3,brw5,1 */
231 {0, 0, 9, 0}, /* Xob.+2,brb.+6,jmp5,2 */
232 {1, 1, 0, 0}, /* unused 5,3 */
241 void float_cons PARAMS ((int));
243 const pseudo_typeS md_pseudo_table[] =
245 {"dfloat", float_cons, 'd'},
246 {"ffloat", float_cons, 'f'},
247 {"gfloat", float_cons, 'g'},
248 {"hfloat", float_cons, 'h'},
252 #define STATE_PC_RELATIVE (1)
253 #define STATE_CONDITIONAL_BRANCH (2)
254 #define STATE_ALWAYS_BRANCH (3) /* includes BSB... */
255 #define STATE_COMPLEX_BRANCH (4)
256 #define STATE_COMPLEX_HOP (5)
258 #define STATE_BYTE (0)
259 #define STATE_WORD (1)
260 #define STATE_LONG (2)
261 #define STATE_UNDF (3) /* Symbol undefined in pass1 */
263 #define min(a, b) ((a) < (b) ? (a) : (b))
265 int flonum_gen2vax PARAMS ((char format_letter, FLONUM_TYPE * f,
266 LITTLENUM_TYPE * words));
267 static const char *vip_begin PARAMS ((int, const char *, const char *,
269 static void vip_op_1 PARAMS ((int, const char *));
270 static void vip_op_defaults PARAMS ((const char *, const char *, const char *));
271 static void vip_op PARAMS ((char *, struct vop *));
272 static void vip PARAMS ((struct vit *, char *));
274 static int vax_reg_parse PARAMS ((char, char, char, char));
283 if ((errtxt = vip_begin (1, "$", "*", "`")) != 0)
285 as_fatal (_("VIP_BEGIN error:%s"), errtxt);
288 for (i = 0, fP = float_operand;
289 fP < float_operand + VIT_MAX_OPERANDS;
292 fP->low = &big_operand_bits[i][0];
293 fP->high = &big_operand_bits[i][SIZE_OF_LARGE_NUMBER - 1];
298 md_number_to_chars (con, value, nbytes)
303 number_to_chars_littleendian (con, value, nbytes);
306 /* Fix up some data or instructions after we find out the value of a symbol
307 that they reference. */
309 void /* Knows about order of bytes in address. */
310 md_apply_fix3 (fixP, valueP, seg)
313 segT seg ATTRIBUTE_UNUSED;
315 valueT value = * valueP;
317 if (((fixP->fx_addsy == NULL && fixP->fx_subsy == NULL)
318 && fixP->fx_r_type != BFD_RELOC_32_PLT_PCREL
319 && fixP->fx_r_type != BFD_RELOC_32_GOT_PCREL)
320 || fixP->fx_r_type == NO_RELOC)
322 number_to_chars_littleendian (fixP->fx_where + fixP->fx_frag->fr_literal,
323 value, fixP->fx_size);
325 if (fixP->fx_addsy == NULL && fixP->fx_pcrel == 0)
330 md_chars_to_number (con, nbytes)
331 unsigned char con[]; /* Low order byte 1st. */
332 int nbytes; /* Number of bytes in the input. */
335 for (retval = 0, con += nbytes - 1; nbytes--; con--)
337 retval <<= BITS_PER_CHAR;
343 /* vax:md_assemble() emit frags for 1 instruction */
346 md_assemble (instruction_string)
347 char *instruction_string; /* A string: assemble 1 instruction. */
349 /* Non-zero if operand expression's segment is not known yet. */
351 /* Non-zero if operand expression's segment is absolute. */
356 /* An operand. Scans all operands. */
357 struct vop *operandP;
358 char *save_input_line_pointer;
359 /* What used to live after an expression. */
361 /* 1: instruction_string bad for all passes. */
363 /* Points to slot just after last operand. */
364 struct vop *end_operandP;
365 /* Points to expression values for this operand. */
369 /* These refer to an instruction operand expression. */
370 /* Target segment of the address. */
372 valueT this_add_number;
373 /* Positive (minuend) symbol. */
374 symbolS *this_add_symbol;
376 long opcode_as_number;
377 /* Least significant byte 1st. */
378 char *opcode_as_chars;
379 /* As an array of characters. */
380 /* Least significant byte 1st */
381 char *opcode_low_byteP;
382 /* length (bytes) meant by vop_short. */
384 /* 0, or 1 if '@' is in addressing mode. */
386 /* From vop_nbytes: vax_operand_width (in bytes) */
389 LITTLENUM_TYPE literal_float[8];
390 /* Big enough for any floating point literal. */
392 vip (&v, instruction_string);
395 * Now we try to find as many as_warn()s as we can. If we do any as_warn()s
396 * then goofed=1. Notice that we don't make any frags yet.
397 * Should goofed be 1, then this instruction will wedge in any pass,
398 * and we can safely flush it, without causing interpass symbol phase
399 * errors. That is, without changing label values in different passes.
401 if ((goofed = (*v.vit_error)) != 0)
403 as_fatal (_("Ignoring statement due to \"%s\""), v.vit_error);
406 * We need to use expression() and friends, which require us to diddle
407 * input_line_pointer. So we save it and restore it later.
409 save_input_line_pointer = input_line_pointer;
410 for (operandP = v.vit_operand,
411 expP = exp_of_operand,
412 segP = seg_of_operand,
413 floatP = float_operand,
414 end_operandP = v.vit_operand + v.vit_operands;
416 operandP < end_operandP;
418 operandP++, expP++, segP++, floatP++)
419 { /* for each operand */
420 if (operandP->vop_error)
422 as_fatal (_("Aborting because statement has \"%s\""), operandP->vop_error);
427 /* Statement has no syntax goofs: let's sniff the expression. */
428 int can_be_short = 0; /* 1 if a bignum can be reduced to a short literal. */
430 input_line_pointer = operandP->vop_expr_begin;
431 c_save = operandP->vop_expr_end[1];
432 operandP->vop_expr_end[1] = '\0';
433 /* If to_seg == SEG_PASS1, expression() will have set need_pass_2 = 1. */
434 *segP = expression (expP);
438 /* for BSD4.2 compatibility, missing expression is absolute 0 */
439 expP->X_op = O_constant;
440 expP->X_add_number = 0;
441 /* For SEG_ABSOLUTE, we shouldn't need to set X_op_symbol,
442 X_add_symbol to any particular value. But, we will program
443 defensively. Since this situation occurs rarely so it costs
444 us little to do, and stops Dean worrying about the origin of
445 random bits in expressionS's. */
446 expP->X_add_symbol = NULL;
447 expP->X_op_symbol = NULL;
456 * Major bug. We can't handle the case of a
457 * SEG_OP expression in a VIT_OPCODE_SYNTHETIC
458 * variable-length instruction.
459 * We don't have a frag type that is smart enough to
460 * relax a SEG_OP, and so we just force all
461 * SEG_OPs to behave like SEG_PASS1s.
462 * Clearly, if there is a demand we can invent a new or
463 * modified frag type and then coding up a frag for this
464 * case will be easy. SEG_OP was invented for the
465 * .words after a CASE opcode, and was never intended for
466 * instruction operands.
469 as_fatal (_("Can't relocate expression"));
473 /* Preserve the bits. */
474 if (expP->X_add_number > 0)
476 bignum_copy (generic_bignum, expP->X_add_number,
477 floatP->low, SIZE_OF_LARGE_NUMBER);
481 know (expP->X_add_number < 0);
482 flonum_copy (&generic_floating_point_number,
484 if (strchr ("s i", operandP->vop_short))
486 /* Could possibly become S^# */
487 flonum_gen2vax (-expP->X_add_number, floatP, literal_float);
488 switch (-expP->X_add_number)
492 (literal_float[0] & 0xFC0F) == 0x4000
493 && literal_float[1] == 0;
498 (literal_float[0] & 0xFC0F) == 0x4000
499 && literal_float[1] == 0
500 && literal_float[2] == 0
501 && literal_float[3] == 0;
506 (literal_float[0] & 0xFF81) == 0x4000
507 && literal_float[1] == 0
508 && literal_float[2] == 0
509 && literal_float[3] == 0;
513 can_be_short = ((literal_float[0] & 0xFFF8) == 0x4000
514 && (literal_float[1] & 0xE000) == 0
515 && literal_float[2] == 0
516 && literal_float[3] == 0
517 && literal_float[4] == 0
518 && literal_float[5] == 0
519 && literal_float[6] == 0
520 && literal_float[7] == 0);
524 BAD_CASE (-expP->X_add_number);
526 } /* switch (float type) */
527 } /* if (could want to become S^#...) */
528 } /* bignum or flonum ? */
530 if (operandP->vop_short == 's'
531 || operandP->vop_short == 'i'
532 || (operandP->vop_short == ' '
533 && operandP->vop_reg == 0xF
534 && (operandP->vop_mode & 0xE) == 0x8))
537 if (operandP->vop_short == ' ')
539 /* We must chose S^ or I^. */
540 if (expP->X_add_number > 0)
542 /* Bignum: Short literal impossible. */
543 operandP->vop_short = 'i';
544 operandP->vop_mode = 8;
545 operandP->vop_reg = 0xF; /* VAX PC. */
549 /* Flonum: Try to do it. */
552 operandP->vop_short = 's';
553 operandP->vop_mode = 0;
554 operandP->vop_ndx = -1;
555 operandP->vop_reg = -1;
556 expP->X_op = O_constant;
560 operandP->vop_short = 'i';
561 operandP->vop_mode = 8;
562 operandP->vop_reg = 0xF; /* VAX PC */
564 } /* bignum or flonum ? */
565 } /* if #, but no S^ or I^ seen. */
566 /* No more ' ' case: either 's' or 'i'. */
567 if (operandP->vop_short == 's')
569 /* Wants to be a short literal. */
570 if (expP->X_add_number > 0)
572 as_warn (_("Bignum not permitted in short literal. Immediate mode assumed."));
573 operandP->vop_short = 'i';
574 operandP->vop_mode = 8;
575 operandP->vop_reg = 0xF; /* VAX PC. */
581 as_warn (_("Can't do flonum short literal: immediate mode used."));
582 operandP->vop_short = 'i';
583 operandP->vop_mode = 8;
584 operandP->vop_reg = 0xF; /* VAX PC. */
587 { /* Encode short literal now. */
590 switch (-expP->X_add_number)
594 temp = literal_float[0] >> 4;
598 temp = literal_float[0] >> 1;
602 temp = ((literal_float[0] << 3) & 070)
603 | ((literal_float[1] >> 13) & 07);
607 BAD_CASE (-expP->X_add_number);
611 floatP->low[0] = temp & 077;
613 } /* if can be short literal float */
614 } /* flonum or bignum ? */
617 { /* I^# seen: set it up if float. */
618 if (expP->X_add_number < 0)
620 memcpy (floatP->low, literal_float, sizeof (literal_float));
626 as_warn (_("A bignum/flonum may not be a displacement: 0x%lx used"),
627 (expP->X_add_number = 0x80000000L));
628 /* Chosen so luser gets the most offset bits to patch later. */
630 expP->X_add_number = floatP->low[0]
631 | ((LITTLENUM_MASK & (floatP->low[1])) << LITTLENUM_NUMBER_OF_BITS);
633 * For the O_big case we have:
634 * If vop_short == 's' then a short floating literal is in the
635 * lowest 6 bits of floatP -> low [0], which is
636 * big_operand_bits [---] [0].
637 * If vop_short == 'i' then the appropriate number of elements
638 * of big_operand_bits [---] [...] are set up with the correct
640 * Also, just in case width is byte word or long, we copy the lowest
641 * 32 bits of the number to X_add_number.
645 if (input_line_pointer != operandP->vop_expr_end + 1)
647 as_fatal ("Junk at end of expression \"%s\"", input_line_pointer);
650 operandP->vop_expr_end[1] = c_save;
652 } /* for(each operand) */
654 input_line_pointer = save_input_line_pointer;
656 if (need_pass_2 || goofed)
662 /* Remember where it is, in case we want to modify the op-code later. */
663 opcode_low_byteP = frag_more (v.vit_opcode_nbytes);
664 memcpy (opcode_low_byteP, v.vit_opcode, v.vit_opcode_nbytes);
665 opcode_as_number = md_chars_to_number (opcode_as_chars = v.vit_opcode, 4);
666 for (operandP = v.vit_operand,
667 expP = exp_of_operand,
668 segP = seg_of_operand,
669 floatP = float_operand,
670 end_operandP = v.vit_operand + v.vit_operands;
672 operandP < end_operandP;
679 if (operandP->vop_ndx >= 0)
681 /* indexed addressing byte */
682 /* Legality of indexed mode already checked: it is OK */
683 FRAG_APPEND_1_CHAR (0x40 + operandP->vop_ndx);
684 } /* if(vop_ndx>=0) */
686 /* Here to make main operand frag(s). */
687 this_add_number = expP->X_add_number;
688 this_add_symbol = expP->X_add_symbol;
691 is_undefined = (to_seg == undefined_section);
692 is_absolute = (to_seg == absolute_section);
694 is_undefined = (to_seg == SEG_UNKNOWN);
695 is_absolute = (to_seg == SEG_ABSOLUTE);
697 at = operandP->vop_mode & 1;
698 length = (operandP->vop_short == 'b'
699 ? 1 : (operandP->vop_short == 'w'
700 ? 2 : (operandP->vop_short == 'l'
702 nbytes = operandP->vop_nbytes;
703 if (operandP->vop_access == 'b')
705 if (to_seg == now_seg || is_undefined)
707 /* If is_undefined, then it might BECOME now_seg. */
710 p = frag_more (nbytes);
711 fix_new (frag_now, p - frag_now->fr_literal, nbytes,
712 this_add_symbol, this_add_number, 1, NO_RELOC);
715 { /* to_seg==now_seg || to_seg == SEG_UNKNOWN */
717 length_code = is_undefined ? STATE_UNDF : STATE_BYTE;
718 if (opcode_as_number & VIT_OPCODE_SPECIAL)
720 if (operandP->vop_width == VAX_WIDTH_UNCONDITIONAL_JUMP)
723 frag_var (rs_machine_dependent, 5, 1,
724 ENCODE_RELAX (STATE_ALWAYS_BRANCH, length_code),
725 this_add_symbol, this_add_number,
730 if (operandP->vop_width == VAX_WIDTH_WORD_JUMP)
732 length_code = STATE_WORD;
733 /* JF: There is no state_byte for this one! */
734 frag_var (rs_machine_dependent, 10, 2,
735 ENCODE_RELAX (STATE_COMPLEX_BRANCH, length_code),
736 this_add_symbol, this_add_number,
741 know (operandP->vop_width == VAX_WIDTH_BYTE_JUMP);
742 frag_var (rs_machine_dependent, 9, 1,
743 ENCODE_RELAX (STATE_COMPLEX_HOP, length_code),
744 this_add_symbol, this_add_number,
751 know (operandP->vop_width == VAX_WIDTH_CONDITIONAL_JUMP);
752 frag_var (rs_machine_dependent, 7, 1,
753 ENCODE_RELAX (STATE_CONDITIONAL_BRANCH, length_code),
754 this_add_symbol, this_add_number,
761 /* to_seg != now_seg && to_seg != SEG_UNKNOWN */
763 * --- SEG FLOAT MAY APPEAR HERE ----
769 know (!(opcode_as_number & VIT_OPCODE_SYNTHETIC));
770 p = frag_more (nbytes);
771 /* Conventional relocation. */
772 fix_new (frag_now, p - frag_now->fr_literal, nbytes,
774 section_symbol (absolute_section),
778 this_add_number, 1, NO_RELOC);
782 know (opcode_as_number & VIT_OPCODE_SYNTHETIC);
783 if (opcode_as_number & VIT_OPCODE_SPECIAL)
785 if (operandP->vop_width == VAX_WIDTH_UNCONDITIONAL_JUMP)
788 *opcode_low_byteP = opcode_as_chars[0] + VAX_WIDEN_LONG;
789 know (opcode_as_chars[1] == 0);
791 p[0] = VAX_ABSOLUTE_MODE; /* @#... */
792 md_number_to_chars (p + 1, this_add_number, 4);
793 /* Now (eg) JMP @#foo or JSB @#foo. */
797 if (operandP->vop_width == VAX_WIDTH_WORD_JUMP)
805 p[5] = VAX_ABSOLUTE_MODE; /* @#... */
806 md_number_to_chars (p + 6, this_add_number, 4);
816 know (operandP->vop_width == VAX_WIDTH_BYTE_JUMP);
822 p[4] = VAX_ABSOLUTE_MODE; /* @#... */
823 md_number_to_chars (p + 5, this_add_number, 4);
836 *opcode_low_byteP ^= 1;
837 /* To reverse the condition in a VAX branch,
838 complement the lowest order bit. */
842 p[2] = VAX_ABSOLUTE_MODE; /* @#... */
843 md_number_to_chars (p + 3, this_add_number, 4);
854 /* to_seg != now_seg && !is_undefinfed && !is_absolute */
857 /* Pc-relative. Conventional relocation. */
858 know (!(opcode_as_number & VIT_OPCODE_SYNTHETIC));
859 p = frag_more (nbytes);
860 fix_new (frag_now, p - frag_now->fr_literal, nbytes,
862 section_symbol (absolute_section),
866 this_add_number, 1, NO_RELOC);
870 know (opcode_as_number & VIT_OPCODE_SYNTHETIC);
871 if (opcode_as_number & VIT_OPCODE_SPECIAL)
873 if (operandP->vop_width == VAX_WIDTH_UNCONDITIONAL_JUMP)
876 know (opcode_as_chars[1] == 0);
877 *opcode_low_byteP = opcode_as_chars[0] + VAX_WIDEN_LONG;
879 p[0] = VAX_PC_RELATIVE_MODE;
881 p + 1 - frag_now->fr_literal, 4,
883 this_add_number, 1, NO_RELOC);
884 /* Now eg JMP foo or JSB foo. */
888 if (operandP->vop_width == VAX_WIDTH_WORD_JUMP)
896 p[5] = VAX_PC_RELATIVE_MODE;
898 p + 6 - frag_now->fr_literal, 4,
900 this_add_number, 1, NO_RELOC);
910 know (operandP->vop_width == VAX_WIDTH_BYTE_JUMP);
916 p[4] = VAX_PC_RELATIVE_MODE;
918 p + 5 - frag_now->fr_literal,
920 this_add_number, 1, NO_RELOC);
932 know (operandP->vop_width == VAX_WIDTH_CONDITIONAL_JUMP);
933 *opcode_low_byteP ^= 1; /* Reverse branch condition. */
937 p[2] = VAX_PC_RELATIVE_MODE;
938 fix_new (frag_now, p + 3 - frag_now->fr_literal,
940 this_add_number, 1, NO_RELOC);
948 know (operandP->vop_access != 'b'); /* So it is ordinary operand. */
949 know (operandP->vop_access != ' '); /* ' ' target-independent: elsewhere. */
950 know (operandP->vop_access == 'a'
951 || operandP->vop_access == 'm'
952 || operandP->vop_access == 'r'
953 || operandP->vop_access == 'v'
954 || operandP->vop_access == 'w');
955 if (operandP->vop_short == 's')
959 if (this_add_number >= 64)
961 as_warn (_("Short literal overflow(%ld.), immediate mode assumed."),
962 (long) this_add_number);
963 operandP->vop_short = 'i';
964 operandP->vop_mode = 8;
965 operandP->vop_reg = 0xF;
970 as_warn (_("Forced short literal to immediate mode. now_seg=%s to_seg=%s"),
971 segment_name (now_seg), segment_name (to_seg));
972 operandP->vop_short = 'i';
973 operandP->vop_mode = 8;
974 operandP->vop_reg = 0xF;
977 if (operandP->vop_reg >= 0 && (operandP->vop_mode < 8
978 || (operandP->vop_reg != 0xF && operandP->vop_mode < 10)))
980 /* One byte operand. */
981 know (operandP->vop_mode > 3);
982 FRAG_APPEND_1_CHAR (operandP->vop_mode << 4 | operandP->vop_reg);
983 /* All 1-bytes except S^# happen here. */
987 /* {@}{q^}foo{(Rn)} or S^#foo */
988 if (operandP->vop_reg == -1 && operandP->vop_short != 's')
991 if (to_seg == now_seg)
995 know (operandP->vop_short == ' ');
996 length_code = STATE_BYTE;
998 if (S_IS_EXTERNAL (this_add_symbol)
999 || S_IS_WEAK (this_add_symbol))
1000 length_code = STATE_UNDF;
1002 p = frag_var (rs_machine_dependent, 10, 2,
1003 ENCODE_RELAX (STATE_PC_RELATIVE, length_code),
1004 this_add_symbol, this_add_number,
1006 know (operandP->vop_mode == 10 + at);
1008 /* At is the only context we need to carry
1009 to other side of relax() process. Must
1010 be in the correct bit position of VAX
1011 operand spec. byte. */
1016 know (operandP->vop_short != ' ');
1017 p = frag_more (length + 1);
1018 p[0] = 0xF | ((at + "?\12\14?\16"[length]) << 4);
1019 fix_new (frag_now, p + 1 - frag_now->fr_literal,
1020 length, this_add_symbol,
1021 this_add_number, 1, NO_RELOC);
1025 { /* to_seg != now_seg */
1026 if (this_add_symbol == NULL)
1029 /* Do @#foo: simpler relocation than foo-.(pc) anyway. */
1031 p[0] = VAX_ABSOLUTE_MODE; /* @#... */
1032 md_number_to_chars (p + 1, this_add_number, 4);
1033 if (length && length != 4)
1035 as_warn (_("Length specification ignored. Address mode 9F used"));
1040 /* {@}{q^}other_seg */
1041 know ((length == 0 && operandP->vop_short == ' ')
1042 || (length > 0 && operandP->vop_short != ' '));
1045 || S_IS_WEAK(this_add_symbol)
1046 || S_IS_EXTERNAL(this_add_symbol)
1052 default: length_code = STATE_UNDF; break;
1053 case 1: length_code = STATE_BYTE; break;
1054 case 2: length_code = STATE_WORD; break;
1055 case 4: length_code = STATE_LONG; break;
1058 * We have a SEG_UNKNOWN symbol. It might
1059 * turn out to be in the same segment as
1060 * the instruction, permitting relaxation.
1062 p = frag_var (rs_machine_dependent, 5, 2,
1063 ENCODE_RELAX (STATE_PC_RELATIVE, length_code),
1064 this_add_symbol, this_add_number,
1072 know (operandP->vop_short == ' ');
1073 length = 4; /* Longest possible. */
1075 p = frag_more (length + 1);
1076 p[0] = 0xF | ((at + "?\12\14?\16"[length]) << 4);
1077 md_number_to_chars (p + 1, this_add_number, length);
1079 p + 1 - frag_now->fr_literal,
1080 length, this_add_symbol,
1081 this_add_number, 1, NO_RELOC);
1088 /* {@}{q^}foo(Rn) or S^# or I^# or # */
1089 if (operandP->vop_mode < 0xA)
1091 /* # or S^# or I^# */
1092 if (operandP->vop_access == 'v'
1093 || operandP->vop_access == 'a')
1095 if (operandP->vop_access == 'v')
1096 as_warn (_("Invalid operand: immediate value used as base address."));
1098 as_warn (_("Invalid operand: immediate value used as address."));
1099 /* gcc 2.6.3 is known to generate these in at least
1103 && is_absolute && (expP->X_op != O_big)
1104 && operandP->vop_mode == 8 /* No '@'. */
1105 && this_add_number < 64)
1107 operandP->vop_short = 's';
1109 if (operandP->vop_short == 's')
1111 FRAG_APPEND_1_CHAR (this_add_number);
1117 p = frag_more (nbytes + 1);
1118 know (operandP->vop_reg == 0xF);
1120 if (flag_want_pic && operandP->vop_mode == 8
1121 && this_add_symbol != NULL)
1123 as_warn (_("Symbol used as immediate operand in PIC mode."));
1126 p[0] = (operandP->vop_mode << 4) | 0xF;
1127 if ((is_absolute) && (expP->X_op != O_big))
1130 * If nbytes > 4, then we are scrod. We
1131 * don't know if the high order bytes
1132 * are to be 0xFF or 0x00. BSD4.2 & RMS
1133 * say use 0x00. OK --- but this
1134 * assembler needs ANOTHER rewrite to
1135 * cope properly with this bug. */
1136 md_number_to_chars (p + 1, this_add_number, min (4, nbytes));
1139 memset (p + 5, '\0', nbytes - 4);
1144 if (expP->X_op == O_big)
1147 * Problem here is to get the bytes
1148 * in the right order. We stored
1149 * our constant as LITTLENUMs, not
1161 for (p++; nbytes; nbytes -= 2, p += 2, lP++)
1163 md_number_to_chars (p, *lP, 2);
1169 fix_new (frag_now, p + 1 - frag_now->fr_literal,
1170 nbytes, this_add_symbol,
1171 this_add_number, 0, NO_RELOC);
1177 { /* {@}{q^}foo(Rn) */
1178 know ((length == 0 && operandP->vop_short == ' ')
1179 || (length > 0 && operandP->vop_short != ' '));
1186 test = this_add_number;
1191 length = test & 0xffff8000 ? 4
1192 : test & 0xffffff80 ? 2
1200 p = frag_more (1 + length);
1201 know (operandP->vop_reg >= 0);
1202 p[0] = operandP->vop_reg
1203 | ((at | "?\12\14?\16"[length]) << 4);
1206 md_number_to_chars (p + 1, this_add_number, length);
1210 fix_new (frag_now, p + 1 - frag_now->fr_literal,
1211 length, this_add_symbol,
1212 this_add_number, 0, NO_RELOC);
1216 } /* if(single-byte-operand) */
1218 } /* for(operandP) */
1219 } /* vax_assemble() */
1221 /* md_estimate_size_before_relax(), called just before relax().
1222 Any symbol that is now undefined will not become defined.
1223 Return the correct fr_subtype in the frag and the growth beyond
1226 md_estimate_size_before_relax (fragP, segment)
1230 if (RELAX_LENGTH (fragP->fr_subtype) == STATE_UNDF)
1232 if (S_GET_SEGMENT (fragP->fr_symbol) != segment
1234 || S_IS_WEAK (fragP->fr_symbol)
1235 || S_IS_EXTERNAL (fragP->fr_symbol)
1239 /* Non-relaxable cases. */
1240 int reloc_type = NO_RELOC;
1244 old_fr_fix = fragP->fr_fix;
1245 p = fragP->fr_literal + old_fr_fix;
1247 /* If this is to an undefined symbol, then if it's an indirect
1248 reference indicate that is can mutated into a GLOB_DAT or
1249 JUMP_SLOT by the loader. We restrict ourselves to no offset
1250 due to a limitation in the NetBSD linker. */
1252 if (GOT_symbol == NULL)
1253 GOT_symbol = symbol_find (GLOBAL_OFFSET_TABLE_NAME);
1254 if (PLT_symbol == NULL)
1255 PLT_symbol = symbol_find (PROCEDURE_LINKAGE_TABLE_NAME);
1256 if ((GOT_symbol == NULL || fragP->fr_symbol != GOT_symbol)
1257 && (PLT_symbol == NULL || fragP->fr_symbol != PLT_symbol)
1258 && fragP->fr_symbol != NULL
1260 && (!S_IS_DEFINED (fragP->fr_symbol)
1261 || S_IS_WEAK (fragP->fr_symbol)
1262 || S_IS_EXTERNAL (fragP->fr_symbol)))
1267 as_fatal ("PIC reference to %s is indirect.\n",
1268 S_GET_NAME (fragP->fr_symbol));
1272 if (((unsigned char *) fragP->fr_opcode)[0] == VAX_CALLS
1273 || ((unsigned char *) fragP->fr_opcode)[0] == VAX_CALLG
1274 || ((unsigned char *) fragP->fr_opcode)[0] == VAX_JSB
1275 || ((unsigned char *) fragP->fr_opcode)[0] == VAX_JMP
1276 || S_IS_FUNCTION (fragP->fr_symbol))
1277 reloc_type = BFD_RELOC_32_PLT_PCREL;
1279 reloc_type = BFD_RELOC_32_GOT_PCREL;
1283 switch (RELAX_STATE (fragP->fr_subtype))
1285 case STATE_PC_RELATIVE:
1286 p[0] |= VAX_PC_RELATIVE_MODE; /* Preserve @ bit. */
1287 fragP->fr_fix += 1 + 4;
1288 fix_new (fragP, old_fr_fix + 1, 4, fragP->fr_symbol,
1289 fragP->fr_offset, 1, reloc_type);
1292 case STATE_CONDITIONAL_BRANCH:
1293 *fragP->fr_opcode ^= 1; /* Reverse sense of branch. */
1296 p[2] = VAX_PC_RELATIVE_MODE; /* ...(PC) */
1297 fragP->fr_fix += 1 + 1 + 1 + 4;
1298 fix_new (fragP, old_fr_fix + 3, 4, fragP->fr_symbol,
1299 fragP->fr_offset, 1, NO_RELOC);
1302 case STATE_COMPLEX_BRANCH:
1308 p[5] = VAX_PC_RELATIVE_MODE; /* ...(pc) */
1309 fragP->fr_fix += 2 + 2 + 1 + 1 + 4;
1310 fix_new (fragP, old_fr_fix + 6, 4, fragP->fr_symbol,
1311 fragP->fr_offset, 1, NO_RELOC);
1314 case STATE_COMPLEX_HOP:
1319 p[4] = VAX_PC_RELATIVE_MODE; /* ...(pc) */
1320 fragP->fr_fix += 1 + 2 + 1 + 1 + 4;
1321 fix_new (fragP, old_fr_fix + 5, 4, fragP->fr_symbol,
1322 fragP->fr_offset, 1, NO_RELOC);
1325 case STATE_ALWAYS_BRANCH:
1326 *fragP->fr_opcode += VAX_WIDEN_LONG;
1327 p[0] = VAX_PC_RELATIVE_MODE; /* ...(PC) */
1328 fragP->fr_fix += 1 + 4;
1329 fix_new (fragP, old_fr_fix + 1, 4, fragP->fr_symbol,
1330 fragP->fr_offset, 1, NO_RELOC);
1338 /* Return the growth in the fixed part of the frag. */
1339 return fragP->fr_fix - old_fr_fix;
1342 /* Relaxable cases. Set up the initial guess for the variable
1343 part of the frag. */
1344 switch (RELAX_STATE (fragP->fr_subtype))
1346 case STATE_PC_RELATIVE:
1347 fragP->fr_subtype = ENCODE_RELAX (STATE_PC_RELATIVE, STATE_BYTE);
1349 case STATE_CONDITIONAL_BRANCH:
1350 fragP->fr_subtype = ENCODE_RELAX (STATE_CONDITIONAL_BRANCH, STATE_BYTE);
1352 case STATE_COMPLEX_BRANCH:
1353 fragP->fr_subtype = ENCODE_RELAX (STATE_COMPLEX_BRANCH, STATE_WORD);
1355 case STATE_COMPLEX_HOP:
1356 fragP->fr_subtype = ENCODE_RELAX (STATE_COMPLEX_HOP, STATE_BYTE);
1358 case STATE_ALWAYS_BRANCH:
1359 fragP->fr_subtype = ENCODE_RELAX (STATE_ALWAYS_BRANCH, STATE_BYTE);
1364 if (fragP->fr_subtype >= sizeof (md_relax_table) / sizeof (md_relax_table[0]))
1367 /* Return the size of the variable part of the frag. */
1368 return md_relax_table[fragP->fr_subtype].rlx_length;
1372 * md_convert_frag();
1374 * Called after relax() is finished.
1375 * In: Address of frag.
1376 * fr_type == rs_machine_dependent.
1377 * fr_subtype is what the address relaxed to.
1379 * Out: Any fixSs and constants are set up.
1380 * Caller will turn frag into a ".space 0".
1382 #ifdef BFD_ASSEMBLER
1384 md_convert_frag (headers, seg, fragP)
1385 bfd *headers ATTRIBUTE_UNUSED;
1386 segT seg ATTRIBUTE_UNUSED;
1390 md_convert_frag (headers, seg, fragP)
1391 object_headers *headers ATTRIBUTE_UNUSED;
1392 segT seg ATTRIBUTE_UNUSED;
1396 char *addressP; /* -> _var to change. */
1397 char *opcodeP; /* -> opcode char(s) to change. */
1398 short int extension = 0; /* Size of relaxed address. */
1399 /* Added to fr_fix: incl. ALL var chars. */
1403 know (fragP->fr_type == rs_machine_dependent);
1404 where = fragP->fr_fix;
1405 addressP = fragP->fr_literal + where;
1406 opcodeP = fragP->fr_opcode;
1407 symbolP = fragP->fr_symbol;
1410 switch (fragP->fr_subtype)
1413 case ENCODE_RELAX (STATE_PC_RELATIVE, STATE_BYTE):
1414 know (*addressP == 0 || *addressP == 0x10); /* '@' bit. */
1415 addressP[0] |= 0xAF; /* Byte displacement. */
1416 fix_new (fragP, fragP->fr_fix + 1, 1, fragP->fr_symbol,
1417 fragP->fr_offset, 1, NO_RELOC);
1421 case ENCODE_RELAX (STATE_PC_RELATIVE, STATE_WORD):
1422 know (*addressP == 0 || *addressP == 0x10); /* '@' bit. */
1423 addressP[0] |= 0xCF; /* Word displacement. */
1424 fix_new (fragP, fragP->fr_fix + 1, 2, fragP->fr_symbol,
1425 fragP->fr_offset, 1, NO_RELOC);
1429 case ENCODE_RELAX (STATE_PC_RELATIVE, STATE_LONG):
1430 know (*addressP == 0 || *addressP == 0x10); /* '@' bit. */
1431 addressP[0] |= 0xEF; /* Long word displacement. */
1432 fix_new (fragP, fragP->fr_fix + 1, 4, fragP->fr_symbol,
1433 fragP->fr_offset, 1, NO_RELOC);
1437 case ENCODE_RELAX (STATE_CONDITIONAL_BRANCH, STATE_BYTE):
1438 fix_new (fragP, fragP->fr_fix, 1, fragP->fr_symbol,
1439 fragP->fr_offset, 1, NO_RELOC);
1443 case ENCODE_RELAX (STATE_CONDITIONAL_BRANCH, STATE_WORD):
1444 opcodeP[0] ^= 1; /* Reverse sense of test. */
1446 addressP[1] = VAX_BRW;
1447 fix_new (fragP, fragP->fr_fix + 2, 2, fragP->fr_symbol,
1448 fragP->fr_offset, 1, NO_RELOC);
1452 case ENCODE_RELAX (STATE_CONDITIONAL_BRANCH, STATE_LONG):
1453 opcodeP[0] ^= 1; /* Reverse sense of test. */
1455 addressP[1] = VAX_JMP;
1456 addressP[2] = VAX_PC_RELATIVE_MODE;
1457 fix_new (fragP, fragP->fr_fix + 3, 4, fragP->fr_symbol,
1458 fragP->fr_offset, 1, NO_RELOC);
1462 case ENCODE_RELAX (STATE_ALWAYS_BRANCH, STATE_BYTE):
1463 fix_new (fragP, fragP->fr_fix, 1, fragP->fr_symbol,
1464 fragP->fr_offset, 1, NO_RELOC);
1468 case ENCODE_RELAX (STATE_ALWAYS_BRANCH, STATE_WORD):
1469 opcodeP[0] += VAX_WIDEN_WORD; /* brb -> brw, bsbb -> bsbw */
1470 fix_new (fragP, fragP->fr_fix, 2, fragP->fr_symbol, fragP->fr_offset,
1475 case ENCODE_RELAX (STATE_ALWAYS_BRANCH, STATE_LONG):
1476 opcodeP[0] += VAX_WIDEN_LONG; /* brb -> jmp, bsbb -> jsb */
1477 addressP[0] = VAX_PC_RELATIVE_MODE;
1478 fix_new (fragP, fragP->fr_fix + 1, 4, fragP->fr_symbol,
1479 fragP->fr_offset, 1, NO_RELOC);
1483 case ENCODE_RELAX (STATE_COMPLEX_BRANCH, STATE_WORD):
1484 fix_new (fragP, fragP->fr_fix, 2, fragP->fr_symbol,
1485 fragP->fr_offset, 1, NO_RELOC);
1489 case ENCODE_RELAX (STATE_COMPLEX_BRANCH, STATE_LONG):
1492 addressP[2] = VAX_BRB;
1494 addressP[4] = VAX_JMP;
1495 addressP[5] = VAX_PC_RELATIVE_MODE;
1496 fix_new (fragP, fragP->fr_fix + 6, 4, fragP->fr_symbol,
1497 fragP->fr_offset, 1, NO_RELOC);
1501 case ENCODE_RELAX (STATE_COMPLEX_HOP, STATE_BYTE):
1502 fix_new (fragP, fragP->fr_fix, 1, fragP->fr_symbol,
1503 fragP->fr_offset, 1, NO_RELOC);
1507 case ENCODE_RELAX (STATE_COMPLEX_HOP, STATE_WORD):
1509 addressP[1] = VAX_BRB;
1511 addressP[3] = VAX_BRW;
1512 fix_new (fragP, fragP->fr_fix + 4, 2, fragP->fr_symbol,
1513 fragP->fr_offset, 1, NO_RELOC);
1517 case ENCODE_RELAX (STATE_COMPLEX_HOP, STATE_LONG):
1519 addressP[1] = VAX_BRB;
1521 addressP[3] = VAX_JMP;
1522 addressP[4] = VAX_PC_RELATIVE_MODE;
1523 fix_new (fragP, fragP->fr_fix + 5, 4, fragP->fr_symbol,
1524 fragP->fr_offset, 1, NO_RELOC);
1529 BAD_CASE (fragP->fr_subtype);
1532 fragP->fr_fix += extension;
1533 } /* md_convert_frag() */
1535 /* Translate internal format of relocation info into target format.
1537 On vax: first 4 bytes are normal unsigned long, next three bytes
1538 are symbolnum, least sig. byte first. Last byte is broken up with
1539 the upper nibble as nuthin, bit 3 as extern, bits 2 & 1 as length, and
1543 md_ri_to_chars (the_bytes, ri)
1545 struct reloc_info_generic ri;
1548 md_number_to_chars (the_bytes, ri.r_address, sizeof (ri.r_address));
1549 /* now the fun stuff */
1550 the_bytes[6] = (ri.r_symbolnum >> 16) & 0x0ff;
1551 the_bytes[5] = (ri.r_symbolnum >> 8) & 0x0ff;
1552 the_bytes[4] = ri.r_symbolnum & 0x0ff;
1553 the_bytes[7] = (((ri.r_extern << 3) & 0x08) | ((ri.r_length << 1) & 0x06) |
1554 ((ri.r_pcrel << 0) & 0x01)) & 0x0F;
1557 #endif /* comment */
1560 #ifndef BFD_ASSEMBLER
1562 tc_aout_fix_to_chars (where, fixP, segment_address_in_file)
1565 relax_addressT segment_address_in_file;
1568 * In: length of relocation (or of address) in chars: 1, 2 or 4.
1569 * Out: GNU LD relocation length code: 0, 1, or 2.
1572 static const unsigned char nbytes_r_length[] = {42, 0, 1, 42, 2};
1575 know (fixP->fx_addsy != NULL);
1577 md_number_to_chars (where,
1578 fixP->fx_frag->fr_address + fixP->fx_where - segment_address_in_file,
1581 r_symbolnum = (S_IS_DEFINED (fixP->fx_addsy)
1582 ? S_GET_TYPE (fixP->fx_addsy)
1583 : fixP->fx_addsy->sy_number);
1585 where[6] = (r_symbolnum >> 16) & 0x0ff;
1586 where[5] = (r_symbolnum >> 8) & 0x0ff;
1587 where[4] = r_symbolnum & 0x0ff;
1588 where[7] = ((((!S_IS_DEFINED (fixP->fx_addsy)) << 3) & 0x08)
1589 | ((nbytes_r_length[fixP->fx_size] << 1) & 0x06)
1590 | (((fixP->fx_pcrel << 0) & 0x01) & 0x0f));
1592 #endif /* !BFD_ASSEMBLER */
1593 #endif /* OBJ_AOUT */
1596 * BUGS, GRIPES, APOLOGIA, etc.
1598 * The opcode table 'votstrs' needs to be sorted on opcode frequency.
1599 * That is, AFTER we hash it with hash_...(), we want most-used opcodes
1600 * to come out of the hash table faster.
1602 * I am sorry to inflict yet another VAX assembler on the world, but
1603 * RMS says we must do everything from scratch, to prevent pin-heads
1604 * restricting this software.
1608 * This is a vaguely modular set of routines in C to parse VAX
1609 * assembly code using DEC mnemonics. It is NOT un*x specific.
1611 * The idea here is that the assembler has taken care of all:
1618 * condensing any whitespace down to exactly one space
1619 * and all we have to do is parse 1 line into a vax instruction
1620 * partially formed. We will accept a line, and deliver:
1621 * an error message (hopefully empty)
1622 * a skeleton VAX instruction (tree structure)
1623 * textual pointers to all the operand expressions
1624 * a warning message that notes a silly operand (hopefully empty)
1628 * E D I T H I S T O R Y
1630 * 17may86 Dean Elsner. Bug if line ends immediately after opcode.
1631 * 30apr86 Dean Elsner. New vip_op() uses arg block so change call.
1632 * 6jan86 Dean Elsner. Crock vip_begin() to call vip_op_defaults().
1633 * 2jan86 Dean Elsner. Invent synthetic opcodes.
1634 * Widen vax_opcodeT to 32 bits. Use a bit for VIT_OPCODE_SYNTHETIC,
1635 * which means this is not a real opcode, it is like a macro; it will
1636 * be relax()ed into 1 or more instructions.
1637 * Use another bit for VIT_OPCODE_SPECIAL if the op-code is not optimised
1638 * like a regular branch instruction. Option added to vip_begin():
1639 * exclude synthetic opcodes. Invent synthetic_votstrs[].
1640 * 31dec85 Dean Elsner. Invent vit_opcode_nbytes.
1641 * Also make vit_opcode into a char[]. We now have n-byte vax opcodes,
1642 * so caller's don't have to know the difference between a 1-byte & a
1643 * 2-byte op-code. Still need vax_opcodeT concept, so we know how
1644 * big an object must be to hold an op.code.
1645 * 30dec85 Dean Elsner. Widen typedef vax_opcodeT in "vax-inst.h"
1646 * because vax opcodes may be 16 bits. Our crufty C compiler was
1647 * happily initialising 8-bit vot_codes with 16-bit numbers!
1648 * (Wouldn't the 'phone company like to compress data so easily!)
1649 * 29dec85 Dean Elsner. New static table vax_operand_width_size[].
1650 * Invented so we know hw many bytes a "I^#42" needs in its immediate
1651 * operand. Revised struct vop in "vax-inst.h": explicitly include
1652 * byte length of each operand, and it's letter-code datum type.
1653 * 17nov85 Dean Elsner. Name Change.
1654 * Due to ar(1) truncating names, we learned the hard way that
1655 * "vax-inst-parse.c" -> "vax-inst-parse." dropping the "o" off
1656 * the archived object name. SO... we shortened the name of this
1657 * source file, and changed the makefile.
1660 /* handle of the OPCODE hash table */
1661 static struct hash_control *op_hash;
1664 * In: 1 character, from "bdfghloqpw" being the data-type of an operand
1665 * of a vax instruction.
1667 * Out: the length of an operand of that type, in bytes.
1668 * Special branch operands types "-?!" have length 0.
1671 static const short int vax_operand_width_size[256] =
1673 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1674 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1675 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1676 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1677 0, 0, 1, 0, 8, 0, 4, 8, 16, 0, 0, 0, 4, 0, 0,16, /* ..b.d.fgh...l..o */
1678 0, 8, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, /* .q.....w........ */
1679 0, 0, 1, 0, 8, 0, 4, 8, 16, 0, 0, 0, 4, 0, 0,16, /* ..b.d.fgh...l..o */
1680 0, 8, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, /* .q.....w........ */
1681 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1682 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1683 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1684 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1685 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1686 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1687 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1688 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1692 * This perversion encodes all the vax opcodes as a bunch of strings.
1693 * RMS says we should build our hash-table at run-time. Hmm.
1694 * Please would someone arrange these in decreasing frequency of opcode?
1695 * Because of the way hash_...() works, the most frequently used opcode
1696 * should be textually first and so on.
1698 * Input for this table was 'vax.opcodes', awk(1)ed by 'vax.opcodes.c.awk' .
1699 * So change 'vax.opcodes', then re-generate this table.
1702 #include "opcode/vax.h"
1705 * This is a table of optional op-codes. All of them represent
1706 * 'synthetic' instructions that seem popular.
1708 * Here we make some pseudo op-codes. Every code has a bit set to say
1709 * it is synthetic. This lets you catch them if you want to
1710 * ban these opcodes. They are mnemonics for "elastic" instructions
1711 * that are supposed to assemble into the fewest bytes needed to do a
1712 * branch, or to do a conditional branch, or whatever.
1714 * The opcode is in the usual place [low-order n*8 bits]. This means
1715 * that if you mask off the bucky bits, the usual rules apply about
1716 * how long the opcode is.
1718 * All VAX branch displacements come at the end of the instruction.
1719 * For simple branches (1-byte opcode + 1-byte displacement) the last
1720 * operand is coded 'b?' where the "data type" '?' is a clue that we
1721 * may reverse the sense of the branch (complement lowest order bit)
1722 * and branch around a jump. This is by far the most common case.
1723 * That is why the VIT_OPCODE_SYNTHETIC bit is set: it says this is
1724 * a 0-byte op-code followed by 2 or more bytes of operand address.
1726 * If the op-code has VIT_OPCODE_SPECIAL set, then we have a more unusual
1729 * For JBSB & JBR the treatment is the similar, except (1) we have a 'bw'
1730 * option before (2) we can directly JSB/JMP because there is no condition.
1731 * These operands have 'b-' as their access/data type.
1733 * That leaves a bunch of random opcodes: JACBx, JxOBxxx. In these
1734 * cases, we do the same idea. JACBxxx are all marked with a 'b!'
1735 * JAOBxxx & JSOBxxx are marked with a 'b:'.
1738 #if (VIT_OPCODE_SYNTHETIC != 0x80000000)
1739 You have just broken the encoding below, which assumes the sign bit
1740 means 'I am an imaginary instruction'.
1743 #if (VIT_OPCODE_SPECIAL != 0x40000000)
1744 You have just broken the encoding below, which assumes the 0x40 M bit means
1745 'I am not to be "optimised" the way normal branches are'.
1748 static const struct vot
1749 synthetic_votstrs[] =
1751 {"jbsb", {"b-", 0xC0000010}}, /* BSD 4.2 */
1752 /* jsb used already */
1753 {"jbr", {"b-", 0xC0000011}}, /* BSD 4.2 */
1754 {"jr", {"b-", 0xC0000011}}, /* consistent */
1755 {"jneq", {"b?", 0x80000012}},
1756 {"jnequ", {"b?", 0x80000012}},
1757 {"jeql", {"b?", 0x80000013}},
1758 {"jeqlu", {"b?", 0x80000013}},
1759 {"jgtr", {"b?", 0x80000014}},
1760 {"jleq", {"b?", 0x80000015}},
1761 /* un-used opcodes here */
1762 {"jgeq", {"b?", 0x80000018}},
1763 {"jlss", {"b?", 0x80000019}},
1764 {"jgtru", {"b?", 0x8000001a}},
1765 {"jlequ", {"b?", 0x8000001b}},
1766 {"jvc", {"b?", 0x8000001c}},
1767 {"jvs", {"b?", 0x8000001d}},
1768 {"jgequ", {"b?", 0x8000001e}},
1769 {"jcc", {"b?", 0x8000001e}},
1770 {"jlssu", {"b?", 0x8000001f}},
1771 {"jcs", {"b?", 0x8000001f}},
1773 {"jacbw", {"rwrwmwb!", 0xC000003d}},
1774 {"jacbf", {"rfrfmfb!", 0xC000004f}},
1775 {"jacbd", {"rdrdmdb!", 0xC000006f}},
1776 {"jacbb", {"rbrbmbb!", 0xC000009d}},
1777 {"jacbl", {"rlrlmlb!", 0xC00000f1}},
1778 {"jacbg", {"rgrgmgb!", 0xC0004ffd}},
1779 {"jacbh", {"rhrhmhb!", 0xC0006ffd}},
1781 {"jbs", {"rlvbb?", 0x800000e0}},
1782 {"jbc", {"rlvbb?", 0x800000e1}},
1783 {"jbss", {"rlvbb?", 0x800000e2}},
1784 {"jbcs", {"rlvbb?", 0x800000e3}},
1785 {"jbsc", {"rlvbb?", 0x800000e4}},
1786 {"jbcc", {"rlvbb?", 0x800000e5}},
1787 {"jlbs", {"rlb?", 0x800000e8}},
1788 {"jlbc", {"rlb?", 0x800000e9}},
1790 {"jaoblss", {"rlmlb:", 0xC00000f2}},
1791 {"jaobleq", {"rlmlb:", 0xC00000f3}},
1792 {"jsobgeq", {"mlb:", 0xC00000f4}},
1793 {"jsobgtr", {"mlb:", 0xC00000f5}},
1795 /* CASEx has no branch addresses in our conception of it. */
1796 /* You should use ".word ..." statements after the "case ...". */
1798 {"", {"", 0}} /* empty is end sentinel */
1800 }; /* synthetic_votstrs */
1803 * v i p _ b e g i n ( )
1805 * Call me once before you decode any lines.
1806 * I decode votstrs into a hash table at op_hash (which I create).
1807 * I return an error text or null.
1808 * If you want, I will include the 'synthetic' jXXX instructions in the
1809 * instruction table.
1810 * You must nominate metacharacters for eg DEC's "#", "@", "^".
1814 vip_begin (synthetic_too, immediate, indirect, displen)
1815 int synthetic_too; /* 1 means include jXXX op-codes. */
1816 const char *immediate, *indirect, *displen;
1818 const struct vot *vP; /* scan votstrs */
1819 const char *retval = 0; /* error text */
1821 op_hash = hash_new ();
1823 for (vP = votstrs; *vP->vot_name && !retval; vP++)
1824 retval = hash_insert (op_hash, vP->vot_name, (PTR) &vP->vot_detail);
1827 for (vP = synthetic_votstrs; *vP->vot_name && !retval; vP++)
1828 retval = hash_insert (op_hash, vP->vot_name, (PTR) &vP->vot_detail);
1831 vip_op_defaults (immediate, indirect, displen);
1840 * This converts a string into a vax instruction.
1841 * The string must be a bare single instruction in dec-vax (with BSD4 frobs)
1843 * It provides some error messages: at most one fatal error message (which
1844 * stops the scan) and at most one warning message for each operand.
1845 * The vax instruction is returned in exploded form, since we have no
1846 * knowledge of how you parse (or evaluate) your expressions.
1847 * We do however strip off and decode addressing modes and operation
1850 * The exploded instruction is returned to a struct vit of your choice.
1851 * #include "vax-inst.h" to know what a struct vit is.
1853 * This function's value is a string. If it is not "" then an internal
1854 * logic error was found: read this code to assign meaning to the string.
1855 * No argument string should generate such an error string:
1856 * it means a bug in our code, not in the user's text.
1858 * You MUST have called vip_begin() once before using this function.
1862 vip (vitP, instring)
1863 struct vit *vitP; /* We build an exploded instruction here. */
1864 char *instring; /* Text of a vax instruction: we modify. */
1866 /* How to bit-encode this opcode. */
1867 struct vot_wot *vwP;
1868 /* 1/skip whitespace.2/scan vot_how */
1871 /* counts number of operands seen */
1872 unsigned char count;
1873 /* scan operands in struct vit */
1874 struct vop *operandp;
1875 /* error over all operands */
1876 const char *alloperr;
1877 /* Remember char, (we clobber it with '\0' temporarily). */
1879 /* Op-code of this instruction. */
1882 if (*instring == ' ')
1883 ++instring; /* Skip leading whitespace. */
1884 for (p = instring; *p && *p != ' '; p++);; /* MUST end in end-of-string or exactly 1 space. */
1885 /* Scanned up to end of operation-code. */
1886 /* Operation-code is ended with whitespace. */
1887 if (p - instring == 0)
1889 vitP->vit_error = _("No operator");
1891 memset (vitP->vit_opcode, '\0', sizeof (vitP->vit_opcode));
1898 * Here with instring pointing to what better be an op-name, and p
1899 * pointing to character just past that.
1900 * We trust instring points to an op-name, with no whitespace.
1902 vwP = (struct vot_wot *) hash_find (op_hash, instring);
1903 *p = c; /* Restore char after op-code. */
1906 vitP->vit_error = _("Unknown operator");
1908 memset (vitP->vit_opcode, '\0', sizeof (vitP->vit_opcode));
1913 * We found a match! So let's pick up as many operands as the
1914 * instruction wants, and even gripe if there are too many.
1915 * We expect comma to seperate each operand.
1916 * We let instring track the text, while p tracks a part of the
1921 * The lines below know about 2-byte opcodes starting FD,FE or FF.
1922 * They also understand synthetic opcodes. Note:
1923 * we return 32 bits of opcode, including bucky bits, BUT
1924 * an opcode length is either 8 or 16 bits for vit_opcode_nbytes.
1926 oc = vwP->vot_code; /* The op-code. */
1927 vitP->vit_opcode_nbytes = (oc & 0xFF) >= 0xFD ? 2 : 1;
1928 md_number_to_chars (vitP->vit_opcode, oc, 4);
1929 count = 0; /* no operands seen yet */
1930 instring = p; /* point just past operation code */
1932 for (howp = vwP->vot_how, operandp = vitP->vit_operand;
1933 !(alloperr && *alloperr) && *howp;
1934 operandp++, howp += 2)
1937 * Here to parse one operand. Leave instring pointing just
1938 * past any one ',' that marks the end of this operand.
1941 as_fatal (_("odd number of bytes in operand description"));
1944 for (q = instring; (c = *q) && c != ','; q++)
1947 * Q points to ',' or '\0' that ends argument. C is that
1951 operandp->vop_width = howp[1];
1952 operandp->vop_nbytes = vax_operand_width_size[(unsigned) howp[1]];
1953 operandp->vop_access = howp[0];
1954 vip_op (instring, operandp);
1955 *q = c; /* Restore input text. */
1956 if (operandp->vop_error)
1957 alloperr = _("Bad operand");
1958 instring = q + (c ? 1 : 0); /* next operand (if any) */
1959 count++; /* won another argument, may have an operr */
1962 alloperr = _("Not enough operands");
1966 if (*instring == ' ')
1967 instring++; /* Skip whitespace. */
1969 alloperr = _("Too many operands");
1971 vitP->vit_error = alloperr;
1974 vitP->vit_operands = count;
1980 * Test program for above.
1983 struct vit myvit; /* build an exploded vax instruction here */
1984 char answer[100]; /* human types a line of vax assembler here */
1985 char *mybug; /* "" or an internal logic diagnostic */
1986 int mycount; /* number of operands */
1987 struct vop *myvop; /* scan operands from myvit */
1988 int mysynth; /* 1 means want synthetic opcodes. */
1989 char my_immediate[200];
1990 char my_indirect[200];
1991 char my_displen[200];
1997 printf ("0 means no synthetic instructions. ");
1998 printf ("Value for vip_begin? ");
2000 sscanf (answer, "%d", &mysynth);
2001 printf ("Synthetic opcodes %s be included.\n", mysynth ? "will" : "will not");
2002 printf ("enter immediate symbols eg enter # ");
2003 gets (my_immediate);
2004 printf ("enter indirect symbols eg enter @ ");
2006 printf ("enter displen symbols eg enter ^ ");
2008 if (p = vip_begin (mysynth, my_immediate, my_indirect, my_displen))
2010 error ("vip_begin=%s", p);
2012 printf ("An empty input line will quit you from the vax instruction parser\n");
2015 printf ("vax instruction: ");
2020 break; /* out of for each input text loop */
2022 vip (&myvit, answer);
2023 if (*myvit.vit_error)
2025 printf ("ERR:\"%s\"\n", myvit.vit_error);
2028 for (mycount = myvit.vit_opcode_nbytes, p = myvit.vit_opcode;
2033 printf ("%02x ", *p & 0xFF);
2035 printf (" operand count=%d.\n", mycount = myvit.vit_operands);
2036 for (myvop = myvit.vit_operand; mycount; mycount--, myvop++)
2038 printf ("mode=%xx reg=%xx ndx=%xx len='%c'=%c%c%d. expr=\"",
2039 myvop->vop_mode, myvop->vop_reg, myvop->vop_ndx,
2040 myvop->vop_short, myvop->vop_access, myvop->vop_width,
2042 for (p = myvop->vop_expr_begin; p <= myvop->vop_expr_end; p++)
2047 if (myvop->vop_error)
2049 printf (" err:\"%s\"\n", myvop->vop_error);
2051 if (myvop->vop_warn)
2053 printf (" wrn:\"%s\"\n", myvop->vop_warn);
2058 exit (EXIT_SUCCESS);
2061 #endif /* #ifdef test */
2063 /* end of vax_ins_parse.c */
2065 /* vax_reg_parse.c - convert a VAX register name to a number */
2067 /* Copyright (C) 1987 Free Software Foundation, Inc. A part of GNU. */
2070 * v a x _ r e g _ p a r s e ( )
2072 * Take 3 char.s, the last of which may be `\0` (non-existent)
2073 * and return the VAX register number that they represent.
2075 * Return -1 if they don't form a register name. Good names return
2076 * a number from 0:15 inclusive.
2078 * Case is not important in a name.
2080 * Register names understood are:
2101 #include "safe-ctype.h"
2107 int /* return -1 or 0:15 */
2108 vax_reg_parse (c1, c2, c3, c4) /* 3 chars of register name */
2109 char c1, c2, c3, c4; /* c3 == 0 if 2-character reg name */
2111 int retval; /* return -1:15 */
2116 if (c1 != '%') /* register prefixes are mandatory for ELF */
2123 if (c4 != 0) /* register prefixes are not allowed under VMS */
2127 if (c1 == '%') /* register prefixes are optional under a.out */
2133 else if (c3 && c4) /* can't be 4 characters long. */
2139 if (ISDIGIT (c2) && c1 == 'r')
2144 retval = retval * 10 + c3 - '0';
2145 retval = (retval > 15) ? -1 : retval;
2146 /* clamp the register value to 1 hex digit */
2149 retval = -1; /* c3 must be '\0' or a digit */
2151 else if (c3) /* There are no three letter regs */
2170 else if (c1 == 'p' && c2 == 'c')
2180 * Parse a vax operand in DEC assembler notation.
2181 * For speed, expect a string of whitespace to be reduced to a single ' '.
2182 * This is the case for GNU AS, and is easy for other DEC-compatible
2185 * Knowledge about DEC VAX assembler operand notation lives here.
2186 * This doesn't even know what a register name is, except it believes
2187 * all register names are 2 or 3 characters, and lets vax_reg_parse() say
2188 * what number each name represents.
2189 * It does, however, know that PC, SP etc are special registers so it can
2190 * detect addressing modes that are silly for those registers.
2192 * Where possible, it delivers 1 fatal or 1 warning message if the operand
2193 * is suspect. Exactly what we test for is still evolving.
2201 * There were a number of 'mismatched argument type' bugs to vip_op.
2202 * The most general solution is to typedef each (of many) arguments.
2203 * We used instead a typedef'd argument block. This is less modular
2204 * than using seperate return pointers for each result, but runs faster
2205 * on most engines, and seems to keep programmers happy. It will have
2206 * to be done properly if we ever want to use vip_op as a general-purpose
2207 * module (it was designed to be).
2211 * Doesn't support DEC "G^" format operands. These always take 5 bytes
2212 * to express, and code as modes 8F or 9F. Reason: "G^" deprives you of
2213 * optimising to (say) a "B^" if you are lucky in the way you link.
2214 * When someone builds a linker smart enough to convert "G^" to "B^", "W^"
2215 * whenever possible, then we should implement it.
2216 * If there is some other use for "G^", feel free to code it in!
2221 * If I nested if()s more, I could avoid testing (*err) which would save
2222 * time, space and page faults. I didn't nest all those if()s for clarity
2223 * and because I think the mode testing can be re-arranged 1st to test the
2224 * commoner constructs 1st. Does anybody have statistics on this?
2230 * In future, we should be able to 'compose' error messages in a scratch area
2231 * and give the user MUCH more informative error messages. Although this takes
2232 * a little more code at run-time, it will make this module much more self-
2233 * documenting. As an example of what sucks now: most error messages have
2234 * hardwired into them the DEC VAX metacharacters "#^@" which are nothing like
2235 * the Un*x characters "$`*", that most users will expect from this AS.
2239 * The input is a string, ending with '\0'.
2241 * We also require a 'hint' of what kind of operand is expected: so
2242 * we can remind caller not to write into literals for instance.
2244 * The output is a skeletal instruction.
2246 * The algorithm has two parts.
2247 * 1. extract the syntactic features (parse off all the @^#-()+[] mode crud);
2248 * 2. express the @^#-()+[] as some parameters suited to further analysis.
2250 * 2nd step is where we detect the googles of possible invalid combinations
2251 * a human (or compiler) might write. Note that if we do a half-way
2252 * decent assembler, we don't know how long to make (eg) displacement
2253 * fields when we first meet them (because they may not have defined values).
2254 * So we must wait until we know how many bits are needed for each address,
2255 * then we can know both length and opcodes of instructions.
2256 * For reason(s) above, we will pass to our caller a 'broken' instruction
2257 * of these major components, from which our caller can generate instructions:
2258 * - displacement length I^ S^ L^ B^ W^ unspecified
2260 * - register R0-R15 or absent
2261 * - index register R0-R15 or absent
2262 * - expression text what we don't parse
2263 * - error text(s) why we couldn't understand the operand
2267 * To decode output of this, test errtxt. If errtxt[0] == '\0', then
2268 * we had no errors that prevented parsing. Also, if we ever report
2269 * an internal bug, errtxt[0] is set non-zero. So one test tells you
2270 * if the other outputs are to be taken seriously.
2274 * Because this module is useful for both VMS and UN*X style assemblers
2275 * and because of the variety of UN*X assemblers we must recognise
2276 * the different conventions for assembler operand notation. For example
2277 * VMS says "#42" for immediate mode, while most UN*X say "$42".
2278 * We permit arbitrary sets of (single) characters to represent the
2279 * 3 concepts that DEC writes '#', '@', '^'.
2282 /* character tests */
2283 #define VIP_IMMEDIATE 01 /* Character is like DEC # */
2284 #define VIP_INDIRECT 02 /* Char is like DEC @ */
2285 #define VIP_DISPLEN 04 /* Char is like DEC ^ */
2287 #define IMMEDIATEP(c) (vip_metacharacters [(c)&0xff]&VIP_IMMEDIATE)
2288 #define INDIRECTP(c) (vip_metacharacters [(c)&0xff]&VIP_INDIRECT)
2289 #define DISPLENP(c) (vip_metacharacters [(c)&0xff]&VIP_DISPLEN)
2291 /* We assume 8 bits per byte. Use vip_op_defaults() to set these up BEFORE we
2295 #if defined(CONST_TABLE)
2297 #define I VIP_IMMEDIATE,
2298 #define S VIP_INDIRECT,
2299 #define D VIP_DISPLEN,
2301 vip_metacharacters[256] =
2303 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ /* ^@ ^A ^B ^C ^D ^E ^F ^G ^H ^I ^J ^K ^L ^M ^N ^O*/
2304 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ /* ^P ^Q ^R ^S ^T ^U ^V ^W ^X ^Y ^Z ^[ ^\ ^] ^^ ^_ */
2305 _ _ _ _ I _ _ _ _ _ S _ _ _ _ _ /* sp ! " # $ % & ' ( ) * + , - . / */
2306 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ /*0 1 2 3 4 5 6 7 8 9 : ; < = > ?*/
2307 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ /*@ A B C D E F G H I J K L M N O*/
2308 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ /*P Q R S T U V W X Y Z [ \ ] ^ _*/
2309 D _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ /*` a b c d e f g h i j k l m n o*/
2310 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ /*p q r s t u v w x y z { | } ~ ^?*/
2312 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
2313 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
2314 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
2315 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
2316 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
2317 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
2318 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
2319 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
2326 static char vip_metacharacters[256];
2329 vip_op_1 (bit, syms)
2335 while ((t = *syms++) != 0)
2336 vip_metacharacters[t] |= bit;
2339 /* Can be called any time. More arguments may appear in future. */
2341 vip_op_defaults (immediate, indirect, displen)
2342 const char *immediate;
2343 const char *indirect;
2344 const char *displen;
2346 vip_op_1 (VIP_IMMEDIATE, immediate);
2347 vip_op_1 (VIP_INDIRECT, indirect);
2348 vip_op_1 (VIP_DISPLEN, displen);
2355 * Dec defines the semantics of address modes (and values)
2356 * by a two-letter code, explained here.
2358 * letter 1: access type
2360 * a address calculation - no data access, registers forbidden
2361 * b branch displacement
2362 * m read - let go of bus - write back "modify"
2364 * v bit field address: like 'a' but registers are OK
2366 * space no operator (eg ".long foo") [our convention]
2368 * letter 2: data type (i.e. width, alignment)
2371 * d double precision floating point (D format)
2372 * f single precision floating point (F format)
2373 * g G format floating
2374 * h H format floating
2379 * ? simple synthetic branch operand
2380 * - unconditional synthetic JSB/JSR operand
2381 * ! complex synthetic branch operand
2383 * The '-?!' letter 2's are not for external consumption. They are used
2384 * for various assemblers. Generally, all unknown widths are assumed 0.
2385 * We don't limit your choice of width character.
2387 * DEC operands are hard work to parse. For example, '@' as the first
2388 * character means indirect (deferred) mode but elswhere it is a shift
2390 * The long-winded explanation of how this is supposed to work is
2391 * cancelled. Read a DEC vax manual.
2392 * We try hard not to parse anything that MIGHT be part of the expression
2393 * buried in that syntax. For example if we see @...(Rn) we don't check
2394 * for '-' before the '(' because mode @-(Rn) does not exist.
2396 * After parsing we have:
2398 * at 1 if leading '@' (or Un*x '*')
2399 * len takes one value from " bilsw". eg B^ -> 'b'.
2400 * hash 1 if leading '#' (or Un*x '$')
2401 * expr_begin, expr_end the expression we did not parse
2402 * even though we don't interpret it, we make use
2403 * of its presence or absence.
2404 * sign -1: -(Rn) 0: absent +1: (Rn)+
2405 * paren 1 if () are around register
2406 * reg major register number 0:15 -1 means absent
2407 * ndx index register number 0:15 -1 means absent
2409 * Again, I dare not explain it: just trace ALL the code!
2413 vip_op (optext, vopP)
2414 /* user's input string e.g.: "@B^foo@bar(AP)[FP]:" */
2416 /* Input fields: vop_access, vop_width.
2417 Output fields: _ndx, _reg, _mode, _short, _warn,
2418 _error _expr_begin, _expr_end, _nbytes.
2419 vop_nbytes : number of bytes in a datum. */
2422 /* track operand text forward */
2424 /* track operand text backward */
2426 /* 1 if leading '@' ('*') seen */
2428 /* one of " bilsw" */
2430 /* 1 if leading '#' ('$') seen */
2434 /* 1 if () surround register */
2436 /* register number, -1:absent */
2438 /* index register number -1:absent */
2440 /* report illegal operand, ""==OK */
2441 /* " " is a FAKE error: means we won */
2442 /* ANY err that begins with ' ' is a fake. */
2443 /* " " is converted to "" before return */
2445 /* warn about weird modes pf address */
2447 /* preserve q in case we backup */
2449 /* build up 4-bit operand mode here */
2450 /* note: index mode is in ndx, this is */
2451 /* the major mode of operand address */
2454 * Notice how we move wrong-arg-type bugs INSIDE this module: if we
2455 * get the types wrong below, we lose at compile time rather than at
2458 char access_mode; /* vop_access. */
2459 char width; /* vop_width. */
2461 access_mode = vopP->vop_access;
2462 width = vopP->vop_width;
2463 /* None of our code bugs (yet), no user text errors, no warnings
2469 if (*p == ' ') /* Expect all whitespace reduced to ' '. */
2470 p++; /* skip over whitespace */
2472 if ((at = INDIRECTP (*p)) != 0)
2473 { /* 1 if *p=='@'(or '*' for Un*x) */
2474 p++; /* at is determined */
2475 if (*p == ' ') /* Expect all whitespace reduced to ' '. */
2476 p++; /* skip over whitespace */
2480 * This code is subtle. It tries to detect all legal (letter)'^'
2481 * but it doesn't waste time explicitly testing for premature '\0' because
2482 * this case is rejected as a mismatch against either (letter) or '^'.
2489 if (DISPLENP (p[1]) && strchr ("bilws", len = c))
2490 p += 2; /* skip (letter) '^' */
2491 else /* no (letter) '^' seen */
2492 len = ' '; /* len is determined */
2495 if (*p == ' ') /* Expect all whitespace reduced to ' '. */
2496 p++; /* skip over whitespace */
2498 if ((hash = IMMEDIATEP (*p)) != 0) /* 1 if *p=='#' ('$' for Un*x) */
2499 p++; /* hash is determined */
2502 * p points to what may be the beginning of an expression.
2503 * We have peeled off the front all that is peelable.
2504 * We know at, len, hash.
2506 * Lets point q at the end of the text and parse that (backwards).
2509 for (q = p; *q; q++)
2511 q--; /* now q points at last char of text */
2513 if (*q == ' ' && q >= p) /* Expect all whitespace reduced to ' '. */
2515 /* reverse over whitespace, but don't */
2516 /* run back over *p */
2519 * As a matter of policy here, we look for [Rn], although both Rn and S^#
2520 * forbid [Rn]. This is because it is easy, and because only a sick
2521 * cyborg would have [...] trailing an expression in a VAX-like assembler.
2522 * A meticulous parser would first check for Rn followed by '(' or '['
2523 * and not parse a trailing ']' if it found another. We just ban expressions
2528 while (q >= p && *q != '[')
2530 /* either q<p or we got matching '[' */
2532 err = _("no '[' to match ']'");
2536 * Confusers like "[]" will eventually lose with a bad register
2537 * name error. So again we don't need to check for early '\0'.
2540 ndx = vax_reg_parse (q[1], q[2], 0, 0);
2541 else if (q[4] == ']')
2542 ndx = vax_reg_parse (q[1], q[2], q[3], 0);
2543 else if (q[5] == ']')
2544 ndx = vax_reg_parse (q[1], q[2], q[3], q[4]);
2548 * Since we saw a ']' we will demand a register name in the [].
2549 * If luser hasn't given us one: be rude.
2552 err = _("bad register in []");
2554 err = _("[PC] index banned");
2556 q--; /* point q just before "[...]" */
2560 ndx = -1; /* no ']', so no iNDeX register */
2563 * If err = "..." then we lost: run away.
2564 * Otherwise ndx == -1 if there was no "[...]".
2565 * Otherwise, ndx is index register number, and q points before "[...]".
2568 if (*q == ' ' && q >= p) /* Expect all whitespace reduced to ' '. */
2570 /* reverse over whitespace, but don't */
2571 /* run back over *p */
2574 sign = 0; /* no ()+ or -() seen yet */
2576 if (q > p + 3 && *q == '+' && q[-1] == ')')
2578 sign = 1; /* we saw a ")+" */
2579 q--; /* q points to ')' */
2582 if (*q == ')' && q > p + 2)
2584 paren = 1; /* assume we have "(...)" */
2585 while (q >= p && *q != '(')
2587 /* either q<p or we got matching '(' */
2589 err = _("no '(' to match ')'");
2593 * Confusers like "()" will eventually lose with a bad register
2594 * name error. So again we don't need to check for early '\0'.
2597 reg = vax_reg_parse (q[1], q[2], 0, 0);
2598 else if (q[4] == ')')
2599 reg = vax_reg_parse (q[1], q[2], q[3], 0);
2600 else if (q[5] == ')')
2601 reg = vax_reg_parse (q[1], q[2], q[3], q[4]);
2605 * Since we saw a ')' we will demand a register name in the ')'.
2606 * This is nasty: why can't our hypothetical assembler permit
2607 * parenthesised expressions? BECAUSE I AM LAZY! That is why.
2608 * Abuse luser if we didn't spy a register name.
2612 /* JF allow parenthasized expressions. I hope this works */
2616 /* err = "unknown register in ()"; */
2619 q--; /* point just before '(' of "(...)" */
2621 * If err == "..." then we lost. Run away.
2622 * Otherwise if reg >= 0 then we saw (Rn).
2626 * If err == "..." then we lost.
2627 * Otherwise paren==1 and reg = register in "()".
2633 * If err == "..." then we lost.
2634 * Otherwise, q points just before "(Rn)", if any.
2635 * If there was a "(...)" then paren==1, and reg is the register.
2639 * We should only seek '-' of "-(...)" if:
2640 * we saw "(...)" paren == 1
2641 * we have no errors so far ! *err
2642 * we did not see '+' of "(...)+" sign < 1
2643 * We don't check len. We want a specific error message later if
2644 * user tries "x^...-(Rn)". This is a feature not a bug.
2648 if (paren && sign < 1)/* !sign is adequate test */
2657 * We have back-tracked over most
2658 * of the crud at the end of an operand.
2659 * Unless err, we know: sign, paren. If paren, we know reg.
2660 * The last case is of an expression "Rn".
2661 * This is worth hunting for if !err, !paren.
2662 * We wouldn't be here if err.
2663 * We remember to save q, in case we didn't want "Rn" anyway.
2667 if (*q == ' ' && q >= p) /* Expect all whitespace reduced to ' '. */
2669 /* reverse over whitespace, but don't */
2670 /* run back over *p */
2671 /* room for Rn or Rnn (include prefix) exactly? */
2672 if (q > p && q < p + 4)
2673 reg = vax_reg_parse (p[0], p[1],
2674 q < p + 2 ? 0 : p[2],
2675 q < p + 3 ? 0 : p[3]);
2677 reg = -1; /* always comes here if no register at all */
2679 * Here with a definitive reg value.
2690 * have reg. -1:absent; else 0:15
2694 * We have: err, at, len, hash, ndx, sign, paren, reg.
2695 * Also, any remaining expression is from *p through *q inclusive.
2696 * Should there be no expression, q==p-1. So expression length = q-p+1.
2697 * This completes the first part: parsing the operand text.
2701 * We now want to boil the data down, checking consistency on the way.
2702 * We want: len, mode, reg, ndx, err, p, q, wrn, bug.
2703 * We will deliver a 4-bit reg, and a 4-bit mode.
2707 * Case of branch operand. Different. No L^B^W^I^S^ allowed for instance.
2721 * p:q whatever was input
2723 * err " " or error message, and other outputs trashed
2725 /* branch operands have restricted forms */
2726 if ((!err || !*err) && access_mode == 'b')
2728 if (at || hash || sign || paren || ndx >= 0 || reg >= 0 || len != ' ')
2729 err = _("invalid branch operand");
2734 /* Since nobody seems to use it: comment this 'feature'(?) out for now. */
2737 * Case of stand-alone operand. e.g. ".long foo"
2751 * p:q whatever was input
2753 * err " " or error message, and other outputs trashed
2755 if ((!err || !*err) && access_mode == ' ')
2758 err = _("address prohibits @");
2760 err = _("address prohibits #");
2764 err = _("address prohibits -()");
2766 err = _("address prohibits ()+");
2769 err = _("address prohibits ()");
2771 err = _("address prohibits []");
2773 err = _("address prohibits register");
2774 else if (len != ' ')
2775 err = _("address prohibits displacement length specifier");
2778 err = " "; /* succeed */
2782 #endif /*#Ifdef NEVER*/
2788 * len 's' definition
2790 * p:q demand not empty
2791 * sign 0 by paren==0
2792 * paren 0 by "()" scan logic because "S^" seen
2793 * reg -1 or nn by mistake
2802 if ((!err || !*err) && len == 's')
2804 if (!hash || paren || at || ndx >= 0)
2805 err = _("invalid operand of S^#");
2811 * SHIT! we saw S^#Rnn ! put the Rnn back in
2812 * expression. KLUDGE! Use oldq so we don't
2813 * need to know exact length of reg name.
2819 * We have all the expression we will ever get.
2822 err = _("S^# needs expression");
2823 else if (access_mode == 'r')
2825 err = " "; /* WIN! */
2829 err = _("S^# may only read-access");
2834 * Case of -(Rn), which is weird case.
2840 * sign -1 by definition
2841 * paren 1 by definition
2842 * reg present by definition
2848 * exp "" enforce empty expression
2849 * ndx optional warn if same as reg
2851 if ((!err || !*err) && sign < 0)
2853 if (len != ' ' || hash || at || p <= q)
2854 err = _("invalid operand of -()");
2857 err = " "; /* win */
2860 wrn = _("-(PC) unpredictable");
2861 else if (reg == ndx)
2862 wrn = _("[]index same as -()register: unpredictable");
2867 * We convert "(Rn)" to "@Rn" for our convenience.
2868 * (I hope this is convenient: has someone got a better way to parse this?)
2869 * A side-effect of this is that "@Rn" is a valid operand.
2871 if (paren && !sign && !hash && !at && len == ' ' && p > q)
2878 * Case of (Rn)+, which is slightly different.
2884 * sign +1 by definition
2885 * paren 1 by definition
2886 * reg present by definition
2892 * exp "" enforce empty expression
2893 * ndx optional warn if same as reg
2895 if ((!err || !*err) && sign > 0)
2897 if (len != ' ' || hash || p <= q)
2898 err = _("invalid operand of ()+");
2901 err = " "; /* win */
2902 mode = 8 + (at ? 1 : 0);
2904 wrn = _("(PC)+ unpredictable");
2905 else if (reg == ndx)
2906 wrn = _("[]index same as ()+register: unpredictable");
2911 * Case of #, without S^.
2915 * hash 1 by definition
2928 if ((!err || !*err) && hash)
2930 if (len != 'i' && len != ' ')
2931 err = _("# conflicts length");
2933 err = _("# bars register");
2939 * SHIT! we saw #Rnn! Put the Rnn back into the expression.
2940 * By using oldq, we don't need to know how long Rnn was.
2944 reg = -1; /* no register any more */
2946 err = " "; /* win */
2948 /* JF a bugfix, I think! */
2949 if (at && access_mode == 'a')
2950 vopP->vop_nbytes = 4;
2952 mode = (at ? 9 : 8);
2954 if ((access_mode == 'm' || access_mode == 'w') && !at)
2955 wrn = _("writing or modifying # is unpredictable");
2959 * If !*err, then sign == 0
2964 * Case of Rn. We seperate this one because it has a few special
2965 * errors the remaining modes lack.
2969 * hash 0 by program logic
2971 * sign 0 by program logic
2972 * paren 0 by definition
2973 * reg present by definition
2978 * len ' ' enforce no length
2979 * exp "" enforce empty expression
2980 * ndx optional warn if same as reg
2982 if ((!err || !*err) && !paren && reg >= 0)
2985 err = _("length not needed");
2988 err = " "; /* win */
2992 err = _("can't []index a register, because it has no address");
2993 else if (access_mode == 'a')
2994 err = _("a register has no address");
2998 * Idea here is to detect from length of datum
2999 * and from register number if we will touch PC.
3001 * vop_nbytes is number of bytes in operand.
3002 * Compute highest byte affected, compare to PC0.
3004 if ((vopP->vop_nbytes + reg * 4) > 60)
3005 wrn = _("PC part of operand unpredictable");
3006 err = " "; /* win */
3011 * If !*err, sign == 0
3013 * paren == 1 OR reg==-1
3017 * Rest of cases fit into one bunch.
3020 * len ' ' or 'b' or 'w' or 'l'
3021 * hash 0 by program logic
3022 * p:q expected (empty is not an error)
3023 * sign 0 by program logic
3028 * out: mode 10 + @ + len
3030 * len ' ' or 'b' or 'w' or 'l'
3032 * ndx optional warn if same as reg
3036 err = " "; /* win (always) */
3037 mode = 10 + (at ? 1 : 0);
3044 case ' ': /* assumed B^ until our caller changes it */
3051 * here with completely specified mode
3059 err = 0; /* " " is no longer an error */
3061 vopP->vop_mode = mode;
3062 vopP->vop_reg = reg;
3063 vopP->vop_short = len;
3064 vopP->vop_expr_begin = p;
3065 vopP->vop_expr_end = q;
3066 vopP->vop_ndx = ndx;
3067 vopP->vop_error = err;
3068 vopP->vop_warn = wrn;
3073 Summary of vip_op outputs.
3077 {@}Rn 5+@ n ' ' optional
3078 branch operand 0 -1 ' ' -1
3080 -(Rn) 7 n ' ' optional
3081 {@}(Rn)+ 8+@ n ' ' optional
3082 {@}#foo, no S^ 8+@ PC " i" optional
3083 {@}{q^}{(Rn)} 10+@+q option " bwl" optional
3087 #ifdef TEST /* #Define to use this testbed. */
3090 * Follows a test program for this function.
3091 * We declare arrays non-local in case some of our tiny-minded machines
3092 * default to small stacks. Also, helps with some debuggers.
3097 char answer[100]; /* human types into here */
3110 int my_operand_length;
3111 char my_immediate[200];
3112 char my_indirect[200];
3113 char my_displen[200];
3117 printf ("enter immediate symbols eg enter # ");
3118 gets (my_immediate);
3119 printf ("enter indirect symbols eg enter @ ");
3121 printf ("enter displen symbols eg enter ^ ");
3123 vip_op_defaults (my_immediate, my_indirect, my_displen);
3126 printf ("access,width (eg 'ab' or 'wh') [empty line to quit] : ");
3130 exit (EXIT_SUCCESS);
3131 myaccess = answer[0];
3132 mywidth = answer[1];
3136 my_operand_length = 1;
3139 my_operand_length = 8;
3142 my_operand_length = 4;
3145 my_operand_length = 16;
3148 my_operand_length = 32;
3151 my_operand_length = 4;
3154 my_operand_length = 16;
3157 my_operand_length = 8;
3160 my_operand_length = 2;
3165 my_operand_length = 0;
3169 my_operand_length = 2;
3170 printf ("I dn't understand access width %c\n", mywidth);
3173 printf ("VAX assembler instruction operand: ");
3176 mybug = vip_op (answer, myaccess, mywidth, my_operand_length,
3177 &mymode, &myreg, &mylen, &myleft, &myright, &myndx,
3181 printf ("error: \"%s\"\n", myerr);
3183 printf (" bug: \"%s\"\n", mybug);
3188 printf ("warning: \"%s\"\n", mywrn);
3189 mumble ("mode", mymode);
3190 mumble ("register", myreg);
3191 mumble ("index", myndx);
3192 printf ("width:'%c' ", mylen);
3193 printf ("expression: \"");
3194 while (myleft <= myright)
3195 putchar (*myleft++);
3201 mumble (text, value)
3205 printf ("%s:", text);
3207 printf ("%xx", value);
3213 #endif /* ifdef TEST */
3217 const int md_short_jump_size = 3;
3218 const int md_long_jump_size = 6;
3219 const int md_reloc_size = 8; /* Size of relocation record */
3222 md_create_short_jump (ptr, from_addr, to_addr, frag, to_symbol)
3225 addressT to_addr ATTRIBUTE_UNUSED;
3226 fragS *frag ATTRIBUTE_UNUSED;
3227 symbolS *to_symbol ATTRIBUTE_UNUSED;
3231 /* This former calculation was off by two:
3232 offset = to_addr - (from_addr + 1);
3233 We need to account for the one byte instruction and also its
3234 two byte operand. */
3235 offset = to_addr - (from_addr + 1 + 2);
3236 *ptr++ = VAX_BRW; /* branch with word (16 bit) offset */
3237 md_number_to_chars (ptr, offset, 2);
3241 md_create_long_jump (ptr, from_addr, to_addr, frag, to_symbol)
3243 addressT from_addr ATTRIBUTE_UNUSED;
3250 offset = to_addr - S_GET_VALUE (to_symbol);
3251 *ptr++ = VAX_JMP; /* arbitrary jump */
3252 *ptr++ = VAX_ABSOLUTE_MODE;
3253 md_number_to_chars (ptr, offset, 4);
3254 fix_new (frag, ptr - frag->fr_literal, 4, to_symbol, (long) 0, 0, NO_RELOC);
3258 const char *md_shortopts = "d:STt:V+1h:Hv::";
3259 #elif defined(OBJ_ELC)
3260 const char *md_shortopts = "d:STt:VkK";
3262 const char *md_shortopts = "d:STt:V";
3264 struct option md_longopts[] = {
3265 {NULL, no_argument, NULL, 0}
3267 size_t md_longopts_size = sizeof (md_longopts);
3270 md_parse_option (c, arg)
3277 as_warn (_("SYMBOL TABLE not implemented"));
3281 as_warn (_("TOKEN TRACE not implemented"));
3285 as_warn (_("Displacement length %s ignored!"), arg);
3289 as_warn (_("I don't need or use temp. file \"%s\"."), arg);
3293 as_warn (_("I don't use an interpass file! -V ignored"));
3297 case '+': /* For g++. Hash any name > 31 chars long. */
3298 flag_hash_long_names = 1;
3301 case '1': /* For backward compatibility */
3305 case 'H': /* Show new symbol after hash truncation */
3306 flag_show_after_trunc = 1;
3309 case 'h': /* No hashing of mixed-case names */
3311 extern char vms_name_mapping;
3312 vms_name_mapping = atoi (arg);
3313 flag_no_hash_mixed_case = 1;
3319 extern char *compiler_version_string;
3320 if (!arg || !*arg || access (arg, 0) == 0)
3321 return 0; /* have caller show the assembler version */
3322 compiler_version_string = arg;
3331 break; /* -pic, Position Independent Code */
3342 md_show_usage (stream)
3345 fprintf (stream, _("\
3347 -d LENGTH ignored\n\
3354 fprintf (stream, _("\
3356 -+ hash encode names longer than 31 characters\n\
3357 -1 `const' handling compatible with gcc 1.x\n\
3358 -H show new symbol after hash truncation\n\
3359 -h NUM don't hash mixed-case names, and adjust case:\n\
3360 0 = upper, 2 = lower, 3 = preserve case\n\
3361 -v\"VERSION\" code being assembled was produced by compiler \"VERSION\"\n"));
3365 /* We have no need to default values of symbols. */
3368 md_undefined_symbol (name)
3369 char *name ATTRIBUTE_UNUSED;
3374 /* Round up a section size to the appropriate boundary. */
3376 md_section_align (segment, size)
3377 segT segment ATTRIBUTE_UNUSED;
3380 return size; /* Byte alignment is fine */
3383 /* Exactly what point is a PC-relative offset relative TO?
3384 On the vax, they're relative to the address of the offset, plus
3387 md_pcrel_from (fixP)
3390 return fixP->fx_size + fixP->fx_where + fixP->fx_frag->fr_address;
3394 #ifndef BFD_ASSEMBLER
3396 tc_headers_hook(headers)
3397 object_headers *headers;
3400 N_SET_INFO(headers->header, OMAGIC, M_VAX4K_NETBSD, 0);
3401 headers->header.a_info = htonl(headers->header.a_info);
3404 #endif /* !BFD_ASSEMBLER */
3405 #endif /* OBJ_AOUT */
3407 #ifdef BFD_ASSEMBLER
3409 tc_gen_reloc (section, fixp)
3410 asection *section ATTRIBUTE_UNUSED;
3414 bfd_reloc_code_real_type code;
3419 if (fixp->fx_r_type != BFD_RELOC_NONE)
3421 code = fixp->fx_r_type;
3427 case BFD_RELOC_8_PCREL:
3428 case BFD_RELOC_16_PCREL:
3429 case BFD_RELOC_32_PCREL:
3431 case BFD_RELOC_8_GOT_PCREL:
3432 case BFD_RELOC_16_GOT_PCREL:
3433 case BFD_RELOC_32_GOT_PCREL:
3434 case BFD_RELOC_8_PLT_PCREL:
3435 case BFD_RELOC_16_PLT_PCREL:
3436 case BFD_RELOC_32_PLT_PCREL:
3440 as_bad_where (fixp->fx_file, fixp->fx_line,
3441 _("Cannot make %s relocation PC relative"),
3442 bfd_get_reloc_code_name (code));
3448 #define F(SZ,PCREL) (((SZ) << 1) + (PCREL))
3449 switch (F (fixp->fx_size, fixp->fx_pcrel))
3451 #define MAP(SZ,PCREL,TYPE) case F(SZ,PCREL): code = (TYPE); break
3452 MAP (1, 0, BFD_RELOC_8);
3453 MAP (2, 0, BFD_RELOC_16);
3454 MAP (4, 0, BFD_RELOC_32);
3455 MAP (1, 1, BFD_RELOC_8_PCREL);
3456 MAP (2, 1, BFD_RELOC_16_PCREL);
3457 MAP (4, 1, BFD_RELOC_32_PCREL);
3465 reloc = (arelent *) xmalloc (sizeof (arelent));
3466 reloc->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
3467 *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
3468 reloc->address = fixp->fx_frag->fr_address + fixp->fx_where;
3471 reloc->addend = fixp->fx_addnumber;
3475 reloc->addend = fixp->fx_offset;
3478 reloc->howto = bfd_reloc_type_lookup (stdoutput, code);
3479 assert (reloc->howto != 0);
3483 #endif /* BFD_ASSEMBLER */
3485 /* end of tc-vax.c */
projects / binutils.git / blob