1 /* tc-vax.c - vax-specific -
2 Copyright (C) 1987-2020 Free Software Foundation, Inc.
4 This file is part of GAS, the GNU Assembler.
6 GAS is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3, or (at your option)
11 GAS is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GAS; see the file COPYING. If not, write to the Free
18 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
24 #include "obstack.h" /* For FRAG_APPEND_1_CHAR macro in "frags.h" */
26 #include "safe-ctype.h"
32 /* These chars start a comment anywhere in a source file (except inside
34 const char comment_chars
[] = "#";
36 /* These chars only start a comment at the beginning of a line. */
37 /* Note that for the VAX the are the same as comment_chars above. */
38 const char line_comment_chars
[] = "#";
40 const char line_separator_chars
[] = ";";
42 /* Chars that can be used to separate mant from exp in floating point nums. */
43 const char EXP_CHARS
[] = "eE";
45 /* Chars that mean this number is a floating point constant
47 or 0H1.234E-12 (see exp chars above). */
48 const char FLT_CHARS
[] = "dDfFgGhH";
50 /* Also be aware that MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT may have to be
51 changed in read.c . Ideally it shouldn't have to know about it at all,
52 but nothing is ideal around here. */
54 /* Hold details of an operand expression. */
55 static expressionS exp_of_operand
[VIT_MAX_OPERANDS
];
56 static segT seg_of_operand
[VIT_MAX_OPERANDS
];
58 /* A vax instruction after decoding. */
61 /* Hold details of big operands. */
62 LITTLENUM_TYPE big_operand_bits
[VIT_MAX_OPERANDS
][SIZE_OF_LARGE_NUMBER
];
63 FLONUM_TYPE float_operand
[VIT_MAX_OPERANDS
];
64 /* Above is made to point into big_operand_bits by md_begin(). */
67 #define GLOBAL_OFFSET_TABLE_NAME "_GLOBAL_OFFSET_TABLE_"
68 #define PROCEDURE_LINKAGE_TABLE_NAME "_PROCEDURE_LINKAGE_TABLE_"
69 symbolS
*GOT_symbol
; /* Pre-defined "_GLOBAL_OFFSET_TABLE_". */
70 symbolS
*PLT_symbol
; /* Pre-defined "_PROCEDURE_LINKAGE_TABLE_". */
73 int flag_hash_long_names
; /* -+ */
74 int flag_one
; /* -1 */
75 int flag_show_after_trunc
; /* -H */
76 int flag_no_hash_mixed_case
; /* -h NUM */
78 int flag_want_pic
; /* -k */
81 /* For VAX, relative addresses of "just the right length" are easy.
82 The branch displacement is always the last operand, even in
83 synthetic instructions.
84 For VAX, we encode the relax_substateTs (in e.g. fr_substate) as:
87 ---/ /--+-------+-------+-------+-------+-------+
88 | what state ? | how long ? |
89 ---/ /--+-------+-------+-------+-------+-------+
91 The "how long" bits are 00=byte, 01=word, 10=long.
92 This is a Un*x convention.
93 Not all lengths are legit for a given value of (what state).
94 The "how long" refers merely to the displacement length.
95 The address usually has some constant bytes in it as well.
97 groups for VAX address relaxing.
100 length of byte, word, long
102 2a. J<cond> where <cond> is a simple flag test.
103 length of byte, word, long.
104 VAX opcodes are: (Hex)
117 Always, you complement 0th bit to reverse condition.
118 Always, 1-byte opcode, then 1-byte displacement.
120 2b. J<cond> where cond tests a memory bit.
121 length of byte, word, long.
122 Vax opcodes are: (Hex)
129 Always, you complement 0th bit to reverse condition.
130 Always, 1-byte opcode, longword-address, byte-address, 1-byte-displacement
132 2c. J<cond> where cond tests low-order memory bit
133 length of byte,word,long.
134 Vax opcodes are: (Hex)
137 Always, you complement 0th bit to reverse condition.
138 Always, 1-byte opcode, longword-address, 1-byte displacement.
141 length of byte,word,long.
142 Vax opcodes are: (Hex)
145 These are like (2) but there is no condition to reverse.
146 Always, 1 byte opcode, then displacement/absolute.
149 length of word, long.
150 Vax opcodes are: (Hex)
158 Always, we cannot reverse the sense of the branch; we have a word
160 The double-byte op-codes don't hurt: we never want to modify the
161 opcode, so we don't care how many bytes are between the opcode and
165 length of long, long, byte.
166 Vax opcodes are: (Hex)
171 Always, we cannot reverse the sense of the branch; we have a byte
174 The only time we need to modify the opcode is for class 2 instructions.
175 After relax() we may complement the lowest order bit of such instruction
176 to reverse sense of branch.
178 For class 2 instructions, we store context of "where is the opcode literal".
179 We can change an opcode's lowest order bit without breaking anything else.
181 We sometimes store context in the operand literal. This way we can figure out
182 after relax() what the original addressing mode was. */
184 /* These displacements are relative to the start address of the
185 displacement. The first letter is Byte, Word. 2nd letter is
186 Forward, Backward. */
189 #define WF (2+ 32767)
190 #define WB (2+-32768)
191 /* Don't need LF, LB because they always reach. [They are coded as 0.] */
193 #define C(a,b) ENCODE_RELAX(a,b)
194 /* This macro has no side-effects. */
195 #define ENCODE_RELAX(what,length) (((what) << 2) + (length))
196 #define RELAX_STATE(s) ((s) >> 2)
197 #define RELAX_LENGTH(s) ((s) & 3)
199 const relax_typeS md_relax_table
[] =
201 {1, 1, 0, 0}, /* error sentinel 0,0 */
202 {1, 1, 0, 0}, /* unused 0,1 */
203 {1, 1, 0, 0}, /* unused 0,2 */
204 {1, 1, 0, 0}, /* unused 0,3 */
206 {BF
+ 1, BB
+ 1, 2, C (1, 1)},/* B^"foo" 1,0 */
207 {WF
+ 1, WB
+ 1, 3, C (1, 2)},/* W^"foo" 1,1 */
208 {0, 0, 5, 0}, /* L^"foo" 1,2 */
209 {1, 1, 0, 0}, /* unused 1,3 */
211 {BF
, BB
, 1, C (2, 1)}, /* b<cond> B^"foo" 2,0 */
212 {WF
+ 2, WB
+ 2, 4, C (2, 2)},/* br.+? brw X 2,1 */
213 {0, 0, 7, 0}, /* br.+? jmp X 2,2 */
214 {1, 1, 0, 0}, /* unused 2,3 */
216 {BF
, BB
, 1, C (3, 1)}, /* brb B^foo 3,0 */
217 {WF
, WB
, 2, C (3, 2)}, /* brw W^foo 3,1 */
218 {0, 0, 5, 0}, /* Jmp L^foo 3,2 */
219 {1, 1, 0, 0}, /* unused 3,3 */
221 {1, 1, 0, 0}, /* unused 4,0 */
222 {WF
, WB
, 2, C (4, 2)}, /* acb_ ^Wfoo 4,1 */
223 {0, 0, 10, 0}, /* acb_,br,jmp L^foo4,2 */
224 {1, 1, 0, 0}, /* unused 4,3 */
226 {BF
, BB
, 1, C (5, 1)}, /* Xob___,,foo 5,0 */
227 {WF
+ 4, WB
+ 4, 6, C (5, 2)},/* Xob.+2,brb.+3,brw5,1 */
228 {0, 0, 9, 0}, /* Xob.+2,brb.+6,jmp5,2 */
229 {1, 1, 0, 0}, /* unused 5,3 */
238 void float_cons (int);
239 int flonum_gen2vax (int, FLONUM_TYPE
*, LITTLENUM_TYPE
*);
241 const pseudo_typeS md_pseudo_table
[] =
243 {"dfloat", float_cons
, 'd'},
244 {"ffloat", float_cons
, 'f'},
245 {"gfloat", float_cons
, 'g'},
246 {"hfloat", float_cons
, 'h'},
247 {"d_floating", float_cons
, 'd'},
248 {"f_floating", float_cons
, 'f'},
249 {"g_floating", float_cons
, 'g'},
250 {"h_floating", float_cons
, 'h'},
254 #define STATE_PC_RELATIVE (1)
255 #define STATE_CONDITIONAL_BRANCH (2)
256 #define STATE_ALWAYS_BRANCH (3) /* includes BSB... */
257 #define STATE_COMPLEX_BRANCH (4)
258 #define STATE_COMPLEX_HOP (5)
260 #define STATE_BYTE (0)
261 #define STATE_WORD (1)
262 #define STATE_LONG (2)
263 #define STATE_UNDF (3) /* Symbol undefined in pass1. */
265 #define min(a, b) ((a) < (b) ? (a) : (b))
268 md_number_to_chars (char con
[], valueT value
, int nbytes
)
270 number_to_chars_littleendian (con
, value
, nbytes
);
273 /* Fix up some data or instructions after we find out the value of a symbol
274 that they reference. */
276 void /* Knows about order of bytes in address. */
277 md_apply_fix (fixS
*fixP
, valueT
*valueP
, segT seg ATTRIBUTE_UNUSED
)
279 valueT value
= * valueP
;
281 if (fixP
->fx_subsy
!= (symbolS
*) NULL
)
282 as_bad_where (fixP
->fx_file
, fixP
->fx_line
, _("expression too complex"));
284 if (fixP
->fx_addsy
== NULL
)
288 number_to_chars_littleendian (fixP
->fx_where
+ fixP
->fx_frag
->fr_literal
,
289 value
, fixP
->fx_size
);
291 /* Initialise the part of an instruction frag covered by the
292 relocation. (Many occurrences of frag_more followed by fix_new
293 lack any init of the frag.) Since VAX uses RELA relocs the
294 value we write into this field doesn't really matter. */
295 memset (fixP
->fx_where
+ fixP
->fx_frag
->fr_literal
, 0, fixP
->fx_size
);
298 /* Convert a number from VAX byte order (little endian)
299 into host byte order.
300 con is the buffer to convert,
301 nbytes is the length of the given buffer. */
303 md_chars_to_number (unsigned char con
[], int nbytes
)
307 for (retval
= 0, con
+= nbytes
- 1; nbytes
--; con
--)
309 retval
<<= BITS_PER_CHAR
;
315 /* Copy a bignum from in to out.
316 If the output is shorter than the input, copy lower-order
317 littlenums. Return 0 or the number of significant littlenums
318 dropped. Assumes littlenum arrays are densely packed: no unused
319 chars between the littlenums. Uses memcpy() to move littlenums, and
320 wants to know length (in chars) of the input bignum. */
323 bignum_copy (LITTLENUM_TYPE
*in
,
324 int in_length
, /* in sizeof(littlenum)s */
326 int out_length
/* in sizeof(littlenum)s */)
328 int significant_littlenums_dropped
;
330 if (out_length
< in_length
)
332 LITTLENUM_TYPE
*p
; /* -> most significant (non-zero) input
335 memcpy ((void *) out
, (void *) in
,
336 (unsigned int) out_length
<< LITTLENUM_SHIFT
);
337 for (p
= in
+ in_length
- 1; p
>= in
; --p
)
342 significant_littlenums_dropped
= p
- in
- in_length
+ 1;
344 if (significant_littlenums_dropped
< 0)
345 significant_littlenums_dropped
= 0;
349 memcpy ((char *) out
, (char *) in
,
350 (unsigned int) in_length
<< LITTLENUM_SHIFT
);
352 if (out_length
> in_length
)
353 memset ((char *) (out
+ in_length
), '\0',
354 (unsigned int) (out_length
- in_length
) << LITTLENUM_SHIFT
);
356 significant_littlenums_dropped
= 0;
359 return significant_littlenums_dropped
;
362 /* md_estimate_size_before_relax(), called just before relax().
363 Any symbol that is now undefined will not become defined.
364 Return the correct fr_subtype in the frag and the growth beyond
367 md_estimate_size_before_relax (fragS
*fragP
, segT segment
)
369 if (RELAX_LENGTH (fragP
->fr_subtype
) == STATE_UNDF
)
371 if (S_GET_SEGMENT (fragP
->fr_symbol
) != segment
373 || S_IS_WEAK (fragP
->fr_symbol
)
374 || S_IS_EXTERNAL (fragP
->fr_symbol
)
378 /* Non-relaxable cases. */
379 int reloc_type
= NO_RELOC
;
383 old_fr_fix
= fragP
->fr_fix
;
384 p
= &fragP
->fr_literal
[0] + old_fr_fix
;
386 /* If this is to an undefined symbol, then if it's an indirect
387 reference indicate that is can mutated into a GLOB_DAT or
388 JUMP_SLOT by the loader. We restrict ourselves to no offset
389 due to a limitation in the NetBSD linker. */
391 if (GOT_symbol
== NULL
)
392 GOT_symbol
= symbol_find (GLOBAL_OFFSET_TABLE_NAME
);
393 if (PLT_symbol
== NULL
)
394 PLT_symbol
= symbol_find (PROCEDURE_LINKAGE_TABLE_NAME
);
395 if ((GOT_symbol
== NULL
|| fragP
->fr_symbol
!= GOT_symbol
)
396 && (PLT_symbol
== NULL
|| fragP
->fr_symbol
!= PLT_symbol
)
397 && fragP
->fr_symbol
!= NULL
399 && (!S_IS_DEFINED (fragP
->fr_symbol
)
400 || S_IS_WEAK (fragP
->fr_symbol
)
401 || S_IS_EXTERNAL (fragP
->fr_symbol
)))
403 /* Indirect references cannot go through the GOT or PLT,
404 let's hope they'll become local in the final link. */
405 if ((ELF_ST_VISIBILITY (S_GET_OTHER (fragP
->fr_symbol
))
408 reloc_type
= BFD_RELOC_32_PCREL
;
409 else if (((unsigned char *) fragP
->fr_opcode
)[0] == VAX_CALLS
410 || ((unsigned char *) fragP
->fr_opcode
)[0] == VAX_CALLG
411 || ((unsigned char *) fragP
->fr_opcode
)[0] == VAX_JSB
412 || ((unsigned char *) fragP
->fr_opcode
)[0] == VAX_JMP
413 || S_IS_FUNCTION (fragP
->fr_symbol
))
414 reloc_type
= BFD_RELOC_32_PLT_PCREL
;
416 reloc_type
= BFD_RELOC_32_GOT_PCREL
;
419 switch (RELAX_STATE (fragP
->fr_subtype
))
421 case STATE_PC_RELATIVE
:
422 p
[0] |= VAX_PC_RELATIVE_MODE
; /* Preserve @ bit. */
423 fragP
->fr_fix
+= 1 + 4;
424 fix_new (fragP
, old_fr_fix
+ 1, 4, fragP
->fr_symbol
,
425 fragP
->fr_offset
, 1, reloc_type
);
428 case STATE_CONDITIONAL_BRANCH
:
429 *fragP
->fr_opcode
^= 1; /* Reverse sense of branch. */
432 p
[2] = VAX_PC_RELATIVE_MODE
; /* ...(PC) */
433 fragP
->fr_fix
+= 1 + 1 + 1 + 4;
434 fix_new (fragP
, old_fr_fix
+ 3, 4, fragP
->fr_symbol
,
435 fragP
->fr_offset
, 1, NO_RELOC
);
438 case STATE_COMPLEX_BRANCH
:
444 p
[5] = VAX_PC_RELATIVE_MODE
; /* ...(pc) */
445 fragP
->fr_fix
+= 2 + 2 + 1 + 1 + 4;
446 fix_new (fragP
, old_fr_fix
+ 6, 4, fragP
->fr_symbol
,
447 fragP
->fr_offset
, 1, NO_RELOC
);
450 case STATE_COMPLEX_HOP
:
455 p
[4] = VAX_PC_RELATIVE_MODE
; /* ...(pc) */
456 fragP
->fr_fix
+= 1 + 2 + 1 + 1 + 4;
457 fix_new (fragP
, old_fr_fix
+ 5, 4, fragP
->fr_symbol
,
458 fragP
->fr_offset
, 1, NO_RELOC
);
461 case STATE_ALWAYS_BRANCH
:
462 *fragP
->fr_opcode
+= VAX_WIDEN_LONG
;
463 p
[0] = VAX_PC_RELATIVE_MODE
; /* ...(PC) */
464 fragP
->fr_fix
+= 1 + 4;
465 fix_new (fragP
, old_fr_fix
+ 1, 4, fragP
->fr_symbol
,
466 fragP
->fr_offset
, 1, NO_RELOC
);
474 /* Return the growth in the fixed part of the frag. */
475 return fragP
->fr_fix
- old_fr_fix
;
478 /* Relaxable cases. Set up the initial guess for the variable
480 switch (RELAX_STATE (fragP
->fr_subtype
))
482 case STATE_PC_RELATIVE
:
483 fragP
->fr_subtype
= ENCODE_RELAX (STATE_PC_RELATIVE
, STATE_BYTE
);
485 case STATE_CONDITIONAL_BRANCH
:
486 fragP
->fr_subtype
= ENCODE_RELAX (STATE_CONDITIONAL_BRANCH
, STATE_BYTE
);
488 case STATE_COMPLEX_BRANCH
:
489 fragP
->fr_subtype
= ENCODE_RELAX (STATE_COMPLEX_BRANCH
, STATE_WORD
);
491 case STATE_COMPLEX_HOP
:
492 fragP
->fr_subtype
= ENCODE_RELAX (STATE_COMPLEX_HOP
, STATE_BYTE
);
494 case STATE_ALWAYS_BRANCH
:
495 fragP
->fr_subtype
= ENCODE_RELAX (STATE_ALWAYS_BRANCH
, STATE_BYTE
);
500 if (fragP
->fr_subtype
>= sizeof (md_relax_table
) / sizeof (md_relax_table
[0]))
503 /* Return the size of the variable part of the frag. */
504 return md_relax_table
[fragP
->fr_subtype
].rlx_length
;
507 /* Called after relax() is finished.
509 fr_type == rs_machine_dependent.
510 fr_subtype is what the address relaxed to.
512 Out: Any fixSs and constants are set up.
513 Caller will turn frag into a ".space 0". */
515 md_convert_frag (bfd
*headers ATTRIBUTE_UNUSED
,
516 segT seg ATTRIBUTE_UNUSED
,
519 char *addressP
; /* -> _var to change. */
520 char *opcodeP
; /* -> opcode char(s) to change. */
521 short int extension
= 0; /* Size of relaxed address. */
522 /* Added to fr_fix: incl. ALL var chars. */
526 know (fragP
->fr_type
== rs_machine_dependent
);
527 where
= fragP
->fr_fix
;
528 addressP
= &fragP
->fr_literal
[0] + where
;
529 opcodeP
= fragP
->fr_opcode
;
530 symbolP
= fragP
->fr_symbol
;
533 switch (fragP
->fr_subtype
)
535 case ENCODE_RELAX (STATE_PC_RELATIVE
, STATE_BYTE
):
536 know (*addressP
== 0 || *addressP
== 0x10); /* '@' bit. */
537 addressP
[0] |= 0xAF; /* Byte displacement. */
538 fix_new (fragP
, fragP
->fr_fix
+ 1, 1, fragP
->fr_symbol
,
539 fragP
->fr_offset
, 1, NO_RELOC
);
543 case ENCODE_RELAX (STATE_PC_RELATIVE
, STATE_WORD
):
544 know (*addressP
== 0 || *addressP
== 0x10); /* '@' bit. */
545 addressP
[0] |= 0xCF; /* Word displacement. */
546 fix_new (fragP
, fragP
->fr_fix
+ 1, 2, fragP
->fr_symbol
,
547 fragP
->fr_offset
, 1, NO_RELOC
);
551 case ENCODE_RELAX (STATE_PC_RELATIVE
, STATE_LONG
):
552 know (*addressP
== 0 || *addressP
== 0x10); /* '@' bit. */
553 addressP
[0] |= 0xEF; /* Long word displacement. */
554 fix_new (fragP
, fragP
->fr_fix
+ 1, 4, fragP
->fr_symbol
,
555 fragP
->fr_offset
, 1, NO_RELOC
);
559 case ENCODE_RELAX (STATE_CONDITIONAL_BRANCH
, STATE_BYTE
):
560 fix_new (fragP
, fragP
->fr_fix
, 1, fragP
->fr_symbol
,
561 fragP
->fr_offset
, 1, NO_RELOC
);
565 case ENCODE_RELAX (STATE_CONDITIONAL_BRANCH
, STATE_WORD
):
566 opcodeP
[0] ^= 1; /* Reverse sense of test. */
568 addressP
[1] = VAX_BRW
;
569 fix_new (fragP
, fragP
->fr_fix
+ 2, 2, fragP
->fr_symbol
,
570 fragP
->fr_offset
, 1, NO_RELOC
);
574 case ENCODE_RELAX (STATE_CONDITIONAL_BRANCH
, STATE_LONG
):
575 opcodeP
[0] ^= 1; /* Reverse sense of test. */
577 addressP
[1] = VAX_JMP
;
578 addressP
[2] = VAX_PC_RELATIVE_MODE
;
579 fix_new (fragP
, fragP
->fr_fix
+ 3, 4, fragP
->fr_symbol
,
580 fragP
->fr_offset
, 1, NO_RELOC
);
584 case ENCODE_RELAX (STATE_ALWAYS_BRANCH
, STATE_BYTE
):
585 fix_new (fragP
, fragP
->fr_fix
, 1, fragP
->fr_symbol
,
586 fragP
->fr_offset
, 1, NO_RELOC
);
590 case ENCODE_RELAX (STATE_ALWAYS_BRANCH
, STATE_WORD
):
591 opcodeP
[0] += VAX_WIDEN_WORD
; /* brb -> brw, bsbb -> bsbw */
592 fix_new (fragP
, fragP
->fr_fix
, 2, fragP
->fr_symbol
, fragP
->fr_offset
,
597 case ENCODE_RELAX (STATE_ALWAYS_BRANCH
, STATE_LONG
):
598 opcodeP
[0] += VAX_WIDEN_LONG
; /* brb -> jmp, bsbb -> jsb */
599 addressP
[0] = VAX_PC_RELATIVE_MODE
;
600 fix_new (fragP
, fragP
->fr_fix
+ 1, 4, fragP
->fr_symbol
,
601 fragP
->fr_offset
, 1, NO_RELOC
);
605 case ENCODE_RELAX (STATE_COMPLEX_BRANCH
, STATE_WORD
):
606 fix_new (fragP
, fragP
->fr_fix
, 2, fragP
->fr_symbol
,
607 fragP
->fr_offset
, 1, NO_RELOC
);
611 case ENCODE_RELAX (STATE_COMPLEX_BRANCH
, STATE_LONG
):
614 addressP
[2] = VAX_BRB
;
616 addressP
[4] = VAX_JMP
;
617 addressP
[5] = VAX_PC_RELATIVE_MODE
;
618 fix_new (fragP
, fragP
->fr_fix
+ 6, 4, fragP
->fr_symbol
,
619 fragP
->fr_offset
, 1, NO_RELOC
);
623 case ENCODE_RELAX (STATE_COMPLEX_HOP
, STATE_BYTE
):
624 fix_new (fragP
, fragP
->fr_fix
, 1, fragP
->fr_symbol
,
625 fragP
->fr_offset
, 1, NO_RELOC
);
629 case ENCODE_RELAX (STATE_COMPLEX_HOP
, STATE_WORD
):
631 addressP
[1] = VAX_BRB
;
633 addressP
[3] = VAX_BRW
;
634 fix_new (fragP
, fragP
->fr_fix
+ 4, 2, fragP
->fr_symbol
,
635 fragP
->fr_offset
, 1, NO_RELOC
);
639 case ENCODE_RELAX (STATE_COMPLEX_HOP
, STATE_LONG
):
641 addressP
[1] = VAX_BRB
;
643 addressP
[3] = VAX_JMP
;
644 addressP
[4] = VAX_PC_RELATIVE_MODE
;
645 fix_new (fragP
, fragP
->fr_fix
+ 5, 4, fragP
->fr_symbol
,
646 fragP
->fr_offset
, 1, NO_RELOC
);
651 BAD_CASE (fragP
->fr_subtype
);
654 fragP
->fr_fix
+= extension
;
657 /* Translate internal format of relocation info into target format.
659 On vax: first 4 bytes are normal unsigned long, next three bytes
660 are symbolnum, least sig. byte first. Last byte is broken up with
661 the upper nibble as nuthin, bit 3 as extern, bits 2 & 1 as length, and
665 md_ri_to_chars (char *the_bytes
, struct reloc_info_generic ri
)
668 md_number_to_chars (the_bytes
, ri
.r_address
, sizeof (ri
.r_address
));
669 /* Now the fun stuff. */
670 the_bytes
[6] = (ri
.r_symbolnum
>> 16) & 0x0ff;
671 the_bytes
[5] = (ri
.r_symbolnum
>> 8) & 0x0ff;
672 the_bytes
[4] = ri
.r_symbolnum
& 0x0ff;
673 the_bytes
[7] = (((ri
.r_extern
<< 3) & 0x08) | ((ri
.r_length
<< 1) & 0x06)
674 | ((ri
.r_pcrel
<< 0) & 0x01)) & 0x0F;
679 /* BUGS, GRIPES, APOLOGIA, etc.
681 The opcode table 'votstrs' needs to be sorted on opcode frequency.
682 That is, AFTER we hash it with hash_...(), we want most-used opcodes
683 to come out of the hash table faster.
685 I am sorry to inflict yet another VAX assembler on the world, but
686 RMS says we must do everything from scratch, to prevent pin-heads
687 restricting this software.
689 This is a vaguely modular set of routines in C to parse VAX
690 assembly code using DEC mnemonics. It is NOT un*x specific.
692 The idea here is that the assembler has taken care of all:
699 condensing any whitespace down to exactly one space
700 and all we have to do is parse 1 line into a vax instruction
701 partially formed. We will accept a line, and deliver:
702 an error message (hopefully empty)
703 a skeleton VAX instruction (tree structure)
704 textual pointers to all the operand expressions
705 a warning message that notes a silly operand (hopefully empty)
707 E D I T H I S T O R Y
709 17may86 Dean Elsner. Bug if line ends immediately after opcode.
710 30apr86 Dean Elsner. New vip_op() uses arg block so change call.
711 6jan86 Dean Elsner. Crock vip_begin() to call vip_op_defaults().
712 2jan86 Dean Elsner. Invent synthetic opcodes.
713 Widen vax_opcodeT to 32 bits. Use a bit for VIT_OPCODE_SYNTHETIC,
714 which means this is not a real opcode, it is like a macro; it will
715 be relax()ed into 1 or more instructions.
716 Use another bit for VIT_OPCODE_SPECIAL if the op-code is not optimised
717 like a regular branch instruction. Option added to vip_begin():
718 exclude synthetic opcodes. Invent synthetic_votstrs[].
719 31dec85 Dean Elsner. Invent vit_opcode_nbytes.
720 Also make vit_opcode into a char[]. We now have n-byte vax opcodes,
721 so caller's don't have to know the difference between a 1-byte & a
722 2-byte op-code. Still need vax_opcodeT concept, so we know how
723 big an object must be to hold an op.code.
724 30dec85 Dean Elsner. Widen typedef vax_opcodeT in "vax-inst.h"
725 because vax opcodes may be 16 bits. Our crufty C compiler was
726 happily initialising 8-bit vot_codes with 16-bit numbers!
727 (Wouldn't the 'phone company like to compress data so easily!)
728 29dec85 Dean Elsner. New static table vax_operand_width_size[].
729 Invented so we know hw many bytes a "I^#42" needs in its immediate
730 operand. Revised struct vop in "vax-inst.h": explicitly include
731 byte length of each operand, and it's letter-code datum type.
732 17nov85 Dean Elsner. Name Change.
733 Due to ar(1) truncating names, we learned the hard way that
734 "vax-inst-parse.c" -> "vax-inst-parse." dropping the "o" off
735 the archived object name. SO... we shortened the name of this
736 source file, and changed the makefile. */
738 /* Handle of the OPCODE hash table. */
739 static htab_t op_hash
;
741 /* In: 1 character, from "bdfghloqpw" being the data-type of an operand
742 of a vax instruction.
744 Out: the length of an operand of that type, in bytes.
745 Special branch operands types "-?!" have length 0. */
747 static const short int vax_operand_width_size
[256] =
749 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
750 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
751 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
752 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
753 0, 0, 1, 0, 8, 0, 4, 8, 16, 0, 0, 0, 4, 0, 0,16, /* ..b.d.fgh...l..o */
754 0, 8, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, /* .q.....w........ */
755 0, 0, 1, 0, 8, 0, 4, 8, 16, 0, 0, 0, 4, 0, 0,16, /* ..b.d.fgh...l..o */
756 0, 8, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, /* .q.....w........ */
757 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
758 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
759 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
760 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
761 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
762 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
763 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
764 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
767 /* This perversion encodes all the vax opcodes as a bunch of strings.
768 RMS says we should build our hash-table at run-time. Hmm.
769 Please would someone arrange these in decreasing frequency of opcode?
770 Because of the way hash_...() works, the most frequently used opcode
771 should be textually first and so on.
773 Input for this table was 'vax.opcodes', awk(1)ed by 'vax.opcodes.c.awk' .
774 So change 'vax.opcodes', then re-generate this table. */
776 #include "opcode/vax.h"
778 /* This is a table of optional op-codes. All of them represent
779 'synthetic' instructions that seem popular.
781 Here we make some pseudo op-codes. Every code has a bit set to say
782 it is synthetic. This lets you catch them if you want to
783 ban these opcodes. They are mnemonics for "elastic" instructions
784 that are supposed to assemble into the fewest bytes needed to do a
785 branch, or to do a conditional branch, or whatever.
787 The opcode is in the usual place [low-order n*8 bits]. This means
788 that if you mask off the bucky bits, the usual rules apply about
789 how long the opcode is.
791 All VAX branch displacements come at the end of the instruction.
792 For simple branches (1-byte opcode + 1-byte displacement) the last
793 operand is coded 'b?' where the "data type" '?' is a clue that we
794 may reverse the sense of the branch (complement lowest order bit)
795 and branch around a jump. This is by far the most common case.
796 That is why the VIT_OPCODE_SYNTHETIC bit is set: it says this is
797 a 0-byte op-code followed by 2 or more bytes of operand address.
799 If the op-code has VIT_OPCODE_SPECIAL set, then we have a more unusual
802 For JBSB & JBR the treatment is the similar, except (1) we have a 'bw'
803 option before (2) we can directly JSB/JMP because there is no condition.
804 These operands have 'b-' as their access/data type.
806 That leaves a bunch of random opcodes: JACBx, JxOBxxx. In these
807 cases, we do the same idea. JACBxxx are all marked with a 'b!'
808 JAOBxxx & JSOBxxx are marked with a 'b:'. */
809 #if (VIT_OPCODE_SYNTHETIC != 0x80000000)
810 #error "You have just broken the encoding below, which assumes the sign bit means 'I am an imaginary instruction'."
813 #if (VIT_OPCODE_SPECIAL != 0x40000000)
814 #error "You have just broken the encoding below, which assumes the 0x40 M bit means 'I am not to be "optimised" the way normal branches are'."
817 static const struct vot
818 synthetic_votstrs
[] =
820 {"jbsb", {"b-", 0xC0000010}}, /* BSD 4.2 */
821 /* jsb used already */
822 {"jbr", {"b-", 0xC0000011}}, /* BSD 4.2 */
823 {"jr", {"b-", 0xC0000011}}, /* consistent */
824 {"jneq", {"b?", 0x80000012}},
825 {"jnequ", {"b?", 0x80000012}},
826 {"jeql", {"b?", 0x80000013}},
827 {"jeqlu", {"b?", 0x80000013}},
828 {"jgtr", {"b?", 0x80000014}},
829 {"jleq", {"b?", 0x80000015}},
830 /* un-used opcodes here */
831 {"jgeq", {"b?", 0x80000018}},
832 {"jlss", {"b?", 0x80000019}},
833 {"jgtru", {"b?", 0x8000001a}},
834 {"jlequ", {"b?", 0x8000001b}},
835 {"jvc", {"b?", 0x8000001c}},
836 {"jvs", {"b?", 0x8000001d}},
837 {"jgequ", {"b?", 0x8000001e}},
838 {"jcc", {"b?", 0x8000001e}},
839 {"jlssu", {"b?", 0x8000001f}},
840 {"jcs", {"b?", 0x8000001f}},
842 {"jacbw", {"rwrwmwb!", 0xC000003d}},
843 {"jacbf", {"rfrfmfb!", 0xC000004f}},
844 {"jacbd", {"rdrdmdb!", 0xC000006f}},
845 {"jacbb", {"rbrbmbb!", 0xC000009d}},
846 {"jacbl", {"rlrlmlb!", 0xC00000f1}},
847 {"jacbg", {"rgrgmgb!", 0xC0004ffd}},
848 {"jacbh", {"rhrhmhb!", 0xC0006ffd}},
850 {"jbs", {"rlvbb?", 0x800000e0}},
851 {"jbc", {"rlvbb?", 0x800000e1}},
852 {"jbss", {"rlvbb?", 0x800000e2}},
853 {"jbcs", {"rlvbb?", 0x800000e3}},
854 {"jbsc", {"rlvbb?", 0x800000e4}},
855 {"jbcc", {"rlvbb?", 0x800000e5}},
856 {"jbssi", {"rlvbb?", 0x800000e6}},
857 {"jbcci", {"rlvbb?", 0x800000e7}},
858 {"jlbs", {"rlb?", 0x800000e8}},
859 {"jlbc", {"rlb?", 0x800000e9}},
861 {"jaoblss", {"rlmlb:", 0xC00000f2}},
862 {"jaobleq", {"rlmlb:", 0xC00000f3}},
863 {"jsobgeq", {"mlb:", 0xC00000f4}},
864 {"jsobgtr", {"mlb:", 0xC00000f5}},
866 /* CASEx has no branch addresses in our conception of it. */
867 /* You should use ".word ..." statements after the "case ...". */
869 {"", {"", 0}} /* Empty is end sentinel. */
872 /* Because this module is useful for both VMS and UN*X style assemblers
873 and because of the variety of UN*X assemblers we must recognise
874 the different conventions for assembler operand notation. For example
875 VMS says "#42" for immediate mode, while most UN*X say "$42".
876 We permit arbitrary sets of (single) characters to represent the
877 3 concepts that DEC writes '#', '@', '^'. */
879 /* Character tests. */
880 #define VIP_IMMEDIATE 01 /* Character is like DEC # */
881 #define VIP_INDIRECT 02 /* Char is like DEC @ */
882 #define VIP_DISPLEN 04 /* Char is like DEC ^ */
884 #define IMMEDIATEP(c) (vip_metacharacters [(c) & 0xff] & VIP_IMMEDIATE)
885 #define INDIRECTP(c) (vip_metacharacters [(c) & 0xff] & VIP_INDIRECT)
886 #define DISPLENP(c) (vip_metacharacters [(c) & 0xff] & VIP_DISPLEN)
888 /* We assume 8 bits per byte. Use vip_op_defaults() to set these up BEFORE we
891 #if defined(CONST_TABLE)
893 #define I VIP_IMMEDIATE,
894 #define S VIP_INDIRECT,
895 #define D VIP_DISPLEN,
897 vip_metacharacters
[256] =
899 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
/* ^@ ^A ^B ^C ^D ^E ^F ^G ^H ^I ^J ^K ^L ^M ^N ^O*/
900 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
/* ^P ^Q ^R ^S ^T ^U ^V ^W ^X ^Y ^Z ^[ ^\ ^] ^^ ^_ */
901 _ _ _ _ I _ _ _ _ _ S _ _ _ _ _
/* sp ! " # $ % & ' ( ) * + , - . / */
902 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
/*0 1 2 3 4 5 6 7 8 9 : ; < = > ?*/
903 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
/*@ A B C D E F G H I J K L M N O*/
904 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
/*P Q R S T U V W X Y Z [ \ ] ^ _*/
905 D _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
/*` a b c d e f g h i j k l m n o*/
906 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
/*p q r s t u v w x y z { | } ~ ^?*/
908 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
909 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
910 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
911 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
912 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
913 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
914 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
915 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
924 static char vip_metacharacters
[256];
927 vip_op_1 (int bit
, const char *syms
)
931 while ((t
= *syms
++) != 0)
932 vip_metacharacters
[t
] |= bit
;
935 /* Can be called any time. More arguments may appear in future. */
937 vip_op_defaults (const char *immediate
, const char *indirect
, const char *displen
)
939 vip_op_1 (VIP_IMMEDIATE
, immediate
);
940 vip_op_1 (VIP_INDIRECT
, indirect
);
941 vip_op_1 (VIP_DISPLEN
, displen
);
946 /* Call me once before you decode any lines.
947 I decode votstrs into a hash table at op_hash (which I create).
948 I return an error text or null.
949 If you want, I will include the 'synthetic' jXXX instructions in the
951 You must nominate metacharacters for eg DEC's "#", "@", "^". */
954 vip_begin (int synthetic_too
, /* 1 means include jXXX op-codes. */
955 const char *immediate
,
956 const char *indirect
,
959 const struct vot
*vP
; /* scan votstrs */
961 op_hash
= str_htab_create ();
963 for (vP
= votstrs
; *vP
->vot_name
; vP
++)
964 str_hash_insert (op_hash
, vP
->vot_name
, (void *) &vP
->vot_detail
);
967 for (vP
= synthetic_votstrs
; *vP
->vot_name
; vP
++)
968 str_hash_insert (op_hash
, vP
->vot_name
, (void *) &vP
->vot_detail
);
971 vip_op_defaults (immediate
, indirect
, displen
);
975 /* Take 3 char.s, the last of which may be `\0` (non-existent)
976 and return the VAX register number that they represent.
978 Return -1 if they don't form a register name. Good names return
979 a number from 0:15 inclusive.
981 Case is not important in a name.
983 Register names understood are:
1007 /* Returns the register number of something like '%r15' or 'ap', supplied
1008 in four single chars. Returns -1 if the register isn't recognized,
1011 vax_reg_parse (char c1
, char c2
, char c3
, char c4
)
1016 if (c1
!= '%') /* Register prefixes are mandatory for ELF. */
1023 if (c4
!= 0) /* Register prefixes are not allowed under VMS. */
1027 if (c1
== '%') /* Register prefixes are optional under a.out. */
1033 else if (c3
&& c4
) /* Can't be 4 characters long. */
1039 if (ISDIGIT (c2
) && c1
== 'r')
1044 retval
= retval
* 10 + c3
- '0';
1045 retval
= (retval
> 15) ? -1 : retval
;
1046 /* clamp the register value to 1 hex digit */
1049 retval
= -1; /* c3 must be '\0' or a digit. */
1051 else if (c3
) /* There are no three letter regs. */
1070 else if (c1
== 'p' && c2
== 'c')
1077 /* Parse a vax operand in DEC assembler notation.
1078 For speed, expect a string of whitespace to be reduced to a single ' '.
1079 This is the case for GNU AS, and is easy for other DEC-compatible
1082 Knowledge about DEC VAX assembler operand notation lives here.
1083 This doesn't even know what a register name is, except it believes
1084 all register names are 2 or 3 characters, and lets vax_reg_parse() say
1085 what number each name represents.
1086 It does, however, know that PC, SP etc are special registers so it can
1087 detect addressing modes that are silly for those registers.
1089 Where possible, it delivers 1 fatal or 1 warning message if the operand
1090 is suspect. Exactly what we test for is still evolving.
1095 There were a number of 'mismatched argument type' bugs to vip_op.
1096 The most general solution is to typedef each (of many) arguments.
1097 We used instead a typedef'd argument block. This is less modular
1098 than using separate return pointers for each result, but runs faster
1099 on most engines, and seems to keep programmers happy. It will have
1100 to be done properly if we ever want to use vip_op as a general-purpose
1101 module (it was designed to be).
1105 Doesn't support DEC "G^" format operands. These always take 5 bytes
1106 to express, and code as modes 8F or 9F. Reason: "G^" deprives you of
1107 optimising to (say) a "B^" if you are lucky in the way you link.
1108 When someone builds a linker smart enough to convert "G^" to "B^", "W^"
1109 whenever possible, then we should implement it.
1110 If there is some other use for "G^", feel free to code it in!
1114 If I nested if()s more, I could avoid testing (*err) which would save
1115 time, space and page faults. I didn't nest all those if()s for clarity
1116 and because I think the mode testing can be re-arranged 1st to test the
1117 commoner constructs 1st. Does anybody have statistics on this?
1121 In future, we should be able to 'compose' error messages in a scratch area
1122 and give the user MUCH more informative error messages. Although this takes
1123 a little more code at run-time, it will make this module much more self-
1124 documenting. As an example of what sucks now: most error messages have
1125 hardwired into them the DEC VAX metacharacters "#^@" which are nothing like
1126 the Un*x characters "$`*", that most users will expect from this AS.
1130 The input is a string, ending with '\0'.
1132 We also require a 'hint' of what kind of operand is expected: so
1133 we can remind caller not to write into literals for instance.
1135 The output is a skeletal instruction.
1137 The algorithm has two parts.
1138 1. extract the syntactic features (parse off all the @^#-()+[] mode crud);
1139 2. express the @^#-()+[] as some parameters suited to further analysis.
1141 2nd step is where we detect the googles of possible invalid combinations
1142 a human (or compiler) might write. Note that if we do a half-way
1143 decent assembler, we don't know how long to make (eg) displacement
1144 fields when we first meet them (because they may not have defined values).
1145 So we must wait until we know how many bits are needed for each address,
1146 then we can know both length and opcodes of instructions.
1147 For reason(s) above, we will pass to our caller a 'broken' instruction
1148 of these major components, from which our caller can generate instructions:
1149 - displacement length I^ S^ L^ B^ W^ unspecified
1151 - register R0-R15 or absent
1152 - index register R0-R15 or absent
1153 - expression text what we don't parse
1154 - error text(s) why we couldn't understand the operand
1158 To decode output of this, test errtxt. If errtxt[0] == '\0', then
1159 we had no errors that prevented parsing. Also, if we ever report
1160 an internal bug, errtxt[0] is set non-zero. So one test tells you
1161 if the other outputs are to be taken seriously.
1165 Dec defines the semantics of address modes (and values)
1166 by a two-letter code, explained here.
1168 letter 1: access type
1170 a address calculation - no data access, registers forbidden
1171 b branch displacement
1172 m read - let go of bus - write back "modify"
1174 v bit field address: like 'a' but registers are OK
1176 space no operator (eg ".long foo") [our convention]
1178 letter 2: data type (i.e. width, alignment)
1181 d double precision floating point (D format)
1182 f single precision floating point (F format)
1189 ? simple synthetic branch operand
1190 - unconditional synthetic JSB/JSR operand
1191 ! complex synthetic branch operand
1193 The '-?!' letter 2's are not for external consumption. They are used
1194 for various assemblers. Generally, all unknown widths are assumed 0.
1195 We don't limit your choice of width character.
1197 DEC operands are hard work to parse. For example, '@' as the first
1198 character means indirect (deferred) mode but elsewhere it is a shift
1200 The long-winded explanation of how this is supposed to work is
1201 cancelled. Read a DEC vax manual.
1202 We try hard not to parse anything that MIGHT be part of the expression
1203 buried in that syntax. For example if we see @...(Rn) we don't check
1204 for '-' before the '(' because mode @-(Rn) does not exist.
1206 After parsing we have:
1208 at 1 if leading '@' (or Un*x '*')
1209 len takes one value from " bilsw". eg B^ -> 'b'.
1210 hash 1 if leading '#' (or Un*x '$')
1211 expr_begin, expr_end the expression we did not parse
1212 even though we don't interpret it, we make use
1213 of its presence or absence.
1214 sign -1: -(Rn) 0: absent +1: (Rn)+
1215 paren 1 if () are around register
1216 reg major register number 0:15 -1 means absent
1217 ndx index register number 0:15 -1 means absent
1219 Again, I dare not explain it: just trace ALL the code!
1221 Summary of vip_op outputs.
1225 {@}Rn 5+@ n ' ' optional
1226 branch operand 0 -1 ' ' -1
1228 -(Rn) 7 n ' ' optional
1229 {@}(Rn)+ 8+@ n ' ' optional
1230 {@}#foo, no S^ 8+@ PC " i" optional
1231 {@}{q^}{(Rn)} 10+@+q option " bwl" optional */
1233 /* Dissect user-input 'optext' (which is something like "@B^foo@bar(AP)[FP]:")
1234 using the vop in vopP. vopP's vop_access and vop_width. We fill _ndx, _reg,
1235 _mode, _short, _warn, _error, _expr_begin, _expr_end and _nbytes. */
1238 vip_op (char *optext
, struct vop
*vopP
)
1240 /* Track operand text forward. */
1242 /* Track operand text backward. */
1244 /* 1 if leading '@' ('*') seen. */
1246 /* one of " bilsw" */
1248 /* 1 if leading '#' ('$') seen. */
1252 /* 1 if () surround register. */
1254 /* Register number, -1:absent. */
1256 /* Index register number -1:absent. */
1258 /* Report illegal operand, ""==OK. */
1259 /* " " is a FAKE error: means we won. */
1260 /* ANY err that begins with ' ' is a fake. */
1261 /* " " is converted to "" before return. */
1263 /* Warn about weird modes pf address. */
1265 /* Preserve q in case we backup. */
1267 /* Build up 4-bit operand mode here. */
1268 /* Note: index mode is in ndx, this is. */
1269 /* The major mode of operand address. */
1271 /* Notice how we move wrong-arg-type bugs INSIDE this module: if we
1272 get the types wrong below, we lose at compile time rather than at
1273 lint or run time. */
1274 char access_mode
; /* vop_access. */
1276 access_mode
= vopP
->vop_access
;
1277 /* None of our code bugs (yet), no user text errors, no warnings
1283 if (*p
== ' ') /* Expect all whitespace reduced to ' '. */
1284 p
++; /* skip over whitespace */
1286 if ((at
= INDIRECTP (*p
)) != 0)
1287 { /* 1 if *p=='@'(or '*' for Un*x) */
1288 p
++; /* at is determined */
1289 if (*p
== ' ') /* Expect all whitespace reduced to ' '. */
1290 p
++; /* skip over whitespace */
1293 /* This code is subtle. It tries to detect all legal (letter)'^'
1294 but it doesn't waste time explicitly testing for premature '\0' because
1295 this case is rejected as a mismatch against either (letter) or '^'. */
1301 if (DISPLENP (p
[1]) && strchr ("bilws", len
= c
))
1302 p
+= 2; /* Skip (letter) '^'. */
1303 else /* No (letter) '^' seen. */
1304 len
= ' '; /* Len is determined. */
1307 if (*p
== ' ') /* Expect all whitespace reduced to ' '. */
1310 if ((hash
= IMMEDIATEP (*p
)) != 0) /* 1 if *p=='#' ('$' for Un*x) */
1311 p
++; /* Hash is determined. */
1313 /* p points to what may be the beginning of an expression.
1314 We have peeled off the front all that is peelable.
1315 We know at, len, hash.
1317 Lets point q at the end of the text and parse that (backwards). */
1319 for (q
= p
; *q
; q
++)
1321 q
--; /* Now q points at last char of text. */
1323 if (*q
== ' ' && q
>= p
) /* Expect all whitespace reduced to ' '. */
1326 /* Reverse over whitespace, but don't. */
1327 /* Run back over *p. */
1329 /* As a matter of policy here, we look for [Rn], although both Rn and S^#
1330 forbid [Rn]. This is because it is easy, and because only a sick
1331 cyborg would have [...] trailing an expression in a VAX-like assembler.
1332 A meticulous parser would first check for Rn followed by '(' or '['
1333 and not parse a trailing ']' if it found another. We just ban expressions
1337 while (q
>= p
&& *q
!= '[')
1339 /* Either q<p or we got matching '['. */
1341 err
= _("no '[' to match ']'");
1344 /* Confusers like "[]" will eventually lose with a bad register
1345 * name error. So again we don't need to check for early '\0'. */
1347 ndx
= vax_reg_parse (q
[1], q
[2], 0, 0);
1348 else if (q
[4] == ']')
1349 ndx
= vax_reg_parse (q
[1], q
[2], q
[3], 0);
1350 else if (q
[5] == ']')
1351 ndx
= vax_reg_parse (q
[1], q
[2], q
[3], q
[4]);
1354 /* Since we saw a ']' we will demand a register name in the [].
1355 * If luser hasn't given us one: be rude. */
1357 err
= _("bad register in []");
1359 err
= _("[PC] index banned");
1361 /* Point q just before "[...]". */
1366 /* No ']', so no iNDeX register. */
1369 /* If err = "..." then we lost: run away.
1370 Otherwise ndx == -1 if there was no "[...]".
1371 Otherwise, ndx is index register number, and q points before "[...]". */
1373 if (*q
== ' ' && q
>= p
) /* Expect all whitespace reduced to ' '. */
1375 /* Reverse over whitespace, but don't. */
1376 /* Run back over *p. */
1379 /* no ()+ or -() seen yet */
1382 if (q
> p
+ 3 && *q
== '+' && q
[-1] == ')')
1384 sign
= 1; /* we saw a ")+" */
1385 q
--; /* q points to ')' */
1388 if (*q
== ')' && q
> p
+ 2)
1390 paren
= 1; /* assume we have "(...)" */
1391 while (q
>= p
&& *q
!= '(')
1393 /* either q<p or we got matching '(' */
1395 err
= _("no '(' to match ')'");
1398 /* Confusers like "()" will eventually lose with a bad register
1399 name error. So again we don't need to check for early '\0'. */
1401 reg
= vax_reg_parse (q
[1], q
[2], 0, 0);
1402 else if (q
[4] == ')')
1403 reg
= vax_reg_parse (q
[1], q
[2], q
[3], 0);
1404 else if (q
[5] == ')')
1405 reg
= vax_reg_parse (q
[1], q
[2], q
[3], q
[4]);
1408 /* Since we saw a ')' we will demand a register name in the ')'.
1409 This is nasty: why can't our hypothetical assembler permit
1410 parenthesised expressions? BECAUSE I AM LAZY! That is why.
1411 Abuse luser if we didn't spy a register name. */
1414 /* JF allow parenthesized expressions. I hope this works. */
1418 /* err = "unknown register in ()"; */
1421 q
--; /* point just before '(' of "(...)" */
1422 /* If err == "..." then we lost. Run away.
1423 Otherwise if reg >= 0 then we saw (Rn). */
1425 /* If err == "..." then we lost.
1426 Otherwise paren==1 and reg = register in "()". */
1430 /* If err == "..." then we lost.
1431 Otherwise, q points just before "(Rn)", if any.
1432 If there was a "(...)" then paren==1, and reg is the register. */
1434 /* We should only seek '-' of "-(...)" if:
1435 we saw "(...)" paren == 1
1436 we have no errors so far ! *err
1437 we did not see '+' of "(...)+" sign < 1
1438 We don't check len. We want a specific error message later if
1439 user tries "x^...-(Rn)". This is a feature not a bug. */
1442 if (paren
&& sign
< 1)/* !sign is adequate test */
1450 /* We have back-tracked over most
1451 of the crud at the end of an operand.
1452 Unless err, we know: sign, paren. If paren, we know reg.
1453 The last case is of an expression "Rn".
1454 This is worth hunting for if !err, !paren.
1455 We wouldn't be here if err.
1456 We remember to save q, in case we didn't want "Rn" anyway. */
1459 if (*q
== ' ' && q
>= p
) /* Expect all whitespace reduced to ' '. */
1461 /* Reverse over whitespace, but don't. */
1462 /* Run back over *p. */
1463 /* Room for Rn or Rnn (include prefix) exactly? */
1464 if (q
> p
&& q
< p
+ 4)
1465 reg
= vax_reg_parse (p
[0], p
[1],
1466 q
< p
+ 2 ? 0 : p
[2],
1467 q
< p
+ 3 ? 0 : p
[3]);
1469 reg
= -1; /* Always comes here if no register at all. */
1470 /* Here with a definitive reg value. */
1479 /* have reg. -1:absent; else 0:15. */
1481 /* We have: err, at, len, hash, ndx, sign, paren, reg.
1482 Also, any remaining expression is from *p through *q inclusive.
1483 Should there be no expression, q==p-1. So expression length = q-p+1.
1484 This completes the first part: parsing the operand text. */
1486 /* We now want to boil the data down, checking consistency on the way.
1487 We want: len, mode, reg, ndx, err, p, q, wrn, bug.
1488 We will deliver a 4-bit reg, and a 4-bit mode. */
1490 /* Case of branch operand. Different. No L^B^W^I^S^ allowed for instance.
1504 p:q whatever was input
1506 err " " or error message, and other outputs trashed. */
1507 /* Branch operands have restricted forms. */
1508 if ((!err
|| !*err
) && access_mode
== 'b')
1510 if (at
|| hash
|| sign
|| paren
|| ndx
>= 0 || reg
>= 0 || len
!= ' ')
1511 err
= _("invalid branch operand");
1516 /* Since nobody seems to use it: comment this 'feature'(?) out for now. */
1518 /* Case of stand-alone operand. e.g. ".long foo"
1532 p:q whatever was input
1534 err " " or error message, and other outputs trashed. */
1535 if ((!err
|| !*err
) && access_mode
== ' ')
1538 err
= _("address prohibits @");
1540 err
= _("address prohibits #");
1544 err
= _("address prohibits -()");
1546 err
= _("address prohibits ()+");
1549 err
= _("address prohibits ()");
1551 err
= _("address prohibits []");
1553 err
= _("address prohibits register");
1554 else if (len
!= ' ')
1555 err
= _("address prohibits displacement length specifier");
1558 err
= " "; /* succeed */
1569 p:q demand not empty
1571 paren 0 by "()" scan logic because "S^" seen
1572 reg -1 or nn by mistake
1580 if ((!err
|| !*err
) && len
== 's')
1582 if (!hash
|| paren
|| at
|| ndx
>= 0)
1583 err
= _("invalid operand of S^#");
1588 /* Darn! we saw S^#Rnn ! put the Rnn back in
1589 expression. KLUDGE! Use oldq so we don't
1590 need to know exact length of reg name. */
1594 /* We have all the expression we will ever get. */
1596 err
= _("S^# needs expression");
1597 else if (access_mode
== 'r')
1599 err
= " "; /* WIN! */
1603 err
= _("S^# may only read-access");
1607 /* Case of -(Rn), which is weird case.
1613 sign -1 by definition
1614 paren 1 by definition
1615 reg present by definition
1621 exp "" enforce empty expression
1622 ndx optional warn if same as reg. */
1623 if ((!err
|| !*err
) && sign
< 0)
1625 if (len
!= ' ' || hash
|| at
|| p
<= q
)
1626 err
= _("invalid operand of -()");
1629 err
= " "; /* win */
1632 wrn
= _("-(PC) unpredictable");
1633 else if (reg
== ndx
)
1634 wrn
= _("[]index same as -()register: unpredictable");
1638 /* We convert "(Rn)" to "@Rn" for our convenience.
1639 (I hope this is convenient: has someone got a better way to parse this?)
1640 A side-effect of this is that "@Rn" is a valid operand. */
1641 if (paren
&& !sign
&& !hash
&& !at
&& len
== ' ' && p
> q
)
1647 /* Case of (Rn)+, which is slightly different.
1653 sign +1 by definition
1654 paren 1 by definition
1655 reg present by definition
1661 exp "" enforce empty expression
1662 ndx optional warn if same as reg. */
1663 if ((!err
|| !*err
) && sign
> 0)
1665 if (len
!= ' ' || hash
|| p
<= q
)
1666 err
= _("invalid operand of ()+");
1669 err
= " "; /* win */
1670 mode
= 8 + (at
? 1 : 0);
1672 wrn
= _("(PC)+ unpredictable");
1673 else if (reg
== ndx
)
1674 wrn
= _("[]index same as ()+register: unpredictable");
1678 /* Case of #, without S^.
1682 hash 1 by definition
1694 if ((!err
|| !*err
) && hash
)
1696 if (len
!= 'i' && len
!= ' ')
1697 err
= _("# conflicts length");
1699 err
= _("# bars register");
1704 /* Darn! we saw #Rnn! Put the Rnn back into the expression.
1705 By using oldq, we don't need to know how long Rnn was.
1708 reg
= -1; /* No register any more. */
1710 err
= " "; /* Win. */
1712 /* JF a bugfix, I think! */
1713 if (at
&& access_mode
== 'a')
1714 vopP
->vop_nbytes
= 4;
1716 mode
= (at
? 9 : 8);
1718 if ((access_mode
== 'm' || access_mode
== 'w') && !at
)
1719 wrn
= _("writing or modifying # is unpredictable");
1722 /* If !*err, then sign == 0
1725 /* Case of Rn. We separate this one because it has a few special
1726 errors the remaining modes lack.
1730 hash 0 by program logic
1732 sign 0 by program logic
1733 paren 0 by definition
1734 reg present by definition
1739 len ' ' enforce no length
1740 exp "" enforce empty expression
1741 ndx optional warn if same as reg. */
1742 if ((!err
|| !*err
) && !paren
&& reg
>= 0)
1745 err
= _("length not needed");
1748 err
= " "; /* win */
1752 err
= _("can't []index a register, because it has no address");
1753 else if (access_mode
== 'a')
1754 err
= _("a register has no address");
1757 /* Idea here is to detect from length of datum
1758 and from register number if we will touch PC.
1760 vop_nbytes is number of bytes in operand.
1761 Compute highest byte affected, compare to PC0. */
1762 if ((vopP
->vop_nbytes
+ reg
* 4) > 60)
1763 wrn
= _("PC part of operand unpredictable");
1764 err
= " "; /* win */
1768 /* If !*err, sign == 0
1770 paren == 1 OR reg==-1 */
1772 /* Rest of cases fit into one bunch.
1775 len ' ' or 'b' or 'w' or 'l'
1776 hash 0 by program logic
1777 p:q expected (empty is not an error)
1778 sign 0 by program logic
1783 out: mode 10 + @ + len
1785 len ' ' or 'b' or 'w' or 'l'
1787 ndx optional warn if same as reg. */
1790 err
= " "; /* win (always) */
1791 mode
= 10 + (at
? 1 : 0);
1800 case ' ': /* Assumed B^ until our caller changes it. */
1806 /* here with completely specified mode
1813 err
= 0; /* " " is no longer an error. */
1815 vopP
->vop_mode
= mode
;
1816 vopP
->vop_reg
= reg
;
1817 vopP
->vop_short
= len
;
1818 vopP
->vop_expr_begin
= p
;
1819 vopP
->vop_expr_end
= q
;
1820 vopP
->vop_ndx
= ndx
;
1821 vopP
->vop_error
= err
;
1822 vopP
->vop_warn
= wrn
;
1825 /* This converts a string into a vax instruction.
1826 The string must be a bare single instruction in dec-vax (with BSD4 frobs)
1828 It provides some error messages: at most one fatal error message (which
1829 stops the scan) and at most one warning message for each operand.
1830 The vax instruction is returned in exploded form, since we have no
1831 knowledge of how you parse (or evaluate) your expressions.
1832 We do however strip off and decode addressing modes and operation
1835 The exploded instruction is returned to a struct vit of your choice.
1836 #include "vax-inst.h" to know what a struct vit is.
1838 This function's value is a string. If it is not "" then an internal
1839 logic error was found: read this code to assign meaning to the string.
1840 No argument string should generate such an error string:
1841 it means a bug in our code, not in the user's text.
1843 You MUST have called vip_begin() once before using this function. */
1846 vip (struct vit
*vitP
, /* We build an exploded instruction here. */
1847 char *instring
) /* Text of a vax instruction: we modify. */
1849 /* How to bit-encode this opcode. */
1850 struct vot_wot
*vwP
;
1851 /* 1/skip whitespace.2/scan vot_how */
1854 /* counts number of operands seen */
1855 unsigned char count
;
1856 /* scan operands in struct vit */
1857 struct vop
*operandp
;
1858 /* error over all operands */
1859 const char *alloperr
;
1860 /* Remember char, (we clobber it with '\0' temporarily). */
1862 /* Op-code of this instruction. */
1865 if (*instring
== ' ')
1868 /* MUST end in end-of-string or exactly 1 space. */
1869 for (p
= instring
; *p
&& *p
!= ' '; p
++)
1872 /* Scanned up to end of operation-code. */
1873 /* Operation-code is ended with whitespace. */
1874 if (p
- instring
== 0)
1876 vitP
->vit_error
= _("No operator");
1878 memset (vitP
->vit_opcode
, '\0', sizeof (vitP
->vit_opcode
));
1884 /* Here with instring pointing to what better be an op-name, and p
1885 pointing to character just past that.
1886 We trust instring points to an op-name, with no whitespace. */
1887 vwP
= (struct vot_wot
*) str_hash_find (op_hash
, instring
);
1888 /* Restore char after op-code. */
1892 vitP
->vit_error
= _("Unknown operator");
1894 memset (vitP
->vit_opcode
, '\0', sizeof (vitP
->vit_opcode
));
1898 /* We found a match! So let's pick up as many operands as the
1899 instruction wants, and even gripe if there are too many.
1900 We expect comma to separate each operand.
1901 We let instring track the text, while p tracks a part of the
1904 /* The lines below know about 2-byte opcodes starting FD,FE or FF.
1905 They also understand synthetic opcodes. Note:
1906 we return 32 bits of opcode, including bucky bits, BUT
1907 an opcode length is either 8 or 16 bits for vit_opcode_nbytes. */
1908 oc
= vwP
->vot_code
; /* The op-code. */
1909 vitP
->vit_opcode_nbytes
= (oc
& 0xFF) >= 0xFD ? 2 : 1;
1910 md_number_to_chars (vitP
->vit_opcode
, oc
, 4);
1911 count
= 0; /* No operands seen yet. */
1912 instring
= p
; /* Point just past operation code. */
1914 for (howp
= vwP
->vot_how
, operandp
= vitP
->vit_operand
;
1915 !(alloperr
&& *alloperr
) && *howp
;
1916 operandp
++, howp
+= 2)
1918 /* Here to parse one operand. Leave instring pointing just
1919 past any one ',' that marks the end of this operand. */
1921 as_fatal (_("odd number of bytes in operand description"));
1924 for (q
= instring
; (c
= *q
) && c
!= ','; q
++)
1926 /* Q points to ',' or '\0' that ends argument. C is that
1929 operandp
->vop_width
= howp
[1];
1930 operandp
->vop_nbytes
= vax_operand_width_size
[(unsigned) howp
[1]];
1931 operandp
->vop_access
= howp
[0];
1932 vip_op (instring
, operandp
);
1933 *q
= c
; /* Restore input text. */
1934 if (operandp
->vop_error
)
1935 alloperr
= _("Bad operand");
1936 instring
= q
+ (c
? 1 : 0); /* Next operand (if any). */
1937 count
++; /* Won another argument, may have an operr. */
1940 alloperr
= _("Not enough operands");
1944 if (*instring
== ' ')
1947 alloperr
= _("Too many operands");
1949 vitP
->vit_error
= alloperr
;
1952 vitP
->vit_operands
= count
;
1957 /* Test program for above. */
1959 struct vit myvit
; /* Build an exploded vax instruction here. */
1960 char answer
[100]; /* Human types a line of vax assembler here. */
1961 char *mybug
; /* "" or an internal logic diagnostic. */
1962 int mycount
; /* Number of operands. */
1963 struct vop
*myvop
; /* Scan operands from myvit. */
1964 int mysynth
; /* 1 means want synthetic opcodes. */
1965 char my_immediate
[200];
1966 char my_indirect
[200];
1967 char my_displen
[200];
1974 printf ("0 means no synthetic instructions. ");
1975 printf ("Value for vip_begin? ");
1977 sscanf (answer
, "%d", &mysynth
);
1978 printf ("Synthetic opcodes %s be included.\n", mysynth
? "will" : "will not");
1979 printf ("enter immediate symbols eg enter # ");
1980 gets (my_immediate
);
1981 printf ("enter indirect symbols eg enter @ ");
1983 printf ("enter displen symbols eg enter ^ ");
1986 vip_begin (mysynth
, my_immediate
, my_indirect
, my_displen
)
1988 printf ("An empty input line will quit you from the vax instruction parser\n");
1991 printf ("vax instruction: ");
1995 break; /* Out of for each input text loop. */
1997 vip (& myvit
, answer
);
1998 if (*myvit
.vit_error
)
1999 printf ("ERR:\"%s\"\n", myvit
.vit_error
);
2002 for (mycount
= myvit
.vit_opcode_nbytes
, p
= myvit
.vit_opcode
;
2005 printf ("%02x ", *p
& 0xFF);
2007 printf (" operand count=%d.\n", mycount
= myvit
.vit_operands
);
2008 for (myvop
= myvit
.vit_operand
; mycount
; mycount
--, myvop
++)
2010 printf ("mode=%xx reg=%xx ndx=%xx len='%c'=%c%c%d. expr=\"",
2011 myvop
->vop_mode
, myvop
->vop_reg
, myvop
->vop_ndx
,
2012 myvop
->vop_short
, myvop
->vop_access
, myvop
->vop_width
,
2014 for (p
= myvop
->vop_expr_begin
; p
<= myvop
->vop_expr_end
; p
++)
2018 if (myvop
->vop_error
)
2019 printf (" err:\"%s\"\n", myvop
->vop_error
);
2021 if (myvop
->vop_warn
)
2022 printf (" wrn:\"%s\"\n", myvop
->vop_warn
);
2026 exit (EXIT_SUCCESS
);
2031 #ifdef TEST /* #Define to use this testbed. */
2033 /* Follows a test program for this function.
2034 We declare arrays non-local in case some of our tiny-minded machines
2035 default to small stacks. Also, helps with some debuggers. */
2037 char answer
[100]; /* Human types into here. */
2050 int my_operand_length
;
2051 char my_immediate
[200];
2052 char my_indirect
[200];
2053 char my_displen
[200];
2058 printf ("enter immediate symbols eg enter # ");
2059 gets (my_immediate
);
2060 printf ("enter indirect symbols eg enter @ ");
2062 printf ("enter displen symbols eg enter ^ ");
2064 vip_op_defaults (my_immediate
, my_indirect
, my_displen
);
2068 printf ("access,width (eg 'ab' or 'wh') [empty line to quit] : ");
2072 exit (EXIT_SUCCESS
);
2073 myaccess
= answer
[0];
2074 mywidth
= answer
[1];
2078 my_operand_length
= 1;
2081 my_operand_length
= 8;
2084 my_operand_length
= 4;
2087 my_operand_length
= 16;
2090 my_operand_length
= 32;
2093 my_operand_length
= 4;
2096 my_operand_length
= 16;
2099 my_operand_length
= 8;
2102 my_operand_length
= 2;
2107 my_operand_length
= 0;
2111 my_operand_length
= 2;
2112 printf ("I don't understand access width %c\n", mywidth
);
2115 printf ("VAX assembler instruction operand: ");
2118 mybug
= vip_op (answer
, myaccess
, mywidth
, my_operand_length
,
2119 &mymode
, &myreg
, &mylen
, &myleft
, &myright
, &myndx
,
2123 printf ("error: \"%s\"\n", myerr
);
2125 printf (" bug: \"%s\"\n", mybug
);
2130 printf ("warning: \"%s\"\n", mywrn
);
2131 mumble ("mode", mymode
);
2132 mumble ("register", myreg
);
2133 mumble ("index", myndx
);
2134 printf ("width:'%c' ", mylen
);
2135 printf ("expression: \"");
2136 while (myleft
<= myright
)
2137 putchar (*myleft
++);
2144 mumble (char *text
, int value
)
2146 printf ("%s:", text
);
2148 printf ("%xx", value
);
2156 int md_short_jump_size
= 3;
2157 int md_long_jump_size
= 6;
2160 md_create_short_jump (char *ptr
,
2162 addressT to_addr ATTRIBUTE_UNUSED
,
2163 fragS
*frag ATTRIBUTE_UNUSED
,
2164 symbolS
*to_symbol ATTRIBUTE_UNUSED
)
2168 /* This former calculation was off by two:
2169 offset = to_addr - (from_addr + 1);
2170 We need to account for the one byte instruction and also its
2171 two byte operand. */
2172 offset
= to_addr
- (from_addr
+ 1 + 2);
2173 *ptr
++ = VAX_BRW
; /* Branch with word (16 bit) offset. */
2174 md_number_to_chars (ptr
, offset
, 2);
2178 md_create_long_jump (char *ptr
,
2179 addressT from_addr ATTRIBUTE_UNUSED
,
2186 offset
= to_addr
- S_GET_VALUE (to_symbol
);
2187 *ptr
++ = VAX_JMP
; /* Arbitrary jump. */
2188 *ptr
++ = VAX_ABSOLUTE_MODE
;
2189 md_number_to_chars (ptr
, offset
, 4);
2190 fix_new (frag
, ptr
- frag
->fr_literal
, 4, to_symbol
, (long) 0, 0, NO_RELOC
);
2194 const char *md_shortopts
= "d:STt:V+1h:Hv::";
2195 #elif defined(OBJ_ELF)
2196 const char *md_shortopts
= "d:STt:VkKQ:";
2198 const char *md_shortopts
= "d:STt:V";
2200 struct option md_longopts
[] =
2203 #define OPTION_PIC (OPTION_MD_BASE)
2204 { "pic", no_argument
, NULL
, OPTION_PIC
},
2206 { NULL
, no_argument
, NULL
, 0 }
2208 size_t md_longopts_size
= sizeof (md_longopts
);
2211 md_parse_option (int c
, const char *arg
)
2216 as_warn (_("SYMBOL TABLE not implemented"));
2220 as_warn (_("TOKEN TRACE not implemented"));
2224 as_warn (_("Displacement length %s ignored!"), arg
);
2228 as_warn (_("I don't need or use temp. file \"%s\"."), arg
);
2232 as_warn (_("I don't use an interpass file! -V ignored"));
2236 case '+': /* For g++. Hash any name > 31 chars long. */
2237 flag_hash_long_names
= 1;
2240 case '1': /* For backward compatibility. */
2244 case 'H': /* Show new symbol after hash truncation. */
2245 flag_show_after_trunc
= 1;
2248 case 'h': /* No hashing of mixed-case names. */
2250 extern char vms_name_mapping
;
2251 vms_name_mapping
= atoi (arg
);
2252 flag_no_hash_mixed_case
= 1;
2258 extern char *compiler_version_string
;
2260 if (!arg
|| !*arg
|| access (arg
, 0) == 0)
2261 return 0; /* Have caller show the assembler version. */
2262 compiler_version_string
= arg
;
2271 break; /* -pic, Position Independent Code. */
2273 /* -Qy, -Qn: SVR4 arguments controlling whether a .comment
2274 section should be emitted or not. FIXME: Not implemented. */
2287 md_show_usage (FILE *stream
)
2289 fprintf (stream
, _("\
2291 -d LENGTH ignored\n\
2298 fprintf (stream
, _("\
2300 -+ hash encode names longer than 31 characters\n\
2301 -1 `const' handling compatible with gcc 1.x\n\
2302 -H show new symbol after hash truncation\n\
2303 -h NUM don't hash mixed-case names, and adjust case:\n\
2304 0 = upper, 2 = lower, 3 = preserve case\n\
2305 -v\"VERSION\" code being assembled was produced by compiler \"VERSION\"\n"));
2309 /* We have no need to default values of symbols. */
2312 md_undefined_symbol (char *name ATTRIBUTE_UNUSED
)
2317 /* Round up a section size to the appropriate boundary. */
2319 md_section_align (segT segment ATTRIBUTE_UNUSED
, valueT size
)
2321 /* Byte alignment is fine */
2325 /* Exactly what point is a PC-relative offset relative TO?
2326 On the vax, they're relative to the address of the offset, plus
2329 md_pcrel_from (fixS
*fixP
)
2331 return fixP
->fx_size
+ fixP
->fx_where
+ fixP
->fx_frag
->fr_address
;
2335 tc_gen_reloc (asection
*section ATTRIBUTE_UNUSED
, fixS
*fixp
)
2338 bfd_reloc_code_real_type code
;
2343 if (fixp
->fx_r_type
!= NO_RELOC
)
2345 code
= fixp
->fx_r_type
;
2351 case BFD_RELOC_8_PCREL
:
2352 case BFD_RELOC_16_PCREL
:
2353 case BFD_RELOC_32_PCREL
:
2355 case BFD_RELOC_8_GOT_PCREL
:
2356 case BFD_RELOC_16_GOT_PCREL
:
2357 case BFD_RELOC_32_GOT_PCREL
:
2358 case BFD_RELOC_8_PLT_PCREL
:
2359 case BFD_RELOC_16_PLT_PCREL
:
2360 case BFD_RELOC_32_PLT_PCREL
:
2364 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
2365 _("Cannot make %s relocation PC relative"),
2366 bfd_get_reloc_code_name (code
));
2372 #define F(SZ,PCREL) (((SZ) << 1) + (PCREL))
2373 switch (F (fixp
->fx_size
, fixp
->fx_pcrel
))
2375 #define MAP(SZ,PCREL,TYPE) case F(SZ,PCREL): code = (TYPE); break
2376 MAP (1, 0, BFD_RELOC_8
);
2377 MAP (2, 0, BFD_RELOC_16
);
2378 MAP (4, 0, BFD_RELOC_32
);
2379 MAP (1, 1, BFD_RELOC_8_PCREL
);
2380 MAP (2, 1, BFD_RELOC_16_PCREL
);
2381 MAP (4, 1, BFD_RELOC_32_PCREL
);
2389 reloc
= XNEW (arelent
);
2390 reloc
->sym_ptr_ptr
= XNEW (asymbol
*);
2391 *reloc
->sym_ptr_ptr
= symbol_get_bfdsym (fixp
->fx_addsy
);
2392 reloc
->address
= fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
2395 reloc
->addend
= fixp
->fx_addnumber
;
2399 reloc
->addend
= fixp
->fx_offset
;
2402 reloc
->howto
= bfd_reloc_type_lookup (stdoutput
, code
);
2403 gas_assert (reloc
->howto
!= 0);
2408 /* vax:md_assemble() emit frags for 1 instruction given in textual form. */
2410 md_assemble (char *instruction_string
)
2412 /* Non-zero if operand expression's segment is not known yet. */
2414 /* Non-zero if operand expression's segment is absolute. */
2418 /* An operand. Scans all operands. */
2419 struct vop
*operandP
;
2420 char *save_input_line_pointer
;
2421 /* What used to live after an expression. */
2423 /* 1: instruction_string bad for all passes. */
2425 /* Points to slot just after last operand. */
2426 struct vop
*end_operandP
;
2427 /* Points to expression values for this operand. */
2431 /* These refer to an instruction operand expression. */
2432 /* Target segment of the address. */
2434 valueT this_add_number
;
2435 /* Positive (minuend) symbol. */
2436 symbolS
*this_add_symbol
;
2438 long opcode_as_number
;
2439 /* Least significant byte 1st. */
2440 char *opcode_as_chars
;
2441 /* As an array of characters. */
2442 /* Least significant byte 1st */
2443 char *opcode_low_byteP
;
2444 /* length (bytes) meant by vop_short. */
2446 /* 0, or 1 if '@' is in addressing mode. */
2448 /* From vop_nbytes: vax_operand_width (in bytes) */
2450 FLONUM_TYPE
*floatP
;
2451 LITTLENUM_TYPE literal_float
[8];
2452 /* Big enough for any floating point literal. */
2454 vip (&v
, instruction_string
);
2456 /* Now we try to find as many as_warn()s as we can. If we do any as_warn()s
2457 then goofed=1. Notice that we don't make any frags yet.
2458 Should goofed be 1, then this instruction will wedge in any pass,
2459 and we can safely flush it, without causing interpass symbol phase
2460 errors. That is, without changing label values in different passes. */
2461 if ((goofed
= (*v
.vit_error
)) != 0)
2463 as_fatal (_("Ignoring statement due to \"%s\""), v
.vit_error
);
2465 /* We need to use expression() and friends, which require us to diddle
2466 input_line_pointer. So we save it and restore it later. */
2467 save_input_line_pointer
= input_line_pointer
;
2468 for (operandP
= v
.vit_operand
,
2469 expP
= exp_of_operand
,
2470 segP
= seg_of_operand
,
2471 floatP
= float_operand
,
2472 end_operandP
= v
.vit_operand
+ v
.vit_operands
;
2474 operandP
< end_operandP
;
2476 operandP
++, expP
++, segP
++, floatP
++)
2478 if (operandP
->vop_error
)
2480 as_fatal (_("Aborting because statement has \"%s\""), operandP
->vop_error
);
2485 /* Statement has no syntax goofs: let's sniff the expression. */
2486 int can_be_short
= 0; /* 1 if a bignum can be reduced to a short literal. */
2488 input_line_pointer
= operandP
->vop_expr_begin
;
2489 c_save
= operandP
->vop_expr_end
[1];
2490 operandP
->vop_expr_end
[1] = '\0';
2491 /* If to_seg == SEG_PASS1, expression() will have set need_pass_2 = 1. */
2492 *segP
= expression (expP
);
2496 /* for BSD4.2 compatibility, missing expression is absolute 0 */
2497 expP
->X_op
= O_constant
;
2498 expP
->X_add_number
= 0;
2499 /* For SEG_ABSOLUTE, we shouldn't need to set X_op_symbol,
2500 X_add_symbol to any particular value. But, we will program
2501 defensively. Since this situation occurs rarely so it costs
2502 us little to do, and stops Dean worrying about the origin of
2503 random bits in expressionS's. */
2504 expP
->X_add_symbol
= NULL
;
2505 expP
->X_op_symbol
= NULL
;
2513 /* Major bug. We can't handle the case of a
2514 SEG_OP expression in a VIT_OPCODE_SYNTHETIC
2515 variable-length instruction.
2516 We don't have a frag type that is smart enough to
2517 relax a SEG_OP, and so we just force all
2518 SEG_OPs to behave like SEG_PASS1s.
2519 Clearly, if there is a demand we can invent a new or
2520 modified frag type and then coding up a frag for this
2521 case will be easy. SEG_OP was invented for the
2522 .words after a CASE opcode, and was never intended for
2523 instruction operands. */
2525 as_fatal (_("Can't relocate expression"));
2529 /* Preserve the bits. */
2530 if (expP
->X_add_number
> 0)
2532 bignum_copy (generic_bignum
, expP
->X_add_number
,
2533 floatP
->low
, SIZE_OF_LARGE_NUMBER
);
2537 know (expP
->X_add_number
< 0);
2538 flonum_copy (&generic_floating_point_number
,
2540 if (strchr ("s i", operandP
->vop_short
))
2542 /* Could possibly become S^# */
2543 flonum_gen2vax (-expP
->X_add_number
, floatP
, literal_float
);
2544 switch (-expP
->X_add_number
)
2548 (literal_float
[0] & 0xFC0F) == 0x4000
2549 && literal_float
[1] == 0;
2554 (literal_float
[0] & 0xFC0F) == 0x4000
2555 && literal_float
[1] == 0
2556 && literal_float
[2] == 0
2557 && literal_float
[3] == 0;
2562 (literal_float
[0] & 0xFF81) == 0x4000
2563 && literal_float
[1] == 0
2564 && literal_float
[2] == 0
2565 && literal_float
[3] == 0;
2569 can_be_short
= ((literal_float
[0] & 0xFFF8) == 0x4000
2570 && (literal_float
[1] & 0xE000) == 0
2571 && literal_float
[2] == 0
2572 && literal_float
[3] == 0
2573 && literal_float
[4] == 0
2574 && literal_float
[5] == 0
2575 && literal_float
[6] == 0
2576 && literal_float
[7] == 0);
2580 BAD_CASE (-expP
->X_add_number
);
2586 if (operandP
->vop_short
== 's'
2587 || operandP
->vop_short
== 'i'
2588 || (operandP
->vop_short
== ' '
2589 && operandP
->vop_reg
== 0xF
2590 && (operandP
->vop_mode
& 0xE) == 0x8))
2593 if (operandP
->vop_short
== ' ')
2595 /* We must chose S^ or I^. */
2596 if (expP
->X_add_number
> 0)
2598 /* Bignum: Short literal impossible. */
2599 operandP
->vop_short
= 'i';
2600 operandP
->vop_mode
= 8;
2601 operandP
->vop_reg
= 0xF; /* VAX PC. */
2605 /* Flonum: Try to do it. */
2608 operandP
->vop_short
= 's';
2609 operandP
->vop_mode
= 0;
2610 operandP
->vop_ndx
= -1;
2611 operandP
->vop_reg
= -1;
2612 expP
->X_op
= O_constant
;
2616 operandP
->vop_short
= 'i';
2617 operandP
->vop_mode
= 8;
2618 operandP
->vop_reg
= 0xF; /* VAX PC */
2620 } /* bignum or flonum ? */
2621 } /* if #, but no S^ or I^ seen. */
2622 /* No more ' ' case: either 's' or 'i'. */
2623 if (operandP
->vop_short
== 's')
2625 /* Wants to be a short literal. */
2626 if (expP
->X_add_number
> 0)
2628 as_warn (_("Bignum not permitted in short literal. Immediate mode assumed."));
2629 operandP
->vop_short
= 'i';
2630 operandP
->vop_mode
= 8;
2631 operandP
->vop_reg
= 0xF; /* VAX PC. */
2637 as_warn (_("Can't do flonum short literal: immediate mode used."));
2638 operandP
->vop_short
= 'i';
2639 operandP
->vop_mode
= 8;
2640 operandP
->vop_reg
= 0xF; /* VAX PC. */
2644 /* Encode short literal now. */
2647 switch (-expP
->X_add_number
)
2651 temp
= literal_float
[0] >> 4;
2655 temp
= literal_float
[0] >> 1;
2659 temp
= ((literal_float
[0] << 3) & 070)
2660 | ((literal_float
[1] >> 13) & 07);
2664 BAD_CASE (-expP
->X_add_number
);
2668 floatP
->low
[0] = temp
& 077;
2675 /* I^# seen: set it up if float. */
2676 if (expP
->X_add_number
< 0)
2678 memcpy (floatP
->low
, literal_float
, sizeof (literal_float
));
2680 } /* if S^# seen. */
2684 as_warn (_("A bignum/flonum may not be a displacement: 0x%lx used"),
2685 (expP
->X_add_number
= 0x80000000L
));
2686 /* Chosen so luser gets the most offset bits to patch later. */
2688 expP
->X_add_number
= floatP
->low
[0]
2689 | ((LITTLENUM_MASK
& (floatP
->low
[1])) << LITTLENUM_NUMBER_OF_BITS
);
2691 /* For the O_big case we have:
2692 If vop_short == 's' then a short floating literal is in the
2693 lowest 6 bits of floatP -> low [0], which is
2694 big_operand_bits [---] [0].
2695 If vop_short == 'i' then the appropriate number of elements
2696 of big_operand_bits [---] [...] are set up with the correct
2698 Also, just in case width is byte word or long, we copy the lowest
2699 32 bits of the number to X_add_number. */
2702 if (input_line_pointer
!= operandP
->vop_expr_end
+ 1)
2704 as_fatal ("Junk at end of expression \"%s\"", input_line_pointer
);
2707 operandP
->vop_expr_end
[1] = c_save
;
2711 input_line_pointer
= save_input_line_pointer
;
2713 if (need_pass_2
|| goofed
)
2716 dwarf2_emit_insn (0);
2718 /* Remember where it is, in case we want to modify the op-code later. */
2719 opcode_low_byteP
= frag_more (v
.vit_opcode_nbytes
);
2720 memcpy (opcode_low_byteP
, v
.vit_opcode
, v
.vit_opcode_nbytes
);
2721 opcode_as_chars
= v
.vit_opcode
;
2722 opcode_as_number
= md_chars_to_number ((unsigned char *) opcode_as_chars
, 4);
2723 for (operandP
= v
.vit_operand
,
2724 expP
= exp_of_operand
,
2725 segP
= seg_of_operand
,
2726 floatP
= float_operand
,
2727 end_operandP
= v
.vit_operand
+ v
.vit_operands
;
2729 operandP
< end_operandP
;
2736 if (operandP
->vop_ndx
>= 0)
2738 /* Indexed addressing byte. */
2739 /* Legality of indexed mode already checked: it is OK. */
2740 FRAG_APPEND_1_CHAR (0x40 + operandP
->vop_ndx
);
2741 } /* if(vop_ndx>=0) */
2743 /* Here to make main operand frag(s). */
2744 this_add_number
= expP
->X_add_number
;
2745 this_add_symbol
= expP
->X_add_symbol
;
2747 is_undefined
= (to_seg
== undefined_section
);
2748 is_absolute
= (to_seg
== absolute_section
);
2749 at
= operandP
->vop_mode
& 1;
2750 length
= (operandP
->vop_short
== 'b'
2751 ? 1 : (operandP
->vop_short
== 'w'
2752 ? 2 : (operandP
->vop_short
== 'l'
2754 nbytes
= operandP
->vop_nbytes
;
2755 if (operandP
->vop_access
== 'b')
2757 if (to_seg
== now_seg
|| is_undefined
)
2759 /* If is_undefined, then it might BECOME now_seg. */
2762 p
= frag_more (nbytes
);
2763 fix_new (frag_now
, p
- frag_now
->fr_literal
, nbytes
,
2764 this_add_symbol
, this_add_number
, 1, NO_RELOC
);
2768 /* to_seg==now_seg || to_seg == SEG_UNKNOWN */
2770 length_code
= is_undefined
? STATE_UNDF
: STATE_BYTE
;
2771 if (opcode_as_number
& VIT_OPCODE_SPECIAL
)
2773 if (operandP
->vop_width
== VAX_WIDTH_UNCONDITIONAL_JUMP
)
2776 frag_var (rs_machine_dependent
, 5, 1,
2777 ENCODE_RELAX (STATE_ALWAYS_BRANCH
, length_code
),
2778 this_add_symbol
, this_add_number
,
2783 if (operandP
->vop_width
== VAX_WIDTH_WORD_JUMP
)
2785 length_code
= STATE_WORD
;
2786 /* JF: There is no state_byte for this one! */
2787 frag_var (rs_machine_dependent
, 10, 2,
2788 ENCODE_RELAX (STATE_COMPLEX_BRANCH
, length_code
),
2789 this_add_symbol
, this_add_number
,
2794 know (operandP
->vop_width
== VAX_WIDTH_BYTE_JUMP
);
2795 frag_var (rs_machine_dependent
, 9, 1,
2796 ENCODE_RELAX (STATE_COMPLEX_HOP
, length_code
),
2797 this_add_symbol
, this_add_number
,
2804 know (operandP
->vop_width
== VAX_WIDTH_CONDITIONAL_JUMP
);
2805 frag_var (rs_machine_dependent
, 7, 1,
2806 ENCODE_RELAX (STATE_CONDITIONAL_BRANCH
, length_code
),
2807 this_add_symbol
, this_add_number
,
2814 /* to_seg != now_seg && to_seg != SEG_UNKNOWN */
2815 /* --- SEG FLOAT MAY APPEAR HERE --- */
2820 know (!(opcode_as_number
& VIT_OPCODE_SYNTHETIC
));
2821 p
= frag_more (nbytes
);
2822 /* Conventional relocation. */
2823 fix_new (frag_now
, p
- frag_now
->fr_literal
, nbytes
,
2824 section_symbol (absolute_section
),
2825 this_add_number
, 1, NO_RELOC
);
2829 know (opcode_as_number
& VIT_OPCODE_SYNTHETIC
);
2830 if (opcode_as_number
& VIT_OPCODE_SPECIAL
)
2832 if (operandP
->vop_width
== VAX_WIDTH_UNCONDITIONAL_JUMP
)
2835 *opcode_low_byteP
= opcode_as_chars
[0] + VAX_WIDEN_LONG
;
2836 know (opcode_as_chars
[1] == 0);
2838 p
[0] = VAX_ABSOLUTE_MODE
; /* @#... */
2839 md_number_to_chars (p
+ 1, this_add_number
, 4);
2840 /* Now (eg) JMP @#foo or JSB @#foo. */
2844 if (operandP
->vop_width
== VAX_WIDTH_WORD_JUMP
)
2852 p
[5] = VAX_ABSOLUTE_MODE
; /* @#... */
2853 md_number_to_chars (p
+ 6, this_add_number
, 4);
2861 know (operandP
->vop_width
== VAX_WIDTH_BYTE_JUMP
);
2867 p
[4] = VAX_ABSOLUTE_MODE
; /* @#... */
2868 md_number_to_chars (p
+ 5, this_add_number
, 4);
2869 /* Now (eg) xOBxxx 1f
2879 *opcode_low_byteP
^= 1;
2880 /* To reverse the condition in a VAX branch,
2881 complement the lowest order bit. */
2885 p
[2] = VAX_ABSOLUTE_MODE
; /* @#... */
2886 md_number_to_chars (p
+ 3, this_add_number
, 4);
2895 /* to_seg != now_seg && !is_undefinfed && !is_absolute */
2898 /* Pc-relative. Conventional relocation. */
2899 know (!(opcode_as_number
& VIT_OPCODE_SYNTHETIC
));
2900 p
= frag_more (nbytes
);
2901 fix_new (frag_now
, p
- frag_now
->fr_literal
, nbytes
,
2902 section_symbol (absolute_section
),
2903 this_add_number
, 1, NO_RELOC
);
2907 know (opcode_as_number
& VIT_OPCODE_SYNTHETIC
);
2908 if (opcode_as_number
& VIT_OPCODE_SPECIAL
)
2910 if (operandP
->vop_width
== VAX_WIDTH_UNCONDITIONAL_JUMP
)
2913 know (opcode_as_chars
[1] == 0);
2914 *opcode_low_byteP
= opcode_as_chars
[0] + VAX_WIDEN_LONG
;
2916 p
[0] = VAX_PC_RELATIVE_MODE
;
2918 p
+ 1 - frag_now
->fr_literal
, 4,
2920 this_add_number
, 1, NO_RELOC
);
2921 /* Now eg JMP foo or JSB foo. */
2925 if (operandP
->vop_width
== VAX_WIDTH_WORD_JUMP
)
2933 p
[5] = VAX_PC_RELATIVE_MODE
;
2935 p
+ 6 - frag_now
->fr_literal
, 4,
2937 this_add_number
, 1, NO_RELOC
);
2945 know (operandP
->vop_width
== VAX_WIDTH_BYTE_JUMP
);
2951 p
[4] = VAX_PC_RELATIVE_MODE
;
2953 p
+ 5 - frag_now
->fr_literal
,
2955 this_add_number
, 1, NO_RELOC
);
2956 /* Now (eg) xOBxxx 1f
2965 know (operandP
->vop_width
== VAX_WIDTH_CONDITIONAL_JUMP
);
2966 *opcode_low_byteP
^= 1; /* Reverse branch condition. */
2970 p
[2] = VAX_PC_RELATIVE_MODE
;
2971 fix_new (frag_now
, p
+ 3 - frag_now
->fr_literal
,
2973 this_add_number
, 1, NO_RELOC
);
2981 /* So it is ordinary operand. */
2982 know (operandP
->vop_access
!= 'b');
2983 /* ' ' target-independent: elsewhere. */
2984 know (operandP
->vop_access
!= ' ');
2985 know (operandP
->vop_access
== 'a'
2986 || operandP
->vop_access
== 'm'
2987 || operandP
->vop_access
== 'r'
2988 || operandP
->vop_access
== 'v'
2989 || operandP
->vop_access
== 'w');
2990 if (operandP
->vop_short
== 's')
2994 if (this_add_number
>= 64)
2996 as_warn (_("Short literal overflow(%ld.), immediate mode assumed."),
2997 (long) this_add_number
);
2998 operandP
->vop_short
= 'i';
2999 operandP
->vop_mode
= 8;
3000 operandP
->vop_reg
= 0xF;
3005 as_warn (_("Forced short literal to immediate mode. now_seg=%s to_seg=%s"),
3006 segment_name (now_seg
), segment_name (to_seg
));
3007 operandP
->vop_short
= 'i';
3008 operandP
->vop_mode
= 8;
3009 operandP
->vop_reg
= 0xF;
3012 if (operandP
->vop_reg
>= 0 && (operandP
->vop_mode
< 8
3013 || (operandP
->vop_reg
!= 0xF && operandP
->vop_mode
< 10)))
3015 /* One byte operand. */
3016 know (operandP
->vop_mode
> 3);
3017 FRAG_APPEND_1_CHAR (operandP
->vop_mode
<< 4 | operandP
->vop_reg
);
3018 /* All 1-bytes except S^# happen here. */
3022 /* {@}{q^}foo{(Rn)} or S^#foo */
3023 if (operandP
->vop_reg
== -1 && operandP
->vop_short
!= 's')
3026 if (to_seg
== now_seg
)
3030 know (operandP
->vop_short
== ' ');
3031 length_code
= STATE_BYTE
;
3033 if (S_IS_EXTERNAL (this_add_symbol
)
3034 || S_IS_WEAK (this_add_symbol
))
3035 length_code
= STATE_UNDF
;
3037 p
= frag_var (rs_machine_dependent
, 10, 2,
3038 ENCODE_RELAX (STATE_PC_RELATIVE
, length_code
),
3039 this_add_symbol
, this_add_number
,
3041 know (operandP
->vop_mode
== 10 + at
);
3043 /* At is the only context we need to carry
3044 to other side of relax() process. Must
3045 be in the correct bit position of VAX
3046 operand spec. byte. */
3051 know (operandP
->vop_short
!= ' ');
3052 p
= frag_more (length
+ 1);
3053 p
[0] = 0xF | ((at
+ "?\12\14?\16"[length
]) << 4);
3054 fix_new (frag_now
, p
+ 1 - frag_now
->fr_literal
,
3055 length
, this_add_symbol
,
3056 this_add_number
, 1, NO_RELOC
);
3061 /* to_seg != now_seg */
3062 if (this_add_symbol
== NULL
)
3065 /* Do @#foo: simpler relocation than foo-.(pc) anyway. */
3067 p
[0] = VAX_ABSOLUTE_MODE
; /* @#... */
3068 md_number_to_chars (p
+ 1, this_add_number
, 4);
3069 if (length
&& length
!= 4)
3070 as_warn (_("Length specification ignored. Address mode 9F used"));
3074 /* {@}{q^}other_seg */
3075 know ((length
== 0 && operandP
->vop_short
== ' ')
3076 || (length
> 0 && operandP
->vop_short
!= ' '));
3079 || S_IS_WEAK(this_add_symbol
)
3080 || S_IS_EXTERNAL(this_add_symbol
)
3086 default: length_code
= STATE_UNDF
; break;
3087 case 1: length_code
= STATE_BYTE
; break;
3088 case 2: length_code
= STATE_WORD
; break;
3089 case 4: length_code
= STATE_LONG
; break;
3091 /* We have a SEG_UNKNOWN symbol. It might
3092 turn out to be in the same segment as
3093 the instruction, permitting relaxation. */
3094 p
= frag_var (rs_machine_dependent
, 5, 2,
3095 ENCODE_RELAX (STATE_PC_RELATIVE
, length_code
),
3096 this_add_symbol
, this_add_number
,
3104 know (operandP
->vop_short
== ' ');
3105 length
= 4; /* Longest possible. */
3107 p
= frag_more (length
+ 1);
3108 p
[0] = 0xF | ((at
+ "?\12\14?\16"[length
]) << 4);
3109 md_number_to_chars (p
+ 1, this_add_number
, length
);
3111 p
+ 1 - frag_now
->fr_literal
,
3112 length
, this_add_symbol
,
3113 this_add_number
, 1, NO_RELOC
);
3120 /* {@}{q^}foo(Rn) or S^# or I^# or # */
3121 if (operandP
->vop_mode
< 0xA)
3123 /* # or S^# or I^# */
3124 if (operandP
->vop_access
== 'v'
3125 || operandP
->vop_access
== 'a')
3127 if (operandP
->vop_access
== 'v')
3128 as_warn (_("Invalid operand: immediate value used as base address."));
3130 as_warn (_("Invalid operand: immediate value used as address."));
3131 /* gcc 2.6.3 is known to generate these in at least
3135 && is_absolute
&& (expP
->X_op
!= O_big
)
3136 && operandP
->vop_mode
== 8 /* No '@'. */
3137 && this_add_number
< 64)
3139 operandP
->vop_short
= 's';
3141 if (operandP
->vop_short
== 's')
3143 FRAG_APPEND_1_CHAR (this_add_number
);
3149 p
= frag_more (nbytes
+ 1);
3150 know (operandP
->vop_reg
== 0xF);
3152 if (flag_want_pic
&& operandP
->vop_mode
== 8
3153 && this_add_symbol
!= NULL
)
3155 as_warn (_("Symbol %s used as immediate operand in PIC mode."),
3156 S_GET_NAME (this_add_symbol
));
3159 p
[0] = (operandP
->vop_mode
<< 4) | 0xF;
3160 if ((is_absolute
) && (expP
->X_op
!= O_big
))
3162 /* If nbytes > 4, then we are scrod. We
3163 don't know if the high order bytes
3164 are to be 0xFF or 0x00. BSD4.2 & RMS
3165 say use 0x00. OK --- but this
3166 assembler needs ANOTHER rewrite to
3167 cope properly with this bug. */
3168 md_number_to_chars (p
+ 1, this_add_number
,
3169 min (sizeof (valueT
),
3171 if ((size_t) nbytes
> sizeof (valueT
))
3172 memset (p
+ 1 + sizeof (valueT
),
3173 '\0', nbytes
- sizeof (valueT
));
3177 if (expP
->X_op
== O_big
)
3179 /* Problem here is to get the bytes
3180 in the right order. We stored
3181 our constant as LITTLENUMs, not
3193 for (p
++; nbytes
; nbytes
-= 2, p
+= 2, lP
++)
3194 md_number_to_chars (p
, *lP
, 2);
3199 fix_new (frag_now
, p
+ 1 - frag_now
->fr_literal
,
3200 nbytes
, this_add_symbol
,
3201 this_add_number
, 0, NO_RELOC
);
3208 /* {@}{q^}foo(Rn) */
3209 know ((length
== 0 && operandP
->vop_short
== ' ')
3210 || (length
> 0 && operandP
->vop_short
!= ' '));
3217 test
= this_add_number
;
3222 length
= test
& 0xffff8000 ? 4
3223 : test
& 0xffffff80 ? 2
3231 p
= frag_more (1 + length
);
3232 know (operandP
->vop_reg
>= 0);
3233 p
[0] = operandP
->vop_reg
3234 | ((at
| "?\12\14?\16"[length
]) << 4);
3237 md_number_to_chars (p
+ 1, this_add_number
, length
);
3241 fix_new (frag_now
, p
+ 1 - frag_now
->fr_literal
,
3242 length
, this_add_symbol
,
3243 this_add_number
, 0, NO_RELOC
);
3258 vip_begin (1, "$", "*", "`");
3260 for (i
= 0, fP
= float_operand
;
3261 fP
< float_operand
+ VIT_MAX_OPERANDS
;
3264 fP
->low
= &big_operand_bits
[i
][0];
3265 fP
->high
= &big_operand_bits
[i
][SIZE_OF_LARGE_NUMBER
- 1];
3269 bfd_reloc_code_real_type
3270 vax_cons (expressionS
*exp
, int size
)
3273 const char *vax_cons_special_reloc
;
3276 vax_cons_special_reloc
= NULL
;
3277 save
= input_line_pointer
;
3278 if (input_line_pointer
[0] == '%')
3280 if (strncmp (input_line_pointer
+ 1, "pcrel", 5) == 0)
3282 input_line_pointer
+= 6;
3283 vax_cons_special_reloc
= "pcrel";
3285 if (vax_cons_special_reloc
)
3292 if (*input_line_pointer
!= '8')
3294 input_line_pointer
--;
3297 if (input_line_pointer
[0] != '1' || input_line_pointer
[1] != '6')
3301 if (input_line_pointer
[0] != '3' || input_line_pointer
[1] != '2')
3311 as_bad (_("Illegal operands: Only %%r_%s%d allowed in %d-byte data fields"),
3312 vax_cons_special_reloc
, size
* 8, size
);
3316 input_line_pointer
+= 2;
3317 if (*input_line_pointer
!= '(')
3319 as_bad (_("Illegal operands: %%r_%s%d requires arguments in ()"),
3320 vax_cons_special_reloc
, size
* 8);
3327 input_line_pointer
= save
;
3328 vax_cons_special_reloc
= NULL
;
3333 char *end
= ++input_line_pointer
;
3336 while (! is_end_of_line
[(c
= *end
)])
3350 as_bad (_("Illegal operands: %%r_%s%d requires arguments in ()"),
3351 vax_cons_special_reloc
, size
* 8);
3357 if (input_line_pointer
!= end
)
3359 as_bad (_("Illegal operands: %%r_%s%d requires arguments in ()"),
3360 vax_cons_special_reloc
, size
* 8);
3364 input_line_pointer
++;
3366 c
= *input_line_pointer
;
3367 if (! is_end_of_line
[c
] && c
!= ',')
3368 as_bad (_("Illegal operands: garbage after %%r_%s%d()"),
3369 vax_cons_special_reloc
, size
* 8);
3375 if (vax_cons_special_reloc
== NULL
)
3380 case 1: return BFD_RELOC_8_PCREL
;
3381 case 2: return BFD_RELOC_16_PCREL
;
3382 case 4: return BFD_RELOC_32_PCREL
;
3387 /* This is called by emit_expr via TC_CONS_FIX_NEW when creating a
3388 reloc for a cons. */
3391 vax_cons_fix_new (fragS
*frag
, int where
, unsigned int nbytes
, expressionS
*exp
,
3392 bfd_reloc_code_real_type r
)
3395 r
= (nbytes
== 1 ? BFD_RELOC_8
3396 : nbytes
== 2 ? BFD_RELOC_16
3399 fix_new_exp (frag
, where
, (int) nbytes
, exp
, 0, r
);
3403 md_atof (int type
, char * litP
, int * sizeP
)
3405 return vax_md_atof (type
, litP
, sizeP
);