/build/llvm-toolchain-snapshot-7~svn329677/lib/CodeGen/LLVMTargetMachine.cpp

Bug Summary

File:	lib/CodeGen/LLVMTargetMachine.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 LLVMTargetMachine.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 -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/lib/CodeGen -I /build/llvm-toolchain-snapshot-7~svn329677/lib/CodeGen -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/lib/CodeGen -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -fobjc-runtime=gcc -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/lib/CodeGen/LLVMTargetMachine.cpp

/build/llvm-toolchain-snapshot-7~svn329677/lib/CodeGen/LLVMTargetMachine.cpp

→

1//===-- LLVMTargetMachine.cpp - Implement the LLVMTargetMachine class -----===//
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 implements the LLVMTargetMachine class.
11//
12//===----------------------------------------------------------------------===//
13 
14#include "llvm/Analysis/Passes.h"
15#include "llvm/CodeGen/AsmPrinter.h"
16#include "llvm/CodeGen/BasicTTIImpl.h"
17#include "llvm/CodeGen/MachineModuleInfo.h"
18#include "llvm/CodeGen/Passes.h"
19#include "llvm/CodeGen/TargetPassConfig.h"
20#include "llvm/IR/LegacyPassManager.h"
21#include "llvm/MC/MCAsmBackend.h"
22#include "llvm/MC/MCAsmInfo.h"
23#include "llvm/MC/MCCodeEmitter.h"
24#include "llvm/MC/MCContext.h"
25#include "llvm/MC/MCInstrInfo.h"
26#include "llvm/MC/MCStreamer.h"
27#include "llvm/MC/MCSubtargetInfo.h"
28#include "llvm/Support/CommandLine.h"
29#include "llvm/Support/ErrorHandling.h"
30#include "llvm/Support/FormattedStream.h"
31#include "llvm/Support/TargetRegistry.h"
32#include "llvm/Target/TargetLoweringObjectFile.h"
33#include "llvm/Target/TargetMachine.h"
34#include "llvm/Target/TargetOptions.h"
35using namespace llvm;
36 
37static cl::opt<bool> EnableTrapUnreachable("trap-unreachable",
38  cl::Hidden, cl::ZeroOrMore, cl::init(false),
39  cl::desc("Enable generating trap for unreachable"));
40 
41void LLVMTargetMachine::initAsmInfo() {
42  MRI = TheTarget.createMCRegInfo(getTargetTriple().str());
43  MII = TheTarget.createMCInstrInfo();
44  // FIXME: Having an MCSubtargetInfo on the target machine is a hack due
45  // to some backends having subtarget feature dependent module level
46  // code generation. This is similar to the hack in the AsmPrinter for
47  // module level assembly etc.
48  STI = TheTarget.createMCSubtargetInfo(getTargetTriple().str(), getTargetCPU(),
49                                        getTargetFeatureString());
50 
51  MCAsmInfo *TmpAsmInfo =
52      TheTarget.createMCAsmInfo(*MRI, getTargetTriple().str());
53  // TargetSelect.h moved to a different directory between LLVM 2.9 and 3.0,
54  // and if the old one gets included then MCAsmInfo will be NULL and
55  // we'll crash later.
56  // Provide the user with a useful error message about what's wrong.
57  assert(TmpAsmInfo && "MCAsmInfo not initialized. "(static_cast <bool> (TmpAsmInfo && "MCAsmInfo not initialized. "
 "Make sure you include the correct TargetSelect.h" "and that InitializeAllTargetMCs() is being invoked!"
) ? void (0) : __assert_fail ("TmpAsmInfo && \"MCAsmInfo not initialized. \" \"Make sure you include the correct TargetSelect.h\" \"and that InitializeAllTargetMCs() is being invoked!\""
, "/build/llvm-toolchain-snapshot-7~svn329677/lib/CodeGen/LLVMTargetMachine.cpp"
, 59, __extension__ __PRETTY_FUNCTION__))
58         "Make sure you include the correct TargetSelect.h"(static_cast <bool> (TmpAsmInfo && "MCAsmInfo not initialized. "
 "Make sure you include the correct TargetSelect.h" "and that InitializeAllTargetMCs() is being invoked!"
) ? void (0) : __assert_fail ("TmpAsmInfo && \"MCAsmInfo not initialized. \" \"Make sure you include the correct TargetSelect.h\" \"and that InitializeAllTargetMCs() is being invoked!\""
, "/build/llvm-toolchain-snapshot-7~svn329677/lib/CodeGen/LLVMTargetMachine.cpp"
, 59, __extension__ __PRETTY_FUNCTION__))
59         "and that InitializeAllTargetMCs() is being invoked!")(static_cast <bool> (TmpAsmInfo && "MCAsmInfo not initialized. "
 "Make sure you include the correct TargetSelect.h" "and that InitializeAllTargetMCs() is being invoked!"
) ? void (0) : __assert_fail ("TmpAsmInfo && \"MCAsmInfo not initialized. \" \"Make sure you include the correct TargetSelect.h\" \"and that InitializeAllTargetMCs() is being invoked!\""
, "/build/llvm-toolchain-snapshot-7~svn329677/lib/CodeGen/LLVMTargetMachine.cpp"
, 59, __extension__ __PRETTY_FUNCTION__));
60 
61  if (Options.DisableIntegratedAS)
62    TmpAsmInfo->setUseIntegratedAssembler(false);
63 
64  TmpAsmInfo->setPreserveAsmComments(Options.MCOptions.PreserveAsmComments);
65 
66  TmpAsmInfo->setCompressDebugSections(Options.CompressDebugSections);
67 
68  TmpAsmInfo->setRelaxELFRelocations(Options.RelaxELFRelocations);
69 
70  if (Options.ExceptionModel != ExceptionHandling::None)
71    TmpAsmInfo->setExceptionsType(Options.ExceptionModel);
72 
73  AsmInfo = TmpAsmInfo;
74}
75 
76LLVMTargetMachine::LLVMTargetMachine(const Target &T,
77                                     StringRef DataLayoutString,
78                                     const Triple &TT, StringRef CPU,
79                                     StringRef FS, const TargetOptions &Options,
80                                     Reloc::Model RM, CodeModel::Model CM,
81                                     CodeGenOpt::Level OL)
82    : TargetMachine(T, DataLayoutString, TT, CPU, FS, Options) {
83  this->RM = RM;
84  this->CMModel = CM;
85  this->OptLevel = OL;
86 
87  if (EnableTrapUnreachable)
88    this->Options.TrapUnreachable = true;
89}
90 
91TargetTransformInfo
92LLVMTargetMachine::getTargetTransformInfo(const Function &F) {
93  return TargetTransformInfo(BasicTTIImpl(this, F));
94}
95 
96/// addPassesToX helper drives creation and initialization of TargetPassConfig.
97static MCContext *
98addPassesToGenerateCode(LLVMTargetMachine *TM, PassManagerBase &PM,
99                        bool DisableVerify, bool &WillCompleteCodeGenPipeline,
100                        raw_pwrite_stream &Out, MachineModuleInfo *MMI) {
101  // Targets may override createPassConfig to provide a target-specific
102  // subclass.
103  TargetPassConfig *PassConfig = TM->createPassConfig(PM);
104  // Set PassConfig options provided by TargetMachine.
105  PassConfig->setDisableVerify(DisableVerify);
106  WillCompleteCodeGenPipeline = PassConfig->willCompleteCodeGenPipeline();
107  PM.add(PassConfig);
108  if (!MMI)
109    MMI = new MachineModuleInfo(TM);
110  PM.add(MMI);
111 
112  if (PassConfig->addISelPasses())
113    return nullptr;
114  PassConfig->addMachinePasses();
115  PassConfig->setInitialized();
116  if (!WillCompleteCodeGenPipeline)
117    PM.add(createPrintMIRPass(Out));
118 
119  return &MMI->getContext();
120}
121 
122bool LLVMTargetMachine::addAsmPrinter(PassManagerBase &PM,
123    raw_pwrite_stream &Out, CodeGenFileType FileType,
124    MCContext &Context) {
125  if (Options.MCOptions.MCSaveTempLabels)
3
←
Assuming the condition is false→
4
←
Taking false branch→
126    Context.setAllowTemporaryLabels(false);
127 
128  const MCSubtargetInfo &STI = *getMCSubtargetInfo();
129  const MCAsmInfo &MAI = *getMCAsmInfo();
130  const MCRegisterInfo &MRI = *getMCRegisterInfo();
131  const MCInstrInfo &MII = *getMCInstrInfo();
132 
133  std::unique_ptr<MCStreamer> AsmStreamer;
134 
135  switch (FileType) {
5
←
Control jumps to 'case CGFT_AssemblyFile:'  at line 136→
136  case CGFT_AssemblyFile: {
137    MCInstPrinter *InstPrinter = getTarget().createMCInstPrinter(
138        getTargetTriple(), MAI.getAssemblerDialect(), MAI, MII, MRI);
139 
140    // Create a code emitter if asked to show the encoding.
141    MCCodeEmitter *MCE = nullptr;
142    if (Options.MCOptions.ShowMCEncoding)
6
←
Assuming the condition is false→
7
←
Taking false branch→
143      MCE = getTarget().createMCCodeEmitter(MII, MRI, Context);
144 
145    MCAsmBackend *MAB =
146        getTarget().createMCAsmBackend(STI, MRI, Options.MCOptions);
147    auto FOut = llvm::make_unique<formatted_raw_ostream>(Out);
148    MCStreamer *S = getTarget().createAsmStreamer(
8
←
Calling 'Target::createAsmStreamer'→
149        Context, std::move(FOut), Options.MCOptions.AsmVerbose,
150        Options.MCOptions.MCUseDwarfDirectory, InstPrinter, MCE, MAB,
151        Options.MCOptions.ShowMCInst);
152    AsmStreamer.reset(S);
153    break;
154  }
155  case CGFT_ObjectFile: {
156    // Create the code emitter for the target if it exists.  If not, .o file
157    // emission fails.
158    MCCodeEmitter *MCE = getTarget().createMCCodeEmitter(MII, MRI, Context);
159    MCAsmBackend *MAB =
160        getTarget().createMCAsmBackend(STI, MRI, Options.MCOptions);
161    if (!MCE || !MAB)
162      return true;
163 
164    // Don't waste memory on names of temp labels.
165    Context.setUseNamesOnTempLabels(false);
166 
167    Triple T(getTargetTriple().str());
168    AsmStreamer.reset(getTarget().createMCObjectStreamer(
169        T, Context, std::unique_ptr<MCAsmBackend>(MAB), Out,
170        std::unique_ptr<MCCodeEmitter>(MCE), STI, Options.MCOptions.MCRelaxAll,
171        Options.MCOptions.MCIncrementalLinkerCompatible,
172        /*DWARFMustBeAtTheEnd*/ true));
173    break;
174  }
175  case CGFT_Null:
176    // The Null output is intended for use for performance analysis and testing,
177    // not real users.
178    AsmStreamer.reset(getTarget().createNullStreamer(Context));
179    break;
180  }
181 
182  // Create the AsmPrinter, which takes ownership of AsmStreamer if successful.
183  FunctionPass *Printer =
184      getTarget().createAsmPrinter(*this, std::move(AsmStreamer));
185  if (!Printer)
186    return true;
187 
188  PM.add(Printer);
189  return false;
190}
191 
192bool LLVMTargetMachine::addPassesToEmitFile(PassManagerBase &PM,
193                                            raw_pwrite_stream &Out,
194                                            CodeGenFileType FileType,
195                                            bool DisableVerify,
196                                            MachineModuleInfo *MMI) {
197  // Add common CodeGen passes.
198  bool WillCompleteCodeGenPipeline = true;
199  MCContext *Context = addPassesToGenerateCode(
200      this, PM, DisableVerify, WillCompleteCodeGenPipeline, Out, MMI);
201  if (!Context)
1
Taking false branch→
202    return true;
203 
204  if (WillCompleteCodeGenPipeline && addAsmPrinter(PM, Out, FileType, *Context))
2
←
Calling 'LLVMTargetMachine::addAsmPrinter'→
205    return true;
206 
207  PM.add(createFreeMachineFunctionPass());
208  return false;
209}
210 
211/// addPassesToEmitMC - Add passes to the specified pass manager to get
212/// machine code emitted with the MCJIT. This method returns true if machine
213/// code is not supported. It fills the MCContext Ctx pointer which can be
214/// used to build custom MCStreamer.
215///
216bool LLVMTargetMachine::addPassesToEmitMC(PassManagerBase &PM, MCContext *&Ctx,
217                                          raw_pwrite_stream &Out,
218                                          bool DisableVerify) {
219  // Add common CodeGen passes.
220  bool WillCompleteCodeGenPipeline = true;
221  Ctx = addPassesToGenerateCode(this, PM, DisableVerify,
222                                WillCompleteCodeGenPipeline, Out,
223                                /*MachineModuleInfo*/ nullptr);
224  if (!Ctx)
225    return true;
226  assert(WillCompleteCodeGenPipeline && "CodeGen pipeline has been altered")(static_cast <bool> (WillCompleteCodeGenPipeline &&
 "CodeGen pipeline has been altered") ? void (0) : __assert_fail
 ("WillCompleteCodeGenPipeline && \"CodeGen pipeline has been altered\""
, "/build/llvm-toolchain-snapshot-7~svn329677/lib/CodeGen/LLVMTargetMachine.cpp"
, 226, __extension__ __PRETTY_FUNCTION__));
227 
228  if (Options.MCOptions.MCSaveTempLabels)
229    Ctx->setAllowTemporaryLabels(false);
230 
231  // Create the code emitter for the target if it exists.  If not, .o file
232  // emission fails.
233  const MCSubtargetInfo &STI = *getMCSubtargetInfo();
234  const MCRegisterInfo &MRI = *getMCRegisterInfo();
235  MCCodeEmitter *MCE =
236      getTarget().createMCCodeEmitter(*getMCInstrInfo(), MRI, *Ctx);
237  MCAsmBackend *MAB =
238      getTarget().createMCAsmBackend(STI, MRI, Options.MCOptions);
239  if (!MCE || !MAB)
240    return true;
241 
242  const Triple &T = getTargetTriple();
243  std::unique_ptr<MCStreamer> AsmStreamer(getTarget().createMCObjectStreamer(
244      T, *Ctx, std::unique_ptr<MCAsmBackend>(MAB), Out,
245      std::unique_ptr<MCCodeEmitter>(MCE), STI, Options.MCOptions.MCRelaxAll,
246      Options.MCOptions.MCIncrementalLinkerCompatible,
247      /*DWARFMustBeAtTheEnd*/ true));
248 
249  // Create the AsmPrinter, which takes ownership of AsmStreamer if successful.
250  FunctionPass *Printer =
251      getTarget().createAsmPrinter(*this, std::move(AsmStreamer));
252  if (!Printer)
253    return true;
254 
255  PM.add(Printer);
256  PM.add(createFreeMachineFunctionPass());
257 
258  return false; // success!
259}

←

/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,
9
←
Calling '~unique_ptr'→
14
←
Returning from '~unique_ptr'→
                                          UseDwarfDirectory, InstPrint, CE,
                                          TAB, ShowInst);
  createAsmTargetStreamer(*S, OSRef, InstPrint, IsVerboseAsm);
15
←
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;
12
←
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)
10
←
Taking true branch→
 get_deleter()(__ptr);
11
←
Calling 'default_delete::operator()'→
13
←
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 */