X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;ds=sidebyside;f=gas%2Fitbl-ops.c;h=6498a0f4753411e47eeb2bb461212ccc5550ff75;hb=b44d461b0ebcb9f30595e5c3e4c748775349ecf1;hp=27cca606f7565ce339188333ad6ea5d8f81532b1;hpb=dc9e099fc0eced486ae2b49455c9da113c11f4ff;p=binutils-gdb.git diff --git a/gas/itbl-ops.c b/gas/itbl-ops.c index 27cca606f75..6498a0f4753 100644 --- a/gas/itbl-ops.c +++ b/gas/itbl-ops.c @@ -1,5 +1,5 @@ /* itbl-ops.c - Copyright (C) 1997, 1998, 1999 Free Software Foundation, Inc. + Copyright 1997, 1999, 2000, 2001 Free Software Foundation, Inc. This file is part of GAS, the GNU Assembler. @@ -92,7 +92,7 @@ #include #include #include "itbl-ops.h" -#include "itbl-parse.h" +#include /* #define DEBUG */ @@ -114,45 +114,39 @@ int itbl_have_entries = 0; /*======================================================================*/ /* structures for keeping itbl format entries */ -struct itbl_range - { - int sbit; /* mask starting bit position */ - int ebit; /* mask ending bit position */ - }; - -struct itbl_field - { - e_type type; /* dreg/creg/greg/immed/symb */ - struct itbl_range range; /* field's bitfield range within instruction */ - unsigned long flags; /* field flags */ - struct itbl_field *next; /* next field in list */ - }; +struct itbl_range { + int sbit; /* mask starting bit position */ + int ebit; /* mask ending bit position */ +}; +struct itbl_field { + e_type type; /* dreg/creg/greg/immed/symb */ + struct itbl_range range; /* field's bitfield range within instruction */ + unsigned long flags; /* field flags */ + struct itbl_field *next; /* next field in list */ +}; /* These structures define the instructions and registers for a processor. * If the type is an instruction, the structure defines the format of an * instruction where the fields are the list of operands. * The flags field below uses the same values as those defined in the - * gnu assembler and are machine specific. */ -struct itbl_entry - { - e_processor processor; /* processor number */ - e_type type; /* dreg/creg/greg/insn */ - char *name; /* mnemionic name for insn/register */ - unsigned long value; /* opcode/instruction mask/register number */ - unsigned long flags; /* effects of the instruction */ - struct itbl_range range; /* bit range within instruction for value */ - struct itbl_field *fields; /* list of operand definitions (if any) */ - struct itbl_entry *next; /* next entry */ - }; - + * gnu assembler and are machine specific. */ +struct itbl_entry { + e_processor processor; /* processor number */ + e_type type; /* dreg/creg/greg/insn */ + char *name; /* mnemionic name for insn/register */ + unsigned long value; /* opcode/instruction mask/register number */ + unsigned long flags; /* effects of the instruction */ + struct itbl_range range; /* bit range within instruction for value */ + struct itbl_field *fields; /* list of operand definitions (if any) */ + struct itbl_entry *next; /* next entry */ +}; /* local data and structures */ static int itbl_num_opcodes = 0; /* Array of entries for each processor and entry type */ -static struct itbl_entry *entries[e_nprocs][e_ntypes] = -{ +static struct itbl_entry *entries[e_nprocs][e_ntypes] = { {0, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 0}, @@ -160,48 +154,45 @@ static struct itbl_entry *entries[e_nprocs][e_ntypes] = }; /* local prototypes */ -static unsigned long build_opcode PARAMS ((struct itbl_entry *e)); -static e_type get_type PARAMS ((int yytype)); -static e_processor get_processor PARAMS ((int yyproc)); -static struct itbl_entry **get_entries PARAMS ((e_processor processor, - e_type type)); -static struct itbl_entry *find_entry_byname PARAMS ((e_processor processor, - e_type type, char *name)); -static struct itbl_entry *find_entry_byval PARAMS ((e_processor processor, - e_type type, unsigned long val, struct itbl_range *r)); -static struct itbl_entry *alloc_entry PARAMS ((e_processor processor, - e_type type, char *name, unsigned long value)); -static unsigned long apply_range PARAMS ((unsigned long value, - struct itbl_range r)); -static unsigned long extract_range PARAMS ((unsigned long value, - struct itbl_range r)); -static struct itbl_field *alloc_field PARAMS ((e_type type, int sbit, - int ebit, unsigned long flags)); - +static unsigned long build_opcode (struct itbl_entry *e); +static e_type get_type (int yytype); +static e_processor get_processor (int yyproc); +static struct itbl_entry **get_entries (e_processor processor, + e_type type); +static struct itbl_entry *find_entry_byname (e_processor processor, + e_type type, char *name); +static struct itbl_entry *find_entry_byval (e_processor processor, + e_type type, unsigned long val, struct itbl_range *r); +static struct itbl_entry *alloc_entry (e_processor processor, + e_type type, char *name, unsigned long value); +static unsigned long apply_range (unsigned long value, struct itbl_range r); +static unsigned long extract_range (unsigned long value, struct itbl_range r); +static struct itbl_field *alloc_field (e_type type, int sbit, + int ebit, unsigned long flags); /*======================================================================*/ /* Interfaces to the parser */ - /* Open the table and use lex and yacc to parse the entries. * Return 1 for failure; 0 for success. */ -int +int itbl_parse (char *insntbl) { extern FILE *yyin; extern int yyparse (void); - yyin = fopen (insntbl, "r"); + + yyin = fopen (insntbl, FOPEN_RT); if (yyin == 0) { printf ("Can't open processor instruction specification file \"%s\"\n", insntbl); return 1; } - else - { - while (yyparse ()); - } + + while (yyparse ()) + ; + fclose (yyin); itbl_have_entries = 1; return 0; @@ -213,18 +204,6 @@ struct itbl_entry * itbl_add_reg (int yyprocessor, int yytype, char *regname, int regnum) { -#if 0 -#include "as.h" -#include "symbols.h" - /* Since register names don't have a prefix, we put them in the symbol table so - they can't be used as symbols. This also simplifies argument parsing as - we can let gas parse registers for us. The recorded register number is - regnum. */ - /* Use symbol_create here instead of symbol_new so we don't try to - output registers into the object file's symbol table. */ - symbol_table_insert (symbol_create (regname, reg_section, - regnum, &zero_address_frag)); -#endif return alloc_entry (get_processor (yyprocessor), get_type (yytype), regname, (unsigned long) regnum); } @@ -256,7 +235,7 @@ itbl_add_operand (struct itbl_entry *e, int yytype, int sbit, struct itbl_field *f, **last_f; if (!e) return 0; - /* Add to end of fields' list. */ + /* Add to end of fields' list. */ f = alloc_field (get_type (yytype), sbit, ebit, flags); if (f) { @@ -269,7 +248,6 @@ itbl_add_operand (struct itbl_entry *e, int yytype, int sbit, return f; } - /*======================================================================*/ /* Interfaces for assembler and disassembler */ @@ -278,8 +256,9 @@ itbl_add_operand (struct itbl_entry *e, int yytype, int sbit, #include "symbols.h" static void append_insns_as_macros (void); -/* initialize for gas */ -void +/* Initialize for gas. */ + +void itbl_init (void) { struct itbl_entry *e, **es; @@ -287,11 +266,11 @@ itbl_init (void) e_type type; if (!itbl_have_entries) - return; + return; /* Since register names don't have a prefix, put them in the symbol table so they can't be used as symbols. This simplifies argument parsing as - we can let gas parse registers for us. */ + we can let gas parse registers for us. */ /* Use symbol_create instead of symbol_new so we don't try to output registers into the object file's symbol table. */ @@ -302,22 +281,21 @@ itbl_init (void) for (e = *es; e; e = e->next) { symbol_table_insert (symbol_create (e->name, reg_section, - e->value, &zero_address_frag)); + e->value, &zero_address_frag)); } } append_insns_as_macros (); } - -/* Append insns to opcodes table and increase number of opcodes - * Structure of opcodes table: +/* Append insns to opcodes table and increase number of opcodes + * Structure of opcodes table: * struct itbl_opcode * { * const char *name; - * const char *args; - string describing the arguments. - * unsigned long match; - opcode, or ISA level if pinfo=INSN_MACRO - * unsigned long mask; - opcode mask, or macro id if pinfo=INSN_MACRO - * unsigned long pinfo; - insn flags, or INSN_MACRO + * const char *args; - string describing the arguments. + * unsigned long match; - opcode, or ISA level if pinfo=INSN_MACRO + * unsigned long mask; - opcode mask, or macro id if pinfo=INSN_MACRO + * unsigned long pinfo; - insn flags, or INSN_MACRO * }; * examples: * {"li", "t,i", 0x34000000, 0xffe00000, WR_t }, @@ -325,7 +303,7 @@ itbl_init (void) */ static char *form_args (struct itbl_entry *e); -static void +static void append_insns_as_macros (void) { struct ITBL_OPCODE_STRUCT *new_opcodes, *o; @@ -333,7 +311,7 @@ append_insns_as_macros (void) int n, id, size, new_size, new_num_opcodes; if (!itbl_have_entries) - return; + return; if (!itbl_num_opcodes) /* no new instructions to add! */ { @@ -352,18 +330,18 @@ append_insns_as_macros (void) ASSERT (new_size > size); /* FIXME since ITBL_OPCODES culd be a static table, - we can't realloc or delete the old memory. */ + we can't realloc or delete the old memory. */ new_opcodes = (struct ITBL_OPCODE_STRUCT *) malloc (new_size); if (!new_opcodes) { printf (_("Unable to allocate memory for new instructions\n")); return; } - if (size) /* copy prexisting opcodes table */ + if (size) /* copy preexisting opcodes table */ memcpy (new_opcodes, ITBL_OPCODES, size); /* FIXME! some NUMOPCODES are calculated expressions. - These need to be changed before itbls can be supported. */ + These need to be changed before itbls can be supported. */ id = ITBL_NUM_MACROS; /* begin the next macro id after the last */ o = &new_opcodes[ITBL_NUM_OPCODES]; /* append macro to opcodes list */ @@ -380,13 +358,13 @@ append_insns_as_macros (void) o->name = e->name; o->args = strdup (form_args (e)); o->mask = apply_range (e->value, e->range); - /* FIXME how to catch durring assembly? */ + /* FIXME how to catch during assembly? */ /* mask to identify this insn */ o->match = apply_range (e->value, e->range); o->pinfo = 0; #ifdef USE_MACROS - o->mask = id++; /* FIXME how to catch durring assembly? */ + o->mask = id++; /* FIXME how to catch during assembly? */ o->match = 0; /* for macros, the insn_isa number */ o->pinfo = INSN_MACRO; #endif @@ -407,7 +385,7 @@ append_insns_as_macros (void) Don't free name though, since name is being used by the new opcodes table. - Eventually, we should also free the new opcodes table itself + Eventually, we should also free the new opcodes table itself on exit. */ } @@ -454,7 +432,6 @@ form_args (struct itbl_entry *e) } #endif /* !STAND_ALONE */ - /* Get processor's register name from val */ int @@ -501,23 +478,22 @@ itbl_get_val (e_processor processor, e_type type, char *name, return 1; } - /* Assemble instruction "name" with operands "s". * name - name of instruction * s - operands * returns - long word for assembled instruction */ -unsigned long +unsigned long itbl_assemble (char *name, char *s) { unsigned long opcode; - struct itbl_entry *e; + struct itbl_entry *e = NULL; struct itbl_field *f; char *n; int processor; if (!name || !*name) - return 0; /* error! must have a opcode name/expr */ + return 0; /* error! must have an opcode name/expr */ /* find entry in list of instructions for all processors */ for (processor = 0; processor < e_nprocs; processor++) @@ -527,11 +503,11 @@ itbl_assemble (char *name, char *s) break; } if (!e) - return 0; /* opcode not in table; invalid instrustion */ + return 0; /* opcode not in table; invalid instruction */ opcode = build_opcode (e); /* parse opcode's args (if any) */ - for (f = e->fields; f; f = f->next) /* for each arg, ... */ + for (f = e->fields; f; f = f->next) /* for each arg, ... */ { struct itbl_entry *r; unsigned long value; @@ -573,7 +549,7 @@ itbl_assemble (char *name, char *s) */ /* If not a symbol, fall thru to IMMED */ case e_immed: - if (*n == '0' && *(n + 1) == 'x') /* hex begins 0x... */ + if (*n == '0' && *(n + 1) == 'x') /* hex begins 0x... */ { n += 2; value = strtol (n, 0, 16); @@ -603,7 +579,7 @@ itbl_assemble (char *name, char *s) * returns - 1 if succeeded; 0 if failed */ -int +int itbl_disassemble (char *s, unsigned long insn) { e_processor processor; @@ -611,24 +587,24 @@ itbl_disassemble (char *s, unsigned long insn) struct itbl_field *f; if (!ITBL_IS_INSN (insn)) - return 0; /* error*/ + return 0; /* error */ processor = get_processor (ITBL_DECODE_PNUM (insn)); /* find entry in list */ e = find_entry_byval (processor, e_insn, insn, 0); if (!e) - return 0; /* opcode not in table; invalid instrustion */ + return 0; /* opcode not in table; invalid instruction */ strcpy (s, e->name); - /* parse insn's args (if any) */ - for (f = e->fields; f; f = f->next) /* for each arg, ... */ + /* Parse insn's args (if any). */ + for (f = e->fields; f; f = f->next) /* for each arg, ... */ { struct itbl_entry *r; unsigned long value; - if (f == e->fields) /* first operand is preceeded by tab */ + if (f == e->fields) /* First operand is preceded by tab. */ strcat (s, "\t"); - else /* ','s separate following operands */ + else /* ','s separate following operands. */ strcat (s, ","); value = extract_range (insn, f->range); /* n should be in form $n or 0xhhh (are symbol names valid?? */ @@ -638,7 +614,7 @@ itbl_disassemble (char *s, unsigned long insn) case e_creg: case e_greg: /* Accept either a string name - * or '$' followed by the register number */ + or '$' followed by the register number. */ r = find_entry_byval (e->processor, f->type, value, &f->range); if (r) strcat (s, r->name); @@ -646,11 +622,9 @@ itbl_disassemble (char *s, unsigned long insn) sprintf (s, "%s$%lu", s, value); break; case e_addr: - /* use assembler's symbol table to find symbol */ - /* FIXME!! Do we need this? - * if so, what about relocs?? - */ - /* If not a symbol, fall thru to IMMED */ + /* Use assembler's symbol table to find symbol. */ + /* FIXME!! Do we need this? If so, what about relocs?? */ + /* If not a symbol, fall through to IMMED. */ case e_immed: sprintf (s, "%s0x%lx", s, value); break; @@ -658,7 +632,7 @@ itbl_disassemble (char *s, unsigned long insn) return 0; /* error; invalid field spec */ } } - return 1; /* done! */ + return 1; /* Done! */ } /*======================================================================*/ @@ -670,7 +644,7 @@ itbl_disassemble (char *s, unsigned long insn) /* Calculate instruction's opcode and function values from entry */ -static unsigned long +static unsigned long build_opcode (struct itbl_entry *e) { unsigned long opcode; @@ -691,7 +665,7 @@ build_opcode (struct itbl_entry *e) * mask: 0x01f00000. */ -static unsigned long +static unsigned long apply_range (unsigned long rval, struct itbl_range r) { unsigned long mask; @@ -715,7 +689,7 @@ apply_range (unsigned long rval, struct itbl_range r) /* Calculate relative value given the absolute value and bit position range * within the instruction. */ -static unsigned long +static unsigned long extract_range (unsigned long aval, struct itbl_range r) { unsigned long mask; @@ -772,7 +746,7 @@ find_entry_byname (e_processor processor, struct itbl_entry *e, **es; es = get_entries (processor, type); - for (e = *es; e; e = e->next) /* for each entry, ... */ + for (e = *es; e; e = e->next) /* for each entry, ... */ { if (!strcmp (e->name, n)) return e; @@ -794,7 +768,7 @@ find_entry_byval (e_processor processor, e_type type, unsigned long eval; es = get_entries (processor, type); - for (e = *es; e; e = e->next) /* for each entry, ... */ + for (e = *es; e; e = e->next) /* for each entry, ... */ { if (processor != e->processor) continue; @@ -804,7 +778,7 @@ find_entry_byval (e_processor processor, e_type type, * This could cause ambiguities. * For operands, we get an extracted value and a range. */ - /* if range is 0, mask val against the range of the compared entry. */ + /* if range is 0, mask val against the range of the compared entry. */ if (r == 0) /* if no range passed, must be whole 32-bits * so create 32-bit value from entry's range */ { @@ -825,7 +799,7 @@ find_entry_byval (e_processor processor, e_type type, return 0; } -/* Return a pointer to the list of entries for a given processor and type. */ +/* Return a pointer to the list of entries for a given processor and type. */ static struct itbl_entry ** get_entries (e_processor processor, e_type type) @@ -833,9 +807,9 @@ get_entries (e_processor processor, e_type type) return &entries[processor][type]; } -/* Return an integral value for the processor passed from yyparse. */ +/* Return an integral value for the processor passed from yyparse. */ -static e_processor +static e_processor get_processor (int yyproc) { /* translate from yacc's processor to enum */ @@ -844,9 +818,9 @@ get_processor (int yyproc) return e_invproc; /* error; invalid processor */ } -/* Return an integral value for the entry type passed from yyparse. */ +/* Return an integral value for the entry type passed from yyparse. */ -static e_type +static e_type get_type (int yytype) { switch (yytype) @@ -869,7 +843,6 @@ get_type (int yytype) } } - /* Allocate and initialize an entry */ static struct itbl_entry *