void copyRect(
const ExPop::Gfx::Image *src,
ExPop::Gfx::Image *dst,
int src_left,
int src_top,
int dst_left,
int dst_top,
int width,
int height)
{
for(int x = 0; x < width; x++) {
for(int y = 0; y < height; y++) {
int wrapped_src_x = wrapValue(x + src_left, src->getWidth());
int wrapped_src_y = wrapValue(y + src_top, src->getHeight());
int wrapped_dst_x = wrapValue(x + dst_left, dst->getWidth());
int wrapped_dst_y = wrapValue(y + dst_top, dst->getHeight());
const ExPop::Gfx::Pixel *src_p = src->getPixel(wrapped_src_x, wrapped_src_y);
ExPop::Gfx::Pixel *dst_p = dst->getPixel(wrapped_dst_x, wrapped_dst_y);
*dst_p = *src_p;
}
}
}
void AAAnalyzer::handle_instrinsic(Instruction *inst) {
IntrinsicInst * call = (IntrinsicInst*) inst;
switch (call->getIntrinsicID()) {
// Variable Argument Handling Intrinsics
case Intrinsic::vastart:
{
Value * va_list_ptr = call->getArgOperand(0);
wrapValue(va_list_ptr);
}
break;
case Intrinsic::vaend:
{
}
break;
case Intrinsic::vacopy: // the same with memmove/memcpy
//Standard C Library Intrinsics
case Intrinsic::memmove:
case Intrinsic::memcpy:
{
Value * src_ptr = call->getArgOperand(0);
Value * dst_ptr = call->getArgOperand(1);
DyckVertex* src_ptr_ver = wrapValue(src_ptr);
DyckVertex* dst_ptr_ver = wrapValue(dst_ptr);
DyckVertex* src_ver = addPtrTo(src_ptr_ver, NULL);
DyckVertex* dst_ver = addPtrTo(dst_ptr_ver, NULL);
makeAlias(src_ver, dst_ver);
}
break;
case Intrinsic::memset:
{
Value * ptr = call->getArgOperand(0);
Value * val = call->getArgOperand(1);
addPtrTo(wrapValue(ptr), wrapValue(val));
}
break;
/// @todo other C lib intrinsics
//Accurate Garbage Collection Intrinsics
//Code Generator Intrinsics
//Bit Manipulation Intrinsics
//Exception Handling Intrinsics
//Trampoline Intrinsics
//Memory Use Markers
//General Intrinsics
//Arithmetic with Overflow Intrinsics
//Specialised Arithmetic Intrinsics
//Half Precision Floating Point Intrinsics
//Debugger Intrinsics
default:break;
}
}
void AAAnalyzer::handle_lib_invoke_call_inst(Value* ret, Function* f, vector<Value*>* args, FunctionWrapper* parent) {
if(!f->empty() || f->isIntrinsic())
return;
const string& functionName = f->getName().str();
switch (args->size()) {
case 2:
{
if (functionName == "strcat" || functionName == "strcpy") {
if (ret != NULL){
this->makeAlias(wrapValue(ret), wrapValue(args->at(0)));
} else{
errs()<< "ERROR strcat/cpy does not return.\n";
exit(1);
}
}
}
break;
case 3:
{
if (functionName == "strncat" || functionName == "strncpy") {
if (ret != NULL){
this->makeAlias(wrapValue(ret), wrapValue(args->at(0)));
} else{
errs()<< "ERROR strncat/cpy does not return.\n";
exit(1);
}
}
}
break;
case 4:
{
if (functionName == "pthread_create") {
Value * ret = NULL;
vector<Value*> xargs;
xargs.push_back(args->at(3));
FunctionWrapper* parent = NULL;
if (!wrapped_functions_map.count(f)) {
parent = new FunctionWrapper(f);
wrapped_functions_map.insert(pair<Function*, FunctionWrapper *>(f, parent));
wrapped_functions.insert(parent);
} else {
parent = wrapped_functions_map[f];
}
this->handle_invoke_call_inst(ret, args->at(2), &xargs, parent);
valuesEscapedFromThreadCreate.insert(args->at(3));
}
}
break;
default: break;
}
}
static LLVMValueRef
translateBinOp(SymbolTable *TyTable, SymbolTable *ValTable, ASTNode *Node) {
ASTNode *NodeE1 = (ASTNode*) ptrVectorGet(&(Node->Child), 0),
*NodeE2 = (ASTNode*) ptrVectorGet(&(Node->Child), 1);
LLVMValueRef ValueE1Ptr = translateExpr(TyTable, ValTable, NodeE1),
ValueE2Ptr = translateExpr(TyTable, ValTable, NodeE2);
LLVMValueRef ValueE1 = LLVMBuildLoad(Builder, ValueE1Ptr, "binop.ld.e1."),
ValueE2 = LLVMBuildLoad(Builder, ValueE2Ptr, "binop.ld.e2.");
LLVMValueRef ResultVal = NULL;
switch (LLVMGetTypeKind(LLVMTypeOf(ValueE1))) {
case LLVMIntegerTypeKind: ResultVal = translateIntBinOp (Node->Kind, ValueE1, ValueE2); break;
case LLVMFloatTypeKind: ResultVal = translateFloatBinOp (Node->Kind, ValueE1, ValueE2); break;
case LLVMStructTypeKind: ResultVal = translateStructBinOp(Node->Kind, ValueE1Ptr, ValueE2Ptr); break;
case LLVMPointerTypeKind: ResultVal = translateStringBinOp(Node->Kind, ValueE1, ValueE2); break;
default: return NULL;
}
switch (LLVMGetTypeKind(LLVMTypeOf(ResultVal))) {
case LLVMIntegerTypeKind: ResultVal = LLVMBuildZExt(Builder, ResultVal, LLVMInt32Type(), ""); break;
default: break;
}
return wrapValue(ResultVal);
}
void AAAnalyzer::handle_invoke_call_inst(Value* ret, Value* cv, vector<Value*>* args, FunctionWrapper* parent) {
if (isa<Function>(cv)) {
if (((Function*) cv)->isIntrinsic()) {
handle_instrinsic((Instruction*) ret);
} else {
this->handle_lib_invoke_call_inst(ret, (Function*) cv, args, parent);
parent->addCommonCall(new CommonCall(ret, (Function*) cv, args));
}
} else {
wrapValue(cv);
if (isa<ConstantExpr>(cv)) {
Value * cvcopy = cv;
while (isa<ConstantExpr>(cvcopy) && ((ConstantExpr*) cvcopy)->isCast()) {
cvcopy = ((ConstantExpr*) cvcopy)->getOperand(0);
}
if (isa<Function>(cvcopy)) {
this->handle_lib_invoke_call_inst(ret, (Function*) cvcopy, args, parent);
parent->addCommonCall(new CommonCall(ret, (Function*) cvcopy, args));
} else {
PointerCall* pcall = new PointerCall(ret, cv, getCompatibleFunctions((FunctionType*) (cvcopy->getType()->getPointerElementType())), args);
parent->addPointerCall(pcall);
}
} else {
PointerCall * pcall = new PointerCall(ret, cv, getCompatibleFunctions((FunctionType*) (cv->getType()->getPointerElementType())), args);
parent->addPointerCall(pcall);
}
}
}
String WddxPacket::getWddxEncoded(const String& varType,
const String& varValue,
const String& varName,
bool hasVarTag) {
if (varType.compare("NULL") == 0 || varType.compare("null") == 0) {
return wrapValue("<null/>", "", "", varName, hasVarTag);
}
if (varType.compare("boolean") == 0) {
return wrapValue("<boolean value='", "'/>", varValue, varName, hasVarTag);
}
if (varType.compare("integer") == 0 || varType.compare("double") == 0) {
return wrapValue("<number>", "</number>", varValue, varName, hasVarTag);
}
if (varType.compare("string") == 0) {
return wrapValue("<string>", "</string>", varValue, varName, hasVarTag);
}
return "";
}
void clearRect(
ExPop::Gfx::Image *dst,
int dst_left,
int dst_top,
int width,
int height)
{
for(int x = 0; x < width; x++) {
for(int y = 0; y < height; y++) {
int wrapped_dst_x = wrapValue(x + dst_left, dst->getWidth());
int wrapped_dst_y = wrapValue(y + dst_top, dst->getHeight());
ExPop::Gfx::Pixel *dst_p = dst->getPixel(wrapped_dst_x, wrapped_dst_y);
dst_p->value = 0;
}
}
}
static LLVMValueRef
translateStringLit(ASTNode *Node) {
int Length = strlen(Node->Value);
LLVMValueRef GlobVar = LLVMAddGlobal(Module, LLVMArrayType(LLVMInt8Type(), Length+1), "global.var");
LLVMSetInitializer(GlobVar, LLVMConstString(Node->Value, Length, 0));
LLVMValueRef LocalVar = LLVMBuildAlloca(Builder, LLVMArrayType(LLVMInt8Type(), Length+1), "local.string.");
LLVMValueRef LocalI8 = LLVMBuildBitCast(Builder, LocalVar, LLVMPointerType(LLVMInt8Type(), 0), "");
copyMemory(LocalI8, GlobVar, getSConstInt(Length+1));
return wrapValue(LocalI8);
}
std::unique_ptr<protocol::Runtime::RemoteObject> InjectedScript::wrapObject(ErrorString* errorString, v8::Local<v8::Value> value, const String16& groupName, bool forceValueType, bool generatePreview) const
{
v8::HandleScope handles(m_context->isolate());
v8::Local<v8::Value> wrappedObject;
if (!wrapValue(errorString, value, groupName, forceValueType, generatePreview).ToLocal(&wrappedObject))
return nullptr;
protocol::ErrorSupport errors;
std::unique_ptr<protocol::Runtime::RemoteObject> remoteObject = protocol::Runtime::RemoteObject::parse(toProtocolValue(m_context->context(), wrappedObject).get(), &errors);
if (!remoteObject)
*errorString = "Object has too long reference chain";
return remoteObject;
}
bool InjectedScript::wrapObjectProperty(ErrorString* errorString, v8::Local<v8::Object> object, v8::Local<v8::Value> key, const String16& groupName, bool forceValueType, bool generatePreview) const
{
v8::Local<v8::Value> property;
if (hasInternalError(errorString, !object->Get(m_context->context(), key).ToLocal(&property)))
return false;
v8::Local<v8::Value> wrappedProperty;
if (!wrapValue(errorString, property, groupName, forceValueType, generatePreview).ToLocal(&wrappedProperty))
return false;
v8::Maybe<bool> success = object->Set(m_context->context(), key, wrappedProperty);
if (hasInternalError(errorString, success.IsNothing() || !success.FromJust()))
return false;
return true;
}
void AAAnalyzer::handle_inst(Instruction *inst, FunctionWrapper * parent_func) {
//outs()<<*inst<<"\n"; outs().flush();
switch (inst->getOpcode()) {
// common/bitwise binary operations
// Terminator instructions
case Instruction::Ret:
{
ReturnInst* retInst = ((ReturnInst*) inst);
if (retInst->getNumOperands() > 0 && !retInst->getOperandUse(0)->getType()->isVoidTy()) {
parent_func->addRet(retInst->getOperandUse(0));
}
}
break;
case Instruction::Resume:
{
Value* resume = ((ResumeInst*) inst)->getOperand(0);
parent_func->addResume(resume);
}
break;
case Instruction::Switch:
case Instruction::Br:
case Instruction::IndirectBr:
case Instruction::Unreachable:
break;
// vector operations
case Instruction::ExtractElement:
{
}
break;
case Instruction::InsertElement:
{
}
break;
case Instruction::ShuffleVector:
{
}
break;
// aggregate operations
case Instruction::ExtractValue:
{
Value * agg = ((ExtractValueInst*) inst)->getAggregateOperand();
DyckVertex* aggV = wrapValue(agg);
Type* aggTy = agg->getType();
ArrayRef<unsigned> indices = ((ExtractValueInst*) inst)->getIndices();
DyckVertex* currentStruct = aggV;
for (unsigned int i = 0; i < indices.size(); i++) {
if (isa<CompositeType>(aggTy) && aggTy->isSized()) {
if (!aggTy->isStructTy()) {
aggTy = ((CompositeType*) aggTy)->getTypeAtIndex(indices[i]);
#ifndef ARRAY_SIMPLIFIED
current = addPtrOffset(current, (int) indices[i] * dl.getTypeAllocSize(aggTy), dgraph);
#endif
if (i == indices.size() - 1) {
this->makeAlias(currentStruct, wrapValue(inst));
}
} else {
aggTy = ((CompositeType*) aggTy)->getTypeAtIndex(indices[i]);
if (i != indices.size() - 1) {
currentStruct = this->addField(currentStruct, -2 - (int) indices[i], NULL);
} else {
currentStruct = this->addField(currentStruct, -2 - (int) indices[i], wrapValue(inst));
}
}
} else {
break;
}
}
}
break;
case Instruction::InsertValue:
{
DyckVertex* resultV = wrapValue(inst);
Value * agg = ((InsertValueInst*) inst)->getAggregateOperand();
if (!isa<UndefValue>(agg)) {
makeAlias(resultV, wrapValue(agg));
}
Value * val = ((InsertValueInst*) inst)->getInsertedValueOperand();
DyckVertex* insertedVal = wrapValue(val);
Type *aggTy = inst->getType();
ArrayRef<unsigned> indices = ((InsertValueInst*) inst)->getIndices();
DyckVertex* currentStruct = resultV;
for (unsigned int i = 0; i < indices.size(); i++) {
if (isa<CompositeType>(aggTy) && aggTy->isSized()) {
if (!aggTy->isStructTy()) {
aggTy = ((CompositeType*) aggTy)->getTypeAtIndex(indices[i]);
#ifndef ARRAY_SIMPLIFIED
current = addPtrOffset(current, (int) indices[i] * dl.getTypeAllocSize(aggTy), dgraph);
#endif
if (i == indices.size() - 1) {
this->makeAlias(currentStruct, insertedVal);
}
} else {
aggTy = ((CompositeType*) aggTy)->getTypeAtIndex(indices[i]);
if (i != indices.size() - 1) {
currentStruct = this->addField(currentStruct, -2 - (int) indices[i], NULL);
} else {
currentStruct = this->addField(currentStruct, -2 - (int) indices[i], insertedVal);
}
}
} else {
break;
}
}
}
break;
// memory accessing and addressing operations
case Instruction::Alloca:
{
}
break;
case Instruction::Fence:
{
}
break;
case Instruction::AtomicCmpXchg:
{
Value * retXchg = inst;
Value * ptrXchg = inst->getOperand(0);
Value * newXchg = inst->getOperand(2);
addPtrTo(wrapValue(ptrXchg), wrapValue(retXchg));
addPtrTo(wrapValue(ptrXchg), wrapValue(newXchg));
}
break;
case Instruction::AtomicRMW:
{
Value * retRmw = inst;
Value * ptrRmw = ((AtomicRMWInst*) inst)->getPointerOperand();
addPtrTo(wrapValue(ptrRmw), wrapValue(retRmw));
switch (((AtomicRMWInst*) inst)->getOperation()) {
case AtomicRMWInst::Max:
case AtomicRMWInst::Min:
case AtomicRMWInst::UMax:
case AtomicRMWInst::UMin:
case AtomicRMWInst::Xchg:
{
Value * newRmw = ((AtomicRMWInst*) inst)->getValOperand();
addPtrTo(wrapValue(ptrRmw), wrapValue(newRmw));
}
break;
default:
//others are binary ops like add/sub/...
///@TODO
break;
}
}
break;
case Instruction::Load:
{
Value *lval = inst;
Value *ladd = inst->getOperand(0);
addPtrTo(wrapValue(ladd), wrapValue(lval));
}
break;
case Instruction::Store:
{
Value * sval = inst->getOperand(0);
Value * sadd = inst->getOperand(1);
addPtrTo(wrapValue(sadd), wrapValue(sval));
}
break;
case Instruction::GetElementPtr:
{
makeAlias(wrapValue(inst), handle_gep((GEPOperator*) inst));
}
break;
// conversion operations
case Instruction::Trunc:
case Instruction::ZExt:
case Instruction::SExt:
case Instruction::FPTrunc:
case Instruction::FPExt:
case Instruction::FPToUI:
case Instruction::FPToSI:
case Instruction::UIToFP:
case Instruction::SIToFP:
case Instruction::BitCast:
case Instruction::PtrToInt:
case Instruction::IntToPtr:
{
Value * itpv = inst->getOperand(0);
makeAlias(wrapValue(inst), wrapValue(itpv));
}
break;
// other operations
case Instruction::Invoke: // invoke is a terminal operation
{
InvokeInst * invoke = (InvokeInst*) inst;
LandingPadInst* lpd = invoke->getLandingPadInst();
parent_func->addLandingPad(invoke, lpd);
Value * cv = invoke->getCalledValue();
vector<Value*> args;
for (unsigned i = 0; i < invoke->getNumArgOperands(); i++) {
args.push_back(invoke->getArgOperand(i));
}
this->handle_invoke_call_inst(invoke, cv, &args, parent_func);
}
break;
case Instruction::Call:
{
CallInst * callinst = (CallInst*) inst;
if (callinst->isInlineAsm()) {
break;
}
Value * cv = callinst->getCalledValue();
vector<Value*> args;
for (unsigned i = 0; i < callinst->getNumArgOperands(); i++) {
args.push_back(callinst->getArgOperand(i));
}
this->handle_invoke_call_inst(callinst, cv, &args, parent_func);
}
break;
case Instruction::PHI:
{
PHINode *phi = (PHINode *) inst;
int nums = phi->getNumIncomingValues();
for (int i = 0; i < nums; i++) {
Value * p = phi->getIncomingValue(i);
makeAlias(wrapValue(inst), wrapValue(p));
}
}
break;
case Instruction::Select:
{
Value *first = ((SelectInst*) inst)->getTrueValue();
Value *second = ((SelectInst*) inst)->getFalseValue();
makeAlias(wrapValue(inst), wrapValue(first));
makeAlias(wrapValue(inst), wrapValue(second));
}
break;
case Instruction::VAArg:
{
parent_func->addVAArg(inst);
DyckVertex* vaarg = wrapValue(inst);
Value * ptrVaarg = inst->getOperand(0);
addPtrTo(wrapValue(ptrVaarg), vaarg);
}
break;
case Instruction::LandingPad: // handled with invoke inst
case Instruction::ICmp:
case Instruction::FCmp:
default:
break;
}
}
DyckVertex* AAAnalyzer::wrapValue(Value * v) {
// if the vertex of v exists, return it, otherwise create one
pair < DyckVertex*, bool> retpair = dgraph->retrieveDyckVertex(v);
if (retpair.second) {
return retpair.first;
}
DyckVertex* vdv = retpair.first;
// constantTy are handled as below.
if (isa<ConstantExpr>(v)) {
// constant expr should be handled like a assignment instruction
if (isa<GEPOperator>(v)) {
DyckVertex * got = handle_gep((GEPOperator*) v);
makeAlias(vdv, got);
} else if (((ConstantExpr*) v)->isCast()) {
// errs() << *v << "\n";
DyckVertex * got = wrapValue(((ConstantExpr*) v)->getOperand(0));
makeAlias(vdv, got);
} else {
unsigned opcode = ((ConstantExpr*) v)->getOpcode();
switch (opcode) {
case 23: // BinaryConstantExpr "and"
case 24: // BinaryConstantExpr "or"
{
// do nothing
}
break;
default:
{
errs() << "ERROR when handle the following constant expression\n";
errs() << *v << "\n";
errs() << ((ConstantExpr*) v)->getOpcode() << "\n";
errs() << ((ConstantExpr*) v)->getOpcodeName() << "\n";
errs().flush();
exit(-1);
}
break;
}
}
} else if (isa<ConstantArray>(v)) {
#ifndef ARRAY_SIMPLIFIED
DyckVertex* ptr = addPtrTo(NULL, vdv, dgraph);
DyckVertex* current = ptr;
Constant * vAgg = (Constant*) v;
int numElmt = vAgg->getNumOperands();
for (int i = 0; i < numElmt; i++) {
Value * vi = vAgg->getOperand(i);
DyckVertex* viptr = addPtrOffset(current, i * dl.getTypeAllocSize(vi->getType()), dgraph);
addPtrTo(viptr, wrapValue(vi, dgraph, dl), dgraph);
}
#else
Constant * vAgg = (Constant*) v;
int numElmt = vAgg->getNumOperands();
for (int i = 0; i < numElmt; i++) {
Value * vi = vAgg->getOperand(i);
makeAlias(vdv, wrapValue(vi));
}
#endif
} else if (isa<ConstantStruct>(v)) {
//DyckVertex* ptr = addPtrTo(NULL, vdv);
//DyckVertex* current = ptr;
Constant * vAgg = (Constant*) v;
int numElmt = vAgg->getNumOperands();
for (int i = 0; i < numElmt; i++) {
Value * vi = vAgg->getOperand(i);
addField(vdv, -2 - i, wrapValue(vi));
}
} else if (isa<GlobalValue>(v)) {
if (isa<GlobalVariable>(v)) {
GlobalVariable * global = (GlobalVariable *) v;
if (global->hasInitializer()) {
Value * initializer = global->getInitializer();
if (!isa<UndefValue>(initializer)) {
DyckVertex * initVer = wrapValue(initializer);
addPtrTo(vdv, initVer);
}
}
} else if (isa<GlobalAlias>(v)) {
GlobalAlias * global = (GlobalAlias *) v;
Value * aliasee = global->getAliasee();
makeAlias(vdv, wrapValue(aliasee));
} else if (isa<Function>(v)) {
// do nothing
} // no else
} else if (isa<ConstantInt>(v) || isa<ConstantFP>(v) || isa<ConstantPointerNull>(v) || isa<UndefValue>(v)) {
// do nothing
} else if (isa<ConstantDataArray>(v) || isa<ConstantAggregateZero>(v)) {
// do nothing
} else if (isa<BlockAddress>(v)) {
// do nothing
} else if (isa<ConstantDataVector>(v)) {
errs() << "ERROR when handle the following ConstantDataSequential, ConstantDataVector\n";
errs() << *v << "\n";
errs().flush();
exit(-1);
} else if (isa<ConstantVector>(v)) {
errs() << "ERROR when handle the following ConstantVector\n";
errs() << *v << "\n";
errs().flush();
exit(-1);
} else if (isa<Constant>(v)) {
errs() << "ERROR when handle the following constant value\n";
errs() << *v << "\n";
errs().flush();
exit(-1);
}
return vdv;
}
DyckVertex* AAAnalyzer::handle_gep(GEPOperator* gep) {
Value * ptr = gep->getPointerOperand();
DyckVertex* current = wrapValue(ptr);
gep_type_iterator preGTI = gep_type_begin(gep); // preGTI is the PointerTy of ptr
gep_type_iterator GTI = gep_type_begin(gep); // GTI is the PointerTy of ptr
if (GTI != gep_type_end(gep))
GTI++; // ptr's element type, e.g. struct
int num_indices = gep->getNumIndices();
int idxidx = 0;
while (idxidx < num_indices) {
Value * idx = gep->getOperand(++idxidx);
if (/*!isa<ConstantInt>(idx) ||*/ !GTI->isSized()) {
// current->addProperty("unknown-offset", (void*) 1);
break;
}
if ((*preGTI)->isStructTy()) {
// example: gep y 0 constIdx
// s1: y--deref-->?1--(-2-constIdx)-->?2
DyckVertex* theStruct = this->addPtrTo(current, NULL);
ConstantInt * ci = cast<ConstantInt>(idx);
if (ci == NULL) {
errs() << ("ERROR: when dealing with gep: \n");
errs() << *gep << "\n";
exit(1);
}
// field index need not be the same as original value
// make it be a negative integer
long fieldIdx = (long) (*(ci->getValue().getRawData()));
DyckVertex* field = this->addField(theStruct, -2 - fieldIdx, NULL);
// s2: ?3--deref-->?2
DyckVertex* fieldPtr = this->addPtrTo(NULL, field);
/// the label representation and feature impl is temporal. @FIXME
// s3: y--2-->?3
current->getRepresentative()->addTarget(fieldPtr->getRepresentative(), (void*) (fieldIdx));
// update current
current = fieldPtr;
} else if ((*preGTI)->isPointerTy() || (*preGTI)->isArrayTy()) {
#ifndef ARRAY_SIMPLIFIED
current = addPtrOffset(current, getConstantIntRawData(cast<ConstantInt>(idx)) * dl.getTypeAllocSize(*GTI), dgraph);
#endif
} else {
errs() << "ERROR in handle_gep: unknown type:\n";
errs() << "Type Id: " << (*preGTI)->getTypeID() << "\n";
exit(1);
}
if (GTI != gep_type_end(gep))
GTI++;
if (preGTI != gep_type_end(gep))
preGTI++;
}
return current;
}
void AAAnalyzer::handle_common_function_call(Call* c, FunctionWrapper* caller, FunctionWrapper* callee) {
//landingpad<->resume
if (c->ret != NULL) {
Value* lpd = caller->getLandingPad(c->ret);
if (lpd != NULL) {
DyckVertex* lpdVertex = wrapValue(lpd);
set<Value*>& res = callee->getResumes();
set<Value*>::iterator resIt = res.begin();
while (resIt != res.end()) {
makeAlias(wrapValue(*resIt), lpdVertex);
resIt++;
}
}
}
//return<->call
set<Value*>& rets = callee->getReturns();
if (c->ret != NULL) {
set<Value*>::iterator retIt = rets.begin();
while (retIt != rets.end()) {
makeAlias(wrapValue(*retIt), wrapValue(c->ret));
retIt++;
}
}
// parameter<->arg
unsigned int numOfArgOp = c->args.size();
unsigned argIdx = 0;
Function * func = callee->getLLVMFunction();
if (!func->isIntrinsic()) {
vector<Value*>& parameters = callee->getArgs();
vector<Value*>::iterator pit = parameters.begin();
while (pit != parameters.end()) {
if (numOfArgOp <= argIdx) {
errs() << "Warning the number of args is less than that of parameters\n";
errs() << func->getName() << "\n";
errs() << *(c->ret) << "\n";
break; //exit(-1);
}
Value * arg = c->args[argIdx];
Value * par = *pit;
makeAlias(wrapValue(par), wrapValue(arg));
argIdx++;
pit++;
}
if (func->isVarArg()) {
vector<Value*>& va_parameters = callee->getVAArgs();
for (unsigned int i = argIdx; i < numOfArgOp; i++) {
Value * arg = c->args[i];
DyckVertex* arg_v = wrapValue(arg);
vector<Value*>::iterator va_par_it = va_parameters.begin();
while (va_par_it != va_parameters.end()) {
Value* va_par = *va_par_it;
makeAlias(arg_v, wrapValue(va_par));
va_par_it++;
}
}
}
} else {
errs() << "ERROR in handle_common_function_call(...):\n";
errs() << func->getName() << " can not be an intrinsic.\n";
exit(-1);
}
}