1 #include <magic/support/MagicUtil.h>
2 
3 using namespace llvm;
4 
5 namespace llvm {
6 
7 //===----------------------------------------------------------------------===//
8 // Public static methods
9 //===----------------------------------------------------------------------===//
10 
11 static std::map<const std::string, GlobalVariable*> stringRefCache;
12 
13 unsigned getLabelHash(std::string label) {
14     unsigned hash = 0;
15     for(unsigned i=0;i<label.length();i++){
16         hash ^= (label[i]);
17         hash = (hash << 9) | (hash >> ((sizeof(unsigned)*8)-9));
18     }
19     return hash;
20 }
21 
22 unsigned getModuleHash(DIDescriptor DID, const std::string &baseDir, StringRef extraField="") {
23     std::string relPath;
24     PassUtil::getDbgLocationInfo(DID, baseDir, NULL, NULL, &relPath);
25     return getLabelHash(relPath + "/" + extraField.data());
26 }
27 
28 StringRef MagicUtil::getGVSourceName(Module &M, GlobalVariable *GV, DIGlobalVariable **DIGVP, const std::string &baseDir) {
29     static DIGlobalVariable Var;
30     MDNode *DIGV = PassUtil::findDbgGlobalDeclare(GV);
31     if(DIGV) {
32         Var = DIGlobalVariable(DIGV);
33         if(DIGVP) *DIGVP = &Var;
34         if(GV->getLinkage() == GlobalValue::InternalLinkage){
35             /* static variable */
36             StringRef funcName, countStr;
37             DIScope scope = Var.getContext();
38             if(scope.isLexicalBlock()){
39                 /* find the subprogram that contains this basic block recursively */
40                 while(!scope.isSubprogram()){
41                     scope = DILexicalBlock(scope).getContext();
42                 }
43             }
44             if(scope.isSubprogram()){
45                 /* static function variable */
46 
47                 funcName = DISubprogram(scope).getName();
48 
49                 int count=0;
50                 Module::GlobalListType &globalList = M.getGlobalList();
51                 for (Module::global_iterator it = globalList.begin(); it != globalList.end(); ++it) {
52                     GlobalVariable *OtherGV = &(*it);
53                     MDNode *OtherDIGV = PassUtil::findDbgGlobalDeclare(OtherGV);
54                     if(OtherDIGV) {
55                         DIGlobalVariable OtherVar(OtherDIGV);
56 
57                         DIScope otherScope = OtherVar.getContext();
58                         if(otherScope.isLexicalBlock()){
59                             /* find the subprogram that contains this basic block recursively */
60                             while(!otherScope.isSubprogram()){
61                                 otherScope = DILexicalBlock(otherScope).getContext();
62                             }
63                         }
64                         if(otherScope.isSubprogram()){
65                             if(!strcmp(Var.getName().data(), OtherVar.getName().data())){
66                                 if(DIGV == OtherDIGV){
67                                     break;
68                                 }
69                                 count++;
70                             }
71                         }
72                     }
73                 }
74 
75                 std::stringstream stm;
76                 if(count > 0){
77                     stm << "." << count;
78                 }
79                 countStr = StringRef(*new std::string(stm.str()));
80 
81             }else{
82                 /* static global variable */
83                 funcName = "";
84                 countStr = "";
85             }
86 
87             std::stringstream stm;
88             stm << Var.getName().data() << "." << getModuleHash(Var, baseDir, funcName) << countStr.data();
89             return StringRef(*new std::string(stm.str()));
90 
91         }else{
92             /* global variable */
93             return Var.getName();
94         }
95     }else{
96         /* llvm .str variables and assembly */
97         if(DIGVP) *DIGVP = NULL;
98         return GV->getName();
99     }
100 }
101 
102 StringRef MagicUtil::getLVSourceName(Module &M, AllocaInst *V, DIVariable **DIVP) {
103     static DIVariable Var;
104     const DbgDeclareInst *DDI = FindAllocaDbgDeclare(V);
105     if(DDI && DDI != (const DbgDeclareInst *) -1){
106         Var = DIVariable(cast<MDNode>(DDI->getVariable()));
107         if(DIVP) *DIVP = &Var;
108 
109         int count = 0;
110 
111         Function *F = V->getParent()->getParent();
112         for (inst_iterator it = inst_begin(F), et = inst_end(F); it != et; ++it) {
113             Instruction *inst = &(*it);
114             if (DbgDeclareInst *OtherDDI = dyn_cast<DbgDeclareInst>(inst)){
115                 DIVariable otherVar(cast<MDNode>(OtherDDI->getVariable()));
116                 if(!strcmp(Var.getName().data(), otherVar.getName().data())){
117                     if(OtherDDI == DDI){
118                         break;
119                     }
120                     count++;
121                 }
122             }
123         }
124 
125         std::stringstream stm;
126         stm << Var.getName().data();
127         if(count > 0){
128             stm << "." << count;
129         }
130         return StringRef(*new std::string(stm.str()));
131     }else{
132         if(DIVP) *DIVP = NULL;
133         return V->getName();
134     }
135 }
136 
137 StringRef MagicUtil::getFunctionSourceName(Module &M, Function *F, DISubprogram **DISP, const std::string &baseDir) {
138     static DISubprogram Func;
139     MDNode *DIF = PassUtil::findDbgSubprogramDeclare(F);
140     if(DIF) {
141         Func = DISubprogram(DIF);
142         if(DISP) *DISP = &Func;
143         if(F->getLinkage() == GlobalValue::InternalLinkage){
144             std::stringstream stm;
145             stm << Func.getName().data() << "." << getModuleHash(Func, baseDir);
146             return StringRef(*new std::string(stm.str()));
147         }else{
148             return Func.getName();
149         }
150     }else{
151         /* assembly */
152         if(DISP) *DISP = NULL;
153         return F->getName();
154     }
155 }
156 
157 void MagicUtil::putStringRefCache(Module &M, const std::string &str, GlobalVariable *GV) {
158     std::map<const std::string, GlobalVariable*>::iterator it;
159     it = stringRefCache.find(str);
160     if(it == stringRefCache.end()) {
161         stringRefCache.insert(std::pair<const std::string, GlobalVariable*>(str, GV));
162     }
163 }
164 
165 Constant* MagicUtil::getGetElementPtrConstant(Constant *constant, std::vector<Value*> &indexes) {
166     return PassUtil::getGetElementPtrConstant(constant, indexes);
167 }
168 
169 GetElementPtrInst* MagicUtil::createGetElementPtrInstruction(Value *ptr, std::vector<Value*> &indexes, const Twine &NameStr, Instruction *InsertBefore) {
170     return PassUtil::createGetElementPtrInstruction(ptr, indexes, NameStr, InsertBefore);
171 }
172 
173 GetElementPtrInst* MagicUtil::createGetElementPtrInstruction(Value *ptr, std::vector<Value*> &indexes, const Twine &NameStr, BasicBlock *InsertAtEnd) {
174     return PassUtil::createGetElementPtrInstruction(ptr, indexes, NameStr, InsertAtEnd);
175 }
176 
177 CallInst* MagicUtil::createCallInstruction(Value *F, std::vector<Value*> &args, const Twine &NameStr, Instruction *InsertBefore) {
178     return PassUtil::createCallInstruction(F, args, NameStr, InsertBefore);
179 }
180 
181 CallInst* MagicUtil::createCallInstruction(Value *F, std::vector<Value*> &args, const Twine &NameStr, BasicBlock *InsertAtEnd) {
182     return PassUtil::createCallInstruction(F, args, NameStr, InsertAtEnd);
183 }
184 
185 Function* MagicUtil::getIntrinsicFunction(Module &M, Intrinsic::ID id, TYPECONST Type** types, unsigned size) {
186     return PassUtil::getIntrinsicFunction(M, id, types, size);
187 }
188 
189 GlobalVariable *MagicUtil::getStringRef(Module &M, const std::string &str) {
190     std::map<const std::string, GlobalVariable*>::iterator it;
191     GlobalVariable *stringRef = NULL;
192     bool debug = false;
193 
194     it = stringRefCache.find(str);
195     if(it != stringRefCache.end()) {
196         if(debug) magicUtilLog("*** getStringRef: cache hit for " << str);
197         stringRef = it->second;
198     }
199     if(stringRef == NULL) {
200     	stringRef = PassUtil::getStringGlobalVariable(M, str, MAGIC_HIDDEN_STR_PREFIX, MAGIC_STATIC_VARS_SECTION_RO);
201         stringRefCache.insert(std::pair<const std::string, GlobalVariable*>(str, stringRef));
202     }
203 
204      return stringRef;
205  }
206 
207 
208 GlobalVariable *MagicUtil::getIntArrayRef(Module &M, unsigned arrSize, std::vector<int> *arr, bool isConstant) {
209     static std::map<std::vector<int>, GlobalVariable*> arrayRefCache;
210     std::map<std::vector<int>, GlobalVariable*>::iterator it;
211     static std::vector<int> defInitilizer;
212 
213     //construct an appropriate initializer if we do not have one
214     if(!arr) {
215         arr = &defInitilizer;
216         arr->clear();
217         for(unsigned i=0;i<arrSize;i++) arr->push_back(0);
218     }
219     assert(arrSize == arr->size());
220 
221     //cache lookup
222     if(isConstant) {
223         it = arrayRefCache.find(*arr);
224         if(it != arrayRefCache.end()) {
225             return it->second;
226         }
227     }
228 
229     //create a constant internal array reference
230     std::vector<Constant*> arrayElems;
231     for(unsigned i=0;i<arr->size();i++) {
232         arrayElems.push_back(ConstantInt::get(M.getContext(), APInt(32, (*arr)[i], 10)));
233     }
234     ArrayType* arrayTy = ArrayType::get(IntegerType::get(M.getContext(), 32), arr->size());
235     Constant *arrayValue = ConstantArray::get(arrayTy, arrayElems);
236 
237     //create the global variable and record it in the module
238     GlobalVariable *arrayRef = new GlobalVariable(arrayValue->getType(), isConstant,
239         GlobalValue::InternalLinkage, arrayValue,
240         MAGIC_HIDDEN_ARRAY_PREFIX);
241     MagicUtil::setGlobalVariableSection(arrayRef, isConstant ? MAGIC_STATIC_VARS_SECTION_RO : MAGIC_STATIC_VARS_SECTION_DATA);
242     M.getGlobalList().push_back(arrayRef);
243 
244     //populate cache
245     if(isConstant) {
246         arrayRefCache.insert(std::pair<std::vector<int>, GlobalVariable*>(*arr, arrayRef));
247     }
248 
249     return arrayRef;
250 }
251 
252 GlobalVariable *MagicUtil::getStringArrayRef(Module &M, unsigned arrSize, std::vector<std::string> *arr, bool isConstant) {
253     static std::map<std::vector<std::string>, GlobalVariable*> arrayRefCache;
254     std::map<std::vector<std::string>, GlobalVariable*>::iterator it;
255     static std::vector<std::string> defInitilizer;
256     //construct an appropriate initializer if we do not have one
257     if(!arr) {
258         arr = &defInitilizer;
259         arr->clear();
260         for(unsigned i=0;i<arrSize;i++) arr->push_back("");
261     }
262     assert(arrSize == arr->size());
263 
264     //cache lookup
265     if(isConstant) {
266         it = arrayRefCache.find(*arr);
267         if(it != arrayRefCache.end()) {
268             return it->second;
269         }
270     }
271 
272     //create a constant internal array reference
273     std::vector<Constant*> arrayElems;
274     std::vector<Value*> arrayIndexes;
275     arrayIndexes.push_back(ConstantInt::get(M.getContext(), APInt(32, 0, 10)));
276     arrayIndexes.push_back(ConstantInt::get(M.getContext(), APInt(32, 0, 10)));
277     for(unsigned i=0;i<arr->size();i++) {
278         arrayElems.push_back(getGetElementPtrConstant(getStringRef(M, (*arr)[i]), arrayIndexes));
279     }
280     ArrayType* arrayTy = ArrayType::get(PointerType::get(IntegerType::get(M.getContext(), 8), 0), arr->size());
281     Constant *arrayValue = ConstantArray::get(arrayTy, arrayElems);
282 
283     //create the global variable and record it in the module
284     GlobalVariable *arrayRef = new GlobalVariable(arrayValue->getType(), isConstant,
285         GlobalValue::InternalLinkage, arrayValue,
286         MAGIC_HIDDEN_ARRAY_PREFIX);
287     MagicUtil::setGlobalVariableSection(arrayRef, isConstant ? MAGIC_STATIC_VARS_SECTION_RO : MAGIC_STATIC_VARS_SECTION_DATA);
288     M.getGlobalList().push_back(arrayRef);
289 
290     //populate cache
291     if(isConstant) {
292         arrayRefCache.insert(std::pair<std::vector<std::string>, GlobalVariable*>(*arr, arrayRef));
293     }
294 
295     return arrayRef;
296 }
297 
298 GlobalVariable *MagicUtil::getGenericArrayRef(Module &M, std::vector<Constant*> &arrayElems, bool isConstant) {
299     static std::map<std::vector<Constant*>, GlobalVariable*> arrayRefCache;
300     std::map<std::vector<Constant*>, GlobalVariable*>::iterator it;
301     assert(arrayElems.size() > 0);
302 
303     //cache lookup
304     if(isConstant) {
305         it = arrayRefCache.find(arrayElems);
306         if(it != arrayRefCache.end()) {
307             return it->second;
308         }
309     }
310 
311     //create a constant internal array reference
312     ArrayType* arrayTy = ArrayType::get(arrayElems[0]->getType(), arrayElems.size());
313     Constant *arrayValue = ConstantArray::get(arrayTy, arrayElems);
314 
315     //create the global variable and record it in the module
316     GlobalVariable *arrayRef = new GlobalVariable(arrayValue->getType(), isConstant,
317         GlobalValue::InternalLinkage, arrayValue,
318         MAGIC_HIDDEN_ARRAY_PREFIX);
319     MagicUtil::setGlobalVariableSection(arrayRef, isConstant ? MAGIC_STATIC_VARS_SECTION_RO : MAGIC_STATIC_VARS_SECTION_DATA);
320     M.getGlobalList().push_back(arrayRef);
321 
322     //populate cache
323     if(isConstant) {
324         arrayRefCache.insert(std::pair<std::vector<Constant*>, GlobalVariable*>(arrayElems, arrayRef));
325     }
326 
327     return arrayRef;
328 }
329 
330 GlobalVariable *MagicUtil::getMagicTypePtrArrayRef(Module &M, Instruction *InsertBefore, std::vector<Value*> &globalTypeIndexes, GlobalVariable *magicTypeArray) {
331     int numTypeIndexes = globalTypeIndexes.size();
332     TYPECONST StructType* magicTypeStructTy = (TYPECONST StructType*) ((TYPECONST ArrayType*)magicTypeArray->getType()->getElementType())->getElementType();
333     ArrayType* typeIndexesArrTy = ArrayType::get(PointerType::get(magicTypeStructTy, 0), numTypeIndexes+1);
334     std::vector<Constant*> arrayElems;
335     for(int i=0;i<numTypeIndexes;i++) {
336         std::vector<Value*> magicTypeArrayIndexes;
337         magicTypeArrayIndexes.clear();
338         magicTypeArrayIndexes.push_back(ConstantInt::get(M.getContext(), APInt(64, 0, 10)));
339         magicTypeArrayIndexes.push_back(globalTypeIndexes[i]);
340         Constant* typePtr = getGetElementPtrConstant(magicTypeArray, magicTypeArrayIndexes);
341         arrayElems.push_back(typePtr);
342     }
343     arrayElems.push_back(ConstantPointerNull::get(PointerType::get(magicTypeStructTy, 0))); //NULL-terminated array
344 
345     //create the global variable and record it in the module
346     Constant *arrayValue = ConstantArray::get(typeIndexesArrTy, arrayElems);
347     GlobalVariable *arrayRef = new GlobalVariable(arrayValue->getType(), true,
348         GlobalValue::InternalLinkage, arrayValue,
349         MAGIC_HIDDEN_ARRAY_PREFIX);
350     MagicUtil::setGlobalVariableSection(arrayRef, MAGIC_STATIC_VARS_SECTION_RO);
351     M.getGlobalList().push_back(arrayRef);
352 
353     return arrayRef;
354 }
355 
356 GlobalVariable* MagicUtil::getExportedIntGlobalVar(Module &M, std::string name, int value, bool isConstant) {
357     Constant *intValue = ConstantInt::get(M.getContext(), APInt(32, value, 10));
358 
359     //create the global variable and record it in the module
360     GlobalVariable *GV = new GlobalVariable(intValue->getType(), isConstant,
361         GlobalValue::LinkOnceAnyLinkage, intValue, name);
362     MagicUtil::setGlobalVariableSection(GV, isConstant ? MAGIC_STATIC_VARS_SECTION_RO : MAGIC_STATIC_VARS_SECTION_DATA);
363     M.getGlobalList().push_back(GV);
364 
365     return GV;
366 }
367 
368 GlobalVariable* MagicUtil::getShadowRef(Module &M, GlobalVariable *GV) {
369     //create the shadow global variable and record it in the module
370     TYPECONST Type* type = GV->getType()->getElementType();
371     GlobalVariable *SGV = new GlobalVariable(type, GV->isConstant(),
372                                           GlobalValue::InternalLinkage, 0,
373                                           MAGIC_SHADOW_VAR_PREFIX + GV->getName());
374     SGV->setInitializer(Constant::getNullValue(type));
375     MagicUtil::setGlobalVariableSection(SGV, GV->isConstant() ? MAGIC_SHADOW_VARS_SECTION_RO : MAGIC_SHADOW_VARS_SECTION_DATA);
376     M.getGlobalList().push_back(SGV);
377 
378     if(!GV->hasInitializer()) {
379         magicUtilLog("Shadowing for extern variable: " << GV->getName());
380     }
381     if(GV->isConstant()) {
382         magicUtilLog("Shadowing for constant variable: " << GV->getName());
383     }
384 
385     return SGV;
386 }
387 
388 Value* MagicUtil::getMagicStructFieldPtr(Module &M, Instruction *InsertBefore, GlobalVariable* var, Value* arrayIndex, const std::string &structFieldName, std::string *structFieldNames) {
389     //lookup field index
390     int structFieldIndex;
391     Value *varPtr;
392     for(structFieldIndex=0; structFieldName.compare(structFieldNames[structFieldIndex]) != 0; structFieldIndex++) {}
393 
394     if(arrayIndex) {
395         //get array ptr
396         std::vector<Value*> arrayIndexes;
397         arrayIndexes.push_back(ConstantInt::get(M.getContext(), APInt(64, 0, 10)));
398         arrayIndexes.push_back(arrayIndex);
399         varPtr = createGetElementPtrInstruction(var, arrayIndexes, "", InsertBefore);
400     }
401     else {
402     	varPtr = var;
403     }
404 
405     //get struct field ptr
406     std::vector<Value*> structFieldIndexes;
407     structFieldIndexes.push_back(ConstantInt::get(M.getContext(), APInt(32, 0, 10)));
408     structFieldIndexes.push_back(ConstantInt::get(M.getContext(), APInt(32, structFieldIndex, 10)));
409     Instruction* structFieldPtr = createGetElementPtrInstruction(varPtr, structFieldIndexes, "", InsertBefore);
410 
411     return structFieldPtr;
412 }
413 
414 Value* MagicUtil::getMagicSStructFieldPtr(Module &M, Instruction *InsertBefore, GlobalVariable* magicArray, Value* magicArrayIndex, const std::string &structFieldName) {
415     static std::string structFieldNames[] = { MAGIC_SSTRUCT_FIELDS };
416     return getMagicStructFieldPtr(M, InsertBefore, magicArray, magicArrayIndex, structFieldName, structFieldNames);
417 }
418 
419 Value* MagicUtil::getMagicTStructFieldPtr(Module &M, Instruction *InsertBefore, GlobalVariable* magicTypeArray, Value* magicTypeArrayIndex, const std::string &structFieldName) {
420     static std::string structFieldNames[] = { MAGIC_TSTRUCT_FIELDS };
421     return getMagicStructFieldPtr(M, InsertBefore, magicTypeArray, magicTypeArrayIndex, structFieldName, structFieldNames);
422 }
423 
424 Value* MagicUtil::getMagicFStructFieldPtr(Module &M, Instruction *InsertBefore, GlobalVariable* magicFunctionArray, Value* magicFunctionArrayIndex, const std::string &structFieldName) {
425     static std::string structFieldNames[] = { MAGIC_FSTRUCT_FIELDS };
426     return getMagicStructFieldPtr(M, InsertBefore, magicFunctionArray, magicFunctionArrayIndex, structFieldName, structFieldNames);
427 }
428 
429 Value* MagicUtil::getMagicRStructFieldPtr(Module &M, Instruction *InsertBefore, GlobalVariable* magicVar, const std::string &structFieldName) {
430     static std::string structFieldNames[] = { MAGIC_RSTRUCT_FIELDS };
431     return getMagicStructFieldPtr(M, InsertBefore, magicVar, NULL, structFieldName, structFieldNames);
432 }
433 
434 Value* MagicUtil::getMagicDStructFieldPtr(Module &M, Instruction *InsertBefore, GlobalVariable* magicDsindexArray, Value* magicDsindexArrayIndex, const std::string &structFieldName) {
435     static std::string structFieldNames[] = { MAGIC_DSTRUCT_FIELDS };
436     return getMagicStructFieldPtr(M, InsertBefore, magicDsindexArray, magicDsindexArrayIndex, structFieldName, structFieldNames);
437 }
438 
439 Constant* MagicUtil::getArrayPtr(Module &M, GlobalVariable* array) {
440     //indexes for array
441     static std::vector<Value*> arrayIndexes;
442     if(arrayIndexes.empty()) {
443         arrayIndexes.push_back(ConstantInt::get(M.getContext(), APInt(64, 0, 10))); //pointer to A[]
444         arrayIndexes.push_back(ConstantInt::get(M.getContext(), APInt(64, 0, 10))); //pointer to A[0]
445     }
446 
447     //get array ptr
448     Constant* arrayPtr = getGetElementPtrConstant(array, arrayIndexes);
449 
450     return arrayPtr;
451 }
452 
453 void MagicUtil::insertMemcpyInst(Module &M, Instruction *InsertBefore, Value *Dst, Value *Src, Value *Len, unsigned Align) {
454     bool useMemCpyIntrinsics = false;
455     Function *MemCpy = M.getFunction("memcpy");
456     if(!MemCpy) {
457         TYPECONST Type *ArgTys[1] = { IntegerType::getInt32Ty(M.getContext()) };
458         MemCpy = getIntrinsicFunction(M, Intrinsic::memcpy, ArgTys, 1);
459         useMemCpyIntrinsics = true;
460     }
461     else {
462         MemCpy = (Function*) M.getOrInsertFunction(MAGIC_MEMCPY_FUNC_NAME, MemCpy->getFunctionType());
463     }
464 
465     // Insert the memcpy instruction
466     std::vector<Value*> MemCpyArgs;
467     MemCpyArgs.push_back(Dst);
468     MemCpyArgs.push_back(Src);
469     MemCpyArgs.push_back(Len);
470     if(useMemCpyIntrinsics) {
471         MemCpyArgs.push_back(ConstantInt::get(M.getContext(), APInt(32, Align, 10)));
472     }
473     createCallInstruction(MemCpy, MemCpyArgs, "", InsertBefore);
474 }
475 
476 void MagicUtil::insertCopyInst(Module &M, Instruction *InsertBefore, GlobalVariable *GV, GlobalVariable *SGV, int GVSize, bool forceMemcpy) {
477     //get type and type size
478     TYPECONST Type *GVType = GV->getType()->getElementType();
479     bool isPrimitiveOrPointerType = !GVType->isAggregateType();
480 
481     //no need for memcpy for primitive types or pointer types
482     if(isPrimitiveOrPointerType && !forceMemcpy) {
483         LoadInst* primitiveValue = new LoadInst(GV, "", false, InsertBefore);
484         new StoreInst(primitiveValue, SGV, false, InsertBefore);
485         return;
486     }
487 
488     //cast pointers to match memcpy prototype
489     PointerType* voidPointerType = PointerType::get(IntegerType::get(M.getContext(), 8), 0);
490     Constant* varAddress = ConstantExpr::getCast(Instruction::BitCast, GV, voidPointerType);
491     Constant* varShadowAddress = ConstantExpr::getCast(Instruction::BitCast, SGV, voidPointerType);
492 
493     //insert the memcpy instruction
494     MagicUtil::insertMemcpyInst(M, InsertBefore, varShadowAddress, varAddress, ConstantInt::get(M.getContext(), APInt(32, GVSize, 10)), 0);
495 }
496 
497 Function* MagicUtil::getCalledFunctionFromCS(const CallSite &CS) {
498     assert(CS.getInstruction());
499     Function *function = CS.getCalledFunction();
500     if(function) {
501         return function;
502     }
503 
504     //handle the weird case of bitcasted function call
505     //IMPORTANT! function may still be null, if it's an indirect call
506     ConstantExpr *CE = dyn_cast<ConstantExpr>(CS.getCalledValue());
507     if (CE) {
508         assert(CE->getOpcode() == Instruction::BitCast && "Bitcast expected, something else found!");
509         function = dyn_cast<Function>(CE->getOperand(0));
510         assert(function);
511     } else {
512         errs() << "Warning! Indirect call encountered!\n";
513     }
514 
515     return function;
516 }
517 
518 void MagicUtil::replaceCallInst(Instruction *originalInst, CallInst *newInst, int argOffset, bool removeUnusedFunction) {
519     SmallVector< std::pair< unsigned, MDNode * >, 8> MDs;
520     originalInst->getAllMetadata(MDs);
521     for(unsigned i=0;i<MDs.size();i++) {
522         newInst->setMetadata(MDs[i].first, MDs[i].second);
523     }
524     CallSite CS = MagicUtil::getCallSiteFromInstruction(originalInst);
525     assert(CS);
526     CallingConv::ID CC = CS.getCallingConv();
527     Function *originalFunction = getCalledFunctionFromCS(CS);
528     newInst->setCallingConv(CC);
529     ATTRIBUTE_SET_TY NewAttrs = PassUtil::remapCallSiteAttributes(CS, argOffset);
530     newInst->setAttributes(NewAttrs);
531 
532     originalInst->replaceAllUsesWith(newInst);
533 
534     // If the old instruction was an invoke, add an unconditional branch
535     // before the invoke, which will become the new terminator.
536     if (InvokeInst *II = dyn_cast<InvokeInst>(originalInst))
537       BranchInst::Create(II->getNormalDest(), originalInst);
538 
539     // Delete the old call site
540     originalInst->eraseFromParent();
541 
542     // When asked, remove the original function when nobody uses it any more.
543     if(removeUnusedFunction && originalFunction->use_empty()) {
544         originalFunction->eraseFromParent();
545     }
546 }
547 
548 std::vector<Function*> MagicUtil::getGlobalVariablesShadowFunctions(Module &M, std::vector<GlobalVariable*> globalVariables, std::vector<GlobalVariable*> shadowGlobalVariables, std::vector<int> globalVariableSizes, GlobalVariable* magicArray, int magicArraySize, bool forceShadow, bool setDirtyFlag) {
549     std::vector<Function*> globalVariableShadowFunctions;
550     for(int i=0;i<magicArraySize;i++) {
551         Function* func = getGlobalVariableShadowFunction(M, globalVariables[i], shadowGlobalVariables[i], globalVariableSizes[i], magicArray, i, forceShadow, setDirtyFlag);
552         globalVariableShadowFunctions.push_back(func);
553     }
554 
555     return globalVariableShadowFunctions;
556 }
557 
558 Function* MagicUtil::getGlobalVariableShadowFunction(Module &M, GlobalVariable* GV, GlobalVariable* SGV, int GVSize, GlobalVariable* magicArray, int magicArrayIndex, bool forceShadow, bool setDirtyFlag) {
559     static Constant* magicStateDirty = ConstantInt::get(M.getContext(), APInt(32, MAGIC_STATE_DIRTY, 10));
560     static Function* shadowFunc = NULL;
561     ConstantInt* magicArrayIndexConst = ConstantInt::get(M.getContext(), APInt(32, magicArrayIndex, 10));
562 
563     //determine name
564     std::string name(MAGIC_SHADOW_FUNC_PREFIX);
565     name.append("_");
566     if(forceShadow) {
567         name.append("force_");
568     }
569     if(setDirtyFlag) {
570         name.append("setdf_");
571     }
572     name.append(GV->getName());
573 
574     //create function
575     std::vector<TYPECONST Type*>shadowFuncArgs;
576     FunctionType* shadowFuncType = FunctionType::get(Type::getVoidTy(M.getContext()), shadowFuncArgs, false);
577     shadowFunc = Function::Create(shadowFuncType, GlobalValue::InternalLinkage, name, &M);
578     shadowFunc->setCallingConv(CallingConv::C);
579 
580     //create blocks
581     BasicBlock* label_entry = BasicBlock::Create(M.getContext(), "entry",shadowFunc,0);
582     BasicBlock* label_shadow = BasicBlock::Create(M.getContext(), "shadow",shadowFunc,0);
583     BasicBlock* label_return = BasicBlock::Create(M.getContext(), "return",shadowFunc,0);
584     BranchInst::Create(label_shadow, label_entry);
585     BranchInst::Create(label_return, label_shadow);
586     Instruction* entryTerm = label_entry->getTerminator();
587     Instruction* shadowTerm = label_shadow->getTerminator();
588 
589     if(!forceShadow || setDirtyFlag) {
590         //get flags
591         Value* structFlagsField = MagicUtil::getMagicSStructFieldPtr(M, entryTerm, magicArray, magicArrayIndexConst, MAGIC_SSTRUCT_FIELD_FLAGS);
592         LoadInst* varFlags = new LoadInst(structFlagsField, "", false, entryTerm);
593 
594         //when not forcing, don't shadow if dirty is already set
595         if(!forceShadow) {
596             BinaryOperator* andedVarFlags = BinaryOperator::Create(Instruction::And, varFlags, magicStateDirty, "", entryTerm);
597             ICmpInst* flagsCmp = new ICmpInst(entryTerm, ICmpInst::ICMP_EQ, andedVarFlags, ConstantInt::get(M.getContext(), APInt(32, 0, 10)), "");
598             BranchInst::Create(label_shadow, label_return, flagsCmp, entryTerm);
599             entryTerm->eraseFromParent();
600         }
601 
602         //set the dirty flag for the variable
603         if(setDirtyFlag) {
604             BinaryOperator* oredVarFlags = BinaryOperator::Create(Instruction::Or, varFlags, magicStateDirty, "", shadowTerm);
605             new StoreInst(oredVarFlags, structFlagsField, false, shadowTerm);
606         }
607     }
608 
609     //perform a memory copy from the original variable to the shadow variable
610     MagicUtil::insertCopyInst(M, shadowTerm, GV, SGV, GVSize, /* forceMemcpy */ false);
611 
612     ReturnInst::Create(M.getContext(), label_return);
613 
614     return shadowFunc;
615 }
616 
617 void MagicUtil::insertGlobalVariableCleanDirtyFlag(Module &M, GlobalVariable* GV, GlobalVariable* magicArray, int magicArrayIndex, Instruction *InsertBefore) {
618     Value* structFlagsField = MagicUtil::getMagicSStructFieldPtr(M, InsertBefore, magicArray, ConstantInt::get(M.getContext(), APInt(32, magicArrayIndex, 10)), MAGIC_SSTRUCT_FIELD_FLAGS);
619     new StoreInst(ConstantInt::get(M.getContext(), APInt(32, 0, 10)), structFlagsField, false, InsertBefore);
620 }
621 
622 void MagicUtil::insertShadowTag(Module &M, GlobalVariable *GV, Instruction *InsertBefore) {
623     static Function* shadowFunc = NULL;
624     PointerType* voidPointerType = PointerType::get(IntegerType::get(M.getContext(), 8), 0);
625 
626     //create function
627     if(!shadowFunc) {
628             std::vector<TYPECONST Type*>shadowFuncArgs;
629             shadowFuncArgs.push_back(voidPointerType);
630             FunctionType* shadowFuncType = FunctionType::get(Type::getVoidTy(M.getContext()), shadowFuncArgs, false);
631             shadowFunc = Function::Create(shadowFuncType, GlobalValue::ExternalLinkage, MAGIC_LAZY_CHECKPOINT_SHADOW_TAG, &M);
632             shadowFunc->setCallingConv(CallingConv::C);
633     }
634 
635     //shadow global variable
636     std::vector<Value*> args;
637     args.push_back(new BitCastInst(GV, voidPointerType, "", InsertBefore));
638     CallInst *callInst = createCallInstruction(shadowFunc, args, "", InsertBefore);
639     callInst->setCallingConv(CallingConv::C);
640 }
641 
642 bool MagicUtil::isShadowTag(Instruction *inst) {
643     if(dyn_cast<CallInst>(inst)) {
644             CallInst *callInst = dyn_cast<CallInst>(inst);
645             Function *function = callInst->getCalledFunction();
646             if(function == NULL) {
647                     return false;
648             }
649             std::string funcName = function->getName();
650             if(!funcName.compare(MAGIC_LAZY_CHECKPOINT_SHADOW_TAG)) {
651                     return true;
652             }
653     }
654     return false;
655 }
656 
657 GlobalVariable* MagicUtil::getGlobalVariableFromShadowTag(Instruction *inst, std::vector<Instruction*> &instructionsToRemove) {
658     CallSite CS = MagicUtil::getCallSiteFromInstruction(inst);
659     assert(CS.arg_size() == 1);
660     instructionsToRemove.push_back(inst);
661     CallSite::arg_iterator AI = CS.arg_begin();
662     Value *ActualArg = *AI;
663 
664     while(true) {
665         BitCastInst *castInst = dyn_cast<BitCastInst>(ActualArg);
666         ConstantExpr *castExpr = dyn_cast<ConstantExpr>(ActualArg);
667         if(castInst) {
668             assert(castInst->getNumOperands() == 1);
669             ActualArg = castInst->getOperand(0);
670             instructionsToRemove.push_back(castInst);
671         }
672         else if(castExpr) {
673             //assert(castExpr->getNumOperands() == 1);
674             ActualArg = castExpr->getOperand(0);
675         }
676         else {
677             break;
678         }
679     }
680 
681     GlobalVariable *GV = dyn_cast<GlobalVariable>(ActualArg);
682     if(GV == NULL) {
683         magicUtilLog("Weird ActualArg: " << *ActualArg);
684     }
685     assert(GV != NULL);
686 
687     return GV;
688 }
689 
690 void MagicUtil::cleanupShadowTag(Module &M, std::vector<Instruction*> &instructionsToRemove) {
691     int i=0;
692 
693     for(i =0;i<(int)instructionsToRemove.size();i++) {
694         Instruction *inst = instructionsToRemove[i];
695         inst->eraseFromParent();
696     }
697     Function* func = M.getFunction(MAGIC_LAZY_CHECKPOINT_SHADOW_TAG);
698     if(func && func->getNumUses() == 0) {
699         func->eraseFromParent();
700     }
701 }
702 
703 bool MagicUtil::hasAddressTaken(const GlobalValue *GV, bool includeMembers) {
704   //Most of the code taken from LLVM's SCCP.cpp
705 
706   // Delete any dead constantexpr klingons.
707   GV->removeDeadConstantUsers();
708 
709   std::vector<const User*> sourceUsers;
710   sourceUsers.push_back(GV);
711   if(includeMembers && isa<GlobalVariable>(GV)) {
712       for (const Use &UI : GV->uses()) {
713           const User *U = UI.getUser();
714           const ConstantExpr *constantExpr = dyn_cast<ConstantExpr>(U);
715           if(isa<GetElementPtrInst>(U)) {
716               sourceUsers.push_back(U);
717           }
718           else if(constantExpr && constantExpr->getOpcode() == Instruction::GetElementPtr) {
719               sourceUsers.push_back(U);
720           }
721       }
722   }
723 
724   for(unsigned i=0;i<sourceUsers.size();i++) {
725       for (const Use &UI : sourceUsers[i]->uses()) {
726         const User *U = UI.getUser();
727         if (const StoreInst *SI = dyn_cast<StoreInst>(U)) {
728           if (SI->getOperand(0) == sourceUsers[i] || SI->isVolatile())
729             return true;  // Storing addr of sourceUsers[i].
730         } else if (isa<InvokeInst>(U) || isa<CallInst>(U)) {
731           // Make sure we are calling the function, not passing the address.
732           ImmutableCallSite CS(cast<Instruction>(U));
733           if (!CS.isCallee(&UI))
734             return true;
735         } else if (const LoadInst *LI = dyn_cast<LoadInst>(U)) {
736           if (LI->isVolatile())
737             return true;
738         } else if (isa<BlockAddress>(U)) {
739           // blockaddress doesn't take the address of the function, it takes addr
740           // of label.
741         } else {
742           return true;
743         }
744       }
745   }
746   return false;
747 }
748 
749 bool MagicUtil::lookupValueSet(const GlobalVariable *GV, std::vector<int> &valueSet) {
750   //Similar to hasAddressTaken above, but we look for values
751 
752   if(!isa<IntegerType>(GV->getType()->getElementType())) {
753       //integers is all we are interested in
754       return false;
755   }
756   if(!GV->hasInitializer()) {
757       //external variable
758       return false;
759   }
760 
761   // Delete any dead constantexpr klingons.
762   GV->removeDeadConstantUsers();
763 
764   std::set<int> set;
765   for (Value::const_user_iterator UI = GV->user_begin(), E = GV->user_end();
766       UI != E; ++UI) {
767       const User *U = *UI;
768       if (const StoreInst *SI = dyn_cast<StoreInst>(U)) {
769           if (SI->getOperand(1) == GV) {
770              Value *value = SI->getOperand(0);
771              if(ConstantInt *intValue = dyn_cast<ConstantInt>(value)) {
772                  set.insert(intValue->getSExtValue());
773              }
774              else {
775                  return false;
776              }
777           }
778       }
779   }
780   const Constant *constant = GV->getInitializer();
781   if(const ConstantInt *intConstant = dyn_cast<const ConstantInt>(constant)) {
782       set.insert(intConstant->getSExtValue());
783   }
784   else {
785       return false;
786   }
787 
788   assert(set.size() > 0);
789   valueSet.push_back(set.size()); //push length as the first value
790   for(std::set<int>::iterator it=set.begin() ; it != set.end(); it++) {
791       valueSet.push_back(*it);
792   }
793 
794   return true;
795 }
796 
797 Value* MagicUtil::getStringOwner(GlobalVariable *GV)
798 {
799   //Similar to hasAddressTaken above, but we look for string owners
800   assert(GV && GV->isConstant());
801 
802   // Skip emtpy strings.
803   if(GV->hasInitializer() && GV->getInitializer()->isNullValue()) {
804       return NULL;
805   }
806 
807   // Delete any dead constantexpr klingons.
808   GV->removeDeadConstantUsers();
809 
810   std::vector<User*> sourceUsers;
811   sourceUsers.push_back(GV);
812   for (Value::user_iterator UI = GV->user_begin(), E = GV->user_end();
813       UI != E; ++UI) {
814       User *U = *UI;
815       ConstantExpr *constantExpr = dyn_cast<ConstantExpr>(U);
816       if(isa<GetElementPtrInst>(U)) {
817           sourceUsers.push_back(U);
818       }
819       else if(constantExpr && constantExpr->getOpcode() == Instruction::GetElementPtr) {
820           sourceUsers.push_back(U);
821       }
822   }
823 
824   Value *stringOwner = NULL;
825   for(unsigned i=0;i<sourceUsers.size();i++) {
826       for (Value::user_iterator UI = sourceUsers[i]->user_begin(), E = sourceUsers[i]->user_end();
827            UI != E; ++UI) {
828           User *U = *UI;
829           Value *V = U;
830           if (StoreInst *SI = dyn_cast<StoreInst>(U)) {
831               V = SI->getPointerOperand();
832           }
833           if(isa<GlobalVariable>(V) || isa<AllocaInst>(V)) {
834               if(stringOwner != NULL && stringOwner != V) {
835                   //no owner in the ambiguous cases
836                   return NULL;
837               }
838               stringOwner = V;
839           }
840       }
841   }
842 
843   return stringOwner;
844 }
845 
846 Instruction* MagicUtil::getFirstNonAllocaInst(Function *F, bool skipAllocaPoint)
847 {
848   Instruction *I = NULL;
849   if (skipAllocaPoint) {
850       PassUtil::getAllocaInfo(F, NULL, &I);
851   }
852   else {
853       PassUtil::getAllocaInfo(F, &I, NULL);
854   }
855   assert(I);
856   return I;
857 }
858 
859 void MagicUtil::setGlobalVariableSection(GlobalVariable *GV, const std::string &section)
860 {
861   if(GV->isThreadLocal()) {
862       return;
863   }
864 
865   GV->setSection(section);
866 }
867 
868 bool MagicUtil::getCallAnnotation(Module &M, const CallSite &CS, int *annotation)
869 {
870   static GlobalVariable *magicAnnotationVar = NULL;
871   bool instFound = false;
872   bool annotationFound = false;
873   if(!magicAnnotationVar) {
874       magicAnnotationVar = M.getNamedGlobal(MAGIC_CALL_ANNOTATION_VAR_NAME);
875       assert(magicAnnotationVar);
876   }
877   Instruction *I = CS.getInstruction();
878   if(!I) {
879       return false;
880   }
881   BasicBlock *parent = I->getParent();
882   for (BasicBlock::iterator i = parent->begin(), e = parent->end(); i != e; ++i) {
883       Instruction *inst = i;
884       if(inst != I && !instFound) {
885           continue;
886       }
887       instFound = true;
888       if(inst == I) {
889           continue;
890       }
891       if(StoreInst *SI = dyn_cast<StoreInst>(inst)) {
892           if(SI->getOperand(1) == magicAnnotationVar) {
893               ConstantInt *CI = dyn_cast<ConstantInt>(SI->getOperand(0));
894               assert(CI && "Bad call annotation!");
895               annotationFound = true;
896               *annotation = CI->getSExtValue();
897               break;
898           }
899       }
900       else if(isa<CallInst>(inst) || isa<InvokeInst>(inst)) {
901           break;
902       }
903   }
904   return annotationFound;
905 }
906 
907 bool MagicUtil::getVarAnnotation(Module &M, const GlobalVariable *GV, int *annotation)
908 {
909   std::string GVName = GV->getName();
910   GlobalVariable *annotationGV = M.getNamedGlobal(MAGIC_VAR_ANNOTATION_PREFIX_NAME + GVName);
911   if(!annotationGV || !annotationGV->hasInitializer()) {
912       return false;
913   }
914   ConstantInt* annotationValue = dyn_cast<ConstantInt>(annotationGV->getInitializer());
915   if(!annotationValue) {
916       return false;
917   }
918   *annotation = (int) annotationValue->getSExtValue();
919   return true;
920 }
921 
922 CallSite MagicUtil::getCallSiteFromInstruction(Instruction *I)
923 {
924   return PassUtil::getCallSiteFromInstruction(I);
925 }
926 
927 AllocaInst* MagicUtil::getAllocaInstFromArgument(Argument *argument)
928 {
929   Function *parent = argument->getParent();
930   std::string targetString = argument->getName().str() + "_addr";
931   std::string targetString2 = argument->getName().str() + ".addr";
932   StringRef targetName(targetString);
933   StringRef targetName2(targetString2);
934   for (inst_iterator it = inst_begin(parent), et = inst_end(parent); it != et; ++it) {
935       AllocaInst *AI = dyn_cast<AllocaInst>(&(*it));
936       if(!AI) {
937           break;
938       }
939       if(AI->getName().startswith(targetName) || AI->getName().startswith(targetName2)) {
940           return AI;
941       }
942   }
943 
944   return NULL;
945 }
946 
947 // searches for the specified function in module symbol table assuming that its name has been mangled
948 // returns NULL if the function has not been found
949 Function* MagicUtil::getMangledFunction(Module &M, StringRef functionName)
950 {
951 	Function *F = NULL;
952 	char* outbuf;
953 	const char* functionNameString = functionName.data();
954 	int status;
955 	for (Module::iterator it = M.begin(); it != M.end(); ++it) {
956 		StringRef mangledName = (*it).getName();
957 		outbuf = abi::__cxa_demangle(mangledName.data(), NULL, NULL, &status);
958 		if (status == -2) {
959 			continue; // mangledName is not a valid name under the C++ ABI mangling rules
960 		}
961 		assert(status == 0 && outbuf && "Error when trying to demangle a function name.");
962 		// testing whether this is the function we are looking for
963 		// the unmangled name is similar to a function prototype eg my_func(int, void*, int)
964 		char* pos = strstr(outbuf, functionNameString);
965 		if (!pos) {
966 			free(outbuf);
967 			continue;
968 		}
969 		// function names can only contain alpha-numeric characters and '_'
970 		// if the unmangled name refers to the target function, then that substring should not
971 		// be surrounded by characters allowed in a function name
972 		// (to exclude cases such as myfunc vs _myfunc vs myfunc2)
973 		if (pos > outbuf) {
974 			if (isalnum(*(pos - 1)) || (*(pos - 1) == '_')) {
975 				free(outbuf);
976 				continue;
977 			}
978 		}
979 		if (strlen(pos) > strlen(functionNameString)) {
980 			if (isalnum(*(pos + strlen(functionNameString))) || (*(pos + strlen(functionNameString)) == '_')) {
981 				free(outbuf);
982 				continue;
983 			}
984 		}
985 		F = it;
986 		free(outbuf);
987 		break;
988 	}
989 
990 	return F;
991 }
992 
993 Function* MagicUtil::getFunction(Module &M, StringRef functionName)
994 {
995 	Function* F = M.getFunction(functionName);
996 	if (!F) {
997 		F = MagicUtil::getMangledFunction(M, functionName);
998 	}
999 	return F;
1000 }
1001 
1002 // can Type1 be represented as Type2 (with no precision loss)
1003 bool MagicUtil::isCompatibleType(const Type* Type1, const Type* Type2)
1004 {
1005 	if (Type1 == Type2) {
1006 		return true;
1007 	}
1008 	if (Type1->isIntegerTy() && Type2->isIntegerTy()) {
1009 		if (((const IntegerType*)Type1)->getBitWidth() <= ((const IntegerType*)Type2)->getBitWidth()) {
1010 			return true;
1011 		}
1012 	}
1013 
1014 	return false;
1015 }
1016 
1017 // inserts an inlined call to the pre-hook function before any other instruction is executed
1018 // it can forward (some of) the original function's parameters and additional trailing arguments
1019 void MagicUtil::inlinePreHookForwardingCall(Function* function, Function* preHookFunction, std::vector<unsigned> argsMapping, std::vector<Value*> trailingArgs)
1020 {
1021 	std::vector<Value*> callArgs;
1022 	assert(preHookFunction->arg_size() == argsMapping.size() + trailingArgs.size() &&
1023 			"The number of parameter values specified for the pre-hook function does not match the signature of the function.");
1024 	for (std::vector<unsigned>::iterator it = argsMapping.begin(); it != argsMapping.end(); it++) {
1025 		callArgs.push_back(MagicUtil::getFunctionParam(function, *it - 1));
1026 	}
1027 	for (std::vector<Value*>::iterator it = trailingArgs.begin(); it != trailingArgs.end(); it++) {
1028 		callArgs.push_back(*it);
1029 	}
1030 	// insert the call after the alloca instructions so that they remain for sure in the entry block
1031 	Instruction *FirstInst = MagicUtil::getFirstNonAllocaInst(function);
1032 	for (unsigned i = 0; i < callArgs.size(); ++i) {
1033 		TYPECONST Type* ArgType = callArgs[i]->getType();
1034 		TYPECONST Type* ParamType = preHookFunction->getFunctionType()->getParamType(i);
1035 
1036 		if (!MagicUtil::isCompatibleType(ArgType, ParamType)) {
1037 			assert(CastInst::isCastable(ArgType, ParamType) && "The value of the argument cannot be "
1038 					"casted to the parameter type required by the function to be called.");
1039 			Instruction::CastOps CastOpCode = CastInst::getCastOpcode(callArgs[i], false, ParamType, false);
1040 			callArgs[i] = CastInst::Create(CastOpCode, callArgs[i], ParamType, "", FirstInst);
1041 		}
1042 	}
1043 
1044 	CallInst* WrapperFuncCall = MagicUtil::createCallInstruction(preHookFunction, callArgs, "", FirstInst);
1045 	InlineFunctionInfo IFI;
1046 	InlineFunction(WrapperFuncCall, IFI);
1047 }
1048 
1049 // inserts an inlined call to the post-hook function before all return instructions
1050 // forwarded arguments from the first function come first, followed by the trailing ones
1051 // use offsets > 0 for function parameter mappings, and 0 for the return value of the function
1052 void MagicUtil::inlinePostHookForwardingCall(Function* function, Function* postHookFunction, std::vector<unsigned> mapping, std::vector<Value*> trailingArgs)
1053 {
1054 	std::vector<CallInst*> wrapperCalls;
1055 	assert(postHookFunction->arg_size() == mapping.size() + trailingArgs.size()
1056 			&& "The number of parameter values specified for the post-hook function does not match the signature of the function.");
1057 
1058 	for (Function::iterator BI = function->getBasicBlockList().begin(); BI != function->getBasicBlockList().end(); ++BI) {
1059 		ReturnInst *RetInst = dyn_cast<ReturnInst>(BI->getTerminator());
1060 		if (RetInst) {
1061 			std::vector<Value*> callArgs;
1062 			for (std::vector<unsigned>::iterator it = mapping.begin(); it != mapping.end(); it++) {
1063 				if (*it > 0) {
1064 					callArgs.push_back(MagicUtil::getFunctionParam(function, *it - 1));
1065 				} else {
1066 					callArgs.push_back(RetInst->getReturnValue());
1067 				}
1068 			}
1069 			for (std::vector<Value*>::iterator it = trailingArgs.begin(); it != trailingArgs.end(); it++) {
1070 				callArgs.push_back(*it);
1071 			}
1072 			for (unsigned i = 0; i < callArgs.size(); i++) {
1073 				TYPECONST Type* ArgType = callArgs[i]->getType();
1074 				TYPECONST Type* ParamType = postHookFunction->getFunctionType()->getParamType(i);
1075 
1076 				if (!MagicUtil::isCompatibleType(ArgType, ParamType)) {
1077 					assert(CastInst::isCastable(ArgType, ParamType) && "The value of the argument cannot be "
1078 							"casted to the parameter type required by the function to be called.");
1079 					Instruction::CastOps CastOpCode = CastInst::getCastOpcode(callArgs[i], false, ParamType, false);
1080 					callArgs[i] = CastInst::Create(CastOpCode, callArgs[i], ParamType, "", RetInst);
1081 				}
1082 			}
1083 			CallInst* WrapperFuncCall = MagicUtil::createCallInstruction(postHookFunction, callArgs, "", RetInst);
1084 			wrapperCalls.push_back(WrapperFuncCall);
1085 		}
1086 	}
1087 	for (std::vector<CallInst*>::iterator it = wrapperCalls.begin(); it != wrapperCalls.end(); ++it) {
1088 		InlineFunctionInfo IFI;
1089 		InlineFunction(*it, IFI);
1090 	}
1091 }
1092 
1093 int MagicUtil::getPointerIndirectionLevel(const Type* type)
1094 {
1095 	int level = 0;
1096 	if (const PointerType* ptr_type = dyn_cast<PointerType>(type)) {
1097 		while (ptr_type) {
1098 			level++;
1099 			ptr_type = dyn_cast<PointerType>(ptr_type->getElementType());
1100 		}
1101 	}
1102 
1103 	return level;
1104 }
1105 
1106 Value* MagicUtil::getFunctionParam(Function* function, unsigned index)
1107 {
1108 	if (index >= function->arg_size()) {
1109 		return NULL;
1110 	}
1111 	Function::arg_iterator AI = function->arg_begin();
1112 	while (index --> 0) {
1113 		AI++;
1114 	}
1115 	return AI;
1116 }
1117 
1118 bool MagicUtil::isLocalConstant(Module &M, GlobalVariable *GV)
1119 {
1120 	if (!GV->isConstant()) {
1121 		return false;
1122 	}
1123 	if (GV->getName().endswith(".v")) {
1124 		return true;
1125 	}
1126 	std::pair<StringRef, StringRef> stringPair = GV->getName().split('.');
1127 	StringRef functionName = stringPair.first;
1128 	if (!functionName.compare("") || M.getFunction(functionName) == NULL) {
1129 		return false;
1130 	}
1131 
1132 	return true;
1133 }
1134 
1135 }
1136