QDeclarativeObjectMethodScriptClass::Value
QDeclarativeObjectMethodScriptClass::callPrecise(QObject *object, const QDeclarativePropertyCache::Data &data,
QScriptContext *ctxt)
{
if (data.flags & QDeclarativePropertyCache::Data::HasArguments) {
QMetaMethod m = object->metaObject()->method(data.coreIndex);
QList<QByteArray> argTypeNames = m.parameterTypes();
QVarLengthArray<int, 9> argTypes(argTypeNames.count());
// ### Cache
for (int ii = 0; ii < argTypeNames.count(); ++ii) {
argTypes[ii] = QMetaType::type(argTypeNames.at(ii));
if (argTypes[ii] == QVariant::Invalid)
argTypes[ii] = enumType(object->metaObject(), QString::fromLatin1(argTypeNames.at(ii)));
if (argTypes[ii] == QVariant::Invalid)
return Value(ctxt, ctxt->throwError(QString::fromLatin1("Unknown method parameter type: %1").arg(QLatin1String(argTypeNames.at(ii)))));
}
if (argTypes.count() > ctxt->argumentCount())
return Value(ctxt, ctxt->throwError(QLatin1String("Insufficient arguments")));
return callMethod(object, data.coreIndex, data.propType, argTypes.count(), argTypes.data(), ctxt);
} else {
return callMethod(object, data.coreIndex, data.propType, 0, 0, ctxt);
}
}
QDeclarativeObjectMethodScriptClass::Value QDeclarativeObjectMethodScriptClass::call(Object *o, QScriptContext *ctxt)
{
MethodData *method = static_cast<MethodData *>(o);
if (method->data.flags & QDeclarativePropertyCache::Data::HasArguments) {
QMetaMethod m = method->object->metaObject()->method(method->data.coreIndex);
QList<QByteArray> argTypeNames = m.parameterTypes();
QVarLengthArray<int, 9> argTypes(argTypeNames.count());
// ### Cache
for (int ii = 0; ii < argTypeNames.count(); ++ii) {
argTypes[ii] = QMetaType::type(argTypeNames.at(ii));
if (argTypes[ii] == QVariant::Invalid)
return Value(ctxt, ctxt->throwError(QString::fromLatin1("Unknown method parameter type: %1").arg(QLatin1String(argTypeNames.at(ii)))));
}
if (argTypes.count() > ctxt->argumentCount())
return Value(ctxt, ctxt->throwError(QLatin1String("Insufficient arguments")));
QVarLengthArray<MetaCallArgument, 9> args(argTypes.count() + 1);
args[0].initAsType(method->data.propType, engine);
for (int ii = 0; ii < argTypes.count(); ++ii)
args[ii + 1].fromScriptValue(argTypes[ii], engine, ctxt->argument(ii));
QVarLengthArray<void *, 9> argData(args.count());
for (int ii = 0; ii < args.count(); ++ii)
argData[ii] = args[ii].dataPtr();
QMetaObject::metacall(method->object, QMetaObject::InvokeMetaMethod, method->data.coreIndex, argData.data());
return args[0].toValue(engine);
} else if (method->data.propType != 0) {
MetaCallArgument arg;
arg.initAsType(method->data.propType, engine);
void *args[] = { arg.dataPtr() };
QMetaObject::metacall(method->object, QMetaObject::InvokeMetaMethod, method->data.coreIndex, args);
return arg.toValue(engine);
} else {
void *args[] = { 0 };
QMetaObject::metacall(method->object, QMetaObject::InvokeMetaMethod, method->data.coreIndex, args);
return Value();
}
return Value();
}
void Get(PyObject **G, const char* funcName, PyObject***list)
{
PyObject *** pyObjects = new PyObject**[1];
pyObjects[0] = G;
*list = new PyObject*[1];
char * moduleName = "function";
int argc = 1;
TStrV args(0); TStrV argTypes(argc);
argTypes[0] = "pyobject";
CallPyFunction(moduleName, funcName, args, argTypes, *list, pyObjects);
Py_DECREF(pyObjects);
}
static void
addScalarIntrinsic(std::vector<fir::FuncDecl::Ptr>* intrinsics,
const std::string& name,
const std::vector<ScalarType::Type> &args,
const std::vector<ScalarType::Type> &results) {
std::vector<Type::Ptr> argTypes(args.size());
std::vector<Type::Ptr> resultTypes(results.size());
for (unsigned i = 0; i < args.size(); ++i) {
argTypes[i] = makeTensorType(args[i]);
}
for (unsigned i = 0; i < results.size(); ++i) {
resultTypes[i] = makeTensorType(results[i]);
}
addIntrinsic(intrinsics, name, argTypes, resultTypes);
}
Type::Type(vector<Type*>* tupleType, TypeTag t) {// For tuples, modules, events
tag_ = t;
argTypes(tupleType);
};
bool ProfilingPass::runOnFunction(Function &F)
{
LLVMContext& context = F.getContext();
Module *m = F.getParent();
string funcname = F.getNameStr();
string injectfunc("injectFault");
if((profileoption == 'p' || profileoption == 'c' || profileoption == 'i') && (funcname.find(injectfunc) != string::npos))
return false;
std::vector<Instruction*> insert_worklist;
for (inst_iterator In = inst_begin(F), E = inst_end(F); In != E; ++In)
{
Instruction *I = dyn_cast<Instruction>(&*In);
//errs()<<*I<<"\n";
if(profileoption == 'b')
{
if(CmpInst *ci = dyn_cast<CmpInst>(I))
if(is_used_by_branch(ci)){
vector<const Type*> argTypes(1);
argTypes[0] = Type::getInt32Ty(context); // enum for the options
FunctionType* countFuncType = FunctionType::get( Type::getVoidTy(context), argTypes, 0 );
Constant* countFunc = m->getOrInsertFunction("doProfiling", countFuncType); // get the injection function
vector<Value*> countArgs(1);
const IntegerType* itype = IntegerType::get(context,32);
Value* branchVal = ConstantInt::get(itype, BRANCH );
countArgs[0] = branchVal; //enum for branch
CallInst::Create( countFunc, countArgs.begin(),countArgs.end(), "", I);
}
}
else if(profileoption == 'd')
{
//see if the current instruction is a cmp instruction that leads to a conditional branch
//add the instrumentation to the defs of this cmp instruction
//--> Static time deduction since branch not known if executed or not
CmpInst *ci = dyn_cast<CmpInst>(I);
//errs() <<"reached here:\n";
if(!ci)
continue;
//traverse def-use chain
//int is_used_by_branch = 0;
if(!is_used_by_branch(I))
continue;
//the defines of this instruction I --> would be injectFaultCalls.
for (User::op_iterator i = I->op_begin(), e = I->op_end(); i != e; ++i)
{
Instruction *v = dyn_cast<Instruction>(*i);
if(!v)
continue;
//errs() <<"reached here:"<< *v << "\n";
//do profiling for the def
vector<const Type*> argTypes(1);
argTypes[0] = Type::getInt32Ty(context); // enum for the options
FunctionType* countFuncType = FunctionType::get( Type::getVoidTy(context), argTypes, 0 );
Constant* countFunc = m->getOrInsertFunction("doProfiling", countFuncType); // get the injection function
vector<Value*> countArgs(1);
const IntegerType* itype = IntegerType::get(context,32);
Value* defVal = ConstantInt::get(itype, DEF );
countArgs[0] = defVal; //enum for branch
Instruction *beforeInst;
if(isa<PHINode>(v))
{ BasicBlock *bb = v->getParent();
beforeInst = bb->getFirstNonPHI();
}
else
beforeInst = v;
CallInst::Create( countFunc, countArgs.begin(),countArgs.end(), "", beforeInst); // insert the profiling call before the def:v
}
}
else if(profileoption == 'a' )
{
Instruction *beforeInst;
//consider all instructions profiling
vector<const Type*> argTypes(1);
argTypes[0] = Type::getInt32Ty(context); // enum for the options
FunctionType* countFuncType = FunctionType::get( Type::getVoidTy(context), argTypes, 0 );
Constant* countFunc = m->getOrInsertFunction("doProfiling", countFuncType); // get the injection function
vector<Value*> countArgs(1);
const IntegerType* itype = IntegerType::get(context,32);
Value* allVal = ConstantInt::get(itype, ALL );
if(isa<PHINode>(I))
{ BasicBlock *bb = I->getParent();
beforeInst = bb->getFirstNonPHI();
}
else
beforeInst = I;
countArgs[0] = allVal; //enum for All inst
CallInst::Create( countFunc, countArgs.begin(),countArgs.end(), "", beforeInst); // Insert the inject call before the instruction
}
//in fact, here we only use backwardslice ('s')
else if(profileoption == 's')
{
const Type* returnType = I->getType();
if (returnType->isVoidTy() || !filter(I))//Here we can insert a new filter ///////////////////////////////////////////////
{
//errs()<<"filter not passed\n";
continue;
}
//for injection into all instructions except invoke instructions (these are same as unconditional branch instructions with exception handling mechanism)
if((isa<InvokeInst>(I))
#ifdef EXCLUDE_CASTINST
|| (isa<CastInst>(I))
#endif
) // cast instruction added by Jiesheng
continue;
//errs()<<"filter passed\n";
Instruction *beforeInst;
if(isa<PHINode>(I))
{ BasicBlock *bb = I->getParent();
beforeInst = bb->getFirstNonPHI();
}
else
beforeInst = I;
insert_worklist.push_back(beforeInst);
}
}
while(!insert_worklist.empty())
{
Instruction* beforeInst = insert_worklist.back();
insert_worklist.pop_back();
vector<const Type*> argTypes(1);
argTypes[0] = Type::getInt32Ty(context); // enum for the options
FunctionType* countFuncType = FunctionType::get( Type::getVoidTy(context), argTypes, 0 );
Constant* countFunc = m->getOrInsertFunction("doProfiling", countFuncType);
vector<Value*> countArgs(1);
const IntegerType* itype = IntegerType::get(context,32);
Value* allVal = ConstantInt::get(itype, BACKWARD_SLICE );
countArgs[0] = allVal; //enum for All inst
CallInst::Create( countFunc, countArgs.begin(),countArgs.end(), "", beforeInst);
}
return true;
}
