Chris Lattner | 467dd2e | 2004-03-08 17:06:13 +0000 | [diff] [blame] | 1 | //===- ProfilingUtils.cpp - Helper functions shared by profilers ----------===// |
Misha Brukman | fd93908 | 2005-04-21 23:48:37 +0000 | [diff] [blame] | 2 | // |
Chris Lattner | 467dd2e | 2004-03-08 17:06:13 +0000 | [diff] [blame] | 3 | // The LLVM Compiler Infrastructure |
| 4 | // |
| 5 | // This file was developed by the LLVM research group and is distributed under |
| 6 | // the University of Illinois Open Source License. See LICENSE.TXT for details. |
Misha Brukman | fd93908 | 2005-04-21 23:48:37 +0000 | [diff] [blame] | 7 | // |
Chris Lattner | 467dd2e | 2004-03-08 17:06:13 +0000 | [diff] [blame] | 8 | //===----------------------------------------------------------------------===// |
| 9 | // |
| 10 | // This files implements a few helper functions which are used by profile |
| 11 | // instrumentation code to instrument the code. This allows the profiler pass |
| 12 | // to worry about *what* to insert, and these functions take care of *how* to do |
| 13 | // it. |
| 14 | // |
| 15 | //===----------------------------------------------------------------------===// |
| 16 | |
| 17 | #include "ProfilingUtils.h" |
| 18 | #include "llvm/Constants.h" |
| 19 | #include "llvm/DerivedTypes.h" |
| 20 | #include "llvm/Instructions.h" |
| 21 | #include "llvm/Module.h" |
| 22 | |
| 23 | void llvm::InsertProfilingInitCall(Function *MainFn, const char *FnName, |
| 24 | GlobalValue *Array) { |
| 25 | const Type *ArgVTy = PointerType::get(PointerType::get(Type::SByteTy)); |
Brian Gaeke | ebbc0e9 | 2004-05-03 22:06:33 +0000 | [diff] [blame] | 26 | const PointerType *UIntPtr = PointerType::get(Type::UIntTy); |
Chris Lattner | 467dd2e | 2004-03-08 17:06:13 +0000 | [diff] [blame] | 27 | Module &M = *MainFn->getParent(); |
| 28 | Function *InitFn = M.getOrInsertFunction(FnName, Type::IntTy, Type::IntTy, |
Jeff Cohen | 66c5fd6 | 2005-10-23 04:37:20 +0000 | [diff] [blame] | 29 | ArgVTy, UIntPtr, Type::UIntTy, |
| 30 | (Type *)0); |
Chris Lattner | 467dd2e | 2004-03-08 17:06:13 +0000 | [diff] [blame] | 31 | |
| 32 | // This could force argc and argv into programs that wouldn't otherwise have |
| 33 | // them, but instead we just pass null values in. |
| 34 | std::vector<Value*> Args(4); |
| 35 | Args[0] = Constant::getNullValue(Type::IntTy); |
| 36 | Args[1] = Constant::getNullValue(ArgVTy); |
| 37 | |
| 38 | // Skip over any allocas in the entry block. |
| 39 | BasicBlock *Entry = MainFn->begin(); |
| 40 | BasicBlock::iterator InsertPos = Entry->begin(); |
| 41 | while (isa<AllocaInst>(InsertPos)) ++InsertPos; |
| 42 | |
Chris Lattner | 28977af | 2004-04-05 01:30:19 +0000 | [diff] [blame] | 43 | std::vector<Constant*> GEPIndices(2, Constant::getNullValue(Type::IntTy)); |
Brian Gaeke | ebbc0e9 | 2004-05-03 22:06:33 +0000 | [diff] [blame] | 44 | unsigned NumElements = 0; |
| 45 | if (Array) { |
Reid Spencer | 518310c | 2004-07-18 00:44:37 +0000 | [diff] [blame] | 46 | Args[2] = ConstantExpr::getGetElementPtr(Array, GEPIndices); |
Brian Gaeke | ebbc0e9 | 2004-05-03 22:06:33 +0000 | [diff] [blame] | 47 | NumElements = |
| 48 | cast<ArrayType>(Array->getType()->getElementType())->getNumElements(); |
| 49 | } else { |
| 50 | // If this profiling instrumentation doesn't have a constant array, just |
| 51 | // pass null. |
| 52 | Args[2] = ConstantPointerNull::get(UIntPtr); |
| 53 | } |
Reid Spencer | b83eb64 | 2006-10-20 07:07:24 +0000 | [diff] [blame] | 54 | Args[3] = ConstantInt::get(Type::UIntTy, NumElements); |
Misha Brukman | fd93908 | 2005-04-21 23:48:37 +0000 | [diff] [blame] | 55 | |
Chris Lattner | 467dd2e | 2004-03-08 17:06:13 +0000 | [diff] [blame] | 56 | Instruction *InitCall = new CallInst(InitFn, Args, "newargc", InsertPos); |
| 57 | |
| 58 | // If argc or argv are not available in main, just pass null values in. |
Chris Lattner | e4d5c44 | 2005-03-15 04:54:21 +0000 | [diff] [blame] | 59 | Function::arg_iterator AI; |
| 60 | switch (MainFn->arg_size()) { |
Chris Lattner | 467dd2e | 2004-03-08 17:06:13 +0000 | [diff] [blame] | 61 | default: |
| 62 | case 2: |
Chris Lattner | e4d5c44 | 2005-03-15 04:54:21 +0000 | [diff] [blame] | 63 | AI = MainFn->arg_begin(); ++AI; |
Chris Lattner | 467dd2e | 2004-03-08 17:06:13 +0000 | [diff] [blame] | 64 | if (AI->getType() != ArgVTy) { |
Reid Spencer | 3da59db | 2006-11-27 01:05:10 +0000 | [diff] [blame^] | 65 | InitCall->setOperand(2, |
| 66 | CastInst::createInferredCast(AI, ArgVTy, "argv.cast", InitCall)); |
Chris Lattner | 467dd2e | 2004-03-08 17:06:13 +0000 | [diff] [blame] | 67 | } else { |
| 68 | InitCall->setOperand(2, AI); |
| 69 | } |
| 70 | |
| 71 | case 1: |
Chris Lattner | e4d5c44 | 2005-03-15 04:54:21 +0000 | [diff] [blame] | 72 | AI = MainFn->arg_begin(); |
Chris Lattner | 467dd2e | 2004-03-08 17:06:13 +0000 | [diff] [blame] | 73 | // If the program looked at argc, have it look at the return value of the |
| 74 | // init call instead. |
| 75 | if (AI->getType() != Type::IntTy) { |
| 76 | if (!AI->use_empty()) |
Reid Spencer | 3da59db | 2006-11-27 01:05:10 +0000 | [diff] [blame^] | 77 | AI->replaceAllUsesWith( |
| 78 | CastInst::createInferredCast(InitCall, AI->getType(), "", InsertPos)); |
| 79 | InitCall->setOperand(1, |
| 80 | CastInst::createInferredCast(AI, Type::IntTy, "argc.cast", InitCall)); |
Chris Lattner | 467dd2e | 2004-03-08 17:06:13 +0000 | [diff] [blame] | 81 | } else { |
| 82 | AI->replaceAllUsesWith(InitCall); |
| 83 | InitCall->setOperand(1, AI); |
| 84 | } |
Misha Brukman | fd93908 | 2005-04-21 23:48:37 +0000 | [diff] [blame] | 85 | |
Chris Lattner | 467dd2e | 2004-03-08 17:06:13 +0000 | [diff] [blame] | 86 | case 0: break; |
| 87 | } |
| 88 | } |
| 89 | |
| 90 | void llvm::IncrementCounterInBlock(BasicBlock *BB, unsigned CounterNum, |
Reid Spencer | 518310c | 2004-07-18 00:44:37 +0000 | [diff] [blame] | 91 | GlobalValue *CounterArray) { |
Chris Lattner | 467dd2e | 2004-03-08 17:06:13 +0000 | [diff] [blame] | 92 | // Insert the increment after any alloca or PHI instructions... |
| 93 | BasicBlock::iterator InsertPos = BB->begin(); |
| 94 | while (isa<AllocaInst>(InsertPos) || isa<PHINode>(InsertPos)) |
| 95 | ++InsertPos; |
| 96 | |
| 97 | // Create the getelementptr constant expression |
| 98 | std::vector<Constant*> Indices(2); |
Chris Lattner | 28977af | 2004-04-05 01:30:19 +0000 | [diff] [blame] | 99 | Indices[0] = Constant::getNullValue(Type::IntTy); |
Reid Spencer | b83eb64 | 2006-10-20 07:07:24 +0000 | [diff] [blame] | 100 | Indices[1] = ConstantInt::get(Type::IntTy, CounterNum); |
Chris Lattner | 467dd2e | 2004-03-08 17:06:13 +0000 | [diff] [blame] | 101 | Constant *ElementPtr = ConstantExpr::getGetElementPtr(CounterArray, Indices); |
| 102 | |
| 103 | // Load, increment and store the value back. |
| 104 | Value *OldVal = new LoadInst(ElementPtr, "OldFuncCounter", InsertPos); |
| 105 | Value *NewVal = BinaryOperator::create(Instruction::Add, OldVal, |
| 106 | ConstantInt::get(Type::UIntTy, 1), |
| 107 | "NewFuncCounter", InsertPos); |
| 108 | new StoreInst(NewVal, ElementPtr, InsertPos); |
| 109 | } |