Home | History | Annotate | Line # | Download | only in Bitcode 
      1 //===-- BitcodeWriterPass.h - Bitcode writing pass --------------*- C++ -*-===//
      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 /// \file
      9 ///
     10 /// This file provides a bitcode writing pass.
     11 ///
     12 //===----------------------------------------------------------------------===//
     13 
     14 #ifndef LLVM_BITCODE_BITCODEWRITERPASS_H
     15 #define LLVM_BITCODE_BITCODEWRITERPASS_H
     16 
     17 #include "llvm/ADT/StringRef.h"
     18 #include "llvm/IR/PassManager.h"
     19 
     20 namespace llvm {
     21 class Module;
     22 class ModulePass;
     23 class Pass;
     24 class raw_ostream;
     25 
     26 /// Create and return a pass that writes the module to the specified
     27 /// ostream. Note that this pass is designed for use with the legacy pass
     28 /// manager.
     29 ///
     30 /// If \c ShouldPreserveUseListOrder, encode use-list order so it can be
     31 /// reproduced when deserialized.
     32 ///
     33 /// If \c EmitSummaryIndex, emit the summary index (currently for use in ThinLTO
     34 /// optimization).
     35 ///
     36 /// If \c EmitModuleHash, compute and emit the module hash in the bitcode
     37 /// (currently for use in ThinLTO incremental build).
     38 ModulePass *createBitcodeWriterPass(raw_ostream &Str,
     39                                     bool ShouldPreserveUseListOrder = false,
     40                                     bool EmitSummaryIndex = false,
     41                                     bool EmitModuleHash = false);
     42 
     43 /// Check whether a pass is a BitcodeWriterPass.
     44 bool isBitcodeWriterPass(Pass *P);
     45 
     46 /// Pass for writing a module of IR out to a bitcode file.
     47 ///
     48 /// Note that this is intended for use with the new pass manager. To construct
     49 /// a pass for the legacy pass manager, use the function above.
     50 class BitcodeWriterPass : public PassInfoMixin<BitcodeWriterPass> {
     51   raw_ostream &OS;
     52   bool ShouldPreserveUseListOrder;
     53   bool EmitSummaryIndex;
     54   bool EmitModuleHash;
     55 
     56 public:
     57   /// Construct a bitcode writer pass around a particular output stream.
     58   ///
     59   /// If \c ShouldPreserveUseListOrder, encode use-list order so it can be
     60   /// reproduced when deserialized.
     61   ///
     62   /// If \c EmitSummaryIndex, emit the summary index (currently
     63   /// for use in ThinLTO optimization).
     64   explicit BitcodeWriterPass(raw_ostream &OS,
     65                              bool ShouldPreserveUseListOrder = false,
     66                              bool EmitSummaryIndex = false,
     67                              bool EmitModuleHash = false)
     68       : OS(OS), ShouldPreserveUseListOrder(ShouldPreserveUseListOrder),
     69   EmitSummaryIndex(EmitSummaryIndex), EmitModuleHash(EmitModuleHash) {}
     70 
     71   /// Run the bitcode writer pass, and output the module to the selected
     72   /// output stream.
     73   PreservedAnalyses run(Module &M, ModuleAnalysisManager &);
     74 
     75   static bool isRequired() { return true; }
     76 };
     77 
     78 }
     79 
     80 #endif
     81