1# Copyright (c) 2003-2005 The Regents of The University of Michigan
2# All rights reserved.
3#
4# Redistribution and use in source and binary forms, with or without
5# modification, are permitted provided that the following conditions are
6# met: redistributions of source code must retain the above copyright
7# notice, this list of conditions and the following disclaimer;
8# redistributions in binary form must reproduce the above copyright
9# notice, this list of conditions and the following disclaimer in the
10# documentation and/or other materials provided with the distribution;
11# neither the name of the copyright holders nor the names of its
12# contributors may be used to endorse or promote products derived from
13# this software without specific prior written permission.
14#
15# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
16# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
17# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
18# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
19# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
20# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
21# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
22# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
23# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
25# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26#
27# Authors: Steve Reinhardt
28
29import os
30import sys
31import re
32import string
33import inspect, traceback
34# get type names
35from types import *
36
37from m5.util.grammar import Grammar
38
39debug=False
40
41###################
42# Utility functions
43
44#
45# Indent every line in string 's' by two spaces
46# (except preprocessor directives).
47# Used to make nested code blocks look pretty.
48#
49def indent(s):
50 return re.sub(r'(?m)^(?!#)', ' ', s)
51
52#
53# Munge a somewhat arbitrarily formatted piece of Python code
54# (e.g. from a format 'let' block) into something whose indentation
55# will get by the Python parser.
56#
57# The two keys here are that Python will give a syntax error if
58# there's any whitespace at the beginning of the first line, and that
59# all lines at the same lexical nesting level must have identical
60# indentation. Unfortunately the way code literals work, an entire
61# let block tends to have some initial indentation. Rather than
62# trying to figure out what that is and strip it off, we prepend 'if
63# 1:' to make the let code the nested block inside the if (and have
64# the parser automatically deal with the indentation for us).
65#
66# We don't want to do this if (1) the code block is empty or (2) the
67# first line of the block doesn't have any whitespace at the front.
68
69def fixPythonIndentation(s):
70 # get rid of blank lines first
71 s = re.sub(r'(?m)^\s*\n', '', s);
72 if (s != '' and re.match(r'[ \t]', s[0])):
73 s = 'if 1:\n' + s
74 return s
75
76class ISAParserError(Exception):
77 """Error handler for parser errors"""
78 def __init__(self, first, second=None):
79 if second is None:
80 self.lineno = 0
81 self.string = first
82 else:
83 if hasattr(first, 'lexer'):
84 first = first.lexer.lineno
85 self.lineno = first
86 self.string = second
87
88 def display(self, filename_stack, print_traceback=debug):
89 # Output formatted to work under Emacs compile-mode. Optional
90 # 'print_traceback' arg, if set to True, prints a Python stack
91 # backtrace too (can be handy when trying to debug the parser
92 # itself).
93
94 spaces = ""
95 for (filename, line) in filename_stack[:-1]:
96 print "%sIn file included from %s:" % (spaces, filename)
97 spaces += " "
98
99 # Print a Python stack backtrace if requested.
100 if print_traceback or not self.lineno:
101 traceback.print_exc()
102
103 line_str = "%s:" % (filename_stack[-1][0], )
104 if self.lineno:
105 line_str += "%d:" % (self.lineno, )
106
107 return "%s%s %s" % (spaces, line_str, self.string)
108
109 def exit(self, filename_stack, print_traceback=debug):
110 # Just call exit.
111
112 sys.exit(self.display(filename_stack, print_traceback))
113
114def error(*args):
115 raise ISAParserError(*args)
116
117####################
118# Template objects.
119#
120# Template objects are format strings that allow substitution from
121# the attribute spaces of other objects (e.g. InstObjParams instances).
122
123labelRE = re.compile(r'(?<!%)%\(([^\)]+)\)[sd]')
124
125class Template(object):
126 def __init__(self, parser, t):
127 self.parser = parser
128 self.template = t
129
130 def subst(self, d):
131 myDict = None
132
133 # Protect non-Python-dict substitutions (e.g. if there's a printf
134 # in the templated C++ code)
135 template = self.parser.protectNonSubstPercents(self.template)
136 # CPU-model-specific substitutions are handled later (in GenCode).
137 template = self.parser.protectCpuSymbols(template)
138
139 # Build a dict ('myDict') to use for the template substitution.
140 # Start with the template namespace. Make a copy since we're
141 # going to modify it.
142 myDict = self.parser.templateMap.copy()
143
144 if isinstance(d, InstObjParams):
145 # If we're dealing with an InstObjParams object, we need
146 # to be a little more sophisticated. The instruction-wide
147 # parameters are already formed, but the parameters which
148 # are only function wide still need to be generated.
149 compositeCode = ''
150
151 myDict.update(d.__dict__)
152 # The "operands" and "snippets" attributes of the InstObjParams
153 # objects are for internal use and not substitution.
154 del myDict['operands']
155 del myDict['snippets']
156
157 snippetLabels = [l for l in labelRE.findall(template)
158 if d.snippets.has_key(l)]
159
160 snippets = dict([(s, self.parser.mungeSnippet(d.snippets[s]))
161 for s in snippetLabels])
162
163 myDict.update(snippets)
164
165 compositeCode = ' '.join(map(str, snippets.values()))
166
167 # Add in template itself in case it references any
168 # operands explicitly (like Mem)
169 compositeCode += ' ' + template
170
171 operands = SubOperandList(self.parser, compositeCode, d.operands)
172
173 myDict['op_decl'] = operands.concatAttrStrings('op_decl')
174
175 is_src = lambda op: op.is_src
176 is_dest = lambda op: op.is_dest
177
178 myDict['op_src_decl'] = \
179 operands.concatSomeAttrStrings(is_src, 'op_src_decl')
180 myDict['op_dest_decl'] = \
181 operands.concatSomeAttrStrings(is_dest, 'op_dest_decl')
182
183 myDict['op_rd'] = operands.concatAttrStrings('op_rd')
184 myDict['op_wb'] = operands.concatAttrStrings('op_wb')
185
186 if d.operands.memOperand:
187 myDict['mem_acc_size'] = d.operands.memOperand.mem_acc_size
188 myDict['mem_acc_type'] = d.operands.memOperand.mem_acc_type
189
190 elif isinstance(d, dict):
191 # if the argument is a dictionary, we just use it.
192 myDict.update(d)
193 elif hasattr(d, '__dict__'):
194 # if the argument is an object, we use its attribute map.
195 myDict.update(d.__dict__)
196 else:
197 raise TypeError, "Template.subst() arg must be or have dictionary"
198 return template % myDict
199
200 # Convert to string. This handles the case when a template with a
201 # CPU-specific term gets interpolated into another template or into
202 # an output block.
203 def __str__(self):
204 return self.parser.expandCpuSymbolsToString(self.template)
205
206################
207# Format object.
208#
209# A format object encapsulates an instruction format. It must provide
210# a defineInst() method that generates the code for an instruction
211# definition.
212
213class Format(object):
214 def __init__(self, id, params, code):
215 self.id = id
216 self.params = params
217 label = 'def format ' + id
218 self.user_code = compile(fixPythonIndentation(code), label, 'exec')
219 param_list = string.join(params, ", ")
220 f = '''def defInst(_code, _context, %s):
221 my_locals = vars().copy()
222 exec _code in _context, my_locals
223 return my_locals\n''' % param_list
224 c = compile(f, label + ' wrapper', 'exec')
225 exec c
226 self.func = defInst
227
228 def defineInst(self, parser, name, args, lineno):
229 parser.updateExportContext()
230 context = parser.exportContext.copy()
231 if len(name):
232 Name = name[0].upper()
233 if len(name) > 1:
234 Name += name[1:]
235 context.update({ 'name' : name, 'Name' : Name })
236 try:
237 vars = self.func(self.user_code, context, *args[0], **args[1])
238 except Exception, exc:
239 if debug:
240 raise
241 error(lineno, 'error defining "%s": %s.' % (name, exc))
242 for k in vars.keys():
243 if k not in ('header_output', 'decoder_output',
244 'exec_output', 'decode_block'):
245 del vars[k]
246 return GenCode(parser, **vars)
247
248# Special null format to catch an implicit-format instruction
249# definition outside of any format block.
250class NoFormat(object):
251 def __init__(self):
252 self.defaultInst = ''
253
254 def defineInst(self, parser, name, args, lineno):
255 error(lineno,
256 'instruction definition "%s" with no active format!' % name)
257
258###############
259# GenCode class
260#
261# The GenCode class encapsulates generated code destined for various
262# output files. The header_output and decoder_output attributes are
263# strings containing code destined for decoder.hh and decoder.cc
264# respectively. The decode_block attribute contains code to be
265# incorporated in the decode function itself (that will also end up in
266# decoder.cc). The exec_output attribute is a dictionary with a key
267# for each CPU model name; the value associated with a particular key
268# is the string of code for that CPU model's exec.cc file. The
269# has_decode_default attribute is used in the decode block to allow
270# explicit default clauses to override default default clauses.
271
272class GenCode(object):
273 # Constructor. At this point we substitute out all CPU-specific
274 # symbols. For the exec output, these go into the per-model
275 # dictionary. For all other output types they get collapsed into
276 # a single string.
277 def __init__(self, parser,
278 header_output = '', decoder_output = '', exec_output = '',
279 decode_block = '', has_decode_default = False):
280 self.parser = parser
281 self.header_output = parser.expandCpuSymbolsToString(header_output)
282 self.decoder_output = parser.expandCpuSymbolsToString(decoder_output)
283 if isinstance(exec_output, dict):
284 self.exec_output = exec_output
285 elif isinstance(exec_output, str):
286 # If the exec_output arg is a single string, we replicate
287 # it for each of the CPU models, substituting and
288 # %(CPU_foo)s params appropriately.
289 self.exec_output = parser.expandCpuSymbolsToDict(exec_output)
290 self.decode_block = parser.expandCpuSymbolsToString(decode_block)
291 self.has_decode_default = has_decode_default
292
293 # Override '+' operator: generate a new GenCode object that
294 # concatenates all the individual strings in the operands.
295 def __add__(self, other):
296 exec_output = {}
297 for cpu in self.parser.cpuModels:
298 n = cpu.name
299 exec_output[n] = self.exec_output[n] + other.exec_output[n]
300 return GenCode(self.parser,
301 self.header_output + other.header_output,
302 self.decoder_output + other.decoder_output,
303 exec_output,
304 self.decode_block + other.decode_block,
305 self.has_decode_default or other.has_decode_default)
306
307 # Prepend a string (typically a comment) to all the strings.
308 def prepend_all(self, pre):
309 self.header_output = pre + self.header_output
310 self.decoder_output = pre + self.decoder_output
311 self.decode_block = pre + self.decode_block
312 for cpu in self.parser.cpuModels:
313 self.exec_output[cpu.name] = pre + self.exec_output[cpu.name]
314
315 # Wrap the decode block in a pair of strings (e.g., 'case foo:'
316 # and 'break;'). Used to build the big nested switch statement.
317 def wrap_decode_block(self, pre, post = ''):
318 self.decode_block = pre + indent(self.decode_block) + post
319
320#####################################################################
321#
322# Bitfield Operator Support
323#
324#####################################################################
325
326bitOp1ArgRE = re.compile(r'<\s*(\w+)\s*:\s*>')
327
328bitOpWordRE = re.compile(r'(?<![\w\.])([\w\.]+)<\s*(\w+)\s*:\s*(\w+)\s*>')
329bitOpExprRE = re.compile(r'\)<\s*(\w+)\s*:\s*(\w+)\s*>')
330
331def substBitOps(code):
332 # first convert single-bit selectors to two-index form
333 # i.e., <n> --> <n:n>
334 code = bitOp1ArgRE.sub(r'<\1:\1>', code)
335 # simple case: selector applied to ID (name)
336 # i.e., foo<a:b> --> bits(foo, a, b)
337 code = bitOpWordRE.sub(r'bits(\1, \2, \3)', code)
338 # if selector is applied to expression (ending in ')'),
339 # we need to search backward for matching '('
340 match = bitOpExprRE.search(code)
341 while match:
342 exprEnd = match.start()
343 here = exprEnd - 1
344 nestLevel = 1
345 while nestLevel > 0:
346 if code[here] == '(':
347 nestLevel -= 1
348 elif code[here] == ')':
349 nestLevel += 1
350 here -= 1
351 if here < 0:
352 sys.exit("Didn't find '('!")
353 exprStart = here+1
354 newExpr = r'bits(%s, %s, %s)' % (code[exprStart:exprEnd+1],
355 match.group(1), match.group(2))
356 code = code[:exprStart] + newExpr + code[match.end():]
357 match = bitOpExprRE.search(code)
358 return code
359
360
361#####################################################################
362#
363# Code Parser
364#
365# The remaining code is the support for automatically extracting
366# instruction characteristics from pseudocode.
367#
368#####################################################################
369
370# Force the argument to be a list. Useful for flags, where a caller
371# can specify a singleton flag or a list of flags. Also usful for
372# converting tuples to lists so they can be modified.
373def makeList(arg):
374 if isinstance(arg, list):
375 return arg
376 elif isinstance(arg, tuple):
377 return list(arg)
378 elif not arg:
379 return []
380 else:
381 return [ arg ]
382
383class Operand(object):
384 '''Base class for operand descriptors. An instance of this class
385 (or actually a class derived from this one) represents a specific
386 operand for a code block (e.g, "Rc.sq" as a dest). Intermediate
387 derived classes encapsulates the traits of a particular operand
388 type (e.g., "32-bit integer register").'''
389
390 def buildReadCode(self, func = None):
391 subst_dict = {"name": self.base_name,
392 "func": func,
393 "reg_idx": self.reg_spec,
394 "size": self.size,
395 "ctype": self.ctype}
396 if hasattr(self, 'src_reg_idx'):
397 subst_dict['op_idx'] = self.src_reg_idx
398 code = self.read_code % subst_dict
399 if self.size != self.dflt_size:
400 return '%s = bits(%s, %d, 0);\n' % \
401 (self.base_name, code, self.size-1)
402 else:
403 return '%s = %s;\n' % \
404 (self.base_name, code)
405
406 def buildWriteCode(self, func = None):
407 if (self.size != self.dflt_size and self.is_signed):
408 final_val = 'sext<%d>(%s)' % (self.size, self.base_name)
409 else:
410 final_val = self.base_name
411 subst_dict = {"name": self.base_name,
412 "func": func,
413 "reg_idx": self.reg_spec,
414 "size": self.size,
415 "ctype": self.ctype,
416 "final_val": final_val}
417 if hasattr(self, 'dest_reg_idx'):
418 subst_dict['op_idx'] = self.dest_reg_idx
419 code = self.write_code % subst_dict
420 return '''
421 {
422 %s final_val = %s;
423 %s;
424 if (traceData) { traceData->setData(final_val); }
425 }''' % (self.dflt_ctype, final_val, code)
426
427 def __init__(self, parser, full_name, ext, is_src, is_dest):
428 self.full_name = full_name
429 self.ext = ext
430 self.is_src = is_src
431 self.is_dest = is_dest
432 # The 'effective extension' (eff_ext) is either the actual
433 # extension, if one was explicitly provided, or the default.
434 if ext:
435 self.eff_ext = ext
436 else:
437 self.eff_ext = self.dflt_ext
438
439 self.size, self.ctype, self.is_signed = \
440 parser.operandTypeMap[self.eff_ext]
441
442 # note that mem_acc_size is undefined for non-mem operands...
443 # template must be careful not to use it if it doesn't apply.
444 if self.isMem():
445 self.mem_acc_size = self.makeAccSize()
446 if self.ctype in ['Twin32_t', 'Twin64_t']:
447 self.mem_acc_type = 'Twin'
448 else:
449 self.mem_acc_type = 'uint'
450
451 # Finalize additional fields (primarily code fields). This step
452 # is done separately since some of these fields may depend on the
453 # register index enumeration that hasn't been performed yet at the
454 # time of __init__().
455 def finalize(self):
456 self.flags = self.getFlags()
457 self.constructor = self.makeConstructor()
458 self.op_decl = self.makeDecl()
459
460 if self.is_src:
461 self.op_rd = self.makeRead()
462 self.op_src_decl = self.makeDecl()
463 else:
464 self.op_rd = ''
465 self.op_src_decl = ''
466
467 if self.is_dest:
468 self.op_wb = self.makeWrite()
469 self.op_dest_decl = self.makeDecl()
470 else:
471 self.op_wb = ''
472 self.op_dest_decl = ''
473
474 def isMem(self):
475 return 0
476
477 def isReg(self):
478 return 0
479
480 def isFloatReg(self):
481 return 0
482
483 def isIntReg(self):
484 return 0
485
486 def isControlReg(self):
487 return 0
488
489 def getFlags(self):
490 # note the empty slice '[:]' gives us a copy of self.flags[0]
491 # instead of a reference to it
492 my_flags = self.flags[0][:]
493 if self.is_src:
494 my_flags += self.flags[1]
495 if self.is_dest:
496 my_flags += self.flags[2]
497 return my_flags
498
499 def makeDecl(self):
500 # Note that initializations in the declarations are solely
501 # to avoid 'uninitialized variable' errors from the compiler.
502 return self.ctype + ' ' + self.base_name + ' = 0;\n';
503
504class IntRegOperand(Operand):
505 def isReg(self):
506 return 1
507
508 def isIntReg(self):
509 return 1
510
511 def makeConstructor(self):
512 c = ''
513 if self.is_src:
514 c += '\n\t_srcRegIdx[%d] = %s;' % \
515 (self.src_reg_idx, self.reg_spec)
516 if self.is_dest:
517 c += '\n\t_destRegIdx[%d] = %s;' % \
518 (self.dest_reg_idx, self.reg_spec)
519 return c
520
521 def makeRead(self):
522 if (self.ctype == 'float' or self.ctype == 'double'):
523 error('Attempt to read integer register as FP')
524 if self.read_code != None:
525 return self.buildReadCode('readIntRegOperand')
526 if (self.size == self.dflt_size):
527 return '%s = xc->readIntRegOperand(this, %d);\n' % \
528 (self.base_name, self.src_reg_idx)
529 elif (self.size > self.dflt_size):
530 int_reg_val = 'xc->readIntRegOperand(this, %d)' % \
531 (self.src_reg_idx)
532 if (self.is_signed):
533 int_reg_val = 'sext<%d>(%s)' % (self.dflt_size, int_reg_val)
534 return '%s = %s;\n' % (self.base_name, int_reg_val)
535 else:
536 return '%s = bits(xc->readIntRegOperand(this, %d), %d, 0);\n' % \
537 (self.base_name, self.src_reg_idx, self.size-1)
538
539 def makeWrite(self):
540 if (self.ctype == 'float' or self.ctype == 'double'):
541 error('Attempt to write integer register as FP')
542 if self.write_code != None:
543 return self.buildWriteCode('setIntRegOperand')
544 if (self.size != self.dflt_size and self.is_signed):
545 final_val = 'sext<%d>(%s)' % (self.size, self.base_name)
546 else:
547 final_val = self.base_name
548 wb = '''
549 {
550 %s final_val = %s;
551 xc->setIntRegOperand(this, %d, final_val);\n
552 if (traceData) { traceData->setData(final_val); }
553 }''' % (self.dflt_ctype, final_val, self.dest_reg_idx)
554 return wb
555
556class FloatRegOperand(Operand):
557 def isReg(self):
558 return 1
559
560 def isFloatReg(self):
561 return 1
562
563 def makeConstructor(self):
564 c = ''
565 if self.is_src:
566 c += '\n\t_srcRegIdx[%d] = %s + FP_Base_DepTag;' % \
567 (self.src_reg_idx, self.reg_spec)
568 if self.is_dest:
569 c += '\n\t_destRegIdx[%d] = %s + FP_Base_DepTag;' % \
570 (self.dest_reg_idx, self.reg_spec)
571 return c
572
573 def makeRead(self):
574 bit_select = 0
575 if (self.ctype == 'float' or self.ctype == 'double'):
576 func = 'readFloatRegOperand'
577 else:
578 func = 'readFloatRegOperandBits'
579 if (self.size != self.dflt_size):
580 bit_select = 1
581 base = 'xc->%s(this, %d)' % (func, self.src_reg_idx)
582 if self.read_code != None:
583 return self.buildReadCode(func)
584 if bit_select:
585 return '%s = bits(%s, %d, 0);\n' % \
586 (self.base_name, base, self.size-1)
587 else:
588 return '%s = %s;\n' % (self.base_name, base)
589
590 def makeWrite(self):
591 final_val = self.base_name
592 final_ctype = self.ctype
593 if (self.ctype == 'float' or self.ctype == 'double'):
594 func = 'setFloatRegOperand'
595 elif (self.ctype == 'uint32_t' or self.ctype == 'uint64_t'):
596 func = 'setFloatRegOperandBits'
597 else:
598 func = 'setFloatRegOperandBits'
599 final_ctype = 'uint%d_t' % self.dflt_size
600 if (self.size != self.dflt_size and self.is_signed):
601 final_val = 'sext<%d>(%s)' % (self.size, self.base_name)
602 if self.write_code != None:
603 return self.buildWriteCode(func)
604 wb = '''
605 {
606 %s final_val = %s;
607 xc->%s(this, %d, final_val);\n
608 if (traceData) { traceData->setData(final_val); }
609 }''' % (final_ctype, final_val, func, self.dest_reg_idx)
610 return wb
611
612class ControlRegOperand(Operand):
613 def isReg(self):
614 return 1
615
616 def isControlReg(self):
617 return 1
618
619 def makeConstructor(self):
620 c = ''
621 if self.is_src:
622 c += '\n\t_srcRegIdx[%d] = %s + Ctrl_Base_DepTag;' % \
623 (self.src_reg_idx, self.reg_spec)
624 if self.is_dest:
625 c += '\n\t_destRegIdx[%d] = %s + Ctrl_Base_DepTag;' % \
626 (self.dest_reg_idx, self.reg_spec)
627 return c
628
629 def makeRead(self):
630 bit_select = 0
631 if (self.ctype == 'float' or self.ctype == 'double'):
632 error('Attempt to read control register as FP')
633 if self.read_code != None:
634 return self.buildReadCode('readMiscRegOperand')
635 base = 'xc->readMiscRegOperand(this, %s)' % self.src_reg_idx
636 if self.size == self.dflt_size:
637 return '%s = %s;\n' % (self.base_name, base)
638 else:
639 return '%s = bits(%s, %d, 0);\n' % \
640 (self.base_name, base, self.size-1)
641
642 def makeWrite(self):
643 if (self.ctype == 'float' or self.ctype == 'double'):
644 error('Attempt to write control register as FP')
645 if self.write_code != None:
646 return self.buildWriteCode('setMiscRegOperand')
647 wb = 'xc->setMiscRegOperand(this, %s, %s);\n' % \
648 (self.dest_reg_idx, self.base_name)
649 wb += 'if (traceData) { traceData->setData(%s); }' % \
650 self.base_name
651 return wb
652
653class MemOperand(Operand):
654 def isMem(self):
655 return 1
656
657 def makeConstructor(self):
658 return ''
659
660 def makeDecl(self):
661 # Note that initializations in the declarations are solely
662 # to avoid 'uninitialized variable' errors from the compiler.
663 # Declare memory data variable.
664 if self.ctype in ['Twin32_t','Twin64_t']:
665 return "%s %s; %s.a = 0; %s.b = 0;\n" % \
666 (self.ctype, self.base_name, self.base_name, self.base_name)
667 return '%s %s = 0;\n' % (self.ctype, self.base_name)
668
669 def makeRead(self):
670 if self.read_code != None:
671 return self.buildReadCode()
672 return ''
673
674 def makeWrite(self):
675 if self.write_code != None:
676 return self.buildWriteCode()
677 return ''
678
679 # Return the memory access size *in bits*, suitable for
680 # forming a type via "uint%d_t". Divide by 8 if you want bytes.
681 def makeAccSize(self):
682 return self.size
683
684class PCStateOperand(Operand):
685 def makeConstructor(self):
686 return ''
687
688 def makeRead(self):
689 return '%s = xc->pcState();\n' % self.base_name
690
691 def makeWrite(self):
692 return 'xc->pcState(%s);\n' % self.base_name
693
694 def makeDecl(self):
695 return 'TheISA::PCState ' + self.base_name + ' M5_VAR_USED;\n';
696
697class PCOperand(Operand):
698 def makeConstructor(self):
699 return ''
700
701 def makeRead(self):
702 return '%s = xc->instAddr();\n' % self.base_name
703
704class UPCOperand(Operand):
705 def makeConstructor(self):
706 return ''
707
708 def makeRead(self):
709 if self.read_code != None:
710 return self.buildReadCode('microPC')
711 return '%s = xc->microPC();\n' % self.base_name
712
713class NPCOperand(Operand):
714 def makeConstructor(self):
715 return ''
716
717 def makeRead(self):
718 if self.read_code != None:
719 return self.buildReadCode('nextInstAddr')
720 return '%s = xc->nextInstAddr();\n' % self.base_name
721
722class OperandList(object):
723 '''Find all the operands in the given code block. Returns an operand
724 descriptor list (instance of class OperandList).'''
725 def __init__(self, parser, code):
726 self.items = []
727 self.bases = {}
728 # delete comments so we don't match on reg specifiers inside
729 code = commentRE.sub('', code)
730 # search for operands
731 next_pos = 0
732 while 1:
733 match = parser.operandsRE.search(code, next_pos)
734 if not match:
735 # no more matches: we're done
736 break
737 op = match.groups()
738 # regexp groups are operand full name, base, and extension
739 (op_full, op_base, op_ext) = op
740 # if the token following the operand is an assignment, this is
741 # a destination (LHS), else it's a source (RHS)
742 is_dest = (assignRE.match(code, match.end()) != None)
743 is_src = not is_dest
744 # see if we've already seen this one
745 op_desc = self.find_base(op_base)
746 if op_desc:
747 if op_desc.ext != op_ext:
748 error('Inconsistent extensions for operand %s' % \
749 op_base)
750 op_desc.is_src = op_desc.is_src or is_src
751 op_desc.is_dest = op_desc.is_dest or is_dest
752 else:
753 # new operand: create new descriptor
754 op_desc = parser.operandNameMap[op_base](parser,
755 op_full, op_ext, is_src, is_dest)
756 self.append(op_desc)
757 # start next search after end of current match
758 next_pos = match.end()
759 self.sort()
760 # enumerate source & dest register operands... used in building
761 # constructor later
762 self.numSrcRegs = 0
763 self.numDestRegs = 0
764 self.numFPDestRegs = 0
765 self.numIntDestRegs = 0
766 self.memOperand = None
767 for op_desc in self.items:
768 if op_desc.isReg():
769 if op_desc.is_src:
770 op_desc.src_reg_idx = self.numSrcRegs
771 self.numSrcRegs += 1
772 if op_desc.is_dest:
773 op_desc.dest_reg_idx = self.numDestRegs
774 self.numDestRegs += 1
775 if op_desc.isFloatReg():
776 self.numFPDestRegs += 1
777 elif op_desc.isIntReg():
778 self.numIntDestRegs += 1
779 elif op_desc.isMem():
780 if self.memOperand:
781 error("Code block has more than one memory operand.")
782 self.memOperand = op_desc
783 if parser.maxInstSrcRegs < self.numSrcRegs:
784 parser.maxInstSrcRegs = self.numSrcRegs
785 if parser.maxInstDestRegs < self.numDestRegs:
786 parser.maxInstDestRegs = self.numDestRegs
787 # now make a final pass to finalize op_desc fields that may depend
788 # on the register enumeration
789 for op_desc in self.items:
790 op_desc.finalize()
791
792 def __len__(self):
793 return len(self.items)
794
795 def __getitem__(self, index):
796 return self.items[index]
797
798 def append(self, op_desc):
799 self.items.append(op_desc)
800 self.bases[op_desc.base_name] = op_desc
801
802 def find_base(self, base_name):
803 # like self.bases[base_name], but returns None if not found
804 # (rather than raising exception)
805 return self.bases.get(base_name)
806
807 # internal helper function for concat[Some]Attr{Strings|Lists}
808 def __internalConcatAttrs(self, attr_name, filter, result):
809 for op_desc in self.items:
810 if filter(op_desc):
811 result += getattr(op_desc, attr_name)
812 return result
813
814 # return a single string that is the concatenation of the (string)
815 # values of the specified attribute for all operands
816 def concatAttrStrings(self, attr_name):
817 return self.__internalConcatAttrs(attr_name, lambda x: 1, '')
818
819 # like concatAttrStrings, but only include the values for the operands
820 # for which the provided filter function returns true
821 def concatSomeAttrStrings(self, filter, attr_name):
822 return self.__internalConcatAttrs(attr_name, filter, '')
823
824 # return a single list that is the concatenation of the (list)
825 # values of the specified attribute for all operands
826 def concatAttrLists(self, attr_name):
827 return self.__internalConcatAttrs(attr_name, lambda x: 1, [])
828
829 # like concatAttrLists, but only include the values for the operands
830 # for which the provided filter function returns true
831 def concatSomeAttrLists(self, filter, attr_name):
832 return self.__internalConcatAttrs(attr_name, filter, [])
833
834 def sort(self):
835 self.items.sort(lambda a, b: a.sort_pri - b.sort_pri)
836
837class SubOperandList(OperandList):
838 '''Find all the operands in the given code block. Returns an operand
839 descriptor list (instance of class OperandList).'''
840 def __init__(self, parser, code, master_list):
841 self.items = []
842 self.bases = {}
843 # delete comments so we don't match on reg specifiers inside
844 code = commentRE.sub('', code)
845 # search for operands
846 next_pos = 0
847 while 1:
848 match = parser.operandsRE.search(code, next_pos)
849 if not match:
850 # no more matches: we're done
851 break
852 op = match.groups()
853 # regexp groups are operand full name, base, and extension
854 (op_full, op_base, op_ext) = op
855 # find this op in the master list
856 op_desc = master_list.find_base(op_base)
857 if not op_desc:
858 error('Found operand %s which is not in the master list!' \
859 ' This is an internal error' % op_base)
860 else:
861 # See if we've already found this operand
862 op_desc = self.find_base(op_base)
863 if not op_desc:
864 # if not, add a reference to it to this sub list
865 self.append(master_list.bases[op_base])
866
867 # start next search after end of current match
868 next_pos = match.end()
869 self.sort()
870 self.memOperand = None
871 for op_desc in self.items:
872 if op_desc.isMem():
873 if self.memOperand:
874 error("Code block has more than one memory operand.")
875 self.memOperand = op_desc
876
877# Regular expression object to match C++ comments
878# (used in findOperands())
879commentRE = re.compile(r'//.*\n')
880
881# Regular expression object to match assignment statements
882# (used in findOperands())
883assignRE = re.compile(r'\s*=(?!=)', re.MULTILINE)
884
885def makeFlagConstructor(flag_list):
886 if len(flag_list) == 0:
887 return ''
888 # filter out repeated flags
889 flag_list.sort()
890 i = 1
891 while i < len(flag_list):
892 if flag_list[i] == flag_list[i-1]:
893 del flag_list[i]
894 else:
895 i += 1
896 pre = '\n\tflags['
897 post = '] = true;'
898 code = pre + string.join(flag_list, post + pre) + post
899 return code
900
901# Assume all instruction flags are of the form 'IsFoo'
902instFlagRE = re.compile(r'Is.*')
903
904# OpClass constants end in 'Op' except No_OpClass
905opClassRE = re.compile(r'.*Op|No_OpClass')
906
907class InstObjParams(object):
908 def __init__(self, parser, mnem, class_name, base_class = '',
909 snippets = {}, opt_args = []):
910 self.mnemonic = mnem
911 self.class_name = class_name
912 self.base_class = base_class
913 if not isinstance(snippets, dict):
914 snippets = {'code' : snippets}
915 compositeCode = ' '.join(map(str, snippets.values()))
916 self.snippets = snippets
917
918 self.operands = OperandList(parser, compositeCode)
919 self.constructor = self.operands.concatAttrStrings('constructor')
920 self.constructor += \
921 '\n\t_numSrcRegs = %d;' % self.operands.numSrcRegs
922 self.constructor += \
923 '\n\t_numDestRegs = %d;' % self.operands.numDestRegs
924 self.constructor += \
925 '\n\t_numFPDestRegs = %d;' % self.operands.numFPDestRegs
926 self.constructor += \
927 '\n\t_numIntDestRegs = %d;' % self.operands.numIntDestRegs
928 self.flags = self.operands.concatAttrLists('flags')
929
930 # Make a basic guess on the operand class (function unit type).
931 # These are good enough for most cases, and can be overridden
932 # later otherwise.
933 if 'IsStore' in self.flags:
934 self.op_class = 'MemWriteOp'
935 elif 'IsLoad' in self.flags or 'IsPrefetch' in self.flags:
936 self.op_class = 'MemReadOp'
937 elif 'IsFloating' in self.flags:
938 self.op_class = 'FloatAddOp'
939 else:
940 self.op_class = 'IntAluOp'
941
942 # Optional arguments are assumed to be either StaticInst flags
943 # or an OpClass value. To avoid having to import a complete
944 # list of these values to match against, we do it ad-hoc
945 # with regexps.
946 for oa in opt_args:
947 if instFlagRE.match(oa):
948 self.flags.append(oa)
949 elif opClassRE.match(oa):
950 self.op_class = oa
951 else:
952 error('InstObjParams: optional arg "%s" not recognized '
953 'as StaticInst::Flag or OpClass.' % oa)
954
955 # add flag initialization to contructor here to include
956 # any flags added via opt_args
957 self.constructor += makeFlagConstructor(self.flags)
958
959 # if 'IsFloating' is set, add call to the FP enable check
960 # function (which should be provided by isa_desc via a declare)
961 if 'IsFloating' in self.flags:
962 self.fp_enable_check = 'fault = checkFpEnableFault(xc);'
963 else:
964 self.fp_enable_check = ''
965
966##############
967# Stack: a simple stack object. Used for both formats (formatStack)
968# and default cases (defaultStack). Simply wraps a list to give more
969# stack-like syntax and enable initialization with an argument list
970# (as opposed to an argument that's a list).
971
972class Stack(list):
973 def __init__(self, *items):
974 list.__init__(self, items)
975
976 def push(self, item):
977 self.append(item);
978
979 def top(self):
980 return self[-1]
981
982#######################
983#
984# Output file template
985#
986
987file_template = '''
988/*
989 * DO NOT EDIT THIS FILE!!!
990 *
991 * It was automatically generated from the ISA description in %(filename)s
992 */
993
994%(includes)s
995
996%(global_output)s
997
998namespace %(namespace)s {
999
1000%(namespace_output)s
1001
1002} // namespace %(namespace)s
1003
1004%(decode_function)s
1005'''
1006
1007max_inst_regs_template = '''
1008/*
1009 * DO NOT EDIT THIS FILE!!!
1010 *
1011 * It was automatically generated from the ISA description in %(filename)s
1012 */
1013
1014namespace %(namespace)s {
1015
1016 const int MaxInstSrcRegs = %(MaxInstSrcRegs)d;
1017 const int MaxInstDestRegs = %(MaxInstDestRegs)d;
1018
1019} // namespace %(namespace)s
1020
1021'''
1022
1023class ISAParser(Grammar):
1024 def __init__(self, output_dir, cpu_models):
1025 super(ISAParser, self).__init__()
1026 self.output_dir = output_dir
1027
1028 self.cpuModels = cpu_models
1029
1030 # variable to hold templates
1031 self.templateMap = {}
1032
1033 # This dictionary maps format name strings to Format objects.
1034 self.formatMap = {}
1035
1036 # The format stack.
1037 self.formatStack = Stack(NoFormat())
1038
1039 # The default case stack.
1040 self.defaultStack = Stack(None)
1041
1042 # Stack that tracks current file and line number. Each
1043 # element is a tuple (filename, lineno) that records the
1044 # *current* filename and the line number in the *previous*
1045 # file where it was included.
1046 self.fileNameStack = Stack()
1047
1048 symbols = ('makeList', 're', 'string')
1049 self.exportContext = dict([(s, eval(s)) for s in symbols])
1050
1051 self.maxInstSrcRegs = 0
1052 self.maxInstDestRegs = 0
1053
1054 #####################################################################
1055 #
1056 # Lexer
1057 #
1058 # The PLY lexer module takes two things as input:
1059 # - A list of token names (the string list 'tokens')
1060 # - A regular expression describing a match for each token. The
1061 # regexp for token FOO can be provided in two ways:
1062 # - as a string variable named t_FOO
1063 # - as the doc string for a function named t_FOO. In this case,
1064 # the function is also executed, allowing an action to be
1065 # associated with each token match.
1066 #
1067 #####################################################################
1068
1069 # Reserved words. These are listed separately as they are matched
1070 # using the same regexp as generic IDs, but distinguished in the
1071 # t_ID() function. The PLY documentation suggests this approach.
1072 reserved = (
1073 'BITFIELD', 'DECODE', 'DECODER', 'DEFAULT', 'DEF', 'EXEC', 'FORMAT',
1074 'HEADER', 'LET', 'NAMESPACE', 'OPERAND_TYPES', 'OPERANDS',
1075 'OUTPUT', 'SIGNED', 'TEMPLATE'
1076 )
1077
1078 # List of tokens. The lex module requires this.
1079 tokens = reserved + (
1080 # identifier
1081 'ID',
1082
1083 # integer literal
1084 'INTLIT',
1085
1086 # string literal
1087 'STRLIT',
1088
1089 # code literal
1090 'CODELIT',
1091
1092 # ( ) [ ] { } < > , ; . : :: *
1093 'LPAREN', 'RPAREN',
1094 'LBRACKET', 'RBRACKET',
1095 'LBRACE', 'RBRACE',
1096 'LESS', 'GREATER', 'EQUALS',
1097 'COMMA', 'SEMI', 'DOT', 'COLON', 'DBLCOLON',
1098 'ASTERISK',
1099
1100 # C preprocessor directives
1101 'CPPDIRECTIVE'
1102
1103 # The following are matched but never returned. commented out to
1104 # suppress PLY warning
1105 # newfile directive
1106 # 'NEWFILE',
1107
1108 # endfile directive
1109 # 'ENDFILE'
1110 )
1111
1112 # Regular expressions for token matching
1113 t_LPAREN = r'\('
1114 t_RPAREN = r'\)'
1115 t_LBRACKET = r'\['
1116 t_RBRACKET = r'\]'
1117 t_LBRACE = r'\{'
1118 t_RBRACE = r'\}'
1119 t_LESS = r'\<'
1120 t_GREATER = r'\>'
1121 t_EQUALS = r'='
1122 t_COMMA = r','
1123 t_SEMI = r';'
1124 t_DOT = r'\.'
1125 t_COLON = r':'
1126 t_DBLCOLON = r'::'
1127 t_ASTERISK = r'\*'
1128
1129 # Identifiers and reserved words
1130 reserved_map = { }
1131 for r in reserved:
1132 reserved_map[r.lower()] = r
1133
1134 def t_ID(self, t):
1135 r'[A-Za-z_]\w*'
1136 t.type = self.reserved_map.get(t.value, 'ID')
1137 return t
1138
1139 # Integer literal
1140 def t_INTLIT(self, t):
1141 r'-?(0x[\da-fA-F]+)|\d+'
1142 try:
1143 t.value = int(t.value,0)
1144 except ValueError:
1145 error(t, 'Integer value "%s" too large' % t.value)
1146 t.value = 0
1147 return t
1148
1149 # String literal. Note that these use only single quotes, and
1150 # can span multiple lines.
1151 def t_STRLIT(self, t):
1152 r"(?m)'([^'])+'"
1153 # strip off quotes
1154 t.value = t.value[1:-1]
1155 t.lexer.lineno += t.value.count('\n')
1156 return t
1157
1158
1159 # "Code literal"... like a string literal, but delimiters are
1160 # '{{' and '}}' so they get formatted nicely under emacs c-mode
1161 def t_CODELIT(self, t):
1162 r"(?m)\{\{([^\}]|}(?!\}))+\}\}"
1163 # strip off {{ & }}
1164 t.value = t.value[2:-2]
1165 t.lexer.lineno += t.value.count('\n')
1166 return t
1167
1168 def t_CPPDIRECTIVE(self, t):
1169 r'^\#[^\#].*\n'
1170 t.lexer.lineno += t.value.count('\n')
1171 return t
1172
1173 def t_NEWFILE(self, t):
1174 r'^\#\#newfile\s+"[\w/.-]*"'
1175 self.fileNameStack.push((t.value[11:-1], t.lexer.lineno))
1176 t.lexer.lineno = 0
1177
1178 def t_ENDFILE(self, t):
1179 r'^\#\#endfile'
1180 (old_filename, t.lexer.lineno) = self.fileNameStack.pop()
1181
1182 #
1183 # The functions t_NEWLINE, t_ignore, and t_error are
1184 # special for the lex module.
1185 #
1186
1187 # Newlines
1188 def t_NEWLINE(self, t):
1189 r'\n+'
1190 t.lexer.lineno += t.value.count('\n')
1191
1192 # Comments
1193 def t_comment(self, t):
1194 r'//.*'
1195
1196 # Completely ignored characters
1197 t_ignore = ' \t\x0c'
1198
1199 # Error handler
1200 def t_error(self, t):
1201 error(t, "illegal character '%s'" % t.value[0])
1202 t.skip(1)
1203
1204 #####################################################################
1205 #
1206 # Parser
1207 #
1208 # Every function whose name starts with 'p_' defines a grammar
1209 # rule. The rule is encoded in the function's doc string, while
1210 # the function body provides the action taken when the rule is
1211 # matched. The argument to each function is a list of the values
1212 # of the rule's symbols: t[0] for the LHS, and t[1..n] for the
1213 # symbols on the RHS. For tokens, the value is copied from the
1214 # t.value attribute provided by the lexer. For non-terminals, the
1215 # value is assigned by the producing rule; i.e., the job of the
1216 # grammar rule function is to set the value for the non-terminal
1217 # on the LHS (by assigning to t[0]).
1218 #####################################################################
1219
1220 # The LHS of the first grammar rule is used as the start symbol
1221 # (in this case, 'specification'). Note that this rule enforces
1222 # that there will be exactly one namespace declaration, with 0 or
1223 # more global defs/decls before and after it. The defs & decls
1224 # before the namespace decl will be outside the namespace; those
1225 # after will be inside. The decoder function is always inside the
1226 # namespace.
1227 def p_specification(self, t):
1228 'specification : opt_defs_and_outputs name_decl opt_defs_and_outputs decode_block'
1229 global_code = t[1]
1230 isa_name = t[2]
1231 namespace = isa_name + "Inst"
1232 # wrap the decode block as a function definition
1233 t[4].wrap_decode_block('''
1234StaticInstPtr
1235%(isa_name)s::decodeInst(%(isa_name)s::ExtMachInst machInst)
1236{
1237 using namespace %(namespace)s;
1238''' % vars(), '}')
1239 # both the latter output blocks and the decode block are in
1240 # the namespace
1241 namespace_code = t[3] + t[4]
1242 # pass it all back to the caller of yacc.parse()
1243 t[0] = (isa_name, namespace, global_code, namespace_code)
1244
1245 # ISA name declaration looks like "namespace <foo>;"
1246 def p_name_decl(self, t):
1247 'name_decl : NAMESPACE ID SEMI'
1248 t[0] = t[2]
1249
1250 # 'opt_defs_and_outputs' is a possibly empty sequence of
1251 # def and/or output statements.
1252 def p_opt_defs_and_outputs_0(self, t):
1253 'opt_defs_and_outputs : empty'
1254 t[0] = GenCode(self)
1255
1256 def p_opt_defs_and_outputs_1(self, t):
1257 'opt_defs_and_outputs : defs_and_outputs'
1258 t[0] = t[1]
1259
1260 def p_defs_and_outputs_0(self, t):
1261 'defs_and_outputs : def_or_output'
1262 t[0] = t[1]
1263
1264 def p_defs_and_outputs_1(self, t):
1265 'defs_and_outputs : defs_and_outputs def_or_output'
1266 t[0] = t[1] + t[2]
1267
1268 # The list of possible definition/output statements.
1269 def p_def_or_output(self, t):
1270 '''def_or_output : def_format
1271 | def_bitfield
1272 | def_bitfield_struct
1273 | def_template
1274 | def_operand_types
1275 | def_operands
1276 | output_header
1277 | output_decoder
1278 | output_exec
1279 | global_let'''
1280 t[0] = t[1]
1281
1282 # Output blocks 'output <foo> {{...}}' (C++ code blocks) are copied
1283 # directly to the appropriate output section.
1284
1285 # Massage output block by substituting in template definitions and
1286 # bit operators. We handle '%'s embedded in the string that don't
1287 # indicate template substitutions (or CPU-specific symbols, which
1288 # get handled in GenCode) by doubling them first so that the
1289 # format operation will reduce them back to single '%'s.
1290 def process_output(self, s):
1291 s = self.protectNonSubstPercents(s)
1292 # protects cpu-specific symbols too
1293 s = self.protectCpuSymbols(s)
1294 return substBitOps(s % self.templateMap)
1295
1296 def p_output_header(self, t):
1297 'output_header : OUTPUT HEADER CODELIT SEMI'
1298 t[0] = GenCode(self, header_output = self.process_output(t[3]))
1299
1300 def p_output_decoder(self, t):
1301 'output_decoder : OUTPUT DECODER CODELIT SEMI'
1302 t[0] = GenCode(self, decoder_output = self.process_output(t[3]))
1303
1304 def p_output_exec(self, t):
1305 'output_exec : OUTPUT EXEC CODELIT SEMI'
1306 t[0] = GenCode(self, exec_output = self.process_output(t[3]))
1307
1308 # global let blocks 'let {{...}}' (Python code blocks) are
1309 # executed directly when seen. Note that these execute in a
1310 # special variable context 'exportContext' to prevent the code
1311 # from polluting this script's namespace.
1312 def p_global_let(self, t):
1313 'global_let : LET CODELIT SEMI'
1314 self.updateExportContext()
1315 self.exportContext["header_output"] = ''
1316 self.exportContext["decoder_output"] = ''
1317 self.exportContext["exec_output"] = ''
1318 self.exportContext["decode_block"] = ''
1319 try:
1320 exec fixPythonIndentation(t[2]) in self.exportContext
1321 except Exception, exc:
1322 if debug:
1323 raise
1324 error(t, 'error: %s in global let block "%s".' % (exc, t[2]))
1325 t[0] = GenCode(self,
1326 header_output=self.exportContext["header_output"],
1327 decoder_output=self.exportContext["decoder_output"],
1328 exec_output=self.exportContext["exec_output"],
1329 decode_block=self.exportContext["decode_block"])
1330
1331 # Define the mapping from operand type extensions to C++ types and
1332 # bit widths (stored in operandTypeMap).
1333 def p_def_operand_types(self, t):
1334 'def_operand_types : DEF OPERAND_TYPES CODELIT SEMI'
1335 try:
1336 user_dict = eval('{' + t[3] + '}')
1337 except Exception, exc:
1338 if debug:
1339 raise
1340 error(t,
1341 'error: %s in def operand_types block "%s".' % (exc, t[3]))
1342 self.buildOperandTypeMap(user_dict, t.lexer.lineno)
1343 t[0] = GenCode(self) # contributes nothing to the output C++ file
1344
1345 # Define the mapping from operand names to operand classes and
1346 # other traits. Stored in operandNameMap.
1347 def p_def_operands(self, t):
1348 'def_operands : DEF OPERANDS CODELIT SEMI'
1349 if not hasattr(self, 'operandTypeMap'):
1350 error(t, 'error: operand types must be defined before operands')
1351 try:
1352 user_dict = eval('{' + t[3] + '}', self.exportContext)
1353 except Exception, exc:
1354 if debug:
1355 raise
1356 error(t, 'error: %s in def operands block "%s".' % (exc, t[3]))
1357 self.buildOperandNameMap(user_dict, t.lexer.lineno)
1358 t[0] = GenCode(self) # contributes nothing to the output C++ file
1359
1360 # A bitfield definition looks like:
1361 # 'def [signed] bitfield <ID> [<first>:<last>]'
1362 # This generates a preprocessor macro in the output file.
1363 def p_def_bitfield_0(self, t):
1364 'def_bitfield : DEF opt_signed BITFIELD ID LESS INTLIT COLON INTLIT GREATER SEMI'
1365 expr = 'bits(machInst, %2d, %2d)' % (t[6], t[8])
1366 if (t[2] == 'signed'):
1367 expr = 'sext<%d>(%s)' % (t[6] - t[8] + 1, expr)
1368 hash_define = '#undef %s\n#define %s\t%s\n' % (t[4], t[4], expr)
1369 t[0] = GenCode(self, header_output=hash_define)
1370
1371 # alternate form for single bit: 'def [signed] bitfield <ID> [<bit>]'
1372 def p_def_bitfield_1(self, t):
1373 'def_bitfield : DEF opt_signed BITFIELD ID LESS INTLIT GREATER SEMI'
1374 expr = 'bits(machInst, %2d, %2d)' % (t[6], t[6])
1375 if (t[2] == 'signed'):
1376 expr = 'sext<%d>(%s)' % (1, expr)
1377 hash_define = '#undef %s\n#define %s\t%s\n' % (t[4], t[4], expr)
1378 t[0] = GenCode(self, header_output=hash_define)
1379
1380 # alternate form for structure member: 'def bitfield <ID> <ID>'
1381 def p_def_bitfield_struct(self, t):
1382 'def_bitfield_struct : DEF opt_signed BITFIELD ID id_with_dot SEMI'
1383 if (t[2] != ''):
1384 error(t, 'error: structure bitfields are always unsigned.')
1385 expr = 'machInst.%s' % t[5]
1386 hash_define = '#undef %s\n#define %s\t%s\n' % (t[4], t[4], expr)
1387 t[0] = GenCode(self, header_output=hash_define)
1388
1389 def p_id_with_dot_0(self, t):
1390 'id_with_dot : ID'
1391 t[0] = t[1]
1392
1393 def p_id_with_dot_1(self, t):
1394 'id_with_dot : ID DOT id_with_dot'
1395 t[0] = t[1] + t[2] + t[3]
1396
1397 def p_opt_signed_0(self, t):
1398 'opt_signed : SIGNED'
1399 t[0] = t[1]
1400
1401 def p_opt_signed_1(self, t):
1402 'opt_signed : empty'
1403 t[0] = ''
1404
1405 def p_def_template(self, t):
1406 'def_template : DEF TEMPLATE ID CODELIT SEMI'
1407 self.templateMap[t[3]] = Template(self, t[4])
1408 t[0] = GenCode(self)
1409
1410 # An instruction format definition looks like
1411 # "def format <fmt>(<params>) {{...}};"
1412 def p_def_format(self, t):
1413 'def_format : DEF FORMAT ID LPAREN param_list RPAREN CODELIT SEMI'
1414 (id, params, code) = (t[3], t[5], t[7])
1415 self.defFormat(id, params, code, t.lexer.lineno)
1416 t[0] = GenCode(self)
1417
1418 # The formal parameter list for an instruction format is a
1419 # possibly empty list of comma-separated parameters. Positional
1420 # (standard, non-keyword) parameters must come first, followed by
1421 # keyword parameters, followed by a '*foo' parameter that gets
1422 # excess positional arguments (as in Python). Each of these three
1423 # parameter categories is optional.
1424 #
1425 # Note that we do not support the '**foo' parameter for collecting
1426 # otherwise undefined keyword args. Otherwise the parameter list
1427 # is (I believe) identical to what is supported in Python.
1428 #
1429 # The param list generates a tuple, where the first element is a
1430 # list of the positional params and the second element is a dict
1431 # containing the keyword params.
1432 def p_param_list_0(self, t):
1433 'param_list : positional_param_list COMMA nonpositional_param_list'
1434 t[0] = t[1] + t[3]
1435
1436 def p_param_list_1(self, t):
1437 '''param_list : positional_param_list
1438 | nonpositional_param_list'''
1439 t[0] = t[1]
1440
1441 def p_positional_param_list_0(self, t):
1442 'positional_param_list : empty'
1443 t[0] = []
1444
1445 def p_positional_param_list_1(self, t):
1446 'positional_param_list : ID'
1447 t[0] = [t[1]]
1448
1449 def p_positional_param_list_2(self, t):
1450 'positional_param_list : positional_param_list COMMA ID'
1451 t[0] = t[1] + [t[3]]
1452
1453 def p_nonpositional_param_list_0(self, t):
1454 'nonpositional_param_list : keyword_param_list COMMA excess_args_param'
1455 t[0] = t[1] + t[3]
1456
1457 def p_nonpositional_param_list_1(self, t):
1458 '''nonpositional_param_list : keyword_param_list
1459 | excess_args_param'''
1460 t[0] = t[1]
1461
1462 def p_keyword_param_list_0(self, t):
1463 'keyword_param_list : keyword_param'
1464 t[0] = [t[1]]
1465
1466 def p_keyword_param_list_1(self, t):
1467 'keyword_param_list : keyword_param_list COMMA keyword_param'
1468 t[0] = t[1] + [t[3]]
1469
1470 def p_keyword_param(self, t):
1471 'keyword_param : ID EQUALS expr'
1472 t[0] = t[1] + ' = ' + t[3].__repr__()
1473
1474 def p_excess_args_param(self, t):
1475 'excess_args_param : ASTERISK ID'
1476 # Just concatenate them: '*ID'. Wrap in list to be consistent
1477 # with positional_param_list and keyword_param_list.
1478 t[0] = [t[1] + t[2]]
1479
1480 # End of format definition-related rules.
1481 ##############
1482
1483 #
1484 # A decode block looks like:
1485 # decode <field1> [, <field2>]* [default <inst>] { ... }
1486 #
1487 def p_decode_block(self, t):
1488 'decode_block : DECODE ID opt_default LBRACE decode_stmt_list RBRACE'
1489 default_defaults = self.defaultStack.pop()
1490 codeObj = t[5]
1491 # use the "default defaults" only if there was no explicit
1492 # default statement in decode_stmt_list
1493 if not codeObj.has_decode_default:
1494 codeObj += default_defaults
1495 codeObj.wrap_decode_block('switch (%s) {\n' % t[2], '}\n')
1496 t[0] = codeObj
1497
1498 # The opt_default statement serves only to push the "default
1499 # defaults" onto defaultStack. This value will be used by nested
1500 # decode blocks, and used and popped off when the current
1501 # decode_block is processed (in p_decode_block() above).
1502 def p_opt_default_0(self, t):
1503 'opt_default : empty'
1504 # no default specified: reuse the one currently at the top of
1505 # the stack
1506 self.defaultStack.push(self.defaultStack.top())
1507 # no meaningful value returned
1508 t[0] = None
1509
1510 def p_opt_default_1(self, t):
1511 'opt_default : DEFAULT inst'
1512 # push the new default
1513 codeObj = t[2]
1514 codeObj.wrap_decode_block('\ndefault:\n', 'break;\n')
1515 self.defaultStack.push(codeObj)
1516 # no meaningful value returned
1517 t[0] = None
1518
1519 def p_decode_stmt_list_0(self, t):
1520 'decode_stmt_list : decode_stmt'
1521 t[0] = t[1]
1522
1523 def p_decode_stmt_list_1(self, t):
1524 'decode_stmt_list : decode_stmt decode_stmt_list'
1525 if (t[1].has_decode_default and t[2].has_decode_default):
1526 error(t, 'Two default cases in decode block')
1527 t[0] = t[1] + t[2]
1528
1529 #
1530 # Decode statement rules
1531 #
1532 # There are four types of statements allowed in a decode block:
1533 # 1. Format blocks 'format <foo> { ... }'
1534 # 2. Nested decode blocks
1535 # 3. Instruction definitions.
1536 # 4. C preprocessor directives.
1537
1538
1539 # Preprocessor directives found in a decode statement list are
1540 # passed through to the output, replicated to all of the output
1541 # code streams. This works well for ifdefs, so we can ifdef out
1542 # both the declarations and the decode cases generated by an
1543 # instruction definition. Handling them as part of the grammar
1544 # makes it easy to keep them in the right place with respect to
1545 # the code generated by the other statements.
1546 def p_decode_stmt_cpp(self, t):
1547 'decode_stmt : CPPDIRECTIVE'
1548 t[0] = GenCode(self, t[1], t[1], t[1], t[1])
1549
1550 # A format block 'format <foo> { ... }' sets the default
1551 # instruction format used to handle instruction definitions inside
1552 # the block. This format can be overridden by using an explicit
1553 # format on the instruction definition or with a nested format
1554 # block.
1555 def p_decode_stmt_format(self, t):
1556 'decode_stmt : FORMAT push_format_id LBRACE decode_stmt_list RBRACE'
1557 # The format will be pushed on the stack when 'push_format_id'
1558 # is processed (see below). Once the parser has recognized
1559 # the full production (though the right brace), we're done
1560 # with the format, so now we can pop it.
1561 self.formatStack.pop()
1562 t[0] = t[4]
1563
1564 # This rule exists so we can set the current format (& push the
1565 # stack) when we recognize the format name part of the format
1566 # block.
1567 def p_push_format_id(self, t):
1568 'push_format_id : ID'
1569 try:
1570 self.formatStack.push(self.formatMap[t[1]])
1571 t[0] = ('', '// format %s' % t[1])
1572 except KeyError:
1573 error(t, 'instruction format "%s" not defined.' % t[1])
1574
1575 # Nested decode block: if the value of the current field matches
1576 # the specified constant, do a nested decode on some other field.
1577 def p_decode_stmt_decode(self, t):
1578 'decode_stmt : case_label COLON decode_block'
1579 label = t[1]
1580 codeObj = t[3]
1581 # just wrap the decoding code from the block as a case in the
1582 # outer switch statement.
1583 codeObj.wrap_decode_block('\n%s:\n' % label)
1584 codeObj.has_decode_default = (label == 'default')
1585 t[0] = codeObj
1586
1587 # Instruction definition (finally!).
1588 def p_decode_stmt_inst(self, t):
1589 'decode_stmt : case_label COLON inst SEMI'
1590 label = t[1]
1591 codeObj = t[3]
1592 codeObj.wrap_decode_block('\n%s:' % label, 'break;\n')
1593 codeObj.has_decode_default = (label == 'default')
1594 t[0] = codeObj
1595
1596 # The case label is either a list of one or more constants or
1597 # 'default'
1598 def p_case_label_0(self, t):
1599 'case_label : intlit_list'
1600 def make_case(intlit):
1601 if intlit >= 2**32:
1602 return 'case ULL(%#x)' % intlit
1603 else:
1604 return 'case %#x' % intlit
1605 t[0] = ': '.join(map(make_case, t[1]))
1606
1607 def p_case_label_1(self, t):
1608 'case_label : DEFAULT'
1609 t[0] = 'default'
1610
1611 #
1612 # The constant list for a decode case label must be non-empty, but
1613 # may have one or more comma-separated integer literals in it.
1614 #
1615 def p_intlit_list_0(self, t):
1616 'intlit_list : INTLIT'
1617 t[0] = [t[1]]
1618
1619 def p_intlit_list_1(self, t):
1620 'intlit_list : intlit_list COMMA INTLIT'
1621 t[0] = t[1]
1622 t[0].append(t[3])
1623
1624 # Define an instruction using the current instruction format
1625 # (specified by an enclosing format block).
1626 # "<mnemonic>(<args>)"
1627 def p_inst_0(self, t):
1628 'inst : ID LPAREN arg_list RPAREN'
1629 # Pass the ID and arg list to the current format class to deal with.
1630 currentFormat = self.formatStack.top()
1631 codeObj = currentFormat.defineInst(self, t[1], t[3], t.lexer.lineno)
1632 args = ','.join(map(str, t[3]))
1633 args = re.sub('(?m)^', '//', args)
1634 args = re.sub('^//', '', args)
1635 comment = '\n// %s::%s(%s)\n' % (currentFormat.id, t[1], args)
1636 codeObj.prepend_all(comment)
1637 t[0] = codeObj
1638
1639 # Define an instruction using an explicitly specified format:
1640 # "<fmt>::<mnemonic>(<args>)"
1641 def p_inst_1(self, t):
1642 'inst : ID DBLCOLON ID LPAREN arg_list RPAREN'
1643 try:
1644 format = self.formatMap[t[1]]
1645 except KeyError:
1646 error(t, 'instruction format "%s" not defined.' % t[1])
1647
1648 codeObj = format.defineInst(self, t[3], t[5], t.lexer.lineno)
1649 comment = '\n// %s::%s(%s)\n' % (t[1], t[3], t[5])
1650 codeObj.prepend_all(comment)
1651 t[0] = codeObj
1652
1653 # The arg list generates a tuple, where the first element is a
1654 # list of the positional args and the second element is a dict
1655 # containing the keyword args.
1656 def p_arg_list_0(self, t):
1657 'arg_list : positional_arg_list COMMA keyword_arg_list'
1658 t[0] = ( t[1], t[3] )
1659
1660 def p_arg_list_1(self, t):
1661 'arg_list : positional_arg_list'
1662 t[0] = ( t[1], {} )
1663
1664 def p_arg_list_2(self, t):
1665 'arg_list : keyword_arg_list'
1666 t[0] = ( [], t[1] )
1667
1668 def p_positional_arg_list_0(self, t):
1669 'positional_arg_list : empty'
1670 t[0] = []
1671
1672 def p_positional_arg_list_1(self, t):
1673 'positional_arg_list : expr'
1674 t[0] = [t[1]]
1675
1676 def p_positional_arg_list_2(self, t):
1677 'positional_arg_list : positional_arg_list COMMA expr'
1678 t[0] = t[1] + [t[3]]
1679
1680 def p_keyword_arg_list_0(self, t):
1681 'keyword_arg_list : keyword_arg'
1682 t[0] = t[1]
1683
1684 def p_keyword_arg_list_1(self, t):
1685 'keyword_arg_list : keyword_arg_list COMMA keyword_arg'
1686 t[0] = t[1]
1687 t[0].update(t[3])
1688
1689 def p_keyword_arg(self, t):
1690 'keyword_arg : ID EQUALS expr'
1691 t[0] = { t[1] : t[3] }
1692
1693 #
1694 # Basic expressions. These constitute the argument values of
1695 # "function calls" (i.e. instruction definitions in the decode
1696 # block) and default values for formal parameters of format
1697 # functions.
1698 #
1699 # Right now, these are either strings, integers, or (recursively)
1700 # lists of exprs (using Python square-bracket list syntax). Note
1701 # that bare identifiers are trated as string constants here (since
1702 # there isn't really a variable namespace to refer to).
1703 #
1704 def p_expr_0(self, t):
1705 '''expr : ID
1706 | INTLIT
1707 | STRLIT
1708 | CODELIT'''
1709 t[0] = t[1]
1710
1711 def p_expr_1(self, t):
1712 '''expr : LBRACKET list_expr RBRACKET'''
1713 t[0] = t[2]
1714
1715 def p_list_expr_0(self, t):
1716 'list_expr : expr'
1717 t[0] = [t[1]]
1718
1719 def p_list_expr_1(self, t):
1720 'list_expr : list_expr COMMA expr'
1721 t[0] = t[1] + [t[3]]
1722
1723 def p_list_expr_2(self, t):
1724 'list_expr : empty'
1725 t[0] = []
1726
1727 #
1728 # Empty production... use in other rules for readability.
1729 #
1730 def p_empty(self, t):
1731 'empty :'
1732 pass
1733
1734 # Parse error handler. Note that the argument here is the
1735 # offending *token*, not a grammar symbol (hence the need to use
1736 # t.value)
1737 def p_error(self, t):
1738 if t:
1739 error(t, "syntax error at '%s'" % t.value)
1740 else:
1741 error("unknown syntax error")
1742
1743 # END OF GRAMMAR RULES
1744
1745 def updateExportContext(self):
1746
1747 # create a continuation that allows us to grab the current parser
1748 def wrapInstObjParams(*args):
1749 return InstObjParams(self, *args)
1750 self.exportContext['InstObjParams'] = wrapInstObjParams
1751 self.exportContext.update(self.templateMap)
1752
1753 def defFormat(self, id, params, code, lineno):
1754 '''Define a new format'''
1755
1756 # make sure we haven't already defined this one
1757 if id in self.formatMap:
1758 error(lineno, 'format %s redefined.' % id)
1759
1760 # create new object and store in global map
1761 self.formatMap[id] = Format(id, params, code)
1762
1763 def expandCpuSymbolsToDict(self, template):
1764 '''Expand template with CPU-specific references into a
1765 dictionary with an entry for each CPU model name. The entry
1766 key is the model name and the corresponding value is the
1767 template with the CPU-specific refs substituted for that
1768 model.'''
1769
1770 # Protect '%'s that don't go with CPU-specific terms
1771 t = re.sub(r'%(?!\(CPU_)', '%%', template)
1772 result = {}
1773 for cpu in self.cpuModels:
1774 result[cpu.name] = t % cpu.strings
1775 return result
1776
1777 def expandCpuSymbolsToString(self, template):
1778 '''*If* the template has CPU-specific references, return a
1779 single string containing a copy of the template for each CPU
1780 model with the corresponding values substituted in. If the
1781 template has no CPU-specific references, it is returned
1782 unmodified.'''
1783
1784 if template.find('%(CPU_') != -1:
1785 return reduce(lambda x,y: x+y,
1786 self.expandCpuSymbolsToDict(template).values())
1787 else:
1788 return template
1789
1790 def protectCpuSymbols(self, template):
1791 '''Protect CPU-specific references by doubling the
1792 corresponding '%'s (in preparation for substituting a different
1793 set of references into the template).'''
1794
1795 return re.sub(r'%(?=\(CPU_)', '%%', template)
1796
1797 def protectNonSubstPercents(self, s):
1798 '''Protect any non-dict-substitution '%'s in a format string
1799 (i.e. those not followed by '(')'''
1800
1801 return re.sub(r'%(?!\()', '%%', s)
1802
1803 def buildOperandTypeMap(self, user_dict, lineno):
1804 """Generate operandTypeMap from the user's 'def operand_types'
1805 statement."""
1806 operand_type = {}
1807 for (ext, (desc, size)) in user_dict.iteritems():
1808 if desc == 'signed int':
1809 ctype = 'int%d_t' % size
1810 is_signed = 1
1811 elif desc == 'unsigned int':
1812 ctype = 'uint%d_t' % size
1813 is_signed = 0
1814 elif desc == 'float':
1815 is_signed = 1 # shouldn't really matter
1816 if size == 32:
1817 ctype = 'float'
1818 elif size == 64:
1819 ctype = 'double'
1820 elif desc == 'twin64 int':
1821 is_signed = 0
1822 ctype = 'Twin64_t'
1823 elif desc == 'twin32 int':
1824 is_signed = 0
1825 ctype = 'Twin32_t'
1826 if ctype == '':
1827 error(parser, lineno,
1828 'Unrecognized type description "%s" in user_dict')
1829 operand_type[ext] = (size, ctype, is_signed)
1830
1831 self.operandTypeMap = operand_type
1832
1833 def buildOperandNameMap(self, user_dict, lineno):
1834 operand_name = {}
1835 for op_name, val in user_dict.iteritems():
1836 base_cls_name, dflt_ext, reg_spec, flags, sort_pri = val[:5]
1837 if len(val) > 5:
1838 read_code = val[5]
1839 else:
1840 read_code = None
1841 if len(val) > 6:
1842 write_code = val[6]
1843 else:
1844 write_code = None
1845 if len(val) > 7:
1846 error(lineno,
1847 'error: too many attributes for operand "%s"' %
1848 base_cls_name)
1849
1850 (dflt_size, dflt_ctype, dflt_is_signed) = \
1851 self.operandTypeMap[dflt_ext]
1852 # Canonical flag structure is a triple of lists, where each list
1853 # indicates the set of flags implied by this operand always, when
1854 # used as a source, and when used as a dest, respectively.
1855 # For simplicity this can be initialized using a variety of fairly
1856 # obvious shortcuts; we convert these to canonical form here.
1857 if not flags:
1858 # no flags specified (e.g., 'None')
1859 flags = ( [], [], [] )
1860 elif isinstance(flags, str):
1861 # a single flag: assumed to be unconditional
1862 flags = ( [ flags ], [], [] )
1863 elif isinstance(flags, list):
1864 # a list of flags: also assumed to be unconditional
1865 flags = ( flags, [], [] )
1866 elif isinstance(flags, tuple):
1867 # it's a tuple: it should be a triple,
1868 # but each item could be a single string or a list
1869 (uncond_flags, src_flags, dest_flags) = flags
1870 flags = (makeList(uncond_flags),
1871 makeList(src_flags), makeList(dest_flags))
1872 # Accumulate attributes of new operand class in tmp_dict
1873 tmp_dict = {}
1874 for attr in ('dflt_ext', 'reg_spec', 'flags', 'sort_pri',
1875 'dflt_size', 'dflt_ctype', 'dflt_is_signed',
1876 'read_code', 'write_code'):
1877 tmp_dict[attr] = eval(attr)
1878 tmp_dict['base_name'] = op_name
1879 # New class name will be e.g. "IntReg_Ra"
1880 cls_name = base_cls_name + '_' + op_name
1881 # Evaluate string arg to get class object. Note that the
1882 # actual base class for "IntReg" is "IntRegOperand", i.e. we
1883 # have to append "Operand".
1884 try:
1885 base_cls = eval(base_cls_name + 'Operand')
1886 except NameError:
1887 error(lineno,
1888 'error: unknown operand base class "%s"' % base_cls_name)
1889 # The following statement creates a new class called
1890 # <cls_name> as a subclass of <base_cls> with the attributes
1891 # in tmp_dict, just as if we evaluated a class declaration.
1892 operand_name[op_name] = type(cls_name, (base_cls,), tmp_dict)
1893
1894 self.operandNameMap = operand_name
1895
1896 # Define operand variables.
1897 operands = user_dict.keys()
1898
1899 operandsREString = (r'''
1900 (?<![\w\.]) # neg. lookbehind assertion: prevent partial matches
1901 ((%s)(?:\.(\w+))?) # match: operand with optional '.' then suffix
1902 (?![\w\.]) # neg. lookahead assertion: prevent partial matches
1903 '''
1904 % string.join(operands, '|'))
1905
1906 self.operandsRE = re.compile(operandsREString, re.MULTILINE|re.VERBOSE)
1907
1908 # Same as operandsREString, but extension is mandatory, and only two
1909 # groups are returned (base and ext, not full name as above).
1910 # Used for subtituting '_' for '.' to make C++ identifiers.
1911 operandsWithExtREString = (r'(?<![\w\.])(%s)\.(\w+)(?![\w\.])'
1912 % string.join(operands, '|'))
1913
1914 self.operandsWithExtRE = \
1915 re.compile(operandsWithExtREString, re.MULTILINE)
1916
1917 def substMungedOpNames(self, code):
1918 '''Munge operand names in code string to make legal C++
1919 variable names. This means getting rid of the type extension
1920 if any. Will match base_name attribute of Operand object.)'''
1921 return self.operandsWithExtRE.sub(r'\1', code)
1922
1923 def mungeSnippet(self, s):
1924 '''Fix up code snippets for final substitution in templates.'''
1925 if isinstance(s, str):
1926 return self.substMungedOpNames(substBitOps(s))
1927 else:
1928 return s
1929
1930 def update_if_needed(self, file, contents):
1931 '''Update the output file only if the new contents are
1932 different from the current contents. Minimizes the files that
1933 need to be rebuilt after minor changes.'''
1934
1935 file = os.path.join(self.output_dir, file)
1936 update = False
1937 if os.access(file, os.R_OK):
1938 f = open(file, 'r')
1939 old_contents = f.read()
1940 f.close()
1941 if contents != old_contents:
1942 print 'Updating', file
1943 os.remove(file) # in case it's write-protected
1944 update = True
1945 else:
1946 print 'File', file, 'is unchanged'
1947 else:
| 1# Copyright (c) 2003-2005 The Regents of The University of Michigan
2# All rights reserved.
3#
4# Redistribution and use in source and binary forms, with or without
5# modification, are permitted provided that the following conditions are
6# met: redistributions of source code must retain the above copyright
7# notice, this list of conditions and the following disclaimer;
8# redistributions in binary form must reproduce the above copyright
9# notice, this list of conditions and the following disclaimer in the
10# documentation and/or other materials provided with the distribution;
11# neither the name of the copyright holders nor the names of its
12# contributors may be used to endorse or promote products derived from
13# this software without specific prior written permission.
14#
15# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
16# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
17# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
18# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
19# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
20# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
21# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
22# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
23# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
25# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26#
27# Authors: Steve Reinhardt
28
29import os
30import sys
31import re
32import string
33import inspect, traceback
34# get type names
35from types import *
36
37from m5.util.grammar import Grammar
38
39debug=False
40
41###################
42# Utility functions
43
44#
45# Indent every line in string 's' by two spaces
46# (except preprocessor directives).
47# Used to make nested code blocks look pretty.
48#
49def indent(s):
50 return re.sub(r'(?m)^(?!#)', ' ', s)
51
52#
53# Munge a somewhat arbitrarily formatted piece of Python code
54# (e.g. from a format 'let' block) into something whose indentation
55# will get by the Python parser.
56#
57# The two keys here are that Python will give a syntax error if
58# there's any whitespace at the beginning of the first line, and that
59# all lines at the same lexical nesting level must have identical
60# indentation. Unfortunately the way code literals work, an entire
61# let block tends to have some initial indentation. Rather than
62# trying to figure out what that is and strip it off, we prepend 'if
63# 1:' to make the let code the nested block inside the if (and have
64# the parser automatically deal with the indentation for us).
65#
66# We don't want to do this if (1) the code block is empty or (2) the
67# first line of the block doesn't have any whitespace at the front.
68
69def fixPythonIndentation(s):
70 # get rid of blank lines first
71 s = re.sub(r'(?m)^\s*\n', '', s);
72 if (s != '' and re.match(r'[ \t]', s[0])):
73 s = 'if 1:\n' + s
74 return s
75
76class ISAParserError(Exception):
77 """Error handler for parser errors"""
78 def __init__(self, first, second=None):
79 if second is None:
80 self.lineno = 0
81 self.string = first
82 else:
83 if hasattr(first, 'lexer'):
84 first = first.lexer.lineno
85 self.lineno = first
86 self.string = second
87
88 def display(self, filename_stack, print_traceback=debug):
89 # Output formatted to work under Emacs compile-mode. Optional
90 # 'print_traceback' arg, if set to True, prints a Python stack
91 # backtrace too (can be handy when trying to debug the parser
92 # itself).
93
94 spaces = ""
95 for (filename, line) in filename_stack[:-1]:
96 print "%sIn file included from %s:" % (spaces, filename)
97 spaces += " "
98
99 # Print a Python stack backtrace if requested.
100 if print_traceback or not self.lineno:
101 traceback.print_exc()
102
103 line_str = "%s:" % (filename_stack[-1][0], )
104 if self.lineno:
105 line_str += "%d:" % (self.lineno, )
106
107 return "%s%s %s" % (spaces, line_str, self.string)
108
109 def exit(self, filename_stack, print_traceback=debug):
110 # Just call exit.
111
112 sys.exit(self.display(filename_stack, print_traceback))
113
114def error(*args):
115 raise ISAParserError(*args)
116
117####################
118# Template objects.
119#
120# Template objects are format strings that allow substitution from
121# the attribute spaces of other objects (e.g. InstObjParams instances).
122
123labelRE = re.compile(r'(?<!%)%\(([^\)]+)\)[sd]')
124
125class Template(object):
126 def __init__(self, parser, t):
127 self.parser = parser
128 self.template = t
129
130 def subst(self, d):
131 myDict = None
132
133 # Protect non-Python-dict substitutions (e.g. if there's a printf
134 # in the templated C++ code)
135 template = self.parser.protectNonSubstPercents(self.template)
136 # CPU-model-specific substitutions are handled later (in GenCode).
137 template = self.parser.protectCpuSymbols(template)
138
139 # Build a dict ('myDict') to use for the template substitution.
140 # Start with the template namespace. Make a copy since we're
141 # going to modify it.
142 myDict = self.parser.templateMap.copy()
143
144 if isinstance(d, InstObjParams):
145 # If we're dealing with an InstObjParams object, we need
146 # to be a little more sophisticated. The instruction-wide
147 # parameters are already formed, but the parameters which
148 # are only function wide still need to be generated.
149 compositeCode = ''
150
151 myDict.update(d.__dict__)
152 # The "operands" and "snippets" attributes of the InstObjParams
153 # objects are for internal use and not substitution.
154 del myDict['operands']
155 del myDict['snippets']
156
157 snippetLabels = [l for l in labelRE.findall(template)
158 if d.snippets.has_key(l)]
159
160 snippets = dict([(s, self.parser.mungeSnippet(d.snippets[s]))
161 for s in snippetLabels])
162
163 myDict.update(snippets)
164
165 compositeCode = ' '.join(map(str, snippets.values()))
166
167 # Add in template itself in case it references any
168 # operands explicitly (like Mem)
169 compositeCode += ' ' + template
170
171 operands = SubOperandList(self.parser, compositeCode, d.operands)
172
173 myDict['op_decl'] = operands.concatAttrStrings('op_decl')
174
175 is_src = lambda op: op.is_src
176 is_dest = lambda op: op.is_dest
177
178 myDict['op_src_decl'] = \
179 operands.concatSomeAttrStrings(is_src, 'op_src_decl')
180 myDict['op_dest_decl'] = \
181 operands.concatSomeAttrStrings(is_dest, 'op_dest_decl')
182
183 myDict['op_rd'] = operands.concatAttrStrings('op_rd')
184 myDict['op_wb'] = operands.concatAttrStrings('op_wb')
185
186 if d.operands.memOperand:
187 myDict['mem_acc_size'] = d.operands.memOperand.mem_acc_size
188 myDict['mem_acc_type'] = d.operands.memOperand.mem_acc_type
189
190 elif isinstance(d, dict):
191 # if the argument is a dictionary, we just use it.
192 myDict.update(d)
193 elif hasattr(d, '__dict__'):
194 # if the argument is an object, we use its attribute map.
195 myDict.update(d.__dict__)
196 else:
197 raise TypeError, "Template.subst() arg must be or have dictionary"
198 return template % myDict
199
200 # Convert to string. This handles the case when a template with a
201 # CPU-specific term gets interpolated into another template or into
202 # an output block.
203 def __str__(self):
204 return self.parser.expandCpuSymbolsToString(self.template)
205
206################
207# Format object.
208#
209# A format object encapsulates an instruction format. It must provide
210# a defineInst() method that generates the code for an instruction
211# definition.
212
213class Format(object):
214 def __init__(self, id, params, code):
215 self.id = id
216 self.params = params
217 label = 'def format ' + id
218 self.user_code = compile(fixPythonIndentation(code), label, 'exec')
219 param_list = string.join(params, ", ")
220 f = '''def defInst(_code, _context, %s):
221 my_locals = vars().copy()
222 exec _code in _context, my_locals
223 return my_locals\n''' % param_list
224 c = compile(f, label + ' wrapper', 'exec')
225 exec c
226 self.func = defInst
227
228 def defineInst(self, parser, name, args, lineno):
229 parser.updateExportContext()
230 context = parser.exportContext.copy()
231 if len(name):
232 Name = name[0].upper()
233 if len(name) > 1:
234 Name += name[1:]
235 context.update({ 'name' : name, 'Name' : Name })
236 try:
237 vars = self.func(self.user_code, context, *args[0], **args[1])
238 except Exception, exc:
239 if debug:
240 raise
241 error(lineno, 'error defining "%s": %s.' % (name, exc))
242 for k in vars.keys():
243 if k not in ('header_output', 'decoder_output',
244 'exec_output', 'decode_block'):
245 del vars[k]
246 return GenCode(parser, **vars)
247
248# Special null format to catch an implicit-format instruction
249# definition outside of any format block.
250class NoFormat(object):
251 def __init__(self):
252 self.defaultInst = ''
253
254 def defineInst(self, parser, name, args, lineno):
255 error(lineno,
256 'instruction definition "%s" with no active format!' % name)
257
258###############
259# GenCode class
260#
261# The GenCode class encapsulates generated code destined for various
262# output files. The header_output and decoder_output attributes are
263# strings containing code destined for decoder.hh and decoder.cc
264# respectively. The decode_block attribute contains code to be
265# incorporated in the decode function itself (that will also end up in
266# decoder.cc). The exec_output attribute is a dictionary with a key
267# for each CPU model name; the value associated with a particular key
268# is the string of code for that CPU model's exec.cc file. The
269# has_decode_default attribute is used in the decode block to allow
270# explicit default clauses to override default default clauses.
271
272class GenCode(object):
273 # Constructor. At this point we substitute out all CPU-specific
274 # symbols. For the exec output, these go into the per-model
275 # dictionary. For all other output types they get collapsed into
276 # a single string.
277 def __init__(self, parser,
278 header_output = '', decoder_output = '', exec_output = '',
279 decode_block = '', has_decode_default = False):
280 self.parser = parser
281 self.header_output = parser.expandCpuSymbolsToString(header_output)
282 self.decoder_output = parser.expandCpuSymbolsToString(decoder_output)
283 if isinstance(exec_output, dict):
284 self.exec_output = exec_output
285 elif isinstance(exec_output, str):
286 # If the exec_output arg is a single string, we replicate
287 # it for each of the CPU models, substituting and
288 # %(CPU_foo)s params appropriately.
289 self.exec_output = parser.expandCpuSymbolsToDict(exec_output)
290 self.decode_block = parser.expandCpuSymbolsToString(decode_block)
291 self.has_decode_default = has_decode_default
292
293 # Override '+' operator: generate a new GenCode object that
294 # concatenates all the individual strings in the operands.
295 def __add__(self, other):
296 exec_output = {}
297 for cpu in self.parser.cpuModels:
298 n = cpu.name
299 exec_output[n] = self.exec_output[n] + other.exec_output[n]
300 return GenCode(self.parser,
301 self.header_output + other.header_output,
302 self.decoder_output + other.decoder_output,
303 exec_output,
304 self.decode_block + other.decode_block,
305 self.has_decode_default or other.has_decode_default)
306
307 # Prepend a string (typically a comment) to all the strings.
308 def prepend_all(self, pre):
309 self.header_output = pre + self.header_output
310 self.decoder_output = pre + self.decoder_output
311 self.decode_block = pre + self.decode_block
312 for cpu in self.parser.cpuModels:
313 self.exec_output[cpu.name] = pre + self.exec_output[cpu.name]
314
315 # Wrap the decode block in a pair of strings (e.g., 'case foo:'
316 # and 'break;'). Used to build the big nested switch statement.
317 def wrap_decode_block(self, pre, post = ''):
318 self.decode_block = pre + indent(self.decode_block) + post
319
320#####################################################################
321#
322# Bitfield Operator Support
323#
324#####################################################################
325
326bitOp1ArgRE = re.compile(r'<\s*(\w+)\s*:\s*>')
327
328bitOpWordRE = re.compile(r'(?<![\w\.])([\w\.]+)<\s*(\w+)\s*:\s*(\w+)\s*>')
329bitOpExprRE = re.compile(r'\)<\s*(\w+)\s*:\s*(\w+)\s*>')
330
331def substBitOps(code):
332 # first convert single-bit selectors to two-index form
333 # i.e., <n> --> <n:n>
334 code = bitOp1ArgRE.sub(r'<\1:\1>', code)
335 # simple case: selector applied to ID (name)
336 # i.e., foo<a:b> --> bits(foo, a, b)
337 code = bitOpWordRE.sub(r'bits(\1, \2, \3)', code)
338 # if selector is applied to expression (ending in ')'),
339 # we need to search backward for matching '('
340 match = bitOpExprRE.search(code)
341 while match:
342 exprEnd = match.start()
343 here = exprEnd - 1
344 nestLevel = 1
345 while nestLevel > 0:
346 if code[here] == '(':
347 nestLevel -= 1
348 elif code[here] == ')':
349 nestLevel += 1
350 here -= 1
351 if here < 0:
352 sys.exit("Didn't find '('!")
353 exprStart = here+1
354 newExpr = r'bits(%s, %s, %s)' % (code[exprStart:exprEnd+1],
355 match.group(1), match.group(2))
356 code = code[:exprStart] + newExpr + code[match.end():]
357 match = bitOpExprRE.search(code)
358 return code
359
360
361#####################################################################
362#
363# Code Parser
364#
365# The remaining code is the support for automatically extracting
366# instruction characteristics from pseudocode.
367#
368#####################################################################
369
370# Force the argument to be a list. Useful for flags, where a caller
371# can specify a singleton flag or a list of flags. Also usful for
372# converting tuples to lists so they can be modified.
373def makeList(arg):
374 if isinstance(arg, list):
375 return arg
376 elif isinstance(arg, tuple):
377 return list(arg)
378 elif not arg:
379 return []
380 else:
381 return [ arg ]
382
383class Operand(object):
384 '''Base class for operand descriptors. An instance of this class
385 (or actually a class derived from this one) represents a specific
386 operand for a code block (e.g, "Rc.sq" as a dest). Intermediate
387 derived classes encapsulates the traits of a particular operand
388 type (e.g., "32-bit integer register").'''
389
390 def buildReadCode(self, func = None):
391 subst_dict = {"name": self.base_name,
392 "func": func,
393 "reg_idx": self.reg_spec,
394 "size": self.size,
395 "ctype": self.ctype}
396 if hasattr(self, 'src_reg_idx'):
397 subst_dict['op_idx'] = self.src_reg_idx
398 code = self.read_code % subst_dict
399 if self.size != self.dflt_size:
400 return '%s = bits(%s, %d, 0);\n' % \
401 (self.base_name, code, self.size-1)
402 else:
403 return '%s = %s;\n' % \
404 (self.base_name, code)
405
406 def buildWriteCode(self, func = None):
407 if (self.size != self.dflt_size and self.is_signed):
408 final_val = 'sext<%d>(%s)' % (self.size, self.base_name)
409 else:
410 final_val = self.base_name
411 subst_dict = {"name": self.base_name,
412 "func": func,
413 "reg_idx": self.reg_spec,
414 "size": self.size,
415 "ctype": self.ctype,
416 "final_val": final_val}
417 if hasattr(self, 'dest_reg_idx'):
418 subst_dict['op_idx'] = self.dest_reg_idx
419 code = self.write_code % subst_dict
420 return '''
421 {
422 %s final_val = %s;
423 %s;
424 if (traceData) { traceData->setData(final_val); }
425 }''' % (self.dflt_ctype, final_val, code)
426
427 def __init__(self, parser, full_name, ext, is_src, is_dest):
428 self.full_name = full_name
429 self.ext = ext
430 self.is_src = is_src
431 self.is_dest = is_dest
432 # The 'effective extension' (eff_ext) is either the actual
433 # extension, if one was explicitly provided, or the default.
434 if ext:
435 self.eff_ext = ext
436 else:
437 self.eff_ext = self.dflt_ext
438
439 self.size, self.ctype, self.is_signed = \
440 parser.operandTypeMap[self.eff_ext]
441
442 # note that mem_acc_size is undefined for non-mem operands...
443 # template must be careful not to use it if it doesn't apply.
444 if self.isMem():
445 self.mem_acc_size = self.makeAccSize()
446 if self.ctype in ['Twin32_t', 'Twin64_t']:
447 self.mem_acc_type = 'Twin'
448 else:
449 self.mem_acc_type = 'uint'
450
451 # Finalize additional fields (primarily code fields). This step
452 # is done separately since some of these fields may depend on the
453 # register index enumeration that hasn't been performed yet at the
454 # time of __init__().
455 def finalize(self):
456 self.flags = self.getFlags()
457 self.constructor = self.makeConstructor()
458 self.op_decl = self.makeDecl()
459
460 if self.is_src:
461 self.op_rd = self.makeRead()
462 self.op_src_decl = self.makeDecl()
463 else:
464 self.op_rd = ''
465 self.op_src_decl = ''
466
467 if self.is_dest:
468 self.op_wb = self.makeWrite()
469 self.op_dest_decl = self.makeDecl()
470 else:
471 self.op_wb = ''
472 self.op_dest_decl = ''
473
474 def isMem(self):
475 return 0
476
477 def isReg(self):
478 return 0
479
480 def isFloatReg(self):
481 return 0
482
483 def isIntReg(self):
484 return 0
485
486 def isControlReg(self):
487 return 0
488
489 def getFlags(self):
490 # note the empty slice '[:]' gives us a copy of self.flags[0]
491 # instead of a reference to it
492 my_flags = self.flags[0][:]
493 if self.is_src:
494 my_flags += self.flags[1]
495 if self.is_dest:
496 my_flags += self.flags[2]
497 return my_flags
498
499 def makeDecl(self):
500 # Note that initializations in the declarations are solely
501 # to avoid 'uninitialized variable' errors from the compiler.
502 return self.ctype + ' ' + self.base_name + ' = 0;\n';
503
504class IntRegOperand(Operand):
505 def isReg(self):
506 return 1
507
508 def isIntReg(self):
509 return 1
510
511 def makeConstructor(self):
512 c = ''
513 if self.is_src:
514 c += '\n\t_srcRegIdx[%d] = %s;' % \
515 (self.src_reg_idx, self.reg_spec)
516 if self.is_dest:
517 c += '\n\t_destRegIdx[%d] = %s;' % \
518 (self.dest_reg_idx, self.reg_spec)
519 return c
520
521 def makeRead(self):
522 if (self.ctype == 'float' or self.ctype == 'double'):
523 error('Attempt to read integer register as FP')
524 if self.read_code != None:
525 return self.buildReadCode('readIntRegOperand')
526 if (self.size == self.dflt_size):
527 return '%s = xc->readIntRegOperand(this, %d);\n' % \
528 (self.base_name, self.src_reg_idx)
529 elif (self.size > self.dflt_size):
530 int_reg_val = 'xc->readIntRegOperand(this, %d)' % \
531 (self.src_reg_idx)
532 if (self.is_signed):
533 int_reg_val = 'sext<%d>(%s)' % (self.dflt_size, int_reg_val)
534 return '%s = %s;\n' % (self.base_name, int_reg_val)
535 else:
536 return '%s = bits(xc->readIntRegOperand(this, %d), %d, 0);\n' % \
537 (self.base_name, self.src_reg_idx, self.size-1)
538
539 def makeWrite(self):
540 if (self.ctype == 'float' or self.ctype == 'double'):
541 error('Attempt to write integer register as FP')
542 if self.write_code != None:
543 return self.buildWriteCode('setIntRegOperand')
544 if (self.size != self.dflt_size and self.is_signed):
545 final_val = 'sext<%d>(%s)' % (self.size, self.base_name)
546 else:
547 final_val = self.base_name
548 wb = '''
549 {
550 %s final_val = %s;
551 xc->setIntRegOperand(this, %d, final_val);\n
552 if (traceData) { traceData->setData(final_val); }
553 }''' % (self.dflt_ctype, final_val, self.dest_reg_idx)
554 return wb
555
556class FloatRegOperand(Operand):
557 def isReg(self):
558 return 1
559
560 def isFloatReg(self):
561 return 1
562
563 def makeConstructor(self):
564 c = ''
565 if self.is_src:
566 c += '\n\t_srcRegIdx[%d] = %s + FP_Base_DepTag;' % \
567 (self.src_reg_idx, self.reg_spec)
568 if self.is_dest:
569 c += '\n\t_destRegIdx[%d] = %s + FP_Base_DepTag;' % \
570 (self.dest_reg_idx, self.reg_spec)
571 return c
572
573 def makeRead(self):
574 bit_select = 0
575 if (self.ctype == 'float' or self.ctype == 'double'):
576 func = 'readFloatRegOperand'
577 else:
578 func = 'readFloatRegOperandBits'
579 if (self.size != self.dflt_size):
580 bit_select = 1
581 base = 'xc->%s(this, %d)' % (func, self.src_reg_idx)
582 if self.read_code != None:
583 return self.buildReadCode(func)
584 if bit_select:
585 return '%s = bits(%s, %d, 0);\n' % \
586 (self.base_name, base, self.size-1)
587 else:
588 return '%s = %s;\n' % (self.base_name, base)
589
590 def makeWrite(self):
591 final_val = self.base_name
592 final_ctype = self.ctype
593 if (self.ctype == 'float' or self.ctype == 'double'):
594 func = 'setFloatRegOperand'
595 elif (self.ctype == 'uint32_t' or self.ctype == 'uint64_t'):
596 func = 'setFloatRegOperandBits'
597 else:
598 func = 'setFloatRegOperandBits'
599 final_ctype = 'uint%d_t' % self.dflt_size
600 if (self.size != self.dflt_size and self.is_signed):
601 final_val = 'sext<%d>(%s)' % (self.size, self.base_name)
602 if self.write_code != None:
603 return self.buildWriteCode(func)
604 wb = '''
605 {
606 %s final_val = %s;
607 xc->%s(this, %d, final_val);\n
608 if (traceData) { traceData->setData(final_val); }
609 }''' % (final_ctype, final_val, func, self.dest_reg_idx)
610 return wb
611
612class ControlRegOperand(Operand):
613 def isReg(self):
614 return 1
615
616 def isControlReg(self):
617 return 1
618
619 def makeConstructor(self):
620 c = ''
621 if self.is_src:
622 c += '\n\t_srcRegIdx[%d] = %s + Ctrl_Base_DepTag;' % \
623 (self.src_reg_idx, self.reg_spec)
624 if self.is_dest:
625 c += '\n\t_destRegIdx[%d] = %s + Ctrl_Base_DepTag;' % \
626 (self.dest_reg_idx, self.reg_spec)
627 return c
628
629 def makeRead(self):
630 bit_select = 0
631 if (self.ctype == 'float' or self.ctype == 'double'):
632 error('Attempt to read control register as FP')
633 if self.read_code != None:
634 return self.buildReadCode('readMiscRegOperand')
635 base = 'xc->readMiscRegOperand(this, %s)' % self.src_reg_idx
636 if self.size == self.dflt_size:
637 return '%s = %s;\n' % (self.base_name, base)
638 else:
639 return '%s = bits(%s, %d, 0);\n' % \
640 (self.base_name, base, self.size-1)
641
642 def makeWrite(self):
643 if (self.ctype == 'float' or self.ctype == 'double'):
644 error('Attempt to write control register as FP')
645 if self.write_code != None:
646 return self.buildWriteCode('setMiscRegOperand')
647 wb = 'xc->setMiscRegOperand(this, %s, %s);\n' % \
648 (self.dest_reg_idx, self.base_name)
649 wb += 'if (traceData) { traceData->setData(%s); }' % \
650 self.base_name
651 return wb
652
653class MemOperand(Operand):
654 def isMem(self):
655 return 1
656
657 def makeConstructor(self):
658 return ''
659
660 def makeDecl(self):
661 # Note that initializations in the declarations are solely
662 # to avoid 'uninitialized variable' errors from the compiler.
663 # Declare memory data variable.
664 if self.ctype in ['Twin32_t','Twin64_t']:
665 return "%s %s; %s.a = 0; %s.b = 0;\n" % \
666 (self.ctype, self.base_name, self.base_name, self.base_name)
667 return '%s %s = 0;\n' % (self.ctype, self.base_name)
668
669 def makeRead(self):
670 if self.read_code != None:
671 return self.buildReadCode()
672 return ''
673
674 def makeWrite(self):
675 if self.write_code != None:
676 return self.buildWriteCode()
677 return ''
678
679 # Return the memory access size *in bits*, suitable for
680 # forming a type via "uint%d_t". Divide by 8 if you want bytes.
681 def makeAccSize(self):
682 return self.size
683
684class PCStateOperand(Operand):
685 def makeConstructor(self):
686 return ''
687
688 def makeRead(self):
689 return '%s = xc->pcState();\n' % self.base_name
690
691 def makeWrite(self):
692 return 'xc->pcState(%s);\n' % self.base_name
693
694 def makeDecl(self):
695 return 'TheISA::PCState ' + self.base_name + ' M5_VAR_USED;\n';
696
697class PCOperand(Operand):
698 def makeConstructor(self):
699 return ''
700
701 def makeRead(self):
702 return '%s = xc->instAddr();\n' % self.base_name
703
704class UPCOperand(Operand):
705 def makeConstructor(self):
706 return ''
707
708 def makeRead(self):
709 if self.read_code != None:
710 return self.buildReadCode('microPC')
711 return '%s = xc->microPC();\n' % self.base_name
712
713class NPCOperand(Operand):
714 def makeConstructor(self):
715 return ''
716
717 def makeRead(self):
718 if self.read_code != None:
719 return self.buildReadCode('nextInstAddr')
720 return '%s = xc->nextInstAddr();\n' % self.base_name
721
722class OperandList(object):
723 '''Find all the operands in the given code block. Returns an operand
724 descriptor list (instance of class OperandList).'''
725 def __init__(self, parser, code):
726 self.items = []
727 self.bases = {}
728 # delete comments so we don't match on reg specifiers inside
729 code = commentRE.sub('', code)
730 # search for operands
731 next_pos = 0
732 while 1:
733 match = parser.operandsRE.search(code, next_pos)
734 if not match:
735 # no more matches: we're done
736 break
737 op = match.groups()
738 # regexp groups are operand full name, base, and extension
739 (op_full, op_base, op_ext) = op
740 # if the token following the operand is an assignment, this is
741 # a destination (LHS), else it's a source (RHS)
742 is_dest = (assignRE.match(code, match.end()) != None)
743 is_src = not is_dest
744 # see if we've already seen this one
745 op_desc = self.find_base(op_base)
746 if op_desc:
747 if op_desc.ext != op_ext:
748 error('Inconsistent extensions for operand %s' % \
749 op_base)
750 op_desc.is_src = op_desc.is_src or is_src
751 op_desc.is_dest = op_desc.is_dest or is_dest
752 else:
753 # new operand: create new descriptor
754 op_desc = parser.operandNameMap[op_base](parser,
755 op_full, op_ext, is_src, is_dest)
756 self.append(op_desc)
757 # start next search after end of current match
758 next_pos = match.end()
759 self.sort()
760 # enumerate source & dest register operands... used in building
761 # constructor later
762 self.numSrcRegs = 0
763 self.numDestRegs = 0
764 self.numFPDestRegs = 0
765 self.numIntDestRegs = 0
766 self.memOperand = None
767 for op_desc in self.items:
768 if op_desc.isReg():
769 if op_desc.is_src:
770 op_desc.src_reg_idx = self.numSrcRegs
771 self.numSrcRegs += 1
772 if op_desc.is_dest:
773 op_desc.dest_reg_idx = self.numDestRegs
774 self.numDestRegs += 1
775 if op_desc.isFloatReg():
776 self.numFPDestRegs += 1
777 elif op_desc.isIntReg():
778 self.numIntDestRegs += 1
779 elif op_desc.isMem():
780 if self.memOperand:
781 error("Code block has more than one memory operand.")
782 self.memOperand = op_desc
783 if parser.maxInstSrcRegs < self.numSrcRegs:
784 parser.maxInstSrcRegs = self.numSrcRegs
785 if parser.maxInstDestRegs < self.numDestRegs:
786 parser.maxInstDestRegs = self.numDestRegs
787 # now make a final pass to finalize op_desc fields that may depend
788 # on the register enumeration
789 for op_desc in self.items:
790 op_desc.finalize()
791
792 def __len__(self):
793 return len(self.items)
794
795 def __getitem__(self, index):
796 return self.items[index]
797
798 def append(self, op_desc):
799 self.items.append(op_desc)
800 self.bases[op_desc.base_name] = op_desc
801
802 def find_base(self, base_name):
803 # like self.bases[base_name], but returns None if not found
804 # (rather than raising exception)
805 return self.bases.get(base_name)
806
807 # internal helper function for concat[Some]Attr{Strings|Lists}
808 def __internalConcatAttrs(self, attr_name, filter, result):
809 for op_desc in self.items:
810 if filter(op_desc):
811 result += getattr(op_desc, attr_name)
812 return result
813
814 # return a single string that is the concatenation of the (string)
815 # values of the specified attribute for all operands
816 def concatAttrStrings(self, attr_name):
817 return self.__internalConcatAttrs(attr_name, lambda x: 1, '')
818
819 # like concatAttrStrings, but only include the values for the operands
820 # for which the provided filter function returns true
821 def concatSomeAttrStrings(self, filter, attr_name):
822 return self.__internalConcatAttrs(attr_name, filter, '')
823
824 # return a single list that is the concatenation of the (list)
825 # values of the specified attribute for all operands
826 def concatAttrLists(self, attr_name):
827 return self.__internalConcatAttrs(attr_name, lambda x: 1, [])
828
829 # like concatAttrLists, but only include the values for the operands
830 # for which the provided filter function returns true
831 def concatSomeAttrLists(self, filter, attr_name):
832 return self.__internalConcatAttrs(attr_name, filter, [])
833
834 def sort(self):
835 self.items.sort(lambda a, b: a.sort_pri - b.sort_pri)
836
837class SubOperandList(OperandList):
838 '''Find all the operands in the given code block. Returns an operand
839 descriptor list (instance of class OperandList).'''
840 def __init__(self, parser, code, master_list):
841 self.items = []
842 self.bases = {}
843 # delete comments so we don't match on reg specifiers inside
844 code = commentRE.sub('', code)
845 # search for operands
846 next_pos = 0
847 while 1:
848 match = parser.operandsRE.search(code, next_pos)
849 if not match:
850 # no more matches: we're done
851 break
852 op = match.groups()
853 # regexp groups are operand full name, base, and extension
854 (op_full, op_base, op_ext) = op
855 # find this op in the master list
856 op_desc = master_list.find_base(op_base)
857 if not op_desc:
858 error('Found operand %s which is not in the master list!' \
859 ' This is an internal error' % op_base)
860 else:
861 # See if we've already found this operand
862 op_desc = self.find_base(op_base)
863 if not op_desc:
864 # if not, add a reference to it to this sub list
865 self.append(master_list.bases[op_base])
866
867 # start next search after end of current match
868 next_pos = match.end()
869 self.sort()
870 self.memOperand = None
871 for op_desc in self.items:
872 if op_desc.isMem():
873 if self.memOperand:
874 error("Code block has more than one memory operand.")
875 self.memOperand = op_desc
876
877# Regular expression object to match C++ comments
878# (used in findOperands())
879commentRE = re.compile(r'//.*\n')
880
881# Regular expression object to match assignment statements
882# (used in findOperands())
883assignRE = re.compile(r'\s*=(?!=)', re.MULTILINE)
884
885def makeFlagConstructor(flag_list):
886 if len(flag_list) == 0:
887 return ''
888 # filter out repeated flags
889 flag_list.sort()
890 i = 1
891 while i < len(flag_list):
892 if flag_list[i] == flag_list[i-1]:
893 del flag_list[i]
894 else:
895 i += 1
896 pre = '\n\tflags['
897 post = '] = true;'
898 code = pre + string.join(flag_list, post + pre) + post
899 return code
900
901# Assume all instruction flags are of the form 'IsFoo'
902instFlagRE = re.compile(r'Is.*')
903
904# OpClass constants end in 'Op' except No_OpClass
905opClassRE = re.compile(r'.*Op|No_OpClass')
906
907class InstObjParams(object):
908 def __init__(self, parser, mnem, class_name, base_class = '',
909 snippets = {}, opt_args = []):
910 self.mnemonic = mnem
911 self.class_name = class_name
912 self.base_class = base_class
913 if not isinstance(snippets, dict):
914 snippets = {'code' : snippets}
915 compositeCode = ' '.join(map(str, snippets.values()))
916 self.snippets = snippets
917
918 self.operands = OperandList(parser, compositeCode)
919 self.constructor = self.operands.concatAttrStrings('constructor')
920 self.constructor += \
921 '\n\t_numSrcRegs = %d;' % self.operands.numSrcRegs
922 self.constructor += \
923 '\n\t_numDestRegs = %d;' % self.operands.numDestRegs
924 self.constructor += \
925 '\n\t_numFPDestRegs = %d;' % self.operands.numFPDestRegs
926 self.constructor += \
927 '\n\t_numIntDestRegs = %d;' % self.operands.numIntDestRegs
928 self.flags = self.operands.concatAttrLists('flags')
929
930 # Make a basic guess on the operand class (function unit type).
931 # These are good enough for most cases, and can be overridden
932 # later otherwise.
933 if 'IsStore' in self.flags:
934 self.op_class = 'MemWriteOp'
935 elif 'IsLoad' in self.flags or 'IsPrefetch' in self.flags:
936 self.op_class = 'MemReadOp'
937 elif 'IsFloating' in self.flags:
938 self.op_class = 'FloatAddOp'
939 else:
940 self.op_class = 'IntAluOp'
941
942 # Optional arguments are assumed to be either StaticInst flags
943 # or an OpClass value. To avoid having to import a complete
944 # list of these values to match against, we do it ad-hoc
945 # with regexps.
946 for oa in opt_args:
947 if instFlagRE.match(oa):
948 self.flags.append(oa)
949 elif opClassRE.match(oa):
950 self.op_class = oa
951 else:
952 error('InstObjParams: optional arg "%s" not recognized '
953 'as StaticInst::Flag or OpClass.' % oa)
954
955 # add flag initialization to contructor here to include
956 # any flags added via opt_args
957 self.constructor += makeFlagConstructor(self.flags)
958
959 # if 'IsFloating' is set, add call to the FP enable check
960 # function (which should be provided by isa_desc via a declare)
961 if 'IsFloating' in self.flags:
962 self.fp_enable_check = 'fault = checkFpEnableFault(xc);'
963 else:
964 self.fp_enable_check = ''
965
966##############
967# Stack: a simple stack object. Used for both formats (formatStack)
968# and default cases (defaultStack). Simply wraps a list to give more
969# stack-like syntax and enable initialization with an argument list
970# (as opposed to an argument that's a list).
971
972class Stack(list):
973 def __init__(self, *items):
974 list.__init__(self, items)
975
976 def push(self, item):
977 self.append(item);
978
979 def top(self):
980 return self[-1]
981
982#######################
983#
984# Output file template
985#
986
987file_template = '''
988/*
989 * DO NOT EDIT THIS FILE!!!
990 *
991 * It was automatically generated from the ISA description in %(filename)s
992 */
993
994%(includes)s
995
996%(global_output)s
997
998namespace %(namespace)s {
999
1000%(namespace_output)s
1001
1002} // namespace %(namespace)s
1003
1004%(decode_function)s
1005'''
1006
1007max_inst_regs_template = '''
1008/*
1009 * DO NOT EDIT THIS FILE!!!
1010 *
1011 * It was automatically generated from the ISA description in %(filename)s
1012 */
1013
1014namespace %(namespace)s {
1015
1016 const int MaxInstSrcRegs = %(MaxInstSrcRegs)d;
1017 const int MaxInstDestRegs = %(MaxInstDestRegs)d;
1018
1019} // namespace %(namespace)s
1020
1021'''
1022
1023class ISAParser(Grammar):
1024 def __init__(self, output_dir, cpu_models):
1025 super(ISAParser, self).__init__()
1026 self.output_dir = output_dir
1027
1028 self.cpuModels = cpu_models
1029
1030 # variable to hold templates
1031 self.templateMap = {}
1032
1033 # This dictionary maps format name strings to Format objects.
1034 self.formatMap = {}
1035
1036 # The format stack.
1037 self.formatStack = Stack(NoFormat())
1038
1039 # The default case stack.
1040 self.defaultStack = Stack(None)
1041
1042 # Stack that tracks current file and line number. Each
1043 # element is a tuple (filename, lineno) that records the
1044 # *current* filename and the line number in the *previous*
1045 # file where it was included.
1046 self.fileNameStack = Stack()
1047
1048 symbols = ('makeList', 're', 'string')
1049 self.exportContext = dict([(s, eval(s)) for s in symbols])
1050
1051 self.maxInstSrcRegs = 0
1052 self.maxInstDestRegs = 0
1053
1054 #####################################################################
1055 #
1056 # Lexer
1057 #
1058 # The PLY lexer module takes two things as input:
1059 # - A list of token names (the string list 'tokens')
1060 # - A regular expression describing a match for each token. The
1061 # regexp for token FOO can be provided in two ways:
1062 # - as a string variable named t_FOO
1063 # - as the doc string for a function named t_FOO. In this case,
1064 # the function is also executed, allowing an action to be
1065 # associated with each token match.
1066 #
1067 #####################################################################
1068
1069 # Reserved words. These are listed separately as they are matched
1070 # using the same regexp as generic IDs, but distinguished in the
1071 # t_ID() function. The PLY documentation suggests this approach.
1072 reserved = (
1073 'BITFIELD', 'DECODE', 'DECODER', 'DEFAULT', 'DEF', 'EXEC', 'FORMAT',
1074 'HEADER', 'LET', 'NAMESPACE', 'OPERAND_TYPES', 'OPERANDS',
1075 'OUTPUT', 'SIGNED', 'TEMPLATE'
1076 )
1077
1078 # List of tokens. The lex module requires this.
1079 tokens = reserved + (
1080 # identifier
1081 'ID',
1082
1083 # integer literal
1084 'INTLIT',
1085
1086 # string literal
1087 'STRLIT',
1088
1089 # code literal
1090 'CODELIT',
1091
1092 # ( ) [ ] { } < > , ; . : :: *
1093 'LPAREN', 'RPAREN',
1094 'LBRACKET', 'RBRACKET',
1095 'LBRACE', 'RBRACE',
1096 'LESS', 'GREATER', 'EQUALS',
1097 'COMMA', 'SEMI', 'DOT', 'COLON', 'DBLCOLON',
1098 'ASTERISK',
1099
1100 # C preprocessor directives
1101 'CPPDIRECTIVE'
1102
1103 # The following are matched but never returned. commented out to
1104 # suppress PLY warning
1105 # newfile directive
1106 # 'NEWFILE',
1107
1108 # endfile directive
1109 # 'ENDFILE'
1110 )
1111
1112 # Regular expressions for token matching
1113 t_LPAREN = r'\('
1114 t_RPAREN = r'\)'
1115 t_LBRACKET = r'\['
1116 t_RBRACKET = r'\]'
1117 t_LBRACE = r'\{'
1118 t_RBRACE = r'\}'
1119 t_LESS = r'\<'
1120 t_GREATER = r'\>'
1121 t_EQUALS = r'='
1122 t_COMMA = r','
1123 t_SEMI = r';'
1124 t_DOT = r'\.'
1125 t_COLON = r':'
1126 t_DBLCOLON = r'::'
1127 t_ASTERISK = r'\*'
1128
1129 # Identifiers and reserved words
1130 reserved_map = { }
1131 for r in reserved:
1132 reserved_map[r.lower()] = r
1133
1134 def t_ID(self, t):
1135 r'[A-Za-z_]\w*'
1136 t.type = self.reserved_map.get(t.value, 'ID')
1137 return t
1138
1139 # Integer literal
1140 def t_INTLIT(self, t):
1141 r'-?(0x[\da-fA-F]+)|\d+'
1142 try:
1143 t.value = int(t.value,0)
1144 except ValueError:
1145 error(t, 'Integer value "%s" too large' % t.value)
1146 t.value = 0
1147 return t
1148
1149 # String literal. Note that these use only single quotes, and
1150 # can span multiple lines.
1151 def t_STRLIT(self, t):
1152 r"(?m)'([^'])+'"
1153 # strip off quotes
1154 t.value = t.value[1:-1]
1155 t.lexer.lineno += t.value.count('\n')
1156 return t
1157
1158
1159 # "Code literal"... like a string literal, but delimiters are
1160 # '{{' and '}}' so they get formatted nicely under emacs c-mode
1161 def t_CODELIT(self, t):
1162 r"(?m)\{\{([^\}]|}(?!\}))+\}\}"
1163 # strip off {{ & }}
1164 t.value = t.value[2:-2]
1165 t.lexer.lineno += t.value.count('\n')
1166 return t
1167
1168 def t_CPPDIRECTIVE(self, t):
1169 r'^\#[^\#].*\n'
1170 t.lexer.lineno += t.value.count('\n')
1171 return t
1172
1173 def t_NEWFILE(self, t):
1174 r'^\#\#newfile\s+"[\w/.-]*"'
1175 self.fileNameStack.push((t.value[11:-1], t.lexer.lineno))
1176 t.lexer.lineno = 0
1177
1178 def t_ENDFILE(self, t):
1179 r'^\#\#endfile'
1180 (old_filename, t.lexer.lineno) = self.fileNameStack.pop()
1181
1182 #
1183 # The functions t_NEWLINE, t_ignore, and t_error are
1184 # special for the lex module.
1185 #
1186
1187 # Newlines
1188 def t_NEWLINE(self, t):
1189 r'\n+'
1190 t.lexer.lineno += t.value.count('\n')
1191
1192 # Comments
1193 def t_comment(self, t):
1194 r'//.*'
1195
1196 # Completely ignored characters
1197 t_ignore = ' \t\x0c'
1198
1199 # Error handler
1200 def t_error(self, t):
1201 error(t, "illegal character '%s'" % t.value[0])
1202 t.skip(1)
1203
1204 #####################################################################
1205 #
1206 # Parser
1207 #
1208 # Every function whose name starts with 'p_' defines a grammar
1209 # rule. The rule is encoded in the function's doc string, while
1210 # the function body provides the action taken when the rule is
1211 # matched. The argument to each function is a list of the values
1212 # of the rule's symbols: t[0] for the LHS, and t[1..n] for the
1213 # symbols on the RHS. For tokens, the value is copied from the
1214 # t.value attribute provided by the lexer. For non-terminals, the
1215 # value is assigned by the producing rule; i.e., the job of the
1216 # grammar rule function is to set the value for the non-terminal
1217 # on the LHS (by assigning to t[0]).
1218 #####################################################################
1219
1220 # The LHS of the first grammar rule is used as the start symbol
1221 # (in this case, 'specification'). Note that this rule enforces
1222 # that there will be exactly one namespace declaration, with 0 or
1223 # more global defs/decls before and after it. The defs & decls
1224 # before the namespace decl will be outside the namespace; those
1225 # after will be inside. The decoder function is always inside the
1226 # namespace.
1227 def p_specification(self, t):
1228 'specification : opt_defs_and_outputs name_decl opt_defs_and_outputs decode_block'
1229 global_code = t[1]
1230 isa_name = t[2]
1231 namespace = isa_name + "Inst"
1232 # wrap the decode block as a function definition
1233 t[4].wrap_decode_block('''
1234StaticInstPtr
1235%(isa_name)s::decodeInst(%(isa_name)s::ExtMachInst machInst)
1236{
1237 using namespace %(namespace)s;
1238''' % vars(), '}')
1239 # both the latter output blocks and the decode block are in
1240 # the namespace
1241 namespace_code = t[3] + t[4]
1242 # pass it all back to the caller of yacc.parse()
1243 t[0] = (isa_name, namespace, global_code, namespace_code)
1244
1245 # ISA name declaration looks like "namespace <foo>;"
1246 def p_name_decl(self, t):
1247 'name_decl : NAMESPACE ID SEMI'
1248 t[0] = t[2]
1249
1250 # 'opt_defs_and_outputs' is a possibly empty sequence of
1251 # def and/or output statements.
1252 def p_opt_defs_and_outputs_0(self, t):
1253 'opt_defs_and_outputs : empty'
1254 t[0] = GenCode(self)
1255
1256 def p_opt_defs_and_outputs_1(self, t):
1257 'opt_defs_and_outputs : defs_and_outputs'
1258 t[0] = t[1]
1259
1260 def p_defs_and_outputs_0(self, t):
1261 'defs_and_outputs : def_or_output'
1262 t[0] = t[1]
1263
1264 def p_defs_and_outputs_1(self, t):
1265 'defs_and_outputs : defs_and_outputs def_or_output'
1266 t[0] = t[1] + t[2]
1267
1268 # The list of possible definition/output statements.
1269 def p_def_or_output(self, t):
1270 '''def_or_output : def_format
1271 | def_bitfield
1272 | def_bitfield_struct
1273 | def_template
1274 | def_operand_types
1275 | def_operands
1276 | output_header
1277 | output_decoder
1278 | output_exec
1279 | global_let'''
1280 t[0] = t[1]
1281
1282 # Output blocks 'output <foo> {{...}}' (C++ code blocks) are copied
1283 # directly to the appropriate output section.
1284
1285 # Massage output block by substituting in template definitions and
1286 # bit operators. We handle '%'s embedded in the string that don't
1287 # indicate template substitutions (or CPU-specific symbols, which
1288 # get handled in GenCode) by doubling them first so that the
1289 # format operation will reduce them back to single '%'s.
1290 def process_output(self, s):
1291 s = self.protectNonSubstPercents(s)
1292 # protects cpu-specific symbols too
1293 s = self.protectCpuSymbols(s)
1294 return substBitOps(s % self.templateMap)
1295
1296 def p_output_header(self, t):
1297 'output_header : OUTPUT HEADER CODELIT SEMI'
1298 t[0] = GenCode(self, header_output = self.process_output(t[3]))
1299
1300 def p_output_decoder(self, t):
1301 'output_decoder : OUTPUT DECODER CODELIT SEMI'
1302 t[0] = GenCode(self, decoder_output = self.process_output(t[3]))
1303
1304 def p_output_exec(self, t):
1305 'output_exec : OUTPUT EXEC CODELIT SEMI'
1306 t[0] = GenCode(self, exec_output = self.process_output(t[3]))
1307
1308 # global let blocks 'let {{...}}' (Python code blocks) are
1309 # executed directly when seen. Note that these execute in a
1310 # special variable context 'exportContext' to prevent the code
1311 # from polluting this script's namespace.
1312 def p_global_let(self, t):
1313 'global_let : LET CODELIT SEMI'
1314 self.updateExportContext()
1315 self.exportContext["header_output"] = ''
1316 self.exportContext["decoder_output"] = ''
1317 self.exportContext["exec_output"] = ''
1318 self.exportContext["decode_block"] = ''
1319 try:
1320 exec fixPythonIndentation(t[2]) in self.exportContext
1321 except Exception, exc:
1322 if debug:
1323 raise
1324 error(t, 'error: %s in global let block "%s".' % (exc, t[2]))
1325 t[0] = GenCode(self,
1326 header_output=self.exportContext["header_output"],
1327 decoder_output=self.exportContext["decoder_output"],
1328 exec_output=self.exportContext["exec_output"],
1329 decode_block=self.exportContext["decode_block"])
1330
1331 # Define the mapping from operand type extensions to C++ types and
1332 # bit widths (stored in operandTypeMap).
1333 def p_def_operand_types(self, t):
1334 'def_operand_types : DEF OPERAND_TYPES CODELIT SEMI'
1335 try:
1336 user_dict = eval('{' + t[3] + '}')
1337 except Exception, exc:
1338 if debug:
1339 raise
1340 error(t,
1341 'error: %s in def operand_types block "%s".' % (exc, t[3]))
1342 self.buildOperandTypeMap(user_dict, t.lexer.lineno)
1343 t[0] = GenCode(self) # contributes nothing to the output C++ file
1344
1345 # Define the mapping from operand names to operand classes and
1346 # other traits. Stored in operandNameMap.
1347 def p_def_operands(self, t):
1348 'def_operands : DEF OPERANDS CODELIT SEMI'
1349 if not hasattr(self, 'operandTypeMap'):
1350 error(t, 'error: operand types must be defined before operands')
1351 try:
1352 user_dict = eval('{' + t[3] + '}', self.exportContext)
1353 except Exception, exc:
1354 if debug:
1355 raise
1356 error(t, 'error: %s in def operands block "%s".' % (exc, t[3]))
1357 self.buildOperandNameMap(user_dict, t.lexer.lineno)
1358 t[0] = GenCode(self) # contributes nothing to the output C++ file
1359
1360 # A bitfield definition looks like:
1361 # 'def [signed] bitfield <ID> [<first>:<last>]'
1362 # This generates a preprocessor macro in the output file.
1363 def p_def_bitfield_0(self, t):
1364 'def_bitfield : DEF opt_signed BITFIELD ID LESS INTLIT COLON INTLIT GREATER SEMI'
1365 expr = 'bits(machInst, %2d, %2d)' % (t[6], t[8])
1366 if (t[2] == 'signed'):
1367 expr = 'sext<%d>(%s)' % (t[6] - t[8] + 1, expr)
1368 hash_define = '#undef %s\n#define %s\t%s\n' % (t[4], t[4], expr)
1369 t[0] = GenCode(self, header_output=hash_define)
1370
1371 # alternate form for single bit: 'def [signed] bitfield <ID> [<bit>]'
1372 def p_def_bitfield_1(self, t):
1373 'def_bitfield : DEF opt_signed BITFIELD ID LESS INTLIT GREATER SEMI'
1374 expr = 'bits(machInst, %2d, %2d)' % (t[6], t[6])
1375 if (t[2] == 'signed'):
1376 expr = 'sext<%d>(%s)' % (1, expr)
1377 hash_define = '#undef %s\n#define %s\t%s\n' % (t[4], t[4], expr)
1378 t[0] = GenCode(self, header_output=hash_define)
1379
1380 # alternate form for structure member: 'def bitfield <ID> <ID>'
1381 def p_def_bitfield_struct(self, t):
1382 'def_bitfield_struct : DEF opt_signed BITFIELD ID id_with_dot SEMI'
1383 if (t[2] != ''):
1384 error(t, 'error: structure bitfields are always unsigned.')
1385 expr = 'machInst.%s' % t[5]
1386 hash_define = '#undef %s\n#define %s\t%s\n' % (t[4], t[4], expr)
1387 t[0] = GenCode(self, header_output=hash_define)
1388
1389 def p_id_with_dot_0(self, t):
1390 'id_with_dot : ID'
1391 t[0] = t[1]
1392
1393 def p_id_with_dot_1(self, t):
1394 'id_with_dot : ID DOT id_with_dot'
1395 t[0] = t[1] + t[2] + t[3]
1396
1397 def p_opt_signed_0(self, t):
1398 'opt_signed : SIGNED'
1399 t[0] = t[1]
1400
1401 def p_opt_signed_1(self, t):
1402 'opt_signed : empty'
1403 t[0] = ''
1404
1405 def p_def_template(self, t):
1406 'def_template : DEF TEMPLATE ID CODELIT SEMI'
1407 self.templateMap[t[3]] = Template(self, t[4])
1408 t[0] = GenCode(self)
1409
1410 # An instruction format definition looks like
1411 # "def format <fmt>(<params>) {{...}};"
1412 def p_def_format(self, t):
1413 'def_format : DEF FORMAT ID LPAREN param_list RPAREN CODELIT SEMI'
1414 (id, params, code) = (t[3], t[5], t[7])
1415 self.defFormat(id, params, code, t.lexer.lineno)
1416 t[0] = GenCode(self)
1417
1418 # The formal parameter list for an instruction format is a
1419 # possibly empty list of comma-separated parameters. Positional
1420 # (standard, non-keyword) parameters must come first, followed by
1421 # keyword parameters, followed by a '*foo' parameter that gets
1422 # excess positional arguments (as in Python). Each of these three
1423 # parameter categories is optional.
1424 #
1425 # Note that we do not support the '**foo' parameter for collecting
1426 # otherwise undefined keyword args. Otherwise the parameter list
1427 # is (I believe) identical to what is supported in Python.
1428 #
1429 # The param list generates a tuple, where the first element is a
1430 # list of the positional params and the second element is a dict
1431 # containing the keyword params.
1432 def p_param_list_0(self, t):
1433 'param_list : positional_param_list COMMA nonpositional_param_list'
1434 t[0] = t[1] + t[3]
1435
1436 def p_param_list_1(self, t):
1437 '''param_list : positional_param_list
1438 | nonpositional_param_list'''
1439 t[0] = t[1]
1440
1441 def p_positional_param_list_0(self, t):
1442 'positional_param_list : empty'
1443 t[0] = []
1444
1445 def p_positional_param_list_1(self, t):
1446 'positional_param_list : ID'
1447 t[0] = [t[1]]
1448
1449 def p_positional_param_list_2(self, t):
1450 'positional_param_list : positional_param_list COMMA ID'
1451 t[0] = t[1] + [t[3]]
1452
1453 def p_nonpositional_param_list_0(self, t):
1454 'nonpositional_param_list : keyword_param_list COMMA excess_args_param'
1455 t[0] = t[1] + t[3]
1456
1457 def p_nonpositional_param_list_1(self, t):
1458 '''nonpositional_param_list : keyword_param_list
1459 | excess_args_param'''
1460 t[0] = t[1]
1461
1462 def p_keyword_param_list_0(self, t):
1463 'keyword_param_list : keyword_param'
1464 t[0] = [t[1]]
1465
1466 def p_keyword_param_list_1(self, t):
1467 'keyword_param_list : keyword_param_list COMMA keyword_param'
1468 t[0] = t[1] + [t[3]]
1469
1470 def p_keyword_param(self, t):
1471 'keyword_param : ID EQUALS expr'
1472 t[0] = t[1] + ' = ' + t[3].__repr__()
1473
1474 def p_excess_args_param(self, t):
1475 'excess_args_param : ASTERISK ID'
1476 # Just concatenate them: '*ID'. Wrap in list to be consistent
1477 # with positional_param_list and keyword_param_list.
1478 t[0] = [t[1] + t[2]]
1479
1480 # End of format definition-related rules.
1481 ##############
1482
1483 #
1484 # A decode block looks like:
1485 # decode <field1> [, <field2>]* [default <inst>] { ... }
1486 #
1487 def p_decode_block(self, t):
1488 'decode_block : DECODE ID opt_default LBRACE decode_stmt_list RBRACE'
1489 default_defaults = self.defaultStack.pop()
1490 codeObj = t[5]
1491 # use the "default defaults" only if there was no explicit
1492 # default statement in decode_stmt_list
1493 if not codeObj.has_decode_default:
1494 codeObj += default_defaults
1495 codeObj.wrap_decode_block('switch (%s) {\n' % t[2], '}\n')
1496 t[0] = codeObj
1497
1498 # The opt_default statement serves only to push the "default
1499 # defaults" onto defaultStack. This value will be used by nested
1500 # decode blocks, and used and popped off when the current
1501 # decode_block is processed (in p_decode_block() above).
1502 def p_opt_default_0(self, t):
1503 'opt_default : empty'
1504 # no default specified: reuse the one currently at the top of
1505 # the stack
1506 self.defaultStack.push(self.defaultStack.top())
1507 # no meaningful value returned
1508 t[0] = None
1509
1510 def p_opt_default_1(self, t):
1511 'opt_default : DEFAULT inst'
1512 # push the new default
1513 codeObj = t[2]
1514 codeObj.wrap_decode_block('\ndefault:\n', 'break;\n')
1515 self.defaultStack.push(codeObj)
1516 # no meaningful value returned
1517 t[0] = None
1518
1519 def p_decode_stmt_list_0(self, t):
1520 'decode_stmt_list : decode_stmt'
1521 t[0] = t[1]
1522
1523 def p_decode_stmt_list_1(self, t):
1524 'decode_stmt_list : decode_stmt decode_stmt_list'
1525 if (t[1].has_decode_default and t[2].has_decode_default):
1526 error(t, 'Two default cases in decode block')
1527 t[0] = t[1] + t[2]
1528
1529 #
1530 # Decode statement rules
1531 #
1532 # There are four types of statements allowed in a decode block:
1533 # 1. Format blocks 'format <foo> { ... }'
1534 # 2. Nested decode blocks
1535 # 3. Instruction definitions.
1536 # 4. C preprocessor directives.
1537
1538
1539 # Preprocessor directives found in a decode statement list are
1540 # passed through to the output, replicated to all of the output
1541 # code streams. This works well for ifdefs, so we can ifdef out
1542 # both the declarations and the decode cases generated by an
1543 # instruction definition. Handling them as part of the grammar
1544 # makes it easy to keep them in the right place with respect to
1545 # the code generated by the other statements.
1546 def p_decode_stmt_cpp(self, t):
1547 'decode_stmt : CPPDIRECTIVE'
1548 t[0] = GenCode(self, t[1], t[1], t[1], t[1])
1549
1550 # A format block 'format <foo> { ... }' sets the default
1551 # instruction format used to handle instruction definitions inside
1552 # the block. This format can be overridden by using an explicit
1553 # format on the instruction definition or with a nested format
1554 # block.
1555 def p_decode_stmt_format(self, t):
1556 'decode_stmt : FORMAT push_format_id LBRACE decode_stmt_list RBRACE'
1557 # The format will be pushed on the stack when 'push_format_id'
1558 # is processed (see below). Once the parser has recognized
1559 # the full production (though the right brace), we're done
1560 # with the format, so now we can pop it.
1561 self.formatStack.pop()
1562 t[0] = t[4]
1563
1564 # This rule exists so we can set the current format (& push the
1565 # stack) when we recognize the format name part of the format
1566 # block.
1567 def p_push_format_id(self, t):
1568 'push_format_id : ID'
1569 try:
1570 self.formatStack.push(self.formatMap[t[1]])
1571 t[0] = ('', '// format %s' % t[1])
1572 except KeyError:
1573 error(t, 'instruction format "%s" not defined.' % t[1])
1574
1575 # Nested decode block: if the value of the current field matches
1576 # the specified constant, do a nested decode on some other field.
1577 def p_decode_stmt_decode(self, t):
1578 'decode_stmt : case_label COLON decode_block'
1579 label = t[1]
1580 codeObj = t[3]
1581 # just wrap the decoding code from the block as a case in the
1582 # outer switch statement.
1583 codeObj.wrap_decode_block('\n%s:\n' % label)
1584 codeObj.has_decode_default = (label == 'default')
1585 t[0] = codeObj
1586
1587 # Instruction definition (finally!).
1588 def p_decode_stmt_inst(self, t):
1589 'decode_stmt : case_label COLON inst SEMI'
1590 label = t[1]
1591 codeObj = t[3]
1592 codeObj.wrap_decode_block('\n%s:' % label, 'break;\n')
1593 codeObj.has_decode_default = (label == 'default')
1594 t[0] = codeObj
1595
1596 # The case label is either a list of one or more constants or
1597 # 'default'
1598 def p_case_label_0(self, t):
1599 'case_label : intlit_list'
1600 def make_case(intlit):
1601 if intlit >= 2**32:
1602 return 'case ULL(%#x)' % intlit
1603 else:
1604 return 'case %#x' % intlit
1605 t[0] = ': '.join(map(make_case, t[1]))
1606
1607 def p_case_label_1(self, t):
1608 'case_label : DEFAULT'
1609 t[0] = 'default'
1610
1611 #
1612 # The constant list for a decode case label must be non-empty, but
1613 # may have one or more comma-separated integer literals in it.
1614 #
1615 def p_intlit_list_0(self, t):
1616 'intlit_list : INTLIT'
1617 t[0] = [t[1]]
1618
1619 def p_intlit_list_1(self, t):
1620 'intlit_list : intlit_list COMMA INTLIT'
1621 t[0] = t[1]
1622 t[0].append(t[3])
1623
1624 # Define an instruction using the current instruction format
1625 # (specified by an enclosing format block).
1626 # "<mnemonic>(<args>)"
1627 def p_inst_0(self, t):
1628 'inst : ID LPAREN arg_list RPAREN'
1629 # Pass the ID and arg list to the current format class to deal with.
1630 currentFormat = self.formatStack.top()
1631 codeObj = currentFormat.defineInst(self, t[1], t[3], t.lexer.lineno)
1632 args = ','.join(map(str, t[3]))
1633 args = re.sub('(?m)^', '//', args)
1634 args = re.sub('^//', '', args)
1635 comment = '\n// %s::%s(%s)\n' % (currentFormat.id, t[1], args)
1636 codeObj.prepend_all(comment)
1637 t[0] = codeObj
1638
1639 # Define an instruction using an explicitly specified format:
1640 # "<fmt>::<mnemonic>(<args>)"
1641 def p_inst_1(self, t):
1642 'inst : ID DBLCOLON ID LPAREN arg_list RPAREN'
1643 try:
1644 format = self.formatMap[t[1]]
1645 except KeyError:
1646 error(t, 'instruction format "%s" not defined.' % t[1])
1647
1648 codeObj = format.defineInst(self, t[3], t[5], t.lexer.lineno)
1649 comment = '\n// %s::%s(%s)\n' % (t[1], t[3], t[5])
1650 codeObj.prepend_all(comment)
1651 t[0] = codeObj
1652
1653 # The arg list generates a tuple, where the first element is a
1654 # list of the positional args and the second element is a dict
1655 # containing the keyword args.
1656 def p_arg_list_0(self, t):
1657 'arg_list : positional_arg_list COMMA keyword_arg_list'
1658 t[0] = ( t[1], t[3] )
1659
1660 def p_arg_list_1(self, t):
1661 'arg_list : positional_arg_list'
1662 t[0] = ( t[1], {} )
1663
1664 def p_arg_list_2(self, t):
1665 'arg_list : keyword_arg_list'
1666 t[0] = ( [], t[1] )
1667
1668 def p_positional_arg_list_0(self, t):
1669 'positional_arg_list : empty'
1670 t[0] = []
1671
1672 def p_positional_arg_list_1(self, t):
1673 'positional_arg_list : expr'
1674 t[0] = [t[1]]
1675
1676 def p_positional_arg_list_2(self, t):
1677 'positional_arg_list : positional_arg_list COMMA expr'
1678 t[0] = t[1] + [t[3]]
1679
1680 def p_keyword_arg_list_0(self, t):
1681 'keyword_arg_list : keyword_arg'
1682 t[0] = t[1]
1683
1684 def p_keyword_arg_list_1(self, t):
1685 'keyword_arg_list : keyword_arg_list COMMA keyword_arg'
1686 t[0] = t[1]
1687 t[0].update(t[3])
1688
1689 def p_keyword_arg(self, t):
1690 'keyword_arg : ID EQUALS expr'
1691 t[0] = { t[1] : t[3] }
1692
1693 #
1694 # Basic expressions. These constitute the argument values of
1695 # "function calls" (i.e. instruction definitions in the decode
1696 # block) and default values for formal parameters of format
1697 # functions.
1698 #
1699 # Right now, these are either strings, integers, or (recursively)
1700 # lists of exprs (using Python square-bracket list syntax). Note
1701 # that bare identifiers are trated as string constants here (since
1702 # there isn't really a variable namespace to refer to).
1703 #
1704 def p_expr_0(self, t):
1705 '''expr : ID
1706 | INTLIT
1707 | STRLIT
1708 | CODELIT'''
1709 t[0] = t[1]
1710
1711 def p_expr_1(self, t):
1712 '''expr : LBRACKET list_expr RBRACKET'''
1713 t[0] = t[2]
1714
1715 def p_list_expr_0(self, t):
1716 'list_expr : expr'
1717 t[0] = [t[1]]
1718
1719 def p_list_expr_1(self, t):
1720 'list_expr : list_expr COMMA expr'
1721 t[0] = t[1] + [t[3]]
1722
1723 def p_list_expr_2(self, t):
1724 'list_expr : empty'
1725 t[0] = []
1726
1727 #
1728 # Empty production... use in other rules for readability.
1729 #
1730 def p_empty(self, t):
1731 'empty :'
1732 pass
1733
1734 # Parse error handler. Note that the argument here is the
1735 # offending *token*, not a grammar symbol (hence the need to use
1736 # t.value)
1737 def p_error(self, t):
1738 if t:
1739 error(t, "syntax error at '%s'" % t.value)
1740 else:
1741 error("unknown syntax error")
1742
1743 # END OF GRAMMAR RULES
1744
1745 def updateExportContext(self):
1746
1747 # create a continuation that allows us to grab the current parser
1748 def wrapInstObjParams(*args):
1749 return InstObjParams(self, *args)
1750 self.exportContext['InstObjParams'] = wrapInstObjParams
1751 self.exportContext.update(self.templateMap)
1752
1753 def defFormat(self, id, params, code, lineno):
1754 '''Define a new format'''
1755
1756 # make sure we haven't already defined this one
1757 if id in self.formatMap:
1758 error(lineno, 'format %s redefined.' % id)
1759
1760 # create new object and store in global map
1761 self.formatMap[id] = Format(id, params, code)
1762
1763 def expandCpuSymbolsToDict(self, template):
1764 '''Expand template with CPU-specific references into a
1765 dictionary with an entry for each CPU model name. The entry
1766 key is the model name and the corresponding value is the
1767 template with the CPU-specific refs substituted for that
1768 model.'''
1769
1770 # Protect '%'s that don't go with CPU-specific terms
1771 t = re.sub(r'%(?!\(CPU_)', '%%', template)
1772 result = {}
1773 for cpu in self.cpuModels:
1774 result[cpu.name] = t % cpu.strings
1775 return result
1776
1777 def expandCpuSymbolsToString(self, template):
1778 '''*If* the template has CPU-specific references, return a
1779 single string containing a copy of the template for each CPU
1780 model with the corresponding values substituted in. If the
1781 template has no CPU-specific references, it is returned
1782 unmodified.'''
1783
1784 if template.find('%(CPU_') != -1:
1785 return reduce(lambda x,y: x+y,
1786 self.expandCpuSymbolsToDict(template).values())
1787 else:
1788 return template
1789
1790 def protectCpuSymbols(self, template):
1791 '''Protect CPU-specific references by doubling the
1792 corresponding '%'s (in preparation for substituting a different
1793 set of references into the template).'''
1794
1795 return re.sub(r'%(?=\(CPU_)', '%%', template)
1796
1797 def protectNonSubstPercents(self, s):
1798 '''Protect any non-dict-substitution '%'s in a format string
1799 (i.e. those not followed by '(')'''
1800
1801 return re.sub(r'%(?!\()', '%%', s)
1802
1803 def buildOperandTypeMap(self, user_dict, lineno):
1804 """Generate operandTypeMap from the user's 'def operand_types'
1805 statement."""
1806 operand_type = {}
1807 for (ext, (desc, size)) in user_dict.iteritems():
1808 if desc == 'signed int':
1809 ctype = 'int%d_t' % size
1810 is_signed = 1
1811 elif desc == 'unsigned int':
1812 ctype = 'uint%d_t' % size
1813 is_signed = 0
1814 elif desc == 'float':
1815 is_signed = 1 # shouldn't really matter
1816 if size == 32:
1817 ctype = 'float'
1818 elif size == 64:
1819 ctype = 'double'
1820 elif desc == 'twin64 int':
1821 is_signed = 0
1822 ctype = 'Twin64_t'
1823 elif desc == 'twin32 int':
1824 is_signed = 0
1825 ctype = 'Twin32_t'
1826 if ctype == '':
1827 error(parser, lineno,
1828 'Unrecognized type description "%s" in user_dict')
1829 operand_type[ext] = (size, ctype, is_signed)
1830
1831 self.operandTypeMap = operand_type
1832
1833 def buildOperandNameMap(self, user_dict, lineno):
1834 operand_name = {}
1835 for op_name, val in user_dict.iteritems():
1836 base_cls_name, dflt_ext, reg_spec, flags, sort_pri = val[:5]
1837 if len(val) > 5:
1838 read_code = val[5]
1839 else:
1840 read_code = None
1841 if len(val) > 6:
1842 write_code = val[6]
1843 else:
1844 write_code = None
1845 if len(val) > 7:
1846 error(lineno,
1847 'error: too many attributes for operand "%s"' %
1848 base_cls_name)
1849
1850 (dflt_size, dflt_ctype, dflt_is_signed) = \
1851 self.operandTypeMap[dflt_ext]
1852 # Canonical flag structure is a triple of lists, where each list
1853 # indicates the set of flags implied by this operand always, when
1854 # used as a source, and when used as a dest, respectively.
1855 # For simplicity this can be initialized using a variety of fairly
1856 # obvious shortcuts; we convert these to canonical form here.
1857 if not flags:
1858 # no flags specified (e.g., 'None')
1859 flags = ( [], [], [] )
1860 elif isinstance(flags, str):
1861 # a single flag: assumed to be unconditional
1862 flags = ( [ flags ], [], [] )
1863 elif isinstance(flags, list):
1864 # a list of flags: also assumed to be unconditional
1865 flags = ( flags, [], [] )
1866 elif isinstance(flags, tuple):
1867 # it's a tuple: it should be a triple,
1868 # but each item could be a single string or a list
1869 (uncond_flags, src_flags, dest_flags) = flags
1870 flags = (makeList(uncond_flags),
1871 makeList(src_flags), makeList(dest_flags))
1872 # Accumulate attributes of new operand class in tmp_dict
1873 tmp_dict = {}
1874 for attr in ('dflt_ext', 'reg_spec', 'flags', 'sort_pri',
1875 'dflt_size', 'dflt_ctype', 'dflt_is_signed',
1876 'read_code', 'write_code'):
1877 tmp_dict[attr] = eval(attr)
1878 tmp_dict['base_name'] = op_name
1879 # New class name will be e.g. "IntReg_Ra"
1880 cls_name = base_cls_name + '_' + op_name
1881 # Evaluate string arg to get class object. Note that the
1882 # actual base class for "IntReg" is "IntRegOperand", i.e. we
1883 # have to append "Operand".
1884 try:
1885 base_cls = eval(base_cls_name + 'Operand')
1886 except NameError:
1887 error(lineno,
1888 'error: unknown operand base class "%s"' % base_cls_name)
1889 # The following statement creates a new class called
1890 # <cls_name> as a subclass of <base_cls> with the attributes
1891 # in tmp_dict, just as if we evaluated a class declaration.
1892 operand_name[op_name] = type(cls_name, (base_cls,), tmp_dict)
1893
1894 self.operandNameMap = operand_name
1895
1896 # Define operand variables.
1897 operands = user_dict.keys()
1898
1899 operandsREString = (r'''
1900 (?<![\w\.]) # neg. lookbehind assertion: prevent partial matches
1901 ((%s)(?:\.(\w+))?) # match: operand with optional '.' then suffix
1902 (?![\w\.]) # neg. lookahead assertion: prevent partial matches
1903 '''
1904 % string.join(operands, '|'))
1905
1906 self.operandsRE = re.compile(operandsREString, re.MULTILINE|re.VERBOSE)
1907
1908 # Same as operandsREString, but extension is mandatory, and only two
1909 # groups are returned (base and ext, not full name as above).
1910 # Used for subtituting '_' for '.' to make C++ identifiers.
1911 operandsWithExtREString = (r'(?<![\w\.])(%s)\.(\w+)(?![\w\.])'
1912 % string.join(operands, '|'))
1913
1914 self.operandsWithExtRE = \
1915 re.compile(operandsWithExtREString, re.MULTILINE)
1916
1917 def substMungedOpNames(self, code):
1918 '''Munge operand names in code string to make legal C++
1919 variable names. This means getting rid of the type extension
1920 if any. Will match base_name attribute of Operand object.)'''
1921 return self.operandsWithExtRE.sub(r'\1', code)
1922
1923 def mungeSnippet(self, s):
1924 '''Fix up code snippets for final substitution in templates.'''
1925 if isinstance(s, str):
1926 return self.substMungedOpNames(substBitOps(s))
1927 else:
1928 return s
1929
1930 def update_if_needed(self, file, contents):
1931 '''Update the output file only if the new contents are
1932 different from the current contents. Minimizes the files that
1933 need to be rebuilt after minor changes.'''
1934
1935 file = os.path.join(self.output_dir, file)
1936 update = False
1937 if os.access(file, os.R_OK):
1938 f = open(file, 'r')
1939 old_contents = f.read()
1940 f.close()
1941 if contents != old_contents:
1942 print 'Updating', file
1943 os.remove(file) # in case it's write-protected
1944 update = True
1945 else:
1946 print 'File', file, 'is unchanged'
1947 else:
|