From: Chris Lattner Date: Mon, 8 Mar 2004 17:06:13 +0000 (+0000) Subject: Split utility functions out of BlockProfiling.cpp X-Git-Url: http://demsky.eecs.uci.edu/git/?a=commitdiff_plain;h=467dd2ec6192fca6fe1d2a4b339fbc9b45ca3b17;p=oota-llvm.git Split utility functions out of BlockProfiling.cpp git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@12224 91177308-0d34-0410-b5e6-96231b3b80d8 --- diff --git a/lib/Transforms/Instrumentation/BlockProfiling.cpp b/lib/Transforms/Instrumentation/BlockProfiling.cpp index 8dacc92bc26..c518821a6dd 100644 --- a/lib/Transforms/Instrumentation/BlockProfiling.cpp +++ b/lib/Transforms/Instrumentation/BlockProfiling.cpp @@ -21,93 +21,11 @@ #include "llvm/Constants.h" #include "llvm/DerivedTypes.h" -#include "llvm/Instructions.h" #include "llvm/Module.h" #include "llvm/Pass.h" +#include "ProfilingUtils.h" using namespace llvm; -static void insertInitializationCall(Function *MainFn, const char *FnName, - GlobalValue *Array) { - const Type *ArgVTy = PointerType::get(PointerType::get(Type::SByteTy)); - const Type *UIntPtr = PointerType::get(Type::UIntTy); - Module &M = *MainFn->getParent(); - Function *InitFn = M.getOrInsertFunction(FnName, Type::IntTy, Type::IntTy, - ArgVTy, UIntPtr, Type::UIntTy, 0); - - // This could force argc and argv into programs that wouldn't otherwise have - // them, but instead we just pass null values in. - std::vector Args(4); - Args[0] = Constant::getNullValue(Type::IntTy); - Args[1] = Constant::getNullValue(ArgVTy); - - // Skip over any allocas in the entry block. - BasicBlock *Entry = MainFn->begin(); - BasicBlock::iterator InsertPos = Entry->begin(); - while (isa(InsertPos)) ++InsertPos; - - ConstantPointerRef *ArrayCPR = ConstantPointerRef::get(Array); - std::vector GEPIndices(2, Constant::getNullValue(Type::LongTy)); - Args[2] = ConstantExpr::getGetElementPtr(ArrayCPR, GEPIndices); - - unsigned NumElements = - cast(Array->getType()->getElementType())->getNumElements(); - Args[3] = ConstantUInt::get(Type::UIntTy, NumElements); - - Instruction *InitCall = new CallInst(InitFn, Args, "newargc", InsertPos); - - // If argc or argv are not available in main, just pass null values in. - Function::aiterator AI; - switch (MainFn->asize()) { - default: - case 2: - AI = MainFn->abegin(); ++AI; - if (AI->getType() != ArgVTy) { - InitCall->setOperand(2, new CastInst(AI, ArgVTy, "argv.cast", InitCall)); - } else { - InitCall->setOperand(2, AI); - } - - case 1: - AI = MainFn->abegin(); - // If the program looked at argc, have it look at the return value of the - // init call instead. - if (AI->getType() != Type::IntTy) { - if (!AI->use_empty()) - AI->replaceAllUsesWith(new CastInst(InitCall, AI->getType(), "", - InsertPos)); - InitCall->setOperand(1, new CastInst(AI, Type::IntTy, "argc.cast", - InitCall)); - } else { - AI->replaceAllUsesWith(InitCall); - InitCall->setOperand(1, AI); - } - - case 0: break; - } -} - -static void IncrementCounterInBlock(BasicBlock *BB, unsigned CounterNum, - ConstantPointerRef *CounterArray) { - // Insert the increment after any alloca or PHI instructions... - BasicBlock::iterator InsertPos = BB->begin(); - while (isa(InsertPos) || isa(InsertPos)) - ++InsertPos; - - // Create the getelementptr constant expression - std::vector Indices(2); - Indices[0] = Constant::getNullValue(Type::LongTy); - Indices[1] = ConstantSInt::get(Type::LongTy, CounterNum); - Constant *ElementPtr = ConstantExpr::getGetElementPtr(CounterArray, Indices); - - // Load, increment and store the value back. - Value *OldVal = new LoadInst(ElementPtr, "OldFuncCounter", InsertPos); - Value *NewVal = BinaryOperator::create(Instruction::Add, OldVal, - ConstantInt::get(Type::UIntTy, 1), - "NewFuncCounter", InsertPos); - new StoreInst(NewVal, ElementPtr, InsertPos); -} - - namespace { class FunctionProfiler : public Pass { bool run(Module &M); @@ -145,7 +63,7 @@ bool FunctionProfiler::run(Module &M) { IncrementCounterInBlock(I->begin(), i++, CounterCPR); // Add the initialization call to main. - insertInitializationCall(Main, "llvm_start_func_profiling", Counters); + InsertProfilingInitCall(Main, "llvm_start_func_profiling", Counters); return true; } @@ -186,7 +104,7 @@ bool BlockProfiler::run(Module &M) { IncrementCounterInBlock(BB, i++, CounterCPR); // Add the initialization call to main. - insertInitializationCall(Main, "llvm_start_block_profiling", Counters); + InsertProfilingInitCall(Main, "llvm_start_block_profiling", Counters); return true; } diff --git a/lib/Transforms/Instrumentation/ProfilingUtils.cpp b/lib/Transforms/Instrumentation/ProfilingUtils.cpp new file mode 100644 index 00000000000..5baefe9b365 --- /dev/null +++ b/lib/Transforms/Instrumentation/ProfilingUtils.cpp @@ -0,0 +1,102 @@ +//===- ProfilingUtils.cpp - Helper functions shared by profilers ----------===// +// +// The LLVM Compiler Infrastructure +// +// This file was developed by the LLVM research group and is distributed under +// the University of Illinois Open Source License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// This files implements a few helper functions which are used by profile +// instrumentation code to instrument the code. This allows the profiler pass +// to worry about *what* to insert, and these functions take care of *how* to do +// it. +// +//===----------------------------------------------------------------------===// + +#include "ProfilingUtils.h" +#include "llvm/Constants.h" +#include "llvm/DerivedTypes.h" +#include "llvm/Instructions.h" +#include "llvm/Module.h" + +void llvm::InsertProfilingInitCall(Function *MainFn, const char *FnName, + GlobalValue *Array) { + const Type *ArgVTy = PointerType::get(PointerType::get(Type::SByteTy)); + const Type *UIntPtr = PointerType::get(Type::UIntTy); + Module &M = *MainFn->getParent(); + Function *InitFn = M.getOrInsertFunction(FnName, Type::IntTy, Type::IntTy, + ArgVTy, UIntPtr, Type::UIntTy, 0); + + // This could force argc and argv into programs that wouldn't otherwise have + // them, but instead we just pass null values in. + std::vector Args(4); + Args[0] = Constant::getNullValue(Type::IntTy); + Args[1] = Constant::getNullValue(ArgVTy); + + // Skip over any allocas in the entry block. + BasicBlock *Entry = MainFn->begin(); + BasicBlock::iterator InsertPos = Entry->begin(); + while (isa(InsertPos)) ++InsertPos; + + ConstantPointerRef *ArrayCPR = ConstantPointerRef::get(Array); + std::vector GEPIndices(2, Constant::getNullValue(Type::LongTy)); + Args[2] = ConstantExpr::getGetElementPtr(ArrayCPR, GEPIndices); + + unsigned NumElements = + cast(Array->getType()->getElementType())->getNumElements(); + Args[3] = ConstantUInt::get(Type::UIntTy, NumElements); + + Instruction *InitCall = new CallInst(InitFn, Args, "newargc", InsertPos); + + // If argc or argv are not available in main, just pass null values in. + Function::aiterator AI; + switch (MainFn->asize()) { + default: + case 2: + AI = MainFn->abegin(); ++AI; + if (AI->getType() != ArgVTy) { + InitCall->setOperand(2, new CastInst(AI, ArgVTy, "argv.cast", InitCall)); + } else { + InitCall->setOperand(2, AI); + } + + case 1: + AI = MainFn->abegin(); + // If the program looked at argc, have it look at the return value of the + // init call instead. + if (AI->getType() != Type::IntTy) { + if (!AI->use_empty()) + AI->replaceAllUsesWith(new CastInst(InitCall, AI->getType(), "", + InsertPos)); + InitCall->setOperand(1, new CastInst(AI, Type::IntTy, "argc.cast", + InitCall)); + } else { + AI->replaceAllUsesWith(InitCall); + InitCall->setOperand(1, AI); + } + + case 0: break; + } +} + +void llvm::IncrementCounterInBlock(BasicBlock *BB, unsigned CounterNum, + ConstantPointerRef *CounterArray) { + // Insert the increment after any alloca or PHI instructions... + BasicBlock::iterator InsertPos = BB->begin(); + while (isa(InsertPos) || isa(InsertPos)) + ++InsertPos; + + // Create the getelementptr constant expression + std::vector Indices(2); + Indices[0] = Constant::getNullValue(Type::LongTy); + Indices[1] = ConstantSInt::get(Type::LongTy, CounterNum); + Constant *ElementPtr = ConstantExpr::getGetElementPtr(CounterArray, Indices); + + // Load, increment and store the value back. + Value *OldVal = new LoadInst(ElementPtr, "OldFuncCounter", InsertPos); + Value *NewVal = BinaryOperator::create(Instruction::Add, OldVal, + ConstantInt::get(Type::UIntTy, 1), + "NewFuncCounter", InsertPos); + new StoreInst(NewVal, ElementPtr, InsertPos); +} diff --git a/lib/Transforms/Instrumentation/ProfilingUtils.h b/lib/Transforms/Instrumentation/ProfilingUtils.h new file mode 100644 index 00000000000..7e8b85f4db4 --- /dev/null +++ b/lib/Transforms/Instrumentation/ProfilingUtils.h @@ -0,0 +1,32 @@ +//===- ProfilingUtils.h - Helper functions shared by profilers --*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file was developed by the LLVM research group and is distributed under +// the University of Illinois Open Source License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// This files defines a few helper functions which are used by profile +// instrumentation code to instrument the code. This allows the profiler pass +// to worry about *what* to insert, and these functions take care of *how* to do +// it. +// +//===----------------------------------------------------------------------===// + +#ifndef PROFILINGUTILS_H +#define PROFILINGUTILS_H + +namespace llvm { + class Function; + class GlobalValue; + class ConstantPointerRef; + class BasicBlock; + + void InsertProfilingInitCall(Function *MainFn, const char *FnName, + GlobalValue *Arr); + void IncrementCounterInBlock(BasicBlock *BB, unsigned CounterNum, + ConstantPointerRef *CounterArray); +} + +#endif