6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-01-12 17:32:19 +00:00
Code Issues Projects Releases Wiki Activity

* s/Method/Function

Browse Source 
* Fix bug where the character after a % was being discarded


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@2248 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Chris Lattner 2002-04-14 06:15:24 +00:00
parent 3e0e520728
commit 649f5dd77a
1 changed files with 18 additions and 27 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

41
lib/Transforms/Instrumentation/TraceValues.cpp
View File

@ -1,6 +1,6 @@
//===- TraceValues.cpp - Value Tracing for debugging -------------*- C++ -*--=// //===- 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. // exits.
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
@ -38,13 +38,13 @@ namespace {
//-------------------------------------------------------------------------- //--------------------------------------------------------------------------
// Function InsertCodeToTraceValues // 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'. // exits as specified by `traceBasicBlockExits' and `traceFunctionExits'.
// //
static bool doit(Function *M, bool traceBasicBlockExits, static bool doit(Function *M, bool traceBasicBlockExits,
bool traceFunctionExits, Function *Printf); bool traceFunctionExits, Function *Printf);
// runOnMethod - This method does the work. Always successful. // runOnFunction - This method does the work.
// //
bool runOnMethod(Function *F) { bool runOnMethod(Function *F) {
return doit(F, TraceBasicBlockExits, TraceFunctionExits, PrintfFunc); return doit(F, TraceBasicBlockExits, TraceFunctionExits, PrintfFunc);
@ -53,11 +53,11 @@ namespace {
} // end anonymous namespace } // end anonymous namespace
Pass *createTraceValuesPassForMethod() { // Just trace methods Pass *createTraceValuesPassForMethod() { // Just trace functions
return new InsertTraceCode(false, true); return new InsertTraceCode(false, true);
} }
Pass *createTraceValuesPassForBasicBlocks() { // Trace BB's and methods Pass *createTraceValuesPassForBasicBlocks() { // Trace BB's and functions
return new InsertTraceCode(true, true); return new InsertTraceCode(true, true);
} }
@ -123,25 +123,16 @@ static bool ShouldTraceValue(const Instruction *I) {
static string getPrintfCodeFor(const Value *V) { static string getPrintfCodeFor(const Value *V) {
if (V == 0) return ""; if (V == 0) return "";
switch (V->getType()->getPrimitiveID()) { if (V->getType()->isFloatingPoint())
case Type::BoolTyID: return "%g";
case Type::UByteTyID: case Type::UShortTyID: else if (V->getType() == Type::LabelTy || isa<PointerType>(V->getType()))
case Type::UIntTyID: case Type::ULongTyID: return "0x%p";
case Type::SByteTyID: case Type::ShortTyID: else if (V->getType()->isIntegral() || V->getType() == Type::BoolTy)
case Type::IntTyID: case Type::LongTyID:
return "%d"; return "%d";
case Type::FloatTyID: case Type::DoubleTyID:
return "%g";
case Type::LabelTyID: case Type::PointerTyID:
return "%p";
default:
assert(0 && "Illegal value to print out..."); assert(0 && "Illegal value to print out...");
return ""; return "";
} }
}
static void InsertPrintInst(Value *V, BasicBlock *BB, BasicBlock::iterator &BBI, static void InsertPrintInst(Value *V, BasicBlock *BB, BasicBlock::iterator &BBI,
@ -149,7 +140,7 @@ static void InsertPrintInst(Value *V, BasicBlock *BB, BasicBlock::iterator &BBI,
// Escape Message by replacing all % characters with %% chars. // Escape Message by replacing all % characters with %% chars.
unsigned Offset = 0; unsigned Offset = 0;
while ((Offset = Message.find('%', Offset)) != string::npos) { while ((Offset = Message.find('%', Offset)) != string::npos) {
Message.replace(Offset, 2, "%%"); Message.replace(Offset, 1, "%%");
Offset += 2; // Skip over the new %'s Offset += 2; // Skip over the new %'s
} }
@ -188,8 +179,8 @@ static void InsertVerbosePrintInst(Value *V, BasicBlock *BB,
// or that is stored to memory in this basic block. // or that is stored to memory in this basic block.
// If the value is stored to memory, we load it back before printing // If the value is stored to memory, we load it back before printing
// We also return all such loaded values in the vector valuesStoredInFunction // We also return all such loaded values in the vector valuesStoredInFunction
// for printing at the exit from the method. (Note that in each invocation // for printing at the exit from the function. (Note that in each invocation
// of the method, this will only get the last value stored for each static // of the function, this will only get the last value stored for each static
// store instruction). // store instruction).
// *bb must be the block in which the value is computed; // *bb must be the block in which the value is computed;
// this is not checked here. // this is not checked here.
@ -232,7 +223,7 @@ static void TraceValuesAtBBExit(BasicBlock *BB, Function *Printf,
Instruction *I = *II; Instruction *I = *II;
if (StoreInst *SI = dyn_cast<StoreInst>(I)) { if (StoreInst *SI = dyn_cast<StoreInst>(I)) {
assert(valuesStoredInFunction && 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(), LoadInst *LI = new LoadInst(SI->getPointerOperand(), SI->copyIndices(),
"reload"); "reload");
InsertPos = BB->getInstList().insert(InsertPos, LI) + 1; InsertPos = BB->getInstList().insert(InsertPos, LI) + 1;
@ -250,7 +241,7 @@ static inline void InsertCodeToShowFunctionEntry(Function *M, Function *Printf){
std::ostringstream OutStr; std::ostringstream OutStr;
WriteAsOperand(OutStr, M, true); 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 // Now print all the incoming arguments
const Function::ArgumentListType &argList = M->getArgumentList(); const Function::ArgumentListType &argList = M->getArgumentList();
@ -271,7 +262,7 @@ static inline void InsertCodeToShowFunctionExit(BasicBlock *BB,
std::ostringstream OutStr; std::ostringstream OutStr;
WriteAsOperand(OutStr, BB->getParent(), true); 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 // print the return value, if any
if (BB->getParent()->getReturnType() != Type::VoidTy) if (BB->getParent()->getReturnType() != Type::VoidTy)