static void
build_asm_hash_table ()
{
int i;
unsigned int hash;
int count = cgen_insn_count ();
CGEN_OPCODE_DATA *data = cgen_current_opcode_data;
CGEN_INSN_TABLE *insn_table = data->insn_table;
unsigned int entry_size = insn_table->entry_size;
unsigned int hash_size = insn_table->asm_hash_table_size;
const CGEN_INSN *insn;
CGEN_INSN_LIST *insn_lists,*new_insns;
/* The space allocated for the hash table consists of two parts:
the hash table and the hash lists. */
asm_hash_table = (CGEN_INSN_LIST **)
xmalloc (hash_size * sizeof (CGEN_INSN_LIST *)
+ count * sizeof (CGEN_INSN_LIST));
memset (asm_hash_table, 0,
hash_size * sizeof (CGEN_INSN_LIST *)
+ count * sizeof (CGEN_INSN_LIST));
insn_lists = (CGEN_INSN_LIST *) (asm_hash_table + hash_size);
/* Add compiled in insns.
The table is scanned backwards as later additions are inserted in
front of earlier ones and we want earlier ones to be prefered.
We stop at the first one as it is a reserved entry.
This is a bit tricky as the attribute member of CGEN_INSN is variable
among architectures. This code could be moved to cgen-asm.in, but
I prefer to keep it here for now. */
for (insn = (CGEN_INSN *)
((char *) insn_table->init_entries
+ entry_size * (insn_table->num_init_entries - 1));
insn > insn_table->init_entries;
insn = (CGEN_INSN *) ((char *) insn - entry_size), ++insn_lists)
{
hash = (*insn_table->asm_hash) CGEN_INSN_MNEMONIC (insn);
insn_lists->next = asm_hash_table[hash];
insn_lists->insn = insn;
asm_hash_table[hash] = insn_lists;
}
/* Add runtime added insns.
??? Currently later added insns will be prefered over earlier ones.
Not sure this is a bug or not. */
for (new_insns = insn_table->new_entries;
new_insns != NULL;
new_insns = new_insns->next, ++insn_lists)
{
hash = (*insn_table->asm_hash) CGEN_INSN_MNEMONIC (new_insns->insn);
insn_lists->next = asm_hash_table[hash];
insn_lists->insn = new_insns->insn;
asm_hash_table[hash] = insn_lists;
}
}
static CGEN_INSN_LIST *
hash_insn_array (CGEN_CPU_DESC cd,
const CGEN_INSN *insns,
int count,
int entsize ATTRIBUTE_UNUSED,
CGEN_INSN_LIST **htable,
CGEN_INSN_LIST *hentbuf)
{
int i;
for (i = count - 1; i >= 0; --i, ++hentbuf)
{
unsigned int hash;
const CGEN_INSN *insn = &insns[i];
if (! (* cd->asm_hash_p) (insn))
continue;
hash = (* cd->asm_hash) (CGEN_INSN_MNEMONIC (insn));
hentbuf->next = htable[hash];
hentbuf->insn = insn;
htable[hash] = hentbuf;
}
return hentbuf;
}
static CGEN_INSN_LIST *
hash_insn_list (CGEN_CPU_DESC cd,
const CGEN_INSN_LIST *insns,
CGEN_INSN_LIST **htable,
CGEN_INSN_LIST *hentbuf)
{
const CGEN_INSN_LIST *ilist;
for (ilist = insns; ilist != NULL; ilist = ilist->next, ++ hentbuf)
{
unsigned int hash;
if (! (* cd->asm_hash_p) (ilist->insn))
continue;
hash = (* cd->asm_hash) (CGEN_INSN_MNEMONIC (ilist->insn));
hentbuf->next = htable[hash];
hentbuf->insn = ilist->insn;
htable[hash] = hentbuf;
}
return hentbuf;
}
static const char *
parse_insn_normal (CGEN_CPU_DESC cd,
const CGEN_INSN *insn,
const char **strp,
CGEN_FIELDS *fields)
{
/* ??? Runtime added insns not handled yet. */
const CGEN_SYNTAX *syntax = CGEN_INSN_SYNTAX (insn);
const char *str = *strp;
const char *errmsg;
const char *p;
const CGEN_SYNTAX_CHAR_TYPE * syn;
#ifdef CGEN_MNEMONIC_OPERANDS
/* FIXME: wip */
int past_opcode_p;
#endif
/* For now we assume the mnemonic is first (there are no leading operands).
We can parse it without needing to set up operand parsing.
GAS's input scrubber will ensure mnemonics are lowercase, but we may
not be called from GAS. */
p = CGEN_INSN_MNEMONIC (insn);
while (*p && TOLOWER (*p) == TOLOWER (*str))
++p, ++str;
if (* p)
return _("unrecognized instruction");
#ifndef CGEN_MNEMONIC_OPERANDS
if (* str && ! ISSPACE (* str))
return _("unrecognized instruction");
#endif
CGEN_INIT_PARSE (cd);
cgen_init_parse_operand (cd);
#ifdef CGEN_MNEMONIC_OPERANDS
past_opcode_p = 0;
#endif
/* We don't check for (*str != '\0') here because we want to parse
any trailing fake arguments in the syntax string. */
syn = CGEN_SYNTAX_STRING (syntax);
/* Mnemonics come first for now, ensure valid string. */
if (! CGEN_SYNTAX_MNEMONIC_P (* syn))
abort ();
++syn;
while (* syn != 0)
{
/* Non operand chars must match exactly. */
if (CGEN_SYNTAX_CHAR_P (* syn))
{
/* FIXME: While we allow for non-GAS callers above, we assume the
first char after the mnemonic part is a space. */
/* FIXME: We also take inappropriate advantage of the fact that
GAS's input scrubber will remove extraneous blanks. */
if (TOLOWER (*str) == TOLOWER (CGEN_SYNTAX_CHAR (* syn)))
{
#ifdef CGEN_MNEMONIC_OPERANDS
if (CGEN_SYNTAX_CHAR(* syn) == ' ')
past_opcode_p = 1;
#endif
++ syn;
++ str;
}
else if (*str)
{
/* Syntax char didn't match. Can't be this insn. */
static char msg [80];
/* xgettext:c-format */
sprintf (msg, _("syntax error (expected char `%c', found `%c')"),
CGEN_SYNTAX_CHAR(*syn), *str);
return msg;
}
else
{
/* Ran out of input. */
static char msg [80];
/* xgettext:c-format */
sprintf (msg, _("syntax error (expected char `%c', found end of instruction)"),
CGEN_SYNTAX_CHAR(*syn));
return msg;
}
continue;
}
#ifdef CGEN_MNEMONIC_OPERANDS
(void) past_opcode_p;
#endif
/* We have an operand of some sort. */
errmsg = cd->parse_operand (cd, CGEN_SYNTAX_FIELD (*syn), &str, fields);
if (errmsg)
return errmsg;
/* Done with this operand, continue with next one. */
++ syn;
}
/* If we're at the end of the syntax string, we're done. */
if (* syn == 0)
{
/* FIXME: For the moment we assume a valid `str' can only contain
blanks now. IE: We needn't try again with a longer version of
the insn and it is assumed that longer versions of insns appear
before shorter ones (eg: lsr r2,r3,1 vs lsr r2,r3). */
while (ISSPACE (* str))
++ str;
if (* str != '\0')
return _("junk at end of line"); /* FIXME: would like to include `str' */
return NULL;
}
/* We couldn't parse it. */
return _("unrecognized instruction");
}
char *
xstormy16_cgen_build_insn_regex (CGEN_INSN *insn)
{
CGEN_OPCODE *opc = (CGEN_OPCODE *) CGEN_INSN_OPCODE (insn);
const char *mnem = CGEN_INSN_MNEMONIC (insn);
char rxbuf[CGEN_MAX_RX_ELEMENTS];
char *rx = rxbuf;
const CGEN_SYNTAX_CHAR_TYPE *syn;
int reg_err;
syn = CGEN_SYNTAX_STRING (CGEN_OPCODE_SYNTAX (opc));
/* Mnemonics come first in the syntax string. */
if (! CGEN_SYNTAX_MNEMONIC_P (* syn))
return _("missing mnemonic in syntax string");
++syn;
/* Generate a case sensitive regular expression that emulates case
insensitive matching in the "C" locale. We cannot generate a case
insensitive regular expression because in Turkish locales, 'i' and 'I'
are not equal modulo case conversion. */
/* Copy the literal mnemonic out of the insn. */
for (; *mnem; mnem++)
{
char c = *mnem;
if (ISALPHA (c))
{
*rx++ = '[';
*rx++ = TOLOWER (c);
*rx++ = TOUPPER (c);
*rx++ = ']';
}
else
*rx++ = c;
}
/* Copy any remaining literals from the syntax string into the rx. */
for(; * syn != 0 && rx <= rxbuf + (CGEN_MAX_RX_ELEMENTS - 7 - 4); ++syn)
{
if (CGEN_SYNTAX_CHAR_P (* syn))
{
char c = CGEN_SYNTAX_CHAR (* syn);
switch (c)
{
/* Escape any regex metacharacters in the syntax. */
case '.': case '[': case '\\':
case '*': case '^': case '$':
#ifdef CGEN_ESCAPE_EXTENDED_REGEX
case '?': case '{': case '}':
case '(': case ')': case '*':
case '|': case '+': case ']':
#endif
*rx++ = '\\';
*rx++ = c;
break;
default:
if (ISALPHA (c))
{
*rx++ = '[';
*rx++ = TOLOWER (c);
*rx++ = TOUPPER (c);
*rx++ = ']';
}
else
*rx++ = c;
break;
}
}
else
{
/* Replace non-syntax fields with globs. */
*rx++ = '.';
*rx++ = '*';
}
}
/* Trailing whitespace ok. */
* rx++ = '[';
* rx++ = ' ';
* rx++ = '\t';
* rx++ = ']';
* rx++ = '*';
/* But anchor it after that. */
* rx++ = '$';
* rx = '\0';
CGEN_INSN_RX (insn) = xmalloc (sizeof (regex_t));
reg_err = regcomp ((regex_t *) CGEN_INSN_RX (insn), rxbuf, REG_NOSUB);
if (reg_err == 0)
return NULL;
else
{
static char msg[80];
regerror (reg_err, (regex_t *) CGEN_INSN_RX (insn), msg, 80);
regfree ((regex_t *) CGEN_INSN_RX (insn));
free (CGEN_INSN_RX (insn));
(CGEN_INSN_RX (insn)) = NULL;
return msg;
}
}
