Index: gcc/genmatch.c
===================================================================
--- gcc/genmatch.c	(revision 215554)
+++ gcc/genmatch.c	(working copy)
@@ -31,6 +31,7 @@ along with GCC; see the file COPYING3.
 #include "vec.h"
 #include "is-a.h"
 
+
 /* libccp helpers.  */
 
 static struct line_maps *line_table;
@@ -112,26 +113,8 @@ output_line_directive (FILE *f, source_l
 }
 
 
-/* Grammar
-
-     capture = '@' number
-     op = predicate | expr [capture]
-     c_expr = '{' ... '}'
-     genexpr = '(' code genop... ')'
-     genop = capture | genexpr | c_expr
-     transform = 'match_and_transform' name expr genop
-
-     Match and simplify (A + B) - B -> A
-     (simplify foo
-       (PLUS_EXPR (MINUS_EXPR integral_op_p@0 @1) @1)
-       @0)
-
-     Match and simplify (CST + A) + CST to CST' + A
-     (simplify bar
-       (PLUS_EXPR INTEGER_CST_P@0 (PLUS_EXPR @1 INTEGER_CST_P@2))
-       (PLUS_EXPR { int_const_binop (PLUS_EXPR, captures[0], captures[2]); } @1))
-*/
-
+/* Pull in tree codes and builtin function codes from their
+   definition files.  */
 
 #define DEFTREECODE(SYM, STRING, TYPE, NARGS)   SYM,
 enum tree_code {
@@ -150,12 +133,12 @@ END_BUILTINS
 };
 #undef DEF_BUILTIN
 
-/* Hashtable of known pattern operators.  This is pre-seeded from
-   all known tree codes and all known builtin function ids.  */
+
+/* Base class for all identifiers the parser knows.  */
 
 struct id_base : typed_noop_remove<id_base>
 {
-  enum id_kind { CODE, FN, PREDICATE, USER_DEFINED } kind;
+  enum id_kind { CODE, FN, PREDICATE, USER } kind;
 
   id_base (id_kind, const char *, int = -1);
 
@@ -184,6 +167,8 @@ id_base::equal (const value_type *op1,
 	  && strcmp (op1->id, op2->id) == 0);
 }
 
+/* Hashtable of known pattern operators.  This is pre-seeded from
+   all known tree codes and all known builtin function ids.  */
 static hash_table<id_base> *operators;
 
 id_base::id_base (id_kind kind_, const char *id_, int nargs_)
@@ -194,6 +179,8 @@ id_base::id_base (id_kind kind_, const c
   hashval = htab_hash_string (id);
 }
 
+/* Identifier that maps to a tree code.  */
+
 struct operator_id : public id_base
 {
   operator_id (enum tree_code code_, const char *id_, unsigned nargs_,
@@ -203,6 +190,8 @@ struct operator_id : public id_base
   const char *tcc;
 };
 
+/* Identifier that maps to a builtin function code.  */
+
 struct fn_id : public id_base
 {
   fn_id (enum built_in_function fn_, const char *id_)
@@ -212,6 +201,8 @@ struct fn_id : public id_base
 
 struct simplify;
 
+/* Identifier that maps to a user-defined predicate.  */
+
 struct predicate_id : public id_base
 {
   predicate_id (const char *id_)
@@ -219,10 +210,12 @@ struct predicate_id : public id_base
   vec<simplify *> matchers;
 };
 
+/* Identifier that maps to a operator defined by a 'for' directive.  */
+
 struct user_id : public id_base
 {
   user_id (const char *id_)
-    : id_base (id_base::USER_DEFINED, id_), substitutes (vNULL) {}
+    : id_base (id_base::USER, id_), substitutes (vNULL) {}
   vec<id_base *> substitutes;
 };
 
@@ -250,6 +243,16 @@ is_a_helper <predicate_id *>::test (id_b
   return id->kind == id_base::PREDICATE;
 }
 
+template<>
+template<>
+inline bool
+is_a_helper <user_id *>::test (id_base *id)
+{
+  return id->kind == id_base::USER;
+}
+
+/* Add a predicate identifier to the hash.  */
+
 static predicate_id * 
 add_predicate (const char *id)
 {
@@ -261,6 +264,8 @@ add_predicate (const char *id)
   return p;
 }
 
+/* Add a tree code identifier to the hash.  */
+
 static void
 add_operator (enum tree_code code, const char *id,
 	      const char *tcc, unsigned nargs)
@@ -281,6 +286,8 @@ add_operator (enum tree_code code, const
   *slot = op;
 }
 
+/* Add a builtin identifier to the hash.  */
+
 static void
 add_builtin (enum built_in_function code, const char *id)
 {
@@ -291,35 +298,80 @@ add_builtin (enum built_in_function code
   *slot = fn;
 }
 
+/* Helper for easy comparing ID with tree code CODE.  */
+
 static bool
 operator==(id_base &id, enum tree_code code)
 {
-  if (id.kind != id_base::CODE)
-    return false;
-  return static_cast <operator_id&>(id).code == code;
+  if (operator_id *oid = dyn_cast <operator_id *> (&id))
+    return oid->code == code;
+  return false;
+}
+
+/* Lookup the identifier ID.  */
+
+id_base *
+get_operator (const char *id)
+{
+  id_base tem (id_base::CODE, id);
+
+  id_base *op = operators->find_with_hash (&tem, tem.hashval);
+  if (op)
+    return op; 
+
+  /* Try all-uppercase.  */
+  char *id2 = xstrdup (id);
+  for (unsigned i = 0; i < strlen (id2); ++i)
+    id2[i] = TOUPPER (id2[i]);
+  new (&tem) id_base (id_base::CODE, id2);
+  op = operators->find_with_hash (&tem, tem.hashval);
+  if (op)
+    {
+      free (id2);
+      return op;
+    }
+
+  /* Try _EXPR appended.  */
+  id2 = (char *)xrealloc (id2, strlen (id2) + sizeof ("_EXPR") + 1);
+  strcat (id2, "_EXPR");
+  new (&tem) id_base (id_base::CODE, id2);
+  op = operators->find_with_hash (&tem, tem.hashval);
+  if (op)
+    {
+      free (id2);
+      return op;
+    }
+
+  return 0;
 }
 
 
 
-/* The predicate expression tree structure.  */
+/* The AST produced by parsing of the pattern definitions.  */
 
 struct dt_operand;
 
+/* The base class for operands.  */
+
 struct operand {
   enum op_type { OP_PREDICATE, OP_EXPR, OP_CAPTURE, OP_C_EXPR };
   operand (enum op_type type_) : type (type_) {}
   enum op_type type;
-  virtual void gen_transform (FILE *f, const char *, bool, int, const char *, dt_operand ** = 0) = 0;
+  virtual void gen_transform (FILE *, const char *, bool, int,
+			      const char *, dt_operand ** = 0)
+    { gcc_unreachable  (); }
 };
 
+/* A predicate operand.  Predicates are leafs in the AST.  */
+
 struct predicate : public operand
 {
   predicate (predicate_id *p_) : operand (OP_PREDICATE), p (p_) {}
   predicate_id *p;
-  virtual void gen_transform (FILE *, const char *, bool, int, const char *, dt_operand ** = 0)
-    { gcc_unreachable (); }
 };
 
+/* An operand that constitutes an expression.  Expressions include
+   function calls and user-defined predicate invocations.  */
 
 struct expr : public operand
 {
@@ -327,41 +379,54 @@ struct expr : public operand
     : operand (OP_EXPR), operation (operation_),
       ops (vNULL), expr_type (NULL), is_commutative (is_commutative_) {}
   void append_op (operand *op) { ops.safe_push (op); }
+  /* The operator and its operands.  */
   id_base *operation;
   vec<operand *> ops;
+  /* An explicitely specified type - used exclusively for conversions.  */
   const char *expr_type;
+  /* Whether the operation is to be applied commutatively.  This is
+     later lowered to two separate patterns.  */
   bool is_commutative;
   virtual void gen_transform (FILE *f, const char *, bool, int, const char *, dt_operand ** = 0);
 };
 
+/* An operator that is represented by native C code.  This is always
+   a leaf operand in the AST.  This class is also used to represent
+   the code to be generated for 'if' and 'with' expressions.  */
+
 struct c_expr : public operand
 {
+  /* A mapping of an identifier and its replacement.  Used to apply
+     'for' lowering.  */
   struct id_tab {
     const char *id;
     const char *oper;
-
     id_tab (const char *id_, const char *oper_): id (id_), oper (oper_) {}
   };
 
-
   c_expr (cpp_reader *r_, vec<cpp_token> code_, unsigned nr_stmts_,
 	  vec<id_tab> ids_ = vNULL)
     : operand (OP_C_EXPR), r (r_), code (code_),
-      nr_stmts (nr_stmts_), fname (NULL), ids (ids_) {}
+      nr_stmts (nr_stmts_), ids (ids_) {}
+  /* cpplib tokens and state to transform this back to source.  */
   cpp_reader *r;
   vec<cpp_token> code;
+  /* The number of statements parsed (well, the number of ';'s).  */
   unsigned nr_stmts;
-  char *fname;
+  /* The identifier replacement vector.  */
   vec<id_tab> ids;
-
   virtual void gen_transform (FILE *f, const char *, bool, int, const char *, dt_operand **);
 };
 
+/* A wrapper around another operand that captures its value.  */
+
 struct capture : public operand
 {
   capture (const char *where_, operand *what_)
       : operand (OP_CAPTURE), where (where_), what (what_) {}
+  /* Identifier for the value.  */
   const char *where;
+  /* The captured value.  */
   operand *what;
   virtual void gen_transform (FILE *f, const char *, bool, int, const char *, dt_operand ** = 0);
 };
@@ -398,153 +463,48 @@ is_a_helper <expr *>::test (operand *op)
   return op->type == operand::OP_EXPR;
 }
 
-id_base *
-get_operator (const char *id)
-{
-  id_base tem (id_base::CODE, id);
-
-  id_base *op = operators->find_with_hash (&tem, tem.hashval);
-  if (op)
-    return op; 
+/* Helper to distinguish 'if' from 'with' expressions.  */
 
-   /* Try all-uppercase.  */
-  char *id2 = xstrdup (id);
-  for (unsigned i = 0; i < strlen (id2); ++i)
-    id2[i] = TOUPPER (id2[i]);
-  new (&tem) id_base (id_base::CODE, id2);
-  op = operators->find_with_hash (&tem, tem.hashval);
-  if (op)
-    {
-      free (id2);
-      return op;
-    }
-
-  /* Try _EXPR appended.  */
-  id2 = (char *)xrealloc (id2, strlen (id2) + sizeof ("_EXPR") + 1);
-  strcat (id2, "_EXPR");
-  new (&tem) id_base (id_base::CODE, id2);
-  op = operators->find_with_hash (&tem, tem.hashval);
-  if (op)
-    {
-      free (id2);
-      return op;
-    }
-
-  return 0;
-}
-
-struct if_or_with {
-    if_or_with (operand *cexpr_, source_location location_, bool is_with_)
-	: location (location_), cexpr (cexpr_), is_with (is_with_) {}
-    source_location location;
-    operand *cexpr;
-    bool is_with;
+struct if_or_with
+{
+  if_or_with (operand *cexpr_, source_location location_, bool is_with_)
+      : location (location_), cexpr (cexpr_), is_with (is_with_) {}
+  source_location location;
+  operand *cexpr;
+  bool is_with;
 };
 
-struct simplify {
+/* The main class of a pattern and its transform.  This is used to
+   represent both (simplify ...) and (match ...) kinds.  The AST
+   duplicates all outer 'if' and 'for' expressions here so each
+   simplify can exist in isolation.  */
+
+struct simplify
+{
   simplify (operand *match_, source_location match_location_,
-	    struct operand *result_, source_location result_location_, vec<if_or_with> ifexpr_vec_, vec<vec<user_id *> > for_vec_)
+	    struct operand *result_, source_location result_location_,
+	    vec<if_or_with> ifexpr_vec_, vec<vec<user_id *> > for_vec_)
       : match (match_), match_location (match_location_),
       result (result_), result_location (result_location_),
       ifexpr_vec (ifexpr_vec_), for_vec (for_vec_) {}
 
+  /* The expression that is matched against the GENERIC or GIMPLE IL.  */
   operand *match; 
   source_location match_location;
+  /* For a (simplify ...) the expression produced when the pattern applies.
+     For a (match ...) either NULL if it is a simple predicate or the
+     single expression specifying the matched operands.  */
   struct operand *result;
   source_location result_location;
+  /* Collected 'if' expressions that need to evaluate to true to make
+     the pattern apply.  */
   vec<if_or_with> ifexpr_vec;
+  /* Collected 'for' expression operators that have to be replaced
+     in the lowering phase.  */
   vec<vec<user_id *> > for_vec;
 };
 
-struct dt_node
-{
-  enum dt_type { DT_NODE, DT_OPERAND, DT_TRUE, DT_MATCH, DT_SIMPLIFY };
-
-  enum dt_type type;
-  unsigned level;
-  vec<dt_node *> kids;
-
-  dt_node (enum dt_type type_): type (type_), level (0), kids (vNULL) {} 
-  
-  dt_node *append_node (dt_node *); 
-  dt_node *append_op (operand *, dt_node *parent = 0, unsigned pos = 0); 
-  dt_node *append_true_op (dt_node *parent = 0, unsigned pos = 0);
-  dt_node *append_match_op (dt_operand *, dt_node *parent = 0, unsigned pos = 0);
-  dt_node *append_simplify (simplify *, unsigned, dt_operand **); 
-
-  virtual void gen_gimple (FILE *) {}
-  virtual void gen_generic (FILE *) {}
-
-  void gen_gimple_kids (FILE *);
-  void gen_generic_kids (FILE *);
-};
-
-struct dt_operand: public dt_node
-{
-  operand *op;
-  dt_operand *match_dop;
-  dt_operand *parent;
-  unsigned pos;
- 
-  dt_operand (enum dt_type type, operand *op_, dt_operand *match_dop_, dt_operand *parent_ = 0, unsigned pos_ = 0)
-	: dt_node (type), op (op_), match_dop (match_dop_), parent (parent_), pos (pos_) {}
-
-  virtual void gen_gimple (FILE *);
-  virtual void gen_generic (FILE *);
-  unsigned gen_predicate (FILE *, const char *, bool);
-  unsigned gen_match_op (FILE *, const char *);
-
-  unsigned gen_gimple_expr (FILE *);
-  unsigned gen_generic_expr (FILE *, const char *);
-
-  char *get_name (char *);
-  void gen_opname (char *, unsigned);
-};
-
-
-struct dt_simplify: public dt_node
-{
-  static const unsigned capture_max = 6;
-  simplify *s; 
-  unsigned pattern_no;
-  dt_operand *indexes[capture_max]; 
-  
-  dt_simplify (simplify *s_, unsigned pattern_no_, dt_operand **indexes_)
-	: dt_node (DT_SIMPLIFY), s (s_), pattern_no (pattern_no_)
-  {
-    for (unsigned i = 0; i < capture_max; ++i)
-      indexes[i] = indexes_[i];
-  }
-
-  void gen (FILE *f, bool);
-  virtual void gen_gimple (FILE *f) { gen (f, true); }
-  virtual void gen_generic (FILE *f) { gen (f, false); }
-};
-
-template<>
-template<>
-inline bool
-is_a_helper <dt_operand *>::test (dt_node *n)
-{
-  return n->type == dt_node::DT_OPERAND;
-}
-
-struct decision_tree
-{
-  dt_node *root;
-  
-  void insert (struct simplify *, unsigned); 
-  void gen_gimple (FILE *f = stderr);
-  void gen_generic (FILE *f = stderr);
-  void print (FILE *f = stderr);
-
-  decision_tree () { root = new dt_node (dt_node::DT_NODE); }
-
-  static dt_node *insert_operand (dt_node *, operand *, dt_operand **indexes, unsigned pos = 0, dt_node *parent = 0);
-  static dt_node *find_node (vec<dt_node *>&, dt_node *);
-  static bool cmp_node (dt_node *, dt_node *);
-  static void print_node (dt_node *, FILE *f = stderr, unsigned = 0);
-};
+/* Debugging routines for dumping the AST.  */
 
 DEBUG_FUNCTION void
 print_operand (operand *o, FILE *f = stderr, bool flattened = false)
@@ -594,7 +554,12 @@ print_matches (struct simplify *s, FILE
   putc ('\n', f);
 }
 
-void
+
+/* AST lowering.  */
+
+/* Lowering of commutative operators.  */
+
+static void
 cartesian_product (const vec< vec<operand *> >& ops_vector, vec< vec<operand *> >& result, vec<operand *>& v, unsigned n)
 {
   if (n == ops_vector.length ())
@@ -611,7 +576,7 @@ cartesian_product (const vec< vec<operan
     }
 }
  
-void
+static void
 cartesian_product (const vec< vec<operand *> >& ops_vector, vec< vec<operand *> >& result, unsigned n_ops)
 {
   vec<operand *> v = vNULL;
@@ -619,14 +584,13 @@ cartesian_product (const vec< vec<operan
   cartesian_product (ops_vector, result, v, 0);
 }
 
-vec<operand *>
+static vec<operand *>
 commutate (operand *op)
 {
   vec<operand *> ret = vNULL;
 
-  if (op->type == operand::OP_CAPTURE)
+  if (capture *c = dyn_cast <capture *> (op))
     {
-      capture *c = static_cast<capture *> (op);
       if (!c->what)
 	{
 	  ret.safe_push (op);
@@ -641,19 +605,13 @@ commutate (operand *op)
       return ret;	
     }
 
-  if (op->type != operand::OP_EXPR)
+  expr *e = dyn_cast <expr *> (op);
+  if (!e || e->ops.length () == 0)
     {
       ret.safe_push (op);
       return ret;
     }
 
-  expr *e = static_cast<expr *> (op);
-  if (e->ops.length () == 0)
-    {
-      ret.safe_push (e);
-      return ret;
-    }
-
   vec< vec<operand *> > ops_vector = vNULL;
   for (unsigned i = 0; i < e->ops.length (); ++i)
     ops_vector.safe_push (commutate (e->ops[i]));
@@ -684,7 +642,7 @@ commutate (operand *op)
   return ret;
 }
 
-void
+static void
 lower_commutative (simplify *s, vec<simplify *>& simplifiers)
 {
   vec<operand *> matchers = commutate (s->match);
@@ -697,7 +655,9 @@ lower_commutative (simplify *s, vec<simp
     }
 }
 
-operand *
+/* Lowering of conditional converts.  */
+
+static operand *
 lower_opt_convert (operand *o, enum tree_code oper)
 {
   if (capture *c = dyn_cast<capture *> (o))  
@@ -708,10 +668,10 @@ lower_opt_convert (operand *o, enum tree
 	return c;
     }
 
-  if (!is_a<expr *> (o))
+  expr *e = dyn_cast<expr *> (o);
+  if (!e)
     return o;
 
-  expr *e = as_a<expr *> (o);
   if (*e->operation == oper)
     {
       expr *ne = new expr (get_operator ("CONVERT_EXPR"));
@@ -737,10 +697,10 @@ remove_opt_convert (operand *o, enum tre
 	return c;
     }
 
-  if (!is_a<expr *> (o))
+  expr *e = as_a<expr *> (o);
+  if (!e)
     return o;
 
-  expr *e = as_a<expr *> (o);
   if (*e->operation == oper)
     return remove_opt_convert (e->ops[0], oper);
 
@@ -751,7 +711,7 @@ remove_opt_convert (operand *o, enum tre
   return ne;
 }
 
-bool
+static bool
 has_opt_convert (operand *o, enum tree_code oper)
 {
   if (capture *c = dyn_cast<capture *> (o))
@@ -762,11 +722,10 @@ has_opt_convert (operand *o, enum tree_c
 	return false;
     }
 
-  if (!is_a<expr *> (o))
+  expr *e = dyn_cast<expr *> (o);
+  if (!e)
     return false;
 
-  expr *e = as_a<expr *> (o);
-  
   if (*e->operation == oper)
     return true;
 
@@ -777,7 +736,7 @@ has_opt_convert (operand *o, enum tree_c
   return false;
 }
 
-void
+static void
 lower_opt_convert (vec<operand *>& v, operand *o, enum tree_code oper) 
 {
   if (has_opt_convert (o, oper))
@@ -787,7 +746,7 @@ lower_opt_convert (vec<operand *>& v, op
     }
 }
 
-vec<operand *>
+static vec<operand *>
 lower_opt_convert (operand *o)
 {
   vec<operand *> v1 = vNULL, v2;
@@ -813,7 +772,7 @@ lower_opt_convert (operand *o)
   return v1;
 }
 
-void
+static void
 lower_opt_convert (simplify *s, vec<simplify *>& simplifiers)
 {
   vec<operand *> matchers = lower_opt_convert (s->match);
@@ -862,7 +821,7 @@ replace_id (operand *o, user_id *id, id_
 
 /* Lower recorded fors for SIN and output to SIMPLIFIERS.  */
 
-void
+static void
 lower_for (simplify *sin, vec<simplify *>& simplifiers)
 {
   vec<vec<user_id *> >& for_vec = sin->for_vec;
@@ -918,219 +877,123 @@ lower_for (simplify *sin, vec<simplify *
     simplifiers.safe_push (worklist[i]);
 }
 
-bool
-is_conversion (id_base *op)
+/* Lower the AST for everything in SIMPLIFIERS.  */
+
+static void
+lower (vec<simplify *>& simplifiers)
 {
-  return (*op == CONVERT_EXPR
-	  || *op == NOP_EXPR
-	  || *op == FLOAT_EXPR
-	  || *op == FIX_TRUNC_EXPR
-	  || *op == VIEW_CONVERT_EXPR);
-}
+  auto_vec<simplify *> out_simplifiers0;
+  for (unsigned i = 0; i < simplifiers.length (); ++i)
+    lower_opt_convert (simplifiers[i], out_simplifiers0);
 
-/* Get the type to be used for generating operands of OP from the
-   various sources.  */
+  auto_vec<simplify *> out_simplifiers1;
+  for (unsigned i = 0; i < out_simplifiers0.length (); ++i)
+    lower_commutative (out_simplifiers0[i], out_simplifiers1);
 
-static const char *
-get_operand_type (id_base *op, const char *in_type,
-		  const char *expr_type,
-		  const char *other_oprnd_type)
-{
-  /* Generally operands whose type does not match the type of the
-     expression generated need to know their types but match and
-     thus can fall back to 'other_oprnd_type'.  */
-  if (is_conversion (op))
-    return other_oprnd_type;
-  else if (*op == REALPART_EXPR
-	   || *op == IMAGPART_EXPR)
-    return other_oprnd_type;
-  else if (is_a <operator_id *> (op)
-	   && strcmp (as_a <operator_id *> (op)->tcc, "tcc_comparison") == 0)
-    return other_oprnd_type;
-  else
-    {
-      /* Otherwise all types should match - choose one in order of
-         preference.  */
-      if (expr_type)
-	return expr_type;
-      else if (in_type)
-	return in_type;
-      else
-	return other_oprnd_type;
-    }
+  simplifiers.truncate (0);
+  for (unsigned i = 0; i < out_simplifiers1.length (); ++i)
+    lower_for (out_simplifiers1[i], simplifiers);
 }
 
-/* Code gen off the AST.  */
 
-void
-expr::gen_transform (FILE *f, const char *dest, bool gimple, int depth,
-		     const char *in_type, dt_operand **indexes)
+
+
+/* The decision tree built for generating GIMPLE and GENERIC pattern
+   matching code.  It represents the 'match' expression of all
+   simplifies and has those as its leafs.  */
+
+struct dt_node
 {
-  bool conversion_p = is_conversion (operation);
-  const char *type = expr_type;
-  char optype[64];
-  if (type)
-    /* If there was a type specification in the pattern use it.  */
-    ;
-  else if (conversion_p)
-    /* For conversions we need to build the expression using the
-       outer type passed in.  */
-    type = in_type;
-  else if (*operation == REALPART_EXPR
-	   || *operation == IMAGPART_EXPR)
-    {
-      /* __real and __imag use the component type of its operand.  */
-      sprintf (optype, "TREE_TYPE (TREE_TYPE (ops%d[0]))", depth);
-      type = optype;
-    }
-  else if (is_a <operator_id *> (operation)
-	   && strcmp (as_a <operator_id *> (operation)->tcc, "tcc_comparison") == 0)
-    {
-      /* comparisons use boolean_type_node (or what gets in), but
-         their operands need to figure out the types themselves.  */
-      sprintf (optype, "boolean_type_node");
-      type = optype;
-    }
-  else
-    {
-      /* Other operations are of the same type as their first operand.  */
-      sprintf (optype, "TREE_TYPE (ops%d[0])", depth);
-      type = optype;
-    }
-  if (!type)
-    fatal ("two conversions in a row");
+  enum dt_type { DT_NODE, DT_OPERAND, DT_TRUE, DT_MATCH, DT_SIMPLIFY };
 
-  fprintf (f, "{\n");
-  fprintf (f, "  tree ops%d[%u], res;\n", depth, ops.length ());
-  char op0type[64];
-  snprintf (op0type, 64, "TREE_TYPE (ops%d[0])", depth);
-  for (unsigned i = 0; i < ops.length (); ++i)
-    {
-      char dest[32];
-      snprintf (dest, 32, "  ops%d[%u]", depth, i);
-      const char *optype
-	= get_operand_type (operation, in_type, expr_type,
-			    i == 0 ? NULL : op0type);
-      ops[i]->gen_transform (f, dest, gimple, depth + 1, optype, indexes);
-    }
+  enum dt_type type;
+  unsigned level;
+  vec<dt_node *> kids;
 
-  if (gimple)
-    {
-      /* ???  Have another helper that is like gimple_build but may
-	 fail if seq == NULL.  */
-      fprintf (f, "  if (!seq)\n"
-	       "    {\n"
-	       "      res = gimple_simplify (%s, %s",
-	       operation->id, type);
-      for (unsigned i = 0; i < ops.length (); ++i)
-	fprintf (f, ", ops%d[%u]", depth, i);
-      fprintf (f, ", seq, valueize);\n");
-      fprintf (f, "      if (!res) return false;\n");
-      fprintf (f, "    }\n");
-      fprintf (f, "  else\n");
-      fprintf (f, "    res = gimple_build (seq, UNKNOWN_LOCATION, %s, %s",
-	       operation->id, type);
-      for (unsigned i = 0; i < ops.length (); ++i)
-	fprintf (f, ", ops%d[%u]", depth, i);
-      fprintf (f, ", valueize);\n");
-    }
-  else
-    {
-      if (operation->kind == id_base::CODE)
-	fprintf (f, "  res = fold_build%d (%s, %s",
-		 ops.length(), operation->id, type);
-      else
-	fprintf (f, "  res = build_call_expr (builtin_decl_implicit (%s), %d",
-		 operation->id, ops.length());
-      for (unsigned i = 0; i < ops.length (); ++i)
-	fprintf (f, ", ops%d[%u]", depth, i);
-      fprintf (f, ");\n");
-    }
-  fprintf (f, "  %s = res;\n", dest);
-  fprintf (f, "}\n");
-}
+  dt_node (enum dt_type type_): type (type_), level (0), kids (vNULL) {} 
+  
+  dt_node *append_node (dt_node *); 
+  dt_node *append_op (operand *, dt_node *parent = 0, unsigned pos = 0); 
+  dt_node *append_true_op (dt_node *parent = 0, unsigned pos = 0);
+  dt_node *append_match_op (dt_operand *, dt_node *parent = 0, unsigned pos = 0);
+  dt_node *append_simplify (simplify *, unsigned, dt_operand **); 
 
-/* Generate code for a c_expr which is either the expression inside
-   an if statement or a sequence of statements which computes a
-   result to be stored to DEST.  */
+  virtual void gen_gimple (FILE *) {}
+  virtual void gen_generic (FILE *) {}
 
-void
-c_expr::gen_transform (FILE *f, const char *dest,
-		       bool, int, const char *, dt_operand **)
+  void gen_gimple_kids (FILE *);
+  void gen_generic_kids (FILE *);
+};
+
+struct dt_operand : public dt_node
 {
-  if (dest && nr_stmts == 1)
-    fprintf (f, "%s = ", dest);
+  operand *op;
+  dt_operand *match_dop;
+  dt_operand *parent;
+  unsigned pos;
+ 
+  dt_operand (enum dt_type type, operand *op_, dt_operand *match_dop_,
+	      dt_operand *parent_ = 0, unsigned pos_ = 0)
+      : dt_node (type), op (op_), match_dop (match_dop_),
+      parent (parent_), pos (pos_) {}
 
-  unsigned stmt_nr = 1;
-  for (unsigned i = 0; i < code.length (); ++i)
-    {
-      const cpp_token *token = &code[i];
+  virtual void gen_gimple (FILE *);
+  virtual void gen_generic (FILE *);
+  unsigned gen_predicate (FILE *, const char *, bool);
+  unsigned gen_match_op (FILE *, const char *);
 
-      /* Replace captures for code-gen.  */
-      if (token->type == CPP_ATSIGN)
-	{
-	  const cpp_token *n = &code[i+1];
-	  if (n->type == CPP_NUMBER
-	      && !(n->flags & PREV_WHITE))
-	    {
-	      if (token->flags & PREV_WHITE)
-		fputc (' ', f);
-	      fprintf (f, "captures[%s]", n->val.str.text);
-	      ++i;
-	      continue;
-	    }
-	}
+  unsigned gen_gimple_expr (FILE *);
+  unsigned gen_generic_expr (FILE *, const char *);
 
-      if (token->flags & PREV_WHITE)
-	fputc (' ', f);
+  char *get_name (char *);
+  void gen_opname (char *, unsigned);
+};
 
-      if (token->type == CPP_NAME)
-	{
-	  const char *id = (const char *) NODE_NAME (token->val.node.node);
-	  unsigned j;
-	  for (j = 0; j < ids.length (); ++j)
-	    {
-	    if (strcmp (id, ids[j].id) == 0)
-	      {
-		fprintf (f, "%s", ids[j].oper);
-		break;
-	      }
-	    }
-	  if (j < ids.length ())
-	    continue;
-	}
+struct dt_simplify : public dt_node
+{
+  static const unsigned capture_max = 6;
+  simplify *s; 
+  unsigned pattern_no;
+  dt_operand *indexes[capture_max]; 
+  
+  dt_simplify (simplify *s_, unsigned pattern_no_, dt_operand **indexes_)
+	: dt_node (DT_SIMPLIFY), s (s_), pattern_no (pattern_no_)
+  {
+    for (unsigned i = 0; i < capture_max; ++i)
+      indexes[i] = indexes_[i];
+  }
 
-      /* Output the token as string.  */
-      char *tk = (char *)cpp_token_as_text (r, token);
-      fputs (tk, f);
+  void gen (FILE *f, bool);
+  virtual void gen_gimple (FILE *f) { gen (f, true); }
+  virtual void gen_generic (FILE *f) { gen (f, false); }
+};
 
-      if (token->type == CPP_SEMICOLON)
-	{
-	  stmt_nr++;
-	  if (dest && stmt_nr == nr_stmts)
-	    fprintf (f, "\n %s = ", dest);
-	  else
-	    fputc ('\n', f);
-	}
-    }
+template<>
+template<>
+inline bool
+is_a_helper <dt_operand *>::test (dt_node *n)
+{
+  return (n->type == dt_node::DT_OPERAND 
+	  || n->type == dt_node::DT_MATCH);
 }
 
-void
-capture::gen_transform (FILE *f, const char *dest, bool gimple, int depth, const char *in_type, dt_operand **indexes)
+struct decision_tree
 {
-  if (what && is_a<expr *> (what))
-    {
-      int index = atoi (where);
-      if (indexes[index] == 0)
-	{
-	  char buf[20];
-	  sprintf (buf, "captures[%s]", where);
-	  what->gen_transform (f, buf, gimple, depth, in_type, NULL);
-	}
-    }
-	   
-  fprintf (f, "%s = captures[%s];\n", dest, where); 
-}
+  dt_node *root;
+  
+  void insert (struct simplify *, unsigned); 
+  void gen_gimple (FILE *f = stderr);
+  void gen_generic (FILE *f = stderr);
+  void print (FILE *f = stderr);
+
+  decision_tree () { root = new dt_node (dt_node::DT_NODE); }
+
+  static dt_node *insert_operand (dt_node *, operand *, dt_operand **indexes,
+				  unsigned pos = 0, dt_node *parent = 0);
+  static dt_node *find_node (vec<dt_node *>&, dt_node *);
+  static bool cmp_node (dt_node *, dt_node *);
+  static void print_node (dt_node *, FILE *f = stderr, unsigned = 0);
+};
 
 bool
 cmp_operand (operand *o1, operand *o2)
@@ -1148,31 +1011,28 @@ cmp_operand (operand *o1, operand *o2)
     {
       expr *e1 = static_cast<expr *>(o1);
       expr *e2 = static_cast<expr *>(o2);
-      return strcmp (e1->operation->id, e2->operation->id) == 0;
+      return e1->operation == e2->operation;
     }
   else
     return false;
 }
 
-
 bool
 decision_tree::cmp_node (dt_node *n1, dt_node *n2)
 {
   if (!n1 || !n2 || n1->type != n2->type)
     return false;
 
-
   if (n1 == n2 || n1->type == dt_node::DT_TRUE)
     return true;
 
   if (n1->type == dt_node::DT_OPERAND)
-    return cmp_operand ((static_cast<dt_operand *> (n1))->op, (static_cast<dt_operand *> (n2))->op);
-
+    return cmp_operand ((as_a<dt_operand *> (n1))->op,
+			(as_a<dt_operand *> (n2))->op);
   else if (n1->type == dt_node::DT_MATCH)
-    return (static_cast<dt_operand *> (n1))->match_dop == (static_cast<dt_operand *> (n2))->match_dop;
-
-  else
-    return false;
+    return ((as_a<dt_operand *> (n1))->match_dop
+	    == (as_a<dt_operand *> (n2))->match_dop);
+  return false;
 }
 
 dt_node *
@@ -1212,7 +1072,7 @@ dt_node::append_node (dt_node *n)
 dt_node *
 dt_node::append_op (operand *op, dt_node *parent, unsigned pos)
 {
-  dt_operand *parent_ = static_cast<dt_operand *> (parent);
+  dt_operand *parent_ = safe_as_a<dt_operand *> (parent);
   dt_node *n = new dt_operand (DT_OPERAND, op, 0, parent_, pos);
   dt_node *p = append_node (n);
 
@@ -1225,7 +1085,7 @@ dt_node::append_op (operand *op, dt_node
 dt_node *
 dt_node::append_true_op (dt_node *parent, unsigned pos)
 {
-  dt_operand *parent_ = static_cast<dt_operand *> (parent);
+  dt_operand *parent_ = as_a<dt_operand *> (parent);
   dt_node *n = new dt_operand (DT_TRUE, 0, 0, parent_, pos);
   dt_node *p = append_node (n);
 
@@ -1260,9 +1120,8 @@ decision_tree::insert_operand (dt_node *
 {
   dt_node *q, *elm = 0;
 
-  if (o->type == operand::OP_CAPTURE)
+  if (capture *c = dyn_cast<capture *> (o))
     {
-      capture *c = static_cast<capture *> (o);
       unsigned capt_index = atoi (c->where);
 
       if (indexes[capt_index] == 0)
@@ -1275,10 +1134,12 @@ decision_tree::insert_operand (dt_node *
 	      goto at_assert_elm;
 	    }
 	  // get to the last capture
-	  for (operand *what = c->what; what && is_a<capture *> (what); c = as_a<capture *> (what), what = c->what)
+	  for (operand *what = c->what;
+	       what && is_a<capture *> (what);
+	       c = as_a<capture *> (what), what = c->what)
 	    ;
 
-	  if (c->what == 0)
+	  if (!c->what)
 	    {
 	      unsigned cc_index = atoi (c->where);
 	      dt_operand *match_op = indexes[cc_index];
@@ -1297,13 +1158,14 @@ decision_tree::insert_operand (dt_node *
 	      dt_operand temp (dt_node::DT_OPERAND, c->what, 0);
 	      elm = decision_tree::find_node (p->kids, &temp);
 	    }
-	    
+
 at_assert_elm:
-	gcc_assert (elm);
-	gcc_assert (elm->type == dt_node::DT_TRUE || elm->type == dt_node::DT_OPERAND || elm->type == dt_node::DT_MATCH);
-	indexes[capt_index] = static_cast<dt_operand *> (elm);
-	return q;
-      }
+	  gcc_assert (elm->type == dt_node::DT_TRUE
+		      || elm->type == dt_node::DT_OPERAND
+		      || elm->type == dt_node::DT_MATCH);
+	  indexes[capt_index] = static_cast<dt_operand *> (elm);
+	  return q;
+	}
       else
 	{
 	  p = p->append_match_op (indexes[capt_index], parent, pos);
@@ -1316,11 +1178,10 @@ at_assert_elm:
   p = p->append_op (o, parent, pos);
   q = p;
 
-  if (o->type == operand::OP_EXPR)
+  if (expr *e = dyn_cast <expr *>(o))
     {
-      expr *e = static_cast<expr *> (o);
       for (unsigned i = 0; i < e->ops.length (); ++i)
-	q = decision_tree::insert_operand (q, e->ops[i], indexes, i, p);		
+	q = decision_tree::insert_operand (q, e->ops[i], indexes, i, p);
     }
 
   return q;
@@ -1341,6 +1202,8 @@ decision_tree::insert (struct simplify *
   p->append_simplify (s, pattern_no, indexes);
 }
 
+/* Debug functions to dump the decision tree.  */
+
 DEBUG_FUNCTION void
 decision_tree::print_node (dt_node *p, FILE *f, unsigned indent)
 {
@@ -1377,13 +1240,228 @@ decision_tree::print_node (dt_node *p, F
     decision_tree::print_node (p->kids[i], f, indent + 2);
 }
 
-
 DEBUG_FUNCTION void
 decision_tree::print (FILE *f)
 {
   return decision_tree::print_node (root, f);
 }
 
+
+
+/* Code generation off the decision tree and the refered AST nodes.  */
+
+bool
+is_conversion (id_base *op)
+{
+  return (*op == CONVERT_EXPR
+	  || *op == NOP_EXPR
+	  || *op == FLOAT_EXPR
+	  || *op == FIX_TRUNC_EXPR
+	  || *op == VIEW_CONVERT_EXPR);
+}
+
+/* Get the type to be used for generating operands of OP from the
+   various sources.  */
+
+static const char *
+get_operand_type (id_base *op, const char *in_type,
+		  const char *expr_type,
+		  const char *other_oprnd_type)
+{
+  /* Generally operands whose type does not match the type of the
+     expression generated need to know their types but match and
+     thus can fall back to 'other_oprnd_type'.  */
+  if (is_conversion (op))
+    return other_oprnd_type;
+  else if (*op == REALPART_EXPR
+	   || *op == IMAGPART_EXPR)
+    return other_oprnd_type;
+  else if (is_a <operator_id *> (op)
+	   && strcmp (as_a <operator_id *> (op)->tcc, "tcc_comparison") == 0)
+    return other_oprnd_type;
+  else
+    {
+      /* Otherwise all types should match - choose one in order of
+         preference.  */
+      if (expr_type)
+	return expr_type;
+      else if (in_type)
+	return in_type;
+      else
+	return other_oprnd_type;
+    }
+}
+
+void
+expr::gen_transform (FILE *f, const char *dest, bool gimple, int depth,
+		     const char *in_type, dt_operand **indexes)
+{
+  bool conversion_p = is_conversion (operation);
+  const char *type = expr_type;
+  char optype[64];
+  if (type)
+    /* If there was a type specification in the pattern use it.  */
+    ;
+  else if (conversion_p)
+    /* For conversions we need to build the expression using the
+       outer type passed in.  */
+    type = in_type;
+  else if (*operation == REALPART_EXPR
+	   || *operation == IMAGPART_EXPR)
+    {
+      /* __real and __imag use the component type of its operand.  */
+      sprintf (optype, "TREE_TYPE (TREE_TYPE (ops%d[0]))", depth);
+      type = optype;
+    }
+  else if (is_a <operator_id *> (operation)
+	   && strcmp (as_a <operator_id *> (operation)->tcc, "tcc_comparison") == 0)
+    {
+      /* comparisons use boolean_type_node (or what gets in), but
+         their operands need to figure out the types themselves.  */
+      sprintf (optype, "boolean_type_node");
+      type = optype;
+    }
+  else
+    {
+      /* Other operations are of the same type as their first operand.  */
+      sprintf (optype, "TREE_TYPE (ops%d[0])", depth);
+      type = optype;
+    }
+  if (!type)
+    fatal ("two conversions in a row");
+
+  fprintf (f, "{\n");
+  fprintf (f, "  tree ops%d[%u], res;\n", depth, ops.length ());
+  char op0type[64];
+  snprintf (op0type, 64, "TREE_TYPE (ops%d[0])", depth);
+  for (unsigned i = 0; i < ops.length (); ++i)
+    {
+      char dest[32];
+      snprintf (dest, 32, "  ops%d[%u]", depth, i);
+      const char *optype
+	= get_operand_type (operation, in_type, expr_type,
+			    i == 0 ? NULL : op0type);
+      ops[i]->gen_transform (f, dest, gimple, depth + 1, optype, indexes);
+    }
+
+  if (gimple)
+    {
+      /* ???  Have another helper that is like gimple_build but may
+	 fail if seq == NULL.  */
+      fprintf (f, "  if (!seq)\n"
+	       "    {\n"
+	       "      res = gimple_simplify (%s, %s",
+	       operation->id, type);
+      for (unsigned i = 0; i < ops.length (); ++i)
+	fprintf (f, ", ops%d[%u]", depth, i);
+      fprintf (f, ", seq, valueize);\n");
+      fprintf (f, "      if (!res) return false;\n");
+      fprintf (f, "    }\n");
+      fprintf (f, "  else\n");
+      fprintf (f, "    res = gimple_build (seq, UNKNOWN_LOCATION, %s, %s",
+	       operation->id, type);
+      for (unsigned i = 0; i < ops.length (); ++i)
+	fprintf (f, ", ops%d[%u]", depth, i);
+      fprintf (f, ", valueize);\n");
+    }
+  else
+    {
+      if (operation->kind == id_base::CODE)
+	fprintf (f, "  res = fold_build%d (%s, %s",
+		 ops.length(), operation->id, type);
+      else
+	fprintf (f, "  res = build_call_expr (builtin_decl_implicit (%s), %d",
+		 operation->id, ops.length());
+      for (unsigned i = 0; i < ops.length (); ++i)
+	fprintf (f, ", ops%d[%u]", depth, i);
+      fprintf (f, ");\n");
+    }
+  fprintf (f, "  %s = res;\n", dest);
+  fprintf (f, "}\n");
+}
+
+/* Generate code for a c_expr which is either the expression inside
+   an if statement or a sequence of statements which computes a
+   result to be stored to DEST.  */
+
+void
+c_expr::gen_transform (FILE *f, const char *dest,
+		       bool, int, const char *, dt_operand **)
+{
+  if (dest && nr_stmts == 1)
+    fprintf (f, "%s = ", dest);
+
+  unsigned stmt_nr = 1;
+  for (unsigned i = 0; i < code.length (); ++i)
+    {
+      const cpp_token *token = &code[i];
+
+      /* Replace captures for code-gen.  */
+      if (token->type == CPP_ATSIGN)
+	{
+	  const cpp_token *n = &code[i+1];
+	  if (n->type == CPP_NUMBER
+	      && !(n->flags & PREV_WHITE))
+	    {
+	      if (token->flags & PREV_WHITE)
+		fputc (' ', f);
+	      fprintf (f, "captures[%s]", n->val.str.text);
+	      ++i;
+	      continue;
+	    }
+	}
+
+      if (token->flags & PREV_WHITE)
+	fputc (' ', f);
+
+      if (token->type == CPP_NAME)
+	{
+	  const char *id = (const char *) NODE_NAME (token->val.node.node);
+	  unsigned j;
+	  for (j = 0; j < ids.length (); ++j)
+	    {
+	    if (strcmp (id, ids[j].id) == 0)
+	      {
+		fprintf (f, "%s", ids[j].oper);
+		break;
+	      }
+	    }
+	  if (j < ids.length ())
+	    continue;
+	}
+
+      /* Output the token as string.  */
+      char *tk = (char *)cpp_token_as_text (r, token);
+      fputs (tk, f);
+
+      if (token->type == CPP_SEMICOLON)
+	{
+	  stmt_nr++;
+	  if (dest && stmt_nr == nr_stmts)
+	    fprintf (f, "\n %s = ", dest);
+	  else
+	    fputc ('\n', f);
+	}
+    }
+}
+
+void
+capture::gen_transform (FILE *f, const char *dest, bool gimple, int depth, const char *in_type, dt_operand **indexes)
+{
+  if (what && is_a<expr *> (what))
+    {
+      int index = atoi (where);
+      if (indexes[index] == 0)
+	{
+	  char buf[20];
+	  sprintf (buf, "captures[%s]", where);
+	  what->gen_transform (f, buf, gimple, depth, in_type, NULL);
+	}
+    }
+	   
+  fprintf (f, "%s = captures[%s];\n", dest, where); 
+}
+
 char *
 dt_operand::get_name (char *name)
 {
@@ -1515,8 +1593,9 @@ dt_node::gen_gimple_kids (FILE *f)
   dt_node *true_operand = NULL;
   for (unsigned i = 0; i < kids.length (); ++i)
     {
-      if (dt_operand *op = dyn_cast <dt_operand *> (kids[i]))
+      if (kids[i]->type == dt_node::DT_OPERAND)
 	{
+	  dt_operand *op = as_a<dt_operand *> (kids[i]);
 	  if (expr *e = dyn_cast <expr *> (op->op))
 	    {
 	      if (e->ops.length () == 0)
@@ -1856,13 +1935,17 @@ dt_node::gen_generic_kids (FILE *f)
     }
 }
 
+/* Generate code for the '(if ...)', '(with ..)' and actual transform
+   step of a '(simplify ...)' or '(match ...)'.  This handles everything
+   that is not part of the decision tree (simplify->match).  */
 
 void
 dt_simplify::gen (FILE *f, bool gimple)
 {
   fprintf (f, "{\n");
   output_line_directive (f, s->result_location);
-  fprintf (f, "tree captures[%u] ATTRIBUTE_UNUSED = {};\n", dt_simplify::capture_max);
+  fprintf (f, "tree captures[%u] ATTRIBUTE_UNUSED = {};\n",
+	   dt_simplify::capture_max);
 
   for (unsigned i = 0; i < dt_simplify::capture_max; ++i)
     if (indexes[i])
@@ -2021,6 +2104,8 @@ dt_simplify::gen (FILE *f, bool gimple)
   fprintf (f, "}\n");
 }
 
+/* Main entry to generate code for matching GIMPLE IL off the decision
+   tree.  */
 
 void
 decision_tree::gen_gimple (FILE *f)
@@ -2065,6 +2150,8 @@ decision_tree::gen_gimple (FILE *f)
     }
 }
 
+/* Main entry to generate code for matching GENERIC IL off the decision
+   tree.  */
 
 void
 decision_tree::gen_generic (FILE *f)
@@ -2072,7 +2159,8 @@ decision_tree::gen_generic (FILE *f)
   for (unsigned n = 1; n <= 3; ++n)
     {
       fprintf (f, "\ntree\n"
-	       "generic_simplify (enum tree_code code, tree type ATTRIBUTE_UNUSED");
+	       "generic_simplify (enum tree_code code, "
+	       "tree type ATTRIBUTE_UNUSED");
       for (unsigned i = 0; i < n; ++i)
 	fprintf (f, ", tree op%d", i);
       fprintf (f, ")\n");
@@ -2122,6 +2210,8 @@ decision_tree::gen_generic (FILE *f)
     }
 }
 
+/* Write a prototype for the function defined by the predicate P.  */
+
 void
 write_predicate_prototype (FILE *f, predicate_id *p, bool gimple)
 {
@@ -2131,6 +2221,8 @@ write_predicate_prototype (FILE *f, pred
 	   gimple ? ", tree (*valueize)(tree) = NULL" : "");
 }
 
+/* Output code to implement the predicate P from the decision tree DT.  */
+
 void
 write_predicate (FILE *f, predicate_id *p, decision_tree &dt, bool gimple)
 {
@@ -2156,6 +2248,7 @@ write_predicate (FILE *f, predicate_id *
 	   "}\n");
 }
 
+/* Write the common header for the GIMPLE/GENERIC IL matching routines.  */
 
 static void
 write_header (FILE *f, const char *head)
@@ -2168,6 +2261,9 @@ write_header (FILE *f, const char *head)
 }
 
 
+
+/* Lexing helpers.  */
+
 /* Read the next non-whitespace token from R.  */
 
 static const cpp_token *
@@ -2204,6 +2300,9 @@ peek (cpp_reader *r)
   return token;
 }
 
+/* Peek at the next identifier token (or return NULL if the next
+   token is not an identifier or equal to ID if supplied).  */
+
 static const cpp_token *
 peek_ident (cpp_reader *r, const char *id = 0)
 {
@@ -2262,14 +2361,15 @@ get_ident (cpp_reader *r)
   return (const char *)CPP_HASHNODE (token->val.node.node)->ident.str;
 }
 
+/* Eat an identifier token with value S from R.  */
+
 static void
 eat_ident (cpp_reader *r, const char *s)
 {
-  const cpp_token *token = expect (r, CPP_NAME);
-  const char *t = (const char *) CPP_HASHNODE (token->val.node.node)->ident.str;
-
-  if (strcmp (s, t)) 
-    fatal_at (token, "expected %s got %s\n", s, t);
+  const cpp_token *token = peek (r);
+  const char *t = get_ident (r);
+  if (strcmp (s, t) != 0) 
+    fatal_at (token, "expected '%s' got '%s'\n", s, t);
 }
 
 /* Read the next token from R and assert it is of type CPP_NUMBER and
@@ -2283,7 +2383,9 @@ get_number (cpp_reader *r)
 }
 
 
-/* Parsing.  */
+/* AST parsing routines.  */
+
+static struct operand * parse_op (cpp_reader *r);
 
 /* Parse the operator ID, special-casing convert?, convert1? and
    convert2?  */
@@ -2318,7 +2420,8 @@ parse_operation (cpp_reader *r)
   return op;
 }
 
-static struct operand * parse_op (cpp_reader *r);
+/* Parse a capture.
+     capture = '@'<number>  */
 
 static struct operand *
 parse_capture (cpp_reader *r, operand *op)
@@ -2327,9 +2430,9 @@ parse_capture (cpp_reader *r, operand *o
   return new capture (get_number (r), op);
 }
 
+/* Parse an expression
+     expr = '(' <operation>[capture][flag][type] <operand>... ')'  */
 
-/* Parse
-     expr = (operation[capture] op...)  */
 static struct operand *
 parse_expr (cpp_reader *r)
 {
@@ -2379,7 +2482,8 @@ parse_expr (cpp_reader *r)
 	      if (e->ops.length () == 2)
 		e->is_commutative = true;
 	      else
-		fatal_at (token, "only binary operators or function with two arguments can be marked commutative");
+		fatal_at (token, "only binary operators or function with "
+			  "two arguments can be marked commutative");
 	    }
 	  e->expr_type = expr_type;
 	  return op;
@@ -2389,13 +2493,13 @@ parse_expr (cpp_reader *r)
   while (1);
 }
 
-/* Parse [({] .... [})] literally recording everything as string and only
-   replacing captures.  */
+/* Lex native C code delimited by START recording the preprocessing tokens
+   for later processing.
+     c_expr = ('{'|'(') <pp token>... ('}'|')')  */
 
 static c_expr *
 parse_c_expr (cpp_reader *r, cpp_ttype start)
 {
-  /* ???  Use an obstack to build the string.  */
   const cpp_token *token;
   cpp_ttype end;
   unsigned opencnt;
@@ -2420,6 +2524,7 @@ parse_c_expr (cpp_reader *r, cpp_ttype s
 	       && --opencnt == 0)
 	break;
 
+      /* This is a lame way of counting the number of statements.  */
       if (token->type == CPP_SEMICOLON)
 	nr_stmts++;
 
@@ -2430,8 +2535,9 @@ parse_c_expr (cpp_reader *r, cpp_ttype s
   return new c_expr (r, code, nr_stmts);
 }
 
-/* Parse
-     op = predicate | ( expr ) */
+/* Parse an operand which is either an expression, a predicate or
+   a standalone capture.
+     op = predicate | expr | c_expr | capture  */
 
 static struct operand *
 parse_op (cpp_reader *r)
@@ -2487,7 +2593,9 @@ parse_op (cpp_reader *r)
 }
 
 /* Parse
-     'simplify' [ <ident> ] <expr> <result-op>
+     simplify = 'simplify' <expr> <result-op>
+   or
+     match = 'match' <ident> <expr> [<result-op>]
    with
      <result-op> = <op> | <if> | <with>
      <if> = '(' 'if' '(' <c-expr> ')' <result-op> ')'
@@ -2569,7 +2677,8 @@ parse_simplify (cpp_reader *r, source_lo
 		{
 		  expr *e = dyn_cast <expr *> (op);
 		  if (!e)
-		    fatal_at (token, "match operand expression cannot be captured");
+		    fatal_at (token, "match operand expression cannot "
+			      "be captured");
 		  if (matcher->nargs == -1)
 		    matcher->nargs = e->ops.length ();
 		  if (matcher->nargs == 0
@@ -2624,9 +2733,15 @@ parse_simplify (cpp_reader *r, source_lo
     }
 }
 
+/* Parsing of the outer control structures.  */
+
 void parse_pattern (cpp_reader *, vec<simplify *>&,
 		    vec<if_or_with>&, vec<vec<user_id *> >&);
 
+/* Parse a for expression
+     for = '(' 'for' <subst>... <pattern> ')'
+     subst = <ident> '(' <ident>... ')'  */
+
 void
 parse_for (cpp_reader *r, source_location, vec<simplify *>& simplifiers,
 	   vec<if_or_with>& active_ifs, vec<vec<user_id *> >& active_fors)
@@ -2721,6 +2836,9 @@ parse_for (cpp_reader *r, source_locatio
     operators->remove_elt (user_ids[i]);
 }
 
+/* Parse an outer if expression.
+     if = '(' 'if' '(' <c-expr> ')' <pattern> ')'  */
+
 void
 parse_if (cpp_reader *r, source_location loc, vec<simplify *>& simplifiers,
 	  vec<if_or_with>& active_ifs, vec<vec<user_id *> >& active_fors)
@@ -2743,6 +2861,9 @@ parse_if (cpp_reader *r, source_location
   active_ifs.pop ();
 }
 
+/* Parse a list of predefined predicate identifiers.
+     preds = '(' 'define_predicates' <ident>... ')'  */
+
 static void
 parse_predicates (cpp_reader *r, source_location)
 {
@@ -2757,11 +2878,8 @@ parse_predicates (cpp_reader *r, source_
   while (1);
 }
 
-static size_t
-round_alloc_size (size_t s)
-{
-  return s;
-}
+/* Main entry for the parser.  Parse outer control structures.
+     pattern = <preds>|<for>|<if>|<simplify>|<match>  */
 
 void
 parse_pattern (cpp_reader *r, vec<simplify *>& simplifiers,
@@ -2807,23 +2925,15 @@ parse_pattern (cpp_reader *r, vec<simpli
   eat_token (r, CPP_CLOSE_PAREN);
 }
 
-static vec<simplify *>
-lower (vec<simplify *> simplifiers)
+static size_t
+round_alloc_size (size_t s)
 {
-  vec<simplify *> out_simplifiers0 = vNULL;
-  for (unsigned i = 0; i < simplifiers.length (); ++i)
-    lower_opt_convert (simplifiers[i], out_simplifiers0);
-
-  vec<simplify *> out_simplifiers1 = vNULL;
-  for (unsigned i = 0; i < out_simplifiers0.length (); ++i)
-    lower_commutative (out_simplifiers0[i], out_simplifiers1);
+  return s;
+}
 
-  vec<simplify *> out_simplifiers = vNULL;
-  for (unsigned i = 0; i < out_simplifiers1.length (); ++i)
-    lower_for (out_simplifiers1[i], out_simplifiers);
 
-  return out_simplifiers;
-}
+/* The genmatch generator progam.  It reads from a pattern description
+   and outputs GIMPLE or GENERIC IL matching and simplification routines.  */
 
 int
 main(int argc, char **argv)
@@ -2922,16 +3032,15 @@ add_operator (CONVERT2, "CONVERT2", "tcc
       if (predicate_id *p = dyn_cast <predicate_id *> (id))
 	if (p->matchers.exists ())
 	  {
-	    vec<simplify *> matchers = lower (p->matchers);
-	    p->matchers = matchers;
+	    lower (p->matchers);
 
 	    if (verbose)
-	      for (unsigned i = 0; i < matchers.length (); ++i)
-		print_matches (matchers[i]);
+	      for (unsigned i = 0; i < p->matchers.length (); ++i)
+		print_matches (p->matchers[i]);
 
 	    decision_tree dt;
-	    for (unsigned i = 0; i < matchers.length (); ++i)
-	      dt.insert (matchers[i], i);
+	    for (unsigned i = 0; i < p->matchers.length (); ++i)
+	      dt.insert (p->matchers[i], i);
 
 	    if (verbose)
 	      dt.print (stderr);
@@ -2940,15 +3049,16 @@ add_operator (CONVERT2, "CONVERT2", "tcc
 	  }
     }
 
-  vec<simplify *> out_simplifiers = lower (simplifiers);
+  /* Lower the main simplifiers and generate code for them.  */
+  lower (simplifiers);
 
   if (verbose)
-    for (unsigned i = 0; i < out_simplifiers.length (); ++i)
-      print_matches (out_simplifiers[i]);
+    for (unsigned i = 0; i < simplifiers.length (); ++i)
+      print_matches (simplifiers[i]);
 
   decision_tree dt;
-  for (unsigned i = 0; i < out_simplifiers.length (); ++i)
-    dt.insert (out_simplifiers[i], i);
+  for (unsigned i = 0; i < simplifiers.length (); ++i)
+    dt.insert (simplifiers[i], i);
 
   if (verbose)
     dt.print (stderr);
@@ -2958,6 +3068,7 @@ add_operator (CONVERT2, "CONVERT2", "tcc
   else
     dt.gen_generic (stdout);
 
+  /* Finalize.  */
   cpp_finish (r, NULL);
   cpp_destroy (r);
 
