Reworking x86's microcode system. This is a work in progress, and X86 doesn't compile.

src/arch/x86/isa/decoder/one_byte_opcodes.isa:
src/arch/x86/isa/macroop.isa:
src/arch/x86/isa/main.isa:
src/arch/x86/isa/microasm.isa:
src/arch/x86/isa/microops/base.isa:
src/arch/x86/isa/microops/microops.isa:
src/arch/x86/isa/operands.isa:
src/arch/x86/isa/microops/regop.isa:
src/arch/x86/isa/microops/specop.isa:
    Reworking x86's microcode system

--HG--
extra : convert_revision : cab66be59ed758b192226af17eddd5a86aa190f3

1 files changed, 13 insertions, 151 deletions

diff --git a/src/arch/x86/isa/microasm.isa b/src/arch/x86/isa/microasm.isa
index 9d21b6bcc..50a0b10e7 100644
--- a/src/arch/x86/isa/microasm.isa
+++ b/src/arch/x86/isa/microasm.isa
@@ -57,22 +57,24 @@
 
 ////////////////////////////////////////////////////////////////////
 //
-//  The microcode assembler
+// Microcode assembler specialization for x86
 //
 
 let {{
-    # These are used when setting up microops so that they can specialize their
-    # base class template properly.
-    RegOpType = "RegisterOperand"
-    ImmOpType = "ImmediateOperand"
+    from micro_asm import MicroAssembler, Combinational_Macroop, Rom_Macroop, Rom
+    class X86Macroop(Combinational_Macroop):
+        def __init__(self, name):
+            super(X86Macroop, self).__init__(name)
+            self.directives = {
+            }
+
+    mainRom = Rom('main ROM')
 }};
 
 let {{
-    class MicroOpStatement(object):
-        def __init__(self):
-            self.className = ''
-            self.label = ''
-            self.args = []
+    class X86Microop(object):
+        def __init__(self, name):
+            self.name = name
 
         # This converts a list of python bools into
         # a comma seperated list of C++ bools.
@@ -87,145 +89,5 @@ let {{
 
         def getAllocator(self, mnemonic, *microFlags):
             args = ''
-            signature = "<"
-            emptySig = True
-            for arg in self.args:
-                if not emptySig:
-                    signature += ", "
-                emptySig = False
-                if arg.has_key("operandImm"):
-                    args += ", %s" % arg["operandImm"]
-                    signature += ImmOpType
-                elif arg.has_key("operandReg"):
-                    args += ", %s" % arg["operandReg"]
-                    signature += RegOpType
-                elif arg.has_key("operandLabel"):
-                    raise Exception, "Found a label while creating allocator string."
-                else:
-                    raise Exception, "Unrecognized operand type."
-            signature += ">"
-            return 'new %s%s(machInst, %s%s%s)' % (self.className, signature, mnemonic, self.microFlagsText(microFlags), args)
-}};
-
-let{{
-    def assembleMicro(name, Name, code):
-
-        # This function takes in a block of microcode assembly and returns
-        # a python list of objects which describe it.
-
-        # Keep this around in case we need it later
-        orig_code = code
-        # A list of the statements we've found thus far
-        statements = []
-
-        # Regular expressions to pull each piece of the statement out at a
-        # time. Each expression expects the thing it's looking for to be at
-        # the beginning of the line, so the previous component is stripped
-        # before continuing.
-        labelRe = re.compile(r'^[ \t]*(?P<label>\w\w*)[ \t]:')
-        lineRe = re.compile(r'^(?P<line>..*)(\n|$)')
-        classRe = re.compile(r'^[ \t]*(?P<className>[a-zA-Z_]\w*)')
-        # This recognizes three different flavors of operands:
-        # 1. Raw decimal numbers composed of digits between 0 and 9
-        # 2. Code beginning with "{" and continuing until the first "}"
-        #         ^ This one might need revising
-        # 3. A label, which starts with a capital or small letter, or
-        #    underscore, which is optionally followed by a sequence of
-        #    capital or small letters, underscores, or digts between 0 and 9
-        opRe = re.compile( \
-            r'^[ \t]*((\@(?P<operandLabel0>\w\w*))|' +
-                    r'(\@\{(?P<operandLabel1>[^}]*)\})|' +
-                    r'(\%(?P<operandReg0>\w\w*))|' +
-                    r'(\%\{(?P<operandReg1>[^}]*)\})|' +
-                    r'(\$(?P<operandImm0>\w\w*))|' +
-                    r'(\$\{(?P<operandImm1>[^}]*)\}))')
-        lineMatch = lineRe.search(code)
-        while lineMatch != None:
-            statement = MicroOpStatement()
-            # Get a line and seperate it from the rest of the code
-            line = lineMatch.group("line")
-            orig_line = line
-            #print "Parsing line %s" % line
-            code = lineRe.sub('', code, 1)
-
-            # Find the label, if any
-            labelMatch = labelRe.search(line)
-            if labelMatch != None:
-                statement.label = labelMatch.group("label")
-                #print "Found label %s." % statement.label
-            # Clear the label from the statement
-            line = labelRe.sub('', line, 1)
-
-            # Find the class name which is roughly equivalent to the op name
-            classMatch = classRe.search(line)
-            if classMatch == None:
-                raise Exception, "Couldn't find class name in statement: %s" \
-                        % orig_line
-            else:
-                statement.className = classMatch.group("className")
-                #print "Found class name %s." % statement.className
-
-            # Clear the class name from the statement
-            line = classRe.sub('', line, 1)
-
-            #Find as many arguments as you can
-            statement.args = []
-            opMatch = opRe.search(line)
-            while opMatch is not None:
-                statement.args.append({})
-                # args is a list of dicts which collect different
-                # representations of operand values. Different forms might be
-                # needed in different places, for instance to replace a label
-                # with an offset.
-                for opType in ("operandLabel0", "operandReg0", "operandImm0",
-                               "operandLabel1", "operandReg1", "operandImm1"):
-                    if opMatch.group(opType):
-                        statement.args[-1][opType[:-1]] = opMatch.group(opType)
-                if len(statement.args[-1]) == 0:
-                    print "Problem parsing operand in statement: %s" \
-                            % orig_line
-                line = opRe.sub('', line, 1)
-                #print "Found operand %s." % statement.args[-1]
-                opMatch = opRe.search(line)
-            #print "Found operands", statement.args
-
-            # Add this statement to our collection
-            statements.append(statement)
-
-            # Get the next line
-            lineMatch = lineRe.search(code)
-
-        # Decode the labels into displacements
-
-        labels = {}
-        micropc = 0
-        for statement in statements:
-            if statement.label:
-                labels[statement.label] = count
-            micropc += 1
-        micropc = 0
-        for statement in statements:
-            for arg in statement.args:
-                if arg.has_key("operandLabel"):
-                    if not labels.has_key(arg["operandLabel"]):
-                        raise Exception, "Unrecognized label: %s." % arg["operandLabel"]
-                    # This is assuming that intra microcode branches go to
-                    # the next micropc + displacement, or
-                    # micropc + 1 + displacement.
-                    arg["operandImm"] = labels[arg["operandLabel"]] - micropc - 1
-            micropc += 1
-
-        if len(statements) == 0:
-            raise Exception, "Didn't find any microops in microcode: \n%s" % orig_code
-
-        # If we can implement this instruction with exactly one microop, just
-        # use that directly.
-        if len(statements) == 1:
-            decode_block = "return %s;" % \
-                            statements[0].getAllocator('"' + name + '"')
-            return ('', '', decode_block, '')
-        else:
-            # Build a macroop to contain the sequence of microops we've
-            # been given.
-            return genMacroOp(name, Name, statements)
+            return 'new %s(machInst, %s%s%s)' % (self.className, mnemonic, self.microFlagsText(microFlags), args)
 }};