/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/lib/CodeGen/CodeGenAction.cpp

Bug Summary

File:	tools/clang/lib/CodeGen/CodeGenAction.cpp
Warning:	line 890, column 47 Use of memory after it is freed

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name CodeGenAction.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-eagerly-assume -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -mrelocation-model pic -pic-level 2 -mthread-model posix -relaxed-aliasing -fmath-errno -masm-verbose -mconstructor-aliases -munwind-tables -fuse-init-array -target-cpu x86-64 -dwarf-column-info -debugger-tuning=gdb -momit-leaf-frame-pointer -ffunction-sections -fdata-sections -resource-dir /usr/lib/llvm-7/lib/clang/7.0.0 -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-7~svn329677/build-llvm/tools/clang/lib/CodeGen -I /build/llvm-toolchain-snapshot-7~svn329677/tools/clang/lib/CodeGen -I /build/llvm-toolchain-snapshot-7~svn329677/tools/clang/include -I /build/llvm-toolchain-snapshot-7~svn329677/build-llvm/tools/clang/include -I /build/llvm-toolchain-snapshot-7~svn329677/build-llvm/include -I /build/llvm-toolchain-snapshot-7~svn329677/include -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/c++/7.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/x86_64-linux-gnu/c++/7.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/x86_64-linux-gnu/c++/7.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/c++/7.3.0/backward -internal-isystem /usr/include/clang/7.0.0/include/ -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-7/lib/clang/7.0.0/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-comment -std=c++11 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-7~svn329677/build-llvm/tools/clang/lib/CodeGen -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -fobjc-runtime=gcc -fno-common -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-checker optin.performance.Padding -analyzer-output=html -analyzer-config stable-report-filename=true -o /tmp/scan-build-2018-04-11-031539-24776-1 -x c++ /build/llvm-toolchain-snapshot-7~svn329677/tools/clang/lib/CodeGen/CodeGenAction.cpp

/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/lib/CodeGen/CodeGenAction.cpp

→

1//===--- CodeGenAction.cpp - LLVM Code Generation Frontend Action ---------===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//

10#include "clang/CodeGen/CodeGenAction.h"
11#include "CodeGenModule.h"
12#include "CoverageMappingGen.h"
13#include "MacroPPCallbacks.h"
14#include "clang/AST/ASTConsumer.h"
15#include "clang/AST/ASTContext.h"
16#include "clang/AST/DeclCXX.h"
17#include "clang/AST/DeclGroup.h"
18#include "clang/Basic/FileManager.h"
19#include "clang/Basic/SourceManager.h"
20#include "clang/Basic/TargetInfo.h"
21#include "clang/CodeGen/BackendUtil.h"
22#include "clang/CodeGen/ModuleBuilder.h"
23#include "clang/Frontend/CompilerInstance.h"
24#include "clang/Frontend/FrontendDiagnostic.h"
25#include "clang/Lex/Preprocessor.h"
26#include "llvm/Bitcode/BitcodeReader.h"
27#include "llvm/CodeGen/MachineOptimizationRemarkEmitter.h"
28#include "llvm/IR/DebugInfo.h"
29#include "llvm/IR/DiagnosticInfo.h"
30#include "llvm/IR/DiagnosticPrinter.h"
31#include "llvm/IR/GlobalValue.h"
32#include "llvm/IR/LLVMContext.h"
33#include "llvm/IR/Module.h"
34#include "llvm/IRReader/IRReader.h"
35#include "llvm/Linker/Linker.h"
36#include "llvm/Pass.h"
37#include "llvm/Support/MemoryBuffer.h"
38#include "llvm/Support/SourceMgr.h"
39#include "llvm/Support/Timer.h"
40#include "llvm/Support/ToolOutputFile.h"
41#include "llvm/Support/YAMLTraits.h"
42#include "llvm/Transforms/IPO/Internalize.h"

44#include <memory>
45using namespace clang;
46using namespace llvm;

48namespace clang {
class BackendConsumer;
class ClangDiagnosticHandler final : public DiagnosticHandler {
public:
  ClangDiagnosticHandler(const CodeGenOptions &CGOpts, BackendConsumer *BCon)
      : CodeGenOpts(CGOpts), BackendCon(BCon) {}

  bool handleDiagnostics(const DiagnosticInfo &DI) override;

  bool isAnalysisRemarkEnabled(StringRef PassName) const override {
    return (CodeGenOpts.OptimizationRemarkAnalysisPattern &&
            CodeGenOpts.OptimizationRemarkAnalysisPattern->match(PassName));
  }
  bool isMissedOptRemarkEnabled(StringRef PassName) const override {
    return (CodeGenOpts.OptimizationRemarkMissedPattern &&
            CodeGenOpts.OptimizationRemarkMissedPattern->match(PassName));
  }
  bool isPassedOptRemarkEnabled(StringRef PassName) const override {
    return (CodeGenOpts.OptimizationRemarkPattern &&
            CodeGenOpts.OptimizationRemarkPattern->match(PassName));
  }

  bool isAnyRemarkEnabled() const override {
    return (CodeGenOpts.OptimizationRemarkAnalysisPattern ||
            CodeGenOpts.OptimizationRemarkMissedPattern ||
            CodeGenOpts.OptimizationRemarkPattern);
  }

private:
  const CodeGenOptions &CodeGenOpts;
  BackendConsumer *BackendCon;
};

class BackendConsumer : public ASTConsumer {
  using LinkModule = CodeGenAction::LinkModule;

  virtual void anchor();
  DiagnosticsEngine &Diags;
  BackendAction Action;
  const HeaderSearchOptions &HeaderSearchOpts;
  const CodeGenOptions &CodeGenOpts;
  const TargetOptions &TargetOpts;
  const LangOptions &LangOpts;
  std::unique_ptr<raw_pwrite_stream> AsmOutStream;
  ASTContext *Context;

  Timer LLVMIRGeneration;
  unsigned LLVMIRGenerationRefCount;

  /// True if we've finished generating IR. This prevents us from generating
  /// additional LLVM IR after emitting output in HandleTranslationUnit. This
  /// can happen when Clang plugins trigger additional AST deserialization.
  bool IRGenFinished = false;

  std::unique_ptr<CodeGenerator> Gen;

  SmallVector<LinkModule, 4> LinkModules;

  // This is here so that the diagnostic printer knows the module a diagnostic
  // refers to.
  llvm::Module *CurLinkModule = nullptr;

public:
  BackendConsumer(BackendAction Action, DiagnosticsEngine &Diags,
                  const HeaderSearchOptions &HeaderSearchOpts,
                  const PreprocessorOptions &PPOpts,
                  const CodeGenOptions &CodeGenOpts,
                  const TargetOptions &TargetOpts,
                  const LangOptions &LangOpts, bool TimePasses,
                  const std::string &InFile,
                  SmallVector<LinkModule, 4> LinkModules,
                  std::unique_ptr<raw_pwrite_stream> OS, LLVMContext &C,
                  CoverageSourceInfo *CoverageInfo = nullptr)
      : Diags(Diags), Action(Action), HeaderSearchOpts(HeaderSearchOpts),
        CodeGenOpts(CodeGenOpts), TargetOpts(TargetOpts), LangOpts(LangOpts),
        AsmOutStream(std::move(OS)), Context(nullptr),
        LLVMIRGeneration("irgen", "LLVM IR Generation Time"),
        LLVMIRGenerationRefCount(0),
        Gen(CreateLLVMCodeGen(Diags, InFile, HeaderSearchOpts, PPOpts,
                              CodeGenOpts, C, CoverageInfo)),
        LinkModules(std::move(LinkModules)) {
    llvm::TimePassesIsEnabled = TimePasses;
  }
  llvm::Module *getModule() const { return Gen->GetModule(); }
  std::unique_ptr<llvm::Module> takeModule() {
    return std::unique_ptr<llvm::Module>(Gen->ReleaseModule());
  }

  CodeGenerator *getCodeGenerator() { return Gen.get(); }

  void HandleCXXStaticMemberVarInstantiation(VarDecl *VD) override {
    Gen->HandleCXXStaticMemberVarInstantiation(VD);
  }

  void Initialize(ASTContext &Ctx) override {
    assert(!Context && "initialized multiple times")(static_cast <bool> (!Context && "initialized multiple times"
) ? void (0) : __assert_fail ("!Context && \"initialized multiple times\""
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/lib/CodeGen/CodeGenAction.cpp"
, 143, __extension__ __PRETTY_FUNCTION__));

    Context = &Ctx;

    if (llvm::TimePassesIsEnabled)
      LLVMIRGeneration.startTimer();

    Gen->Initialize(Ctx);

    if (llvm::TimePassesIsEnabled)
      LLVMIRGeneration.stopTimer();
  }

  bool HandleTopLevelDecl(DeclGroupRef D) override {
    PrettyStackTraceDecl CrashInfo(*D.begin(), SourceLocation(),
                                   Context->getSourceManager(),
                                   "LLVM IR generation of declaration");

    // Recurse.
    if (llvm::TimePassesIsEnabled) {
      LLVMIRGenerationRefCount += 1;
      if (LLVMIRGenerationRefCount == 1)
        LLVMIRGeneration.startTimer();
    }

    Gen->HandleTopLevelDecl(D);

    if (llvm::TimePassesIsEnabled) {
      LLVMIRGenerationRefCount -= 1;
      if (LLVMIRGenerationRefCount == 0)
        LLVMIRGeneration.stopTimer();
    }

    return true;
  }

  void HandleInlineFunctionDefinition(FunctionDecl *D) override {
    PrettyStackTraceDecl CrashInfo(D, SourceLocation(),
                                   Context->getSourceManager(),
                                   "LLVM IR generation of inline function");
    if (llvm::TimePassesIsEnabled)
      LLVMIRGeneration.startTimer();

    Gen->HandleInlineFunctionDefinition(D);

    if (llvm::TimePassesIsEnabled)
      LLVMIRGeneration.stopTimer();
  }

  void HandleInterestingDecl(DeclGroupRef D) override {
    // Ignore interesting decls from the AST reader after IRGen is finished.
    if (!IRGenFinished)
      HandleTopLevelDecl(D);
  }

  // Links each entry in LinkModules into our module.  Returns true on error.
  bool LinkInModules() {
    for (auto &LM : LinkModules) {
      if (LM.PropagateAttrs)
        for (Function &F : *LM.Module)
          Gen->CGM().AddDefaultFnAttrs(F);

      CurLinkModule = LM.Module.get();

      bool Err;
      if (LM.Internalize) {
        Err = Linker::linkModules(
            *getModule(), std::move(LM.Module), LM.LinkFlags,
            [](llvm::Module &M, const llvm::StringSet<> &GVS) {
              internalizeModule(M, [&GVS](const llvm::GlobalValue &GV) {
                return !GV.hasName() || (GVS.count(GV.getName()) == 0);
              });
            });
      } else {
        Err = Linker::linkModules(*getModule(), std::move(LM.Module),
                                  LM.LinkFlags);
      }

      if (Err)
        return true;
    }
    return false; // success
  }

  void HandleTranslationUnit(ASTContext &C) override {
    {
      PrettyStackTraceString CrashInfo("Per-file LLVM IR generation");
      if (llvm::TimePassesIsEnabled) {
        LLVMIRGenerationRefCount += 1;
        if (LLVMIRGenerationRefCount == 1)
          LLVMIRGeneration.startTimer();
      }

      Gen->HandleTranslationUnit(C);

      if (llvm::TimePassesIsEnabled) {
        LLVMIRGenerationRefCount -= 1;
        if (LLVMIRGenerationRefCount == 0)
          LLVMIRGeneration.stopTimer();
      }

IRGenFinished = true;
    }

    // Silently ignore if we weren't initialized for some reason.
    if (!getModule())
      return;

    // Install an inline asm handler so that diagnostics get printed through
    // our diagnostics hooks.
    LLVMContext &Ctx = getModule()->getContext();
    LLVMContext::InlineAsmDiagHandlerTy OldHandler =
      Ctx.getInlineAsmDiagnosticHandler();
    void *OldContext = Ctx.getInlineAsmDiagnosticContext();
    Ctx.setInlineAsmDiagnosticHandler(InlineAsmDiagHandler, this);

    std::unique_ptr<DiagnosticHandler> OldDiagnosticHandler =
        Ctx.getDiagnosticHandler();
    Ctx.setDiagnosticHandler(llvm::make_unique<ClangDiagnosticHandler>(
      CodeGenOpts, this));
    Ctx.setDiagnosticsHotnessRequested(CodeGenOpts.DiagnosticsWithHotness);
    if (CodeGenOpts.DiagnosticsHotnessThreshold != 0)
      Ctx.setDiagnosticsHotnessThreshold(
          CodeGenOpts.DiagnosticsHotnessThreshold);

    std::unique_ptr<llvm::ToolOutputFile> OptRecordFile;
    if (!CodeGenOpts.OptRecordFile.empty()) {
      std::error_code EC;
      OptRecordFile = llvm::make_unique<llvm::ToolOutputFile>(
          CodeGenOpts.OptRecordFile, EC, sys::fs::F_None);
      if (EC) {
        Diags.Report(diag::err_cannot_open_file) <<
          CodeGenOpts.OptRecordFile << EC.message();
        return;
      }

      Ctx.setDiagnosticsOutputFile(
          llvm::make_unique<yaml::Output>(OptRecordFile->os()));

      if (CodeGenOpts.getProfileUse() != CodeGenOptions::ProfileNone)
        Ctx.setDiagnosticsHotnessRequested(true);
    }

    // Link each LinkModule into our module.
    if (LinkInModules())
      return;

    EmbedBitcode(getModule(), CodeGenOpts, llvm::MemoryBufferRef());

    EmitBackendOutput(Diags, HeaderSearchOpts, CodeGenOpts, TargetOpts,
                      LangOpts, C.getTargetInfo().getDataLayout(),
                      getModule(), Action, std::move(AsmOutStream));

    Ctx.setInlineAsmDiagnosticHandler(OldHandler, OldContext);

    Ctx.setDiagnosticHandler(std::move(OldDiagnosticHandler));

    if (OptRecordFile)
      OptRecordFile->keep();
  }

  void HandleTagDeclDefinition(TagDecl *D) override {
    PrettyStackTraceDecl CrashInfo(D, SourceLocation(),
                                   Context->getSourceManager(),
                                   "LLVM IR generation of declaration");
    Gen->HandleTagDeclDefinition(D);
  }

  void HandleTagDeclRequiredDefinition(const TagDecl *D) override {
    Gen->HandleTagDeclRequiredDefinition(D);
  }

  void CompleteTentativeDefinition(VarDecl *D) override {
    Gen->CompleteTentativeDefinition(D);
  }

  void AssignInheritanceModel(CXXRecordDecl *RD) override {
    Gen->AssignInheritanceModel(RD);
  }

  void HandleVTable(CXXRecordDecl *RD) override {
    Gen->HandleVTable(RD);
  }

  static void InlineAsmDiagHandler(const llvm::SMDiagnostic &SM,void *Context,
                                   unsigned LocCookie) {
    SourceLocation Loc = SourceLocation::getFromRawEncoding(LocCookie);
    ((BackendConsumer*)Context)->InlineAsmDiagHandler2(SM, Loc);
  }

  /// Get the best possible source location to represent a diagnostic that
  /// may have associated debug info.
  const FullSourceLoc
  getBestLocationFromDebugLoc(const llvm::DiagnosticInfoWithLocationBase &D,
                              bool &BadDebugInfo, StringRef &Filename,
                              unsigned &Line, unsigned &Column) const;

  void InlineAsmDiagHandler2(const llvm::SMDiagnostic &,
                             SourceLocation LocCookie);

  void DiagnosticHandlerImpl(const llvm::DiagnosticInfo &DI);
  /// \brief Specialized handler for InlineAsm diagnostic.
  /// \return True if the diagnostic has been successfully reported, false
  /// otherwise.
  bool InlineAsmDiagHandler(const llvm::DiagnosticInfoInlineAsm &D);
  /// \brief Specialized handler for StackSize diagnostic.
  /// \return True if the diagnostic has been successfully reported, false
  /// otherwise.
  bool StackSizeDiagHandler(const llvm::DiagnosticInfoStackSize &D);
  /// \brief Specialized handler for unsupported backend feature diagnostic.
  void UnsupportedDiagHandler(const llvm::DiagnosticInfoUnsupported &D);
  /// \brief Specialized handlers for optimization remarks.
  /// Note that these handlers only accept remarks and they always handle
  /// them.
  void EmitOptimizationMessage(const llvm::DiagnosticInfoOptimizationBase &D,
                               unsigned DiagID);
  void
  OptimizationRemarkHandler(const llvm::DiagnosticInfoOptimizationBase &D);
  void OptimizationRemarkHandler(
      const llvm::OptimizationRemarkAnalysisFPCommute &D);
  void OptimizationRemarkHandler(
      const llvm::OptimizationRemarkAnalysisAliasing &D);
  void OptimizationFailureHandler(
      const llvm::DiagnosticInfoOptimizationFailure &D);
};

void BackendConsumer::anchor() {}
370}

372bool ClangDiagnosticHandler::handleDiagnostics(const DiagnosticInfo &DI) {
BackendCon->DiagnosticHandlerImpl(DI);
return true;
375}

377/// ConvertBackendLocation - Convert a location in a temporary llvm::SourceMgr
378/// buffer to be a valid FullSourceLoc.
379static FullSourceLoc ConvertBackendLocation(const llvm::SMDiagnostic &D,
                                          SourceManager &CSM) {
// Get both the clang and llvm source managers.  The location is relative to
// a memory buffer that the LLVM Source Manager is handling, we need to add
// a copy to the Clang source manager.
const llvm::SourceMgr &LSM = *D.getSourceMgr();

// We need to copy the underlying LLVM memory buffer because llvm::SourceMgr
// already owns its one and clang::SourceManager wants to own its one.
const MemoryBuffer *LBuf =
LSM.getMemoryBuffer(LSM.FindBufferContainingLoc(D.getLoc()));

// Create the copy and transfer ownership to clang::SourceManager.
// TODO: Avoid copying files into memory.
std::unique_ptr<llvm::MemoryBuffer> CBuf =
    llvm::MemoryBuffer::getMemBufferCopy(LBuf->getBuffer(),
                                         LBuf->getBufferIdentifier());
// FIXME: Keep a file ID map instead of creating new IDs for each location.
FileID FID = CSM.createFileID(std::move(CBuf));

// Translate the offset into the file.
unsigned Offset = D.getLoc().getPointer() - LBuf->getBufferStart();
SourceLocation NewLoc =
CSM.getLocForStartOfFile(FID).getLocWithOffset(Offset);
return FullSourceLoc(NewLoc, CSM);
404}


407/// InlineAsmDiagHandler2 - This function is invoked when the backend hits an
408/// error parsing inline asm.  The SMDiagnostic indicates the error relative to
409/// the temporary memory buffer that the inline asm parser has set up.
410void BackendConsumer::InlineAsmDiagHandler2(const llvm::SMDiagnostic &D,
                                          SourceLocation LocCookie) {
// There are a couple of different kinds of errors we could get here.  First,
// we re-format the SMDiagnostic in terms of a clang diagnostic.

// Strip "error: " off the start of the message string.
StringRef Message = D.getMessage();
if (Message.startswith("error: "))
  Message = Message.substr(7);

// If the SMDiagnostic has an inline asm source location, translate it.
FullSourceLoc Loc;
if (D.getLoc() != SMLoc())
  Loc = ConvertBackendLocation(D, Context->getSourceManager());

unsigned DiagID;
switch (D.getKind()) {
case llvm::SourceMgr::DK_Error:
  DiagID = diag::err_fe_inline_asm;
  break;
case llvm::SourceMgr::DK_Warning:
  DiagID = diag::warn_fe_inline_asm;
  break;
case llvm::SourceMgr::DK_Note:
  DiagID = diag::note_fe_inline_asm;
  break;
case llvm::SourceMgr::DK_Remark:
  llvm_unreachable("remarks unexpected")::llvm::llvm_unreachable_internal("remarks unexpected", "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/lib/CodeGen/CodeGenAction.cpp"
, 437);
}
// If this problem has clang-level source location information, report the
// issue in the source with a note showing the instantiated
// code.
if (LocCookie.isValid()) {
  Diags.Report(LocCookie, DiagID).AddString(Message);

  if (D.getLoc().isValid()) {
    DiagnosticBuilder B = Diags.Report(Loc, diag::note_fe_inline_asm_here);
    // Convert the SMDiagnostic ranges into SourceRange and attach them
    // to the diagnostic.
    for (const std::pair<unsigned, unsigned> &Range : D.getRanges()) {
      unsigned Column = D.getColumnNo();
      B << SourceRange(Loc.getLocWithOffset(Range.first - Column),
                       Loc.getLocWithOffset(Range.second - Column));
    }
  }
  return;
}

// Otherwise, report the backend issue as occurring in the generated .s file.
// If Loc is invalid, we still need to report the issue, it just gets no
// location info.
Diags.Report(Loc, DiagID).AddString(Message);
462}

464#define ComputeDiagID(Severity, GroupName, DiagID)                             \
do {                                                                         \
  switch (Severity) {                                                        \
  case llvm::DS_Error:                                                       \
    DiagID = diag::err_fe_##GroupName;                                       \
    break;                                                                   \
  case llvm::DS_Warning:                                                     \
    DiagID = diag::warn_fe_##GroupName;                                      \
    break;                                                                   \
  case llvm::DS_Remark:                                                      \
    llvm_unreachable("'remark' severity not expected")::llvm::llvm_unreachable_internal("'remark' severity not expected"
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/lib/CodeGen/CodeGenAction.cpp"
, 474);                      \
    break;                                                                   \
  case llvm::DS_Note:                                                        \
    DiagID = diag::note_fe_##GroupName;                                      \
    break;                                                                   \
  }                                                                          \
} while (false)

482#define ComputeDiagRemarkID(Severity, GroupName, DiagID)do { switch (Severity) { case llvm::DS_Error: DiagID = diag::
err_fe_GroupName; break; case llvm::DS_Warning: DiagID = diag
::warn_fe_GroupName; break; case llvm::DS_Remark: DiagID = diag
::remark_fe_GroupName; break; case llvm::DS_Note: DiagID = diag
::note_fe_GroupName; break; } } while (false)                       \
do {                                                                         \
  switch (Severity) {                                                        \
  case llvm::DS_Error:                                                       \
    DiagID = diag::err_fe_##GroupName;                                       \
    break;                                                                   \
  case llvm::DS_Warning:                                                     \
    DiagID = diag::warn_fe_##GroupName;                                      \
    break;                                                                   \
  case llvm::DS_Remark:                                                      \
    DiagID = diag::remark_fe_##GroupName;                                    \
    break;                                                                   \
  case llvm::DS_Note:                                                        \
    DiagID = diag::note_fe_##GroupName;                                      \
    break;                                                                   \
  }                                                                          \
} while (false)

500bool
501BackendConsumer::InlineAsmDiagHandler(const llvm::DiagnosticInfoInlineAsm &D) {
unsigned DiagID;
ComputeDiagID(D.getSeverity(), inline_asm, DiagID);
std::string Message = D.getMsgStr().str();

// If this problem has clang-level source location information, report the
// issue as being a problem in the source with a note showing the instantiated
// code.
SourceLocation LocCookie =
    SourceLocation::getFromRawEncoding(D.getLocCookie());
if (LocCookie.isValid())
  Diags.Report(LocCookie, DiagID).AddString(Message);
else {
  // Otherwise, report the backend diagnostic as occurring in the generated
  // .s file.
  // If Loc is invalid, we still need to report the diagnostic, it just gets
  // no location info.
  FullSourceLoc Loc;
  Diags.Report(Loc, DiagID).AddString(Message);
}
// We handled all the possible severities.
return true;
523}

525bool
526BackendConsumer::StackSizeDiagHandler(const llvm::DiagnosticInfoStackSize &D) {
if (D.getSeverity() != llvm::DS_Warning)
  // For now, the only support we have for StackSize diagnostic is warning.
  // We do not know how to format other severities.
  return false;

if (const Decl *ND = Gen->GetDeclForMangledName(D.getFunction().getName())) {
  // FIXME: Shouldn't need to truncate to uint32_t
  Diags.Report(ND->getASTContext().getFullLoc(ND->getLocation()),
               diag::warn_fe_frame_larger_than)
    << static_cast<uint32_t>(D.getStackSize()) << Decl::castToDeclContext(ND);
  return true;
}

return false;
541}

543const FullSourceLoc BackendConsumer::getBestLocationFromDebugLoc(
  const llvm::DiagnosticInfoWithLocationBase &D, bool &BadDebugInfo,
  StringRef &Filename, unsigned &Line, unsigned &Column) const {
SourceManager &SourceMgr = Context->getSourceManager();
FileManager &FileMgr = SourceMgr.getFileManager();
SourceLocation DILoc;

if (D.isLocationAvailable()) {
  D.getLocation(&Filename, &Line, &Column);
  const FileEntry *FE = FileMgr.getFile(Filename);
  if (FE && Line > 0) {
    // If -gcolumn-info was not used, Column will be 0. This upsets the
    // source manager, so pass 1 if Column is not set.
    DILoc = SourceMgr.translateFileLineCol(FE, Line, Column ? Column : 1);
  }
  BadDebugInfo = DILoc.isInvalid();
}

// If a location isn't available, try to approximate it using the associated
// function definition. We use the definition's right brace to differentiate
// from diagnostics that genuinely relate to the function itself.
FullSourceLoc Loc(DILoc, SourceMgr);
if (Loc.isInvalid())
  if (const Decl *FD = Gen->GetDeclForMangledName(D.getFunction().getName()))
    Loc = FD->getASTContext().getFullLoc(FD->getLocation());

if (DILoc.isInvalid() && D.isLocationAvailable())
  // If we were not able to translate the file:line:col information
  // back to a SourceLocation, at least emit a note stating that
  // we could not translate this location. This can happen in the
  // case of #line directives.
  Diags.Report(Loc, diag::note_fe_backend_invalid_loc)
      << Filename << Line << Column;

return Loc;
578}

580void BackendConsumer::UnsupportedDiagHandler(
  const llvm::DiagnosticInfoUnsupported &D) {
// We only support errors.
assert(D.getSeverity() == llvm::DS_Error)(static_cast <bool> (D.getSeverity() == llvm::DS_Error)
 ? void (0) : __assert_fail ("D.getSeverity() == llvm::DS_Error"
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/lib/CodeGen/CodeGenAction.cpp"
, 583, __extension__ __PRETTY_FUNCTION__));

StringRef Filename;
unsigned Line, Column;
bool BadDebugInfo = false;
FullSourceLoc Loc =
    getBestLocationFromDebugLoc(D, BadDebugInfo, Filename, Line, Column);

Diags.Report(Loc, diag::err_fe_backend_unsupported) << D.getMessage().str();

if (BadDebugInfo)
  // If we were not able to translate the file:line:col information
  // back to a SourceLocation, at least emit a note stating that
  // we could not translate this location. This can happen in the
  // case of #line directives.
  Diags.Report(Loc, diag::note_fe_backend_invalid_loc)
      << Filename << Line << Column;
600}

602void BackendConsumer::EmitOptimizationMessage(
  const llvm::DiagnosticInfoOptimizationBase &D, unsigned DiagID) {
// We only support warnings and remarks.
assert(D.getSeverity() == llvm::DS_Remark ||(static_cast <bool> (D.getSeverity() == llvm::DS_Remark
 || D.getSeverity() == llvm::DS_Warning) ? void (0) : __assert_fail
 ("D.getSeverity() == llvm::DS_Remark || D.getSeverity() == llvm::DS_Warning"
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/lib/CodeGen/CodeGenAction.cpp"
, 606, __extension__ __PRETTY_FUNCTION__))
       D.getSeverity() == llvm::DS_Warning)(static_cast <bool> (D.getSeverity() == llvm::DS_Remark
 || D.getSeverity() == llvm::DS_Warning) ? void (0) : __assert_fail
 ("D.getSeverity() == llvm::DS_Remark || D.getSeverity() == llvm::DS_Warning"
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/lib/CodeGen/CodeGenAction.cpp"
, 606, __extension__ __PRETTY_FUNCTION__));

StringRef Filename;
unsigned Line, Column;
bool BadDebugInfo = false;
FullSourceLoc Loc =
    getBestLocationFromDebugLoc(D, BadDebugInfo, Filename, Line, Column);

std::string Msg;
raw_string_ostream MsgStream(Msg);
MsgStream << D.getMsg();

if (D.getHotness())
  MsgStream << " (hotness: " << *D.getHotness() << ")";

Diags.Report(Loc, DiagID)
    << AddFlagValue(D.getPassName())
    << MsgStream.str();

if (BadDebugInfo)
  // If we were not able to translate the file:line:col information
  // back to a SourceLocation, at least emit a note stating that
  // we could not translate this location. This can happen in the
  // case of #line directives.
  Diags.Report(Loc, diag::note_fe_backend_invalid_loc)
      << Filename << Line << Column;
632}

634void BackendConsumer::OptimizationRemarkHandler(
  const llvm::DiagnosticInfoOptimizationBase &D) {
// Without hotness information, don't show noisy remarks.
if (D.isVerbose() && !D.getHotness())
  return;

if (D.isPassed()) {
  // Optimization remarks are active only if the -Rpass flag has a regular
  // expression that matches the name of the pass name in \p D.
  if (CodeGenOpts.OptimizationRemarkPattern &&
      CodeGenOpts.OptimizationRemarkPattern->match(D.getPassName()))
    EmitOptimizationMessage(D, diag::remark_fe_backend_optimization_remark);
} else if (D.isMissed()) {
  // Missed optimization remarks are active only if the -Rpass-missed
  // flag has a regular expression that matches the name of the pass
  // name in \p D.
  if (CodeGenOpts.OptimizationRemarkMissedPattern &&
      CodeGenOpts.OptimizationRemarkMissedPattern->match(D.getPassName()))
    EmitOptimizationMessage(
        D, diag::remark_fe_backend_optimization_remark_missed);
} else {
  assert(D.isAnalysis() && "Unknown remark type")(static_cast <bool> (D.isAnalysis() && "Unknown remark type"
) ? void (0) : __assert_fail ("D.isAnalysis() && \"Unknown remark type\""
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/lib/CodeGen/CodeGenAction.cpp"
, 655, __extension__ __PRETTY_FUNCTION__));

  bool ShouldAlwaysPrint = false;
  if (auto *ORA = dyn_cast<llvm::OptimizationRemarkAnalysis>(&D))
    ShouldAlwaysPrint = ORA->shouldAlwaysPrint();

  if (ShouldAlwaysPrint ||
      (CodeGenOpts.OptimizationRemarkAnalysisPattern &&
       CodeGenOpts.OptimizationRemarkAnalysisPattern->match(D.getPassName())))
    EmitOptimizationMessage(
        D, diag::remark_fe_backend_optimization_remark_analysis);
}
667}

669void BackendConsumer::OptimizationRemarkHandler(
  const llvm::OptimizationRemarkAnalysisFPCommute &D) {
// Optimization analysis remarks are active if the pass name is set to
// llvm::DiagnosticInfo::AlwasyPrint or if the -Rpass-analysis flag has a
// regular expression that matches the name of the pass name in \p D.

if (D.shouldAlwaysPrint() ||
    (CodeGenOpts.OptimizationRemarkAnalysisPattern &&
     CodeGenOpts.OptimizationRemarkAnalysisPattern->match(D.getPassName())))
  EmitOptimizationMessage(
      D, diag::remark_fe_backend_optimization_remark_analysis_fpcommute);
680}

682void BackendConsumer::OptimizationRemarkHandler(
  const llvm::OptimizationRemarkAnalysisAliasing &D) {
// Optimization analysis remarks are active if the pass name is set to
// llvm::DiagnosticInfo::AlwasyPrint or if the -Rpass-analysis flag has a
// regular expression that matches the name of the pass name in \p D.

if (D.shouldAlwaysPrint() ||
    (CodeGenOpts.OptimizationRemarkAnalysisPattern &&
     CodeGenOpts.OptimizationRemarkAnalysisPattern->match(D.getPassName())))
  EmitOptimizationMessage(
      D, diag::remark_fe_backend_optimization_remark_analysis_aliasing);
693}

695void BackendConsumer::OptimizationFailureHandler(
  const llvm::DiagnosticInfoOptimizationFailure &D) {
EmitOptimizationMessage(D, diag::warn_fe_backend_optimization_failure);
698}

700/// \brief This function is invoked when the backend needs
701/// to report something to the user.
702void BackendConsumer::DiagnosticHandlerImpl(const DiagnosticInfo &DI) {
unsigned DiagID = diag::err_fe_inline_asm;
llvm::DiagnosticSeverity Severity = DI.getSeverity();
// Get the diagnostic ID based.
switch (DI.getKind()) {
case llvm::DK_InlineAsm:
  if (InlineAsmDiagHandler(cast<DiagnosticInfoInlineAsm>(DI)))
    return;
  ComputeDiagID(Severity, inline_asm, DiagID);
  break;
case llvm::DK_StackSize:
  if (StackSizeDiagHandler(cast<DiagnosticInfoStackSize>(DI)))
    return;
  ComputeDiagID(Severity, backend_frame_larger_than, DiagID);
  break;
case DK_Linker:
  assert(CurLinkModule)(static_cast <bool> (CurLinkModule) ? void (0) : __assert_fail
 ("CurLinkModule", "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/lib/CodeGen/CodeGenAction.cpp"
, 718, __extension__ __PRETTY_FUNCTION__));
  // FIXME: stop eating the warnings and notes.
  if (Severity != DS_Error)
    return;
  DiagID = diag::err_fe_cannot_link_module;
  break;
case llvm::DK_OptimizationRemark:
  // Optimization remarks are always handled completely by this
  // handler. There is no generic way of emitting them.
  OptimizationRemarkHandler(cast<OptimizationRemark>(DI));
  return;
case llvm::DK_OptimizationRemarkMissed:
  // Optimization remarks are always handled completely by this
  // handler. There is no generic way of emitting them.
  OptimizationRemarkHandler(cast<OptimizationRemarkMissed>(DI));
  return;
case llvm::DK_OptimizationRemarkAnalysis:
  // Optimization remarks are always handled completely by this
  // handler. There is no generic way of emitting them.
  OptimizationRemarkHandler(cast<OptimizationRemarkAnalysis>(DI));
  return;
case llvm::DK_OptimizationRemarkAnalysisFPCommute:
  // Optimization remarks are always handled completely by this
  // handler. There is no generic way of emitting them.
  OptimizationRemarkHandler(cast<OptimizationRemarkAnalysisFPCommute>(DI));
  return;
case llvm::DK_OptimizationRemarkAnalysisAliasing:
  // Optimization remarks are always handled completely by this
  // handler. There is no generic way of emitting them.
  OptimizationRemarkHandler(cast<OptimizationRemarkAnalysisAliasing>(DI));
  return;
case llvm::DK_MachineOptimizationRemark:
  // Optimization remarks are always handled completely by this
  // handler. There is no generic way of emitting them.
  OptimizationRemarkHandler(cast<MachineOptimizationRemark>(DI));
  return;
case llvm::DK_MachineOptimizationRemarkMissed:
  // Optimization remarks are always handled completely by this
  // handler. There is no generic way of emitting them.
  OptimizationRemarkHandler(cast<MachineOptimizationRemarkMissed>(DI));
  return;
case llvm::DK_MachineOptimizationRemarkAnalysis:
  // Optimization remarks are always handled completely by this
  // handler. There is no generic way of emitting them.
  OptimizationRemarkHandler(cast<MachineOptimizationRemarkAnalysis>(DI));
  return;
case llvm::DK_OptimizationFailure:
  // Optimization failures are always handled completely by this
  // handler.
  OptimizationFailureHandler(cast<DiagnosticInfoOptimizationFailure>(DI));
  return;
case llvm::DK_Unsupported:
  UnsupportedDiagHandler(cast<DiagnosticInfoUnsupported>(DI));
  return;
default:
  // Plugin IDs are not bound to any value as they are set dynamically.
  ComputeDiagRemarkID(Severity, backend_plugin, DiagID)do { switch (Severity) { case llvm::DS_Error: DiagID = diag::
err_fe_backend_plugin; break; case llvm::DS_Warning: DiagID =
 diag::warn_fe_backend_plugin; break; case llvm::DS_Remark: DiagID
 = diag::remark_fe_backend_plugin; break; case llvm::DS_Note:
 DiagID = diag::note_fe_backend_plugin; break; } } while (false
);
  break;
}
std::string MsgStorage;
{
  raw_string_ostream Stream(MsgStorage);
  DiagnosticPrinterRawOStream DP(Stream);
  DI.print(DP);
}

if (DiagID == diag::err_fe_cannot_link_module) {
  Diags.Report(diag::err_fe_cannot_link_module)
      << CurLinkModule->getModuleIdentifier() << MsgStorage;
  return;
}

// Report the backend message using the usual diagnostic mechanism.
FullSourceLoc Loc;
Diags.Report(Loc, DiagID).AddString(MsgStorage);
793}
794#undef ComputeDiagID

796CodeGenAction::CodeGenAction(unsigned _Act, LLVMContext *_VMContext)
  : Act(_Act), VMContext(_VMContext ? _VMContext : new LLVMContext),
    OwnsVMContext(!_VMContext) {}

800CodeGenAction::~CodeGenAction() {
TheModule.reset();
if (OwnsVMContext)
  delete VMContext;
804}

806bool CodeGenAction::hasIRSupport() const { return true; }

808void CodeGenAction::EndSourceFileAction() {
// If the consumer creation failed, do nothing.
if (!getCompilerInstance().hasASTConsumer())
  return;

// Steal the module from the consumer.
TheModule = BEConsumer->takeModule();
815}

817std::unique_ptr<llvm::Module> CodeGenAction::takeModule() {
return std::move(TheModule);
819}

821llvm::LLVMContext *CodeGenAction::takeLLVMContext() {
OwnsVMContext = false;
return VMContext;
824}

826static std::unique_ptr<raw_pwrite_stream>
827GetOutputStream(CompilerInstance &CI, StringRef InFile, BackendAction Action) {
switch (Action) {
case Backend_EmitAssembly:
  return CI.createDefaultOutputFile(false, InFile, "s");
case Backend_EmitLL:
  return CI.createDefaultOutputFile(false, InFile, "ll");
case Backend_EmitBC:
  return CI.createDefaultOutputFile(true, InFile, "bc");
case Backend_EmitNothing:
  return nullptr;
case Backend_EmitMCNull:
  return CI.createNullOutputFile();
case Backend_EmitObj:
  return CI.createDefaultOutputFile(true, InFile, "o");
}

llvm_unreachable("Invalid action!")::llvm::llvm_unreachable_internal("Invalid action!", "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/lib/CodeGen/CodeGenAction.cpp"
, 843);
844}

846std::unique_ptr<ASTConsumer>
847CodeGenAction::CreateASTConsumer(CompilerInstance &CI, StringRef InFile) {
BackendAction BA = static_cast<BackendAction>(Act);
std::unique_ptr<raw_pwrite_stream> OS = CI.takeOutputStream();
if (!OS)
1
Taking false branch→
  OS = GetOutputStream(CI, InFile, BA);

if (BA != Backend_EmitNothing && !OS)
2
←
Assuming 'BA' is equal to Backend_EmitNothing→
  return nullptr;

// Load bitcode modules to link with, if we need to.
if (LinkModules.empty())
3
←
Taking false branch→
  for (const CodeGenOptions::BitcodeFileToLink &F :
       CI.getCodeGenOpts().LinkBitcodeFiles) {
    auto BCBuf = CI.getFileManager().getBufferForFile(F.Filename);
    if (!BCBuf) {
      CI.getDiagnostics().Report(diag::err_cannot_open_file)
          << F.Filename << BCBuf.getError().message();
      LinkModules.clear();
      return nullptr;
    }

    Expected<std::unique_ptr<llvm::Module>> ModuleOrErr =
        getOwningLazyBitcodeModule(std::move(*BCBuf), *VMContext);
    if (!ModuleOrErr) {
      handleAllErrors(ModuleOrErr.takeError(), [&](ErrorInfoBase &EIB) {
        CI.getDiagnostics().Report(diag::err_cannot_open_file)
            << F.Filename << EIB.message();
      });
      LinkModules.clear();
      return nullptr;
    }
    LinkModules.push_back({std::move(ModuleOrErr.get()), F.PropagateAttrs,
                           F.Internalize, F.LinkFlags});
  }

CoverageSourceInfo *CoverageInfo = nullptr;
// Add the preprocessor callback only when the coverage mapping is generated.
if (CI.getCodeGenOpts().CoverageMapping) {
4
←
Assuming the condition is true→
5
←
Taking true branch→
  CoverageInfo = new CoverageSourceInfo;
6
←
Memory is allocated→
  CI.getPreprocessor().addPPCallbacks(
                                  std::unique_ptr<PPCallbacks>(CoverageInfo));
7
←
Calling '~unique_ptr'→
12
←
Returning from '~unique_ptr'→
}

std::unique_ptr<BackendConsumer> Result(new BackendConsumer(
13
←
Use of memory after it is freed
    BA, CI.getDiagnostics(), CI.getHeaderSearchOpts(),
    CI.getPreprocessorOpts(), CI.getCodeGenOpts(), CI.getTargetOpts(),
    CI.getLangOpts(), CI.getFrontendOpts().ShowTimers, InFile,
    std::move(LinkModules), std::move(OS), *VMContext, CoverageInfo));
BEConsumer = Result.get();

// Enable generating macro debug info only when debug info is not disabled and
// also macro debug info is enabled.
if (CI.getCodeGenOpts().getDebugInfo() != codegenoptions::NoDebugInfo &&
    CI.getCodeGenOpts().MacroDebugInfo) {
  std::unique_ptr<PPCallbacks> Callbacks =
      llvm::make_unique<MacroPPCallbacks>(BEConsumer->getCodeGenerator(),
                                          CI.getPreprocessor());
  CI.getPreprocessor().addPPCallbacks(std::move(Callbacks));
}

return std::move(Result);
908}

910static void BitcodeInlineAsmDiagHandler(const llvm::SMDiagnostic &SM,
                                       void *Context,
                                       unsigned LocCookie) {
SM.print(nullptr, llvm::errs());

auto Diags = static_cast<DiagnosticsEngine *>(Context);
unsigned DiagID;
switch (SM.getKind()) {
case llvm::SourceMgr::DK_Error:
  DiagID = diag::err_fe_inline_asm;
  break;
case llvm::SourceMgr::DK_Warning:
  DiagID = diag::warn_fe_inline_asm;
  break;
case llvm::SourceMgr::DK_Note:
  DiagID = diag::note_fe_inline_asm;
  break;
case llvm::SourceMgr::DK_Remark:
  llvm_unreachable("remarks unexpected")::llvm::llvm_unreachable_internal("remarks unexpected", "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/lib/CodeGen/CodeGenAction.cpp"
, 928);
}

Diags->Report(DiagID).AddString("cannot compile inline asm");
932}

934std::unique_ptr<llvm::Module> CodeGenAction::loadModule(MemoryBufferRef MBRef) {
CompilerInstance &CI = getCompilerInstance();
SourceManager &SM = CI.getSourceManager();

// For ThinLTO backend invocations, ensure that the context
// merges types based on ODR identifiers. We also need to read
// the correct module out of a multi-module bitcode file.
if (!CI.getCodeGenOpts().ThinLTOIndexFile.empty()) {
  VMContext->enableDebugTypeODRUniquing();

  auto DiagErrors = [&](Error E) -> std::unique_ptr<llvm::Module> {
    unsigned DiagID =
        CI.getDiagnostics().getCustomDiagID(DiagnosticsEngine::Error, "%0");
    handleAllErrors(std::move(E), [&](ErrorInfoBase &EIB) {
      CI.getDiagnostics().Report(DiagID) << EIB.message();
    });
    return {};
  };

  Expected<std::vector<BitcodeModule>> BMsOrErr = getBitcodeModuleList(MBRef);
  if (!BMsOrErr)
    return DiagErrors(BMsOrErr.takeError());
  BitcodeModule *Bm = FindThinLTOModule(*BMsOrErr);
  // We have nothing to do if the file contains no ThinLTO module. This is
  // possible if ThinLTO compilation was not able to split module. Content of
  // the file was already processed by indexing and will be passed to the
  // linker using merged object file.
  if (!Bm) {
    auto M = llvm::make_unique<llvm::Module>("empty", *VMContext);
    M->setTargetTriple(CI.getTargetOpts().Triple);
    return M;
  }
  Expected<std::unique_ptr<llvm::Module>> MOrErr =
      Bm->parseModule(*VMContext);
  if (!MOrErr)
    return DiagErrors(MOrErr.takeError());
  return std::move(*MOrErr);
}

llvm::SMDiagnostic Err;
if (std::unique_ptr<llvm::Module> M = parseIR(MBRef, Err, *VMContext))
  return M;

// Translate from the diagnostic info to the SourceManager location if
// available.
// TODO: Unify this with ConvertBackendLocation()
SourceLocation Loc;
if (Err.getLineNo() > 0) {
  assert(Err.getColumnNo() >= 0)(static_cast <bool> (Err.getColumnNo() >= 0) ? void (
0) : __assert_fail ("Err.getColumnNo() >= 0", "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/lib/CodeGen/CodeGenAction.cpp"
, 982, __extension__ __PRETTY_FUNCTION__));
  Loc = SM.translateFileLineCol(SM.getFileEntryForID(SM.getMainFileID()),
                                Err.getLineNo(), Err.getColumnNo() + 1);
}

// Strip off a leading diagnostic code if there is one.
StringRef Msg = Err.getMessage();
if (Msg.startswith("error: "))
  Msg = Msg.substr(7);

unsigned DiagID =
    CI.getDiagnostics().getCustomDiagID(DiagnosticsEngine::Error, "%0");

CI.getDiagnostics().Report(Loc, DiagID) << Msg;
return {};
997}

999void CodeGenAction::ExecuteAction() {
// If this is an IR file, we have to treat it specially.
if (getCurrentFileKind().getLanguage() == InputKind::LLVM_IR) {
  BackendAction BA = static_cast<BackendAction>(Act);
  CompilerInstance &CI = getCompilerInstance();
  std::unique_ptr<raw_pwrite_stream> OS =
      GetOutputStream(CI, getCurrentFile(), BA);
  if (BA != Backend_EmitNothing && !OS)
    return;

  bool Invalid;
  SourceManager &SM = CI.getSourceManager();
  FileID FID = SM.getMainFileID();
  llvm::MemoryBuffer *MainFile = SM.getBuffer(FID, &Invalid);
  if (Invalid)
    return;

  TheModule = loadModule(*MainFile);
  if (!TheModule)
    return;

  const TargetOptions &TargetOpts = CI.getTargetOpts();
  if (TheModule->getTargetTriple() != TargetOpts.Triple) {
    CI.getDiagnostics().Report(SourceLocation(),
                               diag::warn_fe_override_module)
        << TargetOpts.Triple;
    TheModule->setTargetTriple(TargetOpts.Triple);
  }

  EmbedBitcode(TheModule.get(), CI.getCodeGenOpts(),
               MainFile->getMemBufferRef());

  LLVMContext &Ctx = TheModule->getContext();
  Ctx.setInlineAsmDiagnosticHandler(BitcodeInlineAsmDiagHandler,
                                    &CI.getDiagnostics());

  EmitBackendOutput(CI.getDiagnostics(), CI.getHeaderSearchOpts(),
                    CI.getCodeGenOpts(), TargetOpts, CI.getLangOpts(),
                    CI.getTarget().getDataLayout(), TheModule.get(), BA,
                    std::move(OS));
  return;
}

// Otherwise follow the normal AST path.
this->ASTFrontendAction::ExecuteAction();
1044}

1046//

1048void EmitAssemblyAction::anchor() { }
1049EmitAssemblyAction::EmitAssemblyAction(llvm::LLVMContext *_VMContext)
: CodeGenAction(Backend_EmitAssembly, _VMContext) {}

1052void EmitBCAction::anchor() { }
1053EmitBCAction::EmitBCAction(llvm::LLVMContext *_VMContext)
: CodeGenAction(Backend_EmitBC, _VMContext) {}

1056void EmitLLVMAction::anchor() { }
1057EmitLLVMAction::EmitLLVMAction(llvm::LLVMContext *_VMContext)
: CodeGenAction(Backend_EmitLL, _VMContext) {}

1060void EmitLLVMOnlyAction::anchor() { }
1061EmitLLVMOnlyAction::EmitLLVMOnlyAction(llvm::LLVMContext *_VMContext)
: CodeGenAction(Backend_EmitNothing, _VMContext) {}

1064void EmitCodeGenOnlyAction::anchor() { }
1065EmitCodeGenOnlyAction::EmitCodeGenOnlyAction(llvm::LLVMContext *_VMContext)
: CodeGenAction(Backend_EmitMCNull, _VMContext) {}

1068void EmitObjAction::anchor() { }
1069EmitObjAction::EmitObjAction(llvm::LLVMContext *_VMContext)
: CodeGenAction(Backend_EmitObj, _VMContext) {}

←

/usr/lib/gcc/x86_64-linux-gnu/7.3.0/../../../../include/c++/7.3.0/bits/unique_ptr.h

1// unique_ptr implementation -*- C++ -*-

3// Copyright (C) 2008-2017 Free Software Foundation, Inc.
4//
5// This file is part of the GNU ISO C++ Library.  This library is free
6// software; you can redistribute it and/or modify it under the
7// terms of the GNU General Public License as published by the
8// Free Software Foundation; either version 3, or (at your option)
9// any later version.

11// This library is distributed in the hope that it will be useful,
12// but WITHOUT ANY WARRANTY; without even the implied warranty of
13// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14// GNU General Public License for more details.

16// Under Section 7 of GPL version 3, you are granted additional
17// permissions described in the GCC Runtime Library Exception, version
18// 3.1, as published by the Free Software Foundation.

20// You should have received a copy of the GNU General Public License and
21// a copy of the GCC Runtime Library Exception along with this program;
22// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
23// <http://www.gnu.org/licenses/>.

25/** @file bits/unique_ptr.h
*  This is an internal header file, included by other library headers.
*  Do not attempt to use it directly. @headername{memory}
*/

30#ifndef _UNIQUE_PTR_H1
31#define _UNIQUE_PTR_H1 1

33#include <bits/c++config.h>
34#include <debug/assertions.h>
35#include <type_traits>
36#include <utility>
37#include <tuple>
38#include <bits/stl_function.h>
39#include <bits/functional_hash.h>

41namespace std _GLIBCXX_VISIBILITY(default)__attribute__ ((__visibility__ ("default")))
42{
43_GLIBCXX_BEGIN_NAMESPACE_VERSION

/**
 * @addtogroup pointer_abstractions
 * @{
 */

50#if _GLIBCXX_USE_DEPRECATED1
template<typename> class auto_ptr;
52#endif

/// Primary template of default_delete, used by unique_ptr
template<typename _Tp>
  struct default_delete
  {
    /// Default constructor
    constexpr default_delete() noexcept = default;

    /** @brief Converting constructor.
     *
     * Allows conversion from a deleter for arrays of another type, @p _Up,
     * only if @p _Up* is convertible to @p _Tp*.
     */
    template<typename _Up, typename = typename
      enable_if<is_convertible<_Up*, _Tp*>::value>::type>
      default_delete(const default_delete<_Up>&) noexcept { }

    /// Calls @c delete @p __ptr
    void
    operator()(_Tp* __ptr) const
    {
static_assert(!is_void<_Tp>::value,
      "can't delete pointer to incomplete type");
static_assert(sizeof(_Tp)>0,
      "can't delete pointer to incomplete type");
delete __ptr;
10
←
Memory is released→
    }
  };

// _GLIBCXX_RESOLVE_LIB_DEFECTS
// DR 740 - omit specialization for array objects with a compile time length
/// Specialization for arrays, default_delete.
template<typename _Tp>
  struct default_delete<_Tp[]>
  {
  public:
    /// Default constructor
    constexpr default_delete() noexcept = default;

    /** @brief Converting constructor.
     *
     * Allows conversion from a deleter for arrays of another type, such as
     * a const-qualified version of @p _Tp.
     *
     * Conversions from types derived from @c _Tp are not allowed because
     * it is unsafe to @c delete[] an array of derived types through a
     * pointer to the base type.
     */
    template<typename _Up, typename = typename
      enable_if<is_convertible<_Up(*)[], _Tp(*)[]>::value>::type>
      default_delete(const default_delete<_Up[]>&) noexcept { }

    /// Calls @c delete[] @p __ptr
    template<typename _Up>
    typename enable_if<is_convertible<_Up(*)[], _Tp(*)[]>::value>::type
operator()(_Up* __ptr) const
    {
static_assert(sizeof(_Tp)>0,
      "can't delete pointer to incomplete type");
delete [] __ptr;
    }
  };

template <typename _Tp, typename _Dp>
  class __uniq_ptr_impl
  {
    template <typename _Up, typename _Ep, typename = void>
struct _Ptr
{
 using type = _Up*;
};

    template <typename _Up, typename _Ep>
struct
_Ptr<_Up, _Ep, __void_t<typename remove_reference<_Ep>::type::pointer>>
{
 using type = typename remove_reference<_Ep>::type::pointer;
};

  public:
    using _DeleterConstraint = enable_if<
      __and_<__not_<is_pointer<_Dp>>,
      is_default_constructible<_Dp>>::value>;

    using pointer = typename _Ptr<_Tp, _Dp>::type;

    __uniq_ptr_impl() = default;
    __uniq_ptr_impl(pointer __p) : _M_t() { _M_ptr() = __p; }

    template<typename _Del>
    __uniq_ptr_impl(pointer __p, _Del&& __d)
: _M_t(__p, std::forward<_Del>(__d)) { }

    pointer&   _M_ptr() { return std::get<0>(_M_t); }
    pointer    _M_ptr() const { return std::get<0>(_M_t); }
    _Dp&       _M_deleter() { return std::get<1>(_M_t); }
    const _Dp& _M_deleter() const { return std::get<1>(_M_t); }

  private:
    tuple<pointer, _Dp> _M_t;
  };

/// 20.7.1.2 unique_ptr for single objects.
template <typename _Tp, typename _Dp = default_delete<_Tp>>
  class unique_ptr
  {
    template <class _Up>
    using _DeleterConstraint =
typename __uniq_ptr_impl<_Tp, _Up>::_DeleterConstraint::type;

    __uniq_ptr_impl<_Tp, _Dp> _M_t;

  public:
    using pointer	  = typename __uniq_ptr_impl<_Tp, _Dp>::pointer;
    using element_type  = _Tp;
    using deleter_type  = _Dp;

    // helper template for detecting a safe conversion from another
    // unique_ptr
    template<typename _Up, typename _Ep>
using __safe_conversion_up = __and_<
       is_convertible<typename unique_ptr<_Up, _Ep>::pointer, pointer>,
              __not_<is_array<_Up>>,
              __or_<__and_<is_reference<deleter_type>,
                           is_same<deleter_type, _Ep>>,
                    __and_<__not_<is_reference<deleter_type>>,
                           is_convertible<_Ep, deleter_type>>
              >
            >;

    // Constructors.

    /// Default constructor, creates a unique_ptr that owns nothing.
    template <typename _Up = _Dp,
typename = _DeleterConstraint<_Up>>
constexpr unique_ptr() noexcept
: _M_t()
      { }

    /** Takes ownership of a pointer.
     *
     * @param __p  A pointer to an object of @c element_type
     *
     * The deleter will be value-initialized.
     */
    template <typename _Up = _Dp,
typename = _DeleterConstraint<_Up>>
explicit
unique_ptr(pointer __p) noexcept
: _M_t(__p)
      { }

    /** Takes ownership of a pointer.
     *
     * @param __p  A pointer to an object of @c element_type
     * @param __d  A reference to a deleter.
     *
     * The deleter will be initialized with @p __d
     */
    unique_ptr(pointer __p,
 typename conditional<is_reference<deleter_type>::value,
   deleter_type, const deleter_type&>::type __d) noexcept
    : _M_t(__p, __d) { }

    /** Takes ownership of a pointer.
     *
     * @param __p  A pointer to an object of @c element_type
     * @param __d  An rvalue reference to a deleter.
     *
     * The deleter will be initialized with @p std::move(__d)
     */
    unique_ptr(pointer __p,
 typename remove_reference<deleter_type>::type&& __d) noexcept
    : _M_t(std::move(__p), std::move(__d))
    { static_assert(!std::is_reference<deleter_type>::value,
      "rvalue deleter bound to reference"); }

    /// Creates a unique_ptr that owns nothing.
    template <typename _Up = _Dp,
typename = _DeleterConstraint<_Up>>
constexpr unique_ptr(nullptr_t) noexcept : unique_ptr() { }

    // Move constructors.

    /// Move constructor.
    unique_ptr(unique_ptr&& __u) noexcept
    : _M_t(__u.release(), std::forward<deleter_type>(__u.get_deleter())) { }

    /** @brief Converting constructor from another type
     *
     * Requires that the pointer owned by @p __u is convertible to the
     * type of pointer owned by this object, @p __u does not own an array,
     * and @p __u has a compatible deleter type.
     */
    template<typename _Up, typename _Ep, typename = _Require<
             __safe_conversion_up<_Up, _Ep>,
      typename conditional<is_reference<_Dp>::value,
		    is_same<_Ep, _Dp>,
		    is_convertible<_Ep, _Dp>>::type>>
unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept
: _M_t(__u.release(), std::forward<_Ep>(__u.get_deleter()))
{ }

256#if _GLIBCXX_USE_DEPRECATED1
    /// Converting constructor from @c auto_ptr
    template<typename _Up, typename = _Require<
      is_convertible<_Up*, _Tp*>, is_same<_Dp, default_delete<_Tp>>>>
unique_ptr(auto_ptr<_Up>&& __u) noexcept;
261#endif

    /// Destructor, invokes the deleter if the stored pointer is not null.
    ~unique_ptr() noexcept
    {
auto& __ptr = _M_t._M_ptr();
if (__ptr != nullptr)
8
←
Taking true branch→
 get_deleter()(__ptr);
9
←
Calling 'default_delete::operator()'→
11
←
Returning; memory was released via 2nd parameter→
__ptr = pointer();
    }

    // Assignment.

    /** @brief Move assignment operator.
     *
     * @param __u  The object to transfer ownership from.
     *
     * Invokes the deleter first if this object owns a pointer.
     */
    unique_ptr&
    operator=(unique_ptr&& __u) noexcept
    {
reset(__u.release());
get_deleter() = std::forward<deleter_type>(__u.get_deleter());
return *this;
    }

    /** @brief Assignment from another type.
     *
     * @param __u  The object to transfer ownership from, which owns a
     *             convertible pointer to a non-array object.
     *
     * Invokes the deleter first if this object owns a pointer.
     */
    template<typename _Up, typename _Ep>
      typename enable_if< __and_<
        __safe_conversion_up<_Up, _Ep>,
        is_assignable<deleter_type&, _Ep&&>
        >::value,
        unique_ptr&>::type
operator=(unique_ptr<_Up, _Ep>&& __u) noexcept
{
 reset(__u.release());
 get_deleter() = std::forward<_Ep>(__u.get_deleter());
 return *this;
}

    /// Reset the %unique_ptr to empty, invoking the deleter if necessary.
    unique_ptr&
    operator=(nullptr_t) noexcept
    {
reset();
return *this;
    }

    // Observers.

    /// Dereference the stored pointer.
    typename add_lvalue_reference<element_type>::type
    operator*() const
    {
__glibcxx_assert(get() != pointer());
return *get();
    }

    /// Return the stored pointer.
    pointer
    operator->() const noexcept
    {
_GLIBCXX_DEBUG_PEDASSERT(get() != pointer());
return get();
    }

    /// Return the stored pointer.
    pointer
    get() const noexcept
    { return _M_t._M_ptr(); }

    /// Return a reference to the stored deleter.
    deleter_type&
    get_deleter() noexcept
    { return _M_t._M_deleter(); }

    /// Return a reference to the stored deleter.
    const deleter_type&
    get_deleter() const noexcept
    { return _M_t._M_deleter(); }

    /// Return @c true if the stored pointer is not null.
    explicit operator bool() const noexcept
    { return get() == pointer() ? false : true; }

    // Modifiers.

    /// Release ownership of any stored pointer.
    pointer
    release() noexcept
    {
pointer __p = get();
_M_t._M_ptr() = pointer();
return __p;
    }

    /** @brief Replace the stored pointer.
     *
     * @param __p  The new pointer to store.
     *
     * The deleter will be invoked if a pointer is already owned.
     */
    void
    reset(pointer __p = pointer()) noexcept
    {
using std::swap;
swap(_M_t._M_ptr(), __p);
if (__p != pointer())
 get_deleter()(__p);
    }

    /// Exchange the pointer and deleter with another object.
    void
    swap(unique_ptr& __u) noexcept
    {
using std::swap;
swap(_M_t, __u._M_t);
    }

    // Disable copy from lvalue.
    unique_ptr(const unique_ptr&) = delete;
    unique_ptr& operator=(const unique_ptr&) = delete;
};

/// 20.7.1.3 unique_ptr for array objects with a runtime length
// [unique.ptr.runtime]
// _GLIBCXX_RESOLVE_LIB_DEFECTS
// DR 740 - omit specialization for array objects with a compile time length
template<typename _Tp, typename _Dp>
  class unique_ptr<_Tp[], _Dp>
  {
    template <typename _Up>
    using _DeleterConstraint =
typename __uniq_ptr_impl<_Tp, _Up>::_DeleterConstraint::type;

    __uniq_ptr_impl<_Tp, _Dp> _M_t;

    template<typename _Up>
using __remove_cv = typename remove_cv<_Up>::type;

    // like is_base_of<_Tp, _Up> but false if unqualified types are the same
    template<typename _Up>
using __is_derived_Tp
 = __and_< is_base_of<_Tp, _Up>,
    __not_<is_same<__remove_cv<_Tp>, __remove_cv<_Up>>> >;

  public:
    using pointer	  = typename __uniq_ptr_impl<_Tp, _Dp>::pointer;
    using element_type  = _Tp;
    using deleter_type  = _Dp;

    // helper template for detecting a safe conversion from another
    // unique_ptr
    template<typename _Up, typename _Ep,
             typename _Up_up = unique_ptr<_Up, _Ep>,
      typename _Up_element_type = typename _Up_up::element_type>
using __safe_conversion_up = __and_<
        is_array<_Up>,
        is_same<pointer, element_type*>,
        is_same<typename _Up_up::pointer, _Up_element_type*>,
        is_convertible<_Up_element_type(*)[], element_type(*)[]>,
        __or_<__and_<is_reference<deleter_type>, is_same<deleter_type, _Ep>>,
              __and_<__not_<is_reference<deleter_type>>,
                     is_convertible<_Ep, deleter_type>>>
      >;

    // helper template for detecting a safe conversion from a raw pointer
    template<typename _Up>
      using __safe_conversion_raw = __and_<
        __or_<__or_<is_same<_Up, pointer>,
                    is_same<_Up, nullptr_t>>,
              __and_<is_pointer<_Up>,
                     is_same<pointer, element_type*>,
                     is_convertible<
                       typename remove_pointer<_Up>::type(*)[],
                       element_type(*)[]>
              >
        >
      >;

    // Constructors.

    /// Default constructor, creates a unique_ptr that owns nothing.
    template <typename _Up = _Dp,
typename = _DeleterConstraint<_Up>>
constexpr unique_ptr() noexcept
: _M_t()
      { }

    /** Takes ownership of a pointer.
     *
     * @param __p  A pointer to an array of a type safely convertible
     * to an array of @c element_type
     *
     * The deleter will be value-initialized.
     */
    template<typename _Up,
      typename _Vp = _Dp,
      typename = _DeleterConstraint<_Vp>,
      typename = typename enable_if<
               __safe_conversion_raw<_Up>::value, bool>::type>
explicit
unique_ptr(_Up __p) noexcept
: _M_t(__p)
      { }

    /** Takes ownership of a pointer.
     *
     * @param __p  A pointer to an array of a type safely convertible
     * to an array of @c element_type
     * @param __d  A reference to a deleter.
     *
     * The deleter will be initialized with @p __d
     */
    template<typename _Up,
             typename = typename enable_if<
               __safe_conversion_raw<_Up>::value, bool>::type>
    unique_ptr(_Up __p,
               typename conditional<is_reference<deleter_type>::value,
               deleter_type, const deleter_type&>::type __d) noexcept
    : _M_t(__p, __d) { }

    /** Takes ownership of a pointer.
     *
     * @param __p  A pointer to an array of a type safely convertible
     * to an array of @c element_type
     * @param __d  A reference to a deleter.
     *
     * The deleter will be initialized with @p std::move(__d)
     */
    template<typename _Up,
             typename = typename enable_if<
               __safe_conversion_raw<_Up>::value, bool>::type>
    unique_ptr(_Up __p, typename
 remove_reference<deleter_type>::type&& __d) noexcept
    : _M_t(std::move(__p), std::move(__d))
    { static_assert(!is_reference<deleter_type>::value,
      "rvalue deleter bound to reference"); }

    /// Move constructor.
    unique_ptr(unique_ptr&& __u) noexcept
    : _M_t(__u.release(), std::forward<deleter_type>(__u.get_deleter())) { }

    /// Creates a unique_ptr that owns nothing.
    template <typename _Up = _Dp,
typename = _DeleterConstraint<_Up>>
constexpr unique_ptr(nullptr_t) noexcept : unique_ptr() { }

    template<typename _Up, typename _Ep,
      typename = _Require<__safe_conversion_up<_Up, _Ep>>>
unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept
: _M_t(__u.release(), std::forward<_Ep>(__u.get_deleter()))
{ }

    /// Destructor, invokes the deleter if the stored pointer is not null.
    ~unique_ptr()
    {
auto& __ptr = _M_t._M_ptr();
if (__ptr != nullptr)
 get_deleter()(__ptr);
__ptr = pointer();
    }

    // Assignment.

    /** @brief Move assignment operator.
     *
     * @param __u  The object to transfer ownership from.
     *
     * Invokes the deleter first if this object owns a pointer.
     */
    unique_ptr&
    operator=(unique_ptr&& __u) noexcept
    {
reset(__u.release());
get_deleter() = std::forward<deleter_type>(__u.get_deleter());
return *this;
    }

    /** @brief Assignment from another type.
     *
     * @param __u  The object to transfer ownership from, which owns a
     *             convertible pointer to an array object.
     *
     * Invokes the deleter first if this object owns a pointer.
     */
    template<typename _Up, typename _Ep>
typename
enable_if<__and_<__safe_conversion_up<_Up, _Ep>,
                       is_assignable<deleter_type&, _Ep&&>
                >::value,
                unique_ptr&>::type
operator=(unique_ptr<_Up, _Ep>&& __u) noexcept
{
 reset(__u.release());
 get_deleter() = std::forward<_Ep>(__u.get_deleter());
 return *this;
}

    /// Reset the %unique_ptr to empty, invoking the deleter if necessary.
    unique_ptr&
    operator=(nullptr_t) noexcept
    {
reset();
return *this;
    }

    // Observers.

    /// Access an element of owned array.
    typename std::add_lvalue_reference<element_type>::type
    operator[](size_t __i) const
    {
__glibcxx_assert(get() != pointer());
return get()[__i];
    }

    /// Return the stored pointer.
    pointer
    get() const noexcept
    { return _M_t._M_ptr(); }

    /// Return a reference to the stored deleter.
    deleter_type&
    get_deleter() noexcept
    { return _M_t._M_deleter(); }

    /// Return a reference to the stored deleter.
    const deleter_type&
    get_deleter() const noexcept
    { return _M_t._M_deleter(); }

    /// Return @c true if the stored pointer is not null.
    explicit operator bool() const noexcept
    { return get() == pointer() ? false : true; }

    // Modifiers.

    /// Release ownership of any stored pointer.
    pointer
    release() noexcept
    {
pointer __p = get();
_M_t._M_ptr() = pointer();
return __p;
    }

    /** @brief Replace the stored pointer.
     *
     * @param __p  The new pointer to store.
     *
     * The deleter will be invoked if a pointer is already owned.
     */
    template <typename _Up,
              typename = _Require<
                __or_<is_same<_Up, pointer>,
                      __and_<is_same<pointer, element_type*>,
                             is_pointer<_Up>,
                             is_convertible<
                               typename remove_pointer<_Up>::type(*)[],
                               element_type(*)[]
                             >
                      >
                >
             >>
    void
    reset(_Up __p) noexcept
    {
pointer __ptr = __p;
using std::swap;
swap(_M_t._M_ptr(), __ptr);
if (__ptr != nullptr)
 get_deleter()(__ptr);
    }

    void reset(nullptr_t = nullptr) noexcept
    {
      reset(pointer());
    }

    /// Exchange the pointer and deleter with another object.
    void
    swap(unique_ptr& __u) noexcept
    {
using std::swap;
swap(_M_t, __u._M_t);
    }

    // Disable copy from lvalue.
    unique_ptr(const unique_ptr&) = delete;
    unique_ptr& operator=(const unique_ptr&) = delete;
  };

template<typename _Tp, typename _Dp>
  inline
663#if __cplusplus201103L > 201402L || !defined(__STRICT_ANSI__1) // c++1z or gnu++11
  // Constrained free swap overload, see p0185r1
  typename enable_if<__is_swappable<_Dp>::value>::type
666#else
  void
668#endif
  swap(unique_ptr<_Tp, _Dp>& __x,
unique_ptr<_Tp, _Dp>& __y) noexcept
  { __x.swap(__y); }

673#if __cplusplus201103L > 201402L || !defined(__STRICT_ANSI__1) // c++1z or gnu++11
template<typename _Tp, typename _Dp>
  typename enable_if<!__is_swappable<_Dp>::value>::type
  swap(unique_ptr<_Tp, _Dp>&,
unique_ptr<_Tp, _Dp>&) = delete;
678#endif

template<typename _Tp, typename _Dp,
  typename _Up, typename _Ep>
  inline bool
  operator==(const unique_ptr<_Tp, _Dp>& __x,
      const unique_ptr<_Up, _Ep>& __y)
  { return __x.get() == __y.get(); }

template<typename _Tp, typename _Dp>
  inline bool
  operator==(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) noexcept
  { return !__x; }

template<typename _Tp, typename _Dp>
  inline bool
  operator==(nullptr_t, const unique_ptr<_Tp, _Dp>& __x) noexcept
  { return !__x; }

template<typename _Tp, typename _Dp,
  typename _Up, typename _Ep>
  inline bool
  operator!=(const unique_ptr<_Tp, _Dp>& __x,
      const unique_ptr<_Up, _Ep>& __y)
  { return __x.get() != __y.get(); }

template<typename _Tp, typename _Dp>
  inline bool
  operator!=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t) noexcept
  { return (bool)__x; }

template<typename _Tp, typename _Dp>
  inline bool
  operator!=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x) noexcept
  { return (bool)__x; }

template<typename _Tp, typename _Dp,
  typename _Up, typename _Ep>
  inline bool
  operator<(const unique_ptr<_Tp, _Dp>& __x,
     const unique_ptr<_Up, _Ep>& __y)
  {
    typedef typename
std::common_type<typename unique_ptr<_Tp, _Dp>::pointer,
                typename unique_ptr<_Up, _Ep>::pointer>::type _CT;
    return std::less<_CT>()(__x.get(), __y.get());
  }

template<typename _Tp, typename _Dp>
  inline bool
  operator<(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
  { return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(__x.get(),
						 nullptr); }

template<typename _Tp, typename _Dp>
  inline bool
  operator<(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
  { return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(nullptr,
						 __x.get()); }

template<typename _Tp, typename _Dp,
  typename _Up, typename _Ep>
  inline bool
  operator<=(const unique_ptr<_Tp, _Dp>& __x,
      const unique_ptr<_Up, _Ep>& __y)
  { return !(__y < __x); }

template<typename _Tp, typename _Dp>
  inline bool
  operator<=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
  { return !(nullptr < __x); }

template<typename _Tp, typename _Dp>
  inline bool
  operator<=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
  { return !(__x < nullptr); }

template<typename _Tp, typename _Dp,
  typename _Up, typename _Ep>
  inline bool
  operator>(const unique_ptr<_Tp, _Dp>& __x,
     const unique_ptr<_Up, _Ep>& __y)
  { return (__y < __x); }

template<typename _Tp, typename _Dp>
  inline bool
  operator>(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
  { return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(nullptr,
						 __x.get()); }

template<typename _Tp, typename _Dp>
  inline bool
  operator>(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
  { return std::less<typename unique_ptr<_Tp, _Dp>::pointer>()(__x.get(),
						 nullptr); }

template<typename _Tp, typename _Dp,
  typename _Up, typename _Ep>
  inline bool
  operator>=(const unique_ptr<_Tp, _Dp>& __x,
      const unique_ptr<_Up, _Ep>& __y)
  { return !(__x < __y); }

template<typename _Tp, typename _Dp>
  inline bool
  operator>=(const unique_ptr<_Tp, _Dp>& __x, nullptr_t)
  { return !(__x < nullptr); }

template<typename _Tp, typename _Dp>
  inline bool
  operator>=(nullptr_t, const unique_ptr<_Tp, _Dp>& __x)
  { return !(nullptr < __x); }

/// std::hash specialization for unique_ptr.
template<typename _Tp, typename _Dp>
  struct hash<unique_ptr<_Tp, _Dp>>
  : public __hash_base<size_t, unique_ptr<_Tp, _Dp>>,
  private __poison_hash<typename unique_ptr<_Tp, _Dp>::pointer>
  {
    size_t
    operator()(const unique_ptr<_Tp, _Dp>& __u) const noexcept
    {
typedef unique_ptr<_Tp, _Dp> _UP;
return std::hash<typename _UP::pointer>()(__u.get());
    }
  };

805#if __cplusplus201103L > 201103L

807#define __cpp_lib_make_unique 201304

template<typename _Tp>
  struct _MakeUniq
  { typedef unique_ptr<_Tp> __single_object; };

template<typename _Tp>
  struct _MakeUniq<_Tp[]>
  { typedef unique_ptr<_Tp[]> __array; };

template<typename _Tp, size_t _Bound>
  struct _MakeUniq<_Tp[_Bound]>
  { struct __invalid_type { }; };

/// std::make_unique for single objects
template<typename _Tp, typename... _Args>
  inline typename _MakeUniq<_Tp>::__single_object
  make_unique(_Args&&... __args)
  { return unique_ptr<_Tp>(new _Tp(std::forward<_Args>(__args)...)); }

/// std::make_unique for arrays of unknown bound
template<typename _Tp>
  inline typename _MakeUniq<_Tp>::__array
  make_unique(size_t __num)
  { return unique_ptr<_Tp>(new remove_extent_t<_Tp>[__num]()); }

/// Disable std::make_unique for arrays of known bound
template<typename _Tp, typename... _Args>
  inline typename _MakeUniq<_Tp>::__invalid_type
  make_unique(_Args&&...) = delete;
837#endif

// @} group pointer_abstractions

841_GLIBCXX_END_NAMESPACE_VERSION
842} // namespace

844#endif /* _UNIQUE_PTR_H */