src/mem/slicc/ast/FuncCallExprAST.py

   1 # Copyright (c) 1999-2008 Mark D. Hill and David A. Wood
   2 # Copyright (c) 2009 The Hewlett-Packard Development Company
   3 # Copyright (c) 2013 Advanced Micro Devices, Inc.
   4 # All rights reserved.
   5 #
   6 # Redistribution and use in source and binary forms, with or without
   7 # modification, are permitted provided that the following conditions are
   8 # met: redistributions of source code must retain the above copyright
   9 # notice, this list of conditions and the following disclaimer;
  10 # redistributions in binary form must reproduce the above copyright
  11 # notice, this list of conditions and the following disclaimer in the
  12 # documentation and/or other materials provided with the distribution;
  13 # neither the name of the copyright holders nor the names of its
  14 # contributors may be used to endorse or promote products derived from
  15 # this software without specific prior written permission.
  16 #
  17 # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  18 # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  19 # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  20 # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  21 # OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  22 # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  23 # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  24 # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  25 # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  26 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  27 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  28
  29 from slicc.ast.ExprAST import ExprAST
  30 from slicc.symbols import Func, Type
  31
  32 class FuncCallExprAST(ExprAST):
  33     def __init__(self, slicc, proc_name, exprs):
  34         super(FuncCallExprAST, self).__init__(slicc)
  35         self.proc_name = proc_name
  36         self.exprs = exprs
  37
  38     def __repr__(self):
  39         return "[FuncCallExpr: %s %s]" % (self.proc_name, self.exprs)
  40
  41     def generate(self, code):
  42         machine = self.state_machine
  43
  44         if self.proc_name == "DPRINTF":
  45             # Code for inserting the location of the DPRINTF()
  46             # statement in the .sm file in the statement it self.
  47             # 'self.exprs[0].location' represents the location.
  48             # 'format' represents the second argument of the
  49             # original DPRINTF() call. It is left unmodified.
  50             # str_list is used for concatenating the argument
  51             # list following the format specifier. A DPRINTF()
  52             # call may or may not contain any arguments following
  53             # the format specifier. These two cases need to be
  54             # handled differently. Hence the check whether or not
  55             # the str_list is empty.
  56
  57             dflag = "%s" % (self.exprs[0].name)
  58             machine.addDebugFlag(dflag)
  59             format = "%s" % (self.exprs[1].inline())
  60             format_length = len(format)
  61             str_list = []
  62
  63             for i in range(2, len(self.exprs)):
  64                 str_list.append("%s" % self.exprs[i].inline())
  65
  66             if len(str_list) == 0:
  67                 code('DPRINTF($0, "$1: $2")',
  68                      dflag, self.exprs[0].location, format[2:format_length-2])
  69             else:
  70                 code('DPRINTF($0, "$1: $2", $3)',
  71                      dflag,
  72                      self.exprs[0].location, format[2:format_length-2],
  73                      ', '.join(str_list))
  74
  75             return self.symtab.find("void", Type)
  76
  77         # hack for adding comments to profileTransition
  78         if self.proc_name == "APPEND_TRANSITION_COMMENT":
  79             # FIXME - check for number of parameters
  80             code("APPEND_TRANSITION_COMMENT($0)", self.exprs[0].inline())
  81             return self.symtab.find("void", Type)
  82
  83         func_name_args = self.proc_name
  84
  85         for expr in self.exprs:
  86             actual_type,param_code = expr.inline(True)
  87             func_name_args += "_" + str(actual_type.ident)
  88
  89         # Look up the function in the symbol table
  90         func = self.symtab.find(func_name_args, Func)
  91
  92         # Check the types and get the code for the parameters
  93         if func is None:
  94             self.error("Unrecognized function name: '%s'", func_name_args)
  95
  96         cvec, type_vec = func.checkArguments(self.exprs)
  97
  98         # OK, the semantics of "trigger" here is that, ports in the
  99         # machine have different priorities. We always check the first
 100         # port for doable transitions. If nothing/stalled, we pick one
 101         # from the next port.
 102         #
 103         # One thing we have to be careful as the SLICC protocol
 104         # writter is : If a port have two or more transitions can be
 105         # picked from in one cycle, they must be independent.
 106         # Otherwise, if transition A and B mean to be executed in
 107         # sequential, and A get stalled, transition B can be issued
 108         # erroneously. In practice, in most case, there is only one
 109         # transition should be executed in one cycle for a given
 110         # port. So as most of current protocols.
 111
 112         if self.proc_name == "trigger":
 113             code('''
 114 {
 115 ''')
 116             if machine.TBEType != None and machine.EntryType != None:
 117                 code('''
 118     TransitionResult result = doTransition(${{cvec[0]}}, ${{cvec[2]}}, ${{cvec[3]}}, ${{cvec[1]}});
 119 ''')
 120             elif machine.TBEType != None:
 121                 code('''
 122     TransitionResult result = doTransition(${{cvec[0]}}, ${{cvec[2]}}, ${{cvec[1]}});
 123 ''')
 124             elif machine.EntryType != None:
 125                 code('''
 126     TransitionResult result = doTransition(${{cvec[0]}}, ${{cvec[2]}}, ${{cvec[1]}});
 127 ''')
 128             else:
 129                 code('''
 130     TransitionResult result = doTransition(${{cvec[0]}}, ${{cvec[1]}});
 131 ''')
 132
 133             code('''
 134     if (result == TransitionResult_Valid) {
 135         counter++;
 136         continue; // Check the first port again
 137     }
 138
 139     if (result == TransitionResult_ResourceStall ||
 140         result == TransitionResult_ProtocolStall) {
 141         scheduleEvent(Cycles(1));
 142
 143         // Cannot do anything with this transition, go check next doable transition (mostly likely of next port)
 144     }
 145 }
 146 ''')
 147         elif self.proc_name == "error":
 148             code("$0", self.exprs[0].embedError(cvec[0]))
 149         elif self.proc_name == "assert":
 150             error = self.exprs[0].embedError('"assert failure"')
 151             code('''
 152 #ifndef NDEBUG
 153 if (!(${{cvec[0]}})) {
 154     $error
 155 }
 156 #endif
 157 ''')
 158
 159         elif self.proc_name == "set_cache_entry":
 160             code("set_cache_entry(m_cache_entry_ptr, %s);" %(cvec[0]));
 161         elif self.proc_name == "unset_cache_entry":
 162             code("unset_cache_entry(m_cache_entry_ptr);");
 163         elif self.proc_name == "set_tbe":
 164             code("set_tbe(m_tbe_ptr, %s);" %(cvec[0]));
 165         elif self.proc_name == "unset_tbe":
 166             code("unset_tbe(m_tbe_ptr);");
 167         elif self.proc_name == "stallPort":
 168             code("scheduleEvent(Cycles(1));")
 169
 170         else:
 171             # Normal function
 172             if "external" not in func and not func.isInternalMachineFunc:
 173                 self.error("Invalid function")
 174
 175             params = ""
 176             first_param = True
 177
 178             for (param_code, type) in zip(cvec, type_vec):
 179                 if first_param:
 180                     params = str(param_code)
 181                     first_param  = False
 182                 else:
 183                     params += ', '
 184                     params += str(param_code);
 185
 186             fix = code.nofix()
 187             code('(${{func.c_name}}($params))')
 188             code.fix(fix)
 189
 190         return func.return_type