Chris Lattner | 29c1473 | 2001-12-14 16:26:05 +0000 | [diff] [blame] | 1 | //===- TraceValues.cpp - Value Tracing for debugging -------------*- C++ -*--=// |
| 2 | // |
Chris Lattner | 649f5dd | 2002-04-14 06:15:24 +0000 | [diff] [blame] | 3 | // Support for inserting LLVM code to print values at basic block and function |
Chris Lattner | 29c1473 | 2001-12-14 16:26:05 +0000 | [diff] [blame] | 4 | // exits. |
| 5 | // |
| 6 | //===----------------------------------------------------------------------===// |
Vikram S. Adve | df1892f | 2001-10-14 23:18:45 +0000 | [diff] [blame] | 7 | |
| 8 | #include "llvm/Transforms/Instrumentation/TraceValues.h" |
| 9 | #include "llvm/GlobalVariable.h" |
Chris Lattner | 31bcdb8 | 2002-04-28 19:55:58 +0000 | [diff] [blame] | 10 | #include "llvm/Constants.h" |
Vikram S. Adve | df1892f | 2001-10-14 23:18:45 +0000 | [diff] [blame] | 11 | #include "llvm/DerivedTypes.h" |
Vikram S. Adve | 631b9a3 | 2001-10-18 18:16:11 +0000 | [diff] [blame] | 12 | #include "llvm/iMemory.h" |
Vikram S. Adve | df1892f | 2001-10-14 23:18:45 +0000 | [diff] [blame] | 13 | #include "llvm/iTerminators.h" |
| 14 | #include "llvm/iOther.h" |
Chris Lattner | 42a4127 | 2002-04-09 18:37:46 +0000 | [diff] [blame] | 15 | #include "llvm/BasicBlock.h" |
Chris Lattner | 79df7c0 | 2002-03-26 18:01:55 +0000 | [diff] [blame] | 16 | #include "llvm/Function.h" |
Vikram S. Adve | df1892f | 2001-10-14 23:18:45 +0000 | [diff] [blame] | 17 | #include "llvm/Module.h" |
Chris Lattner | bd0ef77 | 2002-02-26 21:46:54 +0000 | [diff] [blame] | 18 | #include "llvm/Pass.h" |
Chris Lattner | 8d9e377 | 2001-10-18 05:28:08 +0000 | [diff] [blame] | 19 | #include "llvm/Assembly/Writer.h" |
Chris Lattner | cee8f9a | 2001-11-27 00:03:19 +0000 | [diff] [blame] | 20 | #include "Support/StringExtras.h" |
Chris Lattner | b81a0bf | 2001-10-18 20:06:03 +0000 | [diff] [blame] | 21 | #include <sstream> |
Chris Lattner | 697954c | 2002-01-20 22:54:45 +0000 | [diff] [blame] | 22 | using std::vector; |
| 23 | using std::string; |
Vikram S. Adve | d889330 | 2001-10-28 21:37:25 +0000 | [diff] [blame] | 24 | |
Chris Lattner | bd0ef77 | 2002-02-26 21:46:54 +0000 | [diff] [blame] | 25 | namespace { |
Chris Lattner | f57b845 | 2002-04-27 06:56:12 +0000 | [diff] [blame] | 26 | class InsertTraceCode : public FunctionPass { |
Chris Lattner | 79df7c0 | 2002-03-26 18:01:55 +0000 | [diff] [blame] | 27 | bool TraceBasicBlockExits, TraceFunctionExits; |
| 28 | Function *PrintfFunc; |
Chris Lattner | bd0ef77 | 2002-02-26 21:46:54 +0000 | [diff] [blame] | 29 | public: |
Chris Lattner | 79df7c0 | 2002-03-26 18:01:55 +0000 | [diff] [blame] | 30 | InsertTraceCode(bool traceBasicBlockExits, bool traceFunctionExits) |
Chris Lattner | bd0ef77 | 2002-02-26 21:46:54 +0000 | [diff] [blame] | 31 | : TraceBasicBlockExits(traceBasicBlockExits), |
Chris Lattner | 79df7c0 | 2002-03-26 18:01:55 +0000 | [diff] [blame] | 32 | TraceFunctionExits(traceFunctionExits) {} |
Chris Lattner | 96c466b | 2002-04-29 14:57:45 +0000 | [diff] [blame^] | 33 | |
| 34 | const char *getPassName() const { return "Trace Code Insertion"; } |
Chris Lattner | bd0ef77 | 2002-02-26 21:46:54 +0000 | [diff] [blame] | 35 | |
| 36 | // Add a prototype for printf if it is not already in the program. |
| 37 | // |
| 38 | bool doInitialization(Module *M); |
| 39 | |
| 40 | //-------------------------------------------------------------------------- |
| 41 | // Function InsertCodeToTraceValues |
| 42 | // |
Chris Lattner | 649f5dd | 2002-04-14 06:15:24 +0000 | [diff] [blame] | 43 | // Inserts tracing code for all live values at basic block and/or function |
Chris Lattner | 79df7c0 | 2002-03-26 18:01:55 +0000 | [diff] [blame] | 44 | // exits as specified by `traceBasicBlockExits' and `traceFunctionExits'. |
Chris Lattner | bd0ef77 | 2002-02-26 21:46:54 +0000 | [diff] [blame] | 45 | // |
Chris Lattner | 79df7c0 | 2002-03-26 18:01:55 +0000 | [diff] [blame] | 46 | static bool doit(Function *M, bool traceBasicBlockExits, |
| 47 | bool traceFunctionExits, Function *Printf); |
Chris Lattner | bd0ef77 | 2002-02-26 21:46:54 +0000 | [diff] [blame] | 48 | |
Chris Lattner | 649f5dd | 2002-04-14 06:15:24 +0000 | [diff] [blame] | 49 | // runOnFunction - This method does the work. |
Chris Lattner | bd0ef77 | 2002-02-26 21:46:54 +0000 | [diff] [blame] | 50 | // |
Chris Lattner | f57b845 | 2002-04-27 06:56:12 +0000 | [diff] [blame] | 51 | bool runOnFunction(Function *F) { |
Chris Lattner | 79df7c0 | 2002-03-26 18:01:55 +0000 | [diff] [blame] | 52 | return doit(F, TraceBasicBlockExits, TraceFunctionExits, PrintfFunc); |
Chris Lattner | bd0ef77 | 2002-02-26 21:46:54 +0000 | [diff] [blame] | 53 | } |
Chris Lattner | 97e52e4 | 2002-04-28 21:27:06 +0000 | [diff] [blame] | 54 | |
| 55 | virtual void getAnalysisUsage(AnalysisUsage &AU) const { |
| 56 | AU.preservesCFG(); |
| 57 | } |
Chris Lattner | bd0ef77 | 2002-02-26 21:46:54 +0000 | [diff] [blame] | 58 | }; |
| 59 | } // end anonymous namespace |
| 60 | |
| 61 | |
Chris Lattner | f57b845 | 2002-04-27 06:56:12 +0000 | [diff] [blame] | 62 | Pass *createTraceValuesPassForFunction() { // Just trace functions |
Chris Lattner | bd0ef77 | 2002-02-26 21:46:54 +0000 | [diff] [blame] | 63 | return new InsertTraceCode(false, true); |
| 64 | } |
| 65 | |
Chris Lattner | 649f5dd | 2002-04-14 06:15:24 +0000 | [diff] [blame] | 66 | Pass *createTraceValuesPassForBasicBlocks() { // Trace BB's and functions |
Chris Lattner | bd0ef77 | 2002-02-26 21:46:54 +0000 | [diff] [blame] | 67 | return new InsertTraceCode(true, true); |
| 68 | } |
| 69 | |
| 70 | |
| 71 | |
| 72 | |
Chris Lattner | 29c1473 | 2001-12-14 16:26:05 +0000 | [diff] [blame] | 73 | // Add a prototype for printf if it is not already in the program. |
| 74 | // |
Chris Lattner | f4de63f | 2002-01-21 07:31:50 +0000 | [diff] [blame] | 75 | bool InsertTraceCode::doInitialization(Module *M) { |
Chris Lattner | 29c1473 | 2001-12-14 16:26:05 +0000 | [diff] [blame] | 76 | const Type *SBP = PointerType::get(Type::SByteTy); |
Chris Lattner | 2aac6bf | 2002-04-04 22:19:18 +0000 | [diff] [blame] | 77 | const FunctionType *MTy = |
| 78 | FunctionType::get(Type::IntTy, vector<const Type*>(1, SBP), true); |
Vikram S. Adve | d889330 | 2001-10-28 21:37:25 +0000 | [diff] [blame] | 79 | |
Chris Lattner | 8985107 | 2002-03-29 03:43:24 +0000 | [diff] [blame] | 80 | PrintfFunc = M->getOrInsertFunction("printf", MTy); |
| 81 | return false; |
Vikram S. Adve | d889330 | 2001-10-28 21:37:25 +0000 | [diff] [blame] | 82 | } |
| 83 | |
Chris Lattner | 29c1473 | 2001-12-14 16:26:05 +0000 | [diff] [blame] | 84 | |
| 85 | static inline GlobalVariable *getStringRef(Module *M, const string &str) { |
| 86 | // Create a constant internal string reference... |
| 87 | Constant *Init = ConstantArray::get(str); |
Vikram S. Adve | 524185a | 2002-03-18 03:40:25 +0000 | [diff] [blame] | 88 | |
| 89 | // Create the global variable and record it in the module |
| 90 | // The GV will be renamed to a unique name if needed. |
Chris Lattner | 29c1473 | 2001-12-14 16:26:05 +0000 | [diff] [blame] | 91 | GlobalVariable *GV = new GlobalVariable(Init->getType(), true, true, Init, |
| 92 | "trstr"); |
Chris Lattner | b81a0bf | 2001-10-18 20:06:03 +0000 | [diff] [blame] | 93 | M->getGlobalList().push_back(GV); |
| 94 | return GV; |
Vikram S. Adve | df1892f | 2001-10-14 23:18:45 +0000 | [diff] [blame] | 95 | } |
| 96 | |
Vikram S. Adve | bedb00d | 2001-10-18 13:49:22 +0000 | [diff] [blame] | 97 | |
Chris Lattner | 29c1473 | 2001-12-14 16:26:05 +0000 | [diff] [blame] | 98 | // |
| 99 | // Check if this instruction has any uses outside its basic block, |
| 100 | // or if it used by either a Call or Return instruction. |
| 101 | // |
| 102 | static inline bool LiveAtBBExit(const Instruction* I) { |
| 103 | const BasicBlock *BB = I->getParent(); |
| 104 | for (Value::use_const_iterator U = I->use_begin(); U != I->use_end(); ++U) |
| 105 | if (const Instruction *UI = dyn_cast<Instruction>(*U)) |
| 106 | if (UI->getParent() != BB || isa<ReturnInst>(UI)) |
| 107 | return true; |
| 108 | |
| 109 | return false; |
| 110 | } |
| 111 | |
| 112 | |
| 113 | static inline bool TraceThisOpCode(unsigned opCode) { |
Vikram S. Adve | df1892f | 2001-10-14 23:18:45 +0000 | [diff] [blame] | 114 | // Explicitly test for opCodes *not* to trace so that any new opcodes will |
Chris Lattner | 8d9e377 | 2001-10-18 05:28:08 +0000 | [diff] [blame] | 115 | // be traced by default (VoidTy's are already excluded) |
Vikram S. Adve | df1892f | 2001-10-14 23:18:45 +0000 | [diff] [blame] | 116 | // |
| 117 | return (opCode < Instruction::FirstOtherOp && |
Vikram S. Adve | df1892f | 2001-10-14 23:18:45 +0000 | [diff] [blame] | 118 | opCode != Instruction::Alloca && |
Vikram S. Adve | df1892f | 2001-10-14 23:18:45 +0000 | [diff] [blame] | 119 | opCode != Instruction::PHINode && |
| 120 | opCode != Instruction::Cast); |
| 121 | } |
| 122 | |
Chris Lattner | 29c1473 | 2001-12-14 16:26:05 +0000 | [diff] [blame] | 123 | |
| 124 | static bool ShouldTraceValue(const Instruction *I) { |
| 125 | return |
| 126 | I->getType() != Type::VoidTy && LiveAtBBExit(I) && |
| 127 | TraceThisOpCode(I->getOpcode()); |
Vikram S. Adve | 631b9a3 | 2001-10-18 18:16:11 +0000 | [diff] [blame] | 128 | } |
| 129 | |
Chris Lattner | 29c1473 | 2001-12-14 16:26:05 +0000 | [diff] [blame] | 130 | static string getPrintfCodeFor(const Value *V) { |
| 131 | if (V == 0) return ""; |
Chris Lattner | 649f5dd | 2002-04-14 06:15:24 +0000 | [diff] [blame] | 132 | if (V->getType()->isFloatingPoint()) |
| 133 | return "%g"; |
| 134 | else if (V->getType() == Type::LabelTy || isa<PointerType>(V->getType())) |
| 135 | return "0x%p"; |
| 136 | else if (V->getType()->isIntegral() || V->getType() == Type::BoolTy) |
Chris Lattner | 29c1473 | 2001-12-14 16:26:05 +0000 | [diff] [blame] | 137 | return "%d"; |
Chris Lattner | b81a0bf | 2001-10-18 20:06:03 +0000 | [diff] [blame] | 138 | |
Chris Lattner | 649f5dd | 2002-04-14 06:15:24 +0000 | [diff] [blame] | 139 | assert(0 && "Illegal value to print out..."); |
| 140 | return ""; |
Vikram S. Adve | bedb00d | 2001-10-18 13:49:22 +0000 | [diff] [blame] | 141 | } |
Vikram S. Adve | bedb00d | 2001-10-18 13:49:22 +0000 | [diff] [blame] | 142 | |
| 143 | |
Chris Lattner | 29c1473 | 2001-12-14 16:26:05 +0000 | [diff] [blame] | 144 | static void InsertPrintInst(Value *V, BasicBlock *BB, BasicBlock::iterator &BBI, |
Chris Lattner | 79df7c0 | 2002-03-26 18:01:55 +0000 | [diff] [blame] | 145 | string Message, Function *Printf) { |
Chris Lattner | 29c1473 | 2001-12-14 16:26:05 +0000 | [diff] [blame] | 146 | // Escape Message by replacing all % characters with %% chars. |
| 147 | unsigned Offset = 0; |
| 148 | while ((Offset = Message.find('%', Offset)) != string::npos) { |
Chris Lattner | 649f5dd | 2002-04-14 06:15:24 +0000 | [diff] [blame] | 149 | Message.replace(Offset, 1, "%%"); |
Chris Lattner | 29c1473 | 2001-12-14 16:26:05 +0000 | [diff] [blame] | 150 | Offset += 2; // Skip over the new %'s |
| 151 | } |
Chris Lattner | 8d9e377 | 2001-10-18 05:28:08 +0000 | [diff] [blame] | 152 | |
Chris Lattner | 29c1473 | 2001-12-14 16:26:05 +0000 | [diff] [blame] | 153 | Module *Mod = BB->getParent()->getParent(); |
Chris Lattner | 8d9e377 | 2001-10-18 05:28:08 +0000 | [diff] [blame] | 154 | |
Chris Lattner | 4457163 | 2001-10-18 06:03:05 +0000 | [diff] [blame] | 155 | // Turn the marker string into a global variable... |
Chris Lattner | 29c1473 | 2001-12-14 16:26:05 +0000 | [diff] [blame] | 156 | GlobalVariable *fmtVal = getStringRef(Mod, Message+getPrintfCodeFor(V)+"\n"); |
| 157 | |
| 158 | // Turn the format string into an sbyte * |
| 159 | Instruction *GEP = |
| 160 | new GetElementPtrInst(fmtVal, |
| 161 | vector<Value*>(2,ConstantUInt::get(Type::UIntTy, 0)), |
| 162 | "trstr"); |
| 163 | BBI = BB->getInstList().insert(BBI, GEP)+1; |
Chris Lattner | 4457163 | 2001-10-18 06:03:05 +0000 | [diff] [blame] | 164 | |
| 165 | // Insert the first print instruction to print the string flag: |
Chris Lattner | 29c1473 | 2001-12-14 16:26:05 +0000 | [diff] [blame] | 166 | vector<Value*> PrintArgs; |
| 167 | PrintArgs.push_back(GEP); |
| 168 | if (V) PrintArgs.push_back(V); |
| 169 | Instruction *I = new CallInst(Printf, PrintArgs, "trace"); |
Chris Lattner | 4457163 | 2001-10-18 06:03:05 +0000 | [diff] [blame] | 170 | BBI = BB->getInstList().insert(BBI, I)+1; |
Chris Lattner | 29c1473 | 2001-12-14 16:26:05 +0000 | [diff] [blame] | 171 | } |
| 172 | |
Chris Lattner | 4457163 | 2001-10-18 06:03:05 +0000 | [diff] [blame] | 173 | |
Chris Lattner | 29c1473 | 2001-12-14 16:26:05 +0000 | [diff] [blame] | 174 | static void InsertVerbosePrintInst(Value *V, BasicBlock *BB, |
| 175 | BasicBlock::iterator &BBI, |
Chris Lattner | 79df7c0 | 2002-03-26 18:01:55 +0000 | [diff] [blame] | 176 | const string &Message, Function *Printf) { |
Chris Lattner | 697954c | 2002-01-20 22:54:45 +0000 | [diff] [blame] | 177 | std::ostringstream OutStr; |
Chris Lattner | 29c1473 | 2001-12-14 16:26:05 +0000 | [diff] [blame] | 178 | if (V) WriteAsOperand(OutStr, V); |
| 179 | InsertPrintInst(V, BB, BBI, Message+OutStr.str()+" = ", Printf); |
Chris Lattner | 8d9e377 | 2001-10-18 05:28:08 +0000 | [diff] [blame] | 180 | } |
| 181 | |
| 182 | |
Vikram S. Adve | df1892f | 2001-10-14 23:18:45 +0000 | [diff] [blame] | 183 | // Insert print instructions at the end of the basic block *bb |
Vikram S. Adve | 631b9a3 | 2001-10-18 18:16:11 +0000 | [diff] [blame] | 184 | // for each value in valueVec[] that is live at the end of that basic block, |
| 185 | // or that is stored to memory in this basic block. |
| 186 | // If the value is stored to memory, we load it back before printing |
Chris Lattner | 79df7c0 | 2002-03-26 18:01:55 +0000 | [diff] [blame] | 187 | // We also return all such loaded values in the vector valuesStoredInFunction |
Chris Lattner | 649f5dd | 2002-04-14 06:15:24 +0000 | [diff] [blame] | 188 | // for printing at the exit from the function. (Note that in each invocation |
| 189 | // of the function, this will only get the last value stored for each static |
Vikram S. Adve | 631b9a3 | 2001-10-18 18:16:11 +0000 | [diff] [blame] | 190 | // store instruction). |
| 191 | // *bb must be the block in which the value is computed; |
| 192 | // this is not checked here. |
Vikram S. Adve | df1892f | 2001-10-14 23:18:45 +0000 | [diff] [blame] | 193 | // |
Chris Lattner | 79df7c0 | 2002-03-26 18:01:55 +0000 | [diff] [blame] | 194 | static void TraceValuesAtBBExit(BasicBlock *BB, Function *Printf, |
| 195 | vector<Instruction*> *valuesStoredInFunction) { |
Vikram S. Adve | d889330 | 2001-10-28 21:37:25 +0000 | [diff] [blame] | 196 | // Get an iterator to point to the insertion location, which is |
| 197 | // just before the terminator instruction. |
Vikram S. Adve | df1892f | 2001-10-14 23:18:45 +0000 | [diff] [blame] | 198 | // |
Chris Lattner | 29c1473 | 2001-12-14 16:26:05 +0000 | [diff] [blame] | 199 | BasicBlock::iterator InsertPos = BB->end()-1; |
| 200 | assert((*InsertPos)->isTerminator()); |
Vikram S. Adve | df1892f | 2001-10-14 23:18:45 +0000 | [diff] [blame] | 201 | |
Vikram S. Adve | d889330 | 2001-10-28 21:37:25 +0000 | [diff] [blame] | 202 | // If the terminator is a conditional branch, insert the trace code just |
| 203 | // before the instruction that computes the branch condition (just to |
| 204 | // avoid putting a call between the CC-setting instruction and the branch). |
| 205 | // Use laterInstrSet to mark instructions that come after the setCC instr |
| 206 | // because those cannot be traced at the location we choose. |
| 207 | // |
Chris Lattner | 29c1473 | 2001-12-14 16:26:05 +0000 | [diff] [blame] | 208 | Instruction *SetCC = 0; |
| 209 | if (BranchInst *Branch = dyn_cast<BranchInst>(BB->getTerminator())) |
| 210 | if (!Branch->isUnconditional()) |
| 211 | if (Instruction *I = dyn_cast<Instruction>(Branch->getCondition())) |
| 212 | if (I->getParent() == BB) { |
| 213 | SetCC = I; |
| 214 | while (*InsertPos != SetCC) |
| 215 | --InsertPos; // Back up until we can insert before the setcc |
| 216 | } |
| 217 | |
| 218 | // Copy all of the instructions into a vector to avoid problems with Setcc |
| 219 | const vector<Instruction*> Insts(BB->begin(), InsertPos); |
| 220 | |
Chris Lattner | 697954c | 2002-01-20 22:54:45 +0000 | [diff] [blame] | 221 | std::ostringstream OutStr; |
Chris Lattner | 29c1473 | 2001-12-14 16:26:05 +0000 | [diff] [blame] | 222 | WriteAsOperand(OutStr, BB, false); |
| 223 | InsertPrintInst(0, BB, InsertPos, "LEAVING BB:" + OutStr.str(), Printf); |
| 224 | |
Vikram S. Adve | df1892f | 2001-10-14 23:18:45 +0000 | [diff] [blame] | 225 | // Insert a print instruction for each value. |
| 226 | // |
Chris Lattner | 29c1473 | 2001-12-14 16:26:05 +0000 | [diff] [blame] | 227 | for (vector<Instruction*>::const_iterator II = Insts.begin(), |
| 228 | IE = Insts.end(); II != IE; ++II) { |
| 229 | Instruction *I = *II; |
| 230 | if (StoreInst *SI = dyn_cast<StoreInst>(I)) { |
Chris Lattner | 79df7c0 | 2002-03-26 18:01:55 +0000 | [diff] [blame] | 231 | assert(valuesStoredInFunction && |
Chris Lattner | 649f5dd | 2002-04-14 06:15:24 +0000 | [diff] [blame] | 232 | "Should not be printing a store instruction at function exit"); |
Chris Lattner | 29c1473 | 2001-12-14 16:26:05 +0000 | [diff] [blame] | 233 | LoadInst *LI = new LoadInst(SI->getPointerOperand(), SI->copyIndices(), |
| 234 | "reload"); |
| 235 | InsertPos = BB->getInstList().insert(InsertPos, LI) + 1; |
Chris Lattner | 79df7c0 | 2002-03-26 18:01:55 +0000 | [diff] [blame] | 236 | valuesStoredInFunction->push_back(LI); |
Vikram S. Adve | 631b9a3 | 2001-10-18 18:16:11 +0000 | [diff] [blame] | 237 | } |
Chris Lattner | 29c1473 | 2001-12-14 16:26:05 +0000 | [diff] [blame] | 238 | if (ShouldTraceValue(I)) |
| 239 | InsertVerbosePrintInst(I, BB, InsertPos, " ", Printf); |
| 240 | } |
Vikram S. Adve | df1892f | 2001-10-14 23:18:45 +0000 | [diff] [blame] | 241 | } |
| 242 | |
Chris Lattner | 79df7c0 | 2002-03-26 18:01:55 +0000 | [diff] [blame] | 243 | static inline void InsertCodeToShowFunctionEntry(Function *M, Function *Printf){ |
Vikram S. Adve | 631b9a3 | 2001-10-18 18:16:11 +0000 | [diff] [blame] | 244 | // Get an iterator to point to the insertion location |
Chris Lattner | 29c1473 | 2001-12-14 16:26:05 +0000 | [diff] [blame] | 245 | BasicBlock *BB = M->getEntryNode(); |
| 246 | BasicBlock::iterator BBI = BB->begin(); |
| 247 | |
Chris Lattner | 697954c | 2002-01-20 22:54:45 +0000 | [diff] [blame] | 248 | std::ostringstream OutStr; |
Chris Lattner | 29c1473 | 2001-12-14 16:26:05 +0000 | [diff] [blame] | 249 | WriteAsOperand(OutStr, M, true); |
Chris Lattner | 649f5dd | 2002-04-14 06:15:24 +0000 | [diff] [blame] | 250 | InsertPrintInst(0, BB, BBI, "ENTERING FUNCTION: " + OutStr.str(), Printf); |
Chris Lattner | 29c1473 | 2001-12-14 16:26:05 +0000 | [diff] [blame] | 251 | |
Vikram S. Adve | 2ed5ccd | 2001-11-15 15:00:16 +0000 | [diff] [blame] | 252 | // Now print all the incoming arguments |
Chris Lattner | 79df7c0 | 2002-03-26 18:01:55 +0000 | [diff] [blame] | 253 | const Function::ArgumentListType &argList = M->getArgumentList(); |
Chris Lattner | 29c1473 | 2001-12-14 16:26:05 +0000 | [diff] [blame] | 254 | unsigned ArgNo = 0; |
Chris Lattner | 79df7c0 | 2002-03-26 18:01:55 +0000 | [diff] [blame] | 255 | for (Function::ArgumentListType::const_iterator |
Chris Lattner | 29c1473 | 2001-12-14 16:26:05 +0000 | [diff] [blame] | 256 | I = argList.begin(), E = argList.end(); I != E; ++I, ++ArgNo) { |
Chris Lattner | 73e2142 | 2002-04-09 19:48:49 +0000 | [diff] [blame] | 257 | InsertVerbosePrintInst((Value*)*I, BB, BBI, |
Chris Lattner | 29c1473 | 2001-12-14 16:26:05 +0000 | [diff] [blame] | 258 | " Arg #" + utostr(ArgNo), Printf); |
| 259 | } |
Vikram S. Adve | 631b9a3 | 2001-10-18 18:16:11 +0000 | [diff] [blame] | 260 | } |
| 261 | |
| 262 | |
Chris Lattner | 79df7c0 | 2002-03-26 18:01:55 +0000 | [diff] [blame] | 263 | static inline void InsertCodeToShowFunctionExit(BasicBlock *BB, |
| 264 | Function *Printf) { |
Vikram S. Adve | 631b9a3 | 2001-10-18 18:16:11 +0000 | [diff] [blame] | 265 | // Get an iterator to point to the insertion location |
Chris Lattner | 29c1473 | 2001-12-14 16:26:05 +0000 | [diff] [blame] | 266 | BasicBlock::iterator BBI = BB->end()-1; |
| 267 | ReturnInst *Ret = cast<ReturnInst>(*BBI); |
Vikram S. Adve | 631b9a3 | 2001-10-18 18:16:11 +0000 | [diff] [blame] | 268 | |
Chris Lattner | 697954c | 2002-01-20 22:54:45 +0000 | [diff] [blame] | 269 | std::ostringstream OutStr; |
Chris Lattner | 29c1473 | 2001-12-14 16:26:05 +0000 | [diff] [blame] | 270 | WriteAsOperand(OutStr, BB->getParent(), true); |
Chris Lattner | 649f5dd | 2002-04-14 06:15:24 +0000 | [diff] [blame] | 271 | InsertPrintInst(0, BB, BBI, "LEAVING FUNCTION: " + OutStr.str(), Printf); |
Vikram S. Adve | 631b9a3 | 2001-10-18 18:16:11 +0000 | [diff] [blame] | 272 | |
Vikram S. Adve | 2ed5ccd | 2001-11-15 15:00:16 +0000 | [diff] [blame] | 273 | // print the return value, if any |
Chris Lattner | 29c1473 | 2001-12-14 16:26:05 +0000 | [diff] [blame] | 274 | if (BB->getParent()->getReturnType() != Type::VoidTy) |
| 275 | InsertPrintInst(Ret->getReturnValue(), BB, BBI, " Returning: ", Printf); |
Vikram S. Adve | df1892f | 2001-10-14 23:18:45 +0000 | [diff] [blame] | 276 | } |
| 277 | |
| 278 | |
Chris Lattner | 79df7c0 | 2002-03-26 18:01:55 +0000 | [diff] [blame] | 279 | bool InsertTraceCode::doit(Function *M, bool traceBasicBlockExits, |
| 280 | bool traceFunctionEvents, Function *Printf) { |
| 281 | if (!traceBasicBlockExits && !traceFunctionEvents) |
Chris Lattner | 8d9e377 | 2001-10-18 05:28:08 +0000 | [diff] [blame] | 282 | return false; |
Vikram S. Adve | 631b9a3 | 2001-10-18 18:16:11 +0000 | [diff] [blame] | 283 | |
Chris Lattner | 79df7c0 | 2002-03-26 18:01:55 +0000 | [diff] [blame] | 284 | vector<Instruction*> valuesStoredInFunction; |
Chris Lattner | 29c1473 | 2001-12-14 16:26:05 +0000 | [diff] [blame] | 285 | vector<BasicBlock*> exitBlocks; |
| 286 | |
Chris Lattner | 79df7c0 | 2002-03-26 18:01:55 +0000 | [diff] [blame] | 287 | if (traceFunctionEvents) |
| 288 | InsertCodeToShowFunctionEntry(M, Printf); |
Chris Lattner | 29c1473 | 2001-12-14 16:26:05 +0000 | [diff] [blame] | 289 | |
Chris Lattner | 79df7c0 | 2002-03-26 18:01:55 +0000 | [diff] [blame] | 290 | for (Function::iterator BI = M->begin(); BI != M->end(); ++BI) { |
Chris Lattner | 29c1473 | 2001-12-14 16:26:05 +0000 | [diff] [blame] | 291 | BasicBlock *BB = *BI; |
| 292 | if (isa<ReturnInst>(BB->getTerminator())) |
| 293 | exitBlocks.push_back(BB); // record this as an exit block |
| 294 | |
| 295 | if (traceBasicBlockExits) |
Chris Lattner | 79df7c0 | 2002-03-26 18:01:55 +0000 | [diff] [blame] | 296 | TraceValuesAtBBExit(BB, Printf, &valuesStoredInFunction); |
Chris Lattner | 29c1473 | 2001-12-14 16:26:05 +0000 | [diff] [blame] | 297 | } |
| 298 | |
Chris Lattner | 79df7c0 | 2002-03-26 18:01:55 +0000 | [diff] [blame] | 299 | if (traceFunctionEvents) |
Chris Lattner | 29c1473 | 2001-12-14 16:26:05 +0000 | [diff] [blame] | 300 | for (unsigned i=0; i < exitBlocks.size(); ++i) { |
| 301 | #if 0 |
Chris Lattner | 79df7c0 | 2002-03-26 18:01:55 +0000 | [diff] [blame] | 302 | TraceValuesAtBBExit(valuesStoredInFunction, exitBlocks[i], module, |
| 303 | /*indent*/ 0, /*isFunctionExit*/ true, |
| 304 | /*valuesStoredInFunction*/ NULL); |
Chris Lattner | 29c1473 | 2001-12-14 16:26:05 +0000 | [diff] [blame] | 305 | #endif |
Chris Lattner | 79df7c0 | 2002-03-26 18:01:55 +0000 | [diff] [blame] | 306 | InsertCodeToShowFunctionExit(exitBlocks[i], Printf); |
Chris Lattner | 29c1473 | 2001-12-14 16:26:05 +0000 | [diff] [blame] | 307 | } |
Vikram S. Adve | 631b9a3 | 2001-10-18 18:16:11 +0000 | [diff] [blame] | 308 | |
Chris Lattner | 8d9e377 | 2001-10-18 05:28:08 +0000 | [diff] [blame] | 309 | return true; |
Vikram S. Adve | df1892f | 2001-10-14 23:18:45 +0000 | [diff] [blame] | 310 | } |