#include <stdio.h>
#include "libiberty.h"
#include "as.h"
#include "struc-symbol.h"
#include "safe-ctype.h"
#include "subsegs.h"
#include "opcode/arc.h"
#include "../opcodes/arc-ext.h"
#include "elf/arc.h"
#include "dwarf2dbg.h"
extern int arc_get_mach PARAMS ((char *));
extern int arc_operand_type PARAMS ((int));
extern int arc_insn_not_jl PARAMS ((arc_insn));
extern int arc_limm_fixup_adjust PARAMS ((arc_insn));
extern int arc_get_noshortcut_flag PARAMS ((void));
extern int arc_set_ext_seg PARAMS ((void));
extern void arc_code_symbol PARAMS ((expressionS *));
static arc_insn arc_insert_operand PARAMS ((arc_insn,
const struct arc_operand *, int,
const struct arc_operand_value *,
offsetT, char *, unsigned int));
static void arc_common PARAMS ((int));
static void arc_extinst PARAMS ((int));
static void arc_extoper PARAMS ((int));
static void arc_option PARAMS ((int));
static int get_arc_exp_reloc_type PARAMS ((int, int, expressionS *,
expressionS *));
static void init_opcode_tables PARAMS ((int));
const struct suffix_classes {
char *name;
int len;
} suffixclass[] = {
{ "SUFFIX_COND|SUFFIX_FLAG",23 },
{ "SUFFIX_FLAG", 11 },
{ "SUFFIX_COND", 11 },
{ "SUFFIX_NONE", 11 }
};
#define MAXSUFFIXCLASS (sizeof (suffixclass) / sizeof (struct suffix_classes))
const struct syntax_classes {
char *name;
int len;
int class;
} syntaxclass[] = {
{ "SYNTAX_3OP|OP1_MUST_BE_IMM", 26, SYNTAX_3OP|OP1_MUST_BE_IMM|SYNTAX_VALID },
{ "OP1_MUST_BE_IMM|SYNTAX_3OP", 26, OP1_MUST_BE_IMM|SYNTAX_3OP|SYNTAX_VALID },
{ "SYNTAX_2OP|OP1_IMM_IMPLIED", 26, SYNTAX_2OP|OP1_IMM_IMPLIED|SYNTAX_VALID },
{ "OP1_IMM_IMPLIED|SYNTAX_2OP", 26, OP1_IMM_IMPLIED|SYNTAX_2OP|SYNTAX_VALID },
{ "SYNTAX_3OP", 10, SYNTAX_3OP|SYNTAX_VALID },
{ "SYNTAX_2OP", 10, SYNTAX_2OP|SYNTAX_VALID }
};
#define MAXSYNTAXCLASS (sizeof (syntaxclass) / sizeof (struct syntax_classes))
const pseudo_typeS md_pseudo_table[] = {
{ "align", s_align_bytes, 0 },
{ "comm", arc_common, 0 },
{ "common", arc_common, 0 },
{ "lcomm", arc_common, 1 },
{ "lcommon", arc_common, 1 },
{ "2byte", cons, 2 },
{ "half", cons, 2 },
{ "short", cons, 2 },
{ "3byte", cons, 3 },
{ "4byte", cons, 4 },
{ "word", cons, 4 },
{ "option", arc_option, 0 },
{ "cpu", arc_option, 0 },
{ "block", s_space, 0 },
{ "extcondcode", arc_extoper, 0 },
{ "extcoreregister", arc_extoper, 1 },
{ "extauxregister", arc_extoper, 2 },
{ "extinstruction", arc_extinst, 0 },
{ NULL, 0, 0 },
};
const char comment_chars[] = "#;";
const char line_comment_chars[] = "#";
const char line_separator_chars[] = "";
const char EXP_CHARS[] = "eE";
const char FLT_CHARS[] = "rRsSfFdD";
extern int target_big_endian;
const char *arc_target_format = DEFAULT_TARGET_FORMAT;
static int byte_order = DEFAULT_BYTE_ORDER;
static segT arcext_section;
static int arc_mach_type = bfd_mach_arc_6;
static int mach_type_specified_p = 0;
static int cpu_tables_init_p = 0;
static struct hash_control *arc_suffix_hash = NULL;
const char *md_shortopts = "";
struct option md_longopts[] = {
#define OPTION_EB (OPTION_MD_BASE + 0)
{ "EB", no_argument, NULL, OPTION_EB },
#define OPTION_EL (OPTION_MD_BASE + 1)
{ "EL", no_argument, NULL, OPTION_EL },
#define OPTION_ARC5 (OPTION_MD_BASE + 2)
{ "marc5", no_argument, NULL, OPTION_ARC5 },
{ "pre-v6", no_argument, NULL, OPTION_ARC5 },
#define OPTION_ARC6 (OPTION_MD_BASE + 3)
{ "marc6", no_argument, NULL, OPTION_ARC6 },
#define OPTION_ARC7 (OPTION_MD_BASE + 4)
{ "marc7", no_argument, NULL, OPTION_ARC7 },
#define OPTION_ARC8 (OPTION_MD_BASE + 5)
{ "marc8", no_argument, NULL, OPTION_ARC8 },
#define OPTION_ARC (OPTION_MD_BASE + 6)
{ "marc", no_argument, NULL, OPTION_ARC },
{ NULL, no_argument, NULL, 0 }
};
size_t md_longopts_size = sizeof (md_longopts);
#define IS_SYMBOL_OPERAND(o) \
((o) == 'b' || (o) == 'c' || (o) == 's' || (o) == 'o' || (o) == 'O')
struct arc_operand_value *get_ext_suffix (char *s);
int
md_parse_option (c, arg)
int c;
char *arg ATTRIBUTE_UNUSED;
{
switch (c)
{
case OPTION_ARC5:
arc_mach_type = bfd_mach_arc_5;
break;
case OPTION_ARC:
case OPTION_ARC6:
arc_mach_type = bfd_mach_arc_6;
break;
case OPTION_ARC7:
arc_mach_type = bfd_mach_arc_7;
break;
case OPTION_ARC8:
arc_mach_type = bfd_mach_arc_8;
break;
case OPTION_EB:
byte_order = BIG_ENDIAN;
arc_target_format = "elf32-bigarc";
break;
case OPTION_EL:
byte_order = LITTLE_ENDIAN;
arc_target_format = "elf32-littlearc";
break;
default:
return 0;
}
return 1;
}
void
md_show_usage (stream)
FILE *stream;
{
fprintf (stream, "\
ARC Options:\n\
-marc[5|6|7|8] select processor variant (default arc%d)\n\
-EB assemble code for a big endian cpu\n\
-EL assemble code for a little endian cpu\n", arc_mach_type + 5);
}
void
md_begin ()
{
target_big_endian = byte_order == BIG_ENDIAN;
if (!bfd_set_arch_mach (stdoutput, bfd_arch_arc, arc_mach_type))
as_warn ("could not set architecture and machine");
arc_opcode_init_tables (arc_get_opcode_mach (arc_mach_type,
target_big_endian));
}
static void
init_opcode_tables (mach)
int mach;
{
int i;
char *last;
if ((arc_suffix_hash = hash_new ()) == NULL)
as_fatal ("virtual memory exhausted");
if (!bfd_set_arch_mach (stdoutput, bfd_arch_arc, mach))
as_warn ("could not set architecture and machine");
arc_opcode_init_tables (arc_get_opcode_mach (mach, target_big_endian));
last = "";
for (i = 0; i < arc_suffixes_count; i++)
{
if (strcmp (arc_suffixes[i].name, last) != 0)
hash_insert (arc_suffix_hash, arc_suffixes[i].name, (PTR) (arc_suffixes + i));
last = arc_suffixes[i].name;
}
for (i = 0; i < arc_reg_names_count; i++)
{
if (symbol_find (arc_reg_names[i].name))
continue;
symbol_table_insert (symbol_create (arc_reg_names[i].name,
reg_section,
(int) &arc_reg_names[i],
&zero_address_frag));
}
cpu_tables_init_p = 1;
}
static arc_insn
arc_insert_operand (insn, operand, mods, reg, val, file, line)
arc_insn insn;
const struct arc_operand *operand;
int mods;
const struct arc_operand_value *reg;
offsetT val;
char *file;
unsigned int line;
{
if (operand->bits != 32)
{
long min, max;
offsetT test;
if ((operand->flags & ARC_OPERAND_SIGNED) != 0)
{
if ((operand->flags & ARC_OPERAND_SIGNOPT) != 0)
max = (1 << operand->bits) - 1;
else
max = (1 << (operand->bits - 1)) - 1;
min = - (1 << (operand->bits - 1));
}
else
{
max = (1 << operand->bits) - 1;
min = 0;
}
if ((operand->flags & ARC_OPERAND_NEGATIVE) != 0)
test = - val;
else
test = val;
if (test < (offsetT) min || test > (offsetT) max)
as_warn_value_out_of_range (_("operand"), test, (offsetT) min, (offsetT) max, file, line);
}
if (operand->insert)
{
const char *errmsg;
errmsg = NULL;
insn = (*operand->insert) (insn, operand, mods, reg, (long) val, &errmsg);
if (errmsg != (const char *) NULL)
as_warn (errmsg);
}
else
insn |= (((long) val & ((1 << operand->bits) - 1))
<< operand->shift);
return insn;
}
struct arc_fixup {
int opindex;
expressionS exp;
};
#define MAX_FIXUPS 5
#define MAX_SUFFIXES 5
void
md_assemble (str)
char *str;
{
const struct arc_opcode *opcode;
const struct arc_opcode *std_opcode;
struct arc_opcode *ext_opcode;
char *start;
const char *last_errmsg = 0;
arc_insn insn;
static int init_tables_p = 0;
if (!init_tables_p)
{
init_opcode_tables (arc_mach_type);
init_tables_p = 1;
}
while (ISSPACE (*str))
str++;
ext_opcode = arc_ext_opcodes;
std_opcode = arc_opcode_lookup_asm (str);
start = str;
for (opcode = (ext_opcode ? ext_opcode : std_opcode);
opcode != NULL;
opcode = (ARC_OPCODE_NEXT_ASM (opcode)
? ARC_OPCODE_NEXT_ASM (opcode)
: (ext_opcode ? ext_opcode = NULL, std_opcode : NULL)))
{
int past_opcode_p, fc, num_suffixes;
int fix_up_at = 0;
char *syn;
struct arc_fixup fixups[MAX_FIXUPS];
int limm_reloc_p;
int ext_suffix_p;
const struct arc_operand_value *insn_suffixes[MAX_SUFFIXES];
if (! arc_opcode_supported (opcode))
continue;
arc_opcode_init_insert ();
insn = opcode->value;
fc = 0;
past_opcode_p = 0;
num_suffixes = 0;
limm_reloc_p = 0;
ext_suffix_p = 0;
for (str = start, syn = opcode->syntax; *syn != '\0';)
{
int mods;
const struct arc_operand *operand;
if (*syn != '%' || *++syn == '%')
{
if (*str == *syn)
{
if (*syn == ' ')
past_opcode_p = 1;
++syn;
++str;
}
else
break;
continue;
}
mods = 0;
while (ARC_MOD_P (arc_operands[arc_operand_map[(int) *syn]].flags))
{
mods |= arc_operands[arc_operand_map[(int) *syn]].flags & ARC_MOD_BITS;
++syn;
}
operand = arc_operands + arc_operand_map[(int) *syn];
if (operand->fmt == 0)
as_fatal ("unknown syntax format character `%c'", *syn);
if (operand->flags & ARC_OPERAND_FAKE)
{
const char *errmsg = NULL;
if (operand->insert)
{
insn = (*operand->insert) (insn, operand, mods, NULL, 0, &errmsg);
if (errmsg != (const char *) NULL)
{
last_errmsg = errmsg;
if (operand->flags & ARC_OPERAND_ERROR)
{
as_bad (errmsg);
return;
}
else if (operand->flags & ARC_OPERAND_WARN)
as_warn (errmsg);
break;
}
if (limm_reloc_p
&& (operand->flags && operand->flags & ARC_OPERAND_LIMM)
&& (operand->flags &
(ARC_OPERAND_ABSOLUTE_BRANCH | ARC_OPERAND_ADDRESS)))
{
fixups[fix_up_at].opindex = arc_operand_map[operand->fmt];
}
}
++syn;
}
else if (!past_opcode_p)
{
int found;
char c;
char *s, *t;
const struct arc_operand_value *suf, *suffix_end;
const struct arc_operand_value *suffix = NULL;
if (!(operand->flags & ARC_OPERAND_SUFFIX))
abort ();
if (*str == ' ')
{
++syn;
continue;
}
s = str;
if (mods & ARC_MOD_DOT)
{
if (*s != '.')
break;
++s;
}
else
{
if (*s == '.')
{
++syn;
continue;
}
}
for (t = s; *t && ISALNUM (*t); ++t)
continue;
c = *t;
*t = '\0';
if ((suf = get_ext_suffix (s)))
ext_suffix_p = 1;
else
suf = hash_find (arc_suffix_hash, s);
if (!suf)
{
*t = c;
break;
}
found = 0;
if (ext_suffix_p && arc_operands[suf->type].fmt == *syn)
{
*t = c;
if (operand->insert)
insn = (*operand->insert) (insn, operand,
mods, NULL, suf->value,
NULL);
else
insn |= suf->value << operand->shift;
suffix = suf;
str = t;
found = 1;
}
else
{
*t = c;
suffix_end = arc_suffixes + arc_suffixes_count;
for (suffix = suf;
suffix < suffix_end && strcmp (suffix->name, suf->name) == 0;
++suffix)
{
if (arc_operands[suffix->type].fmt == *syn)
{
if (operand->insert)
insn = (*operand->insert) (insn, operand,
mods, NULL, suffix->value,
NULL);
else
insn |= suffix->value << operand->shift;
str = t;
found = 1;
break;
}
}
}
++syn;
if (!found)
;
else
{
if (num_suffixes == MAX_SUFFIXES)
as_bad ("too many suffixes");
else
insn_suffixes[num_suffixes++] = suffix;
}
}
else
{
char *hold;
const struct arc_operand_value *reg = NULL;
long value = 0;
expressionS exp;
if (operand->flags & ARC_OPERAND_SUFFIX)
abort ();
if (is_end_of_line[(unsigned char) *str])
break;
hold = input_line_pointer;
input_line_pointer = str;
expression (&exp);
str = input_line_pointer;
input_line_pointer = hold;
if (exp.X_op == O_illegal)
as_bad ("illegal operand");
else if (exp.X_op == O_absent)
as_bad ("missing operand");
else if (exp.X_op == O_constant)
{
value = exp.X_add_number;
}
else if (exp.X_op == O_register)
{
reg = (struct arc_operand_value *) exp.X_add_number;
}
#define IS_REG_DEST_OPERAND(o) ((o) == 'a')
else if (IS_REG_DEST_OPERAND (*syn))
as_bad ("symbol as destination register");
else
{
if (!strncmp (str, "@h30", 4))
{
arc_code_symbol (&exp);
str += 4;
}
if (fc >= MAX_FIXUPS)
as_fatal ("too many fixups");
fixups[fc].exp = exp;
#define IS_REG_SHIMM_OFFSET(o) ((o) == 'd')
if (IS_REG_SHIMM_OFFSET (*syn))
break;
if (IS_SYMBOL_OPERAND (*syn))
{
const char *junk;
limm_reloc_p = 1;
fix_up_at = fc;
(*arc_operands[arc_operand_map['Q']].insert)
(insn, operand, mods, reg, 0L, &junk);
}
else
fixups[fc].opindex = arc_operand_map[(int) *syn];
++fc;
value = 0;
}
if (operand->insert)
{
const char *errmsg = NULL;
insn = (*operand->insert) (insn, operand, mods,
reg, (long) value, &errmsg);
if (errmsg != (const char *) NULL)
{
last_errmsg = errmsg;
if (operand->flags & ARC_OPERAND_ERROR)
{
as_bad (errmsg);
return;
}
else if (operand->flags & ARC_OPERAND_WARN)
as_warn (errmsg);
break;
}
}
else
insn |= (value & ((1 << operand->bits) - 1)) << operand->shift;
++syn;
}
}
if (*syn == '\0')
{
int i;
char *f;
long limm, limm_p;
while (ISSPACE (*str))
++str;
if (!is_end_of_line[(unsigned char) *str])
as_bad ("junk at end of line: `%s'", str);
limm_p = arc_opcode_limm_p (&limm);
{
static int in_delay_slot_p = 0;
static int prev_insn_needs_cc_nop_p = 0;
int delay_slot_type = ARC_DELAY_NONE;
int conditional = 0;
int cc_set_p = 0;
int cond_branch_p = opcode->flags & ARC_OPCODE_COND_BRANCH;
for (i = 0; i < num_suffixes; ++i)
{
switch (arc_operands[insn_suffixes[i]->type].fmt)
{
case 'n':
delay_slot_type = insn_suffixes[i]->value;
break;
case 'q':
conditional = insn_suffixes[i]->value;
break;
case 'f':
cc_set_p = 1;
break;
}
}
if (in_delay_slot_p && limm_p)
as_warn ("8 byte instruction in delay slot");
if (delay_slot_type != ARC_DELAY_NONE
&& limm_p && arc_insn_not_jl (insn))
as_warn ("8 byte jump instruction with delay slot");
in_delay_slot_p = (delay_slot_type != ARC_DELAY_NONE) && !limm_p;
if (cond_branch_p && conditional != 0
&& prev_insn_needs_cc_nop_p && arc_mach_type == bfd_mach_arc_5)
as_warn ("conditional branch follows set of flags");
prev_insn_needs_cc_nop_p =
cc_set_p && !limm_p;
}
if (limm_p)
{
f = frag_more (8);
md_number_to_chars (f, insn, 4);
md_number_to_chars (f + 4, limm, 4);
dwarf2_emit_insn (8);
}
else if (limm_reloc_p)
{
abort ();
}
else
{
f = frag_more (4);
md_number_to_chars (f, insn, 4);
dwarf2_emit_insn (4);
}
for (i = 0; i < fc; ++i)
{
int op_type, reloc_type;
expressionS exptmp;
const struct arc_operand *operand;
if (arc_operands[fixups[i].opindex].flags & ARC_OPERAND_LIMM)
{
fixups[i].exp.X_add_number += arc_limm_fixup_adjust (insn);
op_type = fixups[i].opindex;
if (op_type == arc_operand_map['L']
|| op_type == arc_operand_map['s']
|| op_type == arc_operand_map['o']
|| op_type == arc_operand_map['O'])
reloc_type = BFD_RELOC_32;
else if (op_type == arc_operand_map['J'])
reloc_type = BFD_RELOC_ARC_B26;
else
abort ();
reloc_type = get_arc_exp_reloc_type (1, reloc_type,
&fixups[i].exp,
&exptmp);
}
else
{
op_type = get_arc_exp_reloc_type (0, fixups[i].opindex,
&fixups[i].exp, &exptmp);
reloc_type = op_type + (int) BFD_RELOC_UNUSED;
}
operand = &arc_operands[op_type];
fix_new_exp (frag_now,
((f - frag_now->fr_literal)
+ (operand->flags & ARC_OPERAND_LIMM ? 4 : 0)), 4,
&exptmp,
(operand->flags & ARC_OPERAND_RELATIVE_BRANCH) != 0,
(bfd_reloc_code_real_type) reloc_type);
}
return;
}
}
if (NULL == last_errmsg)
as_bad ("bad instruction `%s'", start);
else
as_bad (last_errmsg);
}
static void
arc_extoper (opertype)
int opertype;
{
char *name;
char *mode;
char c;
char *p;
int imode = 0;
int number;
struct arc_ext_operand_value *ext_oper;
symbolS *symbolP;
segT old_sec;
int old_subsec;
name = input_line_pointer;
c = get_symbol_end ();
name = xstrdup (name);
p = name;
while (*p)
{
*p = TOLOWER (*p);
p++;
}
p = input_line_pointer;
*p = c;
SKIP_WHITESPACE ();
if (*input_line_pointer != ',')
{
as_bad ("expected comma after operand name");
ignore_rest_of_line ();
free (name);
return;
}
input_line_pointer++;
number = get_absolute_expression ();
if (number < 0)
{
as_bad ("negative operand number %d", number);
ignore_rest_of_line ();
free (name);
return;
}
if (opertype)
{
SKIP_WHITESPACE ();
if (*input_line_pointer != ',')
{
as_bad ("expected comma after register-number");
ignore_rest_of_line ();
free (name);
return;
}
input_line_pointer++;
mode = input_line_pointer;
if (!strncmp (mode, "r|w", 3))
{
imode = 0;
input_line_pointer += 3;
}
else
{
if (!strncmp (mode, "r", 1))
{
imode = ARC_REGISTER_READONLY;
input_line_pointer += 1;
}
else
{
if (strncmp (mode, "w", 1))
{
as_bad ("invalid mode");
ignore_rest_of_line ();
free (name);
return;
}
else
{
imode = ARC_REGISTER_WRITEONLY;
input_line_pointer += 1;
}
}
}
SKIP_WHITESPACE ();
if (1 == opertype)
{
if (*input_line_pointer != ',')
{
as_bad ("expected comma after register-mode");
ignore_rest_of_line ();
free (name);
return;
}
input_line_pointer++;
if (!strncmp (input_line_pointer, "cannot_shortcut", 15))
{
imode |= arc_get_noshortcut_flag ();
input_line_pointer += 15;
}
else
{
if (strncmp (input_line_pointer, "can_shortcut", 12))
{
as_bad ("shortcut designator invalid");
ignore_rest_of_line ();
free (name);
return;
}
else
{
input_line_pointer += 12;
}
}
}
}
if ((opertype == 1) && number > 60)
{
as_bad ("core register value (%d) too large", number);
ignore_rest_of_line ();
free (name);
return;
}
if ((opertype == 0) && number > 31)
{
as_bad ("condition code value (%d) too large", number);
ignore_rest_of_line ();
free (name);
return;
}
ext_oper = (struct arc_ext_operand_value *) \
xmalloc (sizeof (struct arc_ext_operand_value));
if (opertype)
{
if ((symbolP = symbol_find (name)))
{
if (S_GET_SEGMENT (symbolP) == reg_section)
S_SET_VALUE (symbolP, (int) &ext_oper->operand);
else
{
as_bad ("attempt to override symbol: %s", name);
ignore_rest_of_line ();
free (name);
free (ext_oper);
return;
}
}
else
{
symbol_table_insert (symbol_create (name, reg_section,
(int) &ext_oper->operand, &zero_address_frag));
}
}
ext_oper->operand.name = name;
ext_oper->operand.value = number;
ext_oper->operand.type = arc_operand_type (opertype);
ext_oper->operand.flags = imode;
ext_oper->next = arc_ext_operands;
arc_ext_operands = ext_oper;
old_sec = now_seg;
old_subsec = now_subseg;
arc_set_ext_seg ();
switch (opertype)
{
case 0:
p = frag_more (1);
*p = 3 + strlen (name) + 1;
p = frag_more (1);
*p = EXT_COND_CODE;
p = frag_more (1);
*p = number;
p = frag_more (strlen (name) + 1);
strcpy (p, name);
break;
case 1:
p = frag_more (1);
*p = 3 + strlen (name) + 1;
p = frag_more (1);
*p = EXT_CORE_REGISTER;
p = frag_more (1);
*p = number;
p = frag_more (strlen (name) + 1);
strcpy (p, name);
break;
case 2:
p = frag_more (1);
*p = 6 + strlen (name) + 1;
p = frag_more (1);
*p = EXT_AUX_REGISTER;
p = frag_more (1);
*p = number >> 24 & 0xff;
p = frag_more (1);
*p = number >> 16 & 0xff;
p = frag_more (1);
*p = number >> 8 & 0xff;
p = frag_more (1);
*p = number & 0xff;
p = frag_more (strlen (name) + 1);
strcpy (p, name);
break;
default:
as_bad ("invalid opertype");
ignore_rest_of_line ();
free (name);
return;
break;
}
subseg_set (old_sec, old_subsec);
demand_empty_rest_of_line ();
}
static void
arc_extinst (ignore)
int ignore ATTRIBUTE_UNUSED;
{
char syntax[129];
char *name;
char *p;
char c;
int suffixcode = -1;
int opcode, subopcode;
int i;
int class = 0;
int name_len;
struct arc_opcode *ext_op;
segT old_sec;
int old_subsec;
name = input_line_pointer;
c = get_symbol_end ();
name = xstrdup (name);
strcpy (syntax, name);
name_len = strlen (name);
p = input_line_pointer;
*p = c;
SKIP_WHITESPACE ();
if (*input_line_pointer != ',')
{
as_bad ("expected comma after operand name");
ignore_rest_of_line ();
return;
}
input_line_pointer++;
opcode = get_absolute_expression ();
SKIP_WHITESPACE ();
if (*input_line_pointer != ',')
{
as_bad ("expected comma after opcode");
ignore_rest_of_line ();
return;
}
input_line_pointer++;
subopcode = get_absolute_expression ();
if (subopcode < 0)
{
as_bad ("negative subopcode %d", subopcode);
ignore_rest_of_line ();
return;
}
if (subopcode)
{
if (3 != opcode)
{
as_bad ("subcode value found when opcode not equal 0x03");
ignore_rest_of_line ();
return;
}
else
{
if (subopcode < 0x09 || subopcode == 0x3f)
{
as_bad ("invalid subopcode %d", subopcode);
ignore_rest_of_line ();
return;
}
}
}
SKIP_WHITESPACE ();
if (*input_line_pointer != ',')
{
as_bad ("expected comma after subopcode");
ignore_rest_of_line ();
return;
}
input_line_pointer++;
for (i = 0; i < (int) MAXSUFFIXCLASS; i++)
{
if (!strncmp (suffixclass[i].name,input_line_pointer, suffixclass[i].len))
{
suffixcode = i;
input_line_pointer += suffixclass[i].len;
break;
}
}
if (-1 == suffixcode)
{
as_bad ("invalid suffix class");
ignore_rest_of_line ();
return;
}
SKIP_WHITESPACE ();
if (*input_line_pointer != ',')
{
as_bad ("expected comma after suffix class");
ignore_rest_of_line ();
return;
}
input_line_pointer++;
for (i = 0; i < (int) MAXSYNTAXCLASS; i++)
{
if (!strncmp (syntaxclass[i].name,input_line_pointer, syntaxclass[i].len))
{
class = syntaxclass[i].class;
input_line_pointer += syntaxclass[i].len;
break;
}
}
if (0 == (SYNTAX_VALID & class))
{
as_bad ("invalid syntax class");
ignore_rest_of_line ();
return;
}
if ((0x3 == opcode) & (class & SYNTAX_3OP))
{
as_bad ("opcode 0x3 and SYNTAX_3OP invalid");
ignore_rest_of_line ();
return;
}
switch (suffixcode)
{
case 0:
strcat (syntax, "%.q%.f ");
break;
case 1:
strcat (syntax, "%.f ");
break;
case 2:
strcat (syntax, "%.q ");
break;
case 3:
strcat (syntax, " ");
break;
default:
as_bad ("unknown suffix class");
ignore_rest_of_line ();
return;
break;
};
strcat (syntax, ((opcode == 0x3) ? "%a,%b" : ((class & SYNTAX_3OP) ? "%a,%b,%c" : "%b,%c")));
if (suffixcode < 2)
strcat (syntax, "%F");
strcat (syntax, "%S%L");
ext_op = (struct arc_opcode *) xmalloc (sizeof (struct arc_opcode));
ext_op->syntax = xstrdup (syntax);
ext_op->mask = I (-1) | ((0x3 == opcode) ? C (-1) : 0);
ext_op->value = I (opcode) | ((0x3 == opcode) ? C (subopcode) : 0);
ext_op->flags = class;
ext_op->next_asm = arc_ext_opcodes;
ext_op->next_dis = arc_ext_opcodes;
arc_ext_opcodes = ext_op;
old_sec = now_seg;
old_subsec = now_subseg;
arc_set_ext_seg ();
p = frag_more (1);
*p = 5 + name_len + 1;
p = frag_more (1);
*p = EXT_INSTRUCTION;
p = frag_more (1);
*p = opcode;
p = frag_more (1);
*p = subopcode;
p = frag_more (1);
*p = (class & (OP1_MUST_BE_IMM | OP1_IMM_IMPLIED) ? IGNORE_FIRST_OPD : 0);
p = frag_more (name_len);
strncpy (p, syntax, name_len);
p = frag_more (1);
*p = '\0';
subseg_set (old_sec, old_subsec);
demand_empty_rest_of_line ();
}
int
arc_set_ext_seg ()
{
if (!arcext_section)
{
arcext_section = subseg_new (".arcextmap", 0);
bfd_set_section_flags (stdoutput, arcext_section,
SEC_READONLY | SEC_HAS_CONTENTS);
}
else
subseg_set (arcext_section, 0);
return 1;
}
static void
arc_common (localScope)
int localScope;
{
char *name;
char c;
char *p;
int align, size;
symbolS *symbolP;
name = input_line_pointer;
c = get_symbol_end ();
p = input_line_pointer;
*p = c;
SKIP_WHITESPACE ();
if (*input_line_pointer != ',')
{
as_bad ("expected comma after symbol name");
ignore_rest_of_line ();
return;
}
input_line_pointer++;
size = get_absolute_expression ();
if (size < 0)
{
as_bad ("negative symbol length");
ignore_rest_of_line ();
return;
}
*p = 0;
symbolP = symbol_find_or_make (name);
*p = c;
if (S_IS_DEFINED (symbolP) && ! S_IS_COMMON (symbolP))
{
as_bad ("ignoring attempt to re-define symbol");
ignore_rest_of_line ();
return;
}
if (((int) S_GET_VALUE (symbolP) != 0) \
&& ((int) S_GET_VALUE (symbolP) != size))
{
as_warn ("length of symbol \"%s\" already %ld, ignoring %d",
S_GET_NAME (symbolP), (long) S_GET_VALUE (symbolP), size);
}
assert (symbolP->sy_frag == &zero_address_frag);
if (*input_line_pointer == ',')
{
input_line_pointer++;
align = get_absolute_expression ();
if (align < 0)
{
align = 0;
as_warn ("assuming symbol alignment of zero");
}
}
else
align = 0;
if (localScope != 0)
{
segT old_sec;
int old_subsec;
char *pfrag;
old_sec = now_seg;
old_subsec = now_subseg;
record_alignment (bss_section, align);
subseg_set (bss_section, 0);
if (align)
frag_align (align, 0, 0);
if (S_GET_SEGMENT (symbolP) == bss_section)
symbolP->sy_frag->fr_symbol = NULL;
symbolP->sy_frag = frag_now;
pfrag = frag_var (rs_org, 1, 1, (relax_substateT) 0, symbolP,
(offsetT) size, (char *) 0);
*pfrag = 0;
S_SET_SIZE (symbolP, size);
S_SET_SEGMENT (symbolP, bss_section);
S_CLEAR_EXTERNAL (symbolP);
symbolP->local = 1;
subseg_set (old_sec, old_subsec);
}
else
{
S_SET_VALUE (symbolP, (valueT) size);
S_SET_ALIGN (symbolP, align);
S_SET_EXTERNAL (symbolP);
S_SET_SEGMENT (symbolP, bfd_com_section_ptr);
}
symbolP->bsym->flags |= BSF_OBJECT;
demand_empty_rest_of_line ();
}
static void
arc_option (ignore)
int ignore ATTRIBUTE_UNUSED;
{
int mach;
char c;
char *cpu;
cpu = input_line_pointer;
c = get_symbol_end ();
mach = arc_get_mach (cpu);
*input_line_pointer = c;
if (cpu_tables_init_p)
{
as_bad ("\".option\" directive must appear before any instructions");
ignore_rest_of_line ();
return;
}
if (mach == -1)
goto bad_cpu;
if (mach_type_specified_p && mach != arc_mach_type)
{
as_bad ("\".option\" directive conflicts with initial definition");
ignore_rest_of_line ();
return;
}
else
{
if (mach != arc_mach_type)
as_warn ("\".option\" directive overrides command-line (default) value");
arc_mach_type = mach;
if (!bfd_set_arch_mach (stdoutput, bfd_arch_arc, mach))
as_fatal ("could not set architecture and machine");
mach_type_specified_p = 1;
}
demand_empty_rest_of_line ();
return;
bad_cpu:
as_bad ("invalid identifier for \".option\"");
ignore_rest_of_line ();
}
#define MAX_LITTLENUMS 6
char *
md_atof (type, litP, sizeP)
int type;
char *litP;
int *sizeP;
{
int prec;
LITTLENUM_TYPE words[MAX_LITTLENUMS];
LITTLENUM_TYPE *wordP;
char *t;
switch (type)
{
case 'f':
case 'F':
prec = 2;
break;
case 'd':
case 'D':
prec = 4;
break;
default:
*sizeP = 0;
return "bad call to md_atof";
}
t = atof_ieee (input_line_pointer, type, words);
if (t)
input_line_pointer = t;
*sizeP = prec * sizeof (LITTLENUM_TYPE);
for (wordP = words; prec--;)
{
md_number_to_chars (litP, (valueT) (*wordP++), sizeof (LITTLENUM_TYPE));
litP += sizeof (LITTLENUM_TYPE);
}
return NULL;
}
void
md_number_to_chars (buf, val, n)
char *buf;
valueT val;
int n;
{
if (target_big_endian)
number_to_chars_bigendian (buf, val, n);
else
number_to_chars_littleendian (buf, val, n);
}
valueT
md_section_align (segment, size)
segT segment;
valueT size;
{
int align = bfd_get_section_alignment (stdoutput, segment);
return ((size + (1 << align) - 1) & (-1 << align));
}
int
md_estimate_size_before_relax (fragp, seg)
fragS *fragp ATTRIBUTE_UNUSED;
asection *seg ATTRIBUTE_UNUSED;
{
as_fatal (_("md_estimate_size_before_relax\n"));
return 1;
}
void
md_convert_frag (abfd, sec, fragp)
bfd *abfd ATTRIBUTE_UNUSED;
asection *sec ATTRIBUTE_UNUSED;
fragS *fragp ATTRIBUTE_UNUSED;
{
as_fatal (_("md_convert_frag\n"));
}
void
arc_code_symbol (expressionP)
expressionS *expressionP;
{
if (expressionP->X_op == O_symbol && expressionP->X_add_number == 0)
{
expressionS two;
expressionP->X_op = O_right_shift;
expressionP->X_add_symbol->sy_value.X_op = O_constant;
two.X_op = O_constant;
two.X_add_symbol = two.X_op_symbol = NULL;
two.X_add_number = 2;
expressionP->X_op_symbol = make_expr_symbol (&two);
}
else if (expressionP->X_op == O_subtract
&& expressionP->X_add_symbol != NULL
&& expressionP->X_op_symbol != NULL
&& expressionP->X_add_number == 0)
{
expressionS two;
expressionP->X_add_symbol = make_expr_symbol (expressionP);
expressionP->X_op = O_right_shift;
two.X_op = O_constant;
two.X_add_symbol = two.X_op_symbol = NULL;
two.X_add_number = 2;
expressionP->X_op_symbol = make_expr_symbol (&two);
}
else
{
as_bad ("expression too complex code symbol");
return;
}
}
void
md_operand (expressionP)
expressionS *expressionP;
{
char *p = input_line_pointer;
if (*p != '%')
return;
if (strncmp (p, "%st(", 4) == 0)
{
input_line_pointer += 4;
expression (expressionP);
if (*input_line_pointer != ')')
{
as_bad ("missing ')' in %%-op");
return;
}
++input_line_pointer;
arc_code_symbol (expressionP);
}
else
{
int i, l;
struct arc_ext_operand_value *ext_oper = arc_ext_operands;
p++;
while (ext_oper)
{
l = strlen (ext_oper->operand.name);
if (!strncmp (p, ext_oper->operand.name, l) && !ISALNUM (*(p + l)))
{
input_line_pointer += l + 1;
expressionP->X_op = O_register;
expressionP->X_add_number = (int) &ext_oper->operand;
return;
}
ext_oper = ext_oper->next;
}
for (i = 0; i < arc_reg_names_count; i++)
{
l = strlen (arc_reg_names[i].name);
if (!strncmp (p, arc_reg_names[i].name, l) && !ISALNUM (*(p + l)))
{
input_line_pointer += l + 1;
expressionP->X_op = O_register;
expressionP->X_add_number = (int) &arc_reg_names[i];
break;
}
}
}
}
symbolS *
md_undefined_symbol (name)
char *name ATTRIBUTE_UNUSED;
{
return 0;
}
void
arc_parse_cons_expression (exp, nbytes)
expressionS *exp;
unsigned int nbytes ATTRIBUTE_UNUSED;
{
char *p = input_line_pointer;
int code_symbol_fix = 0;
for (; ! is_end_of_line[(unsigned char) *p]; p++)
if (*p == '@' && !strncmp (p, "@h30", 4))
{
code_symbol_fix = 1;
strcpy (p, "; ");
}
expr (0, exp);
if (code_symbol_fix)
{
arc_code_symbol (exp);
input_line_pointer = p;
}
}
void
arc_cons_fix_new (frag, where, nbytes, exp)
fragS *frag;
int where;
int nbytes;
expressionS *exp;
{
if (nbytes == 4)
{
int reloc_type;
expressionS exptmp;
reloc_type = get_arc_exp_reloc_type (1, BFD_RELOC_32, exp, &exptmp);
fix_new_exp (frag, where, nbytes, &exptmp, 0, reloc_type);
}
else
{
fix_new_exp (frag, where, nbytes, exp, 0,
nbytes == 2 ? BFD_RELOC_16
: nbytes == 8 ? BFD_RELOC_64
: BFD_RELOC_32);
}
}
long
md_pcrel_from (fixP)
fixS *fixP;
{
return fixP->fx_frag->fr_address + fixP->fx_where + fixP->fx_size;
}
static int
get_arc_exp_reloc_type (data_p, default_type, exp, expnew)
int data_p;
int default_type;
expressionS *exp;
expressionS *expnew;
{
if (exp->X_op == O_right_shift
&& exp->X_op_symbol != NULL
&& exp->X_op_symbol->sy_value.X_op == O_constant
&& exp->X_op_symbol->sy_value.X_add_number == 2
&& exp->X_add_number == 0)
{
if (exp->X_add_symbol != NULL
&& (exp->X_add_symbol->sy_value.X_op == O_constant
|| exp->X_add_symbol->sy_value.X_op == O_symbol))
{
*expnew = *exp;
expnew->X_op = O_symbol;
expnew->X_op_symbol = NULL;
return data_p ? BFD_RELOC_ARC_B26 : arc_operand_map['J'];
}
else if (exp->X_add_symbol != NULL
&& exp->X_add_symbol->sy_value.X_op == O_subtract)
{
*expnew = exp->X_add_symbol->sy_value;
return data_p ? BFD_RELOC_ARC_B26 : arc_operand_map['J'];
}
}
*expnew = *exp;
return default_type;
}
void
md_apply_fix3 (fixP, valP, seg)
fixS *fixP;
valueT * valP;
segT seg;
{
valueT value = * valP;
if (fixP->fx_addsy == (symbolS *) NULL)
fixP->fx_done = 1;
else if (fixP->fx_pcrel)
{
if (S_GET_SEGMENT (fixP->fx_addsy) != seg)
value += md_pcrel_from (fixP);
}
if (fixP->fx_subsy != NULL)
as_bad_where (fixP->fx_file, fixP->fx_line, _("expression too complex"));
if ((int) fixP->fx_r_type >= (int) BFD_RELOC_UNUSED)
{
int opindex;
const struct arc_operand *operand;
char *where;
arc_insn insn;
opindex = (int) fixP->fx_r_type - (int) BFD_RELOC_UNUSED;
operand = &arc_operands[opindex];
where = fixP->fx_frag->fr_literal + fixP->fx_where;
if (target_big_endian)
insn = bfd_getb32 ((unsigned char *) where);
else
insn = bfd_getl32 ((unsigned char *) where);
insn = arc_insert_operand (insn, operand, -1, NULL, (offsetT) value,
fixP->fx_file, fixP->fx_line);
if (target_big_endian)
bfd_putb32 ((bfd_vma) insn, (unsigned char *) where);
else
bfd_putl32 ((bfd_vma) insn, (unsigned char *) where);
if (fixP->fx_done)
{
return;
}
if (operand->fmt == 'B')
{
assert ((operand->flags & ARC_OPERAND_RELATIVE_BRANCH) != 0
&& operand->bits == 20
&& operand->shift == 7);
fixP->fx_r_type = BFD_RELOC_ARC_B22_PCREL;
}
else if (operand->fmt == 'J')
{
assert ((operand->flags & ARC_OPERAND_ABSOLUTE_BRANCH) != 0
&& operand->bits == 24
&& operand->shift == 32);
fixP->fx_r_type = BFD_RELOC_ARC_B26;
}
else if (operand->fmt == 'L')
{
assert ((operand->flags & ARC_OPERAND_LIMM) != 0
&& operand->bits == 32
&& operand->shift == 32);
fixP->fx_r_type = BFD_RELOC_32;
}
else
{
as_bad_where (fixP->fx_file, fixP->fx_line,
"unresolved expression that must be resolved");
fixP->fx_done = 1;
return;
}
}
else
{
switch (fixP->fx_r_type)
{
case BFD_RELOC_8:
md_number_to_chars (fixP->fx_frag->fr_literal + fixP->fx_where,
value, 1);
break;
case BFD_RELOC_16:
md_number_to_chars (fixP->fx_frag->fr_literal + fixP->fx_where,
value, 2);
break;
case BFD_RELOC_32:
md_number_to_chars (fixP->fx_frag->fr_literal + fixP->fx_where,
value, 4);
break;
case BFD_RELOC_ARC_B26:
value >>= 2;
md_number_to_chars (fixP->fx_frag->fr_literal + fixP->fx_where,
value, 4);
break;
default:
abort ();
}
}
}
arelent *
tc_gen_reloc (section, fixP)
asection *section ATTRIBUTE_UNUSED;
fixS *fixP;
{
arelent *reloc;
reloc = (arelent *) xmalloc (sizeof (arelent));
reloc->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
*reloc->sym_ptr_ptr = symbol_get_bfdsym (fixP->fx_addsy);
reloc->address = fixP->fx_frag->fr_address + fixP->fx_where;
reloc->howto = bfd_reloc_type_lookup (stdoutput, fixP->fx_r_type);
if (reloc->howto == (reloc_howto_type *) NULL)
{
as_bad_where (fixP->fx_file, fixP->fx_line,
"internal error: can't export reloc type %d (`%s')",
fixP->fx_r_type,
bfd_get_reloc_code_name (fixP->fx_r_type));
return NULL;
}
assert (!fixP->fx_pcrel == !reloc->howto->pc_relative);
reloc->addend = (fixP->fx_pcrel ? -4 : 0);
return reloc;
}