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, 2009, 2010
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. */
1275
access_mode = vopP->vop_access;
1276
/* None of our code bugs (yet), no user text errors, no warnings
1282
if (*p == ' ') /* Expect all whitespace reduced to ' '. */
1283
p++; /* skip over whitespace */
1285
if ((at = INDIRECTP (*p)) != 0)
1286
{ /* 1 if *p=='@'(or '*' for Un*x) */
1287
p++; /* at is determined */
1288
if (*p == ' ') /* Expect all whitespace reduced to ' '. */
1289
p++; /* skip over whitespace */
1292
/* This code is subtle. It tries to detect all legal (letter)'^'
1293
but it doesn't waste time explicitly testing for premature '\0' because
1294
this case is rejected as a mismatch against either (letter) or '^'. */
1300
if (DISPLENP (p[1]) && strchr ("bilws", len = c))
1301
p += 2; /* Skip (letter) '^'. */
1302
else /* No (letter) '^' seen. */
1303
len = ' '; /* Len is determined. */
1306
if (*p == ' ') /* Expect all whitespace reduced to ' '. */
1309
if ((hash = IMMEDIATEP (*p)) != 0) /* 1 if *p=='#' ('$' for Un*x) */
1310
p++; /* Hash is determined. */
1312
/* p points to what may be the beginning of an expression.
1313
We have peeled off the front all that is peelable.
1314
We know at, len, hash.
1316
Lets point q at the end of the text and parse that (backwards). */
1318
for (q = p; *q; q++)
1320
q--; /* Now q points at last char of text. */
1322
if (*q == ' ' && q >= p) /* Expect all whitespace reduced to ' '. */
1325
/* Reverse over whitespace, but don't. */
1326
/* Run back over *p. */
1328
/* As a matter of policy here, we look for [Rn], although both Rn and S^#
1329
forbid [Rn]. This is because it is easy, and because only a sick
1330
cyborg would have [...] trailing an expression in a VAX-like assembler.
1331
A meticulous parser would first check for Rn followed by '(' or '['
1332
and not parse a trailing ']' if it found another. We just ban expressions
1336
while (q >= p && *q != '[')
1338
/* Either q<p or we got matching '['. */
1340
err = _("no '[' to match ']'");
1343
/* Confusers like "[]" will eventually lose with a bad register
1344
* name error. So again we don't need to check for early '\0'. */
1346
ndx = vax_reg_parse (q[1], q[2], 0, 0);
1347
else if (q[4] == ']')
1348
ndx = vax_reg_parse (q[1], q[2], q[3], 0);
1349
else if (q[5] == ']')
1350
ndx = vax_reg_parse (q[1], q[2], q[3], q[4]);
1353
/* Since we saw a ']' we will demand a register name in the [].
1354
* If luser hasn't given us one: be rude. */
1356
err = _("bad register in []");
1358
err = _("[PC] index banned");
1360
/* Point q just before "[...]". */
1365
/* No ']', so no iNDeX register. */
1368
/* If err = "..." then we lost: run away.
1369
Otherwise ndx == -1 if there was no "[...]".
1370
Otherwise, ndx is index register number, and q points before "[...]". */
1372
if (*q == ' ' && q >= p) /* Expect all whitespace reduced to ' '. */
1374
/* Reverse over whitespace, but don't. */
1375
/* Run back over *p. */
1378
/* no ()+ or -() seen yet */
1381
if (q > p + 3 && *q == '+' && q[-1] == ')')
1383
sign = 1; /* we saw a ")+" */
1384
q--; /* q points to ')' */
1387
if (*q == ')' && q > p + 2)
1389
paren = 1; /* assume we have "(...)" */
1390
while (q >= p && *q != '(')
1392
/* either q<p or we got matching '(' */
1394
err = _("no '(' to match ')'");
1397
/* Confusers like "()" will eventually lose with a bad register
1398
name error. So again we don't need to check for early '\0'. */
1400
reg = vax_reg_parse (q[1], q[2], 0, 0);
1401
else if (q[4] == ')')
1402
reg = vax_reg_parse (q[1], q[2], q[3], 0);
1403
else if (q[5] == ')')
1404
reg = vax_reg_parse (q[1], q[2], q[3], q[4]);
1407
/* Since we saw a ')' we will demand a register name in the ')'.
1408
This is nasty: why can't our hypothetical assembler permit
1409
parenthesised expressions? BECAUSE I AM LAZY! That is why.
1410
Abuse luser if we didn't spy a register name. */
1413
/* JF allow parenthesized expressions. I hope this works. */
1417
/* err = "unknown register in ()"; */
1420
q--; /* point just before '(' of "(...)" */
1421
/* If err == "..." then we lost. Run away.
1422
Otherwise if reg >= 0 then we saw (Rn). */
1424
/* If err == "..." then we lost.
1425
Otherwise paren==1 and reg = register in "()". */
1429
/* If err == "..." then we lost.
1430
Otherwise, q points just before "(Rn)", if any.
1431
If there was a "(...)" then paren==1, and reg is the register. */
1433
/* We should only seek '-' of "-(...)" if:
1434
we saw "(...)" paren == 1
1435
we have no errors so far ! *err
1436
we did not see '+' of "(...)+" sign < 1
1437
We don't check len. We want a specific error message later if
1438
user tries "x^...-(Rn)". This is a feature not a bug. */
1441
if (paren && sign < 1)/* !sign is adequate test */
1449
/* We have back-tracked over most
1450
of the crud at the end of an operand.
1451
Unless err, we know: sign, paren. If paren, we know reg.
1452
The last case is of an expression "Rn".
1453
This is worth hunting for if !err, !paren.
1454
We wouldn't be here if err.
1455
We remember to save q, in case we didn't want "Rn" anyway. */
1458
if (*q == ' ' && q >= p) /* Expect all whitespace reduced to ' '. */
1460
/* Reverse over whitespace, but don't. */
1461
/* Run back over *p. */
1462
/* Room for Rn or Rnn (include prefix) exactly? */
1463
if (q > p && q < p + 4)
1464
reg = vax_reg_parse (p[0], p[1],
1465
q < p + 2 ? 0 : p[2],
1466
q < p + 3 ? 0 : p[3]);
1468
reg = -1; /* Always comes here if no register at all. */
1469
/* Here with a definitive reg value. */
1478
/* have reg. -1:absent; else 0:15. */
1480
/* We have: err, at, len, hash, ndx, sign, paren, reg.
1481
Also, any remaining expression is from *p through *q inclusive.
1482
Should there be no expression, q==p-1. So expression length = q-p+1.
1483
This completes the first part: parsing the operand text. */
1485
/* We now want to boil the data down, checking consistency on the way.
1486
We want: len, mode, reg, ndx, err, p, q, wrn, bug.
1487
We will deliver a 4-bit reg, and a 4-bit mode. */
1489
/* Case of branch operand. Different. No L^B^W^I^S^ allowed for instance.
1503
p:q whatever was input
1505
err " " or error message, and other outputs trashed. */
1506
/* Branch operands have restricted forms. */
1507
if ((!err || !*err) && access_mode == 'b')
1509
if (at || hash || sign || paren || ndx >= 0 || reg >= 0 || len != ' ')
1510
err = _("invalid branch operand");
1515
/* Since nobody seems to use it: comment this 'feature'(?) out for now. */
1517
/* Case of stand-alone operand. e.g. ".long foo"
1531
p:q whatever was input
1533
err " " or error message, and other outputs trashed. */
1534
if ((!err || !*err) && access_mode == ' ')
1537
err = _("address prohibits @");
1539
err = _("address prohibits #");
1543
err = _("address prohibits -()");
1545
err = _("address prohibits ()+");
1548
err = _("address prohibits ()");
1550
err = _("address prohibits []");
1552
err = _("address prohibits register");
1553
else if (len != ' ')
1554
err = _("address prohibits displacement length specifier");
1557
err = " "; /* succeed */
1568
p:q demand not empty
1570
paren 0 by "()" scan logic because "S^" seen
1571
reg -1 or nn by mistake
1579
if ((!err || !*err) && len == 's')
1581
if (!hash || paren || at || ndx >= 0)
1582
err = _("invalid operand of S^#");
1587
/* Darn! we saw S^#Rnn ! put the Rnn back in
1588
expression. KLUDGE! Use oldq so we don't
1589
need to know exact length of reg name. */
1593
/* We have all the expression we will ever get. */
1595
err = _("S^# needs expression");
1596
else if (access_mode == 'r')
1598
err = " "; /* WIN! */
1602
err = _("S^# may only read-access");
1606
/* Case of -(Rn), which is weird case.
1612
sign -1 by definition
1613
paren 1 by definition
1614
reg present by definition
1620
exp "" enforce empty expression
1621
ndx optional warn if same as reg. */
1622
if ((!err || !*err) && sign < 0)
1624
if (len != ' ' || hash || at || p <= q)
1625
err = _("invalid operand of -()");
1628
err = " "; /* win */
1631
wrn = _("-(PC) unpredictable");
1632
else if (reg == ndx)
1633
wrn = _("[]index same as -()register: unpredictable");
1637
/* We convert "(Rn)" to "@Rn" for our convenience.
1638
(I hope this is convenient: has someone got a better way to parse this?)
1639
A side-effect of this is that "@Rn" is a valid operand. */
1640
if (paren && !sign && !hash && !at && len == ' ' && p > q)
1646
/* Case of (Rn)+, which is slightly different.
1652
sign +1 by definition
1653
paren 1 by definition
1654
reg present by definition
1660
exp "" enforce empty expression
1661
ndx optional warn if same as reg. */
1662
if ((!err || !*err) && sign > 0)
1664
if (len != ' ' || hash || p <= q)
1665
err = _("invalid operand of ()+");
1668
err = " "; /* win */
1669
mode = 8 + (at ? 1 : 0);
1671
wrn = _("(PC)+ unpredictable");
1672
else if (reg == ndx)
1673
wrn = _("[]index same as ()+register: unpredictable");
1677
/* Case of #, without S^.
1681
hash 1 by definition
1693
if ((!err || !*err) && hash)
1695
if (len != 'i' && len != ' ')
1696
err = _("# conflicts length");
1698
err = _("# bars register");
1703
/* Darn! we saw #Rnn! Put the Rnn back into the expression.
1704
By using oldq, we don't need to know how long Rnn was.
1707
reg = -1; /* No register any more. */
1709
err = " "; /* Win. */
1711
/* JF a bugfix, I think! */
1712
if (at && access_mode == 'a')
1713
vopP->vop_nbytes = 4;
1715
mode = (at ? 9 : 8);
1717
if ((access_mode == 'm' || access_mode == 'w') && !at)
1718
wrn = _("writing or modifying # is unpredictable");
1721
/* If !*err, then sign == 0
1724
/* Case of Rn. We separate this one because it has a few special
1725
errors the remaining modes lack.
1729
hash 0 by program logic
1731
sign 0 by program logic
1732
paren 0 by definition
1733
reg present by definition
1738
len ' ' enforce no length
1739
exp "" enforce empty expression
1740
ndx optional warn if same as reg. */
1741
if ((!err || !*err) && !paren && reg >= 0)
1744
err = _("length not needed");
1747
err = " "; /* win */
1751
err = _("can't []index a register, because it has no address");
1752
else if (access_mode == 'a')
1753
err = _("a register has no address");
1756
/* Idea here is to detect from length of datum
1757
and from register number if we will touch PC.
1759
vop_nbytes is number of bytes in operand.
1760
Compute highest byte affected, compare to PC0. */
1761
if ((vopP->vop_nbytes + reg * 4) > 60)
1762
wrn = _("PC part of operand unpredictable");
1763
err = " "; /* win */
1767
/* If !*err, sign == 0
1769
paren == 1 OR reg==-1 */
1771
/* Rest of cases fit into one bunch.
1774
len ' ' or 'b' or 'w' or 'l'
1775
hash 0 by program logic
1776
p:q expected (empty is not an error)
1777
sign 0 by program logic
1782
out: mode 10 + @ + len
1784
len ' ' or 'b' or 'w' or 'l'
1786
ndx optional warn if same as reg. */
1789
err = " "; /* win (always) */
1790
mode = 10 + (at ? 1 : 0);
1797
case ' ': /* Assumed B^ until our caller changes it. */
1803
/* here with completely specified mode
1810
err = 0; /* " " is no longer an error. */
1812
vopP->vop_mode = mode;
1813
vopP->vop_reg = reg;
1814
vopP->vop_short = len;
1815
vopP->vop_expr_begin = p;
1816
vopP->vop_expr_end = q;
1817
vopP->vop_ndx = ndx;
1818
vopP->vop_error = err;
1819
vopP->vop_warn = wrn;
1822
/* This converts a string into a vax instruction.
1823
The string must be a bare single instruction in dec-vax (with BSD4 frobs)
1825
It provides some error messages: at most one fatal error message (which
1826
stops the scan) and at most one warning message for each operand.
1827
The vax instruction is returned in exploded form, since we have no
1828
knowledge of how you parse (or evaluate) your expressions.
1829
We do however strip off and decode addressing modes and operation
1832
The exploded instruction is returned to a struct vit of your choice.
1833
#include "vax-inst.h" to know what a struct vit is.
1835
This function's value is a string. If it is not "" then an internal
1836
logic error was found: read this code to assign meaning to the string.
1837
No argument string should generate such an error string:
1838
it means a bug in our code, not in the user's text.
1840
You MUST have called vip_begin() once before using this function. */
1843
vip (struct vit *vitP, /* We build an exploded instruction here. */
1844
char *instring) /* Text of a vax instruction: we modify. */
1846
/* How to bit-encode this opcode. */
1847
struct vot_wot *vwP;
1848
/* 1/skip whitespace.2/scan vot_how */
1851
/* counts number of operands seen */
1852
unsigned char count;
1853
/* scan operands in struct vit */
1854
struct vop *operandp;
1855
/* error over all operands */
1856
const char *alloperr;
1857
/* Remember char, (we clobber it with '\0' temporarily). */
1859
/* Op-code of this instruction. */
1862
if (*instring == ' ')
1865
/* MUST end in end-of-string or exactly 1 space. */
1866
for (p = instring; *p && *p != ' '; p++)
1869
/* Scanned up to end of operation-code. */
1870
/* Operation-code is ended with whitespace. */
1871
if (p - instring == 0)
1873
vitP->vit_error = _("No operator");
1875
memset (vitP->vit_opcode, '\0', sizeof (vitP->vit_opcode));
1881
/* Here with instring pointing to what better be an op-name, and p
1882
pointing to character just past that.
1883
We trust instring points to an op-name, with no whitespace. */
1884
vwP = (struct vot_wot *) hash_find (op_hash, instring);
1885
/* Restore char after op-code. */
1889
vitP->vit_error = _("Unknown operator");
1891
memset (vitP->vit_opcode, '\0', sizeof (vitP->vit_opcode));
1895
/* We found a match! So let's pick up as many operands as the
1896
instruction wants, and even gripe if there are too many.
1897
We expect comma to separate each operand.
1898
We let instring track the text, while p tracks a part of the
1901
/* The lines below know about 2-byte opcodes starting FD,FE or FF.
1902
They also understand synthetic opcodes. Note:
1903
we return 32 bits of opcode, including bucky bits, BUT
1904
an opcode length is either 8 or 16 bits for vit_opcode_nbytes. */
1905
oc = vwP->vot_code; /* The op-code. */
1906
vitP->vit_opcode_nbytes = (oc & 0xFF) >= 0xFD ? 2 : 1;
1907
md_number_to_chars (vitP->vit_opcode, oc, 4);
1908
count = 0; /* No operands seen yet. */
1909
instring = p; /* Point just past operation code. */
1911
for (howp = vwP->vot_how, operandp = vitP->vit_operand;
1912
!(alloperr && *alloperr) && *howp;
1913
operandp++, howp += 2)
1915
/* Here to parse one operand. Leave instring pointing just
1916
past any one ',' that marks the end of this operand. */
1918
as_fatal (_("odd number of bytes in operand description"));
1921
for (q = instring; (c = *q) && c != ','; q++)
1923
/* Q points to ',' or '\0' that ends argument. C is that
1926
operandp->vop_width = howp[1];
1927
operandp->vop_nbytes = vax_operand_width_size[(unsigned) howp[1]];
1928
operandp->vop_access = howp[0];
1929
vip_op (instring, operandp);
1930
*q = c; /* Restore input text. */
1931
if (operandp->vop_error)
1932
alloperr = _("Bad operand");
1933
instring = q + (c ? 1 : 0); /* Next operand (if any). */
1934
count++; /* Won another argument, may have an operr. */
1937
alloperr = _("Not enough operands");
1941
if (*instring == ' ')
1944
alloperr = _("Too many operands");
1946
vitP->vit_error = alloperr;
1949
vitP->vit_operands = count;
1954
/* Test program for above. */
1956
struct vit myvit; /* Build an exploded vax instruction here. */
1957
char answer[100]; /* Human types a line of vax assembler here. */
1958
char *mybug; /* "" or an internal logic diagnostic. */
1959
int mycount; /* Number of operands. */
1960
struct vop *myvop; /* Scan operands from myvit. */
1961
int mysynth; /* 1 means want synthetic opcodes. */
1962
char my_immediate[200];
1963
char my_indirect[200];
1964
char my_displen[200];
1971
printf ("0 means no synthetic instructions. ");
1972
printf ("Value for vip_begin? ");
1974
sscanf (answer, "%d", &mysynth);
1975
printf ("Synthetic opcodes %s be included.\n", mysynth ? "will" : "will not");
1976
printf ("enter immediate symbols eg enter # ");
1977
gets (my_immediate);
1978
printf ("enter indirect symbols eg enter @ ");
1980
printf ("enter displen symbols eg enter ^ ");
1983
if (p = vip_begin (mysynth, my_immediate, my_indirect, my_displen))
1984
error ("vip_begin=%s", p);
1986
printf ("An empty input line will quit you from the vax instruction parser\n");
1989
printf ("vax instruction: ");
1993
break; /* Out of for each input text loop. */
1995
vip (& myvit, answer);
1996
if (*myvit.vit_error)
1997
printf ("ERR:\"%s\"\n", myvit.vit_error);
2000
for (mycount = myvit.vit_opcode_nbytes, p = myvit.vit_opcode;
2003
printf ("%02x ", *p & 0xFF);
2005
printf (" operand count=%d.\n", mycount = myvit.vit_operands);
2006
for (myvop = myvit.vit_operand; mycount; mycount--, myvop++)
2008
printf ("mode=%xx reg=%xx ndx=%xx len='%c'=%c%c%d. expr=\"",
2009
myvop->vop_mode, myvop->vop_reg, myvop->vop_ndx,
2010
myvop->vop_short, myvop->vop_access, myvop->vop_width,
2012
for (p = myvop->vop_expr_begin; p <= myvop->vop_expr_end; p++)
2016
if (myvop->vop_error)
2017
printf (" err:\"%s\"\n", myvop->vop_error);
2019
if (myvop->vop_warn)
2020
printf (" wrn:\"%s\"\n", myvop->vop_warn);
2024
exit (EXIT_SUCCESS);
2029
#ifdef TEST /* #Define to use this testbed. */
2031
/* Follows a test program for this function.
2032
We declare arrays non-local in case some of our tiny-minded machines
2033
default to small stacks. Also, helps with some debuggers. */
2035
char answer[100]; /* Human types into here. */
2048
int my_operand_length;
2049
char my_immediate[200];
2050
char my_indirect[200];
2051
char my_displen[200];
2056
printf ("enter immediate symbols eg enter # ");
2057
gets (my_immediate);
2058
printf ("enter indirect symbols eg enter @ ");
2060
printf ("enter displen symbols eg enter ^ ");
2062
vip_op_defaults (my_immediate, my_indirect, my_displen);
2066
printf ("access,width (eg 'ab' or 'wh') [empty line to quit] : ");
2070
exit (EXIT_SUCCESS);
2071
myaccess = answer[0];
2072
mywidth = answer[1];
2076
my_operand_length = 1;
2079
my_operand_length = 8;
2082
my_operand_length = 4;
2085
my_operand_length = 16;
2088
my_operand_length = 32;
2091
my_operand_length = 4;
2094
my_operand_length = 16;
2097
my_operand_length = 8;
2100
my_operand_length = 2;
2105
my_operand_length = 0;
2109
my_operand_length = 2;
2110
printf ("I dn't understand access width %c\n", mywidth);
2113
printf ("VAX assembler instruction operand: ");
2116
mybug = vip_op (answer, myaccess, mywidth, my_operand_length,
2117
&mymode, &myreg, &mylen, &myleft, &myright, &myndx,
2121
printf ("error: \"%s\"\n", myerr);
2123
printf (" bug: \"%s\"\n", mybug);
2128
printf ("warning: \"%s\"\n", mywrn);
2129
mumble ("mode", mymode);
2130
mumble ("register", myreg);
2131
mumble ("index", myndx);
2132
printf ("width:'%c' ", mylen);
2133
printf ("expression: \"");
2134
while (myleft <= myright)
2135
putchar (*myleft++);
2142
mumble (char *text, int value)
2144
printf ("%s:", text);
2146
printf ("%xx", value);
2154
int md_short_jump_size = 3;
2155
int md_long_jump_size = 6;
2158
md_create_short_jump (char *ptr,
2160
addressT to_addr ATTRIBUTE_UNUSED,
2161
fragS *frag ATTRIBUTE_UNUSED,
2162
symbolS *to_symbol ATTRIBUTE_UNUSED)
2166
/* This former calculation was off by two:
2167
offset = to_addr - (from_addr + 1);
2168
We need to account for the one byte instruction and also its
2169
two byte operand. */
2170
offset = to_addr - (from_addr + 1 + 2);
2171
*ptr++ = VAX_BRW; /* Branch with word (16 bit) offset. */
2172
md_number_to_chars (ptr, offset, 2);
2176
md_create_long_jump (char *ptr,
2177
addressT from_addr ATTRIBUTE_UNUSED,
2184
offset = to_addr - S_GET_VALUE (to_symbol);
2185
*ptr++ = VAX_JMP; /* Arbitrary jump. */
2186
*ptr++ = VAX_ABSOLUTE_MODE;
2187
md_number_to_chars (ptr, offset, 4);
2188
fix_new (frag, ptr - frag->fr_literal, 4, to_symbol, (long) 0, 0, NO_RELOC);
2192
const char *md_shortopts = "d:STt:V+1h:Hv::";
2193
#elif defined(OBJ_ELF)
2194
const char *md_shortopts = "d:STt:VkKQ:";
2196
const char *md_shortopts = "d:STt:V";
2198
struct option md_longopts[] =
2201
#define OPTION_PIC (OPTION_MD_BASE)
2202
{ "pic", no_argument, NULL, OPTION_PIC },
2204
{ NULL, no_argument, NULL, 0 }
2206
size_t md_longopts_size = sizeof (md_longopts);
2209
md_parse_option (int c, char *arg)
2214
as_warn (_("SYMBOL TABLE not implemented"));
2218
as_warn (_("TOKEN TRACE not implemented"));
2222
as_warn (_("Displacement length %s ignored!"), arg);
2226
as_warn (_("I don't need or use temp. file \"%s\"."), arg);
2230
as_warn (_("I don't use an interpass file! -V ignored"));
2234
case '+': /* For g++. Hash any name > 31 chars long. */
2235
flag_hash_long_names = 1;
2238
case '1': /* For backward compatibility. */
2242
case 'H': /* Show new symbol after hash truncation. */
2243
flag_show_after_trunc = 1;
2246
case 'h': /* No hashing of mixed-case names. */
2248
extern char vms_name_mapping;
2249
vms_name_mapping = atoi (arg);
2250
flag_no_hash_mixed_case = 1;
2256
extern char *compiler_version_string;
2258
if (!arg || !*arg || access (arg, 0) == 0)
2259
return 0; /* Have caller show the assembler version. */
2260
compiler_version_string = arg;
2269
break; /* -pic, Position Independent Code. */
2271
/* -Qy, -Qn: SVR4 arguments controlling whether a .comment
2272
section should be emitted or not. FIXME: Not implemented. */
2285
md_show_usage (FILE *stream)
2287
fprintf (stream, _("\
2289
-d LENGTH ignored\n\
2296
fprintf (stream, _("\
2298
-+ hash encode names longer than 31 characters\n\
2299
-1 `const' handling compatible with gcc 1.x\n\
2300
-H show new symbol after hash truncation\n\
2301
-h NUM don't hash mixed-case names, and adjust case:\n\
2302
0 = upper, 2 = lower, 3 = preserve case\n\
2303
-v\"VERSION\" code being assembled was produced by compiler \"VERSION\"\n"));
2307
/* We have no need to default values of symbols. */
2310
md_undefined_symbol (char *name ATTRIBUTE_UNUSED)
2315
/* Round up a section size to the appropriate boundary. */
2317
md_section_align (segT segment ATTRIBUTE_UNUSED, valueT size)
2319
/* Byte alignment is fine */
2323
/* Exactly what point is a PC-relative offset relative TO?
2324
On the vax, they're relative to the address of the offset, plus
2327
md_pcrel_from (fixS *fixP)
2329
return fixP->fx_size + fixP->fx_where + fixP->fx_frag->fr_address;
2333
tc_gen_reloc (asection *section ATTRIBUTE_UNUSED, fixS *fixp)
2336
bfd_reloc_code_real_type code;
2341
if (fixp->fx_r_type != BFD_RELOC_NONE)
2343
code = fixp->fx_r_type;
2349
case BFD_RELOC_8_PCREL:
2350
case BFD_RELOC_16_PCREL:
2351
case BFD_RELOC_32_PCREL:
2353
case BFD_RELOC_8_GOT_PCREL:
2354
case BFD_RELOC_16_GOT_PCREL:
2355
case BFD_RELOC_32_GOT_PCREL:
2356
case BFD_RELOC_8_PLT_PCREL:
2357
case BFD_RELOC_16_PLT_PCREL:
2358
case BFD_RELOC_32_PLT_PCREL:
2362
as_bad_where (fixp->fx_file, fixp->fx_line,
2363
_("Cannot make %s relocation PC relative"),
2364
bfd_get_reloc_code_name (code));
2370
#define F(SZ,PCREL) (((SZ) << 1) + (PCREL))
2371
switch (F (fixp->fx_size, fixp->fx_pcrel))
2373
#define MAP(SZ,PCREL,TYPE) case F(SZ,PCREL): code = (TYPE); break
2374
MAP (1, 0, BFD_RELOC_8);
2375
MAP (2, 0, BFD_RELOC_16);
2376
MAP (4, 0, BFD_RELOC_32);
2377
MAP (1, 1, BFD_RELOC_8_PCREL);
2378
MAP (2, 1, BFD_RELOC_16_PCREL);
2379
MAP (4, 1, BFD_RELOC_32_PCREL);
2387
reloc = xmalloc (sizeof (arelent));
2388
reloc->sym_ptr_ptr = xmalloc (sizeof (asymbol *));
2389
*reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
2390
reloc->address = fixp->fx_frag->fr_address + fixp->fx_where;
2393
reloc->addend = fixp->fx_addnumber;
2397
reloc->addend = fixp->fx_offset;
2400
reloc->howto = bfd_reloc_type_lookup (stdoutput, code);
2401
gas_assert (reloc->howto != 0);
2406
/* vax:md_assemble() emit frags for 1 instruction given in textual form. */
2408
md_assemble (char *instruction_string)
2410
/* Non-zero if operand expression's segment is not known yet. */
2412
/* Non-zero if operand expression's segment is absolute. */
2416
/* An operand. Scans all operands. */
2417
struct vop *operandP;
2418
char *save_input_line_pointer;
2419
/* What used to live after an expression. */
2421
/* 1: instruction_string bad for all passes. */
2423
/* Points to slot just after last operand. */
2424
struct vop *end_operandP;
2425
/* Points to expression values for this operand. */
2429
/* These refer to an instruction operand expression. */
2430
/* Target segment of the address. */
2432
valueT this_add_number;
2433
/* Positive (minuend) symbol. */
2434
symbolS *this_add_symbol;
2436
long opcode_as_number;
2437
/* Least significant byte 1st. */
2438
char *opcode_as_chars;
2439
/* As an array of characters. */
2440
/* Least significant byte 1st */
2441
char *opcode_low_byteP;
2442
/* length (bytes) meant by vop_short. */
2444
/* 0, or 1 if '@' is in addressing mode. */
2446
/* From vop_nbytes: vax_operand_width (in bytes) */
2448
FLONUM_TYPE *floatP;
2449
LITTLENUM_TYPE literal_float[8];
2450
/* Big enough for any floating point literal. */
2452
vip (&v, instruction_string);
2454
/* Now we try to find as many as_warn()s as we can. If we do any as_warn()s
2455
then goofed=1. Notice that we don't make any frags yet.
2456
Should goofed be 1, then this instruction will wedge in any pass,
2457
and we can safely flush it, without causing interpass symbol phase
2458
errors. That is, without changing label values in different passes. */
2459
if ((goofed = (*v.vit_error)) != 0)
2461
as_fatal (_("Ignoring statement due to \"%s\""), v.vit_error);
2463
/* We need to use expression() and friends, which require us to diddle
2464
input_line_pointer. So we save it and restore it later. */
2465
save_input_line_pointer = input_line_pointer;
2466
for (operandP = v.vit_operand,
2467
expP = exp_of_operand,
2468
segP = seg_of_operand,
2469
floatP = float_operand,
2470
end_operandP = v.vit_operand + v.vit_operands;
2472
operandP < end_operandP;
2474
operandP++, expP++, segP++, floatP++)
2476
if (operandP->vop_error)
2478
as_fatal (_("Aborting because statement has \"%s\""), operandP->vop_error);
2483
/* Statement has no syntax goofs: let's sniff the expression. */
2484
int can_be_short = 0; /* 1 if a bignum can be reduced to a short literal. */
2486
input_line_pointer = operandP->vop_expr_begin;
2487
c_save = operandP->vop_expr_end[1];
2488
operandP->vop_expr_end[1] = '\0';
2489
/* If to_seg == SEG_PASS1, expression() will have set need_pass_2 = 1. */
2490
*segP = expression (expP);
2494
/* for BSD4.2 compatibility, missing expression is absolute 0 */
2495
expP->X_op = O_constant;
2496
expP->X_add_number = 0;
2497
/* For SEG_ABSOLUTE, we shouldn't need to set X_op_symbol,
2498
X_add_symbol to any particular value. But, we will program
2499
defensively. Since this situation occurs rarely so it costs
2500
us little to do, and stops Dean worrying about the origin of
2501
random bits in expressionS's. */
2502
expP->X_add_symbol = NULL;
2503
expP->X_op_symbol = NULL;
2511
/* Major bug. We can't handle the case of a
2512
SEG_OP expression in a VIT_OPCODE_SYNTHETIC
2513
variable-length instruction.
2514
We don't have a frag type that is smart enough to
2515
relax a SEG_OP, and so we just force all
2516
SEG_OPs to behave like SEG_PASS1s.
2517
Clearly, if there is a demand we can invent a new or
2518
modified frag type and then coding up a frag for this
2519
case will be easy. SEG_OP was invented for the
2520
.words after a CASE opcode, and was never intended for
2521
instruction operands. */
2523
as_fatal (_("Can't relocate expression"));
2527
/* Preserve the bits. */
2528
if (expP->X_add_number > 0)
2530
bignum_copy (generic_bignum, expP->X_add_number,
2531
floatP->low, SIZE_OF_LARGE_NUMBER);
2535
know (expP->X_add_number < 0);
2536
flonum_copy (&generic_floating_point_number,
2538
if (strchr ("s i", operandP->vop_short))
2540
/* Could possibly become S^# */
2541
flonum_gen2vax (-expP->X_add_number, floatP, literal_float);
2542
switch (-expP->X_add_number)
2546
(literal_float[0] & 0xFC0F) == 0x4000
2547
&& literal_float[1] == 0;
2552
(literal_float[0] & 0xFC0F) == 0x4000
2553
&& literal_float[1] == 0
2554
&& literal_float[2] == 0
2555
&& literal_float[3] == 0;
2560
(literal_float[0] & 0xFF81) == 0x4000
2561
&& literal_float[1] == 0
2562
&& literal_float[2] == 0
2563
&& literal_float[3] == 0;
2567
can_be_short = ((literal_float[0] & 0xFFF8) == 0x4000
2568
&& (literal_float[1] & 0xE000) == 0
2569
&& literal_float[2] == 0
2570
&& literal_float[3] == 0
2571
&& literal_float[4] == 0
2572
&& literal_float[5] == 0
2573
&& literal_float[6] == 0
2574
&& literal_float[7] == 0);
2578
BAD_CASE (-expP->X_add_number);
2584
if (operandP->vop_short == 's'
2585
|| operandP->vop_short == 'i'
2586
|| (operandP->vop_short == ' '
2587
&& operandP->vop_reg == 0xF
2588
&& (operandP->vop_mode & 0xE) == 0x8))
2591
if (operandP->vop_short == ' ')
2593
/* We must chose S^ or I^. */
2594
if (expP->X_add_number > 0)
2596
/* Bignum: Short literal impossible. */
2597
operandP->vop_short = 'i';
2598
operandP->vop_mode = 8;
2599
operandP->vop_reg = 0xF; /* VAX PC. */
2603
/* Flonum: Try to do it. */
2606
operandP->vop_short = 's';
2607
operandP->vop_mode = 0;
2608
operandP->vop_ndx = -1;
2609
operandP->vop_reg = -1;
2610
expP->X_op = O_constant;
2614
operandP->vop_short = 'i';
2615
operandP->vop_mode = 8;
2616
operandP->vop_reg = 0xF; /* VAX PC */
2618
} /* bignum or flonum ? */
2619
} /* if #, but no S^ or I^ seen. */
2620
/* No more ' ' case: either 's' or 'i'. */
2621
if (operandP->vop_short == 's')
2623
/* Wants to be a short literal. */
2624
if (expP->X_add_number > 0)
2626
as_warn (_("Bignum not permitted in short literal. Immediate mode assumed."));
2627
operandP->vop_short = 'i';
2628
operandP->vop_mode = 8;
2629
operandP->vop_reg = 0xF; /* VAX PC. */
2635
as_warn (_("Can't do flonum short literal: immediate mode used."));
2636
operandP->vop_short = 'i';
2637
operandP->vop_mode = 8;
2638
operandP->vop_reg = 0xF; /* VAX PC. */
2642
/* Encode short literal now. */
2645
switch (-expP->X_add_number)
2649
temp = literal_float[0] >> 4;
2653
temp = literal_float[0] >> 1;
2657
temp = ((literal_float[0] << 3) & 070)
2658
| ((literal_float[1] >> 13) & 07);
2662
BAD_CASE (-expP->X_add_number);
2666
floatP->low[0] = temp & 077;
2673
/* I^# seen: set it up if float. */
2674
if (expP->X_add_number < 0)
2676
memcpy (floatP->low, literal_float, sizeof (literal_float));
2678
} /* if S^# seen. */
2682
as_warn (_("A bignum/flonum may not be a displacement: 0x%lx used"),
2683
(expP->X_add_number = 0x80000000L));
2684
/* Chosen so luser gets the most offset bits to patch later. */
2686
expP->X_add_number = floatP->low[0]
2687
| ((LITTLENUM_MASK & (floatP->low[1])) << LITTLENUM_NUMBER_OF_BITS);
2689
/* For the O_big case we have:
2690
If vop_short == 's' then a short floating literal is in the
2691
lowest 6 bits of floatP -> low [0], which is
2692
big_operand_bits [---] [0].
2693
If vop_short == 'i' then the appropriate number of elements
2694
of big_operand_bits [---] [...] are set up with the correct
2696
Also, just in case width is byte word or long, we copy the lowest
2697
32 bits of the number to X_add_number. */
2700
if (input_line_pointer != operandP->vop_expr_end + 1)
2702
as_fatal ("Junk at end of expression \"%s\"", input_line_pointer);
2705
operandP->vop_expr_end[1] = c_save;
2709
input_line_pointer = save_input_line_pointer;
2711
if (need_pass_2 || goofed)
2714
dwarf2_emit_insn (0);
2716
/* Remember where it is, in case we want to modify the op-code later. */
2717
opcode_low_byteP = frag_more (v.vit_opcode_nbytes);
2718
memcpy (opcode_low_byteP, v.vit_opcode, v.vit_opcode_nbytes);
2719
opcode_as_chars = v.vit_opcode;
2720
opcode_as_number = md_chars_to_number ((unsigned char *) opcode_as_chars, 4);
2721
for (operandP = v.vit_operand,
2722
expP = exp_of_operand,
2723
segP = seg_of_operand,
2724
floatP = float_operand,
2725
end_operandP = v.vit_operand + v.vit_operands;
2727
operandP < end_operandP;
2734
if (operandP->vop_ndx >= 0)
2736
/* Indexed addressing byte. */
2737
/* Legality of indexed mode already checked: it is OK. */
2738
FRAG_APPEND_1_CHAR (0x40 + operandP->vop_ndx);
2739
} /* if(vop_ndx>=0) */
2741
/* Here to make main operand frag(s). */
2742
this_add_number = expP->X_add_number;
2743
this_add_symbol = expP->X_add_symbol;
2745
is_undefined = (to_seg == undefined_section);
2746
is_absolute = (to_seg == absolute_section);
2747
at = operandP->vop_mode & 1;
2748
length = (operandP->vop_short == 'b'
2749
? 1 : (operandP->vop_short == 'w'
2750
? 2 : (operandP->vop_short == 'l'
2752
nbytes = operandP->vop_nbytes;
2753
if (operandP->vop_access == 'b')
2755
if (to_seg == now_seg || is_undefined)
2757
/* If is_undefined, then it might BECOME now_seg. */
2760
p = frag_more (nbytes);
2761
fix_new (frag_now, p - frag_now->fr_literal, nbytes,
2762
this_add_symbol, this_add_number, 1, NO_RELOC);
2766
/* to_seg==now_seg || to_seg == SEG_UNKNOWN */
2768
length_code = is_undefined ? STATE_UNDF : STATE_BYTE;
2769
if (opcode_as_number & VIT_OPCODE_SPECIAL)
2771
if (operandP->vop_width == VAX_WIDTH_UNCONDITIONAL_JUMP)
2774
frag_var (rs_machine_dependent, 5, 1,
2775
ENCODE_RELAX (STATE_ALWAYS_BRANCH, length_code),
2776
this_add_symbol, this_add_number,
2781
if (operandP->vop_width == VAX_WIDTH_WORD_JUMP)
2783
length_code = STATE_WORD;
2784
/* JF: There is no state_byte for this one! */
2785
frag_var (rs_machine_dependent, 10, 2,
2786
ENCODE_RELAX (STATE_COMPLEX_BRANCH, length_code),
2787
this_add_symbol, this_add_number,
2792
know (operandP->vop_width == VAX_WIDTH_BYTE_JUMP);
2793
frag_var (rs_machine_dependent, 9, 1,
2794
ENCODE_RELAX (STATE_COMPLEX_HOP, length_code),
2795
this_add_symbol, this_add_number,
2802
know (operandP->vop_width == VAX_WIDTH_CONDITIONAL_JUMP);
2803
frag_var (rs_machine_dependent, 7, 1,
2804
ENCODE_RELAX (STATE_CONDITIONAL_BRANCH, length_code),
2805
this_add_symbol, this_add_number,
2812
/* to_seg != now_seg && to_seg != SEG_UNKNOWN */
2813
/* --- SEG FLOAT MAY APPEAR HERE --- */
2818
know (!(opcode_as_number & VIT_OPCODE_SYNTHETIC));
2819
p = frag_more (nbytes);
2820
/* Conventional relocation. */
2821
fix_new (frag_now, p - frag_now->fr_literal, nbytes,
2822
section_symbol (absolute_section),
2823
this_add_number, 1, NO_RELOC);
2827
know (opcode_as_number & VIT_OPCODE_SYNTHETIC);
2828
if (opcode_as_number & VIT_OPCODE_SPECIAL)
2830
if (operandP->vop_width == VAX_WIDTH_UNCONDITIONAL_JUMP)
2833
*opcode_low_byteP = opcode_as_chars[0] + VAX_WIDEN_LONG;
2834
know (opcode_as_chars[1] == 0);
2836
p[0] = VAX_ABSOLUTE_MODE; /* @#... */
2837
md_number_to_chars (p + 1, this_add_number, 4);
2838
/* Now (eg) JMP @#foo or JSB @#foo. */
2842
if (operandP->vop_width == VAX_WIDTH_WORD_JUMP)
2850
p[5] = VAX_ABSOLUTE_MODE; /* @#... */
2851
md_number_to_chars (p + 6, this_add_number, 4);
2859
know (operandP->vop_width == VAX_WIDTH_BYTE_JUMP);
2865
p[4] = VAX_ABSOLUTE_MODE; /* @#... */
2866
md_number_to_chars (p + 5, this_add_number, 4);
2867
/* Now (eg) xOBxxx 1f
2877
*opcode_low_byteP ^= 1;
2878
/* To reverse the condition in a VAX branch,
2879
complement the lowest order bit. */
2883
p[2] = VAX_ABSOLUTE_MODE; /* @#... */
2884
md_number_to_chars (p + 3, this_add_number, 4);
2893
/* to_seg != now_seg && !is_undefinfed && !is_absolute */
2896
/* Pc-relative. Conventional relocation. */
2897
know (!(opcode_as_number & VIT_OPCODE_SYNTHETIC));
2898
p = frag_more (nbytes);
2899
fix_new (frag_now, p - frag_now->fr_literal, nbytes,
2900
section_symbol (absolute_section),
2901
this_add_number, 1, NO_RELOC);
2905
know (opcode_as_number & VIT_OPCODE_SYNTHETIC);
2906
if (opcode_as_number & VIT_OPCODE_SPECIAL)
2908
if (operandP->vop_width == VAX_WIDTH_UNCONDITIONAL_JUMP)
2911
know (opcode_as_chars[1] == 0);
2912
*opcode_low_byteP = opcode_as_chars[0] + VAX_WIDEN_LONG;
2914
p[0] = VAX_PC_RELATIVE_MODE;
2916
p + 1 - frag_now->fr_literal, 4,
2918
this_add_number, 1, NO_RELOC);
2919
/* Now eg JMP foo or JSB foo. */
2923
if (operandP->vop_width == VAX_WIDTH_WORD_JUMP)
2931
p[5] = VAX_PC_RELATIVE_MODE;
2933
p + 6 - frag_now->fr_literal, 4,
2935
this_add_number, 1, NO_RELOC);
2943
know (operandP->vop_width == VAX_WIDTH_BYTE_JUMP);
2949
p[4] = VAX_PC_RELATIVE_MODE;
2951
p + 5 - frag_now->fr_literal,
2953
this_add_number, 1, NO_RELOC);
2954
/* Now (eg) xOBxxx 1f
2963
know (operandP->vop_width == VAX_WIDTH_CONDITIONAL_JUMP);
2964
*opcode_low_byteP ^= 1; /* Reverse branch condition. */
2968
p[2] = VAX_PC_RELATIVE_MODE;
2969
fix_new (frag_now, p + 3 - frag_now->fr_literal,
2971
this_add_number, 1, NO_RELOC);
2979
/* So it is ordinary operand. */
2980
know (operandP->vop_access != 'b');
2981
/* ' ' target-independent: elsewhere. */
2982
know (operandP->vop_access != ' ');
2983
know (operandP->vop_access == 'a'
2984
|| operandP->vop_access == 'm'
2985
|| operandP->vop_access == 'r'
2986
|| operandP->vop_access == 'v'
2987
|| operandP->vop_access == 'w');
2988
if (operandP->vop_short == 's')
2992
if (this_add_number >= 64)
2994
as_warn (_("Short literal overflow(%ld.), immediate mode assumed."),
2995
(long) this_add_number);
2996
operandP->vop_short = 'i';
2997
operandP->vop_mode = 8;
2998
operandP->vop_reg = 0xF;
3003
as_warn (_("Forced short literal to immediate mode. now_seg=%s to_seg=%s"),
3004
segment_name (now_seg), segment_name (to_seg));
3005
operandP->vop_short = 'i';
3006
operandP->vop_mode = 8;
3007
operandP->vop_reg = 0xF;
3010
if (operandP->vop_reg >= 0 && (operandP->vop_mode < 8
3011
|| (operandP->vop_reg != 0xF && operandP->vop_mode < 10)))
3013
/* One byte operand. */
3014
know (operandP->vop_mode > 3);
3015
FRAG_APPEND_1_CHAR (operandP->vop_mode << 4 | operandP->vop_reg);
3016
/* All 1-bytes except S^# happen here. */
3020
/* {@}{q^}foo{(Rn)} or S^#foo */
3021
if (operandP->vop_reg == -1 && operandP->vop_short != 's')
3024
if (to_seg == now_seg)
3028
know (operandP->vop_short == ' ');
3029
length_code = STATE_BYTE;
3031
if (S_IS_EXTERNAL (this_add_symbol)
3032
|| S_IS_WEAK (this_add_symbol))
3033
length_code = STATE_UNDF;
3035
p = frag_var (rs_machine_dependent, 10, 2,
3036
ENCODE_RELAX (STATE_PC_RELATIVE, length_code),
3037
this_add_symbol, this_add_number,
3039
know (operandP->vop_mode == 10 + at);
3041
/* At is the only context we need to carry
3042
to other side of relax() process. Must
3043
be in the correct bit position of VAX
3044
operand spec. byte. */
3049
know (operandP->vop_short != ' ');
3050
p = frag_more (length + 1);
3051
p[0] = 0xF | ((at + "?\12\14?\16"[length]) << 4);
3052
fix_new (frag_now, p + 1 - frag_now->fr_literal,
3053
length, this_add_symbol,
3054
this_add_number, 1, NO_RELOC);
3059
/* to_seg != now_seg */
3060
if (this_add_symbol == NULL)
3063
/* Do @#foo: simpler relocation than foo-.(pc) anyway. */
3065
p[0] = VAX_ABSOLUTE_MODE; /* @#... */
3066
md_number_to_chars (p + 1, this_add_number, 4);
3067
if (length && length != 4)
3068
as_warn (_("Length specification ignored. Address mode 9F used"));
3072
/* {@}{q^}other_seg */
3073
know ((length == 0 && operandP->vop_short == ' ')
3074
|| (length > 0 && operandP->vop_short != ' '));
3077
|| S_IS_WEAK(this_add_symbol)
3078
|| S_IS_EXTERNAL(this_add_symbol)
3084
default: length_code = STATE_UNDF; break;
3085
case 1: length_code = STATE_BYTE; break;
3086
case 2: length_code = STATE_WORD; break;
3087
case 4: length_code = STATE_LONG; break;
3089
/* We have a SEG_UNKNOWN symbol. It might
3090
turn out to be in the same segment as
3091
the instruction, permitting relaxation. */
3092
p = frag_var (rs_machine_dependent, 5, 2,
3093
ENCODE_RELAX (STATE_PC_RELATIVE, length_code),
3094
this_add_symbol, this_add_number,
3102
know (operandP->vop_short == ' ');
3103
length = 4; /* Longest possible. */
3105
p = frag_more (length + 1);
3106
p[0] = 0xF | ((at + "?\12\14?\16"[length]) << 4);
3107
md_number_to_chars (p + 1, this_add_number, length);
3109
p + 1 - frag_now->fr_literal,
3110
length, this_add_symbol,
3111
this_add_number, 1, NO_RELOC);
3118
/* {@}{q^}foo(Rn) or S^# or I^# or # */
3119
if (operandP->vop_mode < 0xA)
3121
/* # or S^# or I^# */
3122
if (operandP->vop_access == 'v'
3123
|| operandP->vop_access == 'a')
3125
if (operandP->vop_access == 'v')
3126
as_warn (_("Invalid operand: immediate value used as base address."));
3128
as_warn (_("Invalid operand: immediate value used as address."));
3129
/* gcc 2.6.3 is known to generate these in at least
3133
&& is_absolute && (expP->X_op != O_big)
3134
&& operandP->vop_mode == 8 /* No '@'. */
3135
&& this_add_number < 64)
3137
operandP->vop_short = 's';
3139
if (operandP->vop_short == 's')
3141
FRAG_APPEND_1_CHAR (this_add_number);
3147
p = frag_more (nbytes + 1);
3148
know (operandP->vop_reg == 0xF);
3150
if (flag_want_pic && operandP->vop_mode == 8
3151
&& this_add_symbol != NULL)
3153
as_warn (_("Symbol %s used as immediate operand in PIC mode."),
3154
S_GET_NAME (this_add_symbol));
3157
p[0] = (operandP->vop_mode << 4) | 0xF;
3158
if ((is_absolute) && (expP->X_op != O_big))
3160
/* If nbytes > 4, then we are scrod. We
3161
don't know if the high order bytes
3162
are to be 0xFF or 0x00. BSD4.2 & RMS
3163
say use 0x00. OK --- but this
3164
assembler needs ANOTHER rewrite to
3165
cope properly with this bug. */
3166
md_number_to_chars (p + 1, this_add_number,
3167
min (sizeof (valueT),
3169
if ((size_t) nbytes > sizeof (valueT))
3170
memset (p + 1 + sizeof (valueT),
3171
'\0', nbytes - sizeof (valueT));
3175
if (expP->X_op == O_big)
3177
/* Problem here is to get the bytes
3178
in the right order. We stored
3179
our constant as LITTLENUMs, not
3191
for (p++; nbytes; nbytes -= 2, p += 2, lP++)
3192
md_number_to_chars (p, *lP, 2);
3197
fix_new (frag_now, p + 1 - frag_now->fr_literal,
3198
nbytes, this_add_symbol,
3199
this_add_number, 0, NO_RELOC);
3206
/* {@}{q^}foo(Rn) */
3207
know ((length == 0 && operandP->vop_short == ' ')
3208
|| (length > 0 && operandP->vop_short != ' '));
3215
test = this_add_number;
3220
length = test & 0xffff8000 ? 4
3221
: test & 0xffffff80 ? 2
3229
p = frag_more (1 + length);
3230
know (operandP->vop_reg >= 0);
3231
p[0] = operandP->vop_reg
3232
| ((at | "?\12\14?\16"[length]) << 4);
3235
md_number_to_chars (p + 1, this_add_number, length);
3239
fix_new (frag_now, p + 1 - frag_now->fr_literal,
3240
length, this_add_symbol,
3241
this_add_number, 0, NO_RELOC);
3257
if ((errtxt = vip_begin (1, "$", "*", "`")) != 0)
3258
as_fatal (_("VIP_BEGIN error:%s"), errtxt);
3260
for (i = 0, fP = float_operand;
3261
fP < float_operand + VIT_MAX_OPERANDS;
3264
fP->low = &big_operand_bits[i][0];
3265
fP->high = &big_operand_bits[i][SIZE_OF_LARGE_NUMBER - 1];
3269
static char *vax_cons_special_reloc;
3272
vax_cons (expressionS *exp, int size)
3277
vax_cons_special_reloc = NULL;
3278
save = input_line_pointer;
3279
if (input_line_pointer[0] == '%')
3281
if (strncmp (input_line_pointer + 1, "pcrel", 5) == 0)
3283
input_line_pointer += 6;
3284
vax_cons_special_reloc = "pcrel";
3286
if (vax_cons_special_reloc)
3293
if (*input_line_pointer != '8')
3295
input_line_pointer--;
3298
if (input_line_pointer[0] != '1' || input_line_pointer[1] != '6')
3302
if (input_line_pointer[0] != '3' || input_line_pointer[1] != '2')
3312
as_bad (_("Illegal operands: Only %%r_%s%d allowed in %d-byte data fields"),
3313
vax_cons_special_reloc, size * 8, size);
3317
input_line_pointer += 2;
3318
if (*input_line_pointer != '(')
3320
as_bad (_("Illegal operands: %%r_%s%d requires arguments in ()"),
3321
vax_cons_special_reloc, size * 8);
3328
input_line_pointer = save;
3329
vax_cons_special_reloc = NULL;
3334
char *end = ++input_line_pointer;
3337
while (! is_end_of_line[(c = *end)])
3351
as_bad (_("Illegal operands: %%r_%s%d requires arguments in ()"),
3352
vax_cons_special_reloc, size * 8);
3358
if (input_line_pointer != end)
3360
as_bad (_("Illegal operands: %%r_%s%d requires arguments in ()"),
3361
vax_cons_special_reloc, size * 8);
3365
input_line_pointer++;
3367
c = *input_line_pointer;
3368
if (! is_end_of_line[c] && c != ',')
3369
as_bad (_("Illegal operands: garbage after %%r_%s%d()"),
3370
vax_cons_special_reloc, size * 8);
3376
if (vax_cons_special_reloc == NULL)
3380
/* This is called by emit_expr via TC_CONS_FIX_NEW when creating a
3381
reloc for a cons. */
3384
vax_cons_fix_new (fragS *frag, int where, unsigned int nbytes, expressionS *exp)
3386
bfd_reloc_code_real_type r;
3388
r = (nbytes == 1 ? BFD_RELOC_8 :
3389
(nbytes == 2 ? BFD_RELOC_16 : BFD_RELOC_32));
3391
if (vax_cons_special_reloc)
3393
if (*vax_cons_special_reloc == 'p')
3397
case 1: r = BFD_RELOC_8_PCREL; break;
3398
case 2: r = BFD_RELOC_16_PCREL; break;
3399
case 4: r = BFD_RELOC_32_PCREL; break;
3405
fix_new_exp (frag, where, (int) nbytes, exp, 0, r);
3406
vax_cons_special_reloc = NULL;
3410
md_atof (int type, char * litP, int * sizeP)
3412
return vax_md_atof (type, litP, sizeP);
added
removed
binutils-2.23.52.20130611/gas/config/tc-vax.c
