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, 59 Temple Place - Suite 330, Boston, MA
26 #include "obstack.h" /* For FRAG_APPEND_1_CHAR macro in "frags.h" */
33 #if defined (OBJ_AOUT) && !defined (BFD_ASSEMBLER) && defined (TE_NetBSD)
34 #include <netinet/in.h>
37 /* These chars start a comment anywhere in a source file (except inside
39 const char comment_chars
[] = "#";
41 /* These chars only start a comment at the beginning of a line. */
42 /* Note that for the VAX the are the same as comment_chars above. */
43 const char line_comment_chars
[] = "#";
45 const char line_separator_chars
[] = ";";
47 /* Chars that can be used to separate mant from exp in floating point nums */
48 const char EXP_CHARS
[] = "eE";
50 /* Chars that mean this number is a floating point constant */
52 /* or 0H1.234E-12 (see exp chars above) */
53 const char FLT_CHARS
[] = "dDfFgGhH";
55 /* Also be aware that MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT may have to be
56 changed in read.c . Ideally it shouldn't have to know about it at all,
57 but nothing is ideal around here. */
59 /* Hold details of an operand expression */
60 static expressionS exp_of_operand
[VIT_MAX_OPERANDS
];
61 static segT seg_of_operand
[VIT_MAX_OPERANDS
];
63 /* A vax instruction after decoding. */
66 /* Hold details of big operands. */
67 LITTLENUM_TYPE big_operand_bits
[VIT_MAX_OPERANDS
][SIZE_OF_LARGE_NUMBER
];
68 FLONUM_TYPE float_operand
[VIT_MAX_OPERANDS
];
69 /* Above is made to point into big_operand_bits by md_begin(). */
72 #define GLOBAL_OFFSET_TABLE_NAME "_GLOBAL_OFFSET_TABLE_"
73 #define PROCEDURE_LINKAGE_TABLE_NAME "_PROCEDURE_LINKAGE_TABLE_"
74 symbolS
*GOT_symbol
; /* Pre-defined "_GLOBAL_OFFSET_TABLE_" */
75 symbolS
*PLT_symbol
; /* Pre-defined "_PROCEDURE_LINKAGE_TABLE_" */
78 int flag_hash_long_names
; /* -+ */
79 int flag_one
; /* -1 */
80 int flag_show_after_trunc
; /* -H */
81 int flag_no_hash_mixed_case
; /* -h NUM */
83 int flag_want_pic
; /* -k */
87 * For VAX, relative addresses of "just the right length" are easy.
88 * The branch displacement is always the last operand, even in
89 * synthetic instructions.
90 * For VAX, we encode the relax_substateTs (in e.g. fr_substate) as:
92 * 4 3 2 1 0 bit number
93 * ---/ /--+-------+-------+-------+-------+-------+
94 * | what state ? | how long ? |
95 * ---/ /--+-------+-------+-------+-------+-------+
97 * The "how long" bits are 00=byte, 01=word, 10=long.
98 * This is a Un*x convention.
99 * Not all lengths are legit for a given value of (what state).
100 * The "how long" refers merely to the displacement length.
101 * The address usually has some constant bytes in it as well.
104 groups for VAX address relaxing.
106 1. "foo" pc-relative.
107 length of byte, word, long
109 2a. J<cond> where <cond> is a simple flag test.
110 length of byte, word, long.
111 VAX opcodes are: (Hex)
124 Always, you complement 0th bit to reverse condition.
125 Always, 1-byte opcode, then 1-byte displacement.
127 2b. J<cond> where cond tests a memory bit.
128 length of byte, word, long.
129 Vax opcodes are: (Hex)
136 Always, you complement 0th bit to reverse condition.
137 Always, 1-byte opcde, longword-address, byte-address, 1-byte-displacement
139 2c. J<cond> where cond tests low-order memory bit
140 length of byte,word,long.
141 Vax opcodes are: (Hex)
144 Always, you complement 0th bit to reverse condition.
145 Always, 1-byte opcode, longword-address, 1-byte displacement.
148 length of byte,word,long.
149 Vax opcodes are: (Hex)
152 These are like (2) but there is no condition to reverse.
153 Always, 1 byte opcode, then displacement/absolute.
156 length of word, long.
157 Vax opcodes are: (Hex)
165 Always, we cannot reverse the sense of the branch; we have a word
167 The double-byte op-codes don't hurt: we never want to modify the
168 opcode, so we don't care how many bytes are between the opcode and
172 length of long, long, byte.
173 Vax opcodes are: (Hex)
178 Always, we cannot reverse the sense of the branch; we have a byte
181 The only time we need to modify the opcode is for class 2 instructions.
182 After relax() we may complement the lowest order bit of such instruction
183 to reverse sense of branch.
185 For class 2 instructions, we store context of "where is the opcode literal".
186 We can change an opcode's lowest order bit without breaking anything else.
188 We sometimes store context in the operand literal. This way we can figure out
189 after relax() what the original addressing mode was.
192 /* These displacements are relative to the start address of the
193 displacement. The first letter is Byte, Word. 2nd letter is
194 Forward, Backward. */
197 #define WF (2+ 32767)
198 #define WB (2+-32768)
199 /* Dont need LF, LB because they always reach. [They are coded as 0.] */
201 #define C(a,b) ENCODE_RELAX(a,b)
202 /* This macro has no side-effects. */
203 #define ENCODE_RELAX(what,length) (((what) << 2) + (length))
204 #define RELAX_STATE(s) ((s) >> 2)
205 #define RELAX_LENGTH(s) ((s) & 3)
207 const relax_typeS md_relax_table
[] =
209 {1, 1, 0, 0}, /* error sentinel 0,0 */
210 {1, 1, 0, 0}, /* unused 0,1 */
211 {1, 1, 0, 0}, /* unused 0,2 */
212 {1, 1, 0, 0}, /* unused 0,3 */
214 {BF
+ 1, BB
+ 1, 2, C (1, 1)},/* B^"foo" 1,0 */
215 {WF
+ 1, WB
+ 1, 3, C (1, 2)},/* W^"foo" 1,1 */
216 {0, 0, 5, 0}, /* L^"foo" 1,2 */
217 {1, 1, 0, 0}, /* unused 1,3 */
219 {BF
, BB
, 1, C (2, 1)}, /* b<cond> B^"foo" 2,0 */
220 {WF
+ 2, WB
+ 2, 4, C (2, 2)},/* br.+? brw X 2,1 */
221 {0, 0, 7, 0}, /* br.+? jmp X 2,2 */
222 {1, 1, 0, 0}, /* unused 2,3 */
224 {BF
, BB
, 1, C (3, 1)}, /* brb B^foo 3,0 */
225 {WF
, WB
, 2, C (3, 2)}, /* brw W^foo 3,1 */
226 {0, 0, 5, 0}, /* Jmp L^foo 3,2 */
227 {1, 1, 0, 0}, /* unused 3,3 */
229 {1, 1, 0, 0}, /* unused 4,0 */
230 {WF
, WB
, 2, C (4, 2)}, /* acb_ ^Wfoo 4,1 */
231 {0, 0, 10, 0}, /* acb_,br,jmp L^foo4,2 */
232 {1, 1, 0, 0}, /* unused 4,3 */
234 {BF
, BB
, 1, C (5, 1)}, /* Xob___,,foo 5,0 */
235 {WF
+ 4, WB
+ 4, 6, C (5, 2)},/* Xob.+2,brb.+3,brw5,1 */
236 {0, 0, 9, 0}, /* Xob.+2,brb.+6,jmp5,2 */
237 {1, 1, 0, 0}, /* unused 5,3 */
246 void float_cons
PARAMS ((int));
248 const pseudo_typeS md_pseudo_table
[] =
250 {"dfloat", float_cons
, 'd'},
251 {"ffloat", float_cons
, 'f'},
252 {"gfloat", float_cons
, 'g'},
253 {"hfloat", float_cons
, 'h'},
254 {"d_floating", float_cons
, 'd'},
255 {"f_floating", float_cons
, 'f'},
256 {"g_floating", float_cons
, 'g'},
257 {"h_floating", float_cons
, 'h'},
261 #define STATE_PC_RELATIVE (1)
262 #define STATE_CONDITIONAL_BRANCH (2)
263 #define STATE_ALWAYS_BRANCH (3) /* includes BSB... */
264 #define STATE_COMPLEX_BRANCH (4)
265 #define STATE_COMPLEX_HOP (5)
267 #define STATE_BYTE (0)
268 #define STATE_WORD (1)
269 #define STATE_LONG (2)
270 #define STATE_UNDF (3) /* Symbol undefined in pass1 */
272 #define min(a, b) ((a) < (b) ? (a) : (b))
274 int flonum_gen2vax
PARAMS ((char format_letter
, FLONUM_TYPE
* f
,
275 LITTLENUM_TYPE
* words
));
276 static const char *vip_begin
PARAMS ((int, const char *, const char *,
278 static void vip_op_1
PARAMS ((int, const char *));
279 static void vip_op_defaults
PARAMS ((const char *, const char *, const char *));
280 static void vip_op
PARAMS ((char *, struct vop
*));
281 static void vip
PARAMS ((struct vit
*, char *));
283 static int vax_reg_parse
PARAMS ((char, char, char, char));
292 if ((errtxt
= vip_begin (1, "$", "*", "`")) != 0)
294 as_fatal (_("VIP_BEGIN error:%s"), errtxt
);
297 for (i
= 0, fP
= float_operand
;
298 fP
< float_operand
+ VIT_MAX_OPERANDS
;
301 fP
->low
= &big_operand_bits
[i
][0];
302 fP
->high
= &big_operand_bits
[i
][SIZE_OF_LARGE_NUMBER
- 1];
307 md_number_to_chars (con
, value
, nbytes
)
312 number_to_chars_littleendian (con
, value
, nbytes
);
315 /* Fix up some data or instructions after we find out the value of a symbol
316 that they reference. */
318 void /* Knows about order of bytes in address. */
319 md_apply_fix3 (fixP
, valueP
, seg
)
322 segT seg ATTRIBUTE_UNUSED
;
324 valueT value
= * valueP
;
326 if (((fixP
->fx_addsy
== NULL
&& fixP
->fx_subsy
== NULL
)
327 && fixP
->fx_r_type
!= BFD_RELOC_32_PLT_PCREL
328 && fixP
->fx_r_type
!= BFD_RELOC_32_GOT_PCREL
)
329 || fixP
->fx_r_type
== NO_RELOC
)
331 number_to_chars_littleendian (fixP
->fx_where
+ fixP
->fx_frag
->fr_literal
,
332 value
, fixP
->fx_size
);
334 if (fixP
->fx_addsy
== NULL
&& fixP
->fx_pcrel
== 0)
339 md_chars_to_number (con
, nbytes
)
340 unsigned char con
[]; /* Low order byte 1st. */
341 int nbytes
; /* Number of bytes in the input. */
344 for (retval
= 0, con
+= nbytes
- 1; nbytes
--; con
--)
346 retval
<<= BITS_PER_CHAR
;
352 /* vax:md_assemble() emit frags for 1 instruction */
355 md_assemble (instruction_string
)
356 char *instruction_string
; /* A string: assemble 1 instruction. */
358 /* Non-zero if operand expression's segment is not known yet. */
360 /* Non-zero if operand expression's segment is absolute. */
365 /* An operand. Scans all operands. */
366 struct vop
*operandP
;
367 char *save_input_line_pointer
;
368 /* What used to live after an expression. */
370 /* 1: instruction_string bad for all passes. */
372 /* Points to slot just after last operand. */
373 struct vop
*end_operandP
;
374 /* Points to expression values for this operand. */
378 /* These refer to an instruction operand expression. */
379 /* Target segment of the address. */
381 valueT this_add_number
;
382 /* Positive (minuend) symbol. */
383 symbolS
*this_add_symbol
;
385 long opcode_as_number
;
386 /* Least significant byte 1st. */
387 char *opcode_as_chars
;
388 /* As an array of characters. */
389 /* Least significant byte 1st */
390 char *opcode_low_byteP
;
391 /* length (bytes) meant by vop_short. */
393 /* 0, or 1 if '@' is in addressing mode. */
395 /* From vop_nbytes: vax_operand_width (in bytes) */
398 LITTLENUM_TYPE literal_float
[8];
399 /* Big enough for any floating point literal. */
401 vip (&v
, instruction_string
);
404 * Now we try to find as many as_warn()s as we can. If we do any as_warn()s
405 * then goofed=1. Notice that we don't make any frags yet.
406 * Should goofed be 1, then this instruction will wedge in any pass,
407 * and we can safely flush it, without causing interpass symbol phase
408 * errors. That is, without changing label values in different passes.
410 if ((goofed
= (*v
.vit_error
)) != 0)
412 as_fatal (_("Ignoring statement due to \"%s\""), v
.vit_error
);
415 * We need to use expression() and friends, which require us to diddle
416 * input_line_pointer. So we save it and restore it later.
418 save_input_line_pointer
= input_line_pointer
;
419 for (operandP
= v
.vit_operand
,
420 expP
= exp_of_operand
,
421 segP
= seg_of_operand
,
422 floatP
= float_operand
,
423 end_operandP
= v
.vit_operand
+ v
.vit_operands
;
425 operandP
< end_operandP
;
427 operandP
++, expP
++, segP
++, floatP
++)
428 { /* for each operand */
429 if (operandP
->vop_error
)
431 as_fatal (_("Aborting because statement has \"%s\""), operandP
->vop_error
);
436 /* Statement has no syntax goofs: let's sniff the expression. */
437 int can_be_short
= 0; /* 1 if a bignum can be reduced to a short literal. */
439 input_line_pointer
= operandP
->vop_expr_begin
;
440 c_save
= operandP
->vop_expr_end
[1];
441 operandP
->vop_expr_end
[1] = '\0';
442 /* If to_seg == SEG_PASS1, expression() will have set need_pass_2 = 1. */
443 *segP
= expression (expP
);
447 /* for BSD4.2 compatibility, missing expression is absolute 0 */
448 expP
->X_op
= O_constant
;
449 expP
->X_add_number
= 0;
450 /* For SEG_ABSOLUTE, we shouldn't need to set X_op_symbol,
451 X_add_symbol to any particular value. But, we will program
452 defensively. Since this situation occurs rarely so it costs
453 us little to do, and stops Dean worrying about the origin of
454 random bits in expressionS's. */
455 expP
->X_add_symbol
= NULL
;
456 expP
->X_op_symbol
= NULL
;
465 * Major bug. We can't handle the case of a
466 * SEG_OP expression in a VIT_OPCODE_SYNTHETIC
467 * variable-length instruction.
468 * We don't have a frag type that is smart enough to
469 * relax a SEG_OP, and so we just force all
470 * SEG_OPs to behave like SEG_PASS1s.
471 * Clearly, if there is a demand we can invent a new or
472 * modified frag type and then coding up a frag for this
473 * case will be easy. SEG_OP was invented for the
474 * .words after a CASE opcode, and was never intended for
475 * instruction operands.
478 as_fatal (_("Can't relocate expression"));
482 /* Preserve the bits. */
483 if (expP
->X_add_number
> 0)
485 bignum_copy (generic_bignum
, expP
->X_add_number
,
486 floatP
->low
, SIZE_OF_LARGE_NUMBER
);
490 know (expP
->X_add_number
< 0);
491 flonum_copy (&generic_floating_point_number
,
493 if (strchr ("s i", operandP
->vop_short
))
495 /* Could possibly become S^# */
496 flonum_gen2vax (-expP
->X_add_number
, floatP
, literal_float
);
497 switch (-expP
->X_add_number
)
501 (literal_float
[0] & 0xFC0F) == 0x4000
502 && literal_float
[1] == 0;
507 (literal_float
[0] & 0xFC0F) == 0x4000
508 && literal_float
[1] == 0
509 && literal_float
[2] == 0
510 && literal_float
[3] == 0;
515 (literal_float
[0] & 0xFF81) == 0x4000
516 && literal_float
[1] == 0
517 && literal_float
[2] == 0
518 && literal_float
[3] == 0;
522 can_be_short
= ((literal_float
[0] & 0xFFF8) == 0x4000
523 && (literal_float
[1] & 0xE000) == 0
524 && literal_float
[2] == 0
525 && literal_float
[3] == 0
526 && literal_float
[4] == 0
527 && literal_float
[5] == 0
528 && literal_float
[6] == 0
529 && literal_float
[7] == 0);
533 BAD_CASE (-expP
->X_add_number
);
535 } /* switch (float type) */
536 } /* if (could want to become S^#...) */
537 } /* bignum or flonum ? */
539 if (operandP
->vop_short
== 's'
540 || operandP
->vop_short
== 'i'
541 || (operandP
->vop_short
== ' '
542 && operandP
->vop_reg
== 0xF
543 && (operandP
->vop_mode
& 0xE) == 0x8))
546 if (operandP
->vop_short
== ' ')
548 /* We must chose S^ or I^. */
549 if (expP
->X_add_number
> 0)
551 /* Bignum: Short literal impossible. */
552 operandP
->vop_short
= 'i';
553 operandP
->vop_mode
= 8;
554 operandP
->vop_reg
= 0xF; /* VAX PC. */
558 /* Flonum: Try to do it. */
561 operandP
->vop_short
= 's';
562 operandP
->vop_mode
= 0;
563 operandP
->vop_ndx
= -1;
564 operandP
->vop_reg
= -1;
565 expP
->X_op
= O_constant
;
569 operandP
->vop_short
= 'i';
570 operandP
->vop_mode
= 8;
571 operandP
->vop_reg
= 0xF; /* VAX PC */
573 } /* bignum or flonum ? */
574 } /* if #, but no S^ or I^ seen. */
575 /* No more ' ' case: either 's' or 'i'. */
576 if (operandP
->vop_short
== 's')
578 /* Wants to be a short literal. */
579 if (expP
->X_add_number
> 0)
581 as_warn (_("Bignum not permitted in short literal. Immediate mode assumed."));
582 operandP
->vop_short
= 'i';
583 operandP
->vop_mode
= 8;
584 operandP
->vop_reg
= 0xF; /* VAX PC. */
590 as_warn (_("Can't do flonum short literal: immediate mode used."));
591 operandP
->vop_short
= 'i';
592 operandP
->vop_mode
= 8;
593 operandP
->vop_reg
= 0xF; /* VAX PC. */
596 { /* Encode short literal now. */
599 switch (-expP
->X_add_number
)
603 temp
= literal_float
[0] >> 4;
607 temp
= literal_float
[0] >> 1;
611 temp
= ((literal_float
[0] << 3) & 070)
612 | ((literal_float
[1] >> 13) & 07);
616 BAD_CASE (-expP
->X_add_number
);
620 floatP
->low
[0] = temp
& 077;
622 } /* if can be short literal float */
623 } /* flonum or bignum ? */
626 { /* I^# seen: set it up if float. */
627 if (expP
->X_add_number
< 0)
629 memcpy (floatP
->low
, literal_float
, sizeof (literal_float
));
635 as_warn (_("A bignum/flonum may not be a displacement: 0x%lx used"),
636 (expP
->X_add_number
= 0x80000000L
));
637 /* Chosen so luser gets the most offset bits to patch later. */
639 expP
->X_add_number
= floatP
->low
[0]
640 | ((LITTLENUM_MASK
& (floatP
->low
[1])) << LITTLENUM_NUMBER_OF_BITS
);
642 * For the O_big case we have:
643 * If vop_short == 's' then a short floating literal is in the
644 * lowest 6 bits of floatP -> low [0], which is
645 * big_operand_bits [---] [0].
646 * If vop_short == 'i' then the appropriate number of elements
647 * of big_operand_bits [---] [...] are set up with the correct
649 * Also, just in case width is byte word or long, we copy the lowest
650 * 32 bits of the number to X_add_number.
654 if (input_line_pointer
!= operandP
->vop_expr_end
+ 1)
656 as_fatal ("Junk at end of expression \"%s\"", input_line_pointer
);
659 operandP
->vop_expr_end
[1] = c_save
;
661 } /* for(each operand) */
663 input_line_pointer
= save_input_line_pointer
;
665 if (need_pass_2
|| goofed
)
671 /* Remember where it is, in case we want to modify the op-code later. */
672 opcode_low_byteP
= frag_more (v
.vit_opcode_nbytes
);
673 memcpy (opcode_low_byteP
, v
.vit_opcode
, v
.vit_opcode_nbytes
);
674 opcode_as_chars
= v
.vit_opcode
;
675 opcode_as_number
= md_chars_to_number ((unsigned char *) opcode_as_chars
, 4);
676 for (operandP
= v
.vit_operand
,
677 expP
= exp_of_operand
,
678 segP
= seg_of_operand
,
679 floatP
= float_operand
,
680 end_operandP
= v
.vit_operand
+ v
.vit_operands
;
682 operandP
< end_operandP
;
689 if (operandP
->vop_ndx
>= 0)
691 /* indexed addressing byte */
692 /* Legality of indexed mode already checked: it is OK */
693 FRAG_APPEND_1_CHAR (0x40 + operandP
->vop_ndx
);
694 } /* if(vop_ndx>=0) */
696 /* Here to make main operand frag(s). */
697 this_add_number
= expP
->X_add_number
;
698 this_add_symbol
= expP
->X_add_symbol
;
701 is_undefined
= (to_seg
== undefined_section
);
702 is_absolute
= (to_seg
== absolute_section
);
704 is_undefined
= (to_seg
== SEG_UNKNOWN
);
705 is_absolute
= (to_seg
== SEG_ABSOLUTE
);
707 at
= operandP
->vop_mode
& 1;
708 length
= (operandP
->vop_short
== 'b'
709 ? 1 : (operandP
->vop_short
== 'w'
710 ? 2 : (operandP
->vop_short
== 'l'
712 nbytes
= operandP
->vop_nbytes
;
713 if (operandP
->vop_access
== 'b')
715 if (to_seg
== now_seg
|| is_undefined
)
717 /* If is_undefined, then it might BECOME now_seg. */
720 p
= frag_more (nbytes
);
721 fix_new (frag_now
, p
- frag_now
->fr_literal
, nbytes
,
722 this_add_symbol
, this_add_number
, 1, NO_RELOC
);
725 { /* to_seg==now_seg || to_seg == SEG_UNKNOWN */
727 length_code
= is_undefined
? STATE_UNDF
: STATE_BYTE
;
728 if (opcode_as_number
& VIT_OPCODE_SPECIAL
)
730 if (operandP
->vop_width
== VAX_WIDTH_UNCONDITIONAL_JUMP
)
733 frag_var (rs_machine_dependent
, 5, 1,
734 ENCODE_RELAX (STATE_ALWAYS_BRANCH
, length_code
),
735 this_add_symbol
, this_add_number
,
740 if (operandP
->vop_width
== VAX_WIDTH_WORD_JUMP
)
742 length_code
= STATE_WORD
;
743 /* JF: There is no state_byte for this one! */
744 frag_var (rs_machine_dependent
, 10, 2,
745 ENCODE_RELAX (STATE_COMPLEX_BRANCH
, length_code
),
746 this_add_symbol
, this_add_number
,
751 know (operandP
->vop_width
== VAX_WIDTH_BYTE_JUMP
);
752 frag_var (rs_machine_dependent
, 9, 1,
753 ENCODE_RELAX (STATE_COMPLEX_HOP
, length_code
),
754 this_add_symbol
, this_add_number
,
761 know (operandP
->vop_width
== VAX_WIDTH_CONDITIONAL_JUMP
);
762 frag_var (rs_machine_dependent
, 7, 1,
763 ENCODE_RELAX (STATE_CONDITIONAL_BRANCH
, length_code
),
764 this_add_symbol
, this_add_number
,
771 /* to_seg != now_seg && to_seg != SEG_UNKNOWN */
773 * --- SEG FLOAT MAY APPEAR HERE ----
779 know (!(opcode_as_number
& VIT_OPCODE_SYNTHETIC
));
780 p
= frag_more (nbytes
);
781 /* Conventional relocation. */
782 fix_new (frag_now
, p
- frag_now
->fr_literal
, nbytes
,
784 section_symbol (absolute_section
),
788 this_add_number
, 1, NO_RELOC
);
792 know (opcode_as_number
& VIT_OPCODE_SYNTHETIC
);
793 if (opcode_as_number
& VIT_OPCODE_SPECIAL
)
795 if (operandP
->vop_width
== VAX_WIDTH_UNCONDITIONAL_JUMP
)
798 *opcode_low_byteP
= opcode_as_chars
[0] + VAX_WIDEN_LONG
;
799 know (opcode_as_chars
[1] == 0);
801 p
[0] = VAX_ABSOLUTE_MODE
; /* @#... */
802 md_number_to_chars (p
+ 1, this_add_number
, 4);
803 /* Now (eg) JMP @#foo or JSB @#foo. */
807 if (operandP
->vop_width
== VAX_WIDTH_WORD_JUMP
)
815 p
[5] = VAX_ABSOLUTE_MODE
; /* @#... */
816 md_number_to_chars (p
+ 6, this_add_number
, 4);
826 know (operandP
->vop_width
== VAX_WIDTH_BYTE_JUMP
);
832 p
[4] = VAX_ABSOLUTE_MODE
; /* @#... */
833 md_number_to_chars (p
+ 5, this_add_number
, 4);
846 *opcode_low_byteP
^= 1;
847 /* To reverse the condition in a VAX branch,
848 complement the lowest order bit. */
852 p
[2] = VAX_ABSOLUTE_MODE
; /* @#... */
853 md_number_to_chars (p
+ 3, this_add_number
, 4);
864 /* to_seg != now_seg && !is_undefinfed && !is_absolute */
867 /* Pc-relative. Conventional relocation. */
868 know (!(opcode_as_number
& VIT_OPCODE_SYNTHETIC
));
869 p
= frag_more (nbytes
);
870 fix_new (frag_now
, p
- frag_now
->fr_literal
, nbytes
,
872 section_symbol (absolute_section
),
876 this_add_number
, 1, NO_RELOC
);
880 know (opcode_as_number
& VIT_OPCODE_SYNTHETIC
);
881 if (opcode_as_number
& VIT_OPCODE_SPECIAL
)
883 if (operandP
->vop_width
== VAX_WIDTH_UNCONDITIONAL_JUMP
)
886 know (opcode_as_chars
[1] == 0);
887 *opcode_low_byteP
= opcode_as_chars
[0] + VAX_WIDEN_LONG
;
889 p
[0] = VAX_PC_RELATIVE_MODE
;
891 p
+ 1 - frag_now
->fr_literal
, 4,
893 this_add_number
, 1, NO_RELOC
);
894 /* Now eg JMP foo or JSB foo. */
898 if (operandP
->vop_width
== VAX_WIDTH_WORD_JUMP
)
906 p
[5] = VAX_PC_RELATIVE_MODE
;
908 p
+ 6 - frag_now
->fr_literal
, 4,
910 this_add_number
, 1, NO_RELOC
);
920 know (operandP
->vop_width
== VAX_WIDTH_BYTE_JUMP
);
926 p
[4] = VAX_PC_RELATIVE_MODE
;
928 p
+ 5 - frag_now
->fr_literal
,
930 this_add_number
, 1, NO_RELOC
);
942 know (operandP
->vop_width
== VAX_WIDTH_CONDITIONAL_JUMP
);
943 *opcode_low_byteP
^= 1; /* Reverse branch condition. */
947 p
[2] = VAX_PC_RELATIVE_MODE
;
948 fix_new (frag_now
, p
+ 3 - frag_now
->fr_literal
,
950 this_add_number
, 1, NO_RELOC
);
958 know (operandP
->vop_access
!= 'b'); /* So it is ordinary operand. */
959 know (operandP
->vop_access
!= ' '); /* ' ' target-independent: elsewhere. */
960 know (operandP
->vop_access
== 'a'
961 || operandP
->vop_access
== 'm'
962 || operandP
->vop_access
== 'r'
963 || operandP
->vop_access
== 'v'
964 || operandP
->vop_access
== 'w');
965 if (operandP
->vop_short
== 's')
969 if (this_add_number
>= 64)
971 as_warn (_("Short literal overflow(%ld.), immediate mode assumed."),
972 (long) this_add_number
);
973 operandP
->vop_short
= 'i';
974 operandP
->vop_mode
= 8;
975 operandP
->vop_reg
= 0xF;
980 as_warn (_("Forced short literal to immediate mode. now_seg=%s to_seg=%s"),
981 segment_name (now_seg
), segment_name (to_seg
));
982 operandP
->vop_short
= 'i';
983 operandP
->vop_mode
= 8;
984 operandP
->vop_reg
= 0xF;
987 if (operandP
->vop_reg
>= 0 && (operandP
->vop_mode
< 8
988 || (operandP
->vop_reg
!= 0xF && operandP
->vop_mode
< 10)))
990 /* One byte operand. */
991 know (operandP
->vop_mode
> 3);
992 FRAG_APPEND_1_CHAR (operandP
->vop_mode
<< 4 | operandP
->vop_reg
);
993 /* All 1-bytes except S^# happen here. */
997 /* {@}{q^}foo{(Rn)} or S^#foo */
998 if (operandP
->vop_reg
== -1 && operandP
->vop_short
!= 's')
1001 if (to_seg
== now_seg
)
1005 know (operandP
->vop_short
== ' ');
1006 length_code
= STATE_BYTE
;
1008 if (S_IS_EXTERNAL (this_add_symbol
)
1009 || S_IS_WEAK (this_add_symbol
))
1010 length_code
= STATE_UNDF
;
1012 p
= frag_var (rs_machine_dependent
, 10, 2,
1013 ENCODE_RELAX (STATE_PC_RELATIVE
, length_code
),
1014 this_add_symbol
, this_add_number
,
1016 know (operandP
->vop_mode
== 10 + at
);
1018 /* At is the only context we need to carry
1019 to other side of relax() process. Must
1020 be in the correct bit position of VAX
1021 operand spec. byte. */
1026 know (operandP
->vop_short
!= ' ');
1027 p
= frag_more (length
+ 1);
1028 p
[0] = 0xF | ((at
+ "?\12\14?\16"[length
]) << 4);
1029 fix_new (frag_now
, p
+ 1 - frag_now
->fr_literal
,
1030 length
, this_add_symbol
,
1031 this_add_number
, 1, NO_RELOC
);
1035 { /* to_seg != now_seg */
1036 if (this_add_symbol
== NULL
)
1039 /* Do @#foo: simpler relocation than foo-.(pc) anyway. */
1041 p
[0] = VAX_ABSOLUTE_MODE
; /* @#... */
1042 md_number_to_chars (p
+ 1, this_add_number
, 4);
1043 if (length
&& length
!= 4)
1045 as_warn (_("Length specification ignored. Address mode 9F used"));
1050 /* {@}{q^}other_seg */
1051 know ((length
== 0 && operandP
->vop_short
== ' ')
1052 || (length
> 0 && operandP
->vop_short
!= ' '));
1055 || S_IS_WEAK(this_add_symbol
)
1056 || S_IS_EXTERNAL(this_add_symbol
)
1062 default: length_code
= STATE_UNDF
; break;
1063 case 1: length_code
= STATE_BYTE
; break;
1064 case 2: length_code
= STATE_WORD
; break;
1065 case 4: length_code
= STATE_LONG
; break;
1068 * We have a SEG_UNKNOWN symbol. It might
1069 * turn out to be in the same segment as
1070 * the instruction, permitting relaxation.
1072 p
= frag_var (rs_machine_dependent
, 5, 2,
1073 ENCODE_RELAX (STATE_PC_RELATIVE
, length_code
),
1074 this_add_symbol
, this_add_number
,
1082 know (operandP
->vop_short
== ' ');
1083 length
= 4; /* Longest possible. */
1085 p
= frag_more (length
+ 1);
1086 p
[0] = 0xF | ((at
+ "?\12\14?\16"[length
]) << 4);
1087 md_number_to_chars (p
+ 1, this_add_number
, length
);
1089 p
+ 1 - frag_now
->fr_literal
,
1090 length
, this_add_symbol
,
1091 this_add_number
, 1, NO_RELOC
);
1098 /* {@}{q^}foo(Rn) or S^# or I^# or # */
1099 if (operandP
->vop_mode
< 0xA)
1101 /* # or S^# or I^# */
1102 if (operandP
->vop_access
== 'v'
1103 || operandP
->vop_access
== 'a')
1105 if (operandP
->vop_access
== 'v')
1106 as_warn (_("Invalid operand: immediate value used as base address."));
1108 as_warn (_("Invalid operand: immediate value used as address."));
1109 /* gcc 2.6.3 is known to generate these in at least
1113 && is_absolute
&& (expP
->X_op
!= O_big
)
1114 && operandP
->vop_mode
== 8 /* No '@'. */
1115 && this_add_number
< 64)
1117 operandP
->vop_short
= 's';
1119 if (operandP
->vop_short
== 's')
1121 FRAG_APPEND_1_CHAR (this_add_number
);
1127 p
= frag_more (nbytes
+ 1);
1128 know (operandP
->vop_reg
== 0xF);
1130 if (flag_want_pic
&& operandP
->vop_mode
== 8
1131 && this_add_symbol
!= NULL
)
1133 as_warn (_("Symbol used as immediate operand in PIC mode."));
1136 p
[0] = (operandP
->vop_mode
<< 4) | 0xF;
1137 if ((is_absolute
) && (expP
->X_op
!= O_big
))
1140 * If nbytes > 4, then we are scrod. We
1141 * don't know if the high order bytes
1142 * are to be 0xFF or 0x00. BSD4.2 & RMS
1143 * say use 0x00. OK --- but this
1144 * assembler needs ANOTHER rewrite to
1145 * cope properly with this bug. */
1146 md_number_to_chars (p
+ 1, this_add_number
, min (4, nbytes
));
1149 memset (p
+ 5, '\0', nbytes
- 4);
1154 if (expP
->X_op
== O_big
)
1157 * Problem here is to get the bytes
1158 * in the right order. We stored
1159 * our constant as LITTLENUMs, not
1171 for (p
++; nbytes
; nbytes
-= 2, p
+= 2, lP
++)
1173 md_number_to_chars (p
, *lP
, 2);
1179 fix_new (frag_now
, p
+ 1 - frag_now
->fr_literal
,
1180 nbytes
, this_add_symbol
,
1181 this_add_number
, 0, NO_RELOC
);
1187 { /* {@}{q^}foo(Rn) */
1188 know ((length
== 0 && operandP
->vop_short
== ' ')
1189 || (length
> 0 && operandP
->vop_short
!= ' '));
1196 test
= this_add_number
;
1201 length
= test
& 0xffff8000 ? 4
1202 : test
& 0xffffff80 ? 2
1210 p
= frag_more (1 + length
);
1211 know (operandP
->vop_reg
>= 0);
1212 p
[0] = operandP
->vop_reg
1213 | ((at
| "?\12\14?\16"[length
]) << 4);
1216 md_number_to_chars (p
+ 1, this_add_number
, length
);
1220 fix_new (frag_now
, p
+ 1 - frag_now
->fr_literal
,
1221 length
, this_add_symbol
,
1222 this_add_number
, 0, NO_RELOC
);
1226 } /* if(single-byte-operand) */
1228 } /* for(operandP) */
1229 } /* vax_assemble() */
1231 /* md_estimate_size_before_relax(), called just before relax().
1232 Any symbol that is now undefined will not become defined.
1233 Return the correct fr_subtype in the frag and the growth beyond
1236 md_estimate_size_before_relax (fragP
, segment
)
1240 if (RELAX_LENGTH (fragP
->fr_subtype
) == STATE_UNDF
)
1242 if (S_GET_SEGMENT (fragP
->fr_symbol
) != segment
1244 || S_IS_WEAK (fragP
->fr_symbol
)
1245 || S_IS_EXTERNAL (fragP
->fr_symbol
)
1249 /* Non-relaxable cases. */
1250 int reloc_type
= NO_RELOC
;
1254 old_fr_fix
= fragP
->fr_fix
;
1255 p
= fragP
->fr_literal
+ old_fr_fix
;
1257 /* If this is to an undefined symbol, then if it's an indirect
1258 reference indicate that is can mutated into a GLOB_DAT or
1259 JUMP_SLOT by the loader. We restrict ourselves to no offset
1260 due to a limitation in the NetBSD linker. */
1262 if (GOT_symbol
== NULL
)
1263 GOT_symbol
= symbol_find (GLOBAL_OFFSET_TABLE_NAME
);
1264 if (PLT_symbol
== NULL
)
1265 PLT_symbol
= symbol_find (PROCEDURE_LINKAGE_TABLE_NAME
);
1266 if ((GOT_symbol
== NULL
|| fragP
->fr_symbol
!= GOT_symbol
)
1267 && (PLT_symbol
== NULL
|| fragP
->fr_symbol
!= PLT_symbol
)
1268 && fragP
->fr_symbol
!= NULL
1270 && (!S_IS_DEFINED (fragP
->fr_symbol
)
1271 || S_IS_WEAK (fragP
->fr_symbol
)
1272 || S_IS_EXTERNAL (fragP
->fr_symbol
)))
1277 as_fatal ("PIC reference to %s is indirect.\n",
1278 S_GET_NAME (fragP
->fr_symbol
));
1282 if (((unsigned char *) fragP
->fr_opcode
)[0] == VAX_CALLS
1283 || ((unsigned char *) fragP
->fr_opcode
)[0] == VAX_CALLG
1284 || ((unsigned char *) fragP
->fr_opcode
)[0] == VAX_JSB
1285 || ((unsigned char *) fragP
->fr_opcode
)[0] == VAX_JMP
1286 || S_IS_FUNCTION (fragP
->fr_symbol
))
1287 reloc_type
= BFD_RELOC_32_PLT_PCREL
;
1289 reloc_type
= BFD_RELOC_32_GOT_PCREL
;
1293 switch (RELAX_STATE (fragP
->fr_subtype
))
1295 case STATE_PC_RELATIVE
:
1296 p
[0] |= VAX_PC_RELATIVE_MODE
; /* Preserve @ bit. */
1297 fragP
->fr_fix
+= 1 + 4;
1298 fix_new (fragP
, old_fr_fix
+ 1, 4, fragP
->fr_symbol
,
1299 fragP
->fr_offset
, 1, reloc_type
);
1302 case STATE_CONDITIONAL_BRANCH
:
1303 *fragP
->fr_opcode
^= 1; /* Reverse sense of branch. */
1306 p
[2] = VAX_PC_RELATIVE_MODE
; /* ...(PC) */
1307 fragP
->fr_fix
+= 1 + 1 + 1 + 4;
1308 fix_new (fragP
, old_fr_fix
+ 3, 4, fragP
->fr_symbol
,
1309 fragP
->fr_offset
, 1, NO_RELOC
);
1312 case STATE_COMPLEX_BRANCH
:
1318 p
[5] = VAX_PC_RELATIVE_MODE
; /* ...(pc) */
1319 fragP
->fr_fix
+= 2 + 2 + 1 + 1 + 4;
1320 fix_new (fragP
, old_fr_fix
+ 6, 4, fragP
->fr_symbol
,
1321 fragP
->fr_offset
, 1, NO_RELOC
);
1324 case STATE_COMPLEX_HOP
:
1329 p
[4] = VAX_PC_RELATIVE_MODE
; /* ...(pc) */
1330 fragP
->fr_fix
+= 1 + 2 + 1 + 1 + 4;
1331 fix_new (fragP
, old_fr_fix
+ 5, 4, fragP
->fr_symbol
,
1332 fragP
->fr_offset
, 1, NO_RELOC
);
1335 case STATE_ALWAYS_BRANCH
:
1336 *fragP
->fr_opcode
+= VAX_WIDEN_LONG
;
1337 p
[0] = VAX_PC_RELATIVE_MODE
; /* ...(PC) */
1338 fragP
->fr_fix
+= 1 + 4;
1339 fix_new (fragP
, old_fr_fix
+ 1, 4, fragP
->fr_symbol
,
1340 fragP
->fr_offset
, 1, NO_RELOC
);
1348 /* Return the growth in the fixed part of the frag. */
1349 return fragP
->fr_fix
- old_fr_fix
;
1352 /* Relaxable cases. Set up the initial guess for the variable
1353 part of the frag. */
1354 switch (RELAX_STATE (fragP
->fr_subtype
))
1356 case STATE_PC_RELATIVE
:
1357 fragP
->fr_subtype
= ENCODE_RELAX (STATE_PC_RELATIVE
, STATE_BYTE
);
1359 case STATE_CONDITIONAL_BRANCH
:
1360 fragP
->fr_subtype
= ENCODE_RELAX (STATE_CONDITIONAL_BRANCH
, STATE_BYTE
);
1362 case STATE_COMPLEX_BRANCH
:
1363 fragP
->fr_subtype
= ENCODE_RELAX (STATE_COMPLEX_BRANCH
, STATE_WORD
);
1365 case STATE_COMPLEX_HOP
:
1366 fragP
->fr_subtype
= ENCODE_RELAX (STATE_COMPLEX_HOP
, STATE_BYTE
);
1368 case STATE_ALWAYS_BRANCH
:
1369 fragP
->fr_subtype
= ENCODE_RELAX (STATE_ALWAYS_BRANCH
, STATE_BYTE
);
1374 if (fragP
->fr_subtype
>= sizeof (md_relax_table
) / sizeof (md_relax_table
[0]))
1377 /* Return the size of the variable part of the frag. */
1378 return md_relax_table
[fragP
->fr_subtype
].rlx_length
;
1382 * md_convert_frag();
1384 * Called after relax() is finished.
1385 * In: Address of frag.
1386 * fr_type == rs_machine_dependent.
1387 * fr_subtype is what the address relaxed to.
1389 * Out: Any fixSs and constants are set up.
1390 * Caller will turn frag into a ".space 0".
1392 #ifdef BFD_ASSEMBLER
1394 md_convert_frag (headers
, seg
, fragP
)
1395 bfd
*headers ATTRIBUTE_UNUSED
;
1396 segT seg ATTRIBUTE_UNUSED
;
1400 md_convert_frag (headers
, seg
, fragP
)
1401 object_headers
*headers ATTRIBUTE_UNUSED
;
1402 segT seg ATTRIBUTE_UNUSED
;
1406 char *addressP
; /* -> _var to change. */
1407 char *opcodeP
; /* -> opcode char(s) to change. */
1408 short int extension
= 0; /* Size of relaxed address. */
1409 /* Added to fr_fix: incl. ALL var chars. */
1413 know (fragP
->fr_type
== rs_machine_dependent
);
1414 where
= fragP
->fr_fix
;
1415 addressP
= fragP
->fr_literal
+ where
;
1416 opcodeP
= fragP
->fr_opcode
;
1417 symbolP
= fragP
->fr_symbol
;
1420 switch (fragP
->fr_subtype
)
1423 case ENCODE_RELAX (STATE_PC_RELATIVE
, STATE_BYTE
):
1424 know (*addressP
== 0 || *addressP
== 0x10); /* '@' bit. */
1425 addressP
[0] |= 0xAF; /* Byte displacement. */
1426 fix_new (fragP
, fragP
->fr_fix
+ 1, 1, fragP
->fr_symbol
,
1427 fragP
->fr_offset
, 1, NO_RELOC
);
1431 case ENCODE_RELAX (STATE_PC_RELATIVE
, STATE_WORD
):
1432 know (*addressP
== 0 || *addressP
== 0x10); /* '@' bit. */
1433 addressP
[0] |= 0xCF; /* Word displacement. */
1434 fix_new (fragP
, fragP
->fr_fix
+ 1, 2, fragP
->fr_symbol
,
1435 fragP
->fr_offset
, 1, NO_RELOC
);
1439 case ENCODE_RELAX (STATE_PC_RELATIVE
, STATE_LONG
):
1440 know (*addressP
== 0 || *addressP
== 0x10); /* '@' bit. */
1441 addressP
[0] |= 0xEF; /* Long word displacement. */
1442 fix_new (fragP
, fragP
->fr_fix
+ 1, 4, fragP
->fr_symbol
,
1443 fragP
->fr_offset
, 1, NO_RELOC
);
1447 case ENCODE_RELAX (STATE_CONDITIONAL_BRANCH
, STATE_BYTE
):
1448 fix_new (fragP
, fragP
->fr_fix
, 1, fragP
->fr_symbol
,
1449 fragP
->fr_offset
, 1, NO_RELOC
);
1453 case ENCODE_RELAX (STATE_CONDITIONAL_BRANCH
, STATE_WORD
):
1454 opcodeP
[0] ^= 1; /* Reverse sense of test. */
1456 addressP
[1] = VAX_BRW
;
1457 fix_new (fragP
, fragP
->fr_fix
+ 2, 2, fragP
->fr_symbol
,
1458 fragP
->fr_offset
, 1, NO_RELOC
);
1462 case ENCODE_RELAX (STATE_CONDITIONAL_BRANCH
, STATE_LONG
):
1463 opcodeP
[0] ^= 1; /* Reverse sense of test. */
1465 addressP
[1] = VAX_JMP
;
1466 addressP
[2] = VAX_PC_RELATIVE_MODE
;
1467 fix_new (fragP
, fragP
->fr_fix
+ 3, 4, fragP
->fr_symbol
,
1468 fragP
->fr_offset
, 1, NO_RELOC
);
1472 case ENCODE_RELAX (STATE_ALWAYS_BRANCH
, STATE_BYTE
):
1473 fix_new (fragP
, fragP
->fr_fix
, 1, fragP
->fr_symbol
,
1474 fragP
->fr_offset
, 1, NO_RELOC
);
1478 case ENCODE_RELAX (STATE_ALWAYS_BRANCH
, STATE_WORD
):
1479 opcodeP
[0] += VAX_WIDEN_WORD
; /* brb -> brw, bsbb -> bsbw */
1480 fix_new (fragP
, fragP
->fr_fix
, 2, fragP
->fr_symbol
, fragP
->fr_offset
,
1485 case ENCODE_RELAX (STATE_ALWAYS_BRANCH
, STATE_LONG
):
1486 opcodeP
[0] += VAX_WIDEN_LONG
; /* brb -> jmp, bsbb -> jsb */
1487 addressP
[0] = VAX_PC_RELATIVE_MODE
;
1488 fix_new (fragP
, fragP
->fr_fix
+ 1, 4, fragP
->fr_symbol
,
1489 fragP
->fr_offset
, 1, NO_RELOC
);
1493 case ENCODE_RELAX (STATE_COMPLEX_BRANCH
, STATE_WORD
):
1494 fix_new (fragP
, fragP
->fr_fix
, 2, fragP
->fr_symbol
,
1495 fragP
->fr_offset
, 1, NO_RELOC
);
1499 case ENCODE_RELAX (STATE_COMPLEX_BRANCH
, STATE_LONG
):
1502 addressP
[2] = VAX_BRB
;
1504 addressP
[4] = VAX_JMP
;
1505 addressP
[5] = VAX_PC_RELATIVE_MODE
;
1506 fix_new (fragP
, fragP
->fr_fix
+ 6, 4, fragP
->fr_symbol
,
1507 fragP
->fr_offset
, 1, NO_RELOC
);
1511 case ENCODE_RELAX (STATE_COMPLEX_HOP
, STATE_BYTE
):
1512 fix_new (fragP
, fragP
->fr_fix
, 1, fragP
->fr_symbol
,
1513 fragP
->fr_offset
, 1, NO_RELOC
);
1517 case ENCODE_RELAX (STATE_COMPLEX_HOP
, STATE_WORD
):
1519 addressP
[1] = VAX_BRB
;
1521 addressP
[3] = VAX_BRW
;
1522 fix_new (fragP
, fragP
->fr_fix
+ 4, 2, fragP
->fr_symbol
,
1523 fragP
->fr_offset
, 1, NO_RELOC
);
1527 case ENCODE_RELAX (STATE_COMPLEX_HOP
, STATE_LONG
):
1529 addressP
[1] = VAX_BRB
;
1531 addressP
[3] = VAX_JMP
;
1532 addressP
[4] = VAX_PC_RELATIVE_MODE
;
1533 fix_new (fragP
, fragP
->fr_fix
+ 5, 4, fragP
->fr_symbol
,
1534 fragP
->fr_offset
, 1, NO_RELOC
);
1539 BAD_CASE (fragP
->fr_subtype
);
1542 fragP
->fr_fix
+= extension
;
1543 } /* md_convert_frag() */
1545 /* Translate internal format of relocation info into target format.
1547 On vax: first 4 bytes are normal unsigned long, next three bytes
1548 are symbolnum, least sig. byte first. Last byte is broken up with
1549 the upper nibble as nuthin, bit 3 as extern, bits 2 & 1 as length, and
1553 md_ri_to_chars (the_bytes
, ri
)
1555 struct reloc_info_generic ri
;
1558 md_number_to_chars (the_bytes
, ri
.r_address
, sizeof (ri
.r_address
));
1559 /* now the fun stuff */
1560 the_bytes
[6] = (ri
.r_symbolnum
>> 16) & 0x0ff;
1561 the_bytes
[5] = (ri
.r_symbolnum
>> 8) & 0x0ff;
1562 the_bytes
[4] = ri
.r_symbolnum
& 0x0ff;
1563 the_bytes
[7] = (((ri
.r_extern
<< 3) & 0x08) | ((ri
.r_length
<< 1) & 0x06) |
1564 ((ri
.r_pcrel
<< 0) & 0x01)) & 0x0F;
1567 #endif /* comment */
1570 #ifndef BFD_ASSEMBLER
1572 tc_aout_fix_to_chars (where
, fixP
, segment_address_in_file
)
1575 relax_addressT segment_address_in_file
;
1578 * In: length of relocation (or of address) in chars: 1, 2 or 4.
1579 * Out: GNU LD relocation length code: 0, 1, or 2.
1582 static const unsigned char nbytes_r_length
[] = {42, 0, 1, 42, 2};
1585 know (fixP
->fx_addsy
!= NULL
);
1587 md_number_to_chars (where
,
1588 fixP
->fx_frag
->fr_address
+ fixP
->fx_where
- segment_address_in_file
,
1591 r_symbolnum
= (S_IS_DEFINED (fixP
->fx_addsy
)
1592 ? S_GET_TYPE (fixP
->fx_addsy
)
1593 : fixP
->fx_addsy
->sy_number
);
1595 where
[6] = (r_symbolnum
>> 16) & 0x0ff;
1596 where
[5] = (r_symbolnum
>> 8) & 0x0ff;
1597 where
[4] = r_symbolnum
& 0x0ff;
1598 where
[7] = ((((!S_IS_DEFINED (fixP
->fx_addsy
)) << 3) & 0x08)
1599 | ((nbytes_r_length
[fixP
->fx_size
] << 1) & 0x06)
1600 | (((fixP
->fx_pcrel
<< 0) & 0x01) & 0x0f));
1602 #endif /* !BFD_ASSEMBLER */
1603 #endif /* OBJ_AOUT */
1606 * BUGS, GRIPES, APOLOGIA, etc.
1608 * The opcode table 'votstrs' needs to be sorted on opcode frequency.
1609 * That is, AFTER we hash it with hash_...(), we want most-used opcodes
1610 * to come out of the hash table faster.
1612 * I am sorry to inflict yet another VAX assembler on the world, but
1613 * RMS says we must do everything from scratch, to prevent pin-heads
1614 * restricting this software.
1618 * This is a vaguely modular set of routines in C to parse VAX
1619 * assembly code using DEC mnemonics. It is NOT un*x specific.
1621 * The idea here is that the assembler has taken care of all:
1628 * condensing any whitespace down to exactly one space
1629 * and all we have to do is parse 1 line into a vax instruction
1630 * partially formed. We will accept a line, and deliver:
1631 * an error message (hopefully empty)
1632 * a skeleton VAX instruction (tree structure)
1633 * textual pointers to all the operand expressions
1634 * a warning message that notes a silly operand (hopefully empty)
1638 * E D I T H I S T O R Y
1640 * 17may86 Dean Elsner. Bug if line ends immediately after opcode.
1641 * 30apr86 Dean Elsner. New vip_op() uses arg block so change call.
1642 * 6jan86 Dean Elsner. Crock vip_begin() to call vip_op_defaults().
1643 * 2jan86 Dean Elsner. Invent synthetic opcodes.
1644 * Widen vax_opcodeT to 32 bits. Use a bit for VIT_OPCODE_SYNTHETIC,
1645 * which means this is not a real opcode, it is like a macro; it will
1646 * be relax()ed into 1 or more instructions.
1647 * Use another bit for VIT_OPCODE_SPECIAL if the op-code is not optimised
1648 * like a regular branch instruction. Option added to vip_begin():
1649 * exclude synthetic opcodes. Invent synthetic_votstrs[].
1650 * 31dec85 Dean Elsner. Invent vit_opcode_nbytes.
1651 * Also make vit_opcode into a char[]. We now have n-byte vax opcodes,
1652 * so caller's don't have to know the difference between a 1-byte & a
1653 * 2-byte op-code. Still need vax_opcodeT concept, so we know how
1654 * big an object must be to hold an op.code.
1655 * 30dec85 Dean Elsner. Widen typedef vax_opcodeT in "vax-inst.h"
1656 * because vax opcodes may be 16 bits. Our crufty C compiler was
1657 * happily initialising 8-bit vot_codes with 16-bit numbers!
1658 * (Wouldn't the 'phone company like to compress data so easily!)
1659 * 29dec85 Dean Elsner. New static table vax_operand_width_size[].
1660 * Invented so we know hw many bytes a "I^#42" needs in its immediate
1661 * operand. Revised struct vop in "vax-inst.h": explicitly include
1662 * byte length of each operand, and it's letter-code datum type.
1663 * 17nov85 Dean Elsner. Name Change.
1664 * Due to ar(1) truncating names, we learned the hard way that
1665 * "vax-inst-parse.c" -> "vax-inst-parse." dropping the "o" off
1666 * the archived object name. SO... we shortened the name of this
1667 * source file, and changed the makefile.
1670 /* handle of the OPCODE hash table */
1671 static struct hash_control
*op_hash
;
1674 * In: 1 character, from "bdfghloqpw" being the data-type of an operand
1675 * of a vax instruction.
1677 * Out: the length of an operand of that type, in bytes.
1678 * Special branch operands types "-?!" have length 0.
1681 static const short int vax_operand_width_size
[256] =
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, 1, 0, 8, 0, 4, 8, 16, 0, 0, 0, 4, 0, 0,16, /* ..b.d.fgh...l..o */
1688 0, 8, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, /* .q.....w........ */
1689 0, 0, 1, 0, 8, 0, 4, 8, 16, 0, 0, 0, 4, 0, 0,16, /* ..b.d.fgh...l..o */
1690 0, 8, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, /* .q.....w........ */
1691 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1692 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1693 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1694 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1695 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1696 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1697 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1698 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1702 * This perversion encodes all the vax opcodes as a bunch of strings.
1703 * RMS says we should build our hash-table at run-time. Hmm.
1704 * Please would someone arrange these in decreasing frequency of opcode?
1705 * Because of the way hash_...() works, the most frequently used opcode
1706 * should be textually first and so on.
1708 * Input for this table was 'vax.opcodes', awk(1)ed by 'vax.opcodes.c.awk' .
1709 * So change 'vax.opcodes', then re-generate this table.
1712 #include "opcode/vax.h"
1715 * This is a table of optional op-codes. All of them represent
1716 * 'synthetic' instructions that seem popular.
1718 * Here we make some pseudo op-codes. Every code has a bit set to say
1719 * it is synthetic. This lets you catch them if you want to
1720 * ban these opcodes. They are mnemonics for "elastic" instructions
1721 * that are supposed to assemble into the fewest bytes needed to do a
1722 * branch, or to do a conditional branch, or whatever.
1724 * The opcode is in the usual place [low-order n*8 bits]. This means
1725 * that if you mask off the bucky bits, the usual rules apply about
1726 * how long the opcode is.
1728 * All VAX branch displacements come at the end of the instruction.
1729 * For simple branches (1-byte opcode + 1-byte displacement) the last
1730 * operand is coded 'b?' where the "data type" '?' is a clue that we
1731 * may reverse the sense of the branch (complement lowest order bit)
1732 * and branch around a jump. This is by far the most common case.
1733 * That is why the VIT_OPCODE_SYNTHETIC bit is set: it says this is
1734 * a 0-byte op-code followed by 2 or more bytes of operand address.
1736 * If the op-code has VIT_OPCODE_SPECIAL set, then we have a more unusual
1739 * For JBSB & JBR the treatment is the similar, except (1) we have a 'bw'
1740 * option before (2) we can directly JSB/JMP because there is no condition.
1741 * These operands have 'b-' as their access/data type.
1743 * That leaves a bunch of random opcodes: JACBx, JxOBxxx. In these
1744 * cases, we do the same idea. JACBxxx are all marked with a 'b!'
1745 * JAOBxxx & JSOBxxx are marked with a 'b:'.
1748 #if (VIT_OPCODE_SYNTHETIC != 0x80000000)
1749 You have just broken the encoding below
, which assumes the sign bit
1750 means
'I am an imaginary instruction'.
1753 #if (VIT_OPCODE_SPECIAL != 0x40000000)
1754 You have just broken the encoding below
, which assumes the
0x40 M bit means
1755 'I am not to be "optimised" the way normal branches are'.
1758 static const struct vot
1759 synthetic_votstrs
[] =
1761 {"jbsb", {"b-", 0xC0000010}}, /* BSD 4.2 */
1762 /* jsb used already */
1763 {"jbr", {"b-", 0xC0000011}}, /* BSD 4.2 */
1764 {"jr", {"b-", 0xC0000011}}, /* consistent */
1765 {"jneq", {"b?", 0x80000012}},
1766 {"jnequ", {"b?", 0x80000012}},
1767 {"jeql", {"b?", 0x80000013}},
1768 {"jeqlu", {"b?", 0x80000013}},
1769 {"jgtr", {"b?", 0x80000014}},
1770 {"jleq", {"b?", 0x80000015}},
1771 /* un-used opcodes here */
1772 {"jgeq", {"b?", 0x80000018}},
1773 {"jlss", {"b?", 0x80000019}},
1774 {"jgtru", {"b?", 0x8000001a}},
1775 {"jlequ", {"b?", 0x8000001b}},
1776 {"jvc", {"b?", 0x8000001c}},
1777 {"jvs", {"b?", 0x8000001d}},
1778 {"jgequ", {"b?", 0x8000001e}},
1779 {"jcc", {"b?", 0x8000001e}},
1780 {"jlssu", {"b?", 0x8000001f}},
1781 {"jcs", {"b?", 0x8000001f}},
1783 {"jacbw", {"rwrwmwb!", 0xC000003d}},
1784 {"jacbf", {"rfrfmfb!", 0xC000004f}},
1785 {"jacbd", {"rdrdmdb!", 0xC000006f}},
1786 {"jacbb", {"rbrbmbb!", 0xC000009d}},
1787 {"jacbl", {"rlrlmlb!", 0xC00000f1}},
1788 {"jacbg", {"rgrgmgb!", 0xC0004ffd}},
1789 {"jacbh", {"rhrhmhb!", 0xC0006ffd}},
1791 {"jbs", {"rlvbb?", 0x800000e0}},
1792 {"jbc", {"rlvbb?", 0x800000e1}},
1793 {"jbss", {"rlvbb?", 0x800000e2}},
1794 {"jbcs", {"rlvbb?", 0x800000e3}},
1795 {"jbsc", {"rlvbb?", 0x800000e4}},
1796 {"jbcc", {"rlvbb?", 0x800000e5}},
1797 {"jlbs", {"rlb?", 0x800000e8}},
1798 {"jlbc", {"rlb?", 0x800000e9}},
1800 {"jaoblss", {"rlmlb:", 0xC00000f2}},
1801 {"jaobleq", {"rlmlb:", 0xC00000f3}},
1802 {"jsobgeq", {"mlb:", 0xC00000f4}},
1803 {"jsobgtr", {"mlb:", 0xC00000f5}},
1805 /* CASEx has no branch addresses in our conception of it. */
1806 /* You should use ".word ..." statements after the "case ...". */
1808 {"", {"", 0}} /* empty is end sentinel */
1810 }; /* synthetic_votstrs */
1813 * v i p _ b e g i n ( )
1815 * Call me once before you decode any lines.
1816 * I decode votstrs into a hash table at op_hash (which I create).
1817 * I return an error text or null.
1818 * If you want, I will include the 'synthetic' jXXX instructions in the
1819 * instruction table.
1820 * You must nominate metacharacters for eg DEC's "#", "@", "^".
1824 vip_begin (synthetic_too
, immediate
, indirect
, displen
)
1825 int synthetic_too
; /* 1 means include jXXX op-codes. */
1826 const char *immediate
, *indirect
, *displen
;
1828 const struct vot
*vP
; /* scan votstrs */
1829 const char *retval
= 0; /* error text */
1831 op_hash
= hash_new ();
1833 for (vP
= votstrs
; *vP
->vot_name
&& !retval
; vP
++)
1834 retval
= hash_insert (op_hash
, vP
->vot_name
, (PTR
) &vP
->vot_detail
);
1837 for (vP
= synthetic_votstrs
; *vP
->vot_name
&& !retval
; vP
++)
1838 retval
= hash_insert (op_hash
, vP
->vot_name
, (PTR
) &vP
->vot_detail
);
1841 vip_op_defaults (immediate
, indirect
, displen
);
1850 * This converts a string into a vax instruction.
1851 * The string must be a bare single instruction in dec-vax (with BSD4 frobs)
1853 * It provides some error messages: at most one fatal error message (which
1854 * stops the scan) and at most one warning message for each operand.
1855 * The vax instruction is returned in exploded form, since we have no
1856 * knowledge of how you parse (or evaluate) your expressions.
1857 * We do however strip off and decode addressing modes and operation
1860 * The exploded instruction is returned to a struct vit of your choice.
1861 * #include "vax-inst.h" to know what a struct vit is.
1863 * This function's value is a string. If it is not "" then an internal
1864 * logic error was found: read this code to assign meaning to the string.
1865 * No argument string should generate such an error string:
1866 * it means a bug in our code, not in the user's text.
1868 * You MUST have called vip_begin() once before using this function.
1872 vip (vitP
, instring
)
1873 struct vit
*vitP
; /* We build an exploded instruction here. */
1874 char *instring
; /* Text of a vax instruction: we modify. */
1876 /* How to bit-encode this opcode. */
1877 struct vot_wot
*vwP
;
1878 /* 1/skip whitespace.2/scan vot_how */
1881 /* counts number of operands seen */
1882 unsigned char count
;
1883 /* scan operands in struct vit */
1884 struct vop
*operandp
;
1885 /* error over all operands */
1886 const char *alloperr
;
1887 /* Remember char, (we clobber it with '\0' temporarily). */
1889 /* Op-code of this instruction. */
1892 if (*instring
== ' ')
1893 ++instring
; /* Skip leading whitespace. */
1894 for (p
= instring
; *p
&& *p
!= ' '; p
++);; /* MUST end in end-of-string or exactly 1 space. */
1895 /* Scanned up to end of operation-code. */
1896 /* Operation-code is ended with whitespace. */
1897 if (p
- instring
== 0)
1899 vitP
->vit_error
= _("No operator");
1901 memset (vitP
->vit_opcode
, '\0', sizeof (vitP
->vit_opcode
));
1908 * Here with instring pointing to what better be an op-name, and p
1909 * pointing to character just past that.
1910 * We trust instring points to an op-name, with no whitespace.
1912 vwP
= (struct vot_wot
*) hash_find (op_hash
, instring
);
1913 *p
= c
; /* Restore char after op-code. */
1916 vitP
->vit_error
= _("Unknown operator");
1918 memset (vitP
->vit_opcode
, '\0', sizeof (vitP
->vit_opcode
));
1923 * We found a match! So let's pick up as many operands as the
1924 * instruction wants, and even gripe if there are too many.
1925 * We expect comma to separate each operand.
1926 * We let instring track the text, while p tracks a part of the
1931 * The lines below know about 2-byte opcodes starting FD,FE or FF.
1932 * They also understand synthetic opcodes. Note:
1933 * we return 32 bits of opcode, including bucky bits, BUT
1934 * an opcode length is either 8 or 16 bits for vit_opcode_nbytes.
1936 oc
= vwP
->vot_code
; /* The op-code. */
1937 vitP
->vit_opcode_nbytes
= (oc
& 0xFF) >= 0xFD ? 2 : 1;
1938 md_number_to_chars (vitP
->vit_opcode
, oc
, 4);
1939 count
= 0; /* no operands seen yet */
1940 instring
= p
; /* point just past operation code */
1942 for (howp
= vwP
->vot_how
, operandp
= vitP
->vit_operand
;
1943 !(alloperr
&& *alloperr
) && *howp
;
1944 operandp
++, howp
+= 2)
1947 * Here to parse one operand. Leave instring pointing just
1948 * past any one ',' that marks the end of this operand.
1951 as_fatal (_("odd number of bytes in operand description"));
1954 for (q
= instring
; (c
= *q
) && c
!= ','; q
++)
1957 * Q points to ',' or '\0' that ends argument. C is that
1961 operandp
->vop_width
= howp
[1];
1962 operandp
->vop_nbytes
= vax_operand_width_size
[(unsigned) howp
[1]];
1963 operandp
->vop_access
= howp
[0];
1964 vip_op (instring
, operandp
);
1965 *q
= c
; /* Restore input text. */
1966 if (operandp
->vop_error
)
1967 alloperr
= _("Bad operand");
1968 instring
= q
+ (c
? 1 : 0); /* next operand (if any) */
1969 count
++; /* won another argument, may have an operr */
1972 alloperr
= _("Not enough operands");
1976 if (*instring
== ' ')
1977 instring
++; /* Skip whitespace. */
1979 alloperr
= _("Too many operands");
1981 vitP
->vit_error
= alloperr
;
1984 vitP
->vit_operands
= count
;
1990 * Test program for above.
1993 struct vit myvit
; /* build an exploded vax instruction here */
1994 char answer
[100]; /* human types a line of vax assembler here */
1995 char *mybug
; /* "" or an internal logic diagnostic */
1996 int mycount
; /* number of operands */
1997 struct vop
*myvop
; /* scan operands from myvit */
1998 int mysynth
; /* 1 means want synthetic opcodes. */
1999 char my_immediate
[200];
2000 char my_indirect
[200];
2001 char my_displen
[200];
2007 printf ("0 means no synthetic instructions. ");
2008 printf ("Value for vip_begin? ");
2010 sscanf (answer
, "%d", &mysynth
);
2011 printf ("Synthetic opcodes %s be included.\n", mysynth
? "will" : "will not");
2012 printf ("enter immediate symbols eg enter # ");
2013 gets (my_immediate
);
2014 printf ("enter indirect symbols eg enter @ ");
2016 printf ("enter displen symbols eg enter ^ ");
2018 if (p
= vip_begin (mysynth
, my_immediate
, my_indirect
, my_displen
))
2020 error ("vip_begin=%s", p
);
2022 printf ("An empty input line will quit you from the vax instruction parser\n");
2025 printf ("vax instruction: ");
2030 break; /* out of for each input text loop */
2032 vip (&myvit
, answer
);
2033 if (*myvit
.vit_error
)
2035 printf ("ERR:\"%s\"\n", myvit
.vit_error
);
2038 for (mycount
= myvit
.vit_opcode_nbytes
, p
= myvit
.vit_opcode
;
2043 printf ("%02x ", *p
& 0xFF);
2045 printf (" operand count=%d.\n", mycount
= myvit
.vit_operands
);
2046 for (myvop
= myvit
.vit_operand
; mycount
; mycount
--, myvop
++)
2048 printf ("mode=%xx reg=%xx ndx=%xx len='%c'=%c%c%d. expr=\"",
2049 myvop
->vop_mode
, myvop
->vop_reg
, myvop
->vop_ndx
,
2050 myvop
->vop_short
, myvop
->vop_access
, myvop
->vop_width
,
2052 for (p
= myvop
->vop_expr_begin
; p
<= myvop
->vop_expr_end
; p
++)
2057 if (myvop
->vop_error
)
2059 printf (" err:\"%s\"\n", myvop
->vop_error
);
2061 if (myvop
->vop_warn
)
2063 printf (" wrn:\"%s\"\n", myvop
->vop_warn
);
2068 exit (EXIT_SUCCESS
);
2071 #endif /* #ifdef test */
2073 /* end of vax_ins_parse.c */
2075 /* vax_reg_parse.c - convert a VAX register name to a number */
2077 /* Copyright (C) 1987 Free Software Foundation, Inc. A part of GNU. */
2080 * v a x _ r e g _ p a r s e ( )
2082 * Take 3 char.s, the last of which may be `\0` (non-existent)
2083 * and return the VAX register number that they represent.
2085 * Return -1 if they don't form a register name. Good names return
2086 * a number from 0:15 inclusive.
2088 * Case is not important in a name.
2090 * Register names understood are:
2111 #include "safe-ctype.h"
2117 int /* return -1 or 0:15 */
2118 vax_reg_parse (c1
, c2
, c3
, c4
) /* 3 chars of register name */
2119 char c1
, c2
, c3
, c4
; /* c3 == 0 if 2-character reg name */
2121 int retval
; /* return -1:15 */
2126 if (c1
!= '%') /* register prefixes are mandatory for ELF */
2133 if (c4
!= 0) /* register prefixes are not allowed under VMS */
2137 if (c1
== '%') /* register prefixes are optional under a.out */
2143 else if (c3
&& c4
) /* can't be 4 characters long. */
2149 if (ISDIGIT (c2
) && c1
== 'r')
2154 retval
= retval
* 10 + c3
- '0';
2155 retval
= (retval
> 15) ? -1 : retval
;
2156 /* clamp the register value to 1 hex digit */
2159 retval
= -1; /* c3 must be '\0' or a digit */
2161 else if (c3
) /* There are no three letter regs */
2180 else if (c1
== 'p' && c2
== 'c')
2190 * Parse a vax operand in DEC assembler notation.
2191 * For speed, expect a string of whitespace to be reduced to a single ' '.
2192 * This is the case for GNU AS, and is easy for other DEC-compatible
2195 * Knowledge about DEC VAX assembler operand notation lives here.
2196 * This doesn't even know what a register name is, except it believes
2197 * all register names are 2 or 3 characters, and lets vax_reg_parse() say
2198 * what number each name represents.
2199 * It does, however, know that PC, SP etc are special registers so it can
2200 * detect addressing modes that are silly for those registers.
2202 * Where possible, it delivers 1 fatal or 1 warning message if the operand
2203 * is suspect. Exactly what we test for is still evolving.
2211 * There were a number of 'mismatched argument type' bugs to vip_op.
2212 * The most general solution is to typedef each (of many) arguments.
2213 * We used instead a typedef'd argument block. This is less modular
2214 * than using separate return pointers for each result, but runs faster
2215 * on most engines, and seems to keep programmers happy. It will have
2216 * to be done properly if we ever want to use vip_op as a general-purpose
2217 * module (it was designed to be).
2221 * Doesn't support DEC "G^" format operands. These always take 5 bytes
2222 * to express, and code as modes 8F or 9F. Reason: "G^" deprives you of
2223 * optimising to (say) a "B^" if you are lucky in the way you link.
2224 * When someone builds a linker smart enough to convert "G^" to "B^", "W^"
2225 * whenever possible, then we should implement it.
2226 * If there is some other use for "G^", feel free to code it in!
2231 * If I nested if()s more, I could avoid testing (*err) which would save
2232 * time, space and page faults. I didn't nest all those if()s for clarity
2233 * and because I think the mode testing can be re-arranged 1st to test the
2234 * commoner constructs 1st. Does anybody have statistics on this?
2240 * In future, we should be able to 'compose' error messages in a scratch area
2241 * and give the user MUCH more informative error messages. Although this takes
2242 * a little more code at run-time, it will make this module much more self-
2243 * documenting. As an example of what sucks now: most error messages have
2244 * hardwired into them the DEC VAX metacharacters "#^@" which are nothing like
2245 * the Un*x characters "$`*", that most users will expect from this AS.
2249 * The input is a string, ending with '\0'.
2251 * We also require a 'hint' of what kind of operand is expected: so
2252 * we can remind caller not to write into literals for instance.
2254 * The output is a skeletal instruction.
2256 * The algorithm has two parts.
2257 * 1. extract the syntactic features (parse off all the @^#-()+[] mode crud);
2258 * 2. express the @^#-()+[] as some parameters suited to further analysis.
2260 * 2nd step is where we detect the googles of possible invalid combinations
2261 * a human (or compiler) might write. Note that if we do a half-way
2262 * decent assembler, we don't know how long to make (eg) displacement
2263 * fields when we first meet them (because they may not have defined values).
2264 * So we must wait until we know how many bits are needed for each address,
2265 * then we can know both length and opcodes of instructions.
2266 * For reason(s) above, we will pass to our caller a 'broken' instruction
2267 * of these major components, from which our caller can generate instructions:
2268 * - displacement length I^ S^ L^ B^ W^ unspecified
2270 * - register R0-R15 or absent
2271 * - index register R0-R15 or absent
2272 * - expression text what we don't parse
2273 * - error text(s) why we couldn't understand the operand
2277 * To decode output of this, test errtxt. If errtxt[0] == '\0', then
2278 * we had no errors that prevented parsing. Also, if we ever report
2279 * an internal bug, errtxt[0] is set non-zero. So one test tells you
2280 * if the other outputs are to be taken seriously.
2284 * Because this module is useful for both VMS and UN*X style assemblers
2285 * and because of the variety of UN*X assemblers we must recognise
2286 * the different conventions for assembler operand notation. For example
2287 * VMS says "#42" for immediate mode, while most UN*X say "$42".
2288 * We permit arbitrary sets of (single) characters to represent the
2289 * 3 concepts that DEC writes '#', '@', '^'.
2292 /* character tests */
2293 #define VIP_IMMEDIATE 01 /* Character is like DEC # */
2294 #define VIP_INDIRECT 02 /* Char is like DEC @ */
2295 #define VIP_DISPLEN 04 /* Char is like DEC ^ */
2297 #define IMMEDIATEP(c) (vip_metacharacters [(c)&0xff]&VIP_IMMEDIATE)
2298 #define INDIRECTP(c) (vip_metacharacters [(c)&0xff]&VIP_INDIRECT)
2299 #define DISPLENP(c) (vip_metacharacters [(c)&0xff]&VIP_DISPLEN)
2301 /* We assume 8 bits per byte. Use vip_op_defaults() to set these up BEFORE we
2305 #if defined(CONST_TABLE)
2307 #define I VIP_IMMEDIATE,
2308 #define S VIP_INDIRECT,
2309 #define D VIP_DISPLEN,
2311 vip_metacharacters
[256] =
2313 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
/* ^@ ^A ^B ^C ^D ^E ^F ^G ^H ^I ^J ^K ^L ^M ^N ^O*/
2314 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
/* ^P ^Q ^R ^S ^T ^U ^V ^W ^X ^Y ^Z ^[ ^\ ^] ^^ ^_ */
2315 _ _ _ _ I _ _ _ _ _ S _ _ _ _ _
/* sp ! " # $ % & ' ( ) * + , - . / */
2316 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
/*0 1 2 3 4 5 6 7 8 9 : ; < = > ?*/
2317 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
/*@ A B C D E F G H I J K L M N O*/
2318 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
/*P Q R S T U V W X Y Z [ \ ] ^ _*/
2319 D _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
/*` a b c d e f g h i j k l m n o*/
2320 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
/*p q r s t u v w x y z { | } ~ ^?*/
2322 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
2323 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
2324 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
2325 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
2326 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
2327 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
2328 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
2329 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
2336 static char vip_metacharacters
[256];
2339 vip_op_1 (bit
, syms
)
2345 while ((t
= *syms
++) != 0)
2346 vip_metacharacters
[t
] |= bit
;
2349 /* Can be called any time. More arguments may appear in future. */
2351 vip_op_defaults (immediate
, indirect
, displen
)
2352 const char *immediate
;
2353 const char *indirect
;
2354 const char *displen
;
2356 vip_op_1 (VIP_IMMEDIATE
, immediate
);
2357 vip_op_1 (VIP_INDIRECT
, indirect
);
2358 vip_op_1 (VIP_DISPLEN
, displen
);
2365 * Dec defines the semantics of address modes (and values)
2366 * by a two-letter code, explained here.
2368 * letter 1: access type
2370 * a address calculation - no data access, registers forbidden
2371 * b branch displacement
2372 * m read - let go of bus - write back "modify"
2374 * v bit field address: like 'a' but registers are OK
2376 * space no operator (eg ".long foo") [our convention]
2378 * letter 2: data type (i.e. width, alignment)
2381 * d double precision floating point (D format)
2382 * f single precision floating point (F format)
2383 * g G format floating
2384 * h H format floating
2389 * ? simple synthetic branch operand
2390 * - unconditional synthetic JSB/JSR operand
2391 * ! complex synthetic branch operand
2393 * The '-?!' letter 2's are not for external consumption. They are used
2394 * for various assemblers. Generally, all unknown widths are assumed 0.
2395 * We don't limit your choice of width character.
2397 * DEC operands are hard work to parse. For example, '@' as the first
2398 * character means indirect (deferred) mode but elsewhere it is a shift
2400 * The long-winded explanation of how this is supposed to work is
2401 * cancelled. Read a DEC vax manual.
2402 * We try hard not to parse anything that MIGHT be part of the expression
2403 * buried in that syntax. For example if we see @...(Rn) we don't check
2404 * for '-' before the '(' because mode @-(Rn) does not exist.
2406 * After parsing we have:
2408 * at 1 if leading '@' (or Un*x '*')
2409 * len takes one value from " bilsw". eg B^ -> 'b'.
2410 * hash 1 if leading '#' (or Un*x '$')
2411 * expr_begin, expr_end the expression we did not parse
2412 * even though we don't interpret it, we make use
2413 * of its presence or absence.
2414 * sign -1: -(Rn) 0: absent +1: (Rn)+
2415 * paren 1 if () are around register
2416 * reg major register number 0:15 -1 means absent
2417 * ndx index register number 0:15 -1 means absent
2419 * Again, I dare not explain it: just trace ALL the code!
2423 vip_op (optext
, vopP
)
2424 /* user's input string e.g.: "@B^foo@bar(AP)[FP]:" */
2426 /* Input fields: vop_access, vop_width.
2427 Output fields: _ndx, _reg, _mode, _short, _warn,
2428 _error _expr_begin, _expr_end, _nbytes.
2429 vop_nbytes : number of bytes in a datum. */
2432 /* track operand text forward */
2434 /* track operand text backward */
2436 /* 1 if leading '@' ('*') seen */
2438 /* one of " bilsw" */
2440 /* 1 if leading '#' ('$') seen */
2444 /* 1 if () surround register */
2446 /* register number, -1:absent */
2448 /* index register number -1:absent */
2450 /* report illegal operand, ""==OK */
2451 /* " " is a FAKE error: means we won */
2452 /* ANY err that begins with ' ' is a fake. */
2453 /* " " is converted to "" before return */
2455 /* warn about weird modes pf address */
2457 /* preserve q in case we backup */
2459 /* build up 4-bit operand mode here */
2460 /* note: index mode is in ndx, this is */
2461 /* the major mode of operand address */
2464 * Notice how we move wrong-arg-type bugs INSIDE this module: if we
2465 * get the types wrong below, we lose at compile time rather than at
2468 char access_mode
; /* vop_access. */
2469 char width
; /* vop_width. */
2471 access_mode
= vopP
->vop_access
;
2472 width
= vopP
->vop_width
;
2473 /* None of our code bugs (yet), no user text errors, no warnings
2479 if (*p
== ' ') /* Expect all whitespace reduced to ' '. */
2480 p
++; /* skip over whitespace */
2482 if ((at
= INDIRECTP (*p
)) != 0)
2483 { /* 1 if *p=='@'(or '*' for Un*x) */
2484 p
++; /* at is determined */
2485 if (*p
== ' ') /* Expect all whitespace reduced to ' '. */
2486 p
++; /* skip over whitespace */
2490 * This code is subtle. It tries to detect all legal (letter)'^'
2491 * but it doesn't waste time explicitly testing for premature '\0' because
2492 * this case is rejected as a mismatch against either (letter) or '^'.
2499 if (DISPLENP (p
[1]) && strchr ("bilws", len
= c
))
2500 p
+= 2; /* skip (letter) '^' */
2501 else /* no (letter) '^' seen */
2502 len
= ' '; /* len is determined */
2505 if (*p
== ' ') /* Expect all whitespace reduced to ' '. */
2506 p
++; /* skip over whitespace */
2508 if ((hash
= IMMEDIATEP (*p
)) != 0) /* 1 if *p=='#' ('$' for Un*x) */
2509 p
++; /* hash is determined */
2512 * p points to what may be the beginning of an expression.
2513 * We have peeled off the front all that is peelable.
2514 * We know at, len, hash.
2516 * Lets point q at the end of the text and parse that (backwards).
2519 for (q
= p
; *q
; q
++)
2521 q
--; /* now q points at last char of text */
2523 if (*q
== ' ' && q
>= p
) /* Expect all whitespace reduced to ' '. */
2525 /* reverse over whitespace, but don't */
2526 /* run back over *p */
2529 * As a matter of policy here, we look for [Rn], although both Rn and S^#
2530 * forbid [Rn]. This is because it is easy, and because only a sick
2531 * cyborg would have [...] trailing an expression in a VAX-like assembler.
2532 * A meticulous parser would first check for Rn followed by '(' or '['
2533 * and not parse a trailing ']' if it found another. We just ban expressions
2538 while (q
>= p
&& *q
!= '[')
2540 /* either q<p or we got matching '[' */
2542 err
= _("no '[' to match ']'");
2546 * Confusers like "[]" will eventually lose with a bad register
2547 * name error. So again we don't need to check for early '\0'.
2550 ndx
= vax_reg_parse (q
[1], q
[2], 0, 0);
2551 else if (q
[4] == ']')
2552 ndx
= vax_reg_parse (q
[1], q
[2], q
[3], 0);
2553 else if (q
[5] == ']')
2554 ndx
= vax_reg_parse (q
[1], q
[2], q
[3], q
[4]);
2558 * Since we saw a ']' we will demand a register name in the [].
2559 * If luser hasn't given us one: be rude.
2562 err
= _("bad register in []");
2564 err
= _("[PC] index banned");
2566 q
--; /* point q just before "[...]" */
2570 ndx
= -1; /* no ']', so no iNDeX register */
2573 * If err = "..." then we lost: run away.
2574 * Otherwise ndx == -1 if there was no "[...]".
2575 * Otherwise, ndx is index register number, and q points before "[...]".
2578 if (*q
== ' ' && q
>= p
) /* Expect all whitespace reduced to ' '. */
2580 /* reverse over whitespace, but don't */
2581 /* run back over *p */
2584 sign
= 0; /* no ()+ or -() seen yet */
2586 if (q
> p
+ 3 && *q
== '+' && q
[-1] == ')')
2588 sign
= 1; /* we saw a ")+" */
2589 q
--; /* q points to ')' */
2592 if (*q
== ')' && q
> p
+ 2)
2594 paren
= 1; /* assume we have "(...)" */
2595 while (q
>= p
&& *q
!= '(')
2597 /* either q<p or we got matching '(' */
2599 err
= _("no '(' to match ')'");
2603 * Confusers like "()" will eventually lose with a bad register
2604 * name error. So again we don't need to check for early '\0'.
2607 reg
= vax_reg_parse (q
[1], q
[2], 0, 0);
2608 else if (q
[4] == ')')
2609 reg
= vax_reg_parse (q
[1], q
[2], q
[3], 0);
2610 else if (q
[5] == ')')
2611 reg
= vax_reg_parse (q
[1], q
[2], q
[3], q
[4]);
2615 * Since we saw a ')' we will demand a register name in the ')'.
2616 * This is nasty: why can't our hypothetical assembler permit
2617 * parenthesised expressions? BECAUSE I AM LAZY! That is why.
2618 * Abuse luser if we didn't spy a register name.
2622 /* JF allow parenthesized expressions. I hope this works */
2626 /* err = "unknown register in ()"; */
2629 q
--; /* point just before '(' of "(...)" */
2631 * If err == "..." then we lost. Run away.
2632 * Otherwise if reg >= 0 then we saw (Rn).
2636 * If err == "..." then we lost.
2637 * Otherwise paren==1 and reg = register in "()".
2643 * If err == "..." then we lost.
2644 * Otherwise, q points just before "(Rn)", if any.
2645 * If there was a "(...)" then paren==1, and reg is the register.
2649 * We should only seek '-' of "-(...)" if:
2650 * we saw "(...)" paren == 1
2651 * we have no errors so far ! *err
2652 * we did not see '+' of "(...)+" sign < 1
2653 * We don't check len. We want a specific error message later if
2654 * user tries "x^...-(Rn)". This is a feature not a bug.
2658 if (paren
&& sign
< 1)/* !sign is adequate test */
2667 * We have back-tracked over most
2668 * of the crud at the end of an operand.
2669 * Unless err, we know: sign, paren. If paren, we know reg.
2670 * The last case is of an expression "Rn".
2671 * This is worth hunting for if !err, !paren.
2672 * We wouldn't be here if err.
2673 * We remember to save q, in case we didn't want "Rn" anyway.
2677 if (*q
== ' ' && q
>= p
) /* Expect all whitespace reduced to ' '. */
2679 /* reverse over whitespace, but don't */
2680 /* run back over *p */
2681 /* room for Rn or Rnn (include prefix) exactly? */
2682 if (q
> p
&& q
< p
+ 4)
2683 reg
= vax_reg_parse (p
[0], p
[1],
2684 q
< p
+ 2 ? 0 : p
[2],
2685 q
< p
+ 3 ? 0 : p
[3]);
2687 reg
= -1; /* always comes here if no register at all */
2689 * Here with a definitive reg value.
2700 * have reg. -1:absent; else 0:15
2704 * We have: err, at, len, hash, ndx, sign, paren, reg.
2705 * Also, any remaining expression is from *p through *q inclusive.
2706 * Should there be no expression, q==p-1. So expression length = q-p+1.
2707 * This completes the first part: parsing the operand text.
2711 * We now want to boil the data down, checking consistency on the way.
2712 * We want: len, mode, reg, ndx, err, p, q, wrn, bug.
2713 * We will deliver a 4-bit reg, and a 4-bit mode.
2717 * Case of branch operand. Different. No L^B^W^I^S^ allowed for instance.
2731 * p:q whatever was input
2733 * err " " or error message, and other outputs trashed
2735 /* branch operands have restricted forms */
2736 if ((!err
|| !*err
) && access_mode
== 'b')
2738 if (at
|| hash
|| sign
|| paren
|| ndx
>= 0 || reg
>= 0 || len
!= ' ')
2739 err
= _("invalid branch operand");
2744 /* Since nobody seems to use it: comment this 'feature'(?) out for now. */
2747 * Case of stand-alone operand. e.g. ".long foo"
2761 * p:q whatever was input
2763 * err " " or error message, and other outputs trashed
2765 if ((!err
|| !*err
) && access_mode
== ' ')
2768 err
= _("address prohibits @");
2770 err
= _("address prohibits #");
2774 err
= _("address prohibits -()");
2776 err
= _("address prohibits ()+");
2779 err
= _("address prohibits ()");
2781 err
= _("address prohibits []");
2783 err
= _("address prohibits register");
2784 else if (len
!= ' ')
2785 err
= _("address prohibits displacement length specifier");
2788 err
= " "; /* succeed */
2792 #endif /*#Ifdef NEVER*/
2798 * len 's' definition
2800 * p:q demand not empty
2801 * sign 0 by paren==0
2802 * paren 0 by "()" scan logic because "S^" seen
2803 * reg -1 or nn by mistake
2812 if ((!err
|| !*err
) && len
== 's')
2814 if (!hash
|| paren
|| at
|| ndx
>= 0)
2815 err
= _("invalid operand of S^#");
2821 * SHIT! we saw S^#Rnn ! put the Rnn back in
2822 * expression. KLUDGE! Use oldq so we don't
2823 * need to know exact length of reg name.
2829 * We have all the expression we will ever get.
2832 err
= _("S^# needs expression");
2833 else if (access_mode
== 'r')
2835 err
= " "; /* WIN! */
2839 err
= _("S^# may only read-access");
2844 * Case of -(Rn), which is weird case.
2850 * sign -1 by definition
2851 * paren 1 by definition
2852 * reg present by definition
2858 * exp "" enforce empty expression
2859 * ndx optional warn if same as reg
2861 if ((!err
|| !*err
) && sign
< 0)
2863 if (len
!= ' ' || hash
|| at
|| p
<= q
)
2864 err
= _("invalid operand of -()");
2867 err
= " "; /* win */
2870 wrn
= _("-(PC) unpredictable");
2871 else if (reg
== ndx
)
2872 wrn
= _("[]index same as -()register: unpredictable");
2877 * We convert "(Rn)" to "@Rn" for our convenience.
2878 * (I hope this is convenient: has someone got a better way to parse this?)
2879 * A side-effect of this is that "@Rn" is a valid operand.
2881 if (paren
&& !sign
&& !hash
&& !at
&& len
== ' ' && p
> q
)
2888 * Case of (Rn)+, which is slightly different.
2894 * sign +1 by definition
2895 * paren 1 by definition
2896 * reg present by definition
2902 * exp "" enforce empty expression
2903 * ndx optional warn if same as reg
2905 if ((!err
|| !*err
) && sign
> 0)
2907 if (len
!= ' ' || hash
|| p
<= q
)
2908 err
= _("invalid operand of ()+");
2911 err
= " "; /* win */
2912 mode
= 8 + (at
? 1 : 0);
2914 wrn
= _("(PC)+ unpredictable");
2915 else if (reg
== ndx
)
2916 wrn
= _("[]index same as ()+register: unpredictable");
2921 * Case of #, without S^.
2925 * hash 1 by definition
2938 if ((!err
|| !*err
) && hash
)
2940 if (len
!= 'i' && len
!= ' ')
2941 err
= _("# conflicts length");
2943 err
= _("# bars register");
2949 * SHIT! we saw #Rnn! Put the Rnn back into the expression.
2950 * By using oldq, we don't need to know how long Rnn was.
2954 reg
= -1; /* no register any more */
2956 err
= " "; /* win */
2958 /* JF a bugfix, I think! */
2959 if (at
&& access_mode
== 'a')
2960 vopP
->vop_nbytes
= 4;
2962 mode
= (at
? 9 : 8);
2964 if ((access_mode
== 'm' || access_mode
== 'w') && !at
)
2965 wrn
= _("writing or modifying # is unpredictable");
2969 * If !*err, then sign == 0
2974 * Case of Rn. We separate this one because it has a few special
2975 * errors the remaining modes lack.
2979 * hash 0 by program logic
2981 * sign 0 by program logic
2982 * paren 0 by definition
2983 * reg present by definition
2988 * len ' ' enforce no length
2989 * exp "" enforce empty expression
2990 * ndx optional warn if same as reg
2992 if ((!err
|| !*err
) && !paren
&& reg
>= 0)
2995 err
= _("length not needed");
2998 err
= " "; /* win */
3002 err
= _("can't []index a register, because it has no address");
3003 else if (access_mode
== 'a')
3004 err
= _("a register has no address");
3008 * Idea here is to detect from length of datum
3009 * and from register number if we will touch PC.
3011 * vop_nbytes is number of bytes in operand.
3012 * Compute highest byte affected, compare to PC0.
3014 if ((vopP
->vop_nbytes
+ reg
* 4) > 60)
3015 wrn
= _("PC part of operand unpredictable");
3016 err
= " "; /* win */
3021 * If !*err, sign == 0
3023 * paren == 1 OR reg==-1
3027 * Rest of cases fit into one bunch.
3030 * len ' ' or 'b' or 'w' or 'l'
3031 * hash 0 by program logic
3032 * p:q expected (empty is not an error)
3033 * sign 0 by program logic
3038 * out: mode 10 + @ + len
3040 * len ' ' or 'b' or 'w' or 'l'
3042 * ndx optional warn if same as reg
3046 err
= " "; /* win (always) */
3047 mode
= 10 + (at
? 1 : 0);
3054 case ' ': /* assumed B^ until our caller changes it */
3061 * here with completely specified mode
3069 err
= 0; /* " " is no longer an error */
3071 vopP
->vop_mode
= mode
;
3072 vopP
->vop_reg
= reg
;
3073 vopP
->vop_short
= len
;
3074 vopP
->vop_expr_begin
= p
;
3075 vopP
->vop_expr_end
= q
;
3076 vopP
->vop_ndx
= ndx
;
3077 vopP
->vop_error
= err
;
3078 vopP
->vop_warn
= wrn
;
3083 Summary of vip_op outputs.
3087 {@}Rn 5+@ n ' ' optional
3088 branch operand 0 -1 ' ' -1
3090 -(Rn) 7 n ' ' optional
3091 {@}(Rn)+ 8+@ n ' ' optional
3092 {@}#foo, no S^ 8+@ PC " i" optional
3093 {@}{q^}{(Rn)} 10+@+q option " bwl" optional
3097 #ifdef TEST /* #Define to use this testbed. */
3100 * Follows a test program for this function.
3101 * We declare arrays non-local in case some of our tiny-minded machines
3102 * default to small stacks. Also, helps with some debuggers.
3107 char answer
[100]; /* human types into here */
3120 int my_operand_length
;
3121 char my_immediate
[200];
3122 char my_indirect
[200];
3123 char my_displen
[200];
3127 printf ("enter immediate symbols eg enter # ");
3128 gets (my_immediate
);
3129 printf ("enter indirect symbols eg enter @ ");
3131 printf ("enter displen symbols eg enter ^ ");
3133 vip_op_defaults (my_immediate
, my_indirect
, my_displen
);
3136 printf ("access,width (eg 'ab' or 'wh') [empty line to quit] : ");
3140 exit (EXIT_SUCCESS
);
3141 myaccess
= answer
[0];
3142 mywidth
= answer
[1];
3146 my_operand_length
= 1;
3149 my_operand_length
= 8;
3152 my_operand_length
= 4;
3155 my_operand_length
= 16;
3158 my_operand_length
= 32;
3161 my_operand_length
= 4;
3164 my_operand_length
= 16;
3167 my_operand_length
= 8;
3170 my_operand_length
= 2;
3175 my_operand_length
= 0;
3179 my_operand_length
= 2;
3180 printf ("I dn't understand access width %c\n", mywidth
);
3183 printf ("VAX assembler instruction operand: ");
3186 mybug
= vip_op (answer
, myaccess
, mywidth
, my_operand_length
,
3187 &mymode
, &myreg
, &mylen
, &myleft
, &myright
, &myndx
,
3191 printf ("error: \"%s\"\n", myerr
);
3193 printf (" bug: \"%s\"\n", mybug
);
3198 printf ("warning: \"%s\"\n", mywrn
);
3199 mumble ("mode", mymode
);
3200 mumble ("register", myreg
);
3201 mumble ("index", myndx
);
3202 printf ("width:'%c' ", mylen
);
3203 printf ("expression: \"");
3204 while (myleft
<= myright
)
3205 putchar (*myleft
++);
3211 mumble (text
, value
)
3215 printf ("%s:", text
);
3217 printf ("%xx", value
);
3223 #endif /* ifdef TEST */
3227 int md_short_jump_size
= 3;
3228 int md_long_jump_size
= 6;
3229 const int md_reloc_size
= 8; /* Size of relocation record */
3232 md_create_short_jump (ptr
, from_addr
, to_addr
, frag
, to_symbol
)
3235 addressT to_addr ATTRIBUTE_UNUSED
;
3236 fragS
*frag ATTRIBUTE_UNUSED
;
3237 symbolS
*to_symbol ATTRIBUTE_UNUSED
;
3241 /* This former calculation was off by two:
3242 offset = to_addr - (from_addr + 1);
3243 We need to account for the one byte instruction and also its
3244 two byte operand. */
3245 offset
= to_addr
- (from_addr
+ 1 + 2);
3246 *ptr
++ = VAX_BRW
; /* branch with word (16 bit) offset */
3247 md_number_to_chars (ptr
, offset
, 2);
3251 md_create_long_jump (ptr
, from_addr
, to_addr
, frag
, to_symbol
)
3253 addressT from_addr ATTRIBUTE_UNUSED
;
3260 offset
= to_addr
- S_GET_VALUE (to_symbol
);
3261 *ptr
++ = VAX_JMP
; /* arbitrary jump */
3262 *ptr
++ = VAX_ABSOLUTE_MODE
;
3263 md_number_to_chars (ptr
, offset
, 4);
3264 fix_new (frag
, ptr
- frag
->fr_literal
, 4, to_symbol
, (long) 0, 0, NO_RELOC
);
3268 const char *md_shortopts
= "d:STt:V+1h:Hv::";
3269 #elif defined(OBJ_ELF)
3270 const char *md_shortopts
= "d:STt:VkKQ:";
3272 const char *md_shortopts
= "d:STt:V";
3274 struct option md_longopts
[] = {
3276 #define OPTION_PIC (OPTION_MD_BASE)
3277 {"pic", no_argument
, NULL
, OPTION_PIC
},
3279 {NULL
, no_argument
, NULL
, 0}
3281 size_t md_longopts_size
= sizeof (md_longopts
);
3284 md_parse_option (c
, arg
)
3291 as_warn (_("SYMBOL TABLE not implemented"));
3295 as_warn (_("TOKEN TRACE not implemented"));
3299 as_warn (_("Displacement length %s ignored!"), arg
);
3303 as_warn (_("I don't need or use temp. file \"%s\"."), arg
);
3307 as_warn (_("I don't use an interpass file! -V ignored"));
3311 case '+': /* For g++. Hash any name > 31 chars long. */
3312 flag_hash_long_names
= 1;
3315 case '1': /* For backward compatibility */
3319 case 'H': /* Show new symbol after hash truncation */
3320 flag_show_after_trunc
= 1;
3323 case 'h': /* No hashing of mixed-case names */
3325 extern char vms_name_mapping
;
3326 vms_name_mapping
= atoi (arg
);
3327 flag_no_hash_mixed_case
= 1;
3333 extern char *compiler_version_string
;
3334 if (!arg
|| !*arg
|| access (arg
, 0) == 0)
3335 return 0; /* have caller show the assembler version */
3336 compiler_version_string
= arg
;
3345 break; /* -pic, Position Independent Code */
3347 /* -Qy, -Qn: SVR4 arguments controlling whether a .comment
3348 section should be emitted or not. FIXME: Not implemented. */
3361 md_show_usage (stream
)
3364 fprintf (stream
, _("\
3366 -d LENGTH ignored\n\
3373 fprintf (stream
, _("\
3375 -+ hash encode names longer than 31 characters\n\
3376 -1 `const' handling compatible with gcc 1.x\n\
3377 -H show new symbol after hash truncation\n\
3378 -h NUM don't hash mixed-case names, and adjust case:\n\
3379 0 = upper, 2 = lower, 3 = preserve case\n\
3380 -v\"VERSION\" code being assembled was produced by compiler \"VERSION\"\n"));
3384 /* We have no need to default values of symbols. */
3387 md_undefined_symbol (name
)
3388 char *name ATTRIBUTE_UNUSED
;
3393 /* Round up a section size to the appropriate boundary. */
3395 md_section_align (segment
, size
)
3396 segT segment ATTRIBUTE_UNUSED
;
3399 return size
; /* Byte alignment is fine */
3402 /* Exactly what point is a PC-relative offset relative TO?
3403 On the vax, they're relative to the address of the offset, plus
3406 md_pcrel_from (fixP
)
3409 return fixP
->fx_size
+ fixP
->fx_where
+ fixP
->fx_frag
->fr_address
;
3413 #ifndef BFD_ASSEMBLER
3415 tc_headers_hook(headers
)
3416 object_headers
*headers
;
3419 N_SET_INFO(headers
->header
, OMAGIC
, M_VAX4K_NETBSD
, 0);
3420 headers
->header
.a_info
= htonl (headers
->header
.a_info
);
3423 #endif /* !BFD_ASSEMBLER */
3424 #endif /* OBJ_AOUT */
3426 #ifdef BFD_ASSEMBLER
3428 tc_gen_reloc (section
, fixp
)
3429 asection
*section ATTRIBUTE_UNUSED
;
3433 bfd_reloc_code_real_type code
;
3438 if (fixp
->fx_r_type
!= BFD_RELOC_NONE
)
3440 code
= fixp
->fx_r_type
;
3446 case BFD_RELOC_8_PCREL
:
3447 case BFD_RELOC_16_PCREL
:
3448 case BFD_RELOC_32_PCREL
:
3450 case BFD_RELOC_8_GOT_PCREL
:
3451 case BFD_RELOC_16_GOT_PCREL
:
3452 case BFD_RELOC_32_GOT_PCREL
:
3453 case BFD_RELOC_8_PLT_PCREL
:
3454 case BFD_RELOC_16_PLT_PCREL
:
3455 case BFD_RELOC_32_PLT_PCREL
:
3459 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
3460 _("Cannot make %s relocation PC relative"),
3461 bfd_get_reloc_code_name (code
));
3467 #define F(SZ,PCREL) (((SZ) << 1) + (PCREL))
3468 switch (F (fixp
->fx_size
, fixp
->fx_pcrel
))
3470 #define MAP(SZ,PCREL,TYPE) case F(SZ,PCREL): code = (TYPE); break
3471 MAP (1, 0, BFD_RELOC_8
);
3472 MAP (2, 0, BFD_RELOC_16
);
3473 MAP (4, 0, BFD_RELOC_32
);
3474 MAP (1, 1, BFD_RELOC_8_PCREL
);
3475 MAP (2, 1, BFD_RELOC_16_PCREL
);
3476 MAP (4, 1, BFD_RELOC_32_PCREL
);
3484 reloc
= (arelent
*) xmalloc (sizeof (arelent
));
3485 reloc
->sym_ptr_ptr
= (asymbol
**) xmalloc (sizeof (asymbol
*));
3486 *reloc
->sym_ptr_ptr
= symbol_get_bfdsym (fixp
->fx_addsy
);
3487 reloc
->address
= fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
3490 reloc
->addend
= fixp
->fx_addnumber
;
3494 reloc
->addend
= fixp
->fx_offset
;
3497 reloc
->howto
= bfd_reloc_type_lookup (stdoutput
, code
);
3498 assert (reloc
->howto
!= 0);
3502 #endif /* BFD_ASSEMBLER */
3504 /* end of tc-vax.c */