OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-stable/] [binutils-2.20.1/] [opcodes/] [ia64-gen.c] - Diff between revs 816 and 818

Go to most recent revision | Only display areas with differences | Details | Blame | View Log

Rev 816 Rev 818
/* ia64-gen.c -- Generate a shrunk set of opcode tables
/* ia64-gen.c -- Generate a shrunk set of opcode tables
   Copyright 1999, 2000, 2001, 2002, 2004, 2005, 2006, 2007, 2008, 2009
   Copyright 1999, 2000, 2001, 2002, 2004, 2005, 2006, 2007, 2008, 2009
   Free Software Foundation, Inc.
   Free Software Foundation, Inc.
   Written by Bob Manson, Cygnus Solutions, <manson@cygnus.com>
   Written by Bob Manson, Cygnus Solutions, <manson@cygnus.com>
 
 
   This file is part of the GNU opcodes library.
   This file is part of the GNU opcodes library.
 
 
   This library is free software; you can redistribute it and/or modify
   This library is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 3, or (at your option)
   the Free Software Foundation; either version 3, or (at your option)
   any later version.
   any later version.
 
 
   It is distributed in the hope that it will be useful, but WITHOUT
   It is distributed in the hope that it will be useful, but WITHOUT
   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
   or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
   or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
   License for more details.
   License for more details.
 
 
   You should have received a copy of the GNU General Public License
   You should have received a copy of the GNU General Public License
   along with this file; see the file COPYING.  If not, write to the
   along with this file; see the file COPYING.  If not, write to the
   Free Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
   Free Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
   02110-1301, USA.  */
   02110-1301, USA.  */
 
 
 
 
/* While the ia64-opc-* set of opcode tables are easy to maintain,
/* While the ia64-opc-* set of opcode tables are easy to maintain,
   they waste a tremendous amount of space.  ia64-gen rearranges the
   they waste a tremendous amount of space.  ia64-gen rearranges the
   instructions into a directed acyclic graph (DAG) of instruction opcodes and
   instructions into a directed acyclic graph (DAG) of instruction opcodes and
   their possible completers, as well as compacting the set of strings used.
   their possible completers, as well as compacting the set of strings used.
 
 
   The disassembler table consists of a state machine that does
   The disassembler table consists of a state machine that does
   branching based on the bits of the opcode being disassembled.  The
   branching based on the bits of the opcode being disassembled.  The
   state encodings have been chosen to minimize the amount of space
   state encodings have been chosen to minimize the amount of space
   required.
   required.
 
 
   The resource table is constructed based on some text dependency tables,
   The resource table is constructed based on some text dependency tables,
   which are also easier to maintain than the final representation.  */
   which are also easier to maintain than the final representation.  */
 
 
#include <stdio.h>
#include <stdio.h>
#include <stdarg.h>
#include <stdarg.h>
#include <errno.h>
#include <errno.h>
 
 
#include "ansidecl.h"
#include "ansidecl.h"
#include "libiberty.h"
#include "libiberty.h"
#include "safe-ctype.h"
#include "safe-ctype.h"
#include "sysdep.h"
#include "sysdep.h"
#include "getopt.h"
#include "getopt.h"
#include "ia64-opc.h"
#include "ia64-opc.h"
#include "ia64-opc-a.c"
#include "ia64-opc-a.c"
#include "ia64-opc-i.c"
#include "ia64-opc-i.c"
#include "ia64-opc-m.c"
#include "ia64-opc-m.c"
#include "ia64-opc-b.c"
#include "ia64-opc-b.c"
#include "ia64-opc-f.c"
#include "ia64-opc-f.c"
#include "ia64-opc-x.c"
#include "ia64-opc-x.c"
#include "ia64-opc-d.c"
#include "ia64-opc-d.c"
 
 
#include <libintl.h>
#include <libintl.h>
#define _(String) gettext (String)
#define _(String) gettext (String)
 
 
/* This is a copy of fprintf_vma from bfd/bfd-in2.h.  We have to use this
/* This is a copy of fprintf_vma from bfd/bfd-in2.h.  We have to use this
   always, because we might be compiled without BFD64 defined, if configured
   always, because we might be compiled without BFD64 defined, if configured
   for a 32-bit target and --enable-targets=all is used.  This will work for
   for a 32-bit target and --enable-targets=all is used.  This will work for
   both 32-bit and 64-bit hosts.  */
   both 32-bit and 64-bit hosts.  */
#define _opcode_int64_low(x) ((unsigned long) (((x) & 0xffffffff)))
#define _opcode_int64_low(x) ((unsigned long) (((x) & 0xffffffff)))
#define _opcode_int64_high(x) ((unsigned long) (((x) >> 32) & 0xffffffff))
#define _opcode_int64_high(x) ((unsigned long) (((x) >> 32) & 0xffffffff))
#define opcode_fprintf_vma(s,x) \
#define opcode_fprintf_vma(s,x) \
  fprintf ((s), "%08lx%08lx", _opcode_int64_high (x), _opcode_int64_low (x))
  fprintf ((s), "%08lx%08lx", _opcode_int64_high (x), _opcode_int64_low (x))
 
 
const char * program_name = NULL;
const char * program_name = NULL;
int debug = 0;
int debug = 0;
 
 
#define NELEMS(a) (sizeof (a) / sizeof ((a)[0]))
#define NELEMS(a) (sizeof (a) / sizeof ((a)[0]))
#define tmalloc(X) (X *) xmalloc (sizeof (X))
#define tmalloc(X) (X *) xmalloc (sizeof (X))
 
 
/* The main opcode table entry.  Each entry is a unique combination of
/* The main opcode table entry.  Each entry is a unique combination of
   name and flags (no two entries in the table compare as being equal
   name and flags (no two entries in the table compare as being equal
   via opcodes_eq).  */
   via opcodes_eq).  */
struct main_entry
struct main_entry
{
{
  /* The base name of this opcode.  The names of its completers are
  /* The base name of this opcode.  The names of its completers are
     appended to it to generate the full instruction name.  */
     appended to it to generate the full instruction name.  */
  struct string_entry *name;
  struct string_entry *name;
  /* The base opcode entry.  Which one to use is a fairly arbitrary choice;
  /* The base opcode entry.  Which one to use is a fairly arbitrary choice;
     it uses the first one passed to add_opcode_entry.  */
     it uses the first one passed to add_opcode_entry.  */
  struct ia64_opcode *opcode;
  struct ia64_opcode *opcode;
  /* The list of completers that can be applied to this opcode.  */
  /* The list of completers that can be applied to this opcode.  */
  struct completer_entry *completers;
  struct completer_entry *completers;
  /* Next entry in the chain.  */
  /* Next entry in the chain.  */
  struct main_entry *next;
  struct main_entry *next;
  /* Index in the  main table.  */
  /* Index in the  main table.  */
  int main_index;
  int main_index;
} *maintable, **ordered_table;
} *maintable, **ordered_table;
 
 
int otlen = 0;
int otlen = 0;
int ottotlen = 0;
int ottotlen = 0;
int opcode_count = 0;
int opcode_count = 0;
 
 
/* The set of possible completers for an opcode.  */
/* The set of possible completers for an opcode.  */
struct completer_entry
struct completer_entry
{
{
  /* This entry's index in the ia64_completer_table[] array.  */
  /* This entry's index in the ia64_completer_table[] array.  */
  int num;
  int num;
 
 
  /* The name of the completer.  */
  /* The name of the completer.  */
  struct string_entry *name;
  struct string_entry *name;
 
 
  /* This entry's parent.  */
  /* This entry's parent.  */
  struct completer_entry *parent;
  struct completer_entry *parent;
 
 
  /* Set if this is a terminal completer (occurs at the end of an
  /* Set if this is a terminal completer (occurs at the end of an
     opcode).  */
     opcode).  */
  int is_terminal;
  int is_terminal;
 
 
  /* An alternative completer.  */
  /* An alternative completer.  */
  struct completer_entry *alternative;
  struct completer_entry *alternative;
 
 
  /* Additional completers that can be appended to this one.  */
  /* Additional completers that can be appended to this one.  */
  struct completer_entry *addl_entries;
  struct completer_entry *addl_entries;
 
 
  /* Before compute_completer_bits () is invoked, this contains the actual
  /* Before compute_completer_bits () is invoked, this contains the actual
     instruction opcode for this combination of opcode and completers.
     instruction opcode for this combination of opcode and completers.
     Afterwards, it contains those bits that are different from its
     Afterwards, it contains those bits that are different from its
     parent opcode.  */
     parent opcode.  */
  ia64_insn bits;
  ia64_insn bits;
 
 
  /* Bits set to 1 correspond to those bits in this completer's opcode
  /* Bits set to 1 correspond to those bits in this completer's opcode
     that are different from its parent completer's opcode (or from
     that are different from its parent completer's opcode (or from
     the base opcode if the entry is the root of the opcode's completer
     the base opcode if the entry is the root of the opcode's completer
     list).  This field is filled in by compute_completer_bits ().  */
     list).  This field is filled in by compute_completer_bits ().  */
  ia64_insn mask;
  ia64_insn mask;
 
 
  /* Index into the opcode dependency list, or -1 if none.  */
  /* Index into the opcode dependency list, or -1 if none.  */
  int dependencies;
  int dependencies;
 
 
  /* Remember the order encountered in the opcode tables.  */
  /* Remember the order encountered in the opcode tables.  */
  int order;
  int order;
};
};
 
 
/* One entry in the disassembler name table.  */
/* One entry in the disassembler name table.  */
struct disent
struct disent
{
{
  /* The index into the ia64_name_dis array for this entry.  */
  /* The index into the ia64_name_dis array for this entry.  */
  int ournum;
  int ournum;
 
 
  /* The index into the main_table[] array.  */
  /* The index into the main_table[] array.  */
  int insn;
  int insn;
 
 
  /* The disassmbly priority of this entry.  */
  /* The disassmbly priority of this entry.  */
  int priority;
  int priority;
 
 
  /* The completer_index value for this entry.  */
  /* The completer_index value for this entry.  */
  int completer_index;
  int completer_index;
 
 
  /* How many other entries share this decode.  */
  /* How many other entries share this decode.  */
  int nextcnt;
  int nextcnt;
 
 
  /* The next entry sharing the same decode.  */
  /* The next entry sharing the same decode.  */
  struct disent *nexte;
  struct disent *nexte;
 
 
  /* The next entry in the name list.  */
  /* The next entry in the name list.  */
  struct disent *next_ent;
  struct disent *next_ent;
} *disinsntable = NULL;
} *disinsntable = NULL;
 
 
/* A state machine that will eventually be used to generate the
/* A state machine that will eventually be used to generate the
   disassembler table.  */
   disassembler table.  */
struct bittree
struct bittree
{
{
  struct disent *disent;
  struct disent *disent;
  struct bittree *bits[3]; /* 0, 1, and X (don't care).  */
  struct bittree *bits[3]; /* 0, 1, and X (don't care).  */
  int bits_to_skip;
  int bits_to_skip;
  int skip_flag;
  int skip_flag;
} *bittree;
} *bittree;
 
 
/* The string table contains all opcodes and completers sorted in
/* The string table contains all opcodes and completers sorted in
   alphabetical order.  */
   alphabetical order.  */
 
 
/* One entry in the string table.  */
/* One entry in the string table.  */
struct string_entry
struct string_entry
{
{
  /* The index in the ia64_strings[] array for this entry.  */
  /* The index in the ia64_strings[] array for this entry.  */
  int num;
  int num;
  /* And the string.  */
  /* And the string.  */
  char *s;
  char *s;
} **string_table = NULL;
} **string_table = NULL;
 
 
int strtablen = 0;
int strtablen = 0;
int strtabtotlen = 0;
int strtabtotlen = 0;
 
 


/* Resource dependency entries.  */
/* Resource dependency entries.  */
struct rdep
struct rdep
{
{
  char *name;                       /* Resource name.  */
  char *name;                       /* Resource name.  */
  unsigned
  unsigned
    mode:2,                         /* RAW, WAW, or WAR.  */
    mode:2,                         /* RAW, WAW, or WAR.  */
    semantics:3;                    /* Dependency semantics.  */
    semantics:3;                    /* Dependency semantics.  */
  char *extra;                      /* Additional semantics info.  */
  char *extra;                      /* Additional semantics info.  */
  int nchks;
  int nchks;
  int total_chks;                   /* Total #of terminal insns.  */
  int total_chks;                   /* Total #of terminal insns.  */
  int *chks;                        /* Insn classes which read (RAW), write
  int *chks;                        /* Insn classes which read (RAW), write
                                       (WAW), or write (WAR) this rsrc.  */
                                       (WAW), or write (WAR) this rsrc.  */
  int *chknotes;                    /* Dependency notes for each class.  */
  int *chknotes;                    /* Dependency notes for each class.  */
  int nregs;
  int nregs;
  int total_regs;                   /* Total #of terminal insns.  */
  int total_regs;                   /* Total #of terminal insns.  */
  int *regs;                        /* Insn class which write (RAW), write2
  int *regs;                        /* Insn class which write (RAW), write2
                                       (WAW), or read (WAR) this rsrc.  */
                                       (WAW), or read (WAR) this rsrc.  */
  int *regnotes;                    /* Dependency notes for each class.  */
  int *regnotes;                    /* Dependency notes for each class.  */
 
 
  int waw_special;                  /* Special WAW dependency note.  */
  int waw_special;                  /* Special WAW dependency note.  */
} **rdeps = NULL;
} **rdeps = NULL;
 
 
static int rdepslen = 0;
static int rdepslen = 0;
static int rdepstotlen = 0;
static int rdepstotlen = 0;
 
 
/* Array of all instruction classes.  */
/* Array of all instruction classes.  */
struct iclass
struct iclass
{
{
  char *name;                       /* Instruction class name.  */
  char *name;                       /* Instruction class name.  */
  int is_class;                     /* Is a class, not a terminal.  */
  int is_class;                     /* Is a class, not a terminal.  */
  int nsubs;
  int nsubs;
  int *subs;                        /* Other classes within this class.  */
  int *subs;                        /* Other classes within this class.  */
  int nxsubs;
  int nxsubs;
  int xsubs[4];                     /* Exclusions.  */
  int xsubs[4];                     /* Exclusions.  */
  char *comment;                    /* Optional comment.  */
  char *comment;                    /* Optional comment.  */
  int note;                         /* Optional note.  */
  int note;                         /* Optional note.  */
  int terminal_resolved;            /* Did we match this with anything?  */
  int terminal_resolved;            /* Did we match this with anything?  */
  int orphan;                       /* Detect class orphans.  */
  int orphan;                       /* Detect class orphans.  */
} **ics = NULL;
} **ics = NULL;
 
 
static int iclen = 0;
static int iclen = 0;
static int ictotlen = 0;
static int ictotlen = 0;
 
 
/* An opcode dependency (chk/reg pair of dependency lists).  */
/* An opcode dependency (chk/reg pair of dependency lists).  */
struct opdep
struct opdep
{
{
  int chk;                          /* index into dlists */
  int chk;                          /* index into dlists */
  int reg;                          /* index into dlists */
  int reg;                          /* index into dlists */
} **opdeps;
} **opdeps;
 
 
static int opdeplen = 0;
static int opdeplen = 0;
static int opdeptotlen = 0;
static int opdeptotlen = 0;
 
 
/* A generic list of dependencies w/notes encoded.  These may be shared.  */
/* A generic list of dependencies w/notes encoded.  These may be shared.  */
struct deplist
struct deplist
{
{
  int len;
  int len;
  unsigned short *deps;
  unsigned short *deps;
} **dlists;
} **dlists;
 
 
static int dlistlen = 0;
static int dlistlen = 0;
static int dlisttotlen = 0;
static int dlisttotlen = 0;
 
 
 
 
static void fail (const char *, ...) ATTRIBUTE_PRINTF_1;
static void fail (const char *, ...) ATTRIBUTE_PRINTF_1;
static void warn (const char *, ...) ATTRIBUTE_PRINTF_1;
static void warn (const char *, ...) ATTRIBUTE_PRINTF_1;
static struct rdep * insert_resource (const char *, enum ia64_dependency_mode);
static struct rdep * insert_resource (const char *, enum ia64_dependency_mode);
static int  deplist_equals (struct deplist *, struct deplist *);
static int  deplist_equals (struct deplist *, struct deplist *);
static short insert_deplist (int, unsigned short *);
static short insert_deplist (int, unsigned short *);
static short insert_dependencies (int, unsigned short *, int, unsigned short *);
static short insert_dependencies (int, unsigned short *, int, unsigned short *);
static void  mark_used (struct iclass *, int);
static void  mark_used (struct iclass *, int);
static int  fetch_insn_class (const char *, int);
static int  fetch_insn_class (const char *, int);
static int  sub_compare (const void *, const void *);
static int  sub_compare (const void *, const void *);
static void load_insn_classes (void);
static void load_insn_classes (void);
static void parse_resource_users (const char *, int **, int *, int **);
static void parse_resource_users (const char *, int **, int *, int **);
static int  parse_semantics (char *);
static int  parse_semantics (char *);
static void add_dep (const char *, const char *, const char *, int, int, char *, int);
static void add_dep (const char *, const char *, const char *, int, int, char *, int);
static void load_depfile (const char *, enum ia64_dependency_mode);
static void load_depfile (const char *, enum ia64_dependency_mode);
static void load_dependencies (void);
static void load_dependencies (void);
static int  irf_operand (int, const char *);
static int  irf_operand (int, const char *);
static int  in_iclass_mov_x (struct ia64_opcode *, struct iclass *, const char *, const char *);
static int  in_iclass_mov_x (struct ia64_opcode *, struct iclass *, const char *, const char *);
static int  in_iclass (struct ia64_opcode *, struct iclass *, const char *, const char *, int *);
static int  in_iclass (struct ia64_opcode *, struct iclass *, const char *, const char *, int *);
static int  lookup_regindex (const char *, int);
static int  lookup_regindex (const char *, int);
static int  lookup_specifier (const char *);
static int  lookup_specifier (const char *);
static void print_dependency_table (void);
static void print_dependency_table (void);
static struct string_entry * insert_string (char *);
static struct string_entry * insert_string (char *);
static void gen_dis_table (struct bittree *);
static void gen_dis_table (struct bittree *);
static void print_dis_table (void);
static void print_dis_table (void);
static void generate_disassembler (void);
static void generate_disassembler (void);
static void print_string_table (void);
static void print_string_table (void);
static int  completer_entries_eq (struct completer_entry *, struct completer_entry *);
static int  completer_entries_eq (struct completer_entry *, struct completer_entry *);
static struct completer_entry * insert_gclist (struct completer_entry *);
static struct completer_entry * insert_gclist (struct completer_entry *);
static int  get_prefix_len (const char *);
static int  get_prefix_len (const char *);
static void compute_completer_bits (struct main_entry *, struct completer_entry *);
static void compute_completer_bits (struct main_entry *, struct completer_entry *);
static void collapse_redundant_completers (void);
static void collapse_redundant_completers (void);
static int  insert_opcode_dependencies (struct ia64_opcode *, struct completer_entry *);
static int  insert_opcode_dependencies (struct ia64_opcode *, struct completer_entry *);
static void insert_completer_entry (struct ia64_opcode *, struct main_entry *, int);
static void insert_completer_entry (struct ia64_opcode *, struct main_entry *, int);
static void print_completer_entry (struct completer_entry *);
static void print_completer_entry (struct completer_entry *);
static void print_completer_table (void);
static void print_completer_table (void);
static int  opcodes_eq (struct ia64_opcode *, struct ia64_opcode *);
static int  opcodes_eq (struct ia64_opcode *, struct ia64_opcode *);
static void add_opcode_entry (struct ia64_opcode *);
static void add_opcode_entry (struct ia64_opcode *);
static void print_main_table (void);
static void print_main_table (void);
static void shrink (struct ia64_opcode *);
static void shrink (struct ia64_opcode *);
static void print_version (void);
static void print_version (void);
static void usage (FILE *, int);
static void usage (FILE *, int);
static void finish_distable (void);
static void finish_distable (void);
static void insert_bit_table_ent (struct bittree *, int, ia64_insn, ia64_insn, int, int, int);
static void insert_bit_table_ent (struct bittree *, int, ia64_insn, ia64_insn, int, int, int);
static void add_dis_entry (struct bittree *, ia64_insn, ia64_insn, int, struct completer_entry *, int);
static void add_dis_entry (struct bittree *, ia64_insn, ia64_insn, int, struct completer_entry *, int);
static void compact_distree (struct bittree *);
static void compact_distree (struct bittree *);
static struct bittree * make_bittree_entry (void);
static struct bittree * make_bittree_entry (void);
static struct disent * add_dis_table_ent (struct disent *, int, int, int);
static struct disent * add_dis_table_ent (struct disent *, int, int, int);
 
 


static void
static void
fail (const char *message, ...)
fail (const char *message, ...)
{
{
  va_list args;
  va_list args;
 
 
  va_start (args, message);
  va_start (args, message);
  fprintf (stderr, _("%s: Error: "), program_name);
  fprintf (stderr, _("%s: Error: "), program_name);
  vfprintf (stderr, message, args);
  vfprintf (stderr, message, args);
  va_end (args);
  va_end (args);
  xexit (1);
  xexit (1);
}
}
 
 
static void
static void
warn (const char *message, ...)
warn (const char *message, ...)
{
{
  va_list args;
  va_list args;
 
 
  va_start (args, message);
  va_start (args, message);
 
 
  fprintf (stderr, _("%s: Warning: "), program_name);
  fprintf (stderr, _("%s: Warning: "), program_name);
  vfprintf (stderr, message, args);
  vfprintf (stderr, message, args);
  va_end (args);
  va_end (args);
}
}
 
 
/* Add NAME to the resource table, where TYPE is RAW or WAW.  */
/* Add NAME to the resource table, where TYPE is RAW or WAW.  */
static struct rdep *
static struct rdep *
insert_resource (const char *name, enum ia64_dependency_mode type)
insert_resource (const char *name, enum ia64_dependency_mode type)
{
{
  if (rdepslen == rdepstotlen)
  if (rdepslen == rdepstotlen)
    {
    {
      rdepstotlen += 20;
      rdepstotlen += 20;
      rdeps = (struct rdep **)
      rdeps = (struct rdep **)
        xrealloc (rdeps, sizeof(struct rdep **) * rdepstotlen);
        xrealloc (rdeps, sizeof(struct rdep **) * rdepstotlen);
    }
    }
  rdeps[rdepslen] = tmalloc(struct rdep);
  rdeps[rdepslen] = tmalloc(struct rdep);
  memset((void *)rdeps[rdepslen], 0, sizeof(struct rdep));
  memset((void *)rdeps[rdepslen], 0, sizeof(struct rdep));
  rdeps[rdepslen]->name = xstrdup (name);
  rdeps[rdepslen]->name = xstrdup (name);
  rdeps[rdepslen]->mode = type;
  rdeps[rdepslen]->mode = type;
  rdeps[rdepslen]->waw_special = 0;
  rdeps[rdepslen]->waw_special = 0;
 
 
  return rdeps[rdepslen++];
  return rdeps[rdepslen++];
}
}
 
 
/* Are the lists of dependency indexes equivalent?  */
/* Are the lists of dependency indexes equivalent?  */
static int
static int
deplist_equals (struct deplist *d1, struct deplist *d2)
deplist_equals (struct deplist *d1, struct deplist *d2)
{
{
  int i;
  int i;
 
 
  if (d1->len != d2->len)
  if (d1->len != d2->len)
    return 0;
    return 0;
 
 
  for (i = 0; i < d1->len; i++)
  for (i = 0; i < d1->len; i++)
    if (d1->deps[i] != d2->deps[i])
    if (d1->deps[i] != d2->deps[i])
      return 0;
      return 0;
 
 
  return 1;
  return 1;
}
}
 
 
/* Add the list of dependencies to the list of dependency lists.  */
/* Add the list of dependencies to the list of dependency lists.  */
static short
static short
insert_deplist (int count, unsigned short *deps)
insert_deplist (int count, unsigned short *deps)
{
{
  /* Sort the list, then see if an equivalent list exists already.
  /* Sort the list, then see if an equivalent list exists already.
     this results in a much smaller set of dependency lists.  */
     this results in a much smaller set of dependency lists.  */
  struct deplist *list;
  struct deplist *list;
  char set[0x10000];
  char set[0x10000];
  int i;
  int i;
 
 
  memset ((void *)set, 0, sizeof (set));
  memset ((void *)set, 0, sizeof (set));
  for (i = 0; i < count; i++)
  for (i = 0; i < count; i++)
    set[deps[i]] = 1;
    set[deps[i]] = 1;
 
 
  count = 0;
  count = 0;
  for (i = 0; i < (int) sizeof (set); i++)
  for (i = 0; i < (int) sizeof (set); i++)
    if (set[i])
    if (set[i])
      ++count;
      ++count;
 
 
  list = tmalloc (struct deplist);
  list = tmalloc (struct deplist);
  list->len = count;
  list->len = count;
  list->deps = (unsigned short *) malloc (sizeof (unsigned short) * count);
  list->deps = (unsigned short *) malloc (sizeof (unsigned short) * count);
 
 
  for (i = 0, count = 0; i < (int) sizeof (set); i++)
  for (i = 0, count = 0; i < (int) sizeof (set); i++)
    if (set[i])
    if (set[i])
      list->deps[count++] = i;
      list->deps[count++] = i;
 
 
  /* Does this list exist already?  */
  /* Does this list exist already?  */
  for (i = 0; i < dlistlen; i++)
  for (i = 0; i < dlistlen; i++)
    if (deplist_equals (list, dlists[i]))
    if (deplist_equals (list, dlists[i]))
      {
      {
        free (list->deps);
        free (list->deps);
        free (list);
        free (list);
        return i;
        return i;
      }
      }
 
 
  if (dlistlen == dlisttotlen)
  if (dlistlen == dlisttotlen)
    {
    {
      dlisttotlen += 20;
      dlisttotlen += 20;
      dlists = (struct deplist **)
      dlists = (struct deplist **)
        xrealloc (dlists, sizeof(struct deplist **) * dlisttotlen);
        xrealloc (dlists, sizeof(struct deplist **) * dlisttotlen);
    }
    }
  dlists[dlistlen] = list;
  dlists[dlistlen] = list;
 
 
  return dlistlen++;
  return dlistlen++;
}
}
 
 
/* Add the given pair of dependency lists to the opcode dependency list.  */
/* Add the given pair of dependency lists to the opcode dependency list.  */
static short
static short
insert_dependencies (int nchks, unsigned short *chks,
insert_dependencies (int nchks, unsigned short *chks,
                     int nregs, unsigned short *regs)
                     int nregs, unsigned short *regs)
{
{
  struct opdep *pair;
  struct opdep *pair;
  int i;
  int i;
  int regind = -1;
  int regind = -1;
  int chkind = -1;
  int chkind = -1;
 
 
  if (nregs > 0)
  if (nregs > 0)
    regind = insert_deplist (nregs, regs);
    regind = insert_deplist (nregs, regs);
  if (nchks > 0)
  if (nchks > 0)
    chkind = insert_deplist (nchks, chks);
    chkind = insert_deplist (nchks, chks);
 
 
  for (i = 0; i < opdeplen; i++)
  for (i = 0; i < opdeplen; i++)
    if (opdeps[i]->chk == chkind
    if (opdeps[i]->chk == chkind
        && opdeps[i]->reg == regind)
        && opdeps[i]->reg == regind)
      return i;
      return i;
 
 
  pair = tmalloc (struct opdep);
  pair = tmalloc (struct opdep);
  pair->chk = chkind;
  pair->chk = chkind;
  pair->reg = regind;
  pair->reg = regind;
 
 
  if (opdeplen == opdeptotlen)
  if (opdeplen == opdeptotlen)
    {
    {
      opdeptotlen += 20;
      opdeptotlen += 20;
      opdeps = (struct opdep **)
      opdeps = (struct opdep **)
        xrealloc (opdeps, sizeof(struct opdep **) * opdeptotlen);
        xrealloc (opdeps, sizeof(struct opdep **) * opdeptotlen);
    }
    }
  opdeps[opdeplen] = pair;
  opdeps[opdeplen] = pair;
 
 
  return opdeplen++;
  return opdeplen++;
}
}
 
 
static void
static void
mark_used (struct iclass *ic, int clear_terminals)
mark_used (struct iclass *ic, int clear_terminals)
{
{
  int i;
  int i;
 
 
  ic->orphan = 0;
  ic->orphan = 0;
  if (clear_terminals)
  if (clear_terminals)
    ic->terminal_resolved = 1;
    ic->terminal_resolved = 1;
 
 
  for (i = 0; i < ic->nsubs; i++)
  for (i = 0; i < ic->nsubs; i++)
    mark_used (ics[ic->subs[i]], clear_terminals);
    mark_used (ics[ic->subs[i]], clear_terminals);
 
 
  for (i = 0; i < ic->nxsubs; i++)
  for (i = 0; i < ic->nxsubs; i++)
    mark_used (ics[ic->xsubs[i]], clear_terminals);
    mark_used (ics[ic->xsubs[i]], clear_terminals);
}
}
 
 
/* Look up an instruction class; if CREATE make a new one if none found;
/* Look up an instruction class; if CREATE make a new one if none found;
   returns the index into the insn class array.  */
   returns the index into the insn class array.  */
static int
static int
fetch_insn_class (const char *full_name, int create)
fetch_insn_class (const char *full_name, int create)
{
{
  char *name;
  char *name;
  char *notestr;
  char *notestr;
  char *xsect;
  char *xsect;
  char *comment;
  char *comment;
  int i, note = 0;
  int i, note = 0;
  int ind;
  int ind;
  int is_class = 0;
  int is_class = 0;
 
 
  if (CONST_STRNEQ (full_name, "IC:"))
  if (CONST_STRNEQ (full_name, "IC:"))
    {
    {
      name = xstrdup (full_name + 3);
      name = xstrdup (full_name + 3);
      is_class = 1;
      is_class = 1;
    }
    }
  else
  else
    name = xstrdup (full_name);
    name = xstrdup (full_name);
 
 
  if ((xsect = strchr(name, '\\')) != NULL)
  if ((xsect = strchr(name, '\\')) != NULL)
    is_class = 1;
    is_class = 1;
  if ((comment = strchr(name, '[')) != NULL)
  if ((comment = strchr(name, '[')) != NULL)
    is_class = 1;
    is_class = 1;
  if ((notestr = strchr(name, '+')) != NULL)
  if ((notestr = strchr(name, '+')) != NULL)
    is_class = 1;
    is_class = 1;
 
 
  /* If it is a composite class, then ignore comments and notes that come after
  /* If it is a composite class, then ignore comments and notes that come after
     the '\\', since they don't apply to the part we are decoding now.  */
     the '\\', since they don't apply to the part we are decoding now.  */
  if (xsect)
  if (xsect)
    {
    {
      if (comment > xsect)
      if (comment > xsect)
        comment = 0;
        comment = 0;
      if (notestr > xsect)
      if (notestr > xsect)
        notestr = 0;
        notestr = 0;
    }
    }
 
 
  if (notestr)
  if (notestr)
    {
    {
      char *nextnotestr;
      char *nextnotestr;
 
 
      note = atoi (notestr + 1);
      note = atoi (notestr + 1);
      if ((nextnotestr = strchr (notestr + 1, '+')) != NULL)
      if ((nextnotestr = strchr (notestr + 1, '+')) != NULL)
        {
        {
          if (strcmp (notestr, "+1+13") == 0)
          if (strcmp (notestr, "+1+13") == 0)
            note = 13;
            note = 13;
          else if (!xsect || nextnotestr < xsect)
          else if (!xsect || nextnotestr < xsect)
            warn (_("multiple note %s not handled\n"), notestr);
            warn (_("multiple note %s not handled\n"), notestr);
        }
        }
    }
    }
 
 
  /* If it's a composite class, leave the notes and comments in place so that
  /* If it's a composite class, leave the notes and comments in place so that
     we have a unique name for the composite class.  Otherwise, we remove
     we have a unique name for the composite class.  Otherwise, we remove
     them.  */
     them.  */
  if (!xsect)
  if (!xsect)
    {
    {
      if (notestr)
      if (notestr)
        *notestr = 0;
        *notestr = 0;
      if (comment)
      if (comment)
        *comment = 0;
        *comment = 0;
    }
    }
 
 
  for (i = 0; i < iclen; i++)
  for (i = 0; i < iclen; i++)
    if (strcmp (name, ics[i]->name) == 0
    if (strcmp (name, ics[i]->name) == 0
        && ((comment == NULL && ics[i]->comment == NULL)
        && ((comment == NULL && ics[i]->comment == NULL)
            || (comment != NULL && ics[i]->comment != NULL
            || (comment != NULL && ics[i]->comment != NULL
                && strncmp (ics[i]->comment, comment,
                && strncmp (ics[i]->comment, comment,
                            strlen (ics[i]->comment)) == 0))
                            strlen (ics[i]->comment)) == 0))
        && note == ics[i]->note)
        && note == ics[i]->note)
      return i;
      return i;
 
 
  if (!create)
  if (!create)
    return -1;
    return -1;
 
 
  /* Doesn't exist, so make a new one.  */
  /* Doesn't exist, so make a new one.  */
  if (iclen == ictotlen)
  if (iclen == ictotlen)
    {
    {
      ictotlen += 20;
      ictotlen += 20;
      ics = (struct iclass **)
      ics = (struct iclass **)
        xrealloc (ics, (ictotlen) * sizeof (struct iclass *));
        xrealloc (ics, (ictotlen) * sizeof (struct iclass *));
    }
    }
 
 
  ind = iclen++;
  ind = iclen++;
  ics[ind] = tmalloc (struct iclass);
  ics[ind] = tmalloc (struct iclass);
  memset ((void *)ics[ind], 0, sizeof (struct iclass));
  memset ((void *)ics[ind], 0, sizeof (struct iclass));
  ics[ind]->name = xstrdup (name);
  ics[ind]->name = xstrdup (name);
  ics[ind]->is_class = is_class;
  ics[ind]->is_class = is_class;
  ics[ind]->orphan = 1;
  ics[ind]->orphan = 1;
 
 
  if (comment)
  if (comment)
    {
    {
      ics[ind]->comment = xstrdup (comment + 1);
      ics[ind]->comment = xstrdup (comment + 1);
      ics[ind]->comment[strlen (ics[ind]->comment)-1] = 0;
      ics[ind]->comment[strlen (ics[ind]->comment)-1] = 0;
    }
    }
 
 
  if (notestr)
  if (notestr)
    ics[ind]->note = note;
    ics[ind]->note = note;
 
 
  /* If it's a composite class, there's a comment or note, look for an
  /* If it's a composite class, there's a comment or note, look for an
     existing class or terminal with the same name.  */
     existing class or terminal with the same name.  */
  if ((xsect || comment || notestr) && is_class)
  if ((xsect || comment || notestr) && is_class)
    {
    {
      /* First, populate with the class we're based on.  */
      /* First, populate with the class we're based on.  */
      char *subname = name;
      char *subname = name;
 
 
      if (xsect)
      if (xsect)
        *xsect = 0;
        *xsect = 0;
      else if (comment)
      else if (comment)
        *comment = 0;
        *comment = 0;
      else if (notestr)
      else if (notestr)
        *notestr = 0;
        *notestr = 0;
 
 
      ics[ind]->nsubs = 1;
      ics[ind]->nsubs = 1;
      ics[ind]->subs = tmalloc(int);
      ics[ind]->subs = tmalloc(int);
      ics[ind]->subs[0] = fetch_insn_class (subname, 1);;
      ics[ind]->subs[0] = fetch_insn_class (subname, 1);;
    }
    }
 
 
  while (xsect)
  while (xsect)
    {
    {
      char *subname = xsect + 1;
      char *subname = xsect + 1;
 
 
      xsect = strchr (subname, '\\');
      xsect = strchr (subname, '\\');
      if (xsect)
      if (xsect)
        *xsect = 0;
        *xsect = 0;
      ics[ind]->xsubs[ics[ind]->nxsubs] = fetch_insn_class (subname,1);
      ics[ind]->xsubs[ics[ind]->nxsubs] = fetch_insn_class (subname,1);
      ics[ind]->nxsubs++;
      ics[ind]->nxsubs++;
    }
    }
  free (name);
  free (name);
 
 
  return ind;
  return ind;
}
}
 
 
/* For sorting a class's sub-class list only; make sure classes appear before
/* For sorting a class's sub-class list only; make sure classes appear before
   terminals.  */
   terminals.  */
static int
static int
sub_compare (const void *e1, const void *e2)
sub_compare (const void *e1, const void *e2)
{
{
  struct iclass *ic1 = ics[*(int *)e1];
  struct iclass *ic1 = ics[*(int *)e1];
  struct iclass *ic2 = ics[*(int *)e2];
  struct iclass *ic2 = ics[*(int *)e2];
 
 
  if (ic1->is_class)
  if (ic1->is_class)
    {
    {
      if (!ic2->is_class)
      if (!ic2->is_class)
        return -1;
        return -1;
    }
    }
  else if (ic2->is_class)
  else if (ic2->is_class)
    return 1;
    return 1;
 
 
  return strcmp (ic1->name, ic2->name);
  return strcmp (ic1->name, ic2->name);
}
}
 
 
static void
static void
load_insn_classes (void)
load_insn_classes (void)
{
{
  FILE *fp = fopen ("ia64-ic.tbl", "r");
  FILE *fp = fopen ("ia64-ic.tbl", "r");
  char buf[2048];
  char buf[2048];
 
 
  if (fp == NULL)
  if (fp == NULL)
    fail (_("can't find ia64-ic.tbl for reading\n"));
    fail (_("can't find ia64-ic.tbl for reading\n"));
 
 
  /* Discard first line.  */
  /* Discard first line.  */
  fgets (buf, sizeof(buf), fp);
  fgets (buf, sizeof(buf), fp);
 
 
  while (!feof (fp))
  while (!feof (fp))
    {
    {
      int iclass;
      int iclass;
      char *name;
      char *name;
      char *tmp;
      char *tmp;
 
 
      if (fgets (buf, sizeof (buf), fp) == NULL)
      if (fgets (buf, sizeof (buf), fp) == NULL)
        break;
        break;
 
 
      while (ISSPACE (buf[strlen (buf) - 1]))
      while (ISSPACE (buf[strlen (buf) - 1]))
        buf[strlen (buf) - 1] = '\0';
        buf[strlen (buf) - 1] = '\0';
 
 
      name = tmp = buf;
      name = tmp = buf;
      while (*tmp != ';')
      while (*tmp != ';')
        {
        {
          ++tmp;
          ++tmp;
          if (tmp == buf + sizeof (buf))
          if (tmp == buf + sizeof (buf))
            abort ();
            abort ();
        }
        }
      *tmp++ = '\0';
      *tmp++ = '\0';
 
 
      iclass = fetch_insn_class (name, 1);
      iclass = fetch_insn_class (name, 1);
      ics[iclass]->is_class = 1;
      ics[iclass]->is_class = 1;
 
 
      if (strcmp (name, "none") == 0)
      if (strcmp (name, "none") == 0)
        {
        {
          ics[iclass]->is_class = 0;
          ics[iclass]->is_class = 0;
          ics[iclass]->terminal_resolved = 1;
          ics[iclass]->terminal_resolved = 1;
          continue;
          continue;
        }
        }
 
 
      /* For this class, record all sub-classes.  */
      /* For this class, record all sub-classes.  */
      while (*tmp)
      while (*tmp)
        {
        {
          char *subname;
          char *subname;
          int sub;
          int sub;
 
 
          while (*tmp && ISSPACE (*tmp))
          while (*tmp && ISSPACE (*tmp))
            {
            {
              ++tmp;
              ++tmp;
              if (tmp == buf + sizeof (buf))
              if (tmp == buf + sizeof (buf))
                abort ();
                abort ();
            }
            }
          subname = tmp;
          subname = tmp;
          while (*tmp && *tmp != ',')
          while (*tmp && *tmp != ',')
            {
            {
              ++tmp;
              ++tmp;
              if (tmp == buf + sizeof (buf))
              if (tmp == buf + sizeof (buf))
                abort ();
                abort ();
            }
            }
          if (*tmp == ',')
          if (*tmp == ',')
            *tmp++ = '\0';
            *tmp++ = '\0';
 
 
          ics[iclass]->subs = (int *)
          ics[iclass]->subs = (int *)
            xrealloc ((void *)ics[iclass]->subs,
            xrealloc ((void *)ics[iclass]->subs,
                      (ics[iclass]->nsubs + 1) * sizeof (int));
                      (ics[iclass]->nsubs + 1) * sizeof (int));
 
 
          sub = fetch_insn_class (subname, 1);
          sub = fetch_insn_class (subname, 1);
          ics[iclass]->subs = (int *)
          ics[iclass]->subs = (int *)
            xrealloc (ics[iclass]->subs, (ics[iclass]->nsubs + 1) * sizeof (int));
            xrealloc (ics[iclass]->subs, (ics[iclass]->nsubs + 1) * sizeof (int));
          ics[iclass]->subs[ics[iclass]->nsubs++] = sub;
          ics[iclass]->subs[ics[iclass]->nsubs++] = sub;
        }
        }
 
 
      /* Make sure classes come before terminals.  */
      /* Make sure classes come before terminals.  */
      qsort ((void *)ics[iclass]->subs,
      qsort ((void *)ics[iclass]->subs,
             ics[iclass]->nsubs, sizeof(int), sub_compare);
             ics[iclass]->nsubs, sizeof(int), sub_compare);
    }
    }
  fclose (fp);
  fclose (fp);
 
 
  if (debug)
  if (debug)
    printf ("%d classes\n", iclen);
    printf ("%d classes\n", iclen);
}
}
 
 
/* Extract the insn classes from the given line.  */
/* Extract the insn classes from the given line.  */
static void
static void
parse_resource_users (const char *ref, int **usersp, int *nusersp,
parse_resource_users (const char *ref, int **usersp, int *nusersp,
                      int **notesp)
                      int **notesp)
{
{
  int c;
  int c;
  char *line = xstrdup (ref);
  char *line = xstrdup (ref);
  char *tmp = line;
  char *tmp = line;
  int *users = *usersp;
  int *users = *usersp;
  int count = *nusersp;
  int count = *nusersp;
  int *notes = *notesp;
  int *notes = *notesp;
 
 
  c = *tmp;
  c = *tmp;
  while (c != 0)
  while (c != 0)
    {
    {
      char *notestr;
      char *notestr;
      int note;
      int note;
      char *xsect;
      char *xsect;
      int iclass;
      int iclass;
      int create = 0;
      int create = 0;
      char *name;
      char *name;
 
 
      while (ISSPACE (*tmp))
      while (ISSPACE (*tmp))
        ++tmp;
        ++tmp;
      name = tmp;
      name = tmp;
      while (*tmp && *tmp != ',')
      while (*tmp && *tmp != ',')
        ++tmp;
        ++tmp;
      c = *tmp;
      c = *tmp;
      *tmp++ = '\0';
      *tmp++ = '\0';
 
 
      xsect = strchr (name, '\\');
      xsect = strchr (name, '\\');
      if ((notestr = strstr (name, "+")) != NULL)
      if ((notestr = strstr (name, "+")) != NULL)
        {
        {
          char *nextnotestr;
          char *nextnotestr;
 
 
          note = atoi (notestr + 1);
          note = atoi (notestr + 1);
          if ((nextnotestr = strchr (notestr + 1, '+')) != NULL)
          if ((nextnotestr = strchr (notestr + 1, '+')) != NULL)
            {
            {
              /* Note 13 always implies note 1.  */
              /* Note 13 always implies note 1.  */
              if (strcmp (notestr, "+1+13") == 0)
              if (strcmp (notestr, "+1+13") == 0)
                note = 13;
                note = 13;
              else if (!xsect || nextnotestr < xsect)
              else if (!xsect || nextnotestr < xsect)
                warn (_("multiple note %s not handled\n"), notestr);
                warn (_("multiple note %s not handled\n"), notestr);
            }
            }
          if (!xsect)
          if (!xsect)
            *notestr = '\0';
            *notestr = '\0';
        }
        }
      else
      else
        note = 0;
        note = 0;
 
 
      /* All classes are created when the insn class table is parsed;
      /* All classes are created when the insn class table is parsed;
         Individual instructions might not appear until the dependency tables
         Individual instructions might not appear until the dependency tables
         are read.  Only create new classes if it's *not* an insn class,
         are read.  Only create new classes if it's *not* an insn class,
         or if it's a composite class (which wouldn't necessarily be in the IC
         or if it's a composite class (which wouldn't necessarily be in the IC
         table).  */
         table).  */
      if (! CONST_STRNEQ (name, "IC:") || xsect != NULL)
      if (! CONST_STRNEQ (name, "IC:") || xsect != NULL)
        create = 1;
        create = 1;
 
 
      iclass = fetch_insn_class (name, create);
      iclass = fetch_insn_class (name, create);
      if (iclass != -1)
      if (iclass != -1)
        {
        {
          users = (int *)
          users = (int *)
            xrealloc ((void *) users,(count + 1) * sizeof (int));
            xrealloc ((void *) users,(count + 1) * sizeof (int));
          notes = (int *)
          notes = (int *)
            xrealloc ((void *) notes,(count + 1) * sizeof (int));
            xrealloc ((void *) notes,(count + 1) * sizeof (int));
          notes[count] = note;
          notes[count] = note;
          users[count++] = iclass;
          users[count++] = iclass;
          mark_used (ics[iclass], 0);
          mark_used (ics[iclass], 0);
        }
        }
      else if (debug)
      else if (debug)
        printf("Class %s not found\n", name);
        printf("Class %s not found\n", name);
    }
    }
  /* Update the return values.  */
  /* Update the return values.  */
  *usersp = users;
  *usersp = users;
  *nusersp = count;
  *nusersp = count;
  *notesp = notes;
  *notesp = notes;
 
 
  free (line);
  free (line);
}
}
 
 
static int
static int
parse_semantics (char *sem)
parse_semantics (char *sem)
{
{
  if (strcmp (sem, "none") == 0)
  if (strcmp (sem, "none") == 0)
    return IA64_DVS_NONE;
    return IA64_DVS_NONE;
  else if (strcmp (sem, "implied") == 0)
  else if (strcmp (sem, "implied") == 0)
    return IA64_DVS_IMPLIED;
    return IA64_DVS_IMPLIED;
  else if (strcmp (sem, "impliedF") == 0)
  else if (strcmp (sem, "impliedF") == 0)
    return IA64_DVS_IMPLIEDF;
    return IA64_DVS_IMPLIEDF;
  else if (strcmp (sem, "data") == 0)
  else if (strcmp (sem, "data") == 0)
    return IA64_DVS_DATA;
    return IA64_DVS_DATA;
  else if (strcmp (sem, "instr") == 0)
  else if (strcmp (sem, "instr") == 0)
    return IA64_DVS_INSTR;
    return IA64_DVS_INSTR;
  else if (strcmp (sem, "specific") == 0)
  else if (strcmp (sem, "specific") == 0)
    return IA64_DVS_SPECIFIC;
    return IA64_DVS_SPECIFIC;
  else if (strcmp (sem, "stop") == 0)
  else if (strcmp (sem, "stop") == 0)
    return IA64_DVS_STOP;
    return IA64_DVS_STOP;
  else
  else
    return IA64_DVS_OTHER;
    return IA64_DVS_OTHER;
}
}
 
 
static void
static void
add_dep (const char *name, const char *chk, const char *reg,
add_dep (const char *name, const char *chk, const char *reg,
         int semantics, int mode, char *extra, int flag)
         int semantics, int mode, char *extra, int flag)
{
{
  struct rdep *rs;
  struct rdep *rs;
 
 
  rs = insert_resource (name, mode);
  rs = insert_resource (name, mode);
 
 
  parse_resource_users (chk, &rs->chks, &rs->nchks, &rs->chknotes);
  parse_resource_users (chk, &rs->chks, &rs->nchks, &rs->chknotes);
  parse_resource_users (reg, &rs->regs, &rs->nregs, &rs->regnotes);
  parse_resource_users (reg, &rs->regs, &rs->nregs, &rs->regnotes);
 
 
  rs->semantics = semantics;
  rs->semantics = semantics;
  rs->extra = extra;
  rs->extra = extra;
  rs->waw_special = flag;
  rs->waw_special = flag;
}
}
 
 
static void
static void
load_depfile (const char *filename, enum ia64_dependency_mode mode)
load_depfile (const char *filename, enum ia64_dependency_mode mode)
{
{
  FILE *fp = fopen (filename, "r");
  FILE *fp = fopen (filename, "r");
  char buf[1024];
  char buf[1024];
 
 
  if (fp == NULL)
  if (fp == NULL)
    fail (_("can't find %s for reading\n"), filename);
    fail (_("can't find %s for reading\n"), filename);
 
 
  fgets (buf, sizeof(buf), fp);
  fgets (buf, sizeof(buf), fp);
  while (!feof (fp))
  while (!feof (fp))
    {
    {
      char *name, *tmp;
      char *name, *tmp;
      int semantics;
      int semantics;
      char *extra;
      char *extra;
      char *regp, *chkp;
      char *regp, *chkp;
 
 
      if (fgets (buf, sizeof(buf), fp) == NULL)
      if (fgets (buf, sizeof(buf), fp) == NULL)
        break;
        break;
 
 
      while (ISSPACE (buf[strlen (buf) - 1]))
      while (ISSPACE (buf[strlen (buf) - 1]))
        buf[strlen (buf) - 1] = '\0';
        buf[strlen (buf) - 1] = '\0';
 
 
      name = tmp = buf;
      name = tmp = buf;
      while (*tmp != ';')
      while (*tmp != ';')
        ++tmp;
        ++tmp;
      *tmp++ = '\0';
      *tmp++ = '\0';
 
 
      while (ISSPACE (*tmp))
      while (ISSPACE (*tmp))
        ++tmp;
        ++tmp;
      regp = tmp;
      regp = tmp;
      tmp = strchr (tmp, ';');
      tmp = strchr (tmp, ';');
      if (!tmp)
      if (!tmp)
        abort ();
        abort ();
      *tmp++ = 0;
      *tmp++ = 0;
      while (ISSPACE (*tmp))
      while (ISSPACE (*tmp))
        ++tmp;
        ++tmp;
      chkp = tmp;
      chkp = tmp;
      tmp = strchr (tmp, ';');
      tmp = strchr (tmp, ';');
      if (!tmp)
      if (!tmp)
        abort ();
        abort ();
      *tmp++ = 0;
      *tmp++ = 0;
      while (ISSPACE (*tmp))
      while (ISSPACE (*tmp))
        ++tmp;
        ++tmp;
      semantics = parse_semantics (tmp);
      semantics = parse_semantics (tmp);
      extra = semantics == IA64_DVS_OTHER ? xstrdup (tmp) : NULL;
      extra = semantics == IA64_DVS_OTHER ? xstrdup (tmp) : NULL;
 
 
      /* For WAW entries, if the chks and regs differ, we need to enter the
      /* For WAW entries, if the chks and regs differ, we need to enter the
         entries in both positions so that the tables will be parsed properly,
         entries in both positions so that the tables will be parsed properly,
         without a lot of extra work.  */
         without a lot of extra work.  */
      if (mode == IA64_DV_WAW && strcmp (regp, chkp) != 0)
      if (mode == IA64_DV_WAW && strcmp (regp, chkp) != 0)
        {
        {
          add_dep (name, chkp, regp, semantics, mode, extra, 0);
          add_dep (name, chkp, regp, semantics, mode, extra, 0);
          add_dep (name, regp, chkp, semantics, mode, extra, 1);
          add_dep (name, regp, chkp, semantics, mode, extra, 1);
        }
        }
      else
      else
        {
        {
          add_dep (name, chkp, regp, semantics, mode, extra, 0);
          add_dep (name, chkp, regp, semantics, mode, extra, 0);
        }
        }
    }
    }
  fclose (fp);
  fclose (fp);
}
}
 
 
static void
static void
load_dependencies (void)
load_dependencies (void)
{
{
  load_depfile ("ia64-raw.tbl", IA64_DV_RAW);
  load_depfile ("ia64-raw.tbl", IA64_DV_RAW);
  load_depfile ("ia64-waw.tbl", IA64_DV_WAW);
  load_depfile ("ia64-waw.tbl", IA64_DV_WAW);
  load_depfile ("ia64-war.tbl", IA64_DV_WAR);
  load_depfile ("ia64-war.tbl", IA64_DV_WAR);
 
 
  if (debug)
  if (debug)
    printf ("%d RAW/WAW/WAR dependencies\n", rdepslen);
    printf ("%d RAW/WAW/WAR dependencies\n", rdepslen);
}
}
 
 
/* Is the given operand an indirect register file operand?  */
/* Is the given operand an indirect register file operand?  */
static int
static int
irf_operand (int op, const char *field)
irf_operand (int op, const char *field)
{
{
  if (!field)
  if (!field)
    {
    {
      return op == IA64_OPND_RR_R3 || op == IA64_OPND_DBR_R3
      return op == IA64_OPND_RR_R3 || op == IA64_OPND_DBR_R3
        || op == IA64_OPND_IBR_R3  || op == IA64_OPND_PKR_R3
        || op == IA64_OPND_IBR_R3  || op == IA64_OPND_PKR_R3
        || op == IA64_OPND_PMC_R3  || op == IA64_OPND_PMD_R3
        || op == IA64_OPND_PMC_R3  || op == IA64_OPND_PMD_R3
        || op == IA64_OPND_MSR_R3 || op == IA64_OPND_CPUID_R3;
        || op == IA64_OPND_MSR_R3 || op == IA64_OPND_CPUID_R3;
    }
    }
  else
  else
    {
    {
      return ((op == IA64_OPND_RR_R3 && strstr (field, "rr"))
      return ((op == IA64_OPND_RR_R3 && strstr (field, "rr"))
              || (op == IA64_OPND_DBR_R3 && strstr (field, "dbr"))
              || (op == IA64_OPND_DBR_R3 && strstr (field, "dbr"))
              || (op == IA64_OPND_IBR_R3 && strstr (field, "ibr"))
              || (op == IA64_OPND_IBR_R3 && strstr (field, "ibr"))
              || (op == IA64_OPND_PKR_R3 && strstr (field, "pkr"))
              || (op == IA64_OPND_PKR_R3 && strstr (field, "pkr"))
              || (op == IA64_OPND_PMC_R3 && strstr (field, "pmc"))
              || (op == IA64_OPND_PMC_R3 && strstr (field, "pmc"))
              || (op == IA64_OPND_PMD_R3 && strstr (field, "pmd"))
              || (op == IA64_OPND_PMD_R3 && strstr (field, "pmd"))
              || (op == IA64_OPND_MSR_R3 && strstr (field, "msr"))
              || (op == IA64_OPND_MSR_R3 && strstr (field, "msr"))
              || (op == IA64_OPND_CPUID_R3 && strstr (field, "cpuid")));
              || (op == IA64_OPND_CPUID_R3 && strstr (field, "cpuid")));
    }
    }
}
}
 
 
/* Handle mov_ar, mov_br, mov_cr, mov_indirect, mov_ip, mov_pr, mov_psr, and
/* Handle mov_ar, mov_br, mov_cr, mov_indirect, mov_ip, mov_pr, mov_psr, and
   mov_um insn classes.  */
   mov_um insn classes.  */
static int
static int
in_iclass_mov_x (struct ia64_opcode *idesc, struct iclass *ic,
in_iclass_mov_x (struct ia64_opcode *idesc, struct iclass *ic,
                 const char *format, const char *field)
                 const char *format, const char *field)
{
{
  int plain_mov = strcmp (idesc->name, "mov") == 0;
  int plain_mov = strcmp (idesc->name, "mov") == 0;
 
 
  if (!format)
  if (!format)
    return 0;
    return 0;
 
 
  switch (ic->name[4])
  switch (ic->name[4])
    {
    {
    default:
    default:
      abort ();
      abort ();
    case 'a':
    case 'a':
      {
      {
        int i = strcmp (idesc->name, "mov.i") == 0;
        int i = strcmp (idesc->name, "mov.i") == 0;
        int m = strcmp (idesc->name, "mov.m") == 0;
        int m = strcmp (idesc->name, "mov.m") == 0;
        int i2627 = i && idesc->operands[0] == IA64_OPND_AR3;
        int i2627 = i && idesc->operands[0] == IA64_OPND_AR3;
        int i28 = i && idesc->operands[1] == IA64_OPND_AR3;
        int i28 = i && idesc->operands[1] == IA64_OPND_AR3;
        int m2930 = m && idesc->operands[0] == IA64_OPND_AR3;
        int m2930 = m && idesc->operands[0] == IA64_OPND_AR3;
        int m31 = m && idesc->operands[1] == IA64_OPND_AR3;
        int m31 = m && idesc->operands[1] == IA64_OPND_AR3;
        int pseudo0 = plain_mov && idesc->operands[1] == IA64_OPND_AR3;
        int pseudo0 = plain_mov && idesc->operands[1] == IA64_OPND_AR3;
        int pseudo1 = plain_mov && idesc->operands[0] == IA64_OPND_AR3;
        int pseudo1 = plain_mov && idesc->operands[0] == IA64_OPND_AR3;
 
 
        /* IC:mov ar */
        /* IC:mov ar */
        if (i2627)
        if (i2627)
          return strstr (format, "I26") || strstr (format, "I27");
          return strstr (format, "I26") || strstr (format, "I27");
        if (i28)
        if (i28)
          return strstr (format, "I28") != NULL;
          return strstr (format, "I28") != NULL;
        if (m2930)
        if (m2930)
          return strstr (format, "M29") || strstr (format, "M30");
          return strstr (format, "M29") || strstr (format, "M30");
        if (m31)
        if (m31)
          return strstr (format, "M31") != NULL;
          return strstr (format, "M31") != NULL;
        if (pseudo0 || pseudo1)
        if (pseudo0 || pseudo1)
          return 1;
          return 1;
      }
      }
      break;
      break;
    case 'b':
    case 'b':
      {
      {
        int i21 = idesc->operands[0] == IA64_OPND_B1;
        int i21 = idesc->operands[0] == IA64_OPND_B1;
        int i22 = plain_mov && idesc->operands[1] == IA64_OPND_B2;
        int i22 = plain_mov && idesc->operands[1] == IA64_OPND_B2;
        if (i22)
        if (i22)
          return strstr (format, "I22") != NULL;
          return strstr (format, "I22") != NULL;
        if (i21)
        if (i21)
          return strstr (format, "I21") != NULL;
          return strstr (format, "I21") != NULL;
      }
      }
      break;
      break;
    case 'c':
    case 'c':
      {
      {
        int m32 = plain_mov && idesc->operands[0] == IA64_OPND_CR3;
        int m32 = plain_mov && idesc->operands[0] == IA64_OPND_CR3;
        int m33 = plain_mov && idesc->operands[1] == IA64_OPND_CR3;
        int m33 = plain_mov && idesc->operands[1] == IA64_OPND_CR3;
        if (m32)
        if (m32)
          return strstr (format, "M32") != NULL;
          return strstr (format, "M32") != NULL;
        if (m33)
        if (m33)
          return strstr (format, "M33") != NULL;
          return strstr (format, "M33") != NULL;
      }
      }
      break;
      break;
    case 'i':
    case 'i':
      if (ic->name[5] == 'n')
      if (ic->name[5] == 'n')
        {
        {
          int m42 = plain_mov && irf_operand (idesc->operands[0], field);
          int m42 = plain_mov && irf_operand (idesc->operands[0], field);
          int m43 = plain_mov && irf_operand (idesc->operands[1], field);
          int m43 = plain_mov && irf_operand (idesc->operands[1], field);
          if (m42)
          if (m42)
            return strstr (format, "M42") != NULL;
            return strstr (format, "M42") != NULL;
          if (m43)
          if (m43)
            return strstr (format, "M43") != NULL;
            return strstr (format, "M43") != NULL;
        }
        }
      else if (ic->name[5] == 'p')
      else if (ic->name[5] == 'p')
        {
        {
          return idesc->operands[1] == IA64_OPND_IP;
          return idesc->operands[1] == IA64_OPND_IP;
        }
        }
      else
      else
        abort ();
        abort ();
      break;
      break;
    case 'p':
    case 'p':
      if (ic->name[5] == 'r')
      if (ic->name[5] == 'r')
        {
        {
          int i25 = plain_mov && idesc->operands[1] == IA64_OPND_PR;
          int i25 = plain_mov && idesc->operands[1] == IA64_OPND_PR;
          int i23 = plain_mov && idesc->operands[0] == IA64_OPND_PR;
          int i23 = plain_mov && idesc->operands[0] == IA64_OPND_PR;
          int i24 = plain_mov && idesc->operands[0] == IA64_OPND_PR_ROT;
          int i24 = plain_mov && idesc->operands[0] == IA64_OPND_PR_ROT;
          if (i23)
          if (i23)
            return strstr (format, "I23") != NULL;
            return strstr (format, "I23") != NULL;
          if (i24)
          if (i24)
            return strstr (format, "I24") != NULL;
            return strstr (format, "I24") != NULL;
          if (i25)
          if (i25)
            return strstr (format, "I25") != NULL;
            return strstr (format, "I25") != NULL;
        }
        }
      else if (ic->name[5] == 's')
      else if (ic->name[5] == 's')
        {
        {
          int m35 = plain_mov && idesc->operands[0] == IA64_OPND_PSR_L;
          int m35 = plain_mov && idesc->operands[0] == IA64_OPND_PSR_L;
          int m36 = plain_mov && idesc->operands[1] == IA64_OPND_PSR;
          int m36 = plain_mov && idesc->operands[1] == IA64_OPND_PSR;
          if (m35)
          if (m35)
            return strstr (format, "M35") != NULL;
            return strstr (format, "M35") != NULL;
          if (m36)
          if (m36)
            return strstr (format, "M36") != NULL;
            return strstr (format, "M36") != NULL;
        }
        }
      else
      else
        abort ();
        abort ();
      break;
      break;
    case 'u':
    case 'u':
      {
      {
        int m35 = plain_mov && idesc->operands[0] == IA64_OPND_PSR_UM;
        int m35 = plain_mov && idesc->operands[0] == IA64_OPND_PSR_UM;
        int m36 = plain_mov && idesc->operands[1] == IA64_OPND_PSR_UM;
        int m36 = plain_mov && idesc->operands[1] == IA64_OPND_PSR_UM;
        if (m35)
        if (m35)
          return strstr (format, "M35") != NULL;
          return strstr (format, "M35") != NULL;
        if (m36)
        if (m36)
          return strstr (format, "M36") != NULL;
          return strstr (format, "M36") != NULL;
      }
      }
      break;
      break;
    }
    }
  return 0;
  return 0;
}
}
 
 
/* Is the given opcode in the given insn class?  */
/* Is the given opcode in the given insn class?  */
static int
static int
in_iclass (struct ia64_opcode *idesc, struct iclass *ic,
in_iclass (struct ia64_opcode *idesc, struct iclass *ic,
           const char *format, const char *field, int *notep)
           const char *format, const char *field, int *notep)
{
{
  int i;
  int i;
  int resolved = 0;
  int resolved = 0;
 
 
  if (ic->comment)
  if (ic->comment)
    {
    {
      if (CONST_STRNEQ (ic->comment, "Format"))
      if (CONST_STRNEQ (ic->comment, "Format"))
        {
        {
          /* Assume that the first format seen is the most restrictive, and
          /* Assume that the first format seen is the most restrictive, and
             only keep a later one if it looks like it's more restrictive.  */
             only keep a later one if it looks like it's more restrictive.  */
          if (format)
          if (format)
            {
            {
              if (strlen (ic->comment) < strlen (format))
              if (strlen (ic->comment) < strlen (format))
                {
                {
                  warn (_("most recent format '%s'\nappears more restrictive than '%s'\n"),
                  warn (_("most recent format '%s'\nappears more restrictive than '%s'\n"),
                        ic->comment, format);
                        ic->comment, format);
                  format = ic->comment;
                  format = ic->comment;
                }
                }
            }
            }
          else
          else
            format = ic->comment;
            format = ic->comment;
        }
        }
      else if (CONST_STRNEQ (ic->comment, "Field"))
      else if (CONST_STRNEQ (ic->comment, "Field"))
        {
        {
          if (field)
          if (field)
            warn (_("overlapping field %s->%s\n"),
            warn (_("overlapping field %s->%s\n"),
                  ic->comment, field);
                  ic->comment, field);
          field = ic->comment;
          field = ic->comment;
        }
        }
    }
    }
 
 
  /* An insn class matches anything that is the same followed by completers,
  /* An insn class matches anything that is the same followed by completers,
     except when the absence and presence of completers constitutes different
     except when the absence and presence of completers constitutes different
     instructions.  */
     instructions.  */
  if (ic->nsubs == 0 && ic->nxsubs == 0)
  if (ic->nsubs == 0 && ic->nxsubs == 0)
    {
    {
      int is_mov = CONST_STRNEQ (idesc->name, "mov");
      int is_mov = CONST_STRNEQ (idesc->name, "mov");
      int plain_mov = strcmp (idesc->name, "mov") == 0;
      int plain_mov = strcmp (idesc->name, "mov") == 0;
      int len = strlen(ic->name);
      int len = strlen(ic->name);
 
 
      resolved = ((strncmp (ic->name, idesc->name, len) == 0)
      resolved = ((strncmp (ic->name, idesc->name, len) == 0)
                  && (idesc->name[len] == '\0'
                  && (idesc->name[len] == '\0'
                      || idesc->name[len] == '.'));
                      || idesc->name[len] == '.'));
 
 
      /* All break, nop, and hint variations must match exactly.  */
      /* All break, nop, and hint variations must match exactly.  */
      if (resolved &&
      if (resolved &&
          (strcmp (ic->name, "break") == 0
          (strcmp (ic->name, "break") == 0
           || strcmp (ic->name, "nop") == 0
           || strcmp (ic->name, "nop") == 0
           || strcmp (ic->name, "hint") == 0))
           || strcmp (ic->name, "hint") == 0))
        resolved = strcmp (ic->name, idesc->name) == 0;
        resolved = strcmp (ic->name, idesc->name) == 0;
 
 
      /* Assume restrictions in the FORMAT/FIELD negate resolution,
      /* Assume restrictions in the FORMAT/FIELD negate resolution,
         unless specifically allowed by clauses in this block.  */
         unless specifically allowed by clauses in this block.  */
      if (resolved && field)
      if (resolved && field)
        {
        {
          /* Check Field(sf)==sN against opcode sN.  */
          /* Check Field(sf)==sN against opcode sN.  */
          if (strstr(field, "(sf)==") != NULL)
          if (strstr(field, "(sf)==") != NULL)
            {
            {
              char *sf;
              char *sf;
 
 
              if ((sf = strstr (idesc->name, ".s")) != 0)
              if ((sf = strstr (idesc->name, ".s")) != 0)
                resolved = strcmp (sf + 1, strstr (field, "==") + 2) == 0;
                resolved = strcmp (sf + 1, strstr (field, "==") + 2) == 0;
            }
            }
          /* Check Field(lftype)==XXX.  */
          /* Check Field(lftype)==XXX.  */
          else if (strstr (field, "(lftype)") != NULL)
          else if (strstr (field, "(lftype)") != NULL)
            {
            {
              if (strstr (idesc->name, "fault") != NULL)
              if (strstr (idesc->name, "fault") != NULL)
                resolved = strstr (field, "fault") != NULL;
                resolved = strstr (field, "fault") != NULL;
              else
              else
                resolved = strstr (field, "fault") == NULL;
                resolved = strstr (field, "fault") == NULL;
            }
            }
          /* Handle Field(ctype)==XXX.  */
          /* Handle Field(ctype)==XXX.  */
          else if (strstr (field, "(ctype)") != NULL)
          else if (strstr (field, "(ctype)") != NULL)
            {
            {
              if (strstr (idesc->name, "or.andcm"))
              if (strstr (idesc->name, "or.andcm"))
                resolved = strstr (field, "or.andcm") != NULL;
                resolved = strstr (field, "or.andcm") != NULL;
              else if (strstr (idesc->name, "and.orcm"))
              else if (strstr (idesc->name, "and.orcm"))
                resolved = strstr (field, "and.orcm") != NULL;
                resolved = strstr (field, "and.orcm") != NULL;
              else if (strstr (idesc->name, "orcm"))
              else if (strstr (idesc->name, "orcm"))
                resolved = strstr (field, "or orcm") != NULL;
                resolved = strstr (field, "or orcm") != NULL;
              else if (strstr (idesc->name, "or"))
              else if (strstr (idesc->name, "or"))
                resolved = strstr (field, "or orcm") != NULL;
                resolved = strstr (field, "or orcm") != NULL;
              else if (strstr (idesc->name, "andcm"))
              else if (strstr (idesc->name, "andcm"))
                resolved = strstr (field, "and andcm") != NULL;
                resolved = strstr (field, "and andcm") != NULL;
              else if (strstr (idesc->name, "and"))
              else if (strstr (idesc->name, "and"))
                resolved = strstr (field, "and andcm") != NULL;
                resolved = strstr (field, "and andcm") != NULL;
              else if (strstr (idesc->name, "unc"))
              else if (strstr (idesc->name, "unc"))
                resolved = strstr (field, "unc") != NULL;
                resolved = strstr (field, "unc") != NULL;
              else
              else
                resolved = strcmp (field, "Field(ctype)==") == 0;
                resolved = strcmp (field, "Field(ctype)==") == 0;
            }
            }
        }
        }
 
 
      if (resolved && format)
      if (resolved && format)
        {
        {
          if (CONST_STRNEQ (idesc->name, "dep")
          if (CONST_STRNEQ (idesc->name, "dep")
                   && strstr (format, "I13") != NULL)
                   && strstr (format, "I13") != NULL)
            resolved = idesc->operands[1] == IA64_OPND_IMM8;
            resolved = idesc->operands[1] == IA64_OPND_IMM8;
          else if (CONST_STRNEQ (idesc->name, "chk")
          else if (CONST_STRNEQ (idesc->name, "chk")
                   && strstr (format, "M21") != NULL)
                   && strstr (format, "M21") != NULL)
            resolved = idesc->operands[0] == IA64_OPND_F2;
            resolved = idesc->operands[0] == IA64_OPND_F2;
          else if (CONST_STRNEQ (idesc->name, "lfetch"))
          else if (CONST_STRNEQ (idesc->name, "lfetch"))
            resolved = (strstr (format, "M14 M15") != NULL
            resolved = (strstr (format, "M14 M15") != NULL
                        && (idesc->operands[1] == IA64_OPND_R2
                        && (idesc->operands[1] == IA64_OPND_R2
                            || idesc->operands[1] == IA64_OPND_IMM9b));
                            || idesc->operands[1] == IA64_OPND_IMM9b));
          else if (CONST_STRNEQ (idesc->name, "br.call")
          else if (CONST_STRNEQ (idesc->name, "br.call")
                   && strstr (format, "B5") != NULL)
                   && strstr (format, "B5") != NULL)
            resolved = idesc->operands[1] == IA64_OPND_B2;
            resolved = idesc->operands[1] == IA64_OPND_B2;
          else if (CONST_STRNEQ (idesc->name, "br.call")
          else if (CONST_STRNEQ (idesc->name, "br.call")
                   && strstr (format, "B3") != NULL)
                   && strstr (format, "B3") != NULL)
            resolved = idesc->operands[1] == IA64_OPND_TGT25c;
            resolved = idesc->operands[1] == IA64_OPND_TGT25c;
          else if (CONST_STRNEQ (idesc->name, "brp")
          else if (CONST_STRNEQ (idesc->name, "brp")
                   && strstr (format, "B7") != NULL)
                   && strstr (format, "B7") != NULL)
            resolved = idesc->operands[0] == IA64_OPND_B2;
            resolved = idesc->operands[0] == IA64_OPND_B2;
          else if (strcmp (ic->name, "invala") == 0)
          else if (strcmp (ic->name, "invala") == 0)
            resolved = strcmp (idesc->name, ic->name) == 0;
            resolved = strcmp (idesc->name, ic->name) == 0;
          else if (CONST_STRNEQ (idesc->name, "st")
          else if (CONST_STRNEQ (idesc->name, "st")
                   && (strstr (format, "M5") != NULL
                   && (strstr (format, "M5") != NULL
                       || strstr (format, "M10") != NULL))
                       || strstr (format, "M10") != NULL))
            resolved = idesc->flags & IA64_OPCODE_POSTINC;
            resolved = idesc->flags & IA64_OPCODE_POSTINC;
          else if (CONST_STRNEQ (idesc->name, "ld")
          else if (CONST_STRNEQ (idesc->name, "ld")
                   && (strstr (format, "M2 M3") != NULL
                   && (strstr (format, "M2 M3") != NULL
                       || strstr (format, "M12") != NULL
                       || strstr (format, "M12") != NULL
                       || strstr (format, "M7 M8") != NULL))
                       || strstr (format, "M7 M8") != NULL))
            resolved = idesc->flags & IA64_OPCODE_POSTINC;
            resolved = idesc->flags & IA64_OPCODE_POSTINC;
          else
          else
            resolved = 0;
            resolved = 0;
        }
        }
 
 
      /* Misc brl variations ('.cond' is optional);
      /* Misc brl variations ('.cond' is optional);
         plain brl matches brl.cond.  */
         plain brl matches brl.cond.  */
      if (!resolved
      if (!resolved
          && (strcmp (idesc->name, "brl") == 0
          && (strcmp (idesc->name, "brl") == 0
              || CONST_STRNEQ (idesc->name, "brl."))
              || CONST_STRNEQ (idesc->name, "brl."))
          && strcmp (ic->name, "brl.cond") == 0)
          && strcmp (ic->name, "brl.cond") == 0)
        {
        {
          resolved = 1;
          resolved = 1;
        }
        }
 
 
      /* Misc br variations ('.cond' is optional).  */
      /* Misc br variations ('.cond' is optional).  */
      if (!resolved
      if (!resolved
          && (strcmp (idesc->name, "br") == 0
          && (strcmp (idesc->name, "br") == 0
              || CONST_STRNEQ (idesc->name, "br."))
              || CONST_STRNEQ (idesc->name, "br."))
          && strcmp (ic->name, "br.cond") == 0)
          && strcmp (ic->name, "br.cond") == 0)
        {
        {
          if (format)
          if (format)
            resolved = (strstr (format, "B4") != NULL
            resolved = (strstr (format, "B4") != NULL
                        && idesc->operands[0] == IA64_OPND_B2)
                        && idesc->operands[0] == IA64_OPND_B2)
              || (strstr (format, "B1") != NULL
              || (strstr (format, "B1") != NULL
                  && idesc->operands[0] == IA64_OPND_TGT25c);
                  && idesc->operands[0] == IA64_OPND_TGT25c);
          else
          else
            resolved = 1;
            resolved = 1;
        }
        }
 
 
      /* probe variations.  */
      /* probe variations.  */
      if (!resolved && CONST_STRNEQ (idesc->name, "probe"))
      if (!resolved && CONST_STRNEQ (idesc->name, "probe"))
        {
        {
          resolved = strcmp (ic->name, "probe") == 0
          resolved = strcmp (ic->name, "probe") == 0
            && !((strstr (idesc->name, "fault") != NULL)
            && !((strstr (idesc->name, "fault") != NULL)
                 ^ (format && strstr (format, "M40") != NULL));
                 ^ (format && strstr (format, "M40") != NULL));
        }
        }
 
 
      /* mov variations.  */
      /* mov variations.  */
      if (!resolved && is_mov)
      if (!resolved && is_mov)
        {
        {
          if (plain_mov)
          if (plain_mov)
            {
            {
              /* mov alias for fmerge.  */
              /* mov alias for fmerge.  */
              if (strcmp (ic->name, "fmerge") == 0)
              if (strcmp (ic->name, "fmerge") == 0)
                {
                {
                  resolved = idesc->operands[0] == IA64_OPND_F1
                  resolved = idesc->operands[0] == IA64_OPND_F1
                    && idesc->operands[1] == IA64_OPND_F3;
                    && idesc->operands[1] == IA64_OPND_F3;
                }
                }
              /* mov alias for adds (r3 or imm14).  */
              /* mov alias for adds (r3 or imm14).  */
              else if (strcmp (ic->name, "adds") == 0)
              else if (strcmp (ic->name, "adds") == 0)
                {
                {
                  resolved = (idesc->operands[0] == IA64_OPND_R1
                  resolved = (idesc->operands[0] == IA64_OPND_R1
                              && (idesc->operands[1] == IA64_OPND_R3
                              && (idesc->operands[1] == IA64_OPND_R3
                                  || (idesc->operands[1] == IA64_OPND_IMM14)));
                                  || (idesc->operands[1] == IA64_OPND_IMM14)));
                }
                }
              /* mov alias for addl.  */
              /* mov alias for addl.  */
              else if (strcmp (ic->name, "addl") == 0)
              else if (strcmp (ic->name, "addl") == 0)
                {
                {
                  resolved = idesc->operands[0] == IA64_OPND_R1
                  resolved = idesc->operands[0] == IA64_OPND_R1
                    && idesc->operands[1] == IA64_OPND_IMM22;
                    && idesc->operands[1] == IA64_OPND_IMM22;
                }
                }
            }
            }
 
 
          /* Some variants of mov and mov.[im].  */
          /* Some variants of mov and mov.[im].  */
          if (!resolved && CONST_STRNEQ (ic->name, "mov_"))
          if (!resolved && CONST_STRNEQ (ic->name, "mov_"))
            resolved = in_iclass_mov_x (idesc, ic, format, field);
            resolved = in_iclass_mov_x (idesc, ic, format, field);
        }
        }
 
 
      /* Keep track of this so we can flag any insn classes which aren't
      /* Keep track of this so we can flag any insn classes which aren't
         mapped onto at least one real insn.  */
         mapped onto at least one real insn.  */
      if (resolved)
      if (resolved)
        ic->terminal_resolved = 1;
        ic->terminal_resolved = 1;
    }
    }
  else for (i = 0; i < ic->nsubs; i++)
  else for (i = 0; i < ic->nsubs; i++)
    {
    {
      if (in_iclass (idesc, ics[ic->subs[i]], format, field, notep))
      if (in_iclass (idesc, ics[ic->subs[i]], format, field, notep))
        {
        {
          int j;
          int j;
 
 
          for (j = 0; j < ic->nxsubs; j++)
          for (j = 0; j < ic->nxsubs; j++)
            if (in_iclass (idesc, ics[ic->xsubs[j]], NULL, NULL, NULL))
            if (in_iclass (idesc, ics[ic->xsubs[j]], NULL, NULL, NULL))
              return 0;
              return 0;
 
 
          if (debug > 1)
          if (debug > 1)
            printf ("%s is in IC %s\n", idesc->name, ic->name);
            printf ("%s is in IC %s\n", idesc->name, ic->name);
 
 
          resolved = 1;
          resolved = 1;
          break;
          break;
        }
        }
    }
    }
 
 
  /* If it's in this IC, add the IC note (if any) to the insn.  */
  /* If it's in this IC, add the IC note (if any) to the insn.  */
  if (resolved)
  if (resolved)
    {
    {
      if (ic->note && notep)
      if (ic->note && notep)
        {
        {
          if (*notep && *notep != ic->note)
          if (*notep && *notep != ic->note)
            warn (_("overwriting note %d with note %d (IC:%s)\n"),
            warn (_("overwriting note %d with note %d (IC:%s)\n"),
                  *notep, ic->note, ic->name);
                  *notep, ic->note, ic->name);
 
 
          *notep = ic->note;
          *notep = ic->note;
        }
        }
    }
    }
 
 
  return resolved;
  return resolved;
}
}
 
 


static int
static int
lookup_regindex (const char *name, int specifier)
lookup_regindex (const char *name, int specifier)
{
{
  switch (specifier)
  switch (specifier)
    {
    {
    case IA64_RS_ARX:
    case IA64_RS_ARX:
      if (strstr (name, "[RSC]"))
      if (strstr (name, "[RSC]"))
        return 16;
        return 16;
      if (strstr (name, "[BSP]"))
      if (strstr (name, "[BSP]"))
        return 17;
        return 17;
      else if (strstr (name, "[BSPSTORE]"))
      else if (strstr (name, "[BSPSTORE]"))
        return 18;
        return 18;
      else if (strstr (name, "[RNAT]"))
      else if (strstr (name, "[RNAT]"))
        return 19;
        return 19;
      else if (strstr (name, "[FCR]"))
      else if (strstr (name, "[FCR]"))
        return 21;
        return 21;
      else if (strstr (name, "[EFLAG]"))
      else if (strstr (name, "[EFLAG]"))
        return 24;
        return 24;
      else if (strstr (name, "[CSD]"))
      else if (strstr (name, "[CSD]"))
        return 25;
        return 25;
      else if (strstr (name, "[SSD]"))
      else if (strstr (name, "[SSD]"))
        return 26;
        return 26;
      else if (strstr (name, "[CFLG]"))
      else if (strstr (name, "[CFLG]"))
        return 27;
        return 27;
      else if (strstr (name, "[FSR]"))
      else if (strstr (name, "[FSR]"))
        return 28;
        return 28;
      else if (strstr (name, "[FIR]"))
      else if (strstr (name, "[FIR]"))
        return 29;
        return 29;
      else if (strstr (name, "[FDR]"))
      else if (strstr (name, "[FDR]"))
        return 30;
        return 30;
      else if (strstr (name, "[CCV]"))
      else if (strstr (name, "[CCV]"))
        return 32;
        return 32;
      else if (strstr (name, "[ITC]"))
      else if (strstr (name, "[ITC]"))
        return 44;
        return 44;
      else if (strstr (name, "[RUC]"))
      else if (strstr (name, "[RUC]"))
        return 45;
        return 45;
      else if (strstr (name, "[PFS]"))
      else if (strstr (name, "[PFS]"))
        return 64;
        return 64;
      else if (strstr (name, "[LC]"))
      else if (strstr (name, "[LC]"))
        return 65;
        return 65;
      else if (strstr (name, "[EC]"))
      else if (strstr (name, "[EC]"))
        return 66;
        return 66;
      abort ();
      abort ();
    case IA64_RS_CRX:
    case IA64_RS_CRX:
      if (strstr (name, "[DCR]"))
      if (strstr (name, "[DCR]"))
        return 0;
        return 0;
      else if (strstr (name, "[ITM]"))
      else if (strstr (name, "[ITM]"))
        return 1;
        return 1;
      else if (strstr (name, "[IVA]"))
      else if (strstr (name, "[IVA]"))
        return 2;
        return 2;
      else if (strstr (name, "[PTA]"))
      else if (strstr (name, "[PTA]"))
        return 8;
        return 8;
      else if (strstr (name, "[GPTA]"))
      else if (strstr (name, "[GPTA]"))
        return 9;
        return 9;
      else if (strstr (name, "[IPSR]"))
      else if (strstr (name, "[IPSR]"))
        return 16;
        return 16;
      else if (strstr (name, "[ISR]"))
      else if (strstr (name, "[ISR]"))
        return 17;
        return 17;
      else if (strstr (name, "[IIP]"))
      else if (strstr (name, "[IIP]"))
        return 19;
        return 19;
      else if (strstr (name, "[IFA]"))
      else if (strstr (name, "[IFA]"))
        return 20;
        return 20;
      else if (strstr (name, "[ITIR]"))
      else if (strstr (name, "[ITIR]"))
        return 21;
        return 21;
      else if (strstr (name, "[IIPA]"))
      else if (strstr (name, "[IIPA]"))
        return 22;
        return 22;
      else if (strstr (name, "[IFS]"))
      else if (strstr (name, "[IFS]"))
        return 23;
        return 23;
      else if (strstr (name, "[IIM]"))
      else if (strstr (name, "[IIM]"))
        return 24;
        return 24;
      else if (strstr (name, "[IHA]"))
      else if (strstr (name, "[IHA]"))
        return 25;
        return 25;
      else if (strstr (name, "[LID]"))
      else if (strstr (name, "[LID]"))
        return 64;
        return 64;
      else if (strstr (name, "[IVR]"))
      else if (strstr (name, "[IVR]"))
        return 65;
        return 65;
      else if (strstr (name, "[TPR]"))
      else if (strstr (name, "[TPR]"))
        return 66;
        return 66;
      else if (strstr (name, "[EOI]"))
      else if (strstr (name, "[EOI]"))
        return 67;
        return 67;
      else if (strstr (name, "[ITV]"))
      else if (strstr (name, "[ITV]"))
        return 72;
        return 72;
      else if (strstr (name, "[PMV]"))
      else if (strstr (name, "[PMV]"))
        return 73;
        return 73;
      else if (strstr (name, "[CMCV]"))
      else if (strstr (name, "[CMCV]"))
        return 74;
        return 74;
      abort ();
      abort ();
    case IA64_RS_PSR:
    case IA64_RS_PSR:
      if (strstr (name, ".be"))
      if (strstr (name, ".be"))
        return 1;
        return 1;
      else if (strstr (name, ".up"))
      else if (strstr (name, ".up"))
        return 2;
        return 2;
      else if (strstr (name, ".ac"))
      else if (strstr (name, ".ac"))
        return 3;
        return 3;
      else if (strstr (name, ".mfl"))
      else if (strstr (name, ".mfl"))
        return 4;
        return 4;
      else if (strstr (name, ".mfh"))
      else if (strstr (name, ".mfh"))
        return 5;
        return 5;
      else if (strstr (name, ".ic"))
      else if (strstr (name, ".ic"))
        return 13;
        return 13;
      else if (strstr (name, ".i"))
      else if (strstr (name, ".i"))
        return 14;
        return 14;
      else if (strstr (name, ".pk"))
      else if (strstr (name, ".pk"))
        return 15;
        return 15;
      else if (strstr (name, ".dt"))
      else if (strstr (name, ".dt"))
        return 17;
        return 17;
      else if (strstr (name, ".dfl"))
      else if (strstr (name, ".dfl"))
        return 18;
        return 18;
      else if (strstr (name, ".dfh"))
      else if (strstr (name, ".dfh"))
        return 19;
        return 19;
      else if (strstr (name, ".sp"))
      else if (strstr (name, ".sp"))
        return 20;
        return 20;
      else if (strstr (name, ".pp"))
      else if (strstr (name, ".pp"))
        return 21;
        return 21;
      else if (strstr (name, ".di"))
      else if (strstr (name, ".di"))
        return 22;
        return 22;
      else if (strstr (name, ".si"))
      else if (strstr (name, ".si"))
        return 23;
        return 23;
      else if (strstr (name, ".db"))
      else if (strstr (name, ".db"))
        return 24;
        return 24;
      else if (strstr (name, ".lp"))
      else if (strstr (name, ".lp"))
        return 25;
        return 25;
      else if (strstr (name, ".tb"))
      else if (strstr (name, ".tb"))
        return 26;
        return 26;
      else if (strstr (name, ".rt"))
      else if (strstr (name, ".rt"))
        return 27;
        return 27;
      else if (strstr (name, ".cpl"))
      else if (strstr (name, ".cpl"))
        return 32;
        return 32;
      else if (strstr (name, ".rs"))
      else if (strstr (name, ".rs"))
        return 34;
        return 34;
      else if (strstr (name, ".mc"))
      else if (strstr (name, ".mc"))
        return 35;
        return 35;
      else if (strstr (name, ".it"))
      else if (strstr (name, ".it"))
        return 36;
        return 36;
      else if (strstr (name, ".id"))
      else if (strstr (name, ".id"))
        return 37;
        return 37;
      else if (strstr (name, ".da"))
      else if (strstr (name, ".da"))
        return 38;
        return 38;
      else if (strstr (name, ".dd"))
      else if (strstr (name, ".dd"))
        return 39;
        return 39;
      else if (strstr (name, ".ss"))
      else if (strstr (name, ".ss"))
        return 40;
        return 40;
      else if (strstr (name, ".ri"))
      else if (strstr (name, ".ri"))
        return 41;
        return 41;
      else if (strstr (name, ".ed"))
      else if (strstr (name, ".ed"))
        return 43;
        return 43;
      else if (strstr (name, ".bn"))
      else if (strstr (name, ".bn"))
        return 44;
        return 44;
      else if (strstr (name, ".ia"))
      else if (strstr (name, ".ia"))
        return 45;
        return 45;
      else if (strstr (name, ".vm"))
      else if (strstr (name, ".vm"))
        return 46;
        return 46;
      else
      else
        abort ();
        abort ();
    default:
    default:
      break;
      break;
    }
    }
  return REG_NONE;
  return REG_NONE;
}
}
 
 
static int
static int
lookup_specifier (const char *name)
lookup_specifier (const char *name)
{
{
  if (strchr (name, '%'))
  if (strchr (name, '%'))
    {
    {
      if (strstr (name, "AR[K%]") != NULL)
      if (strstr (name, "AR[K%]") != NULL)
        return IA64_RS_AR_K;
        return IA64_RS_AR_K;
      if (strstr (name, "AR[UNAT]") != NULL)
      if (strstr (name, "AR[UNAT]") != NULL)
        return IA64_RS_AR_UNAT;
        return IA64_RS_AR_UNAT;
      if (strstr (name, "AR%, % in 8") != NULL)
      if (strstr (name, "AR%, % in 8") != NULL)
        return IA64_RS_AR;
        return IA64_RS_AR;
      if (strstr (name, "AR%, % in 48") != NULL)
      if (strstr (name, "AR%, % in 48") != NULL)
        return IA64_RS_ARb;
        return IA64_RS_ARb;
      if (strstr (name, "BR%") != NULL)
      if (strstr (name, "BR%") != NULL)
        return IA64_RS_BR;
        return IA64_RS_BR;
      if (strstr (name, "CR[IIB%]") != NULL)
      if (strstr (name, "CR[IIB%]") != NULL)
        return IA64_RS_CR_IIB;
        return IA64_RS_CR_IIB;
      if (strstr (name, "CR[IRR%]") != NULL)
      if (strstr (name, "CR[IRR%]") != NULL)
        return IA64_RS_CR_IRR;
        return IA64_RS_CR_IRR;
      if (strstr (name, "CR[LRR%]") != NULL)
      if (strstr (name, "CR[LRR%]") != NULL)
        return IA64_RS_CR_LRR;
        return IA64_RS_CR_LRR;
      if (strstr (name, "CR%") != NULL)
      if (strstr (name, "CR%") != NULL)
        return IA64_RS_CR;
        return IA64_RS_CR;
      if (strstr (name, "FR%, % in 0") != NULL)
      if (strstr (name, "FR%, % in 0") != NULL)
        return IA64_RS_FR;
        return IA64_RS_FR;
      if (strstr (name, "FR%, % in 2") != NULL)
      if (strstr (name, "FR%, % in 2") != NULL)
        return IA64_RS_FRb;
        return IA64_RS_FRb;
      if (strstr (name, "GR%") != NULL)
      if (strstr (name, "GR%") != NULL)
        return IA64_RS_GR;
        return IA64_RS_GR;
      if (strstr (name, "PR%, % in 1 ") != NULL)
      if (strstr (name, "PR%, % in 1 ") != NULL)
        return IA64_RS_PR;
        return IA64_RS_PR;
      if (strstr (name, "PR%, % in 16 ") != NULL)
      if (strstr (name, "PR%, % in 16 ") != NULL)
        return IA64_RS_PRr;
        return IA64_RS_PRr;
 
 
      warn (_("don't know how to specify %% dependency %s\n"),
      warn (_("don't know how to specify %% dependency %s\n"),
            name);
            name);
    }
    }
  else if (strchr (name, '#'))
  else if (strchr (name, '#'))
    {
    {
      if (strstr (name, "CPUID#") != NULL)
      if (strstr (name, "CPUID#") != NULL)
        return IA64_RS_CPUID;
        return IA64_RS_CPUID;
      if (strstr (name, "DBR#") != NULL)
      if (strstr (name, "DBR#") != NULL)
        return IA64_RS_DBR;
        return IA64_RS_DBR;
      if (strstr (name, "IBR#") != NULL)
      if (strstr (name, "IBR#") != NULL)
        return IA64_RS_IBR;
        return IA64_RS_IBR;
      if (strstr (name, "MSR#") != NULL)
      if (strstr (name, "MSR#") != NULL)
        return IA64_RS_MSR;
        return IA64_RS_MSR;
      if (strstr (name, "PKR#") != NULL)
      if (strstr (name, "PKR#") != NULL)
        return IA64_RS_PKR;
        return IA64_RS_PKR;
      if (strstr (name, "PMC#") != NULL)
      if (strstr (name, "PMC#") != NULL)
        return IA64_RS_PMC;
        return IA64_RS_PMC;
      if (strstr (name, "PMD#") != NULL)
      if (strstr (name, "PMD#") != NULL)
        return IA64_RS_PMD;
        return IA64_RS_PMD;
      if (strstr (name, "RR#") != NULL)
      if (strstr (name, "RR#") != NULL)
        return IA64_RS_RR;
        return IA64_RS_RR;
 
 
      warn (_("Don't know how to specify # dependency %s\n"),
      warn (_("Don't know how to specify # dependency %s\n"),
            name);
            name);
    }
    }
  else if (CONST_STRNEQ (name, "AR[FPSR]"))
  else if (CONST_STRNEQ (name, "AR[FPSR]"))
    return IA64_RS_AR_FPSR;
    return IA64_RS_AR_FPSR;
  else if (CONST_STRNEQ (name, "AR["))
  else if (CONST_STRNEQ (name, "AR["))
    return IA64_RS_ARX;
    return IA64_RS_ARX;
  else if (CONST_STRNEQ (name, "CR["))
  else if (CONST_STRNEQ (name, "CR["))
    return IA64_RS_CRX;
    return IA64_RS_CRX;
  else if (CONST_STRNEQ (name, "PSR."))
  else if (CONST_STRNEQ (name, "PSR."))
    return IA64_RS_PSR;
    return IA64_RS_PSR;
  else if (strcmp (name, "InService*") == 0)
  else if (strcmp (name, "InService*") == 0)
    return IA64_RS_INSERVICE;
    return IA64_RS_INSERVICE;
  else if (strcmp (name, "GR0") == 0)
  else if (strcmp (name, "GR0") == 0)
    return IA64_RS_GR0;
    return IA64_RS_GR0;
  else if (strcmp (name, "CFM") == 0)
  else if (strcmp (name, "CFM") == 0)
    return IA64_RS_CFM;
    return IA64_RS_CFM;
  else if (strcmp (name, "PR63") == 0)
  else if (strcmp (name, "PR63") == 0)
    return IA64_RS_PR63;
    return IA64_RS_PR63;
  else if (strcmp (name, "RSE") == 0)
  else if (strcmp (name, "RSE") == 0)
    return IA64_RS_RSE;
    return IA64_RS_RSE;
 
 
  return IA64_RS_ANY;
  return IA64_RS_ANY;
}
}
 
 
static void
static void
print_dependency_table (void)
print_dependency_table (void)
{
{
  int i, j;
  int i, j;
 
 
  if (debug)
  if (debug)
    {
    {
      for (i=0;i < iclen;i++)
      for (i=0;i < iclen;i++)
        {
        {
          if (ics[i]->is_class)
          if (ics[i]->is_class)
            {
            {
              if (!ics[i]->nsubs)
              if (!ics[i]->nsubs)
                {
                {
                  if (ics[i]->comment)
                  if (ics[i]->comment)
                    warn (_("IC:%s [%s] has no terminals or sub-classes\n"),
                    warn (_("IC:%s [%s] has no terminals or sub-classes\n"),
                          ics[i]->name, ics[i]->comment);
                          ics[i]->name, ics[i]->comment);
                  else
                  else
                    warn (_("IC:%s has no terminals or sub-classes\n"),
                    warn (_("IC:%s has no terminals or sub-classes\n"),
                          ics[i]->name);
                          ics[i]->name);
                }
                }
            }
            }
          else
          else
            {
            {
              if (!ics[i]->terminal_resolved && !ics[i]->orphan)
              if (!ics[i]->terminal_resolved && !ics[i]->orphan)
                {
                {
                  if (ics[i]->comment)
                  if (ics[i]->comment)
                    warn (_("no insns mapped directly to terminal IC %s [%s]"),
                    warn (_("no insns mapped directly to terminal IC %s [%s]"),
                          ics[i]->name, ics[i]->comment);
                          ics[i]->name, ics[i]->comment);
                  else
                  else
                    warn (_("no insns mapped directly to terminal IC %s\n"),
                    warn (_("no insns mapped directly to terminal IC %s\n"),
                          ics[i]->name);
                          ics[i]->name);
                }
                }
            }
            }
        }
        }
 
 
      for (i = 0; i < iclen; i++)
      for (i = 0; i < iclen; i++)
        {
        {
          if (ics[i]->orphan)
          if (ics[i]->orphan)
            {
            {
              mark_used (ics[i], 1);
              mark_used (ics[i], 1);
              warn (_("class %s is defined but not used\n"),
              warn (_("class %s is defined but not used\n"),
                    ics[i]->name);
                    ics[i]->name);
            }
            }
        }
        }
 
 
      if (debug > 1)
      if (debug > 1)
        for (i = 0; i < rdepslen; i++)
        for (i = 0; i < rdepslen; i++)
          {
          {
            static const char *mode_str[] = { "RAW", "WAW", "WAR" };
            static const char *mode_str[] = { "RAW", "WAW", "WAR" };
 
 
            if (rdeps[i]->total_chks == 0)
            if (rdeps[i]->total_chks == 0)
              {
              {
                if (rdeps[i]->total_regs)
                if (rdeps[i]->total_regs)
                  warn (_("Warning: rsrc %s (%s) has no chks\n"),
                  warn (_("Warning: rsrc %s (%s) has no chks\n"),
                        rdeps[i]->name, mode_str[rdeps[i]->mode]);
                        rdeps[i]->name, mode_str[rdeps[i]->mode]);
                else
                else
                  warn (_("Warning: rsrc %s (%s) has no chks or regs\n"),
                  warn (_("Warning: rsrc %s (%s) has no chks or regs\n"),
                        rdeps[i]->name, mode_str[rdeps[i]->mode]);
                        rdeps[i]->name, mode_str[rdeps[i]->mode]);
              }
              }
            else if (rdeps[i]->total_regs == 0)
            else if (rdeps[i]->total_regs == 0)
              warn (_("rsrc %s (%s) has no regs\n"),
              warn (_("rsrc %s (%s) has no regs\n"),
                    rdeps[i]->name, mode_str[rdeps[i]->mode]);
                    rdeps[i]->name, mode_str[rdeps[i]->mode]);
          }
          }
    }
    }
 
 
  /* The dependencies themselves.  */
  /* The dependencies themselves.  */
  printf ("static const struct ia64_dependency\ndependencies[] = {\n");
  printf ("static const struct ia64_dependency\ndependencies[] = {\n");
  for (i = 0; i < rdepslen; i++)
  for (i = 0; i < rdepslen; i++)
    {
    {
      /* '%', '#', AR[], CR[], or PSR. indicates we need to specify the actual
      /* '%', '#', AR[], CR[], or PSR. indicates we need to specify the actual
         resource used.  */
         resource used.  */
      int specifier = lookup_specifier (rdeps[i]->name);
      int specifier = lookup_specifier (rdeps[i]->name);
      int regindex = lookup_regindex (rdeps[i]->name, specifier);
      int regindex = lookup_regindex (rdeps[i]->name, specifier);
 
 
      printf ("  { \"%s\", %d, %d, %d, %d, ",
      printf ("  { \"%s\", %d, %d, %d, %d, ",
              rdeps[i]->name, specifier,
              rdeps[i]->name, specifier,
              (int)rdeps[i]->mode, (int)rdeps[i]->semantics, regindex);
              (int)rdeps[i]->mode, (int)rdeps[i]->semantics, regindex);
      if (rdeps[i]->semantics == IA64_DVS_OTHER)
      if (rdeps[i]->semantics == IA64_DVS_OTHER)
        {
        {
          const char *quote, *rest;
          const char *quote, *rest;
 
 
          putchar ('\"');
          putchar ('\"');
          rest = rdeps[i]->extra;
          rest = rdeps[i]->extra;
          quote = strchr (rest, '\"');
          quote = strchr (rest, '\"');
          while (quote != NULL)
          while (quote != NULL)
            {
            {
              printf ("%.*s\\\"", (int) (quote - rest), rest);
              printf ("%.*s\\\"", (int) (quote - rest), rest);
              rest = quote + 1;
              rest = quote + 1;
              quote = strchr (rest, '\"');
              quote = strchr (rest, '\"');
            }
            }
          printf ("%s\", ", rest);
          printf ("%s\", ", rest);
        }
        }
      else
      else
        printf ("NULL, ");
        printf ("NULL, ");
      printf("},\n");
      printf("},\n");
    }
    }
  printf ("};\n\n");
  printf ("};\n\n");
 
 
  /* And dependency lists.  */
  /* And dependency lists.  */
  for (i=0;i < dlistlen;i++)
  for (i=0;i < dlistlen;i++)
    {
    {
      int len = 2;
      int len = 2;
      printf ("static const unsigned short dep%d[] = {\n  ", i);
      printf ("static const unsigned short dep%d[] = {\n  ", i);
      for (j=0;j < dlists[i]->len; j++)
      for (j=0;j < dlists[i]->len; j++)
        {
        {
          len += printf ("%d, ", dlists[i]->deps[j]);
          len += printf ("%d, ", dlists[i]->deps[j]);
          if (len > 75)
          if (len > 75)
            {
            {
              printf("\n  ");
              printf("\n  ");
              len = 2;
              len = 2;
            }
            }
        }
        }
      printf ("\n};\n\n");
      printf ("\n};\n\n");
    }
    }
 
 
  /* And opcode dependency list.  */
  /* And opcode dependency list.  */
  printf ("#define NELS(X) (sizeof(X)/sizeof(X[0]))\n");
  printf ("#define NELS(X) (sizeof(X)/sizeof(X[0]))\n");
  printf ("static const struct ia64_opcode_dependency\n");
  printf ("static const struct ia64_opcode_dependency\n");
  printf ("op_dependencies[] = {\n");
  printf ("op_dependencies[] = {\n");
  for (i = 0; i < opdeplen; i++)
  for (i = 0; i < opdeplen; i++)
    {
    {
      printf ("  { ");
      printf ("  { ");
      if (opdeps[i]->chk == -1)
      if (opdeps[i]->chk == -1)
        printf ("0, NULL, ");
        printf ("0, NULL, ");
      else
      else
        printf ("NELS(dep%d), dep%d, ", opdeps[i]->chk, opdeps[i]->chk);
        printf ("NELS(dep%d), dep%d, ", opdeps[i]->chk, opdeps[i]->chk);
      if (opdeps[i]->reg == -1)
      if (opdeps[i]->reg == -1)
        printf ("0, NULL, ");
        printf ("0, NULL, ");
      else
      else
        printf ("NELS(dep%d), dep%d, ", opdeps[i]->reg, opdeps[i]->reg);
        printf ("NELS(dep%d), dep%d, ", opdeps[i]->reg, opdeps[i]->reg);
      printf ("},\n");
      printf ("},\n");
    }
    }
  printf ("};\n\n");
  printf ("};\n\n");
}
}
 
 


/* Add STR to the string table.  */
/* Add STR to the string table.  */
static struct string_entry *
static struct string_entry *
insert_string (char *str)
insert_string (char *str)
{
{
  int start = 0, end = strtablen;
  int start = 0, end = strtablen;
  int i, x;
  int i, x;
 
 
  if (strtablen == strtabtotlen)
  if (strtablen == strtabtotlen)
    {
    {
      strtabtotlen += 20;
      strtabtotlen += 20;
      string_table = (struct string_entry **)
      string_table = (struct string_entry **)
        xrealloc (string_table,
        xrealloc (string_table,
                  sizeof (struct string_entry **) * strtabtotlen);
                  sizeof (struct string_entry **) * strtabtotlen);
    }
    }
 
 
  if (strtablen == 0)
  if (strtablen == 0)
    {
    {
      strtablen = 1;
      strtablen = 1;
      string_table[0] = tmalloc (struct string_entry);
      string_table[0] = tmalloc (struct string_entry);
      string_table[0]->s = xstrdup (str);
      string_table[0]->s = xstrdup (str);
      string_table[0]->num = 0;
      string_table[0]->num = 0;
      return string_table[0];
      return string_table[0];
    }
    }
 
 
  if (strcmp (str, string_table[strtablen - 1]->s) > 0)
  if (strcmp (str, string_table[strtablen - 1]->s) > 0)
    i = end;
    i = end;
  else if (strcmp (str, string_table[0]->s) < 0)
  else if (strcmp (str, string_table[0]->s) < 0)
    i = 0;
    i = 0;
  else
  else
    {
    {
      while (1)
      while (1)
        {
        {
          int c;
          int c;
 
 
          i = (start + end) / 2;
          i = (start + end) / 2;
          c = strcmp (str, string_table[i]->s);
          c = strcmp (str, string_table[i]->s);
 
 
          if (c < 0)
          if (c < 0)
            end = i - 1;
            end = i - 1;
          else if (c == 0)
          else if (c == 0)
            return string_table[i];
            return string_table[i];
          else
          else
            start = i + 1;
            start = i + 1;
 
 
          if (start > end)
          if (start > end)
            break;
            break;
        }
        }
    }
    }
 
 
  for (; i > 0 && i < strtablen; i--)
  for (; i > 0 && i < strtablen; i--)
    if (strcmp (str, string_table[i - 1]->s) > 0)
    if (strcmp (str, string_table[i - 1]->s) > 0)
      break;
      break;
 
 
  for (; i < strtablen; i++)
  for (; i < strtablen; i++)
    if (strcmp (str, string_table[i]->s) < 0)
    if (strcmp (str, string_table[i]->s) < 0)
      break;
      break;
 
 
  for (x = strtablen - 1; x >= i; x--)
  for (x = strtablen - 1; x >= i; x--)
    {
    {
      string_table[x + 1] = string_table[x];
      string_table[x + 1] = string_table[x];
      string_table[x + 1]->num = x + 1;
      string_table[x + 1]->num = x + 1;
    }
    }
 
 
  string_table[i] = tmalloc (struct string_entry);
  string_table[i] = tmalloc (struct string_entry);
  string_table[i]->s = xstrdup (str);
  string_table[i]->s = xstrdup (str);
  string_table[i]->num = i;
  string_table[i]->num = i;
  strtablen++;
  strtablen++;
 
 
  return string_table[i];
  return string_table[i];
}
}


static struct bittree *
static struct bittree *
make_bittree_entry (void)
make_bittree_entry (void)
{
{
  struct bittree *res = tmalloc (struct bittree);
  struct bittree *res = tmalloc (struct bittree);
 
 
  res->disent = NULL;
  res->disent = NULL;
  res->bits[0] = NULL;
  res->bits[0] = NULL;
  res->bits[1] = NULL;
  res->bits[1] = NULL;
  res->bits[2] = NULL;
  res->bits[2] = NULL;
  res->skip_flag = 0;
  res->skip_flag = 0;
  res->bits_to_skip = 0;
  res->bits_to_skip = 0;
  return res;
  return res;
}
}
 
 


static struct disent *
static struct disent *
add_dis_table_ent (struct disent *which, int insn, int order,
add_dis_table_ent (struct disent *which, int insn, int order,
                   int completer_index)
                   int completer_index)
{
{
  int ci = 0;
  int ci = 0;
  struct disent *ent;
  struct disent *ent;
 
 
  if (which != NULL)
  if (which != NULL)
    {
    {
      ent = which;
      ent = which;
 
 
      ent->nextcnt++;
      ent->nextcnt++;
      while (ent->nexte != NULL)
      while (ent->nexte != NULL)
        ent = ent->nexte;
        ent = ent->nexte;
 
 
      ent = (ent->nexte = tmalloc (struct disent));
      ent = (ent->nexte = tmalloc (struct disent));
    }
    }
  else
  else
    {
    {
      ent = tmalloc (struct disent);
      ent = tmalloc (struct disent);
      ent->next_ent = disinsntable;
      ent->next_ent = disinsntable;
      disinsntable = ent;
      disinsntable = ent;
      which = ent;
      which = ent;
    }
    }
  ent->nextcnt = 0;
  ent->nextcnt = 0;
  ent->nexte = NULL;
  ent->nexte = NULL;
  ent->insn = insn;
  ent->insn = insn;
  ent->priority = order;
  ent->priority = order;
 
 
  while (completer_index != 1)
  while (completer_index != 1)
    {
    {
      ci = (ci << 1) | (completer_index & 1);
      ci = (ci << 1) | (completer_index & 1);
      completer_index >>= 1;
      completer_index >>= 1;
    }
    }
  ent->completer_index = ci;
  ent->completer_index = ci;
  return which;
  return which;
}
}


static void
static void
finish_distable (void)
finish_distable (void)
{
{
  struct disent *ent = disinsntable;
  struct disent *ent = disinsntable;
  struct disent *prev = ent;
  struct disent *prev = ent;
 
 
  ent->ournum = 32768;
  ent->ournum = 32768;
  while ((ent = ent->next_ent) != NULL)
  while ((ent = ent->next_ent) != NULL)
    {
    {
      ent->ournum = prev->ournum + prev->nextcnt + 1;
      ent->ournum = prev->ournum + prev->nextcnt + 1;
      prev = ent;
      prev = ent;
    }
    }
}
}


static void
static void
insert_bit_table_ent (struct bittree *curr_ent, int bit, ia64_insn opcode,
insert_bit_table_ent (struct bittree *curr_ent, int bit, ia64_insn opcode,
                      ia64_insn mask, int opcodenum, int order,
                      ia64_insn mask, int opcodenum, int order,
                      int completer_index)
                      int completer_index)
{
{
  ia64_insn m;
  ia64_insn m;
  int b;
  int b;
  struct bittree *next;
  struct bittree *next;
 
 
  if (bit == -1)
  if (bit == -1)
    {
    {
      struct disent *nent = add_dis_table_ent (curr_ent->disent,
      struct disent *nent = add_dis_table_ent (curr_ent->disent,
                                               opcodenum, order,
                                               opcodenum, order,
                                               completer_index);
                                               completer_index);
      curr_ent->disent = nent;
      curr_ent->disent = nent;
      return;
      return;
    }
    }
 
 
  m = ((ia64_insn) 1) << bit;
  m = ((ia64_insn) 1) << bit;
 
 
  if (mask & m)
  if (mask & m)
    b = (opcode & m) ? 1 : 0;
    b = (opcode & m) ? 1 : 0;
  else
  else
    b = 2;
    b = 2;
 
 
  next = curr_ent->bits[b];
  next = curr_ent->bits[b];
  if (next == NULL)
  if (next == NULL)
    {
    {
      next = make_bittree_entry ();
      next = make_bittree_entry ();
      curr_ent->bits[b] = next;
      curr_ent->bits[b] = next;
    }
    }
  insert_bit_table_ent (next, bit - 1, opcode, mask, opcodenum, order,
  insert_bit_table_ent (next, bit - 1, opcode, mask, opcodenum, order,
                        completer_index);
                        completer_index);
}
}


static void
static void
add_dis_entry (struct bittree *first, ia64_insn opcode, ia64_insn mask,
add_dis_entry (struct bittree *first, ia64_insn opcode, ia64_insn mask,
               int opcodenum, struct completer_entry *ent, int completer_index)
               int opcodenum, struct completer_entry *ent, int completer_index)
{
{
  if (completer_index & (1 << 20))
  if (completer_index & (1 << 20))
    abort ();
    abort ();
 
 
  while (ent != NULL)
  while (ent != NULL)
    {
    {
      ia64_insn newopcode = (opcode & (~ ent->mask)) | ent->bits;
      ia64_insn newopcode = (opcode & (~ ent->mask)) | ent->bits;
      add_dis_entry (first, newopcode, mask, opcodenum, ent->addl_entries,
      add_dis_entry (first, newopcode, mask, opcodenum, ent->addl_entries,
                     (completer_index << 1) | 1);
                     (completer_index << 1) | 1);
 
 
      if (ent->is_terminal)
      if (ent->is_terminal)
        {
        {
          insert_bit_table_ent (bittree, 40, newopcode, mask,
          insert_bit_table_ent (bittree, 40, newopcode, mask,
                                opcodenum, opcode_count - ent->order - 1,
                                opcodenum, opcode_count - ent->order - 1,
                                (completer_index << 1) | 1);
                                (completer_index << 1) | 1);
        }
        }
      completer_index <<= 1;
      completer_index <<= 1;
      ent = ent->alternative;
      ent = ent->alternative;
    }
    }
}
}


/* This optimization pass combines multiple "don't care" nodes.  */
/* This optimization pass combines multiple "don't care" nodes.  */
static void
static void
compact_distree (struct bittree *ent)
compact_distree (struct bittree *ent)
{
{
#define IS_SKIP(ent) \
#define IS_SKIP(ent) \
    ((ent->bits[2] !=NULL) \
    ((ent->bits[2] !=NULL) \
     && (ent->bits[0] == NULL && ent->bits[1] == NULL && ent->skip_flag == 0))
     && (ent->bits[0] == NULL && ent->bits[1] == NULL && ent->skip_flag == 0))
 
 
  int bitcnt = 0;
  int bitcnt = 0;
  struct bittree *nent = ent;
  struct bittree *nent = ent;
  int x;
  int x;
 
 
  while (IS_SKIP (nent))
  while (IS_SKIP (nent))
    {
    {
      bitcnt++;
      bitcnt++;
      nent = nent->bits[2];
      nent = nent->bits[2];
    }
    }
 
 
  if (bitcnt)
  if (bitcnt)
    {
    {
      struct bittree *next = ent->bits[2];
      struct bittree *next = ent->bits[2];
 
 
      ent->bits[0] = nent->bits[0];
      ent->bits[0] = nent->bits[0];
      ent->bits[1] = nent->bits[1];
      ent->bits[1] = nent->bits[1];
      ent->bits[2] = nent->bits[2];
      ent->bits[2] = nent->bits[2];
      ent->disent = nent->disent;
      ent->disent = nent->disent;
      ent->skip_flag = 1;
      ent->skip_flag = 1;
      ent->bits_to_skip = bitcnt;
      ent->bits_to_skip = bitcnt;
      while (next != nent)
      while (next != nent)
        {
        {
          struct bittree *b = next;
          struct bittree *b = next;
          next = next->bits[2];
          next = next->bits[2];
          free (b);
          free (b);
        }
        }
      free (nent);
      free (nent);
    }
    }
 
 
  for (x = 0; x < 3; x++)
  for (x = 0; x < 3; x++)
    {
    {
      struct bittree *i = ent->bits[x];
      struct bittree *i = ent->bits[x];
 
 
      if (i != NULL)
      if (i != NULL)
        compact_distree (i);
        compact_distree (i);
    }
    }
}
}


static unsigned char *insn_list;
static unsigned char *insn_list;
static int insn_list_len = 0;
static int insn_list_len = 0;
static int tot_insn_list_len = 0;
static int tot_insn_list_len = 0;
 
 
/* Generate the disassembler state machine corresponding to the tree
/* Generate the disassembler state machine corresponding to the tree
   in ENT.  */
   in ENT.  */
static void
static void
gen_dis_table (struct bittree *ent)
gen_dis_table (struct bittree *ent)
{
{
  int x;
  int x;
  int our_offset = insn_list_len;
  int our_offset = insn_list_len;
  int bitsused = 5;
  int bitsused = 5;
  int totbits = bitsused;
  int totbits = bitsused;
  int needed_bytes;
  int needed_bytes;
  int zero_count = 0;
  int zero_count = 0;
  int zero_dest = 0;     /* Initialize this with 0 to keep gcc quiet...  */
  int zero_dest = 0;     /* Initialize this with 0 to keep gcc quiet...  */
 
 
  /* If this is a terminal entry, there's no point in skipping any
  /* If this is a terminal entry, there's no point in skipping any
     bits.  */
     bits.  */
  if (ent->skip_flag && ent->bits[0] == NULL && ent->bits[1] == NULL &&
  if (ent->skip_flag && ent->bits[0] == NULL && ent->bits[1] == NULL &&
      ent->bits[2] == NULL)
      ent->bits[2] == NULL)
    {
    {
      if (ent->disent == NULL)
      if (ent->disent == NULL)
        abort ();
        abort ();
      else
      else
        ent->skip_flag = 0;
        ent->skip_flag = 0;
    }
    }
 
 
  /* Calculate the amount of space needed for this entry, or at least
  /* Calculate the amount of space needed for this entry, or at least
     a conservatively large approximation.  */
     a conservatively large approximation.  */
  if (ent->skip_flag)
  if (ent->skip_flag)
    totbits += 5;
    totbits += 5;
 
 
  for (x = 1; x < 3; x++)
  for (x = 1; x < 3; x++)
    if (ent->bits[x] != NULL)
    if (ent->bits[x] != NULL)
      totbits += 16;
      totbits += 16;
 
 
  if (ent->disent != NULL)
  if (ent->disent != NULL)
    {
    {
      if (ent->bits[2] != NULL)
      if (ent->bits[2] != NULL)
        abort ();
        abort ();
 
 
      totbits += 16;
      totbits += 16;
    }
    }
 
 
  /* Now allocate the space.  */
  /* Now allocate the space.  */
  needed_bytes = (totbits + 7) / 8;
  needed_bytes = (totbits + 7) / 8;
  if ((needed_bytes + insn_list_len) > tot_insn_list_len)
  if ((needed_bytes + insn_list_len) > tot_insn_list_len)
    {
    {
      tot_insn_list_len += 256;
      tot_insn_list_len += 256;
      insn_list = (unsigned char *) xrealloc (insn_list, tot_insn_list_len);
      insn_list = (unsigned char *) xrealloc (insn_list, tot_insn_list_len);
    }
    }
  our_offset = insn_list_len;
  our_offset = insn_list_len;
  insn_list_len += needed_bytes;
  insn_list_len += needed_bytes;
  memset (insn_list + our_offset, 0, needed_bytes);
  memset (insn_list + our_offset, 0, needed_bytes);
 
 
  /* Encode the skip entry by setting bit 6 set in the state op field,
  /* Encode the skip entry by setting bit 6 set in the state op field,
     and store the # of bits to skip immediately after.  */
     and store the # of bits to skip immediately after.  */
  if (ent->skip_flag)
  if (ent->skip_flag)
    {
    {
      bitsused += 5;
      bitsused += 5;
      insn_list[our_offset + 0] |= 0x40 | ((ent->bits_to_skip >> 2) & 0xf);
      insn_list[our_offset + 0] |= 0x40 | ((ent->bits_to_skip >> 2) & 0xf);
      insn_list[our_offset + 1] |= ((ent->bits_to_skip & 3) << 6);
      insn_list[our_offset + 1] |= ((ent->bits_to_skip & 3) << 6);
    }
    }
 
 
#define IS_ONLY_IFZERO(ENT) \
#define IS_ONLY_IFZERO(ENT) \
  ((ENT)->bits[0] != NULL && (ENT)->bits[1] == NULL && (ENT)->bits[2] == NULL \
  ((ENT)->bits[0] != NULL && (ENT)->bits[1] == NULL && (ENT)->bits[2] == NULL \
   && (ENT)->disent == NULL && (ENT)->skip_flag == 0)
   && (ENT)->disent == NULL && (ENT)->skip_flag == 0)
 
 
  /* Store an "if (bit is zero)" instruction by setting bit 7 in the
  /* Store an "if (bit is zero)" instruction by setting bit 7 in the
     state op field.  */
     state op field.  */
  if (ent->bits[0] != NULL)
  if (ent->bits[0] != NULL)
    {
    {
      struct bittree *nent = ent->bits[0];
      struct bittree *nent = ent->bits[0];
      zero_count = 0;
      zero_count = 0;
 
 
      insn_list[our_offset] |= 0x80;
      insn_list[our_offset] |= 0x80;
 
 
      /* We can encode sequences of multiple "if (bit is zero)" tests
      /* We can encode sequences of multiple "if (bit is zero)" tests
         by storing the # of zero bits to check in the lower 3 bits of
         by storing the # of zero bits to check in the lower 3 bits of
         the instruction.  However, this only applies if the state
         the instruction.  However, this only applies if the state
         solely tests for a zero bit.  */
         solely tests for a zero bit.  */
 
 
      if (IS_ONLY_IFZERO (ent))
      if (IS_ONLY_IFZERO (ent))
        {
        {
          while (IS_ONLY_IFZERO (nent) && zero_count < 7)
          while (IS_ONLY_IFZERO (nent) && zero_count < 7)
            {
            {
              nent = nent->bits[0];
              nent = nent->bits[0];
              zero_count++;
              zero_count++;
            }
            }
 
 
          insn_list[our_offset + 0] |= zero_count;
          insn_list[our_offset + 0] |= zero_count;
        }
        }
      zero_dest = insn_list_len;
      zero_dest = insn_list_len;
      gen_dis_table (nent);
      gen_dis_table (nent);
    }
    }
 
 
  /* Now store the remaining tests.  We also handle a sole "termination
  /* Now store the remaining tests.  We also handle a sole "termination
     entry" by storing it as an "any bit" test.  */
     entry" by storing it as an "any bit" test.  */
 
 
  for (x = 1; x < 3; x++)
  for (x = 1; x < 3; x++)
    {
    {
      if (ent->bits[x] != NULL || (x == 2 && ent->disent != NULL))
      if (ent->bits[x] != NULL || (x == 2 && ent->disent != NULL))
        {
        {
          struct bittree *i = ent->bits[x];
          struct bittree *i = ent->bits[x];
          int idest;
          int idest;
          int currbits = 15;
          int currbits = 15;
 
 
          if (i != NULL)
          if (i != NULL)
            {
            {
              /* If the instruction being branched to only consists of
              /* If the instruction being branched to only consists of
                 a termination entry, use the termination entry as the
                 a termination entry, use the termination entry as the
                 place to branch to instead.  */
                 place to branch to instead.  */
              if (i->bits[0] == NULL && i->bits[1] == NULL
              if (i->bits[0] == NULL && i->bits[1] == NULL
                  && i->bits[2] == NULL && i->disent != NULL)
                  && i->bits[2] == NULL && i->disent != NULL)
                {
                {
                  idest = i->disent->ournum;
                  idest = i->disent->ournum;
                  i = NULL;
                  i = NULL;
                }
                }
              else
              else
                idest = insn_list_len - our_offset;
                idest = insn_list_len - our_offset;
            }
            }
          else
          else
            idest = ent->disent->ournum;
            idest = ent->disent->ournum;
 
 
          /* If the destination offset for the if (bit is 1) test is less
          /* If the destination offset for the if (bit is 1) test is less
             than 256 bytes away, we can store it as 8-bits instead of 16;
             than 256 bytes away, we can store it as 8-bits instead of 16;
             the instruction has bit 5 set for the 16-bit address, and bit
             the instruction has bit 5 set for the 16-bit address, and bit
             4 for the 8-bit address.  Since we've already allocated 16
             4 for the 8-bit address.  Since we've already allocated 16
             bits for the address we need to deallocate the space.
             bits for the address we need to deallocate the space.
 
 
             Note that branchings within the table are relative, and
             Note that branchings within the table are relative, and
             there are no branches that branch past our instruction yet
             there are no branches that branch past our instruction yet
             so we do not need to adjust any other offsets.  */
             so we do not need to adjust any other offsets.  */
          if (x == 1)
          if (x == 1)
            {
            {
              if (idest <= 256)
              if (idest <= 256)
                {
                {
                  int start = our_offset + bitsused / 8 + 1;
                  int start = our_offset + bitsused / 8 + 1;
 
 
                  memmove (insn_list + start,
                  memmove (insn_list + start,
                           insn_list + start + 1,
                           insn_list + start + 1,
                           insn_list_len - (start + 1));
                           insn_list_len - (start + 1));
                  currbits = 7;
                  currbits = 7;
                  totbits -= 8;
                  totbits -= 8;
                  needed_bytes--;
                  needed_bytes--;
                  insn_list_len--;
                  insn_list_len--;
                  insn_list[our_offset] |= 0x10;
                  insn_list[our_offset] |= 0x10;
                  idest--;
                  idest--;
                }
                }
              else
              else
                insn_list[our_offset] |= 0x20;
                insn_list[our_offset] |= 0x20;
            }
            }
          else
          else
            {
            {
              /* An instruction which solely consists of a termination
              /* An instruction which solely consists of a termination
                 marker and whose disassembly name index is < 4096
                 marker and whose disassembly name index is < 4096
                 can be stored in 16 bits.  The encoding is slightly
                 can be stored in 16 bits.  The encoding is slightly
                 odd; the upper 4 bits of the instruction are 0x3, and
                 odd; the upper 4 bits of the instruction are 0x3, and
                 bit 3 loses its normal meaning.  */
                 bit 3 loses its normal meaning.  */
 
 
              if (ent->bits[0] == NULL && ent->bits[1] == NULL
              if (ent->bits[0] == NULL && ent->bits[1] == NULL
                  && ent->bits[2] == NULL && ent->skip_flag == 0
                  && ent->bits[2] == NULL && ent->skip_flag == 0
                  && ent->disent != NULL
                  && ent->disent != NULL
                  && ent->disent->ournum < (32768 + 4096))
                  && ent->disent->ournum < (32768 + 4096))
                {
                {
                  int start = our_offset + bitsused / 8 + 1;
                  int start = our_offset + bitsused / 8 + 1;
 
 
                  memmove (insn_list + start,
                  memmove (insn_list + start,
                           insn_list + start + 1,
                           insn_list + start + 1,
                           insn_list_len - (start + 1));
                           insn_list_len - (start + 1));
                  currbits = 11;
                  currbits = 11;
                  totbits -= 5;
                  totbits -= 5;
                  bitsused--;
                  bitsused--;
                  needed_bytes--;
                  needed_bytes--;
                  insn_list_len--;
                  insn_list_len--;
                  insn_list[our_offset] |= 0x30;
                  insn_list[our_offset] |= 0x30;
                  idest &= ~32768;
                  idest &= ~32768;
                }
                }
              else
              else
                insn_list[our_offset] |= 0x08;
                insn_list[our_offset] |= 0x08;
            }
            }
 
 
          if (debug)
          if (debug)
            {
            {
              int id = idest;
              int id = idest;
 
 
              if (i == NULL)
              if (i == NULL)
                id |= 32768;
                id |= 32768;
              else if (! (id & 32768))
              else if (! (id & 32768))
                id += our_offset;
                id += our_offset;
 
 
              if (x == 1)
              if (x == 1)
                printf ("%d: if (1) goto %d\n", our_offset, id);
                printf ("%d: if (1) goto %d\n", our_offset, id);
              else
              else
                printf ("%d: try %d\n", our_offset, id);
                printf ("%d: try %d\n", our_offset, id);
            }
            }
 
 
          /* Store the address of the entry being branched to.  */
          /* Store the address of the entry being branched to.  */
          while (currbits >= 0)
          while (currbits >= 0)
            {
            {
              unsigned char *byte = insn_list + our_offset + bitsused / 8;
              unsigned char *byte = insn_list + our_offset + bitsused / 8;
 
 
              if (idest & (1 << currbits))
              if (idest & (1 << currbits))
                *byte |= (1 << (7 - (bitsused % 8)));
                *byte |= (1 << (7 - (bitsused % 8)));
 
 
              bitsused++;
              bitsused++;
              currbits--;
              currbits--;
            }
            }
 
 
          /* Now generate the states for the entry being branched to.  */
          /* Now generate the states for the entry being branched to.  */
          if (i != NULL)
          if (i != NULL)
            gen_dis_table (i);
            gen_dis_table (i);
        }
        }
    }
    }
 
 
  if (debug)
  if (debug)
    {
    {
      if (ent->skip_flag)
      if (ent->skip_flag)
        printf ("%d: skipping %d\n", our_offset, ent->bits_to_skip);
        printf ("%d: skipping %d\n", our_offset, ent->bits_to_skip);
 
 
      if (ent->bits[0] != NULL)
      if (ent->bits[0] != NULL)
        printf ("%d: if (0:%d) goto %d\n", our_offset, zero_count + 1,
        printf ("%d: if (0:%d) goto %d\n", our_offset, zero_count + 1,
                zero_dest);
                zero_dest);
    }
    }
 
 
  if (bitsused != totbits)
  if (bitsused != totbits)
    abort ();
    abort ();
}
}


static void
static void
print_dis_table (void)
print_dis_table (void)
{
{
  int x;
  int x;
  struct disent *cent = disinsntable;
  struct disent *cent = disinsntable;
 
 
  printf ("static const char dis_table[] = {\n");
  printf ("static const char dis_table[] = {\n");
  for (x = 0; x < insn_list_len; x++)
  for (x = 0; x < insn_list_len; x++)
    {
    {
      if ((x > 0) && ((x % 12) == 0))
      if ((x > 0) && ((x % 12) == 0))
        printf ("\n");
        printf ("\n");
 
 
      printf ("0x%02x, ", insn_list[x]);
      printf ("0x%02x, ", insn_list[x]);
    }
    }
  printf ("\n};\n\n");
  printf ("\n};\n\n");
 
 
  printf ("static const struct ia64_dis_names ia64_dis_names[] = {\n");
  printf ("static const struct ia64_dis_names ia64_dis_names[] = {\n");
  while (cent != NULL)
  while (cent != NULL)
    {
    {
      struct disent *ent = cent;
      struct disent *ent = cent;
 
 
      while (ent != NULL)
      while (ent != NULL)
        {
        {
          printf ("{ 0x%x, %d, %d, %d },\n", ent->completer_index,
          printf ("{ 0x%x, %d, %d, %d },\n", ent->completer_index,
                  ent->insn, (ent->nexte != NULL ? 1 : 0),
                  ent->insn, (ent->nexte != NULL ? 1 : 0),
                  ent->priority);
                  ent->priority);
          ent = ent->nexte;
          ent = ent->nexte;
        }
        }
      cent = cent->next_ent;
      cent = cent->next_ent;
    }
    }
  printf ("};\n\n");
  printf ("};\n\n");
}
}


static void
static void
generate_disassembler (void)
generate_disassembler (void)
{
{
  int i;
  int i;
 
 
  bittree = make_bittree_entry ();
  bittree = make_bittree_entry ();
 
 
  for (i = 0; i < otlen; i++)
  for (i = 0; i < otlen; i++)
    {
    {
      struct main_entry *ptr = ordered_table[i];
      struct main_entry *ptr = ordered_table[i];
 
 
      if (ptr->opcode->type != IA64_TYPE_DYN)
      if (ptr->opcode->type != IA64_TYPE_DYN)
        add_dis_entry (bittree,
        add_dis_entry (bittree,
                       ptr->opcode->opcode, ptr->opcode->mask,
                       ptr->opcode->opcode, ptr->opcode->mask,
                       ptr->main_index,
                       ptr->main_index,
                       ptr->completers, 1);
                       ptr->completers, 1);
    }
    }
 
 
  compact_distree (bittree);
  compact_distree (bittree);
  finish_distable ();
  finish_distable ();
  gen_dis_table (bittree);
  gen_dis_table (bittree);
 
 
  print_dis_table ();
  print_dis_table ();
}
}


static void
static void
print_string_table (void)
print_string_table (void)
{
{
  int x;
  int x;
  char lbuf[80], buf[80];
  char lbuf[80], buf[80];
  int blen = 0;
  int blen = 0;
 
 
  printf ("static const char * const ia64_strings[] = {\n");
  printf ("static const char * const ia64_strings[] = {\n");
  lbuf[0] = '\0';
  lbuf[0] = '\0';
 
 
  for (x = 0; x < strtablen; x++)
  for (x = 0; x < strtablen; x++)
    {
    {
      int len;
      int len;
 
 
      if (strlen (string_table[x]->s) > 75)
      if (strlen (string_table[x]->s) > 75)
        abort ();
        abort ();
 
 
      sprintf (buf, " \"%s\",", string_table[x]->s);
      sprintf (buf, " \"%s\",", string_table[x]->s);
      len = strlen (buf);
      len = strlen (buf);
 
 
      if ((blen + len) > 75)
      if ((blen + len) > 75)
        {
        {
          printf (" %s\n", lbuf);
          printf (" %s\n", lbuf);
          lbuf[0] = '\0';
          lbuf[0] = '\0';
          blen = 0;
          blen = 0;
        }
        }
      strcat (lbuf, buf);
      strcat (lbuf, buf);
      blen += len;
      blen += len;
    }
    }
 
 
  if (blen > 0)
  if (blen > 0)
    printf (" %s\n", lbuf);
    printf (" %s\n", lbuf);
 
 
  printf ("};\n\n");
  printf ("};\n\n");
}
}


static struct completer_entry **glist;
static struct completer_entry **glist;
static int glistlen = 0;
static int glistlen = 0;
static int glisttotlen = 0;
static int glisttotlen = 0;
 
 
/* If the completer trees ENT1 and ENT2 are equal, return 1.  */
/* If the completer trees ENT1 and ENT2 are equal, return 1.  */
 
 
static int
static int
completer_entries_eq (struct completer_entry *ent1,
completer_entries_eq (struct completer_entry *ent1,
                      struct completer_entry *ent2)
                      struct completer_entry *ent2)
{
{
  while (ent1 != NULL && ent2 != NULL)
  while (ent1 != NULL && ent2 != NULL)
    {
    {
      if (ent1->name->num != ent2->name->num
      if (ent1->name->num != ent2->name->num
          || ent1->bits != ent2->bits
          || ent1->bits != ent2->bits
          || ent1->mask != ent2->mask
          || ent1->mask != ent2->mask
          || ent1->is_terminal != ent2->is_terminal
          || ent1->is_terminal != ent2->is_terminal
          || ent1->dependencies != ent2->dependencies
          || ent1->dependencies != ent2->dependencies
          || ent1->order != ent2->order)
          || ent1->order != ent2->order)
        return 0;
        return 0;
 
 
      if (! completer_entries_eq (ent1->addl_entries, ent2->addl_entries))
      if (! completer_entries_eq (ent1->addl_entries, ent2->addl_entries))
        return 0;
        return 0;
 
 
      ent1 = ent1->alternative;
      ent1 = ent1->alternative;
      ent2 = ent2->alternative;
      ent2 = ent2->alternative;
    }
    }
 
 
  return ent1 == ent2;
  return ent1 == ent2;
}
}


/* Insert ENT into the global list of completers and return it.  If an
/* Insert ENT into the global list of completers and return it.  If an
   equivalent entry (according to completer_entries_eq) already exists,
   equivalent entry (according to completer_entries_eq) already exists,
   it is returned instead.  */
   it is returned instead.  */
static struct completer_entry *
static struct completer_entry *
insert_gclist (struct completer_entry *ent)
insert_gclist (struct completer_entry *ent)
{
{
  if (ent != NULL)
  if (ent != NULL)
    {
    {
      int i;
      int i;
      int x;
      int x;
      int start = 0, end;
      int start = 0, end;
 
 
      ent->addl_entries = insert_gclist (ent->addl_entries);
      ent->addl_entries = insert_gclist (ent->addl_entries);
      ent->alternative = insert_gclist (ent->alternative);
      ent->alternative = insert_gclist (ent->alternative);
 
 
      i = glistlen / 2;
      i = glistlen / 2;
      end = glistlen;
      end = glistlen;
 
 
      if (glisttotlen == glistlen)
      if (glisttotlen == glistlen)
        {
        {
          glisttotlen += 20;
          glisttotlen += 20;
          glist = (struct completer_entry **)
          glist = (struct completer_entry **)
            xrealloc (glist, sizeof (struct completer_entry *) * glisttotlen);
            xrealloc (glist, sizeof (struct completer_entry *) * glisttotlen);
        }
        }
 
 
      if (glistlen == 0)
      if (glistlen == 0)
        {
        {
          glist[0] = ent;
          glist[0] = ent;
          glistlen = 1;
          glistlen = 1;
          return ent;
          return ent;
        }
        }
 
 
      if (ent->name->num < glist[0]->name->num)
      if (ent->name->num < glist[0]->name->num)
        i = 0;
        i = 0;
      else if (ent->name->num > glist[end - 1]->name->num)
      else if (ent->name->num > glist[end - 1]->name->num)
        i = end;
        i = end;
      else
      else
        {
        {
          int c;
          int c;
 
 
          while (1)
          while (1)
            {
            {
              i = (start + end) / 2;
              i = (start + end) / 2;
              c = ent->name->num - glist[i]->name->num;
              c = ent->name->num - glist[i]->name->num;
 
 
              if (c < 0)
              if (c < 0)
                end = i - 1;
                end = i - 1;
              else if (c == 0)
              else if (c == 0)
                {
                {
                  while (i > 0
                  while (i > 0
                         && ent->name->num == glist[i - 1]->name->num)
                         && ent->name->num == glist[i - 1]->name->num)
                    i--;
                    i--;
 
 
                  break;
                  break;
                }
                }
              else
              else
                start = i + 1;
                start = i + 1;
 
 
              if (start > end)
              if (start > end)
                break;
                break;
            }
            }
 
 
          if (c == 0)
          if (c == 0)
            {
            {
              while (i < glistlen)
              while (i < glistlen)
                {
                {
                  if (ent->name->num != glist[i]->name->num)
                  if (ent->name->num != glist[i]->name->num)
                    break;
                    break;
 
 
                  if (completer_entries_eq (ent, glist[i]))
                  if (completer_entries_eq (ent, glist[i]))
                    return glist[i];
                    return glist[i];
 
 
                  i++;
                  i++;
                }
                }
            }
            }
        }
        }
 
 
      for (; i > 0 && i < glistlen; i--)
      for (; i > 0 && i < glistlen; i--)
        if (ent->name->num >= glist[i - 1]->name->num)
        if (ent->name->num >= glist[i - 1]->name->num)
          break;
          break;
 
 
      for (; i < glistlen; i++)
      for (; i < glistlen; i++)
        if (ent->name->num < glist[i]->name->num)
        if (ent->name->num < glist[i]->name->num)
          break;
          break;
 
 
      for (x = glistlen - 1; x >= i; x--)
      for (x = glistlen - 1; x >= i; x--)
        glist[x + 1] = glist[x];
        glist[x + 1] = glist[x];
 
 
      glist[i] = ent;
      glist[i] = ent;
      glistlen++;
      glistlen++;
    }
    }
  return ent;
  return ent;
}
}


static int
static int
get_prefix_len (const char *name)
get_prefix_len (const char *name)
{
{
  char *c;
  char *c;
 
 
  if (name[0] == '\0')
  if (name[0] == '\0')
    return 0;
    return 0;
 
 
  c = strchr (name, '.');
  c = strchr (name, '.');
  if (c != NULL)
  if (c != NULL)
    return c - name;
    return c - name;
  else
  else
    return strlen (name);
    return strlen (name);
}
}


static void
static void
compute_completer_bits (struct main_entry *ment, struct completer_entry *ent)
compute_completer_bits (struct main_entry *ment, struct completer_entry *ent)
{
{
  while (ent != NULL)
  while (ent != NULL)
    {
    {
      compute_completer_bits (ment, ent->addl_entries);
      compute_completer_bits (ment, ent->addl_entries);
 
 
      if (ent->is_terminal)
      if (ent->is_terminal)
        {
        {
          ia64_insn mask = 0;
          ia64_insn mask = 0;
          ia64_insn our_bits = ent->bits;
          ia64_insn our_bits = ent->bits;
          struct completer_entry *p = ent->parent;
          struct completer_entry *p = ent->parent;
          ia64_insn p_bits;
          ia64_insn p_bits;
          int x;
          int x;
 
 
          while (p != NULL && ! p->is_terminal)
          while (p != NULL && ! p->is_terminal)
            p = p->parent;
            p = p->parent;
 
 
          if (p != NULL)
          if (p != NULL)
            p_bits = p->bits;
            p_bits = p->bits;
          else
          else
            p_bits = ment->opcode->opcode;
            p_bits = ment->opcode->opcode;
 
 
          for (x = 0; x < 64; x++)
          for (x = 0; x < 64; x++)
            {
            {
              ia64_insn m = ((ia64_insn) 1) << x;
              ia64_insn m = ((ia64_insn) 1) << x;
 
 
              if ((p_bits & m) != (our_bits & m))
              if ((p_bits & m) != (our_bits & m))
                mask |= m;
                mask |= m;
              else
              else
                our_bits &= ~m;
                our_bits &= ~m;
            }
            }
          ent->bits = our_bits;
          ent->bits = our_bits;
          ent->mask = mask;
          ent->mask = mask;
        }
        }
      else
      else
        {
        {
          ent->bits = 0;
          ent->bits = 0;
          ent->mask = 0;
          ent->mask = 0;
        }
        }
 
 
      ent = ent->alternative;
      ent = ent->alternative;
    }
    }
}
}


/* Find identical completer trees that are used in different
/* Find identical completer trees that are used in different
   instructions and collapse their entries.  */
   instructions and collapse their entries.  */
static void
static void
collapse_redundant_completers (void)
collapse_redundant_completers (void)
{
{
  struct main_entry *ptr;
  struct main_entry *ptr;
  int x;
  int x;
 
 
  for (ptr = maintable; ptr != NULL; ptr = ptr->next)
  for (ptr = maintable; ptr != NULL; ptr = ptr->next)
    {
    {
      if (ptr->completers == NULL)
      if (ptr->completers == NULL)
        abort ();
        abort ();
 
 
      compute_completer_bits (ptr, ptr->completers);
      compute_completer_bits (ptr, ptr->completers);
      ptr->completers = insert_gclist (ptr->completers);
      ptr->completers = insert_gclist (ptr->completers);
    }
    }
 
 
  /* The table has been finalized, now number the indexes.  */
  /* The table has been finalized, now number the indexes.  */
  for (x = 0; x < glistlen; x++)
  for (x = 0; x < glistlen; x++)
    glist[x]->num = x;
    glist[x]->num = x;
}
}


 
 
/* Attach two lists of dependencies to each opcode.
/* Attach two lists of dependencies to each opcode.
   1) all resources which, when already marked in use, conflict with this
   1) all resources which, when already marked in use, conflict with this
   opcode (chks)
   opcode (chks)
   2) all resources which must be marked in use when this opcode is used
   2) all resources which must be marked in use when this opcode is used
   (regs).  */
   (regs).  */
static int
static int
insert_opcode_dependencies (struct ia64_opcode *opc,
insert_opcode_dependencies (struct ia64_opcode *opc,
                            struct completer_entry *cmp ATTRIBUTE_UNUSED)
                            struct completer_entry *cmp ATTRIBUTE_UNUSED)
{
{
  /* Note all resources which point to this opcode.  rfi has the most chks
  /* Note all resources which point to this opcode.  rfi has the most chks
     (79) and cmpxchng has the most regs (54) so 100 here should be enough.  */
     (79) and cmpxchng has the most regs (54) so 100 here should be enough.  */
  int i;
  int i;
  int nregs = 0;
  int nregs = 0;
  unsigned short regs[256];
  unsigned short regs[256];
  int nchks = 0;
  int nchks = 0;
  unsigned short chks[256];
  unsigned short chks[256];
  /* Flag insns for which no class matched; there should be none.  */
  /* Flag insns for which no class matched; there should be none.  */
  int no_class_found = 1;
  int no_class_found = 1;
 
 
  for (i = 0; i < rdepslen; i++)
  for (i = 0; i < rdepslen; i++)
    {
    {
      struct rdep *rs = rdeps[i];
      struct rdep *rs = rdeps[i];
      int j;
      int j;
 
 
      if (strcmp (opc->name, "cmp.eq.and") == 0
      if (strcmp (opc->name, "cmp.eq.and") == 0
          && CONST_STRNEQ (rs->name, "PR%")
          && CONST_STRNEQ (rs->name, "PR%")
          && rs->mode == 1)
          && rs->mode == 1)
        no_class_found = 99;
        no_class_found = 99;
 
 
      for (j=0; j < rs->nregs;j++)
      for (j=0; j < rs->nregs;j++)
        {
        {
          int ic_note = 0;
          int ic_note = 0;
 
 
          if (in_iclass (opc, ics[rs->regs[j]], NULL, NULL, &ic_note))
          if (in_iclass (opc, ics[rs->regs[j]], NULL, NULL, &ic_note))
            {
            {
              /* We can ignore ic_note 11 for non PR resources.  */
              /* We can ignore ic_note 11 for non PR resources.  */
              if (ic_note == 11 && ! CONST_STRNEQ (rs->name, "PR"))
              if (ic_note == 11 && ! CONST_STRNEQ (rs->name, "PR"))
                ic_note = 0;
                ic_note = 0;
 
 
              if (ic_note != 0 && rs->regnotes[j] != 0
              if (ic_note != 0 && rs->regnotes[j] != 0
                  && ic_note != rs->regnotes[j]
                  && ic_note != rs->regnotes[j]
                  && !(ic_note == 11 && rs->regnotes[j] == 1))
                  && !(ic_note == 11 && rs->regnotes[j] == 1))
                warn (_("IC note %d in opcode %s (IC:%s) conflicts with resource %s note %d\n"),
                warn (_("IC note %d in opcode %s (IC:%s) conflicts with resource %s note %d\n"),
                      ic_note, opc->name, ics[rs->regs[j]]->name,
                      ic_note, opc->name, ics[rs->regs[j]]->name,
                      rs->name, rs->regnotes[j]);
                      rs->name, rs->regnotes[j]);
              /* Instruction class notes override resource notes.
              /* Instruction class notes override resource notes.
                 So far, only note 11 applies to an IC instead of a resource,
                 So far, only note 11 applies to an IC instead of a resource,
                 and note 11 implies note 1.  */
                 and note 11 implies note 1.  */
              if (ic_note)
              if (ic_note)
                regs[nregs++] = RDEP(ic_note, i);
                regs[nregs++] = RDEP(ic_note, i);
              else
              else
                regs[nregs++] = RDEP(rs->regnotes[j], i);
                regs[nregs++] = RDEP(rs->regnotes[j], i);
              no_class_found = 0;
              no_class_found = 0;
              ++rs->total_regs;
              ++rs->total_regs;
            }
            }
        }
        }
 
 
      for (j = 0; j < rs->nchks; j++)
      for (j = 0; j < rs->nchks; j++)
        {
        {
          int ic_note = 0;
          int ic_note = 0;
 
 
          if (in_iclass (opc, ics[rs->chks[j]], NULL, NULL, &ic_note))
          if (in_iclass (opc, ics[rs->chks[j]], NULL, NULL, &ic_note))
            {
            {
              /* We can ignore ic_note 11 for non PR resources.  */
              /* We can ignore ic_note 11 for non PR resources.  */
              if (ic_note == 11 && ! CONST_STRNEQ (rs->name, "PR"))
              if (ic_note == 11 && ! CONST_STRNEQ (rs->name, "PR"))
                ic_note = 0;
                ic_note = 0;
 
 
              if (ic_note != 0 && rs->chknotes[j] != 0
              if (ic_note != 0 && rs->chknotes[j] != 0
                  && ic_note != rs->chknotes[j]
                  && ic_note != rs->chknotes[j]
                  && !(ic_note == 11 && rs->chknotes[j] == 1))
                  && !(ic_note == 11 && rs->chknotes[j] == 1))
                warn (_("IC note %d for opcode %s (IC:%s) conflicts with resource %s note %d\n"),
                warn (_("IC note %d for opcode %s (IC:%s) conflicts with resource %s note %d\n"),
                      ic_note, opc->name, ics[rs->chks[j]]->name,
                      ic_note, opc->name, ics[rs->chks[j]]->name,
                      rs->name, rs->chknotes[j]);
                      rs->name, rs->chknotes[j]);
              if (ic_note)
              if (ic_note)
                chks[nchks++] = RDEP(ic_note, i);
                chks[nchks++] = RDEP(ic_note, i);
              else
              else
                chks[nchks++] = RDEP(rs->chknotes[j], i);
                chks[nchks++] = RDEP(rs->chknotes[j], i);
              no_class_found = 0;
              no_class_found = 0;
              ++rs->total_chks;
              ++rs->total_chks;
            }
            }
        }
        }
    }
    }
 
 
  if (no_class_found)
  if (no_class_found)
    warn (_("opcode %s has no class (ops %d %d %d)\n"),
    warn (_("opcode %s has no class (ops %d %d %d)\n"),
          opc->name,
          opc->name,
          opc->operands[0], opc->operands[1], opc->operands[2]);
          opc->operands[0], opc->operands[1], opc->operands[2]);
 
 
  return insert_dependencies (nchks, chks, nregs, regs);
  return insert_dependencies (nchks, chks, nregs, regs);
}
}


static void
static void
insert_completer_entry (struct ia64_opcode *opc, struct main_entry *tabent,
insert_completer_entry (struct ia64_opcode *opc, struct main_entry *tabent,
                        int order)
                        int order)
{
{
  struct completer_entry **ptr = &tabent->completers;
  struct completer_entry **ptr = &tabent->completers;
  struct completer_entry *parent = NULL;
  struct completer_entry *parent = NULL;
  char pcopy[129], *prefix;
  char pcopy[129], *prefix;
  int at_end = 0;
  int at_end = 0;
 
 
  if (strlen (opc->name) > 128)
  if (strlen (opc->name) > 128)
    abort ();
    abort ();
 
 
  strcpy (pcopy, opc->name);
  strcpy (pcopy, opc->name);
  prefix = pcopy + get_prefix_len (pcopy);
  prefix = pcopy + get_prefix_len (pcopy);
 
 
  if (prefix[0] != '\0')
  if (prefix[0] != '\0')
    prefix++;
    prefix++;
 
 
  while (! at_end)
  while (! at_end)
    {
    {
      int need_new_ent = 1;
      int need_new_ent = 1;
      int plen = get_prefix_len (prefix);
      int plen = get_prefix_len (prefix);
      struct string_entry *sent;
      struct string_entry *sent;
 
 
      at_end = (prefix[plen] == '\0');
      at_end = (prefix[plen] == '\0');
      prefix[plen] = '\0';
      prefix[plen] = '\0';
      sent = insert_string (prefix);
      sent = insert_string (prefix);
 
 
      while (*ptr != NULL)
      while (*ptr != NULL)
        {
        {
          int cmpres = sent->num - (*ptr)->name->num;
          int cmpres = sent->num - (*ptr)->name->num;
 
 
          if (cmpres == 0)
          if (cmpres == 0)
            {
            {
              need_new_ent = 0;
              need_new_ent = 0;
              break;
              break;
            }
            }
          else
          else
            ptr = &((*ptr)->alternative);
            ptr = &((*ptr)->alternative);
        }
        }
 
 
      if (need_new_ent)
      if (need_new_ent)
        {
        {
          struct completer_entry *nent = tmalloc (struct completer_entry);
          struct completer_entry *nent = tmalloc (struct completer_entry);
 
 
          nent->name = sent;
          nent->name = sent;
          nent->parent = parent;
          nent->parent = parent;
          nent->addl_entries = NULL;
          nent->addl_entries = NULL;
          nent->alternative = *ptr;
          nent->alternative = *ptr;
          *ptr = nent;
          *ptr = nent;
          nent->is_terminal = 0;
          nent->is_terminal = 0;
          nent->dependencies = -1;
          nent->dependencies = -1;
        }
        }
 
 
      if (! at_end)
      if (! at_end)
        {
        {
          parent = *ptr;
          parent = *ptr;
          ptr = &((*ptr)->addl_entries);
          ptr = &((*ptr)->addl_entries);
          prefix += plen + 1;
          prefix += plen + 1;
        }
        }
    }
    }
 
 
  if ((*ptr)->is_terminal)
  if ((*ptr)->is_terminal)
    abort ();
    abort ();
 
 
  (*ptr)->is_terminal = 1;
  (*ptr)->is_terminal = 1;
  (*ptr)->mask = (ia64_insn)-1;
  (*ptr)->mask = (ia64_insn)-1;
  (*ptr)->bits = opc->opcode;
  (*ptr)->bits = opc->opcode;
  (*ptr)->dependencies = insert_opcode_dependencies (opc, *ptr);
  (*ptr)->dependencies = insert_opcode_dependencies (opc, *ptr);
  (*ptr)->order = order;
  (*ptr)->order = order;
}
}


static void
static void
print_completer_entry (struct completer_entry *ent)
print_completer_entry (struct completer_entry *ent)
{
{
  int moffset = 0;
  int moffset = 0;
  ia64_insn mask = ent->mask, bits = ent->bits;
  ia64_insn mask = ent->mask, bits = ent->bits;
 
 
  if (mask != 0)
  if (mask != 0)
    {
    {
      while (! (mask & 1))
      while (! (mask & 1))
        {
        {
          moffset++;
          moffset++;
          mask = mask >> 1;
          mask = mask >> 1;
          bits = bits >> 1;
          bits = bits >> 1;
        }
        }
 
 
      if (bits & 0xffffffff00000000LL)
      if (bits & 0xffffffff00000000LL)
        abort ();
        abort ();
    }
    }
 
 
  printf ("  { 0x%x, 0x%x, %d, %d, %d, %d, %d, %d },\n",
  printf ("  { 0x%x, 0x%x, %d, %d, %d, %d, %d, %d },\n",
          (int)bits,
          (int)bits,
          (int)mask,
          (int)mask,
          ent->name->num,
          ent->name->num,
          ent->alternative != NULL ? ent->alternative->num : -1,
          ent->alternative != NULL ? ent->alternative->num : -1,
          ent->addl_entries != NULL ? ent->addl_entries->num : -1,
          ent->addl_entries != NULL ? ent->addl_entries->num : -1,
          moffset,
          moffset,
          ent->is_terminal ? 1 : 0,
          ent->is_terminal ? 1 : 0,
          ent->dependencies);
          ent->dependencies);
}
}


static void
static void
print_completer_table (void)
print_completer_table (void)
{
{
  int x;
  int x;
 
 
  printf ("static const struct ia64_completer_table\ncompleter_table[] = {\n");
  printf ("static const struct ia64_completer_table\ncompleter_table[] = {\n");
  for (x = 0; x < glistlen; x++)
  for (x = 0; x < glistlen; x++)
    print_completer_entry (glist[x]);
    print_completer_entry (glist[x]);
  printf ("};\n\n");
  printf ("};\n\n");
}
}


static int
static int
opcodes_eq (struct ia64_opcode *opc1, struct ia64_opcode *opc2)
opcodes_eq (struct ia64_opcode *opc1, struct ia64_opcode *opc2)
{
{
  int x;
  int x;
  int plen1, plen2;
  int plen1, plen2;
 
 
  if ((opc1->mask != opc2->mask) || (opc1->type != opc2->type)
  if ((opc1->mask != opc2->mask) || (opc1->type != opc2->type)
      || (opc1->num_outputs != opc2->num_outputs)
      || (opc1->num_outputs != opc2->num_outputs)
      || (opc1->flags != opc2->flags))
      || (opc1->flags != opc2->flags))
    return 0;
    return 0;
 
 
  for (x = 0; x < 5; x++)
  for (x = 0; x < 5; x++)
    if (opc1->operands[x] != opc2->operands[x])
    if (opc1->operands[x] != opc2->operands[x])
      return 0;
      return 0;
 
 
  plen1 = get_prefix_len (opc1->name);
  plen1 = get_prefix_len (opc1->name);
  plen2 = get_prefix_len (opc2->name);
  plen2 = get_prefix_len (opc2->name);
 
 
  if (plen1 == plen2 && (memcmp (opc1->name, opc2->name, plen1) == 0))
  if (plen1 == plen2 && (memcmp (opc1->name, opc2->name, plen1) == 0))
    return 1;
    return 1;
 
 
  return 0;
  return 0;
}
}


static void
static void
add_opcode_entry (struct ia64_opcode *opc)
add_opcode_entry (struct ia64_opcode *opc)
{
{
  struct main_entry **place;
  struct main_entry **place;
  struct string_entry *name;
  struct string_entry *name;
  char prefix[129];
  char prefix[129];
  int found_it = 0;
  int found_it = 0;
 
 
  if (strlen (opc->name) > 128)
  if (strlen (opc->name) > 128)
    abort ();
    abort ();
 
 
  place = &maintable;
  place = &maintable;
  strcpy (prefix, opc->name);
  strcpy (prefix, opc->name);
  prefix[get_prefix_len (prefix)] = '\0';
  prefix[get_prefix_len (prefix)] = '\0';
  name = insert_string (prefix);
  name = insert_string (prefix);
 
 
  /* Walk the list of opcode table entries.  If it's a new
  /* Walk the list of opcode table entries.  If it's a new
     instruction, allocate and fill in a new entry.  Note
     instruction, allocate and fill in a new entry.  Note
     the main table is alphabetical by opcode name.  */
     the main table is alphabetical by opcode name.  */
 
 
  while (*place != NULL)
  while (*place != NULL)
    {
    {
      if ((*place)->name->num == name->num
      if ((*place)->name->num == name->num
          && opcodes_eq ((*place)->opcode, opc))
          && opcodes_eq ((*place)->opcode, opc))
        {
        {
          found_it = 1;
          found_it = 1;
          break;
          break;
        }
        }
      if ((*place)->name->num > name->num)
      if ((*place)->name->num > name->num)
        break;
        break;
 
 
      place = &((*place)->next);
      place = &((*place)->next);
    }
    }
  if (! found_it)
  if (! found_it)
    {
    {
      struct main_entry *nent = tmalloc (struct main_entry);
      struct main_entry *nent = tmalloc (struct main_entry);
 
 
      nent->name = name;
      nent->name = name;
      nent->opcode = opc;
      nent->opcode = opc;
      nent->next = *place;
      nent->next = *place;
      nent->completers = 0;
      nent->completers = 0;
      *place = nent;
      *place = nent;
 
 
      if (otlen == ottotlen)
      if (otlen == ottotlen)
        {
        {
          ottotlen += 20;
          ottotlen += 20;
          ordered_table = (struct main_entry **)
          ordered_table = (struct main_entry **)
            xrealloc (ordered_table, sizeof (struct main_entry *) * ottotlen);
            xrealloc (ordered_table, sizeof (struct main_entry *) * ottotlen);
        }
        }
      ordered_table[otlen++] = nent;
      ordered_table[otlen++] = nent;
    }
    }
 
 
  insert_completer_entry (opc, *place, opcode_count++);
  insert_completer_entry (opc, *place, opcode_count++);
}
}


static void
static void
print_main_table (void)
print_main_table (void)
{
{
  struct main_entry *ptr = maintable;
  struct main_entry *ptr = maintable;
  int index = 0;
  int index = 0;
 
 
  printf ("static const struct ia64_main_table\nmain_table[] = {\n");
  printf ("static const struct ia64_main_table\nmain_table[] = {\n");
  while (ptr != NULL)
  while (ptr != NULL)
    {
    {
      printf ("  { %d, %d, %d, 0x",
      printf ("  { %d, %d, %d, 0x",
              ptr->name->num,
              ptr->name->num,
              ptr->opcode->type,
              ptr->opcode->type,
              ptr->opcode->num_outputs);
              ptr->opcode->num_outputs);
      opcode_fprintf_vma (stdout, ptr->opcode->opcode);
      opcode_fprintf_vma (stdout, ptr->opcode->opcode);
      printf ("ull, 0x");
      printf ("ull, 0x");
      opcode_fprintf_vma (stdout, ptr->opcode->mask);
      opcode_fprintf_vma (stdout, ptr->opcode->mask);
      printf ("ull, { %d, %d, %d, %d, %d }, 0x%x, %d, },\n",
      printf ("ull, { %d, %d, %d, %d, %d }, 0x%x, %d, },\n",
              ptr->opcode->operands[0],
              ptr->opcode->operands[0],
              ptr->opcode->operands[1],
              ptr->opcode->operands[1],
              ptr->opcode->operands[2],
              ptr->opcode->operands[2],
              ptr->opcode->operands[3],
              ptr->opcode->operands[3],
              ptr->opcode->operands[4],
              ptr->opcode->operands[4],
              ptr->opcode->flags,
              ptr->opcode->flags,
              ptr->completers->num);
              ptr->completers->num);
 
 
      ptr->main_index = index++;
      ptr->main_index = index++;
 
 
      ptr = ptr->next;
      ptr = ptr->next;
    }
    }
  printf ("};\n\n");
  printf ("};\n\n");
}
}


static void
static void
shrink (struct ia64_opcode *table)
shrink (struct ia64_opcode *table)
{
{
  int curr_opcode;
  int curr_opcode;
 
 
  for (curr_opcode = 0; table[curr_opcode].name != NULL; curr_opcode++)
  for (curr_opcode = 0; table[curr_opcode].name != NULL; curr_opcode++)
    {
    {
      add_opcode_entry (table + curr_opcode);
      add_opcode_entry (table + curr_opcode);
      if (table[curr_opcode].num_outputs == 2
      if (table[curr_opcode].num_outputs == 2
          && ((table[curr_opcode].operands[0] == IA64_OPND_P1
          && ((table[curr_opcode].operands[0] == IA64_OPND_P1
               && table[curr_opcode].operands[1] == IA64_OPND_P2)
               && table[curr_opcode].operands[1] == IA64_OPND_P2)
              || (table[curr_opcode].operands[0] == IA64_OPND_P2
              || (table[curr_opcode].operands[0] == IA64_OPND_P2
                  && table[curr_opcode].operands[1] == IA64_OPND_P1)))
                  && table[curr_opcode].operands[1] == IA64_OPND_P1)))
        {
        {
          struct ia64_opcode *alias = tmalloc(struct ia64_opcode);
          struct ia64_opcode *alias = tmalloc(struct ia64_opcode);
          unsigned i;
          unsigned i;
 
 
          *alias = table[curr_opcode];
          *alias = table[curr_opcode];
          for (i = 2; i < NELEMS (alias->operands); ++i)
          for (i = 2; i < NELEMS (alias->operands); ++i)
            alias->operands[i - 1] = alias->operands[i];
            alias->operands[i - 1] = alias->operands[i];
          alias->operands[NELEMS (alias->operands) - 1] = IA64_OPND_NIL;
          alias->operands[NELEMS (alias->operands) - 1] = IA64_OPND_NIL;
          --alias->num_outputs;
          --alias->num_outputs;
          alias->flags |= PSEUDO;
          alias->flags |= PSEUDO;
          add_opcode_entry (alias);
          add_opcode_entry (alias);
        }
        }
    }
    }
}
}


 
 
/* Program options.  */
/* Program options.  */
#define OPTION_SRCDIR   200
#define OPTION_SRCDIR   200
 
 
struct option long_options[] =
struct option long_options[] =
{
{
  {"srcdir",  required_argument, NULL, OPTION_SRCDIR},
  {"srcdir",  required_argument, NULL, OPTION_SRCDIR},
  {"debug",   no_argument,       NULL, 'd'},
  {"debug",   no_argument,       NULL, 'd'},
  {"version", no_argument,       NULL, 'V'},
  {"version", no_argument,       NULL, 'V'},
  {"help",    no_argument,       NULL, 'h'},
  {"help",    no_argument,       NULL, 'h'},
  {0,         no_argument,       NULL, 0}
  {0,         no_argument,       NULL, 0}
};
};
 
 
static void
static void
print_version (void)
print_version (void)
{
{
  printf ("%s: version 1.0\n", program_name);
  printf ("%s: version 1.0\n", program_name);
  xexit (0);
  xexit (0);
}
}
 
 
static void
static void
usage (FILE * stream, int status)
usage (FILE * stream, int status)
{
{
  fprintf (stream, "Usage: %s [-V | --version] [-d | --debug] [--srcdir=dirname] [--help]\n",
  fprintf (stream, "Usage: %s [-V | --version] [-d | --debug] [--srcdir=dirname] [--help]\n",
           program_name);
           program_name);
  xexit (status);
  xexit (status);
}
}
 
 
int
int
main (int argc, char **argv)
main (int argc, char **argv)
{
{
  extern int chdir (char *);
  extern int chdir (char *);
  char *srcdir = NULL;
  char *srcdir = NULL;
  int c;
  int c;
 
 
  program_name = *argv;
  program_name = *argv;
  xmalloc_set_program_name (program_name);
  xmalloc_set_program_name (program_name);
 
 
  while ((c = getopt_long (argc, argv, "vVdh", long_options, 0)) != EOF)
  while ((c = getopt_long (argc, argv, "vVdh", long_options, 0)) != EOF)
    switch (c)
    switch (c)
      {
      {
      case OPTION_SRCDIR:
      case OPTION_SRCDIR:
        srcdir = optarg;
        srcdir = optarg;
        break;
        break;
      case 'V':
      case 'V':
      case 'v':
      case 'v':
        print_version ();
        print_version ();
        break;
        break;
      case 'd':
      case 'd':
        debug = 1;
        debug = 1;
        break;
        break;
      case 'h':
      case 'h':
      case '?':
      case '?':
        usage (stderr, 0);
        usage (stderr, 0);
      default:
      default:
      case 0:
      case 0:
        break;
        break;
      }
      }
 
 
  if (optind != argc)
  if (optind != argc)
    usage (stdout, 1);
    usage (stdout, 1);
 
 
  if (srcdir != NULL)
  if (srcdir != NULL)
    if (chdir (srcdir) != 0)
    if (chdir (srcdir) != 0)
      fail (_("unable to change directory to \"%s\", errno = %s\n"),
      fail (_("unable to change directory to \"%s\", errno = %s\n"),
            srcdir, strerror (errno));
            srcdir, strerror (errno));
 
 
  load_insn_classes ();
  load_insn_classes ();
  load_dependencies ();
  load_dependencies ();
 
 
  shrink (ia64_opcodes_a);
  shrink (ia64_opcodes_a);
  shrink (ia64_opcodes_b);
  shrink (ia64_opcodes_b);
  shrink (ia64_opcodes_f);
  shrink (ia64_opcodes_f);
  shrink (ia64_opcodes_i);
  shrink (ia64_opcodes_i);
  shrink (ia64_opcodes_m);
  shrink (ia64_opcodes_m);
  shrink (ia64_opcodes_x);
  shrink (ia64_opcodes_x);
  shrink (ia64_opcodes_d);
  shrink (ia64_opcodes_d);
 
 
  collapse_redundant_completers ();
  collapse_redundant_completers ();
 
 
  printf ("/* This file is automatically generated by ia64-gen.  Do not edit!  */\n");
  printf ("/* This file is automatically generated by ia64-gen.  Do not edit!  */\n");
  printf ("/* Copyright 2007  Free Software Foundation, Inc.\n\
  printf ("/* Copyright 2007  Free Software Foundation, Inc.\n\
\n\
\n\
   This file is part of the GNU opcodes library.\n\
   This file is part of the GNU opcodes library.\n\
\n\
\n\
   This library is free software; you can redistribute it and/or modify\n\
   This library is free software; you can redistribute it and/or modify\n\
   it under the terms of the GNU General Public License as published by\n\
   it under the terms of the GNU General Public License as published by\n\
   the Free Software Foundation; either version 3, or (at your option)\n\
   the Free Software Foundation; either version 3, or (at your option)\n\
   any later version.\n\
   any later version.\n\
\n\
\n\
   It is distributed in the hope that it will be useful, but WITHOUT\n\
   It is distributed in the hope that it will be useful, but WITHOUT\n\
   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY\n\
   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY\n\
   or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public\n\
   or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public\n\
   License for more details.\n\
   License for more details.\n\
\n\
\n\
   You should have received a copy of the GNU General Public License\n\
   You should have received a copy of the GNU General Public License\n\
   along with this program; see the file COPYING.  If not, write to the\n\
   along with this program; see the file COPYING.  If not, write to the\n\
   Free Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA\n\
   Free Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA\n\
   02110-1301, USA.  */\n");
   02110-1301, USA.  */\n");
 
 
  print_string_table ();
  print_string_table ();
  print_dependency_table ();
  print_dependency_table ();
  print_completer_table ();
  print_completer_table ();
  print_main_table ();
  print_main_table ();
 
 
  generate_disassembler ();
  generate_disassembler ();
 
 
  exit (0);
  exit (0);
}
}
 
 

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.