// We want to check whether a uniform/varying is statically used // because we only count the used ones in packing computing. // Also, gl_FragCoord, gl_PointCoord, and gl_FrontFacing count // toward varying counting if they are statically used in a fragment // shader. void CollectVariables::visitSymbol(TIntermSymbol* symbol) { ASSERT(symbol != NULL); TVariableInfo* var = NULL; switch (symbol->getQualifier()) { case EvqVaryingOut: case EvqInvariantVaryingOut: case EvqVaryingIn: case EvqInvariantVaryingIn: var = findVariable(symbol->getType(), symbol->getSymbol(), mVaryings); break; case EvqUniform: var = findVariable(symbol->getType(), symbol->getSymbol(), mUniforms); break; case EvqFragCoord: if (!mFragCoordAdded) { TVariableInfo info; info.name = "gl_FragCoord"; info.mappedName = "gl_FragCoord"; info.type = SH_FLOAT_VEC4; info.size = 1; info.precision = EbpMedium; // Use mediump as it doesn't really matter. info.staticUse = true; mVaryings.push_back(info); mFragCoordAdded = true; } return; case EvqFrontFacing: if (!mFrontFacingAdded) { TVariableInfo info; info.name = "gl_FrontFacing"; info.mappedName = "gl_FrontFacing"; info.type = SH_BOOL; info.size = 1; info.precision = EbpUndefined; info.staticUse = true; mVaryings.push_back(info); mFrontFacingAdded = true; } return; case EvqPointCoord: if (!mPointCoordAdded) { TVariableInfo info; info.name = "gl_PointCoord"; info.mappedName = "gl_PointCoord"; info.type = SH_FLOAT_VEC2; info.size = 1; info.precision = EbpMedium; // Use mediump as it doesn't really matter. info.staticUse = true; mVaryings.push_back(info); mPointCoordAdded = true; } return; default: break; } if (var) var->staticUse = true; }
// // findVariable // scp - a BPatch_point that defines the scope of the current search // name - name of the variable to find. // BPatch_variableExpr *BPatch_image::findVariableInScope(BPatch_point &scp, const char *name) { // Get the function to search for it's local variables. // XXX - should really use more detailed scoping info here - jkh 6/30/99 BPatch_function *func = const_cast<BPatch_function *> (scp.getFunction()); if (!func) { pdstring msg = pdstring("point passed to findVariable lacks a function\n address point type passed?"); showErrorCallback(100, msg); return NULL; } BPatch_localVar *lv = func->findLocalVar(name); if (!lv) { // look for it in the parameter scope now lv = func->findLocalParam(name); } if (lv) { // create a local expr with the correct frame offset or absolute // address if that is what is needed return new BPatch_variableExpr(proc, (void *) lv->getFrameOffset(), lv->getRegister(), lv->getType(), lv->getStorageClass(), &scp); } // finally check the global scope. // return findVariable(name); /* If we have something else to try, don't report errors on this failure. */ bool reportErrors = true; char mangledName[100]; func->getName( mangledName, 100 ); char * lastScoping = NULL; if( strrchr( mangledName, ':' ) != NULL ) { reportErrors = false; } BPatch_variableExpr * gsVar = findVariable( name, reportErrors ); if( gsVar == NULL ) { /* Try finding it with the function's scope prefixed. */ if( (lastScoping = strrchr( mangledName, ':' )) != NULL ) { * (lastScoping + sizeof(char)) = '\0'; char scopedName[200]; memmove( scopedName, mangledName, strlen( mangledName ) ); memmove( scopedName + strlen( mangledName ), name, strlen( name ) ); scopedName[ strlen( mangledName ) + strlen( name ) ] = '\0'; bperr( "Searching for scoped name '%s'\n", scopedName ); gsVar = findVariable( scopedName ); } } return gsVar; }
bool Sheeve::find( const bool recursive, const std::string &name, bool &isVariable, bool &isProcedure, Declaration::shared_ptr &decl) { isVariable = false; isProcedure = false; DeclaredVariable::shared_ptr varDecl; if(findVariable(recursive, name, varDecl)) { decl = boost::dynamic_pointer_cast<Declaration>(varDecl); isVariable = true; return true; } DeclaredProcedure::shared_ptr procDecl; if (findProcedure(recursive, name, procDecl)) { decl = boost::dynamic_pointer_cast<Declaration>(procDecl); isProcedure = true; return true; } return false; }
int dimeHeaderSection::setVariable(const char * const variableName, const int * const groupcodes, const dimeParam * const params, const int numparams, dimeMemHandler * const memhandler) { int i = findVariable(variableName); if (i < 0) { i = this->records.count(); dimeStringRecord *sr = (dimeStringRecord*)dimeRecord::createRecord(9, memhandler); if (!sr) return false; sr->setString(variableName, memhandler); this->records.append(sr); for (int j = 0; j < numparams; j++) { this->records.append(dimeRecord::createRecord(groupcodes[j], memhandler)); } } i++; int cnt = 0; for (int j = 0; j < numparams; j++) { int k = i; int n = this->records.count(); while (k < n && this->records[k]->getGroupCode() != groupcodes[j] && this->records[k]->getGroupCode() != 9) { k++; } if (k < n && this->records[k]->getGroupCode() == groupcodes[j]) { cnt++; this->records[k]->setValue(params[j]); } } return cnt; }
test_results_t test1_8_Mutator::executeTest() { // Find the entry point to the procedure "test1_8_func1" const char *funcName = "test1_8_func1"; BPatch_Vector<BPatch_function *> found_funcs; if ((NULL == appImage->findFunction(funcName, found_funcs)) || !found_funcs.size()) { logerror(" Unable to find function %s\n", funcName); return FAILED; } if (1 < found_funcs.size()) { logerror("%s[%d]: WARNING : found %d functions named %s. Using the first.\n", __FILE__, __LINE__, found_funcs.size(), funcName); } BPatch_Vector<BPatch_point *> *point8_1 = found_funcs[0]->findPoint(BPatch_entry); if (!point8_1 || ((*point8_1).size() == 0)) { logerror("Unable to find entry point to \"%s\".\n", funcName); return FAILED; } BPatch_Vector<BPatch_snippet*> vect8_1; const char *globalVar = "test1_8_globalVariable1"; BPatch_variableExpr *expr8_1 = findVariable(appImage, globalVar, point8_1); if (!expr8_1) { logerror("**Failed** test #3 (passing variables)\n"); logerror(" Unable to locate variable %s\n", globalVar); return FAILED; } BPatch_arithExpr arith8_1 (BPatch_assign, *expr8_1, BPatch_arithExpr(BPatch_plus, BPatch_arithExpr(BPatch_plus, BPatch_arithExpr(BPatch_plus, BPatch_constExpr(81), BPatch_constExpr(82)), BPatch_arithExpr(BPatch_plus, BPatch_constExpr(83), BPatch_constExpr(84))), BPatch_arithExpr(BPatch_plus, BPatch_arithExpr(BPatch_plus, BPatch_constExpr(85), BPatch_constExpr(86)), BPatch_arithExpr(BPatch_plus, BPatch_constExpr(87), BPatch_constExpr(88))))); vect8_1.push_back(&arith8_1); checkCost(BPatch_sequence(vect8_1)); if(!appAddrSpace->insertSnippet( BPatch_sequence(vect8_1), *point8_1)) return FAILED; return PASSED; }
bool Module::addVariable(const Variable &value) { if (findVariable(value.name)) { return false; } variablesByName_.insert(fullNameKey(value.name), variables_.size()); variables_.push_back(value); return true; }
inline RexxVariable *find(RexxString *name, size_t index) { RexxVariable *variable = get(index); if (variable == OREF_NULL) { variable = findVariable(name, index); } return variable; }
static int doesVariableExist(char* name) { struct scope_info * scopeNode=scope; while (scopeNode != NULL) { unsigned short id=findVariable(scopeNode->variables, name); if (id >= 1) return 1; scopeNode=scopeNode->next; } return 0; }
void XmlConfig::resolveVariables(std::string &val) const { std::smatch res; while (std::regex_search(val, res, regex_)) { if (2 == res.size()) { std::string key(res[1].first, res[1].second); val.replace(res.position(static_cast<std::smatch::size_type>(0)), res.length(0), findVariable(key)); } } }
bool Sheeve::findVariable( const bool recursive, const std::string &varName, DeclaredVariable::shared_ptr &varDecl) { return findVariable( recursive, intrusive_ptr(this), varName, varDecl); }
//--------------------------------------------------------------------------------- AST::INode* SymbolTable::getVariable( const String& name ) const { SymbolTable::VariableMap::const_iterator it = findVariable(name); if ( it != mVariables.end() ) { return it->second; } //variable not found return 0; }
// Set new variable at last position of variables array void CobolWriter::setVariables(int newLevelNumber, string newVariableName, string newDataType, int newNoPics, string newVariableValue) { int position = findVariable(newVariableName); noVariables++; variables[position].variableName = newVariableName; variables[position].variableValue = newVariableValue; variables[position].whatDataType = newDataType; variables[position].noPics = newNoPics; variables[position].levelNumber = newLevelNumber; }
//--------------------------------------------------------------------------------- void SymbolTable::setVariable( const String& name, AST::INode* value ) { VariableMap::iterator iter = findVariable(name); if (iter == mVariables.end()) { mVariables[ name ] = value; } else { mVariables[iter->first] = value; } }
//--------------------------------------------------------------------------------- AST::INode* SymbolTable::removeVariable( const String& name ) { SymbolTable::VariableMap::iterator it = findVariable(name); if ( it != mVariables.end() ) { AST::INode* node = ( *it ).second; mVariables.erase( it ); return node; } //variable not found return 0; }
/** * Retrieves the ID of a variable from the symbol table, with a flag whether we are to allow adding the variable in * if it can not be found */ static unsigned short getVariableId(char * name, int allowAdd) { struct scope_info * scopeNode=scope; while (scopeNode != NULL) { unsigned short id=findVariable(scopeNode->variables, name); if (id >= 1) return id; scopeNode=scopeNode->next; } if (allowAdd) { return addVariable(name); } else { fprintf(stderr, "Can not find variable name %s at line %d, you must declare this before use\n", name, line_num); exit(0); } }
void XmlConfig::XmlConfigData::resolveVariables(std::string &val) const { size_t pos_begin = std::string::npos; while(true) { pos_begin = val.rfind("${", pos_begin); if (pos_begin == std::string::npos) { return; } size_t pos_end = val.find('}', pos_begin); std::string name = val.substr(pos_begin + 2, pos_end - pos_begin - 2); if (checkVariableName(name)) { val.replace(pos_begin, pos_end - pos_begin + 1, findVariable(name)); } else { throw std::runtime_error("incorrect variable name format: " + name); } } }
static int genVRelTest(BPatch_image *appImage, BPatch_Vector<BPatch_snippet*> &vect7_1, BPatch_relOp op, BPatch_variableExpr *r1, BPatch_variableExpr *r2, const char *var1) { const char *funcName = "test1_7_func2"; BPatch_Vector<BPatch_function *> found_funcs; if ((NULL == appImage->findFunction(funcName, found_funcs)) || !found_funcs.size()) { logerror(" Unable to find function %s\n", funcName); return -1; } if (1 < found_funcs.size()) { logerror("%s[%d]: WARNING : found %d functions named %s. Using the first.\n", __FILE__, __LINE__, found_funcs.size(), funcName); } BPatch_Vector<BPatch_point *> *point7_1 = found_funcs[0]->findPoint(BPatch_entry); if (!point7_1 || ((*point7_1).size() == 0)) { logerror("Unable to find entry point to \"%s\".\n", funcName); return -1; } BPatch_variableExpr *expr1_1 = findVariable(appImage, var1, point7_1); if (!expr1_1) { logerror("**Failed** test #7 (relational operators)\n"); logerror(" Unable to locate variable %s\n", var1); return -1; } BPatch_ifExpr *tempExpr1 = new BPatch_ifExpr( BPatch_boolExpr(op, *r1, *r2), BPatch_arithExpr(BPatch_assign, *expr1_1, BPatch_constExpr(74))); vect7_1.push_back(tempExpr1); return 0; }
static Value *idExprInterp(Node *node, void *parser) { #ifndef NDEBUG assert(node->type == NT_ID_EXPR); #endif IdExpr *e = (IdExpr *)node; #ifdef LOG_INTERP logInterpPrefix(parser); rawlog("idExprInterp %s\n", e->val.data); #endif ValueFn fn; /* 搜索内置的变量 */ fn = findVariable(e->val.data); if (fn) return fn(parser, 0, 0, 0); /* 搜索公式定义中的变量 */ return parserFindVariable((Parser *)parser, e->val.data); }
int CellMLModelDefinition::getInitialValueByIndex(const int type,const int index,double* value) { int code = -1; iface::cellml_api::Model* model = static_cast<iface::cellml_api::Model*>(mModel); if (!model) { std::cerr << "CellMLModelDefinition::getInitialValueByIndex -- missing model?" << std::endl; return -2; } RETURN_INTO_OBJREF(var,iface::cellml_api::CellMLVariable,findVariable(model,mAnnotations,type,index)); if (!var) { std::cerr << "CellMLModelDefinition::getInitialValueByIndex -- unable to find variable: " << index << "; of type: " << type << std::endl; return -3; } RETURN_INTO_WSTRING(iv,var->initialValue()); if (iv != L"") { wchar_t* end; double v = wcstod(iv.c_str(),&end); if (end == NULL || *end != 0) { std::wcerr << "CellMLModelDefinition::getInitialValueByIndex -- variable: " << index << "; of type:" << type << "; has non-numeric initial value: " << iv.c_str() << std::endl; code = -5; } else { *value = v; code = 0; } } else { std::cerr << "CellMLModelDefinition::getInitialValueByIndex -- variable: " << index << "; of type:" << type << "; has no initial value." << std::endl; code = -4; } return code; }
void MSinitClientPrg(Client cntxt, str mod, str nme) { InstrPtr p; MalBlkPtr mb; if (cntxt->curprg && idcmp(nme, cntxt->curprg->name) == 0) { MSresetClientPrg(cntxt); return; } cntxt->curprg = newFunction(putName("user", 4), putName(nme, strlen(nme)), FUNCTIONsymbol); mb = cntxt->curprg->def; p = getSignature(cntxt->curprg); if (mod) setModuleId(p, mod); else setModuleScope(p, cntxt->nspace); setVarType(mb, findVariable(mb, nme), TYPE_void); insertSymbol(cntxt->nspace, cntxt->curprg); cntxt->glb = 0; assert(cntxt->curprg->def != NULL); }
bool Sheeve::findVariable( const bool recursive, const Sheeve::intrusive_ptr &sheeve, const std::string &varName, DeclaredVariable::shared_ptr &varDecl) { DeclaredVariable::SheeveData::const_iterator it = sheeve->variables().find(varName); if (it != sheeve->variables().end()) { varDecl = it->second; return true; } if(recursive) { Sheeve::intrusive_ptr p = sheeve->prev(); if (p) { return findVariable(recursive, p, varName, varDecl); } } return false; }
test_results_t test1_5_Mutator::executeTest() { // Find the entry point to the procedure "func5_2" const char *funcName = "test1_5_func2"; BPatch_Vector<BPatch_function *> found_funcs; if ((NULL == appImage->findFunction(funcName, found_funcs)) || !found_funcs.size()) { logerror(" Unable to find function %s\n", funcName); return FAILED; } if (1 < found_funcs.size()) { logerror("%s[%d]: WARNING : found %d functions named %s. Using the first.\n", __FILE__, __LINE__, found_funcs.size(), funcName); } BPatch_Vector<BPatch_point *> *point5_1 = found_funcs[0]->findPoint(BPatch_entry); if (!point5_1 || ((*point5_1).size() == 0)) { logerror("Unable to find entry point to \"%s\".\n", funcName); return FAILED; } const char *funcName2 = "test1_5_func1"; BPatch_Vector<BPatch_function *> found_funcs2; if ((NULL == appImage->findFunction(funcName2, found_funcs2)) || !found_funcs2.size()) { logerror(" Unable to find function %s\n", funcName2); return FAILED; } if (1 < found_funcs2.size()) { logerror("%s[%d]: WARNING : found %d functions named %s. Using the first.\n", __FILE__, __LINE__, found_funcs2.size(), funcName2); } BPatch_Vector<BPatch_point *> *point5_2 = found_funcs2[0]->findPoint(BPatch_subroutine); if (!point5_2 || ((*point5_2).size() == 0)) { logerror("Unable to find subroutine call points in \"%s\".\n", funcName2); return FAILED; } const char *globalVar1 = "test1_5_globalVariable5_1"; const char *globalVar2 = "test1_5_globalVariable5_2"; BPatch_variableExpr *expr5_1 = findVariable (appImage, globalVar1, point5_1); BPatch_variableExpr *expr5_2 = findVariable (appImage, globalVar2, point5_1); if (!expr5_1 || !expr5_2) { logerror("**Failed** test #5 (1f w.o. else)\n"); logerror(" Unable to locate variable %s or ", globalVar1); logerror(" variable %s\n", globalVar2); return FAILED; } BPatch_Vector<BPatch_snippet*> vect5_1; // if (0 == 1) globalVariable5_1 = 52; BPatch_ifExpr expr5_3(BPatch_boolExpr(BPatch_eq, BPatch_constExpr(0), BPatch_constExpr(1)), BPatch_arithExpr(BPatch_assign, *expr5_1, BPatch_constExpr(52))); // if (1 == 1) globalVariable5_2 = 53; BPatch_ifExpr expr5_4(BPatch_boolExpr(BPatch_eq, BPatch_constExpr(1), BPatch_constExpr(1)), BPatch_arithExpr(BPatch_assign, *expr5_2, BPatch_constExpr(53))); vect5_1.push_back(&expr5_3); vect5_1.push_back(&expr5_4); BPatch_sequence expr5_5(vect5_1); checkCost(expr5_5); appAddrSpace->insertSnippet(expr5_5, *point5_1); return PASSED; }
test_results_t test1_7_Mutator::executeTest() { // Find the entry point to the procedure "func7_2" const char *funcName = "test1_7_func2"; BPatch_Vector<BPatch_function *> found_funcs; if ((NULL == appImage->findFunction(funcName, found_funcs)) || !found_funcs.size()) { logerror(" Unable to find function %s\n", funcName); return FAILED; } if (1 < found_funcs.size()) { logerror("%s[%d]: WARNING : found %d functions named %s. Using the first.\n", __FILE__, __LINE__, found_funcs.size(), funcName); } BPatch_Vector<BPatch_point *> *point7_1 = found_funcs[0]->findPoint(BPatch_entry); if (!point7_1 || ((*point7_1).size() == 0)) { logerror("Unable to find entry point to \"%s\".\n", funcName); return FAILED; } BPatch_Vector<BPatch_snippet*> vect7_1; if ( genRelTest(appImage, vect7_1, BPatch_lt, 0, 1, "test1_7_globalVariable1") < 0) return FAILED; if ( genRelTest(appImage, vect7_1, BPatch_lt, 1, 0, "test1_7_globalVariable2") < 0 ) return FAILED; if ( genRelTest(appImage, vect7_1, BPatch_eq, 2, 2, "test1_7_globalVariable3") < 0 ) return FAILED; if ( genRelTest(appImage, vect7_1, BPatch_eq, 2, 3, "test1_7_globalVariable4") < 0 ) return FAILED; if ( genRelTest(appImage, vect7_1, BPatch_gt, 4, 3, "test1_7_globalVariable5") < 0 ) return FAILED; if ( genRelTest(appImage, vect7_1, BPatch_gt, 3, 4, "test1_7_globalVariable6") < 0 ) return FAILED; if ( genRelTest(appImage, vect7_1, BPatch_le, 3, 4, "test1_7_globalVariable7") < 0 ) return FAILED; if ( genRelTest(appImage, vect7_1, BPatch_le, 4, 3, "test1_7_globalVariable8") < 0 ) return FAILED; if ( genRelTest(appImage, vect7_1, BPatch_ne, 5, 6, "test1_7_globalVariable9") < 0 ) return FAILED; if ( genRelTest(appImage, vect7_1, BPatch_ne, 5, 5, "test1_7_globalVariable10") < 0 ) return FAILED; if ( genRelTest(appImage, vect7_1, BPatch_ge, 9, 7, "test1_7_globalVariable11") < 0 ) return FAILED; if ( genRelTest(appImage, vect7_1, BPatch_ge, 7, 9, "test1_7_globalVariable12") < 0 ) return FAILED; if ( genRelTest(appImage, vect7_1, BPatch_and, 1, 1, "test1_7_globalVariable13") < 0 ) return FAILED; if ( genRelTest(appImage, vect7_1, BPatch_and, 1, 0, "test1_7_globalVariable14") < 0 ) return FAILED; if ( genRelTest(appImage, vect7_1, BPatch_or, 1, 0, "test1_7_globalVariable15") < 0 ) return FAILED; if ( genRelTest(appImage, vect7_1, BPatch_or, 0, 0, "test1_7_globalVariable16") < 0 ) return FAILED; const char *funcName2 = "test1_7_func2"; BPatch_Vector<BPatch_function *> found_funcs2; if ((NULL == appImage->findFunction(funcName2, found_funcs2)) || !found_funcs2.size()) { logerror(" Unable to find function %s\n", funcName2); return FAILED; } if (1 < found_funcs2.size()) { logerror("%s[%d]: WARNING : found %d functions named %s. Using the first.\n", __FILE__, __LINE__, found_funcs2.size(), funcName2); } BPatch_Vector<BPatch_point *> *func7_1 = found_funcs2[0]->findPoint(BPatch_entry); if (!func7_1 || ((*func7_1).size() == 0)) { logerror("Unable to find entry points in \"%s\".\n", funcName2); return FAILED; } BPatch_variableExpr *constVar0, *constVar1, *constVar2, *constVar3, *constVar4, *constVar5, *constVar6, *constVar7, *constVar9; constVar0 = findVariable(appImage, "test1_7_constVar0", func7_1); constVar1 = findVariable(appImage, "test1_7_constVar1", func7_1); constVar2 = findVariable(appImage, "test1_7_constVar2", func7_1); constVar3 = findVariable(appImage, "test1_7_constVar3", func7_1); constVar4 = findVariable(appImage, "test1_7_constVar4", func7_1); constVar5 = findVariable(appImage, "test1_7_constVar5", func7_1); constVar6 = findVariable(appImage, "test1_7_constVar6", func7_1); constVar7 = findVariable(appImage, "test1_7_constVar7", func7_1); constVar9 = findVariable(appImage, "test1_7_constVar9", func7_1); if (!constVar0 || !constVar1 || !constVar2 || !constVar3 || !constVar4 || !constVar5 || !constVar6 || !constVar7 || !constVar9 ) { logerror("**Failed** test #7 (relational operators)\n"); logerror(" Unable to locate one of test1_7_constVar?\n"); return FAILED; } if ( genVRelTest(appImage, vect7_1, BPatch_lt, constVar0, constVar1, "test1_7_globalVariable1a") < 0 ) return FAILED; if ( genVRelTest(appImage, vect7_1, BPatch_lt, constVar1, constVar0, "test1_7_globalVariable2a") < 0 ) return FAILED; if ( genVRelTest(appImage, vect7_1, BPatch_eq, constVar2, constVar2, "test1_7_globalVariable3a") < 0 ) return FAILED; if ( genVRelTest(appImage, vect7_1, BPatch_eq, constVar2, constVar3, "test1_7_globalVariable4a") < 0 ) return FAILED; if ( genVRelTest(appImage, vect7_1, BPatch_gt, constVar4, constVar3, "test1_7_globalVariable5a") < 0 ) return FAILED; if ( genVRelTest(appImage, vect7_1, BPatch_gt, constVar3, constVar4, "test1_7_globalVariable6a") < 0 ) return FAILED; if ( genVRelTest(appImage, vect7_1, BPatch_le, constVar3, constVar4, "test1_7_globalVariable7a") < 0 ) return FAILED; if ( genVRelTest(appImage, vect7_1, BPatch_le, constVar4, constVar3, "test1_7_globalVariable8a") < 0 ) return FAILED; if ( genVRelTest(appImage, vect7_1, BPatch_ne, constVar5, constVar6, "test1_7_globalVariable9a") < 0 ) return FAILED; if ( genVRelTest(appImage, vect7_1, BPatch_ne, constVar5, constVar5, "test1_7_globalVariable10a") < 0 ) return FAILED; if ( genVRelTest(appImage, vect7_1, BPatch_ge, constVar9, constVar7, "test1_7_globalVariable11a") < 0 ) return FAILED; if ( genVRelTest(appImage, vect7_1, BPatch_ge, constVar7, constVar9, "test1_7_globalVariable12a") < 0 ) return FAILED; if ( genVRelTest(appImage, vect7_1, BPatch_and, constVar1, constVar1, "test1_7_globalVariable13a") < 0 ) return FAILED; if ( genVRelTest(appImage, vect7_1, BPatch_and, constVar1, constVar0, "test1_7_globalVariable14a") < 0 ) return FAILED; if ( genVRelTest(appImage, vect7_1, BPatch_or, constVar1, constVar0, "test1_7_globalVariable15a") < 0 ) return FAILED; if ( genVRelTest(appImage, vect7_1, BPatch_or, constVar0, constVar0, "test1_7_globalVariable16a") < 0 ) return FAILED; dprintf("relops test vector length is %d\n", vect7_1.size()); checkCost(BPatch_sequence(vect7_1)); if(!appAddrSpace->insertSnippet( BPatch_sequence(vect7_1), *point7_1)) return FAILED; return PASSED; }
LcnSymbol* IpeEnv::findLocal(const char* name) const { return findVariable(name, true); }
LcnSymbol* IpeEnv::findVariable(const char* name) const { return findVariable(name, false); }
test_results_t test1_36_Mutator::executeTest() { const char *funcName = "test1_36_func1"; BPatch_Vector<BPatch_function *> found_funcs; if ((NULL == appImage->findFunction(funcName, found_funcs)) || !found_funcs.size()) { logerror(" Unable to find function %s\n", funcName); return FAILED; } if (1 < found_funcs.size()) { logerror("%s[%d]: WARNING : found %d functions named %s. Using the first.\n", __FILE__, __LINE__, found_funcs.size(), funcName); } BPatch_Vector<BPatch_point *> *all_points36_1 = found_funcs[0]->findPoint(BPatch_subroutine); if (!all_points36_1 || (all_points36_1->size() < 1)) { logerror("Unable to find point %s - subroutines.\n", funcName); return FAILED; } const char *funcName2 = "test1_36_call1"; BPatch_point *point36_1 = NULL; for (unsigned i=0; i<(*all_points36_1).size(); i++) { BPatch_point *cur_point = (*all_points36_1)[i]; if (cur_point == NULL) continue; BPatch_function *func = cur_point->getCalledFunction(); char funcname[100]; if (!func) continue; if (func->getName(funcname, 99)) { if (strstr(funcname, funcName2)) point36_1 = cur_point; } } if (point36_1 == NULL) { logerror("Unable to find callsite %s\n", funcName2); return FAILED; } BPatch_variableExpr *expr36_1 = findVariable(appImage, "test1_36_globalVariable1", all_points36_1); BPatch_variableExpr *expr36_2 = findVariable(appImage, "test1_36_globalVariable2", all_points36_1); BPatch_variableExpr *expr36_3 = findVariable(appImage, "test1_36_globalVariable3", all_points36_1); BPatch_variableExpr *expr36_4 = findVariable(appImage, "test1_36_globalVariable4", all_points36_1); BPatch_variableExpr *expr36_5 = findVariable(appImage, "test1_36_globalVariable5", all_points36_1); BPatch_variableExpr *expr36_6 = findVariable(appImage, "test1_36_globalVariable6", all_points36_1); BPatch_variableExpr *expr36_7 = findVariable(appImage, "test1_36_globalVariable7", all_points36_1); BPatch_variableExpr *expr36_8 = findVariable(appImage, "test1_36_globalVariable8", all_points36_1); BPatch_variableExpr *expr36_9 = findVariable(appImage, "test1_36_globalVariable9", all_points36_1); BPatch_variableExpr *expr36_10 = findVariable(appImage, "test1_36_globalVariable10", all_points36_1); if (expr36_1 == NULL || expr36_2 == NULL || expr36_3 == NULL || expr36_4 == NULL || expr36_5 == NULL || expr36_6 == NULL || expr36_7 == NULL || expr36_8 == NULL || expr36_9 == NULL || expr36_10 == NULL) { logerror("**Failed** test #36 (callsite parameter referencing)\n"); logerror(" Unable to locate at least one of " "test1_36_globalVariable{1...10}\n"); return FAILED; } BPatch_Vector<BPatch_snippet *> snippet_seq; snippet_seq.push_back(makeTest36paramExpr(expr36_1, 0)); snippet_seq.push_back(makeTest36paramExpr(expr36_2, 1)); snippet_seq.push_back(makeTest36paramExpr(expr36_3, 2)); snippet_seq.push_back(makeTest36paramExpr(expr36_4, 3)); snippet_seq.push_back(makeTest36paramExpr(expr36_5, 4)); snippet_seq.push_back(makeTest36paramExpr(expr36_6, 5)); snippet_seq.push_back(makeTest36paramExpr(expr36_7, 6)); snippet_seq.push_back(makeTest36paramExpr(expr36_8, 7)); snippet_seq.push_back(makeTest36paramExpr(expr36_9, 8)); snippet_seq.push_back(makeTest36paramExpr(expr36_10, 9)); BPatch_sequence seqExpr(snippet_seq); checkCost(seqExpr); appAddrSpace->insertSnippet(seqExpr, *point36_1); return PASSED; }
test_results_t test1_25_Mutator::executeTest() { // Used as hack for Fortran to allow assignment of a pointer to an int BPatch::bpatch->setTypeChecking (false); // First verify that we can find a local variable in test1_25_call1 const char *funcName = "test1_25_call1"; BPatch_Vector<BPatch_function *> found_funcs; if ((NULL == appImage->findFunction(funcName, found_funcs)) || !found_funcs.size()) { logerror(" Unable to find function %s\n", funcName); return FAILED; } if (1 < found_funcs.size()) { logerror("%s[%d]: WARNING : found %d functions named %s. Using the first.\n", __FILE__, __LINE__, found_funcs.size(), funcName); } BPatch_Vector<BPatch_point *> *point25_1 = found_funcs[0]->findPoint(BPatch_entry); assert(point25_1); // assert(point25_1 && (point25_1->size() == 1)); BPatch_variableExpr *gvar[8]; for (int i=1; i <= 7; i++) { char name[80]; sprintf (name, "test1_25_globalVariable%d", i); gvar [i] = findVariable (appImage, name, point25_1); if (!gvar[i]) { logerror("**Failed** test #25 (unary operaors)\n"); logerror(" can't find variable %s\n", name); return FAILED; } } // globalVariable25_2 = &globalVariable25_1 #if !defined(rs6000_ibm_aix4_1_test) \ && !defined(i386_unknown_linux2_0_test) \ && !defined(x86_64_unknown_linux2_4_test) /* Blind duplication - Ray */ \ && !defined(ppc64_linux_test) \ && !defined(i386_unknown_nt4_0_test) \ && !defined(os_freebsd_test) // without type info need to inform BPatch_type *type = appImage->findType("void *"); assert(type); gvar[2]->setType(type); #endif BPatch_arithExpr assignment1(BPatch_assign, *gvar[2], BPatch_arithExpr(BPatch_addr, *gvar[1])); appAddrSpace->insertSnippet(assignment1, *point25_1); // globalVariable25_3 = *globalVariable25_2 // Need to make sure this happens after the first one BPatch_arithExpr assignment2(BPatch_assign, *gvar[3], BPatch_arithExpr(BPatch_deref, *gvar[2])); appAddrSpace->insertSnippet(assignment2, *point25_1, BPatch_callBefore, BPatch_lastSnippet); // globalVariable25_5 = -globalVariable25_4 BPatch_arithExpr assignment3(BPatch_assign, *gvar[5], BPatch_arithExpr(BPatch_negate, *gvar[4])); appAddrSpace->insertSnippet(assignment3, *point25_1); // globalVariable25_7 = -globalVariable25_6 BPatch_arithExpr assignment4(BPatch_assign, *gvar[7], BPatch_arithExpr(BPatch_negate, *gvar[6])); appAddrSpace->insertSnippet(assignment4, *point25_1); // Check removed because MIPS is no longer supported // #endif // !MIPS BPatch::bpatch->setTypeChecking (true); return PASSED; }
test_results_t test1_3_Mutator::executeTest() { // Find the entry point to the procedure "func3_1" const char *funcName = "test1_3_func3_1"; BPatch_Vector<BPatch_function *> found_funcs; if ((NULL == appImage->findFunction(funcName, found_funcs)) || !found_funcs.size()) { logerror(" Unable to find function %s\n", funcName); return FAILED; } if (1 < found_funcs.size()) { logerror("%s[%d]: WARNING : found %d functions named %s. Using the first.\n", __FILE__, __LINE__, found_funcs.size(), funcName); } BPatch_Vector<BPatch_point *> *point3_1 = found_funcs[0]->findPoint(BPatch_entry); if (!point3_1 || ((*point3_1).size() == 0)) { logerror("Unable to find entry point to \"%s.\"\n", funcName); return FAILED; } BPatch_Vector<BPatch_function *> bpfv; const char *fn = "test1_3_call3_1"; if (NULL == appImage->findFunction(fn, bpfv) || !bpfv.size() || NULL == bpfv[0]) { logerror(" Unable to find function %s\n", fn); return FAILED; } if (1 < bpfv.size()) { logerror("%s[%d]: WARNING : found %d functions named %s. Using the first.\n", __FILE__, __LINE__, bpfv.size(), fn); } BPatch_function *call3_func = bpfv[0]; BPatch_Vector<BPatch_snippet *> call3_args; BPatch_Vector<BPatch_point *> *call3_1 = call3_func->findPoint(BPatch_subroutine); if (!call3_1 || ((*call3_1).size() == 0)) { logerror(" Unable to find subroutine calls in \"call3_1.\"\n"); return FAILED; } const char *globalVar = "test1_3_globalVariable3_1"; BPatch_variableExpr *expr3_1 = findVariable(appImage, globalVar, call3_1); if (!expr3_1) { logerror("**Failed** test #3 (passing variables)\n"); logerror(" Unable to locate variable %s\n", globalVar); return FAILED; } // see if we can find the address if (expr3_1->getBaseAddr() <= 0) { logerror("*Error*: address %p for %s is not valid\n", expr3_1->getBaseAddr(), globalVar); } BPatch_variableExpr *expr3_2 = appAddrSpace->malloc(*appImage->findType("int")); if (!expr3_2) { logerror("**Failed** test #3 (passing variables)\n"); logerror(" Unable to create new int variable\n"); return FAILED; } BPatch_constExpr expr3_3 (expr3_1->getBaseAddr ()); BPatch_constExpr expr3_4 (expr3_2->getBaseAddr ()); int mutateeFortran = isMutateeFortran(appImage); if (mutateeFortran) { call3_args.push_back (&expr3_3); call3_args.push_back (&expr3_4); } else { call3_args.push_back(expr3_1); call3_args.push_back(expr3_2); } BPatch_funcCallExpr call3Expr(*call3_func, call3_args); checkCost(call3Expr); appAddrSpace->insertSnippet(call3Expr, *point3_1); BPatch_arithExpr expr3_5(BPatch_assign, *expr3_2, BPatch_constExpr(32)); checkCost(expr3_5); appAddrSpace->insertSnippet(expr3_5, *point3_1); dprintf("Inserted snippet3\n"); return PASSED; }