X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Farch%2Fisa_parser.py;h=4e06c2ded836a425e0fb6cb4781e5f428b90dc30;hb=249549f9c3cc9317b1eeca8e844287dbbaf5f4ca;hp=a8f9852ea76cf6c3487cd88021e338887932a41b;hpb=40a05f04fbcd0f411b4cf2e2ac38b9f5bb42f4b6;p=gem5.git

diff --git a/src/arch/isa_parser.py b/src/arch/isa_parser.py
index a8f9852ea..4e06c2ded 100755
--- a/src/arch/isa_parser.py
+++ b/src/arch/isa_parser.py
@@ -36,6 +36,8 @@ from types import *
 
 from m5.util.grammar import Grammar
 
+debug=False
+
 ###################
 # Utility functions
 
@@ -83,7 +85,7 @@ class ISAParserError(Exception):
             self.lineno = first
             self.string = second
 
-    def display(self, filename_stack, print_traceback=False):
+    def display(self, filename_stack, print_traceback=debug):
         # Output formatted to work under Emacs compile-mode.  Optional
         # 'print_traceback' arg, if set to True, prints a Python stack
         # backtrace too (can be handy when trying to debug the parser
@@ -104,7 +106,7 @@ class ISAParserError(Exception):
 
         return "%s%s %s" % (spaces, line_str, self.string)
 
-    def exit(self, filename_stack, print_traceback=False):
+    def exit(self, filename_stack, print_traceback=debug):
         # Just call exit.
 
         sys.exit(self.display(filename_stack, print_traceback))
@@ -121,7 +123,8 @@ def error(*args):
 labelRE = re.compile(r'(?<!%)%\(([^\)]+)\)[sd]')
 
 class Template(object):
-    def __init__(self, t):
+    def __init__(self, parser, t):
+        self.parser = parser
         self.template = t
 
     def subst(self, d):
@@ -129,14 +132,14 @@ class Template(object):
 
         # Protect non-Python-dict substitutions (e.g. if there's a printf
         # in the templated C++ code)
-        template = protect_non_subst_percents(self.template)
+        template = self.parser.protectNonSubstPercents(self.template)
         # CPU-model-specific substitutions are handled later (in GenCode).
-        template = protect_cpu_symbols(template)
+        template = self.parser.protectCpuSymbols(template)
 
         # Build a dict ('myDict') to use for the template substitution.
         # Start with the template namespace.  Make a copy since we're
         # going to modify it.
-        myDict = parser.templateMap.copy()
+        myDict = self.parser.templateMap.copy()
 
         if isinstance(d, InstObjParams):
             # If we're dealing with an InstObjParams object, we need
@@ -154,7 +157,7 @@ class Template(object):
             snippetLabels = [l for l in labelRE.findall(template)
                              if d.snippets.has_key(l)]
 
-            snippets = dict([(s, mungeSnippet(d.snippets[s]))
+            snippets = dict([(s, self.parser.mungeSnippet(d.snippets[s]))
                              for s in snippetLabels])
 
             myDict.update(snippets)
@@ -165,7 +168,7 @@ class Template(object):
             # operands explicitly (like Mem)
             compositeCode += ' ' + template
 
-            operands = SubOperandList(compositeCode, d.operands)
+            operands = SubOperandList(self.parser, compositeCode, d.operands)
 
             myDict['op_decl'] = operands.concatAttrStrings('op_decl')
 
@@ -198,7 +201,7 @@ class Template(object):
     # CPU-specific term gets interpolated into another template or into
     # an output block.
     def __str__(self):
-        return expand_cpu_symbols_to_string(self.template)
+        return self.parser.expandCpuSymbolsToString(self.template)
 
 ################
 # Format object.
@@ -207,21 +210,8 @@ class Template(object):
 # a defineInst() method that generates the code for an instruction
 # definition.
 
-exportContextSymbols = ('InstObjParams', 'makeList', 're', 'string')
-
-exportContext = {}
-
-def updateExportContext():
-    exportContext.update(exportDict(*exportContextSymbols))
-    exportContext.update(parser.templateMap)
-
-def exportDict(*symNames):
-    return dict([(s, eval(s)) for s in symNames])
-
-
 class Format(object):
     def __init__(self, id, params, code):
-        # constructor: just save away arguments
         self.id = id
         self.params = params
         label = 'def format ' + id
@@ -235,24 +225,25 @@ class Format(object):
         exec c
         self.func = defInst
 
-    def defineInst(self, name, args, lineno):
-        context = {}
-        updateExportContext()
-        context.update(exportContext)
+    def defineInst(self, parser, name, args, lineno):
+        parser.updateExportContext()
+        context = parser.exportContext.copy()
         if len(name):
             Name = name[0].upper()
             if len(name) > 1:
                 Name += name[1:]
-        context.update({ 'name': name, 'Name': Name })
+        context.update({ 'name' : name, 'Name' : Name })
         try:
             vars = self.func(self.user_code, context, *args[0], **args[1])
         except Exception, exc:
+            if debug:
+                raise
             error(lineno, 'error defining "%s": %s.' % (name, exc))
         for k in vars.keys():
             if k not in ('header_output', 'decoder_output',
                          'exec_output', 'decode_block'):
                 del vars[k]
-        return GenCode(**vars)
+        return GenCode(parser, **vars)
 
 # Special null format to catch an implicit-format instruction
 # definition outside of any format block.
@@ -260,61 +251,10 @@ class NoFormat(object):
     def __init__(self):
         self.defaultInst = ''
 
-    def defineInst(self, name, args, lineno):
+    def defineInst(self, parser, name, args, lineno):
         error(lineno,
               'instruction definition "%s" with no active format!' % name)
 
-# This dictionary maps format name strings to Format objects.
-formatMap = {}
-
-# Define a new format
-def defFormat(id, params, code, lineno):
-    # make sure we haven't already defined this one
-    if formatMap.get(id, None) != None:
-        error(lineno, 'format %s redefined.' % id)
-    # create new object and store in global map
-    formatMap[id] = Format(id, params, code)
-
-#####################################################################
-#
-#                           Support Classes
-#
-#####################################################################
-
-# Expand template with CPU-specific references into a dictionary with
-# an entry for each CPU model name.  The entry key is the model name
-# and the corresponding value is the template with the CPU-specific
-# refs substituted for that model.
-def expand_cpu_symbols_to_dict(template):
-    # Protect '%'s that don't go with CPU-specific terms
-    t = re.sub(r'%(?!\(CPU_)', '%%', template)
-    result = {}
-    for cpu in cpu_models:
-        result[cpu.name] = t % cpu.strings
-    return result
-
-# *If* the template has CPU-specific references, return a single
-# string containing a copy of the template for each CPU model with the
-# corresponding values substituted in.  If the template has no
-# CPU-specific references, it is returned unmodified.
-def expand_cpu_symbols_to_string(template):
-    if template.find('%(CPU_') != -1:
-        return reduce(lambda x,y: x+y,
-                      expand_cpu_symbols_to_dict(template).values())
-    else:
-        return template
-
-# Protect CPU-specific references by doubling the corresponding '%'s
-# (in preparation for substituting a different set of references into
-# the template).
-def protect_cpu_symbols(template):
-    return re.sub(r'%(?=\(CPU_)', '%%', template)
-
-# Protect any non-dict-substitution '%'s in a format string
-# (i.e. those not followed by '(')
-def protect_non_subst_percents(s):
-    return re.sub(r'%(?!\()', '%%', s)
-
 ###############
 # GenCode class
 #
@@ -334,29 +274,31 @@ class GenCode(object):
     # symbols.  For the exec output, these go into the per-model
     # dictionary.  For all other output types they get collapsed into
     # a single string.
-    def __init__(self,
+    def __init__(self, parser,
                  header_output = '', decoder_output = '', exec_output = '',
                  decode_block = '', has_decode_default = False):
-        self.header_output = expand_cpu_symbols_to_string(header_output)
-        self.decoder_output = expand_cpu_symbols_to_string(decoder_output)
+        self.parser = parser
+        self.header_output = parser.expandCpuSymbolsToString(header_output)
+        self.decoder_output = parser.expandCpuSymbolsToString(decoder_output)
         if isinstance(exec_output, dict):
             self.exec_output = exec_output
         elif isinstance(exec_output, str):
             # If the exec_output arg is a single string, we replicate
             # it for each of the CPU models, substituting and
             # %(CPU_foo)s params appropriately.
-            self.exec_output = expand_cpu_symbols_to_dict(exec_output)
-        self.decode_block = expand_cpu_symbols_to_string(decode_block)
+            self.exec_output = parser.expandCpuSymbolsToDict(exec_output)
+        self.decode_block = parser.expandCpuSymbolsToString(decode_block)
         self.has_decode_default = has_decode_default
 
     # Override '+' operator: generate a new GenCode object that
     # concatenates all the individual strings in the operands.
     def __add__(self, other):
         exec_output = {}
-        for cpu in cpu_models:
+        for cpu in self.parser.cpuModels:
             n = cpu.name
             exec_output[n] = self.exec_output[n] + other.exec_output[n]
-        return GenCode(self.header_output + other.header_output,
+        return GenCode(self.parser,
+                       self.header_output + other.header_output,
                        self.decoder_output + other.decoder_output,
                        exec_output,
                        self.decode_block + other.decode_block,
@@ -367,7 +309,7 @@ class GenCode(object):
         self.header_output = pre + self.header_output
         self.decoder_output  = pre + self.decoder_output
         self.decode_block = pre + self.decode_block
-        for cpu in cpu_models:
+        for cpu in self.parser.cpuModels:
             self.exec_output[cpu.name] = pre + self.exec_output[cpu.name]
 
     # Wrap the decode block in a pair of strings (e.g., 'case foo:'
@@ -438,34 +380,6 @@ def makeList(arg):
     else:
         return [ arg ]
 
-# Generate operandTypeMap from the user's 'def operand_types'
-# statement.
-def buildOperandTypeMap(user_dict, lineno):
-    global operandTypeMap
-    operandTypeMap = {}
-    for (ext, (desc, size)) in user_dict.iteritems():
-        if desc == 'signed int':
-            ctype = 'int%d_t' % size
-            is_signed = 1
-        elif desc == 'unsigned int':
-            ctype = 'uint%d_t' % size
-            is_signed = 0
-        elif desc == 'float':
-            is_signed = 1       # shouldn't really matter
-            if size == 32:
-                ctype = 'float'
-            elif size == 64:
-                ctype = 'double'
-        elif desc == 'twin64 int':
-            is_signed = 0
-            ctype = 'Twin64_t'
-        elif desc == 'twin32 int':
-            is_signed = 0
-            ctype = 'Twin32_t'
-        if ctype == '':
-            error(lineno, 'Unrecognized type description "%s" in user_dict')
-        operandTypeMap[ext] = (size, ctype, is_signed)
-
 class Operand(object):
     '''Base class for operand descriptors.  An instance of this class
     (or actually a class derived from this one) represents a specific
@@ -474,12 +388,14 @@ class Operand(object):
     type (e.g., "32-bit integer register").'''
 
     def buildReadCode(self, func = None):
-        code = self.read_code % {"name": self.base_name,
-                                 "func": func,
-                                 "op_idx": self.src_reg_idx,
-                                 "reg_idx": self.reg_spec,
-                                 "size": self.size,
-                                 "ctype": self.ctype}
+        subst_dict = {"name": self.base_name,
+                      "func": func,
+                      "reg_idx": self.reg_spec,
+                      "size": self.size,
+                      "ctype": self.ctype}
+        if hasattr(self, 'src_reg_idx'):
+            subst_dict['op_idx'] = self.src_reg_idx
+        code = self.read_code % subst_dict
         if self.size != self.dflt_size:
             return '%s = bits(%s, %d, 0);\n' % \
                    (self.base_name, code, self.size-1)
@@ -492,13 +408,15 @@ class Operand(object):
             final_val = 'sext<%d>(%s)' % (self.size, self.base_name)
         else:
             final_val = self.base_name
-        code = self.write_code % {"name": self.base_name,
-                                  "func": func,
-                                  "op_idx": self.dest_reg_idx,
-                                  "reg_idx": self.reg_spec,
-                                  "size": self.size,
-                                  "ctype": self.ctype,
-                                  "final_val": final_val}
+        subst_dict = {"name": self.base_name,
+                      "func": func,
+                      "reg_idx": self.reg_spec,
+                      "size": self.size,
+                      "ctype": self.ctype,
+                      "final_val": final_val}
+        if hasattr(self, 'dest_reg_idx'):
+            subst_dict['op_idx'] = self.dest_reg_idx
+        code = self.write_code % subst_dict
         return '''
         {
             %s final_val = %s;
@@ -506,7 +424,7 @@ class Operand(object):
             if (traceData) { traceData->setData(final_val); }
         }''' % (self.dflt_ctype, final_val, code)
 
-    def __init__(self, full_name, ext, is_src, is_dest):
+    def __init__(self, parser, full_name, ext, is_src, is_dest):
         self.full_name = full_name
         self.ext = ext
         self.is_src = is_src
@@ -518,7 +436,8 @@ class Operand(object):
         else:
             self.eff_ext = self.dflt_ext
 
-        (self.size, self.ctype, self.is_signed) = operandTypeMap[self.eff_ext]
+        self.size, self.ctype, self.is_signed = \
+                    parser.operandTypeMap[self.eff_ext]
 
         # note that mem_acc_size is undefined for non-mem operands...
         # template must be careful not to use it if it doesn't apply.
@@ -828,96 +747,10 @@ class NNPCOperand(Operand):
             return self.buildWriteCode('setNextNPC')
         return 'xc->setNextNPC(%s);\n' % self.base_name
 
-def buildOperandNameMap(user_dict, lineno):
-    global operandNameMap
-    operandNameMap = {}
-    for (op_name, val) in user_dict.iteritems():
-        (base_cls_name, dflt_ext, reg_spec, flags, sort_pri) = val[:5]
-        if len(val) > 5:
-            read_code = val[5]
-        else:
-            read_code = None
-        if len(val) > 6:
-            write_code = val[6]
-        else:
-            write_code = None
-        if len(val) > 7:
-            error(lineno,
-                  'error: too many attributes for operand "%s"' %
-                  base_cls_name)
-            
-        (dflt_size, dflt_ctype, dflt_is_signed) = operandTypeMap[dflt_ext]
-        # Canonical flag structure is a triple of lists, where each list
-        # indicates the set of flags implied by this operand always, when
-        # used as a source, and when used as a dest, respectively.
-        # For simplicity this can be initialized using a variety of fairly
-        # obvious shortcuts; we convert these to canonical form here.
-        if not flags:
-            # no flags specified (e.g., 'None')
-            flags = ( [], [], [] )
-        elif isinstance(flags, str):
-            # a single flag: assumed to be unconditional
-            flags = ( [ flags ], [], [] )
-        elif isinstance(flags, list):
-            # a list of flags: also assumed to be unconditional
-            flags = ( flags, [], [] )
-        elif isinstance(flags, tuple):
-            # it's a tuple: it should be a triple,
-            # but each item could be a single string or a list
-            (uncond_flags, src_flags, dest_flags) = flags
-            flags = (makeList(uncond_flags),
-                     makeList(src_flags), makeList(dest_flags))
-        # Accumulate attributes of new operand class in tmp_dict
-        tmp_dict = {}
-        for attr in ('dflt_ext', 'reg_spec', 'flags', 'sort_pri',
-                     'dflt_size', 'dflt_ctype', 'dflt_is_signed',
-                     'read_code', 'write_code'):
-            tmp_dict[attr] = eval(attr)
-        tmp_dict['base_name'] = op_name
-        # New class name will be e.g. "IntReg_Ra"
-        cls_name = base_cls_name + '_' + op_name
-        # Evaluate string arg to get class object.  Note that the
-        # actual base class for "IntReg" is "IntRegOperand", i.e. we
-        # have to append "Operand".
-        try:
-            base_cls = eval(base_cls_name + 'Operand')
-        except NameError:
-            error(lineno,
-                  'error: unknown operand base class "%s"' % base_cls_name)
-        # The following statement creates a new class called
-        # <cls_name> as a subclass of <base_cls> with the attributes
-        # in tmp_dict, just as if we evaluated a class declaration.
-        operandNameMap[op_name] = type(cls_name, (base_cls,), tmp_dict)
-
-    # Define operand variables.
-    operands = user_dict.keys()
-
-    operandsREString = (r'''
-    (?<![\w\.])      # neg. lookbehind assertion: prevent partial matches
-    ((%s)(?:\.(\w+))?)   # match: operand with optional '.' then suffix
-    (?![\w\.])       # neg. lookahead assertion: prevent partial matches
-    '''
-                        % string.join(operands, '|'))
-
-    global operandsRE
-    operandsRE = re.compile(operandsREString, re.MULTILINE|re.VERBOSE)
-
-    # Same as operandsREString, but extension is mandatory, and only two
-    # groups are returned (base and ext, not full name as above).
-    # Used for subtituting '_' for '.' to make C++ identifiers.
-    operandsWithExtREString = (r'(?<![\w\.])(%s)\.(\w+)(?![\w\.])'
-                               % string.join(operands, '|'))
-
-    global operandsWithExtRE
-    operandsWithExtRE = re.compile(operandsWithExtREString, re.MULTILINE)
-
-maxInstSrcRegs = 0
-maxInstDestRegs = 0
-
 class OperandList(object):
     '''Find all the operands in the given code block.  Returns an operand
     descriptor list (instance of class OperandList).'''
-    def __init__(self, code):
+    def __init__(self, parser, code):
         self.items = []
         self.bases = {}
         # delete comments so we don't match on reg specifiers inside
@@ -925,7 +758,7 @@ class OperandList(object):
         # search for operands
         next_pos = 0
         while 1:
-            match = operandsRE.search(code, next_pos)
+            match = parser.operandsRE.search(code, next_pos)
             if not match:
                 # no more matches: we're done
                 break
@@ -946,8 +779,8 @@ class OperandList(object):
                 op_desc.is_dest = op_desc.is_dest or is_dest
             else:
                 # new operand: create new descriptor
-                op_desc = operandNameMap[op_base](op_full, op_ext,
-                                                  is_src, is_dest)
+                op_desc = parser.operandNameMap[op_base](parser,
+                    op_full, op_ext, is_src, is_dest)
                 self.append(op_desc)
             # start next search after end of current match
             next_pos = match.end()
@@ -975,12 +808,10 @@ class OperandList(object):
                 if self.memOperand:
                     error("Code block has more than one memory operand.")
                 self.memOperand = op_desc
-        global maxInstSrcRegs
-        global maxInstDestRegs
-        if maxInstSrcRegs < self.numSrcRegs:
-            maxInstSrcRegs = self.numSrcRegs
-        if maxInstDestRegs < self.numDestRegs:
-            maxInstDestRegs = self.numDestRegs
+        if parser.maxInstSrcRegs < self.numSrcRegs:
+            parser.maxInstSrcRegs = self.numSrcRegs
+        if parser.maxInstDestRegs < self.numDestRegs:
+            parser.maxInstDestRegs = self.numDestRegs
         # now make a final pass to finalize op_desc fields that may depend
         # on the register enumeration
         for op_desc in self.items:
@@ -1034,7 +865,7 @@ class OperandList(object):
 class SubOperandList(OperandList):
     '''Find all the operands in the given code block.  Returns an operand
     descriptor list (instance of class OperandList).'''
-    def __init__(self, code, master_list):
+    def __init__(self, parser, code, master_list):
         self.items = []
         self.bases = {}
         # delete comments so we don't match on reg specifiers inside
@@ -1042,7 +873,7 @@ class SubOperandList(OperandList):
         # search for operands
         next_pos = 0
         while 1:
-            match = operandsRE.search(code, next_pos)
+            match = parser.operandsRE.search(code, next_pos)
             if not match:
                 # no more matches: we're done
                 break
@@ -1079,19 +910,6 @@ commentRE = re.compile(r'//.*\n')
 # (used in findOperands())
 assignRE = re.compile(r'\s*=(?!=)', re.MULTILINE)
 
-# Munge operand names in code string to make legal C++ variable names.
-# This means getting rid of the type extension if any.
-# (Will match base_name attribute of Operand object.)
-def substMungedOpNames(code):
-    return operandsWithExtRE.sub(r'\1', code)
-
-# Fix up code snippets for final substitution in templates.
-def mungeSnippet(s):
-    if isinstance(s, str):
-        return substMungedOpNames(substBitOps(s))
-    else:
-        return s
-
 def makeFlagConstructor(flag_list):
     if len(flag_list) == 0:
         return ''
@@ -1115,7 +933,7 @@ instFlagRE = re.compile(r'Is.*')
 opClassRE = re.compile(r'.*Op|No_OpClass')
 
 class InstObjParams(object):
-    def __init__(self, mnem, class_name, base_class = '',
+    def __init__(self, parser, mnem, class_name, base_class = '',
                  snippets = {}, opt_args = []):
         self.mnemonic = mnem
         self.class_name = class_name
@@ -1125,7 +943,7 @@ class InstObjParams(object):
         compositeCode = ' '.join(map(str, snippets.values()))
         self.snippets = snippets
 
-        self.operands = OperandList(compositeCode)
+        self.operands = OperandList(parser, compositeCode)
         self.constructor = self.operands.concatAttrStrings('constructor')
         self.constructor += \
                  '\n\t_numSrcRegs = %d;' % self.operands.numSrcRegs
@@ -1189,19 +1007,6 @@ class Stack(list):
     def top(self):
         return self[-1]
 
-# The global format stack.
-formatStack = Stack(NoFormat())
-
-# The global default case stack.
-defaultStack = Stack(None)
-
-# Global stack that tracks current file and line number.
-# Each element is a tuple (filename, lineno) that records the
-# *current* filename and the line number in the *previous* file where
-# it was included.
-fileNameStack = Stack()
-
-
 #######################
 #
 # Output file template
@@ -1244,12 +1049,36 @@ namespace %(namespace)s {
 '''
 
 class ISAParser(Grammar):
-    def __init__(self, output_dir):
+    def __init__(self, output_dir, cpu_models):
         super(ISAParser, self).__init__()
         self.output_dir = output_dir
 
+        self.cpuModels = cpu_models
+
+        # variable to hold templates
         self.templateMap = {}
 
+        # This dictionary maps format name strings to Format objects.
+        self.formatMap = {}
+
+        # The format stack.
+        self.formatStack = Stack(NoFormat())
+
+        # The default case stack.
+        self.defaultStack = Stack(None)
+
+        # Stack that tracks current file and line number.  Each
+        # element is a tuple (filename, lineno) that records the
+        # *current* filename and the line number in the *previous*
+        # file where it was included.
+        self.fileNameStack = Stack()
+
+        symbols = ('makeList', 're', 'string')
+        self.exportContext = dict([(s, eval(s)) for s in symbols])
+
+        self.maxInstSrcRegs = 0
+        self.maxInstDestRegs = 0
+
     #####################################################################
     #
     #                                Lexer
@@ -1371,12 +1200,12 @@ class ISAParser(Grammar):
 
     def t_NEWFILE(self, t):
         r'^\#\#newfile\s+"[\w/.-]*"'
-        fileNameStack.push((t.value[11:-1], t.lexer.lineno))
+        self.fileNameStack.push((t.value[11:-1], t.lexer.lineno))
         t.lexer.lineno = 0
 
     def t_ENDFILE(self, t):
         r'^\#\#endfile'
-        (old_filename, t.lexer.lineno) = fileNameStack.pop()
+        (old_filename, t.lexer.lineno) = self.fileNameStack.pop()
 
     #
     # The functions t_NEWLINE, t_ignore, and t_error are
@@ -1450,7 +1279,7 @@ StaticInstPtr
     # def and/or output statements.
     def p_opt_defs_and_outputs_0(self, t):
         'opt_defs_and_outputs : empty'
-        t[0] = GenCode()
+        t[0] = GenCode(self)
 
     def p_opt_defs_and_outputs_1(self, t):
         'opt_defs_and_outputs : defs_and_outputs'
@@ -1487,22 +1316,22 @@ StaticInstPtr
     # get handled in GenCode) by doubling them first so that the
     # format operation will reduce them back to single '%'s.
     def process_output(self, s):
-        s = protect_non_subst_percents(s)
+        s = self.protectNonSubstPercents(s)
         # protects cpu-specific symbols too
-        s = protect_cpu_symbols(s)
+        s = self.protectCpuSymbols(s)
         return substBitOps(s % self.templateMap)
 
     def p_output_header(self, t):
         'output_header : OUTPUT HEADER CODELIT SEMI'
-        t[0] = GenCode(header_output = self.process_output(t[3]))
+        t[0] = GenCode(self, header_output = self.process_output(t[3]))
 
     def p_output_decoder(self, t):
         'output_decoder : OUTPUT DECODER CODELIT SEMI'
-        t[0] = GenCode(decoder_output = self.process_output(t[3]))
+        t[0] = GenCode(self, decoder_output = self.process_output(t[3]))
 
     def p_output_exec(self, t):
         'output_exec : OUTPUT EXEC CODELIT SEMI'
-        t[0] = GenCode(exec_output = self.process_output(t[3]))
+        t[0] = GenCode(self, exec_output = self.process_output(t[3]))
 
     # global let blocks 'let {{...}}' (Python code blocks) are
     # executed directly when seen.  Note that these execute in a
@@ -1510,19 +1339,22 @@ StaticInstPtr
     # from polluting this script's namespace.
     def p_global_let(self, t):
         'global_let : LET CODELIT SEMI'
-        updateExportContext()
-        exportContext["header_output"] = ''
-        exportContext["decoder_output"] = ''
-        exportContext["exec_output"] = ''
-        exportContext["decode_block"] = ''
+        self.updateExportContext()
+        self.exportContext["header_output"] = ''
+        self.exportContext["decoder_output"] = ''
+        self.exportContext["exec_output"] = ''
+        self.exportContext["decode_block"] = ''
         try:
-            exec fixPythonIndentation(t[2]) in exportContext
+            exec fixPythonIndentation(t[2]) in self.exportContext
         except Exception, exc:
+            if debug:
+                raise
             error(t, 'error: %s in global let block "%s".' % (exc, t[2]))
-        t[0] = GenCode(header_output = exportContext["header_output"],
-                       decoder_output = exportContext["decoder_output"],
-                       exec_output = exportContext["exec_output"],
-                       decode_block = exportContext["decode_block"])
+        t[0] = GenCode(self,
+                       header_output=self.exportContext["header_output"],
+                       decoder_output=self.exportContext["decoder_output"],
+                       exec_output=self.exportContext["exec_output"],
+                       decode_block=self.exportContext["decode_block"])
 
     # Define the mapping from operand type extensions to C++ types and
     # bit widths (stored in operandTypeMap).
@@ -1531,23 +1363,27 @@ StaticInstPtr
         try:
             user_dict = eval('{' + t[3] + '}')
         except Exception, exc:
+            if debug:
+                raise
             error(t,
                   'error: %s in def operand_types block "%s".' % (exc, t[3]))
-        buildOperandTypeMap(user_dict, t.lexer.lineno)
-        t[0] = GenCode() # contributes nothing to the output C++ file
+        self.buildOperandTypeMap(user_dict, t.lexer.lineno)
+        t[0] = GenCode(self) # contributes nothing to the output C++ file
 
     # Define the mapping from operand names to operand classes and
     # other traits.  Stored in operandNameMap.
     def p_def_operands(self, t):
         'def_operands : DEF OPERANDS CODELIT SEMI'
-        if not globals().has_key('operandTypeMap'):
+        if not hasattr(self, 'operandTypeMap'):
             error(t, 'error: operand types must be defined before operands')
         try:
-            user_dict = eval('{' + t[3] + '}', exportContext)
+            user_dict = eval('{' + t[3] + '}', self.exportContext)
         except Exception, exc:
+            if debug:
+                raise
             error(t, 'error: %s in def operands block "%s".' % (exc, t[3]))
-        buildOperandNameMap(user_dict, t.lexer.lineno)
-        t[0] = GenCode() # contributes nothing to the output C++ file
+        self.buildOperandNameMap(user_dict, t.lexer.lineno)
+        t[0] = GenCode(self) # contributes nothing to the output C++ file
 
     # A bitfield definition looks like:
     # 'def [signed] bitfield <ID> [<first>:<last>]'
@@ -1558,7 +1394,7 @@ StaticInstPtr
         if (t[2] == 'signed'):
             expr = 'sext<%d>(%s)' % (t[6] - t[8] + 1, expr)
         hash_define = '#undef %s\n#define %s\t%s\n' % (t[4], t[4], expr)
-        t[0] = GenCode(header_output = hash_define)
+        t[0] = GenCode(self, header_output=hash_define)
 
     # alternate form for single bit: 'def [signed] bitfield <ID> [<bit>]'
     def p_def_bitfield_1(self, t):
@@ -1567,7 +1403,7 @@ StaticInstPtr
         if (t[2] == 'signed'):
             expr = 'sext<%d>(%s)' % (1, expr)
         hash_define = '#undef %s\n#define %s\t%s\n' % (t[4], t[4], expr)
-        t[0] = GenCode(header_output = hash_define)
+        t[0] = GenCode(self, header_output=hash_define)
 
     # alternate form for structure member: 'def bitfield <ID> <ID>'
     def p_def_bitfield_struct(self, t):
@@ -1576,7 +1412,7 @@ StaticInstPtr
             error(t, 'error: structure bitfields are always unsigned.')
         expr = 'machInst.%s' % t[5]
         hash_define = '#undef %s\n#define %s\t%s\n' % (t[4], t[4], expr)
-        t[0] = GenCode(header_output = hash_define)
+        t[0] = GenCode(self, header_output=hash_define)
 
     def p_id_with_dot_0(self, t):
         'id_with_dot : ID'
@@ -1596,16 +1432,16 @@ StaticInstPtr
 
     def p_def_template(self, t):
         'def_template : DEF TEMPLATE ID CODELIT SEMI'
-        self.templateMap[t[3]] = Template(t[4])
-        t[0] = GenCode()
+        self.templateMap[t[3]] = Template(self, t[4])
+        t[0] = GenCode(self)
 
     # An instruction format definition looks like
     # "def format <fmt>(<params>) {{...}};"
     def p_def_format(self, t):
         'def_format : DEF FORMAT ID LPAREN param_list RPAREN CODELIT SEMI'
         (id, params, code) = (t[3], t[5], t[7])
-        defFormat(id, params, code, t.lexer.lineno)
-        t[0] = GenCode()
+        self.defFormat(id, params, code, t.lexer.lineno)
+        t[0] = GenCode(self)
 
     # The formal parameter list for an instruction format is a
     # possibly empty list of comma-separated parameters.  Positional
@@ -1678,7 +1514,7 @@ StaticInstPtr
     #
     def p_decode_block(self, t):
         'decode_block : DECODE ID opt_default LBRACE decode_stmt_list RBRACE'
-        default_defaults = defaultStack.pop()
+        default_defaults = self.defaultStack.pop()
         codeObj = t[5]
         # use the "default defaults" only if there was no explicit
         # default statement in decode_stmt_list
@@ -1695,7 +1531,7 @@ StaticInstPtr
         'opt_default : empty'
         # no default specified: reuse the one currently at the top of
         # the stack
-        defaultStack.push(defaultStack.top())
+        self.defaultStack.push(self.defaultStack.top())
         # no meaningful value returned
         t[0] = None
 
@@ -1704,7 +1540,7 @@ StaticInstPtr
         # push the new default
         codeObj = t[2]
         codeObj.wrap_decode_block('\ndefault:\n', 'break;\n')
-        defaultStack.push(codeObj)
+        self.defaultStack.push(codeObj)
         # no meaningful value returned
         t[0] = None
 
@@ -1737,7 +1573,7 @@ StaticInstPtr
     # the code generated by the other statements.
     def p_decode_stmt_cpp(self, t):
         'decode_stmt : CPPDIRECTIVE'
-        t[0] = GenCode(t[1], t[1], t[1], t[1])
+        t[0] = GenCode(self, t[1], t[1], t[1], t[1])
 
     # A format block 'format <foo> { ... }' sets the default
     # instruction format used to handle instruction definitions inside
@@ -1750,7 +1586,7 @@ StaticInstPtr
         # is processed (see below).  Once the parser has recognized
         # the full production (though the right brace), we're done
         # with the format, so now we can pop it.
-        formatStack.pop()
+        self.formatStack.pop()
         t[0] = t[4]
 
     # This rule exists so we can set the current format (& push the
@@ -1759,7 +1595,7 @@ StaticInstPtr
     def p_push_format_id(self, t):
         'push_format_id : ID'
         try:
-            formatStack.push(formatMap[t[1]])
+            self.formatStack.push(self.formatMap[t[1]])
             t[0] = ('', '// format %s' % t[1])
         except KeyError:
             error(t, 'instruction format "%s" not defined.' % t[1])
@@ -1819,8 +1655,8 @@ StaticInstPtr
     def p_inst_0(self, t):
         'inst : ID LPAREN arg_list RPAREN'
         # Pass the ID and arg list to the current format class to deal with.
-        currentFormat = formatStack.top()
-        codeObj = currentFormat.defineInst(t[1], t[3], t.lexer.lineno)
+        currentFormat = self.formatStack.top()
+        codeObj = currentFormat.defineInst(self, t[1], t[3], t.lexer.lineno)
         args = ','.join(map(str, t[3]))
         args = re.sub('(?m)^', '//', args)
         args = re.sub('^//', '', args)
@@ -1833,10 +1669,11 @@ StaticInstPtr
     def p_inst_1(self, t):
         'inst : ID DBLCOLON ID LPAREN arg_list RPAREN'
         try:
-            format = formatMap[t[1]]
+            format = self.formatMap[t[1]]
         except KeyError:
             error(t, 'instruction format "%s" not defined.' % t[1])
-        codeObj = format.defineInst(t[3], t[5], t.lexer.lineno)
+
+        codeObj = format.defineInst(self, t[3], t[5], t.lexer.lineno)
         comment = '\n// %s::%s(%s)\n' % (t[1], t[3], t[5])
         codeObj.prepend_all(comment)
         t[0] = codeObj
@@ -1933,6 +1770,191 @@ StaticInstPtr
 
     # END OF GRAMMAR RULES
 
+    def updateExportContext(self):
+
+        # create a continuation that allows us to grab the current parser
+        def wrapInstObjParams(*args):
+            return InstObjParams(self, *args)
+        self.exportContext['InstObjParams'] = wrapInstObjParams
+        self.exportContext.update(self.templateMap)
+
+    def defFormat(self, id, params, code, lineno):
+        '''Define a new format'''
+
+        # make sure we haven't already defined this one
+        if id in self.formatMap:
+            error(lineno, 'format %s redefined.' % id)
+
+        # create new object and store in global map
+        self.formatMap[id] = Format(id, params, code)
+
+    def expandCpuSymbolsToDict(self, template):
+        '''Expand template with CPU-specific references into a
+        dictionary with an entry for each CPU model name.  The entry
+        key is the model name and the corresponding value is the
+        template with the CPU-specific refs substituted for that
+        model.'''
+
+        # Protect '%'s that don't go with CPU-specific terms
+        t = re.sub(r'%(?!\(CPU_)', '%%', template)
+        result = {}
+        for cpu in self.cpuModels:
+            result[cpu.name] = t % cpu.strings
+        return result
+
+    def expandCpuSymbolsToString(self, template):
+        '''*If* the template has CPU-specific references, return a
+        single string containing a copy of the template for each CPU
+        model with the corresponding values substituted in.  If the
+        template has no CPU-specific references, it is returned
+        unmodified.'''
+
+        if template.find('%(CPU_') != -1:
+            return reduce(lambda x,y: x+y,
+                          self.expandCpuSymbolsToDict(template).values())
+        else:
+            return template
+
+    def protectCpuSymbols(self, template):
+        '''Protect CPU-specific references by doubling the
+        corresponding '%'s (in preparation for substituting a different
+        set of references into the template).'''
+
+        return re.sub(r'%(?=\(CPU_)', '%%', template)
+
+    def protectNonSubstPercents(self, s):
+        '''Protect any non-dict-substitution '%'s in a format string
+        (i.e. those not followed by '(')'''
+
+        return re.sub(r'%(?!\()', '%%', s)
+
+    def buildOperandTypeMap(self, user_dict, lineno):
+        """Generate operandTypeMap from the user's 'def operand_types'
+        statement."""
+        operand_type = {}
+        for (ext, (desc, size)) in user_dict.iteritems():
+            if desc == 'signed int':
+                ctype = 'int%d_t' % size
+                is_signed = 1
+            elif desc == 'unsigned int':
+                ctype = 'uint%d_t' % size
+                is_signed = 0
+            elif desc == 'float':
+                is_signed = 1       # shouldn't really matter
+                if size == 32:
+                    ctype = 'float'
+                elif size == 64:
+                    ctype = 'double'
+            elif desc == 'twin64 int':
+                is_signed = 0
+                ctype = 'Twin64_t'
+            elif desc == 'twin32 int':
+                is_signed = 0
+                ctype = 'Twin32_t'
+            if ctype == '':
+                error(parser, lineno,
+                      'Unrecognized type description "%s" in user_dict')
+            operand_type[ext] = (size, ctype, is_signed)
+
+        self.operandTypeMap = operand_type
+
+    def buildOperandNameMap(self, user_dict, lineno):
+        operand_name = {}
+        for op_name, val in user_dict.iteritems():
+            base_cls_name, dflt_ext, reg_spec, flags, sort_pri = val[:5]
+            if len(val) > 5:
+                read_code = val[5]
+            else:
+                read_code = None
+            if len(val) > 6:
+                write_code = val[6]
+            else:
+                write_code = None
+            if len(val) > 7:
+                error(lineno,
+                      'error: too many attributes for operand "%s"' %
+                      base_cls_name)
+
+            (dflt_size, dflt_ctype, dflt_is_signed) = \
+                        self.operandTypeMap[dflt_ext]
+            # Canonical flag structure is a triple of lists, where each list
+            # indicates the set of flags implied by this operand always, when
+            # used as a source, and when used as a dest, respectively.
+            # For simplicity this can be initialized using a variety of fairly
+            # obvious shortcuts; we convert these to canonical form here.
+            if not flags:
+                # no flags specified (e.g., 'None')
+                flags = ( [], [], [] )
+            elif isinstance(flags, str):
+                # a single flag: assumed to be unconditional
+                flags = ( [ flags ], [], [] )
+            elif isinstance(flags, list):
+                # a list of flags: also assumed to be unconditional
+                flags = ( flags, [], [] )
+            elif isinstance(flags, tuple):
+                # it's a tuple: it should be a triple,
+                # but each item could be a single string or a list
+                (uncond_flags, src_flags, dest_flags) = flags
+                flags = (makeList(uncond_flags),
+                         makeList(src_flags), makeList(dest_flags))
+            # Accumulate attributes of new operand class in tmp_dict
+            tmp_dict = {}
+            for attr in ('dflt_ext', 'reg_spec', 'flags', 'sort_pri',
+                         'dflt_size', 'dflt_ctype', 'dflt_is_signed',
+                         'read_code', 'write_code'):
+                tmp_dict[attr] = eval(attr)
+            tmp_dict['base_name'] = op_name
+            # New class name will be e.g. "IntReg_Ra"
+            cls_name = base_cls_name + '_' + op_name
+            # Evaluate string arg to get class object.  Note that the
+            # actual base class for "IntReg" is "IntRegOperand", i.e. we
+            # have to append "Operand".
+            try:
+                base_cls = eval(base_cls_name + 'Operand')
+            except NameError:
+                error(lineno,
+                      'error: unknown operand base class "%s"' % base_cls_name)
+            # The following statement creates a new class called
+            # <cls_name> as a subclass of <base_cls> with the attributes
+            # in tmp_dict, just as if we evaluated a class declaration.
+            operand_name[op_name] = type(cls_name, (base_cls,), tmp_dict)
+
+        self.operandNameMap = operand_name
+
+        # Define operand variables.
+        operands = user_dict.keys()
+
+        operandsREString = (r'''
+        (?<![\w\.])      # neg. lookbehind assertion: prevent partial matches
+        ((%s)(?:\.(\w+))?)   # match: operand with optional '.' then suffix
+        (?![\w\.])       # neg. lookahead assertion: prevent partial matches
+        '''
+                            % string.join(operands, '|'))
+
+        self.operandsRE = re.compile(operandsREString, re.MULTILINE|re.VERBOSE)
+
+        # Same as operandsREString, but extension is mandatory, and only two
+        # groups are returned (base and ext, not full name as above).
+        # Used for subtituting '_' for '.' to make C++ identifiers.
+        operandsWithExtREString = (r'(?<![\w\.])(%s)\.(\w+)(?![\w\.])'
+                                   % string.join(operands, '|'))
+
+        self.operandsWithExtRE = \
+            re.compile(operandsWithExtREString, re.MULTILINE)
+
+    def substMungedOpNames(self, code):
+        '''Munge operand names in code string to make legal C++
+        variable names.  This means getting rid of the type extension
+        if any.  Will match base_name attribute of Operand object.)'''
+        return self.operandsWithExtRE.sub(r'\1', code)
+
+    def mungeSnippet(self, s):
+        '''Fix up code snippets for final substitution in templates.'''
+        if isinstance(s, str):
+            return self.substMungedOpNames(substBitOps(s))
+        else:
+            return s
+
     def update_if_needed(self, file, contents):
         '''Update the output file only if the new contents are
         different from the current contents.  Minimizes the files that
@@ -1984,14 +2006,14 @@ StaticInstPtr
         except IOError:
             error('Error including file "%s"' % filename)
 
-        fileNameStack.push((filename, 0))
+        self.fileNameStack.push((filename, 0))
 
         # Find any includes and include them
         def replace(matchobj):
             return self.replace_include(matchobj, current_dir)
         contents = self.includeRE.sub(replace, contents)
 
-        fileNameStack.pop()
+        self.fileNameStack.pop()
         return contents
 
     def _parse_isa_desc(self, isa_desc_file):
@@ -2003,7 +2025,7 @@ StaticInstPtr
         isa_desc = self.read_and_flatten(isa_desc_file)
 
         # Initialize filename stack with outer file.
-        fileNameStack.push((isa_desc_file, 0))
+        self.fileNameStack.push((isa_desc_file, 0))
 
         # Parse it.
         (isa_name, namespace, global_code, namespace_code) = \
@@ -2029,7 +2051,7 @@ StaticInstPtr
         self.update_if_needed('decoder.cc', file_template % vars())
 
         # generate per-cpu exec files
-        for cpu in cpu_models:
+        for cpu in self.cpuModels:
             includes = '#include "decoder.hh"\n'
             includes += cpu.includes
             global_output = global_code.exec_output[cpu.name]
@@ -2040,10 +2062,8 @@ StaticInstPtr
         # The variable names here are hacky, but this will creat local
         # variables which will be referenced in vars() which have the
         # value of the globals.
-        global maxInstSrcRegs
-        MaxInstSrcRegs = maxInstSrcRegs
-        global maxInstDestRegs
-        MaxInstDestRegs = maxInstDestRegs
+        MaxInstSrcRegs = self.maxInstSrcRegs
+        MaxInstDestRegs = self.maxInstDestRegs
         # max_inst_regs.hh
         self.update_if_needed('max_inst_regs.hh',
                               max_inst_regs_template % vars())
@@ -2052,15 +2072,11 @@ StaticInstPtr
         try:
             self._parse_isa_desc(*args, **kwargs)
         except ISAParserError, e:
-            e.exit(fileNameStack)
-
-# global list of CpuModel objects (see cpu_models.py)
-cpu_models = []
+            e.exit(self.fileNameStack)
 
 # Called as script: get args from command line.
 # Args are: <path to cpu_models.py> <isa desc file> <output dir> <cpu models>
 if __name__ == '__main__':
     execfile(sys.argv[1])  # read in CpuModel definitions
     cpu_models = [CpuModel.dict[cpu] for cpu in sys.argv[4:]]
-    parser = ISAParser(sys.argv[3])
-    parser.parse_isa_desc(sys.argv[2])
+    ISAParser(sys.argv[3], cpu_models).parse_isa_desc(sys.argv[2])