1 /* tc-vax.c - vax-specific -
2 Copyright (C) 1987-2014 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 opcde, 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 /* Dont 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 (char, 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_addsy
== NULL
&& fixP
->fx_subsy
== NULL
)
282 && fixP
->fx_r_type
!= BFD_RELOC_32_PLT_PCREL
283 && fixP
->fx_r_type
!= BFD_RELOC_32_GOT_PCREL
)
284 || fixP
->fx_r_type
== NO_RELOC
)
285 number_to_chars_littleendian (fixP
->fx_where
+ fixP
->fx_frag
->fr_literal
,
286 value
, fixP
->fx_size
);
288 if (fixP
->fx_addsy
== NULL
&& fixP
->fx_pcrel
== 0)
292 /* Convert a number from VAX byte order (little endian)
293 into host byte order.
294 con is the buffer to convert,
295 nbytes is the length of the given buffer. */
297 md_chars_to_number (unsigned char con
[], int nbytes
)
301 for (retval
= 0, con
+= nbytes
- 1; nbytes
--; con
--)
303 retval
<<= BITS_PER_CHAR
;
309 /* Copy a bignum from in to out.
310 If the output is shorter than the input, copy lower-order
311 littlenums. Return 0 or the number of significant littlenums
312 dropped. Assumes littlenum arrays are densely packed: no unused
313 chars between the littlenums. Uses memcpy() to move littlenums, and
314 wants to know length (in chars) of the input bignum. */
317 bignum_copy (LITTLENUM_TYPE
*in
,
318 int in_length
, /* in sizeof(littlenum)s */
320 int out_length
/* in sizeof(littlenum)s */)
322 int significant_littlenums_dropped
;
324 if (out_length
< in_length
)
326 LITTLENUM_TYPE
*p
; /* -> most significant (non-zero) input
329 memcpy ((void *) out
, (void *) in
,
330 (unsigned int) out_length
<< LITTLENUM_SHIFT
);
331 for (p
= in
+ in_length
- 1; p
>= in
; --p
)
336 significant_littlenums_dropped
= p
- in
- in_length
+ 1;
338 if (significant_littlenums_dropped
< 0)
339 significant_littlenums_dropped
= 0;
343 memcpy ((char *) out
, (char *) in
,
344 (unsigned int) in_length
<< LITTLENUM_SHIFT
);
346 if (out_length
> in_length
)
347 memset ((char *) (out
+ in_length
), '\0',
348 (unsigned int) (out_length
- in_length
) << LITTLENUM_SHIFT
);
350 significant_littlenums_dropped
= 0;
353 return significant_littlenums_dropped
;
356 /* md_estimate_size_before_relax(), called just before relax().
357 Any symbol that is now undefined will not become defined.
358 Return the correct fr_subtype in the frag and the growth beyond
361 md_estimate_size_before_relax (fragS
*fragP
, segT segment
)
363 if (RELAX_LENGTH (fragP
->fr_subtype
) == STATE_UNDF
)
365 if (S_GET_SEGMENT (fragP
->fr_symbol
) != segment
367 || S_IS_WEAK (fragP
->fr_symbol
)
368 || S_IS_EXTERNAL (fragP
->fr_symbol
)
372 /* Non-relaxable cases. */
373 int reloc_type
= NO_RELOC
;
377 old_fr_fix
= fragP
->fr_fix
;
378 p
= fragP
->fr_literal
+ old_fr_fix
;
380 /* If this is to an undefined symbol, then if it's an indirect
381 reference indicate that is can mutated into a GLOB_DAT or
382 JUMP_SLOT by the loader. We restrict ourselves to no offset
383 due to a limitation in the NetBSD linker. */
385 if (GOT_symbol
== NULL
)
386 GOT_symbol
= symbol_find (GLOBAL_OFFSET_TABLE_NAME
);
387 if (PLT_symbol
== NULL
)
388 PLT_symbol
= symbol_find (PROCEDURE_LINKAGE_TABLE_NAME
);
389 if ((GOT_symbol
== NULL
|| fragP
->fr_symbol
!= GOT_symbol
)
390 && (PLT_symbol
== NULL
|| fragP
->fr_symbol
!= PLT_symbol
)
391 && fragP
->fr_symbol
!= NULL
393 && (!S_IS_DEFINED (fragP
->fr_symbol
)
394 || S_IS_WEAK (fragP
->fr_symbol
)
395 || S_IS_EXTERNAL (fragP
->fr_symbol
)))
397 /* Indirect references cannot go through the GOT or PLT,
398 let's hope they'll become local in the final link. */
399 if ((ELF_ST_VISIBILITY (S_GET_OTHER (fragP
->fr_symbol
))
402 reloc_type
= BFD_RELOC_32_PCREL
;
403 else if (((unsigned char *) fragP
->fr_opcode
)[0] == VAX_CALLS
404 || ((unsigned char *) fragP
->fr_opcode
)[0] == VAX_CALLG
405 || ((unsigned char *) fragP
->fr_opcode
)[0] == VAX_JSB
406 || ((unsigned char *) fragP
->fr_opcode
)[0] == VAX_JMP
407 || S_IS_FUNCTION (fragP
->fr_symbol
))
408 reloc_type
= BFD_RELOC_32_PLT_PCREL
;
410 reloc_type
= BFD_RELOC_32_GOT_PCREL
;
413 switch (RELAX_STATE (fragP
->fr_subtype
))
415 case STATE_PC_RELATIVE
:
416 p
[0] |= VAX_PC_RELATIVE_MODE
; /* Preserve @ bit. */
417 fragP
->fr_fix
+= 1 + 4;
418 fix_new (fragP
, old_fr_fix
+ 1, 4, fragP
->fr_symbol
,
419 fragP
->fr_offset
, 1, reloc_type
);
422 case STATE_CONDITIONAL_BRANCH
:
423 *fragP
->fr_opcode
^= 1; /* Reverse sense of branch. */
426 p
[2] = VAX_PC_RELATIVE_MODE
; /* ...(PC) */
427 fragP
->fr_fix
+= 1 + 1 + 1 + 4;
428 fix_new (fragP
, old_fr_fix
+ 3, 4, fragP
->fr_symbol
,
429 fragP
->fr_offset
, 1, NO_RELOC
);
432 case STATE_COMPLEX_BRANCH
:
438 p
[5] = VAX_PC_RELATIVE_MODE
; /* ...(pc) */
439 fragP
->fr_fix
+= 2 + 2 + 1 + 1 + 4;
440 fix_new (fragP
, old_fr_fix
+ 6, 4, fragP
->fr_symbol
,
441 fragP
->fr_offset
, 1, NO_RELOC
);
444 case STATE_COMPLEX_HOP
:
449 p
[4] = VAX_PC_RELATIVE_MODE
; /* ...(pc) */
450 fragP
->fr_fix
+= 1 + 2 + 1 + 1 + 4;
451 fix_new (fragP
, old_fr_fix
+ 5, 4, fragP
->fr_symbol
,
452 fragP
->fr_offset
, 1, NO_RELOC
);
455 case STATE_ALWAYS_BRANCH
:
456 *fragP
->fr_opcode
+= VAX_WIDEN_LONG
;
457 p
[0] = VAX_PC_RELATIVE_MODE
; /* ...(PC) */
458 fragP
->fr_fix
+= 1 + 4;
459 fix_new (fragP
, old_fr_fix
+ 1, 4, fragP
->fr_symbol
,
460 fragP
->fr_offset
, 1, NO_RELOC
);
468 /* Return the growth in the fixed part of the frag. */
469 return fragP
->fr_fix
- old_fr_fix
;
472 /* Relaxable cases. Set up the initial guess for the variable
474 switch (RELAX_STATE (fragP
->fr_subtype
))
476 case STATE_PC_RELATIVE
:
477 fragP
->fr_subtype
= ENCODE_RELAX (STATE_PC_RELATIVE
, STATE_BYTE
);
479 case STATE_CONDITIONAL_BRANCH
:
480 fragP
->fr_subtype
= ENCODE_RELAX (STATE_CONDITIONAL_BRANCH
, STATE_BYTE
);
482 case STATE_COMPLEX_BRANCH
:
483 fragP
->fr_subtype
= ENCODE_RELAX (STATE_COMPLEX_BRANCH
, STATE_WORD
);
485 case STATE_COMPLEX_HOP
:
486 fragP
->fr_subtype
= ENCODE_RELAX (STATE_COMPLEX_HOP
, STATE_BYTE
);
488 case STATE_ALWAYS_BRANCH
:
489 fragP
->fr_subtype
= ENCODE_RELAX (STATE_ALWAYS_BRANCH
, STATE_BYTE
);
494 if (fragP
->fr_subtype
>= sizeof (md_relax_table
) / sizeof (md_relax_table
[0]))
497 /* Return the size of the variable part of the frag. */
498 return md_relax_table
[fragP
->fr_subtype
].rlx_length
;
501 /* Called after relax() is finished.
503 fr_type == rs_machine_dependent.
504 fr_subtype is what the address relaxed to.
506 Out: Any fixSs and constants are set up.
507 Caller will turn frag into a ".space 0". */
509 md_convert_frag (bfd
*headers ATTRIBUTE_UNUSED
,
510 segT seg ATTRIBUTE_UNUSED
,
513 char *addressP
; /* -> _var to change. */
514 char *opcodeP
; /* -> opcode char(s) to change. */
515 short int extension
= 0; /* Size of relaxed address. */
516 /* Added to fr_fix: incl. ALL var chars. */
520 know (fragP
->fr_type
== rs_machine_dependent
);
521 where
= fragP
->fr_fix
;
522 addressP
= fragP
->fr_literal
+ where
;
523 opcodeP
= fragP
->fr_opcode
;
524 symbolP
= fragP
->fr_symbol
;
527 switch (fragP
->fr_subtype
)
529 case ENCODE_RELAX (STATE_PC_RELATIVE
, STATE_BYTE
):
530 know (*addressP
== 0 || *addressP
== 0x10); /* '@' bit. */
531 addressP
[0] |= 0xAF; /* Byte displacement. */
532 fix_new (fragP
, fragP
->fr_fix
+ 1, 1, fragP
->fr_symbol
,
533 fragP
->fr_offset
, 1, NO_RELOC
);
537 case ENCODE_RELAX (STATE_PC_RELATIVE
, STATE_WORD
):
538 know (*addressP
== 0 || *addressP
== 0x10); /* '@' bit. */
539 addressP
[0] |= 0xCF; /* Word displacement. */
540 fix_new (fragP
, fragP
->fr_fix
+ 1, 2, fragP
->fr_symbol
,
541 fragP
->fr_offset
, 1, NO_RELOC
);
545 case ENCODE_RELAX (STATE_PC_RELATIVE
, STATE_LONG
):
546 know (*addressP
== 0 || *addressP
== 0x10); /* '@' bit. */
547 addressP
[0] |= 0xEF; /* Long word displacement. */
548 fix_new (fragP
, fragP
->fr_fix
+ 1, 4, fragP
->fr_symbol
,
549 fragP
->fr_offset
, 1, NO_RELOC
);
553 case ENCODE_RELAX (STATE_CONDITIONAL_BRANCH
, STATE_BYTE
):
554 fix_new (fragP
, fragP
->fr_fix
, 1, fragP
->fr_symbol
,
555 fragP
->fr_offset
, 1, NO_RELOC
);
559 case ENCODE_RELAX (STATE_CONDITIONAL_BRANCH
, STATE_WORD
):
560 opcodeP
[0] ^= 1; /* Reverse sense of test. */
562 addressP
[1] = VAX_BRW
;
563 fix_new (fragP
, fragP
->fr_fix
+ 2, 2, fragP
->fr_symbol
,
564 fragP
->fr_offset
, 1, NO_RELOC
);
568 case ENCODE_RELAX (STATE_CONDITIONAL_BRANCH
, STATE_LONG
):
569 opcodeP
[0] ^= 1; /* Reverse sense of test. */
571 addressP
[1] = VAX_JMP
;
572 addressP
[2] = VAX_PC_RELATIVE_MODE
;
573 fix_new (fragP
, fragP
->fr_fix
+ 3, 4, fragP
->fr_symbol
,
574 fragP
->fr_offset
, 1, NO_RELOC
);
578 case ENCODE_RELAX (STATE_ALWAYS_BRANCH
, STATE_BYTE
):
579 fix_new (fragP
, fragP
->fr_fix
, 1, fragP
->fr_symbol
,
580 fragP
->fr_offset
, 1, NO_RELOC
);
584 case ENCODE_RELAX (STATE_ALWAYS_BRANCH
, STATE_WORD
):
585 opcodeP
[0] += VAX_WIDEN_WORD
; /* brb -> brw, bsbb -> bsbw */
586 fix_new (fragP
, fragP
->fr_fix
, 2, fragP
->fr_symbol
, fragP
->fr_offset
,
591 case ENCODE_RELAX (STATE_ALWAYS_BRANCH
, STATE_LONG
):
592 opcodeP
[0] += VAX_WIDEN_LONG
; /* brb -> jmp, bsbb -> jsb */
593 addressP
[0] = VAX_PC_RELATIVE_MODE
;
594 fix_new (fragP
, fragP
->fr_fix
+ 1, 4, fragP
->fr_symbol
,
595 fragP
->fr_offset
, 1, NO_RELOC
);
599 case ENCODE_RELAX (STATE_COMPLEX_BRANCH
, STATE_WORD
):
600 fix_new (fragP
, fragP
->fr_fix
, 2, fragP
->fr_symbol
,
601 fragP
->fr_offset
, 1, NO_RELOC
);
605 case ENCODE_RELAX (STATE_COMPLEX_BRANCH
, STATE_LONG
):
608 addressP
[2] = VAX_BRB
;
610 addressP
[4] = VAX_JMP
;
611 addressP
[5] = VAX_PC_RELATIVE_MODE
;
612 fix_new (fragP
, fragP
->fr_fix
+ 6, 4, fragP
->fr_symbol
,
613 fragP
->fr_offset
, 1, NO_RELOC
);
617 case ENCODE_RELAX (STATE_COMPLEX_HOP
, STATE_BYTE
):
618 fix_new (fragP
, fragP
->fr_fix
, 1, fragP
->fr_symbol
,
619 fragP
->fr_offset
, 1, NO_RELOC
);
623 case ENCODE_RELAX (STATE_COMPLEX_HOP
, STATE_WORD
):
625 addressP
[1] = VAX_BRB
;
627 addressP
[3] = VAX_BRW
;
628 fix_new (fragP
, fragP
->fr_fix
+ 4, 2, fragP
->fr_symbol
,
629 fragP
->fr_offset
, 1, NO_RELOC
);
633 case ENCODE_RELAX (STATE_COMPLEX_HOP
, STATE_LONG
):
635 addressP
[1] = VAX_BRB
;
637 addressP
[3] = VAX_JMP
;
638 addressP
[4] = VAX_PC_RELATIVE_MODE
;
639 fix_new (fragP
, fragP
->fr_fix
+ 5, 4, fragP
->fr_symbol
,
640 fragP
->fr_offset
, 1, NO_RELOC
);
645 BAD_CASE (fragP
->fr_subtype
);
648 fragP
->fr_fix
+= extension
;
651 /* Translate internal format of relocation info into target format.
653 On vax: first 4 bytes are normal unsigned long, next three bytes
654 are symbolnum, least sig. byte first. Last byte is broken up with
655 the upper nibble as nuthin, bit 3 as extern, bits 2 & 1 as length, and
659 md_ri_to_chars (char *the_bytes
, struct reloc_info_generic ri
)
662 md_number_to_chars (the_bytes
, ri
.r_address
, sizeof (ri
.r_address
));
663 /* Now the fun stuff. */
664 the_bytes
[6] = (ri
.r_symbolnum
>> 16) & 0x0ff;
665 the_bytes
[5] = (ri
.r_symbolnum
>> 8) & 0x0ff;
666 the_bytes
[4] = ri
.r_symbolnum
& 0x0ff;
667 the_bytes
[7] = (((ri
.r_extern
<< 3) & 0x08) | ((ri
.r_length
<< 1) & 0x06)
668 | ((ri
.r_pcrel
<< 0) & 0x01)) & 0x0F;
673 /* BUGS, GRIPES, APOLOGIA, etc.
675 The opcode table 'votstrs' needs to be sorted on opcode frequency.
676 That is, AFTER we hash it with hash_...(), we want most-used opcodes
677 to come out of the hash table faster.
679 I am sorry to inflict yet another VAX assembler on the world, but
680 RMS says we must do everything from scratch, to prevent pin-heads
681 restricting this software.
683 This is a vaguely modular set of routines in C to parse VAX
684 assembly code using DEC mnemonics. It is NOT un*x specific.
686 The idea here is that the assembler has taken care of all:
693 condensing any whitespace down to exactly one space
694 and all we have to do is parse 1 line into a vax instruction
695 partially formed. We will accept a line, and deliver:
696 an error message (hopefully empty)
697 a skeleton VAX instruction (tree structure)
698 textual pointers to all the operand expressions
699 a warning message that notes a silly operand (hopefully empty)
701 E D I T H I S T O R Y
703 17may86 Dean Elsner. Bug if line ends immediately after opcode.
704 30apr86 Dean Elsner. New vip_op() uses arg block so change call.
705 6jan86 Dean Elsner. Crock vip_begin() to call vip_op_defaults().
706 2jan86 Dean Elsner. Invent synthetic opcodes.
707 Widen vax_opcodeT to 32 bits. Use a bit for VIT_OPCODE_SYNTHETIC,
708 which means this is not a real opcode, it is like a macro; it will
709 be relax()ed into 1 or more instructions.
710 Use another bit for VIT_OPCODE_SPECIAL if the op-code is not optimised
711 like a regular branch instruction. Option added to vip_begin():
712 exclude synthetic opcodes. Invent synthetic_votstrs[].
713 31dec85 Dean Elsner. Invent vit_opcode_nbytes.
714 Also make vit_opcode into a char[]. We now have n-byte vax opcodes,
715 so caller's don't have to know the difference between a 1-byte & a
716 2-byte op-code. Still need vax_opcodeT concept, so we know how
717 big an object must be to hold an op.code.
718 30dec85 Dean Elsner. Widen typedef vax_opcodeT in "vax-inst.h"
719 because vax opcodes may be 16 bits. Our crufty C compiler was
720 happily initialising 8-bit vot_codes with 16-bit numbers!
721 (Wouldn't the 'phone company like to compress data so easily!)
722 29dec85 Dean Elsner. New static table vax_operand_width_size[].
723 Invented so we know hw many bytes a "I^#42" needs in its immediate
724 operand. Revised struct vop in "vax-inst.h": explicitly include
725 byte length of each operand, and it's letter-code datum type.
726 17nov85 Dean Elsner. Name Change.
727 Due to ar(1) truncating names, we learned the hard way that
728 "vax-inst-parse.c" -> "vax-inst-parse." dropping the "o" off
729 the archived object name. SO... we shortened the name of this
730 source file, and changed the makefile. */
732 /* Handle of the OPCODE hash table. */
733 static struct hash_control
*op_hash
;
735 /* In: 1 character, from "bdfghloqpw" being the data-type of an operand
736 of a vax instruction.
738 Out: the length of an operand of that type, in bytes.
739 Special branch operands types "-?!" have length 0. */
741 static const short int vax_operand_width_size
[256] =
743 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
744 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
745 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
746 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
747 0, 0, 1, 0, 8, 0, 4, 8, 16, 0, 0, 0, 4, 0, 0,16, /* ..b.d.fgh...l..o */
748 0, 8, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, /* .q.....w........ */
749 0, 0, 1, 0, 8, 0, 4, 8, 16, 0, 0, 0, 4, 0, 0,16, /* ..b.d.fgh...l..o */
750 0, 8, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, /* .q.....w........ */
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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
754 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
755 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
756 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
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,
761 /* This perversion encodes all the vax opcodes as a bunch of strings.
762 RMS says we should build our hash-table at run-time. Hmm.
763 Please would someone arrange these in decreasing frequency of opcode?
764 Because of the way hash_...() works, the most frequently used opcode
765 should be textually first and so on.
767 Input for this table was 'vax.opcodes', awk(1)ed by 'vax.opcodes.c.awk' .
768 So change 'vax.opcodes', then re-generate this table. */
770 #include "opcode/vax.h"
772 /* This is a table of optional op-codes. All of them represent
773 'synthetic' instructions that seem popular.
775 Here we make some pseudo op-codes. Every code has a bit set to say
776 it is synthetic. This lets you catch them if you want to
777 ban these opcodes. They are mnemonics for "elastic" instructions
778 that are supposed to assemble into the fewest bytes needed to do a
779 branch, or to do a conditional branch, or whatever.
781 The opcode is in the usual place [low-order n*8 bits]. This means
782 that if you mask off the bucky bits, the usual rules apply about
783 how long the opcode is.
785 All VAX branch displacements come at the end of the instruction.
786 For simple branches (1-byte opcode + 1-byte displacement) the last
787 operand is coded 'b?' where the "data type" '?' is a clue that we
788 may reverse the sense of the branch (complement lowest order bit)
789 and branch around a jump. This is by far the most common case.
790 That is why the VIT_OPCODE_SYNTHETIC bit is set: it says this is
791 a 0-byte op-code followed by 2 or more bytes of operand address.
793 If the op-code has VIT_OPCODE_SPECIAL set, then we have a more unusual
796 For JBSB & JBR the treatment is the similar, except (1) we have a 'bw'
797 option before (2) we can directly JSB/JMP because there is no condition.
798 These operands have 'b-' as their access/data type.
800 That leaves a bunch of random opcodes: JACBx, JxOBxxx. In these
801 cases, we do the same idea. JACBxxx are all marked with a 'b!'
802 JAOBxxx & JSOBxxx are marked with a 'b:'. */
803 #if (VIT_OPCODE_SYNTHETIC != 0x80000000)
804 #error "You have just broken the encoding below, which assumes the sign bit means 'I am an imaginary instruction'."
807 #if (VIT_OPCODE_SPECIAL != 0x40000000)
808 #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'."
811 static const struct vot
812 synthetic_votstrs
[] =
814 {"jbsb", {"b-", 0xC0000010}}, /* BSD 4.2 */
815 /* jsb used already */
816 {"jbr", {"b-", 0xC0000011}}, /* BSD 4.2 */
817 {"jr", {"b-", 0xC0000011}}, /* consistent */
818 {"jneq", {"b?", 0x80000012}},
819 {"jnequ", {"b?", 0x80000012}},
820 {"jeql", {"b?", 0x80000013}},
821 {"jeqlu", {"b?", 0x80000013}},
822 {"jgtr", {"b?", 0x80000014}},
823 {"jleq", {"b?", 0x80000015}},
824 /* un-used opcodes here */
825 {"jgeq", {"b?", 0x80000018}},
826 {"jlss", {"b?", 0x80000019}},
827 {"jgtru", {"b?", 0x8000001a}},
828 {"jlequ", {"b?", 0x8000001b}},
829 {"jvc", {"b?", 0x8000001c}},
830 {"jvs", {"b?", 0x8000001d}},
831 {"jgequ", {"b?", 0x8000001e}},
832 {"jcc", {"b?", 0x8000001e}},
833 {"jlssu", {"b?", 0x8000001f}},
834 {"jcs", {"b?", 0x8000001f}},
836 {"jacbw", {"rwrwmwb!", 0xC000003d}},
837 {"jacbf", {"rfrfmfb!", 0xC000004f}},
838 {"jacbd", {"rdrdmdb!", 0xC000006f}},
839 {"jacbb", {"rbrbmbb!", 0xC000009d}},
840 {"jacbl", {"rlrlmlb!", 0xC00000f1}},
841 {"jacbg", {"rgrgmgb!", 0xC0004ffd}},
842 {"jacbh", {"rhrhmhb!", 0xC0006ffd}},
844 {"jbs", {"rlvbb?", 0x800000e0}},
845 {"jbc", {"rlvbb?", 0x800000e1}},
846 {"jbss", {"rlvbb?", 0x800000e2}},
847 {"jbcs", {"rlvbb?", 0x800000e3}},
848 {"jbsc", {"rlvbb?", 0x800000e4}},
849 {"jbcc", {"rlvbb?", 0x800000e5}},
850 {"jbssi", {"rlvbb?", 0x800000e6}},
851 {"jbcci", {"rlvbb?", 0x800000e7}},
852 {"jlbs", {"rlb?", 0x800000e8}},
853 {"jlbc", {"rlb?", 0x800000e9}},
855 {"jaoblss", {"rlmlb:", 0xC00000f2}},
856 {"jaobleq", {"rlmlb:", 0xC00000f3}},
857 {"jsobgeq", {"mlb:", 0xC00000f4}},
858 {"jsobgtr", {"mlb:", 0xC00000f5}},
860 /* CASEx has no branch addresses in our conception of it. */
861 /* You should use ".word ..." statements after the "case ...". */
863 {"", {"", 0}} /* Empty is end sentinel. */
866 /* Because this module is useful for both VMS and UN*X style assemblers
867 and because of the variety of UN*X assemblers we must recognise
868 the different conventions for assembler operand notation. For example
869 VMS says "#42" for immediate mode, while most UN*X say "$42".
870 We permit arbitrary sets of (single) characters to represent the
871 3 concepts that DEC writes '#', '@', '^'. */
873 /* Character tests. */
874 #define VIP_IMMEDIATE 01 /* Character is like DEC # */
875 #define VIP_INDIRECT 02 /* Char is like DEC @ */
876 #define VIP_DISPLEN 04 /* Char is like DEC ^ */
878 #define IMMEDIATEP(c) (vip_metacharacters [(c) & 0xff] & VIP_IMMEDIATE)
879 #define INDIRECTP(c) (vip_metacharacters [(c) & 0xff] & VIP_INDIRECT)
880 #define DISPLENP(c) (vip_metacharacters [(c) & 0xff] & VIP_DISPLEN)
882 /* We assume 8 bits per byte. Use vip_op_defaults() to set these up BEFORE we
885 #if defined(CONST_TABLE)
887 #define I VIP_IMMEDIATE,
888 #define S VIP_INDIRECT,
889 #define D VIP_DISPLEN,
891 vip_metacharacters
[256] =
893 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
/* ^@ ^A ^B ^C ^D ^E ^F ^G ^H ^I ^J ^K ^L ^M ^N ^O*/
894 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
/* ^P ^Q ^R ^S ^T ^U ^V ^W ^X ^Y ^Z ^[ ^\ ^] ^^ ^_ */
895 _ _ _ _ I _ _ _ _ _ S _ _ _ _ _
/* sp ! " # $ % & ' ( ) * + , - . / */
896 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
/*0 1 2 3 4 5 6 7 8 9 : ; < = > ?*/
897 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
/*@ A B C D E F G H I J K L M N O*/
898 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
/*P Q R S T U V W X Y Z [ \ ] ^ _*/
899 D _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
/*` 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 { | } ~ ^?*/
902 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
903 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
904 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
905 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
906 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
907 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
908 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
909 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
918 static char vip_metacharacters
[256];
921 vip_op_1 (int bit
, const char *syms
)
925 while ((t
= *syms
++) != 0)
926 vip_metacharacters
[t
] |= bit
;
929 /* Can be called any time. More arguments may appear in future. */
931 vip_op_defaults (const char *immediate
, const char *indirect
, const char *displen
)
933 vip_op_1 (VIP_IMMEDIATE
, immediate
);
934 vip_op_1 (VIP_INDIRECT
, indirect
);
935 vip_op_1 (VIP_DISPLEN
, displen
);
940 /* Call me once before you decode any lines.
941 I decode votstrs into a hash table at op_hash (which I create).
942 I return an error text or null.
943 If you want, I will include the 'synthetic' jXXX instructions in the
945 You must nominate metacharacters for eg DEC's "#", "@", "^". */
948 vip_begin (int synthetic_too
, /* 1 means include jXXX op-codes. */
949 const char *immediate
,
950 const char *indirect
,
953 const struct vot
*vP
; /* scan votstrs */
954 const char *retval
= 0; /* error text */
956 op_hash
= hash_new ();
958 for (vP
= votstrs
; *vP
->vot_name
&& !retval
; vP
++)
959 retval
= hash_insert (op_hash
, vP
->vot_name
, (void *) &vP
->vot_detail
);
962 for (vP
= synthetic_votstrs
; *vP
->vot_name
&& !retval
; vP
++)
963 retval
= hash_insert (op_hash
, vP
->vot_name
, (void *) &vP
->vot_detail
);
966 vip_op_defaults (immediate
, indirect
, displen
);
972 /* Take 3 char.s, the last of which may be `\0` (non-existent)
973 and return the VAX register number that they represent.
975 Return -1 if they don't form a register name. Good names return
976 a number from 0:15 inclusive.
978 Case is not important in a name.
980 Register names understood are:
1004 /* Returns the register number of something like '%r15' or 'ap', supplied
1005 in four single chars. Returns -1 if the register isn't recognized,
1008 vax_reg_parse (char c1
, char c2
, char c3
, char c4
)
1013 if (c1
!= '%') /* Register prefixes are mandatory for ELF. */
1020 if (c4
!= 0) /* Register prefixes are not allowed under VMS. */
1024 if (c1
== '%') /* Register prefixes are optional under a.out. */
1030 else if (c3
&& c4
) /* Can't be 4 characters long. */
1036 if (ISDIGIT (c2
) && c1
== 'r')
1041 retval
= retval
* 10 + c3
- '0';
1042 retval
= (retval
> 15) ? -1 : retval
;
1043 /* clamp the register value to 1 hex digit */
1046 retval
= -1; /* c3 must be '\0' or a digit. */
1048 else if (c3
) /* There are no three letter regs. */
1067 else if (c1
== 'p' && c2
== 'c')
1074 /* Parse a vax operand in DEC assembler notation.
1075 For speed, expect a string of whitespace to be reduced to a single ' '.
1076 This is the case for GNU AS, and is easy for other DEC-compatible
1079 Knowledge about DEC VAX assembler operand notation lives here.
1080 This doesn't even know what a register name is, except it believes
1081 all register names are 2 or 3 characters, and lets vax_reg_parse() say
1082 what number each name represents.
1083 It does, however, know that PC, SP etc are special registers so it can
1084 detect addressing modes that are silly for those registers.
1086 Where possible, it delivers 1 fatal or 1 warning message if the operand
1087 is suspect. Exactly what we test for is still evolving.
1092 There were a number of 'mismatched argument type' bugs to vip_op.
1093 The most general solution is to typedef each (of many) arguments.
1094 We used instead a typedef'd argument block. This is less modular
1095 than using separate return pointers for each result, but runs faster
1096 on most engines, and seems to keep programmers happy. It will have
1097 to be done properly if we ever want to use vip_op as a general-purpose
1098 module (it was designed to be).
1102 Doesn't support DEC "G^" format operands. These always take 5 bytes
1103 to express, and code as modes 8F or 9F. Reason: "G^" deprives you of
1104 optimising to (say) a "B^" if you are lucky in the way you link.
1105 When someone builds a linker smart enough to convert "G^" to "B^", "W^"
1106 whenever possible, then we should implement it.
1107 If there is some other use for "G^", feel free to code it in!
1111 If I nested if()s more, I could avoid testing (*err) which would save
1112 time, space and page faults. I didn't nest all those if()s for clarity
1113 and because I think the mode testing can be re-arranged 1st to test the
1114 commoner constructs 1st. Does anybody have statistics on this?
1118 In future, we should be able to 'compose' error messages in a scratch area
1119 and give the user MUCH more informative error messages. Although this takes
1120 a little more code at run-time, it will make this module much more self-
1121 documenting. As an example of what sucks now: most error messages have
1122 hardwired into them the DEC VAX metacharacters "#^@" which are nothing like
1123 the Un*x characters "$`*", that most users will expect from this AS.
1127 The input is a string, ending with '\0'.
1129 We also require a 'hint' of what kind of operand is expected: so
1130 we can remind caller not to write into literals for instance.
1132 The output is a skeletal instruction.
1134 The algorithm has two parts.
1135 1. extract the syntactic features (parse off all the @^#-()+[] mode crud);
1136 2. express the @^#-()+[] as some parameters suited to further analysis.
1138 2nd step is where we detect the googles of possible invalid combinations
1139 a human (or compiler) might write. Note that if we do a half-way
1140 decent assembler, we don't know how long to make (eg) displacement
1141 fields when we first meet them (because they may not have defined values).
1142 So we must wait until we know how many bits are needed for each address,
1143 then we can know both length and opcodes of instructions.
1144 For reason(s) above, we will pass to our caller a 'broken' instruction
1145 of these major components, from which our caller can generate instructions:
1146 - displacement length I^ S^ L^ B^ W^ unspecified
1148 - register R0-R15 or absent
1149 - index register R0-R15 or absent
1150 - expression text what we don't parse
1151 - error text(s) why we couldn't understand the operand
1155 To decode output of this, test errtxt. If errtxt[0] == '\0', then
1156 we had no errors that prevented parsing. Also, if we ever report
1157 an internal bug, errtxt[0] is set non-zero. So one test tells you
1158 if the other outputs are to be taken seriously.
1162 Dec defines the semantics of address modes (and values)
1163 by a two-letter code, explained here.
1165 letter 1: access type
1167 a address calculation - no data access, registers forbidden
1168 b branch displacement
1169 m read - let go of bus - write back "modify"
1171 v bit field address: like 'a' but registers are OK
1173 space no operator (eg ".long foo") [our convention]
1175 letter 2: data type (i.e. width, alignment)
1178 d double precision floating point (D format)
1179 f single precision floating point (F format)
1186 ? simple synthetic branch operand
1187 - unconditional synthetic JSB/JSR operand
1188 ! complex synthetic branch operand
1190 The '-?!' letter 2's are not for external consumption. They are used
1191 for various assemblers. Generally, all unknown widths are assumed 0.
1192 We don't limit your choice of width character.
1194 DEC operands are hard work to parse. For example, '@' as the first
1195 character means indirect (deferred) mode but elsewhere it is a shift
1197 The long-winded explanation of how this is supposed to work is
1198 cancelled. Read a DEC vax manual.
1199 We try hard not to parse anything that MIGHT be part of the expression
1200 buried in that syntax. For example if we see @...(Rn) we don't check
1201 for '-' before the '(' because mode @-(Rn) does not exist.
1203 After parsing we have:
1205 at 1 if leading '@' (or Un*x '*')
1206 len takes one value from " bilsw". eg B^ -> 'b'.
1207 hash 1 if leading '#' (or Un*x '$')
1208 expr_begin, expr_end the expression we did not parse
1209 even though we don't interpret it, we make use
1210 of its presence or absence.
1211 sign -1: -(Rn) 0: absent +1: (Rn)+
1212 paren 1 if () are around register
1213 reg major register number 0:15 -1 means absent
1214 ndx index register number 0:15 -1 means absent
1216 Again, I dare not explain it: just trace ALL the code!
1218 Summary of vip_op outputs.
1222 {@}Rn 5+@ n ' ' optional
1223 branch operand 0 -1 ' ' -1
1225 -(Rn) 7 n ' ' optional
1226 {@}(Rn)+ 8+@ n ' ' optional
1227 {@}#foo, no S^ 8+@ PC " i" optional
1228 {@}{q^}{(Rn)} 10+@+q option " bwl" optional */
1230 /* Dissect user-input 'optext' (which is something like "@B^foo@bar(AP)[FP]:")
1231 using the vop in vopP. vopP's vop_access and vop_width. We fill _ndx, _reg,
1232 _mode, _short, _warn, _error, _expr_begin, _expr_end and _nbytes. */
1235 vip_op (char *optext
, struct vop
*vopP
)
1237 /* Track operand text forward. */
1239 /* Track operand text backward. */
1241 /* 1 if leading '@' ('*') seen. */
1243 /* one of " bilsw" */
1245 /* 1 if leading '#' ('$') seen. */
1249 /* 1 if () surround register. */
1251 /* Register number, -1:absent. */
1253 /* Index register number -1:absent. */
1255 /* Report illegal operand, ""==OK. */
1256 /* " " is a FAKE error: means we won. */
1257 /* ANY err that begins with ' ' is a fake. */
1258 /* " " is converted to "" before return. */
1260 /* Warn about weird modes pf address. */
1262 /* Preserve q in case we backup. */
1264 /* Build up 4-bit operand mode here. */
1265 /* Note: index mode is in ndx, this is. */
1266 /* The major mode of operand address. */
1268 /* Notice how we move wrong-arg-type bugs INSIDE this module: if we
1269 get the types wrong below, we lose at compile time rather than at
1270 lint or run time. */
1271 char access_mode
; /* vop_access. */
1273 access_mode
= vopP
->vop_access
;
1274 /* None of our code bugs (yet), no user text errors, no warnings
1280 if (*p
== ' ') /* Expect all whitespace reduced to ' '. */
1281 p
++; /* skip over whitespace */
1283 if ((at
= INDIRECTP (*p
)) != 0)
1284 { /* 1 if *p=='@'(or '*' for Un*x) */
1285 p
++; /* at is determined */
1286 if (*p
== ' ') /* Expect all whitespace reduced to ' '. */
1287 p
++; /* skip over whitespace */
1290 /* This code is subtle. It tries to detect all legal (letter)'^'
1291 but it doesn't waste time explicitly testing for premature '\0' because
1292 this case is rejected as a mismatch against either (letter) or '^'. */
1298 if (DISPLENP (p
[1]) && strchr ("bilws", len
= c
))
1299 p
+= 2; /* Skip (letter) '^'. */
1300 else /* No (letter) '^' seen. */
1301 len
= ' '; /* Len is determined. */
1304 if (*p
== ' ') /* Expect all whitespace reduced to ' '. */
1307 if ((hash
= IMMEDIATEP (*p
)) != 0) /* 1 if *p=='#' ('$' for Un*x) */
1308 p
++; /* Hash is determined. */
1310 /* p points to what may be the beginning of an expression.
1311 We have peeled off the front all that is peelable.
1312 We know at, len, hash.
1314 Lets point q at the end of the text and parse that (backwards). */
1316 for (q
= p
; *q
; q
++)
1318 q
--; /* Now q points at last char of text. */
1320 if (*q
== ' ' && q
>= p
) /* Expect all whitespace reduced to ' '. */
1323 /* Reverse over whitespace, but don't. */
1324 /* Run back over *p. */
1326 /* As a matter of policy here, we look for [Rn], although both Rn and S^#
1327 forbid [Rn]. This is because it is easy, and because only a sick
1328 cyborg would have [...] trailing an expression in a VAX-like assembler.
1329 A meticulous parser would first check for Rn followed by '(' or '['
1330 and not parse a trailing ']' if it found another. We just ban expressions
1334 while (q
>= p
&& *q
!= '[')
1336 /* Either q<p or we got matching '['. */
1338 err
= _("no '[' to match ']'");
1341 /* Confusers like "[]" will eventually lose with a bad register
1342 * name error. So again we don't need to check for early '\0'. */
1344 ndx
= vax_reg_parse (q
[1], q
[2], 0, 0);
1345 else if (q
[4] == ']')
1346 ndx
= vax_reg_parse (q
[1], q
[2], q
[3], 0);
1347 else if (q
[5] == ']')
1348 ndx
= vax_reg_parse (q
[1], q
[2], q
[3], q
[4]);
1351 /* Since we saw a ']' we will demand a register name in the [].
1352 * If luser hasn't given us one: be rude. */
1354 err
= _("bad register in []");
1356 err
= _("[PC] index banned");
1358 /* Point q just before "[...]". */
1363 /* No ']', so no iNDeX register. */
1366 /* If err = "..." then we lost: run away.
1367 Otherwise ndx == -1 if there was no "[...]".
1368 Otherwise, ndx is index register number, and q points before "[...]". */
1370 if (*q
== ' ' && q
>= p
) /* Expect all whitespace reduced to ' '. */
1372 /* Reverse over whitespace, but don't. */
1373 /* Run back over *p. */
1376 /* no ()+ or -() seen yet */
1379 if (q
> p
+ 3 && *q
== '+' && q
[-1] == ')')
1381 sign
= 1; /* we saw a ")+" */
1382 q
--; /* q points to ')' */
1385 if (*q
== ')' && q
> p
+ 2)
1387 paren
= 1; /* assume we have "(...)" */
1388 while (q
>= p
&& *q
!= '(')
1390 /* either q<p or we got matching '(' */
1392 err
= _("no '(' to match ')'");
1395 /* Confusers like "()" will eventually lose with a bad register
1396 name error. So again we don't need to check for early '\0'. */
1398 reg
= vax_reg_parse (q
[1], q
[2], 0, 0);
1399 else if (q
[4] == ')')
1400 reg
= vax_reg_parse (q
[1], q
[2], q
[3], 0);
1401 else if (q
[5] == ')')
1402 reg
= vax_reg_parse (q
[1], q
[2], q
[3], q
[4]);
1405 /* Since we saw a ')' we will demand a register name in the ')'.
1406 This is nasty: why can't our hypothetical assembler permit
1407 parenthesised expressions? BECAUSE I AM LAZY! That is why.
1408 Abuse luser if we didn't spy a register name. */
1411 /* JF allow parenthesized expressions. I hope this works. */
1415 /* err = "unknown register in ()"; */
1418 q
--; /* point just before '(' of "(...)" */
1419 /* If err == "..." then we lost. Run away.
1420 Otherwise if reg >= 0 then we saw (Rn). */
1422 /* If err == "..." then we lost.
1423 Otherwise paren==1 and reg = register in "()". */
1427 /* If err == "..." then we lost.
1428 Otherwise, q points just before "(Rn)", if any.
1429 If there was a "(...)" then paren==1, and reg is the register. */
1431 /* We should only seek '-' of "-(...)" if:
1432 we saw "(...)" paren == 1
1433 we have no errors so far ! *err
1434 we did not see '+' of "(...)+" sign < 1
1435 We don't check len. We want a specific error message later if
1436 user tries "x^...-(Rn)". This is a feature not a bug. */
1439 if (paren
&& sign
< 1)/* !sign is adequate test */
1447 /* We have back-tracked over most
1448 of the crud at the end of an operand.
1449 Unless err, we know: sign, paren. If paren, we know reg.
1450 The last case is of an expression "Rn".
1451 This is worth hunting for if !err, !paren.
1452 We wouldn't be here if err.
1453 We remember to save q, in case we didn't want "Rn" anyway. */
1456 if (*q
== ' ' && q
>= p
) /* Expect all whitespace reduced to ' '. */
1458 /* Reverse over whitespace, but don't. */
1459 /* Run back over *p. */
1460 /* Room for Rn or Rnn (include prefix) exactly? */
1461 if (q
> p
&& q
< p
+ 4)
1462 reg
= vax_reg_parse (p
[0], p
[1],
1463 q
< p
+ 2 ? 0 : p
[2],
1464 q
< p
+ 3 ? 0 : p
[3]);
1466 reg
= -1; /* Always comes here if no register at all. */
1467 /* Here with a definitive reg value. */
1476 /* have reg. -1:absent; else 0:15. */
1478 /* We have: err, at, len, hash, ndx, sign, paren, reg.
1479 Also, any remaining expression is from *p through *q inclusive.
1480 Should there be no expression, q==p-1. So expression length = q-p+1.
1481 This completes the first part: parsing the operand text. */
1483 /* We now want to boil the data down, checking consistency on the way.
1484 We want: len, mode, reg, ndx, err, p, q, wrn, bug.
1485 We will deliver a 4-bit reg, and a 4-bit mode. */
1487 /* Case of branch operand. Different. No L^B^W^I^S^ allowed for instance.
1501 p:q whatever was input
1503 err " " or error message, and other outputs trashed. */
1504 /* Branch operands have restricted forms. */
1505 if ((!err
|| !*err
) && access_mode
== 'b')
1507 if (at
|| hash
|| sign
|| paren
|| ndx
>= 0 || reg
>= 0 || len
!= ' ')
1508 err
= _("invalid branch operand");
1513 /* Since nobody seems to use it: comment this 'feature'(?) out for now. */
1515 /* Case of stand-alone operand. e.g. ".long foo"
1529 p:q whatever was input
1531 err " " or error message, and other outputs trashed. */
1532 if ((!err
|| !*err
) && access_mode
== ' ')
1535 err
= _("address prohibits @");
1537 err
= _("address prohibits #");
1541 err
= _("address prohibits -()");
1543 err
= _("address prohibits ()+");
1546 err
= _("address prohibits ()");
1548 err
= _("address prohibits []");
1550 err
= _("address prohibits register");
1551 else if (len
!= ' ')
1552 err
= _("address prohibits displacement length specifier");
1555 err
= " "; /* succeed */
1566 p:q demand not empty
1568 paren 0 by "()" scan logic because "S^" seen
1569 reg -1 or nn by mistake
1577 if ((!err
|| !*err
) && len
== 's')
1579 if (!hash
|| paren
|| at
|| ndx
>= 0)
1580 err
= _("invalid operand of S^#");
1585 /* Darn! we saw S^#Rnn ! put the Rnn back in
1586 expression. KLUDGE! Use oldq so we don't
1587 need to know exact length of reg name. */
1591 /* We have all the expression we will ever get. */
1593 err
= _("S^# needs expression");
1594 else if (access_mode
== 'r')
1596 err
= " "; /* WIN! */
1600 err
= _("S^# may only read-access");
1604 /* Case of -(Rn), which is weird case.
1610 sign -1 by definition
1611 paren 1 by definition
1612 reg present by definition
1618 exp "" enforce empty expression
1619 ndx optional warn if same as reg. */
1620 if ((!err
|| !*err
) && sign
< 0)
1622 if (len
!= ' ' || hash
|| at
|| p
<= q
)
1623 err
= _("invalid operand of -()");
1626 err
= " "; /* win */
1629 wrn
= _("-(PC) unpredictable");
1630 else if (reg
== ndx
)
1631 wrn
= _("[]index same as -()register: unpredictable");
1635 /* We convert "(Rn)" to "@Rn" for our convenience.
1636 (I hope this is convenient: has someone got a better way to parse this?)
1637 A side-effect of this is that "@Rn" is a valid operand. */
1638 if (paren
&& !sign
&& !hash
&& !at
&& len
== ' ' && p
> q
)
1644 /* Case of (Rn)+, which is slightly different.
1650 sign +1 by definition
1651 paren 1 by definition
1652 reg present by definition
1658 exp "" enforce empty expression
1659 ndx optional warn if same as reg. */
1660 if ((!err
|| !*err
) && sign
> 0)
1662 if (len
!= ' ' || hash
|| p
<= q
)
1663 err
= _("invalid operand of ()+");
1666 err
= " "; /* win */
1667 mode
= 8 + (at
? 1 : 0);
1669 wrn
= _("(PC)+ unpredictable");
1670 else if (reg
== ndx
)
1671 wrn
= _("[]index same as ()+register: unpredictable");
1675 /* Case of #, without S^.
1679 hash 1 by definition
1691 if ((!err
|| !*err
) && hash
)
1693 if (len
!= 'i' && len
!= ' ')
1694 err
= _("# conflicts length");
1696 err
= _("# bars register");
1701 /* Darn! we saw #Rnn! Put the Rnn back into the expression.
1702 By using oldq, we don't need to know how long Rnn was.
1705 reg
= -1; /* No register any more. */
1707 err
= " "; /* Win. */
1709 /* JF a bugfix, I think! */
1710 if (at
&& access_mode
== 'a')
1711 vopP
->vop_nbytes
= 4;
1713 mode
= (at
? 9 : 8);
1715 if ((access_mode
== 'm' || access_mode
== 'w') && !at
)
1716 wrn
= _("writing or modifying # is unpredictable");
1719 /* If !*err, then sign == 0
1722 /* Case of Rn. We separate this one because it has a few special
1723 errors the remaining modes lack.
1727 hash 0 by program logic
1729 sign 0 by program logic
1730 paren 0 by definition
1731 reg present by definition
1736 len ' ' enforce no length
1737 exp "" enforce empty expression
1738 ndx optional warn if same as reg. */
1739 if ((!err
|| !*err
) && !paren
&& reg
>= 0)
1742 err
= _("length not needed");
1745 err
= " "; /* win */
1749 err
= _("can't []index a register, because it has no address");
1750 else if (access_mode
== 'a')
1751 err
= _("a register has no address");
1754 /* Idea here is to detect from length of datum
1755 and from register number if we will touch PC.
1757 vop_nbytes is number of bytes in operand.
1758 Compute highest byte affected, compare to PC0. */
1759 if ((vopP
->vop_nbytes
+ reg
* 4) > 60)
1760 wrn
= _("PC part of operand unpredictable");
1761 err
= " "; /* win */
1765 /* If !*err, sign == 0
1767 paren == 1 OR reg==-1 */
1769 /* Rest of cases fit into one bunch.
1772 len ' ' or 'b' or 'w' or 'l'
1773 hash 0 by program logic
1774 p:q expected (empty is not an error)
1775 sign 0 by program logic
1780 out: mode 10 + @ + len
1782 len ' ' or 'b' or 'w' or 'l'
1784 ndx optional warn if same as reg. */
1787 err
= " "; /* win (always) */
1788 mode
= 10 + (at
? 1 : 0);
1795 case ' ': /* Assumed B^ until our caller changes it. */
1801 /* here with completely specified mode
1808 err
= 0; /* " " is no longer an error. */
1810 vopP
->vop_mode
= mode
;
1811 vopP
->vop_reg
= reg
;
1812 vopP
->vop_short
= len
;
1813 vopP
->vop_expr_begin
= p
;
1814 vopP
->vop_expr_end
= q
;
1815 vopP
->vop_ndx
= ndx
;
1816 vopP
->vop_error
= err
;
1817 vopP
->vop_warn
= wrn
;
1820 /* This converts a string into a vax instruction.
1821 The string must be a bare single instruction in dec-vax (with BSD4 frobs)
1823 It provides some error messages: at most one fatal error message (which
1824 stops the scan) and at most one warning message for each operand.
1825 The vax instruction is returned in exploded form, since we have no
1826 knowledge of how you parse (or evaluate) your expressions.
1827 We do however strip off and decode addressing modes and operation
1830 The exploded instruction is returned to a struct vit of your choice.
1831 #include "vax-inst.h" to know what a struct vit is.
1833 This function's value is a string. If it is not "" then an internal
1834 logic error was found: read this code to assign meaning to the string.
1835 No argument string should generate such an error string:
1836 it means a bug in our code, not in the user's text.
1838 You MUST have called vip_begin() once before using this function. */
1841 vip (struct vit
*vitP
, /* We build an exploded instruction here. */
1842 char *instring
) /* Text of a vax instruction: we modify. */
1844 /* How to bit-encode this opcode. */
1845 struct vot_wot
*vwP
;
1846 /* 1/skip whitespace.2/scan vot_how */
1849 /* counts number of operands seen */
1850 unsigned char count
;
1851 /* scan operands in struct vit */
1852 struct vop
*operandp
;
1853 /* error over all operands */
1854 const char *alloperr
;
1855 /* Remember char, (we clobber it with '\0' temporarily). */
1857 /* Op-code of this instruction. */
1860 if (*instring
== ' ')
1863 /* MUST end in end-of-string or exactly 1 space. */
1864 for (p
= instring
; *p
&& *p
!= ' '; p
++)
1867 /* Scanned up to end of operation-code. */
1868 /* Operation-code is ended with whitespace. */
1869 if (p
- instring
== 0)
1871 vitP
->vit_error
= _("No operator");
1873 memset (vitP
->vit_opcode
, '\0', sizeof (vitP
->vit_opcode
));
1879 /* Here with instring pointing to what better be an op-name, and p
1880 pointing to character just past that.
1881 We trust instring points to an op-name, with no whitespace. */
1882 vwP
= (struct vot_wot
*) hash_find (op_hash
, instring
);
1883 /* Restore char after op-code. */
1887 vitP
->vit_error
= _("Unknown operator");
1889 memset (vitP
->vit_opcode
, '\0', sizeof (vitP
->vit_opcode
));
1893 /* We found a match! So let's pick up as many operands as the
1894 instruction wants, and even gripe if there are too many.
1895 We expect comma to separate each operand.
1896 We let instring track the text, while p tracks a part of the
1899 /* The lines below know about 2-byte opcodes starting FD,FE or FF.
1900 They also understand synthetic opcodes. Note:
1901 we return 32 bits of opcode, including bucky bits, BUT
1902 an opcode length is either 8 or 16 bits for vit_opcode_nbytes. */
1903 oc
= vwP
->vot_code
; /* The op-code. */
1904 vitP
->vit_opcode_nbytes
= (oc
& 0xFF) >= 0xFD ? 2 : 1;
1905 md_number_to_chars (vitP
->vit_opcode
, oc
, 4);
1906 count
= 0; /* No operands seen yet. */
1907 instring
= p
; /* Point just past operation code. */
1909 for (howp
= vwP
->vot_how
, operandp
= vitP
->vit_operand
;
1910 !(alloperr
&& *alloperr
) && *howp
;
1911 operandp
++, howp
+= 2)
1913 /* Here to parse one operand. Leave instring pointing just
1914 past any one ',' that marks the end of this operand. */
1916 as_fatal (_("odd number of bytes in operand description"));
1919 for (q
= instring
; (c
= *q
) && c
!= ','; q
++)
1921 /* Q points to ',' or '\0' that ends argument. C is that
1924 operandp
->vop_width
= howp
[1];
1925 operandp
->vop_nbytes
= vax_operand_width_size
[(unsigned) howp
[1]];
1926 operandp
->vop_access
= howp
[0];
1927 vip_op (instring
, operandp
);
1928 *q
= c
; /* Restore input text. */
1929 if (operandp
->vop_error
)
1930 alloperr
= _("Bad operand");
1931 instring
= q
+ (c
? 1 : 0); /* Next operand (if any). */
1932 count
++; /* Won another argument, may have an operr. */
1935 alloperr
= _("Not enough operands");
1939 if (*instring
== ' ')
1942 alloperr
= _("Too many operands");
1944 vitP
->vit_error
= alloperr
;
1947 vitP
->vit_operands
= count
;
1952 /* Test program for above. */
1954 struct vit myvit
; /* Build an exploded vax instruction here. */
1955 char answer
[100]; /* Human types a line of vax assembler here. */
1956 char *mybug
; /* "" or an internal logic diagnostic. */
1957 int mycount
; /* Number of operands. */
1958 struct vop
*myvop
; /* Scan operands from myvit. */
1959 int mysynth
; /* 1 means want synthetic opcodes. */
1960 char my_immediate
[200];
1961 char my_indirect
[200];
1962 char my_displen
[200];
1969 printf ("0 means no synthetic instructions. ");
1970 printf ("Value for vip_begin? ");
1972 sscanf (answer
, "%d", &mysynth
);
1973 printf ("Synthetic opcodes %s be included.\n", mysynth
? "will" : "will not");
1974 printf ("enter immediate symbols eg enter # ");
1975 gets (my_immediate
);
1976 printf ("enter indirect symbols eg enter @ ");
1978 printf ("enter displen symbols eg enter ^ ");
1981 if (p
= vip_begin (mysynth
, my_immediate
, my_indirect
, my_displen
))
1982 error ("vip_begin=%s", p
);
1984 printf ("An empty input line will quit you from the vax instruction parser\n");
1987 printf ("vax instruction: ");
1991 break; /* Out of for each input text loop. */
1993 vip (& myvit
, answer
);
1994 if (*myvit
.vit_error
)
1995 printf ("ERR:\"%s\"\n", myvit
.vit_error
);
1998 for (mycount
= myvit
.vit_opcode_nbytes
, p
= myvit
.vit_opcode
;
2001 printf ("%02x ", *p
& 0xFF);
2003 printf (" operand count=%d.\n", mycount
= myvit
.vit_operands
);
2004 for (myvop
= myvit
.vit_operand
; mycount
; mycount
--, myvop
++)
2006 printf ("mode=%xx reg=%xx ndx=%xx len='%c'=%c%c%d. expr=\"",
2007 myvop
->vop_mode
, myvop
->vop_reg
, myvop
->vop_ndx
,
2008 myvop
->vop_short
, myvop
->vop_access
, myvop
->vop_width
,
2010 for (p
= myvop
->vop_expr_begin
; p
<= myvop
->vop_expr_end
; p
++)
2014 if (myvop
->vop_error
)
2015 printf (" err:\"%s\"\n", myvop
->vop_error
);
2017 if (myvop
->vop_warn
)
2018 printf (" wrn:\"%s\"\n", myvop
->vop_warn
);
2022 exit (EXIT_SUCCESS
);
2027 #ifdef TEST /* #Define to use this testbed. */
2029 /* Follows a test program for this function.
2030 We declare arrays non-local in case some of our tiny-minded machines
2031 default to small stacks. Also, helps with some debuggers. */
2033 char answer
[100]; /* Human types into here. */
2046 int my_operand_length
;
2047 char my_immediate
[200];
2048 char my_indirect
[200];
2049 char my_displen
[200];
2054 printf ("enter immediate symbols eg enter # ");
2055 gets (my_immediate
);
2056 printf ("enter indirect symbols eg enter @ ");
2058 printf ("enter displen symbols eg enter ^ ");
2060 vip_op_defaults (my_immediate
, my_indirect
, my_displen
);
2064 printf ("access,width (eg 'ab' or 'wh') [empty line to quit] : ");
2068 exit (EXIT_SUCCESS
);
2069 myaccess
= answer
[0];
2070 mywidth
= answer
[1];
2074 my_operand_length
= 1;
2077 my_operand_length
= 8;
2080 my_operand_length
= 4;
2083 my_operand_length
= 16;
2086 my_operand_length
= 32;
2089 my_operand_length
= 4;
2092 my_operand_length
= 16;
2095 my_operand_length
= 8;
2098 my_operand_length
= 2;
2103 my_operand_length
= 0;
2107 my_operand_length
= 2;
2108 printf ("I dn't understand access width %c\n", mywidth
);
2111 printf ("VAX assembler instruction operand: ");
2114 mybug
= vip_op (answer
, myaccess
, mywidth
, my_operand_length
,
2115 &mymode
, &myreg
, &mylen
, &myleft
, &myright
, &myndx
,
2119 printf ("error: \"%s\"\n", myerr
);
2121 printf (" bug: \"%s\"\n", mybug
);
2126 printf ("warning: \"%s\"\n", mywrn
);
2127 mumble ("mode", mymode
);
2128 mumble ("register", myreg
);
2129 mumble ("index", myndx
);
2130 printf ("width:'%c' ", mylen
);
2131 printf ("expression: \"");
2132 while (myleft
<= myright
)
2133 putchar (*myleft
++);
2140 mumble (char *text
, int value
)
2142 printf ("%s:", text
);
2144 printf ("%xx", value
);
2152 int md_short_jump_size
= 3;
2153 int md_long_jump_size
= 6;
2156 md_create_short_jump (char *ptr
,
2158 addressT to_addr ATTRIBUTE_UNUSED
,
2159 fragS
*frag ATTRIBUTE_UNUSED
,
2160 symbolS
*to_symbol ATTRIBUTE_UNUSED
)
2164 /* This former calculation was off by two:
2165 offset = to_addr - (from_addr + 1);
2166 We need to account for the one byte instruction and also its
2167 two byte operand. */
2168 offset
= to_addr
- (from_addr
+ 1 + 2);
2169 *ptr
++ = VAX_BRW
; /* Branch with word (16 bit) offset. */
2170 md_number_to_chars (ptr
, offset
, 2);
2174 md_create_long_jump (char *ptr
,
2175 addressT from_addr ATTRIBUTE_UNUSED
,
2182 offset
= to_addr
- S_GET_VALUE (to_symbol
);
2183 *ptr
++ = VAX_JMP
; /* Arbitrary jump. */
2184 *ptr
++ = VAX_ABSOLUTE_MODE
;
2185 md_number_to_chars (ptr
, offset
, 4);
2186 fix_new (frag
, ptr
- frag
->fr_literal
, 4, to_symbol
, (long) 0, 0, NO_RELOC
);
2190 const char *md_shortopts
= "d:STt:V+1h:Hv::";
2191 #elif defined(OBJ_ELF)
2192 const char *md_shortopts
= "d:STt:VkKQ:";
2194 const char *md_shortopts
= "d:STt:V";
2196 struct option md_longopts
[] =
2199 #define OPTION_PIC (OPTION_MD_BASE)
2200 { "pic", no_argument
, NULL
, OPTION_PIC
},
2202 { NULL
, no_argument
, NULL
, 0 }
2204 size_t md_longopts_size
= sizeof (md_longopts
);
2207 md_parse_option (int c
, char *arg
)
2212 as_warn (_("SYMBOL TABLE not implemented"));
2216 as_warn (_("TOKEN TRACE not implemented"));
2220 as_warn (_("Displacement length %s ignored!"), arg
);
2224 as_warn (_("I don't need or use temp. file \"%s\"."), arg
);
2228 as_warn (_("I don't use an interpass file! -V ignored"));
2232 case '+': /* For g++. Hash any name > 31 chars long. */
2233 flag_hash_long_names
= 1;
2236 case '1': /* For backward compatibility. */
2240 case 'H': /* Show new symbol after hash truncation. */
2241 flag_show_after_trunc
= 1;
2244 case 'h': /* No hashing of mixed-case names. */
2246 extern char vms_name_mapping
;
2247 vms_name_mapping
= atoi (arg
);
2248 flag_no_hash_mixed_case
= 1;
2254 extern char *compiler_version_string
;
2256 if (!arg
|| !*arg
|| access (arg
, 0) == 0)
2257 return 0; /* Have caller show the assembler version. */
2258 compiler_version_string
= arg
;
2267 break; /* -pic, Position Independent Code. */
2269 /* -Qy, -Qn: SVR4 arguments controlling whether a .comment
2270 section should be emitted or not. FIXME: Not implemented. */
2283 md_show_usage (FILE *stream
)
2285 fprintf (stream
, _("\
2287 -d LENGTH ignored\n\
2294 fprintf (stream
, _("\
2296 -+ hash encode names longer than 31 characters\n\
2297 -1 `const' handling compatible with gcc 1.x\n\
2298 -H show new symbol after hash truncation\n\
2299 -h NUM don't hash mixed-case names, and adjust case:\n\
2300 0 = upper, 2 = lower, 3 = preserve case\n\
2301 -v\"VERSION\" code being assembled was produced by compiler \"VERSION\"\n"));
2305 /* We have no need to default values of symbols. */
2308 md_undefined_symbol (char *name ATTRIBUTE_UNUSED
)
2313 /* Round up a section size to the appropriate boundary. */
2315 md_section_align (segT segment ATTRIBUTE_UNUSED
, valueT size
)
2317 /* Byte alignment is fine */
2321 /* Exactly what point is a PC-relative offset relative TO?
2322 On the vax, they're relative to the address of the offset, plus
2325 md_pcrel_from (fixS
*fixP
)
2327 return fixP
->fx_size
+ fixP
->fx_where
+ fixP
->fx_frag
->fr_address
;
2331 tc_gen_reloc (asection
*section ATTRIBUTE_UNUSED
, fixS
*fixp
)
2334 bfd_reloc_code_real_type code
;
2339 if (fixp
->fx_r_type
!= BFD_RELOC_NONE
)
2341 code
= fixp
->fx_r_type
;
2347 case BFD_RELOC_8_PCREL
:
2348 case BFD_RELOC_16_PCREL
:
2349 case BFD_RELOC_32_PCREL
:
2351 case BFD_RELOC_8_GOT_PCREL
:
2352 case BFD_RELOC_16_GOT_PCREL
:
2353 case BFD_RELOC_32_GOT_PCREL
:
2354 case BFD_RELOC_8_PLT_PCREL
:
2355 case BFD_RELOC_16_PLT_PCREL
:
2356 case BFD_RELOC_32_PLT_PCREL
:
2360 as_bad_where (fixp
->fx_file
, fixp
->fx_line
,
2361 _("Cannot make %s relocation PC relative"),
2362 bfd_get_reloc_code_name (code
));
2368 #define F(SZ,PCREL) (((SZ) << 1) + (PCREL))
2369 switch (F (fixp
->fx_size
, fixp
->fx_pcrel
))
2371 #define MAP(SZ,PCREL,TYPE) case F(SZ,PCREL): code = (TYPE); break
2372 MAP (1, 0, BFD_RELOC_8
);
2373 MAP (2, 0, BFD_RELOC_16
);
2374 MAP (4, 0, BFD_RELOC_32
);
2375 MAP (1, 1, BFD_RELOC_8_PCREL
);
2376 MAP (2, 1, BFD_RELOC_16_PCREL
);
2377 MAP (4, 1, BFD_RELOC_32_PCREL
);
2385 reloc
= xmalloc (sizeof (arelent
));
2386 reloc
->sym_ptr_ptr
= xmalloc (sizeof (asymbol
*));
2387 *reloc
->sym_ptr_ptr
= symbol_get_bfdsym (fixp
->fx_addsy
);
2388 reloc
->address
= fixp
->fx_frag
->fr_address
+ fixp
->fx_where
;
2391 reloc
->addend
= fixp
->fx_addnumber
;
2395 reloc
->addend
= fixp
->fx_offset
;
2398 reloc
->howto
= bfd_reloc_type_lookup (stdoutput
, code
);
2399 gas_assert (reloc
->howto
!= 0);
2404 /* vax:md_assemble() emit frags for 1 instruction given in textual form. */
2406 md_assemble (char *instruction_string
)
2408 /* Non-zero if operand expression's segment is not known yet. */
2410 /* Non-zero if operand expression's segment is absolute. */
2414 /* An operand. Scans all operands. */
2415 struct vop
*operandP
;
2416 char *save_input_line_pointer
;
2417 /* What used to live after an expression. */
2419 /* 1: instruction_string bad for all passes. */
2421 /* Points to slot just after last operand. */
2422 struct vop
*end_operandP
;
2423 /* Points to expression values for this operand. */
2427 /* These refer to an instruction operand expression. */
2428 /* Target segment of the address. */
2430 valueT this_add_number
;
2431 /* Positive (minuend) symbol. */
2432 symbolS
*this_add_symbol
;
2434 long opcode_as_number
;
2435 /* Least significant byte 1st. */
2436 char *opcode_as_chars
;
2437 /* As an array of characters. */
2438 /* Least significant byte 1st */
2439 char *opcode_low_byteP
;
2440 /* length (bytes) meant by vop_short. */
2442 /* 0, or 1 if '@' is in addressing mode. */
2444 /* From vop_nbytes: vax_operand_width (in bytes) */
2446 FLONUM_TYPE
*floatP
;
2447 LITTLENUM_TYPE literal_float
[8];
2448 /* Big enough for any floating point literal. */
2450 vip (&v
, instruction_string
);
2452 /* Now we try to find as many as_warn()s as we can. If we do any as_warn()s
2453 then goofed=1. Notice that we don't make any frags yet.
2454 Should goofed be 1, then this instruction will wedge in any pass,
2455 and we can safely flush it, without causing interpass symbol phase
2456 errors. That is, without changing label values in different passes. */
2457 if ((goofed
= (*v
.vit_error
)) != 0)
2459 as_fatal (_("Ignoring statement due to \"%s\""), v
.vit_error
);
2461 /* We need to use expression() and friends, which require us to diddle
2462 input_line_pointer. So we save it and restore it later. */
2463 save_input_line_pointer
= input_line_pointer
;
2464 for (operandP
= v
.vit_operand
,
2465 expP
= exp_of_operand
,
2466 segP
= seg_of_operand
,
2467 floatP
= float_operand
,
2468 end_operandP
= v
.vit_operand
+ v
.vit_operands
;
2470 operandP
< end_operandP
;
2472 operandP
++, expP
++, segP
++, floatP
++)
2474 if (operandP
->vop_error
)
2476 as_fatal (_("Aborting because statement has \"%s\""), operandP
->vop_error
);
2481 /* Statement has no syntax goofs: let's sniff the expression. */
2482 int can_be_short
= 0; /* 1 if a bignum can be reduced to a short literal. */
2484 input_line_pointer
= operandP
->vop_expr_begin
;
2485 c_save
= operandP
->vop_expr_end
[1];
2486 operandP
->vop_expr_end
[1] = '\0';
2487 /* If to_seg == SEG_PASS1, expression() will have set need_pass_2 = 1. */
2488 *segP
= expression (expP
);
2492 /* for BSD4.2 compatibility, missing expression is absolute 0 */
2493 expP
->X_op
= O_constant
;
2494 expP
->X_add_number
= 0;
2495 /* For SEG_ABSOLUTE, we shouldn't need to set X_op_symbol,
2496 X_add_symbol to any particular value. But, we will program
2497 defensively. Since this situation occurs rarely so it costs
2498 us little to do, and stops Dean worrying about the origin of
2499 random bits in expressionS's. */
2500 expP
->X_add_symbol
= NULL
;
2501 expP
->X_op_symbol
= NULL
;
2509 /* Major bug. We can't handle the case of a
2510 SEG_OP expression in a VIT_OPCODE_SYNTHETIC
2511 variable-length instruction.
2512 We don't have a frag type that is smart enough to
2513 relax a SEG_OP, and so we just force all
2514 SEG_OPs to behave like SEG_PASS1s.
2515 Clearly, if there is a demand we can invent a new or
2516 modified frag type and then coding up a frag for this
2517 case will be easy. SEG_OP was invented for the
2518 .words after a CASE opcode, and was never intended for
2519 instruction operands. */
2521 as_fatal (_("Can't relocate expression"));
2525 /* Preserve the bits. */
2526 if (expP
->X_add_number
> 0)
2528 bignum_copy (generic_bignum
, expP
->X_add_number
,
2529 floatP
->low
, SIZE_OF_LARGE_NUMBER
);
2533 know (expP
->X_add_number
< 0);
2534 flonum_copy (&generic_floating_point_number
,
2536 if (strchr ("s i", operandP
->vop_short
))
2538 /* Could possibly become S^# */
2539 flonum_gen2vax (-expP
->X_add_number
, floatP
, literal_float
);
2540 switch (-expP
->X_add_number
)
2544 (literal_float
[0] & 0xFC0F) == 0x4000
2545 && literal_float
[1] == 0;
2550 (literal_float
[0] & 0xFC0F) == 0x4000
2551 && literal_float
[1] == 0
2552 && literal_float
[2] == 0
2553 && literal_float
[3] == 0;
2558 (literal_float
[0] & 0xFF81) == 0x4000
2559 && literal_float
[1] == 0
2560 && literal_float
[2] == 0
2561 && literal_float
[3] == 0;
2565 can_be_short
= ((literal_float
[0] & 0xFFF8) == 0x4000
2566 && (literal_float
[1] & 0xE000) == 0
2567 && literal_float
[2] == 0
2568 && literal_float
[3] == 0
2569 && literal_float
[4] == 0
2570 && literal_float
[5] == 0
2571 && literal_float
[6] == 0
2572 && literal_float
[7] == 0);
2576 BAD_CASE (-expP
->X_add_number
);
2582 if (operandP
->vop_short
== 's'
2583 || operandP
->vop_short
== 'i'
2584 || (operandP
->vop_short
== ' '
2585 && operandP
->vop_reg
== 0xF
2586 && (operandP
->vop_mode
& 0xE) == 0x8))
2589 if (operandP
->vop_short
== ' ')
2591 /* We must chose S^ or I^. */
2592 if (expP
->X_add_number
> 0)
2594 /* Bignum: Short literal impossible. */
2595 operandP
->vop_short
= 'i';
2596 operandP
->vop_mode
= 8;
2597 operandP
->vop_reg
= 0xF; /* VAX PC. */
2601 /* Flonum: Try to do it. */
2604 operandP
->vop_short
= 's';
2605 operandP
->vop_mode
= 0;
2606 operandP
->vop_ndx
= -1;
2607 operandP
->vop_reg
= -1;
2608 expP
->X_op
= O_constant
;
2612 operandP
->vop_short
= 'i';
2613 operandP
->vop_mode
= 8;
2614 operandP
->vop_reg
= 0xF; /* VAX PC */
2616 } /* bignum or flonum ? */
2617 } /* if #, but no S^ or I^ seen. */
2618 /* No more ' ' case: either 's' or 'i'. */
2619 if (operandP
->vop_short
== 's')
2621 /* Wants to be a short literal. */
2622 if (expP
->X_add_number
> 0)
2624 as_warn (_("Bignum not permitted in short literal. Immediate mode assumed."));
2625 operandP
->vop_short
= 'i';
2626 operandP
->vop_mode
= 8;
2627 operandP
->vop_reg
= 0xF; /* VAX PC. */
2633 as_warn (_("Can't do flonum short literal: immediate mode used."));
2634 operandP
->vop_short
= 'i';
2635 operandP
->vop_mode
= 8;
2636 operandP
->vop_reg
= 0xF; /* VAX PC. */
2640 /* Encode short literal now. */
2643 switch (-expP
->X_add_number
)
2647 temp
= literal_float
[0] >> 4;
2651 temp
= literal_float
[0] >> 1;
2655 temp
= ((literal_float
[0] << 3) & 070)
2656 | ((literal_float
[1] >> 13) & 07);
2660 BAD_CASE (-expP
->X_add_number
);
2664 floatP
->low
[0] = temp
& 077;
2671 /* I^# seen: set it up if float. */
2672 if (expP
->X_add_number
< 0)
2674 memcpy (floatP
->low
, literal_float
, sizeof (literal_float
));
2676 } /* if S^# seen. */
2680 as_warn (_("A bignum/flonum may not be a displacement: 0x%lx used"),
2681 (expP
->X_add_number
= 0x80000000L
));
2682 /* Chosen so luser gets the most offset bits to patch later. */
2684 expP
->X_add_number
= floatP
->low
[0]
2685 | ((LITTLENUM_MASK
& (floatP
->low
[1])) << LITTLENUM_NUMBER_OF_BITS
);
2687 /* For the O_big case we have:
2688 If vop_short == 's' then a short floating literal is in the
2689 lowest 6 bits of floatP -> low [0], which is
2690 big_operand_bits [---] [0].
2691 If vop_short == 'i' then the appropriate number of elements
2692 of big_operand_bits [---] [...] are set up with the correct
2694 Also, just in case width is byte word or long, we copy the lowest
2695 32 bits of the number to X_add_number. */
2698 if (input_line_pointer
!= operandP
->vop_expr_end
+ 1)
2700 as_fatal ("Junk at end of expression \"%s\"", input_line_pointer
);
2703 operandP
->vop_expr_end
[1] = c_save
;
2707 input_line_pointer
= save_input_line_pointer
;
2709 if (need_pass_2
|| goofed
)
2712 dwarf2_emit_insn (0);
2714 /* Remember where it is, in case we want to modify the op-code later. */
2715 opcode_low_byteP
= frag_more (v
.vit_opcode_nbytes
);
2716 memcpy (opcode_low_byteP
, v
.vit_opcode
, v
.vit_opcode_nbytes
);
2717 opcode_as_chars
= v
.vit_opcode
;
2718 opcode_as_number
= md_chars_to_number ((unsigned char *) opcode_as_chars
, 4);
2719 for (operandP
= v
.vit_operand
,
2720 expP
= exp_of_operand
,
2721 segP
= seg_of_operand
,
2722 floatP
= float_operand
,
2723 end_operandP
= v
.vit_operand
+ v
.vit_operands
;
2725 operandP
< end_operandP
;
2732 if (operandP
->vop_ndx
>= 0)
2734 /* Indexed addressing byte. */
2735 /* Legality of indexed mode already checked: it is OK. */
2736 FRAG_APPEND_1_CHAR (0x40 + operandP
->vop_ndx
);
2737 } /* if(vop_ndx>=0) */
2739 /* Here to make main operand frag(s). */
2740 this_add_number
= expP
->X_add_number
;
2741 this_add_symbol
= expP
->X_add_symbol
;
2743 is_undefined
= (to_seg
== undefined_section
);
2744 is_absolute
= (to_seg
== absolute_section
);
2745 at
= operandP
->vop_mode
& 1;
2746 length
= (operandP
->vop_short
== 'b'
2747 ? 1 : (operandP
->vop_short
== 'w'
2748 ? 2 : (operandP
->vop_short
== 'l'
2750 nbytes
= operandP
->vop_nbytes
;
2751 if (operandP
->vop_access
== 'b')
2753 if (to_seg
== now_seg
|| is_undefined
)
2755 /* If is_undefined, then it might BECOME now_seg. */
2758 p
= frag_more (nbytes
);
2759 fix_new (frag_now
, p
- frag_now
->fr_literal
, nbytes
,
2760 this_add_symbol
, this_add_number
, 1, NO_RELOC
);
2764 /* to_seg==now_seg || to_seg == SEG_UNKNOWN */
2766 length_code
= is_undefined
? STATE_UNDF
: STATE_BYTE
;
2767 if (opcode_as_number
& VIT_OPCODE_SPECIAL
)
2769 if (operandP
->vop_width
== VAX_WIDTH_UNCONDITIONAL_JUMP
)
2772 frag_var (rs_machine_dependent
, 5, 1,
2773 ENCODE_RELAX (STATE_ALWAYS_BRANCH
, length_code
),
2774 this_add_symbol
, this_add_number
,
2779 if (operandP
->vop_width
== VAX_WIDTH_WORD_JUMP
)
2781 length_code
= STATE_WORD
;
2782 /* JF: There is no state_byte for this one! */
2783 frag_var (rs_machine_dependent
, 10, 2,
2784 ENCODE_RELAX (STATE_COMPLEX_BRANCH
, length_code
),
2785 this_add_symbol
, this_add_number
,
2790 know (operandP
->vop_width
== VAX_WIDTH_BYTE_JUMP
);
2791 frag_var (rs_machine_dependent
, 9, 1,
2792 ENCODE_RELAX (STATE_COMPLEX_HOP
, length_code
),
2793 this_add_symbol
, this_add_number
,
2800 know (operandP
->vop_width
== VAX_WIDTH_CONDITIONAL_JUMP
);
2801 frag_var (rs_machine_dependent
, 7, 1,
2802 ENCODE_RELAX (STATE_CONDITIONAL_BRANCH
, length_code
),
2803 this_add_symbol
, this_add_number
,
2810 /* to_seg != now_seg && to_seg != SEG_UNKNOWN */
2811 /* --- SEG FLOAT MAY APPEAR HERE --- */
2816 know (!(opcode_as_number
& VIT_OPCODE_SYNTHETIC
));
2817 p
= frag_more (nbytes
);
2818 /* Conventional relocation. */
2819 fix_new (frag_now
, p
- frag_now
->fr_literal
, nbytes
,
2820 section_symbol (absolute_section
),
2821 this_add_number
, 1, NO_RELOC
);
2825 know (opcode_as_number
& VIT_OPCODE_SYNTHETIC
);
2826 if (opcode_as_number
& VIT_OPCODE_SPECIAL
)
2828 if (operandP
->vop_width
== VAX_WIDTH_UNCONDITIONAL_JUMP
)
2831 *opcode_low_byteP
= opcode_as_chars
[0] + VAX_WIDEN_LONG
;
2832 know (opcode_as_chars
[1] == 0);
2834 p
[0] = VAX_ABSOLUTE_MODE
; /* @#... */
2835 md_number_to_chars (p
+ 1, this_add_number
, 4);
2836 /* Now (eg) JMP @#foo or JSB @#foo. */
2840 if (operandP
->vop_width
== VAX_WIDTH_WORD_JUMP
)
2848 p
[5] = VAX_ABSOLUTE_MODE
; /* @#... */
2849 md_number_to_chars (p
+ 6, this_add_number
, 4);
2857 know (operandP
->vop_width
== VAX_WIDTH_BYTE_JUMP
);
2863 p
[4] = VAX_ABSOLUTE_MODE
; /* @#... */
2864 md_number_to_chars (p
+ 5, this_add_number
, 4);
2865 /* Now (eg) xOBxxx 1f
2875 *opcode_low_byteP
^= 1;
2876 /* To reverse the condition in a VAX branch,
2877 complement the lowest order bit. */
2881 p
[2] = VAX_ABSOLUTE_MODE
; /* @#... */
2882 md_number_to_chars (p
+ 3, this_add_number
, 4);
2891 /* to_seg != now_seg && !is_undefinfed && !is_absolute */
2894 /* Pc-relative. Conventional relocation. */
2895 know (!(opcode_as_number
& VIT_OPCODE_SYNTHETIC
));
2896 p
= frag_more (nbytes
);
2897 fix_new (frag_now
, p
- frag_now
->fr_literal
, nbytes
,
2898 section_symbol (absolute_section
),
2899 this_add_number
, 1, NO_RELOC
);
2903 know (opcode_as_number
& VIT_OPCODE_SYNTHETIC
);
2904 if (opcode_as_number
& VIT_OPCODE_SPECIAL
)
2906 if (operandP
->vop_width
== VAX_WIDTH_UNCONDITIONAL_JUMP
)
2909 know (opcode_as_chars
[1] == 0);
2910 *opcode_low_byteP
= opcode_as_chars
[0] + VAX_WIDEN_LONG
;
2912 p
[0] = VAX_PC_RELATIVE_MODE
;
2914 p
+ 1 - frag_now
->fr_literal
, 4,
2916 this_add_number
, 1, NO_RELOC
);
2917 /* Now eg JMP foo or JSB foo. */
2921 if (operandP
->vop_width
== VAX_WIDTH_WORD_JUMP
)
2929 p
[5] = VAX_PC_RELATIVE_MODE
;
2931 p
+ 6 - frag_now
->fr_literal
, 4,
2933 this_add_number
, 1, NO_RELOC
);
2941 know (operandP
->vop_width
== VAX_WIDTH_BYTE_JUMP
);
2947 p
[4] = VAX_PC_RELATIVE_MODE
;
2949 p
+ 5 - frag_now
->fr_literal
,
2951 this_add_number
, 1, NO_RELOC
);
2952 /* Now (eg) xOBxxx 1f
2961 know (operandP
->vop_width
== VAX_WIDTH_CONDITIONAL_JUMP
);
2962 *opcode_low_byteP
^= 1; /* Reverse branch condition. */
2966 p
[2] = VAX_PC_RELATIVE_MODE
;
2967 fix_new (frag_now
, p
+ 3 - frag_now
->fr_literal
,
2969 this_add_number
, 1, NO_RELOC
);
2977 /* So it is ordinary operand. */
2978 know (operandP
->vop_access
!= 'b');
2979 /* ' ' target-independent: elsewhere. */
2980 know (operandP
->vop_access
!= ' ');
2981 know (operandP
->vop_access
== 'a'
2982 || operandP
->vop_access
== 'm'
2983 || operandP
->vop_access
== 'r'
2984 || operandP
->vop_access
== 'v'
2985 || operandP
->vop_access
== 'w');
2986 if (operandP
->vop_short
== 's')
2990 if (this_add_number
>= 64)
2992 as_warn (_("Short literal overflow(%ld.), immediate mode assumed."),
2993 (long) this_add_number
);
2994 operandP
->vop_short
= 'i';
2995 operandP
->vop_mode
= 8;
2996 operandP
->vop_reg
= 0xF;
3001 as_warn (_("Forced short literal to immediate mode. now_seg=%s to_seg=%s"),
3002 segment_name (now_seg
), segment_name (to_seg
));
3003 operandP
->vop_short
= 'i';
3004 operandP
->vop_mode
= 8;
3005 operandP
->vop_reg
= 0xF;
3008 if (operandP
->vop_reg
>= 0 && (operandP
->vop_mode
< 8
3009 || (operandP
->vop_reg
!= 0xF && operandP
->vop_mode
< 10)))
3011 /* One byte operand. */
3012 know (operandP
->vop_mode
> 3);
3013 FRAG_APPEND_1_CHAR (operandP
->vop_mode
<< 4 | operandP
->vop_reg
);
3014 /* All 1-bytes except S^# happen here. */
3018 /* {@}{q^}foo{(Rn)} or S^#foo */
3019 if (operandP
->vop_reg
== -1 && operandP
->vop_short
!= 's')
3022 if (to_seg
== now_seg
)
3026 know (operandP
->vop_short
== ' ');
3027 length_code
= STATE_BYTE
;
3029 if (S_IS_EXTERNAL (this_add_symbol
)
3030 || S_IS_WEAK (this_add_symbol
))
3031 length_code
= STATE_UNDF
;
3033 p
= frag_var (rs_machine_dependent
, 10, 2,
3034 ENCODE_RELAX (STATE_PC_RELATIVE
, length_code
),
3035 this_add_symbol
, this_add_number
,
3037 know (operandP
->vop_mode
== 10 + at
);
3039 /* At is the only context we need to carry
3040 to other side of relax() process. Must
3041 be in the correct bit position of VAX
3042 operand spec. byte. */
3047 know (operandP
->vop_short
!= ' ');
3048 p
= frag_more (length
+ 1);
3049 p
[0] = 0xF | ((at
+ "?\12\14?\16"[length
]) << 4);
3050 fix_new (frag_now
, p
+ 1 - frag_now
->fr_literal
,
3051 length
, this_add_symbol
,
3052 this_add_number
, 1, NO_RELOC
);
3057 /* to_seg != now_seg */
3058 if (this_add_symbol
== NULL
)
3061 /* Do @#foo: simpler relocation than foo-.(pc) anyway. */
3063 p
[0] = VAX_ABSOLUTE_MODE
; /* @#... */
3064 md_number_to_chars (p
+ 1, this_add_number
, 4);
3065 if (length
&& length
!= 4)
3066 as_warn (_("Length specification ignored. Address mode 9F used"));
3070 /* {@}{q^}other_seg */
3071 know ((length
== 0 && operandP
->vop_short
== ' ')
3072 || (length
> 0 && operandP
->vop_short
!= ' '));
3075 || S_IS_WEAK(this_add_symbol
)
3076 || S_IS_EXTERNAL(this_add_symbol
)
3082 default: length_code
= STATE_UNDF
; break;
3083 case 1: length_code
= STATE_BYTE
; break;
3084 case 2: length_code
= STATE_WORD
; break;
3085 case 4: length_code
= STATE_LONG
; break;
3087 /* We have a SEG_UNKNOWN symbol. It might
3088 turn out to be in the same segment as
3089 the instruction, permitting relaxation. */
3090 p
= frag_var (rs_machine_dependent
, 5, 2,
3091 ENCODE_RELAX (STATE_PC_RELATIVE
, length_code
),
3092 this_add_symbol
, this_add_number
,
3100 know (operandP
->vop_short
== ' ');
3101 length
= 4; /* Longest possible. */
3103 p
= frag_more (length
+ 1);
3104 p
[0] = 0xF | ((at
+ "?\12\14?\16"[length
]) << 4);
3105 md_number_to_chars (p
+ 1, this_add_number
, length
);
3107 p
+ 1 - frag_now
->fr_literal
,
3108 length
, this_add_symbol
,
3109 this_add_number
, 1, NO_RELOC
);
3116 /* {@}{q^}foo(Rn) or S^# or I^# or # */
3117 if (operandP
->vop_mode
< 0xA)
3119 /* # or S^# or I^# */
3120 if (operandP
->vop_access
== 'v'
3121 || operandP
->vop_access
== 'a')
3123 if (operandP
->vop_access
== 'v')
3124 as_warn (_("Invalid operand: immediate value used as base address."));
3126 as_warn (_("Invalid operand: immediate value used as address."));
3127 /* gcc 2.6.3 is known to generate these in at least
3131 && is_absolute
&& (expP
->X_op
!= O_big
)
3132 && operandP
->vop_mode
== 8 /* No '@'. */
3133 && this_add_number
< 64)
3135 operandP
->vop_short
= 's';
3137 if (operandP
->vop_short
== 's')
3139 FRAG_APPEND_1_CHAR (this_add_number
);
3145 p
= frag_more (nbytes
+ 1);
3146 know (operandP
->vop_reg
== 0xF);
3148 if (flag_want_pic
&& operandP
->vop_mode
== 8
3149 && this_add_symbol
!= NULL
)
3151 as_warn (_("Symbol %s used as immediate operand in PIC mode."),
3152 S_GET_NAME (this_add_symbol
));
3155 p
[0] = (operandP
->vop_mode
<< 4) | 0xF;
3156 if ((is_absolute
) && (expP
->X_op
!= O_big
))
3158 /* If nbytes > 4, then we are scrod. We
3159 don't know if the high order bytes
3160 are to be 0xFF or 0x00. BSD4.2 & RMS
3161 say use 0x00. OK --- but this
3162 assembler needs ANOTHER rewrite to
3163 cope properly with this bug. */
3164 md_number_to_chars (p
+ 1, this_add_number
,
3165 min (sizeof (valueT
),
3167 if ((size_t) nbytes
> sizeof (valueT
))
3168 memset (p
+ 1 + sizeof (valueT
),
3169 '\0', nbytes
- sizeof (valueT
));
3173 if (expP
->X_op
== O_big
)
3175 /* Problem here is to get the bytes
3176 in the right order. We stored
3177 our constant as LITTLENUMs, not
3189 for (p
++; nbytes
; nbytes
-= 2, p
+= 2, lP
++)
3190 md_number_to_chars (p
, *lP
, 2);
3195 fix_new (frag_now
, p
+ 1 - frag_now
->fr_literal
,
3196 nbytes
, this_add_symbol
,
3197 this_add_number
, 0, NO_RELOC
);
3204 /* {@}{q^}foo(Rn) */
3205 know ((length
== 0 && operandP
->vop_short
== ' ')
3206 || (length
> 0 && operandP
->vop_short
!= ' '));
3213 test
= this_add_number
;
3218 length
= test
& 0xffff8000 ? 4
3219 : test
& 0xffffff80 ? 2
3227 p
= frag_more (1 + length
);
3228 know (operandP
->vop_reg
>= 0);
3229 p
[0] = operandP
->vop_reg
3230 | ((at
| "?\12\14?\16"[length
]) << 4);
3233 md_number_to_chars (p
+ 1, this_add_number
, length
);
3237 fix_new (frag_now
, p
+ 1 - frag_now
->fr_literal
,
3238 length
, this_add_symbol
,
3239 this_add_number
, 0, NO_RELOC
);
3255 if ((errtxt
= vip_begin (1, "$", "*", "`")) != 0)
3256 as_fatal (_("VIP_BEGIN error:%s"), errtxt
);
3258 for (i
= 0, fP
= float_operand
;
3259 fP
< float_operand
+ VIT_MAX_OPERANDS
;
3262 fP
->low
= &big_operand_bits
[i
][0];
3263 fP
->high
= &big_operand_bits
[i
][SIZE_OF_LARGE_NUMBER
- 1];
3267 static char *vax_cons_special_reloc
;
3270 vax_cons (expressionS
*exp
, int size
)
3275 vax_cons_special_reloc
= NULL
;
3276 save
= input_line_pointer
;
3277 if (input_line_pointer
[0] == '%')
3279 if (strncmp (input_line_pointer
+ 1, "pcrel", 5) == 0)
3281 input_line_pointer
+= 6;
3282 vax_cons_special_reloc
= "pcrel";
3284 if (vax_cons_special_reloc
)
3291 if (*input_line_pointer
!= '8')
3293 input_line_pointer
--;
3296 if (input_line_pointer
[0] != '1' || input_line_pointer
[1] != '6')
3300 if (input_line_pointer
[0] != '3' || input_line_pointer
[1] != '2')
3310 as_bad (_("Illegal operands: Only %%r_%s%d allowed in %d-byte data fields"),
3311 vax_cons_special_reloc
, size
* 8, size
);
3315 input_line_pointer
+= 2;
3316 if (*input_line_pointer
!= '(')
3318 as_bad (_("Illegal operands: %%r_%s%d requires arguments in ()"),
3319 vax_cons_special_reloc
, size
* 8);
3326 input_line_pointer
= save
;
3327 vax_cons_special_reloc
= NULL
;
3332 char *end
= ++input_line_pointer
;
3335 while (! is_end_of_line
[(c
= *end
)])
3349 as_bad (_("Illegal operands: %%r_%s%d requires arguments in ()"),
3350 vax_cons_special_reloc
, size
* 8);
3356 if (input_line_pointer
!= end
)
3358 as_bad (_("Illegal operands: %%r_%s%d requires arguments in ()"),
3359 vax_cons_special_reloc
, size
* 8);
3363 input_line_pointer
++;
3365 c
= *input_line_pointer
;
3366 if (! is_end_of_line
[c
] && c
!= ',')
3367 as_bad (_("Illegal operands: garbage after %%r_%s%d()"),
3368 vax_cons_special_reloc
, size
* 8);
3374 if (vax_cons_special_reloc
== NULL
)
3378 /* This is called by emit_expr via TC_CONS_FIX_NEW when creating a
3379 reloc for a cons. */
3382 vax_cons_fix_new (fragS
*frag
, int where
, unsigned int nbytes
, expressionS
*exp
)
3384 bfd_reloc_code_real_type r
;
3386 r
= (nbytes
== 1 ? BFD_RELOC_8
:
3387 (nbytes
== 2 ? BFD_RELOC_16
: BFD_RELOC_32
));
3389 if (vax_cons_special_reloc
)
3391 if (*vax_cons_special_reloc
== 'p')
3395 case 1: r
= BFD_RELOC_8_PCREL
; break;
3396 case 2: r
= BFD_RELOC_16_PCREL
; break;
3397 case 4: r
= BFD_RELOC_32_PCREL
; break;
3403 fix_new_exp (frag
, where
, (int) nbytes
, exp
, 0, r
);
3404 vax_cons_special_reloc
= NULL
;
3408 md_atof (int type
, char * litP
, int * sizeP
)
3410 return vax_md_atof (type
, litP
, sizeP
);