/* tc-alpha.c - Processor-specific code for the DEC Alpha AXP CPU.
- Copyright (C) 1989, 93-98, 1999 Free Software Foundation, Inc.
+ Copyright (C) 1989, 93-98, 1999, 2000, 2001 Free Software Foundation, Inc.
Contributed by Carnegie Mellon University, 1993.
Written by Alessandro Forin, based on earlier gas-1.38 target CPU files.
Modified by Ken Raeburn for gas-2.x and ECOFF support.
#include "as.h"
#include "subsegs.h"
+#include "struc-symbol.h"
#include "ecoff.h"
#include "opcode/alpha.h"
#ifdef OBJ_ELF
#include "elf/alpha.h"
+#include "dwarf2dbg.h"
#endif
#include <ctype.h>
\f
/* Local types */
+#define TOKENIZE_ERROR -1
+#define TOKENIZE_ERROR_REPORT -2
+
#define MAX_INSN_FIXUPS 2
#define MAX_INSN_ARGS 5
unsigned insn;
int nfixups;
struct alpha_fixup fixups[MAX_INSN_FIXUPS];
+ unsigned sequence[MAX_INSN_FIXUPS];
};
enum alpha_macro_arg
{
- MACRO_EOA = 1, MACRO_IR, MACRO_PIR, MACRO_CPIR, MACRO_FPR, MACRO_EXP
+ MACRO_EOA = 1,
+ MACRO_IR,
+ MACRO_PIR,
+ MACRO_OPIR,
+ MACRO_CPIR,
+ MACRO_FPR,
+ MACRO_EXP,
+ MACRO_LITERAL,
+ MACRO_BASE,
+ MACRO_BYTOFF,
+ MACRO_JSR
};
struct alpha_macro
enum alpha_macro_arg argsets[16];
};
-/* Two extra symbols we want to see in our input. This is a blatent
- misuse of the expressionS.X_op field. */
+/* Extra expression types. */
+
+#define O_pregister O_md1 /* O_register, in parentheses */
+#define O_cpregister O_md2 /* + a leading comma */
-#define O_pregister ((operatorT) (O_max+1)) /* O_register, in parentheses */
-#define O_cpregister ((operatorT) (O_pregister+1)) /* + a leading comma */
-#define O_alpha_max ((operatorT) (O_cpregister+1))
+#ifdef RELOC_OP_P
+/* Note, the alpha_reloc_op table below depends on the ordering
+ of O_literal .. O_gprelow. */
+#define O_literal O_md3 /* !literal relocation */
+#define O_lituse_base O_md4 /* !lituse_base relocation */
+#define O_lituse_bytoff O_md5 /* !lituse_bytoff relocation */
+#define O_lituse_jsr O_md6 /* !lituse_jsr relocation */
+#define O_gpdisp O_md7 /* !gpdisp relocation */
+#define O_gprelhigh O_md8 /* !gprelhigh relocation */
+#define O_gprellow O_md9 /* !gprellow relocation */
+
+#define USER_RELOC_P(R) ((R) >= O_literal && (R) <= O_gprellow)
+#endif
/* Macros for extracting the type and number of encoded register tokens */
#if 1
#define range_signed_16(x) \
- (((offsetT)(x) >> 15) == 0 || ((offsetT)(x) >> 15) == -1)
+ (((offsetT) (x) >> 15) == 0 || ((offsetT) (x) >> 15) == -1)
#define range_signed_32(x) \
- (((offsetT)(x) >> 31) == 0 || ((offsetT)(x) >> 31) == -1)
+ (((offsetT) (x) >> 31) == 0 || ((offsetT) (x) >> 31) == -1)
#else
-#define range_signed_16(x) ((offsetT)(x) >= -(offsetT)0x8000 && \
- (offsetT)(x) <= (offsetT)0x7FFF)
-#define range_signed_32(x) ((offsetT)(x) >= -(offsetT)0x80000000 && \
- (offsetT)(x) <= (offsetT)0x7FFFFFFF)
+#define range_signed_16(x) ((offsetT) (x) >= -(offsetT)0x8000 && \
+ (offsetT) (x) <= (offsetT)0x7FFF)
+#define range_signed_32(x) ((offsetT) (x) >= -(offsetT)0x80000000 && \
+ (offsetT) (x) <= (offsetT)0x7FFFFFFF)
#endif
/* Macros for sign extending from 16- and 32-bits. */
but really a predicate should be found to use the non-cast forms. */
#if 1
-#define sign_extend_16(x) ((short)(x))
-#define sign_extend_32(x) ((int)(x))
+#define sign_extend_16(x) ((short) (x))
+#define sign_extend_32(x) ((int) (x))
#else
-#define sign_extend_16(x) ((offsetT)(((x) & 0xFFFF) ^ 0x8000) - 0x8000)
-#define sign_extend_32(x) ((offsetT)(((x) & 0xFFFFFFFF) \
+#define sign_extend_16(x) ((offsetT) (((x) & 0xFFFF) ^ 0x8000) - 0x8000)
+#define sign_extend_32(x) ((offsetT) (((x) & 0xFFFFFFFF) \
^ 0x80000000) - 0x80000000)
#endif
/* Macros to build tokens */
-#define set_tok_reg(t, r) (memset(&(t), 0, sizeof(t)), \
+#define set_tok_reg(t, r) (memset(&(t), 0, sizeof (t)), \
(t).X_op = O_register, \
(t).X_add_number = (r))
-#define set_tok_preg(t, r) (memset(&(t), 0, sizeof(t)), \
+#define set_tok_preg(t, r) (memset(&(t), 0, sizeof (t)), \
(t).X_op = O_pregister, \
(t).X_add_number = (r))
-#define set_tok_cpreg(t, r) (memset(&(t), 0, sizeof(t)), \
+#define set_tok_cpreg(t, r) (memset(&(t), 0, sizeof (t)), \
(t).X_op = O_cpregister, \
(t).X_add_number = (r))
-#define set_tok_freg(t, r) (memset(&(t), 0, sizeof(t)), \
+#define set_tok_freg(t, r) (memset(&(t), 0, sizeof (t)), \
(t).X_op = O_register, \
(t).X_add_number = (r)+32)
-#define set_tok_sym(t, s, a) (memset(&(t), 0, sizeof(t)), \
+#define set_tok_sym(t, s, a) (memset(&(t), 0, sizeof (t)), \
(t).X_op = O_symbol, \
(t).X_add_symbol = (s), \
(t).X_add_number = (a))
-#define set_tok_const(t, n) (memset(&(t), 0, sizeof(t)), \
+#define set_tok_const(t, n) (memset(&(t), 0, sizeof (t)), \
(t).X_op = O_constant, \
(t).X_add_number = (n))
PARAMS ((const char *, const expressionS *, int, int));
static int load_expression
- PARAMS ((int, const expressionS *, int *, expressionS *));
+ PARAMS ((int, const expressionS *, int *, expressionS *,
+ const expressionS *));
static void emit_ldgp PARAMS ((const expressionS *, int, const PTR));
static void emit_division PARAMS ((const expressionS *, int, const PTR));
static void s_alpha_mask PARAMS ((int));
static void s_alpha_frame PARAMS ((int));
static void s_alpha_prologue PARAMS ((int));
+static void s_alpha_file PARAMS ((int));
+static void s_alpha_loc PARAMS ((int));
+static void s_alpha_stab PARAMS ((int));
static void s_alpha_coff_wrapper PARAMS ((int));
#endif
#ifdef OBJ_EVAX
#endif
static void alpha_align PARAMS ((int, char *, symbolS *, int));
+#ifdef RELOC_OP_P
+static void alpha_adjust_symtab_relocs PARAMS ((bfd *, asection *, PTR));
+#endif
+
\f
/* Generic assembler global variables which must be defined by all
targets. */
{ NULL, no_argument, NULL, 0 }
};
-size_t md_longopts_size = sizeof(md_longopts);
+size_t md_longopts_size = sizeof (md_longopts);
\f
#ifdef OBJ_EVAX
#endif
static segT alpha_lit8_section;
-/* Symbols referring to said sections. */
+/* Symbols referring to said sections. */
#ifdef OBJ_ECOFF
static symbolS *alpha_lita_symbol;
static symbolS *alpha_lit4_symbol;
static offsetT alpha_lit8_literal;
#endif
-/* The active .ent symbol. */
#ifdef OBJ_ELF
+/* The active .ent symbol. */
static symbolS *alpha_cur_ent_sym;
#endif
#ifdef OBJ_ELF
/* Whether we are emitting an mdebug section. */
-int alpha_flag_mdebug = 1;
+int alpha_flag_mdebug = -1;
#endif
/* Don't fully resolve relocations, allowing code movement in the linker. */
* longer than 64 characters, else longer symbol names are truncated.
*/
+#endif
+\f
+#ifdef RELOC_OP_P
+/* A table to map the spelling of a relocation operand into an appropriate
+ bfd_reloc_code_real_type type. The table is assumed to be ordered such
+ that op-O_literal indexes into it. */
+
+#define ALPHA_RELOC_TABLE(op) \
+&alpha_reloc_op[ ((!USER_RELOC_P (op)) \
+ ? (abort (), 0) \
+ : (int) (op) - (int)O_literal) ]
+
+#define LITUSE_BASE 1
+#define LITUSE_BYTOFF 2
+#define LITUSE_JSR 3
+
+static const struct alpha_reloc_op_tag {
+ const char *name; /* string to lookup */
+ size_t length; /* size of the string */
+ bfd_reloc_code_real_type reloc; /* relocation before frob */
+ operatorT op; /* which operator to use */
+ int lituse; /* addened to specify lituse */
+} alpha_reloc_op[] = {
+
+ {
+ "literal", /* name */
+ sizeof ("literal")-1, /* length */
+ BFD_RELOC_ALPHA_USER_LITERAL, /* reloc */
+ O_literal, /* op */
+ 0, /* lituse */
+ },
+
+ {
+ "lituse_base", /* name */
+ sizeof ("lituse_base")-1, /* length */
+ BFD_RELOC_ALPHA_USER_LITUSE_BASE, /* reloc */
+ O_lituse_base, /* op */
+ LITUSE_BASE, /* lituse */
+ },
+
+ {
+ "lituse_bytoff", /* name */
+ sizeof ("lituse_bytoff")-1, /* length */
+ BFD_RELOC_ALPHA_USER_LITUSE_BYTOFF, /* reloc */
+ O_lituse_bytoff, /* op */
+ LITUSE_BYTOFF, /* lituse */
+ },
+
+ {
+ "lituse_jsr", /* name */
+ sizeof ("lituse_jsr")-1, /* length */
+ BFD_RELOC_ALPHA_USER_LITUSE_JSR, /* reloc */
+ O_lituse_jsr, /* op */
+ LITUSE_JSR, /* lituse */
+ },
+
+ {
+ "gpdisp", /* name */
+ sizeof ("gpdisp")-1, /* length */
+ BFD_RELOC_ALPHA_USER_GPDISP, /* reloc */
+ O_gpdisp, /* op */
+ 0, /* lituse */
+ },
+
+ {
+ "gprelhigh", /* name */
+ sizeof ("gprelhigh")-1, /* length */
+ BFD_RELOC_ALPHA_USER_GPRELHIGH, /* reloc */
+ O_gprelhigh, /* op */
+ 0, /* lituse */
+ },
+
+ {
+ "gprellow", /* name */
+ sizeof ("gprellow")-1, /* length */
+ BFD_RELOC_ALPHA_USER_GPRELLOW, /* reloc */
+ O_gprellow, /* op */
+ 0, /* lituse */
+ },
+};
+
+static const int alpha_num_reloc_op
+ = sizeof (alpha_reloc_op) / sizeof (*alpha_reloc_op);
+
+/* Maximum # digits needed to hold the largest sequence # */
+#define ALPHA_RELOC_DIGITS 25
+
+/* Whether a sequence number is valid. */
+#define ALPHA_RELOC_SEQUENCE_OK(X) ((X) > 0 && ((unsigned) (X)) == (X))
+
+/* Structure to hold explict sequence information. */
+struct alpha_literal_tag
+{
+ fixS *lituse; /* head of linked list of !literals */
+ segT segment; /* segment relocs are in or undefined_section*/
+ int multi_section_p; /* True if more than one section was used */
+ unsigned sequence; /* sequence # */
+ unsigned n_literals; /* # of literals */
+ unsigned n_lituses; /* # of lituses */
+ char string[1]; /* printable form of sequence to hash with */
+};
+
+/* Hash table to link up literals with the appropriate lituse */
+static struct hash_control *alpha_literal_hash;
#endif
\f
/* A table of CPU names and opcode sets. */
} cpu_types[] =
{
/* Ad hoc convention: cpu number gets palcode, process code doesn't.
- This supports usage under DU 4.0b that does ".arch ev4", and
+ This supports usage under DU 4.0b that does ".arch ev4", and
usage in MILO that does -m21064. Probably something more
specific like -m21064-pal should be used, but oh well. */
{ "ev6", AXP_OPCODE_BASE|AXP_OPCODE_BWX|AXP_OPCODE_MAX|AXP_OPCODE_CIX },
{ "all", AXP_OPCODE_BASE },
- { 0 }
+ { 0, 0 }
};
/* The macro table */
static const struct alpha_macro alpha_macros[] = {
/* Load/Store macros */
{ "lda", emit_lda, NULL,
- { MACRO_IR, MACRO_EXP, MACRO_PIR, MACRO_EOA,
- MACRO_IR, MACRO_EXP, MACRO_EOA } },
+ { MACRO_IR, MACRO_EXP, MACRO_OPIR, MACRO_LITERAL, MACRO_BASE, MACRO_EOA } },
{ "ldah", emit_ldah, NULL,
{ MACRO_IR, MACRO_EXP, MACRO_EOA } },
{ "ldl", emit_ir_load, "ldl",
- { MACRO_IR, MACRO_EXP, MACRO_PIR, MACRO_EOA,
- MACRO_IR, MACRO_EXP, MACRO_EOA } },
+ { MACRO_IR, MACRO_EXP, MACRO_OPIR, MACRO_BASE, MACRO_EOA } },
{ "ldl_l", emit_ir_load, "ldl_l",
- { MACRO_IR, MACRO_EXP, MACRO_PIR, MACRO_EOA,
- MACRO_IR, MACRO_EXP, MACRO_EOA } },
+ { MACRO_IR, MACRO_EXP, MACRO_OPIR, MACRO_BASE, MACRO_EOA } },
{ "ldq", emit_ir_load, "ldq",
- { MACRO_IR, MACRO_EXP, MACRO_PIR, MACRO_EOA,
- MACRO_IR, MACRO_EXP, MACRO_EOA } },
+ { MACRO_IR, MACRO_EXP, MACRO_OPIR, MACRO_BASE, MACRO_LITERAL, MACRO_EOA } },
{ "ldq_l", emit_ir_load, "ldq_l",
- { MACRO_IR, MACRO_EXP, MACRO_PIR, MACRO_EOA,
- MACRO_IR, MACRO_EXP, MACRO_EOA } },
+ { MACRO_IR, MACRO_EXP, MACRO_OPIR, MACRO_BASE, MACRO_EOA } },
{ "ldq_u", emit_ir_load, "ldq_u",
- { MACRO_IR, MACRO_EXP, MACRO_PIR, MACRO_EOA,
- MACRO_IR, MACRO_EXP, MACRO_EOA } },
+ { MACRO_IR, MACRO_EXP, MACRO_OPIR, MACRO_BASE, MACRO_EOA } },
{ "ldf", emit_loadstore, "ldf",
- { MACRO_FPR, MACRO_EXP, MACRO_PIR, MACRO_EOA,
- MACRO_FPR, MACRO_EXP, MACRO_EOA } },
+ { MACRO_FPR, MACRO_EXP, MACRO_OPIR, MACRO_BASE, MACRO_EOA } },
{ "ldg", emit_loadstore, "ldg",
- { MACRO_FPR, MACRO_EXP, MACRO_PIR, MACRO_EOA,
- MACRO_FPR, MACRO_EXP, MACRO_EOA } },
+ { MACRO_FPR, MACRO_EXP, MACRO_OPIR, MACRO_BASE, MACRO_EOA } },
{ "lds", emit_loadstore, "lds",
- { MACRO_FPR, MACRO_EXP, MACRO_PIR, MACRO_EOA,
- MACRO_FPR, MACRO_EXP, MACRO_EOA } },
+ { MACRO_FPR, MACRO_EXP, MACRO_OPIR, MACRO_BASE, MACRO_EOA } },
{ "ldt", emit_loadstore, "ldt",
- { MACRO_FPR, MACRO_EXP, MACRO_PIR, MACRO_EOA,
- MACRO_FPR, MACRO_EXP, MACRO_EOA } },
+ { MACRO_FPR, MACRO_EXP, MACRO_OPIR, MACRO_BASE, MACRO_EOA } },
{ "ldb", emit_ldX, (PTR)0,
- { MACRO_IR, MACRO_EXP, MACRO_PIR, MACRO_EOA,
- MACRO_IR, MACRO_EXP, MACRO_EOA } },
+ { MACRO_IR, MACRO_EXP, MACRO_OPIR, MACRO_BASE, MACRO_EOA } },
{ "ldbu", emit_ldXu, (PTR)0,
- { MACRO_IR, MACRO_EXP, MACRO_PIR, MACRO_EOA,
- MACRO_IR, MACRO_EXP, MACRO_EOA } },
+ { MACRO_IR, MACRO_EXP, MACRO_OPIR, MACRO_BASE, MACRO_EOA } },
{ "ldw", emit_ldX, (PTR)1,
- { MACRO_IR, MACRO_EXP, MACRO_PIR, MACRO_EOA,
- MACRO_IR, MACRO_EXP, MACRO_EOA } },
+ { MACRO_IR, MACRO_EXP, MACRO_OPIR, MACRO_BASE, MACRO_EOA } },
{ "ldwu", emit_ldXu, (PTR)1,
- { MACRO_IR, MACRO_EXP, MACRO_PIR, MACRO_EOA,
- MACRO_IR, MACRO_EXP, MACRO_EOA } },
+ { MACRO_IR, MACRO_EXP, MACRO_OPIR, MACRO_BASE, MACRO_EOA } },
{ "uldw", emit_uldX, (PTR)1,
- { MACRO_IR, MACRO_EXP, MACRO_PIR, MACRO_EOA,
- MACRO_IR, MACRO_EXP, MACRO_EOA } },
+ { MACRO_IR, MACRO_EXP, MACRO_OPIR, MACRO_BASE, MACRO_EOA } },
{ "uldwu", emit_uldXu, (PTR)1,
- { MACRO_IR, MACRO_EXP, MACRO_PIR, MACRO_EOA,
- MACRO_IR, MACRO_EXP, MACRO_EOA } },
+ { MACRO_IR, MACRO_EXP, MACRO_OPIR, MACRO_BASE, MACRO_EOA } },
{ "uldl", emit_uldX, (PTR)2,
- { MACRO_IR, MACRO_EXP, MACRO_PIR, MACRO_EOA,
- MACRO_IR, MACRO_EXP, MACRO_EOA } },
+ { MACRO_IR, MACRO_EXP, MACRO_OPIR, MACRO_BASE, MACRO_EOA } },
{ "uldlu", emit_uldXu, (PTR)2,
- { MACRO_IR, MACRO_EXP, MACRO_PIR, MACRO_EOA,
- MACRO_IR, MACRO_EXP, MACRO_EOA } },
+ { MACRO_IR, MACRO_EXP, MACRO_OPIR, MACRO_BASE, MACRO_EOA } },
{ "uldq", emit_uldXu, (PTR)3,
- { MACRO_IR, MACRO_EXP, MACRO_PIR, MACRO_EOA,
- MACRO_IR, MACRO_EXP, MACRO_EOA } },
+ { MACRO_IR, MACRO_EXP, MACRO_OPIR, MACRO_BASE, MACRO_EOA } },
{ "ldgp", emit_ldgp, NULL,
{ MACRO_IR, MACRO_EXP, MACRO_PIR, MACRO_EOA } },
#endif
{ "stl", emit_loadstore, "stl",
- { MACRO_IR, MACRO_EXP, MACRO_PIR, MACRO_EOA,
- MACRO_IR, MACRO_EXP, MACRO_EOA } },
+ { MACRO_IR, MACRO_EXP, MACRO_OPIR, MACRO_BASE, MACRO_EOA } },
{ "stl_c", emit_loadstore, "stl_c",
- { MACRO_IR, MACRO_EXP, MACRO_PIR, MACRO_EOA,
- MACRO_IR, MACRO_EXP, MACRO_EOA } },
+ { MACRO_IR, MACRO_EXP, MACRO_OPIR, MACRO_BASE, MACRO_EOA } },
{ "stq", emit_loadstore, "stq",
- { MACRO_IR, MACRO_EXP, MACRO_PIR, MACRO_EOA,
- MACRO_IR, MACRO_EXP, MACRO_EOA } },
+ { MACRO_IR, MACRO_EXP, MACRO_OPIR, MACRO_BASE, MACRO_EOA } },
{ "stq_c", emit_loadstore, "stq_c",
- { MACRO_IR, MACRO_EXP, MACRO_PIR, MACRO_EOA,
- MACRO_IR, MACRO_EXP, MACRO_EOA } },
+ { MACRO_IR, MACRO_EXP, MACRO_OPIR, MACRO_BASE, MACRO_EOA } },
{ "stq_u", emit_loadstore, "stq_u",
- { MACRO_IR, MACRO_EXP, MACRO_PIR, MACRO_EOA,
- MACRO_IR, MACRO_EXP, MACRO_EOA } },
+ { MACRO_IR, MACRO_EXP, MACRO_OPIR, MACRO_BASE, MACRO_EOA } },
{ "stf", emit_loadstore, "stf",
- { MACRO_FPR, MACRO_EXP, MACRO_PIR, MACRO_EOA,
- MACRO_FPR, MACRO_EXP, MACRO_EOA } },
+ { MACRO_FPR, MACRO_EXP, MACRO_OPIR, MACRO_BASE, MACRO_EOA } },
{ "stg", emit_loadstore, "stg",
- { MACRO_FPR, MACRO_EXP, MACRO_PIR, MACRO_EOA,
- MACRO_FPR, MACRO_EXP, MACRO_EOA } },
+ { MACRO_FPR, MACRO_EXP, MACRO_OPIR, MACRO_BASE, MACRO_EOA } },
{ "sts", emit_loadstore, "sts",
- { MACRO_FPR, MACRO_EXP, MACRO_PIR, MACRO_EOA,
- MACRO_FPR, MACRO_EXP, MACRO_EOA } },
+ { MACRO_FPR, MACRO_EXP, MACRO_OPIR, MACRO_BASE, MACRO_EOA } },
{ "stt", emit_loadstore, "stt",
- { MACRO_FPR, MACRO_EXP, MACRO_PIR, MACRO_EOA,
- MACRO_FPR, MACRO_EXP, MACRO_EOA } },
+ { MACRO_FPR, MACRO_EXP, MACRO_OPIR, MACRO_BASE, MACRO_EOA } },
{ "stb", emit_stX, (PTR)0,
- { MACRO_IR, MACRO_EXP, MACRO_PIR, MACRO_EOA,
- MACRO_IR, MACRO_EXP, MACRO_EOA } },
+ { MACRO_IR, MACRO_EXP, MACRO_OPIR, MACRO_BASE, MACRO_EOA } },
{ "stw", emit_stX, (PTR)1,
- { MACRO_IR, MACRO_EXP, MACRO_PIR, MACRO_EOA,
- MACRO_IR, MACRO_EXP, MACRO_EOA } },
+ { MACRO_IR, MACRO_EXP, MACRO_OPIR, MACRO_BASE, MACRO_EOA } },
{ "ustw", emit_ustX, (PTR)1,
- { MACRO_IR, MACRO_EXP, MACRO_PIR, MACRO_EOA,
- MACRO_IR, MACRO_EXP, MACRO_EOA } },
+ { MACRO_IR, MACRO_EXP, MACRO_OPIR, MACRO_BASE, MACRO_EOA } },
{ "ustl", emit_ustX, (PTR)2,
- { MACRO_IR, MACRO_EXP, MACRO_PIR, MACRO_EOA,
- MACRO_IR, MACRO_EXP, MACRO_EOA } },
+ { MACRO_IR, MACRO_EXP, MACRO_OPIR, MACRO_BASE, MACRO_EOA } },
{ "ustq", emit_ustX, (PTR)3,
- { MACRO_IR, MACRO_EXP, MACRO_PIR, MACRO_EOA,
- MACRO_IR, MACRO_EXP, MACRO_EOA } },
+ { MACRO_IR, MACRO_EXP, MACRO_OPIR, MACRO_BASE, MACRO_EOA } },
/* Arithmetic macros */
#if 0
MACRO_IR, MACRO_EXP, MACRO_EOA */ } },
{ "jsr", emit_jsrjmp, "jsr",
- { MACRO_PIR, MACRO_EXP, MACRO_EOA,
- MACRO_PIR, MACRO_EOA,
- MACRO_IR, MACRO_EXP, MACRO_EOA,
- MACRO_EXP, MACRO_EOA } },
+ { MACRO_PIR, MACRO_EXP, MACRO_JSR, MACRO_EOA,
+ MACRO_PIR, MACRO_JSR, MACRO_EOA,
+ MACRO_IR, MACRO_EXP, MACRO_JSR, MACRO_EOA,
+ MACRO_EXP, MACRO_JSR, MACRO_EOA } },
{ "jmp", emit_jsrjmp, "jmp",
- { MACRO_PIR, MACRO_EXP, MACRO_EOA,
- MACRO_PIR, MACRO_EOA,
- MACRO_IR, MACRO_EXP, MACRO_EOA,
- MACRO_EXP, MACRO_EOA } },
+ { MACRO_PIR, MACRO_EXP, MACRO_JSR, MACRO_EOA,
+ MACRO_PIR, MACRO_JSR, MACRO_EOA,
+ MACRO_IR, MACRO_EXP, MACRO_JSR, MACRO_EOA,
+ MACRO_EXP, MACRO_JSR, MACRO_EOA } },
{ "ret", emit_retjcr, "ret",
{ MACRO_IR, MACRO_EXP, MACRO_EOA,
MACRO_IR, MACRO_EOA,
MACRO_EOA } },
};
-static const int alpha_num_macros
- = sizeof(alpha_macros) / sizeof(*alpha_macros);
+static const unsigned int alpha_num_macros
+ = sizeof (alpha_macros) / sizeof (*alpha_macros);
\f
/* Public interface functions */
/* Verify that X_op field is wide enough. */
{
expressionS e;
- e.X_op = O_alpha_max;
- assert (e.X_op == O_alpha_max);
+ e.X_op = O_max;
+ assert (e.X_op == O_max);
}
/* Create the opcode hash table */
for (i = 0; i < 32; ++i)
{
char name[4];
- sprintf(name, "$%d", i);
+ sprintf (name, "$%d", i);
alpha_register_table[i] = symbol_create(name, reg_section, i,
&zero_address_frag);
}
for (; i < 64; ++i)
{
char name[5];
- sprintf(name, "$f%d", i-32);
+ sprintf (name, "$f%d", i-32);
alpha_register_table[i] = symbol_create(name, reg_section, i,
&zero_address_frag);
}
#endif /* OBJ_ELF */
subseg_set(text_section, 0);
+
+#ifdef RELOC_OP_P
+ /* Create literal lookup hash table. */
+ alpha_literal_hash = hash_new();
+#endif
}
/* The public interface to the instruction assembler. */
{
char opname[32]; /* current maximum is 13 */
expressionS tok[MAX_INSN_ARGS];
- int ntok, opnamelen, trunclen;
+ int ntok, trunclen;
+ size_t opnamelen;
/* split off the opcode */
- opnamelen = strspn (str, "abcdefghijklmnopqrstuvwxyz_/468");
+ opnamelen = strspn (str, "abcdefghijklmnopqrstuvwxyz_/46819");
trunclen = (opnamelen < sizeof (opname) - 1
? opnamelen
: sizeof (opname) - 1);
/* tokenize the rest of the line */
if ((ntok = tokenize_arguments (str + opnamelen, tok, MAX_INSN_ARGS)) < 0)
{
- as_bad (_("syntax error"));
+ if (ntok != TOKENIZE_ERROR_REPORT)
+ as_bad (_("syntax error"));
+
return;
}
}
/* Turn a string in input_line_pointer into a floating point constant
- of type type, and store the appropriate bytes in *litP. The number
- of LITTLENUMS emitted is stored in *sizeP. An error message is
+ of type TYPE, and store the appropriate bytes in *LITP. The number
+ of LITTLENUMS emitted is stored in *SIZEP. An error message is
returned, or NULL on OK. */
/* Equal to MAX_PRECISION in atof-ieee.c */
break;
#ifdef OBJ_EVAX
- case '+': /* For g++. Hash any name > 63 chars long. */
+ case '+': /* For g++. Hash any name > 63 chars long. */
alpha_flag_hash_long_names = 1;
break;
return 1;
#endif
+#ifdef RELOC_OP_P
+ case BFD_RELOC_ALPHA_USER_LITERAL:
+ case BFD_RELOC_ALPHA_USER_LITUSE_BASE:
+ case BFD_RELOC_ALPHA_USER_LITUSE_BYTOFF:
+ case BFD_RELOC_ALPHA_USER_LITUSE_JSR:
+ return 1;
+
+ case BFD_RELOC_ALPHA_USER_GPDISP:
+ case BFD_RELOC_ALPHA_USER_GPRELHIGH:
+ case BFD_RELOC_ALPHA_USER_GPRELLOW:
+ abort ();
+#endif
+
+ case BFD_RELOC_VTABLE_INHERIT:
+ case BFD_RELOC_VTABLE_ENTRY:
+ return 1;
+
default:
{
const struct alpha_operand *operand;
as_fatal (_("unhandled relocation type %s"),
bfd_get_reloc_code_name (fixP->fx_r_type));
- assert (-(int)fixP->fx_r_type < alpha_num_operands);
+ assert (-(int)fixP->fx_r_type < (int)alpha_num_operands);
operand = &alpha_operands[-(int)fixP->fx_r_type];
/* The rest of these fixups only exist internally during symbol
else
break;
- if (!alpha_noat_on && num == AXP_REG_AT)
+ if (!alpha_noat_on && (num + is_float) == AXP_REG_AT)
as_warn(_("Used $at without \".set noat\""));
return alpha_register_table[num + is_float];
case BFD_RELOC_ALPHA_LINKAGE:
case BFD_RELOC_ALPHA_CODEADDR:
#endif
+#ifdef RELOC_OP_P
+ case BFD_RELOC_ALPHA_USER_LITERAL:
+ case BFD_RELOC_ALPHA_USER_LITUSE_BASE:
+ case BFD_RELOC_ALPHA_USER_LITUSE_BYTOFF:
+ case BFD_RELOC_ALPHA_USER_LITUSE_JSR:
+ case BFD_RELOC_ALPHA_USER_GPDISP:
+ case BFD_RELOC_ALPHA_USER_GPRELHIGH:
+ case BFD_RELOC_ALPHA_USER_GPRELLOW:
+#endif
+ case BFD_RELOC_VTABLE_INHERIT:
+ case BFD_RELOC_VTABLE_ENTRY:
return 1;
case BFD_RELOC_23_PCREL_S2:
return 0;
default:
- assert((int)f->fx_r_type < 0 && -(int)f->fx_r_type < alpha_num_operands);
+ assert((int)f->fx_r_type < 0 && -(int)f->fx_r_type < (int)alpha_num_operands);
return 0;
}
}
#ifdef OBJ_ELF
case BFD_RELOC_ALPHA_ELF_LITERAL:
#endif
+#ifdef RELOC_OP_P
+ case BFD_RELOC_ALPHA_USER_LITERAL:
+#endif
#ifdef OBJ_EVAX
case BFD_RELOC_ALPHA_LINKAGE:
case BFD_RELOC_ALPHA_CODEADDR:
return 1;
case BFD_RELOC_ALPHA_LITUSE:
+#ifdef RELOC_OP_P
+ case BFD_RELOC_ALPHA_USER_LITUSE_BASE:
+ case BFD_RELOC_ALPHA_USER_LITUSE_BYTOFF:
+ case BFD_RELOC_ALPHA_USER_LITUSE_JSR:
+ case BFD_RELOC_ALPHA_USER_GPDISP:
+ case BFD_RELOC_ALPHA_USER_GPRELHIGH:
+ case BFD_RELOC_ALPHA_USER_GPRELLOW:
+#endif
+ case BFD_RELOC_VTABLE_ENTRY:
+ case BFD_RELOC_VTABLE_INHERIT:
return 0;
case BFD_RELOC_GPREL32:
default:
assert ((int)f->fx_r_type < 0
- && - (int)f->fx_r_type < alpha_num_operands);
+ && - (int)f->fx_r_type < (int)alpha_num_operands);
return 1;
}
/*NOTREACHED*/
arelent *
tc_gen_reloc (sec, fixp)
- asection *sec;
+ asection *sec ATTRIBUTE_UNUSED;
fixS *fixp;
{
arelent *reloc;
int
tc_get_register (frame)
- int frame;
+ int frame ATTRIBUTE_UNUSED;
{
int framereg = AXP_REG_SP;
#endif /* OBJ_ECOFF */
\f
+#ifdef RELOC_OP_P
+
+/* Before the relocations are written, reorder them, so that user supplied
+ !lituse relocations follow the appropriate !literal relocations. Also
+ convert the gas-internal relocations to the appropriate linker relocations.
+ */
+
+void
+alpha_adjust_symtab ()
+{
+ if (alpha_literal_hash)
+ {
+#ifdef DEBUG2_ALPHA
+ fprintf (stderr, "alpha_adjust_symtab called\n");
+#endif
+
+ /* Go over each section, reordering the relocations so that all of the
+ explicit LITUSE's are adjacent to the explicit LITERAL's */
+ bfd_map_over_sections (stdoutput, alpha_adjust_symtab_relocs, (char *) 0);
+ }
+}
+
+\f
+/* Inner function to move LITUSE's next to the LITERAL. */
+
+static void
+alpha_adjust_symtab_relocs (abfd, sec, ptr)
+ bfd *abfd ATTRIBUTE_UNUSED;
+ asection *sec;
+ PTR ptr ATTRIBUTE_UNUSED;
+{
+ segment_info_type *seginfo = seg_info (sec);
+ fixS **prevP;
+ fixS *fixp;
+ fixS *next;
+ fixS *lituse;
+ int n_lituses = 0;
+
+#ifdef DEBUG2_ALPHA
+ int n = 0;
+ int n_literals = 0;
+ int n_dup_literals = 0;
+#endif
+
+ /* If seginfo is NULL, we did not create this section; don't do anything with
+ it. By using a pointer to a pointer, we can update the links in place. */
+ if (seginfo == NULL)
+ return;
+
+ /* If there are no relocations, skip the section. */
+ if (! seginfo->fix_root)
+ return;
+
+ /* First rebuild the fixup chain without the expicit lituse's. */
+ prevP = &(seginfo->fix_root);
+ for (fixp = seginfo->fix_root; fixp; fixp = next)
+ {
+ next = fixp->fx_next;
+ fixp->fx_next = (fixS *)0;
+#ifdef DEBUG2_ALPHA
+ n++;
+#endif
+
+ switch (fixp->fx_r_type)
+ {
+ default:
+ *prevP = fixp;
+ prevP = &(fixp->fx_next);
+#ifdef DEBUG2_ALPHA
+ fprintf (stderr,
+ "alpha_adjust_symtab_relocs: 0x%lx, other relocation %s\n",
+ (long)fixp,
+ bfd_get_reloc_code_name (fixp->fx_r_type));
+#endif
+ break;
+
+ case BFD_RELOC_ALPHA_USER_LITERAL:
+ *prevP = fixp;
+ prevP = &(fixp->fx_next);
+ /* prevent assembler from trying to adjust the offset */
+#ifdef DEBUG2_ALPHA
+ n_literals++;
+ if (fixp->tc_fix_data.info->n_literals != 1)
+ n_dup_literals++;
+ fprintf (stderr,
+ "alpha_adjust_symtab_relocs: 0x%lx, !literal!%.6d, # literals = %2d\n",
+ (long)fixp,
+ fixp->tc_fix_data.info->sequence,
+ fixp->tc_fix_data.info->n_literals);
+#endif
+ break;
+
+ /* do not link in lituse's */
+ case BFD_RELOC_ALPHA_USER_LITUSE_BASE:
+ case BFD_RELOC_ALPHA_USER_LITUSE_BYTOFF:
+ case BFD_RELOC_ALPHA_USER_LITUSE_JSR:
+ n_lituses++;
+ if (fixp->tc_fix_data.info->n_literals == 0)
+ as_bad_where (fixp->fx_file, fixp->fx_line,
+ _("No !literal!%d was found"),
+ fixp->tc_fix_data.info->sequence);
+#ifdef DEBUG2_ALPHA
+ fprintf (stderr,
+ "alpha_adjust_symtab_relocs: 0x%lx, !lituse !%.6d, # lituses = %2d, next_lituse = 0x%lx\n",
+ (long)fixp,
+ fixp->tc_fix_data.info->sequence,
+ fixp->tc_fix_data.info->n_lituses,
+ (long)fixp->tc_fix_data.next_lituse);
+#endif
+ break;
+ }
+ }
+
+ /* If there were any lituses, go and add them to the chain, unless there is
+ more than one !literal for a given sequence number. They are linked
+ through the next_lituse field in reverse order, so as we go through the
+ next_lituse chain, we effectively reverse the chain once again. If there
+ was more than one !literal, we fall back to loading up the address w/o
+ optimization. Also, if the !literals/!lituses are spread in different
+ segments (happens in the Linux kernel semaphores), suppress the
+ optimization. */
+ if (n_lituses)
+ {
+ for (fixp = seginfo->fix_root; fixp; fixp = fixp->fx_next)
+ {
+ switch (fixp->fx_r_type)
+ {
+ default:
+ break;
+
+ case BFD_RELOC_ALPHA_USER_LITERAL:
+#ifdef OBJ_ELF
+ fixp->fx_r_type = BFD_RELOC_ALPHA_ELF_LITERAL;
+#else
+ fixp->fx_r_type = BFD_RELOC_ALPHA_LITERAL; /* XXX check this */
+#endif
+ if (fixp->tc_fix_data.info->n_literals == 1
+ && ! fixp->tc_fix_data.info->multi_section_p)
+ {
+ for (lituse = fixp->tc_fix_data.info->lituse;
+ lituse != (fixS *)0;
+ lituse = lituse->tc_fix_data.next_lituse)
+ {
+ lituse->fx_next = fixp->fx_next;
+ fixp->fx_next = lituse;
+ }
+ }
+ break;
+
+ case BFD_RELOC_ALPHA_USER_LITUSE_BASE:
+ case BFD_RELOC_ALPHA_USER_LITUSE_BYTOFF:
+ case BFD_RELOC_ALPHA_USER_LITUSE_JSR:
+ fixp->fx_r_type = BFD_RELOC_ALPHA_LITUSE;
+ break;
+ }
+ }
+ }
+
+#ifdef DEBUG2_ALPHA
+ fprintf (stderr, "alpha_adjust_symtab_relocs: %s, %d literal%s, %d duplicate literal%s, %d lituse%s\n\n",
+ sec->name,
+ n_literals, (n_literals == 1) ? "" : "s",
+ n_dup_literals, (n_dup_literals == 1) ? "" : "s",
+ n_lituses, (n_lituses == 1) ? "" : "s");
+#endif
+}
+
+#endif /* RELOC_OP_P */
+
+\f
+#ifdef DEBUG_ALPHA
+static void
+debug_exp (tok, ntok)
+ expressionS tok[];
+ int ntok;
+{
+ int i;
+
+ fprintf (stderr, "debug_exp: %d tokens", ntok);
+ for (i = 0; i < ntok; i++)
+ {
+ expressionS *t = &tok[i];
+ const char *name;
+ switch (t->X_op)
+ {
+ default: name = "unknown"; break;
+ case O_illegal: name = "O_illegal"; break;
+ case O_absent: name = "O_absent"; break;
+ case O_constant: name = "O_constant"; break;
+ case O_symbol: name = "O_symbol"; break;
+ case O_symbol_rva: name = "O_symbol_rva"; break;
+ case O_register: name = "O_register"; break;
+ case O_big: name = "O_big"; break;
+ case O_uminus: name = "O_uminus"; break;
+ case O_bit_not: name = "O_bit_not"; break;
+ case O_logical_not: name = "O_logical_not"; break;
+ case O_multiply: name = "O_multiply"; break;
+ case O_divide: name = "O_divide"; break;
+ case O_modulus: name = "O_modulus"; break;
+ case O_left_shift: name = "O_left_shift"; break;
+ case O_right_shift: name = "O_right_shift"; break;
+ case O_bit_inclusive_or: name = "O_bit_inclusive_or"; break;
+ case O_bit_or_not: name = "O_bit_or_not"; break;
+ case O_bit_exclusive_or: name = "O_bit_exclusive_or"; break;
+ case O_bit_and: name = "O_bit_and"; break;
+ case O_add: name = "O_add"; break;
+ case O_subtract: name = "O_subtract"; break;
+ case O_eq: name = "O_eq"; break;
+ case O_ne: name = "O_ne"; break;
+ case O_lt: name = "O_lt"; break;
+ case O_le: name = "O_le"; break;
+ case O_ge: name = "O_ge"; break;
+ case O_gt: name = "O_gt"; break;
+ case O_logical_and: name = "O_logical_and"; break;
+ case O_logical_or: name = "O_logical_or"; break;
+ case O_index: name = "O_index"; break;
+ case O_pregister: name = "O_pregister"; break;
+ case O_cpregister: name = "O_cpregister"; break;
+ case O_literal: name = "O_literal"; break;
+ case O_lituse_base: name = "O_lituse_base"; break;
+ case O_lituse_bytoff: name = "O_lituse_bytoff"; break;
+ case O_lituse_jsr: name = "O_lituse_jsr"; break;
+ case O_gpdisp: name = "O_gpdisp"; break;
+ case O_gprelhigh: name = "O_gprelhigh"; break;
+ case O_gprellow: name = "O_gprellow"; break;
+ case O_md10: name = "O_md10"; break;
+ case O_md11: name = "O_md11"; break;
+ case O_md12: name = "O_md12"; break;
+ case O_md13: name = "O_md13"; break;
+ case O_md14: name = "O_md14"; break;
+ case O_md15: name = "O_md15"; break;
+ case O_md16: name = "O_md16"; break;
+ }
+
+ fprintf (stderr, ", %s(%s, %s, %d)", name,
+ (t->X_add_symbol) ? S_GET_NAME (t->X_add_symbol) : "--",
+ (t->X_op_symbol) ? S_GET_NAME (t->X_op_symbol) : "--",
+ (int)t->X_add_number);
+ }
+ fprintf (stderr, "\n");
+ fflush (stderr);
+}
+#endif
+
/* Parse the arguments to an opcode. */
static int
expressionS *end_tok = tok + ntok;
char *old_input_line_pointer;
int saw_comma = 0, saw_arg = 0;
+#ifdef DEBUG_ALPHA
+ expressionS *orig_tok = tok;
+#endif
+#ifdef RELOC_OP_P
+ char *p;
+ const struct alpha_reloc_op_tag *r;
+ int c, i;
+ size_t len;
+ int reloc_found_p = 0;
+#endif
memset (tok, 0, sizeof (*tok) * ntok);
case '\0':
goto fini;
+#ifdef RELOC_OP_P
+ case '!':
+ /* A relocation operand can be placed after the normal operand on an
+ assembly language statement, and has the following form:
+ !relocation_type!sequence_number. */
+ if (reloc_found_p)
+ { /* only support one relocation op per insn */
+ as_bad (_("More than one relocation op per insn"));
+ goto err_report;
+ }
+
+ if (!saw_arg)
+ goto err;
+
+ for (p = ++input_line_pointer;
+ ((c = *p) != '!' && c != ';' && c != '#' && c != ','
+ && !is_end_of_line[c]);
+ p++)
+ ;
+
+ /* Parse !relocation_type */
+ len = p - input_line_pointer;
+ if (len == 0)
+ {
+ as_bad (_("No relocation operand"));
+ goto err_report;
+ }
+
+ if (c != '!')
+ {
+ as_bad (_("No !sequence-number after !%s"), input_line_pointer);
+ goto err_report;
+ }
+
+ r = &alpha_reloc_op[0];
+ for (i = alpha_num_reloc_op-1; i >= 0; i--, r++)
+ {
+ if (len == r->length
+ && memcmp (input_line_pointer, r->name, len) == 0)
+ break;
+ }
+ if (i < 0)
+ {
+ as_bad (_("Unknown relocation operand: !%s"), input_line_pointer);
+ goto err_report;
+ }
+
+ input_line_pointer = ++p;
+
+ /* Parse !sequence_number */
+ memset (tok, '\0', sizeof (expressionS));
+ expression (tok);
+
+ if (tok->X_op != O_constant
+ || ! ALPHA_RELOC_SEQUENCE_OK (tok->X_add_number))
+ {
+ as_bad (_("Bad sequence number: !%s!%s"), r->name, input_line_pointer);
+ goto err_report;
+ }
+
+ tok->X_op = r->op;
+ reloc_found_p = 1;
+ ++tok;
+ break;
+#endif
+
case ',':
++input_line_pointer;
if (saw_comma || !saw_arg)
{
char *hold = input_line_pointer++;
- /* First try for parenthesized register ... */
+ /* First try for parenthesized register ... */
expression (tok);
if (*input_line_pointer == ')' && tok->X_op == O_register)
{
default:
if (saw_arg && !saw_comma)
goto err;
+
expression (tok);
if (tok->X_op == O_illegal || tok->X_op == O_absent)
goto err;
if (saw_comma)
goto err;
input_line_pointer = old_input_line_pointer;
+
+#ifdef DEBUG_ALPHA
+ debug_exp (orig_tok, ntok - (end_tok - tok));
+#endif
+
return ntok - (end_tok - tok);
err:
input_line_pointer = old_input_line_pointer;
- return -1;
+ return TOKENIZE_ERROR;
+
+#ifdef RELOC_OP_P
+err_report:
+ input_line_pointer = old_input_line_pointer;
+ return TOKENIZE_ERROR_REPORT;
+#endif
}
/* Search forward through all variants of an opcode looking for a
default:
/* everything else should have been fake */
- abort();
+ abort ();
}
++tokidx;
}
tokidx = 0;
break;
+ /* index register */
case MACRO_IR:
if (tokidx >= ntok || tok[tokidx].X_op != O_register
|| !is_ir_num(tok[tokidx].X_add_number))
goto match_failed;
++tokidx;
break;
+
+ /* parenthesized index register */
case MACRO_PIR:
if (tokidx >= ntok || tok[tokidx].X_op != O_pregister
|| !is_ir_num(tok[tokidx].X_add_number))
goto match_failed;
++tokidx;
break;
+
+ /* optional parenthesized index register */
+ case MACRO_OPIR:
+ if (tokidx < ntok && tok[tokidx].X_op == O_pregister
+ && is_ir_num(tok[tokidx].X_add_number))
+ ++tokidx;
+ break;
+
+ /* leading comma with a parenthesized index register */
case MACRO_CPIR:
if (tokidx >= ntok || tok[tokidx].X_op != O_cpregister
|| !is_ir_num(tok[tokidx].X_add_number))
goto match_failed;
++tokidx;
break;
+
+ /* floating point register */
case MACRO_FPR:
if (tokidx >= ntok || tok[tokidx].X_op != O_register
|| !is_fpr_num(tok[tokidx].X_add_number))
++tokidx;
break;
+ /* normal expression */
case MACRO_EXP:
if (tokidx >= ntok)
goto match_failed;
case O_register:
case O_pregister:
case O_cpregister:
+#ifdef RELOC_OP_P
+ case O_literal:
+ case O_lituse_base:
+ case O_lituse_bytoff:
+ case O_lituse_jsr:
+ case O_gpdisp:
+ case O_gprelhigh:
+ case O_gprellow:
+#endif
goto match_failed;
default:
++tokidx;
break;
+ /* optional !literal!<number> */
+ case MACRO_LITERAL:
+#ifdef RELOC_OP_P
+ if (tokidx < ntok && tok[tokidx].X_op == O_literal)
+ tokidx++;
+#endif
+ break;
+
+ /* optional !lituse_base!<number> */
+ case MACRO_BASE:
+#ifdef RELOC_OP_P
+ if (tokidx < ntok && tok[tokidx].X_op == O_lituse_base)
+ tokidx++;
+#endif
+ break;
+
+ /* optional !lituse_bytoff!<number> */
+ case MACRO_BYTOFF:
+#ifdef RELOC_OP_P
+ if (tokidx < ntok && tok[tokidx].X_op == O_lituse_bytoff)
+ tokidx++;
+#endif
+ break;
+
+ /* optional !lituse_jsr!<number> */
+ case MACRO_JSR:
+#ifdef RELOC_OP_P
+ if (tokidx < ntok && tok[tokidx].X_op == O_lituse_jsr)
+ tokidx++;
+#endif
+ break;
+
match_failed:
while (*arg != MACRO_EOA)
++arg;
for (argidx = opcode->operands; *argidx; ++argidx)
{
const struct alpha_operand *operand = &alpha_operands[*argidx];
- const expressionS *t;
+ const expressionS *t = (const expressionS *)0;
if (operand->flags & AXP_OPERAND_FAKE)
{
break;
case AXP_OPERAND_DEFAULT_ZERO:
{
- static const expressionS zero_exp = { 0, 0, 0, O_constant, 1 };
+ static expressionS zero_exp;
t = &zero_exp;
+ zero_exp.X_op = O_constant;
+ zero_exp.X_unsigned = 1;
}
break;
default:
- abort();
+ abort ();
}
}
else
f = frag_more (4);
md_number_to_chars (f, insn->insn, 4);
+#ifdef OBJ_ELF
+ dwarf2_emit_insn (4);
+#endif
+
/* Apply the fixups in order */
for (i = 0; i < insn->nfixups; ++i)
{
- const struct alpha_operand *operand;
+ const struct alpha_operand *operand = (const struct alpha_operand *)0;
struct alpha_fixup *fixup = &insn->fixups[i];
int size, pcrel;
fixS *fixP;
+#ifdef RELOC_OP_P
+ char buffer[ALPHA_RELOC_DIGITS];
+ struct alpha_literal_tag *info;
+#endif
/* Some fixups are only used internally and so have no howto */
if ((int)fixup->reloc < 0)
size = 4;
pcrel = ((operand->flags & AXP_OPERAND_RELATIVE) != 0);
}
-#ifdef OBJ_ELF
- /* These relocation types are only used internally. */
- else if (fixup->reloc == BFD_RELOC_ALPHA_GPDISP_HI16
- || fixup->reloc == BFD_RELOC_ALPHA_GPDISP_LO16)
+ else switch (fixup->reloc)
{
- size = 2, pcrel = 0;
- }
+#ifdef OBJ_ELF
+ /* These relocation types are only used internally. */
+ case BFD_RELOC_ALPHA_GPDISP_HI16:
+ case BFD_RELOC_ALPHA_GPDISP_LO16:
+ size = 2;
+ pcrel = 0;
+ break;
#endif
- else
- {
- reloc_howto_type *reloc_howto
- = bfd_reloc_type_lookup (stdoutput, fixup->reloc);
- assert (reloc_howto);
+#ifdef RELOC_OP_P
+ /* and these also are internal only relocations */
+ case BFD_RELOC_ALPHA_USER_LITERAL:
+ case BFD_RELOC_ALPHA_USER_LITUSE_BASE:
+ case BFD_RELOC_ALPHA_USER_LITUSE_BYTOFF:
+ case BFD_RELOC_ALPHA_USER_LITUSE_JSR:
+ case BFD_RELOC_ALPHA_USER_GPDISP:
+ case BFD_RELOC_ALPHA_USER_GPRELHIGH:
+ case BFD_RELOC_ALPHA_USER_GPRELLOW:
+ size = 2;
+ pcrel = 0;
+ break;
+#endif
+
+ default:
+ {
+ reloc_howto_type *reloc_howto
+ = bfd_reloc_type_lookup (stdoutput, fixup->reloc);
+ assert (reloc_howto);
- size = bfd_get_reloc_size (reloc_howto);
- pcrel = reloc_howto->pc_relative;
+ size = bfd_get_reloc_size (reloc_howto);
+ pcrel = reloc_howto->pc_relative;
+ }
+ assert (size >= 1 && size <= 4);
+ break;
}
- assert (size >= 1 && size <= 4);
fixP = fix_new_exp (frag_now, f - frag_now->fr_literal, size,
&fixup->exp, pcrel, fixup->reloc);
- /* Turn off complaints that the addend is too large for some fixups */
+ /* Turn off complaints that the addend is too large for some fixups,
+ and copy in the sequence number for the explicit relocations. */
switch (fixup->reloc)
{
case BFD_RELOC_ALPHA_GPDISP_LO16:
fixP->fx_no_overflow = 1;
break;
+#ifdef RELOC_OP_P
+ case BFD_RELOC_ALPHA_USER_LITERAL:
+ fixP->fx_no_overflow = 1;
+ sprintf (buffer, "!%u", insn->sequence[i]);
+ info = ((struct alpha_literal_tag *)
+ hash_find (alpha_literal_hash, buffer));
+
+ if (! info)
+ {
+ size_t len = strlen (buffer);
+ const char *errmsg;
+
+ info = ((struct alpha_literal_tag *)
+ xcalloc (sizeof (struct alpha_literal_tag) + len, 1));
+
+ info->segment = now_seg;
+ info->sequence = insn->sequence[i];
+ strcpy (info->string, buffer);
+ errmsg = hash_insert (alpha_literal_hash, info->string, (PTR)info);
+ if (errmsg)
+ as_bad (errmsg);
+ }
+
+ ++info->n_literals;
+
+ if (info->segment != now_seg)
+ info->multi_section_p = 1;
+
+ fixP->tc_fix_data.info = info;
+ break;
+
+ case BFD_RELOC_ALPHA_USER_LITUSE_BASE:
+ case BFD_RELOC_ALPHA_USER_LITUSE_BYTOFF:
+ case BFD_RELOC_ALPHA_USER_LITUSE_JSR:
+ sprintf (buffer, "!%u", insn->sequence[i]);
+ info = ((struct alpha_literal_tag *)
+ hash_find (alpha_literal_hash, buffer));
+
+ if (! info)
+ {
+ size_t len = strlen (buffer);
+ const char *errmsg;
+
+ info = ((struct alpha_literal_tag *)
+ xcalloc (sizeof (struct alpha_literal_tag) + len, 1));
+
+ info->segment = now_seg;
+ info->sequence = insn->sequence[i];
+ strcpy (info->string, buffer);
+ errmsg = hash_insert (alpha_literal_hash, info->string, (PTR)info);
+ if (errmsg)
+ as_bad (errmsg);
+ }
+ info->n_lituses++;
+ fixP->tc_fix_data.info = info;
+ fixP->tc_fix_data.next_lituse = info->lituse;
+ info->lituse = fixP;
+ if (info->segment != now_seg)
+ info->multi_section_p = 1;
+
+ break;
+#endif
+
default:
if ((int)fixup->reloc < 0)
{
}
}
+#ifdef RELOC_OP_P
+ if (ntok && USER_RELOC_P (tok[ntok-1].X_op))
+ {
+ const expressionS *reloc_exp = &tok[ntok-1];
+ const struct alpha_reloc_op_tag *r = ALPHA_RELOC_TABLE (reloc_exp->X_op);
+ as_bad (_("Cannot use !%s!%d with %s"), r->name,
+ (int)reloc_exp->X_add_number, opname);
+ ntok--;
+ }
+#endif
+
/* search opcodes */
opcode = (const struct alpha_opcode *) hash_find (alpha_opcode_hash, opname);
if (opcode)
static void
emit_ldgp (tok, ntok, unused)
const expressionS *tok;
- int ntok;
- const PTR unused;
+ int ntok ATTRIBUTE_UNUSED;
+ const PTR unused ATTRIBUTE_UNUSED;
{
#ifdef OBJ_AOUT
FIXME
expressionS newtok[3];
expressionS addend;
+#ifdef RELOC_OP_P
+ if (ntok && USER_RELOC_P (tok[ntok-1].X_op))
+ {
+ const expressionS *reloc_exp = &tok[ntok-1];
+ const struct alpha_reloc_op_tag *r = ALPHA_RELOC_TABLE (reloc_exp->X_op);
+ as_bad (_("Cannot use !%s!%d with %s"), r->name,
+ (int)reloc_exp->X_add_number, "ldgp");
+ ntok--;
+ }
+#endif
+
#ifdef OBJ_ECOFF
if (regno (tok[2].X_add_number) == AXP_REG_PV)
ecoff_set_gp_prolog_size (0);
i.e. "ldq $targ, LIT($gp); addq $targ, $0, $targ". Odd, perhaps,
but this is what OSF/1 does.
+ If explicit relocations of the form !literal!<number> are allowed,
+ and used, then explict_reloc with be an expression pointer.
+
Finally, the return value is true if the calling macro may emit a
LITUSE reloc if otherwise appropriate. */
static int
-load_expression (targreg, exp, pbasereg, poffset)
+load_expression (targreg, exp, pbasereg, poffset, explicit_reloc)
int targreg;
const expressionS *exp;
int *pbasereg;
expressionS *poffset;
+ const expressionS *explicit_reloc;
{
int emit_lituse = 0;
offsetT addend = exp->X_add_number;
assemble_tokens_to_insn ("ldq", newtok, 3, &insn);
+ assert (explicit_reloc == (const expressionS *)0);
assert (insn.nfixups == 1);
insn.fixups[0].reloc = BFD_RELOC_ALPHA_LITERAL;
#endif /* OBJ_ECOFF */
assemble_tokens_to_insn ("ldq", newtok, 3, &insn);
assert (insn.nfixups == 1);
- insn.fixups[0].reloc = BFD_RELOC_ALPHA_ELF_LITERAL;
+ if (!explicit_reloc)
+ insn.fixups[0].reloc = BFD_RELOC_ALPHA_ELF_LITERAL;
+ else
+ {
+#ifdef RELOC_OP_P
+ insn.fixups[0].reloc
+ = (ALPHA_RELOC_TABLE (explicit_reloc->X_op))->reloc;
+ insn.sequence[0] = explicit_reloc->X_add_number;
+#else
+ abort ();
+#endif
+ }
#endif /* OBJ_ELF */
#ifdef OBJ_EVAX
offsetT link;
/* Find symbol or symbol pointer in link section. */
+ assert (explicit_reloc == (const expressionS *)0);
if (exp->X_add_symbol == alpha_evax_proc.symbol)
{
if (range_signed_16 (addend))
break;
case O_constant:
+ assert (explicit_reloc == (const expressionS *)0);
break;
case O_subtract:
/* Assume that this difference expression will be resolved to an
- absolute value and that that value will fit in 16 bits. */
+ absolute value and that that value will fit in 16 bits. */
+ assert (explicit_reloc == (const expressionS *)0);
set_tok_reg (newtok[0], targreg);
newtok[1] = *exp;
set_tok_preg (newtok[2], basereg);
if (insn.nfixups > 0)
{
memmove (&insn.fixups[1], &insn.fixups[0],
- sizeof(struct alpha_fixup) * insn.nfixups);
+ sizeof (struct alpha_fixup) * insn.nfixups);
}
insn.nfixups++;
insn.fixups[0].reloc = BFD_RELOC_ALPHA_LITUSE;
insn.fixups[0].exp.X_op = O_symbol;
insn.fixups[0].exp.X_add_symbol = section_symbol (now_seg);
- insn.fixups[0].exp.X_add_number = 1;
+ insn.fixups[0].exp.X_add_number = LITUSE_BASE;
emit_lituse = 0;
emit_insn (&insn);
large constants. */
static void
-emit_lda (tok, ntok, unused)
+emit_lda (tok, ntok, opname)
const expressionS *tok;
int ntok;
- const PTR unused;
+ const PTR opname;
{
int basereg;
+ const expressionS *reloc = (const expressionS *)0;
+
+#ifdef RELOC_OP_P
+ if (ntok && USER_RELOC_P (tok[ntok-1].X_op))
+ {
+ const struct alpha_reloc_op_tag *r;
+
+ reloc = &tok[ntok-1];
+ r = ALPHA_RELOC_TABLE (reloc->X_op);
+ switch (reloc->X_op)
+ {
+ default:
+ as_bad (_("Cannot use !%s!%d with %s"), r->name,
+ (int)reloc->X_add_number, (const char *)opname);
+
+ reloc = (const expressionS *)0;
+ ntok--;
+ break;
+
+ case O_literal:
+ ntok--;
+ break;
+
+ /* For lda $x,0($x)!lituse_base!y, don't use load_expression, since
+ it is really too general for our needs. Instead just generate the
+ lda directly. */
+ case O_lituse_base:
+ if (ntok != 4
+ || tok[0].X_op != O_register
+ || !is_ir_num(tok[0].X_add_number)
+ || tok[1].X_op != O_constant
+ || tok[2].X_op != O_pregister
+ || !is_ir_num(tok[2].X_add_number))
+ {
+ as_bad (_("bad instruction format for lda !%s!%ld"), r->name,
+ (long) reloc->X_add_number);
+
+ reloc = (const expressionS *)0;
+ ntok--;
+ break;
+ }
+
+ emit_loadstore (tok, ntok, "lda");
+ return;
+ }
+ }
+#endif
if (ntok == 2)
basereg = (tok[1].X_op == O_constant ? AXP_REG_ZERO : alpha_gp_register);
else
basereg = tok[2].X_add_number;
- (void) load_expression (tok[0].X_add_number, &tok[1], &basereg, NULL);
+ (void) load_expression (tok[0].X_add_number, &tok[1], &basereg, NULL, reloc);
}
/* The ldah macro differs from the ldah instruction in that it has $31
static void
emit_ldah (tok, ntok, unused)
const expressionS *tok;
- int ntok;
- const PTR unused;
+ int ntok ATTRIBUTE_UNUSED;
+ const PTR unused ATTRIBUTE_UNUSED;
{
expressionS newtok[3];
+#ifdef RELOC_OP_P
+ if (ntok && USER_RELOC_P (tok[ntok-1].X_op))
+ {
+ const expressionS *reloc_exp = &tok[ntok-1];
+ const struct alpha_reloc_op_tag *r = ALPHA_RELOC_TABLE (reloc_exp->X_op);
+ as_bad (_("Cannot use !%s!%d with %s"), r->name,
+ (int)reloc_exp->X_add_number, "ldah");
+ ntok--;
+ }
+#endif
+
newtok[0] = tok[0];
newtok[1] = tok[1];
set_tok_preg (newtok[2], AXP_REG_ZERO);
expressionS newtok[3];
struct alpha_insn insn;
+#ifdef RELOC_OP_P
+ const expressionS *reloc = (const expressionS *)0;
+
+ if (ntok && USER_RELOC_P (tok[ntok-1].X_op))
+ {
+ const struct alpha_reloc_op_tag *r;
+
+ reloc = &tok[ntok-1];
+ switch (reloc->X_op)
+ {
+ case O_lituse_base:
+ ntok--;
+ break;
+
+ case O_literal:
+ if (strcmp ((const char *)opname, "ldq") == 0)
+ {
+ emit_lda (tok, ntok, opname);
+ return;
+ }
+
+ /* fall through */
+ default:
+ ntok--;
+ r = ALPHA_RELOC_TABLE (reloc->X_op);
+ as_bad (_("Cannot use !%s!%d with %s"), r->name,
+ (int)reloc->X_add_number, (const char *)opname);
+ }
+ }
+#endif
+
if (ntok == 2)
basereg = (tok[1].X_op == O_constant ? AXP_REG_ZERO : alpha_gp_register);
else
basereg = tok[2].X_add_number;
lituse = load_expression (tok[0].X_add_number, &tok[1], &basereg,
- &newtok[1]);
+ &newtok[1], (const expressionS *)0);
newtok[0] = tok[0];
set_tok_preg (newtok[2], basereg);
assemble_tokens_to_insn ((const char *)opname, newtok, 3, &insn);
+#ifdef RELOC_OP_P
+ if (reloc)
+ {
+ int nfixups = insn.nfixups;
+ const struct alpha_reloc_op_tag *r = ALPHA_RELOC_TABLE (reloc->X_op);
+
+ assert (nfixups < MAX_INSN_FIXUPS);
+ insn.fixups[nfixups].reloc = r->reloc;
+ insn.fixups[nfixups].exp.X_op = O_symbol;
+ insn.fixups[nfixups].exp.X_add_symbol = section_symbol (now_seg);
+ insn.fixups[nfixups].exp.X_add_number = r->lituse;
+ insn.sequence[nfixups] = reloc->X_add_number;
+ insn.nfixups++;
+ }
+#endif
+
if (lituse)
{
assert (insn.nfixups < MAX_INSN_FIXUPS);
if (insn.nfixups > 0)
{
memmove (&insn.fixups[1], &insn.fixups[0],
- sizeof(struct alpha_fixup) * insn.nfixups);
+ sizeof (struct alpha_fixup) * insn.nfixups);
}
insn.nfixups++;
insn.fixups[0].reloc = BFD_RELOC_ALPHA_LITUSE;
insn.fixups[0].exp.X_op = O_symbol;
insn.fixups[0].exp.X_add_symbol = section_symbol (now_seg);
- insn.fixups[0].exp.X_add_number = 1;
+ insn.fixups[0].exp.X_add_number = LITUSE_BASE;
}
emit_insn (&insn);
expressionS newtok[3];
struct alpha_insn insn;
+#ifdef RELOC_OP_P
+ const expressionS *reloc = (const expressionS *)0;
+
+ if (ntok && USER_RELOC_P (tok[ntok-1].X_op))
+ {
+ reloc = &tok[--ntok];
+ if (reloc->X_op != O_lituse_base)
+ {
+ const struct alpha_reloc_op_tag *r = &alpha_reloc_op[ reloc->X_md ];
+ as_bad (_("Cannot use !%s!%d with %s"), r->name,
+ (int)reloc->X_add_number, (const char *)opname);
+ }
+ }
+#endif
+
if (ntok == 2)
basereg = (tok[1].X_op == O_constant ? AXP_REG_ZERO : alpha_gp_register);
else
if (alpha_noat_on)
as_bad (_("macro requires $at register while noat in effect"));
- lituse = load_expression (AXP_REG_AT, &tok[1], &basereg, &newtok[1]);
+ lituse = load_expression (AXP_REG_AT, &tok[1], &basereg, &newtok[1],
+ (const expressionS *)0);
}
else
{
assemble_tokens_to_insn ((const char *)opname, newtok, 3, &insn);
+#ifdef RELOC_OP_P
+ if (reloc)
+ {
+ int nfixups = insn.nfixups;
+ const struct alpha_reloc_op_tag *r = ALPHA_RELOC_TABLE (reloc->X_op);
+
+ assert (nfixups < MAX_INSN_FIXUPS);
+ insn.fixups[nfixups].reloc = r->reloc;
+ insn.fixups[nfixups].exp.X_op = O_symbol;
+ insn.fixups[nfixups].exp.X_add_symbol = section_symbol (now_seg);
+ insn.fixups[nfixups].exp.X_add_number = r->lituse;
+ insn.sequence[nfixups] = reloc->X_add_number;
+ insn.nfixups++;
+ }
+#endif
+
if (lituse)
{
assert (insn.nfixups < MAX_INSN_FIXUPS);
if (insn.nfixups > 0)
{
memmove (&insn.fixups[1], &insn.fixups[0],
- sizeof(struct alpha_fixup) * insn.nfixups);
+ sizeof (struct alpha_fixup) * insn.nfixups);
}
insn.nfixups++;
insn.fixups[0].reloc = BFD_RELOC_ALPHA_LITUSE;
insn.fixups[0].exp.X_op = O_symbol;
insn.fixups[0].exp.X_add_symbol = section_symbol (now_seg);
- insn.fixups[0].exp.X_add_number = 1;
+ insn.fixups[0].exp.X_add_number = LITUSE_BASE;
}
emit_insn (&insn);
{
expressionS newtok[3];
+#ifdef RELOC_OP_P
+ if (ntok && USER_RELOC_P (tok[ntok-1].X_op))
+ {
+ const expressionS *reloc_exp = &tok[ntok-1];
+ const struct alpha_reloc_op_tag *r
+ = ALPHA_RELOC_TABLE (reloc_exp->X_op);
+
+ as_bad (_("Cannot use !%s!%d with %s"), r->name,
+ (int)reloc_exp->X_add_number, "ldbu/ldwu");
+ ntok--;
+ }
+#endif
+
if (alpha_noat_on)
as_bad (_("macro requires $at register while noat in effect"));
emit_ldil (tok, ntok, unused)
const expressionS *tok;
int ntok;
- const PTR unused;
+ const PTR unused ATTRIBUTE_UNUSED;
{
expressionS newtok[2];
- memcpy (newtok, tok, sizeof(newtok));
+#ifdef RELOC_OP_P
+ if (ntok && USER_RELOC_P (tok[ntok-1].X_op))
+ {
+ const expressionS *reloc_exp = &tok[ntok-1];
+ const struct alpha_reloc_op_tag *r = ALPHA_RELOC_TABLE (reloc_exp->X_op);
+ as_bad (_("Cannot use !%s!%d with %s"), r->name,
+ (int)reloc_exp->X_add_number, "ldil");
+ ntok--;
+ }
+#endif
+
+ memcpy (newtok, tok, sizeof (newtok));
newtok[1].X_add_number = sign_extend_32 (tok[1].X_add_number);
assemble_tokens ("lda", newtok, ntok, 1);
int ntok;
const PTR vlgsize;
{
- int lgsize = (int)(long)vlgsize;
+ int lgsize = (int) (long)vlgsize;
if (alpha_target & AXP_OPCODE_BWX)
emit_loadstore (tok, ntok, stX_op[lgsize]);
int ntok;
const PTR vlgsize;
{
- int lgsize = (int)(long)vlgsize;
+ int lgsize = (int) (long)vlgsize;
expressionS newtok[3];
/* emit "lda $at, exp" */
int bitshift = 64 - 8 * (1 << lgsize);
expressionS newtok[3];
+#ifdef RELOC_OP_P
+ if (ntok && USER_RELOC_P (tok[ntok-1].X_op))
+ {
+ const expressionS *reloc_exp = &tok[ntok-1];
+ const struct alpha_reloc_op_tag *r
+ = ALPHA_RELOC_TABLE (reloc_exp->X_op);
+
+ as_bad (_("Cannot use !%s!%d with %s"), r->name,
+ (int)reloc_exp->X_add_number, "setxt");
+ ntok--;
+ }
+#endif
+
/* emit "sll src,bits,dst" */
newtok[0] = tok[0];
symbolS *sym;
expressionS newtok[3];
+#ifdef RELOC_OP_P
+ if (ntok && USER_RELOC_P (tok[ntok-1].X_op))
+ {
+ const expressionS *reloc_exp = &tok[ntok-1];
+ const struct alpha_reloc_op_tag *r = ALPHA_RELOC_TABLE (reloc_exp->X_op);
+ as_bad (_("Cannot use !%s!%d with %s"), r->name,
+ (int)reloc_exp->X_add_number, (char char *)symname);
+ ntok--;
+ }
+#endif
+
xr = regno (tok[0].X_add_number);
yr = regno (tok[1].X_add_number);
symbolS *sym;
expressionS newtok[3];
+#ifdef RELOC_OP_P
+ if (ntok && USER_RELOC_P (tok[ntok-1].X_op))
+ {
+ const expressionS *reloc_exp = &tok[ntok-1];
+ const struct alpha_reloc_op_tag *r = ALPHA_RELOC_TABLE (reloc_exp->X_op);
+ as_bad (_("Cannot use !%s!%d with %s"), r->name,
+ (int)reloc_exp->X_add_number, (const char *)symname);
+ ntok--;
+ }
+#endif
+
xr = regno (tok[0].X_add_number);
yr = regno (tok[1].X_add_number);
expressionS newtok[3];
int r, tokidx = 0, lituse = 0;
+#ifdef RELOC_OP_P
+ if (ntok && USER_RELOC_P (tok[ntok-1].X_op))
+ {
+ const expressionS *reloc_exp = &tok[ntok-1];
+ const struct alpha_reloc_op_tag *r = ALPHA_RELOC_TABLE (reloc_exp->X_op);
+ as_bad (_("Cannot use !%s!%d with %s"), r->name,
+ (int)reloc_exp->X_add_number, opname);
+ ntok--;
+ }
+#endif
+
if (tokidx < ntok && tok[tokidx].X_op == O_register)
r = regno (tok[tokidx++].X_add_number);
else
else
{
int basereg = alpha_gp_register;
- lituse = load_expression (r = AXP_REG_PV, &tok[tokidx], &basereg, NULL);
+ lituse = load_expression (r = AXP_REG_PV, &tok[tokidx], &basereg, NULL,
+ (const expressionS *)0);
}
#endif
if (insn.nfixups > 0)
{
memmove (&insn.fixups[1], &insn.fixups[0],
- sizeof(struct alpha_fixup) * insn.nfixups);
+ sizeof (struct alpha_fixup) * insn.nfixups);
}
insn.nfixups++;
insn.fixups[0].reloc = BFD_RELOC_ALPHA_LITUSE;
insn.fixups[0].exp.X_op = O_symbol;
insn.fixups[0].exp.X_add_symbol = section_symbol (now_seg);
- insn.fixups[0].exp.X_add_number = 3;
+ insn.fixups[0].exp.X_add_number = LITUSE_JSR;
}
emit_insn (&insn);
expressionS newtok[3];
int r, tokidx = 0;
+#ifdef RELOC_OP_P
+ if (ntok && USER_RELOC_P (tok[ntok-1].X_op))
+ {
+ const expressionS *reloc_exp = &tok[ntok-1];
+ const struct alpha_reloc_op_tag *r = ALPHA_RELOC_TABLE (reloc_exp->X_op);
+ as_bad (_("Cannot use !%s!%d with %s"), r->name,
+ (int)reloc_exp->X_add_number, opname);
+ ntok--;
+ }
+#endif
+
if (tokidx < ntok && tok[tokidx].X_op == O_register)
r = regno (tok[tokidx++].X_add_number);
else
{
offsetT align;
- input_line_pointer++;
+ input_line_pointer++;
align = get_absolute_expression ();
bfd_set_section_alignment (stdoutput, new_seg, align);
}
#ifdef OBJ_EVAX
if (bfd_section_size (stdoutput, new_seg) > 0)
- {
+ {
if (bfd_section_size (stdoutput, new_seg) != temp)
as_bad (_("Length of .comm \"%s\" is already %ld. Not changed to %ld."),
S_GET_NAME (symbolP),
#endif
else
{
-#ifdef OBJ_EVAX
+#ifdef OBJ_EVAX
subseg_set (new_seg, 0);
p = frag_more (temp);
new_seg->flags |= SEC_IS_COMMON;
static void
s_alpha_ent (dummy)
- int dummy;
+ int dummy ATTRIBUTE_UNUSED;
{
if (ECOFF_DEBUGGING)
ecoff_directive_ent (0);
static void
s_alpha_end (dummy)
- int dummy;
+ int dummy ATTRIBUTE_UNUSED;
{
if (ECOFF_DEBUGGING)
ecoff_directive_end (0);
static void
s_alpha_frame (dummy)
- int dummy;
+ int dummy ATTRIBUTE_UNUSED;
{
if (ECOFF_DEBUGGING)
ecoff_directive_frame (0);
static void
s_alpha_prologue (ignore)
- int ignore;
+ int ignore ATTRIBUTE_UNUSED;
{
symbolS *sym;
int arg;
switch (arg)
{
case 0: /* No PV required. */
- S_SET_OTHER (sym, STO_ALPHA_NOPV);
+ S_SET_OTHER (sym, STO_ALPHA_NOPV
+ | (S_GET_OTHER (sym) & ~STO_ALPHA_STD_GPLOAD));
break;
case 1: /* Std GP load. */
- S_SET_OTHER (sym, STO_ALPHA_STD_GPLOAD);
+ S_SET_OTHER (sym, STO_ALPHA_STD_GPLOAD
+ | (S_GET_OTHER (sym) & ~STO_ALPHA_STD_GPLOAD));
break;
case 2: /* Non-std use of PV. */
break;
default:
as_bad (_("Invalid argument %d to .prologue."), arg);
break;
- }
+ }
+}
+
+static char * first_file_directive;
+
+static void
+s_alpha_file (ignore)
+ int ignore ATTRIBUTE_UNUSED;
+{
+ /* Save the first .file directive we see, so that we can change our
+ minds about whether ecoff debugging should or shouldn't be enabled. */
+ if (alpha_flag_mdebug < 0 && ! first_file_directive)
+ {
+ char *start = input_line_pointer;
+ size_t len;
+
+ discard_rest_of_line ();
+
+ len = input_line_pointer - start;
+ first_file_directive = xmalloc (len + 1);
+ memcpy (first_file_directive, start, len);
+ first_file_directive[len] = '\0';
+
+ input_line_pointer = start;
+ }
+
+ if (ECOFF_DEBUGGING)
+ ecoff_directive_file (0);
+ else
+ dwarf2_directive_file (0);
+}
+
+static void
+s_alpha_loc (ignore)
+ int ignore ATTRIBUTE_UNUSED;
+{
+ if (ECOFF_DEBUGGING)
+ ecoff_directive_loc (0);
+ else
+ dwarf2_directive_loc (0);
+}
+
+static void
+s_alpha_stab (n)
+ int n;
+{
+ /* If we've been undecided about mdebug, make up our minds in favour. */
+ if (alpha_flag_mdebug < 0)
+ {
+ segT sec = subseg_new(".mdebug", 0);
+ bfd_set_section_flags(stdoutput, sec, SEC_HAS_CONTENTS|SEC_READONLY);
+ bfd_set_section_alignment(stdoutput, sec, 3);
+
+ ecoff_read_begin_hook ();
+
+ if (first_file_directive)
+ {
+ char *save_ilp = input_line_pointer;
+ input_line_pointer = first_file_directive;
+ ecoff_directive_file (0);
+ input_line_pointer = save_ilp;
+ free (first_file_directive);
+ }
+
+ alpha_flag_mdebug = 1;
+ }
+ s_stab (n);
}
static void
ecoff_directive_def,
ecoff_directive_dim,
ecoff_directive_endef,
- ecoff_directive_file,
ecoff_directive_scl,
ecoff_directive_tag,
ecoff_directive_val,
- ecoff_directive_loc,
};
- assert (which >= 0 && which < sizeof(fns)/sizeof(*fns));
+ assert (which >= 0 && which < (int) (sizeof (fns)/sizeof (*fns)));
if (ECOFF_DEBUGGING)
- (*fns[which])(0);
+ (*fns[which]) (0);
else
{
as_bad (_("ECOFF debugging is disabled."));
#endif /* OBJ_ELF */
#ifdef OBJ_EVAX
-
+
/* Handle the section specific pseudo-op. */
-
+
static void
s_alpha_section (secid)
int secid;
alpha_current_align = 0;
}
-
/* Parse .ent directives. */
static void
return;
}
-
/* Parse .frame <framreg>,<framesize>,RA,<rsa_offset> directives. */
static void
return;
}
-
/* Support for crash debug on vms. */
static void
return;
}
-
static void
s_alpha_linkage (ignore)
int ignore;
return;
}
-
static void
s_alpha_code_address (ignore)
int ignore;
return;
}
-
static void
s_alpha_fp_save (ignore)
int ignore;
return;
}
-
static void
s_alpha_mask (ignore)
int ignore;
return;
}
-
static void
s_alpha_fmask (ignore)
int ignore;
return;
}
-
static void
s_alpha_file (ignore)
int ignore;
static void
s_alpha_gprel32 (ignore)
- int ignore;
+ int ignore ATTRIBUTE_UNUSED;
{
expressionS e;
char *p;
case O_symbol:
break;
default:
- abort();
+ abort ();
}
#else
#ifdef OBJ_ECOFF
static void
s_alpha_proc (is_static)
- int is_static;
+ int is_static ATTRIBUTE_UNUSED;
{
char *name;
char c;
static void
s_alpha_set (x)
- int x;
+ int x ATTRIBUTE_UNUSED;
{
char *name, ch, *s;
int yesno = 1;
static void
s_alpha_base (ignore)
- int ignore;
+ int ignore ATTRIBUTE_UNUSED;
{
#if 0
if (first_32bit_quadrant)
static void
s_alpha_align (ignore)
- int ignore;
+ int ignore ATTRIBUTE_UNUSED;
{
int align;
char fill, *pfill;
static void
s_alpha_arch (ignored)
- int ignored;
+ int ignored ATTRIBUTE_UNUSED;
{
char *name, ch;
const struct cpu_type *p;
{"fmask", s_alpha_mask, 1},
{"frame", s_alpha_frame, 0},
{"prologue", s_alpha_prologue, 0},
+ {"file", s_alpha_file, 5},
+ {"loc", s_alpha_loc, 9},
+ {"stabs", s_alpha_stab, 's'},
+ {"stabn", s_alpha_stab, 'n'},
/* COFF debugging related pseudos. */
{"begin", s_alpha_coff_wrapper, 0},
{"bend", s_alpha_coff_wrapper, 1},
{"def", s_alpha_coff_wrapper, 2},
{"dim", s_alpha_coff_wrapper, 3},
{"endef", s_alpha_coff_wrapper, 4},
- {"file", s_alpha_coff_wrapper, 5},
- {"scl", s_alpha_coff_wrapper, 6},
- {"tag", s_alpha_coff_wrapper, 7},
- {"val", s_alpha_coff_wrapper, 8},
- {"loc", s_alpha_coff_wrapper, 9},
+ {"scl", s_alpha_coff_wrapper, 5},
+ {"tag", s_alpha_coff_wrapper, 6},
+ {"val", s_alpha_coff_wrapper, 7},
#else
{"prologue", s_ignore, 0},
#endif
int n;
char *pfill;
symbolS *label;
- int force;
+ int force ATTRIBUTE_UNUSED;
{
if (alpha_current_align >= n)
return;
if (pfill == NULL)
{
- if (n > 2
- && (bfd_get_section_flags (stdoutput, now_seg) & SEC_CODE) != 0)
- {
- static char const unop[4] = { 0x00, 0x00, 0xe0, 0x2f };
- static char const nopunop[8] = {
- 0x1f, 0x04, 0xff, 0x47,
- 0x00, 0x00, 0xe0, 0x2f
- };
-
- /* First, make sure we're on a four-byte boundary, in case
- someone has been putting .byte values into the text
- section. The DEC assembler silently fills with unaligned
- no-op instructions. This will zero-fill, then nop-fill
- with proper alignment. */
- if (alpha_current_align < 2)
- frag_align (2, 0, 0);
- if (alpha_current_align < 3)
- frag_align_pattern (3, unop, sizeof unop, 0);
- if (n > 3)
- frag_align_pattern (n, nopunop, sizeof nopunop, 0);
- }
+ if (subseg_text_p (now_seg))
+ frag_align_code (n, 0);
else
frag_align (n, 0, 0);
}
alpha_current_align = n;
- if (label != NULL)
+ if (label != NULL && S_GET_SEGMENT (label) == now_seg)
{
- assert (S_GET_SEGMENT (label) == now_seg);
symbol_set_frag (label, frag_now);
S_SET_VALUE (label, (valueT) frag_now_fix ());
}
- record_alignment(now_seg, n);
+ record_alignment (now_seg, n);
- /* ??? if alpha_flag_relax && force && elf, record the requested alignment
+ /* ??? If alpha_flag_relax && force && elf, record the requested alignment
in a reloc for the linker to see. */
}
+/* This is called from HANDLE_ALIGN in write.c. Fill in the contents
+ of an rs_align_code fragment. */
+
+void
+alpha_handle_align (fragp)
+ fragS *fragp;
+{
+ static char const unop[4] = { 0x00, 0x00, 0xe0, 0x2f };
+ static char const nopunop[8] = {
+ 0x1f, 0x04, 0xff, 0x47,
+ 0x00, 0x00, 0xe0, 0x2f
+ };
+
+ int bytes, fix;
+ char *p;
+
+ if (fragp->fr_type != rs_align_code)
+ return;
+
+ bytes = fragp->fr_next->fr_address - fragp->fr_address - fragp->fr_fix;
+ p = fragp->fr_literal + fragp->fr_fix;
+ fix = 0;
+
+ if (bytes & 3)
+ {
+ fix = bytes & 3;
+ memset (p, 0, fix);
+ p += fix;
+ bytes -= fix;
+ }
+
+ if (bytes & 4)
+ {
+ memcpy (p, unop, 4);
+ p += 4;
+ bytes -= 4;
+ fix += 4;
+ }
+
+ memcpy (p, nopunop, 8);
+
+ fragp->fr_fix += fix;
+ fragp->fr_var = 8;
+}
+
/* The Alpha has support for some VAX floating point types, as well as for
IEEE floating point. We consider IEEE to be the primary floating point
format, and sneak in the VAX floating point support here. */
projects / deliverable / binutils-gdb.git / blobdiff