//===- BitcodeWriterPass.cpp - Bitcode writing pass -----------------------===//

//

// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.

// See https://llvm.org/LICENSE.txt for license information.

// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

//

//===----------------------------------------------------------------------===//

//

// BitcodeWriterPass implementation.

//

//===----------------------------------------------------------------------===//

#include "llvm/Bitcode/BitcodeWriterPass.h"

#include "llvm/Analysis/ModuleSummaryAnalysis.h"

#include "llvm/Bitcode/BitcodeWriter.h"

#include "llvm/IR/Module.h"

#include "llvm/IR/PassManager.h"

#include "llvm/Pass.h"

using namespace llvm;

PreservedAnalyses BitcodeWriterPass::run(Module &M, ModuleAnalysisManager &AM) {

const ModuleSummaryIndex *Index =

EmitSummaryIndex ? &(AM.getResult<ModuleSummaryIndexAnalysis>(M))

: nullptr;

WriteBitcodeToFile(M, OS, ShouldPreserveUseListOrder, Index, EmitModuleHash);

return PreservedAnalyses::all();

}

namespace {

class WriteBitcodePass : public ModulePass {

raw_ostream &OS; // raw_ostream to print on

bool ShouldPreserveUseListOrder;

bool EmitSummaryIndex;

bool EmitModuleHash;

public:

static char ID; // Pass identification, replacement for typeid

WriteBitcodePass() : ModulePass(ID), OS(dbgs()) {

initializeWriteBitcodePassPass(*PassRegistry::getPassRegistry());

}

explicit WriteBitcodePass(raw_ostream &o, bool ShouldPreserveUseListOrder,

bool EmitSummaryIndex, bool EmitModuleHash)

: ModulePass(ID), OS(o),

ShouldPreserveUseListOrder(ShouldPreserveUseListOrder),

EmitSummaryIndex(EmitSummaryIndex), EmitModuleHash(EmitModuleHash) {

initializeWriteBitcodePassPass(*PassRegistry::getPassRegistry());

}

StringRef getPassName() const override { return "Bitcode Writer"; }

bool runOnModule(Module &M) override {

const ModuleSummaryIndex *Index =

EmitSummaryIndex

? &(getAnalysis<ModuleSummaryIndexWrapperPass>().getIndex())

: nullptr;

WriteBitcodeToFile(M, OS, ShouldPreserveUseListOrder, Index,

EmitModuleHash);

return false;

}

void getAnalysisUsage(AnalysisUsage &AU) const override {

AU.setPreservesAll();

if (EmitSummaryIndex)

AU.addRequired<ModuleSummaryIndexWrapperPass>();

}

};

}

char WriteBitcodePass::ID = 0;

INITIALIZE_PASS_BEGIN(WriteBitcodePass, "write-bitcode", "Write Bitcode", false,

true)

INITIALIZE_PASS_DEPENDENCY(ModuleSummaryIndexWrapperPass)

INITIALIZE_PASS_END(WriteBitcodePass, "write-bitcode", "Write Bitcode", false,

true)

ModulePass *llvm::createBitcodeWriterPass(raw_ostream &Str,

bool ShouldPreserveUseListOrder,

bool EmitSummaryIndex, bool EmitModuleHash) {

return new WriteBitcodePass(Str, ShouldPreserveUseListOrder,

EmitSummaryIndex, EmitModuleHash);

}

bool llvm::isBitcodeWriterPass(Pass *P) {

return P->getPassID() == (llvm::AnalysisID)&WriteBitcodePass::ID;

}