isa_parser.py revision 7720:65d338a8dba4
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:
1948            print 'Generating', file
1949            update = True
1950        if update:
1951            f = open(file, 'w')
1952            f.write(contents)
1953            f.close()
1954
1955    # This regular expression matches '##include' directives
1956    includeRE = re.compile(r'^\s*##include\s+"(?P<filename>[\w/.-]*)".*$',
1957                           re.MULTILINE)
1958
1959    def replace_include(self, matchobj, dirname):
1960        """Function to replace a matched '##include' directive with the
1961        contents of the specified file (with nested ##includes
1962        replaced recursively).  'matchobj' is an re match object
1963        (from a match of includeRE) and 'dirname' is the directory
1964        relative to which the file path should be resolved."""
1965
1966        fname = matchobj.group('filename')
1967        full_fname = os.path.normpath(os.path.join(dirname, fname))
1968        contents = '##newfile "%s"\n%s\n##endfile\n' % \
1969                   (full_fname, self.read_and_flatten(full_fname))
1970        return contents
1971
1972    def read_and_flatten(self, filename):
1973        """Read a file and recursively flatten nested '##include' files."""
1974
1975        current_dir = os.path.dirname(filename)
1976        try:
1977            contents = open(filename).read()
1978        except IOError:
1979            error('Error including file "%s"' % filename)
1980
1981        self.fileNameStack.push((filename, 0))
1982
1983        # Find any includes and include them
1984        def replace(matchobj):
1985            return self.replace_include(matchobj, current_dir)
1986        contents = self.includeRE.sub(replace, contents)
1987
1988        self.fileNameStack.pop()
1989        return contents
1990
1991    def _parse_isa_desc(self, isa_desc_file):
1992        '''Read in and parse the ISA description.'''
1993
1994        # Read file and (recursively) all included files into a string.
1995        # PLY requires that the input be in a single string so we have to
1996        # do this up front.
1997        isa_desc = self.read_and_flatten(isa_desc_file)
1998
1999        # Initialize filename stack with outer file.
2000        self.fileNameStack.push((isa_desc_file, 0))
2001
2002        # Parse it.
2003        (isa_name, namespace, global_code, namespace_code) = \
2004                   self.parse(isa_desc)
2005
2006        # grab the last three path components of isa_desc_file to put in
2007        # the output
2008        filename = '/'.join(isa_desc_file.split('/')[-3:])
2009
2010        # generate decoder.hh
2011        includes = '#include "base/bitfield.hh" // for bitfield support'
2012        global_output = global_code.header_output
2013        namespace_output = namespace_code.header_output
2014        decode_function = ''
2015        self.update_if_needed('decoder.hh', file_template % vars())
2016
2017        # generate decoder.cc
2018        includes = '#include "decoder.hh"'
2019        global_output = global_code.decoder_output
2020        namespace_output = namespace_code.decoder_output
2021        # namespace_output += namespace_code.decode_block
2022        decode_function = namespace_code.decode_block
2023        self.update_if_needed('decoder.cc', file_template % vars())
2024
2025        # generate per-cpu exec files
2026        for cpu in self.cpuModels:
2027            includes = '#include "decoder.hh"\n'
2028            includes += cpu.includes
2029            global_output = global_code.exec_output[cpu.name]
2030            namespace_output = namespace_code.exec_output[cpu.name]
2031            decode_function = ''
2032            self.update_if_needed(cpu.filename, file_template % vars())
2033
2034        # The variable names here are hacky, but this will creat local
2035        # variables which will be referenced in vars() which have the
2036        # value of the globals.
2037        MaxInstSrcRegs = self.maxInstSrcRegs
2038        MaxInstDestRegs = self.maxInstDestRegs
2039        # max_inst_regs.hh
2040        self.update_if_needed('max_inst_regs.hh',
2041                              max_inst_regs_template % vars())
2042
2043    def parse_isa_desc(self, *args, **kwargs):
2044        try:
2045            self._parse_isa_desc(*args, **kwargs)
2046        except ISAParserError, e:
2047            e.exit(self.fileNameStack)
2048
2049# Called as script: get args from command line.
2050# Args are: <path to cpu_models.py> <isa desc file> <output dir> <cpu models>
2051if __name__ == '__main__':
2052    execfile(sys.argv[1])  # read in CpuModel definitions
2053    cpu_models = [CpuModel.dict[cpu] for cpu in sys.argv[4:]]
2054    ISAParser(sys.argv[3], cpu_models).parse_isa_desc(sys.argv[2])
2055