SizeOffsetType ObjectSizeOffsetVisitor::visitArgument(Argument &A) { // no interprocedural analysis is done at the moment if (!A.hasByValOrInAllocaAttr()) { ++ObjectVisitorArgument; return unknown(); } PointerType *PT = cast<PointerType>(A.getType()); APInt Size(IntTyBits, DL.getTypeAllocSize(PT->getElementType())); return std::make_pair(align(Size, A.getParamAlignment()), Zero); }
void ArgumentParser::addArgument(const Argument& arg) { vargs.push_back(arg); if (arg.getShortArg().size() > 0) { args.insert(pair<string, Argument>(arg.getShortArg(), arg)); } if (arg.getLongArg().size() > 0) { args.insert(pair<string, Argument>(arg.getLongArg(), arg)); } }
/*! the argument list is documented if one of its * arguments is documented */ bool ArgumentList::hasDocumentation() const { bool hasDocs=FALSE; ArgumentListIterator ali(*this); Argument *a; for (ali.toFirst();!hasDocs && (a=ali.current());++ali) { hasDocs = hasDocs || a->hasDocumentation(); } return hasDocs; }
AValue get(string name) { Argument *arg = getArgument(name); for (auto entry : map) { if (arg->is(entry.first)) { return AValue(entry.second); } } return AValue({}); }
Argument* Argument::applySubstitution(){ Argument* args = new Argument(); try { for (Argument::iterator it = begin(); it != end(); it++) args->push_back((*it)->applySubstitution()); return args; } catch (OutOfRange&){ delete args; throw; } }
void GCOVProfiler::insertIndirectCounterIncrement() { Function *Fn = cast<Function>(GCOVProfiler::getIncrementIndirectCounterFunc()); Fn->setUnnamedAddr(true); Fn->setLinkage(GlobalValue::InternalLinkage); Fn->addFnAttr(Attributes::NoInline); if (NoRedZone) Fn->addFnAttr(Attributes::NoRedZone); Type *Int32Ty = Type::getInt32Ty(*Ctx); Type *Int64Ty = Type::getInt64Ty(*Ctx); Constant *NegOne = ConstantInt::get(Int32Ty, 0xffffffff); // Create basic blocks for function. BasicBlock *BB = BasicBlock::Create(*Ctx, "entry", Fn); IRBuilder<> Builder(BB); BasicBlock *PredNotNegOne = BasicBlock::Create(*Ctx, "", Fn); BasicBlock *CounterEnd = BasicBlock::Create(*Ctx, "", Fn); BasicBlock *Exit = BasicBlock::Create(*Ctx, "exit", Fn); // uint32_t pred = *predecessor; // if (pred == 0xffffffff) return; Argument *Arg = Fn->arg_begin(); Arg->setName("predecessor"); Value *Pred = Builder.CreateLoad(Arg, "pred"); Value *Cond = Builder.CreateICmpEQ(Pred, NegOne); BranchInst::Create(Exit, PredNotNegOne, Cond, BB); Builder.SetInsertPoint(PredNotNegOne); // uint64_t *counter = counters[pred]; // if (!counter) return; Value *ZExtPred = Builder.CreateZExt(Pred, Int64Ty); Arg = llvm::next(Fn->arg_begin()); Arg->setName("counters"); Value *GEP = Builder.CreateGEP(Arg, ZExtPred); Value *Counter = Builder.CreateLoad(GEP, "counter"); Cond = Builder.CreateICmpEQ(Counter, Constant::getNullValue(Int64Ty->getPointerTo())); Builder.CreateCondBr(Cond, Exit, CounterEnd); // ++*counter; Builder.SetInsertPoint(CounterEnd); Value *Add = Builder.CreateAdd(Builder.CreateLoad(Counter), ConstantInt::get(Int64Ty, 1)); Builder.CreateStore(Add, Counter); Builder.CreateBr(Exit); // Fill in the exit block. Builder.SetInsertPoint(Exit); Builder.CreateRetVoid(); }
int tesla::ArgIndex(const Argument& A) { switch (A.type()) { case Argument::Any: case Argument::Constant: return -1; case Argument::Variable: case Argument::Field: case Argument::Indirect: return A.index(); } }
CyberXML::Node *MediaPlayer::browse( Device *dev, const char *objectID, const char *browseFlag, const char *filter, int startIndex, int requestedCount, const char *sortCaiteria) { if (dev == NULL) return NULL; Service *conDir = dev->getService(ContentDirectory::SERVICE_TYPE); if (conDir == NULL) return NULL; Action *action = conDir->getAction(ContentDirectory::BROWSE); if (action == NULL) return NULL; BrowseAction browseAction(action); browseAction.setObjectID(objectID); browseAction.setBrowseFlag(browseFlag); browseAction.setStartingIndex(startIndex); browseAction.setRequestedCount(requestedCount); browseAction.setFilter(filter); browseAction.setSortCriteria(sortCaiteria); if (browseAction.postControlAction() == false) return NULL; Argument *resultArg = browseAction.getArgument(BrowseAction::RESULT); if (resultArg == NULL) return NULL; const char *resultStr = resultArg->getValue(); if (resultStr == NULL) return NULL; Node *node = NULL; Parser xmlParser; int resultUniStrLen; UnicodeStr *resultUniStr = XML::Local2Unicode(resultStr, resultUniStrLen); if (resultUniStr != NULL) { node = xmlParser.parse(resultUniStr, resultUniStrLen); delete []resultUniStr; } if (node == NULL) node = xmlParser.parse(resultStr); return node; }
void ArgumentGroup::accept(const Argument & argument) { bool same_option = this->_num_selected > 0 && (this->_num_selected == 1 && this->_last_selected_option == argument.option()); if(this->_mutually_exclusive && (this->_num_selected > 0) && (! same_option)) { throw ArgParserError(DEBUG_INFO, "invalid option " + argument.option().option_string() + ": option " + this->_last_selected_option.option_string() + " already set in mutually exclusive group " + this->_name); } if(! same_option) { this->_last_selected_option = argument.option(); ++this->_num_selected; } }
static uid_t dropped_uid() { uid_t uid = -1; try { uid = boost::lexical_cast<int>(user.get()); } catch (boost::bad_lexical_cast const &) { uid = uid_by_name(user.get()); } return uid; }
inline static bool isSameArrayElement(const Argument<Base>* oldArg, const Argument<Base>& arg) { if (oldArg != nullptr) { if (oldArg->getParameter() != nullptr) { if (arg.getParameter() != nullptr) { return (*arg.getParameter() == *oldArg->getParameter()); } } else { return (arg.getOperation() == oldArg->getOperation()); } } return false; }
std::string to_string(const Argument<hns::Namespace>& ns) { std::ostringstream os; os << ns->getName() << " [" << ns->getID().short_string() << "] NS["; for(hns::Namespace::IDListType::const_iterator it = ns->accessChildNamespaceList().begin(); it != ns->accessChildNamespaceList().end(); it++) { os << ";" << it->short_string();; } return os.str(); }
static Function *CreateFibFunction(Module *M, LLVMContext &Context) { // Create the fib function and insert it into module M. This function is said // to return an int and take an int parameter. Function *FibF = cast<Function>(M->getOrInsertFunction("fib", Type::getInt32Ty(Context), Type::getInt32Ty(Context), (Type *)0)); // Add a basic block to the function. BasicBlock *BB = BasicBlock::Create(Context, "EntryBlock", FibF); // Get pointers to the constants. Value *One = ConstantInt::get(Type::getInt32Ty(Context), 1); Value *Two = ConstantInt::get(Type::getInt32Ty(Context), 2); // Get pointer to the integer argument of the add1 function... Argument *ArgX = FibF->arg_begin(); // Get the arg. ArgX->setName("AnArg"); // Give it a nice symbolic name for fun. // Create the true_block. BasicBlock *RetBB = BasicBlock::Create(Context, "return", FibF); // Create an exit block. BasicBlock* RecurseBB = BasicBlock::Create(Context, "recurse", FibF); // Create the "if (arg <= 2) goto exitbb" Value *CondInst = new ICmpInst(*BB, ICmpInst::ICMP_SLE, ArgX, Two, "cond"); BranchInst::Create(RetBB, RecurseBB, CondInst, BB); // Create: ret int 1 ReturnInst::Create(Context, One, RetBB); // create fib(x-1) Value *Sub = BinaryOperator::CreateSub(ArgX, One, "arg", RecurseBB); CallInst *CallFibX1 = CallInst::Create(FibF, Sub, "fibx1", RecurseBB); CallFibX1->setTailCall(); // create fib(x-2) Sub = BinaryOperator::CreateSub(ArgX, Two, "arg", RecurseBB); CallInst *CallFibX2 = CallInst::Create(FibF, Sub, "fibx2", RecurseBB); CallFibX2->setTailCall(); // fib(x-1)+fib(x-2) Value *Sum = BinaryOperator::CreateAdd(CallFibX1, CallFibX2, "addresult", RecurseBB); // Create the return instruction and add it to the basic block ReturnInst::Create(Context, Sum, RecurseBB); return FibF; }
bool AMDGPURewriteOutArguments::isOutArgumentCandidate(Argument &Arg) const { const unsigned MaxOutArgSizeBytes = 4 * MaxNumRetRegs; PointerType *ArgTy = dyn_cast<PointerType>(Arg.getType()); // TODO: It might be useful for any out arguments, not just privates. if (!ArgTy || (ArgTy->getAddressSpace() != DL->getAllocaAddrSpace() && !AnyAddressSpace) || Arg.hasByValAttr() || Arg.hasStructRetAttr() || DL->getTypeStoreSize(ArgTy->getPointerElementType()) > MaxOutArgSizeBytes) { return false; } return checkArgumentUses(Arg); }
unordered_multimap<const char*, Value*>& ArgumentRecovery::exposeAllRegisters(llvm::Function* fn) { auto iter = registerAddresses.find(fn); if (iter != registerAddresses.end()) { return iter->second; } auto& addresses = registerAddresses[fn]; if (fn->isDeclaration()) { // If a function has no body, it doesn't need a register map. return addresses; } Argument* firstArg = fn->arg_begin(); assert(isStructType(firstArg)); // Get explicitly-used GEPs const auto& target = getAnalysis<TargetInfo>(); for (User* user : firstArg->users()) { if (auto gep = dyn_cast<GetElementPtrInst>(user)) { const char* name = target.registerName(*gep); const char* largestRegister = target.largestOverlappingRegister(name); addresses.insert({largestRegister, gep}); } } // Synthesize GEPs for implicitly-used registers. // Implicit uses are when a function callee uses a register without there being a reference in the caller. // This happens either because the parameter is passed through, or because the register is a scratch register that // the caller doesn't use itself. auto insertionPoint = fn->begin()->begin(); auto& regUse = getAnalysis<RegisterUse>(); const auto& modRefInfo = *regUse.getModRefInfo(fn); for (const auto& pair : modRefInfo) { if ((pair.second & RegisterUse::ModRef) != 0 && addresses.find(pair.first) == addresses.end()) { // Need a GEP here, because the function ModRefs the register implicitly. GetElementPtrInst* synthesizedGep = target.getRegister(firstArg, pair.first); synthesizedGep->insertBefore(insertionPoint); addresses.insert({pair.first, synthesizedGep}); } } return addresses; }
void ActionRequest::initArgumentList() { Node *actNode = getActionNode(); if (actNode == NULL) return; int nArgNodes = actNode->getNNodes(); argumentList.clear(); for (int n = 0; n < nArgNodes; n++) { Argument *arg = new Argument(); Node *argNode = actNode->getNode(n); arg->setName(argNode->getName()); arg->setValue(argNode->getValue()); argumentList.add(arg); } }
int Scope::drive(State& S, int t) { if(self_) self_->drive(S, t); for(ArgumentList::iterator i = arg_objs_.begin(); i != arg_objs_.end(); ++i) { Argument* a = *i; a->drive(S, t); } body_->drive(S, t); return t; }
ArgumentArea::ArgumentArea(QWidget *parent, Argument arg) : KHBox(parent) { prefix = arg.getPrefix(); QLabel *label = new QLabel(arg.getName(), this); label->setToolTip(arg.getDescription()); if(arg.getOptional() == true){ QCheckBox *enabled = new QCheckBox("", this); enabled->setCheckState(Qt::Unchecked); if(arg.getType() == Argument::Switch){ connect(enabled, SIGNAL(stateChanged(int)), this, SLOT(switchUpdate(int))); }
Argument *Action::getArgument(const std::string &name) { ArgumentList *argList = getArgumentList(); int nArgs = argList->size(); for (int n = 0; n < nArgs; n++) { Argument *arg = argList->getArgument(n); const char *argName = arg->getName(); if (argName == NULL) continue; string argNameStr = argName; if (argNameStr.compare(name) == 0) return arg; } return NULL; }
void PrintDeviceInfo(Device *dev, int indent) { string indentStr; GetIndentString(indent, indentStr); const char *devName = dev->getFriendlyName(); cout << indentStr << devName << endl; int i, n, j; ServiceList *serviceList = dev->getServiceList(); int serviceCnt = serviceList->size(); for (n=0; n<serviceCnt; n++) { Service *service = serviceList->getService(n); cout << indentStr << " service[" << n << "] = "<< service->getServiceType() << endl; ActionList *actionList = service->getActionList(); int actionCnt = actionList->size(); for (i=0; i<actionCnt; i++) { Action *action = actionList->getAction(i); cout << indentStr << " action[" << i << "] = "<< action->getName() << endl; ArgumentList *argList = action->getArgumentList(); int argCnt = argList->size(); for (j=0; j<argCnt; j++) { Argument *arg = argList->getArgument(j); cout << indentStr << " arg[" << j << "] = " << arg->getName() << "(" << arg->getDirection() << ")"; StateVariable *stateVar = arg->getRelatedStateVariable(); if (stateVar != NULL) cout << " - " << stateVar->getName(); cout << endl; } } ServiceStateTable *stateTable = service->getServiceStateTable(); int varCnt = stateTable->size(); for (i=0; i<varCnt; i++) { StateVariable *stateVar = stateTable->getStateVariable(i); cout << indentStr << " stateVar[" << i << "] = " << stateVar->getName() << endl; AllowedValueList *valueList = stateVar->getAllowedValueList(); int valueListCnt = valueList->size(); if (0 < valueListCnt) { for (j=0; j<valueListCnt; j++) cout << indentStr << " AllowedValueList[" << j << "] = " << valueList->getAllowedValue(j) << endl; } AllowedValueRange *valueRange = stateVar->getAllowedValueRange(); if (valueRange != NULL) { cout << indentStr << " AllowedRange[minimum] = " << valueRange->getMinimum() << endl; cout << indentStr << " AllowedRange[maximum] = " << valueRange->getMaximum() << endl; cout << indentStr << " AllowedRange[step] = " << valueRange->getStep() << endl; } } } }
bool has(string name) { Argument *arg = getArgument(name); if (arg == nullptr) { return false; } for (auto entry : map) { if (arg->is(entry.first)) { return true; } } return false; }
bool loadConfigFile() { std::string path(config.get()); struct stat st; if (::stat(path.c_str(), &st) < 0 || !S_ISREG(st.st_mode)) { std::cerr << "Not a file: " << path << std::endl; return false; } std::ifstream is(path.c_str(), std::ios::binary); if (!is.is_open()) { std::cerr << "File not readable: " << path << std::endl; return false; } is.seekg(0, std::ios_base::end); std::streampos len = is.tellg(); is.seekg(0, std::ios::beg); std::string data; if (len > 0) { data.resize(len); is.read(&data[0], len); std::string error; if (!ArgumentBase::parseData(data, error)) { std::cerr << error << std::endl; return false; } } return true; }
std::string tesla::BaseName(const Argument& A) { switch (A.type()) { case Argument::Any: case Argument::Constant: assert(false && "called BaseName() on a non-variable Argument"); case Argument::Variable: return A.name(); case Argument::Indirect: return BaseName(A.indirection()); case Argument::Field: return BaseName(A.field().base()); } }
bool TestDevice::actionControlReceived(Action *action) { const char *actionName = action->getName(); if (strcmp("GetCount", actionName) == 0) { Argument *countArg = action->getArgument("CurrentCount"); countArg->setValue(count); return true; } if (strcmp(actionName, "SetCount") == 0) { Argument *countArg = action->getArgument("NewCount"); int newCount = countArg->getIntegerValue(); count = newCount; return true; } return false; }
bool CheckDeclarator::visit(FunctionDeclaratorAST *ast) { Function *fun = control()->newFunction(ast->firstToken()); fun->setAmbiguous(ast->as_cpp_initializer != 0); ast->symbol = fun; fun->setReturnType(_fullySpecifiedType); if (_fullySpecifiedType.isVirtual()) fun->setVirtual(true); if (ast->parameters) { DeclarationListAST *parameter_declarations = ast->parameters->parameter_declarations; for (DeclarationListAST *decl = parameter_declarations; decl; decl = decl->next) { semantic()->check(decl->declaration, fun->arguments()); } if (ast->parameters->dot_dot_dot_token) fun->setVariadic(true); } // check the arguments bool hasDefaultArguments = false; for (unsigned i = 0; i < fun->argumentCount(); ++i) { Argument *arg = fun->argumentAt(i)->asArgument(); if (hasDefaultArguments && ! arg->hasInitializer()) { translationUnit()->error(ast->firstToken(), "default argument missing for parameter at position %d", i + 1); } else if (! hasDefaultArguments) { hasDefaultArguments = arg->hasInitializer(); } } FullySpecifiedType funTy(fun); _fullySpecifiedType = funTy; for (SpecifierAST *it = ast->cv_qualifier_seq; it; it = it->next) { SimpleSpecifierAST *cv = static_cast<SimpleSpecifierAST *>(it); int k = tokenKind(cv->specifier_token); if (k == T_CONST) fun->setConst(true); else if (k == T_VOLATILE) fun->setVolatile(true); } accept(ast->next); return false; }
void OpenHome::Net::Invocation::OutputArgument(IAsyncOutput& aConsole, const TChar* aKey, const Argument& aArgument) { static const TUint kMaxStackBytes = 1024; TChar str[kMaxStackBytes]; TChar* bigStr = NULL; ASSERT(aArgument.Parameter().Name().Bytes() < kMaxStackBytes-40); // add code to support mega-names if this ever fails OpenHome::Net::Parameter::EType paramType = aArgument.Parameter().Type(); if (paramType == OpenHome::Net::Parameter::eTypeRelated) { paramType = ((const ParameterRelated&)aArgument.Parameter()).Related().Parameter().Type(); } const Brx& paramName = aArgument.Parameter().Name(); if (paramType == OpenHome::Net::Parameter::eTypeBinary) { (void)sprintf(str, "%s (binary - size %lu)", paramName.Ptr(), (unsigned long)((const ArgumentBinary&)aArgument).Value().Bytes()); } else if (paramType == OpenHome::Net::Parameter::eTypeString) { char fmt[] = "%s (%s)"; const ArgumentString& argString = (const ArgumentString&)aArgument; const TUint len = paramName.Bytes() + argString.Value().Bytes() + sizeof(*fmt); if (len > kMaxStackBytes) { bigStr = new TChar[len]; (void)sprintf(bigStr, fmt, paramName.Ptr(), argString.Value().Ptr()); } else { (void)sprintf(str, fmt, paramName.Ptr(), argString.Value().Ptr()); } } else { switch (paramType) { case OpenHome::Net::Parameter::eTypeBool: (void)sprintf(str, "%s (%d)", paramName.Ptr(), ((const ArgumentBool&)aArgument).Value()); break; case OpenHome::Net::Parameter::eTypeInt: (void)sprintf(str, "%s (%lu)", paramName.Ptr(), (unsigned long)((const ArgumentInt&)aArgument).Value()); break; case OpenHome::Net::Parameter::eTypeUint: (void)sprintf(str, "%s (%lu)", paramName.Ptr(), (unsigned long)((const ArgumentUint&)aArgument).Value()); break; default: ASSERTS(); } } aConsole.Output(aKey, (bigStr==NULL? str : bigStr)); delete bigStr; }
void CheckDeclaration::checkFunctionArguments(Function *fun) { if (! _checkAnonymousArguments) return; if (_scope->isClassScope() && fun->isPublic()) { for (unsigned argc = 0; argc < fun->argumentCount(); ++argc) { Argument *arg = fun->argumentAt(argc)->asArgument(); assert(arg != 0); if (! arg->name()) { translationUnit()->warning(arg->sourceLocation(), "anonymous argument"); } } } }
void Condition::_Compile(Argument& EndSym) { Expr->Compile(); Node::Compile(Magic, 1); EndSym.CompileRaw(); ConditionBlock->Compile(); SymCounter++; }
/// RemoveDeadArgumentsFromCallers - Checks if the given function has any /// arguments that are unused, and changes the caller parameters to be undefined /// instead. bool DAE::RemoveDeadArgumentsFromCallers(Function &Fn) { if (Fn.isDeclaration() || Fn.mayBeOverridden()) return false; // Functions with local linkage should already have been handled, except the // fragile (variadic) ones which we can improve here. if (Fn.hasLocalLinkage() && !Fn.getFunctionType()->isVarArg()) return false; if (Fn.use_empty()) return false; SmallVector<unsigned, 8> UnusedArgs; for (Function::arg_iterator I = Fn.arg_begin(), E = Fn.arg_end(); I != E; ++I) { Argument *Arg = I; if (Arg->use_empty() && !Arg->hasByValAttr()) UnusedArgs.push_back(Arg->getArgNo()); } if (UnusedArgs.empty()) return false; bool Changed = false; for (Function::use_iterator I = Fn.use_begin(), E = Fn.use_end(); I != E; ++I) { CallSite CS(*I); if (!CS || !CS.isCallee(I)) continue; // Now go through all unused args and replace them with "undef". for (unsigned I = 0, E = UnusedArgs.size(); I != E; ++I) { unsigned ArgNo = UnusedArgs[I]; Value *Arg = CS.getArgument(ArgNo); CS.setArgument(ArgNo, UndefValue::get(Arg->getType())); ++NumArgumentsReplacedWithUndef; Changed = true; } } return Changed; }
static void printRequest(HttpRequestHolder const &req, StatServer *ss) { if (debugHttp.enabled()) { LogNotice << "http serving" << req->url(); } LogDebug << "Serving:" << req->method() << req->url(); boost::shared_ptr<RequestInFlight> rif(new RequestInFlight(req.p_, ss, filesDir.get())); ss->service().post(boost::bind(&RequestInFlight::go, rif)); }