mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-12-29 10:32:47 +00:00
Call doInitialization(), releaseMemory(), and doFinalization() for on-the-fly passes as well.
Also don't call finalizers for LoopPass if initialization was not called. Add a unittest that tests that these methods are called, in the proper order, and the correct number of times. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@74438 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Torok Edwin
parent
23737e0423
commit
1970a89a49
@ -195,6 +195,9 @@ bool LPPassManager::runOnFunction(Function &F) {
|
||||
for (LoopInfo::iterator I = LI->begin(), E = LI->end(); I != E; ++I)
|
||||
addLoopIntoQueue(*I, LQ);
|
||||
|
||||
if (LQ.empty()) // No loops, skip calling finalizers
|
||||
return false;
|
||||
|
||||
// Initialization
|
||||
for (std::deque<Loop *>::const_iterator I = LQ.begin(), E = LQ.end();
|
||||
I != E; ++I) {
|
||||
|
||||
@ -165,11 +165,13 @@ namespace llvm {
|
||||
class FunctionPassManagerImpl : public Pass,
|
||||
public PMDataManager,
|
||||
public PMTopLevelManager {
|
||||
private:
|
||||
bool wasRun;
|
||||
public:
|
||||
static char ID;
|
||||
explicit FunctionPassManagerImpl(int Depth) :
|
||||
Pass(&ID), PMDataManager(Depth),
|
||||
PMTopLevelManager(TLM_Function) { }
|
||||
PMTopLevelManager(TLM_Function), wasRun(false) { }
|
||||
|
||||
/// add - Add a pass to the queue of passes to run. This passes ownership of
|
||||
/// the Pass to the PassManager. When the PassManager is destroyed, the pass
|
||||
@ -179,6 +181,10 @@ public:
|
||||
schedulePass(P);
|
||||
}
|
||||
|
||||
// Prepare for running an on the fly pass, freeing memory if needed
|
||||
// from a previous run.
|
||||
void releaseMemoryOnTheFly();
|
||||
|
||||
/// run - Execute all of the passes scheduled for execution. Keep track of
|
||||
/// whether any of the passes modifies the module, and if so, return true.
|
||||
bool run(Function &F);
|
||||
@ -1290,6 +1296,17 @@ void FPPassManager::cleanup() {
|
||||
}
|
||||
}
|
||||
|
||||
void FunctionPassManagerImpl::releaseMemoryOnTheFly() {
|
||||
if (!wasRun)
|
||||
return;
|
||||
for (unsigned Index = 0; Index < getNumContainedManagers(); ++Index) {
|
||||
FPPassManager *FPPM = getContainedManager(Index);
|
||||
for (unsigned Index = 0; Index < FPPM->getNumContainedPasses(); ++Index) {
|
||||
FPPM->getContainedPass(Index)->releaseMemory();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Execute all the passes managed by this top level manager.
|
||||
// Return true if any function is modified by a pass.
|
||||
bool FunctionPassManagerImpl::run(Function &F) {
|
||||
@ -1306,6 +1323,7 @@ bool FunctionPassManagerImpl::run(Function &F) {
|
||||
for (unsigned Index = 0; Index < getNumContainedManagers(); ++Index)
|
||||
getContainedManager(Index)->cleanup();
|
||||
|
||||
wasRun = true;
|
||||
return Changed;
|
||||
}
|
||||
|
||||
@ -1404,6 +1422,14 @@ bool
|
||||
MPPassManager::runOnModule(Module &M) {
|
||||
bool Changed = false;
|
||||
|
||||
// Initialize on-the-fly passes
|
||||
for (std::map<Pass *, FunctionPassManagerImpl *>::iterator
|
||||
I = OnTheFlyManagers.begin(), E = OnTheFlyManagers.end();
|
||||
I != E; ++I) {
|
||||
FunctionPassManagerImpl *FPP = I->second;
|
||||
Changed |= FPP->doInitialization(M);
|
||||
}
|
||||
|
||||
for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) {
|
||||
ModulePass *MP = getContainedPass(Index);
|
||||
|
||||
@ -1430,6 +1456,17 @@ MPPassManager::runOnModule(Module &M) {
|
||||
recordAvailableAnalysis(MP);
|
||||
removeDeadPasses(MP, M.getModuleIdentifier().c_str(), ON_MODULE_MSG);
|
||||
}
|
||||
|
||||
// Finalize on-the-fly passes
|
||||
for (std::map<Pass *, FunctionPassManagerImpl *>::iterator
|
||||
I = OnTheFlyManagers.begin(), E = OnTheFlyManagers.end();
|
||||
I != E; ++I) {
|
||||
FunctionPassManagerImpl *FPP = I->second;
|
||||
// We don't know when is the last time an on-the-fly pass is run,
|
||||
// so we need to releaseMemory / finalize here
|
||||
FPP->releaseMemoryOnTheFly();
|
||||
Changed |= FPP->doFinalization(M);
|
||||
}
|
||||
return Changed;
|
||||
}
|
||||
|
||||
@ -1466,6 +1503,7 @@ Pass* MPPassManager::getOnTheFlyPass(Pass *MP, const PassInfo *PI, Function &F){
|
||||
FunctionPassManagerImpl *FPP = OnTheFlyManagers[MP];
|
||||
assert(FPP && "Unable to find on the fly pass");
|
||||
|
||||
FPP->releaseMemoryOnTheFly();
|
||||
FPP->run(F);
|
||||
return (dynamic_cast<PMTopLevelManager *>(FPP))->findAnalysisPass(PI);
|
||||
}
|
||||
|
||||
@ -9,7 +9,7 @@
|
||||
|
||||
LEVEL = ../..
|
||||
TESTNAME = VMCore
|
||||
LINK_COMPONENTS := core support
|
||||
LINK_COMPONENTS := core support target ipa
|
||||
|
||||
include $(LEVEL)/Makefile.config
|
||||
include $(LLVM_SRC_ROOT)/unittests/Makefile.unittest
|
||||
|
||||
526
unittests/VMCore/PassManagerTest.cpp
Normal file
526
unittests/VMCore/PassManagerTest.cpp
Normal file
@ -0,0 +1,526 @@
|
||||
//===- llvm/unittest/VMCore/PassManager.cpp - Constants unit tests ------===//
|
||||
//
|
||||
// The LLVM Compiler Infrastructure
|
||||
//
|
||||
// This file is distributed under the University of Illinois Open Source
|
||||
// License. See LICENSE.TXT for details.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#include "llvm/Module.h"
|
||||
#include "llvm/PassManager.h"
|
||||
#include "llvm/Analysis/LoopInfo.h"
|
||||
#include "llvm/Pass.h"
|
||||
#include "llvm/Analysis/LoopPass.h"
|
||||
#include "llvm/CallGraphSCCPass.h"
|
||||
#include "llvm/Target/TargetData.h"
|
||||
#include "llvm/Support/raw_ostream.h"
|
||||
#include "llvm/DerivedTypes.h"
|
||||
#include "llvm/Constants.h"
|
||||
#include "llvm/GlobalVariable.h"
|
||||
#include "llvm/Function.h"
|
||||
#include "llvm/CallingConv.h"
|
||||
#include "llvm/BasicBlock.h"
|
||||
#include "llvm/Instructions.h"
|
||||
#include "llvm/InlineAsm.h"
|
||||
#include "llvm/Support/MathExtras.h"
|
||||
#include "llvm/Support/raw_ostream.h"
|
||||
#include "llvm/PassManager.h"
|
||||
#include "llvm/ADT/SmallVector.h"
|
||||
#include "llvm/Analysis/Verifier.h"
|
||||
#include "llvm/Assembly/PrintModulePass.h"
|
||||
#include "gtest/gtest.h"
|
||||
|
||||
namespace llvm {
|
||||
namespace {
|
||||
// ND = no deps
|
||||
// NM = no modifications
|
||||
struct ModuleNDNM: public ModulePass {
|
||||
public:
|
||||
static char run;
|
||||
static char ID;
|
||||
ModuleNDNM() : ModulePass(&ID) {}
|
||||
virtual bool runOnModule(Module &M) {
|
||||
run++;
|
||||
return false;
|
||||
}
|
||||
virtual void getAnalysisUsage(AnalysisUsage &AU) const {
|
||||
AU.setPreservesAll();
|
||||
}
|
||||
};
|
||||
char ModuleNDNM::ID=0;
|
||||
char ModuleNDNM::run=0;
|
||||
|
||||
struct ModuleNDM : public ModulePass {
|
||||
public:
|
||||
static char run;
|
||||
static char ID;
|
||||
ModuleNDM() : ModulePass(&ID) {}
|
||||
virtual bool runOnModule(Module &M) {
|
||||
run++;
|
||||
return true;
|
||||
}
|
||||
};
|
||||
char ModuleNDM::ID=0;
|
||||
char ModuleNDM::run=0;
|
||||
RegisterPass<ModuleNDM> X("mndm","mndm",false,false);
|
||||
|
||||
struct ModuleNDM2 : public ModulePass {
|
||||
public:
|
||||
static char run;
|
||||
static char ID;
|
||||
ModuleNDM2() : ModulePass(&ID) {}
|
||||
virtual bool runOnModule(Module &M) {
|
||||
run++;
|
||||
return true;
|
||||
}
|
||||
};
|
||||
char ModuleNDM2::ID=0;
|
||||
char ModuleNDM2::run=0;
|
||||
|
||||
struct ModuleDNM : public ModulePass {
|
||||
public:
|
||||
static char run;
|
||||
static char ID;
|
||||
ModuleDNM() : ModulePass(&ID) {}
|
||||
virtual bool runOnModule(Module &M) {
|
||||
EXPECT_TRUE(getAnalysisIfAvailable<TargetData>());
|
||||
run++;
|
||||
return false;
|
||||
}
|
||||
virtual void getAnalysisUsage(AnalysisUsage &AU) const {
|
||||
AU.addRequired<ModuleNDM>();
|
||||
AU.setPreservesAll();
|
||||
}
|
||||
};
|
||||
char ModuleDNM::ID=0;
|
||||
char ModuleDNM::run=0;
|
||||
|
||||
template<typename P>
|
||||
struct PassTestBase : public P {
|
||||
protected:
|
||||
static int runc;
|
||||
static bool initialized;
|
||||
static bool finalized;
|
||||
int allocated;
|
||||
void run() {
|
||||
EXPECT_EQ(true, initialized);
|
||||
EXPECT_EQ(false, finalized);
|
||||
EXPECT_EQ(0, allocated);
|
||||
allocated++;
|
||||
runc++;
|
||||
}
|
||||
public:
|
||||
static char ID;
|
||||
static void finishedOK(int run) {
|
||||
EXPECT_GT(runc, 0);
|
||||
EXPECT_EQ(true, initialized);
|
||||
EXPECT_EQ(true, finalized);
|
||||
EXPECT_EQ(run, runc);
|
||||
}
|
||||
PassTestBase() : P(&ID), allocated(0) {
|
||||
initialized = false;
|
||||
finalized = false;
|
||||
runc = 0;
|
||||
}
|
||||
|
||||
virtual void releaseMemory() {
|
||||
EXPECT_GT(runc, 0);
|
||||
EXPECT_GT(allocated, 0);
|
||||
allocated--;
|
||||
}
|
||||
};
|
||||
template<typename P> char PassTestBase<P>::ID;
|
||||
template<typename P> int PassTestBase<P>::runc;
|
||||
template<typename P> bool PassTestBase<P>::initialized;
|
||||
template<typename P> bool PassTestBase<P>::finalized;
|
||||
|
||||
template<typename T, typename P>
|
||||
struct PassTest : public PassTestBase<P> {
|
||||
public:
|
||||
virtual bool doInitialization(T &t) {
|
||||
EXPECT_EQ(false, PassTestBase<P>::initialized);
|
||||
PassTestBase<P>::initialized = true;
|
||||
return false;
|
||||
}
|
||||
virtual bool doFinalization(T &t) {
|
||||
EXPECT_EQ(false, PassTestBase<P>::finalized);
|
||||
PassTestBase<P>::finalized = true;
|
||||
EXPECT_EQ(0, PassTestBase<P>::allocated);
|
||||
return false;
|
||||
}
|
||||
};
|
||||
|
||||
struct CGPass : public PassTest<CallGraph, CallGraphSCCPass> {
|
||||
public:
|
||||
virtual bool runOnSCC(const std::vector<CallGraphNode*> &SCMM) {
|
||||
EXPECT_TRUE(getAnalysisIfAvailable<TargetData>());
|
||||
run();
|
||||
return false;
|
||||
}
|
||||
};
|
||||
RegisterPass<CGPass> X1("cgp","cgp");
|
||||
|
||||
struct FPass : public PassTest<Module, FunctionPass> {
|
||||
public:
|
||||
virtual bool runOnFunction(Function &F) {
|
||||
// FIXME: PR4112
|
||||
// EXPECT_TRUE(getAnalysisIfAvailable<TargetData>());
|
||||
run();
|
||||
return false;
|
||||
}
|
||||
};
|
||||
RegisterPass<FPass> X2("fp","fp");
|
||||
|
||||
struct LPass : public PassTestBase<LoopPass> {
|
||||
private:
|
||||
static int initcount;
|
||||
static int fincount;
|
||||
public:
|
||||
LPass() {
|
||||
initcount = 0; fincount=0;
|
||||
EXPECT_EQ(false, initialized);
|
||||
}
|
||||
static void finishedOK(int run, int finalized) {
|
||||
PassTestBase<LoopPass>::finishedOK(run);
|
||||
EXPECT_EQ(run, initcount);
|
||||
EXPECT_EQ(finalized, fincount);
|
||||
}
|
||||
virtual bool doInitialization(Loop* L, LPPassManager &LPM) {
|
||||
initialized = true;
|
||||
initcount++;
|
||||
return false;
|
||||
}
|
||||
virtual bool runOnLoop(Loop *L, LPPassManager &LPM) {
|
||||
EXPECT_TRUE(getAnalysisIfAvailable<TargetData>());
|
||||
run();
|
||||
return false;
|
||||
}
|
||||
virtual bool doFinalization() {
|
||||
fincount++;
|
||||
finalized = true;
|
||||
return false;
|
||||
}
|
||||
};
|
||||
int LPass::initcount=0;
|
||||
int LPass::fincount=0;
|
||||
RegisterPass<LPass> X3("lp","lp");
|
||||
|
||||
struct BPass : public PassTestBase<BasicBlockPass> {
|
||||
private:
|
||||
static int inited;
|
||||
static int fin;
|
||||
public:
|
||||
static void finishedOK(int run, int N) {
|
||||
PassTestBase<BasicBlockPass>::finishedOK(run);
|
||||
EXPECT_EQ(inited, N);
|
||||
EXPECT_EQ(fin, N);
|
||||
}
|
||||
BPass() {
|
||||
inited = 0;
|
||||
fin = 0;
|
||||
}
|
||||
virtual bool doInitialization(Module &M) {
|
||||
EXPECT_EQ(false, initialized);
|
||||
initialized = true;
|
||||
return false;
|
||||
}
|
||||
virtual bool doInitialization(Function &F) {
|
||||
inited++;
|
||||
return false;
|
||||
}
|
||||
virtual bool runOnBasicBlock(BasicBlock &BB) {
|
||||
EXPECT_TRUE(getAnalysisIfAvailable<TargetData>());
|
||||
run();
|
||||
return false;
|
||||
}
|
||||
virtual bool doFinalization(Function &F) {
|
||||
fin++;
|
||||
return false;
|
||||
}
|
||||
virtual bool doFinalization(Module &M) {
|
||||
EXPECT_EQ(false, finalized);
|
||||
finalized = true;
|
||||
EXPECT_EQ(0, allocated);
|
||||
return false;
|
||||
}
|
||||
};
|
||||
int BPass::inited=0;
|
||||
int BPass::fin=0;
|
||||
RegisterPass<BPass> X4("bp","bp");
|
||||
|
||||
struct OnTheFlyTest: public ModulePass {
|
||||
public:
|
||||
static char ID;
|
||||
OnTheFlyTest() : ModulePass(&ID) {}
|
||||
virtual bool runOnModule(Module &M) {
|
||||
EXPECT_TRUE(getAnalysisIfAvailable<TargetData>());
|
||||
for (Module::iterator I=M.begin(),E=M.end(); I != E; ++I) {
|
||||
Function &F = *I;
|
||||
{
|
||||
SCOPED_TRACE("Running on the fly function pass");
|
||||
getAnalysis<FPass>(F);
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
virtual void getAnalysisUsage(AnalysisUsage &AU) const {
|
||||
AU.addRequired<FPass>();
|
||||
}
|
||||
};
|
||||
char OnTheFlyTest::ID=0;
|
||||
|
||||
TEST(PassManager, RunOnce) {
|
||||
Module M("test-once");
|
||||
struct ModuleNDNM *mNDNM = new ModuleNDNM();
|
||||
struct ModuleDNM *mDNM = new ModuleDNM();
|
||||
struct ModuleNDM *mNDM = new ModuleNDM();
|
||||
struct ModuleNDM2 *mNDM2 = new ModuleNDM2();
|
||||
|
||||
mNDM->run = mNDNM->run = mDNM->run = mNDM2->run = 0;
|
||||
|
||||
PassManager Passes;
|
||||
Passes.add(new TargetData(&M));
|
||||
Passes.add(mNDM2);
|
||||
Passes.add(mNDM);
|
||||
Passes.add(mNDNM);
|
||||
Passes.add(mDNM);
|
||||
|
||||
Passes.run(M);
|
||||
// each pass must be run exactly once, since nothing invalidates them
|
||||
EXPECT_EQ(1, mNDM->run);
|
||||
EXPECT_EQ(1, mNDNM->run);
|
||||
EXPECT_EQ(1, mDNM->run);
|
||||
EXPECT_EQ(1, mNDM2->run);
|
||||
}
|
||||
|
||||
TEST(PassManager, ReRun) {
|
||||
Module M("test-rerun");
|
||||
struct ModuleNDNM *mNDNM = new ModuleNDNM();
|
||||
struct ModuleDNM *mDNM = new ModuleDNM();
|
||||
struct ModuleNDM *mNDM = new ModuleNDM();
|
||||
struct ModuleNDM2 *mNDM2 = new ModuleNDM2();
|
||||
|
||||
mNDM->run = mNDNM->run = mDNM->run = mNDM2->run = 0;
|
||||
|
||||
PassManager Passes;
|
||||
Passes.add(new TargetData(&M));
|
||||
Passes.add(mNDM);
|
||||
Passes.add(mNDNM);
|
||||
Passes.add(mNDM2);// invalidates mNDM needed by mDNM
|
||||
Passes.add(mDNM);
|
||||
|
||||
Passes.run(M);
|
||||
// Some passes must be rerun because a pass that modified the
|
||||
// module/function was run inbetween
|
||||
EXPECT_EQ(2, mNDM->run);
|
||||
EXPECT_EQ(1, mNDNM->run);
|
||||
EXPECT_EQ(1, mNDM2->run);
|
||||
EXPECT_EQ(1, mDNM->run);
|
||||
}
|
||||
|
||||
Module* makeLLVMModule();
|
||||
|
||||
template<typename T>
|
||||
void MemoryTestHelper(int run) {
|
||||
Module *M = makeLLVMModule();
|
||||
T *P = new T();
|
||||
PassManager Passes;
|
||||
Passes.add(new TargetData(M));
|
||||
Passes.add(P);
|
||||
Passes.run(*M);
|
||||
T::finishedOK(run);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
void MemoryTestHelper(int run, int N) {
|
||||
Module *M = makeLLVMModule();
|
||||
T *P = new T();
|
||||
PassManager Passes;
|
||||
Passes.add(new TargetData(M));
|
||||
Passes.add(P);
|
||||
Passes.run(*M);
|
||||
T::finishedOK(run, N);
|
||||
delete M;
|
||||
}
|
||||
|
||||
TEST(PassManager, Memory) {
|
||||
// SCC#1: test1->test2->test3->test1
|
||||
// SCC#2: test4
|
||||
// SCC#3: indirect call node
|
||||
{
|
||||
SCOPED_TRACE("Callgraph pass");
|
||||
MemoryTestHelper<CGPass>(3);
|
||||
}
|
||||
|
||||
{
|
||||
SCOPED_TRACE("Function pass");
|
||||
MemoryTestHelper<FPass>(4);// 4 functions
|
||||
}
|
||||
|
||||
{
|
||||
SCOPED_TRACE("Loop pass");
|
||||
MemoryTestHelper<LPass>(2, 1); //2 loops, 1 function
|
||||
}
|
||||
{
|
||||
SCOPED_TRACE("Basic block pass");
|
||||
MemoryTestHelper<BPass>(7, 4); //9 basic blocks
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
TEST(PassManager, MemoryOnTheFly) {
|
||||
Module *M = makeLLVMModule();
|
||||
{
|
||||
SCOPED_TRACE("Running OnTheFlyTest");
|
||||
struct OnTheFlyTest *O = new OnTheFlyTest();
|
||||
PassManager Passes;
|
||||
Passes.add(new TargetData(M));
|
||||
Passes.add(O);
|
||||
Passes.run(*M);
|
||||
|
||||
FPass::finishedOK(4);
|
||||
}
|
||||
delete M;
|
||||
}
|
||||
|
||||
Module* makeLLVMModule() {
|
||||
// Module Construction
|
||||
Module* mod = new Module("test-mem");
|
||||
mod->setDataLayout("e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
|
||||
"i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-"
|
||||
"a0:0:64-s0:64:64-f80:128:128");
|
||||
mod->setTargetTriple("x86_64-unknown-linux-gnu");
|
||||
|
||||
// Type Definitions
|
||||
std::vector<const Type*>FuncTy_0_args;
|
||||
FunctionType* FuncTy_0 = FunctionType::get(
|
||||
/*Result=*/IntegerType::get(32),
|
||||
/*Params=*/FuncTy_0_args,
|
||||
/*isVarArg=*/false);
|
||||
|
||||
std::vector<const Type*>FuncTy_2_args;
|
||||
FuncTy_2_args.push_back(IntegerType::get(1));
|
||||
FunctionType* FuncTy_2 = FunctionType::get(
|
||||
/*Result=*/Type::VoidTy,
|
||||
/*Params=*/FuncTy_2_args,
|
||||
/*isVarArg=*/false);
|
||||
|
||||
|
||||
// Function Declarations
|
||||
|
||||
Function* func_test1 = Function::Create(
|
||||
/*Type=*/FuncTy_0,
|
||||
/*Linkage=*/GlobalValue::ExternalLinkage,
|
||||
/*Name=*/"test1", mod);
|
||||
func_test1->setCallingConv(CallingConv::C);
|
||||
AttrListPtr func_test1_PAL;
|
||||
func_test1->setAttributes(func_test1_PAL);
|
||||
|
||||
Function* func_test2 = Function::Create(
|
||||
/*Type=*/FuncTy_0,
|
||||
/*Linkage=*/GlobalValue::ExternalLinkage,
|
||||
/*Name=*/"test2", mod);
|
||||
func_test2->setCallingConv(CallingConv::C);
|
||||
AttrListPtr func_test2_PAL;
|
||||
func_test2->setAttributes(func_test2_PAL);
|
||||
|
||||
Function* func_test3 = Function::Create(
|
||||
/*Type=*/FuncTy_0,
|
||||
/*Linkage=*/GlobalValue::ExternalLinkage,
|
||||
/*Name=*/"test3", mod);
|
||||
func_test3->setCallingConv(CallingConv::C);
|
||||
AttrListPtr func_test3_PAL;
|
||||
func_test3->setAttributes(func_test3_PAL);
|
||||
|
||||
Function* func_test4 = Function::Create(
|
||||
/*Type=*/FuncTy_2,
|
||||
/*Linkage=*/GlobalValue::ExternalLinkage,
|
||||
/*Name=*/"test4", mod);
|
||||
func_test4->setCallingConv(CallingConv::C);
|
||||
AttrListPtr func_test4_PAL;
|
||||
func_test4->setAttributes(func_test4_PAL);
|
||||
|
||||
// Global Variable Declarations
|
||||
|
||||
|
||||
// Constant Definitions
|
||||
|
||||
// Global Variable Definitions
|
||||
|
||||
// Function Definitions
|
||||
|
||||
// Function: test1 (func_test1)
|
||||
{
|
||||
|
||||
BasicBlock* label_entry = BasicBlock::Create("entry",func_test1,0);
|
||||
|
||||
// Block entry (label_entry)
|
||||
CallInst* int32_3 = CallInst::Create(func_test2, "", label_entry);
|
||||
int32_3->setCallingConv(CallingConv::C);
|
||||
int32_3->setTailCall(false);AttrListPtr int32_3_PAL;
|
||||
int32_3->setAttributes(int32_3_PAL);
|
||||
|
||||
ReturnInst::Create(int32_3, label_entry);
|
||||
|
||||
}
|
||||
|
||||
// Function: test2 (func_test2)
|
||||
{
|
||||
|
||||
BasicBlock* label_entry_5 = BasicBlock::Create("entry",func_test2,0);
|
||||
|
||||
// Block entry (label_entry_5)
|
||||
CallInst* int32_6 = CallInst::Create(func_test3, "", label_entry_5);
|
||||
int32_6->setCallingConv(CallingConv::C);
|
||||
int32_6->setTailCall(false);AttrListPtr int32_6_PAL;
|
||||
int32_6->setAttributes(int32_6_PAL);
|
||||
|
||||
ReturnInst::Create(int32_6, label_entry_5);
|
||||
|
||||
}
|
||||
|
||||
// Function: test3 (func_test3)
|
||||
{
|
||||
|
||||
BasicBlock* label_entry_8 = BasicBlock::Create("entry",func_test3,0);
|
||||
|
||||
// Block entry (label_entry_8)
|
||||
CallInst* int32_9 = CallInst::Create(func_test1, "", label_entry_8);
|
||||
int32_9->setCallingConv(CallingConv::C);
|
||||
int32_9->setTailCall(false);AttrListPtr int32_9_PAL;
|
||||
int32_9->setAttributes(int32_9_PAL);
|
||||
|
||||
ReturnInst::Create(int32_9, label_entry_8);
|
||||
|
||||
}
|
||||
|
||||
// Function: test4 (func_test4)
|
||||
{
|
||||
Function::arg_iterator args = func_test4->arg_begin();
|
||||
Value* int1_f = args++;
|
||||
int1_f->setName("f");
|
||||
|
||||
BasicBlock* label_entry_11 = BasicBlock::Create("entry",func_test4,0);
|
||||
BasicBlock* label_bb = BasicBlock::Create("bb",func_test4,0);
|
||||
BasicBlock* label_bb1 = BasicBlock::Create("bb1",func_test4,0);
|
||||
BasicBlock* label_return = BasicBlock::Create("return",func_test4,0);
|
||||
|
||||
// Block entry (label_entry_11)
|
||||
BranchInst::Create(label_bb, label_entry_11);
|
||||
|
||||
// Block bb (label_bb)
|
||||
BranchInst::Create(label_bb, label_bb1, int1_f, label_bb);
|
||||
|
||||
// Block bb1 (label_bb1)
|
||||
BranchInst::Create(label_bb1, label_return, int1_f, label_bb1);
|
||||
|
||||
// Block return (label_return)
|
||||
ReturnInst::Create(label_return);
|
||||
|
||||
}
|
||||
return mod;
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
Loading…
Reference in New Issue
Block a user