1 /* tc-vax.c - vax-specific -
2 Copyright 1987, 1991, 1992, 1993, 1994, 1995, 1998, 2000, 2001, 2002,
3 2003, 2004, 2005, 2006, 2007, 2008
4 Free Software Foundation, Inc.
6 This file is part of GAS, the GNU Assembler.
8 GAS is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
13 GAS is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GAS; see the file COPYING. If not, write to the Free
20 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
26 #include "obstack.h" /* For FRAG_APPEND_1_CHAR macro in "frags.h" */
28 #include "safe-ctype.h"
34 /* These chars start a comment anywhere in a source file (except inside
36 const char comment_chars[] = "#";
38 /* These chars only start a comment at the beginning of a line. */
39 /* Note that for the VAX the are the same as comment_chars above. */
40 const char line_comment_chars[] = "#";
42 const char line_separator_chars[] = ";";
44 /* Chars that can be used to separate mant from exp in floating point nums. */
45 const char EXP_CHARS[] = "eE";
47 /* Chars that mean this number is a floating point constant
49 or 0H1.234E-12 (see exp chars above). */
50 const char FLT_CHARS[] = "dDfFgGhH";
52 /* Also be aware that MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT may have to be
53 changed in read.c . Ideally it shouldn't have to know about it at all,
54 but nothing is ideal around here. */
56 /* Hold details of an operand expression. */
57 static expressionS exp_of_operand[VIT_MAX_OPERANDS];
58 static segT seg_of_operand[VIT_MAX_OPERANDS];
60 /* A vax instruction after decoding. */
63 /* Hold details of big operands. */
64 LITTLENUM_TYPE big_operand_bits[VIT_MAX_OPERANDS][SIZE_OF_LARGE_NUMBER];
65 FLONUM_TYPE float_operand[VIT_MAX_OPERANDS];
66 /* Above is made to point into big_operand_bits by md_begin(). */
69 #define GLOBAL_OFFSET_TABLE_NAME "_GLOBAL_OFFSET_TABLE_"
70 #define PROCEDURE_LINKAGE_TABLE_NAME "_PROCEDURE_LINKAGE_TABLE_"
71 symbolS *GOT_symbol; /* Pre-defined "_GLOBAL_OFFSET_TABLE_". */
72 symbolS *PLT_symbol; /* Pre-defined "_PROCEDURE_LINKAGE_TABLE_". */
75 int flag_hash_long_names; /* -+ */
76 int flag_one; /* -1 */
77 int flag_show_after_trunc; /* -H */
78 int flag_no_hash_mixed_case; /* -h NUM */
80 int flag_want_pic; /* -k */
83 /* For VAX, relative addresses of "just the right length" are easy.
84 The branch displacement is always the last operand, even in
85 synthetic instructions.
86 For VAX, we encode the relax_substateTs (in e.g. fr_substate) as:
89 ---/ /--+-------+-------+-------+-------+-------+
90 | what state ? | how long ? |
91 ---/ /--+-------+-------+-------+-------+-------+
93 The "how long" bits are 00=byte, 01=word, 10=long.
94 This is a Un*x convention.
95 Not all lengths are legit for a given value of (what state).
96 The "how long" refers merely to the displacement length.
97 The address usually has some constant bytes in it as well.
99 groups for VAX address relaxing.
101 1. "foo" pc-relative.
102 length of byte, word, long
104 2a. J<cond> where <cond> is a simple flag test.
105 length of byte, word, long.
106 VAX opcodes are: (Hex)
119 Always, you complement 0th bit to reverse condition.
120 Always, 1-byte opcode, then 1-byte displacement.
122 2b. J<cond> where cond tests a memory bit.
123 length of byte, word, long.
124 Vax opcodes are: (Hex)
131 Always, you complement 0th bit to reverse condition.
132 Always, 1-byte opcde, longword-address, byte-address, 1-byte-displacement
134 2c. J<cond> where cond tests low-order memory bit
135 length of byte,word,long.
136 Vax opcodes are: (Hex)
139 Always, you complement 0th bit to reverse condition.
140 Always, 1-byte opcode, longword-address, 1-byte displacement.
143 length of byte,word,long.
144 Vax opcodes are: (Hex)
147 These are like (2) but there is no condition to reverse.
148 Always, 1 byte opcode, then displacement/absolute.
151 length of word, long.
152 Vax opcodes are: (Hex)
160 Always, we cannot reverse the sense of the branch; we have a word
162 The double-byte op-codes don't hurt: we never want to modify the
163 opcode, so we don't care how many bytes are between the opcode and
167 length of long, long, byte.
168 Vax opcodes are: (Hex)
173 Always, we cannot reverse the sense of the branch; we have a byte
176 The only time we need to modify the opcode is for class 2 instructions.
177 After relax() we may complement the lowest order bit of such instruction
178 to reverse sense of branch.
180 For class 2 instructions, we store context of "where is the opcode literal".
181 We can change an opcode's lowest order bit without breaking anything else.
183 We sometimes store context in the operand literal. This way we can figure out
184 after relax() what the original addressing mode was. */
186 /* These displacements are relative to the start address of the
187 displacement. The first letter is Byte, Word. 2nd letter is
188 Forward, Backward. */
191 #define WF (2+ 32767)
192 #define WB (2+-32768)
193 /* Dont need LF, LB because they always reach. [They are coded as 0.] */
195 #define C(a,b) ENCODE_RELAX(a,b)
196 /* This macro has no side-effects. */
197 #define ENCODE_RELAX(what,length) (((what) << 2) + (length))
198 #define RELAX_STATE(s) ((s) >> 2)
199 #define RELAX_LENGTH(s) ((s) & 3)
201 const relax_typeS md_relax_table[] =
203 {1, 1, 0, 0}, /* error sentinel 0,0 */
204 {1, 1, 0, 0}, /* unused 0,1 */
205 {1, 1, 0, 0}, /* unused 0,2 */
206 {1, 1, 0, 0}, /* unused 0,3 */
208 {BF + 1, BB + 1, 2, C (1, 1)},/* B^"foo" 1,0 */
209 {WF + 1, WB + 1, 3, C (1, 2)},/* W^"foo" 1,1 */
210 {0, 0, 5, 0}, /* L^"foo" 1,2 */
211 {1, 1, 0, 0}, /* unused 1,3 */
213 {BF, BB, 1, C (2, 1)}, /* b<cond> B^"foo" 2,0 */
214 {WF + 2, WB + 2, 4, C (2, 2)},/* br.+? brw X 2,1 */
215 {0, 0, 7, 0}, /* br.+? jmp X 2,2 */
216 {1, 1, 0, 0}, /* unused 2,3 */
218 {BF, BB, 1, C (3, 1)}, /* brb B^foo 3,0 */
219 {WF, WB, 2, C (3, 2)}, /* brw W^foo 3,1 */
220 {0, 0, 5, 0}, /* Jmp L^foo 3,2 */
221 {1, 1, 0, 0}, /* unused 3,3 */
223 {1, 1, 0, 0}, /* unused 4,0 */
224 {WF, WB, 2, C (4, 2)}, /* acb_ ^Wfoo 4,1 */
225 {0, 0, 10, 0}, /* acb_,br,jmp L^foo4,2 */
226 {1, 1, 0, 0}, /* unused 4,3 */
228 {BF, BB, 1, C (5, 1)}, /* Xob___,,foo 5,0 */
229 {WF + 4, WB + 4, 6, C (5, 2)},/* Xob.+2,brb.+3,brw5,1 */
230 {0, 0, 9, 0}, /* Xob.+2,brb.+6,jmp5,2 */
231 {1, 1, 0, 0}, /* unused 5,3 */
240 void float_cons (int);
241 int flonum_gen2vax (char, FLONUM_TYPE *, LITTLENUM_TYPE *);
243 const pseudo_typeS md_pseudo_table[] =
245 {"dfloat", float_cons, 'd'},
246 {"ffloat", float_cons, 'f'},
247 {"gfloat", float_cons, 'g'},
248 {"hfloat", float_cons, 'h'},
249 {"d_floating", float_cons, 'd'},
250 {"f_floating", float_cons, 'f'},
251 {"g_floating", float_cons, 'g'},
252 {"h_floating", float_cons, 'h'},
256 #define STATE_PC_RELATIVE (1)
257 #define STATE_CONDITIONAL_BRANCH (2)
258 #define STATE_ALWAYS_BRANCH (3) /* includes BSB... */
259 #define STATE_COMPLEX_BRANCH (4)
260 #define STATE_COMPLEX_HOP (5)
262 #define STATE_BYTE (0)
263 #define STATE_WORD (1)
264 #define STATE_LONG (2)
265 #define STATE_UNDF (3) /* Symbol undefined in pass1. */
267 #define min(a, b) ((a) < (b) ? (a) : (b))
270 md_number_to_chars (char con[], valueT value, int nbytes)
272 number_to_chars_littleendian (con, value, nbytes);
275 /* Fix up some data or instructions after we find out the value of a symbol
276 that they reference. */
278 void /* Knows about order of bytes in address. */
279 md_apply_fix (fixS *fixP, valueT *valueP, segT seg ATTRIBUTE_UNUSED)
281 valueT value = * valueP;
283 if (((fixP->fx_addsy == NULL && fixP->fx_subsy == NULL)
284 && fixP->fx_r_type != BFD_RELOC_32_PLT_PCREL
285 && fixP->fx_r_type != BFD_RELOC_32_GOT_PCREL)
286 || fixP->fx_r_type == NO_RELOC)
287 number_to_chars_littleendian (fixP->fx_where + fixP->fx_frag->fr_literal,
288 value, fixP->fx_size);
290 if (fixP->fx_addsy == NULL && fixP->fx_pcrel == 0)
294 /* Convert a number from VAX byte order (little endian)
295 into host byte order.
296 con is the buffer to convert,
297 nbytes is the length of the given buffer. */
299 md_chars_to_number (unsigned char con[], int nbytes)
303 for (retval = 0, con += nbytes - 1; nbytes--; con--)
305 retval <<= BITS_PER_CHAR;
311 /* Copy a bignum from in to out.
312 If the output is shorter than the input, copy lower-order
313 littlenums. Return 0 or the number of significant littlenums
314 dropped. Assumes littlenum arrays are densely packed: no unused
315 chars between the littlenums. Uses memcpy() to move littlenums, and
316 wants to know length (in chars) of the input bignum. */
319 bignum_copy (LITTLENUM_TYPE *in,
320 int in_length, /* in sizeof(littlenum)s */
322 int out_length /* in sizeof(littlenum)s */)
324 int significant_littlenums_dropped;
326 if (out_length < in_length)
328 LITTLENUM_TYPE *p; /* -> most significant (non-zero) input
331 memcpy ((void *) out, (void *) in,
332 (unsigned int) out_length << LITTLENUM_SHIFT);
333 for (p = in + in_length - 1; p >= in; --p)
338 significant_littlenums_dropped = p - in - in_length + 1;
340 if (significant_littlenums_dropped < 0)
341 significant_littlenums_dropped = 0;
345 memcpy ((char *) out, (char *) in,
346 (unsigned int) in_length << LITTLENUM_SHIFT);
348 if (out_length > in_length)
349 memset ((char *) (out + in_length), '\0',
350 (unsigned int) (out_length - in_length) << LITTLENUM_SHIFT);
352 significant_littlenums_dropped = 0;
355 return significant_littlenums_dropped;
358 /* md_estimate_size_before_relax(), called just before relax().
359 Any symbol that is now undefined will not become defined.
360 Return the correct fr_subtype in the frag and the growth beyond
363 md_estimate_size_before_relax (fragS *fragP, segT segment)
365 if (RELAX_LENGTH (fragP->fr_subtype) == STATE_UNDF)
367 if (S_GET_SEGMENT (fragP->fr_symbol) != segment
369 || S_IS_WEAK (fragP->fr_symbol)
370 || S_IS_EXTERNAL (fragP->fr_symbol)
374 /* Non-relaxable cases. */
375 int reloc_type = NO_RELOC;
379 old_fr_fix = fragP->fr_fix;
380 p = fragP->fr_literal + old_fr_fix;
382 /* If this is to an undefined symbol, then if it's an indirect
383 reference indicate that is can mutated into a GLOB_DAT or
384 JUMP_SLOT by the loader. We restrict ourselves to no offset
385 due to a limitation in the NetBSD linker. */
387 if (GOT_symbol == NULL)
388 GOT_symbol = symbol_find (GLOBAL_OFFSET_TABLE_NAME);
389 if (PLT_symbol == NULL)
390 PLT_symbol = symbol_find (PROCEDURE_LINKAGE_TABLE_NAME);
391 if ((GOT_symbol == NULL || fragP->fr_symbol != GOT_symbol)
392 && (PLT_symbol == NULL || fragP->fr_symbol != PLT_symbol)
393 && fragP->fr_symbol != NULL
395 && (!S_IS_DEFINED (fragP->fr_symbol)
396 || S_IS_WEAK (fragP->fr_symbol)
397 || S_IS_EXTERNAL (fragP->fr_symbol)))
399 /* Indirect references cannot go through the GOT or PLT,
400 let's hope they'll become local in the final link. */
401 if ((ELF_ST_VISIBILITY (S_GET_OTHER (fragP->fr_symbol))
404 reloc_type = BFD_RELOC_32_PCREL;
405 else if (((unsigned char *) fragP->fr_opcode)[0] == VAX_CALLS
406 || ((unsigned char *) fragP->fr_opcode)[0] == VAX_CALLG
407 || ((unsigned char *) fragP->fr_opcode)[0] == VAX_JSB
408 || ((unsigned char *) fragP->fr_opcode)[0] == VAX_JMP
409 || S_IS_FUNCTION (fragP->fr_symbol))
410 reloc_type = BFD_RELOC_32_PLT_PCREL;
412 reloc_type = BFD_RELOC_32_GOT_PCREL;
415 switch (RELAX_STATE (fragP->fr_subtype))
417 case STATE_PC_RELATIVE:
418 p[0] |= VAX_PC_RELATIVE_MODE; /* Preserve @ bit. */
419 fragP->fr_fix += 1 + 4;
420 fix_new (fragP, old_fr_fix + 1, 4, fragP->fr_symbol,
421 fragP->fr_offset, 1, reloc_type);
424 case STATE_CONDITIONAL_BRANCH:
425 *fragP->fr_opcode ^= 1; /* Reverse sense of branch. */
428 p[2] = VAX_PC_RELATIVE_MODE; /* ...(PC) */
429 fragP->fr_fix += 1 + 1 + 1 + 4;
430 fix_new (fragP, old_fr_fix + 3, 4, fragP->fr_symbol,
431 fragP->fr_offset, 1, NO_RELOC);
434 case STATE_COMPLEX_BRANCH:
440 p[5] = VAX_PC_RELATIVE_MODE; /* ...(pc) */
441 fragP->fr_fix += 2 + 2 + 1 + 1 + 4;
442 fix_new (fragP, old_fr_fix + 6, 4, fragP->fr_symbol,
443 fragP->fr_offset, 1, NO_RELOC);
446 case STATE_COMPLEX_HOP:
451 p[4] = VAX_PC_RELATIVE_MODE; /* ...(pc) */
452 fragP->fr_fix += 1 + 2 + 1 + 1 + 4;
453 fix_new (fragP, old_fr_fix + 5, 4, fragP->fr_symbol,
454 fragP->fr_offset, 1, NO_RELOC);
457 case STATE_ALWAYS_BRANCH:
458 *fragP->fr_opcode += VAX_WIDEN_LONG;
459 p[0] = VAX_PC_RELATIVE_MODE; /* ...(PC) */
460 fragP->fr_fix += 1 + 4;
461 fix_new (fragP, old_fr_fix + 1, 4, fragP->fr_symbol,
462 fragP->fr_offset, 1, NO_RELOC);
470 /* Return the growth in the fixed part of the frag. */
471 return fragP->fr_fix - old_fr_fix;
474 /* Relaxable cases. Set up the initial guess for the variable
476 switch (RELAX_STATE (fragP->fr_subtype))
478 case STATE_PC_RELATIVE:
479 fragP->fr_subtype = ENCODE_RELAX (STATE_PC_RELATIVE, STATE_BYTE);
481 case STATE_CONDITIONAL_BRANCH:
482 fragP->fr_subtype = ENCODE_RELAX (STATE_CONDITIONAL_BRANCH, STATE_BYTE);
484 case STATE_COMPLEX_BRANCH:
485 fragP->fr_subtype = ENCODE_RELAX (STATE_COMPLEX_BRANCH, STATE_WORD);
487 case STATE_COMPLEX_HOP:
488 fragP->fr_subtype = ENCODE_RELAX (STATE_COMPLEX_HOP, STATE_BYTE);
490 case STATE_ALWAYS_BRANCH:
491 fragP->fr_subtype = ENCODE_RELAX (STATE_ALWAYS_BRANCH, STATE_BYTE);
496 if (fragP->fr_subtype >= sizeof (md_relax_table) / sizeof (md_relax_table[0]))
499 /* Return the size of the variable part of the frag. */
500 return md_relax_table[fragP->fr_subtype].rlx_length;
503 /* Called after relax() is finished.
505 fr_type == rs_machine_dependent.
506 fr_subtype is what the address relaxed to.
508 Out: Any fixSs and constants are set up.
509 Caller will turn frag into a ".space 0". */
511 md_convert_frag (bfd *headers ATTRIBUTE_UNUSED,
512 segT seg ATTRIBUTE_UNUSED,
515 char *addressP; /* -> _var to change. */
516 char *opcodeP; /* -> opcode char(s) to change. */
517 short int extension = 0; /* Size of relaxed address. */
518 /* Added to fr_fix: incl. ALL var chars. */
522 know (fragP->fr_type == rs_machine_dependent);
523 where = fragP->fr_fix;
524 addressP = fragP->fr_literal + where;
525 opcodeP = fragP->fr_opcode;
526 symbolP = fragP->fr_symbol;
529 switch (fragP->fr_subtype)
531 case ENCODE_RELAX (STATE_PC_RELATIVE, STATE_BYTE):
532 know (*addressP == 0 || *addressP == 0x10); /* '@' bit. */
533 addressP[0] |= 0xAF; /* Byte displacement. */
534 fix_new (fragP, fragP->fr_fix + 1, 1, fragP->fr_symbol,
535 fragP->fr_offset, 1, NO_RELOC);
539 case ENCODE_RELAX (STATE_PC_RELATIVE, STATE_WORD):
540 know (*addressP == 0 || *addressP == 0x10); /* '@' bit. */
541 addressP[0] |= 0xCF; /* Word displacement. */
542 fix_new (fragP, fragP->fr_fix + 1, 2, fragP->fr_symbol,
543 fragP->fr_offset, 1, NO_RELOC);
547 case ENCODE_RELAX (STATE_PC_RELATIVE, STATE_LONG):
548 know (*addressP == 0 || *addressP == 0x10); /* '@' bit. */
549 addressP[0] |= 0xEF; /* Long word displacement. */
550 fix_new (fragP, fragP->fr_fix + 1, 4, fragP->fr_symbol,
551 fragP->fr_offset, 1, NO_RELOC);
555 case ENCODE_RELAX (STATE_CONDITIONAL_BRANCH, STATE_BYTE):
556 fix_new (fragP, fragP->fr_fix, 1, fragP->fr_symbol,
557 fragP->fr_offset, 1, NO_RELOC);
561 case ENCODE_RELAX (STATE_CONDITIONAL_BRANCH, STATE_WORD):
562 opcodeP[0] ^= 1; /* Reverse sense of test. */
564 addressP[1] = VAX_BRW;
565 fix_new (fragP, fragP->fr_fix + 2, 2, fragP->fr_symbol,
566 fragP->fr_offset, 1, NO_RELOC);
570 case ENCODE_RELAX (STATE_CONDITIONAL_BRANCH, STATE_LONG):
571 opcodeP[0] ^= 1; /* Reverse sense of test. */
573 addressP[1] = VAX_JMP;
574 addressP[2] = VAX_PC_RELATIVE_MODE;
575 fix_new (fragP, fragP->fr_fix + 3, 4, fragP->fr_symbol,
576 fragP->fr_offset, 1, NO_RELOC);
580 case ENCODE_RELAX (STATE_ALWAYS_BRANCH, STATE_BYTE):
581 fix_new (fragP, fragP->fr_fix, 1, fragP->fr_symbol,
582 fragP->fr_offset, 1, NO_RELOC);
586 case ENCODE_RELAX (STATE_ALWAYS_BRANCH, STATE_WORD):
587 opcodeP[0] += VAX_WIDEN_WORD; /* brb -> brw, bsbb -> bsbw */
588 fix_new (fragP, fragP->fr_fix, 2, fragP->fr_symbol, fragP->fr_offset,
593 case ENCODE_RELAX (STATE_ALWAYS_BRANCH, STATE_LONG):
594 opcodeP[0] += VAX_WIDEN_LONG; /* brb -> jmp, bsbb -> jsb */
595 addressP[0] = VAX_PC_RELATIVE_MODE;
596 fix_new (fragP, fragP->fr_fix + 1, 4, fragP->fr_symbol,
597 fragP->fr_offset, 1, NO_RELOC);
601 case ENCODE_RELAX (STATE_COMPLEX_BRANCH, STATE_WORD):
602 fix_new (fragP, fragP->fr_fix, 2, fragP->fr_symbol,
603 fragP->fr_offset, 1, NO_RELOC);
607 case ENCODE_RELAX (STATE_COMPLEX_BRANCH, STATE_LONG):
610 addressP[2] = VAX_BRB;
612 addressP[4] = VAX_JMP;
613 addressP[5] = VAX_PC_RELATIVE_MODE;
614 fix_new (fragP, fragP->fr_fix + 6, 4, fragP->fr_symbol,
615 fragP->fr_offset, 1, NO_RELOC);
619 case ENCODE_RELAX (STATE_COMPLEX_HOP, STATE_BYTE):
620 fix_new (fragP, fragP->fr_fix, 1, fragP->fr_symbol,
621 fragP->fr_offset, 1, NO_RELOC);
625 case ENCODE_RELAX (STATE_COMPLEX_HOP, STATE_WORD):
627 addressP[1] = VAX_BRB;
629 addressP[3] = VAX_BRW;
630 fix_new (fragP, fragP->fr_fix + 4, 2, fragP->fr_symbol,
631 fragP->fr_offset, 1, NO_RELOC);
635 case ENCODE_RELAX (STATE_COMPLEX_HOP, STATE_LONG):
637 addressP[1] = VAX_BRB;
639 addressP[3] = VAX_JMP;
640 addressP[4] = VAX_PC_RELATIVE_MODE;
641 fix_new (fragP, fragP->fr_fix + 5, 4, fragP->fr_symbol,
642 fragP->fr_offset, 1, NO_RELOC);
647 BAD_CASE (fragP->fr_subtype);
650 fragP->fr_fix += extension;
653 /* Translate internal format of relocation info into target format.
655 On vax: first 4 bytes are normal unsigned long, next three bytes
656 are symbolnum, least sig. byte first. Last byte is broken up with
657 the upper nibble as nuthin, bit 3 as extern, bits 2 & 1 as length, and
661 md_ri_to_chars (char *the_bytes, struct reloc_info_generic ri)
664 md_number_to_chars (the_bytes, ri.r_address, sizeof (ri.r_address));
665 /* Now the fun stuff. */
666 the_bytes[6] = (ri.r_symbolnum >> 16) & 0x0ff;
667 the_bytes[5] = (ri.r_symbolnum >> 8) & 0x0ff;
668 the_bytes[4] = ri.r_symbolnum & 0x0ff;
669 the_bytes[7] = (((ri.r_extern << 3) & 0x08) | ((ri.r_length << 1) & 0x06)
670 | ((ri.r_pcrel << 0) & 0x01)) & 0x0F;
675 /* BUGS, GRIPES, APOLOGIA, etc.
677 The opcode table 'votstrs' needs to be sorted on opcode frequency.
678 That is, AFTER we hash it with hash_...(), we want most-used opcodes
679 to come out of the hash table faster.
681 I am sorry to inflict yet another VAX assembler on the world, but
682 RMS says we must do everything from scratch, to prevent pin-heads
683 restricting this software.
685 This is a vaguely modular set of routines in C to parse VAX
686 assembly code using DEC mnemonics. It is NOT un*x specific.
688 The idea here is that the assembler has taken care of all:
695 condensing any whitespace down to exactly one space
696 and all we have to do is parse 1 line into a vax instruction
697 partially formed. We will accept a line, and deliver:
698 an error message (hopefully empty)
699 a skeleton VAX instruction (tree structure)
700 textual pointers to all the operand expressions
701 a warning message that notes a silly operand (hopefully empty)
703 E D I T H I S T O R Y
705 17may86 Dean Elsner. Bug if line ends immediately after opcode.
706 30apr86 Dean Elsner. New vip_op() uses arg block so change call.
707 6jan86 Dean Elsner. Crock vip_begin() to call vip_op_defaults().
708 2jan86 Dean Elsner. Invent synthetic opcodes.
709 Widen vax_opcodeT to 32 bits. Use a bit for VIT_OPCODE_SYNTHETIC,
710 which means this is not a real opcode, it is like a macro; it will
711 be relax()ed into 1 or more instructions.
712 Use another bit for VIT_OPCODE_SPECIAL if the op-code is not optimised
713 like a regular branch instruction. Option added to vip_begin():
714 exclude synthetic opcodes. Invent synthetic_votstrs[].
715 31dec85 Dean Elsner. Invent vit_opcode_nbytes.
716 Also make vit_opcode into a char[]. We now have n-byte vax opcodes,
717 so caller's don't have to know the difference between a 1-byte & a
718 2-byte op-code. Still need vax_opcodeT concept, so we know how
719 big an object must be to hold an op.code.
720 30dec85 Dean Elsner. Widen typedef vax_opcodeT in "vax-inst.h"
721 because vax opcodes may be 16 bits. Our crufty C compiler was
722 happily initialising 8-bit vot_codes with 16-bit numbers!
723 (Wouldn't the 'phone company like to compress data so easily!)
724 29dec85 Dean Elsner. New static table vax_operand_width_size[].
725 Invented so we know hw many bytes a "I^#42" needs in its immediate
726 operand. Revised struct vop in "vax-inst.h": explicitly include
727 byte length of each operand, and it's letter-code datum type.
728 17nov85 Dean Elsner. Name Change.
729 Due to ar(1) truncating names, we learned the hard way that
730 "vax-inst-parse.c" -> "vax-inst-parse." dropping the "o" off
731 the archived object name. SO... we shortened the name of this
732 source file, and changed the makefile. */
734 /* Handle of the OPCODE hash table. */
735 static struct hash_control *op_hash;
737 /* In: 1 character, from "bdfghloqpw" being the data-type of an operand
738 of a vax instruction.
740 Out: the length of an operand of that type, in bytes.
741 Special branch operands types "-?!" have length 0. */
743 static const short int vax_operand_width_size[256] =
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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
748 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
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, 1, 0, 8, 0, 4, 8, 16, 0, 0, 0, 4, 0, 0,16, /* ..b.d.fgh...l..o */
752 0, 8, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, /* .q.....w........ */
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,
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,
763 /* This perversion encodes all the vax opcodes as a bunch of strings.
764 RMS says we should build our hash-table at run-time. Hmm.
765 Please would someone arrange these in decreasing frequency of opcode?
766 Because of the way hash_...() works, the most frequently used opcode
767 should be textually first and so on.
769 Input for this table was 'vax.opcodes', awk(1)ed by 'vax.opcodes.c.awk' .
770 So change 'vax.opcodes', then re-generate this table. */
772 #include "opcode/vax.h"
774 /* This is a table of optional op-codes. All of them represent
775 'synthetic' instructions that seem popular.
777 Here we make some pseudo op-codes. Every code has a bit set to say
778 it is synthetic. This lets you catch them if you want to
779 ban these opcodes. They are mnemonics for "elastic" instructions
780 that are supposed to assemble into the fewest bytes needed to do a
781 branch, or to do a conditional branch, or whatever.
783 The opcode is in the usual place [low-order n*8 bits]. This means
784 that if you mask off the bucky bits, the usual rules apply about
785 how long the opcode is.
787 All VAX branch displacements come at the end of the instruction.
788 For simple branches (1-byte opcode + 1-byte displacement) the last
789 operand is coded 'b?' where the "data type" '?' is a clue that we
790 may reverse the sense of the branch (complement lowest order bit)
791 and branch around a jump. This is by far the most common case.
792 That is why the VIT_OPCODE_SYNTHETIC bit is set: it says this is
793 a 0-byte op-code followed by 2 or more bytes of operand address.
795 If the op-code has VIT_OPCODE_SPECIAL set, then we have a more unusual
798 For JBSB & JBR the treatment is the similar, except (1) we have a 'bw'
799 option before (2) we can directly JSB/JMP because there is no condition.
800 These operands have 'b-' as their access/data type.
802 That leaves a bunch of random opcodes: JACBx, JxOBxxx. In these
803 cases, we do the same idea. JACBxxx are all marked with a 'b!'
804 JAOBxxx & JSOBxxx are marked with a 'b:'. */
805 #if (VIT_OPCODE_SYNTHETIC != 0x80000000)
806 #error "You have just broken the encoding below, which assumes the sign bit means 'I am an imaginary instruction'."
809 #if (VIT_OPCODE_SPECIAL != 0x40000000)
810 #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'."
813 static const struct vot
814 synthetic_votstrs[] =
816 {"jbsb", {"b-", 0xC0000010}}, /* BSD 4.2 */
817 /* jsb used already */
818 {"jbr", {"b-", 0xC0000011}}, /* BSD 4.2 */
819 {"jr", {"b-", 0xC0000011}}, /* consistent */
820 {"jneq", {"b?", 0x80000012}},
821 {"jnequ", {"b?", 0x80000012}},
822 {"jeql", {"b?", 0x80000013}},
823 {"jeqlu", {"b?", 0x80000013}},
824 {"jgtr", {"b?", 0x80000014}},
825 {"jleq", {"b?", 0x80000015}},
826 /* un-used opcodes here */
827 {"jgeq", {"b?", 0x80000018}},
828 {"jlss", {"b?", 0x80000019}},
829 {"jgtru", {"b?", 0x8000001a}},
830 {"jlequ", {"b?", 0x8000001b}},
831 {"jvc", {"b?", 0x8000001c}},
832 {"jvs", {"b?", 0x8000001d}},
833 {"jgequ", {"b?", 0x8000001e}},
834 {"jcc", {"b?", 0x8000001e}},
835 {"jlssu", {"b?", 0x8000001f}},
836 {"jcs", {"b?", 0x8000001f}},
838 {"jacbw", {"rwrwmwb!", 0xC000003d}},
839 {"jacbf", {"rfrfmfb!", 0xC000004f}},
840 {"jacbd", {"rdrdmdb!", 0xC000006f}},
841 {"jacbb", {"rbrbmbb!", 0xC000009d}},
842 {"jacbl", {"rlrlmlb!", 0xC00000f1}},
843 {"jacbg", {"rgrgmgb!", 0xC0004ffd}},
844 {"jacbh", {"rhrhmhb!", 0xC0006ffd}},
846 {"jbs", {"rlvbb?", 0x800000e0}},
847 {"jbc", {"rlvbb?", 0x800000e1}},
848 {"jbss", {"rlvbb?", 0x800000e2}},
849 {"jbcs", {"rlvbb?", 0x800000e3}},
850 {"jbsc", {"rlvbb?", 0x800000e4}},
851 {"jbcc", {"rlvbb?", 0x800000e5}},
852 {"jbssi", {"rlvbb?", 0x800000e6}},
853 {"jbcci", {"rlvbb?", 0x800000e7}},
854 {"jlbs", {"rlb?", 0x800000e8}},
855 {"jlbc", {"rlb?", 0x800000e9}},
857 {"jaoblss", {"rlmlb:", 0xC00000f2}},
858 {"jaobleq", {"rlmlb:", 0xC00000f3}},
859 {"jsobgeq", {"mlb:", 0xC00000f4}},
860 {"jsobgtr", {"mlb:", 0xC00000f5}},
862 /* CASEx has no branch addresses in our conception of it. */
863 /* You should use ".word ..." statements after the "case ...". */
865 {"", {"", 0}} /* Empty is end sentinel. */
868 /* Because this module is useful for both VMS and UN*X style assemblers
869 and because of the variety of UN*X assemblers we must recognise
870 the different conventions for assembler operand notation. For example
871 VMS says "#42" for immediate mode, while most UN*X say "$42".
872 We permit arbitrary sets of (single) characters to represent the
873 3 concepts that DEC writes '#', '@', '^'. */
875 /* Character tests. */
876 #define VIP_IMMEDIATE 01 /* Character is like DEC # */
877 #define VIP_INDIRECT 02 /* Char is like DEC @ */
878 #define VIP_DISPLEN 04 /* Char is like DEC ^ */
880 #define IMMEDIATEP(c) (vip_metacharacters [(c) & 0xff] & VIP_IMMEDIATE)
881 #define INDIRECTP(c) (vip_metacharacters [(c) & 0xff] & VIP_INDIRECT)
882 #define DISPLENP(c) (vip_metacharacters [(c) & 0xff] & VIP_DISPLEN)
884 /* We assume 8 bits per byte. Use vip_op_defaults() to set these up BEFORE we
887 #if defined(CONST_TABLE)
889 #define I VIP_IMMEDIATE,
890 #define S VIP_INDIRECT,
891 #define D VIP_DISPLEN,
893 vip_metacharacters[256] =
895 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ /* ^@ ^A ^B ^C ^D ^E ^F ^G ^H ^I ^J ^K ^L ^M ^N ^O*/
896 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ /* ^P ^Q ^R ^S ^T ^U ^V ^W ^X ^Y ^Z ^[ ^\ ^] ^^ ^_ */
897 _ _ _ _ I _ _ _ _ _ S _ _ _ _ _ /* sp ! " # $ % & ' ( ) * + , - . / */
898 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ /*0 1 2 3 4 5 6 7 8 9 : ; < = > ?*/
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 D _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ /*` a b c d e f g h i j k l m n o*/
902 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ /*p q r s t u v w x y z { | } ~ ^?*/
904 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
905 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
906 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
907 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
908 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
909 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
910 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
911 _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
920 static char vip_metacharacters[256];
923 vip_op_1 (int bit, const char *syms)
927 while ((t = *syms++) != 0)
928 vip_metacharacters[t] |= bit;
931 /* Can be called any time. More arguments may appear in future. */
933 vip_op_defaults (const char *immediate, const char *indirect, const char *displen)
935 vip_op_1 (VIP_IMMEDIATE, immediate);
936 vip_op_1 (VIP_INDIRECT, indirect);
937 vip_op_1 (VIP_DISPLEN, displen);
942 /* Call me once before you decode any lines.
943 I decode votstrs into a hash table at op_hash (which I create).
944 I return an error text or null.
945 If you want, I will include the 'synthetic' jXXX instructions in the
947 You must nominate metacharacters for eg DEC's "#", "@", "^". */
950 vip_begin (int synthetic_too, /* 1 means include jXXX op-codes. */
951 const char *immediate,
952 const char *indirect,
955 const struct vot *vP; /* scan votstrs */
956 const char *retval = 0; /* error text */
958 op_hash = hash_new ();
960 for (vP = votstrs; *vP->vot_name && !retval; vP++)
961 retval = hash_insert (op_hash, vP->vot_name, (void *) &vP->vot_detail);
964 for (vP = synthetic_votstrs; *vP->vot_name && !retval; vP++)
965 retval = hash_insert (op_hash, vP->vot_name, (void *) &vP->vot_detail);
968 vip_op_defaults (immediate, indirect, displen);
974 /* Take 3 char.s, the last of which may be `\0` (non-existent)
975 and return the VAX register number that they represent.
977 Return -1 if they don't form a register name. Good names return
978 a number from 0:15 inclusive.
980 Case is not important in a name.
982 Register names understood are:
1006 /* Returns the register number of something like '%r15' or 'ap', supplied
1007 in four single chars. Returns -1 if the register isn't recognized,
1010 vax_reg_parse (char c1, char c2, char c3, char c4)
1015 if (c1 != '%') /* Register prefixes are mandatory for ELF. */
1022 if (c4 != 0) /* Register prefixes are not allowed under VMS. */
1026 if (c1 == '%') /* Register prefixes are optional under a.out. */
1032 else if (c3 && c4) /* Can't be 4 characters long. */
1038 if (ISDIGIT (c2) && c1 == 'r')
1043 retval = retval * 10 + c3 - '0';
1044 retval = (retval > 15) ? -1 : retval;
1045 /* clamp the register value to 1 hex digit */
1048 retval = -1; /* c3 must be '\0' or a digit. */
1050 else if (c3) /* There are no three letter regs. */
1069 else if (c1 == 'p' && c2 == 'c')
1076 /* Parse a vax operand in DEC assembler notation.
1077 For speed, expect a string of whitespace to be reduced to a single ' '.
1078 This is the case for GNU AS, and is easy for other DEC-compatible
1081 Knowledge about DEC VAX assembler operand notation lives here.
1082 This doesn't even know what a register name is, except it believes
1083 all register names are 2 or 3 characters, and lets vax_reg_parse() say
1084 what number each name represents.
1085 It does, however, know that PC, SP etc are special registers so it can
1086 detect addressing modes that are silly for those registers.
1088 Where possible, it delivers 1 fatal or 1 warning message if the operand
1089 is suspect. Exactly what we test for is still evolving.
1094 There were a number of 'mismatched argument type' bugs to vip_op.
1095 The most general solution is to typedef each (of many) arguments.
1096 We used instead a typedef'd argument block. This is less modular
1097 than using separate return pointers for each result, but runs faster
1098 on most engines, and seems to keep programmers happy. It will have
1099 to be done properly if we ever want to use vip_op as a general-purpose
1100 module (it was designed to be).
1104 Doesn't support DEC "G^" format operands. These always take 5 bytes
1105 to express, and code as modes 8F or 9F. Reason: "G^" deprives you of
1106 optimising to (say) a "B^" if you are lucky in the way you link.
1107 When someone builds a linker smart enough to convert "G^" to "B^", "W^"
1108 whenever possible, then we should implement it.
1109 If there is some other use for "G^", feel free to code it in!
1113 If I nested if()s more, I could avoid testing (*err) which would save
1114 time, space and page faults. I didn't nest all those if()s for clarity
1115 and because I think the mode testing can be re-arranged 1st to test the
1116 commoner constructs 1st. Does anybody have statistics on this?
1120 In future, we should be able to 'compose' error messages in a scratch area
1121 and give the user MUCH more informative error messages. Although this takes
1122 a little more code at run-time, it will make this module much more self-
1123 documenting. As an example of what sucks now: most error messages have
1124 hardwired into them the DEC VAX metacharacters "#^@" which are nothing like
1125 the Un*x characters "$`*", that most users will expect from this AS.
1129 The input is a string, ending with '\0'.
1131 We also require a 'hint' of what kind of operand is expected: so
1132 we can remind caller not to write into literals for instance.
1134 The output is a skeletal instruction.
1136 The algorithm has two parts.
1137 1. extract the syntactic features (parse off all the @^#-()+[] mode crud);
1138 2. express the @^#-()+[] as some parameters suited to further analysis.
1140 2nd step is where we detect the googles of possible invalid combinations
1141 a human (or compiler) might write. Note that if we do a half-way
1142 decent assembler, we don't know how long to make (eg) displacement
1143 fields when we first meet them (because they may not have defined values).
1144 So we must wait until we know how many bits are needed for each address,
1145 then we can know both length and opcodes of instructions.
1146 For reason(s) above, we will pass to our caller a 'broken' instruction
1147 of these major components, from which our caller can generate instructions:
1148 - displacement length I^ S^ L^ B^ W^ unspecified
1150 - register R0-R15 or absent
1151 - index register R0-R15 or absent
1152 - expression text what we don't parse
1153 - error text(s) why we couldn't understand the operand
1157 To decode output of this, test errtxt. If errtxt[0] == '\0', then
1158 we had no errors that prevented parsing. Also, if we ever report
1159 an internal bug, errtxt[0] is set non-zero. So one test tells you
1160 if the other outputs are to be taken seriously.
1164 Dec defines the semantics of address modes (and values)
1165 by a two-letter code, explained here.
1167 letter 1: access type
1169 a address calculation - no data access, registers forbidden
1170 b branch displacement
1171 m read - let go of bus - write back "modify"
1173 v bit field address: like 'a' but registers are OK
1175 space no operator (eg ".long foo") [our convention]
1177 letter 2: data type (i.e. width, alignment)
1180 d double precision floating point (D format)
1181 f single precision floating point (F format)
1188 ? simple synthetic branch operand
1189 - unconditional synthetic JSB/JSR operand
1190 ! complex synthetic branch operand
1192 The '-?!' letter 2's are not for external consumption. They are used
1193 for various assemblers. Generally, all unknown widths are assumed 0.
1194 We don't limit your choice of width character.
1196 DEC operands are hard work to parse. For example, '@' as the first
1197 character means indirect (deferred) mode but elsewhere it is a shift
1199 The long-winded explanation of how this is supposed to work is
1200 cancelled. Read a DEC vax manual.
1201 We try hard not to parse anything that MIGHT be part of the expression
1202 buried in that syntax. For example if we see @...(Rn) we don't check
1203 for '-' before the '(' because mode @-(Rn) does not exist.
1205 After parsing we have:
1207 at 1 if leading '@' (or Un*x '*')
1208 len takes one value from " bilsw". eg B^ -> 'b'.
1209 hash 1 if leading '#' (or Un*x '$')
1210 expr_begin, expr_end the expression we did not parse
1211 even though we don't interpret it, we make use
1212 of its presence or absence.
1213 sign -1: -(Rn) 0: absent +1: (Rn)+
1214 paren 1 if () are around register
1215 reg major register number 0:15 -1 means absent
1216 ndx index register number 0:15 -1 means absent
1218 Again, I dare not explain it: just trace ALL the code!
1220 Summary of vip_op outputs.
1224 {@}Rn 5+@ n ' ' optional
1225 branch operand 0 -1 ' ' -1
1227 -(Rn) 7 n ' ' optional
1228 {@}(Rn)+ 8+@ n ' ' optional
1229 {@}#foo, no S^ 8+@ PC " i" optional
1230 {@}{q^}{(Rn)} 10+@+q option " bwl" optional */
1232 /* Dissect user-input 'optext' (which is something like "@B^foo@bar(AP)[FP]:")
1233 using the vop in vopP. vopP's vop_access and vop_width. We fill _ndx, _reg,
1234 _mode, _short, _warn, _error, _expr_begin, _expr_end and _nbytes. */
1237 vip_op (char *optext, struct vop *vopP)
1239 /* Track operand text forward. */
1241 /* Track operand text backward. */
1243 /* 1 if leading '@' ('*') seen. */
1245 /* one of " bilsw" */
1247 /* 1 if leading '#' ('$') seen. */
1251 /* 1 if () surround register. */
1253 /* Register number, -1:absent. */
1255 /* Index register number -1:absent. */
1257 /* Report illegal operand, ""==OK. */
1258 /* " " is a FAKE error: means we won. */
1259 /* ANY err that begins with ' ' is a fake. */
1260 /* " " is converted to "" before return. */
1262 /* Warn about weird modes pf address. */
1264 /* Preserve q in case we backup. */
1266 /* Build up 4-bit operand mode here. */
1267 /* Note: index mode is in ndx, this is. */
1268 /* The major mode of operand address. */
1270 /* Notice how we move wrong-arg-type bugs INSIDE this module: if we
1271 get the types wrong below, we lose at compile time rather than at
1272 lint or run time. */
1273 char access_mode; /* vop_access. */
1274 char width; /* vop_width. */
1276 access_mode = vopP->vop_access;
1277 width = vopP->vop_width;
1278 /* None of our code bugs (yet), no user text errors, no warnings
1284 if (*p == ' ') /* Expect all whitespace reduced to ' '. */
1285 p++; /* skip over whitespace */
1287 if ((at = INDIRECTP (*p)) != 0)
1288 { /* 1 if *p=='@'(or '*' for Un*x) */
1289 p++; /* at is determined */
1290 if (*p == ' ') /* Expect all whitespace reduced to ' '. */
1291 p++; /* skip over whitespace */
1294 /* This code is subtle. It tries to detect all legal (letter)'^'
1295 but it doesn't waste time explicitly testing for premature '\0' because
1296 this case is rejected as a mismatch against either (letter) or '^'. */
1302 if (DISPLENP (p[1]) && strchr ("bilws", len = c))
1303 p += 2; /* Skip (letter) '^'. */
1304 else /* No (letter) '^' seen. */
1305 len = ' '; /* Len is determined. */
1308 if (*p == ' ') /* Expect all whitespace reduced to ' '. */
1311 if ((hash = IMMEDIATEP (*p)) != 0) /* 1 if *p=='#' ('$' for Un*x) */
1312 p++; /* Hash is determined. */
1314 /* p points to what may be the beginning of an expression.
1315 We have peeled off the front all that is peelable.
1316 We know at, len, hash.
1318 Lets point q at the end of the text and parse that (backwards). */
1320 for (q = p; *q; q++)
1322 q--; /* Now q points at last char of text. */
1324 if (*q == ' ' && q >= p) /* Expect all whitespace reduced to ' '. */
1327 /* Reverse over whitespace, but don't. */
1328 /* Run back over *p. */
1330 /* As a matter of policy here, we look for [Rn], although both Rn and S^#
1331 forbid [Rn]. This is because it is easy, and because only a sick
1332 cyborg would have [...] trailing an expression in a VAX-like assembler.
1333 A meticulous parser would first check for Rn followed by '(' or '['
1334 and not parse a trailing ']' if it found another. We just ban expressions
1338 while (q >= p && *q != '[')
1340 /* Either q<p or we got matching '['. */
1342 err = _("no '[' to match ']'");
1345 /* Confusers like "[]" will eventually lose with a bad register
1346 * name error. So again we don't need to check for early '\0'. */
1348 ndx = vax_reg_parse (q[1], q[2], 0, 0);
1349 else if (q[4] == ']')
1350 ndx = vax_reg_parse (q[1], q[2], q[3], 0);
1351 else if (q[5] == ']')
1352 ndx = vax_reg_parse (q[1], q[2], q[3], q[4]);
1355 /* Since we saw a ']' we will demand a register name in the [].
1356 * If luser hasn't given us one: be rude. */
1358 err = _("bad register in []");
1360 err = _("[PC] index banned");
1362 /* Point q just before "[...]". */
1367 /* No ']', so no iNDeX register. */
1370 /* If err = "..." then we lost: run away.
1371 Otherwise ndx == -1 if there was no "[...]".
1372 Otherwise, ndx is index register number, and q points before "[...]". */
1374 if (*q == ' ' && q >= p) /* Expect all whitespace reduced to ' '. */
1376 /* Reverse over whitespace, but don't. */
1377 /* Run back over *p. */
1380 /* no ()+ or -() seen yet */
1383 if (q > p + 3 && *q == '+' && q[-1] == ')')
1385 sign = 1; /* we saw a ")+" */
1386 q--; /* q points to ')' */
1389 if (*q == ')' && q > p + 2)
1391 paren = 1; /* assume we have "(...)" */
1392 while (q >= p && *q != '(')
1394 /* either q<p or we got matching '(' */
1396 err = _("no '(' to match ')'");
1399 /* Confusers like "()" will eventually lose with a bad register
1400 name error. So again we don't need to check for early '\0'. */
1402 reg = vax_reg_parse (q[1], q[2], 0, 0);
1403 else if (q[4] == ')')
1404 reg = vax_reg_parse (q[1], q[2], q[3], 0);
1405 else if (q[5] == ')')
1406 reg = vax_reg_parse (q[1], q[2], q[3], q[4]);
1409 /* Since we saw a ')' we will demand a register name in the ')'.
1410 This is nasty: why can't our hypothetical assembler permit
1411 parenthesised expressions? BECAUSE I AM LAZY! That is why.
1412 Abuse luser if we didn't spy a register name. */
1415 /* JF allow parenthesized expressions. I hope this works. */
1419 /* err = "unknown register in ()"; */
1422 q--; /* point just before '(' of "(...)" */
1423 /* If err == "..." then we lost. Run away.
1424 Otherwise if reg >= 0 then we saw (Rn). */
1426 /* If err == "..." then we lost.
1427 Otherwise paren==1 and reg = register in "()". */
1431 /* If err == "..." then we lost.
1432 Otherwise, q points just before "(Rn)", if any.
1433 If there was a "(...)" then paren==1, and reg is the register. */
1435 /* We should only seek '-' of "-(...)" if:
1436 we saw "(...)" paren == 1
1437 we have no errors so far ! *err
1438 we did not see '+' of "(...)+" sign < 1
1439 We don't check len. We want a specific error message later if
1440 user tries "x^...-(Rn)". This is a feature not a bug. */
1443 if (paren && sign < 1)/* !sign is adequate test */
1451 /* We have back-tracked over most
1452 of the crud at the end of an operand.
1453 Unless err, we know: sign, paren. If paren, we know reg.
1454 The last case is of an expression "Rn".
1455 This is worth hunting for if !err, !paren.
1456 We wouldn't be here if err.
1457 We remember to save q, in case we didn't want "Rn" anyway. */
1460 if (*q == ' ' && q >= p) /* Expect all whitespace reduced to ' '. */
1462 /* Reverse over whitespace, but don't. */
1463 /* Run back over *p. */
1464 /* Room for Rn or Rnn (include prefix) exactly? */
1465 if (q > p && q < p + 4)
1466 reg = vax_reg_parse (p[0], p[1],
1467 q < p + 2 ? 0 : p[2],
1468 q < p + 3 ? 0 : p[3]);
1470 reg = -1; /* Always comes here if no register at all. */
1471 /* Here with a definitive reg value. */
1480 /* have reg. -1:absent; else 0:15. */
1482 /* We have: err, at, len, hash, ndx, sign, paren, reg.
1483 Also, any remaining expression is from *p through *q inclusive.
1484 Should there be no expression, q==p-1. So expression length = q-p+1.
1485 This completes the first part: parsing the operand text. */
1487 /* We now want to boil the data down, checking consistency on the way.
1488 We want: len, mode, reg, ndx, err, p, q, wrn, bug.
1489 We will deliver a 4-bit reg, and a 4-bit mode. */
1491 /* Case of branch operand. Different. No L^B^W^I^S^ allowed for instance.
1505 p:q whatever was input
1507 err " " or error message, and other outputs trashed. */
1508 /* Branch operands have restricted forms. */
1509 if ((!err || !*err) && access_mode == 'b')
1511 if (at || hash || sign || paren || ndx >= 0 || reg >= 0 || len != ' ')
1512 err = _("invalid branch operand");
1517 /* Since nobody seems to use it: comment this 'feature'(?) out for now. */
1519 /* Case of stand-alone operand. e.g. ".long foo"
1533 p:q whatever was input
1535 err " " or error message, and other outputs trashed. */
1536 if ((!err || !*err) && access_mode == ' ')
1539 err = _("address prohibits @");
1541 err = _("address prohibits #");
1545 err = _("address prohibits -()");
1547 err = _("address prohibits ()+");
1550 err = _("address prohibits ()");
1552 err = _("address prohibits []");
1554 err = _("address prohibits register");
1555 else if (len != ' ')
1556 err = _("address prohibits displacement length specifier");
1559 err = " "; /* succeed */
1570 p:q demand not empty
1572 paren 0 by "()" scan logic because "S^" seen
1573 reg -1 or nn by mistake
1581 if ((!err || !*err) && len == 's')
1583 if (!hash || paren || at || ndx >= 0)
1584 err = _("invalid operand of S^#");
1589 /* Darn! we saw S^#Rnn ! put the Rnn back in
1590 expression. KLUDGE! Use oldq so we don't
1591 need to know exact length of reg name. */
1595 /* We have all the expression we will ever get. */
1597 err = _("S^# needs expression");
1598 else if (access_mode == 'r')
1600 err = " "; /* WIN! */
1604 err = _("S^# may only read-access");
1608 /* Case of -(Rn), which is weird case.
1614 sign -1 by definition
1615 paren 1 by definition
1616 reg present by definition
1622 exp "" enforce empty expression
1623 ndx optional warn if same as reg. */
1624 if ((!err || !*err) && sign < 0)
1626 if (len != ' ' || hash || at || p <= q)
1627 err = _("invalid operand of -()");
1630 err = " "; /* win */
1633 wrn = _("-(PC) unpredictable");
1634 else if (reg == ndx)
1635 wrn = _("[]index same as -()register: unpredictable");
1639 /* We convert "(Rn)" to "@Rn" for our convenience.
1640 (I hope this is convenient: has someone got a better way to parse this?)
1641 A side-effect of this is that "@Rn" is a valid operand. */
1642 if (paren && !sign && !hash && !at && len == ' ' && p > q)
1648 /* Case of (Rn)+, which is slightly different.
1654 sign +1 by definition
1655 paren 1 by definition
1656 reg present by definition
1662 exp "" enforce empty expression
1663 ndx optional warn if same as reg. */
1664 if ((!err || !*err) && sign > 0)
1666 if (len != ' ' || hash || p <= q)
1667 err = _("invalid operand of ()+");
1670 err = " "; /* win */
1671 mode = 8 + (at ? 1 : 0);
1673 wrn = _("(PC)+ unpredictable");
1674 else if (reg == ndx)
1675 wrn = _("[]index same as ()+register: unpredictable");
1679 /* Case of #, without S^.
1683 hash 1 by definition
1695 if ((!err || !*err) && hash)
1697 if (len != 'i' && len != ' ')
1698 err = _("# conflicts length");
1700 err = _("# bars register");
1705 /* Darn! we saw #Rnn! Put the Rnn back into the expression.
1706 By using oldq, we don't need to know how long Rnn was.
1709 reg = -1; /* No register any more. */
1711 err = " "; /* Win. */
1713 /* JF a bugfix, I think! */
1714 if (at && access_mode == 'a')
1715 vopP->vop_nbytes = 4;
1717 mode = (at ? 9 : 8);
1719 if ((access_mode == 'm' || access_mode == 'w') && !at)
1720 wrn = _("writing or modifying # is unpredictable");
1723 /* If !*err, then sign == 0
1726 /* Case of Rn. We separate this one because it has a few special
1727 errors the remaining modes lack.
1731 hash 0 by program logic
1733 sign 0 by program logic
1734 paren 0 by definition
1735 reg present by definition
1740 len ' ' enforce no length
1741 exp "" enforce empty expression
1742 ndx optional warn if same as reg. */
1743 if ((!err || !*err) && !paren && reg >= 0)
1746 err = _("length not needed");
1749 err = " "; /* win */
1753 err = _("can't []index a register, because it has no address");
1754 else if (access_mode == 'a')
1755 err = _("a register has no address");
1758 /* Idea here is to detect from length of datum
1759 and from register number if we will touch PC.
1761 vop_nbytes is number of bytes in operand.
1762 Compute highest byte affected, compare to PC0. */
1763 if ((vopP->vop_nbytes + reg * 4) > 60)
1764 wrn = _("PC part of operand unpredictable");
1765 err = " "; /* win */
1769 /* If !*err, sign == 0
1771 paren == 1 OR reg==-1 */
1773 /* Rest of cases fit into one bunch.
1776 len ' ' or 'b' or 'w' or 'l'
1777 hash 0 by program logic
1778 p:q expected (empty is not an error)
1779 sign 0 by program logic
1784 out: mode 10 + @ + len
1786 len ' ' or 'b' or 'w' or 'l'
1788 ndx optional warn if same as reg. */
1791 err = " "; /* win (always) */
1792 mode = 10 + (at ? 1 : 0);
1799 case ' ': /* Assumed B^ until our caller changes it. */
1805 /* here with completely specified mode
1812 err = 0; /* " " is no longer an error. */
1814 vopP->vop_mode = mode;
1815 vopP->vop_reg = reg;
1816 vopP->vop_short = len;
1817 vopP->vop_expr_begin = p;
1818 vopP->vop_expr_end = q;
1819 vopP->vop_ndx = ndx;
1820 vopP->vop_error = err;
1821 vopP->vop_warn = wrn;
1824 /* This converts a string into a vax instruction.
1825 The string must be a bare single instruction in dec-vax (with BSD4 frobs)
1827 It provides some error messages: at most one fatal error message (which
1828 stops the scan) and at most one warning message for each operand.
1829 The vax instruction is returned in exploded form, since we have no
1830 knowledge of how you parse (or evaluate) your expressions.
1831 We do however strip off and decode addressing modes and operation
1834 The exploded instruction is returned to a struct vit of your choice.
1835 #include "vax-inst.h" to know what a struct vit is.
1837 This function's value is a string. If it is not "" then an internal
1838 logic error was found: read this code to assign meaning to the string.
1839 No argument string should generate such an error string:
1840 it means a bug in our code, not in the user's text.
1842 You MUST have called vip_begin() once before using this function. */
1845 vip (struct vit *vitP, /* We build an exploded instruction here. */
1846 char *instring) /* Text of a vax instruction: we modify. */
1848 /* How to bit-encode this opcode. */
1849 struct vot_wot *vwP;
1850 /* 1/skip whitespace.2/scan vot_how */
1853 /* counts number of operands seen */
1854 unsigned char count;
1855 /* scan operands in struct vit */
1856 struct vop *operandp;
1857 /* error over all operands */
1858 const char *alloperr;
1859 /* Remember char, (we clobber it with '\0' temporarily). */
1861 /* Op-code of this instruction. */
1864 if (*instring == ' ')
1867 /* MUST end in end-of-string or exactly 1 space. */
1868 for (p = instring; *p && *p != ' '; p++)
1871 /* Scanned up to end of operation-code. */
1872 /* Operation-code is ended with whitespace. */
1873 if (p - instring == 0)
1875 vitP->vit_error = _("No operator");
1877 memset (vitP->vit_opcode, '\0', sizeof (vitP->vit_opcode));
1883 /* Here with instring pointing to what better be an op-name, and p
1884 pointing to character just past that.
1885 We trust instring points to an op-name, with no whitespace. */
1886 vwP = (struct vot_wot *) hash_find (op_hash, instring);
1887 /* Restore char after op-code. */
1891 vitP->vit_error = _("Unknown operator");
1893 memset (vitP->vit_opcode, '\0', sizeof (vitP->vit_opcode));
1897 /* We found a match! So let's pick up as many operands as the
1898 instruction wants, and even gripe if there are too many.
1899 We expect comma to separate each operand.
1900 We let instring track the text, while p tracks a part of the
1903 /* The lines below know about 2-byte opcodes starting FD,FE or FF.
1904 They also understand synthetic opcodes. Note:
1905 we return 32 bits of opcode, including bucky bits, BUT
1906 an opcode length is either 8 or 16 bits for vit_opcode_nbytes. */
1907 oc = vwP->vot_code; /* The op-code. */
1908 vitP->vit_opcode_nbytes = (oc & 0xFF) >= 0xFD ? 2 : 1;
1909 md_number_to_chars (vitP->vit_opcode, oc, 4);
1910 count = 0; /* No operands seen yet. */
1911 instring = p; /* Point just past operation code. */
1913 for (howp = vwP->vot_how, operandp = vitP->vit_operand;
1914 !(alloperr && *alloperr) && *howp;
1915 operandp++, howp += 2)
1917 /* Here to parse one operand. Leave instring pointing just
1918 past any one ',' that marks the end of this operand. */
1920 as_fatal (_("odd number of bytes in operand description"));
1923 for (q = instring; (c = *q) && c != ','; q++)
1925 /* Q points to ',' or '\0' that ends argument. C is that
1928 operandp->vop_width = howp[1];
1929 operandp->vop_nbytes = vax_operand_width_size[(unsigned) howp[1]];
1930 operandp->vop_access = howp[0];
1931 vip_op (instring, operandp);
1932 *q = c; /* Restore input text. */
1933 if (operandp->vop_error)
1934 alloperr = _("Bad operand");
1935 instring = q + (c ? 1 : 0); /* Next operand (if any). */
1936 count++; /* Won another argument, may have an operr. */
1939 alloperr = _("Not enough operands");
1943 if (*instring == ' ')
1946 alloperr = _("Too many operands");
1948 vitP->vit_error = alloperr;
1951 vitP->vit_operands = count;
1956 /* Test program for above. */
1958 struct vit myvit; /* Build an exploded vax instruction here. */
1959 char answer[100]; /* Human types a line of vax assembler here. */
1960 char *mybug; /* "" or an internal logic diagnostic. */
1961 int mycount; /* Number of operands. */
1962 struct vop *myvop; /* Scan operands from myvit. */
1963 int mysynth; /* 1 means want synthetic opcodes. */
1964 char my_immediate[200];
1965 char my_indirect[200];
1966 char my_displen[200];
1973 printf ("0 means no synthetic instructions. ");
1974 printf ("Value for vip_begin? ");
1976 sscanf (answer, "%d", &mysynth);
1977 printf ("Synthetic opcodes %s be included.\n", mysynth ? "will" : "will not");
1978 printf ("enter immediate symbols eg enter # ");
1979 gets (my_immediate);
1980 printf ("enter indirect symbols eg enter @ ");
1982 printf ("enter displen symbols eg enter ^ ");
1985 if (p = vip_begin (mysynth, my_immediate, my_indirect, my_displen))
1986 error ("vip_begin=%s", p);
1988 printf ("An empty input line will quit you from the vax instruction parser\n");
1991 printf ("vax instruction: ");
1995 break; /* Out of for each input text loop. */
1997 vip (& myvit, answer);
1998 if (*myvit.vit_error)
1999 printf ("ERR:\"%s\"\n", myvit.vit_error);
2002 for (mycount = myvit.vit_opcode_nbytes, p = myvit.vit_opcode;
2005 printf ("%02x ", *p & 0xFF);
2007 printf (" operand count=%d.\n", mycount = myvit.vit_operands);
2008 for (myvop = myvit.vit_operand; mycount; mycount--, myvop++)
2010 printf ("mode=%xx reg=%xx ndx=%xx len='%c'=%c%c%d. expr=\"",
2011 myvop->vop_mode, myvop->vop_reg, myvop->vop_ndx,
2012 myvop->vop_short, myvop->vop_access, myvop->vop_width,
2014 for (p = myvop->vop_expr_begin; p <= myvop->vop_expr_end; p++)
2018 if (myvop->vop_error)
2019 printf (" err:\"%s\"\n", myvop->vop_error);
2021 if (myvop->vop_warn)
2022 printf (" wrn:\"%s\"\n", myvop->vop_warn);
2026 exit (EXIT_SUCCESS);
2031 #ifdef TEST /* #Define to use this testbed. */
2033 /* Follows a test program for this function.
2034 We declare arrays non-local in case some of our tiny-minded machines
2035 default to small stacks. Also, helps with some debuggers. */
2037 char answer[100]; /* Human types into here. */
2050 int my_operand_length;
2051 char my_immediate[200];
2052 char my_indirect[200];
2053 char my_displen[200];
2058 printf ("enter immediate symbols eg enter # ");
2059 gets (my_immediate);
2060 printf ("enter indirect symbols eg enter @ ");
2062 printf ("enter displen symbols eg enter ^ ");
2064 vip_op_defaults (my_immediate, my_indirect, my_displen);
2068 printf ("access,width (eg 'ab' or 'wh') [empty line to quit] : ");
2072 exit (EXIT_SUCCESS);
2073 myaccess = answer[0];
2074 mywidth = answer[1];
2078 my_operand_length = 1;
2081 my_operand_length = 8;
2084 my_operand_length = 4;
2087 my_operand_length = 16;
2090 my_operand_length = 32;
2093 my_operand_length = 4;
2096 my_operand_length = 16;
2099 my_operand_length = 8;
2102 my_operand_length = 2;
2107 my_operand_length = 0;
2111 my_operand_length = 2;
2112 printf ("I dn't understand access width %c\n", mywidth);
2115 printf ("VAX assembler instruction operand: ");
2118 mybug = vip_op (answer, myaccess, mywidth, my_operand_length,
2119 &mymode, &myreg, &mylen, &myleft, &myright, &myndx,
2123 printf ("error: \"%s\"\n", myerr);
2125 printf (" bug: \"%s\"\n", mybug);
2130 printf ("warning: \"%s\"\n", mywrn);
2131 mumble ("mode", mymode);
2132 mumble ("register", myreg);
2133 mumble ("index", myndx);
2134 printf ("width:'%c' ", mylen);
2135 printf ("expression: \"");
2136 while (myleft <= myright)
2137 putchar (*myleft++);
2144 mumble (char *text, int value)
2146 printf ("%s:", text);
2148 printf ("%xx", value);
2156 int md_short_jump_size = 3;
2157 int md_long_jump_size = 6;
2160 md_create_short_jump (char *ptr,
2162 addressT to_addr ATTRIBUTE_UNUSED,
2163 fragS *frag ATTRIBUTE_UNUSED,
2164 symbolS *to_symbol ATTRIBUTE_UNUSED)
2168 /* This former calculation was off by two:
2169 offset = to_addr - (from_addr + 1);
2170 We need to account for the one byte instruction and also its
2171 two byte operand. */
2172 offset = to_addr - (from_addr + 1 + 2);
2173 *ptr++ = VAX_BRW; /* Branch with word (16 bit) offset. */
2174 md_number_to_chars (ptr, offset, 2);
2178 md_create_long_jump (char *ptr,
2179 addressT from_addr ATTRIBUTE_UNUSED,
2186 offset = to_addr - S_GET_VALUE (to_symbol);
2187 *ptr++ = VAX_JMP; /* Arbitrary jump. */
2188 *ptr++ = VAX_ABSOLUTE_MODE;
2189 md_number_to_chars (ptr, offset, 4);
2190 fix_new (frag, ptr - frag->fr_literal, 4, to_symbol, (long) 0, 0, NO_RELOC);
2194 const char *md_shortopts = "d:STt:V+1h:Hv::";
2195 #elif defined(OBJ_ELF)
2196 const char *md_shortopts = "d:STt:VkKQ:";
2198 const char *md_shortopts = "d:STt:V";
2200 struct option md_longopts[] =
2203 #define OPTION_PIC (OPTION_MD_BASE)
2204 { "pic", no_argument, NULL, OPTION_PIC },
2206 { NULL, no_argument, NULL, 0 }
2208 size_t md_longopts_size = sizeof (md_longopts);
2211 md_parse_option (int c, char *arg)
2216 as_warn (_("SYMBOL TABLE not implemented"));
2220 as_warn (_("TOKEN TRACE not implemented"));
2224 as_warn (_("Displacement length %s ignored!"), arg);
2228 as_warn (_("I don't need or use temp. file \"%s\"."), arg);
2232 as_warn (_("I don't use an interpass file! -V ignored"));
2236 case '+': /* For g++. Hash any name > 31 chars long. */
2237 flag_hash_long_names = 1;
2240 case '1': /* For backward compatibility. */
2244 case 'H': /* Show new symbol after hash truncation. */
2245 flag_show_after_trunc = 1;
2248 case 'h': /* No hashing of mixed-case names. */
2250 extern char vms_name_mapping;
2251 vms_name_mapping = atoi (arg);
2252 flag_no_hash_mixed_case = 1;
2258 extern char *compiler_version_string;
2260 if (!arg || !*arg || access (arg, 0) == 0)
2261 return 0; /* Have caller show the assembler version. */
2262 compiler_version_string = arg;
2271 break; /* -pic, Position Independent Code. */
2273 /* -Qy, -Qn: SVR4 arguments controlling whether a .comment
2274 section should be emitted or not. FIXME: Not implemented. */
2287 md_show_usage (FILE *stream)
2289 fprintf (stream, _("\
2291 -d LENGTH ignored\n\
2298 fprintf (stream, _("\
2300 -+ hash encode names longer than 31 characters\n\
2301 -1 `const' handling compatible with gcc 1.x\n\
2302 -H show new symbol after hash truncation\n\
2303 -h NUM don't hash mixed-case names, and adjust case:\n\
2304 0 = upper, 2 = lower, 3 = preserve case\n\
2305 -v\"VERSION\" code being assembled was produced by compiler \"VERSION\"\n"));
2309 /* We have no need to default values of symbols. */
2312 md_undefined_symbol (char *name ATTRIBUTE_UNUSED)
2317 /* Round up a section size to the appropriate boundary. */
2319 md_section_align (segT segment ATTRIBUTE_UNUSED, valueT size)
2321 /* Byte alignment is fine */
2325 /* Exactly what point is a PC-relative offset relative TO?
2326 On the vax, they're relative to the address of the offset, plus
2329 md_pcrel_from (fixS *fixP)
2331 return fixP->fx_size + fixP->fx_where + fixP->fx_frag->fr_address;
2335 tc_gen_reloc (asection *section ATTRIBUTE_UNUSED, fixS *fixp)
2338 bfd_reloc_code_real_type code;
2343 if (fixp->fx_r_type != BFD_RELOC_NONE)
2345 code = fixp->fx_r_type;
2351 case BFD_RELOC_8_PCREL:
2352 case BFD_RELOC_16_PCREL:
2353 case BFD_RELOC_32_PCREL:
2355 case BFD_RELOC_8_GOT_PCREL:
2356 case BFD_RELOC_16_GOT_PCREL:
2357 case BFD_RELOC_32_GOT_PCREL:
2358 case BFD_RELOC_8_PLT_PCREL:
2359 case BFD_RELOC_16_PLT_PCREL:
2360 case BFD_RELOC_32_PLT_PCREL:
2364 as_bad_where (fixp->fx_file, fixp->fx_line,
2365 _("Cannot make %s relocation PC relative"),
2366 bfd_get_reloc_code_name (code));
2372 #define F(SZ,PCREL) (((SZ) << 1) + (PCREL))
2373 switch (F (fixp->fx_size, fixp->fx_pcrel))
2375 #define MAP(SZ,PCREL,TYPE) case F(SZ,PCREL): code = (TYPE); break
2376 MAP (1, 0, BFD_RELOC_8);
2377 MAP (2, 0, BFD_RELOC_16);
2378 MAP (4, 0, BFD_RELOC_32);
2379 MAP (1, 1, BFD_RELOC_8_PCREL);
2380 MAP (2, 1, BFD_RELOC_16_PCREL);
2381 MAP (4, 1, BFD_RELOC_32_PCREL);
2389 reloc = xmalloc (sizeof (arelent));
2390 reloc->sym_ptr_ptr = xmalloc (sizeof (asymbol *));
2391 *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
2392 reloc->address = fixp->fx_frag->fr_address + fixp->fx_where;
2395 reloc->addend = fixp->fx_addnumber;
2399 reloc->addend = fixp->fx_offset;
2402 reloc->howto = bfd_reloc_type_lookup (stdoutput, code);
2403 gas_assert (reloc->howto != 0);
2408 /* vax:md_assemble() emit frags for 1 instruction given in textual form. */
2410 md_assemble (char *instruction_string)
2412 /* Non-zero if operand expression's segment is not known yet. */
2414 /* Non-zero if operand expression's segment is absolute. */
2418 /* An operand. Scans all operands. */
2419 struct vop *operandP;
2420 char *save_input_line_pointer;
2421 /* What used to live after an expression. */
2423 /* 1: instruction_string bad for all passes. */
2425 /* Points to slot just after last operand. */
2426 struct vop *end_operandP;
2427 /* Points to expression values for this operand. */
2431 /* These refer to an instruction operand expression. */
2432 /* Target segment of the address. */
2434 valueT this_add_number;
2435 /* Positive (minuend) symbol. */
2436 symbolS *this_add_symbol;
2438 long opcode_as_number;
2439 /* Least significant byte 1st. */
2440 char *opcode_as_chars;
2441 /* As an array of characters. */
2442 /* Least significant byte 1st */
2443 char *opcode_low_byteP;
2444 /* length (bytes) meant by vop_short. */
2446 /* 0, or 1 if '@' is in addressing mode. */
2448 /* From vop_nbytes: vax_operand_width (in bytes) */
2450 FLONUM_TYPE *floatP;
2451 LITTLENUM_TYPE literal_float[8];
2452 /* Big enough for any floating point literal. */
2454 vip (&v, instruction_string);
2456 /* Now we try to find as many as_warn()s as we can. If we do any as_warn()s
2457 then goofed=1. Notice that we don't make any frags yet.
2458 Should goofed be 1, then this instruction will wedge in any pass,
2459 and we can safely flush it, without causing interpass symbol phase
2460 errors. That is, without changing label values in different passes. */
2461 if ((goofed = (*v.vit_error)) != 0)
2463 as_fatal (_("Ignoring statement due to \"%s\""), v.vit_error);
2465 /* We need to use expression() and friends, which require us to diddle
2466 input_line_pointer. So we save it and restore it later. */
2467 save_input_line_pointer = input_line_pointer;
2468 for (operandP = v.vit_operand,
2469 expP = exp_of_operand,
2470 segP = seg_of_operand,
2471 floatP = float_operand,
2472 end_operandP = v.vit_operand + v.vit_operands;
2474 operandP < end_operandP;
2476 operandP++, expP++, segP++, floatP++)
2478 if (operandP->vop_error)
2480 as_fatal (_("Aborting because statement has \"%s\""), operandP->vop_error);
2485 /* Statement has no syntax goofs: let's sniff the expression. */
2486 int can_be_short = 0; /* 1 if a bignum can be reduced to a short literal. */
2488 input_line_pointer = operandP->vop_expr_begin;
2489 c_save = operandP->vop_expr_end[1];
2490 operandP->vop_expr_end[1] = '\0';
2491 /* If to_seg == SEG_PASS1, expression() will have set need_pass_2 = 1. */
2492 *segP = expression (expP);
2496 /* for BSD4.2 compatibility, missing expression is absolute 0 */
2497 expP->X_op = O_constant;
2498 expP->X_add_number = 0;
2499 /* For SEG_ABSOLUTE, we shouldn't need to set X_op_symbol,
2500 X_add_symbol to any particular value. But, we will program
2501 defensively. Since this situation occurs rarely so it costs
2502 us little to do, and stops Dean worrying about the origin of
2503 random bits in expressionS's. */
2504 expP->X_add_symbol = NULL;
2505 expP->X_op_symbol = NULL;
2513 /* Major bug. We can't handle the case of a
2514 SEG_OP expression in a VIT_OPCODE_SYNTHETIC
2515 variable-length instruction.
2516 We don't have a frag type that is smart enough to
2517 relax a SEG_OP, and so we just force all
2518 SEG_OPs to behave like SEG_PASS1s.
2519 Clearly, if there is a demand we can invent a new or
2520 modified frag type and then coding up a frag for this
2521 case will be easy. SEG_OP was invented for the
2522 .words after a CASE opcode, and was never intended for
2523 instruction operands. */
2525 as_fatal (_("Can't relocate expression"));
2529 /* Preserve the bits. */
2530 if (expP->X_add_number > 0)
2532 bignum_copy (generic_bignum, expP->X_add_number,
2533 floatP->low, SIZE_OF_LARGE_NUMBER);
2537 know (expP->X_add_number < 0);
2538 flonum_copy (&generic_floating_point_number,
2540 if (strchr ("s i", operandP->vop_short))
2542 /* Could possibly become S^# */
2543 flonum_gen2vax (-expP->X_add_number, floatP, literal_float);
2544 switch (-expP->X_add_number)
2548 (literal_float[0] & 0xFC0F) == 0x4000
2549 && literal_float[1] == 0;
2554 (literal_float[0] & 0xFC0F) == 0x4000
2555 && literal_float[1] == 0
2556 && literal_float[2] == 0
2557 && literal_float[3] == 0;
2562 (literal_float[0] & 0xFF81) == 0x4000
2563 && literal_float[1] == 0
2564 && literal_float[2] == 0
2565 && literal_float[3] == 0;
2569 can_be_short = ((literal_float[0] & 0xFFF8) == 0x4000
2570 && (literal_float[1] & 0xE000) == 0
2571 && literal_float[2] == 0
2572 && literal_float[3] == 0
2573 && literal_float[4] == 0
2574 && literal_float[5] == 0
2575 && literal_float[6] == 0
2576 && literal_float[7] == 0);
2580 BAD_CASE (-expP->X_add_number);
2586 if (operandP->vop_short == 's'
2587 || operandP->vop_short == 'i'
2588 || (operandP->vop_short == ' '
2589 && operandP->vop_reg == 0xF
2590 && (operandP->vop_mode & 0xE) == 0x8))
2593 if (operandP->vop_short == ' ')
2595 /* We must chose S^ or I^. */
2596 if (expP->X_add_number > 0)
2598 /* Bignum: Short literal impossible. */
2599 operandP->vop_short = 'i';
2600 operandP->vop_mode = 8;
2601 operandP->vop_reg = 0xF; /* VAX PC. */
2605 /* Flonum: Try to do it. */
2608 operandP->vop_short = 's';
2609 operandP->vop_mode = 0;
2610 operandP->vop_ndx = -1;
2611 operandP->vop_reg = -1;
2612 expP->X_op = O_constant;
2616 operandP->vop_short = 'i';
2617 operandP->vop_mode = 8;
2618 operandP->vop_reg = 0xF; /* VAX PC */
2620 } /* bignum or flonum ? */
2621 } /* if #, but no S^ or I^ seen. */
2622 /* No more ' ' case: either 's' or 'i'. */
2623 if (operandP->vop_short == 's')
2625 /* Wants to be a short literal. */
2626 if (expP->X_add_number > 0)
2628 as_warn (_("Bignum not permitted in short literal. Immediate mode assumed."));
2629 operandP->vop_short = 'i';
2630 operandP->vop_mode = 8;
2631 operandP->vop_reg = 0xF; /* VAX PC. */
2637 as_warn (_("Can't do flonum short literal: immediate mode used."));
2638 operandP->vop_short = 'i';
2639 operandP->vop_mode = 8;
2640 operandP->vop_reg = 0xF; /* VAX PC. */
2644 /* Encode short literal now. */
2647 switch (-expP->X_add_number)
2651 temp = literal_float[0] >> 4;
2655 temp = literal_float[0] >> 1;
2659 temp = ((literal_float[0] << 3) & 070)
2660 | ((literal_float[1] >> 13) & 07);
2664 BAD_CASE (-expP->X_add_number);
2668 floatP->low[0] = temp & 077;
2675 /* I^# seen: set it up if float. */
2676 if (expP->X_add_number < 0)
2678 memcpy (floatP->low, literal_float, sizeof (literal_float));
2680 } /* if S^# seen. */
2684 as_warn (_("A bignum/flonum may not be a displacement: 0x%lx used"),
2685 (expP->X_add_number = 0x80000000L));
2686 /* Chosen so luser gets the most offset bits to patch later. */
2688 expP->X_add_number = floatP->low[0]
2689 | ((LITTLENUM_MASK & (floatP->low[1])) << LITTLENUM_NUMBER_OF_BITS);
2691 /* For the O_big case we have:
2692 If vop_short == 's' then a short floating literal is in the
2693 lowest 6 bits of floatP -> low [0], which is
2694 big_operand_bits [---] [0].
2695 If vop_short == 'i' then the appropriate number of elements
2696 of big_operand_bits [---] [...] are set up with the correct
2698 Also, just in case width is byte word or long, we copy the lowest
2699 32 bits of the number to X_add_number. */
2702 if (input_line_pointer != operandP->vop_expr_end + 1)
2704 as_fatal ("Junk at end of expression \"%s\"", input_line_pointer);
2707 operandP->vop_expr_end[1] = c_save;
2711 input_line_pointer = save_input_line_pointer;
2713 if (need_pass_2 || goofed)
2717 /* Remember where it is, in case we want to modify the op-code later. */
2718 opcode_low_byteP = frag_more (v.vit_opcode_nbytes);
2719 memcpy (opcode_low_byteP, v.vit_opcode, v.vit_opcode_nbytes);
2720 opcode_as_chars = v.vit_opcode;
2721 opcode_as_number = md_chars_to_number ((unsigned char *) opcode_as_chars, 4);
2722 for (operandP = v.vit_operand,
2723 expP = exp_of_operand,
2724 segP = seg_of_operand,
2725 floatP = float_operand,
2726 end_operandP = v.vit_operand + v.vit_operands;
2728 operandP < end_operandP;
2735 if (operandP->vop_ndx >= 0)
2737 /* Indexed addressing byte. */
2738 /* Legality of indexed mode already checked: it is OK. */
2739 FRAG_APPEND_1_CHAR (0x40 + operandP->vop_ndx);
2740 } /* if(vop_ndx>=0) */
2742 /* Here to make main operand frag(s). */
2743 this_add_number = expP->X_add_number;
2744 this_add_symbol = expP->X_add_symbol;
2746 is_undefined = (to_seg == undefined_section);
2747 is_absolute = (to_seg == absolute_section);
2748 at = operandP->vop_mode & 1;
2749 length = (operandP->vop_short == 'b'
2750 ? 1 : (operandP->vop_short == 'w'
2751 ? 2 : (operandP->vop_short == 'l'
2753 nbytes = operandP->vop_nbytes;
2754 if (operandP->vop_access == 'b')
2756 if (to_seg == now_seg || is_undefined)
2758 /* If is_undefined, then it might BECOME now_seg. */
2761 p = frag_more (nbytes);
2762 fix_new (frag_now, p - frag_now->fr_literal, nbytes,
2763 this_add_symbol, this_add_number, 1, NO_RELOC);
2767 /* to_seg==now_seg || to_seg == SEG_UNKNOWN */
2769 length_code = is_undefined ? STATE_UNDF : STATE_BYTE;
2770 if (opcode_as_number & VIT_OPCODE_SPECIAL)
2772 if (operandP->vop_width == VAX_WIDTH_UNCONDITIONAL_JUMP)
2775 frag_var (rs_machine_dependent, 5, 1,
2776 ENCODE_RELAX (STATE_ALWAYS_BRANCH, length_code),
2777 this_add_symbol, this_add_number,
2782 if (operandP->vop_width == VAX_WIDTH_WORD_JUMP)
2784 length_code = STATE_WORD;
2785 /* JF: There is no state_byte for this one! */
2786 frag_var (rs_machine_dependent, 10, 2,
2787 ENCODE_RELAX (STATE_COMPLEX_BRANCH, length_code),
2788 this_add_symbol, this_add_number,
2793 know (operandP->vop_width == VAX_WIDTH_BYTE_JUMP);
2794 frag_var (rs_machine_dependent, 9, 1,
2795 ENCODE_RELAX (STATE_COMPLEX_HOP, length_code),
2796 this_add_symbol, this_add_number,
2803 know (operandP->vop_width == VAX_WIDTH_CONDITIONAL_JUMP);
2804 frag_var (rs_machine_dependent, 7, 1,
2805 ENCODE_RELAX (STATE_CONDITIONAL_BRANCH, length_code),
2806 this_add_symbol, this_add_number,
2813 /* to_seg != now_seg && to_seg != SEG_UNKNOWN */
2814 /* --- SEG FLOAT MAY APPEAR HERE --- */
2819 know (!(opcode_as_number & VIT_OPCODE_SYNTHETIC));
2820 p = frag_more (nbytes);
2821 /* Conventional relocation. */
2822 fix_new (frag_now, p - frag_now->fr_literal, nbytes,
2823 section_symbol (absolute_section),
2824 this_add_number, 1, NO_RELOC);
2828 know (opcode_as_number & VIT_OPCODE_SYNTHETIC);
2829 if (opcode_as_number & VIT_OPCODE_SPECIAL)
2831 if (operandP->vop_width == VAX_WIDTH_UNCONDITIONAL_JUMP)
2834 *opcode_low_byteP = opcode_as_chars[0] + VAX_WIDEN_LONG;
2835 know (opcode_as_chars[1] == 0);
2837 p[0] = VAX_ABSOLUTE_MODE; /* @#... */
2838 md_number_to_chars (p + 1, this_add_number, 4);
2839 /* Now (eg) JMP @#foo or JSB @#foo. */
2843 if (operandP->vop_width == VAX_WIDTH_WORD_JUMP)
2851 p[5] = VAX_ABSOLUTE_MODE; /* @#... */
2852 md_number_to_chars (p + 6, this_add_number, 4);
2860 know (operandP->vop_width == VAX_WIDTH_BYTE_JUMP);
2866 p[4] = VAX_ABSOLUTE_MODE; /* @#... */
2867 md_number_to_chars (p + 5, this_add_number, 4);
2868 /* Now (eg) xOBxxx 1f
2878 *opcode_low_byteP ^= 1;
2879 /* To reverse the condition in a VAX branch,
2880 complement the lowest order bit. */
2884 p[2] = VAX_ABSOLUTE_MODE; /* @#... */
2885 md_number_to_chars (p + 3, this_add_number, 4);
2894 /* to_seg != now_seg && !is_undefinfed && !is_absolute */
2897 /* Pc-relative. Conventional relocation. */
2898 know (!(opcode_as_number & VIT_OPCODE_SYNTHETIC));
2899 p = frag_more (nbytes);
2900 fix_new (frag_now, p - frag_now->fr_literal, nbytes,
2901 section_symbol (absolute_section),
2902 this_add_number, 1, NO_RELOC);
2906 know (opcode_as_number & VIT_OPCODE_SYNTHETIC);
2907 if (opcode_as_number & VIT_OPCODE_SPECIAL)
2909 if (operandP->vop_width == VAX_WIDTH_UNCONDITIONAL_JUMP)
2912 know (opcode_as_chars[1] == 0);
2913 *opcode_low_byteP = opcode_as_chars[0] + VAX_WIDEN_LONG;
2915 p[0] = VAX_PC_RELATIVE_MODE;
2917 p + 1 - frag_now->fr_literal, 4,
2919 this_add_number, 1, NO_RELOC);
2920 /* Now eg JMP foo or JSB foo. */
2924 if (operandP->vop_width == VAX_WIDTH_WORD_JUMP)
2932 p[5] = VAX_PC_RELATIVE_MODE;
2934 p + 6 - frag_now->fr_literal, 4,
2936 this_add_number, 1, NO_RELOC);
2944 know (operandP->vop_width == VAX_WIDTH_BYTE_JUMP);
2950 p[4] = VAX_PC_RELATIVE_MODE;
2952 p + 5 - frag_now->fr_literal,
2954 this_add_number, 1, NO_RELOC);
2955 /* Now (eg) xOBxxx 1f
2964 know (operandP->vop_width == VAX_WIDTH_CONDITIONAL_JUMP);
2965 *opcode_low_byteP ^= 1; /* Reverse branch condition. */
2969 p[2] = VAX_PC_RELATIVE_MODE;
2970 fix_new (frag_now, p + 3 - frag_now->fr_literal,
2972 this_add_number, 1, NO_RELOC);
2980 /* So it is ordinary operand. */
2981 know (operandP->vop_access != 'b');
2982 /* ' ' target-independent: elsewhere. */
2983 know (operandP->vop_access != ' ');
2984 know (operandP->vop_access == 'a'
2985 || operandP->vop_access == 'm'
2986 || operandP->vop_access == 'r'
2987 || operandP->vop_access == 'v'
2988 || operandP->vop_access == 'w');
2989 if (operandP->vop_short == 's')
2993 if (this_add_number >= 64)
2995 as_warn (_("Short literal overflow(%ld.), immediate mode assumed."),
2996 (long) this_add_number);
2997 operandP->vop_short = 'i';
2998 operandP->vop_mode = 8;
2999 operandP->vop_reg = 0xF;
3004 as_warn (_("Forced short literal to immediate mode. now_seg=%s to_seg=%s"),
3005 segment_name (now_seg), segment_name (to_seg));
3006 operandP->vop_short = 'i';
3007 operandP->vop_mode = 8;
3008 operandP->vop_reg = 0xF;
3011 if (operandP->vop_reg >= 0 && (operandP->vop_mode < 8
3012 || (operandP->vop_reg != 0xF && operandP->vop_mode < 10)))
3014 /* One byte operand. */
3015 know (operandP->vop_mode > 3);
3016 FRAG_APPEND_1_CHAR (operandP->vop_mode << 4 | operandP->vop_reg);
3017 /* All 1-bytes except S^# happen here. */
3021 /* {@}{q^}foo{(Rn)} or S^#foo */
3022 if (operandP->vop_reg == -1 && operandP->vop_short != 's')
3025 if (to_seg == now_seg)
3029 know (operandP->vop_short == ' ');
3030 length_code = STATE_BYTE;
3032 if (S_IS_EXTERNAL (this_add_symbol)
3033 || S_IS_WEAK (this_add_symbol))
3034 length_code = STATE_UNDF;
3036 p = frag_var (rs_machine_dependent, 10, 2,
3037 ENCODE_RELAX (STATE_PC_RELATIVE, length_code),
3038 this_add_symbol, this_add_number,
3040 know (operandP->vop_mode == 10 + at);
3042 /* At is the only context we need to carry
3043 to other side of relax() process. Must
3044 be in the correct bit position of VAX
3045 operand spec. byte. */
3050 know (operandP->vop_short != ' ');
3051 p = frag_more (length + 1);
3052 p[0] = 0xF | ((at + "?\12\14?\16"[length]) << 4);
3053 fix_new (frag_now, p + 1 - frag_now->fr_literal,
3054 length, this_add_symbol,
3055 this_add_number, 1, NO_RELOC);
3060 /* to_seg != now_seg */
3061 if (this_add_symbol == NULL)
3064 /* Do @#foo: simpler relocation than foo-.(pc) anyway. */
3066 p[0] = VAX_ABSOLUTE_MODE; /* @#... */
3067 md_number_to_chars (p + 1, this_add_number, 4);
3068 if (length && length != 4)
3069 as_warn (_("Length specification ignored. Address mode 9F used"));
3073 /* {@}{q^}other_seg */
3074 know ((length == 0 && operandP->vop_short == ' ')
3075 || (length > 0 && operandP->vop_short != ' '));
3078 || S_IS_WEAK(this_add_symbol)
3079 || S_IS_EXTERNAL(this_add_symbol)
3085 default: length_code = STATE_UNDF; break;
3086 case 1: length_code = STATE_BYTE; break;
3087 case 2: length_code = STATE_WORD; break;
3088 case 4: length_code = STATE_LONG; break;
3090 /* We have a SEG_UNKNOWN symbol. It might
3091 turn out to be in the same segment as
3092 the instruction, permitting relaxation. */
3093 p = frag_var (rs_machine_dependent, 5, 2,
3094 ENCODE_RELAX (STATE_PC_RELATIVE, length_code),
3095 this_add_symbol, this_add_number,
3103 know (operandP->vop_short == ' ');
3104 length = 4; /* Longest possible. */
3106 p = frag_more (length + 1);
3107 p[0] = 0xF | ((at + "?\12\14?\16"[length]) << 4);
3108 md_number_to_chars (p + 1, this_add_number, length);
3110 p + 1 - frag_now->fr_literal,
3111 length, this_add_symbol,
3112 this_add_number, 1, NO_RELOC);
3119 /* {@}{q^}foo(Rn) or S^# or I^# or # */
3120 if (operandP->vop_mode < 0xA)
3122 /* # or S^# or I^# */
3123 if (operandP->vop_access == 'v'
3124 || operandP->vop_access == 'a')
3126 if (operandP->vop_access == 'v')
3127 as_warn (_("Invalid operand: immediate value used as base address."));
3129 as_warn (_("Invalid operand: immediate value used as address."));
3130 /* gcc 2.6.3 is known to generate these in at least
3134 && is_absolute && (expP->X_op != O_big)
3135 && operandP->vop_mode == 8 /* No '@'. */
3136 && this_add_number < 64)
3138 operandP->vop_short = 's';
3140 if (operandP->vop_short == 's')
3142 FRAG_APPEND_1_CHAR (this_add_number);
3148 p = frag_more (nbytes + 1);
3149 know (operandP->vop_reg == 0xF);
3151 if (flag_want_pic && operandP->vop_mode == 8
3152 && this_add_symbol != NULL)
3154 as_warn (_("Symbol %s used as immediate operand in PIC mode."),
3155 S_GET_NAME (this_add_symbol));
3158 p[0] = (operandP->vop_mode << 4) | 0xF;
3159 if ((is_absolute) && (expP->X_op != O_big))
3161 /* If nbytes > 4, then we are scrod. We
3162 don't know if the high order bytes
3163 are to be 0xFF or 0x00. BSD4.2 & RMS
3164 say use 0x00. OK --- but this
3165 assembler needs ANOTHER rewrite to
3166 cope properly with this bug. */
3167 md_number_to_chars (p + 1, this_add_number,
3168 min (sizeof (valueT),
3170 if ((size_t) nbytes > sizeof (valueT))
3171 memset (p + 1 + sizeof (valueT),
3172 '\0', nbytes - sizeof (valueT));
3176 if (expP->X_op == O_big)
3178 /* Problem here is to get the bytes
3179 in the right order. We stored
3180 our constant as LITTLENUMs, not
3192 for (p++; nbytes; nbytes -= 2, p += 2, lP++)
3193 md_number_to_chars (p, *lP, 2);
3198 fix_new (frag_now, p + 1 - frag_now->fr_literal,
3199 nbytes, this_add_symbol,
3200 this_add_number, 0, NO_RELOC);
3207 /* {@}{q^}foo(Rn) */
3208 know ((length == 0 && operandP->vop_short == ' ')
3209 || (length > 0 && operandP->vop_short != ' '));
3216 test = this_add_number;
3221 length = test & 0xffff8000 ? 4
3222 : test & 0xffffff80 ? 2
3230 p = frag_more (1 + length);
3231 know (operandP->vop_reg >= 0);
3232 p[0] = operandP->vop_reg
3233 | ((at | "?\12\14?\16"[length]) << 4);
3236 md_number_to_chars (p + 1, this_add_number, length);
3240 fix_new (frag_now, p + 1 - frag_now->fr_literal,
3241 length, this_add_symbol,
3242 this_add_number, 0, NO_RELOC);
3258 if ((errtxt = vip_begin (1, "$", "*", "`")) != 0)
3259 as_fatal (_("VIP_BEGIN error:%s"), errtxt);
3261 for (i = 0, fP = float_operand;
3262 fP < float_operand + VIT_MAX_OPERANDS;
3265 fP->low = &big_operand_bits[i][0];
3266 fP->high = &big_operand_bits[i][SIZE_OF_LARGE_NUMBER - 1];
3270 static char *vax_cons_special_reloc;
3273 vax_cons (expressionS *exp, int size)
3278 vax_cons_special_reloc = NULL;
3279 save = input_line_pointer;
3280 if (input_line_pointer[0] == '%')
3282 if (strncmp (input_line_pointer + 1, "pcrel", 5) == 0)
3284 input_line_pointer += 6;
3285 vax_cons_special_reloc = "pcrel";
3287 if (vax_cons_special_reloc)
3294 if (*input_line_pointer != '8')
3296 input_line_pointer--;
3299 if (input_line_pointer[0] != '1' || input_line_pointer[1] != '6')
3303 if (input_line_pointer[0] != '3' || input_line_pointer[1] != '2')
3313 as_bad (_("Illegal operands: Only %%r_%s%d allowed in %d-byte data fields"),
3314 vax_cons_special_reloc, size * 8, size);
3318 input_line_pointer += 2;
3319 if (*input_line_pointer != '(')
3321 as_bad (_("Illegal operands: %%r_%s%d requires arguments in ()"),
3322 vax_cons_special_reloc, size * 8);
3329 input_line_pointer = save;
3330 vax_cons_special_reloc = NULL;
3335 char *end = ++input_line_pointer;
3338 while (! is_end_of_line[(c = *end)])
3352 as_bad (_("Illegal operands: %%r_%s%d requires arguments in ()"),
3353 vax_cons_special_reloc, size * 8);
3359 if (input_line_pointer != end)
3361 as_bad (_("Illegal operands: %%r_%s%d requires arguments in ()"),
3362 vax_cons_special_reloc, size * 8);
3366 input_line_pointer++;
3368 c = *input_line_pointer;
3369 if (! is_end_of_line[c] && c != ',')
3370 as_bad (_("Illegal operands: garbage after %%r_%s%d()"),
3371 vax_cons_special_reloc, size * 8);
3377 if (vax_cons_special_reloc == NULL)
3381 /* This is called by emit_expr via TC_CONS_FIX_NEW when creating a
3382 reloc for a cons. */
3385 vax_cons_fix_new (fragS *frag, int where, unsigned int nbytes, expressionS *exp)
3387 bfd_reloc_code_real_type r;
3389 r = (nbytes == 1 ? BFD_RELOC_8 :
3390 (nbytes == 2 ? BFD_RELOC_16 : BFD_RELOC_32));
3392 if (vax_cons_special_reloc)
3394 if (*vax_cons_special_reloc == 'p')
3398 case 1: r = BFD_RELOC_8_PCREL; break;
3399 case 2: r = BFD_RELOC_16_PCREL; break;
3400 case 4: r = BFD_RELOC_32_PCREL; break;
3406 fix_new_exp (frag, where, (int) nbytes, exp, 0, r);
3407 vax_cons_special_reloc = NULL;
3411 md_atof (int type, char * litP, int * sizeP)
3413 return vax_md_atof (type, litP, sizeP);
OSDN Git Service
