LLVM  10.0.0svn
BitcodeWriterPass.cpp
Go to the documentation of this file.
1 //===- BitcodeWriterPass.cpp - Bitcode writing pass -----------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // BitcodeWriterPass implementation.
10 //
11 //===----------------------------------------------------------------------===//
12 
16 #include "llvm/IR/Module.h"
17 #include "llvm/IR/PassManager.h"
18 #include "llvm/Pass.h"
19 using namespace llvm;
20 
22  const ModuleSummaryIndex *Index =
23  EmitSummaryIndex ? &(AM.getResult<ModuleSummaryIndexAnalysis>(M))
24  : nullptr;
25  WriteBitcodeToFile(M, OS, ShouldPreserveUseListOrder, Index, EmitModuleHash);
26  return PreservedAnalyses::all();
27 }
28 
29 namespace {
30  class WriteBitcodePass : public ModulePass {
31  raw_ostream &OS; // raw_ostream to print on
32  bool ShouldPreserveUseListOrder;
33  bool EmitSummaryIndex;
34  bool EmitModuleHash;
35 
36  public:
37  static char ID; // Pass identification, replacement for typeid
38  WriteBitcodePass() : ModulePass(ID), OS(dbgs()) {
40  }
41 
42  explicit WriteBitcodePass(raw_ostream &o, bool ShouldPreserveUseListOrder,
43  bool EmitSummaryIndex, bool EmitModuleHash)
44  : ModulePass(ID), OS(o),
45  ShouldPreserveUseListOrder(ShouldPreserveUseListOrder),
46  EmitSummaryIndex(EmitSummaryIndex), EmitModuleHash(EmitModuleHash) {
48  }
49 
50  StringRef getPassName() const override { return "Bitcode Writer"; }
51 
52  bool runOnModule(Module &M) override {
53  const ModuleSummaryIndex *Index =
54  EmitSummaryIndex
55  ? &(getAnalysis<ModuleSummaryIndexWrapperPass>().getIndex())
56  : nullptr;
57  WriteBitcodeToFile(M, OS, ShouldPreserveUseListOrder, Index,
58  EmitModuleHash);
59  return false;
60  }
61  void getAnalysisUsage(AnalysisUsage &AU) const override {
62  AU.setPreservesAll();
63  if (EmitSummaryIndex)
65  }
66  };
67 }
68 
69 char WriteBitcodePass::ID = 0;
70 INITIALIZE_PASS_BEGIN(WriteBitcodePass, "write-bitcode", "Write Bitcode", false,
71  true)
73 INITIALIZE_PASS_END(WriteBitcodePass, "write-bitcode", "Write Bitcode", false,
74  true)
75 
77  bool ShouldPreserveUseListOrder,
78  bool EmitSummaryIndex, bool EmitModuleHash) {
79  return new WriteBitcodePass(Str, ShouldPreserveUseListOrder,
80  EmitSummaryIndex, EmitModuleHash);
81 }
82 
84  return P->getPassID() == (llvm::AnalysisID)&WriteBitcodePass::ID;
85 }
Pass interface - Implemented by all &#39;passes&#39;.
Definition: Pass.h:80
static PassRegistry * getPassRegistry()
getPassRegistry - Access the global registry object, which is automatically initialized at applicatio...
PassT::Result & getResult(IRUnitT &IR, ExtraArgTs... ExtraArgs)
Get the result of an analysis pass for a given IR unit.
Definition: PassManager.h:777
This class represents lattice values for constants.
Definition: AllocatorList.h:23
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:66
This is the interface to build a ModuleSummaryIndex for a module.
This file provides a bitcode writing pass.
block Block Frequency true
Analysis pass to provide the ModuleSummaryIndex object.
INITIALIZE_PASS_BEGIN(WriteBitcodePass, "write-bitcode", "Write Bitcode", false, true) INITIALIZE_PASS_END(WriteBitcodePass
AnalysisUsage & addRequired()
#define INITIALIZE_PASS_DEPENDENCY(depName)
Definition: PassSupport.h:50
write bitcode
bool isBitcodeWriterPass(Pass *P)
Check whether a pass is a BitcodeWriterPass.
Class to hold module path string table and global value map, and encapsulate methods for operating on...
#define P(N)
void initializeWriteBitcodePassPass(PassRegistry &)
A set of analyses that are preserved following a run of a transformation pass.
Definition: PassManager.h:154
AnalysisID getPassID() const
getPassID - Return the PassID number that corresponds to this pass.
Definition: Pass.h:99
void WriteBitcodeToFile(const Module &M, raw_ostream &Out, bool ShouldPreserveUseListOrder=false, const ModuleSummaryIndex *Index=nullptr, bool GenerateHash=false, ModuleHash *ModHash=nullptr)
Write the specified module to the specified raw output stream.
Represent the analysis usage information of a pass.
static void write(bool isBE, void *P, T V)
static PreservedAnalyses all()
Construct a special preserved set that preserves all passes.
Definition: PassManager.h:160
INITIALIZE_PASS_END(RegBankSelect, DEBUG_TYPE, "Assign register bank of generic virtual registers", false, false) RegBankSelect
write Write Bitcode
Module.h This file contains the declarations for the Module class.
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:132
const void * AnalysisID
Definition: Pass.h:48
void setPreservesAll()
Set by analyses that do not transform their input at all.
ModulePass * createBitcodeWriterPass(raw_ostream &Str, bool ShouldPreserveUseListOrder=false, bool EmitSummaryIndex=false, bool EmitModuleHash=false)
Create and return a pass that writes the module to the specified ostream.
ModulePass class - This class is used to implement unstructured interprocedural optimizations and ana...
Definition: Pass.h:224
PreservedAnalyses run(Module &M, ModuleAnalysisManager &)
Run the bitcode writer pass, and output the module to the selected output stream. ...
This class implements an extremely fast bulk output stream that can only output to a stream...
Definition: raw_ostream.h:45
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:48
A container for analyses that lazily runs them and caches their results.
This header defines various interfaces for pass management in LLVM.
Legacy wrapper pass to provide the ModuleSummaryIndex object.