#include <stdio.h>
#include "as.h"
#include "safe-ctype.h"
#include "subsegs.h"
#include "symcat.h"
#include "opcodes/iq2000-desc.h"
#include "opcodes/iq2000-opc.h"
#include "cgen.h"
#include "elf/common.h"
#include "elf/iq2000.h"
#include "libbfd.h"
#include "hash.h"
#include "macro.h"
typedef struct
{
const CGEN_INSN * insn;
const CGEN_INSN * orig_insn;
CGEN_FIELDS fields;
#if CGEN_INT_INSN_P
CGEN_INSN_INT buffer [1];
#define INSN_VALUE(buf) (*(buf))
#else
unsigned char buffer [CGEN_MAX_INSN_SIZE];
#define INSN_VALUE(buf) (buf)
#endif
char * addr;
fragS * frag;
int num_fixups;
fixS * fixups [GAS_CGEN_MAX_FIXUPS];
int indices [MAX_OPERAND_INSTANCES];
}
iq2000_insn;
const char comment_chars[] = "#";
const char line_comment_chars[] = "";
const char line_separator_chars[] = ";";
const char EXP_CHARS[] = "eE";
const char FLT_CHARS[] = "dD";
#define DEFAULT_MACHINE bfd_mach_iq2000
#define DEFAULT_FLAGS EF_IQ2000_CPU_IQ2000
static unsigned long iq2000_mach = bfd_mach_iq2000;
static int cpu_mach = (1 << MACH_IQ2000);
static flagword iq2000_flags = DEFAULT_FLAGS;
typedef struct proc {
symbolS *isym;
unsigned long reg_mask;
unsigned long reg_offset;
unsigned long fpreg_mask;
unsigned long fpreg_offset;
unsigned long frame_offset;
unsigned long frame_reg;
unsigned long pc_reg;
} procS;
static procS cur_proc;
static procS *cur_proc_ptr;
static int numprocs;
static void s_change_sec PARAMS ((int));
static void s_iq2000_set PARAMS ((int));
static void s_iq2000_mask PARAMS ((int));
static void s_iq2000_frame PARAMS ((int));
static void s_iq2000_ent PARAMS ((int));
static void s_iq2000_end PARAMS ((int));
static int get_number PARAMS ((void));
static symbolS * get_symbol PARAMS ((void));
static void iq2000_record_hi16 PARAMS((int, fixS *, segT));
const pseudo_typeS md_pseudo_table[] =
{
{ "align", s_align_bytes, 0 },
{ "word", cons, 4 },
{ "rdata", s_change_sec, 'r'},
{ "sdata", s_change_sec, 's'},
{ "set", s_iq2000_set, 0 },
{ "ent", s_iq2000_ent, 0 },
{ "end", s_iq2000_end, 0 },
{ "frame", s_iq2000_frame, 0 },
{ "fmask", s_iq2000_mask, 'F' },
{ "mask", s_iq2000_mask, 'R' },
{ "dword", cons, 8 },
{ "half", cons, 2 },
{ NULL, NULL, 0 }
};
struct iq2000_hi_fixup
{
struct iq2000_hi_fixup * next;
fixS * fixp;
segT seg;
};
static struct iq2000_hi_fixup * iq2000_hi_fixup_list;
#define OPTION_CPU_2000 (OPTION_MD_BASE)
#define OPTION_CPU_10 (OPTION_MD_BASE + 1)
struct option md_longopts[] =
{
{ "m2000", no_argument, NULL, OPTION_CPU_2000 },
{ "m10", no_argument, NULL, OPTION_CPU_10 },
{ NULL, no_argument, NULL, 0 },
};
size_t md_longopts_size = sizeof (md_longopts);
const char * md_shortopts = "";
static void iq2000_add_macro PARAMS ((const char *, const char *, const char **));
static void iq2000_load_macros PARAMS ((void));
static void iq10_load_macros PARAMS ((void));
extern struct hash_control *macro_hash;
int
md_parse_option (c, arg)
int c ATTRIBUTE_UNUSED;
char * arg ATTRIBUTE_UNUSED;
{
switch (c)
{
case OPTION_CPU_2000:
iq2000_flags = (iq2000_flags & ~EF_IQ2000_CPU_MASK) | EF_IQ2000_CPU_IQ2000;
iq2000_mach = bfd_mach_iq2000;
cpu_mach = (1 << MACH_IQ2000);
break;
case OPTION_CPU_10:
iq2000_flags = (iq2000_flags & ~EF_IQ2000_CPU_MASK) | EF_IQ2000_CPU_IQ10;
iq2000_mach = bfd_mach_iq10;
cpu_mach = (1 << MACH_IQ10);
break;
default:
return 0;
}
return 1;
}
void
md_show_usage (stream)
FILE * stream;
{
fprintf (stream, _("IQ2000 specific command line options:\n"));
fprintf (stream, _("-m2000 <default> IQ2000 processor\n"));
fprintf (stream, _("-m10 IQ10 processor\n"));
}
void
md_begin ()
{
gas_cgen_cpu_desc = iq2000_cgen_cpu_open (CGEN_CPU_OPEN_MACHS, cpu_mach,
CGEN_CPU_OPEN_ENDIAN,
CGEN_ENDIAN_BIG,
CGEN_CPU_OPEN_END);
iq2000_cgen_init_asm (gas_cgen_cpu_desc);
cgen_set_parse_operand_fn (gas_cgen_cpu_desc, gas_cgen_parse_operand);
if (iq2000_flags)
bfd_set_private_flags (stdoutput, iq2000_flags);
bfd_default_set_arch_mach (stdoutput, bfd_arch_iq2000, iq2000_mach);
if (iq2000_mach == bfd_mach_iq2000)
iq2000_load_macros ();
else
iq10_load_macros ();
}
static void
iq2000_add_macro (name, semantics, arguments)
const char *name;
const char *semantics;
const char **arguments;
{
macro_entry *macro;
sb macro_name;
const char *namestr;
macro = (macro_entry *) xmalloc (sizeof (macro_entry));
sb_new (¯o->sub);
sb_new (¯o_name);
macro->formal_count = 0;
macro->formals = 0;
sb_add_string (¯o->sub, semantics);
if (arguments != NULL)
{
formal_entry **p = ¯o->formals;
macro->formal_count = 0;
macro->formal_hash = hash_new ();
while (*arguments != NULL)
{
formal_entry *formal;
formal = (formal_entry *) xmalloc (sizeof (formal_entry));
sb_new (&formal->name);
sb_new (&formal->def);
sb_new (&formal->actual);
if (strchr (*arguments,'='))
{
char * tt_args = strdup(*arguments);
char * tt_dflt = strchr(tt_args,'=');
*tt_dflt = 0;
sb_add_string (&formal->name, tt_args);
sb_add_string (&formal->def, tt_dflt + 1);
}
else
sb_add_string (&formal->name, *arguments);
hash_jam (macro->formal_hash, sb_terminate (&formal->name), formal);
formal->index = macro->formal_count;
macro->formal_count++;
*p = formal;
p = &formal->next;
*p = NULL;
++arguments;
}
}
sb_add_string (¯o_name, name);
namestr = sb_terminate (¯o_name);
hash_jam (macro_hash, namestr, (PTR) macro);
macro_defined = 1;
}
typedef struct {
const char * mnemonic;
const char ** expansion;
const char ** args;
} iq2000_macro_defs_s;
static const char * abs_args[] = { "rd", "rs", "scratch=%1", NULL };
static const char * abs_expn = "\n sra \\rd,\\rs,31\n xor \\scratch,\\rd,\\rs\n sub \\rd,\\scratch,\\rd\n";
static const char * la_expn = "\n lui \\reg,%hi(\\label)\n ori \\reg,\\reg,%lo(\\label)\n";
static const char * la_args[] = { "reg", "label", NULL };
static const char * bxx_args[] = { "rs", "rt", "label", "scratch=%1", NULL };
static const char * bge_expn = "\n slt \\scratch,\\rs,\\rt\n beq %0,\\scratch,\\label\n";
static const char * bgeu_expn = "\n sltu \\scratch,\\rs,\\rt\n beq %0,\\scratch,\\label\n";
static const char * bgt_expn = "\n slt \\scratch,\\rt,\\rs\n bne %0,\\scratch,\\label\n";
static const char * bgtu_expn = "\n sltu \\scratch,\\rt,\\rs\n bne %0,\\scratch,\\label\n";
static const char * ble_expn = "\n slt \\scratch,\\rt,\\rs\n beq %0,\\scratch,\\label\n";
static const char * bleu_expn = "\n sltu \\scratch,\\rt,\\rs\n beq %0,\\scratch,\\label\n";
static const char * blt_expn = "\n slt \\scratch,\\rs,\\rt\n bne %0,\\scratch,\\label\n";
static const char * bltu_expn = "\n sltu \\scratch,\\rs,\\rt\n bne %0,\\scratch,\\label\n";
static const char * sxx_args[] = { "rd", "rs", "rt", NULL };
static const char * sge_expn = "\n slt \\rd,\\rs,\\rt\n xori \\rd,\\rd,1\n";
static const char * sgeu_expn = "\n sltu \\rd,\\rs,\\rt\n xori \\rd,\\rd,1\n";
static const char * sle_expn = "\n slt \\rd,\\rt,\\rs\n xori \\rd,\\rd,1\n";
static const char * sleu_expn = "\n sltu \\rd,\\rt,\\rs\n xori \\rd,\\rd,1\n";
static const char * sgt_expn = "\n slt \\rd,\\rt,\\rs\n";
static const char * sgtu_expn = "\n sltu \\rd,\\rt,\\rs\n";
static const char * sne_expn = "\n xor \\rd,\\rt,\\rs\n sltu \\rd,%0,\\rd\n";
static const char * seq_expn = "\n xor \\rd,\\rt,\\rs\n sltu \\rd,%0,\\rd\n xori \\rd,\\rd,1\n";
static const char * ai32_args[] = { "rt", "rs", "imm", NULL };
static const char * andi32_expn = "\n\
.if (\\imm & 0xffff0000 == 0xffff0000)\n\
andoi \\rt,\\rs,%lo(\\imm)\n\
.elseif (\\imm & 0x0000ffff == 0x0000ffff)\n\
andoui \\rt,\\rs,%uhi(\\imm)\n\
.elseif (\\imm & 0xffff0000 == 0x00000000)\n\
andi \\rt,\\rs,%lo(\\imm)\n\
.else\n\
andoui \\rt,\\rs,%uhi(\\imm)\n\
andoi \\rt,\\rt,%lo(\\imm)\n\
.endif\n";
static const char * ori32_expn = "\n\
.if (\\imm & 0xffff == 0)\n\
orui \\rt,\\rs,%uhi(\\imm)\n\
.elseif (\\imm & 0xffff0000 == 0)\n\
ori \\rt,\\rs,%lo(\\imm)\n\
.else\n\
orui \\rt,\\rs,%uhi(\\imm)\n\
ori \\rt,\\rt,%lo(\\imm)\n\
.endif\n";
static const char * neg_args[] = { "rd", "rs", NULL };
static const char * neg_expn = "\n sub \\rd,%0,\\rs\n";
static const char * negu_expn = "\n subu \\rd,%0,\\rs\n";
static const char * li_args[] = { "rt", "imm", NULL };
static const char * li_expn = "\n\
.if (\\imm & 0xffff0000 == 0x0)\n\
ori \\rt,%0,\\imm\n\
.elseif (\\imm & 0xffff0000 == 0xffff0000)\n\
addi \\rt,%0,\\imm\n\
.elseif (\\imm & 0x0000ffff == 0)\n\
lui \\rt,%uhi(\\imm)\n\
.else\n\
lui \\rt,%uhi(\\imm)\n\
ori \\rt,\\rt,%lo(\\imm)\n\
.endif\n";
static iq2000_macro_defs_s iq2000_macro_defs[] = {
{"abs", (const char **)&abs_expn, (const char **)&abs_args},
{"la", (const char **)&la_expn, (const char **)&la_args},
{"bge", (const char **)&bge_expn, (const char **)&bxx_args},
{"bgeu", (const char **)&bgeu_expn, (const char **)&bxx_args},
{"bgt", (const char **)&bgt_expn, (const char **)&bxx_args},
{"bgtu", (const char **)&bgtu_expn, (const char **)&bxx_args},
{"ble", (const char **)&ble_expn, (const char **)&bxx_args},
{"bleu", (const char **)&bleu_expn, (const char **)&bxx_args},
{"blt", (const char **)&blt_expn, (const char **)&bxx_args},
{"bltu", (const char **)&bltu_expn, (const char **)&bxx_args},
{"sge", (const char **)&sge_expn, (const char **)&sxx_args},
{"sgeu", (const char **)&sgeu_expn, (const char **)&sxx_args},
{"sle", (const char **)&sle_expn, (const char **)&sxx_args},
{"sleu", (const char **)&sleu_expn, (const char **)&sxx_args},
{"sgt", (const char **)&sgt_expn, (const char **)&sxx_args},
{"sgtu", (const char **)&sgtu_expn, (const char **)&sxx_args},
{"seq", (const char **)&seq_expn, (const char **)&sxx_args},
{"sne", (const char **)&sne_expn, (const char **)&sxx_args},
{"neg", (const char **)&neg_expn, (const char **)&neg_args},
{"negu", (const char **)&negu_expn, (const char **)&neg_args},
{"li", (const char **)&li_expn, (const char **)&li_args},
{"ori32", (const char **)&ori32_expn, (const char **)&ai32_args},
{"andi32",(const char **)&andi32_expn,(const char **)&ai32_args},
};
static void
iq2000_load_macros ()
{
int i;
int mcnt = sizeof (iq2000_macro_defs) / sizeof (iq2000_macro_defs_s);
for (i = 0; i < mcnt; i++)
iq2000_add_macro (iq2000_macro_defs[i].mnemonic,
*iq2000_macro_defs[i].expansion,
iq2000_macro_defs[i].args);
}
static void
iq10_load_macros ()
{
iq2000_load_macros ();
#if 0
char *la_sem = "\n lui \\reg,%hi(\\label)\n ori \\reg,\\reg,%lo(\\label)\n";
char *la_arg_1 = "reg";
char *la_arg_2 = "label";
const char *la_args[3] = { la_arg_1, la_arg_2, NULL };
iq2000_add_macro ("la", la_sem, la_args);
#endif
}
void
md_assemble (str)
char * str;
{
static long delayed_load_register = 0;
static int last_insn_had_delay_slot = 0;
static int last_insn_has_load_delay = 0;
static int last_insn_unconditional_jump = 0;
static int last_insn_was_ldw = 0;
iq2000_insn insn;
char * errmsg;
gas_cgen_init_parse ();
insn.insn = iq2000_cgen_assemble_insn
(gas_cgen_cpu_desc, str, & insn.fields, insn.buffer, & errmsg);
if (!insn.insn)
{
as_bad ("%s", errmsg);
return;
}
gas_cgen_finish_insn (insn.insn, insn.buffer,
CGEN_FIELDS_BITSIZE (& insn.fields), 1, NULL);
if ((last_insn_had_delay_slot && !last_insn_has_load_delay) &&
CGEN_INSN_ATTR_VALUE (insn.insn, CGEN_INSN_YIELD_INSN))
as_bad (_("the yielding instruction %s may not be in a delay slot."),
CGEN_INSN_NAME (insn.insn));
if (iq2000_mach == bfd_mach_iq2000
&& CGEN_INSN_ATTR_VALUE (insn.insn, CGEN_INSN_EVEN_REG_NUM)
&& (insn.fields.f_rt % 2))
as_bad (_("Register number (R%ld) for double word access must be even."),
insn.fields.f_rt);
if (iq2000_mach == bfd_mach_iq10
&& CGEN_INSN_ATTR_VALUE (insn.insn, CGEN_INSN_EVEN_REG_NUM)
&& (insn.fields.f_rd % 2))
as_bad (_("Register number (R%ld) for double word access must be even."),
insn.fields.f_rd);
if (delayed_load_register && (last_insn_has_load_delay || last_insn_was_ldw))
{
if (CGEN_INSN_ATTR_VALUE (insn.insn, CGEN_INSN_USES_RD) &&
insn.fields.f_rd == delayed_load_register)
as_warn (_("operand references R%ld of previous load."),
insn.fields.f_rd);
if (CGEN_INSN_ATTR_VALUE (insn.insn, CGEN_INSN_USES_RS) &&
insn.fields.f_rs == delayed_load_register)
as_warn (_("operand references R%ld of previous load."),
insn.fields.f_rs);
if (CGEN_INSN_ATTR_VALUE (insn.insn, CGEN_INSN_USES_RT) &&
insn.fields.f_rt == delayed_load_register)
as_warn (_("operand references R%ld of previous load."),
insn.fields.f_rt);
if (CGEN_INSN_ATTR_VALUE (insn.insn, CGEN_INSN_USES_R31) &&
delayed_load_register == 31)
as_warn (_("instruction implicitly accesses R31 of previous load."));
}
if (last_insn_was_ldw)
{
if ((CGEN_INSN_ATTR_VALUE (insn.insn, CGEN_INSN_USES_RD)
&& insn.fields.f_rd == delayed_load_register + 1)
|| (CGEN_INSN_ATTR_VALUE (insn.insn, CGEN_INSN_USES_RS)
&& insn.fields.f_rs == delayed_load_register + 1)
|| (CGEN_INSN_ATTR_VALUE (insn.insn, CGEN_INSN_USES_RT)
&& insn.fields.f_rt == delayed_load_register + 1))
as_warn (_("operand references R%ld of previous load."),
delayed_load_register + 1);
}
last_insn_had_delay_slot =
CGEN_INSN_ATTR_VALUE (insn.insn, CGEN_INSN_DELAY_SLOT);
last_insn_has_load_delay =
CGEN_INSN_ATTR_VALUE (insn.insn, CGEN_INSN_LOAD_DELAY);
if (last_insn_unconditional_jump)
last_insn_has_load_delay = last_insn_unconditional_jump = 0;
else if (! strcmp (CGEN_INSN_MNEMONIC (insn.insn), "j")
|| ! strcmp (CGEN_INSN_MNEMONIC (insn.insn), "jal"))
last_insn_unconditional_jump = 1;
last_insn_was_ldw = ! strcmp ("ldw", CGEN_INSN_NAME (insn.insn));
delayed_load_register = insn.fields.f_rt;
}
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));
}
symbolS *
md_undefined_symbol (name)
char * name ATTRIBUTE_UNUSED;
{
return 0;
}
int
md_estimate_size_before_relax (fragP, segment)
fragS * fragP;
segT segment ATTRIBUTE_UNUSED;
{
int old_fr_fix = fragP->fr_fix;
return (fragP->fr_var + fragP->fr_fix - old_fr_fix);
}
void
md_convert_frag (abfd, sec, fragP)
bfd * abfd ATTRIBUTE_UNUSED;
segT sec ATTRIBUTE_UNUSED;
fragS * fragP ATTRIBUTE_UNUSED;
{
}
long
md_pcrel_from_section (fixP, sec)
fixS * fixP;
segT sec;
{
if (fixP->fx_addsy != (symbolS *) NULL
&& (! S_IS_DEFINED (fixP->fx_addsy)
|| S_GET_SEGMENT (fixP->fx_addsy) != sec))
{
return 0;
}
return fixP->fx_size + fixP->fx_where + fixP->fx_frag->fr_address;
}
bfd_reloc_code_real_type
md_cgen_lookup_reloc (insn, operand, fixP)
const CGEN_INSN * insn ATTRIBUTE_UNUSED;
const CGEN_OPERAND * operand;
fixS * fixP ATTRIBUTE_UNUSED;
{
switch (operand->type)
{
case IQ2000_OPERAND_OFFSET:
return BFD_RELOC_16_PCREL_S2;
case IQ2000_OPERAND_JMPTARG:
return BFD_RELOC_IQ2000_OFFSET_16;
case IQ2000_OPERAND_JMPTARGQ10:
if (iq2000_mach == bfd_mach_iq10)
return BFD_RELOC_IQ2000_OFFSET_21;
return BFD_RELOC_NONE;
case IQ2000_OPERAND_HI16:
return BFD_RELOC_HI16;
case IQ2000_OPERAND_LO16:
return BFD_RELOC_LO16;
default:
return BFD_RELOC_NONE;
}
return BFD_RELOC_NONE;
}
static void
iq2000_record_hi16 (reloc_type, fixP, seg)
int reloc_type;
fixS * fixP;
segT seg ATTRIBUTE_UNUSED;
{
struct iq2000_hi_fixup * hi_fixup;
assert (reloc_type == BFD_RELOC_HI16);
hi_fixup = ((struct iq2000_hi_fixup *)
xmalloc (sizeof (struct iq2000_hi_fixup)));
hi_fixup->fixp = fixP;
hi_fixup->seg = now_seg;
hi_fixup->next = iq2000_hi_fixup_list;
iq2000_hi_fixup_list = hi_fixup;
}
fixS *
iq2000_cgen_record_fixup_exp (frag, where, insn, length, operand, opinfo, exp)
fragS * frag;
int where;
const CGEN_INSN * insn;
int length;
const CGEN_OPERAND * operand;
int opinfo;
expressionS * exp;
{
fixS * fixP = gas_cgen_record_fixup_exp (frag, where, insn, length,
operand, opinfo, exp);
switch (operand->type)
{
case IQ2000_OPERAND_HI16 :
if (fixP->fx_cgen.opinfo == BFD_RELOC_HI16
|| fixP->fx_cgen.opinfo == BFD_RELOC_LO16)
iq2000_record_hi16 (fixP->fx_cgen.opinfo, fixP, now_seg);
break;
default :
break;
}
return fixP;
}
#define FX_OPINFO_R_TYPE(f) ((f)->fx_cgen.opinfo)
void
iq2000_frob_file ()
{
struct iq2000_hi_fixup * l;
for (l = iq2000_hi_fixup_list; l != NULL; l = l->next)
{
segment_info_type * seginfo;
int pass;
assert (FX_OPINFO_R_TYPE (l->fixp) == BFD_RELOC_HI16
|| FX_OPINFO_R_TYPE (l->fixp) == BFD_RELOC_LO16);
if (l->fixp->fx_next != NULL
&& FX_OPINFO_R_TYPE (l->fixp->fx_next) == BFD_RELOC_LO16
&& l->fixp->fx_addsy == l->fixp->fx_next->fx_addsy
&& l->fixp->fx_offset == l->fixp->fx_next->fx_offset)
continue;
seginfo = seg_info (l->seg);
for (pass = 0; pass < 2; pass++)
{
fixS * f;
fixS * prev;
prev = NULL;
for (f = seginfo->fix_root; f != NULL; f = f->fx_next)
{
if (FX_OPINFO_R_TYPE (f) == BFD_RELOC_LO16
&& f->fx_addsy == l->fixp->fx_addsy
&& f->fx_offset == l->fixp->fx_offset
&& (pass == 1
|| prev == NULL
|| (FX_OPINFO_R_TYPE (prev) != BFD_RELOC_HI16)
|| prev->fx_addsy != f->fx_addsy
|| prev->fx_offset != f->fx_offset))
{
fixS ** pf;
for (pf = &seginfo->fix_root;
* pf != l->fixp;
pf = & (* pf)->fx_next)
assert (* pf != NULL);
* pf = l->fixp->fx_next;
l->fixp->fx_next = f;
if (prev == NULL)
seginfo->fix_root = l->fixp;
else
prev->fx_next = l->fixp;
break;
}
prev = f;
}
if (f != NULL)
break;
if (pass == 1)
as_warn_where (l->fixp->fx_file, l->fixp->fx_line,
_("Unmatched high relocation"));
}
}
}
int
iq2000_force_relocation (fix)
fixS * fix;
{
if (fix->fx_r_type == BFD_RELOC_VTABLE_INHERIT
|| fix->fx_r_type == BFD_RELOC_VTABLE_ENTRY)
return 1;
return 0;
}
static void
s_iq2000_set (x)
int x ATTRIBUTE_UNUSED;
{
char *name = input_line_pointer, ch;
char *save_ILP = input_line_pointer;
while (!is_end_of_line[(unsigned char) *input_line_pointer])
input_line_pointer++;
ch = *input_line_pointer;
*input_line_pointer = '\0';
if (strcmp (name, "reorder") == 0)
{
}
else if (strcmp (name, "noreorder") == 0)
{
}
else if (strcmp (name, "at") == 0)
{
}
else if (strcmp (name, "noat") == 0)
{
}
else if (strcmp (name, "macro") == 0)
{
}
else if (strcmp (name, "nomacro") == 0)
{
}
else if (strcmp (name, "move") == 0 || strcmp (name, "novolatile") == 0)
{
}
else if (strcmp (name, "nomove") == 0 || strcmp (name, "volatile") == 0)
{
}
else if (strcmp (name, "bopt") == 0)
{
}
else if (strcmp (name, "nobopt") == 0)
{
}
else
{
input_line_pointer = save_ILP;
s_set (0);
return;
}
*input_line_pointer = ch;
demand_empty_rest_of_line ();
}
void
md_number_to_chars (buf, val, n)
char * buf;
valueT val;
int n;
{
number_to_chars_bigendian (buf, val, n);
}
void
md_operand (exp)
expressionS * exp;
{
if (exp->X_op == O_absent)
gas_cgen_md_operand (exp);
}
#define MAX_LITTLENUMS 6
char *
md_atof (type, litP, sizeP)
char type;
char *litP;
int *sizeP;
{
int i;
int prec;
LITTLENUM_TYPE words [MAX_LITTLENUMS];
char * t;
switch (type)
{
case 'f':
case 'F':
case 's':
case 'S':
prec = 2;
break;
case 'd':
case 'D':
case 'r':
case 'R':
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 (i = 0; i < prec; i++)
{
md_number_to_chars (litP, (valueT) words[i],
sizeof (LITTLENUM_TYPE));
litP += sizeof (LITTLENUM_TYPE);
}
return 0;
}
bfd_boolean
iq2000_fix_adjustable (fixP)
fixS * fixP;
{
bfd_reloc_code_real_type reloc_type;
if ((int) fixP->fx_r_type >= (int) BFD_RELOC_UNUSED)
{
const CGEN_INSN *insn = NULL;
int opindex = (int) fixP->fx_r_type - (int) BFD_RELOC_UNUSED;
const CGEN_OPERAND *operand = cgen_operand_lookup_by_num(gas_cgen_cpu_desc, opindex);
reloc_type = md_cgen_lookup_reloc (insn, operand, fixP);
}
else
reloc_type = fixP->fx_r_type;
if (fixP->fx_addsy == NULL)
return TRUE;
if (S_IS_EXTERN (fixP->fx_addsy))
return FALSE;
if (S_IS_WEAK (fixP->fx_addsy))
return FALSE;
if ( reloc_type == BFD_RELOC_VTABLE_INHERIT
|| reloc_type == BFD_RELOC_VTABLE_ENTRY)
return FALSE;
return TRUE;
}
static void
s_change_sec (sec)
int sec;
{
#ifdef OBJ_ELF
obj_elf_section_change_hook ();
#endif
switch (sec)
{
case 't':
s_text (0);
break;
case 'd':
case 'r':
s_data (0);
break;
}
}
static void
s_iq2000_end (x)
int x ATTRIBUTE_UNUSED;
{
symbolS *p;
int maybe_text;
if (!is_end_of_line[(unsigned char) *input_line_pointer])
{
p = get_symbol ();
demand_empty_rest_of_line ();
}
else
p = NULL;
if (1)
{
#ifdef BFD_ASSEMBLER
if ((bfd_get_section_flags (stdoutput, now_seg) & SEC_CODE) != 0)
maybe_text = 1;
else
maybe_text = 0;
#else
if (now_seg != data_section && now_seg != bss_section)
maybe_text = 1;
else
maybe_text = 0;
#endif
if (!maybe_text)
as_warn (_(".end not in text section"));
if (!cur_proc_ptr)
{
as_warn (_(".end directive without a preceding .ent directive."));
demand_empty_rest_of_line ();
return;
}
if (p != NULL)
{
assert (S_GET_NAME (p));
if (strcmp (S_GET_NAME (p), S_GET_NAME (cur_proc_ptr->isym)))
as_warn (_(".end symbol does not match .ent symbol."));
}
else
as_warn (_(".end directive missing or unknown symbol"));
}
cur_proc_ptr = NULL;
}
static void
s_iq2000_ent (aent)
int aent;
{
int number = 0;
symbolS *symbolP;
int maybe_text;
if (1)
{
symbolP = get_symbol ();
if (*input_line_pointer == ',')
input_line_pointer++;
SKIP_WHITESPACE ();
if (ISDIGIT (*input_line_pointer) || *input_line_pointer == '-')
number = get_number ();
#ifdef BFD_ASSEMBLER
if ((bfd_get_section_flags (stdoutput, now_seg) & SEC_CODE) != 0)
maybe_text = 1;
else
maybe_text = 0;
#else
if (now_seg != data_section && now_seg != bss_section)
maybe_text = 1;
else
maybe_text = 0;
#endif
if (!maybe_text)
as_warn (_(".ent or .aent not in text section."));
if (!aent && cur_proc_ptr)
as_warn (_("missing `.end'"));
if (!aent)
{
cur_proc_ptr = &cur_proc;
memset (cur_proc_ptr, '\0', sizeof (procS));
cur_proc_ptr->isym = symbolP;
symbol_get_bfdsym (symbolP)->flags |= BSF_FUNCTION;
numprocs++;
}
}
else
as_bad (_("unknown pseudo-op: `%s'"), ".ent");
demand_empty_rest_of_line ();
}
static void
s_iq2000_frame (ignore)
int ignore;
{
s_ignore (ignore);
}
static void
s_iq2000_mask (reg_type)
char reg_type;
{
s_ignore (reg_type);
}
static symbolS *
get_symbol ()
{
int c;
char *name;
symbolS *p;
name = input_line_pointer;
c = get_symbol_end ();
p = (symbolS *) symbol_find_or_make (name);
*input_line_pointer = c;
return p;
}
static int
get_number ()
{
int negative = 0;
long val = 0;
if (*input_line_pointer == '-')
{
++input_line_pointer;
negative = 1;
}
if (! ISDIGIT (*input_line_pointer))
as_bad (_("Expected simple number."));
if (input_line_pointer[0] == '0')
{
if (input_line_pointer[1] == 'x')
{
input_line_pointer += 2;
while (ISXDIGIT (*input_line_pointer))
{
val <<= 4;
val |= hex_value (*input_line_pointer++);
}
return negative ? -val : val;
}
else
{
++input_line_pointer;
while (ISDIGIT (*input_line_pointer))
{
val <<= 3;
val |= *input_line_pointer++ - '0';
}
return negative ? -val : val;
}
}
if (! ISDIGIT (*input_line_pointer))
{
printf (_(" *input_line_pointer == '%c' 0x%02x\n"),
*input_line_pointer, *input_line_pointer);
as_warn (_("Invalid number"));
return -1;
}
while (ISDIGIT (*input_line_pointer))
{
val *= 10;
val += *input_line_pointer++ - '0';
}
return negative ? -val : val;
}