Change table data_processing_immediate to use the new notation. Also

src/trusted/validator_arm/dgen_core.py

 #!/usr/bin/python
 #
 # Copyright (c) 2012 The Native Client Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 #
 
 """
 The core object model for the Decoder Generator.  The dg_input and
 dg_output modules both operate in terms of these classes.
@@ skipping 11 matching lines @@
         count = count + ((int >> bit) & 1)
     return count
 
 def neutral_repr(value):
   """Returns a neutral representation for the value.
 
      Used to remove identifier references from values, so that we can
      merge rows/actions of the table.
      """
   if (isinstance(value, BitExpr) or isinstance(value, SymbolTable) or
-      isinstance(value, Row) or isinstance(value, DecoderAction)):
+      isinstance(value, Row) or isinstance(value, DecoderAction) or
+      isinstance(value, RuleRestrictions)):
     return value.neutral_repr()
   elif isinstance(value, list):
     return [ neutral_repr(v) for v in value ]
   else:
     return repr(value)
 
 class BitExpr(object):
   """Define a bit expression."""
 
   def negate(self):
@@ skipping 1184 matching lines @@
 
 class RuleRestrictions(object):
   """A rule restriction defines zero or more (anded) bit patterns, and
      an optional other (i.e. base class) restriction to be used when testing.
      """
 
   def __init__(self, restrictions=[], other=None):
     self.restrictions = restrictions[:]
     self.other = other
 
-  def __hash__(self):
-    return sum([hash(r) for r in self.restrictions]) + hash(self.other)
-
   def IsEmpty(self):
     return not self.restrictions and not self.other
 
   def add(self, restriction):
     self.restrictions = self.restrictions + [restriction]
 
   def __repr__(self):
     """ Returns the printable string for the restrictions. """
     rep = ''
     if self.restrictions:
       for r in self.restrictions:
-        rep += '& ' + r
+        rep += '& %s' % r
       rep += ' '
     if self.other:
       rep += ('& other: %s' % self.other)
     return rep
 
+  def neutral_repr(self):
+    """Returns a normalized neutral representation of the rule restrictions."""
+    rep = ''
+    if self.restrictions:
+      for r in self.restrictions:
+        rep += '& %s' % neutral_repr(r)
+      rep += ' '
+    if self.other:
+      rep += ('& other: %s' % self.other)
+    return rep
+
+  def __hash__(self):
+    return hash(self.neutral_repr())
+
   def __cmp__(self, v):
-    value = cmp(self.other, v.other)
-    if value != 0: return value
-    return cmp(self.restrictions, v.restrictions)
+    return cmp(self.neutral_repr(), neutral_repr(v))
 
 TABLE_FORMAT="""
 Table %s
 %s
 %s
 """
 class Table(object):
     """A table in the instruction set definition.  Each table contains 1+
     columns, and 1+ rows.  Each row contains a bit pattern for each column, plus
     the action to be taken if the row matches."""
@@ skipping 408 matching lines @@
        the rule field.
     """
     return sorted(filter(lambda (r): r.rule, self.decoders()))
 
   def show_table(self, table):
     tbl = self.get_table(table)
     if tbl != None:
       print "%s" % tbl
     else:
       raise Exception("Can't find table %s" % table)