/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/tools/driver/cc1as

Bug Summary

File:	tools/clang/tools/driver/cc1as_main.cpp
Warning:	line 502, column 5 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 cc1as_main.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/tools/driver -I /build/llvm-toolchain-snapshot-7~svn329677/tools/clang/tools/driver -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/tools/driver -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/tools/driver/cc1as_main.cpp

/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/tools/driver/cc1as_main.cpp

→

1//===-- cc1as_main.cpp - Clang Assembler  ---------------------------------===//
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//===----------------------------------------------------------------------===//
9//
10// This is the entry point to the clang -cc1as functionality, which implements
11// the direct interface to the LLVM MC based assembler.
12//
13//===----------------------------------------------------------------------===//

15#include "clang/Basic/Diagnostic.h"
16#include "clang/Basic/DiagnosticOptions.h"
17#include "clang/Driver/DriverDiagnostic.h"
18#include "clang/Driver/Options.h"
19#include "clang/Frontend/FrontendDiagnostic.h"
20#include "clang/Frontend/TextDiagnosticPrinter.h"
21#include "clang/Frontend/Utils.h"
22#include "llvm/ADT/STLExtras.h"
23#include "llvm/ADT/StringSwitch.h"
24#include "llvm/ADT/Triple.h"
25#include "llvm/IR/DataLayout.h"
26#include "llvm/MC/MCAsmBackend.h"
27#include "llvm/MC/MCAsmInfo.h"
28#include "llvm/MC/MCCodeEmitter.h"
29#include "llvm/MC/MCContext.h"
30#include "llvm/MC/MCInstrInfo.h"
31#include "llvm/MC/MCObjectFileInfo.h"
32#include "llvm/MC/MCParser/MCAsmParser.h"
33#include "llvm/MC/MCParser/MCTargetAsmParser.h"
34#include "llvm/MC/MCRegisterInfo.h"
35#include "llvm/MC/MCStreamer.h"
36#include "llvm/MC/MCSubtargetInfo.h"
37#include "llvm/MC/MCTargetOptions.h"
38#include "llvm/Option/Arg.h"
39#include "llvm/Option/ArgList.h"
40#include "llvm/Option/OptTable.h"
41#include "llvm/Support/CommandLine.h"
42#include "llvm/Support/ErrorHandling.h"
43#include "llvm/Support/FileSystem.h"
44#include "llvm/Support/FormattedStream.h"
45#include "llvm/Support/Host.h"
46#include "llvm/Support/MemoryBuffer.h"
47#include "llvm/Support/Path.h"
48#include "llvm/Support/Signals.h"
49#include "llvm/Support/SourceMgr.h"
50#include "llvm/Support/TargetRegistry.h"
51#include "llvm/Support/TargetSelect.h"
52#include "llvm/Support/Timer.h"
53#include "llvm/Support/raw_ostream.h"
54#include <memory>
55#include <system_error>
56using namespace clang;
57using namespace clang::driver;
58using namespace clang::driver::options;
59using namespace llvm;
60using namespace llvm::opt;

62namespace {

64/// \brief Helper class for representing a single invocation of the assembler.
65struct AssemblerInvocation {
/// @name Target Options
/// @{

/// The name of the target triple to assemble for.
std::string Triple;

/// If given, the name of the target CPU to determine which instructions
/// are legal.
std::string CPU;

/// The list of target specific features to enable or disable -- this should
/// be a list of strings starting with '+' or '-'.
std::vector<std::string> Features;

/// The list of symbol definitions.
std::vector<std::string> SymbolDefs;

/// @}
/// @name Language Options
/// @{

std::vector<std::string> IncludePaths;
unsigned NoInitialTextSection : 1;
unsigned SaveTemporaryLabels : 1;
unsigned GenDwarfForAssembly : 1;
unsigned RelaxELFRelocations : 1;
unsigned DwarfVersion;
std::string DwarfDebugFlags;
std::string DwarfDebugProducer;
std::string DebugCompilationDir;
llvm::DebugCompressionType CompressDebugSections =
    llvm::DebugCompressionType::None;
std::string MainFileName;

/// @}
/// @name Frontend Options
/// @{

std::string InputFile;
std::vector<std::string> LLVMArgs;
std::string OutputPath;
enum FileType {
  FT_Asm,  ///< Assembly (.s) output, transliterate mode.
  FT_Null, ///< No output, for timing purposes.
  FT_Obj   ///< Object file output.
};
FileType OutputType;
unsigned ShowHelp : 1;
unsigned ShowVersion : 1;

/// @}
/// @name Transliterate Options
/// @{

unsigned OutputAsmVariant;
unsigned ShowEncoding : 1;
unsigned ShowInst : 1;

/// @}
/// @name Assembler Options
/// @{

unsigned RelaxAll : 1;
unsigned NoExecStack : 1;
unsigned FatalWarnings : 1;
unsigned IncrementalLinkerCompatible : 1;

/// The name of the relocation model to use.
std::string RelocationModel;

/// @}

138public:
AssemblerInvocation() {
  Triple = "";
  NoInitialTextSection = 0;
  InputFile = "-";
  OutputPath = "-";
  OutputType = FT_Asm;
  OutputAsmVariant = 0;
  ShowInst = 0;
  ShowEncoding = 0;
  RelaxAll = 0;
  NoExecStack = 0;
  FatalWarnings = 0;
  IncrementalLinkerCompatible = 0;
  DwarfVersion = 0;
}

static bool CreateFromArgs(AssemblerInvocation &Res,
                           ArrayRef<const char *> Argv,
                           DiagnosticsEngine &Diags);
158};

160}

162bool AssemblerInvocation::CreateFromArgs(AssemblerInvocation &Opts,
                                       ArrayRef<const char *> Argv,
                                       DiagnosticsEngine &Diags) {
bool Success = true;

// Parse the arguments.
std::unique_ptr<OptTable> OptTbl(createDriverOptTable());

const unsigned IncludedFlagsBitmask = options::CC1AsOption;
unsigned MissingArgIndex, MissingArgCount;
InputArgList Args = OptTbl->ParseArgs(Argv, MissingArgIndex, MissingArgCount,
                                      IncludedFlagsBitmask);

// Check for missing argument error.
if (MissingArgCount) {
  Diags.Report(diag::err_drv_missing_argument)
      << Args.getArgString(MissingArgIndex) << MissingArgCount;
  Success = false;
}

// Issue errors on unknown arguments.
for (const Arg *A : Args.filtered(OPT_UNKNOWN)) {
  auto ArgString = A->getAsString(Args);
  std::string Nearest;
  if (OptTbl->findNearest(ArgString, Nearest, IncludedFlagsBitmask) > 1)
    Diags.Report(diag::err_drv_unknown_argument) << ArgString;
  else
    Diags.Report(diag::err_drv_unknown_argument_with_suggestion)
        << ArgString << Nearest;
  Success = false;
}

// Construct the invocation.

// Target Options
Opts.Triple = llvm::Triple::normalize(Args.getLastArgValue(OPT_triple));
Opts.CPU = Args.getLastArgValue(OPT_target_cpu);
Opts.Features = Args.getAllArgValues(OPT_target_feature);

// Use the default target triple if unspecified.
if (Opts.Triple.empty())
  Opts.Triple = llvm::sys::getDefaultTargetTriple();

// Language Options
Opts.IncludePaths = Args.getAllArgValues(OPT_I);
Opts.NoInitialTextSection = Args.hasArg(OPT_n);
Opts.SaveTemporaryLabels = Args.hasArg(OPT_msave_temp_labels);
// Any DebugInfoKind implies GenDwarfForAssembly.
Opts.GenDwarfForAssembly = Args.hasArg(OPT_debug_info_kind_EQ);

if (const Arg *A = Args.getLastArg(OPT_compress_debug_sections,
                                   OPT_compress_debug_sections_EQ)) {
  if (A->getOption().getID() == OPT_compress_debug_sections) {
    // TODO: be more clever about the compression type auto-detection
    Opts.CompressDebugSections = llvm::DebugCompressionType::GNU;
  } else {
    Opts.CompressDebugSections =
        llvm::StringSwitch<llvm::DebugCompressionType>(A->getValue())
            .Case("none", llvm::DebugCompressionType::None)
            .Case("zlib", llvm::DebugCompressionType::Z)
            .Case("zlib-gnu", llvm::DebugCompressionType::GNU)
            .Default(llvm::DebugCompressionType::None);
  }
}

Opts.RelaxELFRelocations = Args.hasArg(OPT_mrelax_relocations);
Opts.DwarfVersion = getLastArgIntValue(Args, OPT_dwarf_version_EQ, 2, Diags);
Opts.DwarfDebugFlags = Args.getLastArgValue(OPT_dwarf_debug_flags);
Opts.DwarfDebugProducer = Args.getLastArgValue(OPT_dwarf_debug_producer);
Opts.DebugCompilationDir = Args.getLastArgValue(OPT_fdebug_compilation_dir);
Opts.MainFileName = Args.getLastArgValue(OPT_main_file_name);

// Frontend Options
if (Args.hasArg(OPT_INPUT)) {
  bool First = true;
  for (const Arg *A : Args.filtered(OPT_INPUT)) {
    if (First) {
      Opts.InputFile = A->getValue();
      First = false;
    } else {
      Diags.Report(diag::err_drv_unknown_argument) << A->getAsString(Args);
      Success = false;
    }
  }
}
Opts.LLVMArgs = Args.getAllArgValues(OPT_mllvm);
Opts.OutputPath = Args.getLastArgValue(OPT_o);
if (Arg *A = Args.getLastArg(OPT_filetype)) {
  StringRef Name = A->getValue();
  unsigned OutputType = StringSwitch<unsigned>(Name)
    .Case("asm", FT_Asm)
    .Case("null", FT_Null)
    .Case("obj", FT_Obj)
    .Default(~0U);
  if (OutputType == ~0U) {
    Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Name;
    Success = false;
  } else
    Opts.OutputType = FileType(OutputType);
}
Opts.ShowHelp = Args.hasArg(OPT_help);
Opts.ShowVersion = Args.hasArg(OPT_version);

// Transliterate Options
Opts.OutputAsmVariant =
    getLastArgIntValue(Args, OPT_output_asm_variant, 0, Diags);
Opts.ShowEncoding = Args.hasArg(OPT_show_encoding);
Opts.ShowInst = Args.hasArg(OPT_show_inst);

// Assemble Options
Opts.RelaxAll = Args.hasArg(OPT_mrelax_all);
Opts.NoExecStack = Args.hasArg(OPT_mno_exec_stack);
Opts.FatalWarnings = Args.hasArg(OPT_massembler_fatal_warnings);
Opts.RelocationModel = Args.getLastArgValue(OPT_mrelocation_model, "pic");
Opts.IncrementalLinkerCompatible =
    Args.hasArg(OPT_mincremental_linker_compatible);
Opts.SymbolDefs = Args.getAllArgValues(OPT_defsym);

return Success;
281}

283static std::unique_ptr<raw_fd_ostream>
284getOutputStream(AssemblerInvocation &Opts, DiagnosticsEngine &Diags,
              bool Binary) {
if (Opts.OutputPath.empty())
  Opts.OutputPath = "-";

// Make sure that the Out file gets unlinked from the disk if we get a
// SIGINT.
if (Opts.OutputPath != "-")
  sys::RemoveFileOnSignal(Opts.OutputPath);

std::error_code EC;
auto Out = llvm::make_unique<raw_fd_ostream>(
    Opts.OutputPath, EC, (Binary ? sys::fs::F_None : sys::fs::F_Text));
if (EC) {
  Diags.Report(diag::err_fe_unable_to_open_output) << Opts.OutputPath
                                                   << EC.message();
  return nullptr;
}

return Out;
304}

306static bool ExecuteAssembler(AssemblerInvocation &Opts,
                           DiagnosticsEngine &Diags) {
// Get the target specific parser.
std::string Error;
const Target *TheTarget = TargetRegistry::lookupTarget(Opts.Triple, Error);
if (!TheTarget)
10
←
Assuming 'TheTarget' is non-null→
11
←
Taking false branch→
  return Diags.Report(diag::err_target_unknown_triple) << Opts.Triple;

ErrorOr<std::unique_ptr<MemoryBuffer>> Buffer =
    MemoryBuffer::getFileOrSTDIN(Opts.InputFile);

if (std::error_code EC = Buffer.getError()) {
12
←
Taking false branch→
  Error = EC.message();
  return Diags.Report(diag::err_fe_error_reading) << Opts.InputFile;
}

SourceMgr SrcMgr;

// Tell SrcMgr about this buffer, which is what the parser will pick up.
SrcMgr.AddNewSourceBuffer(std::move(*Buffer), SMLoc());

// Record the location of the include directories so that the lexer can find
// it later.
SrcMgr.setIncludeDirs(Opts.IncludePaths);

std::unique_ptr<MCRegisterInfo> MRI(TheTarget->createMCRegInfo(Opts.Triple));
assert(MRI && "Unable to create target register info!")(static_cast <bool> (MRI && "Unable to create target register info!"
) ? void (0) : __assert_fail ("MRI && \"Unable to create target register info!\""
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/tools/driver/cc1as_main.cpp"
, 332, __extension__ __PRETTY_FUNCTION__));

std::unique_ptr<MCAsmInfo> MAI(TheTarget->createMCAsmInfo(*MRI, Opts.Triple));
assert(MAI && "Unable to create target asm info!")(static_cast <bool> (MAI && "Unable to create target asm info!"
) ? void (0) : __assert_fail ("MAI && \"Unable to create target asm info!\""
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/tools/driver/cc1as_main.cpp"
, 335, __extension__ __PRETTY_FUNCTION__));

// Ensure MCAsmInfo initialization occurs before any use, otherwise sections
// may be created with a combination of default and explicit settings.
MAI->setCompressDebugSections(Opts.CompressDebugSections);

MAI->setRelaxELFRelocations(Opts.RelaxELFRelocations);

bool IsBinary = Opts.OutputType == AssemblerInvocation::FT_Obj;
13
←
Assuming the condition is false→
std::unique_ptr<raw_fd_ostream> FDOS = getOutputStream(Opts, Diags, IsBinary);
if (!FDOS)
14
←
Taking false branch→
  return true;

// FIXME: This is not pretty. MCContext has a ptr to MCObjectFileInfo and
// MCObjectFileInfo needs a MCContext reference in order to initialize itself.
std::unique_ptr<MCObjectFileInfo> MOFI(new MCObjectFileInfo());

MCContext Ctx(MAI.get(), MRI.get(), MOFI.get(), &SrcMgr);

bool PIC = false;
if (Opts.RelocationModel == "static") {
15
←
Taking true branch→
  PIC = false;
} else if (Opts.RelocationModel == "pic") {
  PIC = true;
} else {
  assert(Opts.RelocationModel == "dynamic-no-pic" &&(static_cast <bool> (Opts.RelocationModel == "dynamic-no-pic"
 && "Invalid PIC model!") ? void (0) : __assert_fail (
"Opts.RelocationModel == \"dynamic-no-pic\" && \"Invalid PIC model!\""
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/tools/driver/cc1as_main.cpp"
, 361, __extension__ __PRETTY_FUNCTION__))
         "Invalid PIC model!")(static_cast <bool> (Opts.RelocationModel == "dynamic-no-pic"
 && "Invalid PIC model!") ? void (0) : __assert_fail (
"Opts.RelocationModel == \"dynamic-no-pic\" && \"Invalid PIC model!\""
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/tools/driver/cc1as_main.cpp"
, 361, __extension__ __PRETTY_FUNCTION__));
  PIC = false;
}

MOFI->InitMCObjectFileInfo(Triple(Opts.Triple), PIC, Ctx);
if (Opts.SaveTemporaryLabels)
16
←
Assuming the condition is false→
17
←
Taking false branch→
  Ctx.setAllowTemporaryLabels(false);
if (Opts.GenDwarfForAssembly)
18
←
Assuming the condition is false→
19
←
Taking false branch→
  Ctx.setGenDwarfForAssembly(true);
if (!Opts.DwarfDebugFlags.empty())
20
←
Assuming the condition is false→
21
←
Taking false branch→
  Ctx.setDwarfDebugFlags(StringRef(Opts.DwarfDebugFlags));
if (!Opts.DwarfDebugProducer.empty())
22
←
Assuming the condition is false→
23
←
Taking false branch→
  Ctx.setDwarfDebugProducer(StringRef(Opts.DwarfDebugProducer));
if (!Opts.DebugCompilationDir.empty())
24
←
Assuming the condition is false→
25
←
Taking false branch→
  Ctx.setCompilationDir(Opts.DebugCompilationDir);
if (!Opts.MainFileName.empty())
26
←
Assuming the condition is false→
27
←
Taking false branch→
  Ctx.setMainFileName(StringRef(Opts.MainFileName));
Ctx.setDwarfVersion(Opts.DwarfVersion);

// Build up the feature string from the target feature list.
std::string FS;
if (!Opts.Features.empty()) {
28
←
Assuming the condition is false→
29
←
Taking false branch→
  FS = Opts.Features[0];
  for (unsigned i = 1, e = Opts.Features.size(); i != e; ++i)
    FS += "," + Opts.Features[i];
}

std::unique_ptr<MCStreamer> Str;

std::unique_ptr<MCInstrInfo> MCII(TheTarget->createMCInstrInfo());
std::unique_ptr<MCSubtargetInfo> STI(
    TheTarget->createMCSubtargetInfo(Opts.Triple, Opts.CPU, FS));

raw_pwrite_stream *Out = FDOS.get();
std::unique_ptr<buffer_ostream> BOS;

// FIXME: There is a bit of code duplication with addPassesToEmitFile.
if (Opts.OutputType == AssemblerInvocation::FT_Asm) {
30
←
Assuming the condition is true→
31
←
Taking true branch→
  MCInstPrinter *IP = TheTarget->createMCInstPrinter(
      llvm::Triple(Opts.Triple), Opts.OutputAsmVariant, *MAI, *MCII, *MRI);
  MCCodeEmitter *CE = nullptr;
  MCAsmBackend *MAB = nullptr;
  if (Opts.ShowEncoding) {
32
←
Assuming the condition is false→
33
←
Taking false branch→
    CE = TheTarget->createMCCodeEmitter(*MCII, *MRI, Ctx);
    MCTargetOptions Options;
    MAB = TheTarget->createMCAsmBackend(*STI, *MRI, Options);
  }
  auto FOut = llvm::make_unique<formatted_raw_ostream>(*Out);
  Str.reset(TheTarget->createAsmStreamer(
34
←
Calling 'Target::createAsmStreamer'→
      Ctx, std::move(FOut), /*asmverbose*/ true,
      /*useDwarfDirectory*/ true, IP, CE, MAB, Opts.ShowInst));
} else if (Opts.OutputType == AssemblerInvocation::FT_Null) {
  Str.reset(createNullStreamer(Ctx));
} else {
  assert(Opts.OutputType == AssemblerInvocation::FT_Obj &&(static_cast <bool> (Opts.OutputType == AssemblerInvocation
::FT_Obj && "Invalid file type!") ? void (0) : __assert_fail
 ("Opts.OutputType == AssemblerInvocation::FT_Obj && \"Invalid file type!\""
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/tools/driver/cc1as_main.cpp"
, 416, __extension__ __PRETTY_FUNCTION__))
         "Invalid file type!")(static_cast <bool> (Opts.OutputType == AssemblerInvocation
::FT_Obj && "Invalid file type!") ? void (0) : __assert_fail
 ("Opts.OutputType == AssemblerInvocation::FT_Obj && \"Invalid file type!\""
, "/build/llvm-toolchain-snapshot-7~svn329677/tools/clang/tools/driver/cc1as_main.cpp"
, 416, __extension__ __PRETTY_FUNCTION__));
  if (!FDOS->supportsSeeking()) {
    BOS = make_unique<buffer_ostream>(*FDOS);
    Out = BOS.get();
  }

  MCCodeEmitter *CE = TheTarget->createMCCodeEmitter(*MCII, *MRI, Ctx);
  MCTargetOptions Options;
  MCAsmBackend *MAB = TheTarget->createMCAsmBackend(*STI, *MRI, Options);
  Triple T(Opts.Triple);
  Str.reset(TheTarget->createMCObjectStreamer(
              T, Ctx, std::unique_ptr<MCAsmBackend>(MAB), *Out, std::unique_ptr<MCCodeEmitter>(CE), *STI,
      Opts.RelaxAll, Opts.IncrementalLinkerCompatible,
      /*DWARFMustBeAtTheEnd*/ true));
  Str.get()->InitSections(Opts.NoExecStack);
}

bool Failed = false;

std::unique_ptr<MCAsmParser> Parser(
    createMCAsmParser(SrcMgr, Ctx, *Str.get(), *MAI));

// FIXME: init MCTargetOptions from sanitizer flags here.
MCTargetOptions Options;
std::unique_ptr<MCTargetAsmParser> TAP(
    TheTarget->createMCAsmParser(*STI, *Parser, *MCII, Options));
if (!TAP)
  Failed = Diags.Report(diag::err_target_unknown_triple) << Opts.Triple;

// Set values for symbols, if any.
for (auto &S : Opts.SymbolDefs) {
  auto Pair = StringRef(S).split('=');
  auto Sym = Pair.first;
  auto Val = Pair.second;
  int64_t Value;
  // We have already error checked this in the driver.
  Val.getAsInteger(0, Value);
  Ctx.setSymbolValue(Parser->getStreamer(), Sym, Value);
}

if (!Failed) {
  Parser->setTargetParser(*TAP.get());
  Failed = Parser->Run(Opts.NoInitialTextSection);
}

// Close Streamer first.
// It might have a reference to the output stream.
Str.reset();
// Close the output stream early.
BOS.reset();
FDOS.reset();

// Delete output file if there were errors.
if (Failed && Opts.OutputPath != "-")
  sys::fs::remove(Opts.OutputPath);

return Failed;
473}

475static void LLVMErrorHandler(void *UserData, const std::string &Message,
                           bool GenCrashDiag) {
DiagnosticsEngine &Diags = *static_cast<DiagnosticsEngine*>(UserData);

Diags.Report(diag::err_fe_error_backend) << Message;

// We cannot recover from llvm errors.
exit(1);
483}

485int cc1as_main(ArrayRef<const char *> Argv, const char *Argv0, void *MainAddr) {
// Initialize targets and assembly printers/parsers.
InitializeAllTargetInfos();
InitializeAllTargetMCs();
InitializeAllAsmParsers();

// Construct our diagnostic client.
IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions();
TextDiagnosticPrinter *DiagClient
  = new TextDiagnosticPrinter(errs(), &*DiagOpts);
DiagClient->setPrefix("clang -cc1as");
IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
DiagnosticsEngine Diags(DiagID, &*DiagOpts, DiagClient);

// Set an error handler, so that any LLVM backend diagnostics go through our
// error handler.
ScopedFatalErrorHandler FatalErrorHandler
  (LLVMErrorHandler, static_cast<void*>(&Diags));

// Parse the arguments.
AssemblerInvocation Asm;
if (!AssemblerInvocation::CreateFromArgs(Asm, Argv, Diags))
1
Taking false branch→
  return 1;

if (Asm.ShowHelp) {
2
←
Assuming the condition is false→
3
←
Taking false branch→
  std::unique_ptr<OptTable> Opts(driver::createDriverOptTable());
  Opts->PrintHelp(llvm::outs(), "clang -cc1as", "Clang Integrated Assembler",
                  /*Include=*/driver::options::CC1AsOption, /*Exclude=*/0,
                  /*ShowAllAliases=*/false);
  return 0;
}

// Honor -version.
//
// FIXME: Use a better -version message?
if (Asm.ShowVersion) {
4
←
Assuming the condition is false→
5
←
Taking false branch→
  llvm::cl::PrintVersionMessage();
  return 0;
}

// Honor -mllvm.
//
// FIXME: Remove this, one day.
if (!Asm.LLVMArgs.empty()) {
6
←
Assuming the condition is false→
7
←
Taking false branch→
  unsigned NumArgs = Asm.LLVMArgs.size();
  auto Args = llvm::make_unique<const char*[]>(NumArgs + 2);
  Args[0] = "clang (LLVM option parsing)";
  for (unsigned i = 0; i != NumArgs; ++i)
    Args[i + 1] = Asm.LLVMArgs[i].c_str();
  Args[NumArgs + 1] = nullptr;
  llvm::cl::ParseCommandLineOptions(NumArgs + 1, Args.get());
}

// Execute the invocation, unless there were parsing errors.
bool Failed = Diags.hasErrorOccurred() || ExecuteAssembler(Asm, Diags);
8
←
Assuming the condition is false→
9
←
Calling 'ExecuteAssembler'→

// If any timers were active but haven't been destroyed yet, print their
// results now.
TimerGroup::printAll(errs());

return !!Failed;
546}

←

/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/Support/TargetRegistry.h

→

1//===- Support/TargetRegistry.h - Target Registration -----------*- C++ -*-===//
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//===----------------------------------------------------------------------===//
9//
10// This file exposes the TargetRegistry interface, which tools can use to access
11// the appropriate target specific classes (TargetMachine, AsmPrinter, etc.)
12// which have been registered.
13//
14// Target specific class implementations should register themselves using the
15// appropriate TargetRegistry interfaces.
16//
17//===----------------------------------------------------------------------===//

19#ifndef LLVM_SUPPORT_TARGETREGISTRY_H
20#define LLVM_SUPPORT_TARGETREGISTRY_H

22#include "llvm-c/DisassemblerTypes.h"
23#include "llvm/ADT/Optional.h"
24#include "llvm/ADT/StringRef.h"
25#include "llvm/ADT/Triple.h"
26#include "llvm/ADT/iterator_range.h"
27#include "llvm/Support/CodeGen.h"
28#include "llvm/Support/ErrorHandling.h"
29#include "llvm/Support/FormattedStream.h"
30#include <algorithm>
31#include <cassert>
32#include <cstddef>
33#include <iterator>
34#include <memory>
35#include <string>

37namespace llvm {

39class AsmPrinter;
40class MCAsmBackend;
41class MCAsmInfo;
42class MCAsmParser;
43class MCCodeEmitter;
44class MCContext;
45class MCDisassembler;
46class MCInstPrinter;
47class MCInstrAnalysis;
48class MCInstrInfo;
49class MCRegisterInfo;
50class MCRelocationInfo;
51class MCStreamer;
52class MCSubtargetInfo;
53class MCSymbolizer;
54class MCTargetAsmParser;
55class MCTargetOptions;
56class MCTargetStreamer;
57class raw_ostream;
58class raw_pwrite_stream;
59class TargetMachine;
60class TargetOptions;

62MCStreamer *createNullStreamer(MCContext &Ctx);
63MCStreamer *createAsmStreamer(MCContext &Ctx,
                            std::unique_ptr<formatted_raw_ostream> OS,
                            bool isVerboseAsm, bool useDwarfDirectory,
                            MCInstPrinter *InstPrint, MCCodeEmitter *CE,
                            MCAsmBackend *TAB, bool ShowInst);

69/// Takes ownership of \p TAB and \p CE.
70MCStreamer *createELFStreamer(MCContext &Ctx,
                            std::unique_ptr<MCAsmBackend> &&TAB,
                            raw_pwrite_stream &OS,
                            std::unique_ptr<MCCodeEmitter> &&CE,
                            bool RelaxAll);
75MCStreamer *createMachOStreamer(MCContext &Ctx,
                              std::unique_ptr<MCAsmBackend> &&TAB,
                              raw_pwrite_stream &OS,
                              std::unique_ptr<MCCodeEmitter> &&CE,
                              bool RelaxAll, bool DWARFMustBeAtTheEnd,
                              bool LabelSections = false);
81MCStreamer *createWasmStreamer(MCContext &Ctx,
                             std::unique_ptr<MCAsmBackend> &&TAB,
                             raw_pwrite_stream &OS,
                             std::unique_ptr<MCCodeEmitter> &&CE,
                             bool RelaxAll);

87MCRelocationInfo *createMCRelocationInfo(const Triple &TT, MCContext &Ctx);

89MCSymbolizer *createMCSymbolizer(const Triple &TT, LLVMOpInfoCallback GetOpInfo,
                               LLVMSymbolLookupCallback SymbolLookUp,
                               void *DisInfo, MCContext *Ctx,
                               std::unique_ptr<MCRelocationInfo> &&RelInfo);

94/// Target - Wrapper for Target specific information.
95///
96/// For registration purposes, this is a POD type so that targets can be
97/// registered without the use of static constructors.
98///
99/// Targets should implement a single global instance of this class (which
100/// will be zero initialized), and pass that instance to the TargetRegistry as
101/// part of their initialization.
102class Target {
103public:
friend struct TargetRegistry;

using ArchMatchFnTy = bool (*)(Triple::ArchType Arch);

using MCAsmInfoCtorFnTy = MCAsmInfo *(*)(const MCRegisterInfo &MRI,
                                         const Triple &TT);
using MCInstrInfoCtorFnTy = MCInstrInfo *(*)();
using MCInstrAnalysisCtorFnTy = MCInstrAnalysis *(*)(const MCInstrInfo *Info);
using MCRegInfoCtorFnTy = MCRegisterInfo *(*)(const Triple &TT);
using MCSubtargetInfoCtorFnTy = MCSubtargetInfo *(*)(const Triple &TT,
                                                     StringRef CPU,
                                                     StringRef Features);
using TargetMachineCtorTy = TargetMachine
    *(*)(const Target &T, const Triple &TT, StringRef CPU, StringRef Features,
         const TargetOptions &Options, Optional<Reloc::Model> RM,
         Optional<CodeModel::Model> CM, CodeGenOpt::Level OL, bool JIT);
// If it weren't for layering issues (this header is in llvm/Support, but
// depends on MC?) this should take the Streamer by value rather than rvalue
// reference.
using AsmPrinterCtorTy = AsmPrinter *(*)(
    TargetMachine &TM, std::unique_ptr<MCStreamer> &&Streamer);
using MCAsmBackendCtorTy = MCAsmBackend *(*)(const Target &T,
                                             const MCSubtargetInfo &STI,
                                             const MCRegisterInfo &MRI,
                                             const MCTargetOptions &Options);
using MCAsmParserCtorTy = MCTargetAsmParser *(*)(
    const MCSubtargetInfo &STI, MCAsmParser &P, const MCInstrInfo &MII,
    const MCTargetOptions &Options);
using MCDisassemblerCtorTy = MCDisassembler *(*)(const Target &T,
                                                 const MCSubtargetInfo &STI,
                                                 MCContext &Ctx);
using MCInstPrinterCtorTy = MCInstPrinter *(*)(const Triple &T,
                                               unsigned SyntaxVariant,
                                               const MCAsmInfo &MAI,
                                               const MCInstrInfo &MII,
                                               const MCRegisterInfo &MRI);
using MCCodeEmitterCtorTy = MCCodeEmitter *(*)(const MCInstrInfo &II,
                                               const MCRegisterInfo &MRI,
                                               MCContext &Ctx);
using ELFStreamerCtorTy =
    MCStreamer *(*)(const Triple &T, MCContext &Ctx,
                    std::unique_ptr<MCAsmBackend> &&TAB,
                    raw_pwrite_stream &OS,
                    std::unique_ptr<MCCodeEmitter> &&Emitter, bool RelaxAll);
using MachOStreamerCtorTy =
    MCStreamer *(*)(MCContext &Ctx, std::unique_ptr<MCAsmBackend> &&TAB,
                    raw_pwrite_stream &OS,
                    std::unique_ptr<MCCodeEmitter> &&Emitter, bool RelaxAll,
                    bool DWARFMustBeAtTheEnd);
using COFFStreamerCtorTy =
    MCStreamer *(*)(MCContext &Ctx, std::unique_ptr<MCAsmBackend> &&TAB,
                    raw_pwrite_stream &OS,
                    std::unique_ptr<MCCodeEmitter> &&Emitter, bool RelaxAll,
                    bool IncrementalLinkerCompatible);
using WasmStreamerCtorTy =
    MCStreamer *(*)(const Triple &T, MCContext &Ctx,
                    std::unique_ptr<MCAsmBackend> &&TAB,
                    raw_pwrite_stream &OS,
                    std::unique_ptr<MCCodeEmitter> &&Emitter, bool RelaxAll);
using NullTargetStreamerCtorTy = MCTargetStreamer *(*)(MCStreamer &S);
using AsmTargetStreamerCtorTy = MCTargetStreamer *(*)(
    MCStreamer &S, formatted_raw_ostream &OS, MCInstPrinter *InstPrint,
    bool IsVerboseAsm);
using ObjectTargetStreamerCtorTy = MCTargetStreamer *(*)(
    MCStreamer &S, const MCSubtargetInfo &STI);
using MCRelocationInfoCtorTy = MCRelocationInfo *(*)(const Triple &TT,
                                                     MCContext &Ctx);
using MCSymbolizerCtorTy = MCSymbolizer *(*)(
    const Triple &TT, LLVMOpInfoCallback GetOpInfo,
    LLVMSymbolLookupCallback SymbolLookUp, void *DisInfo, MCContext *Ctx,
    std::unique_ptr<MCRelocationInfo> &&RelInfo);

176private:
/// Next - The next registered target in the linked list, maintained by the
/// TargetRegistry.
Target *Next;

/// The target function for checking if an architecture is supported.
ArchMatchFnTy ArchMatchFn;

/// Name - The target name.
const char *Name;

/// ShortDesc - A short description of the target.
const char *ShortDesc;

/// BackendName - The name of the backend implementation. This must match the
/// name of the 'def X : Target ...' in TableGen.
const char *BackendName;

/// HasJIT - Whether this target supports the JIT.
bool HasJIT;

/// MCAsmInfoCtorFn - Constructor function for this target's MCAsmInfo, if
/// registered.
MCAsmInfoCtorFnTy MCAsmInfoCtorFn;

/// MCInstrInfoCtorFn - Constructor function for this target's MCInstrInfo,
/// if registered.
MCInstrInfoCtorFnTy MCInstrInfoCtorFn;

/// MCInstrAnalysisCtorFn - Constructor function for this target's
/// MCInstrAnalysis, if registered.
MCInstrAnalysisCtorFnTy MCInstrAnalysisCtorFn;

/// MCRegInfoCtorFn - Constructor function for this target's MCRegisterInfo,
/// if registered.
MCRegInfoCtorFnTy MCRegInfoCtorFn;

/// MCSubtargetInfoCtorFn - Constructor function for this target's
/// MCSubtargetInfo, if registered.
MCSubtargetInfoCtorFnTy MCSubtargetInfoCtorFn;

/// TargetMachineCtorFn - Construction function for this target's
/// TargetMachine, if registered.
TargetMachineCtorTy TargetMachineCtorFn;

/// MCAsmBackendCtorFn - Construction function for this target's
/// MCAsmBackend, if registered.
MCAsmBackendCtorTy MCAsmBackendCtorFn;

/// MCAsmParserCtorFn - Construction function for this target's
/// MCTargetAsmParser, if registered.
MCAsmParserCtorTy MCAsmParserCtorFn;

/// AsmPrinterCtorFn - Construction function for this target's AsmPrinter,
/// if registered.
AsmPrinterCtorTy AsmPrinterCtorFn;

/// MCDisassemblerCtorFn - Construction function for this target's
/// MCDisassembler, if registered.
MCDisassemblerCtorTy MCDisassemblerCtorFn;

/// MCInstPrinterCtorFn - Construction function for this target's
/// MCInstPrinter, if registered.
MCInstPrinterCtorTy MCInstPrinterCtorFn;

/// MCCodeEmitterCtorFn - Construction function for this target's
/// CodeEmitter, if registered.
MCCodeEmitterCtorTy MCCodeEmitterCtorFn;

// Construction functions for the various object formats, if registered.
COFFStreamerCtorTy COFFStreamerCtorFn = nullptr;
MachOStreamerCtorTy MachOStreamerCtorFn = nullptr;
ELFStreamerCtorTy ELFStreamerCtorFn = nullptr;
WasmStreamerCtorTy WasmStreamerCtorFn = nullptr;

/// Construction function for this target's null TargetStreamer, if
/// registered (default = nullptr).
NullTargetStreamerCtorTy NullTargetStreamerCtorFn = nullptr;

/// Construction function for this target's asm TargetStreamer, if
/// registered (default = nullptr).
AsmTargetStreamerCtorTy AsmTargetStreamerCtorFn = nullptr;

/// Construction function for this target's obj TargetStreamer, if
/// registered (default = nullptr).
ObjectTargetStreamerCtorTy ObjectTargetStreamerCtorFn = nullptr;

/// MCRelocationInfoCtorFn - Construction function for this target's
/// MCRelocationInfo, if registered (default = llvm::createMCRelocationInfo)
MCRelocationInfoCtorTy MCRelocationInfoCtorFn = nullptr;

/// MCSymbolizerCtorFn - Construction function for this target's
/// MCSymbolizer, if registered (default = llvm::createMCSymbolizer)
MCSymbolizerCtorTy MCSymbolizerCtorFn = nullptr;

271public:
Target() = default;

/// @name Target Information
/// @{

// getNext - Return the next registered target.
const Target *getNext() const { return Next; }

/// getName - Get the target name.
const char *getName() const { return Name; }

/// getShortDescription - Get a short description of the target.
const char *getShortDescription() const { return ShortDesc; }

/// getBackendName - Get the backend name.
const char *getBackendName() const { return BackendName; }

/// @}
/// @name Feature Predicates
/// @{

/// hasJIT - Check if this targets supports the just-in-time compilation.
bool hasJIT() const { return HasJIT; }

/// hasTargetMachine - Check if this target supports code generation.
bool hasTargetMachine() const { return TargetMachineCtorFn != nullptr; }

/// hasMCAsmBackend - Check if this target supports .o generation.
bool hasMCAsmBackend() const { return MCAsmBackendCtorFn != nullptr; }

/// hasMCAsmParser - Check if this target supports assembly parsing.
bool hasMCAsmParser() const { return MCAsmParserCtorFn != nullptr; }

/// @}
/// @name Feature Constructors
/// @{

/// createMCAsmInfo - Create a MCAsmInfo implementation for the specified
/// target triple.
///
/// \param TheTriple This argument is used to determine the target machine
/// feature set; it should always be provided. Generally this should be
/// either the target triple from the module, or the target triple of the
/// host if that does not exist.
MCAsmInfo *createMCAsmInfo(const MCRegisterInfo &MRI,
                           StringRef TheTriple) const {
  if (!MCAsmInfoCtorFn)
    return nullptr;
  return MCAsmInfoCtorFn(MRI, Triple(TheTriple));
}

/// createMCInstrInfo - Create a MCInstrInfo implementation.
///
MCInstrInfo *createMCInstrInfo() const {
  if (!MCInstrInfoCtorFn)
    return nullptr;
  return MCInstrInfoCtorFn();
}

/// createMCInstrAnalysis - Create a MCInstrAnalysis implementation.
///
MCInstrAnalysis *createMCInstrAnalysis(const MCInstrInfo *Info) const {
  if (!MCInstrAnalysisCtorFn)
    return nullptr;
  return MCInstrAnalysisCtorFn(Info);
}

/// createMCRegInfo - Create a MCRegisterInfo implementation.
///
MCRegisterInfo *createMCRegInfo(StringRef TT) const {
  if (!MCRegInfoCtorFn)
    return nullptr;
  return MCRegInfoCtorFn(Triple(TT));
}

/// createMCSubtargetInfo - Create a MCSubtargetInfo implementation.
///
/// \param TheTriple This argument is used to determine the target machine
/// feature set; it should always be provided. Generally this should be
/// either the target triple from the module, or the target triple of the
/// host if that does not exist.
/// \param CPU This specifies the name of the target CPU.
/// \param Features This specifies the string representation of the
/// additional target features.
MCSubtargetInfo *createMCSubtargetInfo(StringRef TheTriple, StringRef CPU,
                                       StringRef Features) const {
  if (!MCSubtargetInfoCtorFn)
    return nullptr;
  return MCSubtargetInfoCtorFn(Triple(TheTriple), CPU, Features);
}

/// createTargetMachine - Create a target specific machine implementation
/// for the specified \p Triple.
///
/// \param TT This argument is used to determine the target machine
/// feature set; it should always be provided. Generally this should be
/// either the target triple from the module, or the target triple of the
/// host if that does not exist.
TargetMachine *createTargetMachine(StringRef TT, StringRef CPU,
                                   StringRef Features,
                                   const TargetOptions &Options,
                                   Optional<Reloc::Model> RM,
                                   Optional<CodeModel::Model> CM = None,
                                   CodeGenOpt::Level OL = CodeGenOpt::Default,
                                   bool JIT = false) const {
  if (!TargetMachineCtorFn)
    return nullptr;
  return TargetMachineCtorFn(*this, Triple(TT), CPU, Features, Options, RM,
                             CM, OL, JIT);
}

/// createMCAsmBackend - Create a target specific assembly parser.
MCAsmBackend *createMCAsmBackend(const MCSubtargetInfo &STI,
                                 const MCRegisterInfo &MRI,
                                 const MCTargetOptions &Options) const {
  if (!MCAsmBackendCtorFn)
    return nullptr;
  return MCAsmBackendCtorFn(*this, STI, MRI, Options);
}

/// createMCAsmParser - Create a target specific assembly parser.
///
/// \param Parser The target independent parser implementation to use for
/// parsing and lexing.
MCTargetAsmParser *createMCAsmParser(const MCSubtargetInfo &STI,
                                     MCAsmParser &Parser,
                                     const MCInstrInfo &MII,
                                     const MCTargetOptions &Options) const {
  if (!MCAsmParserCtorFn)
    return nullptr;
  return MCAsmParserCtorFn(STI, Parser, MII, Options);
}

/// createAsmPrinter - Create a target specific assembly printer pass.  This
/// takes ownership of the MCStreamer object.
AsmPrinter *createAsmPrinter(TargetMachine &TM,
                             std::unique_ptr<MCStreamer> &&Streamer) const {
  if (!AsmPrinterCtorFn)
    return nullptr;
  return AsmPrinterCtorFn(TM, std::move(Streamer));
}

MCDisassembler *createMCDisassembler(const MCSubtargetInfo &STI,
                                     MCContext &Ctx) const {
  if (!MCDisassemblerCtorFn)
    return nullptr;
  return MCDisassemblerCtorFn(*this, STI, Ctx);
}

MCInstPrinter *createMCInstPrinter(const Triple &T, unsigned SyntaxVariant,
                                   const MCAsmInfo &MAI,
                                   const MCInstrInfo &MII,
                                   const MCRegisterInfo &MRI) const {
  if (!MCInstPrinterCtorFn)
    return nullptr;
  return MCInstPrinterCtorFn(T, SyntaxVariant, MAI, MII, MRI);
}

/// createMCCodeEmitter - Create a target specific code emitter.
MCCodeEmitter *createMCCodeEmitter(const MCInstrInfo &II,
                                   const MCRegisterInfo &MRI,
                                   MCContext &Ctx) const {
  if (!MCCodeEmitterCtorFn)
    return nullptr;
  return MCCodeEmitterCtorFn(II, MRI, Ctx);
}

/// Create a target specific MCStreamer.
///
/// \param T The target triple.
/// \param Ctx The target context.
/// \param TAB The target assembler backend object. Takes ownership.
/// \param OS The stream object.
/// \param Emitter The target independent assembler object.Takes ownership.
/// \param RelaxAll Relax all fixups?
MCStreamer *createMCObjectStreamer(const Triple &T, MCContext &Ctx,
                                   std::unique_ptr<MCAsmBackend> &&TAB,
                                   raw_pwrite_stream &OS,
                                   std::unique_ptr<MCCodeEmitter> &&Emitter,
                                   const MCSubtargetInfo &STI, bool RelaxAll,
                                   bool IncrementalLinkerCompatible,
                                   bool DWARFMustBeAtTheEnd) const {
  MCStreamer *S;
  switch (T.getObjectFormat()) {
  default:
    llvm_unreachable("Unknown object format")::llvm::llvm_unreachable_internal("Unknown object format", "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/Support/TargetRegistry.h"
, 457);
  case Triple::COFF:
    assert(T.isOSWindows() && "only Windows COFF is supported")(static_cast <bool> (T.isOSWindows() && "only Windows COFF is supported"
) ? void (0) : __assert_fail ("T.isOSWindows() && \"only Windows COFF is supported\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/Support/TargetRegistry.h"
, 459, __extension__ __PRETTY_FUNCTION__));
    S = COFFStreamerCtorFn(Ctx, std::move(TAB), OS, std::move(Emitter),
                           RelaxAll, IncrementalLinkerCompatible);
    break;
  case Triple::MachO:
    if (MachOStreamerCtorFn)
      S = MachOStreamerCtorFn(Ctx, std::move(TAB), OS, std::move(Emitter),
                              RelaxAll, DWARFMustBeAtTheEnd);
    else
      S = createMachOStreamer(Ctx, std::move(TAB), OS, std::move(Emitter),
                              RelaxAll, DWARFMustBeAtTheEnd);
    break;
  case Triple::ELF:
    if (ELFStreamerCtorFn)
      S = ELFStreamerCtorFn(T, Ctx, std::move(TAB), OS, std::move(Emitter),
                            RelaxAll);
    else
      S = createELFStreamer(Ctx, std::move(TAB), OS, std::move(Emitter),
                            RelaxAll);
    break;
  case Triple::Wasm:
    if (WasmStreamerCtorFn)
      S = WasmStreamerCtorFn(T, Ctx, std::move(TAB), OS, std::move(Emitter),
                             RelaxAll);
    else
      S = createWasmStreamer(Ctx, std::move(TAB), OS, std::move(Emitter),
                             RelaxAll);
    break;
  }
  if (ObjectTargetStreamerCtorFn)
    ObjectTargetStreamerCtorFn(*S, STI);
  return S;
}

MCStreamer *createAsmStreamer(MCContext &Ctx,
                              std::unique_ptr<formatted_raw_ostream> OS,
                              bool IsVerboseAsm, bool UseDwarfDirectory,
                              MCInstPrinter *InstPrint, MCCodeEmitter *CE,
                              MCAsmBackend *TAB, bool ShowInst) const {
  formatted_raw_ostream &OSRef = *OS;
  MCStreamer *S = llvm::createAsmStreamer(Ctx, std::move(OS), IsVerboseAsm,
35
←
Calling '~unique_ptr'→
40
←
Returning from '~unique_ptr'→
                                          UseDwarfDirectory, InstPrint, CE,
                                          TAB, ShowInst);
  createAsmTargetStreamer(*S, OSRef, InstPrint, IsVerboseAsm);
41
←
Use of memory after it is freed
  return S;
}

MCTargetStreamer *createAsmTargetStreamer(MCStreamer &S,
                                          formatted_raw_ostream &OS,
                                          MCInstPrinter *InstPrint,
                                          bool IsVerboseAsm) const {
  if (AsmTargetStreamerCtorFn)
    return AsmTargetStreamerCtorFn(S, OS, InstPrint, IsVerboseAsm);
  return nullptr;
}

MCStreamer *createNullStreamer(MCContext &Ctx) const {
  MCStreamer *S = llvm::createNullStreamer(Ctx);
  createNullTargetStreamer(*S);
  return S;
}

MCTargetStreamer *createNullTargetStreamer(MCStreamer &S) const {
  if (NullTargetStreamerCtorFn)
    return NullTargetStreamerCtorFn(S);
  return nullptr;
}

/// createMCRelocationInfo - Create a target specific MCRelocationInfo.
///
/// \param TT The target triple.
/// \param Ctx The target context.
MCRelocationInfo *createMCRelocationInfo(StringRef TT, MCContext &Ctx) const {
  MCRelocationInfoCtorTy Fn = MCRelocationInfoCtorFn
                                  ? MCRelocationInfoCtorFn
                                  : llvm::createMCRelocationInfo;
  return Fn(Triple(TT), Ctx);
}

/// createMCSymbolizer - Create a target specific MCSymbolizer.
///
/// \param TT The target triple.
/// \param GetOpInfo The function to get the symbolic information for
/// operands.
/// \param SymbolLookUp The function to lookup a symbol name.
/// \param DisInfo The pointer to the block of symbolic information for above
/// call
/// back.
/// \param Ctx The target context.
/// \param RelInfo The relocation information for this target. Takes
/// ownership.
MCSymbolizer *
createMCSymbolizer(StringRef TT, LLVMOpInfoCallback GetOpInfo,
                   LLVMSymbolLookupCallback SymbolLookUp, void *DisInfo,
                   MCContext *Ctx,
                   std::unique_ptr<MCRelocationInfo> &&RelInfo) const {
  MCSymbolizerCtorTy Fn =
      MCSymbolizerCtorFn ? MCSymbolizerCtorFn : llvm::createMCSymbolizer;
  return Fn(Triple(TT), GetOpInfo, SymbolLookUp, DisInfo, Ctx,
            std::move(RelInfo));
}

/// @}
562};

564/// TargetRegistry - Generic interface to target specific features.
565struct TargetRegistry {
// FIXME: Make this a namespace, probably just move all the Register*
// functions into Target (currently they all just set members on the Target
// anyway, and Target friends this class so those functions can...
// function).
TargetRegistry() = delete;

class iterator
    : public std::iterator<std::forward_iterator_tag, Target, ptrdiff_t> {
  friend struct TargetRegistry;

  const Target *Current = nullptr;

  explicit iterator(Target *T) : Current(T) {}

public:
  iterator() = default;

  bool operator==(const iterator &x) const { return Current == x.Current; }
  bool operator!=(const iterator &x) const { return !operator==(x); }

  // Iterator traversal: forward iteration only
  iterator &operator++() { // Preincrement
    assert(Current && "Cannot increment end iterator!")(static_cast <bool> (Current && "Cannot increment end iterator!"
) ? void (0) : __assert_fail ("Current && \"Cannot increment end iterator!\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/Support/TargetRegistry.h"
, 588, __extension__ __PRETTY_FUNCTION__));
    Current = Current->getNext();
    return *this;
  }
  iterator operator++(int) { // Postincrement
    iterator tmp = *this;
    ++*this;
    return tmp;
  }

  const Target &operator*() const {
    assert(Current && "Cannot dereference end iterator!")(static_cast <bool> (Current && "Cannot dereference end iterator!"
) ? void (0) : __assert_fail ("Current && \"Cannot dereference end iterator!\""
, "/build/llvm-toolchain-snapshot-7~svn329677/include/llvm/Support/TargetRegistry.h"
, 599, __extension__ __PRETTY_FUNCTION__));
    return *Current;
  }

  const Target *operator->() const { return &operator*(); }
};

/// printRegisteredTargetsForVersion - Print the registered targets
/// appropriately for inclusion in a tool's version output.
static void printRegisteredTargetsForVersion(raw_ostream &OS);

/// @name Registry Access
/// @{

static iterator_range<iterator> targets();

/// lookupTarget - Lookup a target based on a target triple.
///
/// \param Triple - The triple to use for finding a target.
/// \param Error - On failure, an error string describing why no target was
/// found.
static const Target *lookupTarget(const std::string &Triple,
                                  std::string &Error);

/// lookupTarget - Lookup a target based on an architecture name
/// and a target triple.  If the architecture name is non-empty,
/// then the lookup is done by architecture.  Otherwise, the target
/// triple is used.
///
/// \param ArchName - The architecture to use for finding a target.
/// \param TheTriple - The triple to use for finding a target.  The
/// triple is updated with canonical architecture name if a lookup
/// by architecture is done.
/// \param Error - On failure, an error string describing why no target was
/// found.
static const Target *lookupTarget(const std::string &ArchName,
                                  Triple &TheTriple, std::string &Error);

/// @}
/// @name Target Registration
/// @{

/// RegisterTarget - Register the given target. Attempts to register a
/// target which has already been registered will be ignored.
///
/// Clients are responsible for ensuring that registration doesn't occur
/// while another thread is attempting to access the registry. Typically
/// this is done by initializing all targets at program startup.
///
/// @param T - The target being registered.
/// @param Name - The target name. This should be a static string.
/// @param ShortDesc - A short target description. This should be a static
/// string.
/// @param BackendName - The name of the backend. This should be a static
/// string that is the same for all targets that share a backend
/// implementation and must match the name used in the 'def X : Target ...' in
/// TableGen.
/// @param ArchMatchFn - The arch match checking function for this target.
/// @param HasJIT - Whether the target supports JIT code
/// generation.
static void RegisterTarget(Target &T, const char *Name, const char *ShortDesc,
                           const char *BackendName,
                           Target::ArchMatchFnTy ArchMatchFn,
                           bool HasJIT = false);

/// RegisterMCAsmInfo - Register a MCAsmInfo implementation for the
/// given target.
///
/// Clients are responsible for ensuring that registration doesn't occur
/// while another thread is attempting to access the registry. Typically
/// this is done by initializing all targets at program startup.
///
/// @param T - The target being registered.
/// @param Fn - A function to construct a MCAsmInfo for the target.
static void RegisterMCAsmInfo(Target &T, Target::MCAsmInfoCtorFnTy Fn) {
  T.MCAsmInfoCtorFn = Fn;
}

/// RegisterMCInstrInfo - Register a MCInstrInfo implementation for the
/// given target.
///
/// Clients are responsible for ensuring that registration doesn't occur
/// while another thread is attempting to access the registry. Typically
/// this is done by initializing all targets at program startup.
///
/// @param T - The target being registered.
/// @param Fn - A function to construct a MCInstrInfo for the target.
static void RegisterMCInstrInfo(Target &T, Target::MCInstrInfoCtorFnTy Fn) {
  T.MCInstrInfoCtorFn = Fn;
}

/// RegisterMCInstrAnalysis - Register a MCInstrAnalysis implementation for
/// the given target.
static void RegisterMCInstrAnalysis(Target &T,
                                    Target::MCInstrAnalysisCtorFnTy Fn) {
  T.MCInstrAnalysisCtorFn = Fn;
}

/// RegisterMCRegInfo - Register a MCRegisterInfo implementation for the
/// given target.
///
/// Clients are responsible for ensuring that registration doesn't occur
/// while another thread is attempting to access the registry. Typically
/// this is done by initializing all targets at program startup.
///
/// @param T - The target being registered.
/// @param Fn - A function to construct a MCRegisterInfo for the target.
static void RegisterMCRegInfo(Target &T, Target::MCRegInfoCtorFnTy Fn) {
  T.MCRegInfoCtorFn = Fn;
}

/// RegisterMCSubtargetInfo - Register a MCSubtargetInfo implementation for
/// the given target.
///
/// Clients are responsible for ensuring that registration doesn't occur
/// while another thread is attempting to access the registry. Typically
/// this is done by initializing all targets at program startup.
///
/// @param T - The target being registered.
/// @param Fn - A function to construct a MCSubtargetInfo for the target.
static void RegisterMCSubtargetInfo(Target &T,
                                    Target::MCSubtargetInfoCtorFnTy Fn) {
  T.MCSubtargetInfoCtorFn = Fn;
}

/// RegisterTargetMachine - Register a TargetMachine implementation for the
/// given target.
///
/// Clients are responsible for ensuring that registration doesn't occur
/// while another thread is attempting to access the registry. Typically
/// this is done by initializing all targets at program startup.
///
/// @param T - The target being registered.
/// @param Fn - A function to construct a TargetMachine for the target.
static void RegisterTargetMachine(Target &T, Target::TargetMachineCtorTy Fn) {
  T.TargetMachineCtorFn = Fn;
}

/// RegisterMCAsmBackend - Register a MCAsmBackend implementation for the
/// given target.
///
/// Clients are responsible for ensuring that registration doesn't occur
/// while another thread is attempting to access the registry. Typically
/// this is done by initializing all targets at program startup.
///
/// @param T - The target being registered.
/// @param Fn - A function to construct an AsmBackend for the target.
static void RegisterMCAsmBackend(Target &T, Target::MCAsmBackendCtorTy Fn) {
  T.MCAsmBackendCtorFn = Fn;
}

/// RegisterMCAsmParser - Register a MCTargetAsmParser implementation for
/// the given target.
///
/// Clients are responsible for ensuring that registration doesn't occur
/// while another thread is attempting to access the registry. Typically
/// this is done by initializing all targets at program startup.
///
/// @param T - The target being registered.
/// @param Fn - A function to construct an MCTargetAsmParser for the target.
static void RegisterMCAsmParser(Target &T, Target::MCAsmParserCtorTy Fn) {
  T.MCAsmParserCtorFn = Fn;
}

/// RegisterAsmPrinter - Register an AsmPrinter implementation for the given
/// target.
///
/// Clients are responsible for ensuring that registration doesn't occur
/// while another thread is attempting to access the registry. Typically
/// this is done by initializing all targets at program startup.
///
/// @param T - The target being registered.
/// @param Fn - A function to construct an AsmPrinter for the target.
static void RegisterAsmPrinter(Target &T, Target::AsmPrinterCtorTy Fn) {
  T.AsmPrinterCtorFn = Fn;
}

/// RegisterMCDisassembler - Register a MCDisassembler implementation for
/// the given target.
///
/// Clients are responsible for ensuring that registration doesn't occur
/// while another thread is attempting to access the registry. Typically
/// this is done by initializing all targets at program startup.
///
/// @param T - The target being registered.
/// @param Fn - A function to construct an MCDisassembler for the target.
static void RegisterMCDisassembler(Target &T,
                                   Target::MCDisassemblerCtorTy Fn) {
  T.MCDisassemblerCtorFn = Fn;
}

/// RegisterMCInstPrinter - Register a MCInstPrinter implementation for the
/// given target.
///
/// Clients are responsible for ensuring that registration doesn't occur
/// while another thread is attempting to access the registry. Typically
/// this is done by initializing all targets at program startup.
///
/// @param T - The target being registered.
/// @param Fn - A function to construct an MCInstPrinter for the target.
static void RegisterMCInstPrinter(Target &T, Target::MCInstPrinterCtorTy Fn) {
  T.MCInstPrinterCtorFn = Fn;
}

/// RegisterMCCodeEmitter - Register a MCCodeEmitter implementation for the
/// given target.
///
/// Clients are responsible for ensuring that registration doesn't occur
/// while another thread is attempting to access the registry. Typically
/// this is done by initializing all targets at program startup.
///
/// @param T - The target being registered.
/// @param Fn - A function to construct an MCCodeEmitter for the target.
static void RegisterMCCodeEmitter(Target &T, Target::MCCodeEmitterCtorTy Fn) {
  T.MCCodeEmitterCtorFn = Fn;
}

static void RegisterCOFFStreamer(Target &T, Target::COFFStreamerCtorTy Fn) {
  T.COFFStreamerCtorFn = Fn;
}

static void RegisterMachOStreamer(Target &T, Target::MachOStreamerCtorTy Fn) {
  T.MachOStreamerCtorFn = Fn;
}

static void RegisterELFStreamer(Target &T, Target::ELFStreamerCtorTy Fn) {
  T.ELFStreamerCtorFn = Fn;
}

static void RegisterWasmStreamer(Target &T, Target::WasmStreamerCtorTy Fn) {
  T.WasmStreamerCtorFn = Fn;
}

static void RegisterNullTargetStreamer(Target &T,
                                       Target::NullTargetStreamerCtorTy Fn) {
  T.NullTargetStreamerCtorFn = Fn;
}

static void RegisterAsmTargetStreamer(Target &T,
                                      Target::AsmTargetStreamerCtorTy Fn) {
  T.AsmTargetStreamerCtorFn = Fn;
}

static void
RegisterObjectTargetStreamer(Target &T,
                             Target::ObjectTargetStreamerCtorTy Fn) {
  T.ObjectTargetStreamerCtorFn = Fn;
}

/// RegisterMCRelocationInfo - Register an MCRelocationInfo
/// implementation for the given target.
///
/// Clients are responsible for ensuring that registration doesn't occur
/// while another thread is attempting to access the registry. Typically
/// this is done by initializing all targets at program startup.
///
/// @param T - The target being registered.
/// @param Fn - A function to construct an MCRelocationInfo for the target.
static void RegisterMCRelocationInfo(Target &T,
                                     Target::MCRelocationInfoCtorTy Fn) {
  T.MCRelocationInfoCtorFn = Fn;
}

/// RegisterMCSymbolizer - Register an MCSymbolizer
/// implementation for the given target.
///
/// Clients are responsible for ensuring that registration doesn't occur
/// while another thread is attempting to access the registry. Typically
/// this is done by initializing all targets at program startup.
///
/// @param T - The target being registered.
/// @param Fn - A function to construct an MCSymbolizer for the target.
static void RegisterMCSymbolizer(Target &T, Target::MCSymbolizerCtorTy Fn) {
  T.MCSymbolizerCtorFn = Fn;
}

/// @}
876};

878//===--------------------------------------------------------------------===//

880/// RegisterTarget - Helper template for registering a target, for use in the
881/// target's initialization function. Usage:
882///
883///
884/// Target &getTheFooTarget() { // The global target instance.
885///   static Target TheFooTarget;
886///   return TheFooTarget;
887/// }
888/// extern "C" void LLVMInitializeFooTargetInfo() {
889///   RegisterTarget<Triple::foo> X(getTheFooTarget(), "foo", "Foo
890///   description", "Foo" /* Backend Name */);
891/// }
892template <Triple::ArchType TargetArchType = Triple::UnknownArch,
        bool HasJIT = false>
894struct RegisterTarget {
RegisterTarget(Target &T, const char *Name, const char *Desc,
               const char *BackendName) {
  TargetRegistry::RegisterTarget(T, Name, Desc, BackendName, &getArchMatch,
                                 HasJIT);
}

static bool getArchMatch(Triple::ArchType Arch) {
  return Arch == TargetArchType;
}
904};

906/// RegisterMCAsmInfo - Helper template for registering a target assembly info
907/// implementation.  This invokes the static "Create" method on the class to
908/// actually do the construction.  Usage:
909///
910/// extern "C" void LLVMInitializeFooTarget() {
911///   extern Target TheFooTarget;
912///   RegisterMCAsmInfo<FooMCAsmInfo> X(TheFooTarget);
913/// }
914template <class MCAsmInfoImpl> struct RegisterMCAsmInfo {
RegisterMCAsmInfo(Target &T) {
  TargetRegistry::RegisterMCAsmInfo(T, &Allocator);
}

919private:
static MCAsmInfo *Allocator(const MCRegisterInfo & /*MRI*/,
                            const Triple &TT) {
  return new MCAsmInfoImpl(TT);
}
924};

926/// RegisterMCAsmInfoFn - Helper template for registering a target assembly info
927/// implementation.  This invokes the specified function to do the
928/// construction.  Usage:
929///
930/// extern "C" void LLVMInitializeFooTarget() {
931///   extern Target TheFooTarget;
932///   RegisterMCAsmInfoFn X(TheFooTarget, TheFunction);
933/// }
934struct RegisterMCAsmInfoFn {
RegisterMCAsmInfoFn(Target &T, Target::MCAsmInfoCtorFnTy Fn) {
  TargetRegistry::RegisterMCAsmInfo(T, Fn);
}
938};

940/// RegisterMCInstrInfo - Helper template for registering a target instruction
941/// info implementation.  This invokes the static "Create" method on the class
942/// to actually do the construction.  Usage:
943///
944/// extern "C" void LLVMInitializeFooTarget() {
945///   extern Target TheFooTarget;
946///   RegisterMCInstrInfo<FooMCInstrInfo> X(TheFooTarget);
947/// }
948template <class MCInstrInfoImpl> struct RegisterMCInstrInfo {
RegisterMCInstrInfo(Target &T) {
  TargetRegistry::RegisterMCInstrInfo(T, &Allocator);
}

953private:
static MCInstrInfo *Allocator() { return new MCInstrInfoImpl(); }
955};

957/// RegisterMCInstrInfoFn - Helper template for registering a target
958/// instruction info implementation.  This invokes the specified function to
959/// do the construction.  Usage:
960///
961/// extern "C" void LLVMInitializeFooTarget() {
962///   extern Target TheFooTarget;
963///   RegisterMCInstrInfoFn X(TheFooTarget, TheFunction);
964/// }
965struct RegisterMCInstrInfoFn {
RegisterMCInstrInfoFn(Target &T, Target::MCInstrInfoCtorFnTy Fn) {
  TargetRegistry::RegisterMCInstrInfo(T, Fn);
}
969};

971/// RegisterMCInstrAnalysis - Helper template for registering a target
972/// instruction analyzer implementation.  This invokes the static "Create"
973/// method on the class to actually do the construction.  Usage:
974///
975/// extern "C" void LLVMInitializeFooTarget() {
976///   extern Target TheFooTarget;
977///   RegisterMCInstrAnalysis<FooMCInstrAnalysis> X(TheFooTarget);
978/// }
979template <class MCInstrAnalysisImpl> struct RegisterMCInstrAnalysis {
RegisterMCInstrAnalysis(Target &T) {
  TargetRegistry::RegisterMCInstrAnalysis(T, &Allocator);
}

984private:
static MCInstrAnalysis *Allocator(const MCInstrInfo *Info) {
  return new MCInstrAnalysisImpl(Info);
}
988};

990/// RegisterMCInstrAnalysisFn - Helper template for registering a target
991/// instruction analyzer implementation.  This invokes the specified function
992/// to do the construction.  Usage:
993///
994/// extern "C" void LLVMInitializeFooTarget() {
995///   extern Target TheFooTarget;
996///   RegisterMCInstrAnalysisFn X(TheFooTarget, TheFunction);
997/// }
998struct RegisterMCInstrAnalysisFn {
RegisterMCInstrAnalysisFn(Target &T, Target::MCInstrAnalysisCtorFnTy Fn) {
  TargetRegistry::RegisterMCInstrAnalysis(T, Fn);
}
1002};

1004/// RegisterMCRegInfo - Helper template for registering a target register info
1005/// implementation.  This invokes the static "Create" method on the class to
1006/// actually do the construction.  Usage:
1007///
1008/// extern "C" void LLVMInitializeFooTarget() {
1009///   extern Target TheFooTarget;
1010///   RegisterMCRegInfo<FooMCRegInfo> X(TheFooTarget);
1011/// }
1012template <class MCRegisterInfoImpl> struct RegisterMCRegInfo {
RegisterMCRegInfo(Target &T) {
  TargetRegistry::RegisterMCRegInfo(T, &Allocator);
}

1017private:
static MCRegisterInfo *Allocator(const Triple & /*TT*/) {
  return new MCRegisterInfoImpl();
}
1021};

1023/// RegisterMCRegInfoFn - Helper template for registering a target register
1024/// info implementation.  This invokes the specified function to do the
1025/// construction.  Usage:
1026///
1027/// extern "C" void LLVMInitializeFooTarget() {
1028///   extern Target TheFooTarget;
1029///   RegisterMCRegInfoFn X(TheFooTarget, TheFunction);
1030/// }
1031struct RegisterMCRegInfoFn {
RegisterMCRegInfoFn(Target &T, Target::MCRegInfoCtorFnTy Fn) {
  TargetRegistry::RegisterMCRegInfo(T, Fn);
}
1035};

1037/// RegisterMCSubtargetInfo - Helper template for registering a target
1038/// subtarget info implementation.  This invokes the static "Create" method
1039/// on the class to actually do the construction.  Usage:
1040///
1041/// extern "C" void LLVMInitializeFooTarget() {
1042///   extern Target TheFooTarget;
1043///   RegisterMCSubtargetInfo<FooMCSubtargetInfo> X(TheFooTarget);
1044/// }
1045template <class MCSubtargetInfoImpl> struct RegisterMCSubtargetInfo {
RegisterMCSubtargetInfo(Target &T) {
  TargetRegistry::RegisterMCSubtargetInfo(T, &Allocator);
}

1050private:
static MCSubtargetInfo *Allocator(const Triple & /*TT*/, StringRef /*CPU*/,
                                  StringRef /*FS*/) {
  return new MCSubtargetInfoImpl();
}
1055};

1057/// RegisterMCSubtargetInfoFn - Helper template for registering a target
1058/// subtarget info implementation.  This invokes the specified function to
1059/// do the construction.  Usage:
1060///
1061/// extern "C" void LLVMInitializeFooTarget() {
1062///   extern Target TheFooTarget;
1063///   RegisterMCSubtargetInfoFn X(TheFooTarget, TheFunction);
1064/// }
1065struct RegisterMCSubtargetInfoFn {
RegisterMCSubtargetInfoFn(Target &T, Target::MCSubtargetInfoCtorFnTy Fn) {
  TargetRegistry::RegisterMCSubtargetInfo(T, Fn);
}
1069};

1071/// RegisterTargetMachine - Helper template for registering a target machine
1072/// implementation, for use in the target machine initialization
1073/// function. Usage:
1074///
1075/// extern "C" void LLVMInitializeFooTarget() {
1076///   extern Target TheFooTarget;
1077///   RegisterTargetMachine<FooTargetMachine> X(TheFooTarget);
1078/// }
1079template <class TargetMachineImpl> struct RegisterTargetMachine {
RegisterTargetMachine(Target &T) {
  TargetRegistry::RegisterTargetMachine(T, &Allocator);
}

1084private:
static TargetMachine *
Allocator(const Target &T, const Triple &TT, StringRef CPU, StringRef FS,
          const TargetOptions &Options, Optional<Reloc::Model> RM,
          Optional<CodeModel::Model> CM, CodeGenOpt::Level OL, bool JIT) {
  return new TargetMachineImpl(T, TT, CPU, FS, Options, RM, CM, OL, JIT);
}
1091};

1093/// RegisterMCAsmBackend - Helper template for registering a target specific
1094/// assembler backend. Usage:
1095///
1096/// extern "C" void LLVMInitializeFooMCAsmBackend() {
1097///   extern Target TheFooTarget;
1098///   RegisterMCAsmBackend<FooAsmLexer> X(TheFooTarget);
1099/// }
1100template <class MCAsmBackendImpl> struct RegisterMCAsmBackend {
RegisterMCAsmBackend(Target &T) {
  TargetRegistry::RegisterMCAsmBackend(T, &Allocator);
}

1105private:
static MCAsmBackend *Allocator(const Target &T, const MCSubtargetInfo &STI,
                               const MCRegisterInfo &MRI,
                               const MCTargetOptions &Options) {
  return new MCAsmBackendImpl(T, STI, MRI);
}
1111};

1113/// RegisterMCAsmParser - Helper template for registering a target specific
1114/// assembly parser, for use in the target machine initialization
1115/// function. Usage:
1116///
1117/// extern "C" void LLVMInitializeFooMCAsmParser() {
1118///   extern Target TheFooTarget;
1119///   RegisterMCAsmParser<FooAsmParser> X(TheFooTarget);
1120/// }
1121template <class MCAsmParserImpl> struct RegisterMCAsmParser {
RegisterMCAsmParser(Target &T) {
  TargetRegistry::RegisterMCAsmParser(T, &Allocator);
}

1126private:
static MCTargetAsmParser *Allocator(const MCSubtargetInfo &STI,
                                    MCAsmParser &P, const MCInstrInfo &MII,
                                    const MCTargetOptions &Options) {
  return new MCAsmParserImpl(STI, P, MII, Options);
}
1132};

1134/// RegisterAsmPrinter - Helper template for registering a target specific
1135/// assembly printer, for use in the target machine initialization
1136/// function. Usage:
1137///
1138/// extern "C" void LLVMInitializeFooAsmPrinter() {
1139///   extern Target TheFooTarget;
1140///   RegisterAsmPrinter<FooAsmPrinter> X(TheFooTarget);
1141/// }
1142template <class AsmPrinterImpl> struct RegisterAsmPrinter {
RegisterAsmPrinter(Target &T) {
  TargetRegistry::RegisterAsmPrinter(T, &Allocator);
}

1147private:
static AsmPrinter *Allocator(TargetMachine &TM,
                             std::unique_ptr<MCStreamer> &&Streamer) {
  return new AsmPrinterImpl(TM, std::move(Streamer));
}
1152};

1154/// RegisterMCCodeEmitter - Helper template for registering a target specific
1155/// machine code emitter, for use in the target initialization
1156/// function. Usage:
1157///
1158/// extern "C" void LLVMInitializeFooMCCodeEmitter() {
1159///   extern Target TheFooTarget;
1160///   RegisterMCCodeEmitter<FooCodeEmitter> X(TheFooTarget);
1161/// }
1162template <class MCCodeEmitterImpl> struct RegisterMCCodeEmitter {
RegisterMCCodeEmitter(Target &T) {
  TargetRegistry::RegisterMCCodeEmitter(T, &Allocator);
}

1167private:
static MCCodeEmitter *Allocator(const MCInstrInfo & /*II*/,
                                const MCRegisterInfo & /*MRI*/,
                                MCContext & /*Ctx*/) {
  return new MCCodeEmitterImpl();
}
1173};

1175} // end namespace llvm

1177#endif // LLVM_SUPPORT_TARGETREGISTRY_H

←

/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;
38
←
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)
36
←
Taking true branch→
 get_deleter()(__ptr);
37
←
Calling 'default_delete::operator()'→
39
←
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 */