1 /* tc-vax.c - vax-specific -
2 Copyright 1987, 1991, 1992, 1993, 1994, 1995, 1998, 2000, 2001, 2002,
4 Free Software Foundation, Inc.
6 This file is part of GAS, the GNU Assembler.
8 GAS is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
13 GAS is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GAS; see the file COPYING. If not, write to the Free
20 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
26 #include "obstack.h" /* For FRAG_APPEND_1_CHAR macro in "frags.h" */
33 /* These chars start a comment anywhere in a source file (except inside
35 const char comment_chars
[] = "#";
37 /* These chars only start a comment at the beginning of a line. */
38 /* Note that for the VAX the are the same as comment_chars above. */
39 const char line_comment_chars
[] = "#";
41 const char line_separator_chars
[] = ";";
43 /* Chars that can be used to separate mant from exp in floating point nums */
44 const char EXP_CHARS
[] = "eE";
46 /* Chars that mean this number is a floating point constant */
48 /* or 0H1.234E-12 (see exp chars above) */
49 const char FLT_CHARS
[] = "dDfFgGhH";
51 /* Also be aware that MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT may have to be
52 changed in read.c . Ideally it shouldn't have to know about it at all,
53 but nothing is ideal around here. */
55 /* Hold details of an operand expression */
56 static expressionS exp_of_operand
[VIT_MAX_OPERANDS
];
57 static segT seg_of_operand
[VIT_MAX_OPERANDS
];
59 /* A vax instruction after decoding. */
62 /* Hold details of big operands. */
63 LITTLENUM_TYPE big_operand_bits
[VIT_MAX_OPERANDS
][SIZE_OF_LARGE_NUMBER
];
64 FLONUM_TYPE float_operand
[VIT_MAX_OPERANDS
];
65 /* Above is made to point into big_operand_bits by md_begin(). */
68 #define GLOBAL_OFFSET_TABLE_NAME "_GLOBAL_OFFSET_TABLE_"
69 #define PROCEDURE_LINKAGE_TABLE_NAME "_PROCEDURE_LINKAGE_TABLE_"
70 symbolS
*GOT_symbol
; /* Pre-defined "_GLOBAL_OFFSET_TABLE_" */
71 symbolS
*PLT_symbol
; /* Pre-defined "_PROCEDURE_LINKAGE_TABLE_" */
74 int flag_hash_long_names
; /* -+ */
75 int flag_one
; /* -1 */
76 int flag_show_after_trunc
; /* -H */
77 int flag_no_hash_mixed_case
; /* -h NUM */
79 int flag_want_pic
; /* -k */
83 * For VAX, relative addresses of "just the right length" are easy.
84 * The branch displacement is always the last operand, even in
85 * synthetic instructions.
86 * For VAX, we encode the relax_substateTs (in e.g. fr_substate) as:
88 * 4 3 2 1 0 bit number
89 * ---/ /--+-------+-------+-------+-------+-------+
90 * | what state ? | how long ? |
91 * ---/ /--+-------+-------+-------+-------+-------+
93 * The "how long" bits are 00=byte, 01=word, 10=long.
94 * This is a Un*x convention.
95 * Not all lengths are legit for a given value of (what state).
96 * The "how long" refers merely to the displacement length.
97 * The address usually has some constant bytes in it as well.
100 groups for VAX address relaxing.
102 1. "foo" pc-relative.
103 length of byte, word, long
105 2a. J<cond> where <cond> is a simple flag test.
106 length of byte, word, long.
107 VAX opcodes are: (Hex)
120 Always, you complement 0th bit to reverse condition.
121 Always, 1-byte opcode, then 1-byte displacement.
123 2b. J<cond> where cond tests a memory bit.
124 length of byte, word, long.
125 Vax opcodes are: (Hex)
132 Always, you complement 0th bit to reverse condition.
133 Always, 1-byte opcde, longword-address, byte-address, 1-byte-displacement
135 2c. J<cond> where cond tests low-order memory bit
136 length of byte,word,long.
137 Vax opcodes are: (Hex)
140 Always, you complement 0th bit to reverse condition.
141 Always, 1-byte opcode, longword-address, 1-byte displacement.
144 length of byte,word,long.
145 Vax opcodes are: (Hex)
148 These are like (2) but there is no condition to reverse.
149 Always, 1 byte opcode, then displacement/absolute.
152 length of word, long.
153 Vax opcodes are: (Hex)
161 Always, we cannot reverse the sense of the branch; we have a word
163 The double-byte op-codes don't hurt: we never want to modify the
164 opcode, so we don't care how many bytes are between the opcode and
168 length of long, long, byte.
169 Vax opcodes are: (Hex)
174 Always, we cannot reverse the sense of the branch; we have a byte
177 The only time we need to modify the opcode is for class 2 instructions.
178 After relax() we may complement the lowest order bit of such instruction
179 to reverse sense of branch.
181 For class 2 instructions, we store context of "where is the opcode literal".
182 We can change an opcode's lowest order bit without breaking anything else.
184 We sometimes store context in the operand literal. This way we can figure out
185 after relax() what the original addressing mode was.
188 /* These displacements are relative to the start address of the
189 displacement. The first letter is Byte, Word. 2nd letter is
190 Forward, Backward. */
193 #define WF (2+ 32767)
194 #define WB (2+-32768)
195 /* Dont need LF, LB because they always reach. [They are coded as 0.] */
197 #define C(a,b) ENCODE_RELAX(a,b)
198 /* This macro has no side-effects. */
199 #define ENCODE_RELAX(what,length) (((what) << 2) + (length))
200 #define RELAX_STATE(s) ((s) >> 2)
201 #define RELAX_LENGTH(s) ((s) & 3)
203 const relax_typeS md_relax_table
[] =
205 {1, 1, 0, 0}, /* error sentinel 0,0 */
206 {1, 1, 0, 0}, /* unused 0,1 */
207 {1, 1, 0, 0}, /* unused 0,2 */
208 {1, 1, 0, 0}, /* unused 0,3 */
210 {BF
+ 1, BB
+ 1, 2, C (1, 1)},/* B^"foo" 1,0 */
211 {WF
+ 1, WB
+ 1, 3, C (1, 2)},/* W^"foo" 1,1 */
212 {0, 0, 5, 0}, /* L^"foo" 1,2 */
213 {1, 1, 0, 0}, /* unused 1,3 */
215 {BF
, BB
, 1, C (2, 1)}, /* b<cond> B^"foo" 2,0 */
216 {WF
+ 2, WB
+ 2, 4, C (2, 2)},/* br.+? brw X 2,1 */
217 {0, 0, 7, 0}, /* br.+? jmp X 2,2 */
218 {1, 1, 0, 0}, /* unused 2,3 */
220 {BF
, BB
, 1, C (3, 1)}, /* brb B^foo 3,0 */
221 {WF
, WB
, 2, C (3, 2)}, /* brw W^foo 3,1 */
222 {0, 0, 5, 0}, /* Jmp L^foo 3,2 */
223 {1, 1, 0, 0}, /* unused 3,3 */
225 {1, 1, 0, 0}, /* unused 4,0 */
226 {WF
, WB
, 2, C (4, 2)}, /* acb_ ^Wfoo 4,1 */
227 {0, 0, 10, 0}, /* acb_,br,jmp L^foo4,2 */
228 {1, 1, 0, 0}, /* unused 4,3 */
230 {BF
, BB
, 1, C (5, 1)}, /* Xob___,,foo 5,0 */
231 {WF
+ 4, WB
+ 4, 6, C (5, 2)},/* Xob.+2,brb.+3,brw5,1 */
232 {0, 0, 9, 0}, /* Xob.+2,brb.+6,jmp5,2 */
233 {1, 1, 0, 0}, /* unused 5,3 */
242 void float_cons
PARAMS ((int));
244 const pseudo_typeS md_pseudo_table
[] =
246 {"dfloat", float_cons
, 'd'},
247 {"ffloat", float_cons
, 'f'},
248 {"gfloat", float_cons
, 'g'},
249 {"hfloat", float_cons
, 'h'},
250 {"d_floating", float_cons
, 'd'},
251 {"f_floating", float_cons
, 'f'},
252 {"g_floating", float_cons
, 'g'},
253 {"h_floating", float_cons
, 'h'},
257 #define STATE_PC_RELATIVE (1)
258 #define STATE_CONDITIONAL_BRANCH (2)
259 #define STATE_ALWAYS_BRANCH (3) /* includes BSB... */
260 #define STATE_COMPLEX_BRANCH (4)
261 #define STATE_COMPLEX_HOP (5)
263 #define STATE_BYTE (0)
264 #define STATE_WORD (1)
265 #define STATE_LONG (2)
266 #define STATE_UNDF (3) /* Symbol undefined in pass1 */
268 #define min(a, b) ((a) < (b) ? (a) : (b))
270 int flonum_gen2vax
PARAMS ((char format_letter
, FLONUM_TYPE
* f
,
271 LITTLENUM_TYPE
* words
));
272 static const char *vip_begin
PARAMS ((int, const char *, const char *,
274 static void vip_op_1
PARAMS ((int, const char *));
275 static void vip_op_defaults
PARAMS ((const char *, const char *, const char *));
276 static void vip_op
PARAMS ((char *, struct vop
*));
277 static void vip
PARAMS ((struct vit
*, char *));
279 static int vax_reg_parse
PARAMS ((char, char, char, char));
288 if ((errtxt
= vip_begin (1, "$", "*", "`")) != 0)
290 as_fatal (_("VIP_BEGIN error:%s"), errtxt
);
293 for (i
= 0, fP
= float_operand
;
294 fP
< float_operand
+ VIT_MAX_OPERANDS
;
297 fP
->low
= &big_operand_bits
[i
][0];
298 fP
->high
= &big_operand_bits
[i
][SIZE_OF_LARGE_NUMBER
- 1];
303 md_number_to_chars (con
, value
, nbytes
)
308 number_to_chars_littleendian (con
, value
, nbytes
);
311 /* Fix up some data or instructions after we find out the value of a symbol
312 that they reference. */
314 void /* Knows about order of bytes in address. */
315 md_apply_fix (fixP
, valueP
, seg
)
318 segT seg ATTRIBUTE_UNUSED
;
320 valueT value
= * valueP
;
322 if (((fixP
->fx_addsy
== NULL
&& fixP
->fx_subsy
== NULL
)
323 && fixP
->fx_r_type
!= BFD_RELOC_32_PLT_PCREL
324 && fixP
->fx_r_type
!= BFD_RELOC_32_GOT_PCREL
)
325 || fixP
->fx_r_type
== NO_RELOC
)
326 number_to_chars_littleendian (fixP
->fx_where
+ fixP
->fx_frag
->fr_literal
,
327 value
, fixP
->fx_size
);
329 if (fixP
->fx_addsy
== NULL
&& fixP
->fx_pcrel
== 0)
334 md_chars_to_number (con
, nbytes
)
335 unsigned char con
[]; /* Low order byte 1st. */
336 int nbytes
; /* Number of bytes in the input. */
339 for (retval
= 0, con
+= nbytes
- 1; nbytes
--; con
--)
341 retval
<<= BITS_PER_CHAR
;
348 * Copy a bignum from in to out.
349 * If the output is shorter than the input, copy lower-order
350 * littlenums. Return 0 or the number of significant littlenums
351 * dropped. Assumes littlenum arrays are densely packed: no unused
352 * chars between the littlenums. Uses memcpy() to move littlenums, and
353 * wants to know length (in chars) of the input bignum.
357 bignum_copy (register LITTLENUM_TYPE
*in
,
358 register int in_length
, /* in sizeof(littlenum)s */
359 register LITTLENUM_TYPE
*out
,
360 register int out_length
/* in sizeof(littlenum)s */)
362 int significant_littlenums_dropped
;
364 if (out_length
< in_length
)
366 LITTLENUM_TYPE
*p
; /* -> most significant (non-zero) input
369 memcpy ((void *) out
, (void *) in
,
370 (unsigned int) out_length
<< LITTLENUM_SHIFT
);
371 for (p
= in
+ in_length
- 1; p
>= in
; --p
)
376 significant_littlenums_dropped
= p
- in
- in_length
+ 1;
378 if (significant_littlenums_dropped
< 0)
380 significant_littlenums_dropped
= 0;
385 memcpy ((char *) out
, (char *) in
,
386 (unsigned int) in_length
<< LITTLENUM_SHIFT
);
388 if (out_length
> in_length
)
390 memset ((char *) (out
+ in_length
),
392 (unsigned int) (out_length
- in_length
) << LITTLENUM_SHIFT
);
395 significant_littlenums_dropped
= 0;
398 return (significant_littlenums_dropped
);
401 /* vax:md_assemble() emit frags for 1 instruction */
404 md_assemble (instruction_string
)
405 char *instruction_string
; /* A string: assemble 1 instruction. */
407 /* Non-zero if operand expression's segment is not known yet. */
409 /* Non-zero if operand expression's segment is absolute. */
414 /* An operand. Scans all operands. */
415 struct vop
*operandP
;
416 char *save_input_line_pointer
;
417 /* What used to live after an expression. */
419 /* 1: instruction_string bad for all passes. */
421 /* Points to slot just after last operand. */
422 struct vop
*end_operandP
;
423 /* Points to expression values for this operand. */
427 /* These refer to an instruction operand expression. */
428 /* Target segment of the address. */
430 valueT this_add_number
;
431 /* Positive (minuend) symbol. */
432 symbolS
*this_add_symbol
;
434 long opcode_as_number
;
435 /* Least significant byte 1st. */
436 char *opcode_as_chars
;
437 /* As an array of characters. */
438 /* Least significant byte 1st */
439 char *opcode_low_byteP
;
440 /* length (bytes) meant by vop_short. */
442 /* 0, or 1 if '@' is in addressing mode. */
444 /* From vop_nbytes: vax_operand_width (in bytes) */
447 LITTLENUM_TYPE literal_float
[8];
448 /* Big enough for any floating point literal. */
450 vip (&v
, instruction_string
);
453 * Now we try to find as many as_warn()s as we can. If we do any as_warn()s
454 * then goofed=1. Notice that we don't make any frags yet.
455 * Should goofed be 1, then this instruction will wedge in any pass,
456 * and we can safely flush it, without causing interpass symbol phase
457 * errors. That is, without changing label values in different passes.
459 if ((goofed
= (*v
.vit_error
)) != 0)
461 as_fatal (_("Ignoring statement due to \"%s\""), v
.vit_error
);
464 * We need to use expression() and friends, which require us to diddle
465 * input_line_pointer. So we save it and restore it later.
467 save_input_line_pointer
= input_line_pointer
;
468 for (operandP
= v
.vit_operand
,
469 expP
= exp_of_operand
,
470 segP
= seg_of_operand
,
471 floatP
= float_operand
,
472 end_operandP
= v
.vit_operand
+ v
.vit_operands
;
474 operandP
< end_operandP
;
476 operandP
++, expP
++, segP
++, floatP
++)
477 { /* for each operand */
478 if (operandP
->vop_error
)
480 as_fatal (_("Aborting because statement has \"%s\""), operandP
->vop_error
);
485 /* Statement has no syntax goofs: let's sniff the expression. */
486 int can_be_short
= 0; /* 1 if a bignum can be reduced to a short literal. */
488 input_line_pointer
= operandP
->vop_expr_begin
;
489 c_save
= operandP
->vop_expr_end
[1];
490 operandP
->vop_expr_end
[1] = '\0';
491 /* If to_seg == SEG_PASS1, expression() will have set need_pass_2 = 1. */
492 *segP
= expression (expP
);
496 /* for BSD4.2 compatibility, missing expression is absolute 0 */
497 expP
->X_op
= O_constant
;
498 expP
->X_add_number
= 0;
499 /* For SEG_ABSOLUTE, we shouldn't need to set X_op_symbol,
500 X_add_symbol to any particular value. But, we will program
501 defensively. Since this situation occurs rarely so it costs
502 us little to do, and stops Dean worrying about the origin of
503 random bits in expressionS's. */
504 expP
->X_add_symbol
= NULL
;
505 expP
->X_op_symbol
= NULL
;
514 * Major bug. We can't handle the case of a
515 * SEG_OP expression in a VIT_OPCODE_SYNTHETIC
516 * variable-length instruction.
517 * We don't have a frag type that is smart enough to
518 * relax a SEG_OP, and so we just force all
519 * SEG_OPs to behave like SEG_PASS1s.
520 * Clearly, if there is a demand we can invent a new or
521 * modified frag type and then coding up a frag for this
522 * case will be easy. SEG_OP was invented for the
523 * .words after a CASE opcode, and was never intended for
524 * instruction operands.
527 as_fatal (_("Can't relocate expression"));
531 /* Preserve the bits. */
532 if (expP
->X_add_number
> 0)
534 bignum_copy (generic_bignum
, expP
->X_add_number
,
535 floatP
->low
, SIZE_OF_LARGE_NUMBER
);
539 know (expP
->X_add_number
< 0);
540 flonum_copy (&generic_floating_point_number
,
542 if (strchr ("s i", operandP
->vop_short
))
544 /* Could possibly become S^# */
545 flonum_gen2vax (-expP
->X_add_number
, floatP
, literal_float
);
546 switch (-expP
->X_add_number
)
550 (literal_float
[0] & 0xFC0F) == 0x4000
551 && literal_float
[1] == 0;
556 (literal_float
[0] & 0xFC0F) == 0x4000
557 && literal_float
[1] == 0
558 && literal_float
[2] == 0
559 && literal_float
[3] == 0;
564 (literal_float
[0] & 0xFF81) == 0x4000
565 && literal_float
[1] == 0
566 && literal_float
[2] == 0
567 && literal_float
[3] == 0;
571 can_be_short
= ((literal_float
[0] & 0xFFF8) == 0x4000
572 && (literal_float
[1] & 0xE000) == 0
573 && literal_float
[2] == 0
574 && literal_float
[3] == 0
575 && literal_float
[4] == 0
576 && literal_float
[5] == 0
577 && literal_float
[6] == 0
578 && literal_float
[7] == 0);
582 BAD_CASE (-expP
->X_add_number
);
584 } /* switch (float type) */
585 } /* if (could want to become S^#...) */
586 } /* bignum or flonum ? */
588 if (operandP
->vop_short
== 's'
589 || operandP
->vop_short
== 'i'
590 || (operandP
->vop_short
== ' '
591 && operandP
->vop_reg
== 0xF
592 && (operandP
->vop_mode
& 0xE) == 0x8))
595 if (operandP
->vop_short
== ' ')
597 /* We must chose S^ or I^. */
598 if (expP
->X_add_number
> 0)
600 /* Bignum: Short literal impossible. */
601 operandP
->vop_short
= 'i';
602 operandP
->vop_mode
= 8;
603 operandP
->vop_reg
= 0xF; /* VAX PC. */
607 /* Flonum: Try to do it. */
610 operandP
->vop_short
= 's';
611 operandP
->vop_mode
= 0;
612 operandP
->vop_ndx
= -1;
613 operandP
->vop_reg
= -1;
614 expP
->X_op
= O_constant
;
618 operandP
->vop_short
= 'i';
619 operandP
->vop_mode
= 8;
620 operandP
->vop_reg
= 0xF; /* VAX PC */
622 } /* bignum or flonum ? */
623 } /* if #, but no S^ or I^ seen. */
624 /* No more ' ' case: either 's' or 'i'. */
625 if (operandP
->vop_short
== 's')
627 /* Wants to be a short literal. */
628 if (expP
->X_add_number
> 0)
630 as_warn (_("Bignum not permitted in short literal. Immediate mode assumed."));
631 operandP
->vop_short
= 'i';
632 operandP
->vop_mode
= 8;
633 operandP
->vop_reg
= 0xF; /* VAX PC. */
639 as_warn (_("Can't do flonum short literal: immediate mode used."));
640 operandP
->vop_short
= 'i';
641 operandP
->vop_mode
= 8;
642 operandP
->vop_reg
= 0xF; /* VAX PC. */
645 { /* Encode short literal now. */
648 switch (-expP
->X_add_number
)
652 temp
= literal_float
[0] >> 4;
656 temp
= literal_float
[0] >> 1;
660 temp
= ((literal_float
[0] << 3) & 070)
661 | ((literal_float
[1] >> 13) & 07);
665 BAD_CASE (-expP
->X_add_number
);
669 floatP
->low
[0] = temp
& 077;
671 } /* if can be short literal float */
672 } /* flonum or bignum ? */
675 { /* I^# seen: set it up if float. */
676 if (expP
->X_add_number
< 0)
678 memcpy (floatP
->low
, literal_float
, sizeof (literal_float
));
684 as_warn (_("A bignum/flonum may not be a displacement: 0x%lx used"),
685 (expP
->X_add_number
= 0x80000000L
));
686 /* Chosen so luser gets the most offset bits to patch later. */
688 expP
->X_add_number
= floatP
->low
[0]
689 | ((LITTLENUM_MASK
& (floatP
->low
[1])) << LITTLENUM_NUMBER_OF_BITS
);
691 * For the O_big case we have:
692 * If vop_short == 's' then a short floating literal is in the
693 * lowest 6 bits of floatP -> low [0], which is
694 * big_operand_bits [---] [0].
695 * If vop_short == 'i' then the appropriate number of elements
696 * of big_operand_bits [---] [...] are set up with the correct
698 * Also, just in case width is byte word or long, we copy the lowest
699 * 32 bits of the number to X_add_number.
703 if (input_line_pointer
!= operandP
->vop_expr_end
+ 1)
705 as_fatal ("Junk at end of expression \"%s\"", input_line_pointer
);
708 operandP
->vop_expr_end
[1] = c_save
;
710 } /* for(each operand) */
712 input_line_pointer
= save_input_line_pointer
;
714 if (need_pass_2
|| goofed
)
720 /* Remember where it is, in case we want to modify the op-code later. */
721 opcode_low_byteP
= frag_more (v
.vit_opcode_nbytes
);
722 memcpy (opcode_low_byteP
, v
.vit_opcode
, v
.vit_opcode_nbytes
);
723 opcode_as_chars
= v
.vit_opcode
;
724 opcode_as_number
= md_chars_to_number ((unsigned char *) opcode_as_chars
, 4);
725 for (operandP
= v
.vit_operand
,
726 expP
= exp_of_operand
,
727 segP
= seg_of_operand
,
728 floatP
= float_operand
,
729 end_operandP
= v
.vit_operand
+ v
.vit_operands
;
731 operandP
< end_operandP
;
738 if (operandP
->vop_ndx
>= 0)
740 /* indexed addressing byte */
741 /* Legality of indexed mode already checked: it is OK */
742 FRAG_APPEND_1_CHAR (0x40 + operandP
->vop_ndx
);
743 } /* if(vop_ndx>=0) */
745 /* Here to make main operand frag(s). */
746 this_add_number
= expP
->X_add_number
;
747 this_add_symbol
= expP
->X_add_symbol
;
749 is_undefined
= (to_seg
== undefined_section
);
750 is_absolute
= (to_seg
== absolute_section
);
751 at
= operandP
->vop_mode
& 1;
752 length
= (operandP
->vop_short
== 'b'
753 ? 1 : (operandP
->vop_short
== 'w'
754 ? 2 : (operandP
->vop_short
== 'l'
756 nbytes
= operandP
->vop_nbytes
;
757 if (operandP
->vop_access
== 'b')
759 if (to_seg
== now_seg
|| is_undefined
)
761 /* If is_undefined, then it might BECOME now_seg. */
764 p
= frag_more (nbytes
);
765 fix_new (frag_now
, p
- frag_now
->fr_literal
, nbytes
,
766 this_add_symbol
, this_add_number
, 1, NO_RELOC
);
769 { /* to_seg==now_seg || to_seg == SEG_UNKNOWN */
771 length_code
= is_undefined
? STATE_UNDF
: STATE_BYTE
;
772 if (opcode_as_number
& VIT_OPCODE_SPECIAL
)
774 if (operandP
->vop_width
== VAX_WIDTH_UNCONDITIONAL_JUMP
)
777 frag_var (rs_machine_dependent
, 5, 1,
778 ENCODE_RELAX (STATE_ALWAYS_BRANCH
, length_code
),
779 this_add_symbol
, this_add_number
,
784 if (operandP
->vop_width
== VAX_WIDTH_WORD_JUMP
)
786 length_code
= STATE_WORD
;
787 /* JF: There is no state_byte for this one! */
788 frag_var (rs_machine_dependent
, 10, 2,
789 ENCODE_RELAX (STATE_COMPLEX_BRANCH
, length_code
),
790 this_add_symbol
, this_add_number
,
795 know (operandP
->vop_width
== VAX_WIDTH_BYTE_JUMP
);
796 frag_var (rs_machine_dependent
, 9, 1,
797 ENCODE_RELAX (STATE_COMPLEX_HOP
, length_code
),
798 this_add_symbol
, this_add_number
,
805 know (operandP
->vop_width
== VAX_WIDTH_CONDITIONAL_JUMP
);
806 frag_var (rs_machine_dependent
, 7, 1,
807 ENCODE_RELAX (STATE_CONDITIONAL_BRANCH
, length_code
),
808 this_add_symbol
, this_add_number
,
815 /* to_seg != now_seg && to_seg != SEG_UNKNOWN */
817 * --- SEG FLOAT MAY APPEAR HERE ----
823 know (!(opcode_as_number
& VIT_OPCODE_SYNTHETIC
));
824 p
= frag_more (nbytes
);
825 /* Conventional relocation. */
826 fix_new (frag_now
, p
- frag_now
->fr_literal
, nbytes
,
827 section_symbol (absolute_section
),
828 this_add_number
, 1, NO_RELOC
);
832 know (opcode_as_number
& VIT_OPCODE_SYNTHETIC
);
833 if (opcode_as_number
& VIT_OPCODE_SPECIAL
)
835 if (operandP
->vop_width
== VAX_WIDTH_UNCONDITIONAL_JUMP
)
838 *opcode_low_byteP
= opcode_as_chars
[0] + VAX_WIDEN_LONG
;
839 know (opcode_as_chars
[1] == 0);
841 p
[0] = VAX_ABSOLUTE_MODE
; /* @#... */
842 md_number_to_chars (p
+ 1, this_add_number
, 4);
843 /* Now (eg) JMP @#foo or JSB @#foo. */
847 if (operandP
->vop_width
== VAX_WIDTH_WORD_JUMP
)
855 p
[5] = VAX_ABSOLUTE_MODE
; /* @#... */
856 md_number_to_chars (p
+ 6, this_add_number
, 4);
866 know (operandP
->vop_width
== VAX_WIDTH_BYTE_JUMP
);
872 p
[4] = VAX_ABSOLUTE_MODE
; /* @#... */
873 md_number_to_chars (p
+ 5, this_add_number
, 4);
886 *opcode_low_byteP
^= 1;
887 /* To reverse the condition in a VAX branch,
888 complement the lowest order bit. */
892 p
[2] = VAX_ABSOLUTE_MODE
; /* @#... */
893 md_number_to_chars (p
+ 3, this_add_number
, 4);
904 /* to_seg != now_seg && !is_undefinfed && !is_absolute */
907 /* Pc-relative. Conventional relocation. */
908 know (!(opcode_as_number
& VIT_OPCODE_SYNTHETIC
));
909 p
= frag_more (nbytes
);
910 fix_new (frag_now
, p
- frag_now
->fr_literal
, nbytes
,
911 section_symbol (absolute_section
),
912 this_add_number
, 1, NO_RELOC
);
916 know (opcode_as_number
& VIT_OPCODE_SYNTHETIC
);
917 if (opcode_as_number
& VIT_OPCODE_SPECIAL
)
919 if (operandP
->vop_width
== VAX_WIDTH_UNCONDITIONAL_JUMP
)
922 know (opcode_as_chars
[1] == 0);
923 *opcode_low_byteP
= opcode_as_chars
[0] + VAX_WIDEN_LONG
;
925 p
[0] = VAX_PC_RELATIVE_MODE
;
927 p
+ 1 - frag_now
->fr_literal
, 4,
929 this_add_number
, 1, NO_RELOC
);
930 /* Now eg JMP foo or JSB foo. */
934 if (operandP
->vop_width
== VAX_WIDTH_WORD_JUMP
)
942 p
[5] = VAX_PC_RELATIVE_MODE
;
944 p
+ 6 - frag_now
->fr_literal
, 4,
946 this_add_number
, 1, NO_RELOC
);
956 know (operandP
->vop_width
== VAX_WIDTH_BYTE_JUMP
);
962 p
[4] = VAX_PC_RELATIVE_MODE
;
964 p
+ 5 - frag_now
->fr_literal
,
966 this_add_number
, 1, NO_RELOC
);
978 know (operandP
->vop_width
== VAX_WIDTH_CONDITIONAL_JUMP
);
979 *opcode_low_byteP
^= 1; /* Reverse branch condition. */
983 p
[2] = VAX_PC_RELATIVE_MODE
;
984 fix_new (frag_now
, p
+ 3 - frag_now
->fr_literal
,
986 this_add_number
, 1, NO_RELOC
);
994 know (operandP
->vop_access
!= 'b'); /* So it is ordinary operand. */
995 know (operandP
->vop_access
!= ' '); /* ' ' target-independent: elsewhere. */
996 know (operandP
->vop_access
== 'a'
997 || operandP
->vop_access
== 'm'
998 || operandP
->vop_access
== 'r'
999 || operandP
->vop_access
== 'v'
1000 || operandP
->vop_access
== 'w');
1001 if (operandP
->vop_short
== 's')
1005 if (this_add_number
>= 64)
1007 as_warn (_("Short literal overflow(%ld.), immediate mode assumed."),
1008 (long) this_add_number
);
1009 operandP
->vop_short
= 'i';
1010 operandP
->vop_mode
= 8;
1011 operandP
->vop_reg
= 0xF;
1016 as_warn (_("Forced short literal to immediate mode. now_seg=%s to_seg=%s"),
1017 segment_name (now_seg
), segment_name (to_seg
));
1018 operandP
->vop_short
= 'i';
1019 operandP
->vop_mode
= 8;
1020 operandP
->vop_reg
= 0xF;
1023 if (operandP
->vop_reg
>= 0 && (operandP
->vop_mode
< 8
1024 || (operandP
->vop_reg
!= 0xF && operandP
->vop_mode
< 10)))
1026 /* One byte operand. */
1027 know (operandP
->vop_mode
> 3);
1028 FRAG_APPEND_1_CHAR (operandP
->vop_mode
<< 4 | operandP
->vop_reg
);
1029 /* All 1-bytes except S^# happen here. */
1033 /* {@}{q^}foo{(Rn)} or S^#foo */
1034 if (operandP
->vop_reg
== -1 && operandP
->vop_short
!= 's')
1037 if (to_seg
== now_seg
)
1041 know (operandP
->vop_short
== ' ');
1042 length_code
= STATE_BYTE
;
1044 if (S_IS_EXTERNAL (this_add_symbol
)
1045 || S_IS_WEAK (this_add_symbol
))
1046 length_code
= STATE_UNDF
;
1048 p
= frag_var (rs_machine_dependent
, 10, 2,
1049 ENCODE_RELAX (STATE_PC_RELATIVE
, length_code
),
1050 this_add_symbol
, this_add_number
,
1052 know (operandP
->vop_mode
== 10 + at
);
1054 /* At is the only context we need to carry
1055 to other side of relax() process. Must
1056 be in the correct bit position of VAX
1057 operand spec. byte. */
1062 know (operandP
->vop_short
!= ' ');
1063 p
= frag_more (length
+ 1);
1064 p
[0] = 0xF | ((at
+ "?\12\14?\16"[length
]) << 4);
1065 fix_new (frag_now
, p
+ 1 - frag_now
->fr_literal
,
1066 length
, this_add_symbol
,
1067 this_add_number
, 1, NO_RELOC
);
1071 { /* to_seg != now_seg */
1072 if (this_add_symbol
== NULL
)
1075 /* Do @#foo: simpler relocation than foo-.(pc) anyway. */
1077 p
[0] = VAX_ABSOLUTE_MODE
; /* @#... */
1078 md_number_to_chars (p
+ 1, this_add_number
, 4);
1079 if (length
&& length
!= 4)
1081 as_warn (_("Length specification ignored. Address mode 9F used"));
1086 /* {@}{q^}other_seg */
1087 know ((length
== 0 && operandP
->vop_short
== ' ')
1088 || (length
> 0 && operandP
->vop_short
!= ' '));
1091 || S_IS_WEAK(this_add_symbol
)
1092 || S_IS_EXTERNAL(this_add_symbol
)
1098 default: length_code
= STATE_UNDF
; break;
1099 case 1: length_code
= STATE_BYTE
; break;
1100 case 2: length_code
= STATE_WORD
; break;
1101 case 4: length_code
= STATE_LONG
; break;
1104 * We have a SEG_UNKNOWN symbol. It might
1105 * turn out to be in the same segment as
1106 * the instruction, permitting relaxation.
1108 p
= frag_var (rs_machine_dependent
, 5, 2,
1109 ENCODE_RELAX (STATE_PC_RELATIVE
, length_code
),
1110 this_add_symbol
, this_add_number
,
1118 know (operandP
->vop_short
== ' ');
1119 length
= 4; /* Longest possible. */
1121 p
= frag_more (length
+ 1);
1122 p
[0] = 0xF | ((at
+ "?\12\14?\16"[length
]) << 4);
1123 md_number_to_chars (p
+ 1, this_add_number
, length
);
1125 p
+ 1 - frag_now
->fr_literal
,
1126 length
, this_add_symbol
,
1127 this_add_number
, 1, NO_RELOC
);
1134 /* {@}{q^}foo(Rn) or S^# or I^# or # */
1135 if (operandP
->vop_mode
< 0xA)
1137 /* # or S^# or I^# */
1138 if (operandP
->vop_access
== 'v'
1139 || operandP
->vop_access
== 'a')
1141 if (operandP
->vop_access
== 'v')
1142 as_warn (_("Invalid operand: immediate value used as base address."));
1144 as_warn (_("Invalid operand: immediate value used as address."));
1145 /* gcc 2.6.3 is known to generate these in at least
1149 && is_absolute
&& (expP
->X_op
!= O_big
)
1150 && operandP
->vop_mode
== 8 /* No '@'. */
1151 && this_add_number
< 64)
1153 operandP
->vop_short
= 's';
1155 if (operandP
->vop_short
== 's')
1157 FRAG_APPEND_1_CHAR (this_add_number
);
1163 p
= frag_more (nbytes
+ 1);
1164 know (operandP
->vop_reg
== 0xF);
1166 if (flag_want_pic
&& operandP
->vop_mode
== 8
1167 && this_add_symbol
!= NULL
)
1169 as_warn (_("Symbol used as immediate operand in PIC mode."));
1172 p
[0] = (operandP
->vop_mode
<< 4) | 0xF;
1173 if ((is_absolute
) && (expP
->X_op
!= O_big
))
1175 /* If nbytes > 4, then we are scrod. We
1176 don't know if the high order bytes
1177 are to be 0xFF or 0x00. BSD4.2 & RMS
1178 say use 0x00. OK --- but this
1179 assembler needs ANOTHER rewrite to
1180 cope properly with this bug. */
1181 md_number_to_chars (p
+ 1, this_add_number
,
1182 min (sizeof (valueT
),
1184 if ((size_t) nbytes
> sizeof (valueT
))
1185 memset (p
+ 5, '\0', nbytes
- sizeof (valueT
));
1189 if (expP
->X_op
== O_big
)
1192 * Problem here is to get the bytes
1193 * in the right order. We stored
1194 * our constant as LITTLENUMs, not
1206 for (p
++; nbytes
; nbytes
-= 2, p
+= 2, lP
++)
1208 md_number_to_chars (p
, *lP
, 2);
1214 fix_new (frag_now
, p
+ 1 - frag_now
->fr_literal
,
1215 nbytes
, this_add_symbol
,
1216 this_add_number
, 0, NO_RELOC
);
1222 { /* {@}{q^}foo(Rn) */
1223 know ((length
== 0 && operandP
->vop_short
== ' ')
1224 || (length
> 0 && operandP
->vop_short
!= ' '));
1231 test
= this_add_number
;
1236 length
= test
& 0xffff8000 ? 4
1237 : test
& 0xffffff80 ? 2
1245 p
= frag_more (1 + length
);
1246 know (operandP
->vop_reg
>= 0);
1247 p
[0] = operandP
->vop_reg
1248 | ((at
| "?\12\14?\16"[length
]) << 4);
1251 md_number_to_chars (p
+ 1, this_add_number
, length
);
1255 fix_new (frag_now
, p
+ 1 - frag_now
->fr_literal
,
1256 length
, this_add_symbol
,
1257 this_add_number
, 0, NO_RELOC
);
1261 } /* if(single-byte-operand) */
1263 } /* for(operandP) */
1264 } /* vax_assemble() */
1266 /* md_estimate_size_before_relax(), called just before relax().
1267 Any symbol that is now undefined will not become defined.
1268 Return the correct fr_subtype in the frag and the growth beyond
1271 md_estimate_size_before_relax (fragP
, segment
)
1275 if (RELAX_LENGTH (fragP
->fr_subtype
) == STATE_UNDF
)
1277 if (S_GET_SEGMENT (fragP
->fr_symbol
) != segment
1279 || S_IS_WEAK (fragP
->fr_symbol
)
1280 || S_IS_EXTERNAL (fragP
->fr_symbol
)
1284 /* Non-relaxable cases. */
1285 int reloc_type
= NO_RELOC
;
1289 old_fr_fix
= fragP
->fr_fix
;
1290 p
= fragP
->fr_literal
+ old_fr_fix
;
1292 /* If this is to an undefined symbol, then if it's an indirect
1293 reference indicate that is can mutated into a GLOB_DAT or
1294 JUMP_SLOT by the loader. We restrict ourselves to no offset
1295 due to a limitation in the NetBSD linker. */
1297 if (GOT_symbol
== NULL
)
1298 GOT_symbol
= symbol_find (GLOBAL_OFFSET_TABLE_NAME
);
1299 if (PLT_symbol
== NULL
)
1300 PLT_symbol
= symbol_find (PROCEDURE_LINKAGE_TABLE_NAME
);
1301 if ((GOT_symbol
== NULL
|| fragP
->fr_symbol
!= GOT_symbol
)
1302 && (PLT_symbol
== NULL
|| fragP
->fr_symbol
!= PLT_symbol
)
1303 && fragP
->fr_symbol
!= NULL
1305 && (!S_IS_DEFINED (fragP
->fr_symbol
)
1306 || S_IS_WEAK (fragP
->fr_symbol
)
1307 || S_IS_EXTERNAL (fragP
->fr_symbol
)))
1312 as_fatal ("PIC reference to %s is indirect.\n",
1313 S_GET_NAME (fragP
->fr_symbol
));
1317 if (((unsigned char *) fragP
->fr_opcode
)[0] == VAX_CALLS
1318 || ((unsigned char *) fragP
->fr_opcode
)[0] == VAX_CALLG
1319 || ((unsigned char *) fragP
->fr_opcode
)[0] == VAX_JSB
1320 || ((unsigned char *) fragP
->fr_opcode
)[0] == VAX_JMP
1321 || S_IS_FUNCTION (fragP
->fr_symbol
))
1322 reloc_type
= BFD_RELOC_32_PLT_PCREL
;
1324 reloc_type
= BFD_RELOC_32_GOT_PCREL
;
1328 switch (RELAX_STATE (fragP
->fr_subtype
))
1330 case STATE_PC_RELATIVE
:
1331 p
[0] |= VAX_PC_RELATIVE_MODE
; /* Preserve @ bit. */
1332 fragP
->fr_fix
+= 1 + 4;
1333 fix_new (fragP
, old_fr_fix
+ 1, 4, fragP
->fr_symbol
,
1334 fragP
->fr_offset
, 1, reloc_type
);
1337 case STATE_CONDITIONAL_BRANCH
:
1338 *fragP
->fr_opcode
^= 1; /* Reverse sense of branch. */
1341 p
[2] = VAX_PC_RELATIVE_MODE
; /* ...(PC) */
1342 fragP
->fr_fix
+= 1 + 1 + 1 + 4;
1343 fix_new (fragP
, old_fr_fix
+ 3, 4, fragP
->fr_symbol
,
1344 fragP
->fr_offset
, 1, NO_RELOC
);
1347 case STATE_COMPLEX_BRANCH
:
1353 p
[5] = VAX_PC_RELATIVE_MODE
; /* ...(pc) */
1354 fragP
->fr_fix
+= 2 + 2 + 1 + 1 + 4;
1355 fix_new (fragP
, old_fr_fix
+ 6, 4, fragP
->fr_symbol
,
1356 fragP
->fr_offset
, 1, NO_RELOC
);
1359 case STATE_COMPLEX_HOP
:
1364 p
[4] = VAX_PC_RELATIVE_MODE
; /* ...(pc) */
1365 fragP
->fr_fix
+= 1 + 2 + 1 + 1 + 4;
1366 fix_new (fragP
, old_fr_fix
+ 5, 4, fragP
->fr_symbol
,
1367 fragP
->fr_offset
, 1, NO_RELOC
);
1370 case STATE_ALWAYS_BRANCH
:
1371 *fragP
->fr_opcode
+= VAX_WIDEN_LONG
;
1372 p
[0] = VAX_PC_RELATIVE_MODE
; /* ...(PC) */
1373 fragP
->fr_fix
+= 1 + 4;
1374 fix_new (fragP
, old_fr_fix
+ 1, 4, fragP
->fr_symbol
,
1375 fragP
->fr_offset
, 1, NO_RELOC
);
1383 /* Return the growth in the fixed part of the frag. */
1384 return fragP
->fr_fix
- old_fr_fix
;
1387 /* Relaxable cases. Set up the initial guess for the variable
1388 part of the frag. */
1389 switch (RELAX_STATE (fragP
->fr_subtype
))
1391 case STATE_PC_RELATIVE
:
1392 fragP
->fr_subtype
= ENCODE_RELAX (STATE_PC_RELATIVE
, STATE_BYTE
);
1394 case STATE_CONDITIONAL_BRANCH
:
1395 fragP
->fr_subtype
= ENCODE_RELAX (STATE_CONDITIONAL_BRANCH
, STATE_BYTE
);
1397 case STATE_COMPLEX_BRANCH
:
1398 fragP
->fr_subtype
= ENCODE_RELAX (STATE_COMPLEX_BRANCH
, STATE_WORD
);
1400 case STATE_COMPLEX_HOP
:
1401 fragP
->fr_subtype
= ENCODE_RELAX (STATE_COMPLEX_HOP
, STATE_BYTE
);
1403 case STATE_ALWAYS_BRANCH
:
1404 fragP
->fr_subtype
= ENCODE_RELAX (STATE_ALWAYS_BRANCH
, STATE_BYTE
);
1409 if (fragP
->fr_subtype
>= sizeof (md_relax_table
) / sizeof (md_relax_table
[0]))
1412 /* Return the size of the variable part of the frag. */
1413 return md_relax_table
[fragP
->fr_subtype
].rlx_length
;
1417 * md_convert_frag();
1419 * Called after relax() is finished.
1420 * In: Address of frag.
1421 * fr_type == rs_machine_dependent.
1422 * fr_subtype is what the address relaxed to.
1424 * Out: Any fixSs and constants are set up.
1425 * Caller will turn frag into a ".space 0".
1428 md_convert_frag (headers
, seg
, fragP
)
1429 bfd
*headers ATTRIBUTE_UNUSED
;
1430 segT seg ATTRIBUTE_UNUSED
;
1433 char *addressP
; /* -> _var to change. */
1434 char *opcodeP
; /* -> opcode char(s) to change. */
1435 short int extension
= 0; /* Size of relaxed address. */
1436 /* Added to fr_fix: incl. ALL var chars. */
1440 know (fragP
->fr_type
== rs_machine_dependent
);
1441 where
= fragP
->fr_fix
;
1442 addressP
= fragP
->fr_literal
+ where
;
1443 opcodeP
= fragP
->fr_opcode
;
1444 symbolP
= fragP
->fr_symbol
;
1447 switch (fragP
->fr_subtype
)
1450 case ENCODE_RELAX (STATE_PC_RELATIVE
, STATE_BYTE
):
1451 know (*addressP
== 0 || *addressP
== 0x10); /* '@' bit. */
1452 addressP
[0] |= 0xAF; /* Byte displacement. */
1453 fix_new (fragP
, fragP
->fr_fix
+ 1, 1, fragP
->fr_symbol
,
1454 fragP
->fr_offset
, 1, NO_RELOC
);
1458 case ENCODE_RELAX (STATE_PC_RELATIVE
, STATE_WORD
):
1459 know (*addressP
== 0 || *addressP
== 0x10); /* '@' bit. */
1460 addressP
[0] |= 0xCF; /* Word displacement. */
1461 fix_new (fragP
, fragP
->fr_fix
+ 1, 2, fragP
->fr_symbol
,
1462 fragP
->fr_offset
, 1, NO_RELOC
);
1466 case ENCODE_RELAX (STATE_PC_RELATIVE
, STATE_LONG
):
1467 know (*addressP
== 0 || *addressP
== 0x10); /* '@' bit. */
1468 addressP
[0] |= 0xEF; /* Long word displacement. */
1469 fix_new (fragP
, fragP
->fr_fix
+ 1, 4, fragP
->fr_symbol
,
1470 fragP
->fr_offset
, 1, NO_RELOC
);
1474 case ENCODE_RELAX (STATE_CONDITIONAL_BRANCH
, STATE_BYTE
):
1475 fix_new (fragP
, fragP
->fr_fix
, 1, fragP
->fr_symbol
,
1476 fragP
->fr_offset
, 1, NO_RELOC
);
1480 case ENCODE_RELAX (STATE_CONDITIONAL_BRANCH
, STATE_WORD
):
1481 opcodeP
[0] ^= 1; /* Reverse sense of test. */
1483 addressP
[1] = VAX_BRW
;
1484 fix_new (fragP
, fragP
->fr_fix
+ 2, 2, fragP
->fr_symbol
,
1485 fragP
->fr_offset
, 1, NO_RELOC
);
1489 case ENCODE_RELAX (STATE_CONDITIONAL_BRANCH
, STATE_LONG
):
1490 opcodeP
[0] ^= 1; /* Reverse sense of test. */
1492 addressP
[1] = VAX_JMP
;
1493 addressP
[2] = VAX_PC_RELATIVE_MODE
;
1494 fix_new (fragP
, fragP
->fr_fix
+ 3, 4, fragP
->fr_symbol
,
1495 fragP
->fr_offset
, 1, NO_RELOC
);
1499 case ENCODE_RELAX (STATE_ALWAYS_BRANCH
, STATE_BYTE
):
1500 fix_new (fragP
, fragP
->fr_fix
, 1, fragP
->fr_symbol
,
1501 fragP
->fr_offset
, 1, NO_RELOC
);
1505 case ENCODE_RELAX (STATE_ALWAYS_BRANCH
, STATE_WORD
):
1506 opcodeP
[0] += VAX_WIDEN_WORD
; /* brb -> brw, bsbb -> bsbw */
1507 fix_new (fragP
, fragP
->fr_fix
, 2, fragP
->fr_symbol
, fragP
->fr_offset
,
1512 case ENCODE_RELAX (STATE_ALWAYS_BRANCH
, STATE_LONG
):
1513 opcodeP
[0] += VAX_WIDEN_LONG
; /* brb -> jmp, bsbb -> jsb */
1514 addressP
[0] = VAX_PC_RELATIVE_MODE
;
1515 fix_new (fragP
, fragP
->fr_fix
+ 1, 4, fragP
->fr_symbol
,
1516 fragP
->fr_offset
, 1, NO_RELOC
);
1520 case ENCODE_RELAX (STATE_COMPLEX_BRANCH
, STATE_WORD
):
1521 fix_new (fragP
, fragP
->fr_fix
, 2, fragP
->fr_symbol
,
1522 fragP
->fr_offset
, 1, NO_RELOC
);
1526 case ENCODE_RELAX (STATE_COMPLEX_BRANCH
, STATE_LONG
):
1529 addressP
[2] = VAX_BRB
;
1531 addressP
[4] = VAX_JMP
;
1532 addressP
[5] = VAX_PC_RELATIVE_MODE
;
1533 fix_new (fragP
, fragP
->fr_fix
+ 6, 4, fragP
->fr_symbol
,
1534 fragP
->fr_offset
, 1, NO_RELOC
);
1538 case ENCODE_RELAX (STATE_COMPLEX_HOP
, STATE_BYTE
):
1539 fix_new (fragP
, fragP
->fr_fix
, 1, fragP
->fr_symbol
,
1540 fragP
->fr_offset
, 1, NO_RELOC
);
1544 case ENCODE_RELAX (STATE_COMPLEX_HOP
, STATE_WORD
):
1546 addressP
[1] = VAX_BRB
;
1548 addressP
[3] = VAX_BRW
;
1549 fix_new (fragP
, fragP
->fr_fix
+ 4, 2, fragP
->fr_symbol
,
1550 fragP
->fr_offset
, 1, NO_RELOC
);
1554 case ENCODE_RELAX (STATE_COMPLEX_HOP
, STATE_LONG
):
1556 addressP
[1] = VAX_BRB
;
1558 addressP
[3] = VAX_JMP
;
1559 addressP
[4] = VAX_PC_RELATIVE_MODE
;
1560 fix_new (fragP
, fragP
->fr_fix
+ 5, 4, fragP
->fr_symbol
,
1561 fragP
->fr_offset
, 1, NO_RELOC
);
1566 BAD_CASE (fragP
->fr_subtype
);
1569 fragP
->fr_fix
+= extension
;
1570 } /* md_convert_frag() */
1572 /* Translate internal format of relocation info into target format.
1574 On vax: first 4 bytes are normal unsigned long, next three bytes
1575 are symbolnum, least sig. byte first. Last byte is broken up with
1576 the upper nibble as nuthin, bit 3 as extern, bits 2 & 1 as length, and
1580 md_ri_to_chars (the_bytes
, ri
)
1582 struct reloc_info_generic ri
;
1585 md_number_to_chars (the_bytes
, ri
.r_address
, sizeof (ri
.r_address
));
1586 /* now the fun stuff */
1587 the_bytes
[6] = (ri
.r_symbolnum
>> 16) & 0x0ff;
1588 the_bytes
[5] = (ri
.r_symbolnum
>> 8) & 0x0ff;
1589 the_bytes
[4] = ri
.r_symbolnum
& 0x0ff;
1590 the_bytes
[7] = (((ri
.r_extern
<< 3) & 0x08) | ((ri
.r_length
<< 1) & 0x06) |
1591 ((ri
.r_pcrel
<< 0) & 0x01)) & 0x0F;
1594 #endif /* comment */
1597 * BUGS, GRIPES, APOLOGIA, etc.
1599 * The opcode table 'votstrs' needs to be sorted on opcode frequency.
1600 * That is, AFTER we hash it with hash_...(), we want most-used opcodes
1601 * to come out of the hash table faster.
1603 * I am sorry to inflict yet another VAX assembler on the world, but
1604 * RMS says we must do everything from scratch, to prevent pin-heads
1605 * restricting this software.
1609 * This is a vaguely modular set of routines in C to parse VAX
1610 * assembly code using DEC mnemonics. It is NOT un*x specific.
1612 * The idea here is that the assembler has taken care of all:
1619 * condensing any whitespace down to exactly one space
1620 * and all we have to do is parse 1 line into a vax instruction
1621 * partially formed. We will accept a line, and deliver:
1622 * an error message (hopefully empty)
1623 * a skeleton VAX instruction (tree structure)
1624 * textual pointers to all the operand expressions
1625 * a warning message that notes a silly operand (hopefully empty)
1629 * E D I T H I S T O R Y
1631 * 17may86 Dean Elsner. Bug if line ends immediately after opcode.
1632 * 30apr86 Dean Elsner. New vip_op() uses arg block so change call.
1633 * 6jan86 Dean Elsner. Crock vip_begin() to call vip_op_defaults().
1634 * 2jan86 Dean Elsner. Invent synthetic opcodes.
1635 * Widen vax_opcodeT to 32 bits. Use a bit for VIT_OPCODE_SYNTHETIC,
1636 * which means this is not a real opcode, it is like a macro; it will
1637 * be relax()ed into 1 or more instructions.
1638 * Use another bit for VIT_OPCODE_SPECIAL if the op-code is not optimised
1639 * like a regular branch instruction. Option added to vip_begin():
1640 * exclude synthetic opcodes. Invent synthetic_votstrs[].
1641 * 31dec85 Dean Elsner. Invent vit_opcode_nbytes.
1642 * Also make vit_opcode into a char[]. We now have n-byte vax opcodes,
1643 * so caller's don't have to know the difference between a 1-byte & a
1644 * 2-byte op-code. Still need vax_opcodeT concept, so we know how
1645 * big an object must be to hold an op.code.
1646 * 30dec85 Dean Elsner. Widen typedef vax_opcodeT in "vax-inst.h"
1647 * because vax opcodes may be 16 bits. Our crufty C compiler was
1648 * happily initialising 8-bit vot_codes with 16-bit numbers!
1649 * (Wouldn't the 'phone company like to compress data so easily!)
1650 * 29dec85 Dean Elsner. New static table vax_operand_width_size[].
1651 * Invented so we know hw many bytes a "I^#42" needs in its immediate
1652 * operand. Revised struct vop in "vax-inst.h": explicitly include
1653 * byte length of each operand, and it's letter-code datum type.
1654 * 17nov85 Dean Elsner. Name Change.
1655 * Due to ar(1) truncating names, we learned the hard way that
1656 * "vax-inst-parse.c" -> "vax-inst-parse." dropping the "o" off
1657 * the archived object name. SO... we shortened the name of this
1658 * source file, and changed the makefile.
1661 /* handle of the OPCODE hash table */
1662 static struct hash_control
*op_hash
;
1665 * In: 1 character, from "bdfghloqpw" being the data-type of an operand
1666 * of a vax instruction.
1668 * Out: the length of an operand of that type, in bytes.
1669 * Special branch operands types "-?!" have length 0.
1672 static const short int vax_operand_width_size
[256] =
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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1678 0, 0, 1, 0, 8, 0, 4, 8, 16, 0, 0, 0, 4, 0, 0,16, /* ..b.d.fgh...l..o */
1679 0, 8, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, /* .q.....w........ */
1680 0, 0, 1, 0, 8, 0, 4, 8, 16, 0, 0, 0, 4, 0, 0,16, /* ..b.d.fgh...l..o */
1681 0, 8, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, /* .q.....w........ */
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,
1689 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1693 * This perversion encodes all the vax opcodes as a bunch of strings.
1694 * RMS says we should build our hash-table at run-time. Hmm.
1695 * Please would someone arrange these in decreasing frequency of opcode?
1696 * Because of the way hash_...() works, the most frequently used opcode
1697 * should be textually first and so on.
1699 * Input for this table was 'vax.opcodes', awk(1)ed by 'vax.opcodes.c.awk' .
1700 * So change 'vax.opcodes', then re-generate this table.
1703 #include "opcode/vax.h"
1706 * This is a table of optional op-codes. All of them represent
1707 * 'synthetic' instructions that seem popular.
1709 * Here we make some pseudo op-codes. Every code has a bit set to say
1710 * it is synthetic. This lets you catch them if you want to
1711 * ban these opcodes. They are mnemonics for "elastic" instructions
1712 * that are supposed to assemble into the fewest bytes needed to do a
1713 * branch, or to do a conditional branch, or whatever.
1715 * The opcode is in the usual place [low-order n*8 bits]. This means
1716 * that if you mask off the bucky bits, the usual rules apply about
1717 * how long the opcode is.
1719 * All VAX branch displacements come at the end of the instruction.
1720 * For simple branches (1-byte opcode + 1-byte displacement) the last
1721 * operand is coded 'b?' where the "data type" '?' is a clue that we
1722 * may reverse the sense of the branch (complement lowest order bit)
1723 * and branch around a jump. This is by far the most common case.
1724 * That is why the VIT_OPCODE_SYNTHETIC bit is set: it says this is
1725 * a 0-byte op-code followed by 2 or more bytes of operand address.
1727 * If the op-code has VIT_OPCODE_SPECIAL set, then we have a more unusual
1730 * For JBSB & JBR the treatment is the similar, except (1) we have a 'bw'
1731 * option before (2) we can directly JSB/JMP because there is no condition.
1732 * These operands have 'b-' as their access/data type.
1734 * That leaves a bunch of random opcodes: JACBx, JxOBxxx. In these
1735 * cases, we do the same idea. JACBxxx are all marked with a 'b!'
1736 * JAOBxxx & JSOBxxx are marked with a 'b:'.
1739 #if (VIT_OPCODE_SYNTHETIC != 0x80000000)
1740 You have just broken the encoding below
, which assumes the sign bit
1741 means
'I am an imaginary instruction'.
1744 #if (VIT_OPCODE_SPECIAL != 0x40000000)
1745 You have just broken the encoding below
, which assumes the
0x40 M bit means
1746 'I am not to be "optimised" the way normal branches are'.
1749 static const struct vot
1750 synthetic_votstrs
[] =
1752 {"jbsb", {"b-", 0xC0000010}}, /* BSD 4.2 */
1753 /* jsb used already */
1754 {"jbr", {"b-", 0xC0000011}}, /* BSD 4.2 */
1755 {"jr", {"b-", 0xC0000011}}, /* consistent */
1756 {"jneq", {"b?", 0x80000012}},
1757 {"jnequ", {"b?", 0x80000012}},
1758 {"jeql", {"b?", 0x80000013}},
1759 {"jeqlu", {"b?", 0x80000013}},
1760 {"jgtr", {"b?", 0x80000014}},
1761 {"jleq", {"b?", 0x80000015}},
1762 /* un-used opcodes here */
1763 {"jgeq", {"b?", 0x80000018}},
1764 {"jlss", {"b?", 0x80000019}},
1765 {"jgtru", {"b?", 0x8000001a}},
1766 {"jlequ", {"b?", 0x8000001b}},
1767 {"jvc", {"b?", 0x8000001c}},
1768 {"jvs", {"b?", 0x8000001d}},
1769 {"jgequ", {"b?", 0x8000001e}},
1770 {"jcc", {"b?", 0x8000001e}},
1771 {"jlssu", {"b?", 0x8000001f}},
1772 {"jcs", {"b?", 0x8000001f}},
1774 {"jacbw", {"rwrwmwb!", 0xC000003d}},
1775 {"jacbf", {"rfrfmfb!", 0xC000004f}},
1776 {"jacbd", {"rdrdmdb!", 0xC000006f}},
1777 {"jacbb", {"rbrbmbb!", 0xC000009d}},
1778 {"jacbl", {"rlrlmlb!", 0xC00000f1}},
1779 {"jacbg", {"rgrgmgb!", 0xC0004ffd}},
1780 {"jacbh", {"rhrhmhb!", 0xC0006ffd}},
1782 {"jbs", {"rlvbb?", 0x800000e0}},
1783 {"jbc", {"rlvbb?", 0x800000e1}},
1784 {"jbss", {"rlvbb?", 0x800000e2}},
1785 {"jbcs", {"rlvbb?", 0x800000e3}},
1786 {"jbsc", {"rlvbb?", 0x800000e4}},
1787 {"jbcc", {"rlvbb?", 0x800000e5}},
1788 {"jlbs", {"rlb?", 0x800000e8}},
1789 {"jlbc", {"rlb?", 0x800000e9}},
1791 {"jaoblss", {"rlmlb:", 0xC00000f2}},
1792 {"jaobleq", {"rlmlb:", 0xC00000f3}},
1793 {"jsobgeq", {"mlb:", 0xC00000f4}},
1794 {"jsobgtr", {"mlb:", 0xC00000f5}},
1796 /* CASEx has no branch addresses in our conception of it. */
1797 /* You should use ".word ..." statements after the "case ...". */
1799 {"", {"", 0}} /* empty is end sentinel */
1801 }; /* synthetic_votstrs */
1804 * v i p _ b e g i n ( )
1806 * Call me once before you decode any lines.
1807 * I decode votstrs into a hash table at op_hash (which I create).
1808 * I return an error text or null.
1809 * If you want, I will include the 'synthetic' jXXX instructions in the
1810 * instruction table.
1811 * You must nominate metacharacters for eg DEC's "#", "@", "^".
1815 vip_begin (synthetic_too
, immediate
, indirect
, displen
)
1816 int synthetic_too
; /* 1 means include jXXX op-codes. */
1817 const char *immediate
, *indirect
, *displen
;
1819 const struct vot
*vP
; /* scan votstrs */
1820 const char *retval
= 0; /* error text */
1822 op_hash
= hash_new ();
1824 for (vP
= votstrs
; *vP
->vot_name
&& !retval
; vP
++)
1825 retval
= hash_insert (op_hash
, vP
->vot_name
, (PTR
) &vP
->vot_detail
);
1828 for (vP
= synthetic_votstrs
; *vP
->vot_name
&& !retval
; vP
++)
1829 retval
= hash_insert (op_hash
, vP
->vot_name
, (PTR
) &vP
->vot_detail
);
1832 vip_op_defaults (immediate
, indirect
, displen
);
1841 * This converts a string into a vax instruction.
1842 * The string must be a bare single instruction in dec-vax (with BSD4 frobs)
1844 * It provides some error messages: at most one fatal error message (which
1845 * stops the scan) and at most one warning message for each operand.
1846 * The vax instruction is returned in exploded form, since we have no
1847 * knowledge of how you parse (or evaluate) your expressions.
1848 * We do however strip off and decode addressing modes and operation
1851 * The exploded instruction is returned to a struct vit of your choice.
1852 * #include "vax-inst.h" to know what a struct vit is.
1854 * This function's value is a string. If it is not "" then an internal
1855 * logic error was found: read this code to assign meaning to the string.
1856 * No argument string should generate such an error string:
1857 * it means a bug in our code, not in the user's text.
1859 * You MUST have called vip_begin() once before using this function.
1863 vip (vitP
, instring
)
1864 struct vit
*vitP
; /* We build an exploded instruction here. */
1865 char *instring
; /* Text of a vax instruction: we modify. */
1867 /* How to bit-encode this opcode. */
1868 struct vot_wot
*vwP
;
1869 /* 1/skip whitespace.2/scan vot_how */
1872 /* counts number of operands seen */
1873 unsigned char count
;
1874 /* scan operands in struct vit */
1875 struct vop
*operandp
;
1876 /* error over all operands */
1877 const char *alloperr
;
1878 /* Remember char, (we clobber it with '\0' temporarily). */
1880 /* Op-code of this instruction. */
1883 if (*instring
== ' ')
1884 ++instring
; /* Skip leading whitespace. */
1885 for (p
= instring
; *p
&& *p
!= ' '; p
++);; /* MUST end in end-of-string or exactly 1 space. */
1886 /* Scanned up to end of operation-code. */
1887 /* Operation-code is ended with whitespace. */
1888 if (p
- instring
== 0)
1890 vitP
->vit_error
= _("No operator");
1892 memset (vitP
->vit_opcode
, '\0', sizeof (vitP
->vit_opcode
));
1899 * Here with instring pointing to what better be an op-name, and p
1900 * pointing to character just past that.
1901 * We trust instring points to an op-name, with no whitespace.
1903 vwP
= (struct vot_wot
*) hash_find (op_hash
, instring
);
1904 *p
= c
; /* Restore char after op-code. */
1907 vitP
->vit_error
= _("Unknown operator");
1909 memset (vitP
->vit_opcode
, '\0', sizeof (vitP
->vit_opcode
));
1914 * We found a match! So let's pick up as many operands as the
1915 * instruction wants, and even gripe if there are too many.
1916 * We expect comma to separate each operand.
1917 * We let instring track the text, while p tracks a part of the
1922 * The lines below know about 2-byte opcodes starting FD,FE or FF.
1923 * They also understand synthetic opcodes. Note:
1924 * we return 32 bits of opcode, including bucky bits, BUT
1925 * an opcode length is either 8 or 16 bits for vit_opcode_nbytes.
1927 oc
= vwP
->vot_code
; /* The op-code. */
1928 vitP
->vit_opcode_nbytes
= (oc
& 0xFF) >= 0xFD ? 2 : 1;
1929 md_number_to_chars (vitP
->vit_opcode
, oc
, 4);
1930 count
= 0; /* no operands seen yet */
1931 instring
= p
; /* point just past operation code */
1933 for (howp
= vwP
->vot_how
, operandp
= vitP
->vit_operand
;
1934 !(alloperr
&& *alloperr
) && *howp
;
1935 operandp
++, howp
+= 2)
1938 * Here to parse one operand. Leave instring pointing just
1939 * past any one ',' that marks the end of this operand.
1942 as_fatal (_("odd number of bytes in operand description"));
1945 for (q
= instring
; (c
= *q
) && c
!= ','; q
++)
1948 * Q points to ',' or '\0' that ends argument. C is that
1952 operandp
->vop_width
= howp
[1];
1953 operandp
->vop_nbytes
= vax_operand_width_size
[(unsigned) howp
[1]];
1954 operandp
->vop_access
= howp
[0];
1955 vip_op (instring
, operandp
);
1956 *q
= c
; /* Restore input text. */
1957 if (operandp
->vop_error
)
1958 alloperr
= _("Bad operand");
1959 instring
= q
+ (c
? 1 : 0); /* next operand (if any) */
1960 count
++; /* won another argument, may have an operr */
1963 alloperr
= _("Not enough operands");
1967 if (*instring
== ' ')
1968 instring
++; /* Skip whitespace. */
1970 alloperr
= _("Too many operands");
1972 vitP
->vit_error
= alloperr
;
1975 vitP
->vit_operands
= count
;
1981 * Test program for above.
1984 struct vit myvit
; /* build an exploded vax instruction here */
1985 char answer
[100]; /* human types a line of vax assembler here */
1986 char *mybug
; /* "" or an internal logic diagnostic */
1987 int mycount
; /* number of operands */
1988 struct vop
*myvop
; /* scan operands from myvit */
1989 int mysynth
; /* 1 means want synthetic opcodes. */
1990 char my_immediate
[200];
1991 char my_indirect
[200];
1992 char my_displen
[200];
1998 printf ("0 means no synthetic instructions. ");
1999 printf ("Value for vip_begin? ");
2001 sscanf (answer
, "%d", &mysynth
);
2002 printf ("Synthetic opcodes %s be included.\n", mysynth
? "will" : "will not");
2003 printf ("enter immediate symbols eg enter # ");
2004 gets (my_immediate
);
2005 printf ("enter indirect symbols eg enter @ ");
2007 printf ("enter displen symbols eg enter ^ ");
2009 if (p
= vip_begin (mysynth
, my_immediate
, my_indirect
, my_displen
))
2011 error ("vip_begin=%s", p
);
2013 printf ("An empty input line will quit you from the vax instruction parser\n");
2016 printf ("vax instruction: ");
2021 break; /* out of for each input text loop */
2023 vip (&myvit
, answer
);
2024 if (*myvit
.vit_error
)
2026 printf ("ERR:\"%s\"\n", myvit
.vit_error
);
2029 for (mycount
= myvit
.vit_opcode_nbytes
, p
= myvit
.vit_opcode
;
2034 printf ("%02x ", *p
& 0xFF);
2036 printf (" operand count=%d.\n", mycount
= myvit
.vit_operands
);
2037 for (myvop
= myvit
.vit_operand
; mycount
; mycount
--, myvop
++)
2039 printf ("mode=%xx reg=%xx ndx=%xx len='%c'=%c%c%d. expr=\"",
2040 myvop
->vop_mode
, myvop
->vop_reg
, myvop
->vop_ndx
,
2041 myvop
->vop_short
, myvop
->vop_access
, myvop
->vop_width
,
2043 for (p
= myvop
->vop_expr_begin
; p
<= myvop
->vop_expr_end
; p
++)
2048 if (myvop
->vop_error
)
2050 printf (" err:\"%s\"\n", myvop
->vop_error
);
2052 if (myvop
->vop_warn
)
2054 printf (" wrn:\"%s\"\n", myvop
->vop_warn
);
2059 exit (EXIT_SUCCESS
);
2062 #endif /* #ifdef test */
2064 /* end of vax_ins_parse.c */
2066 /* vax_reg_parse.c - convert a VAX register name to a number */
2068 /* Copyright (C) 1987 Free Software Foundation, Inc. A part of GNU. */
2071 * v a x _ r e g _ p a r s e ( )
2073 * Take 3 char.s, the last of which may be `\0` (non-existent)
2074 * and return the VAX register number that they represent.
2076 * Return -1 if they don't form a register name. Good names return
2077 * a number from 0:15 inclusive.
2079 * Case is not important in a name.
2081 * Register names understood are:
2102 #include "safe-ctype.h"
2108 int /* return -1 or 0:15 */
2109 vax_reg_parse (c1
, c2
, c3
, c4
) /* 3 chars of register name */
2110 char c1
, c2
, c3
, c4
; /* c3 == 0 if 2-character reg name */
2112 int retval
; /* return -1:15 */
2117 if (c1
!= '%') /* register prefixes are mandatory for ELF */
2124 if (c4
!= 0) /* register prefixes are not allowed under VMS */
2128 if (c1
== '%') /* register prefixes are optional under a.out */
2134 else if (c3
&& c4
) /* can't be 4 characters long. */
2140 if (ISDIGIT (c2
) && c1
== 'r')
2145 retval
= retval
* 10 + c3
- '0';
2146 retval
= (retval
> 15) ? -1 : retval
;
2147 /* clamp the register value to 1 hex digit */
2150 retval
= -1; /* c3 must be '\0' or a digit */
2152 else if (c3
) /* There are no three letter regs */
2171 else if (c1
== 'p' && c2
== 'c')
2181 * Parse a vax operand in DEC assembler notation.
2182 * For speed, expect a string of whitespace to be reduced to a single ' '.
2183 * This is the case for GNU AS, and is easy for other DEC-compatible
2186 * Knowledge about DEC VAX assembler operand notation lives here.
2187 * This doesn't even know what a register name is, except it believes
2188 * all register names are 2 or 3 characters, and lets vax_reg_parse() say
2189 * what number each name represents.
2190 * It does, however, know that PC, SP etc are special registers so it can
2191 * detect addressing modes that are silly for those registers.
2193 * Where possible, it delivers 1 fatal or 1 warning message if the operand
2194 * is suspect. Exactly what we test for is still evolving.
2202 * There were a number of 'mismatched argument type' bugs to vip_op.
2203 * The most general solution is to typedef each (of many) arguments.
2204 * We used instead a typedef'd argument block. This is less modular
2205 * than using separate return pointers for each result, but runs faster
2206 * on most engines, and seems to keep programmers happy. It will have
2207 * to be done properly if we ever want to use vip_op as a general-purpose
2208 * module (it was designed to be).
2212 * Doesn't support DEC "G^" format operands. These always take 5 bytes
2213 * to express, and code as modes 8F or 9F. Reason: "G^" deprives you of
2214 * optimising to (say) a "B^" if you are lucky in the way you link.
2215 * When someone builds a linker smart enough to convert "G^" to "B^", "W^"
2216 * whenever possible, then we should implement it.
2217 * If there is some other use for "G^", feel free to code it in!
2222 * If I nested if()s more, I could avoid testing (*err) which would save
2223 * time, space and page faults. I didn't nest all those if()s for clarity
2224 * and because I think the mode testing can be re-arranged 1st to test the
2225 * commoner constructs 1st. Does anybody have statistics on this?
2231 * In future, we should be able to 'compose' error messages in a scratch area
2232 * and give the user MUCH more informative error messages. Although this takes
2233 * a little more code at run-time, it will make this module much more self-
2234 * documenting. As an example of what sucks now: most error messages have
2235 * hardwired into them the DEC VAX metacharacters "#^@" which are nothing like
2236 * the Un*x characters "$`*", that most users will expect from this AS.
2240 * The input is a string, ending with '\0'.
2242 * We also require a 'hint' of what kind of operand is expected: so
2243 * we can remind caller not to write into literals for instance.
2245 * The output is a skeletal instruction.
2247 * The algorithm has two parts.
2248 * 1. extract the syntactic features (parse off all the @^#-()+[] mode crud);
2249 * 2. express the @^#-()+[] as some parameters suited to further analysis.
2251 * 2nd step is where we detect the googles of possible invalid combinations
2252 * a human (or compiler) might write. Note that if we do a half-way
2253 * decent assembler, we don't know how long to make (eg) displacement
2254 * fields when we first meet them (because they may not have defined values).
2255 * So we must wait until we know how many bits are needed for each address,
2256 * then we can know both length and opcodes of instructions.
2257 * For reason(s) above, we will pass to our caller a 'broken' instruction
2258 * of these major components, from which our caller can generate instructions:
2259 * - displacement length I^ S^ L^ B^ W^ unspecified
2261 * - register R0-R15 or absent
2262 * - index register R0-R15 or absent
2263 * - expression text what we don't parse
2264 * - error text(s) why we couldn't understand the operand
2268 * To decode output of this, test errtxt. If errtxt[0] == '\0', then
2269 * we had no errors that prevented parsing. Also, if we ever report
2270 * an internal bug, errtxt[0] is set non-zero. So one test tells you
2271 * if the other outputs are to be taken seriously.
2275 * Because this module is useful for both VMS and UN*X style assemblers
2276 * and because of the variety of UN*X assemblers we must recognise
2277 * the different conventions for assembler operand notation. For example
2278 * VMS says "#42" for immediate mode, while most UN*X say "$42".
2279 * We permit arbitrary sets of (single) characters to represent the
2280 * 3 concepts that DEC writes '#', '@', '^'.
2283 /* character tests */
2284 #define VIP_IMMEDIATE 01 /* Character is like DEC # */
2285 #define VIP_INDIRECT 02 /* Char is like DEC @ */
2286 #define VIP_DISPLEN 04 /* Char is like DEC ^ */
2288 #define IMMEDIATEP(c) (vip_metacharacters [(c)&0xff]&VIP_IMMEDIATE)
2289 #define INDIRECTP(c) (vip_metacharacters [(c)&0xff]&VIP_INDIRECT)
2290 #define DISPLENP(c) (vip_metacharacters [(c)&0xff]&VIP_DISPLEN)
2292 /* We assume 8 bits per byte. Use vip_op_defaults() to set these up BEFORE we
2296 #if defined(CONST_TABLE)
2298 #define I VIP_IMMEDIATE,
2299 #define S VIP_INDIRECT,
2300 #define D VIP_DISPLEN,
2302 vip_metacharacters
[256] =
2304 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
/* ^@ ^A ^B ^C ^D ^E ^F ^G ^H ^I ^J ^K ^L ^M ^N ^O*/
2305 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
/* ^P ^Q ^R ^S ^T ^U ^V ^W ^X ^Y ^Z ^[ ^\ ^] ^^ ^_ */
2306 _ _ _ _ I _ _ _ _ _ S _ _ _ _ _
/* sp ! " # $ % & ' ( ) * + , - . / */
2307 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
/*0 1 2 3 4 5 6 7 8 9 : ; < = > ?*/
2308 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
/*@ A B C D E F G H I J K L M N O*/
2309 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
/*P Q R S T U V W X Y Z [ \ ] ^ _*/
2310 D _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
/*` a b c d e f g h i j k l m n o*/
2311 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
/*p q r s t u v w x y z { | } ~ ^?*/
2313 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
2314 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
2315 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
2316 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
2317 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
2318 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
2319 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
2320 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
2327 static char vip_metacharacters
[256];
2330 vip_op_1 (bit
, syms
)
2336 while ((t
= *syms
++) != 0)
2337 vip_metacharacters
[t
] |= bit
;
2340 /* Can be called any time. More arguments may appear in future. */
2342 vip_op_defaults (immediate
, indirect
, displen
)
2343 const char *immediate
;
2344 const char *indirect
;
2345 const char *displen
;
2347 vip_op_1 (VIP_IMMEDIATE
, immediate
);
2348 vip_op_1 (VIP_INDIRECT
, indirect
);
2349 vip_op_1 (VIP_DISPLEN
, displen
);
2356 * Dec defines the semantics of address modes (and values)
2357 * by a two-letter code, explained here.
2359 * letter 1: access type
2361 * a address calculation - no data access, registers forbidden
2362 * b branch displacement
2363 * m read - let go of bus - write back "modify"
2365 * v bit field address: like 'a' but registers are OK
2367 * space no operator (eg ".long foo") [our convention]
2369 * letter 2: data type (i.e. width, alignment)
2372 * d double precision floating point (D format)
2373 * f single precision floating point (F format)
2374 * g G format floating
2375 * h H format floating
2380 * ? simple synthetic branch operand
2381 * - unconditional synthetic JSB/JSR operand
2382 * ! complex synthetic branch operand
2384 * The '-?!' letter 2's are not for external consumption. They are used
2385 * for various assemblers. Generally, all unknown widths are assumed 0.
2386 * We don't limit your choice of width character.
2388 * DEC operands are hard work to parse. For example, '@' as the first
2389 * character means indirect (deferred) mode but elsewhere it is a shift
2391 * The long-winded explanation of how this is supposed to work is
2392 * cancelled. Read a DEC vax manual.
2393 * We try hard not to parse anything that MIGHT be part of the expression
2394 * buried in that syntax. For example if we see @...(Rn) we don't check
2395 * for '-' before the '(' because mode @-(Rn) does not exist.
2397 * After parsing we have:
2399 * at 1 if leading '@' (or Un*x '*')
2400 * len takes one value from " bilsw". eg B^ -> 'b'.
2401 * hash 1 if leading '#' (or Un*x '$')
2402 * expr_begin, expr_end the expression we did not parse
2403 * even though we don't interpret it, we make use
2404 * of its presence or absence.
2405 * sign -1: -(Rn) 0: absent +1: (Rn)+
2406 * paren 1 if () are around register
2407 * reg major register number 0:15 -1 means absent
2408 * ndx index register number 0:15 -1 means absent
2410 * Again, I dare not explain it: just trace ALL the code!
2414 vip_op (optext
, vopP
)
2415 /* user's input string e.g.: "@B^foo@bar(AP)[FP]:" */
2417 /* Input fields: vop_access, vop_width.
2418 Output fields: _ndx, _reg, _mode, _short, _warn,
2419 _error _expr_begin, _expr_end, _nbytes.
2420 vop_nbytes : number of bytes in a datum. */
2423 /* track operand text forward */
2425 /* track operand text backward */
2427 /* 1 if leading '@' ('*') seen */
2429 /* one of " bilsw" */
2431 /* 1 if leading '#' ('$') seen */
2435 /* 1 if () surround register */
2437 /* register number, -1:absent */
2439 /* index register number -1:absent */
2441 /* report illegal operand, ""==OK */
2442 /* " " is a FAKE error: means we won */
2443 /* ANY err that begins with ' ' is a fake. */
2444 /* " " is converted to "" before return */
2446 /* warn about weird modes pf address */
2448 /* preserve q in case we backup */
2450 /* build up 4-bit operand mode here */
2451 /* note: index mode is in ndx, this is */
2452 /* the major mode of operand address */
2455 * Notice how we move wrong-arg-type bugs INSIDE this module: if we
2456 * get the types wrong below, we lose at compile time rather than at
2459 char access_mode
; /* vop_access. */
2460 char width
; /* vop_width. */
2462 access_mode
= vopP
->vop_access
;
2463 width
= vopP
->vop_width
;
2464 /* None of our code bugs (yet), no user text errors, no warnings
2470 if (*p
== ' ') /* Expect all whitespace reduced to ' '. */
2471 p
++; /* skip over whitespace */
2473 if ((at
= INDIRECTP (*p
)) != 0)
2474 { /* 1 if *p=='@'(or '*' for Un*x) */
2475 p
++; /* at is determined */
2476 if (*p
== ' ') /* Expect all whitespace reduced to ' '. */
2477 p
++; /* skip over whitespace */
2481 * This code is subtle. It tries to detect all legal (letter)'^'
2482 * but it doesn't waste time explicitly testing for premature '\0' because
2483 * this case is rejected as a mismatch against either (letter) or '^'.
2490 if (DISPLENP (p
[1]) && strchr ("bilws", len
= c
))
2491 p
+= 2; /* skip (letter) '^' */
2492 else /* no (letter) '^' seen */
2493 len
= ' '; /* len is determined */
2496 if (*p
== ' ') /* Expect all whitespace reduced to ' '. */
2497 p
++; /* skip over whitespace */
2499 if ((hash
= IMMEDIATEP (*p
)) != 0) /* 1 if *p=='#' ('$' for Un*x) */
2500 p
++; /* hash is determined */
2503 * p points to what may be the beginning of an expression.
2504 * We have peeled off the front all that is peelable.
2505 * We know at, len, hash.
2507 * Lets point q at the end of the text and parse that (backwards).
2510 for (q
= p
; *q
; q
++)
2512 q
--; /* now q points at last char of text */
2514 if (*q
== ' ' && q
>= p
) /* Expect all whitespace reduced to ' '. */
2516 /* reverse over whitespace, but don't */
2517 /* run back over *p */
2520 * As a matter of policy here, we look for [Rn], although both Rn and S^#
2521 * forbid [Rn]. This is because it is easy, and because only a sick
2522 * cyborg would have [...] trailing an expression in a VAX-like assembler.
2523 * A meticulous parser would first check for Rn followed by '(' or '['
2524 * and not parse a trailing ']' if it found another. We just ban expressions
2529 while (q
>= p
&& *q
!= '[')
2531 /* either q<p or we got matching '[' */
2533 err
= _("no '[' to match ']'");
2537 * Confusers like "[]" will eventually lose with a bad register
2538 * name error. So again we don't need to check for early '\0'.
2541 ndx
= vax_reg_parse (q
[1], q
[2], 0, 0);
2542 else if (q
[4] == ']')
2543 ndx
= vax_reg_parse (q
[1], q
[2], q
[3], 0);
2544 else if (q
[5] == ']')
2545 ndx
= vax_reg_parse (q
[1], q
[2], q
[3], q
[4]);
2549 * Since we saw a ']' we will demand a register name in the [].
2550 * If luser hasn't given us one: be rude.
2553 err
= _("bad register in []");
2555 err
= _("[PC] index banned");
2557 q
--; /* point q just before "[...]" */
2561 ndx
= -1; /* no ']', so no iNDeX register */
2564 * If err = "..." then we lost: run away.
2565 * Otherwise ndx == -1 if there was no "[...]".
2566 * Otherwise, ndx is index register number, and q points before "[...]".
2569 if (*q
== ' ' && q
>= p
) /* Expect all whitespace reduced to ' '. */
2571 /* reverse over whitespace, but don't */
2572 /* run back over *p */
2575 sign
= 0; /* no ()+ or -() seen yet */
2577 if (q
> p
+ 3 && *q
== '+' && q
[-1] == ')')
2579 sign
= 1; /* we saw a ")+" */
2580 q
--; /* q points to ')' */
2583 if (*q
== ')' && q
> p
+ 2)
2585 paren
= 1; /* assume we have "(...)" */
2586 while (q
>= p
&& *q
!= '(')
2588 /* either q<p or we got matching '(' */
2590 err
= _("no '(' to match ')'");
2594 * Confusers like "()" will eventually lose with a bad register
2595 * name error. So again we don't need to check for early '\0'.
2598 reg
= vax_reg_parse (q
[1], q
[2], 0, 0);
2599 else if (q
[4] == ')')
2600 reg
= vax_reg_parse (q
[1], q
[2], q
[3], 0);
2601 else if (q
[5] == ')')
2602 reg
= vax_reg_parse (q
[1], q
[2], q
[3], q
[4]);
2606 * Since we saw a ')' we will demand a register name in the ')'.
2607 * This is nasty: why can't our hypothetical assembler permit
2608 * parenthesised expressions? BECAUSE I AM LAZY! That is why.
2609 * Abuse luser if we didn't spy a register name.
2613 /* JF allow parenthesized expressions. I hope this works */
2617 /* err = "unknown register in ()"; */
2620 q
--; /* point just before '(' of "(...)" */
2622 * If err == "..." then we lost. Run away.
2623 * Otherwise if reg >= 0 then we saw (Rn).
2627 * If err == "..." then we lost.
2628 * Otherwise paren==1 and reg = register in "()".
2634 * If err == "..." then we lost.
2635 * Otherwise, q points just before "(Rn)", if any.
2636 * If there was a "(...)" then paren==1, and reg is the register.
2640 * We should only seek '-' of "-(...)" if:
2641 * we saw "(...)" paren == 1
2642 * we have no errors so far ! *err
2643 * we did not see '+' of "(...)+" sign < 1
2644 * We don't check len. We want a specific error message later if
2645 * user tries "x^...-(Rn)". This is a feature not a bug.
2649 if (paren
&& sign
< 1)/* !sign is adequate test */
2658 * We have back-tracked over most
2659 * of the crud at the end of an operand.
2660 * Unless err, we know: sign, paren. If paren, we know reg.
2661 * The last case is of an expression "Rn".
2662 * This is worth hunting for if !err, !paren.
2663 * We wouldn't be here if err.
2664 * We remember to save q, in case we didn't want "Rn" anyway.
2668 if (*q
== ' ' && q
>= p
) /* Expect all whitespace reduced to ' '. */
2670 /* reverse over whitespace, but don't */
2671 /* run back over *p */
2672 /* room for Rn or Rnn (include prefix) exactly? */
2673 if (q
> p
&& q
< p
+ 4)
2674 reg
= vax_reg_parse (p
[0], p
[1],
2675 q
< p
+ 2 ? 0 : p
[2],
2676 q
< p
+ 3 ? 0 : p
[3]);
2678 reg
= -1; /* always comes here if no register at all */
2680 * Here with a definitive reg value.
2691 * have reg. -1:absent; else 0:15
2695 * We have: err, at, len, hash, ndx, sign, paren, reg.
2696 * Also, any remaining expression is from *p through *q inclusive.
2697 * Should there be no expression, q==p-1. So expression length = q-p+1.
2698 * This completes the first part: parsing the operand text.
2702 * We now want to boil the data down, checking consistency on the way.
2703 * We want: len, mode, reg, ndx, err, p, q, wrn, bug.
2704 * We will deliver a 4-bit reg, and a 4-bit mode.
2708 * Case of branch operand. Different. No L^B^W^I^S^ allowed for instance.
2722 * p:q whatever was input
2724 * err " " or error message, and other outputs trashed
2726 /* branch operands have restricted forms */
2727 if ((!err
|| !*err
) && access_mode
== 'b')
2729 if (at
|| hash
|| sign
|| paren
|| ndx
>= 0 || reg
>= 0 || len
!= ' ')
2730 err
= _("invalid branch operand");
2735 /* Since nobody seems to use it: comment this 'feature'(?) out for now. */
2738 * Case of stand-alone operand. e.g. ".long foo"
2752 * p:q whatever was input
2754 * err " " or error message, and other outputs trashed
2756 if ((!err
|| !*err
) && access_mode
== ' ')
2759 err
= _("address prohibits @");
2761 err
= _("address prohibits #");
2765 err
= _("address prohibits -()");
2767 err
= _("address prohibits ()+");
2770 err
= _("address prohibits ()");
2772 err
= _("address prohibits []");
2774 err
= _("address prohibits register");
2775 else if (len
!= ' ')
2776 err
= _("address prohibits displacement length specifier");
2779 err
= " "; /* succeed */
2783 #endif /*#Ifdef NEVER*/
2789 * len 's' definition
2791 * p:q demand not empty
2792 * sign 0 by paren==0
2793 * paren 0 by "()" scan logic because "S^" seen
2794 * reg -1 or nn by mistake
2803 if ((!err
|| !*err
) && len
== 's')
2805 if (!hash
|| paren
|| at
|| ndx
>= 0)
2806 err
= _("invalid operand of S^#");
2812 * SHIT! we saw S^#Rnn ! put the Rnn back in
2813 * expression. KLUDGE! Use oldq so we don't
2814 * need to know exact length of reg name.
2820 * We have all the expression we will ever get.
2823 err
= _("S^# needs expression");
2824 else if (access_mode
== 'r')
2826 err
= " "; /* WIN! */
2830 err
= _("S^# may only read-access");
2835 * Case of -(Rn), which is weird case.
2841 * sign -1 by definition
2842 * paren 1 by definition
2843 * reg present by definition
2849 * exp "" enforce empty expression
2850 * ndx optional warn if same as reg
2852 if ((!err
|| !*err
) && sign
< 0)
2854 if (len
!= ' ' || hash
|| at
|| p
<= q
)
2855 err
= _("invalid operand of -()");
2858 err
= " "; /* win */
2861 wrn
= _("-(PC) unpredictable");
2862 else if (reg
== ndx
)
2863 wrn
= _("[]index same as -()register: unpredictable");
2868 * We convert "(Rn)" to "@Rn" for our convenience.
2869 * (I hope this is convenient: has someone got a better way to parse this?)
2870 * A side-effect of this is that "@Rn" is a valid operand.
2872 if (paren
&& !sign
&& !hash
&& !at
&& len
== ' ' && p
> q
)
2879 * Case of (Rn)+, which is slightly different.
2885 * sign +1 by definition
2886 * paren 1 by definition
2887 * reg present by definition
2893 * exp "" enforce empty expression
2894 * ndx optional warn if same as reg
2896 if ((!err
|| !*err
) && sign
> 0)
2898 if (len
!= ' ' || hash
|| p
<= q
)
2899 err
= _("invalid operand of ()+");
2902 err
= " "; /* win */
2903 mode
= 8 + (at
? 1 : 0);
2905 wrn
= _("(PC)+ unpredictable");
2906 else if (reg
== ndx
)
2907 wrn
= _("[]index same as ()+register: unpredictable");
2912 * Case of #, without S^.
2916 * hash 1 by definition
2929 if ((!err
|| !*err
) && hash
)
2931 if (len
!= 'i' && len
!= ' ')
2932 err
= _("# conflicts length");
2934 err
= _("# bars register");
2940 * SHIT! we saw #Rnn! Put the Rnn back into the expression.
2941 * By using oldq, we don't need to know how long Rnn was.
2945 reg
= -1; /* no register any more */
2947 err
= " "; /* win */
2949 /* JF a bugfix, I think! */
2950 if (at
&& access_mode
== 'a')
2951 vopP
->vop_nbytes
= 4;
2953 mode
= (at
? 9 : 8);
2955 if ((access_mode
== 'm' || access_mode
== 'w') && !at
)
2956 wrn
= _("writing or modifying # is unpredictable");
2960 * If !*err, then sign == 0
2965 * Case of Rn. We separate this one because it has a few special
2966 * errors the remaining modes lack.
2970 * hash 0 by program logic
2972 * sign 0 by program logic
2973 * paren 0 by definition
2974 * reg present by definition
2979 * len ' ' enforce no length
2980 * exp "" enforce empty expression
2981 * ndx optional warn if same as reg
2983 if ((!err
|| !*err
) && !paren
&& reg
>= 0)
2986 err
= _("length not needed");
2989 err
= " "; /* win */
2993 err
= _("can't []index a register, because it has no address");
2994 else if (access_mode
== 'a')
2995 err
= _("a register has no address");
2999 * Idea here is to detect from length of datum
3000 * and from register number if we will touch PC.
3002 * vop_nbytes is number of bytes in operand.
3003 * Compute highest byte affected, compare to PC0.
3005 if ((vopP
->vop_nbytes
+ reg
* 4) > 60)
3006 wrn
= _("PC part of operand unpredictable");
3007 err
= " "; /* win */
3012 * If !*err, sign == 0
3014 * paren == 1 OR reg==-1
3018 * Rest of cases fit into one bunch.
3021 * len ' ' or 'b' or 'w' or 'l'
3022 * hash 0 by program logic
3023 * p:q expected (empty is not an error)
3024 * sign 0 by program logic
3029 * out: mode 10 + @ + len
3031 * len ' ' or 'b' or 'w' or 'l'
3033 * ndx optional warn if same as reg
3037 err
= " "; /* win (always) */
3038 mode
= 10 + (at
? 1 : 0);
3045 case ' ': /* assumed B^ until our caller changes it */
3052 * here with completely specified mode
3060 err
= 0; /* " " is no longer an error */
3062 vopP
->vop_mode
= mode
;
3063 vopP
->vop_reg
= reg
;
3064 vopP
->vop_short
= len
;
3065 vopP
->vop_expr_begin
= p
;
3066 vopP
->vop_expr_end
= q
;
3067 vopP
->vop_ndx
= ndx
;
3068 vopP
->vop_error
= err
;
3069 vopP
->vop_warn
= wrn
;
3074 Summary of vip_op outputs.
3078 {@}Rn 5+@ n ' ' optional
3079 branch operand 0 -1 ' ' -1
3081 -(Rn) 7 n ' ' optional
3082 {@}(Rn)+ 8+@ n ' ' optional
3083 {@}#foo, no S^ 8+@ PC " i" optional
3084 {@}{q^}{(Rn)} 10+@+q option " bwl" optional
3088 #ifdef TEST /* #Define to use this testbed. */
3091 * Follows a test program for this function.
3092 * We declare arrays non-local in case some of our tiny-minded machines
3093 * default to small stacks. Also, helps with some debuggers.
3098 char answer
[100]; /* human types into here */
3111 int my_operand_length
;
3112 char my_immediate
[200];
3113 char my_indirect
[200];
3114 char my_displen
[200];
3118 printf ("enter immediate symbols eg enter # ");
3119 gets (my_immediate
);
3120 printf ("enter indirect symbols eg enter @ ");
3122 printf ("enter displen symbols eg enter ^ ");
3124 vip_op_defaults (my_immediate
, my_indirect
, my_displen
);
3127 printf ("access,width (eg 'ab' or 'wh') [empty line to quit] : ");
3131 exit (EXIT_SUCCESS
);
3132 myaccess
= answer
[0];
3133 mywidth
= answer
[1];
3137 my_operand_length
= 1;
3140 my_operand_length
= 8;
3143 my_operand_length
= 4;
3146 my_operand_length
= 16;
3149 my_operand_length
= 32;
3152 my_operand_length
= 4;
3155 my_operand_length
= 16;
3158 my_operand_length
= 8;
3161 my_operand_length
= 2;
3166 my_operand_length
= 0;
3170 my_operand_length
= 2;
3171 printf ("I dn't understand access width %c\n", mywidth
);
3174 printf ("VAX assembler instruction operand: ");
3177 mybug
= vip_op (answer
, myaccess
, mywidth
, my_operand_length
,
3178 &mymode
, &myreg
, &mylen
, &myleft
, &myright
, &myndx
,
3182 printf ("error: \"%s\"\n", myerr
);
3184 printf (" bug: \"%s\"\n", mybug
);
3189 printf ("warning: \"%s\"\n", mywrn
);
3190 mumble ("mode", mymode
);
3191 mumble ("register", myreg
);
3192 mumble ("index", myndx
);
3193 printf ("width:'%c' ", mylen
);
3194 printf ("expression: \"");
3195 while (myleft
<= myright
)
3196 putchar (*myleft
++);
3202 mumble (text
, value
)
3206 printf ("%s:", text
);
3208 printf ("%xx", value
);
3214 #endif /* ifdef TEST */
3218 int md_short_jump_size
= 3;
3219 int md_long_jump_size
= 6;
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_ELF)
3260 const char *md_shortopts
= "d:STt:VkKQ:";
3262 const char *md_shortopts
= "d:STt:V";
3264 struct option md_longopts
[] = {
3266 #define OPTION_PIC (OPTION_MD_BASE)
3267 {"pic", no_argument
, NULL
, OPTION_PIC
},
3269 {NULL
, no_argument
, NULL
, 0}
3271 size_t md_longopts_size
= sizeof (md_longopts
);
3274 md_parse_option (c
, arg
)
3281 as_warn (_("SYMBOL TABLE not implemented"));
3285 as_warn (_("TOKEN TRACE not implemented"));
3289 as_warn (_("Displacement length %s ignored!"), arg
);
3293 as_warn (_("I don't need or use temp. file \"%s\"."), arg
);
3297 as_warn (_("I don't use an interpass file! -V ignored"));
3301 case '+': /* For g++. Hash any name > 31 chars long. */
3302 flag_hash_long_names
= 1;
3305 case '1': /* For backward compatibility */
3309 case 'H': /* Show new symbol after hash truncation */
3310 flag_show_after_trunc
= 1;
3313 case 'h': /* No hashing of mixed-case names */
3315 extern char vms_name_mapping
;
3316 vms_name_mapping
= atoi (arg
);
3317 flag_no_hash_mixed_case
= 1;
3323 extern char *compiler_version_string
;
3324 if (!arg
|| !*arg
|| access (arg
, 0) == 0)
3325 return 0; /* have caller show the assembler version */
3326 compiler_version_string
= arg
;
3335 break; /* -pic, Position Independent Code */
3337 /* -Qy, -Qn: SVR4 arguments controlling whether a .comment
3338 section should be emitted or not. FIXME: Not implemented. */
3351 md_show_usage (stream
)
3354 fprintf (stream
, _("\
3356 -d LENGTH ignored\n\
3363 fprintf (stream
, _("\
3365 -+ hash encode names longer than 31 characters\n\
3366 -1 `const' handling compatible with gcc 1.x\n\
3367 -H show new symbol after hash truncation\n\
3368 -h NUM don't hash mixed-case names, and adjust case:\n\
3369 0 = upper, 2 = lower, 3 = preserve case\n\
3370 -v\"VERSION\" code being assembled was produced by compiler \"VERSION\"\n"));
3374 /* We have no need to default values of symbols. */
3377 md_undefined_symbol (name
)
3378 char *name ATTRIBUTE_UNUSED
;
3383 /* Round up a section size to the appropriate boundary. */
3385 md_section_align (segment
, size
)
3386 segT segment ATTRIBUTE_UNUSED
;
3389 return size
; /* Byte alignment is fine */
3392 /* Exactly what point is a PC-relative offset relative TO?
3393 On the vax, they're relative to the address of the offset, plus
3396 md_pcrel_from (fixP
)
3399 return fixP
->fx_size
+ fixP
->fx_where
+ fixP
->fx_frag
->fr_address
;
3403 tc_gen_reloc (section
, fixp
)
3404 asection
*section ATTRIBUTE_UNUSED
;
3408 bfd_reloc_code_real_type code
;
3413 if (fixp
->fx_r_type
!= BFD_RELOC_NONE
)
3415 code
= fixp
->fx_r_type
;
3421 case BFD_RELOC_8_PCREL
:
3422 case BFD_RELOC_16_PCREL
:
3423 case BFD_RELOC_32_PCREL
:
3425 case BFD_RELOC_8_GOT_PCREL
:
3426 case BFD_RELOC_16_GOT_PCREL
:
3427 case BFD_RELOC_32_GOT_PCREL
:
3428 case BFD_RELOC_8_PLT_PCREL
:
3429 case BFD_RELOC_16_PLT_PCREL
:
3430 case BFD_RELOC_32_PLT_PCREL
:
3434 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
3435 _("Cannot make %s relocation PC relative"),
3436 bfd_get_reloc_code_name (code
));
3442 #define F(SZ,PCREL) (((SZ) << 1) + (PCREL))
3443 switch (F (fixp
->fx_size
, fixp
->fx_pcrel
))
3445 #define MAP(SZ,PCREL,TYPE) case F(SZ,PCREL): code = (TYPE); break
3446 MAP (1, 0, BFD_RELOC_8
);
3447 MAP (2, 0, BFD_RELOC_16
);
3448 MAP (4, 0, BFD_RELOC_32
);
3449 MAP (1, 1, BFD_RELOC_8_PCREL
);
3450 MAP (2, 1, BFD_RELOC_16_PCREL
);
3451 MAP (4, 1, BFD_RELOC_32_PCREL
);
3459 reloc
= (arelent
*) xmalloc (sizeof (arelent
));
3460 reloc
->sym_ptr_ptr
= (asymbol
**) xmalloc (sizeof (asymbol
*));
3461 *reloc
->sym_ptr_ptr
= symbol_get_bfdsym (fixp
->fx_addsy
);
3462 reloc
->address
= fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
3465 reloc
->addend
= fixp
->fx_addnumber
;
3469 reloc
->addend
= fixp
->fx_offset
;
3472 reloc
->howto
= bfd_reloc_type_lookup (stdoutput
, code
);
3473 assert (reloc
->howto
!= 0);
3478 /* end of tc-vax.c */