1// -*- mode:c++ -*-
2
3// Copyright (c) 2007 The Hewlett-Packard Development Company
4// All rights reserved.
5//
6// Redistribution and use of this software in source and binary forms,
7// with or without modification, are permitted provided that the
8// following conditions are met:
9//
10// The software must be used only for Non-Commercial Use which means any
11// use which is NOT directed to receiving any direct monetary
12// compensation for, or commercial advantage from such use. Illustrative
13// examples of non-commercial use are academic research, personal study,
14// teaching, education and corporate research & development.
15// Illustrative examples of commercial use are distributing products for
16// commercial advantage and providing services using the software for
17// commercial advantage.
18//
19// If you wish to use this software or functionality therein that may be
20// covered by patents for commercial use, please contact:
21// Director of Intellectual Property Licensing
22// Office of Strategy and Technology
23// Hewlett-Packard Company
24// 1501 Page Mill Road
25// Palo Alto, California 94304
26//
27// Redistributions of source code must retain the above copyright notice,
28// this list of conditions and the following disclaimer. Redistributions
29// in binary form must reproduce the above copyright notice, this list of
30// conditions and the following disclaimer in the documentation and/or
31// other materials provided with the distribution. Neither the name of
32// the COPYRIGHT HOLDER(s), HEWLETT-PACKARD COMPANY, nor the names of its
33// contributors may be used to endorse or promote products derived from
34// this software without specific prior written permission. No right of
35// sublicense is granted herewith. Derivatives of the software and
36// output created using the software may be prepared, but only for
37// Non-Commercial Uses. Derivatives of the software may be shared with
38// others provided: (i) the others agree to abide by the list of
39// conditions herein which includes the Non-Commercial Use restrictions;
40// and (ii) such Derivatives of the software include the above copyright
41// notice to acknowledge the contribution from this software where
42// applicable, this list of conditions and the disclaimer below.
43//
44// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
45// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
46// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
47// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
48// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
49// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
50// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
51// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
52// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
53// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
54// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
55//
56// Authors: Gabe Black
57
58////////////////////////////////////////////////////////////////////
59//
60// Code to "specialize" a microcode sequence to use a particular
61// variety of operands
62//
63
64let {{
| 1// -*- mode:c++ -*-
2
3// Copyright (c) 2007 The Hewlett-Packard Development Company
4// All rights reserved.
5//
6// Redistribution and use of this software in source and binary forms,
7// with or without modification, are permitted provided that the
8// following conditions are met:
9//
10// The software must be used only for Non-Commercial Use which means any
11// use which is NOT directed to receiving any direct monetary
12// compensation for, or commercial advantage from such use. Illustrative
13// examples of non-commercial use are academic research, personal study,
14// teaching, education and corporate research & development.
15// Illustrative examples of commercial use are distributing products for
16// commercial advantage and providing services using the software for
17// commercial advantage.
18//
19// If you wish to use this software or functionality therein that may be
20// covered by patents for commercial use, please contact:
21// Director of Intellectual Property Licensing
22// Office of Strategy and Technology
23// Hewlett-Packard Company
24// 1501 Page Mill Road
25// Palo Alto, California 94304
26//
27// Redistributions of source code must retain the above copyright notice,
28// this list of conditions and the following disclaimer. Redistributions
29// in binary form must reproduce the above copyright notice, this list of
30// conditions and the following disclaimer in the documentation and/or
31// other materials provided with the distribution. Neither the name of
32// the COPYRIGHT HOLDER(s), HEWLETT-PACKARD COMPANY, nor the names of its
33// contributors may be used to endorse or promote products derived from
34// this software without specific prior written permission. No right of
35// sublicense is granted herewith. Derivatives of the software and
36// output created using the software may be prepared, but only for
37// Non-Commercial Uses. Derivatives of the software may be shared with
38// others provided: (i) the others agree to abide by the list of
39// conditions herein which includes the Non-Commercial Use restrictions;
40// and (ii) such Derivatives of the software include the above copyright
41// notice to acknowledge the contribution from this software where
42// applicable, this list of conditions and the disclaimer below.
43//
44// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
45// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
46// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
47// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
48// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
49// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
50// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
51// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
52// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
53// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
54// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
55//
56// Authors: Gabe Black
57
58////////////////////////////////////////////////////////////////////
59//
60// Code to "specialize" a microcode sequence to use a particular
61// variety of operands
62//
63
64let {{
|
65 # This builds either a regular or macro op to implement the sequence of
66 # ops we give it.
67 def genInst(name, Name, ops):
68 # If we can implement this instruction with exactly one microop, just
69 # use that directly.
70 newStmnt = ''
71 if len(ops) == 1:
72 decode_block = "return %s;" % \
73 ops[0].getAllocator()
74 return ('', '', decode_block, '')
75 else:
76 # Build a macroop to contain the sequence of microops we've
77 # been given.
78 return genMacroOp(name, Name, ops)
79}};
80
81let {{
| |
82 # This code builds up a decode block which decodes based on switchval.
83 # vals is a dict which matches case values with what should be decoded to.
84 # builder is called on the exploded contents of "vals" values to generate
85 # whatever code should be used.
86 def doSplitDecode(name, Name, builder, switchVal, vals, default = None):
87 header_output = ''
88 decoder_output = ''
89 decode_block = 'switch(%s) {\n' % switchVal
90 exec_output = ''
91 for (val, todo) in vals.items():
92 (new_header_output,
93 new_decoder_output,
94 new_decode_block,
95 new_exec_output) = builder(name, Name, *todo)
96 header_output += new_header_output
97 decoder_output += new_decoder_output
98 decode_block += '\tcase %s: %s\n' % (val, new_decode_block)
99 exec_output += new_exec_output
100 if default:
101 (new_header_output,
102 new_decoder_output,
103 new_decode_block,
104 new_exec_output) = builder(name, Name, *default)
105 header_output += new_header_output
106 decoder_output += new_decoder_output
107 decode_block += '\tdefault: %s\n' % new_decode_block
108 exec_output += new_exec_output
109 decode_block += '}\n'
110 return (header_output, decoder_output, decode_block, exec_output)
111}};
112
113let {{
114 class OpType(object):
115 parser = re.compile(r"(?P<tag>[A-Z][A-Z]*)(?P<size>[a-z][a-z]*)|(r(?P<reg>[A-Za-z0-9][A-Za-z0-9]*))")
116 def __init__(self, opTypeString):
117 match = OpType.parser.search(opTypeString)
118 if match == None:
119 raise Exception, "Problem parsing operand type %s" % opTypeString
120 self.reg = match.group("reg")
121 self.tag = match.group("tag")
122 self.size = match.group("size")
123}};
124
125let {{
126
127 # This function specializes the given piece of code to use a particular
128 # set of argument types described by "opTypes". These are "implemented"
129 # in reverse order.
130 def specializeInst(name, Name, code, opTypes):
131 opNum = len(opTypes) - 1
132 while len(opTypes):
133 # print "Building a composite op with tags", opTypes
134 # print "And code", code
135 opNum = len(opTypes) - 1
136 # A regular expression to find the operand placeholders we're
137 # interested in.
138 opRe = re.compile("\\^(?P<operandNum>%d)(?=[^0-9]|$)" % opNum)
139
140 # Parse the operand type strign we're working with
141 opType = OpType(opTypes[opNum])
142
143 if opType.reg:
144 #Figure out what to do with fixed register operands
145 if opType.reg in ("Ax", "Bx", "Cx", "Dx"):
146 code = opRe.sub("%%{INTREG_R%s}" % opType.reg.upper(), code)
147 elif opType.reg == "Al":
148 # We need a way to specify register width
149 code = opRe.sub("%{INTREG_RAX}", code)
150 else:
151 print "Didn't know how to encode fixed register %s!" % opType.reg
152 elif opType.tag == None or opType.size == None:
153 raise Exception, "Problem parsing operand tag: %s" % opType.tag
154 elif opType.tag in ("C", "D", "G", "P", "S", "T", "V"):
155 # Use the "reg" field of the ModRM byte to select the register
156 code = opRe.sub("%{(uint8_t)MODRM_REG}", code)
157 elif opType.tag in ("E", "Q", "W"):
158 # This might refer to memory or to a register. We need to
159 # divide it up farther.
160 regCode = opRe.sub("%{(uint8_t)MODRM_RM}", code)
161 regTypes = copy.copy(opTypes)
162 regTypes.pop(-1)
163 # This needs to refer to memory, but we'll fill in the details
164 # later. It needs to take into account unaligned memory
165 # addresses.
166 memCode = opRe.sub("%0", code)
167 memTypes = copy.copy(opTypes)
168 memTypes.pop(-1)
169 return doSplitDecode(name, Name, specializeInst, "MODRM_MOD",
170 {"3" : (regCode, regTypes)}, (memCode, memTypes))
171 elif opType.tag in ("I", "J"):
172 # Immediates are already in the instruction, so don't leave in
173 # those parameters
174 code = opRe.sub("${IMMEDIATE}", code)
175 elif opType.tag == "M":
176 # This needs to refer to memory, but we'll fill in the details
177 # later. It needs to take into account unaligned memory
178 # addresses.
179 code = opRe.sub("%0", code)
180 elif opType.tag in ("PR", "R", "VR"):
181 # There should probably be a check here to verify that mod
182 # is equal to 11b
183 code = opRe.sub("%{(uint8_t)MODRM_RM}", code)
184 else:
185 raise Exception, "Unrecognized tag %s." % opType.tag
186 opTypes.pop(-1)
187
188 # At this point, we've built up "code" to have all the necessary extra
189 # instructions needed to implement whatever types of operands were
| 65 # This code builds up a decode block which decodes based on switchval.
66 # vals is a dict which matches case values with what should be decoded to.
67 # builder is called on the exploded contents of "vals" values to generate
68 # whatever code should be used.
69 def doSplitDecode(name, Name, builder, switchVal, vals, default = None):
70 header_output = ''
71 decoder_output = ''
72 decode_block = 'switch(%s) {\n' % switchVal
73 exec_output = ''
74 for (val, todo) in vals.items():
75 (new_header_output,
76 new_decoder_output,
77 new_decode_block,
78 new_exec_output) = builder(name, Name, *todo)
79 header_output += new_header_output
80 decoder_output += new_decoder_output
81 decode_block += '\tcase %s: %s\n' % (val, new_decode_block)
82 exec_output += new_exec_output
83 if default:
84 (new_header_output,
85 new_decoder_output,
86 new_decode_block,
87 new_exec_output) = builder(name, Name, *default)
88 header_output += new_header_output
89 decoder_output += new_decoder_output
90 decode_block += '\tdefault: %s\n' % new_decode_block
91 exec_output += new_exec_output
92 decode_block += '}\n'
93 return (header_output, decoder_output, decode_block, exec_output)
94}};
95
96let {{
97 class OpType(object):
98 parser = re.compile(r"(?P<tag>[A-Z][A-Z]*)(?P<size>[a-z][a-z]*)|(r(?P<reg>[A-Za-z0-9][A-Za-z0-9]*))")
99 def __init__(self, opTypeString):
100 match = OpType.parser.search(opTypeString)
101 if match == None:
102 raise Exception, "Problem parsing operand type %s" % opTypeString
103 self.reg = match.group("reg")
104 self.tag = match.group("tag")
105 self.size = match.group("size")
106}};
107
108let {{
109
110 # This function specializes the given piece of code to use a particular
111 # set of argument types described by "opTypes". These are "implemented"
112 # in reverse order.
113 def specializeInst(name, Name, code, opTypes):
114 opNum = len(opTypes) - 1
115 while len(opTypes):
116 # print "Building a composite op with tags", opTypes
117 # print "And code", code
118 opNum = len(opTypes) - 1
119 # A regular expression to find the operand placeholders we're
120 # interested in.
121 opRe = re.compile("\\^(?P<operandNum>%d)(?=[^0-9]|$)" % opNum)
122
123 # Parse the operand type strign we're working with
124 opType = OpType(opTypes[opNum])
125
126 if opType.reg:
127 #Figure out what to do with fixed register operands
128 if opType.reg in ("Ax", "Bx", "Cx", "Dx"):
129 code = opRe.sub("%%{INTREG_R%s}" % opType.reg.upper(), code)
130 elif opType.reg == "Al":
131 # We need a way to specify register width
132 code = opRe.sub("%{INTREG_RAX}", code)
133 else:
134 print "Didn't know how to encode fixed register %s!" % opType.reg
135 elif opType.tag == None or opType.size == None:
136 raise Exception, "Problem parsing operand tag: %s" % opType.tag
137 elif opType.tag in ("C", "D", "G", "P", "S", "T", "V"):
138 # Use the "reg" field of the ModRM byte to select the register
139 code = opRe.sub("%{(uint8_t)MODRM_REG}", code)
140 elif opType.tag in ("E", "Q", "W"):
141 # This might refer to memory or to a register. We need to
142 # divide it up farther.
143 regCode = opRe.sub("%{(uint8_t)MODRM_RM}", code)
144 regTypes = copy.copy(opTypes)
145 regTypes.pop(-1)
146 # This needs to refer to memory, but we'll fill in the details
147 # later. It needs to take into account unaligned memory
148 # addresses.
149 memCode = opRe.sub("%0", code)
150 memTypes = copy.copy(opTypes)
151 memTypes.pop(-1)
152 return doSplitDecode(name, Name, specializeInst, "MODRM_MOD",
153 {"3" : (regCode, regTypes)}, (memCode, memTypes))
154 elif opType.tag in ("I", "J"):
155 # Immediates are already in the instruction, so don't leave in
156 # those parameters
157 code = opRe.sub("${IMMEDIATE}", code)
158 elif opType.tag == "M":
159 # This needs to refer to memory, but we'll fill in the details
160 # later. It needs to take into account unaligned memory
161 # addresses.
162 code = opRe.sub("%0", code)
163 elif opType.tag in ("PR", "R", "VR"):
164 # There should probably be a check here to verify that mod
165 # is equal to 11b
166 code = opRe.sub("%{(uint8_t)MODRM_RM}", code)
167 else:
168 raise Exception, "Unrecognized tag %s." % opType.tag
169 opTypes.pop(-1)
170
171 # At this point, we've built up "code" to have all the necessary extra
172 # instructions needed to implement whatever types of operands were
|
190 # specified. Now we'll assemble it it into a microOp sequence.
191 ops = assembleMicro(code)
192
193 # Build a macroop to contain the sequence of microops we've
194 # constructed. The decode block will be used to fill in our
195 # inner decode structure, and the rest will be concatenated and
196 # passed back.
197 return genInst(name, Name, ops)
| 173 # specified. Now we'll assemble it it into a StaticInst.
174 return assembleMicro(name, Name, code)
|
198}};
199
200////////////////////////////////////////////////////////////////////
201//
202// The microcode assembler
203//
204
205let {{
| 175}};
176
177////////////////////////////////////////////////////////////////////
178//
179// The microcode assembler
180//
181
182let {{
|
| 183 # These are used when setting up microops so that they can specialize their
184 # base class template properly.
185 RegOpType = "RegisterOperand"
186 ImmOpType = "ImmediateOperand"
187}};
188
189let {{
|
206 class MicroOpStatement(object):
207 def __init__(self):
208 self.className = ''
209 self.label = ''
210 self.args = []
211
212 # This converts a list of python bools into
213 # a comma seperated list of C++ bools.
214 def microFlagsText(self, vals):
215 text = ""
216 for val in vals:
217 if val:
218 text += ", true"
219 else:
220 text += ", false"
221 return text
222
223 def getAllocator(self, *microFlags):
224 args = ''
225 signature = "<"
226 emptySig = True
227 for arg in self.args:
228 if not emptySig:
229 signature += ", "
230 emptySig = False
231 if arg.has_key("operandImm"):
232 args += ", %s" % arg["operandImm"]
233 signature += ImmOpType
234 elif arg.has_key("operandReg"):
235 args += ", %s" % arg["operandReg"]
236 signature += RegOpType
237 elif arg.has_key("operandLabel"):
238 raise Exception, "Found a label while creating allocator string."
239 else:
240 raise Exception, "Unrecognized operand type."
241 signature += ">"
242 return 'new %s%s(machInst%s%s)' % (self.className, signature, self.microFlagsText(microFlags), args)
243}};
244
| 190 class MicroOpStatement(object):
191 def __init__(self):
192 self.className = ''
193 self.label = ''
194 self.args = []
195
196 # This converts a list of python bools into
197 # a comma seperated list of C++ bools.
198 def microFlagsText(self, vals):
199 text = ""
200 for val in vals:
201 if val:
202 text += ", true"
203 else:
204 text += ", false"
205 return text
206
207 def getAllocator(self, *microFlags):
208 args = ''
209 signature = "<"
210 emptySig = True
211 for arg in self.args:
212 if not emptySig:
213 signature += ", "
214 emptySig = False
215 if arg.has_key("operandImm"):
216 args += ", %s" % arg["operandImm"]
217 signature += ImmOpType
218 elif arg.has_key("operandReg"):
219 args += ", %s" % arg["operandReg"]
220 signature += RegOpType
221 elif arg.has_key("operandLabel"):
222 raise Exception, "Found a label while creating allocator string."
223 else:
224 raise Exception, "Unrecognized operand type."
225 signature += ">"
226 return 'new %s%s(machInst%s%s)' % (self.className, signature, self.microFlagsText(microFlags), args)
227}};
228
|
245let {{
246 def buildLabelDict(ops):
247 labels = {}
248 micropc = 0
249 for op in ops:
250 if op.label:
251 labels[op.label] = count
252 micropc += 1
253 return labels
254}};
255
| |
256let{{
| 229let{{
|
257 def assembleMicro(code):
| 230 def assembleMicro(name, Name, code):
231
|
258 # This function takes in a block of microcode assembly and returns
259 # a python list of objects which describe it.
260
261 # Keep this around in case we need it later
262 orig_code = code
263 # A list of the statements we've found thus far
264 statements = []
265
266 # Regular expressions to pull each piece of the statement out at a
267 # time. Each expression expects the thing it's looking for to be at
268 # the beginning of the line, so the previous component is stripped
269 # before continuing.
270 labelRe = re.compile(r'^[ \t]*(?P<label>\w\w*)[ \t]:')
271 lineRe = re.compile(r'^(?P<line>[^\n][^\n]*)$')
272 classRe = re.compile(r'^[ \t]*(?P<className>[a-zA-Z_]\w*)')
273 # This recognizes three different flavors of operands:
274 # 1. Raw decimal numbers composed of digits between 0 and 9
275 # 2. Code beginning with "{" and continuing until the first "}"
276 # ^ This one might need revising
277 # 3. A label, which starts with a capital or small letter, or
278 # underscore, which is optionally followed by a sequence of
279 # capital or small letters, underscores, or digts between 0 and 9
280 opRe = re.compile( \
281 r'^[ \t]*((\@(?P<operandLabel0>\w\w*))|' +
282 r'(\@\{(?P<operandLabel1>[^}]*)\})|' +
283 r'(\%(?P<operandReg0>\w\w*))|' +
284 r'(\%\{(?P<operandReg1>[^}]*)\})|' +
285 r'(\$(?P<operandImm0>\w\w*))|' +
286 r'(\$\{(?P<operandImm1>[^}]*)\}))')
287 lineMatch = lineRe.search(code)
288 while lineMatch != None:
289 statement = MicroOpStatement()
290 # Get a line and seperate it from the rest of the code
291 line = lineMatch.group("line")
292 orig_line = line
293 # print "Parsing line %s" % line
294 code = lineRe.sub('', code, 1)
295
296 # Find the label, if any
297 labelMatch = labelRe.search(line)
298 if labelMatch != None:
299 statement.label = labelMatch.group("label")
300 # print "Found label %s." % statement.label
301 # Clear the label from the statement
302 line = labelRe.sub('', line, 1)
303
304 # Find the class name which is roughly equivalent to the op name
305 classMatch = classRe.search(line)
306 if classMatch == None:
307 raise Exception, "Couldn't find class name in statement: %s" \
308 % orig_line
309 else:
310 statement.className = classMatch.group("className")
311 # print "Found class name %s." % statement.className
312
313 # Clear the class name from the statement
314 line = classRe.sub('', line, 1)
315
316 #Find as many arguments as you can
317 statement.args = []
318 opMatch = opRe.search(line)
319 while opMatch is not None:
320 statement.args.append({})
321 # args is a list of dicts which collect different
322 # representations of operand values. Different forms might be
323 # needed in different places, for instance to replace a label
324 # with an offset.
325 for opType in ("operandLabel0", "operandReg0", "operandImm0",
326 "operandLabel1", "operandReg1", "operandImm1"):
327 if opMatch.group(opType):
328 statement.args[-1][opType[:-1]] = opMatch.group(opType)
329 if len(statement.args[-1]) == 0:
330 print "Problem parsing operand in statement: %s" \
331 % orig_line
332 line = opRe.sub('', line, 1)
333 # print "Found operand %s." % statement.args[-1]
334 opMatch = opRe.search(line)
335 # print "Found operands", statement.args
336
337 # Add this statement to our collection
338 statements.append(statement)
339
340 # Get the next line
341 lineMatch = lineRe.search(code)
342
343 # Decode the labels into displacements
| 232 # This function takes in a block of microcode assembly and returns
233 # a python list of objects which describe it.
234
235 # Keep this around in case we need it later
236 orig_code = code
237 # A list of the statements we've found thus far
238 statements = []
239
240 # Regular expressions to pull each piece of the statement out at a
241 # time. Each expression expects the thing it's looking for to be at
242 # the beginning of the line, so the previous component is stripped
243 # before continuing.
244 labelRe = re.compile(r'^[ \t]*(?P<label>\w\w*)[ \t]:')
245 lineRe = re.compile(r'^(?P<line>[^\n][^\n]*)$')
246 classRe = re.compile(r'^[ \t]*(?P<className>[a-zA-Z_]\w*)')
247 # This recognizes three different flavors of operands:
248 # 1. Raw decimal numbers composed of digits between 0 and 9
249 # 2. Code beginning with "{" and continuing until the first "}"
250 # ^ This one might need revising
251 # 3. A label, which starts with a capital or small letter, or
252 # underscore, which is optionally followed by a sequence of
253 # capital or small letters, underscores, or digts between 0 and 9
254 opRe = re.compile( \
255 r'^[ \t]*((\@(?P<operandLabel0>\w\w*))|' +
256 r'(\@\{(?P<operandLabel1>[^}]*)\})|' +
257 r'(\%(?P<operandReg0>\w\w*))|' +
258 r'(\%\{(?P<operandReg1>[^}]*)\})|' +
259 r'(\$(?P<operandImm0>\w\w*))|' +
260 r'(\$\{(?P<operandImm1>[^}]*)\}))')
261 lineMatch = lineRe.search(code)
262 while lineMatch != None:
263 statement = MicroOpStatement()
264 # Get a line and seperate it from the rest of the code
265 line = lineMatch.group("line")
266 orig_line = line
267 # print "Parsing line %s" % line
268 code = lineRe.sub('', code, 1)
269
270 # Find the label, if any
271 labelMatch = labelRe.search(line)
272 if labelMatch != None:
273 statement.label = labelMatch.group("label")
274 # print "Found label %s." % statement.label
275 # Clear the label from the statement
276 line = labelRe.sub('', line, 1)
277
278 # Find the class name which is roughly equivalent to the op name
279 classMatch = classRe.search(line)
280 if classMatch == None:
281 raise Exception, "Couldn't find class name in statement: %s" \
282 % orig_line
283 else:
284 statement.className = classMatch.group("className")
285 # print "Found class name %s." % statement.className
286
287 # Clear the class name from the statement
288 line = classRe.sub('', line, 1)
289
290 #Find as many arguments as you can
291 statement.args = []
292 opMatch = opRe.search(line)
293 while opMatch is not None:
294 statement.args.append({})
295 # args is a list of dicts which collect different
296 # representations of operand values. Different forms might be
297 # needed in different places, for instance to replace a label
298 # with an offset.
299 for opType in ("operandLabel0", "operandReg0", "operandImm0",
300 "operandLabel1", "operandReg1", "operandImm1"):
301 if opMatch.group(opType):
302 statement.args[-1][opType[:-1]] = opMatch.group(opType)
303 if len(statement.args[-1]) == 0:
304 print "Problem parsing operand in statement: %s" \
305 % orig_line
306 line = opRe.sub('', line, 1)
307 # print "Found operand %s." % statement.args[-1]
308 opMatch = opRe.search(line)
309 # print "Found operands", statement.args
310
311 # Add this statement to our collection
312 statements.append(statement)
313
314 # Get the next line
315 lineMatch = lineRe.search(code)
316
317 # Decode the labels into displacements
|
344 labels = buildLabelDict(statements)
| 318
319 labels = {}
|
345 micropc = 0
346 for statement in statements:
| 320 micropc = 0
321 for statement in statements:
|
| 322 if statement.label:
323 labels[statement.label] = count
324 micropc += 1
325 micropc = 0
326 for statement in statements:
|
347 for arg in statement.args:
348 if arg.has_key("operandLabel"):
349 if not labels.has_key(arg["operandLabel"]):
350 raise Exception, "Unrecognized label: %s." % arg["operandLabel"]
351 # This is assuming that intra microcode branches go to
352 # the next micropc + displacement, or
353 # micropc + 1 + displacement.
354 arg["operandImm"] = labels[arg["operandLabel"]] - micropc - 1
355 micropc += 1
| 327 for arg in statement.args:
328 if arg.has_key("operandLabel"):
329 if not labels.has_key(arg["operandLabel"]):
330 raise Exception, "Unrecognized label: %s." % arg["operandLabel"]
331 # This is assuming that intra microcode branches go to
332 # the next micropc + displacement, or
333 # micropc + 1 + displacement.
334 arg["operandImm"] = labels[arg["operandLabel"]] - micropc - 1
335 micropc += 1
|
356 return statements
| 336
337 # If we can implement this instruction with exactly one microop, just
338 # use that directly.
339 if len(statements) == 1:
340 decode_block = "return %s;" % \
341 statements[0].getAllocator()
342 return ('', '', decode_block, '')
343 else:
344 # Build a macroop to contain the sequence of microops we've
345 # been given.
346 return genMacroOp(name, Name, statements)
|
357}};
| 347}};
|