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));
}
