1 /* tc-vax.c - vax-specific -
2 Copyright (C) 1987-2018 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 + 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 + 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 struct hash_control *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 */
960 const char *retval = 0; /* error text */
962 op_hash = hash_new ();
964 for (vP = votstrs; *vP->vot_name && !retval; vP++)
965 retval = hash_insert (op_hash, vP->vot_name, (void *) &vP->vot_detail);
968 for (vP = synthetic_votstrs; *vP->vot_name && !retval; vP++)
969 retval = hash_insert (op_hash, vP->vot_name, (void *) &vP->vot_detail);
972 vip_op_defaults (immediate, indirect, displen);
978 /* Take 3 char.s, the last of which may be `\0` (non-existent)
979 and return the VAX register number that they represent.
981 Return -1 if they don't form a register name. Good names return
982 a number from 0:15 inclusive.
984 Case is not important in a name.
986 Register names understood are:
1010 /* Returns the register number of something like '%r15' or 'ap', supplied
1011 in four single chars. Returns -1 if the register isn't recognized,
1014 vax_reg_parse (char c1, char c2, char c3, char c4)
1019 if (c1 != '%') /* Register prefixes are mandatory for ELF. */
1026 if (c4 != 0) /* Register prefixes are not allowed under VMS. */
1030 if (c1 == '%') /* Register prefixes are optional under a.out. */
1036 else if (c3 && c4) /* Can't be 4 characters long. */
1042 if (ISDIGIT (c2) && c1 == 'r')
1047 retval = retval * 10 + c3 - '0';
1048 retval = (retval > 15) ? -1 : retval;
1049 /* clamp the register value to 1 hex digit */
1052 retval = -1; /* c3 must be '\0' or a digit. */
1054 else if (c3) /* There are no three letter regs. */
1073 else if (c1 == 'p' && c2 == 'c')
1080 /* Parse a vax operand in DEC assembler notation.
1081 For speed, expect a string of whitespace to be reduced to a single ' '.
1082 This is the case for GNU AS, and is easy for other DEC-compatible
1085 Knowledge about DEC VAX assembler operand notation lives here.
1086 This doesn't even know what a register name is, except it believes
1087 all register names are 2 or 3 characters, and lets vax_reg_parse() say
1088 what number each name represents.
1089 It does, however, know that PC, SP etc are special registers so it can
1090 detect addressing modes that are silly for those registers.
1092 Where possible, it delivers 1 fatal or 1 warning message if the operand
1093 is suspect. Exactly what we test for is still evolving.
1098 There were a number of 'mismatched argument type' bugs to vip_op.
1099 The most general solution is to typedef each (of many) arguments.
1100 We used instead a typedef'd argument block. This is less modular
1101 than using separate return pointers for each result, but runs faster
1102 on most engines, and seems to keep programmers happy. It will have
1103 to be done properly if we ever want to use vip_op as a general-purpose
1104 module (it was designed to be).
1108 Doesn't support DEC "G^" format operands. These always take 5 bytes
1109 to express, and code as modes 8F or 9F. Reason: "G^" deprives you of
1110 optimising to (say) a "B^" if you are lucky in the way you link.
1111 When someone builds a linker smart enough to convert "G^" to "B^", "W^"
1112 whenever possible, then we should implement it.
1113 If there is some other use for "G^", feel free to code it in!
1117 If I nested if()s more, I could avoid testing (*err) which would save
1118 time, space and page faults. I didn't nest all those if()s for clarity
1119 and because I think the mode testing can be re-arranged 1st to test the
1120 commoner constructs 1st. Does anybody have statistics on this?
1124 In future, we should be able to 'compose' error messages in a scratch area
1125 and give the user MUCH more informative error messages. Although this takes
1126 a little more code at run-time, it will make this module much more self-
1127 documenting. As an example of what sucks now: most error messages have
1128 hardwired into them the DEC VAX metacharacters "#^@" which are nothing like
1129 the Un*x characters "$`*", that most users will expect from this AS.
1133 The input is a string, ending with '\0'.
1135 We also require a 'hint' of what kind of operand is expected: so
1136 we can remind caller not to write into literals for instance.
1138 The output is a skeletal instruction.
1140 The algorithm has two parts.
1141 1. extract the syntactic features (parse off all the @^#-()+[] mode crud);
1142 2. express the @^#-()+[] as some parameters suited to further analysis.
1144 2nd step is where we detect the googles of possible invalid combinations
1145 a human (or compiler) might write. Note that if we do a half-way
1146 decent assembler, we don't know how long to make (eg) displacement
1147 fields when we first meet them (because they may not have defined values).
1148 So we must wait until we know how many bits are needed for each address,
1149 then we can know both length and opcodes of instructions.
1150 For reason(s) above, we will pass to our caller a 'broken' instruction
1151 of these major components, from which our caller can generate instructions:
1152 - displacement length I^ S^ L^ B^ W^ unspecified
1154 - register R0-R15 or absent
1155 - index register R0-R15 or absent
1156 - expression text what we don't parse
1157 - error text(s) why we couldn't understand the operand
1161 To decode output of this, test errtxt. If errtxt[0] == '\0', then
1162 we had no errors that prevented parsing. Also, if we ever report
1163 an internal bug, errtxt[0] is set non-zero. So one test tells you
1164 if the other outputs are to be taken seriously.
1168 Dec defines the semantics of address modes (and values)
1169 by a two-letter code, explained here.
1171 letter 1: access type
1173 a address calculation - no data access, registers forbidden
1174 b branch displacement
1175 m read - let go of bus - write back "modify"
1177 v bit field address: like 'a' but registers are OK
1179 space no operator (eg ".long foo") [our convention]
1181 letter 2: data type (i.e. width, alignment)
1184 d double precision floating point (D format)
1185 f single precision floating point (F format)
1192 ? simple synthetic branch operand
1193 - unconditional synthetic JSB/JSR operand
1194 ! complex synthetic branch operand
1196 The '-?!' letter 2's are not for external consumption. They are used
1197 for various assemblers. Generally, all unknown widths are assumed 0.
1198 We don't limit your choice of width character.
1200 DEC operands are hard work to parse. For example, '@' as the first
1201 character means indirect (deferred) mode but elsewhere it is a shift
1203 The long-winded explanation of how this is supposed to work is
1204 cancelled. Read a DEC vax manual.
1205 We try hard not to parse anything that MIGHT be part of the expression
1206 buried in that syntax. For example if we see @...(Rn) we don't check
1207 for '-' before the '(' because mode @-(Rn) does not exist.
1209 After parsing we have:
1211 at 1 if leading '@' (or Un*x '*')
1212 len takes one value from " bilsw". eg B^ -> 'b'.
1213 hash 1 if leading '#' (or Un*x '$')
1214 expr_begin, expr_end the expression we did not parse
1215 even though we don't interpret it, we make use
1216 of its presence or absence.
1217 sign -1: -(Rn) 0: absent +1: (Rn)+
1218 paren 1 if () are around register
1219 reg major register number 0:15 -1 means absent
1220 ndx index register number 0:15 -1 means absent
1222 Again, I dare not explain it: just trace ALL the code!
1224 Summary of vip_op outputs.
1228 {@}Rn 5+@ n ' ' optional
1229 branch operand 0 -1 ' ' -1
1231 -(Rn) 7 n ' ' optional
1232 {@}(Rn)+ 8+@ n ' ' optional
1233 {@}#foo, no S^ 8+@ PC " i" optional
1234 {@}{q^}{(Rn)} 10+@+q option " bwl" optional */
1236 /* Dissect user-input 'optext' (which is something like "@B^foo@bar(AP)[FP]:")
1237 using the vop in vopP. vopP's vop_access and vop_width. We fill _ndx, _reg,
1238 _mode, _short, _warn, _error, _expr_begin, _expr_end and _nbytes. */
1241 vip_op (char *optext, struct vop *vopP)
1243 /* Track operand text forward. */
1245 /* Track operand text backward. */
1247 /* 1 if leading '@' ('*') seen. */
1249 /* one of " bilsw" */
1251 /* 1 if leading '#' ('$') seen. */
1255 /* 1 if () surround register. */
1257 /* Register number, -1:absent. */
1259 /* Index register number -1:absent. */
1261 /* Report illegal operand, ""==OK. */
1262 /* " " is a FAKE error: means we won. */
1263 /* ANY err that begins with ' ' is a fake. */
1264 /* " " is converted to "" before return. */
1266 /* Warn about weird modes pf address. */
1268 /* Preserve q in case we backup. */
1270 /* Build up 4-bit operand mode here. */
1271 /* Note: index mode is in ndx, this is. */
1272 /* The major mode of operand address. */
1274 /* Notice how we move wrong-arg-type bugs INSIDE this module: if we
1275 get the types wrong below, we lose at compile time rather than at
1276 lint or run time. */
1277 char access_mode; /* vop_access. */
1279 access_mode = vopP->vop_access;
1280 /* None of our code bugs (yet), no user text errors, no warnings
1286 if (*p == ' ') /* Expect all whitespace reduced to ' '. */
1287 p++; /* skip over whitespace */
1289 if ((at = INDIRECTP (*p)) != 0)
1290 { /* 1 if *p=='@'(or '*' for Un*x) */
1291 p++; /* at is determined */
1292 if (*p == ' ') /* Expect all whitespace reduced to ' '. */
1293 p++; /* skip over whitespace */
1296 /* This code is subtle. It tries to detect all legal (letter)'^'
1297 but it doesn't waste time explicitly testing for premature '\0' because
1298 this case is rejected as a mismatch against either (letter) or '^'. */
1304 if (DISPLENP (p[1]) && strchr ("bilws", len = c))
1305 p += 2; /* Skip (letter) '^'. */
1306 else /* No (letter) '^' seen. */
1307 len = ' '; /* Len is determined. */
1310 if (*p == ' ') /* Expect all whitespace reduced to ' '. */
1313 if ((hash = IMMEDIATEP (*p)) != 0) /* 1 if *p=='#' ('$' for Un*x) */
1314 p++; /* Hash is determined. */
1316 /* p points to what may be the beginning of an expression.
1317 We have peeled off the front all that is peelable.
1318 We know at, len, hash.
1320 Lets point q at the end of the text and parse that (backwards). */
1322 for (q = p; *q; q++)
1324 q--; /* Now q points at last char of text. */
1326 if (*q == ' ' && q >= p) /* Expect all whitespace reduced to ' '. */
1329 /* Reverse over whitespace, but don't. */
1330 /* Run back over *p. */
1332 /* As a matter of policy here, we look for [Rn], although both Rn and S^#
1333 forbid [Rn]. This is because it is easy, and because only a sick
1334 cyborg would have [...] trailing an expression in a VAX-like assembler.
1335 A meticulous parser would first check for Rn followed by '(' or '['
1336 and not parse a trailing ']' if it found another. We just ban expressions
1340 while (q >= p && *q != '[')
1342 /* Either q<p or we got matching '['. */
1344 err = _("no '[' to match ']'");
1347 /* Confusers like "[]" will eventually lose with a bad register
1348 * name error. So again we don't need to check for early '\0'. */
1350 ndx = vax_reg_parse (q[1], q[2], 0, 0);
1351 else if (q[4] == ']')
1352 ndx = vax_reg_parse (q[1], q[2], q[3], 0);
1353 else if (q[5] == ']')
1354 ndx = vax_reg_parse (q[1], q[2], q[3], q[4]);
1357 /* Since we saw a ']' we will demand a register name in the [].
1358 * If luser hasn't given us one: be rude. */
1360 err = _("bad register in []");
1362 err = _("[PC] index banned");
1364 /* Point q just before "[...]". */
1369 /* No ']', so no iNDeX register. */
1372 /* If err = "..." then we lost: run away.
1373 Otherwise ndx == -1 if there was no "[...]".
1374 Otherwise, ndx is index register number, and q points before "[...]". */
1376 if (*q == ' ' && q >= p) /* Expect all whitespace reduced to ' '. */
1378 /* Reverse over whitespace, but don't. */
1379 /* Run back over *p. */
1382 /* no ()+ or -() seen yet */
1385 if (q > p + 3 && *q == '+' && q[-1] == ')')
1387 sign = 1; /* we saw a ")+" */
1388 q--; /* q points to ')' */
1391 if (*q == ')' && q > p + 2)
1393 paren = 1; /* assume we have "(...)" */
1394 while (q >= p && *q != '(')
1396 /* either q<p or we got matching '(' */
1398 err = _("no '(' to match ')'");
1401 /* Confusers like "()" will eventually lose with a bad register
1402 name error. So again we don't need to check for early '\0'. */
1404 reg = vax_reg_parse (q[1], q[2], 0, 0);
1405 else if (q[4] == ')')
1406 reg = vax_reg_parse (q[1], q[2], q[3], 0);
1407 else if (q[5] == ')')
1408 reg = vax_reg_parse (q[1], q[2], q[3], q[4]);
1411 /* Since we saw a ')' we will demand a register name in the ')'.
1412 This is nasty: why can't our hypothetical assembler permit
1413 parenthesised expressions? BECAUSE I AM LAZY! That is why.
1414 Abuse luser if we didn't spy a register name. */
1417 /* JF allow parenthesized expressions. I hope this works. */
1421 /* err = "unknown register in ()"; */
1424 q--; /* point just before '(' of "(...)" */
1425 /* If err == "..." then we lost. Run away.
1426 Otherwise if reg >= 0 then we saw (Rn). */
1428 /* If err == "..." then we lost.
1429 Otherwise paren==1 and reg = register in "()". */
1433 /* If err == "..." then we lost.
1434 Otherwise, q points just before "(Rn)", if any.
1435 If there was a "(...)" then paren==1, and reg is the register. */
1437 /* We should only seek '-' of "-(...)" if:
1438 we saw "(...)" paren == 1
1439 we have no errors so far ! *err
1440 we did not see '+' of "(...)+" sign < 1
1441 We don't check len. We want a specific error message later if
1442 user tries "x^...-(Rn)". This is a feature not a bug. */
1445 if (paren && sign < 1)/* !sign is adequate test */
1453 /* We have back-tracked over most
1454 of the crud at the end of an operand.
1455 Unless err, we know: sign, paren. If paren, we know reg.
1456 The last case is of an expression "Rn".
1457 This is worth hunting for if !err, !paren.
1458 We wouldn't be here if err.
1459 We remember to save q, in case we didn't want "Rn" anyway. */
1462 if (*q == ' ' && q >= p) /* Expect all whitespace reduced to ' '. */
1464 /* Reverse over whitespace, but don't. */
1465 /* Run back over *p. */
1466 /* Room for Rn or Rnn (include prefix) exactly? */
1467 if (q > p && q < p + 4)
1468 reg = vax_reg_parse (p[0], p[1],
1469 q < p + 2 ? 0 : p[2],
1470 q < p + 3 ? 0 : p[3]);
1472 reg = -1; /* Always comes here if no register at all. */
1473 /* Here with a definitive reg value. */
1482 /* have reg. -1:absent; else 0:15. */
1484 /* We have: err, at, len, hash, ndx, sign, paren, reg.
1485 Also, any remaining expression is from *p through *q inclusive.
1486 Should there be no expression, q==p-1. So expression length = q-p+1.
1487 This completes the first part: parsing the operand text. */
1489 /* We now want to boil the data down, checking consistency on the way.
1490 We want: len, mode, reg, ndx, err, p, q, wrn, bug.
1491 We will deliver a 4-bit reg, and a 4-bit mode. */
1493 /* Case of branch operand. Different. No L^B^W^I^S^ allowed for instance.
1507 p:q whatever was input
1509 err " " or error message, and other outputs trashed. */
1510 /* Branch operands have restricted forms. */
1511 if ((!err || !*err) && access_mode == 'b')
1513 if (at || hash || sign || paren || ndx >= 0 || reg >= 0 || len != ' ')
1514 err = _("invalid branch operand");
1519 /* Since nobody seems to use it: comment this 'feature'(?) out for now. */
1521 /* Case of stand-alone operand. e.g. ".long foo"
1535 p:q whatever was input
1537 err " " or error message, and other outputs trashed. */
1538 if ((!err || !*err) && access_mode == ' ')
1541 err = _("address prohibits @");
1543 err = _("address prohibits #");
1547 err = _("address prohibits -()");
1549 err = _("address prohibits ()+");
1552 err = _("address prohibits ()");
1554 err = _("address prohibits []");
1556 err = _("address prohibits register");
1557 else if (len != ' ')
1558 err = _("address prohibits displacement length specifier");
1561 err = " "; /* succeed */
1572 p:q demand not empty
1574 paren 0 by "()" scan logic because "S^" seen
1575 reg -1 or nn by mistake
1583 if ((!err || !*err) && len == 's')
1585 if (!hash || paren || at || ndx >= 0)
1586 err = _("invalid operand of S^#");
1591 /* Darn! we saw S^#Rnn ! put the Rnn back in
1592 expression. KLUDGE! Use oldq so we don't
1593 need to know exact length of reg name. */
1597 /* We have all the expression we will ever get. */
1599 err = _("S^# needs expression");
1600 else if (access_mode == 'r')
1602 err = " "; /* WIN! */
1606 err = _("S^# may only read-access");
1610 /* Case of -(Rn), which is weird case.
1616 sign -1 by definition
1617 paren 1 by definition
1618 reg present by definition
1624 exp "" enforce empty expression
1625 ndx optional warn if same as reg. */
1626 if ((!err || !*err) && sign < 0)
1628 if (len != ' ' || hash || at || p <= q)
1629 err = _("invalid operand of -()");
1632 err = " "; /* win */
1635 wrn = _("-(PC) unpredictable");
1636 else if (reg == ndx)
1637 wrn = _("[]index same as -()register: unpredictable");
1641 /* We convert "(Rn)" to "@Rn" for our convenience.
1642 (I hope this is convenient: has someone got a better way to parse this?)
1643 A side-effect of this is that "@Rn" is a valid operand. */
1644 if (paren && !sign && !hash && !at && len == ' ' && p > q)
1650 /* Case of (Rn)+, which is slightly different.
1656 sign +1 by definition
1657 paren 1 by definition
1658 reg present by definition
1664 exp "" enforce empty expression
1665 ndx optional warn if same as reg. */
1666 if ((!err || !*err) && sign > 0)
1668 if (len != ' ' || hash || p <= q)
1669 err = _("invalid operand of ()+");
1672 err = " "; /* win */
1673 mode = 8 + (at ? 1 : 0);
1675 wrn = _("(PC)+ unpredictable");
1676 else if (reg == ndx)
1677 wrn = _("[]index same as ()+register: unpredictable");
1681 /* Case of #, without S^.
1685 hash 1 by definition
1697 if ((!err || !*err) && hash)
1699 if (len != 'i' && len != ' ')
1700 err = _("# conflicts length");
1702 err = _("# bars register");
1707 /* Darn! we saw #Rnn! Put the Rnn back into the expression.
1708 By using oldq, we don't need to know how long Rnn was.
1711 reg = -1; /* No register any more. */
1713 err = " "; /* Win. */
1715 /* JF a bugfix, I think! */
1716 if (at && access_mode == 'a')
1717 vopP->vop_nbytes = 4;
1719 mode = (at ? 9 : 8);
1721 if ((access_mode == 'm' || access_mode == 'w') && !at)
1722 wrn = _("writing or modifying # is unpredictable");
1725 /* If !*err, then sign == 0
1728 /* Case of Rn. We separate this one because it has a few special
1729 errors the remaining modes lack.
1733 hash 0 by program logic
1735 sign 0 by program logic
1736 paren 0 by definition
1737 reg present by definition
1742 len ' ' enforce no length
1743 exp "" enforce empty expression
1744 ndx optional warn if same as reg. */
1745 if ((!err || !*err) && !paren && reg >= 0)
1748 err = _("length not needed");
1751 err = " "; /* win */
1755 err = _("can't []index a register, because it has no address");
1756 else if (access_mode == 'a')
1757 err = _("a register has no address");
1760 /* Idea here is to detect from length of datum
1761 and from register number if we will touch PC.
1763 vop_nbytes is number of bytes in operand.
1764 Compute highest byte affected, compare to PC0. */
1765 if ((vopP->vop_nbytes + reg * 4) > 60)
1766 wrn = _("PC part of operand unpredictable");
1767 err = " "; /* win */
1771 /* If !*err, sign == 0
1773 paren == 1 OR reg==-1 */
1775 /* Rest of cases fit into one bunch.
1778 len ' ' or 'b' or 'w' or 'l'
1779 hash 0 by program logic
1780 p:q expected (empty is not an error)
1781 sign 0 by program logic
1786 out: mode 10 + @ + len
1788 len ' ' or 'b' or 'w' or 'l'
1790 ndx optional warn if same as reg. */
1793 err = " "; /* win (always) */
1794 mode = 10 + (at ? 1 : 0);
1803 case ' ': /* Assumed B^ until our caller changes it. */
1809 /* here with completely specified mode
1816 err = 0; /* " " is no longer an error. */
1818 vopP->vop_mode = mode;
1819 vopP->vop_reg = reg;
1820 vopP->vop_short = len;
1821 vopP->vop_expr_begin = p;
1822 vopP->vop_expr_end = q;
1823 vopP->vop_ndx = ndx;
1824 vopP->vop_error = err;
1825 vopP->vop_warn = wrn;
1828 /* This converts a string into a vax instruction.
1829 The string must be a bare single instruction in dec-vax (with BSD4 frobs)
1831 It provides some error messages: at most one fatal error message (which
1832 stops the scan) and at most one warning message for each operand.
1833 The vax instruction is returned in exploded form, since we have no
1834 knowledge of how you parse (or evaluate) your expressions.
1835 We do however strip off and decode addressing modes and operation
1838 The exploded instruction is returned to a struct vit of your choice.
1839 #include "vax-inst.h" to know what a struct vit is.
1841 This function's value is a string. If it is not "" then an internal
1842 logic error was found: read this code to assign meaning to the string.
1843 No argument string should generate such an error string:
1844 it means a bug in our code, not in the user's text.
1846 You MUST have called vip_begin() once before using this function. */
1849 vip (struct vit *vitP, /* We build an exploded instruction here. */
1850 char *instring) /* Text of a vax instruction: we modify. */
1852 /* How to bit-encode this opcode. */
1853 struct vot_wot *vwP;
1854 /* 1/skip whitespace.2/scan vot_how */
1857 /* counts number of operands seen */
1858 unsigned char count;
1859 /* scan operands in struct vit */
1860 struct vop *operandp;
1861 /* error over all operands */
1862 const char *alloperr;
1863 /* Remember char, (we clobber it with '\0' temporarily). */
1865 /* Op-code of this instruction. */
1868 if (*instring == ' ')
1871 /* MUST end in end-of-string or exactly 1 space. */
1872 for (p = instring; *p && *p != ' '; p++)
1875 /* Scanned up to end of operation-code. */
1876 /* Operation-code is ended with whitespace. */
1877 if (p - instring == 0)
1879 vitP->vit_error = _("No operator");
1881 memset (vitP->vit_opcode, '\0', sizeof (vitP->vit_opcode));
1887 /* Here with instring pointing to what better be an op-name, and p
1888 pointing to character just past that.
1889 We trust instring points to an op-name, with no whitespace. */
1890 vwP = (struct vot_wot *) hash_find (op_hash, instring);
1891 /* Restore char after op-code. */
1895 vitP->vit_error = _("Unknown operator");
1897 memset (vitP->vit_opcode, '\0', sizeof (vitP->vit_opcode));
1901 /* We found a match! So let's pick up as many operands as the
1902 instruction wants, and even gripe if there are too many.
1903 We expect comma to separate each operand.
1904 We let instring track the text, while p tracks a part of the
1907 /* The lines below know about 2-byte opcodes starting FD,FE or FF.
1908 They also understand synthetic opcodes. Note:
1909 we return 32 bits of opcode, including bucky bits, BUT
1910 an opcode length is either 8 or 16 bits for vit_opcode_nbytes. */
1911 oc = vwP->vot_code; /* The op-code. */
1912 vitP->vit_opcode_nbytes = (oc & 0xFF) >= 0xFD ? 2 : 1;
1913 md_number_to_chars (vitP->vit_opcode, oc, 4);
1914 count = 0; /* No operands seen yet. */
1915 instring = p; /* Point just past operation code. */
1917 for (howp = vwP->vot_how, operandp = vitP->vit_operand;
1918 !(alloperr && *alloperr) && *howp;
1919 operandp++, howp += 2)
1921 /* Here to parse one operand. Leave instring pointing just
1922 past any one ',' that marks the end of this operand. */
1924 as_fatal (_("odd number of bytes in operand description"));
1927 for (q = instring; (c = *q) && c != ','; q++)
1929 /* Q points to ',' or '\0' that ends argument. C is that
1932 operandp->vop_width = howp[1];
1933 operandp->vop_nbytes = vax_operand_width_size[(unsigned) howp[1]];
1934 operandp->vop_access = howp[0];
1935 vip_op (instring, operandp);
1936 *q = c; /* Restore input text. */
1937 if (operandp->vop_error)
1938 alloperr = _("Bad operand");
1939 instring = q + (c ? 1 : 0); /* Next operand (if any). */
1940 count++; /* Won another argument, may have an operr. */
1943 alloperr = _("Not enough operands");
1947 if (*instring == ' ')
1950 alloperr = _("Too many operands");
1952 vitP->vit_error = alloperr;
1955 vitP->vit_operands = count;
1960 /* Test program for above. */
1962 struct vit myvit; /* Build an exploded vax instruction here. */
1963 char answer[100]; /* Human types a line of vax assembler here. */
1964 char *mybug; /* "" or an internal logic diagnostic. */
1965 int mycount; /* Number of operands. */
1966 struct vop *myvop; /* Scan operands from myvit. */
1967 int mysynth; /* 1 means want synthetic opcodes. */
1968 char my_immediate[200];
1969 char my_indirect[200];
1970 char my_displen[200];
1977 printf ("0 means no synthetic instructions. ");
1978 printf ("Value for vip_begin? ");
1980 sscanf (answer, "%d", &mysynth);
1981 printf ("Synthetic opcodes %s be included.\n", mysynth ? "will" : "will not");
1982 printf ("enter immediate symbols eg enter # ");
1983 gets (my_immediate);
1984 printf ("enter indirect symbols eg enter @ ");
1986 printf ("enter displen symbols eg enter ^ ");
1989 if (p = vip_begin (mysynth, my_immediate, my_indirect, my_displen))
1990 error ("vip_begin=%s", p);
1992 printf ("An empty input line will quit you from the vax instruction parser\n");
1995 printf ("vax instruction: ");
1999 break; /* Out of for each input text loop. */
2001 vip (& myvit, answer);
2002 if (*myvit.vit_error)
2003 printf ("ERR:\"%s\"\n", myvit.vit_error);
2006 for (mycount = myvit.vit_opcode_nbytes, p = myvit.vit_opcode;
2009 printf ("%02x ", *p & 0xFF);
2011 printf (" operand count=%d.\n", mycount = myvit.vit_operands);
2012 for (myvop = myvit.vit_operand; mycount; mycount--, myvop++)
2014 printf ("mode=%xx reg=%xx ndx=%xx len='%c'=%c%c%d. expr=\"",
2015 myvop->vop_mode, myvop->vop_reg, myvop->vop_ndx,
2016 myvop->vop_short, myvop->vop_access, myvop->vop_width,
2018 for (p = myvop->vop_expr_begin; p <= myvop->vop_expr_end; p++)
2022 if (myvop->vop_error)
2023 printf (" err:\"%s\"\n", myvop->vop_error);
2025 if (myvop->vop_warn)
2026 printf (" wrn:\"%s\"\n", myvop->vop_warn);
2030 exit (EXIT_SUCCESS);
2035 #ifdef TEST /* #Define to use this testbed. */
2037 /* Follows a test program for this function.
2038 We declare arrays non-local in case some of our tiny-minded machines
2039 default to small stacks. Also, helps with some debuggers. */
2041 char answer[100]; /* Human types into here. */
2054 int my_operand_length;
2055 char my_immediate[200];
2056 char my_indirect[200];
2057 char my_displen[200];
2062 printf ("enter immediate symbols eg enter # ");
2063 gets (my_immediate);
2064 printf ("enter indirect symbols eg enter @ ");
2066 printf ("enter displen symbols eg enter ^ ");
2068 vip_op_defaults (my_immediate, my_indirect, my_displen);
2072 printf ("access,width (eg 'ab' or 'wh') [empty line to quit] : ");
2076 exit (EXIT_SUCCESS);
2077 myaccess = answer[0];
2078 mywidth = answer[1];
2082 my_operand_length = 1;
2085 my_operand_length = 8;
2088 my_operand_length = 4;
2091 my_operand_length = 16;
2094 my_operand_length = 32;
2097 my_operand_length = 4;
2100 my_operand_length = 16;
2103 my_operand_length = 8;
2106 my_operand_length = 2;
2111 my_operand_length = 0;
2115 my_operand_length = 2;
2116 printf ("I don't understand access width %c\n", mywidth);
2119 printf ("VAX assembler instruction operand: ");
2122 mybug = vip_op (answer, myaccess, mywidth, my_operand_length,
2123 &mymode, &myreg, &mylen, &myleft, &myright, &myndx,
2127 printf ("error: \"%s\"\n", myerr);
2129 printf (" bug: \"%s\"\n", mybug);
2134 printf ("warning: \"%s\"\n", mywrn);
2135 mumble ("mode", mymode);
2136 mumble ("register", myreg);
2137 mumble ("index", myndx);
2138 printf ("width:'%c' ", mylen);
2139 printf ("expression: \"");
2140 while (myleft <= myright)
2141 putchar (*myleft++);
2148 mumble (char *text, int value)
2150 printf ("%s:", text);
2152 printf ("%xx", value);
2160 int md_short_jump_size = 3;
2161 int md_long_jump_size = 6;
2164 md_create_short_jump (char *ptr,
2166 addressT to_addr ATTRIBUTE_UNUSED,
2167 fragS *frag ATTRIBUTE_UNUSED,
2168 symbolS *to_symbol ATTRIBUTE_UNUSED)
2172 /* This former calculation was off by two:
2173 offset = to_addr - (from_addr + 1);
2174 We need to account for the one byte instruction and also its
2175 two byte operand. */
2176 offset = to_addr - (from_addr + 1 + 2);
2177 *ptr++ = VAX_BRW; /* Branch with word (16 bit) offset. */
2178 md_number_to_chars (ptr, offset, 2);
2182 md_create_long_jump (char *ptr,
2183 addressT from_addr ATTRIBUTE_UNUSED,
2190 offset = to_addr - S_GET_VALUE (to_symbol);
2191 *ptr++ = VAX_JMP; /* Arbitrary jump. */
2192 *ptr++ = VAX_ABSOLUTE_MODE;
2193 md_number_to_chars (ptr, offset, 4);
2194 fix_new (frag, ptr - frag->fr_literal, 4, to_symbol, (long) 0, 0, NO_RELOC);
2198 const char *md_shortopts = "d:STt:V+1h:Hv::";
2199 #elif defined(OBJ_ELF)
2200 const char *md_shortopts = "d:STt:VkKQ:";
2202 const char *md_shortopts = "d:STt:V";
2204 struct option md_longopts[] =
2207 #define OPTION_PIC (OPTION_MD_BASE)
2208 { "pic", no_argument, NULL, OPTION_PIC },
2210 { NULL, no_argument, NULL, 0 }
2212 size_t md_longopts_size = sizeof (md_longopts);
2215 md_parse_option (int c, const char *arg)
2220 as_warn (_("SYMBOL TABLE not implemented"));
2224 as_warn (_("TOKEN TRACE not implemented"));
2228 as_warn (_("Displacement length %s ignored!"), arg);
2232 as_warn (_("I don't need or use temp. file \"%s\"."), arg);
2236 as_warn (_("I don't use an interpass file! -V ignored"));
2240 case '+': /* For g++. Hash any name > 31 chars long. */
2241 flag_hash_long_names = 1;
2244 case '1': /* For backward compatibility. */
2248 case 'H': /* Show new symbol after hash truncation. */
2249 flag_show_after_trunc = 1;
2252 case 'h': /* No hashing of mixed-case names. */
2254 extern char vms_name_mapping;
2255 vms_name_mapping = atoi (arg);
2256 flag_no_hash_mixed_case = 1;
2262 extern char *compiler_version_string;
2264 if (!arg || !*arg || access (arg, 0) == 0)
2265 return 0; /* Have caller show the assembler version. */
2266 compiler_version_string = arg;
2275 break; /* -pic, Position Independent Code. */
2277 /* -Qy, -Qn: SVR4 arguments controlling whether a .comment
2278 section should be emitted or not. FIXME: Not implemented. */
2291 md_show_usage (FILE *stream)
2293 fprintf (stream, _("\
2295 -d LENGTH ignored\n\
2302 fprintf (stream, _("\
2304 -+ hash encode names longer than 31 characters\n\
2305 -1 `const' handling compatible with gcc 1.x\n\
2306 -H show new symbol after hash truncation\n\
2307 -h NUM don't hash mixed-case names, and adjust case:\n\
2308 0 = upper, 2 = lower, 3 = preserve case\n\
2309 -v\"VERSION\" code being assembled was produced by compiler \"VERSION\"\n"));
2313 /* We have no need to default values of symbols. */
2316 md_undefined_symbol (char *name ATTRIBUTE_UNUSED)
2321 /* Round up a section size to the appropriate boundary. */
2323 md_section_align (segT segment ATTRIBUTE_UNUSED, valueT size)
2325 /* Byte alignment is fine */
2329 /* Exactly what point is a PC-relative offset relative TO?
2330 On the vax, they're relative to the address of the offset, plus
2333 md_pcrel_from (fixS *fixP)
2335 return fixP->fx_size + fixP->fx_where + fixP->fx_frag->fr_address;
2339 tc_gen_reloc (asection *section ATTRIBUTE_UNUSED, fixS *fixp)
2342 bfd_reloc_code_real_type code;
2347 if (fixp->fx_r_type != NO_RELOC)
2349 code = fixp->fx_r_type;
2355 case BFD_RELOC_8_PCREL:
2356 case BFD_RELOC_16_PCREL:
2357 case BFD_RELOC_32_PCREL:
2359 case BFD_RELOC_8_GOT_PCREL:
2360 case BFD_RELOC_16_GOT_PCREL:
2361 case BFD_RELOC_32_GOT_PCREL:
2362 case BFD_RELOC_8_PLT_PCREL:
2363 case BFD_RELOC_16_PLT_PCREL:
2364 case BFD_RELOC_32_PLT_PCREL:
2368 as_bad_where (fixp->fx_file, fixp->fx_line,
2369 _("Cannot make %s relocation PC relative"),
2370 bfd_get_reloc_code_name (code));
2376 #define F(SZ,PCREL) (((SZ) << 1) + (PCREL))
2377 switch (F (fixp->fx_size, fixp->fx_pcrel))
2379 #define MAP(SZ,PCREL,TYPE) case F(SZ,PCREL): code = (TYPE); break
2380 MAP (1, 0, BFD_RELOC_8);
2381 MAP (2, 0, BFD_RELOC_16);
2382 MAP (4, 0, BFD_RELOC_32);
2383 MAP (1, 1, BFD_RELOC_8_PCREL);
2384 MAP (2, 1, BFD_RELOC_16_PCREL);
2385 MAP (4, 1, BFD_RELOC_32_PCREL);
2393 reloc = XNEW (arelent);
2394 reloc->sym_ptr_ptr = XNEW (asymbol *);
2395 *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
2396 reloc->address = fixp->fx_frag->fr_address + fixp->fx_where;
2399 reloc->addend = fixp->fx_addnumber;
2403 reloc->addend = fixp->fx_offset;
2406 reloc->howto = bfd_reloc_type_lookup (stdoutput, code);
2407 gas_assert (reloc->howto != 0);
2412 /* vax:md_assemble() emit frags for 1 instruction given in textual form. */
2414 md_assemble (char *instruction_string)
2416 /* Non-zero if operand expression's segment is not known yet. */
2418 /* Non-zero if operand expression's segment is absolute. */
2422 /* An operand. Scans all operands. */
2423 struct vop *operandP;
2424 char *save_input_line_pointer;
2425 /* What used to live after an expression. */
2427 /* 1: instruction_string bad for all passes. */
2429 /* Points to slot just after last operand. */
2430 struct vop *end_operandP;
2431 /* Points to expression values for this operand. */
2435 /* These refer to an instruction operand expression. */
2436 /* Target segment of the address. */
2438 valueT this_add_number;
2439 /* Positive (minuend) symbol. */
2440 symbolS *this_add_symbol;
2442 long opcode_as_number;
2443 /* Least significant byte 1st. */
2444 char *opcode_as_chars;
2445 /* As an array of characters. */
2446 /* Least significant byte 1st */
2447 char *opcode_low_byteP;
2448 /* length (bytes) meant by vop_short. */
2450 /* 0, or 1 if '@' is in addressing mode. */
2452 /* From vop_nbytes: vax_operand_width (in bytes) */
2454 FLONUM_TYPE *floatP;
2455 LITTLENUM_TYPE literal_float[8];
2456 /* Big enough for any floating point literal. */
2458 vip (&v, instruction_string);
2460 /* Now we try to find as many as_warn()s as we can. If we do any as_warn()s
2461 then goofed=1. Notice that we don't make any frags yet.
2462 Should goofed be 1, then this instruction will wedge in any pass,
2463 and we can safely flush it, without causing interpass symbol phase
2464 errors. That is, without changing label values in different passes. */
2465 if ((goofed = (*v.vit_error)) != 0)
2467 as_fatal (_("Ignoring statement due to \"%s\""), v.vit_error);
2469 /* We need to use expression() and friends, which require us to diddle
2470 input_line_pointer. So we save it and restore it later. */
2471 save_input_line_pointer = input_line_pointer;
2472 for (operandP = v.vit_operand,
2473 expP = exp_of_operand,
2474 segP = seg_of_operand,
2475 floatP = float_operand,
2476 end_operandP = v.vit_operand + v.vit_operands;
2478 operandP < end_operandP;
2480 operandP++, expP++, segP++, floatP++)
2482 if (operandP->vop_error)
2484 as_fatal (_("Aborting because statement has \"%s\""), operandP->vop_error);
2489 /* Statement has no syntax goofs: let's sniff the expression. */
2490 int can_be_short = 0; /* 1 if a bignum can be reduced to a short literal. */
2492 input_line_pointer = operandP->vop_expr_begin;
2493 c_save = operandP->vop_expr_end[1];
2494 operandP->vop_expr_end[1] = '\0';
2495 /* If to_seg == SEG_PASS1, expression() will have set need_pass_2 = 1. */
2496 *segP = expression (expP);
2500 /* for BSD4.2 compatibility, missing expression is absolute 0 */
2501 expP->X_op = O_constant;
2502 expP->X_add_number = 0;
2503 /* For SEG_ABSOLUTE, we shouldn't need to set X_op_symbol,
2504 X_add_symbol to any particular value. But, we will program
2505 defensively. Since this situation occurs rarely so it costs
2506 us little to do, and stops Dean worrying about the origin of
2507 random bits in expressionS's. */
2508 expP->X_add_symbol = NULL;
2509 expP->X_op_symbol = NULL;
2517 /* Major bug. We can't handle the case of a
2518 SEG_OP expression in a VIT_OPCODE_SYNTHETIC
2519 variable-length instruction.
2520 We don't have a frag type that is smart enough to
2521 relax a SEG_OP, and so we just force all
2522 SEG_OPs to behave like SEG_PASS1s.
2523 Clearly, if there is a demand we can invent a new or
2524 modified frag type and then coding up a frag for this
2525 case will be easy. SEG_OP was invented for the
2526 .words after a CASE opcode, and was never intended for
2527 instruction operands. */
2529 as_fatal (_("Can't relocate expression"));
2533 /* Preserve the bits. */
2534 if (expP->X_add_number > 0)
2536 bignum_copy (generic_bignum, expP->X_add_number,
2537 floatP->low, SIZE_OF_LARGE_NUMBER);
2541 know (expP->X_add_number < 0);
2542 flonum_copy (&generic_floating_point_number,
2544 if (strchr ("s i", operandP->vop_short))
2546 /* Could possibly become S^# */
2547 flonum_gen2vax (-expP->X_add_number, floatP, literal_float);
2548 switch (-expP->X_add_number)
2552 (literal_float[0] & 0xFC0F) == 0x4000
2553 && literal_float[1] == 0;
2558 (literal_float[0] & 0xFC0F) == 0x4000
2559 && literal_float[1] == 0
2560 && literal_float[2] == 0
2561 && literal_float[3] == 0;
2566 (literal_float[0] & 0xFF81) == 0x4000
2567 && literal_float[1] == 0
2568 && literal_float[2] == 0
2569 && literal_float[3] == 0;
2573 can_be_short = ((literal_float[0] & 0xFFF8) == 0x4000
2574 && (literal_float[1] & 0xE000) == 0
2575 && literal_float[2] == 0
2576 && literal_float[3] == 0
2577 && literal_float[4] == 0
2578 && literal_float[5] == 0
2579 && literal_float[6] == 0
2580 && literal_float[7] == 0);
2584 BAD_CASE (-expP->X_add_number);
2590 if (operandP->vop_short == 's'
2591 || operandP->vop_short == 'i'
2592 || (operandP->vop_short == ' '
2593 && operandP->vop_reg == 0xF
2594 && (operandP->vop_mode & 0xE) == 0x8))
2597 if (operandP->vop_short == ' ')
2599 /* We must chose S^ or I^. */
2600 if (expP->X_add_number > 0)
2602 /* Bignum: Short literal impossible. */
2603 operandP->vop_short = 'i';
2604 operandP->vop_mode = 8;
2605 operandP->vop_reg = 0xF; /* VAX PC. */
2609 /* Flonum: Try to do it. */
2612 operandP->vop_short = 's';
2613 operandP->vop_mode = 0;
2614 operandP->vop_ndx = -1;
2615 operandP->vop_reg = -1;
2616 expP->X_op = O_constant;
2620 operandP->vop_short = 'i';
2621 operandP->vop_mode = 8;
2622 operandP->vop_reg = 0xF; /* VAX PC */
2624 } /* bignum or flonum ? */
2625 } /* if #, but no S^ or I^ seen. */
2626 /* No more ' ' case: either 's' or 'i'. */
2627 if (operandP->vop_short == 's')
2629 /* Wants to be a short literal. */
2630 if (expP->X_add_number > 0)
2632 as_warn (_("Bignum not permitted in short literal. Immediate mode assumed."));
2633 operandP->vop_short = 'i';
2634 operandP->vop_mode = 8;
2635 operandP->vop_reg = 0xF; /* VAX PC. */
2641 as_warn (_("Can't do flonum short literal: immediate mode used."));
2642 operandP->vop_short = 'i';
2643 operandP->vop_mode = 8;
2644 operandP->vop_reg = 0xF; /* VAX PC. */
2648 /* Encode short literal now. */
2651 switch (-expP->X_add_number)
2655 temp = literal_float[0] >> 4;
2659 temp = literal_float[0] >> 1;
2663 temp = ((literal_float[0] << 3) & 070)
2664 | ((literal_float[1] >> 13) & 07);
2668 BAD_CASE (-expP->X_add_number);
2672 floatP->low[0] = temp & 077;
2679 /* I^# seen: set it up if float. */
2680 if (expP->X_add_number < 0)
2682 memcpy (floatP->low, literal_float, sizeof (literal_float));
2684 } /* if S^# seen. */
2688 as_warn (_("A bignum/flonum may not be a displacement: 0x%lx used"),
2689 (expP->X_add_number = 0x80000000L));
2690 /* Chosen so luser gets the most offset bits to patch later. */
2692 expP->X_add_number = floatP->low[0]
2693 | ((LITTLENUM_MASK & (floatP->low[1])) << LITTLENUM_NUMBER_OF_BITS);
2695 /* For the O_big case we have:
2696 If vop_short == 's' then a short floating literal is in the
2697 lowest 6 bits of floatP -> low [0], which is
2698 big_operand_bits [---] [0].
2699 If vop_short == 'i' then the appropriate number of elements
2700 of big_operand_bits [---] [...] are set up with the correct
2702 Also, just in case width is byte word or long, we copy the lowest
2703 32 bits of the number to X_add_number. */
2706 if (input_line_pointer != operandP->vop_expr_end + 1)
2708 as_fatal ("Junk at end of expression \"%s\"", input_line_pointer);
2711 operandP->vop_expr_end[1] = c_save;
2715 input_line_pointer = save_input_line_pointer;
2717 if (need_pass_2 || goofed)
2720 dwarf2_emit_insn (0);
2722 /* Remember where it is, in case we want to modify the op-code later. */
2723 opcode_low_byteP = frag_more (v.vit_opcode_nbytes);
2724 memcpy (opcode_low_byteP, v.vit_opcode, v.vit_opcode_nbytes);
2725 opcode_as_chars = v.vit_opcode;
2726 opcode_as_number = md_chars_to_number ((unsigned char *) opcode_as_chars, 4);
2727 for (operandP = v.vit_operand,
2728 expP = exp_of_operand,
2729 segP = seg_of_operand,
2730 floatP = float_operand,
2731 end_operandP = v.vit_operand + v.vit_operands;
2733 operandP < end_operandP;
2740 if (operandP->vop_ndx >= 0)
2742 /* Indexed addressing byte. */
2743 /* Legality of indexed mode already checked: it is OK. */
2744 FRAG_APPEND_1_CHAR (0x40 + operandP->vop_ndx);
2745 } /* if(vop_ndx>=0) */
2747 /* Here to make main operand frag(s). */
2748 this_add_number = expP->X_add_number;
2749 this_add_symbol = expP->X_add_symbol;
2751 is_undefined = (to_seg == undefined_section);
2752 is_absolute = (to_seg == absolute_section);
2753 at = operandP->vop_mode & 1;
2754 length = (operandP->vop_short == 'b'
2755 ? 1 : (operandP->vop_short == 'w'
2756 ? 2 : (operandP->vop_short == 'l'
2758 nbytes = operandP->vop_nbytes;
2759 if (operandP->vop_access == 'b')
2761 if (to_seg == now_seg || is_undefined)
2763 /* If is_undefined, then it might BECOME now_seg. */
2766 p = frag_more (nbytes);
2767 fix_new (frag_now, p - frag_now->fr_literal, nbytes,
2768 this_add_symbol, this_add_number, 1, NO_RELOC);
2772 /* to_seg==now_seg || to_seg == SEG_UNKNOWN */
2774 length_code = is_undefined ? STATE_UNDF : STATE_BYTE;
2775 if (opcode_as_number & VIT_OPCODE_SPECIAL)
2777 if (operandP->vop_width == VAX_WIDTH_UNCONDITIONAL_JUMP)
2780 frag_var (rs_machine_dependent, 5, 1,
2781 ENCODE_RELAX (STATE_ALWAYS_BRANCH, length_code),
2782 this_add_symbol, this_add_number,
2787 if (operandP->vop_width == VAX_WIDTH_WORD_JUMP)
2789 length_code = STATE_WORD;
2790 /* JF: There is no state_byte for this one! */
2791 frag_var (rs_machine_dependent, 10, 2,
2792 ENCODE_RELAX (STATE_COMPLEX_BRANCH, length_code),
2793 this_add_symbol, this_add_number,
2798 know (operandP->vop_width == VAX_WIDTH_BYTE_JUMP);
2799 frag_var (rs_machine_dependent, 9, 1,
2800 ENCODE_RELAX (STATE_COMPLEX_HOP, length_code),
2801 this_add_symbol, this_add_number,
2808 know (operandP->vop_width == VAX_WIDTH_CONDITIONAL_JUMP);
2809 frag_var (rs_machine_dependent, 7, 1,
2810 ENCODE_RELAX (STATE_CONDITIONAL_BRANCH, length_code),
2811 this_add_symbol, this_add_number,
2818 /* to_seg != now_seg && to_seg != SEG_UNKNOWN */
2819 /* --- SEG FLOAT MAY APPEAR HERE --- */
2824 know (!(opcode_as_number & VIT_OPCODE_SYNTHETIC));
2825 p = frag_more (nbytes);
2826 /* Conventional relocation. */
2827 fix_new (frag_now, p - frag_now->fr_literal, nbytes,
2828 section_symbol (absolute_section),
2829 this_add_number, 1, NO_RELOC);
2833 know (opcode_as_number & VIT_OPCODE_SYNTHETIC);
2834 if (opcode_as_number & VIT_OPCODE_SPECIAL)
2836 if (operandP->vop_width == VAX_WIDTH_UNCONDITIONAL_JUMP)
2839 *opcode_low_byteP = opcode_as_chars[0] + VAX_WIDEN_LONG;
2840 know (opcode_as_chars[1] == 0);
2842 p[0] = VAX_ABSOLUTE_MODE; /* @#... */
2843 md_number_to_chars (p + 1, this_add_number, 4);
2844 /* Now (eg) JMP @#foo or JSB @#foo. */
2848 if (operandP->vop_width == VAX_WIDTH_WORD_JUMP)
2856 p[5] = VAX_ABSOLUTE_MODE; /* @#... */
2857 md_number_to_chars (p + 6, this_add_number, 4);
2865 know (operandP->vop_width == VAX_WIDTH_BYTE_JUMP);
2871 p[4] = VAX_ABSOLUTE_MODE; /* @#... */
2872 md_number_to_chars (p + 5, this_add_number, 4);
2873 /* Now (eg) xOBxxx 1f
2883 *opcode_low_byteP ^= 1;
2884 /* To reverse the condition in a VAX branch,
2885 complement the lowest order bit. */
2889 p[2] = VAX_ABSOLUTE_MODE; /* @#... */
2890 md_number_to_chars (p + 3, this_add_number, 4);
2899 /* to_seg != now_seg && !is_undefinfed && !is_absolute */
2902 /* Pc-relative. Conventional relocation. */
2903 know (!(opcode_as_number & VIT_OPCODE_SYNTHETIC));
2904 p = frag_more (nbytes);
2905 fix_new (frag_now, p - frag_now->fr_literal, nbytes,
2906 section_symbol (absolute_section),
2907 this_add_number, 1, NO_RELOC);
2911 know (opcode_as_number & VIT_OPCODE_SYNTHETIC);
2912 if (opcode_as_number & VIT_OPCODE_SPECIAL)
2914 if (operandP->vop_width == VAX_WIDTH_UNCONDITIONAL_JUMP)
2917 know (opcode_as_chars[1] == 0);
2918 *opcode_low_byteP = opcode_as_chars[0] + VAX_WIDEN_LONG;
2920 p[0] = VAX_PC_RELATIVE_MODE;
2922 p + 1 - frag_now->fr_literal, 4,
2924 this_add_number, 1, NO_RELOC);
2925 /* Now eg JMP foo or JSB foo. */
2929 if (operandP->vop_width == VAX_WIDTH_WORD_JUMP)
2937 p[5] = VAX_PC_RELATIVE_MODE;
2939 p + 6 - frag_now->fr_literal, 4,
2941 this_add_number, 1, NO_RELOC);
2949 know (operandP->vop_width == VAX_WIDTH_BYTE_JUMP);
2955 p[4] = VAX_PC_RELATIVE_MODE;
2957 p + 5 - frag_now->fr_literal,
2959 this_add_number, 1, NO_RELOC);
2960 /* Now (eg) xOBxxx 1f
2969 know (operandP->vop_width == VAX_WIDTH_CONDITIONAL_JUMP);
2970 *opcode_low_byteP ^= 1; /* Reverse branch condition. */
2974 p[2] = VAX_PC_RELATIVE_MODE;
2975 fix_new (frag_now, p + 3 - frag_now->fr_literal,
2977 this_add_number, 1, NO_RELOC);
2985 /* So it is ordinary operand. */
2986 know (operandP->vop_access != 'b');
2987 /* ' ' target-independent: elsewhere. */
2988 know (operandP->vop_access != ' ');
2989 know (operandP->vop_access == 'a'
2990 || operandP->vop_access == 'm'
2991 || operandP->vop_access == 'r'
2992 || operandP->vop_access == 'v'
2993 || operandP->vop_access == 'w');
2994 if (operandP->vop_short == 's')
2998 if (this_add_number >= 64)
3000 as_warn (_("Short literal overflow(%ld.), immediate mode assumed."),
3001 (long) this_add_number);
3002 operandP->vop_short = 'i';
3003 operandP->vop_mode = 8;
3004 operandP->vop_reg = 0xF;
3009 as_warn (_("Forced short literal to immediate mode. now_seg=%s to_seg=%s"),
3010 segment_name (now_seg), segment_name (to_seg));
3011 operandP->vop_short = 'i';
3012 operandP->vop_mode = 8;
3013 operandP->vop_reg = 0xF;
3016 if (operandP->vop_reg >= 0 && (operandP->vop_mode < 8
3017 || (operandP->vop_reg != 0xF && operandP->vop_mode < 10)))
3019 /* One byte operand. */
3020 know (operandP->vop_mode > 3);
3021 FRAG_APPEND_1_CHAR (operandP->vop_mode << 4 | operandP->vop_reg);
3022 /* All 1-bytes except S^# happen here. */
3026 /* {@}{q^}foo{(Rn)} or S^#foo */
3027 if (operandP->vop_reg == -1 && operandP->vop_short != 's')
3030 if (to_seg == now_seg)
3034 know (operandP->vop_short == ' ');
3035 length_code = STATE_BYTE;
3037 if (S_IS_EXTERNAL (this_add_symbol)
3038 || S_IS_WEAK (this_add_symbol))
3039 length_code = STATE_UNDF;
3041 p = frag_var (rs_machine_dependent, 10, 2,
3042 ENCODE_RELAX (STATE_PC_RELATIVE, length_code),
3043 this_add_symbol, this_add_number,
3045 know (operandP->vop_mode == 10 + at);
3047 /* At is the only context we need to carry
3048 to other side of relax() process. Must
3049 be in the correct bit position of VAX
3050 operand spec. byte. */
3055 know (operandP->vop_short != ' ');
3056 p = frag_more (length + 1);
3057 p[0] = 0xF | ((at + "?\12\14?\16"[length]) << 4);
3058 fix_new (frag_now, p + 1 - frag_now->fr_literal,
3059 length, this_add_symbol,
3060 this_add_number, 1, NO_RELOC);
3065 /* to_seg != now_seg */
3066 if (this_add_symbol == NULL)
3069 /* Do @#foo: simpler relocation than foo-.(pc) anyway. */
3071 p[0] = VAX_ABSOLUTE_MODE; /* @#... */
3072 md_number_to_chars (p + 1, this_add_number, 4);
3073 if (length && length != 4)
3074 as_warn (_("Length specification ignored. Address mode 9F used"));
3078 /* {@}{q^}other_seg */
3079 know ((length == 0 && operandP->vop_short == ' ')
3080 || (length > 0 && operandP->vop_short != ' '));
3083 || S_IS_WEAK(this_add_symbol)
3084 || S_IS_EXTERNAL(this_add_symbol)
3090 default: length_code = STATE_UNDF; break;
3091 case 1: length_code = STATE_BYTE; break;
3092 case 2: length_code = STATE_WORD; break;
3093 case 4: length_code = STATE_LONG; break;
3095 /* We have a SEG_UNKNOWN symbol. It might
3096 turn out to be in the same segment as
3097 the instruction, permitting relaxation. */
3098 p = frag_var (rs_machine_dependent, 5, 2,
3099 ENCODE_RELAX (STATE_PC_RELATIVE, length_code),
3100 this_add_symbol, this_add_number,
3108 know (operandP->vop_short == ' ');
3109 length = 4; /* Longest possible. */
3111 p = frag_more (length + 1);
3112 p[0] = 0xF | ((at + "?\12\14?\16"[length]) << 4);
3113 md_number_to_chars (p + 1, this_add_number, length);
3115 p + 1 - frag_now->fr_literal,
3116 length, this_add_symbol,
3117 this_add_number, 1, NO_RELOC);
3124 /* {@}{q^}foo(Rn) or S^# or I^# or # */
3125 if (operandP->vop_mode < 0xA)
3127 /* # or S^# or I^# */
3128 if (operandP->vop_access == 'v'
3129 || operandP->vop_access == 'a')
3131 if (operandP->vop_access == 'v')
3132 as_warn (_("Invalid operand: immediate value used as base address."));
3134 as_warn (_("Invalid operand: immediate value used as address."));
3135 /* gcc 2.6.3 is known to generate these in at least
3139 && is_absolute && (expP->X_op != O_big)
3140 && operandP->vop_mode == 8 /* No '@'. */
3141 && this_add_number < 64)
3143 operandP->vop_short = 's';
3145 if (operandP->vop_short == 's')
3147 FRAG_APPEND_1_CHAR (this_add_number);
3153 p = frag_more (nbytes + 1);
3154 know (operandP->vop_reg == 0xF);
3156 if (flag_want_pic && operandP->vop_mode == 8
3157 && this_add_symbol != NULL)
3159 as_warn (_("Symbol %s used as immediate operand in PIC mode."),
3160 S_GET_NAME (this_add_symbol));
3163 p[0] = (operandP->vop_mode << 4) | 0xF;
3164 if ((is_absolute) && (expP->X_op != O_big))
3166 /* If nbytes > 4, then we are scrod. We
3167 don't know if the high order bytes
3168 are to be 0xFF or 0x00. BSD4.2 & RMS
3169 say use 0x00. OK --- but this
3170 assembler needs ANOTHER rewrite to
3171 cope properly with this bug. */
3172 md_number_to_chars (p + 1, this_add_number,
3173 min (sizeof (valueT),
3175 if ((size_t) nbytes > sizeof (valueT))
3176 memset (p + 1 + sizeof (valueT),
3177 '\0', nbytes - sizeof (valueT));
3181 if (expP->X_op == O_big)
3183 /* Problem here is to get the bytes
3184 in the right order. We stored
3185 our constant as LITTLENUMs, not
3197 for (p++; nbytes; nbytes -= 2, p += 2, lP++)
3198 md_number_to_chars (p, *lP, 2);
3203 fix_new (frag_now, p + 1 - frag_now->fr_literal,
3204 nbytes, this_add_symbol,
3205 this_add_number, 0, NO_RELOC);
3212 /* {@}{q^}foo(Rn) */
3213 know ((length == 0 && operandP->vop_short == ' ')
3214 || (length > 0 && operandP->vop_short != ' '));
3221 test = this_add_number;
3226 length = test & 0xffff8000 ? 4
3227 : test & 0xffffff80 ? 2
3235 p = frag_more (1 + length);
3236 know (operandP->vop_reg >= 0);
3237 p[0] = operandP->vop_reg
3238 | ((at | "?\12\14?\16"[length]) << 4);
3241 md_number_to_chars (p + 1, this_add_number, length);
3245 fix_new (frag_now, p + 1 - frag_now->fr_literal,
3246 length, this_add_symbol,
3247 this_add_number, 0, NO_RELOC);
3263 if ((errtxt = vip_begin (1, "$", "*", "`")) != 0)
3264 as_fatal (_("VIP_BEGIN error:%s"), errtxt);
3266 for (i = 0, fP = float_operand;
3267 fP < float_operand + VIT_MAX_OPERANDS;
3270 fP->low = &big_operand_bits[i][0];
3271 fP->high = &big_operand_bits[i][SIZE_OF_LARGE_NUMBER - 1];
3275 bfd_reloc_code_real_type
3276 vax_cons (expressionS *exp, int size)
3279 const char *vax_cons_special_reloc;
3282 vax_cons_special_reloc = NULL;
3283 save = input_line_pointer;
3284 if (input_line_pointer[0] == '%')
3286 if (strncmp (input_line_pointer + 1, "pcrel", 5) == 0)
3288 input_line_pointer += 6;
3289 vax_cons_special_reloc = "pcrel";
3291 if (vax_cons_special_reloc)
3298 if (*input_line_pointer != '8')
3300 input_line_pointer--;
3303 if (input_line_pointer[0] != '1' || input_line_pointer[1] != '6')
3307 if (input_line_pointer[0] != '3' || input_line_pointer[1] != '2')
3317 as_bad (_("Illegal operands: Only %%r_%s%d allowed in %d-byte data fields"),
3318 vax_cons_special_reloc, size * 8, size);
3322 input_line_pointer += 2;
3323 if (*input_line_pointer != '(')
3325 as_bad (_("Illegal operands: %%r_%s%d requires arguments in ()"),
3326 vax_cons_special_reloc, size * 8);
3333 input_line_pointer = save;
3334 vax_cons_special_reloc = NULL;
3339 char *end = ++input_line_pointer;
3342 while (! is_end_of_line[(c = *end)])
3356 as_bad (_("Illegal operands: %%r_%s%d requires arguments in ()"),
3357 vax_cons_special_reloc, size * 8);
3363 if (input_line_pointer != end)
3365 as_bad (_("Illegal operands: %%r_%s%d requires arguments in ()"),
3366 vax_cons_special_reloc, size * 8);
3370 input_line_pointer++;
3372 c = *input_line_pointer;
3373 if (! is_end_of_line[c] && c != ',')
3374 as_bad (_("Illegal operands: garbage after %%r_%s%d()"),
3375 vax_cons_special_reloc, size * 8);
3381 if (vax_cons_special_reloc == NULL)
3386 case 1: return BFD_RELOC_8_PCREL;
3387 case 2: return BFD_RELOC_16_PCREL;
3388 case 4: return BFD_RELOC_32_PCREL;
3393 /* This is called by emit_expr via TC_CONS_FIX_NEW when creating a
3394 reloc for a cons. */
3397 vax_cons_fix_new (fragS *frag, int where, unsigned int nbytes, expressionS *exp,
3398 bfd_reloc_code_real_type r)
3401 r = (nbytes == 1 ? BFD_RELOC_8
3402 : nbytes == 2 ? BFD_RELOC_16
3405 fix_new_exp (frag, where, (int) nbytes, exp, 0, r);
3409 md_atof (int type, char * litP, int * sizeP)
3411 return vax_md_atof (type, litP, sizeP);