-/* vax.c - vax-specific -
- Copyright (C) 1987, 1991 Free Software Foundation, Inc.
+/* tc-vax.c - vax-specific -
+ Copyright (C) 1987, 91, 92, 93, 94, 95, 98, 99, 2000
+ Free Software Foundation, Inc.
-This file is part of GAS, the GNU Assembler.
+ This file is part of GAS, the GNU Assembler.
-GAS is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 1, or (at your option)
-any later version.
+ GAS is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2, or (at your option)
+ any later version.
-GAS is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with GAS; see the file COPYING. If not, write to
-the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
-
-/* $Id$ */
-
-/* JF I moved almost all the vax specific stuff into this one file 'cuz RMS
- seems to think its a good idea. I hope I managed to get all the VAX-isms */
+ GAS is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+ You should have received a copy of the GNU General Public License
+ along with GAS; see the file COPYING. If not, write to the Free
+ Software Foundation, 59 Temple Place - Suite 330, Boston, MA
+ 02111-1307, USA. */
#include "as.h"
-#include "read.h"
-#include "flonum.h"
#include "vax-inst.h"
#include "obstack.h" /* For FRAG_APPEND_1_CHAR macro in "frags.h" */
-#include "frags.h"
-#include "expr.h"
-#include "symbols.h"
/* These chars start a comment anywhere in a source file (except inside
another comment */
const char comment_chars[] = "#";
-/* These chars only start a comment at the beginning of a line. */
-/* Note that for the VAX the are the same as comment_chars above. */
+/* These chars only start a comment at the beginning of a line. */
+/* Note that for the VAX the are the same as comment_chars above. */
const char line_comment_chars[] = "#";
+const char line_separator_chars[] = ";";
+
/* Chars that can be used to separate mant from exp in floating point nums */
const char EXP_CHARS[] = "eE";
/* Also be aware that MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT may have to be
changed in read.c . Ideally it shouldn't have to know about it at all,
- but nothing is ideal around here.
- */
+ but nothing is ideal around here. */
-static expressionS /* Hold details of an operand expression */
- exp_of_operand[VIT_MAX_OPERANDS];
+/* Hold details of an operand expression */
+static expressionS exp_of_operand[VIT_MAX_OPERANDS];
+static segT seg_of_operand[VIT_MAX_OPERANDS];
-static struct vit
- v; /* A vax instruction after decoding. */
+/* A vax instruction after decoding. */
+static struct vit v;
+/* Hold details of big operands. */
LITTLENUM_TYPE big_operand_bits[VIT_MAX_OPERANDS][SIZE_OF_LARGE_NUMBER];
- /* Hold details of big operands. */
FLONUM_TYPE float_operand[VIT_MAX_OPERANDS];
- /* Above is made to point into */
- /* big_operand_bits by md_begin(). */
+/* Above is made to point into big_operand_bits by md_begin(). */
+
+int flag_hash_long_names; /* -+ */
+int flag_one; /* -1 */
+int flag_show_after_trunc; /* -H */
+int flag_no_hash_mixed_case; /* -h NUM */
\f
/*
* For VAX, relative addresses of "just the right length" are easy.
* The address usually has some constant bytes in it as well.
*
-groups for VAX address relaxing.
-
-1. "foo" pc-relative.
- length of byte, word, long
-
-2a. J<cond> where <cond> is a simple flag test.
- length of byte, word, long.
- VAX opcodes are: (Hex)
- bneq/bnequ 12
- beql/beqlu 13
- bgtr 14
- bleq 15
- bgeq 18
- blss 19
- bgtru 1a
- blequ 1b
- bvc 1c
- bvs 1d
- bgequ/bcc 1e
- blssu/bcs 1f
- Always, you complement 0th bit to reverse condition.
- Always, 1-byte opcode, then 1-byte displacement.
-
-2b. J<cond> where cond tests a memory bit.
- length of byte, word, long.
- Vax opcodes are: (Hex)
- bbs e0
- bbc e1
- bbss e2
- bbcs e3
- bbsc e4
- bbcc e5
- bbssi e6
- bbcci e7
- Always, you complement 0th bit to reverse condition.
- Always, 1-byte opcde, longword-address, byte-address, 1-byte-displacement
-
-2c. J<cond> where cond tests low-order memory bit
- length of byte,word,long.
- Vax opcodes are: (Hex)
- blbs e8
- blbc e9
- Always, you complement 0th bit to reverse condition.
- Always, 1-byte opcode, longword-address, 1-byte displacement.
-
-3. Jbs/Jbr.
- length of byte,word,long.
- Vax opcodes are: (Hex)
- bsbb 10
- brb 11
- These are like (2) but there is no condition to reverse.
- Always, 1 byte opcode, then displacement/absolute.
-
-4a. JacbX
- length of word, long.
- Vax opcodes are: (Hex)
- acbw 3d
- acbf 4f
- acbd 6f
- abcb 9d
- acbl f1
- acbg 4ffd
- acbh 6ffd
- Always, we cannot reverse the sense of the branch; we have a word
- displacement.
- The double-byte op-codes don't hurt: we never want to modify the
- opcode, so we don't care how many bytes are between the opcode and
- the operand.
-
-4b. JXobXXX
- length of long, long, byte.
- Vax opcodes are: (Hex)
- aoblss f2
- aobleq f3
- sobgeq f4
- sobgtr f5
- Always, we cannot reverse the sense of the branch; we have a byte
- displacement.
-
-The only time we need to modify the opcode is for class 2 instructions.
-After relax() we may complement the lowest order bit of such instruction
-to reverse sense of branch.
-
-For class 2 instructions, we store context of "where is the opcode literal".
-We can change an opcode's lowest order bit without breaking anything else.
-
-We sometimes store context in the operand literal. This way we can figure out
-after relax() what the original addressing mode was.
-*/
+ groups for VAX address relaxing.
+
+ 1. "foo" pc-relative.
+ length of byte, word, long
+
+ 2a. J<cond> where <cond> is a simple flag test.
+ length of byte, word, long.
+ VAX opcodes are: (Hex)
+ bneq/bnequ 12
+ beql/beqlu 13
+ bgtr 14
+ bleq 15
+ bgeq 18
+ blss 19
+ bgtru 1a
+ blequ 1b
+ bvc 1c
+ bvs 1d
+ bgequ/bcc 1e
+ blssu/bcs 1f
+ Always, you complement 0th bit to reverse condition.
+ Always, 1-byte opcode, then 1-byte displacement.
+
+ 2b. J<cond> where cond tests a memory bit.
+ length of byte, word, long.
+ Vax opcodes are: (Hex)
+ bbs e0
+ bbc e1
+ bbss e2
+ bbcs e3
+ bbsc e4
+ bbcc e5
+ Always, you complement 0th bit to reverse condition.
+ Always, 1-byte opcde, longword-address, byte-address, 1-byte-displacement
+
+ 2c. J<cond> where cond tests low-order memory bit
+ length of byte,word,long.
+ Vax opcodes are: (Hex)
+ blbs e8
+ blbc e9
+ Always, you complement 0th bit to reverse condition.
+ Always, 1-byte opcode, longword-address, 1-byte displacement.
+
+ 3. Jbs/Jbr.
+ length of byte,word,long.
+ Vax opcodes are: (Hex)
+ bsbb 10
+ brb 11
+ These are like (2) but there is no condition to reverse.
+ Always, 1 byte opcode, then displacement/absolute.
+
+ 4a. JacbX
+ length of word, long.
+ Vax opcodes are: (Hex)
+ acbw 3d
+ acbf 4f
+ acbd 6f
+ abcb 9d
+ acbl f1
+ acbg 4ffd
+ acbh 6ffd
+ Always, we cannot reverse the sense of the branch; we have a word
+ displacement.
+ The double-byte op-codes don't hurt: we never want to modify the
+ opcode, so we don't care how many bytes are between the opcode and
+ the operand.
+
+ 4b. JXobXXX
+ length of long, long, byte.
+ Vax opcodes are: (Hex)
+ aoblss f2
+ aobleq f3
+ sobgeq f4
+ sobgtr f5
+ Always, we cannot reverse the sense of the branch; we have a byte
+ displacement.
+
+ The only time we need to modify the opcode is for class 2 instructions.
+ After relax() we may complement the lowest order bit of such instruction
+ to reverse sense of branch.
+
+ For class 2 instructions, we store context of "where is the opcode literal".
+ We can change an opcode's lowest order bit without breaking anything else.
+
+ We sometimes store context in the operand literal. This way we can figure out
+ after relax() what the original addressing mode was.
+ */
\f
- /* These displacements are relative to */
- /* the start address of the displacement. */
- /* The first letter is Byte, Word. */
- /* 2nd letter is Forward, Backward. */
+/* These displacements are relative to the start address of the
+ displacement. The first letter is Byte, Word. 2nd letter is
+ Forward, Backward. */
#define BF (1+ 127)
#define BB (1+-128)
#define WF (2+ 32767)
#define WB (2+-32768)
- /* Dont need LF, LB because they always */
- /* reach. [They are coded as 0.] */
-
+/* Dont need LF, LB because they always reach. [They are coded as 0.] */
#define C(a,b) ENCODE_RELAX(a,b)
- /* This macro has no side-effects. */
+/* This macro has no side-effects. */
#define ENCODE_RELAX(what,length) (((what) << 2) + (length))
-const relax_typeS
-md_relax_table[] =
+const relax_typeS md_relax_table[] =
{
- {
- 1, 1, 0, 0
- }, /* error sentinel 0,0 */
- {
- 1, 1, 0, 0
- }, /* unused 0,1 */
- {
- 1, 1, 0, 0
- }, /* unused 0,2 */
- {
- 1, 1, 0, 0
- }, /* unused 0,3 */
- {
- BF + 1, BB + 1, 2, C (1, 1)
- }, /* B^"foo" 1,0 */
- {
- WF + 1, WB + 1, 3, C (1, 2)
- }, /* W^"foo" 1,1 */
- {
- 0, 0, 5, 0
- }, /* L^"foo" 1,2 */
- {
- 1, 1, 0, 0
- }, /* unused 1,3 */
- {
- BF, BB, 1, C (2, 1)
- }, /* b<cond> B^"foo" 2,0 */
- {
- WF + 2, WB + 2, 4, C (2, 2)
- }, /* br.+? brw X 2,1 */
- {
- 0, 0, 7, 0
- }, /* br.+? jmp X 2,2 */
- {
- 1, 1, 0, 0
- }, /* unused 2,3 */
- {
- BF, BB, 1, C (3, 1)
- }, /* brb B^foo 3,0 */
- {
- WF, WB, 2, C (3, 2)
- }, /* brw W^foo 3,1 */
- {
- 0, 0, 5, 0
- }, /* Jmp L^foo 3,2 */
- {
- 1, 1, 0, 0
- }, /* unused 3,3 */
- {
- 1, 1, 0, 0
- }, /* unused 4,0 */
- {
- WF, WB, 2, C (4, 2)
- }, /* acb_ ^Wfoo 4,1 */
- {
- 0, 0, 10, 0
- }, /* acb_,br,jmp L^foo4,2 */
- {
- 1, 1, 0, 0
- }, /* unused 4,3 */
- {
- BF, BB, 1, C (5, 1)
- }, /* Xob___,,foo 5,0 */
- {
- WF + 4, WB + 4, 6, C (5, 2)
- }, /* Xob.+2,brb.+3,brw5,1 */
- {
- 0, 0, 9, 0
- }, /* Xob.+2,brb.+6,jmp5,2 */
+ {1, 1, 0, 0}, /* error sentinel 0,0 */
+ {1, 1, 0, 0}, /* unused 0,1 */
+ {1, 1, 0, 0}, /* unused 0,2 */
+ {1, 1, 0, 0}, /* unused 0,3 */
+ {BF + 1, BB + 1, 2, C (1, 1)},/* B^"foo" 1,0 */
+ {WF + 1, WB + 1, 3, C (1, 2)},/* W^"foo" 1,1 */
+ {0, 0, 5, 0}, /* L^"foo" 1,2 */
+ {1, 1, 0, 0}, /* unused 1,3 */
+ {BF, BB, 1, C (2, 1)}, /* b<cond> B^"foo" 2,0 */
+ {WF + 2, WB + 2, 4, C (2, 2)},/* br.+? brw X 2,1 */
+ {0, 0, 7, 0}, /* br.+? jmp X 2,2 */
+ {1, 1, 0, 0}, /* unused 2,3 */
+ {BF, BB, 1, C (3, 1)}, /* brb B^foo 3,0 */
+ {WF, WB, 2, C (3, 2)}, /* brw W^foo 3,1 */
+ {0, 0, 5, 0}, /* Jmp L^foo 3,2 */
+ {1, 1, 0, 0}, /* unused 3,3 */
+ {1, 1, 0, 0}, /* unused 4,0 */
+ {WF, WB, 2, C (4, 2)}, /* acb_ ^Wfoo 4,1 */
+ {0, 0, 10, 0}, /* acb_,br,jmp L^foo4,2 */
+ {1, 1, 0, 0}, /* unused 4,3 */
+ {BF, BB, 1, C (5, 1)}, /* Xob___,,foo 5,0 */
+ {WF + 4, WB + 4, 6, C (5, 2)},/* Xob.+2,brb.+3,brw5,1 */
+ {0, 0, 9, 0}, /* Xob.+2,brb.+6,jmp5,2 */
};
#undef C
{"ffloat", float_cons, 'f'},
{"gfloat", float_cons, 'g'},
{"hfloat", float_cons, 'h'},
- {0}
+ {0},
};
#define STATE_PC_RELATIVE (1)
#define STATE_CONDITIONAL_BRANCH (2)
-#define STATE_ALWAYS_BRANCH (3) /* includes BSB... */
+#define STATE_ALWAYS_BRANCH (3) /* includes BSB... */
#define STATE_COMPLEX_BRANCH (4)
#define STATE_COMPLEX_HOP (5)
#define STATE_LONG (2)
#define STATE_UNDF (3) /* Symbol undefined in pass1 */
-
#define min(a, b) ((a) < (b) ? (a) : (b))
-\f
+
+int flonum_gen2vax PARAMS ((char format_letter, FLONUM_TYPE * f,
+ LITTLENUM_TYPE * words));
+static const char *vip_begin PARAMS ((int, const char *, const char *,
+ const char *));
+static void vip_op_defaults PARAMS ((const char *, const char *, const char *));
+static void vip_op PARAMS ((char *, struct vop *));
+static void vip PARAMS ((struct vit *, char *));
void
md_begin ()
{
- char *vip_begin ();
- char *errtxt;
+ const char *errtxt;
FLONUM_TYPE *fP;
int i;
- if (*(errtxt = vip_begin (TRUE, "$", "*", "`")))
+ if ((errtxt = vip_begin (1, "$", "*", "`")) != 0)
{
- as_fatal("VIP_BEGIN error:%s", errtxt);
+ as_fatal (_("VIP_BEGIN error:%s"), errtxt);
}
for (i = 0, fP = float_operand;
fP->high = &big_operand_bits[i][SIZE_OF_LARGE_NUMBER - 1];
}
}
-
-void
-md_end ()
-{
- vip_end ();
-}
\f
-void /* Knows about order of bytes in address. */
+void
md_number_to_chars (con, value, nbytes)
- char con[]; /* Return 'nbytes' of chars here. */
- long value; /* The value of the bits. */
- int nbytes; /* Number of bytes in the output. */
+ char con[];
+ valueT value;
+ int nbytes;
{
- int n;
- long v;
-
- n = nbytes;
- v = value;
- while (nbytes--)
- {
- *con++ = value; /* Lint wants & MASK_CHAR. */
- value >>= BITS_PER_CHAR;
- }
- /* XXX line number probably botched for this warning message. */
- if (value != 0 && value != -1)
- as_bad("Displacement (%ld) long for instruction field length (%d).", v, n);
+ number_to_chars_littleendian (con, value, nbytes);
}
/* Fix up some data or instructions after we find out the value of a symbol
that they reference. */
-void /* Knows about order of bytes in address. */
-md_apply_fix(fixP, value)
- fixS *fixP; /* Fixup struct pointer */
- long value; /* The value of the bits. */
+void /* Knows about order of bytes in address. */
+md_apply_fix (fixP, value)
+ fixS *fixP;
+ long value;
{
- char *buf = fixP->fx_where + fixP->fx_frag->fr_literal;
- int nbytes; /* Number of bytes in the output. */
-
- nbytes = fixP->fx_size;
- while (nbytes--)
- {
- *buf++ = value; /* Lint wants & MASK_CHAR. */
- value >>= BITS_PER_CHAR;
- }
+ number_to_chars_littleendian (fixP->fx_where + fixP->fx_frag->fr_literal,
+ (valueT) value, fixP->fx_size);
}
-long /* Knows about the byte order in a word. */
+long
md_chars_to_number (con, nbytes)
- unsigned char con[]; /* Low order byte 1st. */
- int nbytes; /* Number of bytes in the input. */
+ unsigned char con[]; /* Low order byte 1st. */
+ int nbytes; /* Number of bytes in the input. */
{
long retval;
for (retval = 0, con += nbytes - 1; nbytes--; con--)
void
md_assemble (instruction_string)
- char *instruction_string; /* A string: assemble 1 instruction. */
+ char *instruction_string; /* A string: assemble 1 instruction. */
{
+ /* Non-zero if operand expression's segment is not known yet. */
+ int is_undefined;
+
+ int length_code;
char *p;
- register struct vop *operandP;/* An operand. Scans all operands. */
+ /* An operand. Scans all operands. */
+ struct vop *operandP;
char *save_input_line_pointer;
- char c_save; /* What used to live after an expression. */
- struct frag *fragP; /* Fragment of code we just made. */
- register int goofed; /* TRUE: instruction_string bad for all passes. */
- register struct vop *end_operandP; /* -> slot just after last operand */
- /* Limit of the for (each operand). */
- register expressionS *expP; /* -> expression values for this operand */
-
- /* These refer to an instruction operand expression. */
- segT to_seg; /* Target segment of the address. */
- register valueT this_add_number;
- register struct symbol *this_add_symbol; /* +ve (minuend) symbol. */
- register struct symbol *this_subtract_symbol; /* -ve(subtrahend) symbol. */
-
- long opcode_as_number; /* As a number. */
- char *opcode_as_chars; /* Least significant byte 1st. */
- /* As an array of characters. */
- char *opcode_low_byteP; /* Least significant byte 1st */
- struct details *detP; /* The details of an ADxxx frag. */
- int length; /* length (bytes) meant by vop_short. */
- int at; /* 0, or 1 if '@' is in addressing mode. */
- int nbytes; /* From vop_nbytes: vax_operand_width (in bytes) */
+ /* What used to live after an expression. */
+ char c_save;
+ /* 1: instruction_string bad for all passes. */
+ int goofed;
+ /* Points to slot just after last operand. */
+ struct vop *end_operandP;
+ /* Points to expression values for this operand. */
+ expressionS *expP;
+ segT *segP;
+
+ /* These refer to an instruction operand expression. */
+ /* Target segment of the address. */
+ segT to_seg;
+ valueT this_add_number;
+ /* Positive (minuend) symbol. */
+ symbolS *this_add_symbol;
+ /* As a number. */
+ long opcode_as_number;
+ /* Least significant byte 1st. */
+ char *opcode_as_chars;
+ /* As an array of characters. */
+ /* Least significant byte 1st */
+ char *opcode_low_byteP;
+ /* length (bytes) meant by vop_short. */
+ int length;
+ /* 0, or 1 if '@' is in addressing mode. */
+ int at;
+ /* From vop_nbytes: vax_operand_width (in bytes) */
+ int nbytes;
FLONUM_TYPE *floatP;
- char *vip ();
LITTLENUM_TYPE literal_float[8];
- /* Big enough for any floating point literal. */
+ /* Big enough for any floating point literal. */
+
+ vip (&v, instruction_string);
- if (*(p = vip (&v, instruction_string)))
- {
- as_fatal("vax_assemble\"%s\" in=\"%s\"", p, instruction_string);
- }
/*
* Now we try to find as many as_warn()s as we can. If we do any as_warn()s
- * then goofed=TRUE. Notice that we don't make any frags yet.
- * Should goofed be TRUE, then this instruction will wedge in any pass,
+ * then goofed=1. Notice that we don't make any frags yet.
+ * Should goofed be 1, then this instruction will wedge in any pass,
* and we can safely flush it, without causing interpass symbol phase
* errors. That is, without changing label values in different passes.
*/
- if (goofed = (*v.vit_error))
+ if ((goofed = (*v.vit_error)) != 0)
{
- as_warn ("Ignoring statement due to \"%s\"", v.vit_error);
+ as_warn (_("Ignoring statement due to \"%s\""), v.vit_error);
}
/*
* We need to use expression() and friends, which require us to diddle
save_input_line_pointer = input_line_pointer;
for (operandP = v.vit_operand,
expP = exp_of_operand,
+ segP = seg_of_operand,
floatP = float_operand,
end_operandP = v.vit_operand + v.vit_operands;
operandP < end_operandP;
- operandP++,
- expP++,
- floatP++
- ) /* for each operand */
- {
- if (*(operandP->vop_error))
+ operandP++, expP++, segP++, floatP++)
+ { /* for each operand */
+ if (operandP->vop_error)
{
- as_warn ("Ignoring statement because \"%s\"", (operandP->vop_error));
- goofed = TRUE;
+ as_warn (_("Ignoring statement because \"%s\""), operandP->vop_error);
+ goofed = 1;
}
else
- { /* statement has no syntax goofs: lets sniff the expression */
- int can_be_short; /* TRUE if a bignum can be reduced to a short literal. */
+ {
+ /* Statement has no syntax goofs: let's sniff the expression. */
+ int can_be_short = 0; /* 1 if a bignum can be reduced to a short literal. */
input_line_pointer = operandP->vop_expr_begin;
c_save = operandP->vop_expr_end[1];
operandP->vop_expr_end[1] = '\0';
- /* If to_seg == SEG_PASS1, expression() will have set need_pass_2 = TRUE. */
- switch (to_seg = expression (expP))
+ /* If to_seg == SEG_PASS1, expression() will have set need_pass_2 = 1. */
+ *segP = expression (expP);
+ switch (expP->X_op)
{
- case SEG_ABSENT:
+ case O_absent:
/* for BSD4.2 compatibility, missing expression is absolute 0 */
- to_seg = expP->X_seg = SEG_ABSOLUTE;
+ expP->X_op = O_constant;
expP->X_add_number = 0;
- /* for SEG_ABSOLUTE, we shouldnt need to set X_subtract_symbol, X_add_symbol to any particular value. */
- /* But, we will program defensively. Since this situation occurs */
- /* rarely so it costs us little to do, and stops Dean */
- /* worrying about the origin of random bits in expressionS's. */
+ /* For SEG_ABSOLUTE, we shouldn't need to set X_op_symbol,
+ X_add_symbol to any particular value. But, we will program
+ defensively. Since this situation occurs rarely so it costs
+ us little to do, and stops Dean worrying about the origin of
+ random bits in expressionS's. */
expP->X_add_symbol = NULL;
- expP->X_subtract_symbol = NULL;
- case SEG_TEXT:
- case SEG_DATA:
- case SEG_BSS:
- case SEG_ABSOLUTE:
- case SEG_UNKNOWN:
+ expP->X_op_symbol = NULL;
break;
- case SEG_DIFFERENCE:
- case SEG_PASS1:
+ case O_symbol:
+ case O_constant:
+ break;
+
+ default:
/*
* Major bug. We can't handle the case of a
- * SEG_DIFFERENCE expression in a VIT_OPCODE_SYNTHETIC
+ * SEG_OP expression in a VIT_OPCODE_SYNTHETIC
* variable-length instruction.
* We don't have a frag type that is smart enough to
- * relax a SEG_DIFFERENCE, and so we just force all
- * SEG_DIFFERENCEs to behave like SEG_PASS1s.
+ * relax a SEG_OP, and so we just force all
+ * SEG_OPs to behave like SEG_PASS1s.
* Clearly, if there is a demand we can invent a new or
* modified frag type and then coding up a frag for this
- * case will be easy. SEG_DIFFERENCE was invented for the
+ * case will be easy. SEG_OP was invented for the
* .words after a CASE opcode, and was never intended for
* instruction operands.
*/
- need_pass_2 = TRUE;
- as_warn("Can't relocate expression");
+ need_pass_2 = 1;
+ as_warn (_("Can't relocate expression"));
break;
- case SEG_BIG:
- /* Preserve the bits. */
+ case O_big:
+ /* Preserve the bits. */
if (expP->X_add_number > 0)
{
bignum_copy (generic_bignum, expP->X_add_number,
flonum_copy (&generic_floating_point_number,
floatP);
if (strchr ("s i", operandP->vop_short))
- { /* Could possibly become S^# */
+ {
+ /* Could possibly become S^# */
flonum_gen2vax (-expP->X_add_number, floatP, literal_float);
switch (-expP->X_add_number)
{
break;
case 'h':
- can_be_short =
- (literal_float[0] & 0xFFF8) == 0x4000
- && (literal_float[1] & 0xE000) == 0
- && literal_float[2] == 0
- && literal_float[3] == 0
- && literal_float[4] == 0
- && literal_float[5] == 0
- && literal_float[6] == 0
- && literal_float[7] == 0;
+ can_be_short = ((literal_float[0] & 0xFFF8) == 0x4000
+ && (literal_float[1] & 0xE000) == 0
+ && literal_float[2] == 0
+ && literal_float[3] == 0
+ && literal_float[4] == 0
+ && literal_float[5] == 0
+ && literal_float[6] == 0
+ && literal_float[7] == 0);
break;
default:
&& operandP->vop_reg == 0xF
&& (operandP->vop_mode & 0xE) == 0x8))
{
- /* Saw a '#'. */
+ /* Saw a '#'. */
if (operandP->vop_short == ' ')
- { /* We must chose S^ or I^. */
+ {
+ /* We must chose S^ or I^. */
if (expP->X_add_number > 0)
- { /* Bignum: Short literal impossible. */
+ {
+ /* Bignum: Short literal impossible. */
operandP->vop_short = 'i';
operandP->vop_mode = 8;
- operandP->vop_reg = 0xF; /* VAX PC. */
+ operandP->vop_reg = 0xF; /* VAX PC. */
}
else
- { /* Flonum: Try to do it. */
+ {
+ /* Flonum: Try to do it. */
if (can_be_short)
{
operandP->vop_short = 's';
operandP->vop_mode = 0;
operandP->vop_ndx = -1;
operandP->vop_reg = -1;
- /* JF hope this is the right thing */
- expP->X_seg = SEG_ABSOLUTE;
+ expP->X_op = O_constant;
}
else
{
operandP->vop_reg = 0xF; /* VAX PC */
}
} /* bignum or flonum ? */
- } /* if #, but no S^ or I^ seen. */
- /* No more ' ' case: either 's' or 'i'. */
+ } /* if #, but no S^ or I^ seen. */
+ /* No more ' ' case: either 's' or 'i'. */
if (operandP->vop_short == 's')
{
- /* Wants to be a short literal. */
+ /* Wants to be a short literal. */
if (expP->X_add_number > 0)
{
- as_warn ("Bignum not permitted in short literal. Immediate mode assumed.");
+ as_warn (_("Bignum not permitted in short literal. Immediate mode assumed."));
operandP->vop_short = 'i';
operandP->vop_mode = 8;
- operandP->vop_reg = 0xF; /* VAX PC. */
+ operandP->vop_reg = 0xF; /* VAX PC. */
}
else
{
if (!can_be_short)
{
- as_warn ("Can't do flonum short literal: immediate mode used.");
+ as_warn (_("Can't do flonum short literal: immediate mode used."));
operandP->vop_short = 'i';
operandP->vop_mode = 8;
- operandP->vop_reg = 0xF; /* VAX PC. */
+ operandP->vop_reg = 0xF; /* VAX PC. */
}
else
- { /* Encode short literal now. */
- register int temp;
+ { /* Encode short literal now. */
+ int temp = 0;
switch (-expP->X_add_number)
{
} /* flonum or bignum ? */
}
else
- { /* I^# seen: set it up if float. */
+ { /* I^# seen: set it up if float. */
if (expP->X_add_number < 0)
{
- bcopy (literal_float, floatP->low, sizeof (literal_float));
+ memcpy (floatP->low, literal_float, sizeof (literal_float));
}
- } /* if S^# seen. */
+ } /* if S^# seen. */
}
else
{
- as_warn ("A bignum/flonum may not be a displacement: 0x%x used",
- expP->X_add_number = 0x80000000);
- /* Chosen so luser gets the most offset bits to patch later. */
+ as_warn (_("A bignum/flonum may not be a displacement: 0x%lx used"),
+ (expP->X_add_number = 0x80000000L));
+ /* Chosen so luser gets the most offset bits to patch later. */
}
expP->X_add_number = floatP->low[0]
| ((LITTLENUM_MASK & (floatP->low[1])) << LITTLENUM_NUMBER_OF_BITS);
-/*
- * For the SEG_BIG case we have:
- * If vop_short == 's' then a short floating literal is in the
- * lowest 6 bits of floatP -> low [0], which is
- * big_operand_bits [---] [0].
- * If vop_short == 'i' then the appropriate number of elements
- * of big_operand_bits [---] [...] are set up with the correct
- * bits.
- * Also, just in case width is byte word or long, we copy the lowest
- * 32 bits of the number to X_add_number.
- */
- break;
-
- default:
- BAD_CASE (to_seg);
+ /*
+ * For the O_big case we have:
+ * If vop_short == 's' then a short floating literal is in the
+ * lowest 6 bits of floatP -> low [0], which is
+ * big_operand_bits [---] [0].
+ * If vop_short == 'i' then the appropriate number of elements
+ * of big_operand_bits [---] [...] are set up with the correct
+ * bits.
+ * Also, just in case width is byte word or long, we copy the lowest
+ * 32 bits of the number to X_add_number.
+ */
break;
}
if (input_line_pointer != operandP->vop_expr_end + 1)
{
as_warn ("Junk at end of expression \"%s\"", input_line_pointer);
- goofed = TRUE;
+ goofed = 1;
}
operandP->vop_expr_end[1] = c_save;
}
} /* for(each operand) */
+
input_line_pointer = save_input_line_pointer;
- if (!need_pass_2 && !goofed)
+ if (need_pass_2 || goofed)
+ {
+ return;
+ }
+
+ /* Emit op-code. */
+ /* Remember where it is, in case we want to modify the op-code later. */
+ opcode_low_byteP = frag_more (v.vit_opcode_nbytes);
+ memcpy (opcode_low_byteP, v.vit_opcode, v.vit_opcode_nbytes);
+ opcode_as_number = md_chars_to_number (opcode_as_chars = v.vit_opcode, 4);
+ for (operandP = v.vit_operand,
+ expP = exp_of_operand,
+ segP = seg_of_operand,
+ floatP = float_operand,
+ end_operandP = v.vit_operand + v.vit_operands;
+
+ operandP < end_operandP;
+
+ operandP++,
+ floatP++,
+ segP++,
+ expP++)
{
- /* We saw no errors in any operands - try to make frag(s) */
- int is_undefined; /* True if operand expression's */
- /* segment not known yet. */
- int length_code;
-
- /* Emit op-code. */
- /* Remember where it is, in case we want to modify the op-code later. */
- opcode_low_byteP = frag_more (v.vit_opcode_nbytes);
- bcopy (v.vit_opcode, opcode_low_byteP, v.vit_opcode_nbytes);
- opcode_as_number = md_chars_to_number (opcode_as_chars = v.vit_opcode, 4);
- for (operandP = v.vit_operand,
- expP = exp_of_operand,
- floatP = float_operand,
- end_operandP = v.vit_operand + v.vit_operands;
-
- operandP < end_operandP;
-
- operandP++,
- floatP++,
- expP++
- ) /* for each operand */
+ if (operandP->vop_ndx >= 0)
+ {
+ /* indexed addressing byte */
+ /* Legality of indexed mode already checked: it is OK */
+ FRAG_APPEND_1_CHAR (0x40 + operandP->vop_ndx);
+ } /* if(vop_ndx>=0) */
+
+ /* Here to make main operand frag(s). */
+ this_add_number = expP->X_add_number;
+ this_add_symbol = expP->X_add_symbol;
+ to_seg = *segP;
+ is_undefined = (to_seg == SEG_UNKNOWN);
+ at = operandP->vop_mode & 1;
+ length = (operandP->vop_short == 'b'
+ ? 1 : (operandP->vop_short == 'w'
+ ? 2 : (operandP->vop_short == 'l'
+ ? 4 : 0)));
+ nbytes = operandP->vop_nbytes;
+ if (operandP->vop_access == 'b')
{
- if (operandP->vop_ndx >= 0)
+ if (to_seg == now_seg || is_undefined)
{
- /* indexed addressing byte */
- /* Legality of indexed mode already checked: it is OK */
- FRAG_APPEND_1_CHAR (0x40 + operandP->vop_ndx);
- } /* if(vop_ndx>=0) */
-
- /* Here to make main operand frag(s). */
- this_add_number = expP->X_add_number;
- this_add_symbol = expP->X_add_symbol;
- this_subtract_symbol = expP->X_subtract_symbol;
- to_seg = expP->X_seg;
- is_undefined = (to_seg == SEG_UNKNOWN);
- know (to_seg == SEG_UNKNOWN
- ||to_seg == SEG_ABSOLUTE
- ||to_seg == SEG_DATA
- ||to_seg == SEG_TEXT
- ||to_seg == SEG_BSS
- ||to_seg == SEG_BIG
- );
- at = operandP->vop_mode & 1;
- length = operandP->vop_short == 'b' ? 1 : operandP->vop_short == 'w' ? 2 : operandP->vop_short == 'l' ? 4 : 0;
- nbytes = operandP->vop_nbytes;
- if (operandP->vop_access == 'b')
+ /* If is_undefined, then it might BECOME now_seg. */
+ if (nbytes)
+ {
+ p = frag_more (nbytes);
+ fix_new (frag_now, p - frag_now->fr_literal, nbytes,
+ this_add_symbol, this_add_number, 1, NO_RELOC);
+ }
+ else
+ { /* to_seg==now_seg || to_seg == SEG_UNKNOWN */
+ /* nbytes==0 */
+ length_code = is_undefined ? STATE_UNDF : STATE_BYTE;
+ if (opcode_as_number & VIT_OPCODE_SPECIAL)
+ {
+ if (operandP->vop_width == VAX_WIDTH_UNCONDITIONAL_JUMP)
+ {
+ /* br or jsb */
+ frag_var (rs_machine_dependent, 5, 1,
+ ENCODE_RELAX (STATE_ALWAYS_BRANCH, length_code),
+ this_add_symbol, this_add_number,
+ opcode_low_byteP);
+ }
+ else
+ {
+ if (operandP->vop_width == VAX_WIDTH_WORD_JUMP)
+ {
+ length_code = STATE_WORD;
+ /* JF: There is no state_byte for this one! */
+ frag_var (rs_machine_dependent, 10, 2,
+ ENCODE_RELAX (STATE_COMPLEX_BRANCH, length_code),
+ this_add_symbol, this_add_number,
+ opcode_low_byteP);
+ }
+ else
+ {
+ know (operandP->vop_width == VAX_WIDTH_BYTE_JUMP);
+ frag_var (rs_machine_dependent, 9, 1,
+ ENCODE_RELAX (STATE_COMPLEX_HOP, length_code),
+ this_add_symbol, this_add_number,
+ opcode_low_byteP);
+ }
+ }
+ }
+ else
+ {
+ know (operandP->vop_width == VAX_WIDTH_CONDITIONAL_JUMP);
+ frag_var (rs_machine_dependent, 7, 1,
+ ENCODE_RELAX (STATE_CONDITIONAL_BRANCH, length_code),
+ this_add_symbol, this_add_number,
+ opcode_low_byteP);
+ }
+ }
+ }
+ else
{
- if (to_seg == now_seg || is_undefined)
- { /* If is_undefined, then it might BECOME now_seg. */
+ /* to_seg != now_seg && to_seg != SEG_UNKNOWN */
+ /*
+ * --- SEG FLOAT MAY APPEAR HERE ----
+ */
+ if (to_seg == SEG_ABSOLUTE)
+ {
if (nbytes)
{
+ know (!(opcode_as_number & VIT_OPCODE_SYNTHETIC));
p = frag_more (nbytes);
- fix_new (frag_now, p - frag_now->fr_literal, nbytes,
- this_add_symbol, 0, this_add_number, 1);
+ /* Conventional relocation. */
+ fix_new (frag_now, p - frag_now->fr_literal,
+ nbytes, &abs_symbol, this_add_number,
+ 1, NO_RELOC);
}
else
- { /* to_seg==now_seg || to_seg == SEG_UNKNOWN */
- /* nbytes==0 */
- length_code = is_undefined ? STATE_UNDF : STATE_BYTE;
+ {
+ know (opcode_as_number & VIT_OPCODE_SYNTHETIC);
if (opcode_as_number & VIT_OPCODE_SPECIAL)
{
if (operandP->vop_width == VAX_WIDTH_UNCONDITIONAL_JUMP)
{
/* br or jsb */
- frag_var (rs_machine_dependent, 5, 1,
- ENCODE_RELAX (STATE_ALWAYS_BRANCH, length_code),
- this_add_symbol, this_add_number,
- opcode_low_byteP);
+ *opcode_low_byteP = opcode_as_chars[0] + VAX_WIDEN_LONG;
+ know (opcode_as_chars[1] == 0);
+ p = frag_more (5);
+ p[0] = VAX_ABSOLUTE_MODE; /* @#... */
+ md_number_to_chars (p + 1, this_add_number, 4);
+ /* Now (eg) JMP @#foo or JSB @#foo. */
}
else
{
if (operandP->vop_width == VAX_WIDTH_WORD_JUMP)
{
- length_code = STATE_WORD; /* JF: There is no state_byte for this one! */
- frag_var (rs_machine_dependent, 10, 2,
- ENCODE_RELAX (STATE_COMPLEX_BRANCH, length_code),
- this_add_symbol, this_add_number,
- opcode_low_byteP);
+ p = frag_more (10);
+ p[0] = 2;
+ p[1] = 0;
+ p[2] = VAX_BRB;
+ p[3] = 6;
+ p[4] = VAX_JMP;
+ p[5] = VAX_ABSOLUTE_MODE; /* @#... */
+ md_number_to_chars (p + 6, this_add_number, 4);
+ /*
+ * Now (eg) ACBx 1f
+ * BRB 2f
+ * 1: JMP @#foo
+ * 2:
+ */
}
else
{
know (operandP->vop_width == VAX_WIDTH_BYTE_JUMP);
- frag_var (rs_machine_dependent, 9, 1,
- ENCODE_RELAX (STATE_COMPLEX_HOP, length_code),
- this_add_symbol, this_add_number,
- opcode_low_byteP);
+ p = frag_more (9);
+ p[0] = 2;
+ p[1] = VAX_BRB;
+ p[2] = 6;
+ p[3] = VAX_JMP;
+ p[4] = VAX_ABSOLUTE_MODE; /* @#... */
+ md_number_to_chars (p + 5, this_add_number, 4);
+ /*
+ * Now (eg) xOBxxx 1f
+ * BRB 2f
+ * 1: JMP @#foo
+ * 2:
+ */
}
}
}
else
{
- know (operandP->vop_width == VAX_WIDTH_CONDITIONAL_JUMP);
- frag_var (rs_machine_dependent, 7, 1,
- ENCODE_RELAX (STATE_CONDITIONAL_BRANCH, length_code),
- this_add_symbol, this_add_number,
- opcode_low_byteP);
+ /* b<cond> */
+ *opcode_low_byteP ^= 1;
+ /* To reverse the condition in a VAX branch,
+ complement the lowest order bit. */
+ p = frag_more (7);
+ p[0] = 6;
+ p[1] = VAX_JMP;
+ p[2] = VAX_ABSOLUTE_MODE; /* @#... */
+ md_number_to_chars (p + 3, this_add_number, 4);
+ /*
+ * Now (eg) BLEQ 1f
+ * JMP @#foo
+ * 1:
+ */
}
}
}
else
- { /* to_seg != now_seg && to_seg != SEG_UNKNOWN */
-/*
- * --- SEG FLOAT MAY APPEAR HERE ----
- */
- if (to_seg == SEG_ABSOLUTE)
+ {
+ /* to_seg != now_seg && to_seg != SEG_UNKNOWN && to_Seg != SEG_ABSOLUTE */
+ if (nbytes > 0)
{
- if (nbytes)
- {
- know (!(opcode_as_number & VIT_OPCODE_SYNTHETIC));
- p = frag_more (nbytes);
- /* Conventional relocation. */
- fix_new (frag_now, p - frag_now->fr_literal,
- nbytes, &abs_symbol, 0, this_add_number, 1);
- }
- else
+ /* Pc-relative. Conventional relocation. */
+ know (!(opcode_as_number & VIT_OPCODE_SYNTHETIC));
+ p = frag_more (nbytes);
+ fix_new (frag_now, p - frag_now->fr_literal,
+ nbytes, &abs_symbol, this_add_number,
+ 1, NO_RELOC);
+ }
+ else
+ {
+ know (opcode_as_number & VIT_OPCODE_SYNTHETIC);
+ if (opcode_as_number & VIT_OPCODE_SPECIAL)
{
- know (opcode_as_number & VIT_OPCODE_SYNTHETIC);
- if (opcode_as_number & VIT_OPCODE_SPECIAL)
+ if (operandP->vop_width == VAX_WIDTH_UNCONDITIONAL_JUMP)
{
- if (operandP->vop_width == VAX_WIDTH_UNCONDITIONAL_JUMP)
- {
- /* br or jsb */
- *opcode_low_byteP = opcode_as_chars[0] + VAX_WIDEN_LONG;
- know (opcode_as_chars[1] == 0);
- p = frag_more (5);
- p[0] = VAX_ABSOLUTE_MODE; /* @#... */
- md_number_to_chars (p + 1, this_add_number, 4);
- /* Now (eg) JMP @#foo or JSB @#foo. */
- }
- else
- {
- if (operandP->vop_width == VAX_WIDTH_WORD_JUMP)
- {
- p = frag_more (10);
- p[0] = 2;
- p[1] = 0;
- p[2] = VAX_BRB;
- p[3] = 6;
- p[4] = VAX_JMP;
- p[5] = VAX_ABSOLUTE_MODE; /* @#... */
- md_number_to_chars (p + 6, this_add_number, 4);
- /*
- * Now (eg) ACBx 1f
- * BRB 2f
- * 1: JMP @#foo
- * 2:
- */
- }
- else
- {
- know (operandP->vop_width == VAX_WIDTH_BYTE_JUMP);
- p = frag_more (9);
- p[0] = 2;
- p[1] = VAX_BRB;
- p[2] = 6;
- p[3] = VAX_JMP;
- p[4] = VAX_PC_RELATIVE_MODE + 1; /* @#... */
- md_number_to_chars (p + 5, this_add_number, 4);
- /*
- * Now (eg) xOBxxx 1f
- * BRB 2f
- * 1: JMP @#foo
- * 2:
- */
- }
- }
+ /* br or jsb */
+ know (opcode_as_chars[1] == 0);
+ *opcode_low_byteP = opcode_as_chars[0] + VAX_WIDEN_LONG;
+ p = frag_more (5);
+ p[0] = VAX_PC_RELATIVE_MODE;
+ fix_new (frag_now,
+ p + 1 - frag_now->fr_literal, 4,
+ this_add_symbol,
+ this_add_number, 1, NO_RELOC);
+ /* Now eg JMP foo or JSB foo. */
}
else
{
- /* b<cond> */
- *opcode_low_byteP ^= 1; /* To reverse the condition in a VAX branch, complement the lowest order bit. */
- p = frag_more (7);
- p[0] = 6;
- p[1] = VAX_JMP;
- p[2] = VAX_ABSOLUTE_MODE; /* @#... */
- md_number_to_chars (p + 3, this_add_number, 4);
- /*
- * Now (eg) BLEQ 1f
- * JMP @#foo
- * 1:
- */
- }
- }
- }
- else
- { /* to_seg != now_seg && to_seg != SEG_UNKNOWN && to_Seg != SEG_ABSOLUTE */
- if (nbytes > 0)
- {
- /* Pc-relative. Conventional relocation. */
- know (!(opcode_as_number & VIT_OPCODE_SYNTHETIC));
- p = frag_more (nbytes);
- fix_new (frag_now, p - frag_now->fr_literal,
- nbytes, &abs_symbol, 0, this_add_number, 1);
- }
- else
- {
- know (opcode_as_number & VIT_OPCODE_SYNTHETIC);
- if (opcode_as_number & VIT_OPCODE_SPECIAL)
- {
- if (operandP->vop_width == VAX_WIDTH_UNCONDITIONAL_JUMP)
+ if (operandP->vop_width == VAX_WIDTH_WORD_JUMP)
{
- /* br or jsb */
- know (opcode_as_chars[1] == 0);
- *opcode_low_byteP = opcode_as_chars[0] + VAX_WIDEN_LONG;
- p = frag_more (5);
- p[0] = VAX_PC_RELATIVE_MODE;
+ p = frag_more (10);
+ p[0] = 0;
+ p[1] = 2;
+ p[2] = VAX_BRB;
+ p[3] = 6;
+ p[4] = VAX_JMP;
+ p[5] = VAX_PC_RELATIVE_MODE;
fix_new (frag_now,
- p + 1 - frag_now->fr_literal, 4,
- this_add_symbol, 0,
- this_add_number, 1);
- /* Now eg JMP foo or JSB foo. */
+ p + 6 - frag_now->fr_literal, 4,
+ this_add_symbol,
+ this_add_number, 1, NO_RELOC);
+ /*
+ * Now (eg) ACBx 1f
+ * BRB 2f
+ * 1: JMP foo
+ * 2:
+ */
}
else
{
- if (operandP->vop_width == VAX_WIDTH_WORD_JUMP)
- {
- p = frag_more (10);
- p[0] = 0;
- p[1] = 2;
- p[2] = VAX_BRB;
- p[3] = 6;
- p[4] = VAX_JMP;
- p[5] = VAX_PC_RELATIVE_MODE;
- fix_new (frag_now,
- p + 6 - frag_now->fr_literal, 4,
- this_add_symbol, 0,
- this_add_number, 1);
- /*
- * Now (eg) ACBx 1f
- * BRB 2f
- * 1: JMP foo
- * 2:
- */
- }
- else
- {
- know (operandP->vop_width == VAX_WIDTH_BYTE_JUMP);
- p = frag_more (10);
- p[0] = 2;
- p[1] = VAX_BRB;
- p[2] = 6;
- p[3] = VAX_JMP;
- p[4] = VAX_PC_RELATIVE_MODE;
- fix_new (frag_now,
- p + 5 - frag_now->fr_literal,
- 4, this_add_symbol, 0,
- this_add_number, 1);
- /*
- * Now (eg) xOBxxx 1f
- * BRB 2f
- * 1: JMP foo
- * 2:
- */
- }
+ know (operandP->vop_width == VAX_WIDTH_BYTE_JUMP);
+ p = frag_more (10);
+ p[0] = 2;
+ p[1] = VAX_BRB;
+ p[2] = 6;
+ p[3] = VAX_JMP;
+ p[4] = VAX_PC_RELATIVE_MODE;
+ fix_new (frag_now,
+ p + 5 - frag_now->fr_literal,
+ 4, this_add_symbol,
+ this_add_number, 1, NO_RELOC);
+ /*
+ * Now (eg) xOBxxx 1f
+ * BRB 2f
+ * 1: JMP foo
+ * 2:
+ */
}
}
- else
- {
- know (operandP->vop_width == VAX_WIDTH_CONDITIONAL_JUMP);
- *opcode_low_byteP ^= 1; /* Reverse branch condition. */
- p = frag_more (7);
- p[0] = 6;
- p[1] = VAX_JMP;
- p[2] = VAX_PC_RELATIVE_MODE;
- fix_new (frag_now, p + 3 - frag_now->fr_literal,
- 4, this_add_symbol, 0,
- this_add_number, 1);
- }
+ }
+ else
+ {
+ know (operandP->vop_width == VAX_WIDTH_CONDITIONAL_JUMP);
+ *opcode_low_byteP ^= 1; /* Reverse branch condition. */
+ p = frag_more (7);
+ p[0] = 6;
+ p[1] = VAX_JMP;
+ p[2] = VAX_PC_RELATIVE_MODE;
+ fix_new (frag_now, p + 3 - frag_now->fr_literal,
+ 4, this_add_symbol,
+ this_add_number, 1, NO_RELOC);
}
}
}
}
- else
+ }
+ else
+ {
+ know (operandP->vop_access != 'b'); /* So it is ordinary operand. */
+ know (operandP->vop_access != ' '); /* ' ' target-independent: elsewhere. */
+ know (operandP->vop_access == 'a'
+ || operandP->vop_access == 'm'
+ || operandP->vop_access == 'r'
+ || operandP->vop_access == 'v'
+ || operandP->vop_access == 'w');
+ if (operandP->vop_short == 's')
{
- know (operandP->vop_access != 'b'); /* So it is ordinary operand. */
- know (operandP->vop_access != ' '); /* ' ' target-independent: elsewhere. */
- know (operandP->vop_access == 'a' || operandP->vop_access == 'm' || operandP->vop_access == 'r' || operandP->vop_access == 'v' || operandP->vop_access == 'w');
- if (operandP->vop_short == 's')
+ if (to_seg == SEG_ABSOLUTE)
{
- if (to_seg == SEG_ABSOLUTE)
- {
- if (this_add_number < 0 || this_add_number >= 64)
- {
- as_warn ("Short literal overflow(%d.), immediate mode assumed.", this_add_number);
- operandP->vop_short = 'i';
- operandP->vop_mode = 8;
- operandP->vop_reg = 0xF;
- }
- }
- else
+ if (this_add_number >= 64)
{
- as_warn ("Forced short literal to immediate mode. now_seg=%s to_seg=%s", segment_name(now_seg), segment_name(to_seg));
+ as_warn (_("Short literal overflow(%ld.), immediate mode assumed."),
+ (long) this_add_number);
operandP->vop_short = 'i';
operandP->vop_mode = 8;
operandP->vop_reg = 0xF;
}
}
- if (operandP->vop_reg >= 0 && (operandP->vop_mode < 8 || (operandP->vop_reg != 0xF && operandP->vop_mode < 10)))
- { /* One byte operand. */
- know (operandP->vop_mode > 3);
- FRAG_APPEND_1_CHAR (operandP->vop_mode << 4 | operandP->vop_reg);
- /* All 1-bytes except S^# happen here. */
- }
else
- { /* {@}{q^}foo{(Rn)} or S^#foo */
- if (operandP->vop_reg == -1 && operandP->vop_short != 's')
- { /* "{@}{q^}foo" */
- if (to_seg == now_seg)
+ {
+ as_warn (_("Forced short literal to immediate mode. now_seg=%s to_seg=%s"),
+ segment_name (now_seg), segment_name (to_seg));
+ operandP->vop_short = 'i';
+ operandP->vop_mode = 8;
+ operandP->vop_reg = 0xF;
+ }
+ }
+ if (operandP->vop_reg >= 0 && (operandP->vop_mode < 8
+ || (operandP->vop_reg != 0xF && operandP->vop_mode < 10)))
+ {
+ /* One byte operand. */
+ know (operandP->vop_mode > 3);
+ FRAG_APPEND_1_CHAR (operandP->vop_mode << 4 | operandP->vop_reg);
+ /* All 1-bytes except S^# happen here. */
+ }
+ else
+ {
+ /* {@}{q^}foo{(Rn)} or S^#foo */
+ if (operandP->vop_reg == -1 && operandP->vop_short != 's')
+ {
+ /* "{@}{q^}foo" */
+ if (to_seg == now_seg)
+ {
+ if (length == 0)
{
- if (length == 0)
- {
- know (operandP->vop_short == ' ');
- p = frag_var (rs_machine_dependent, 10, 2,
+ know (operandP->vop_short == ' ');
+ p = frag_var (rs_machine_dependent, 10, 2,
ENCODE_RELAX (STATE_PC_RELATIVE, STATE_BYTE),
+ this_add_symbol, this_add_number,
+ opcode_low_byteP);
+ know (operandP->vop_mode == 10 + at);
+ *p = at << 4;
+ /* At is the only context we need to carry
+ to other side of relax() process. Must
+ be in the correct bit position of VAX
+ operand spec. byte. */
+ }
+ else
+ {
+ know (length);
+ know (operandP->vop_short != ' ');
+ p = frag_more (length + 1);
+ p[0] = 0xF | ((at + "?\12\14?\16"[length]) << 4);
+ fix_new (frag_now, p + 1 - frag_now->fr_literal,
+ length, this_add_symbol,
+ this_add_number, 1, NO_RELOC);
+ }
+ }
+ else
+ { /* to_seg != now_seg */
+ if (this_add_symbol == NULL)
+ {
+ know (to_seg == SEG_ABSOLUTE);
+ /* Do @#foo: simpler relocation than foo-.(pc) anyway. */
+ p = frag_more (5);
+ p[0] = VAX_ABSOLUTE_MODE; /* @#... */
+ md_number_to_chars (p + 1, this_add_number, 4);
+ if (length && length != 4)
+ {
+ as_warn (_("Length specification ignored. Address mode 9F used"));
+ }
+ }
+ else
+ {
+ /* {@}{q^}other_seg */
+ know ((length == 0 && operandP->vop_short == ' ')
+ || (length > 0 && operandP->vop_short != ' '));
+ if (is_undefined)
+ {
+ /*
+ * We have a SEG_UNKNOWN symbol. It might
+ * turn out to be in the same segment as
+ * the instruction, permitting relaxation.
+ */
+ p = frag_var (rs_machine_dependent, 5, 2,
+ ENCODE_RELAX (STATE_PC_RELATIVE, STATE_UNDF),
this_add_symbol, this_add_number,
- opcode_low_byteP);
- know (operandP->vop_mode == 10 + at);
- *p = at << 4;
- /* At is the only context we need to carry to */
- /* other side of relax() process. */
- /* Must be in the correct bit position of VAX */
- /* operand spec. byte. */
+ 0);
+ p[0] = at << 4;
}
else
{
- know (length);
- know (operandP->vop_short != ' ');
+ if (length == 0)
+ {
+ know (operandP->vop_short == ' ');
+ length = 4; /* Longest possible. */
+ }
p = frag_more (length + 1);
- /* JF is this array stuff really going to work? */
p[0] = 0xF | ((at + "?\12\14?\16"[length]) << 4);
- fix_new (frag_now, p + 1 - frag_now->fr_literal,
- length, this_add_symbol, 0,
- this_add_number, 1);
+ md_number_to_chars (p + 1, this_add_number, length);
+ fix_new (frag_now,
+ p + 1 - frag_now->fr_literal,
+ length, this_add_symbol,
+ this_add_number, 1, NO_RELOC);
}
}
+ }
+ }
+ else
+ {
+ /* {@}{q^}foo(Rn) or S^# or I^# or # */
+ if (operandP->vop_mode < 0xA)
+ {
+ /* # or S^# or I^# */
+ if (operandP->vop_access == 'v'
+ || operandP->vop_access == 'a')
+ {
+ if (operandP->vop_access == 'v')
+ as_warn (_("Invalid operand: immediate value used as base address."));
+ else
+ as_warn (_("Invalid operand: immediate value used as address."));
+ /* gcc 2.6.3 is known to generate these in at least
+ one case. */
+ }
+ if (length == 0
+ && to_seg == SEG_ABSOLUTE && (expP->X_op != O_big)
+ && operandP->vop_mode == 8 /* No '@'. */
+ && this_add_number < 64)
+ {
+ operandP->vop_short = 's';
+ }
+ if (operandP->vop_short == 's')
+ {
+ FRAG_APPEND_1_CHAR (this_add_number);
+ }
else
- { /* to_seg != now_seg */
- if (this_add_symbol == NULL)
+ {
+ /* I^#... */
+ know (nbytes);
+ p = frag_more (nbytes + 1);
+ know (operandP->vop_reg == 0xF);
+ p[0] = (operandP->vop_mode << 4) | 0xF;
+ if ((to_seg == SEG_ABSOLUTE) && (expP->X_op != O_big))
{
- know (to_seg == SEG_ABSOLUTE);
- /* Do @#foo: simpler relocation than foo-.(pc) anyway. */
- p = frag_more (5);
- p[0] = VAX_ABSOLUTE_MODE; /* @#... */
- md_number_to_chars (p + 1, this_add_number, 4);
- if (length && length != 4)
+ /*
+ * If nbytes > 4, then we are scrod. We
+ * don't know if the high order bytes
+ * are to be 0xFF or 0x00. BSD4.2 & RMS
+ * say use 0x00. OK --- but this
+ * assembler needs ANOTHER rewrite to
+ * cope properly with this bug. */
+ md_number_to_chars (p + 1, this_add_number, min (4, nbytes));
+ if (nbytes > 4)
{
- as_warn ("Length specification ignored. Address mode 9F used");
+ memset (p + 5, '\0', nbytes - 4);
}
}
else
{
- /* {@}{q^}other_seg */
- know ((length == 0 && operandP->vop_short == ' ')
- ||(length > 0 && operandP->vop_short != ' '));
- if (is_undefined)
+ if (expP->X_op == O_big)
{
/*
- * We have a SEG_UNKNOWN symbol. It might
- * turn out to be in the same segment as
- * the instruction, permitting relaxation.
- */
- p = frag_var (rs_machine_dependent, 5, 2,
- ENCODE_RELAX (STATE_PC_RELATIVE, STATE_UNDF),
- this_add_symbol, this_add_number,
- 0);
- p[0] = at << 4;
- }
- else
- {
- if (length == 0)
+ * Problem here is to get the bytes
+ * in the right order. We stored
+ * our constant as LITTLENUMs, not
+ * bytes. */
+ LITTLENUM_TYPE *lP;
+
+ lP = floatP->low;
+ if (nbytes & 1)
{
- know (operandP->vop_short == ' ');
- length = 4; /* Longest possible. */
+ know (nbytes == 1);
+ p[1] = *lP;
}
- p = frag_more (length + 1);
- p[0] = 0xF | ((at + "?\12\14?\16"[length]) << 4);
- md_number_to_chars (p + 1, this_add_number, length);
- fix_new (frag_now,
- p + 1 - frag_now->fr_literal,
- length, this_add_symbol, 0,
- this_add_number, 1);
- }
- }
- }
- }
- else
- { /* {@}{q^}foo(Rn) or S^# or I^# or # */
- if (operandP->vop_mode < 0xA)
- { /* # or S^# or I^# */
- /* know( (length == 0 && operandP->vop_short == ' ')
- || (length > 0 && operandP->vop_short != ' ')); */
- if (length == 0
- && to_seg == SEG_ABSOLUTE
- && operandP->vop_mode == 8 /* No '@'. */
- && this_add_number < 64
- && this_add_number >= 0)
- {
- operandP->vop_short = 's';
- }
- if (operandP->vop_short == 's')
- {
- FRAG_APPEND_1_CHAR (this_add_number);
- }
- else
- { /* I^#... */
- know (nbytes);
- p = frag_more (nbytes + 1);
- know (operandP->vop_reg == 0xF);
- p[0] = (operandP->vop_mode << 4) | 0xF;
- if (to_seg == SEG_ABSOLUTE)
- {
-/*
- * If nbytes > 4, then we are scrod. We don't know if the
- * high order bytes are to be 0xFF or 0x00.
- * BSD4.2 & RMS say use 0x00. OK --- but this
- * assembler needs ANOTHER rewrite to
- * cope properly with this bug.
- */
- md_number_to_chars (p + 1, this_add_number, min (4, nbytes));
- if (nbytes > 4)
+ else
{
- bzero (p + 5, nbytes - 4);
+ for (p++; nbytes; nbytes -= 2, p += 2, lP++)
+ {
+ md_number_to_chars (p, *lP, 2);
+ }
}
}
else
{
- if (to_seg == SEG_BIG)
- {
-/*
- * Problem here is to get the bytes in the right order.
- * We stored our constant as LITTLENUMs, not bytes.
- */
- LITTLENUM_TYPE *lP;
-
- lP = floatP->low;
- if (nbytes & 1)
- {
- know (nbytes == 1);
- p[1] = *lP;
- }
- else
- {
- for (p++; nbytes; nbytes -= 2, p += 2, lP++)
- {
- md_number_to_chars (p, *lP, 2);
- }
- }
- }
- else
- {
- fix_new (frag_now, p + 1 - frag_now->fr_literal,
- nbytes, this_add_symbol, 0,
- this_add_number, 0);
- }
+ fix_new (frag_now, p + 1 - frag_now->fr_literal,
+ nbytes, this_add_symbol,
+ this_add_number, 0, NO_RELOC);
}
}
}
- else
- { /* {@}{q^}foo(Rn) */
- know ((length == 0 && operandP->vop_short == ' ')
- ||(length > 0 && operandP->vop_short != ' '));
- if (length == 0)
+ }
+ else
+ { /* {@}{q^}foo(Rn) */
+ know ((length == 0 && operandP->vop_short == ' ')
+ || (length > 0 && operandP->vop_short != ' '));
+ if (length == 0)
+ {
+ if (to_seg == SEG_ABSOLUTE)
{
- if (to_seg == SEG_ABSOLUTE)
- {
- register long test;
+ long test;
- test = this_add_number;
+ test = this_add_number;
- if (test < 0)
- test = ~test;
+ if (test < 0)
+ test = ~test;
- length = test & 0xffff8000 ? 4
- : test & 0xffffff80 ? 2
- : 1;
- }
- else
- {
- length = 4;
- }
- }
- p = frag_more (1 + length);
- know (operandP->vop_reg >= 0);
- p[0] = operandP->vop_reg
- | ((at | "?\12\14?\16"[length]) << 4);
- if (to_seg == SEG_ABSOLUTE)
- {
- md_number_to_chars (p + 1, this_add_number, length);
+ length = test & 0xffff8000 ? 4
+ : test & 0xffffff80 ? 2
+ : 1;
}
else
{
- fix_new (frag_now, p + 1 - frag_now->fr_literal,
- length, this_add_symbol, 0,
- this_add_number, 0);
+ length = 4;
}
}
+ p = frag_more (1 + length);
+ know (operandP->vop_reg >= 0);
+ p[0] = operandP->vop_reg
+ | ((at | "?\12\14?\16"[length]) << 4);
+ if (to_seg == SEG_ABSOLUTE)
+ {
+ md_number_to_chars (p + 1, this_add_number, length);
+ }
+ else
+ {
+ fix_new (frag_now, p + 1 - frag_now->fr_literal,
+ length, this_add_symbol,
+ this_add_number, 0, NO_RELOC);
+ }
}
- } /* if(single-byte-operand) */
- }
- } /* for(operandP) */
- } /* if(!need_pass_2&&!goofed) */
+ }
+ } /* if(single-byte-operand) */
+ }
+ } /* for(operandP) */
} /* vax_assemble() */
\f
/*
*/
int
md_estimate_size_before_relax (fragP, segment)
- register fragS *fragP;
- register segT segment;
+ fragS *fragP;
+ segT segment;
{
- register char *p;
- register int old_fr_fix;
+ char *p;
+ int old_fr_fix;
old_fr_fix = fragP->fr_fix;
switch (fragP->fr_subtype)
{
case ENCODE_RELAX (STATE_PC_RELATIVE, STATE_UNDF):
- if (S_GET_SEGMENT(fragP->fr_symbol) == segment)
- { /* A relaxable case. */
+ if (S_GET_SEGMENT (fragP->fr_symbol) == segment)
+ { /* A relaxable case. */
fragP->fr_subtype = ENCODE_RELAX (STATE_PC_RELATIVE, STATE_BYTE);
}
else
{
p = fragP->fr_literal + old_fr_fix;
- p[0] |= VAX_PC_RELATIVE_MODE; /* Preserve @ bit. */
+ p[0] |= VAX_PC_RELATIVE_MODE; /* Preserve @ bit. */
fragP->fr_fix += 1 + 4;
- fix_new (fragP, old_fr_fix + 1, 4, fragP->fr_symbol, 0,
- fragP->fr_offset, 1);
+ fix_new (fragP, old_fr_fix + 1, 4, fragP->fr_symbol,
+ fragP->fr_offset, 1, NO_RELOC);
frag_wane (fragP);
}
break;
case ENCODE_RELAX (STATE_CONDITIONAL_BRANCH, STATE_UNDF):
- if (S_GET_SEGMENT(fragP->fr_symbol) == segment)
+ if (S_GET_SEGMENT (fragP->fr_symbol) == segment)
{
fragP->fr_subtype = ENCODE_RELAX (STATE_CONDITIONAL_BRANCH, STATE_BYTE);
}
else
{
p = fragP->fr_literal + old_fr_fix;
- *fragP->fr_opcode ^= 1; /* Reverse sense of branch. */
+ *fragP->fr_opcode ^= 1; /* Reverse sense of branch. */
p[0] = 6;
p[1] = VAX_JMP;
p[2] = VAX_PC_RELATIVE_MODE; /* ...(PC) */
fragP->fr_fix += 1 + 1 + 1 + 4;
- fix_new (fragP, old_fr_fix + 3, 4, fragP->fr_symbol, 0,
- fragP->fr_offset, 1);
+ fix_new (fragP, old_fr_fix + 3, 4, fragP->fr_symbol,
+ fragP->fr_offset, 1, NO_RELOC);
frag_wane (fragP);
}
break;
case ENCODE_RELAX (STATE_COMPLEX_BRANCH, STATE_UNDF):
- if (S_GET_SEGMENT(fragP->fr_symbol) == segment)
+ if (S_GET_SEGMENT (fragP->fr_symbol) == segment)
{
fragP->fr_subtype = ENCODE_RELAX (STATE_COMPLEX_BRANCH, STATE_WORD);
}
p[4] = VAX_JMP;
p[5] = VAX_PC_RELATIVE_MODE; /* ...(pc) */
fragP->fr_fix += 2 + 2 + 1 + 1 + 4;
- fix_new (fragP, old_fr_fix + 6, 4, fragP->fr_symbol, 0,
- fragP->fr_offset, 1);
+ fix_new (fragP, old_fr_fix + 6, 4, fragP->fr_symbol,
+ fragP->fr_offset, 1, NO_RELOC);
frag_wane (fragP);
}
break;
case ENCODE_RELAX (STATE_COMPLEX_HOP, STATE_UNDF):
- if (S_GET_SEGMENT(fragP->fr_symbol) == segment)
+ if (S_GET_SEGMENT (fragP->fr_symbol) == segment)
{
fragP->fr_subtype = ENCODE_RELAX (STATE_COMPLEX_HOP, STATE_BYTE);
}
p[3] = VAX_JMP;
p[4] = VAX_PC_RELATIVE_MODE; /* ...(pc) */
fragP->fr_fix += 1 + 2 + 1 + 1 + 4;
- fix_new (fragP, old_fr_fix + 5, 4, fragP->fr_symbol, 0,
- fragP->fr_offset, 1);
+ fix_new (fragP, old_fr_fix + 5, 4, fragP->fr_symbol,
+ fragP->fr_offset, 1, NO_RELOC);
frag_wane (fragP);
}
break;
case ENCODE_RELAX (STATE_ALWAYS_BRANCH, STATE_UNDF):
- if (S_GET_SEGMENT(fragP->fr_symbol) == segment)
+ if (S_GET_SEGMENT (fragP->fr_symbol) == segment)
{
fragP->fr_subtype = ENCODE_RELAX (STATE_ALWAYS_BRANCH, STATE_BYTE);
}
*fragP->fr_opcode += VAX_WIDEN_LONG;
p[0] = VAX_PC_RELATIVE_MODE; /* ...(PC) */
fragP->fr_fix += 1 + 4;
- fix_new (fragP, old_fr_fix + 1, 4, fragP->fr_symbol, 0,
- fragP->fr_offset, 1);
+ fix_new (fragP, old_fr_fix + 1, 4, fragP->fr_symbol,
+ fragP->fr_offset, 1, NO_RELOC);
frag_wane (fragP);
}
break;
* Caller will turn frag into a ".space 0".
*/
void
-md_convert_frag (fragP)
- register fragS *fragP;
+md_convert_frag (headers, seg, fragP)
+ object_headers *headers;
+ segT seg;
+ fragS *fragP;
{
- register char *addressP; /* -> _var to change. */
- register char *opcodeP; /* -> opcode char(s) to change. */
- register short int length_code; /* 2=long 1=word 0=byte */
- register short int extension; /* Size of relaxed address. */
- /* Added to fr_fix: incl. ALL var chars. */
- register symbolS *symbolP;
- register long where;
- register long address_of_var;
+ char *addressP; /* -> _var to change. */
+ char *opcodeP; /* -> opcode char(s) to change. */
+ short int length_code; /* 2=long 1=word 0=byte */
+ short int extension = 0; /* Size of relaxed address. */
+ /* Added to fr_fix: incl. ALL var chars. */
+ symbolS *symbolP;
+ long where;
+ long address_of_var;
/* Where, in file space, is _var of *fragP? */
- register long target_address;
+ long target_address = 0;
/* Where, in file space, does addr point? */
know (fragP->fr_type == rs_machine_dependent);
opcodeP = fragP->fr_opcode;
symbolP = fragP->fr_symbol;
know (symbolP);
- target_address = symbolP->sy_value + fragP->fr_offset;
+ target_address = S_GET_VALUE (symbolP) + fragP->fr_offset;
address_of_var = fragP->fr_address + where;
+
switch (fragP->fr_subtype)
{
+
case ENCODE_RELAX (STATE_PC_RELATIVE, STATE_BYTE):
- know (*addressP == 0 || *addressP == 0x10); /* '@' bit. */
- addressP[0] |= 0xAF; /* Byte displacement. */
+ know (*addressP == 0 || *addressP == 0x10); /* '@' bit. */
+ addressP[0] |= 0xAF; /* Byte displacement. */
addressP[1] = target_address - (address_of_var + 2);
extension = 2;
break;
case ENCODE_RELAX (STATE_PC_RELATIVE, STATE_WORD):
- know (*addressP == 0 || *addressP == 0x10); /* '@' bit. */
- addressP[0] |= 0xCF; /* Word displacement. */
+ know (*addressP == 0 || *addressP == 0x10); /* '@' bit. */
+ addressP[0] |= 0xCF; /* Word displacement. */
md_number_to_chars (addressP + 1, target_address - (address_of_var + 3), 2);
extension = 3;
break;
case ENCODE_RELAX (STATE_PC_RELATIVE, STATE_LONG):
- know (*addressP == 0 || *addressP == 0x10); /* '@' bit. */
- addressP[0] |= 0xEF; /* Long word displacement. */
+ know (*addressP == 0 || *addressP == 0x10); /* '@' bit. */
+ addressP[0] |= 0xEF; /* Long word displacement. */
md_number_to_chars (addressP + 1, target_address - (address_of_var + 5), 4);
extension = 5;
break;
break;
case ENCODE_RELAX (STATE_CONDITIONAL_BRANCH, STATE_WORD):
- opcodeP[0] ^= 1; /* Reverse sense of test. */
+ opcodeP[0] ^= 1; /* Reverse sense of test. */
addressP[0] = 3;
addressP[1] = VAX_BRB + VAX_WIDEN_WORD;
md_number_to_chars (addressP + 2, target_address - (address_of_var + 4), 2);
break;
case ENCODE_RELAX (STATE_CONDITIONAL_BRANCH, STATE_LONG):
- opcodeP[0] ^= 1; /* Reverse sense of test. */
+ opcodeP[0] ^= 1; /* Reverse sense of test. */
addressP[0] = 6;
addressP[1] = VAX_JMP;
addressP[2] = VAX_PC_RELATIVE_MODE;
- md_number_to_chars (addressP + 3, target_address, 4);
+ md_number_to_chars (addressP + 3, target_address - (address_of_var + 7), 4);
extension = 7;
break;
addressP[3] = 6;
addressP[4] = VAX_JMP;
addressP[5] = VAX_PC_RELATIVE_MODE;
- md_number_to_chars (addressP + 6, target_address, 4);
+ md_number_to_chars (addressP + 6, target_address - (address_of_var + 10), 4);
extension = 10;
break;
addressP[2] = 6;
addressP[3] = VAX_JMP;
addressP[4] = VAX_PC_RELATIVE_MODE;
- md_number_to_chars (addressP + 5, target_address, 4);
+ md_number_to_chars (addressP + 5, target_address - (address_of_var + 9), 4);
extension = 9;
break;
break;
}
fragP->fr_fix += extension;
-}
+} /* md_convert_frag() */
/* Translate internal format of relocation info into target format.
On vax: first 4 bytes are normal unsigned long, next three bytes
are symbolnum, least sig. byte first. Last byte is broken up with
the upper nibble as nuthin, bit 3 as extern, bits 2 & 1 as length, and
- bit 0 as pcrel. */
-void
+ bit 0 as pcrel. */
+#ifdef comment
+void
md_ri_to_chars (the_bytes, ri)
char *the_bytes;
struct reloc_info_generic ri;
the_bytes[7] = (((ri.r_extern << 3) & 0x08) | ((ri.r_length << 1) & 0x06) |
((ri.r_pcrel << 0) & 0x01)) & 0x0F;
}
-\f
+
+#endif /* comment */
+
+void
+tc_aout_fix_to_chars (where, fixP, segment_address_in_file)
+ char *where;
+ fixS *fixP;
+ relax_addressT segment_address_in_file;
+{
+ /*
+ * In: length of relocation (or of address) in chars: 1, 2 or 4.
+ * Out: GNU LD relocation length code: 0, 1, or 2.
+ */
+
+ static const unsigned char nbytes_r_length[] = {42, 0, 1, 42, 2};
+ long r_symbolnum;
+
+ know (fixP->fx_addsy != NULL);
+
+ md_number_to_chars (where,
+ fixP->fx_frag->fr_address + fixP->fx_where - segment_address_in_file,
+ 4);
+
+ r_symbolnum = (S_IS_DEFINED (fixP->fx_addsy)
+ ? S_GET_TYPE (fixP->fx_addsy)
+ : fixP->fx_addsy->sy_number);
+
+ where[6] = (r_symbolnum >> 16) & 0x0ff;
+ where[5] = (r_symbolnum >> 8) & 0x0ff;
+ where[4] = r_symbolnum & 0x0ff;
+ where[7] = ((((!S_IS_DEFINED (fixP->fx_addsy)) << 3) & 0x08)
+ | ((nbytes_r_length[fixP->fx_size] << 1) & 0x06)
+ | (((fixP->fx_pcrel << 0) & 0x01) & 0x0f));
+}
+
/*
* BUGS, GRIPES, APOLOGIA, etc.
*
* That is, AFTER we hash it with hash_...(), we want most-used opcodes
* to come out of the hash table faster.
*
- * I am sorry to inflict
- * yet another VAX assembler on the world, but RMS says we must
- * do everything from scratch, to prevent pin-heads restricting
- * this software.
+ * I am sorry to inflict yet another VAX assembler on the world, but
+ * RMS says we must do everything from scratch, to prevent pin-heads
+ * restricting this software.
*/
/*
* source file, and changed the makefile.
*/
-static char *op_hash = NULL; /* handle of the OPCODE hash table */
- /* NULL means any use before vip_begin() */
- /* will crash */
+/* handle of the OPCODE hash table */
+static struct hash_control *op_hash;
/*
* In: 1 character, from "bdfghloqpw" being the data-type of an operand
static const short int vax_operand_width_size[256] =
{
-
-#define _ 0
- _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _,
- _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _,
- _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _,
- _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _,
- _, _, 1, _, 8, _, 4, 8, 16, _, _, _, 4, _, _, 16, /* ..b.d.fgh...l..o */
- _, 8, _, _, _, _, _, 2, _, _, _, _, _, _, _, _, /* .q.....w........ */
- _, _, 1, _, 8, _, 4, 8, 16, _, _, _, 4, _, _, 16, /* ..b.d.fgh...l..o */
- _, 8, _, _, _, _, _, 2, _, _, _, _, _, _, _, _, /* .q.....w........ */
- _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _,
- _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _,
- _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _,
- _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _,
- _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _,
- _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _,
- _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _,
- _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _};
-#undef _
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 1, 0, 8, 0, 4, 8, 16, 0, 0, 0, 4, 0, 0,16, /* ..b.d.fgh...l..o */
+ 0, 8, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, /* .q.....w........ */
+ 0, 0, 1, 0, 8, 0, 4, 8, 16, 0, 0, 0, 4, 0, 0,16, /* ..b.d.fgh...l..o */
+ 0, 8, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, /* .q.....w........ */
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+};
\f
/*
* This perversion encodes all the vax opcodes as a bunch of strings.
* So change 'vax.opcodes', then re-generate this table.
*/
-#include "vax-opcode.h"
+#include "opcode/vax.h"
\f
/*
* This is a table of optional op-codes. All of them represent
*/
#if (VIT_OPCODE_SYNTHETIC != 0x80000000)
You have just broken the encoding below, which assumes the sign bit
- means 'I am an imaginary instruction'.
+ means 'I am an imaginary instruction'.
#endif
#if (VIT_OPCODE_SPECIAL != 0x40000000)
- 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'.
+ 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'.
#endif
static const struct vot
- synthetic_votstrs[] =
+ synthetic_votstrs[] =
{
- {"jbsb",
- {"b-", 0xC0000010}}, /* BSD 4.2 */
- /* jsb used already */
- {"jbr",
- {"b-", 0xC0000011}}, /* BSD 4.2 */
- {"jr",
- {"b-", 0xC0000011}}, /* consistent */
- {"jneq",
- {"b?", 0x80000012}},
- {"jnequ",
- {"b?", 0x80000012}},
- {"jeql",
- {"b?", 0x80000013}},
- {"jeqlu",
- {"b?", 0x80000013}},
- {"jgtr",
- {"b?", 0x80000014}},
- {"jleq",
- {"b?", 0x80000015}},
- /* un-used opcodes here */
- {"jgeq",
- {"b?", 0x80000018}},
- {"jlss",
- {"b?", 0x80000019}},
- {"jgtru",
- {"b?", 0x8000001a}},
- {"jlequ",
- {"b?", 0x8000001b}},
- {"jvc",
- {"b?", 0x8000001c}},
- {"jvs",
- {"b?", 0x8000001d}},
- {"jgequ",
- {"b?", 0x8000001e}},
- {"jcc",
- {"b?", 0x8000001e}},
- {"jlssu",
- {"b?", 0x8000001f}},
- {"jcs",
- {"b?", 0x8000001f}},
-
- {"jacbw",
- {"rwrwmwb!", 0xC000003d}},
- {"jacbf",
- {"rfrfmfb!", 0xC000004f}},
- {"jacbd",
- {"rdrdmdb!", 0xC000006f}},
- {"jacbb",
- {"rbrbmbb!", 0xC000009d}},
- {"jacbl",
- {"rlrlmlb!", 0xC00000f1}},
- {"jacbg",
- {"rgrgmgb!", 0xC0004ffd}},
- {"jacbh",
- {"rhrhmhb!", 0xC0006ffd}},
-
- {"jbs",
- {"rlvbb?", 0x800000e0}},
- {"jbc",
- {"rlvbb?", 0x800000e1}},
- {"jbss",
- {"rlvbb?", 0x800000e2}},
- {"jbcs",
- {"rlvbb?", 0x800000e3}},
- {"jbsc",
- {"rlvbb?", 0x800000e4}},
- {"jbcc",
- {"rlvbb?", 0x800000e5}},
- {"jbssi",
- {"rlvbb?", 0x800000e6}},
- {"jbcci",
- {"rlvbb?", 0x800000e7}},
- {"jlbs",
- {"rlb?", 0x800000e8}}, /* JF changed from rlvbb? */
- {"jlbc",
- {"rlb?", 0x800000e9}}, /* JF changed from rlvbb? */
-
- {"jaoblss",
- {"rlmlb:", 0xC00000f2}},
- {"jaobleq",
- {"rlmlb:", 0xC00000f3}},
- {"jsobgeq",
- {"mlb:", 0xC00000f4}}, /* JF was rlmlb: */
- {"jsobgtr",
- {"mlb:", 0xC00000f5}}, /* JF was rlmlb: */
-
-/* CASEx has no branch addresses in our conception of it. */
-/* You should use ".word ..." statements after the "case ...". */
-
- {"", ""} /* empty is end sentinel */
+ {"jbsb", {"b-", 0xC0000010}}, /* BSD 4.2 */
+/* jsb used already */
+ {"jbr", {"b-", 0xC0000011}}, /* BSD 4.2 */
+ {"jr", {"b-", 0xC0000011}}, /* consistent */
+ {"jneq", {"b?", 0x80000012}},
+ {"jnequ", {"b?", 0x80000012}},
+ {"jeql", {"b?", 0x80000013}},
+ {"jeqlu", {"b?", 0x80000013}},
+ {"jgtr", {"b?", 0x80000014}},
+ {"jleq", {"b?", 0x80000015}},
+/* un-used opcodes here */
+ {"jgeq", {"b?", 0x80000018}},
+ {"jlss", {"b?", 0x80000019}},
+ {"jgtru", {"b?", 0x8000001a}},
+ {"jlequ", {"b?", 0x8000001b}},
+ {"jvc", {"b?", 0x8000001c}},
+ {"jvs", {"b?", 0x8000001d}},
+ {"jgequ", {"b?", 0x8000001e}},
+ {"jcc", {"b?", 0x8000001e}},
+ {"jlssu", {"b?", 0x8000001f}},
+ {"jcs", {"b?", 0x8000001f}},
+
+ {"jacbw", {"rwrwmwb!", 0xC000003d}},
+ {"jacbf", {"rfrfmfb!", 0xC000004f}},
+ {"jacbd", {"rdrdmdb!", 0xC000006f}},
+ {"jacbb", {"rbrbmbb!", 0xC000009d}},
+ {"jacbl", {"rlrlmlb!", 0xC00000f1}},
+ {"jacbg", {"rgrgmgb!", 0xC0004ffd}},
+ {"jacbh", {"rhrhmhb!", 0xC0006ffd}},
+
+ {"jbs", {"rlvbb?", 0x800000e0}},
+ {"jbc", {"rlvbb?", 0x800000e1}},
+ {"jbss", {"rlvbb?", 0x800000e2}},
+ {"jbcs", {"rlvbb?", 0x800000e3}},
+ {"jbsc", {"rlvbb?", 0x800000e4}},
+ {"jbcc", {"rlvbb?", 0x800000e5}},
+ {"jlbs", {"rlb?", 0x800000e8}},
+ {"jlbc", {"rlb?", 0x800000e9}},
+
+ {"jaoblss", {"rlmlb:", 0xC00000f2}},
+ {"jaobleq", {"rlmlb:", 0xC00000f3}},
+ {"jsobgeq", {"mlb:", 0xC00000f4}},
+ {"jsobgtr", {"mlb:", 0xC00000f5}},
+
+/* CASEx has no branch addresses in our conception of it. */
+/* You should use ".word ..." statements after the "case ...". */
+
+ {"", {"", 0}} /* empty is end sentinel */
}; /* synthetic_votstrs */
\f
*
* Call me once before you decode any lines.
* I decode votstrs into a hash table at op_hash (which I create).
- * I return an error text: hopefully "".
+ * I return an error text or null.
* If you want, I will include the 'synthetic' jXXX instructions in the
* instruction table.
* You must nominate metacharacters for eg DEC's "#", "@", "^".
*/
-char *
+static const char *
vip_begin (synthetic_too, immediate, indirect, displen)
- int synthetic_too; /* TRUE means include jXXX op-codes. */
- char *immediate, *indirect, *displen;
+ int synthetic_too; /* 1 means include jXXX op-codes. */
+ const char *immediate, *indirect, *displen;
{
- register const struct vot *vP; /* scan votstrs */
- register char *retval; /* error text */
+ const struct vot *vP; /* scan votstrs */
+ const char *retval = 0; /* error text */
- char *hash_insert (); /* */
- char *hash_new (); /* lies */
+ op_hash = hash_new ();
+
+ for (vP = votstrs; *vP->vot_name && !retval; vP++)
+ retval = hash_insert (op_hash, vP->vot_name, (PTR) &vP->vot_detail);
+
+ if (synthetic_too)
+ for (vP = synthetic_votstrs; *vP->vot_name && !retval; vP++)
+ retval = hash_insert (op_hash, vP->vot_name, (PTR) &vP->vot_detail);
- if ((op_hash = hash_new ()))
- {
- retval = ""; /* OK so far */
- for (vP = votstrs; *vP->vot_name && !*retval; vP++)
- {
- retval = hash_insert (op_hash, vP->vot_name, &vP->vot_detail);
- }
- if (synthetic_too)
- {
- for (vP = synthetic_votstrs; *vP->vot_name && !*retval; vP++)
- {
- retval = hash_insert (op_hash, vP->vot_name, &vP->vot_detail);
- }
- }
- }
- else
- {
- retval = "virtual memory exceeded";
- }
#ifndef CONST_TABLE
vip_op_defaults (immediate, indirect, displen);
#endif
- return (retval);
+ return retval;
}
-
-/*
- * v i p _ e n d ( )
- *
- * Call me once after you have decoded all lines.
- * I do any cleaning-up needed.
- *
- * We don't have to do any cleanup ourselves: all of our operand
- * symbol table is static, and free()ing it is naughty.
- */
-vip_end ()
-{
-}
-\f
/*
* v i p ( )
*
* No argument string should generate such an error string:
* it means a bug in our code, not in the user's text.
*
- * You MUST have called vip_begin() once and vip_end() never before using
- * this function.
+ * You MUST have called vip_begin() once before using this function.
*/
-char * /* "" or bug string */
+static void
vip (vitP, instring)
- struct vit *vitP; /* We build an exploded instruction here. */
- char *instring; /* Text of a vax instruction: we modify. */
+ struct vit *vitP; /* We build an exploded instruction here. */
+ char *instring; /* Text of a vax instruction: we modify. */
{
- register struct vot_wot *vwP; /* How to bit-encode this opcode. */
- register char *p; /* 1/skip whitespace.2/scan vot_how */
- register char *q; /* */
- register char *bug; /* "" or program logic error */
- register unsigned char count; /* counts number of operands seen */
- register struct vop *operandp;/* scan operands in struct vit */
- register char *alloperr; /* error over all operands */
- register char c; /* Remember char, (we clobber it */
- /* with '\0' temporarily). */
- register vax_opcodeT oc; /* Op-code of this instruction. */
-
- struct vot_wot *hash_find ();
- char *vip_op ();
-
- bug = "";
+ /* How to bit-encode this opcode. */
+ struct vot_wot *vwP;
+ /* 1/skip whitespace.2/scan vot_how */
+ char *p;
+ char *q;
+ /* counts number of operands seen */
+ unsigned char count;
+ /* scan operands in struct vit */
+ struct vop *operandp;
+ /* error over all operands */
+ const char *alloperr;
+ /* Remember char, (we clobber it with '\0' temporarily). */
+ char c;
+ /* Op-code of this instruction. */
+ vax_opcodeT oc;
+
if (*instring == ' ')
- ++instring; /* Skip leading whitespace. */
- for (p = instring; *p && *p != ' '; p++)
- ; /* MUST end in end-of-string or exactly 1 space. */
- /* Scanned up to end of operation-code. */
- /* Operation-code is ended with whitespace. */
+ ++instring; /* Skip leading whitespace. */
+ for (p = instring; *p && *p != ' '; p++);; /* MUST end in end-of-string or exactly 1 space. */
+ /* Scanned up to end of operation-code. */
+ /* Operation-code is ended with whitespace. */
if (p - instring == 0)
{
- vitP->vit_error = "No operator";
+ vitP->vit_error = _("No operator");
count = 0;
- bzero (vitP->vit_opcode, sizeof (vitP->vit_opcode));
+ memset (vitP->vit_opcode, '\0', sizeof (vitP->vit_opcode));
}
else
{
* pointing to character just past that.
* We trust instring points to an op-name, with no whitespace.
*/
- vwP = hash_find (op_hash, instring);
- *p = c; /* Restore char after op-code. */
+ vwP = (struct vot_wot *) hash_find (op_hash, instring);
+ *p = c; /* Restore char after op-code. */
if (vwP == 0)
{
- vitP->vit_error = "Unknown operator";
+ vitP->vit_error = _("Unknown operator");
count = 0;
- bzero (vitP->vit_opcode, sizeof (vitP->vit_opcode));
+ memset (vitP->vit_opcode, '\0', sizeof (vitP->vit_opcode));
}
else
{
/*
- * We found a match! So lets pick up as many operands as the
+ * We found a match! So let's pick up as many operands as the
* instruction wants, and even gripe if there are too many.
* We expect comma to seperate each operand.
* We let instring track the text, while p tracks a part of the
* struct vot.
*/
+ const char *howp;
/*
* The lines below know about 2-byte opcodes starting FD,FE or FF.
* They also understand synthetic opcodes. Note:
* we return 32 bits of opcode, including bucky bits, BUT
* an opcode length is either 8 or 16 bits for vit_opcode_nbytes.
*/
- oc = vwP->vot_code; /* The op-code. */
+ oc = vwP->vot_code; /* The op-code. */
vitP->vit_opcode_nbytes = (oc & 0xFF) >= 0xFD ? 2 : 1;
md_number_to_chars (vitP->vit_opcode, oc, 4);
count = 0; /* no operands seen yet */
instring = p; /* point just past operation code */
alloperr = "";
- for (p = vwP->vot_how, operandp = vitP->vit_operand;
- !*alloperr && !*bug && *p;
- operandp++, p += 2
- )
+ for (howp = vwP->vot_how, operandp = vitP->vit_operand;
+ !(alloperr && *alloperr) && *howp;
+ operandp++, howp += 2)
{
/*
* Here to parse one operand. Leave instring pointing just
* past any one ',' that marks the end of this operand.
*/
- if (!p[1])
- bug = "p"; /* ODD(!!) number of bytes in vot_how?? */
+ if (!howp[1])
+ as_fatal (_("odd number of bytes in operand description"));
else if (*instring)
{
for (q = instring; (c = *q) && c != ','; q++)
* character.
*/
*q = 0;
- operandp->vop_width = p[1];
- operandp->vop_nbytes = vax_operand_width_size[p[1]];
- operandp->vop_access = p[0];
- bug = vip_op (instring, operandp);
- *q = c; /* Restore input text. */
- if (*(operandp->vop_error))
- alloperr = "Bad operand";
+ operandp->vop_width = howp[1];
+ operandp->vop_nbytes = vax_operand_width_size[(unsigned) howp[1]];
+ operandp->vop_access = howp[0];
+ vip_op (instring, operandp);
+ *q = c; /* Restore input text. */
+ if (operandp->vop_error)
+ alloperr = _("Bad operand");
instring = q + (c ? 1 : 0); /* next operand (if any) */
count++; /* won another argument, may have an operr */
}
else
- alloperr = "Not enough operands";
+ alloperr = _("Not enough operands");
}
if (!*alloperr)
{
if (*instring == ' ')
- instring++; /* Skip whitespace. */
+ instring++; /* Skip whitespace. */
if (*instring)
- alloperr = "Too many operands";
+ alloperr = _("Too many operands");
}
vitP->vit_error = alloperr;
}
}
vitP->vit_operands = count;
- return (bug);
}
\f
#ifdef test
char *mybug; /* "" or an internal logic diagnostic */
int mycount; /* number of operands */
struct vop *myvop; /* scan operands from myvit */
-int mysynth; /* TRUE means want synthetic opcodes. */
+int mysynth; /* 1 means want synthetic opcodes. */
char my_immediate[200];
char my_indirect[200];
char my_displen[200];
-char *vip ();
-
main ()
{
char *p;
- char *vip_begin ();
printf ("0 means no synthetic instructions. ");
printf ("Value for vip_begin? ");
gets (my_indirect);
printf ("enter displen symbols eg enter ^ ");
gets (my_displen);
- if (*(p = vip_begin (mysynth, my_immediate, my_indirect, my_displen)))
+ if (p = vip_begin (mysynth, my_immediate, my_indirect, my_displen))
{
error ("vip_begin=%s", p);
}
{
break; /* out of for each input text loop */
}
- mybug = vip (&myvit, answer);
- if (*mybug)
- {
- printf ("BUG:\"%s\"\n", mybug);
- }
+ vip (&myvit, answer);
if (*myvit.vit_error)
{
printf ("ERR:\"%s\"\n", myvit.vit_error);
putchar (*p);
}
printf ("\"\n");
- if (*myvop->vop_error)
+ if (myvop->vop_error)
{
printf (" err:\"%s\"\n", myvop->vop_error);
}
- if (*myvop->vop_warn)
+ if (myvop->vop_warn)
{
printf (" wrn:\"%s\"\n", myvop->vop_warn);
}
}
}
vip_end ();
- exit ();
+ exit (EXIT_SUCCESS);
}
#endif /* #ifdef test */
/* end of vax_ins_parse.c */
- /* JF this used to be a separate file also */
/* vax_reg_parse.c - convert a VAX register name to a number */
-/* Copyright (C) 1987 Free Software Foundation, Inc. A part of GNU. */
+/* Copyright (C) 1987 Free Software Foundation, Inc. A part of GNU. */
/*
* v a x _ r e g _ p a r s e ( )
vax_reg_parse (c1, c2, c3) /* 3 chars of register name */
char c1, c2, c3; /* c3 == 0 if 2-character reg name */
{
- register int retval; /* return -1:15 */
+ int retval; /* return -1:15 */
retval = -1;
* if the other outputs are to be taken seriously.
*/
-
- /* vax registers we need to know */
-/* JF #define SP (14)
-/* JF for one big happy file #define PC (15) */
-
- /* useful ideas */
-/* #define TRUE (1) */
-/* #define FALSE (0) */
-\f
/*
* Because this module is useful for both VMS and UN*X style assemblers
* and because of the variety of UN*X assemblers we must recognise
* 3 concepts that DEC writes '#', '@', '^'.
*/
- /* character tests */
-#define VIP_IMMEDIATE 01 /* Character is like DEC # */
-#define VIP_INDIRECT 02 /* Char is like DEC @ */
-#define VIP_DISPLEN 04 /* Char is like DEC ^ */
+/* character tests */
+#define VIP_IMMEDIATE 01 /* Character is like DEC # */
+#define VIP_INDIRECT 02 /* Char is like DEC @ */
+#define VIP_DISPLEN 04 /* Char is like DEC ^ */
#define IMMEDIATEP(c) (vip_metacharacters [(c)&0xff]&VIP_IMMEDIATE)
#define INDIRECTP(c) (vip_metacharacters [(c)&0xff]&VIP_INDIRECT)
#define S VIP_INDIRECT,
#define D VIP_DISPLEN,
static const char
-vip_metacharacters[256] = {
-_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _/*^@ ^A ^B ^C ^D ^E ^F ^G ^H ^I ^J ^K ^L ^M ^N ^O*/
-_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _/*^P ^Q ^R ^S ^T ^U ^V ^W ^X ^Y ^Z ^[ ^\ ^] ^^ ^_*/
-_ _ _ _ I _ _ _ _ _ S _ _ _ _ _/*sp ! " # $ % & ' ( ) * + , - . /*/
-_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _/*0 1 2 3 4 5 6 7 8 9 : ; < = > ?*/
-_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _/*@ A B C D E F G H I J K L M N O*/
-_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _/*P Q R S T U V W X Y Z [ \ ] ^ _*/
-D _ _ _ _ _ _ _ _ _ _ _ _ _ _ _/*` a b c d e f g h i j k l m n o*/
-_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _/*p q r s t u v w x y z { | } ~ ^?*/
-
-_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
-_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
-_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
-_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
-_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
-_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
-_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
-_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
+vip_metacharacters[256] =
+{
+ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ /* ^@ ^A ^B ^C ^D ^E ^F ^G ^H ^I ^J ^K ^L ^M ^N ^O*/
+ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ /* ^P ^Q ^R ^S ^T ^U ^V ^W ^X ^Y ^Z ^[ ^\ ^] ^^ ^_ */
+ _ _ _ _ I _ _ _ _ _ S _ _ _ _ _ /* sp ! " # $ % & ' ( ) * + , - . / */
+ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ /*0 1 2 3 4 5 6 7 8 9 : ; < = > ?*/
+ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ /*@ A B C D E F G H I J K L M N O*/
+ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ /*P Q R S T U V W X Y Z [ \ ] ^ _*/
+ D _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ /*` a b c d e f g h i j k l m n o*/
+ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ /*p q r s t u v w x y z { | } ~ ^?*/
+
+ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
+ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
+ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
+ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
+ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
+ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
+ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
+ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
};
#undef _
#undef I
#else
static char vip_metacharacters[256];
-/* Macro is faster under GCC; The constant table is faster yet, but only works with ASCII */
-#if 0
-static
-#ifdef __GNUC__
-inline
-#endif
static void
-vip_op_1(bit,syms)
-int bit;
-char *syms;
+vip_op_1 (bit, syms)
+ int bit;
+ const char *syms;
{
unsigned char t;
- while(t= *syms++)
- vip_metacharacters[t]|=bit;
+ while ((t = *syms++) != 0)
+ vip_metacharacters[t] |= bit;
}
-#else
-#define vip_op_1(bit,syms) { \
- unsigned char t; \
- char *table=vip_metacharacters; \
- while(t= *syms++) \
- table[t]|=bit; \
- }
-#endif
-vip_op_defaults (immediate, indirect, displen) /* can be called any time */
- char *immediate, /* Strings of characters for each job. */
- *indirect, *displen; /* more arguments may appear in future! */
+/* Can be called any time. More arguments may appear in future. */
+static void
+vip_op_defaults (immediate, indirect, displen)
+ const char *immediate;
+ const char *indirect;
+ const char *displen;
{
vip_op_1 (VIP_IMMEDIATE, immediate);
vip_op_1 (VIP_INDIRECT, indirect);
vip_op_1 (VIP_DISPLEN, displen);
}
-#endif
+#endif
\f
+
/*
* Dec defines the semantics of address modes (and values)
* by a two-letter code, explained here.
*
* After parsing we have:
*
- * at TRUE if leading '@' (or Un*x '*')
+ * at 1 if leading '@' (or Un*x '*')
* len takes one value from " bilsw". eg B^ -> 'b'.
- * hash TRUE if leading '#' (or Un*x '$')
+ * hash 1 if leading '#' (or Un*x '$')
* expr_begin, expr_end the expression we did not parse
* even though we don't interpret it, we make use
* of its presence or absence.
* sign -1: -(Rn) 0: absent +1: (Rn)+
- * paren TRUE if () are around register
+ * paren 1 if () are around register
* reg major register number 0:15 -1 means absent
* ndx index register number 0:15 -1 means absent
*
* Again, I dare not explain it: just trace ALL the code!
*/
\f
-char * /* (code here) bug message, "" = OK */
- /* our code bug, NOT bad assembly language */
+static void
vip_op (optext, vopP)
- char *optext; /* user's input string e.g.: */
- /* "@B^foo@bar(AP)[FP]:" */
- struct vop *vopP; /* In: vop_access, vop_width. */
- /* Out: _ndx, _reg, _mode, _short, _warn, */
- /* _error _expr_begin, _expr_end, _nbytes. */
- /* vop_nbytes : number of bytes in a datum. */
+ /* user's input string e.g.: "@B^foo@bar(AP)[FP]:" */
+ char *optext;
+ /* Input fields: vop_access, vop_width.
+ Output fields: _ndx, _reg, _mode, _short, _warn,
+ _error _expr_begin, _expr_end, _nbytes.
+ vop_nbytes : number of bytes in a datum. */
+ struct vop *vopP;
{
- char *p; /* track operand text forward */
- char *q; /* track operand text backward */
- int at; /* TRUE if leading '@' ('*') seen */
- char len; /* one of " bilsw" */
- int hash; /* TRUE if leading '#' ('$') seen */
- int sign; /* -1, 0 or +1 */
- int paren; /* TRUE if () surround register */
- int reg; /* register number, -1:absent */
- int ndx; /* index register number -1:absent */
- char *bug; /* report any logic error in here, ""==OK */
- char *err; /* report illegal operand, ""==OK */
+ /* track operand text forward */
+ char *p;
+ /* track operand text backward */
+ char *q;
+ /* 1 if leading '@' ('*') seen */
+ int at;
+ /* one of " bilsw" */
+ char len;
+ /* 1 if leading '#' ('$') seen */
+ int hash;
+ /* -1, 0 or +1 */
+ int sign = 0;
+ /* 1 if () surround register */
+ int paren = 0;
+ /* register number, -1:absent */
+ int reg = 0;
+ /* index register number -1:absent */
+ int ndx = 0;
+ /* report illegal operand, ""==OK */
/* " " is a FAKE error: means we won */
- /* ANY err that begins with ' ' is a fake. */
+ /* ANY err that begins with ' ' is a fake. */
/* " " is converted to "" before return */
- char *wrn; /* warn about weird modes pf address */
- char *oldq; /* preserve q in case we backup */
- int mode; /* build up 4-bit operand mode here */
+ const char *err;
+ /* warn about weird modes pf address */
+ const char *wrn;
+ /* preserve q in case we backup */
+ char *oldq = NULL;
+ /* build up 4-bit operand mode here */
/* note: index mode is in ndx, this is */
/* the major mode of operand address */
-/*
- * Notice how we move wrong-arg-type bugs INSIDE this module: if we
- * get the types wrong below, we lose at compile time rather than at
- * lint or run time.
- */
- char access; /* vop_access. */
- char width; /* vop_width. */
-
- int vax_reg_parse (); /* returns 0:15 or -1 if not a register */
+ int mode = 0;
+ /*
+ * Notice how we move wrong-arg-type bugs INSIDE this module: if we
+ * get the types wrong below, we lose at compile time rather than at
+ * lint or run time.
+ */
+ char access_mode; /* vop_access. */
+ char width; /* vop_width. */
- access = vopP->vop_access;
+ access_mode = vopP->vop_access;
width = vopP->vop_width;
- bug = /* none of our code bugs (yet) */
- err = /* no user text errors */
- wrn = ""; /* no warnings even */
+ /* None of our code bugs (yet), no user text errors, no warnings
+ even. */
+ err = wrn = 0;
p = optext;
- if (*p == ' ') /* Expect all whitespace reduced to ' '. */
+ if (*p == ' ') /* Expect all whitespace reduced to ' '. */
p++; /* skip over whitespace */
- if (at = INDIRECTP (*p))
- { /* TRUE if *p=='@'(or '*' for Un*x) */
+ if ((at = INDIRECTP (*p)) != 0)
+ { /* 1 if *p=='@'(or '*' for Un*x) */
p++; /* at is determined */
- if (*p == ' ') /* Expect all whitespace reduced to ' '. */
+ if (*p == ' ') /* Expect all whitespace reduced to ' '. */
p++; /* skip over whitespace */
}
* this case is rejected as a mismatch against either (letter) or '^'.
*/
{
- register char c;
+ char c;
c = *p;
if (isupper (c))
len = ' '; /* len is determined */
}
- if (*p == ' ') /* Expect all whitespace reduced to ' '. */
+ if (*p == ' ') /* Expect all whitespace reduced to ' '. */
p++; /* skip over whitespace */
- if (hash = IMMEDIATEP (*p)) /* TRUE if *p=='#' ('$' for Un*x) */
+ if ((hash = IMMEDIATEP (*p)) != 0) /* 1 if *p=='#' ('$' for Un*x) */
p++; /* hash is determined */
/*
;
q--; /* now q points at last char of text */
\f
- if (*q == ' ' && q >= p) /* Expect all whitespace reduced to ' '. */
+ if (*q == ' ' && q >= p) /* Expect all whitespace reduced to ' '. */
q--;
/* reverse over whitespace, but don't */
/* run back over *p */
q--;
/* either q<p or we got matching '[' */
if (q < p)
- err = "no '[' to match ']'";
+ err = _("no '[' to match ']'");
else
{
/*
* If luser hasn't given us one: be rude.
*/
if (ndx < 0)
- err = "bad register in []";
+ err = _("bad register in []");
else if (ndx == PC)
- err = "[PC] index banned";
+ err = _("[PC] index banned");
else
q--; /* point q just before "[...]" */
}
* Otherwise, ndx is index register number, and q points before "[...]".
*/
\f
- if (*q == ' ' && q >= p) /* Expect all whitespace reduced to ' '. */
+ if (*q == ' ' && q >= p) /* Expect all whitespace reduced to ' '. */
q--;
/* reverse over whitespace, but don't */
/* run back over *p */
- if (!*err)
+ if (!err || !*err)
{
sign = 0; /* no ()+ or -() seen yet */
if (*q == ')' && q > p + 2)
{
- paren = TRUE; /* assume we have "(...)" */
+ paren = 1; /* assume we have "(...)" */
while (q >= p && *q != '(')
q--;
/* either q<p or we got matching '(' */
if (q < p)
- err = "no '(' to match ')'";
+ err = _("no '(' to match ')'");
else
{
/*
if (reg < 0)
{
/* JF allow parenthasized expressions. I hope this works */
- paren = FALSE;
+ paren = 0;
while (*q != ')')
q++;
/* err = "unknown register in ()"; */
}
/*
* If err == "..." then we lost.
- * Otherwise paren==TRUE and reg = register in "()".
+ * Otherwise paren==1 and reg = register in "()".
*/
}
else
- paren = FALSE;
+ paren = 0;
/*
* If err == "..." then we lost.
* Otherwise, q points just before "(Rn)", if any.
- * If there was a "(...)" then paren==TRUE, and reg is the register.
+ * If there was a "(...)" then paren==1, and reg is the register.
*/
\f
/*
* We should only seek '-' of "-(...)" if:
- * we saw "(...)" paren == TRUE
+ * we saw "(...)" paren == 1
* we have no errors so far ! *err
* we did not see '+' of "(...)+" sign < 1
* We don't check len. We want a specific error message later if
* user tries "x^...-(Rn)". This is a feature not a bug.
*/
- if (!*err)
+ if (!err || !*err)
{
if (paren && sign < 1)/* !sign is adequate test */
{
*/
if (!paren)
{
- if (*q == ' ' && q >= p) /* Expect all whitespace reduced to ' '. */
+ if (*q == ' ' && q >= p) /* Expect all whitespace reduced to ' '. */
q--;
/* reverse over whitespace, but don't */
/* run back over *p */
* err " " or error message, and other outputs trashed
*/
/* branch operands have restricted forms */
- if (!*err && access == 'b')
+ if ((!err || !*err) && access_mode == 'b')
{
if (at || hash || sign || paren || ndx >= 0 || reg >= 0 || len != ' ')
- err = "invalid branch operand";
+ err = _("invalid branch operand");
else
err = " ";
}
\f
-/* Since nobody seems to use it: comment this 'feature'(?) out for now. */
+ /* Since nobody seems to use it: comment this 'feature'(?) out for now. */
#ifdef NEVER
/*
* Case of stand-alone operand. e.g. ".long foo"
* ndx -1
* err " " or error message, and other outputs trashed
*/
- if (!*err)
+ if ((!err || !*err) && access_mode == ' ')
{
- if (access == ' ')
- { /* addresses have restricted forms */
- if (at)
- err = "address prohibits @";
+ if (at)
+ err = _("address prohibits @");
+ else if (hash)
+ err = _("address prohibits #");
+ else if (sign)
+ {
+ if (sign < 0)
+ err = _("address prohibits -()");
else
- {
- if (hash)
- err = "address prohibits #";
- else
- {
- if (sign)
- {
- if (sign < 0)
- err = "address prohibits -()";
- else
- err = "address prohibits ()+";
- }
- else
- {
- if (paren)
- err = "address prohibits ()";
- else
- {
- if (ndx >= 0)
- err = "address prohibits []";
- else
- {
- if (reg >= 0)
- err = "address prohibits register";
- else
- {
- if (len != ' ')
- err = "address prohibits displacement length specifier";
- else
- {
- err = " "; /* succeed */
- mode = 0;
- }
- }
- }
- }
- }
- }
- }
+ err = _("address prohibits ()+");
+ }
+ else if (paren)
+ err = _("address prohibits ()");
+ else if (ndx >= 0)
+ err = _("address prohibits []");
+ else if (reg >= 0)
+ err = _("address prohibits register");
+ else if (len != ' ')
+ err = _("address prohibits displacement length specifier");
+ else
+ {
+ err = " "; /* succeed */
+ mode = 0;
}
}
#endif /*#Ifdef NEVER*/
/*
* Case of S^#.
*
- * in: at FALSE
+ * in: at 0
* len 's' definition
- * hash TRUE demand
+ * hash 1 demand
* p:q demand not empty
- * sign 0 by paren==FALSE
- * paren FALSE by "()" scan logic because "S^" seen
+ * sign 0 by paren==0
+ * paren 0 by "()" scan logic because "S^" seen
* reg -1 or nn by mistake
* ndx -1
*
* exp
* ndx -1
*/
- if (!*err && len == 's')
+ if ((!err || !*err) && len == 's')
{
if (!hash || paren || at || ndx >= 0)
- err = "invalid operand of S^#";
+ err = _("invalid operand of S^#");
else
{
if (reg >= 0)
* We have all the expression we will ever get.
*/
if (p > q)
- err = "S^# needs expression";
- else if (access == 'r')
+ err = _("S^# needs expression");
+ else if (access_mode == 'r')
{
err = " "; /* WIN! */
mode = 0;
}
else
- err = "S^# may only read-access";
+ err = _("S^# may only read-access");
}
}
\f
/*
* Case of -(Rn), which is weird case.
*
- * in: at FALSE
+ * in: at 0
* len '
- * hash FALSE
+ * hash 0
* p:q q<p
* sign -1 by definition
- * paren TRUE by definition
+ * paren 1 by definition
* reg present by definition
* ndx optional
*
* exp "" enforce empty expression
* ndx optional warn if same as reg
*/
- if (!*err && sign < 0)
+ if ((!err || !*err) && sign < 0)
{
if (len != ' ' || hash || at || p <= q)
- err = "invalid operand of -()";
+ err = _("invalid operand of -()");
else
{
err = " "; /* win */
mode = 7;
if (reg == PC)
- wrn = "-(PC) unpredictable";
+ wrn = _("-(PC) unpredictable");
else if (reg == ndx)
- wrn = "[]index same as -()register: unpredictable";
+ wrn = _("[]index same as -()register: unpredictable");
}
}
\f
*/
if (paren && !sign && !hash && !at && len == ' ' && p > q)
{
- at = TRUE;
- paren = FALSE;
+ at = 1;
+ paren = 0;
}
/*
*
* in: at
* len ' '
- * hash FALSE
+ * hash 0
* p:q q<p
* sign +1 by definition
- * paren TRUE by definition
+ * paren 1 by definition
* reg present by definition
* ndx optional
*
* exp "" enforce empty expression
* ndx optional warn if same as reg
*/
- if (!*err && sign > 0)
+ if ((!err || !*err) && sign > 0)
{
if (len != ' ' || hash || p <= q)
- err = "invalid operand of ()+";
+ err = _("invalid operand of ()+");
else
{
err = " "; /* win */
mode = 8 + (at ? 1 : 0);
if (reg == PC)
- wrn = "(PC)+ unpredictable";
+ wrn = _("(PC)+ unpredictable");
else if (reg == ndx)
- wrn = "[]index same as ()+register: unpredictable";
+ wrn = _("[]index same as ()+register: unpredictable");
}
}
\f
*
* in: at
* len ' ' or 'i'
- * hash TRUE by definition
+ * hash 1 by definition
* p:q
* sign 0
- * paren FALSE
+ * paren 0
* reg absent
* ndx optional
*
* exp
* ndx optional
*/
- if (!*err && hash)
+ if ((!err || !*err) && hash)
{
if (len != 'i' && len != ' ')
- err = "# conflicts length";
+ err = _("# conflicts length");
else if (paren)
- err = "# bars register";
+ err = _("# bars register");
else
{
if (reg >= 0)
{
/*
- * SHIT! we saw #Rnn! Put the Rnn back into the expression.
- * By using oldq, we don't need to know how long Rnn was.
- * KLUDGE!
- */
+ * SHIT! we saw #Rnn! Put the Rnn back into the expression.
+ * By using oldq, we don't need to know how long Rnn was.
+ * KLUDGE!
+ */
q = oldq;
reg = -1; /* no register any more */
}
err = " "; /* win */
- /* JF a bugfix, I think! */
- if(at && access=='a')
- vopP->vop_nbytes=4;
+ /* JF a bugfix, I think! */
+ if (at && access_mode == 'a')
+ vopP->vop_nbytes = 4;
mode = (at ? 9 : 8);
reg = PC;
- if ((access == 'm' || access == 'w') && !at)
- wrn = "writing or modifying # is unpredictable";
+ if ((access_mode == 'm' || access_mode == 'w') && !at)
+ wrn = _("writing or modifying # is unpredictable");
}
}
/*
* If !*err, then sign == 0
- * hash == FALSE
+ * hash == 0
*/
\f
/*
*
* in: at optional
* len ' '
- * hash FALSE by program logic
+ * hash 0 by program logic
* p:q empty
* sign 0 by program logic
- * paren FALSE by definition
+ * paren 0 by definition
* reg present by definition
* ndx optional
*
* exp "" enforce empty expression
* ndx optional warn if same as reg
*/
- if (!*err && !paren && reg >= 0)
+ if ((!err || !*err) && !paren && reg >= 0)
{
if (len != ' ')
- err = "length not needed";
+ err = _("length not needed");
else if (at)
{
err = " "; /* win */
mode = 6; /* @Rn */
}
else if (ndx >= 0)
- err = "can't []index a register, because it has no address";
- else if (access == 'a')
- err = "a register has no address";
+ err = _("can't []index a register, because it has no address");
+ else if (access_mode == 'a')
+ err = _("a register has no address");
else
{
/*
- * Idea here is to detect from length of datum
- * and from register number if we will touch PC.
- * Warn if we do.
- * vop_nbytes is number of bytes in operand.
- * Compute highest byte affected, compare to PC0.
- */
+ * Idea here is to detect from length of datum
+ * and from register number if we will touch PC.
+ * Warn if we do.
+ * vop_nbytes is number of bytes in operand.
+ * Compute highest byte affected, compare to PC0.
+ */
if ((vopP->vop_nbytes + reg * 4) > 60)
- wrn = "PC part of operand unpredictable";
+ wrn = _("PC part of operand unpredictable");
err = " "; /* win */
mode = 5; /* Rn */
}
}
/*
* If !*err, sign == 0
- * hash == FALSE
- * paren == TRUE OR reg==-1
+ * hash == 0
+ * paren == 1 OR reg==-1
*/
\f
/*
*
* in: at optional
* len ' ' or 'b' or 'w' or 'l'
- * hash FALSE by program logic
+ * hash 0 by program logic
* p:q expected (empty is not an error)
* sign 0 by program logic
* paren optional
* exp maybe empty
* ndx optional warn if same as reg
*/
- if (!*err)
+ if (!err || !*err)
{
err = " "; /* win (always) */
mode = 10 + (at ? 1 : 0);
*/
if (*err == ' ')
- err = ""; /* " " is no longer an error */
+ err = 0; /* " " is no longer an error */
vopP->vop_mode = mode;
vopP->vop_reg = reg;
vopP->vop_ndx = ndx;
vopP->vop_error = err;
vopP->vop_warn = wrn;
- return (bug);
-
-} /* vip_op() */
+}
\f
/*
-Summary of vip_op outputs.
+ Summary of vip_op outputs.
- mode reg len ndx
-(Rn) => @Rn
-{@}Rn 5+@ n ' ' optional
-branch operand 0 -1 ' ' -1
-S^#foo 0 -1 's' -1
--(Rn) 7 n ' ' optional
-{@}(Rn)+ 8+@ n ' ' optional
-{@}#foo, no S^ 8+@ PC " i" optional
-{@}{q^}{(Rn)} 10+@+q option " bwl" optional
+ mode reg len ndx
+ (Rn) => @Rn
+ {@}Rn 5+@ n ' ' optional
+ branch operand 0 -1 ' ' -1
+ S^#foo 0 -1 's' -1
+ -(Rn) 7 n ' ' optional
+ {@}(Rn)+ 8+@ n ' ' optional
+ {@}#foo, no S^ 8+@ PC " i" optional
+ {@}{q^}{(Rn)} 10+@+q option " bwl" optional
-*/
+ */
\f
-#ifdef TEST /* #Define to use this testbed. */
+#ifdef TEST /* #Define to use this testbed. */
/*
* Follows a test program for this function.
main ()
{
- char *vip_op (); /* make cc happy */
-
printf ("enter immediate symbols eg enter # ");
gets (my_immediate);
printf ("enter indirect symbols eg enter @ ");
fflush (stdout);
gets (answer);
if (!answer[0])
- exit (0);
+ exit (EXIT_SUCCESS);
myaccess = answer[0];
mywidth = answer[1];
switch (mywidth)
const int md_short_jump_size = 3;
const int md_long_jump_size = 6;
-const int md_reloc_size = 8; /* Size of relocation record */
+const int md_reloc_size = 8; /* Size of relocation record */
void
md_create_short_jump (ptr, from_addr, to_addr, frag, to_symbol)
char *ptr;
- long from_addr, to_addr;
+ addressT from_addr, to_addr;
fragS *frag;
symbolS *to_symbol;
{
- long offset;
-
- offset = to_addr - (from_addr + 1);
- *ptr++ = 0x31;
+ valueT offset;
+
+ /* This former calculation was off by two:
+ offset = to_addr - (from_addr + 1);
+ We need to account for the one byte instruction and also its
+ two byte operand. */
+ offset = to_addr - (from_addr + 1 + 2);
+ *ptr++ = VAX_BRW; /* branch with word (16 bit) offset */
md_number_to_chars (ptr, offset, 2);
}
void
md_create_long_jump (ptr, from_addr, to_addr, frag, to_symbol)
char *ptr;
- long from_addr, to_addr;
+ addressT from_addr, to_addr;
fragS *frag;
symbolS *to_symbol;
{
- long offset;
+ valueT offset;
- offset = to_addr - to_symbol->sy_value;
- *ptr++ = 0x17;
- *ptr++ = 0x9F;
+ offset = to_addr - S_GET_VALUE (to_symbol);
+ *ptr++ = VAX_JMP; /* arbitrary jump */
+ *ptr++ = VAX_ABSOLUTE_MODE;
md_number_to_chars (ptr, offset, 4);
- fix_new (frag, ptr - frag->fr_literal, 4, to_symbol, (symbolS *) 0, (long) 0, 0);
+ fix_new (frag, ptr - frag->fr_literal, 4, to_symbol, (long) 0, 0, NO_RELOC);
}
+\f
+#ifdef OBJ_VMS
+CONST char *md_shortopts = "d:STt:V+1h:Hv::";
+#else
+CONST char *md_shortopts = "d:STt:V";
+#endif
+struct option md_longopts[] = {
+ {NULL, no_argument, NULL, 0}
+};
+size_t md_longopts_size = sizeof (md_longopts);
int
-md_parse_option (argP, cntP, vecP)
- char **argP;
- int *cntP;
- char ***vecP;
+md_parse_option (c, arg)
+ int c;
+ char *arg;
{
- char *temp_name; /* name for -t or -d options */
- char opt;
-
- switch (**argP)
+ switch (c)
{
- case 'J':
- /* as_warn ("I can do better than -J!"); */
- break;
-
case 'S':
- as_warn ("SYMBOL TABLE not implemented");
- break; /* SYMBOL TABLE not implemented */
+ as_warn (_("SYMBOL TABLE not implemented"));
+ break;
case 'T':
- as_warn ("TOKEN TRACE not implemented");
- break; /* TOKEN TRACE not implemented */
+ as_warn (_("TOKEN TRACE not implemented"));
+ break;
case 'd':
- case 't':
- opt= **argP;
- if (**argP)
- { /* Rest of argument is filename. */
- temp_name = *argP;
- while (**argP)
- (*argP)++;
- }
- else if (*cntP)
- {
- while (**argP)
- (*argP)++;
- --(*cntP);
- temp_name = *++(*vecP);
- **vecP = NULL; /* Remember this is not a file-name. */
- }
- else
- {
- as_warn ("I expected a filename after -%c.",opt);
- temp_name = "{absent}";
- }
+ as_warn (_("Displacement length %s ignored!"), arg);
+ break;
- if(opt=='d')
- as_warn ("Displacement length %s ignored!", temp_name);
- else
- as_warn ("I don't need or use temp. file \"%s\".", temp_name);
+ case 't':
+ as_warn (_("I don't need or use temp. file \"%s\"."), arg);
break;
case 'V':
- as_warn ("I don't use an interpass file! -V ignored");
+ as_warn (_("I don't use an interpass file! -V ignored"));
+ break;
+
+#ifdef OBJ_VMS
+ case '+': /* For g++. Hash any name > 31 chars long. */
+ flag_hash_long_names = 1;
break;
-#ifdef VMS
- case '+': /* For g++ */
+ case '1': /* For backward compatibility */
+ flag_one = 1;
break;
- case 'h': /* No hashing of mixed-case names */
+ case 'H': /* Show new symbol after hash truncation */
+ flag_show_after_trunc = 1;
break;
- case 'H': /* Show new symbol after hash truncation */
+ case 'h': /* No hashing of mixed-case names */
+ {
+ extern char vms_name_mapping;
+ vms_name_mapping = atoi (arg);
+ flag_no_hash_mixed_case = 1;
+ }
+ break;
+
+ case 'v':
+ {
+ extern char *compiler_version_string;
+ if (!arg || !*arg || access (arg, 0) == 0)
+ return 0; /* have caller show the assembler version */
+ compiler_version_string = arg;
+ }
break;
#endif
default:
return 0;
-
}
+
return 1;
}
+void
+md_show_usage (stream)
+ FILE *stream;
+{
+ fprintf (stream, _("\
+VAX options:\n\
+-d LENGTH ignored\n\
+-J ignored\n\
+-S ignored\n\
+-t FILE ignored\n\
+-T ignored\n\
+-V ignored\n"));
+#ifdef OBJ_VMS
+ fprintf (stream, _("\
+VMS options:\n\
+-+ hash encode names longer than 31 characters\n\
+-1 `const' handling compatible with gcc 1.x\n\
+-H show new symbol after hash truncation\n\
+-h NUM don't hash mixed-case names, and adjust case:\n\
+ 0 = upper, 2 = lower, 3 = preserve case\n\
+-v\"VERSION\" code being assembled was produced by compiler \"VERSION\"\n"));
+#endif
+}
+\f
/* We have no need to default values of symbols. */
/* ARGSUSED */
return 0;
}
-/* Parse an operand that is machine-specific.
- We just return without modifying the expression if we have nothing
- to do. */
-
-/* ARGSUSED */
-void
-md_operand (expressionP)
- expressionS *expressionP;
-{
-}
-
/* Round up a section size to the appropriate boundary. */
-long
+valueT
md_section_align (segment, size)
segT segment;
- long size;
+ valueT size;
{
- return size; /* Byte alignment is fine */
+ return size; /* Byte alignment is fine */
}
/* Exactly what point is a PC-relative offset relative TO?
{
return fixP->fx_size + fixP->fx_where + fixP->fx_frag->fr_address;
}
+
+/* end of tc-vax.c */
projects / deliverable / binutils-gdb.git / blobdiff