//===- TraceValues.cpp - Value Tracing for debugging -------------*- C++ -*--=//
//
-// Support for inserting LLVM code to print values at basic block and method
+// Support for inserting LLVM code to print values at basic block and function
// exits.
//
//===----------------------------------------------------------------------===//
#include "llvm/Transforms/Instrumentation/TraceValues.h"
#include "llvm/GlobalVariable.h"
-#include "llvm/ConstantVals.h"
+#include "llvm/Constants.h"
#include "llvm/DerivedTypes.h"
#include "llvm/iMemory.h"
#include "llvm/iTerminators.h"
#include "llvm/iOther.h"
+#include "llvm/BasicBlock.h"
#include "llvm/Function.h"
#include "llvm/Module.h"
-#include "llvm/SymbolTable.h"
#include "llvm/Pass.h"
#include "llvm/Assembly/Writer.h"
#include "Support/StringExtras.h"
using std::string;
namespace {
- class InsertTraceCode : public MethodPass {
+ class InsertTraceCode : public FunctionPass {
bool TraceBasicBlockExits, TraceFunctionExits;
Function *PrintfFunc;
public:
//--------------------------------------------------------------------------
// Function InsertCodeToTraceValues
//
- // Inserts tracing code for all live values at basic block and/or method
+ // Inserts tracing code for all live values at basic block and/or function
// exits as specified by `traceBasicBlockExits' and `traceFunctionExits'.
//
static bool doit(Function *M, bool traceBasicBlockExits,
bool traceFunctionExits, Function *Printf);
- // runOnMethod - This method does the work. Always successful.
+ // runOnFunction - This method does the work.
//
- bool runOnMethod(Function *F) {
+ bool runOnFunction(Function *F) {
return doit(F, TraceBasicBlockExits, TraceFunctionExits, PrintfFunc);
}
};
} // end anonymous namespace
-Pass *createTraceValuesPassForMethod() { // Just trace methods
+Pass *createTraceValuesPassForFunction() { // Just trace functions
return new InsertTraceCode(false, true);
}
-Pass *createTraceValuesPassForBasicBlocks() { // Trace BB's and methods
+Pass *createTraceValuesPassForBasicBlocks() { // Trace BB's and functions
return new InsertTraceCode(true, true);
}
// Add a prototype for printf if it is not already in the program.
//
bool InsertTraceCode::doInitialization(Module *M) {
- SymbolTable *ST = M->getSymbolTable();
const Type *SBP = PointerType::get(Type::SByteTy);
- const MethodType *MTy =
- MethodType::get(Type::IntTy, vector<const Type*>(1, SBP), true);
+ const FunctionType *MTy =
+ FunctionType::get(Type::IntTy, vector<const Type*>(1, SBP), true);
- if (Value *Func = ST->lookup(PointerType::get(MTy), "printf")) {
- PrintfFunc = cast<Function>(Func);
- return false;
- }
-
- // Create a new method and add it to the module
- PrintfFunc = new Function(MTy, false, "printf");
- M->getFunctionList().push_back(PrintfFunc);
- return true;
+ PrintfFunc = M->getOrInsertFunction("printf", MTy);
+ return false;
}
static string getPrintfCodeFor(const Value *V) {
if (V == 0) return "";
- switch (V->getType()->getPrimitiveID()) {
- case Type::BoolTyID:
- case Type::UByteTyID: case Type::UShortTyID:
- case Type::UIntTyID: case Type::ULongTyID:
- case Type::SByteTyID: case Type::ShortTyID:
- case Type::IntTyID: case Type::LongTyID:
- return "%d";
-
- case Type::FloatTyID: case Type::DoubleTyID:
+ if (V->getType()->isFloatingPoint())
return "%g";
-
- case Type::LabelTyID: case Type::PointerTyID:
- return "%p";
+ else if (V->getType() == Type::LabelTy || isa<PointerType>(V->getType()))
+ return "0x%p";
+ else if (V->getType()->isIntegral() || V->getType() == Type::BoolTy)
+ return "%d";
- default:
- assert(0 && "Illegal value to print out...");
- return "";
- }
+ assert(0 && "Illegal value to print out...");
+ return "";
}
// Escape Message by replacing all % characters with %% chars.
unsigned Offset = 0;
while ((Offset = Message.find('%', Offset)) != string::npos) {
- Message.replace(Offset, 2, "%%");
+ Message.replace(Offset, 1, "%%");
Offset += 2; // Skip over the new %'s
}
// or that is stored to memory in this basic block.
// If the value is stored to memory, we load it back before printing
// We also return all such loaded values in the vector valuesStoredInFunction
-// for printing at the exit from the method. (Note that in each invocation
-// of the method, this will only get the last value stored for each static
+// for printing at the exit from the function. (Note that in each invocation
+// of the function, this will only get the last value stored for each static
// store instruction).
// *bb must be the block in which the value is computed;
// this is not checked here.
Instruction *I = *II;
if (StoreInst *SI = dyn_cast<StoreInst>(I)) {
assert(valuesStoredInFunction &&
- "Should not be printing a store instruction at method exit");
+ "Should not be printing a store instruction at function exit");
LoadInst *LI = new LoadInst(SI->getPointerOperand(), SI->copyIndices(),
"reload");
InsertPos = BB->getInstList().insert(InsertPos, LI) + 1;
std::ostringstream OutStr;
WriteAsOperand(OutStr, M, true);
- InsertPrintInst(0, BB, BBI, "ENTERING METHOD: " + OutStr.str(), Printf);
+ InsertPrintInst(0, BB, BBI, "ENTERING FUNCTION: " + OutStr.str(), Printf);
// Now print all the incoming arguments
const Function::ArgumentListType &argList = M->getArgumentList();
unsigned ArgNo = 0;
for (Function::ArgumentListType::const_iterator
I = argList.begin(), E = argList.end(); I != E; ++I, ++ArgNo) {
- InsertVerbosePrintInst(*I, BB, BBI,
+ InsertVerbosePrintInst((Value*)*I, BB, BBI,
" Arg #" + utostr(ArgNo), Printf);
}
}
std::ostringstream OutStr;
WriteAsOperand(OutStr, BB->getParent(), true);
- InsertPrintInst(0, BB, BBI, "LEAVING METHOD: " + OutStr.str(), Printf);
+ InsertPrintInst(0, BB, BBI, "LEAVING FUNCTION: " + OutStr.str(), Printf);
// print the return value, if any
if (BB->getParent()->getReturnType() != Type::VoidTy)