Changeset 5913

Timestamp:

Mar 18, 2018, 11:27:16 AM (13 months ago)

Author:

cameron

Message:

Restructuring step

Location:

icGREP/icgrep-devel/icgrep

Files:

• grep/grep_engine.cpp (modified) (21 diffs)
• grep/grep_engine.h (modified) (4 diffs)
• icgrep.cpp (modified) (2 diffs)
• toolchain/cpudriver.cpp (modified) (8 diffs)
• toolchain/cpudriver.h (modified) (3 diffs)

icGREP/icgrep-devel/icgrep/grep/grep_engine.cpp

@@ -70 +70 @@
     
 
-void accumulate_match_wrapper(intptr_t accum_addr, const size_t lineNum, char * line_start, char * line_end) {
+extern "C" void accumulate_match_wrapper(intptr_t accum_addr, const size_t lineNum, char * line_start, char * line_end) {
     reinterpret_cast<MatchAccumulator *>(accum_addr)->accumulate_match(lineNum, line_start, line_end);
 }
 
-void finalize_match_wrapper(intptr_t accum_addr, char * buffer_end) {
+extern "C" void finalize_match_wrapper(intptr_t accum_addr, char * buffer_end) {
     reinterpret_cast<MatchAccumulator *>(accum_addr)->finalize_match(buffer_end);
 }
@@ -99 +99 @@
     
     idb->SetInsertPoint(BasicBlock::Create(M->getContext(), "entry", mainFunc, 0));
-    
     StreamSetBuffer * ByteStream = pxDriver.addBuffer<SourceBuffer>(idb, idb->getStreamSetTy(1, 8));
     kernel::Kernel * sourceK = pxDriver.addKernelInstance<kernel::MemorySourceKernel>(idb, idb->getInt8PtrTy());
@@ -185 +184 @@
 }
 
+    
+
+    
 void GrepEngine::initFileResult(std::vector<std::string> & filenames) {
     const unsigned n = filenames.size();
@@ -192 +194 @@
 }
 
+void GrepEngine::initREs(std::vector<re::RE *> & REs) {
+    if (mGrepRecordBreak == GrepRecordBreakKind::Unicode) {
+        mBreakCC = re::makeCC(re::makeCC(0x0A, 0x0D), re::makeCC(re::makeCC(0x85), re::makeCC(0x2028, 0x2029)));
+    } else if (mGrepRecordBreak == GrepRecordBreakKind::Null) {
+        mBreakCC = re::makeByte(0);  // Null
+    } else {
+        mBreakCC = re::makeByte(0x0A); // LF
+    }
+    re::RE * anchorRE = mBreakCC;
+    if (mGrepRecordBreak == GrepRecordBreakKind::Unicode) {
+        re::Name * anchorName = re::makeName("UTF8_LB", re::Name::Type::Unicode);
+        anchorName->setDefinition(UCD::UnicodeBreakRE());
+        anchorRE = anchorName;
+    }
+    
+    mREs = REs;
+    for(unsigned i = 0; i < mREs.size(); ++i) {
+        mREs[i] = resolveModesAndExternalSymbols(mREs[i]);
+        mREs[i] = re::exclude_CC(mREs[i], mBreakCC);
+        mREs[i] = resolveAnchors(mREs[i], anchorRE);
+        re::gatherUnicodeProperties(mREs[i], mUnicodeProperties);
+        mREs[i] = regular_expression_passes(mREs[i]);
+    }
+
+}
+
+
+    
 // Code Generation
 //
@@ -201 +231 @@
 }
     
-std::pair<StreamSetBuffer *, StreamSetBuffer *> GrepEngine::grepPipeline(std::vector<re::RE *> & REs, StreamSetBuffer * ByteStream) {
+std::pair<StreamSetBuffer *, StreamSetBuffer *> GrepEngine::grepPipeline(StreamSetBuffer * ByteStream) {
     auto & idb = mGrepDriver->getBuilder();
     const unsigned segmentSize = codegen::SegmentSize;
@@ -211 +241 @@
     
     //  Regular Expression Processing and Analysis Phase
-    const auto nREs = REs.size();
+    const auto nREs = mREs.size();
     bool hasGCB[nREs];
     bool anyGCB = false;
-    
-    std::set<re::Name *> UnicodeProperties;
-    
-    re::CC * breakCC = nullptr;
-    std::string breakName;
-    if (mGrepRecordBreak == GrepRecordBreakKind::Unicode) {
-        breakCC = re::makeCC(re::makeCC(0x0A, 0x0D), re::makeCC(re::makeCC(0x85), re::makeCC(0x2028, 0x2029)));
-    } else if (mGrepRecordBreak == GrepRecordBreakKind::Null) {
-        breakCC = re::makeByte(0);  // Null
-    } else {
-        breakCC = re::makeByte(0x0A); // LF
-    }
-    re::RE * anchorRE = breakCC;
-    if (mGrepRecordBreak == GrepRecordBreakKind::Unicode) {
-        re::Name * anchorName = re::makeName("UTF8_LB", re::Name::Type::Unicode);
-        anchorName->setDefinition(UCD::UnicodeBreakRE());
-        anchorRE = anchorName;
-    }
 
     for(unsigned i = 0; i < nREs; ++i) {
-        REs[i] = resolveModesAndExternalSymbols(REs[i]);
-        REs[i] = re::exclude_CC(REs[i], breakCC);
-        REs[i] = resolveAnchors(REs[i], anchorRE);
-        re::gatherUnicodeProperties(REs[i], UnicodeProperties);
-        REs[i] = regular_expression_passes(REs[i]);
-        hasGCB[i] = hasGraphemeClusterBoundary(REs[i]);
+        hasGCB[i] = hasGraphemeClusterBoundary(mREs[i]);
         anyGCB |= hasGCB[i];
     }
-    
     StreamSetBuffer * LineBreakStream = mGrepDriver->addBuffer<CircularBuffer>(idb, idb->getStreamSetTy(1, 1), baseBufferSize);
     std::vector<StreamSetBuffer *> MatchResultsBufs(nREs);
@@ -252 +258 @@
     bool isSimple = (nREs == 1) && (mGrepRecordBreak != GrepRecordBreakKind::Unicode) && (!anyGCB);
     if (isSimple) {
-        REs[0] = toUTF8(REs[0]);
-    }
-    if (isSimple && byteTestsWithinLimit(REs[0], ByteCClimit)) {
+        mREs[0] = toUTF8(mREs[0]);
+    }
+    if (isSimple && byteTestsWithinLimit(mREs[0], ByteCClimit)) {
         StreamSetBuffer * MatchResults = mGrepDriver->addBuffer<CircularBuffer>(idb, idb->getStreamSetTy(1, 1), baseBufferSize);
-        kernel::Kernel * icgrepK = mGrepDriver->addKernelInstance<kernel::ByteGrepKernel>(idb, REs[0]);
+        kernel::Kernel * icgrepK = mGrepDriver->addKernelInstance<kernel::ByteGrepKernel>(idb, mREs[0]);
         mGrepDriver->makeKernelCall(icgrepK, {ByteStream}, {MatchResults});
         MatchResultsBufs[0] = MatchResults;
-        kernel::Kernel * breakK = mGrepDriver->addKernelInstance<kernel::DirectCharacterClassKernelBuilder>(idb, "breakCC", std::vector<re::CC *>{breakCC}, 1);
+        kernel::Kernel * breakK = mGrepDriver->addKernelInstance<kernel::DirectCharacterClassKernelBuilder>(idb, "breakCC", std::vector<re::CC *>{mBreakCC}, 1);
         mGrepDriver->makeKernelCall(breakK, {ByteStream}, {LineBreakStream});
-    } else if (isSimple && hasTriCCwithinLimit(REs[0], ByteCClimit, prefixRE, suffixRE)) {
+    } else if (isSimple && hasTriCCwithinLimit(mREs[0], ByteCClimit, prefixRE, suffixRE)) {
         StreamSetBuffer * MatchResults = mGrepDriver->addBuffer<CircularBuffer>(idb, idb->getStreamSetTy(1, 1), baseBufferSize);
         kernel::Kernel * icgrepK = mGrepDriver->addKernelInstance<kernel::ByteBitGrepKernel>(idb, prefixRE, suffixRE);
         mGrepDriver->makeKernelCall(icgrepK, {ByteStream}, {MatchResults});
         MatchResultsBufs[0] = MatchResults;
-        kernel::Kernel * breakK = mGrepDriver->addKernelInstance<kernel::DirectCharacterClassKernelBuilder>(idb, "breakCC", std::vector<re::CC *>{breakCC}, 1);
+        kernel::Kernel * breakK = mGrepDriver->addKernelInstance<kernel::DirectCharacterClassKernelBuilder>(idb, "breakCC", std::vector<re::CC *>{mBreakCC}, 1);
         mGrepDriver->makeKernelCall(breakK, {ByteStream}, {LineBreakStream});
     } else {
+        
         StreamSetBuffer * BasisBits = mGrepDriver->addBuffer<CircularBuffer>(idb, idb->getStreamSetTy(encodingBits, 1), baseBufferSize);
         kernel::Kernel * s2pk = nullptr;
@@ -292 +299 @@
             LineBreakStream = LineFeedStream;
         } else if (mGrepRecordBreak == GrepRecordBreakKind::Null) {
-            kernel::Kernel * breakK = mGrepDriver->addKernelInstance<kernel::ParabixCharacterClassKernelBuilder>(idb, "Null", std::vector<re::CC *>{breakCC}, 8);
+            kernel::Kernel * breakK = mGrepDriver->addKernelInstance<kernel::ParabixCharacterClassKernelBuilder>(idb, "Null", std::vector<re::CC *>{mBreakCC}, 8);
             mGrepDriver->makeKernelCall(breakK, {BasisBits}, {LineBreakStream});
         } else {
@@ -300 +307 @@
         std::map<std::string, StreamSetBuffer *> propertyStream;
         if (PropertyKernels) {
-            for (auto p : UnicodeProperties) {
+            for (auto p : mUnicodeProperties) {
                 auto name = p->getFullName();
                 StreamSetBuffer * s = mGrepDriver->addBuffer<CircularBuffer>(idb, idb->getStreamSetTy(1, 1), baseBufferSize);
@@ -326 +333 @@
             std::set<re::Name *> UnicodeProperties;
             if (PropertyKernels) {
-                re::gatherUnicodeProperties(REs[i], UnicodeProperties);
+                re::gatherUnicodeProperties(mREs[i], UnicodeProperties);
                 for (auto p : UnicodeProperties) {
                     auto name = p->getFullName();
@@ -340 +347 @@
             }
             if (CC_Multiplexing) {
-                const auto UnicodeSets = re::collectUnicodeSets(REs[i], std::set<re::Name *>({re::makeZeroWidth("\\b{g}")}));
+                const auto UnicodeSets = re::collectUnicodeSets(mREs[i], std::set<re::Name *>({re::makeZeroWidth("\\b{g}")}));
                 StreamSetBuffer * const MatchResults = mGrepDriver->addBuffer<CircularBuffer>(idb, idb->getStreamSetTy(1, 1), baseBufferSize);
                 if (UnicodeSets.size() <= 1) {
-                    kernel::Kernel * icgrepK = mGrepDriver->addKernelInstance<kernel::ICGrepKernel>(idb, REs[i], externalStreamNames);
+                    kernel::Kernel * icgrepK = mGrepDriver->addKernelInstance<kernel::ICGrepKernel>(idb, mREs[i], externalStreamNames);
                     mGrepDriver->makeKernelCall(icgrepK, icgrepInputSets, {MatchResults});
                     MatchResultsBufs[i] = MatchResults;
                 } else {
                     mpx = make_unique<MultiplexedAlphabet>("mpx", UnicodeSets);
-                    REs[i] = transformCCs(mpx.get(), REs[i]);
+                    mREs[i] = transformCCs(mpx.get(), mREs[i]);
                     std::vector<re::CC *> mpx_basis = mpx->getMultiplexedCCs();
                     auto numOfCharacterClasses = mpx_basis.size();
@@ -356 +363 @@
     //                kernel::Kernel * ccK = mGrepDriver->addKernelInstance<kernel::CharClassesKernel>(idb, std::move(mpx_basis), true);
     //                mGrepDriver->makeKernelCall(ccK, {ByteStream}, {CharClasses});
-                    kernel::Kernel * icgrepK = mGrepDriver->addKernelInstance<kernel::ICGrepKernel>(idb, REs[i], externalStreamNames, std::vector<cc::Alphabet *>{mpx.get()});
+                    kernel::Kernel * icgrepK = mGrepDriver->addKernelInstance<kernel::ICGrepKernel>(idb, mREs[i], externalStreamNames, std::vector<cc::Alphabet *>{mpx.get()});
                     icgrepInputSets.push_back(CharClasses);
                     mGrepDriver->makeKernelCall(icgrepK, icgrepInputSets, {MatchResults});
@@ -363 +370 @@
             } else {
                 StreamSetBuffer * MatchResults = mGrepDriver->addBuffer<CircularBuffer>(idb, idb->getStreamSetTy(1, 1), baseBufferSize);
-                kernel::Kernel * icgrepK = mGrepDriver->addKernelInstance<kernel::ICGrepKernel>(idb, REs[i], externalStreamNames);
+                kernel::Kernel * icgrepK = mGrepDriver->addKernelInstance<kernel::ICGrepKernel>(idb, mREs[i], externalStreamNames);
                 mGrepDriver->makeKernelCall(icgrepK, icgrepInputSets, {MatchResults});
                 MatchResultsBufs[i] = MatchResults;
@@ -369 +376 @@
         }
     }
+
     StreamSetBuffer * MergedResults = MatchResultsBufs[0];
-    if (REs.size() > 1) {
+    if (mREs.size() > 1) {
         MergedResults = mGrepDriver->addBuffer<CircularBuffer>(idb, idb->getStreamSetTy(1, 1), baseBufferSize);
-        kernel::Kernel * streamsMergeK = mGrepDriver->addKernelInstance<kernel::StreamsMerge>(idb, 1, REs.size());
+        kernel::Kernel * streamsMergeK = mGrepDriver->addKernelInstance<kernel::StreamsMerge>(idb, 1, mREs.size());
         mGrepDriver->makeKernelCall(streamsMergeK, MatchResultsBufs, {MergedResults});
     }
     StreamSetBuffer * Matches = MergedResults;
-
     if (mMoveMatchesToEOL) {
         StreamSetBuffer * OriginalMatches = Matches;
@@ -383 +390 @@
         mGrepDriver->makeKernelCall(matchedLinesK, {OriginalMatches, LineBreakStream}, {Matches});
     }
-
     if (InvertMatchFlag) {
         kernel::Kernel * invertK = mGrepDriver->addKernelInstance<kernel::InvertMatchesKernel>(idb);
@@ -397 +403 @@
         mGrepDriver->makeKernelCall(untilK, {AllMatches}, {Matches});
     }
+
     return std::pair<StreamSetBuffer *, StreamSetBuffer *>(LineBreakStream, Matches);
 }
@@ -404 +411 @@
 //
 
-void GrepEngine::grepCodeGen(std::vector<re::RE *> REs) {
+void GrepEngine::grepCodeGen() {
 
     assert (mGrepDriver == nullptr);
@@ -428 +435 @@
     StreamSetBuffer * LineBreakStream;
     StreamSetBuffer * Matches;
-    std::tie(LineBreakStream, Matches) = grepPipeline(REs, ByteStream);
+    std::tie(LineBreakStream, Matches) = grepPipeline(ByteStream);
 
     kernel::Kernel * matchCountK = mGrepDriver->addKernelInstance<kernel::PopcountKernel>(idb);
@@ -498 +505 @@
 }
 
-void EmitMatchesEngine::grepCodeGen(std::vector<re::RE *> REs) {
+void EmitMatchesEngine::grepCodeGen() {
     assert (mGrepDriver == nullptr);
     mGrepDriver = new ParabixDriver("engine");
@@ -523 +530 @@
     StreamSetBuffer * LineBreakStream;
     StreamSetBuffer * Matches;
-    std::tie(LineBreakStream, Matches) = grepPipeline(REs, ByteStream);
+    std::tie(LineBreakStream, Matches) = grepPipeline(ByteStream);
 
     kernel::Kernel * scanMatchK = mGrepDriver->addKernelInstance<kernel::ScanMatchKernel>(idb);
@@ -642 +649 @@
     }
     // Main thread also does the work;
-
     DoGrepThreadMethod();
     for(unsigned i = 1; i < numOfThreads; ++i) {

icGREP/icgrep-devel/icgrep/grep/grep_engine.h

@@ -31 +31 @@
 };
 
-void accumulate_match_wrapper(intptr_t accum_addr, const size_t lineNum, char * line_start, char * line_end);
+extern "C" void accumulate_match_wrapper(intptr_t accum_addr, const size_t lineNum, char * line_start, char * line_end);
 
-void finalize_match_wrapper(intptr_t accum_addr, char * buffer_end);
+extern "C" void finalize_match_wrapper(intptr_t accum_addr, char * buffer_end);
 
 void grepBuffer(re::RE * pattern, const char * buffer, size_t bufferLength, MatchAccumulator * accum);
@@ -46 +46 @@
     void setRecordBreak(GrepRecordBreakKind b);
     void initFileResult(std::vector<std::string> & filenames);
-    virtual void grepCodeGen(std::vector<re::RE *> REs);
+    void initREs(std::vector<re::RE *> & REs);
+    virtual void grepCodeGen();
     bool searchAllFiles();
     void * DoGrepThreadMethod();
 
 protected:
-    std::pair<parabix::StreamSetBuffer *, parabix::StreamSetBuffer *> grepPipeline(std::vector<re::RE *> & REs, parabix::StreamSetBuffer * ByteStream);
+    std::pair<parabix::StreamSetBuffer *, parabix::StreamSetBuffer *> grepPipeline(parabix::StreamSetBuffer * ByteStream);
 
     virtual uint64_t doGrep(const std::string & fileName, const uint32_t fileIdx);
@@ -66 +67 @@
     bool grepMatchFound;
     GrepRecordBreakKind mGrepRecordBreak;
-
+    
+    std::vector<re:: RE *> mREs;
+    std::set<re::Name *> mUnicodeProperties;
+    re::CC * mBreakCC;
     std::unique_ptr<cc::MultiplexedAlphabet> mpx;
     std::string mFileSuffix;
@@ -76 +80 @@
 public:
     EmitMatchesEngine();
-    void grepCodeGen(std::vector<re::RE *> REs) override;
+    void grepCodeGen() override;
 private:
     uint64_t doGrep(const std::string & fileName, const uint32_t fileIdx) override;

icGREP/icgrep-devel/icgrep/icgrep.cpp

@@ -172 +172 @@
     grep::InitializeCommandLineInterface(argc, argv);
     
-    const auto REs = readExpressions();
+    auto REs = readExpressions();
 
     std::vector<std::string> allFiles = getFullFileList(inputFiles);
@@ -204 +204 @@
         grepEngine->setRecordBreak(grep::GrepRecordBreakKind::LF);
     }
-    
-    grepEngine->grepCodeGen(REs);
-
+    grepEngine->initREs(REs);
+    grepEngine->grepCodeGen();
     grepEngine->initFileResult(allFiles);
-    
     bool matchFound = grepEngine->searchAllFiles();
-    
     delete(grepEngine);
     

icGREP/icgrep-devel/icgrep/toolchain/cpudriver.cpp

@@ -3 +3 @@
 #include <IR_Gen/idisa_target.h>
 #include <toolchain/toolchain.h>
+#include <llvm/Support/DynamicLibrary.h>           // for LoadLibraryPermanently
+#include <llvm/ExecutionEngine/RuntimeDyld.h>
+#include <llvm/ExecutionEngine/RTDyldMemoryManager.h>
 #include <llvm/ExecutionEngine/ExecutionEngine.h>  // for EngineBuilder
 #include <llvm/IR/LegacyPassManager.h>             // for PassManager
@@ -47 +50 @@
     InitializeNativeTargetAsmPrinter();
     InitializeNativeTargetAsmParser();
-
-    PassRegistry * Registry = PassRegistry::getPassRegistry();
-    initializeCore(*Registry);
-    initializeCodeGen(*Registry);
-    initializeLowerIntrinsicsPass(*Registry);
+    llvm::sys::DynamicLibrary::LoadLibraryPermanently(nullptr);
+
+    preparePassManager();
 
     std::string errMessage;
@@ -143 +144 @@
 }
 
-void ParabixDriver::finalizeObject() {
-
-    legacy::PassManager PM;
+void ParabixDriver::preparePassManager() {
+    PassRegistry * Registry = PassRegistry::getPassRegistry();
+    initializeCore(*Registry);
+    initializeCodeGen(*Registry);
+    initializeLowerIntrinsicsPass(*Registry);
+    
     if (LLVM_UNLIKELY(codegen::ShowUnoptimizedIROption != codegen::OmittedOption)) {
         if (LLVM_LIKELY(mIROutputStream == nullptr)) {
@@ -155 +159 @@
             }
         }
-        PM.add(createPrintModulePass(*mIROutputStream));
+        mPassManager.add(createPrintModulePass(*mIROutputStream));
     }
     if (IN_DEBUG_MODE || LLVM_UNLIKELY(codegen::DebugOptionIsSet(codegen::VerifyIR))) {
-        PM.add(createVerifierPass());
-    }
-    PM.add(createPromoteMemoryToRegisterPass());    // Promote stack variables to constants or PHI nodes
-    PM.add(createCFGSimplificationPass());          // Remove dead basic blocks and unnecessary branch statements / phi nodes
-    PM.add(createEarlyCSEPass());                   // Simple common subexpression elimination pass
-    PM.add(createInstructionCombiningPass());       // Simple peephole optimizations and bit-twiddling.
-    PM.add(createReassociatePass());                // Canonicalizes commutative expressions
-    PM.add(createGVNPass());                        // Global value numbering redundant expression elimination pass
-    PM.add(createCFGSimplificationPass());          // Repeat CFG Simplification to "clean up" any newly found redundant phi nodes
-
+        mPassManager.add(createVerifierPass());
+    }
+    mPassManager.add(createPromoteMemoryToRegisterPass());    // Promote stack variables to constants or PHI nodes
+    mPassManager.add(createCFGSimplificationPass());          // Remove dead basic blocks and unnecessary branch statements / phi nodes
+    mPassManager.add(createEarlyCSEPass());                   // Simple common subexpression elimination pass
+    mPassManager.add(createInstructionCombiningPass());       // Simple peephole optimizations and bit-twiddling.
+    mPassManager.add(createReassociatePass());                // Canonicalizes commutative expressions
+    mPassManager.add(createGVNPass());                        // Global value numbering redundant expression elimination pass
+    mPassManager.add(createCFGSimplificationPass());          // Repeat CFG Simplification to "clean up" any newly found redundant phi nodes
+    
     if (LLVM_UNLIKELY(codegen::ShowIROption != codegen::OmittedOption)) {
         if (LLVM_LIKELY(mIROutputStream == nullptr)) {
@@ -177 +181 @@
             }
         }
-        PM.add(createPrintModulePass(*mIROutputStream));
-    }
-
+        mPassManager.add(createPrintModulePass(*mIROutputStream));
+    }
+    
 #if LLVM_VERSION_INTEGER >= LLVM_VERSION_CODE(3, 7, 0)
     if (LLVM_UNLIKELY(codegen::ShowASMOption != codegen::OmittedOption)) {
@@ -188 +192 @@
             mASMOutputStream = new raw_fd_ostream(STDERR_FILENO, false, true);
         }
-        if (LLVM_UNLIKELY(mTarget->addPassesToEmitFile(PM, *mASMOutputStream, TargetMachine::CGFT_AssemblyFile))) {
+        if (LLVM_UNLIKELY(mTarget->addPassesToEmitFile(mPassManager, *mASMOutputStream, TargetMachine::CGFT_AssemblyFile))) {
             report_fatal_error("LLVM error: could not add emit assembly pass");
         }
     }
 #endif
+}
+
+
+void ParabixDriver::finalizeObject() {
 
     Module * module = nullptr;
@@ -201 +209 @@
             module = kernel->getModule(); assert (module);
             module->setTargetTriple(mMainModule->getTargetTriple());
-            PM.run(*module);
+            mPassManager.run(*module);
         }
         module = mMainModule;
         iBuilder->setKernel(nullptr);
-        PM.run(*mMainModule);
+        mPassManager.run(*mMainModule);
         for (Kernel * const kernel : mPipeline) {
             if (LLVM_UNLIKELY(kernel->getModule() == nullptr)) {
@@ -220 +228 @@
 
 bool ParabixDriver::hasExternalFunction(llvm::StringRef functionName) const {
-    return mEngine->getPointerToNamedFunction(functionName, false) != nullptr;
+    return RTDyldMemoryManager::getSymbolAddressInProcess(functionName);
 }
 

icGREP/icgrep-devel/icgrep/toolchain/cpudriver.h

@@ -2 +2 @@
 #define CPUDRIVER_H
 #include "driver.h"
+#include <llvm/IR/LegacyPassManager.h>             // for PassManager
 
 namespace llvm { class ExecutionEngine; }
@@ -29 +30 @@
 
 private:
+    void preparePassManager();
 
     llvm::Function * addLinkFunction(llvm::Module * mod, llvm::StringRef name, llvm::FunctionType * type, void * functionPtr) const override;
@@ -34 +36 @@
 private:
     llvm::TargetMachine *                                   mTarget;
+    llvm::legacy::PassManager                               mPassManager;
     llvm::ExecutionEngine *                                 mEngine;
     ParabixObjectCache *                                    mCache;