From 9648c05db19292ddd285a80914593cc0631403ff Mon Sep 17 00:00:00 2001 From: Nilay Vaish Date: Fri, 14 Aug 2015 19:28:43 -0500 Subject: [PATCH] ruby: slicc: use default argument value Before this patch, while one could declare / define a function with default argument values, but the actual function call would require one to specify all the arguments. This patch changes the check for function arguments. Now a function call needs to specify arguments that are at least as much as those with default values and at most the total number of arguments taken as input by the function. --- .../structures/AbstractReplacementPolicy.cc | 2 +- .../structures/AbstractReplacementPolicy.hh | 6 ++--- src/mem/ruby/structures/LRUPolicy.cc | 8 +++---- src/mem/ruby/structures/LRUPolicy.hh | 4 ++-- src/mem/ruby/structures/PseudoLRUPolicy.cc | 12 +++++----- src/mem/ruby/structures/PseudoLRUPolicy.hh | 6 ++--- src/mem/slicc/ast/EnumDeclAST.py | 2 +- src/mem/slicc/ast/FormalParamAST.py | 22 +++++++++++++++++-- src/mem/slicc/ast/FuncDeclAST.py | 17 +++++++++----- src/mem/slicc/ast/InPortDeclAST.py | 4 ++-- src/mem/slicc/ast/StateDeclAST.py | 4 ++-- src/mem/slicc/symbols/Func.py | 22 +++++++++++-------- 12 files changed, 69 insertions(+), 40 deletions(-) diff --git a/src/mem/ruby/structures/AbstractReplacementPolicy.cc b/src/mem/ruby/structures/AbstractReplacementPolicy.cc index fbcce6e2d..d802ecd31 100644 --- a/src/mem/ruby/structures/AbstractReplacementPolicy.cc +++ b/src/mem/ruby/structures/AbstractReplacementPolicy.cc @@ -66,7 +66,7 @@ AbstractReplacementPolicy::~AbstractReplacementPolicy() } Tick -AbstractReplacementPolicy::getLastAccess(int64 set, int64 way) +AbstractReplacementPolicy::getLastAccess(int64_t set, int64_t way) { return m_last_ref_ptr[set][way]; } diff --git a/src/mem/ruby/structures/AbstractReplacementPolicy.hh b/src/mem/ruby/structures/AbstractReplacementPolicy.hh index 03ef0d2fd..c118f3c11 100644 --- a/src/mem/ruby/structures/AbstractReplacementPolicy.hh +++ b/src/mem/ruby/structures/AbstractReplacementPolicy.hh @@ -44,13 +44,13 @@ class AbstractReplacementPolicy : public SimObject virtual ~AbstractReplacementPolicy(); /* touch a block. a.k.a. update timestamp */ - virtual void touch(int64 set, int64 way, Tick time) = 0; + virtual void touch(int64_t set, int64_t way, Tick time) = 0; /* returns the way to replace */ - virtual int64 getVictim(int64 set) const = 0; + virtual int64_t getVictim(int64_t set) const = 0; /* get the time of the last access */ - Tick getLastAccess(int64 set, int64 way); + Tick getLastAccess(int64_t set, int64_t way); virtual bool useOccupancy() const { return false; } diff --git a/src/mem/ruby/structures/LRUPolicy.cc b/src/mem/ruby/structures/LRUPolicy.cc index a1e3b277e..286d19772 100644 --- a/src/mem/ruby/structures/LRUPolicy.cc +++ b/src/mem/ruby/structures/LRUPolicy.cc @@ -50,7 +50,7 @@ LRUReplacementPolicyParams::create() void -LRUPolicy::touch(int64 set, int64 index, Tick time) +LRUPolicy::touch(int64_t set, int64_t index, Tick time) { assert(index >= 0 && index < m_assoc); assert(set >= 0 && set < m_num_sets); @@ -58,11 +58,11 @@ LRUPolicy::touch(int64 set, int64 index, Tick time) m_last_ref_ptr[set][index] = time; } -int64 -LRUPolicy::getVictim(int64 set) const +int64_t +LRUPolicy::getVictim(int64_t set) const { Tick time, smallest_time; - int64 smallest_index; + int64_t smallest_index; smallest_index = 0; smallest_time = m_last_ref_ptr[set][0]; diff --git a/src/mem/ruby/structures/LRUPolicy.hh b/src/mem/ruby/structures/LRUPolicy.hh index 9a9c9e3eb..388718319 100644 --- a/src/mem/ruby/structures/LRUPolicy.hh +++ b/src/mem/ruby/structures/LRUPolicy.hh @@ -41,8 +41,8 @@ class LRUPolicy : public AbstractReplacementPolicy LRUPolicy(const Params * p); ~LRUPolicy(); - void touch(int64 set, int64 way, Tick time); - int64 getVictim(int64 set) const; + void touch(int64_t set, int64_t way, Tick time); + int64_t getVictim(int64_t set) const; }; #endif // __MEM_RUBY_STRUCTURES_LRUPOLICY_HH__ diff --git a/src/mem/ruby/structures/PseudoLRUPolicy.cc b/src/mem/ruby/structures/PseudoLRUPolicy.cc index 8eee0821b..a2b21a625 100644 --- a/src/mem/ruby/structures/PseudoLRUPolicy.cc +++ b/src/mem/ruby/structures/PseudoLRUPolicy.cc @@ -38,7 +38,7 @@ PseudoLRUPolicy::PseudoLRUPolicy(const Params * p) // associativity cannot exceed capacity of tree representation assert(m_num_sets > 0 && m_assoc > 1 && - m_assoc <= (int64) sizeof(uint64)*4); + m_assoc <= (int64_t) sizeof(uint64_t)*4); m_trees = NULL; m_num_levels = 0; @@ -55,7 +55,7 @@ PseudoLRUPolicy::PseudoLRUPolicy(const Params * p) m_num_levels++; } assert(m_num_levels < sizeof(unsigned int)*4); - m_trees = new uint64[m_num_sets]; + m_trees = new uint64_t[m_num_sets]; for (unsigned i = 0; i < m_num_sets; i++) { m_trees[i] = 0; } @@ -75,7 +75,7 @@ PseudoLRUPolicy::~PseudoLRUPolicy() } void -PseudoLRUPolicy::touch(int64 set, int64 index, Tick time) +PseudoLRUPolicy::touch(int64_t set, int64_t index, Tick time) { assert(index >= 0 && index < m_assoc); assert(set >= 0 && set < m_num_sets); @@ -93,10 +93,10 @@ PseudoLRUPolicy::touch(int64 set, int64 index, Tick time) m_last_ref_ptr[set][index] = time; } -int64 -PseudoLRUPolicy::getVictim(int64 set) const +int64_t +PseudoLRUPolicy::getVictim(int64_t set) const { - int64 index = 0; + int64_t index = 0; int tree_index = 0; int node_val; diff --git a/src/mem/ruby/structures/PseudoLRUPolicy.hh b/src/mem/ruby/structures/PseudoLRUPolicy.hh index fc5add8b1..a4a388cf5 100644 --- a/src/mem/ruby/structures/PseudoLRUPolicy.hh +++ b/src/mem/ruby/structures/PseudoLRUPolicy.hh @@ -53,13 +53,13 @@ class PseudoLRUPolicy : public AbstractReplacementPolicy PseudoLRUPolicy(const Params * p); ~PseudoLRUPolicy(); - void touch(int64 set, int64 way, Tick time); - int64 getVictim(int64 set) const; + void touch(int64_t set, int64_t way, Tick time); + int64_t getVictim(int64_t set) const; private: unsigned int m_effective_assoc; /** nearest (to ceiling) power of 2 */ unsigned int m_num_levels; /** number of levels in the tree */ - uint64* m_trees; /** bit representation of the + uint64_t *m_trees; /** bit representation of the * trees, one for each set */ }; diff --git a/src/mem/slicc/ast/EnumDeclAST.py b/src/mem/slicc/ast/EnumDeclAST.py index d97c13483..bc0c1c224 100644 --- a/src/mem/slicc/ast/EnumDeclAST.py +++ b/src/mem/slicc/ast/EnumDeclAST.py @@ -67,6 +67,6 @@ class EnumDeclAST(DeclAST): pairs = { "external" : "yes" } func = Func(self.symtab, func_id + "_" + t.c_ident, func_id, self.location, - self.symtab.find("std::string", Type), [ t ], [], "", + self.symtab.find("std::string", Type), [ t ], [], [], "", pairs) self.symtab.newSymbol(func) diff --git a/src/mem/slicc/ast/FormalParamAST.py b/src/mem/slicc/ast/FormalParamAST.py index ce73304f1..ef39b40f0 100644 --- a/src/mem/slicc/ast/FormalParamAST.py +++ b/src/mem/slicc/ast/FormalParamAST.py @@ -46,6 +46,9 @@ class FormalParamAST(AST): def generate(self): type = self.type_ast.type param = "param_%s" % self.ident + proto = "" + body = "" + default = False # Add to symbol table v = Var(self.symtab, self.ident, self.location, type, param, @@ -56,6 +59,21 @@ class FormalParamAST(AST): "interface" in type and ( type["interface"] == "AbstractCacheEntry" or type["interface"] == "AbstractEntry")): - return type, "%s* %s" % (type.c_ident, param) + proto = "%s* %s" % (type.c_ident, param) + body = proto + elif self.default != None: + value = "" + if self.default == True: + value = "true" + elif self.default == False: + value = "false" + else: + value = "%s" % self.default + proto = "const %s& %s = %s" % (type.c_ident, param, value) + body = "const %s& %s" % (type.c_ident, param) + default = True else: - return type, "const %s& %s" % (type.c_ident, param) + proto = "const %s& %s" % (type.c_ident, param) + body = proto + + return type, proto, body, default diff --git a/src/mem/slicc/ast/FuncDeclAST.py b/src/mem/slicc/ast/FuncDeclAST.py index 47ae7076e..4e64c0ba5 100644 --- a/src/mem/slicc/ast/FuncDeclAST.py +++ b/src/mem/slicc/ast/FuncDeclAST.py @@ -45,7 +45,9 @@ class FuncDeclAST(DeclAST): def generate(self, parent = None): types = [] - params = [] + proto_params = [] + body_params = [] + default_count = 0 void_type = self.symtab.find("void", Type) # Generate definition code @@ -58,13 +60,17 @@ class FuncDeclAST(DeclAST): for formal in self.formals: # Lookup parameter types try: - type, ident = formal.generate() + type, proto, body, default = formal.generate() types.append(type) - params.append(ident) + proto_params.append(proto) + body_params.append(body) + if default: + default_count += 1 except AttributeError: types.append(formal.type) - params.append(None) + proto_params.append(None) + body_params.append(None) body = self.slicc.codeFormatter() if self.statements is None: @@ -87,7 +93,8 @@ class FuncDeclAST(DeclAST): machine = self.state_machine func = Func(self.symtab, func_name_args, self.ident, self.location, - return_type, types, params, str(body), self.pairs) + return_type, types, proto_params, + body_params, str(body), self.pairs, default_count) if parent is not None: if not parent.addFunc(func): diff --git a/src/mem/slicc/ast/InPortDeclAST.py b/src/mem/slicc/ast/InPortDeclAST.py index 7a019a0e0..2ef043151 100644 --- a/src/mem/slicc/ast/InPortDeclAST.py +++ b/src/mem/slicc/ast/InPortDeclAST.py @@ -89,13 +89,13 @@ class InPortDeclAST(DeclAST): for param in param_types: trigger_func_name += "_" + param.ident func = Func(self.symtab, trigger_func_name, "trigger", self.location, - void_type, param_types, [], "", pairs) + void_type, param_types, [], [], "", pairs) symtab.newSymbol(func) # Add the stallPort method - this hacks reschedules the controller # for stalled messages that don't trigger events func = Func(self.symtab, "stallPort", "stallPort", self.location, - void_type, [], [], "", pairs) + void_type, [], [], [], "", pairs) symtab.newSymbol(func) param_types = [] diff --git a/src/mem/slicc/ast/StateDeclAST.py b/src/mem/slicc/ast/StateDeclAST.py index f0a0b97d3..a33ea9245 100644 --- a/src/mem/slicc/ast/StateDeclAST.py +++ b/src/mem/slicc/ast/StateDeclAST.py @@ -66,7 +66,7 @@ class StateDeclAST(DeclAST): pairs = { "external" : "yes" } func = Func(self.symtab, func_id + "_" + t.ident, func_id, self.location, - self.symtab.find("std::string", Type), [ t ], [], "", + self.symtab.find("std::string", Type), [ t ], [], [], "", pairs) self.symtab.newSymbol(func) @@ -76,6 +76,6 @@ class StateDeclAST(DeclAST): pairs = { "external" : "yes" } func = Func(self.symtab, func_id + "_" + t.ident, func_id, self.location, - self.symtab.find("AccessPermission", Type), [ t ], [], "", + self.symtab.find("AccessPermission", Type), [ t ], [], [], "", pairs) self.symtab.newSymbol(func) diff --git a/src/mem/slicc/symbols/Func.py b/src/mem/slicc/symbols/Func.py index 6da74002a..695450b9c 100644 --- a/src/mem/slicc/symbols/Func.py +++ b/src/mem/slicc/symbols/Func.py @@ -30,16 +30,19 @@ from slicc.symbols.Type import Type class Func(Symbol): def __init__(self, table, ident, name, location, return_type, param_types, - param_strings, body, pairs): + proto_param_strings, body_param_strings, body, + pairs, default_count = 0): super(Func, self).__init__(table, ident, location, pairs) self.return_type = return_type self.param_types = param_types - self.param_strings = param_strings + self.proto_param_strings = proto_param_strings + self.body_param_strings = body_param_strings self.body = body self.isInternalMachineFunc = False self.c_ident = ident self.c_name = name self.class_name = "" + self.default_count = default_count def __repr__(self): return "" @@ -57,16 +60,17 @@ class Func(Symbol): return_type += "*" return "%s %s(%s);" % (return_type, self.c_name, - ", ".join(self.param_strings)) + ", ".join(self.proto_param_strings)) def writeCodeFiles(self, path, includes): return def checkArguments(self, args): - if len(args) != len(self.param_types): - self.error("Wrong number of arguments passed to function : '%s'" +\ - " Expected %d, got %d", self.c_ident, - len(self.param_types), len(args)) + if len(args) + self.default_count < len(self.param_types) or \ + len(args) > len(self.param_types): + self.error("Wrong number of arguments passed to function: '%s'" + \ + " Expected at least: %d, got: %d", self.c_ident, + len(self.param_types) - self.default_count, len(args)) cvec = [] type_vec = [] @@ -91,14 +95,14 @@ class Func(Symbol): code = self.symtab.codeFormatter() # Generate function header - void_type = self.symtab.find("void", Type) return_type = self.return_type.c_ident + void_type = self.symtab.find("void", Type) if "return_by_ref" in self and self.return_type != void_type: return_type += "&" if "return_by_pointer" in self and self.return_type != void_type: return_type += "*" - params = ', '.join(self.param_strings) + params = ', '.join(self.body_param_strings) code(''' $return_type -- 2.30.2