reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced

References

examples/Kaleidoscope/BuildingAJIT/Chapter1/toy.cpp

  584     LHS =

examples/Kaleidoscope/BuildingAJIT/Chapter2/toy.cpp

  584     LHS =

examples/Kaleidoscope/BuildingAJIT/Chapter3/toy.cpp

  584     LHS =

examples/Kaleidoscope/BuildingAJIT/Chapter4/toy.cpp

  569     LHS =

examples/Kaleidoscope/BuildingAJIT/Chapter5/KaleidoscopeJIT.h

  136     IndirectStubsMgr = cantFail(Remote.createIndirectStubsManager());

examples/Kaleidoscope/BuildingAJIT/Chapter5/toy.cpp

  586     LHS =

examples/Kaleidoscope/Chapter2/toy.cpp

  303     LHS = std::make_unique<BinaryExprAST>(BinOp, std::move(LHS),

examples/Kaleidoscope/Chapter3/toy.cpp

  329     LHS =

examples/Kaleidoscope/Chapter4/toy.cpp

  339     LHS =

examples/Kaleidoscope/Chapter5/toy.cpp

  466     LHS =

examples/Kaleidoscope/Chapter6/toy.cpp

  516     LHS =

examples/Kaleidoscope/Chapter7/toy.cpp

  589     LHS =

examples/Kaleidoscope/Chapter8/toy.cpp

  590     LHS =

examples/Kaleidoscope/Chapter9/toy.cpp

  702     LHS = std::make_unique<BinaryExprAST>(BinLoc, BinOp, std::move(LHS),

include/llvm/ADT/Any.h

   81     Storage = std::make_unique<StorageImpl<U>>(std::forward<T>(Value));

include/llvm/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.h

  400     LinkedObjects[K] = createLinkedObject(

lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp

 1080     Entity = std::make_unique<DbgVariable>(
 1084     Entity = std::make_unique<DbgLabel>(

lib/CodeGen/GlobalISel/CSEInfo.cpp

   69     Config = std::make_unique<CSEConfigConstantOnly>();
   71     Config = std::make_unique<CSEConfigFull>();

lib/CodeGen/GlobalISel/IRTranslator.cpp

 2228     EntryBuilder = std::make_unique<CSEMIRBuilder>(CurMF);
 2231     CurBuilder = std::make_unique<CSEMIRBuilder>(CurMF);

lib/CodeGen/GlobalISel/Legalizer.cpp

  187     MIRBuilder = std::make_unique<CSEMIRBuilder>();

lib/CodeGen/GlobalISel/RegisterBankInfo.cpp

  286   PartMapping = std::make_unique<PartialMapping>(StartIdx, Length, RegBank);
  320   ValMapping = std::make_unique<ValueMapping>(BreakDown, NumBreakDowns);
  394   InstrMapping = std::make_unique<InstructionMapping>(

lib/CodeGen/PseudoSourceValue.cpp

  141     E = std::make_unique<GlobalValuePseudoSourceValue>(GV, TII);
  150     E = std::make_unique<ExternalSymbolPseudoSourceValue>(ES, TII);

lib/DebugInfo/DWARF/DWARFUnit.cpp

   86         U = std::make_unique<DWARFTypeUnit>(Context, InfoSection, Header, DA,
   90         U = std::make_unique<DWARFCompileUnit>(Context, InfoSection, Header,

lib/DebugInfo/PDB/Native/NativeSession.cpp

   72   Session =

lib/DebugInfo/PDB/Native/TpiStream.cpp

  112     HashStream = std::move(*HS);

lib/DebugInfo/Symbolize/Symbolize.cpp

  416     SymMod = std::move(*InfoOrErr);
  470     Context =

lib/ExecutionEngine/Orc/OrcCBindingsStack.h

  310     KeyLayers[K] = detail::createGenericLayer(Layer);
  370       KeyLayers[K] = detail::createGenericLayer(ObjectLayer);

lib/ExecutionEngine/RuntimeDyld/RuntimeDyld.cpp

 1311       Dyld =
 1316       Dyld = createRuntimeDyldMachO(
 1320       Dyld = createRuntimeDyldCOFF(

lib/LTO/LTOBackend.cpp

   61   ResolutionFile = std::make_unique<raw_fd_ostream>(

lib/MCA/InstrBuilder.cpp

  590     Descriptors[MCI.getOpcode()] = std::move(ID);
  594   VariantDescriptors[&MCI] = std::move(ID);

lib/ObjectYAML/ELFYAML.cpp

 1195         Section = std::make_unique<ELFYAML::StackSizesSection>();
 1197         Section = std::make_unique<ELFYAML::RawContentSection>();

lib/ProfileData/Coverage/CoverageMappingReader.cpp

  688     OF = std::move(ObjectFileOrErr.get());

lib/ProfileData/InstrProfReader.cpp

  841     Remapper = std::make_unique<
  847     Remapper = std::make_unique<InstrProfReaderNullRemapper>(*IndexPtr);
  849   Index = std::move(IndexPtr);

lib/ProfileData/SampleProfWriter.cpp

  136   LocalBufStream = std::make_unique<raw_string_ostream>(LocalBuf);

lib/Support/VirtualFileSystem.cpp

 1450       Result = std::make_unique<RedirectingFileSystem::RedirectingFileEntry>(
 1454       Result =
 1473       Result =

lib/Target/AArch64/AsmParser/AArch64AsmParser.cpp

 3693           Operands[0] = AArch64Operand::CreateToken("movz", false, Loc, Ctx);
 4522         Operands[0] = AArch64Operand::CreateToken(
 4526         Operands[3] = AArch64Operand::CreateImm(NewOp3, Op3.getStartLoc(),
 4572         Operands[0] = AArch64Operand::CreateToken(
 4574         Operands[2] = AArch64Operand::CreateReg(
 4577         Operands[3] = AArch64Operand::CreateImm(
 4630           Operands[3] = AArch64Operand::CreateImm(
 4632           Operands[4] = AArch64Operand::CreateImm(
 4635             Operands[0] = AArch64Operand::CreateToken(
 4638             Operands[0] = AArch64Operand::CreateToken(
 4641             Operands[0] = AArch64Operand::CreateToken(
 4686           Operands[4] = AArch64Operand::CreateImm(
 4689             Operands[0] = AArch64Operand::CreateToken(
 4692             Operands[0] = AArch64Operand::CreateToken(
 4695             Operands[0] = AArch64Operand::CreateToken(
 4722         Operands[Idx] = AArch64Operand::CreateToken(".16b", false, IDLoc,
 4737       Operands[2] = AArch64Operand::CreateReg(Reg, RegKind::Scalar,
 4753         Operands[2] = AArch64Operand::CreateReg(Reg, RegKind::Scalar,
 4770         Operands[1] = AArch64Operand::CreateReg(Reg, RegKind::Scalar,

lib/Target/AMDGPU/AMDGPULibFunc.cpp

  685     F.Impl = std::make_unique<AMDGPUMangledLibFunc>();
  687     F.Impl = std::make_unique<AMDGPUUnmangledLibFunc>();

lib/Target/AMDGPU/SIMachineFunctionInfo.h

  894       GWSResourcePSV =

lib/Target/ARM/AsmParser/ARMAsmParser.cpp

 7119         Operands[Idx] =
 7139     Operands.front() = ARMOperand::CreateToken(Name, NameLoc);

lib/Target/AVR/AVRTargetMachine.cpp

   53   this->TLOF = std::make_unique<AVRTargetObjectFile>();

lib/Target/WebAssembly/WebAssemblyCFGSort.cpp

  100       LoopMap[ML] = std::make_unique<ConcreteRegion<MachineLoop>>(ML);
  106       ExceptionMap[WE] =

lib/Target/X86/AsmParser/X86AsmParser.cpp

 2706         Operands[0] = X86Operand::CreateToken(Name, NameLoc);
 2711       Operands[1] = X86Operand::CreateReg(Reg, Loc, Loc);
 2723       Operands.back() = X86Operand::CreateReg(X86::DX, Op.getStartLoc(),
 2732       Operands[1] = X86Operand::CreateReg(X86::DX, Op.getStartLoc(),
 2813       Operands.back() = X86Operand::CreateToken("movsl", NameLoc);
 3078     Operands[0] = X86Operand::CreateToken(Repl, IDLoc);

lib/XRay/FDRRecordProducer.cpp

  170     R = std::make_unique<FunctionRecord>();

tools/clang/include/clang/Lex/Preprocessor.h

  998       C = std::make_unique<PPChainedCallbacks>(std::move(C),

tools/clang/include/clang/Serialization/ASTReader.h

 1589       L = std::make_unique<ChainedASTReaderListener>(std::move(L),
 1605         L = std::make_unique<ChainedASTReaderListener>(std::move(L),

tools/clang/lib/AST/VTableBuilder.cpp

 2286   Entry = CreateVTableLayout(Builder);
 3579     VFTableLayouts[id] = std::make_unique<VTableLayout>(

tools/clang/lib/ASTMatchers/Dynamic/Registry.cpp

   65   Constructors[MatcherName] = std::move(Callback);

tools/clang/lib/Driver/Driver.cpp

  632       CudaTC = std::make_unique<toolchains::CudaToolChain>(
  647       HIPTC = std::make_unique<toolchains::HIPToolChain>(
  705                 CudaTC = std::make_unique<toolchains::CudaToolChain>(
 4704       TC = std::make_unique<toolchains::AIX>(*this, Target, Args);
 4707       TC = std::make_unique<toolchains::Haiku>(*this, Target, Args);
 4710       TC = std::make_unique<toolchains::Ananas>(*this, Target, Args);
 4713       TC = std::make_unique<toolchains::CloudABI>(*this, Target, Args);
 4720       TC = std::make_unique<toolchains::DarwinClang>(*this, Target, Args);
 4723       TC = std::make_unique<toolchains::DragonFly>(*this, Target, Args);
 4726       TC = std::make_unique<toolchains::OpenBSD>(*this, Target, Args);
 4729       TC = std::make_unique<toolchains::NetBSD>(*this, Target, Args);
 4732       TC = std::make_unique<toolchains::FreeBSD>(*this, Target, Args);
 4735       TC = std::make_unique<toolchains::Minix>(*this, Target, Args);
 4740         TC = std::make_unique<toolchains::HexagonToolChain>(*this, Target,
 4744         TC = std::make_unique<toolchains::MipsLLVMToolChain>(*this, Target,
 4749         TC = std::make_unique<toolchains::PPCLinuxToolChain>(*this, Target,
 4752         TC = std::make_unique<toolchains::Linux>(*this, Target, Args);
 4755       TC = std::make_unique<toolchains::NaClToolChain>(*this, Target, Args);
 4758       TC = std::make_unique<toolchains::Fuchsia>(*this, Target, Args);
 4761       TC = std::make_unique<toolchains::Solaris>(*this, Target, Args);
 4766       TC = std::make_unique<toolchains::AMDGPUToolChain>(*this, Target, Args);
 4772           TC = std::make_unique<toolchains::Generic_ELF>(*this, Target, Args);
 4774           TC = std::make_unique<toolchains::MachO>(*this, Target, Args);
 4776           TC = std::make_unique<toolchains::Generic_GCC>(*this, Target, Args);
 4779         TC = std::make_unique<toolchains::MinGW>(*this, Target, Args);
 4782         TC = std::make_unique<toolchains::CrossWindowsToolChain>(*this, Target,
 4789           TC = std::make_unique<toolchains::CrossWindowsToolChain>(
 4792           TC =
 4798       TC = std::make_unique<toolchains::PS4CPU>(*this, Target, Args);
 4801       TC = std::make_unique<toolchains::Contiki>(*this, Target, Args);
 4804       TC = std::make_unique<toolchains::Hurd>(*this, Target, Args);
 4811         TC = std::make_unique<toolchains::TCEToolChain>(*this, Target, Args);
 4814         TC = std::make_unique<toolchains::TCELEToolChain>(*this, Target, Args);
 4817         TC = std::make_unique<toolchains::HexagonToolChain>(*this, Target,
 4821         TC = std::make_unique<toolchains::LanaiToolChain>(*this, Target, Args);
 4824         TC = std::make_unique<toolchains::XCoreToolChain>(*this, Target, Args);
 4828         TC = std::make_unique<toolchains::WebAssembly>(*this, Target, Args);
 4831         TC = std::make_unique<toolchains::AVRToolChain>(*this, Target, Args);
 4834         TC =
 4839         TC = std::make_unique<toolchains::RISCVToolChain>(*this, Target, Args);
 4843           TC = std::make_unique<toolchains::MyriadToolChain>(*this, Target,
 4846           TC = std::make_unique<toolchains::BareMetal>(*this, Target, Args);
 4848           TC = std::make_unique<toolchains::Generic_ELF>(*this, Target, Args);
 4850           TC = std::make_unique<toolchains::MachO>(*this, Target, Args);
 4852           TC = std::make_unique<toolchains::Generic_GCC>(*this, Target, Args);

tools/clang/lib/Frontend/CompilerInstance.cpp

  235       StreamOwner = std::move(FileOS);

tools/clang/lib/Frontend/PrecompiledPreamble.cpp

  205     OS = std::make_unique<llvm::raw_string_ostream>(*InMemStorage);
  208     OS = GeneratePCHAction::CreateOutputFile(CI, InFile, OutputFile);

tools/clang/lib/FrontendTool/ExecuteCompilerInvocation.cpp

  144     Act = std::make_unique<FixItRecompile>(std::move(Act));
  155       Act = std::make_unique<arcmt::CheckAction>(std::move(Act));
  158       Act = std::make_unique<arcmt::ModifyAction>(std::move(Act));
  161       Act = std::make_unique<arcmt::MigrateAction>(std::move(Act),
  169       Act = std::make_unique<arcmt::ObjCMigrateAction>(std::move(Act),
  179     Act = std::make_unique<ASTMergeAction>(std::move(Act),

tools/clang/lib/Parse/ParsePragma.cpp

  268   AlignHandler = std::make_unique<PragmaAlignHandler>();
  271   GCCVisibilityHandler = std::make_unique<PragmaGCCVisibilityHandler>();
  274   OptionsHandler = std::make_unique<PragmaOptionsHandler>();
  277   PackHandler = std::make_unique<PragmaPackHandler>();
  280   MSStructHandler = std::make_unique<PragmaMSStructHandler>();
  283   UnusedHandler = std::make_unique<PragmaUnusedHandler>();
  286   WeakHandler = std::make_unique<PragmaWeakHandler>();
  289   RedefineExtnameHandler = std::make_unique<PragmaRedefineExtnameHandler>();
  292   FPContractHandler = std::make_unique<PragmaFPContractHandler>();
  295   STDCFENVHandler = std::make_unique<PragmaSTDC_FENV_ACCESSHandler>();
  298   STDCCXLIMITHandler = std::make_unique<PragmaSTDC_CX_LIMITED_RANGEHandler>();
  301   STDCUnknownHandler = std::make_unique<PragmaSTDC_UnknownHandler>();
  304   PCSectionHandler = std::make_unique<PragmaClangSectionHandler>(Actions);
  308     OpenCLExtensionHandler = std::make_unique<PragmaOpenCLExtensionHandler>();
  314     OpenMPHandler = std::make_unique<PragmaOpenMPHandler>();
  316     OpenMPHandler = std::make_unique<PragmaNoOpenMPHandler>();
  321     MSCommentHandler = std::make_unique<PragmaCommentHandler>(Actions);
  326     MSDetectMismatchHandler =
  329     MSPointersToMembers = std::make_unique<PragmaMSPointersToMembers>();
  331     MSVtorDisp = std::make_unique<PragmaMSVtorDisp>();
  333     MSInitSeg = std::make_unique<PragmaMSPragma>("init_seg");
  335     MSDataSeg = std::make_unique<PragmaMSPragma>("data_seg");
  337     MSBSSSeg = std::make_unique<PragmaMSPragma>("bss_seg");
  339     MSConstSeg = std::make_unique<PragmaMSPragma>("const_seg");
  341     MSCodeSeg = std::make_unique<PragmaMSPragma>("code_seg");
  343     MSSection = std::make_unique<PragmaMSPragma>("section");
  345     MSRuntimeChecks = std::make_unique<PragmaMSRuntimeChecksHandler>();
  347     MSIntrinsic = std::make_unique<PragmaMSIntrinsicHandler>();
  349     MSOptimize = std::make_unique<PragmaMSOptimizeHandler>();
  354     CUDAForceHostDeviceHandler =
  359   OptimizeHandler = std::make_unique<PragmaOptimizeHandler>(Actions);
  362   LoopHintHandler = std::make_unique<PragmaLoopHintHandler>();
  365   UnrollHintHandler = std::make_unique<PragmaUnrollHintHandler>("unroll");
  368   NoUnrollHintHandler = std::make_unique<PragmaUnrollHintHandler>("nounroll");
  371   UnrollAndJamHintHandler =
  375   NoUnrollAndJamHintHandler =
  379   FPHandler = std::make_unique<PragmaFPHandler>();
  382   AttributePragmaHandler =

tools/clang/lib/StaticAnalyzer/Checkers/MallocChecker.cpp

 3303       StackHint = std::make_unique<StackHintGeneratorForReallocationFailed>(

tools/clang/lib/StaticAnalyzer/Checkers/NonNullParamChecker.cpp

  148           R = genReportNullAttrNonNull(errorNode, ArgE, idx + 1);
  150           R = genReportReferenceToNullPointer(errorNode, ArgE);

tools/clang/lib/Tooling/CommonOptionsParser.cpp

  110   Compilations =
  153   Compilations = std::move(AdjustingCompilations);

tools/clang/tools/clang-diff/ClangDiff.cpp

   83   Compilations = std::move(AdjustingCompilations);
   99       Compilations =

tools/clang/tools/extra/clangd/ClangdLSPServer.cpp

  482     BaseCDB = std::make_unique<DirectoryBasedGlobalCompilationDatabase>(

tools/clang/tools/extra/clangd/tool/ClangdMain.cpp

  644     ClangTidyOptProvider = std::make_unique<tidy::FileOptionsProvider>(

tools/clang/utils/TableGen/ClangAttrEmitter.cpp

 1261     Ptr = std::make_unique<AlignedArgument>(Arg, Attr);
 1263     Ptr = std::make_unique<EnumArgument>(Arg, Attr);
 1265     Ptr = std::make_unique<ExprArgument>(Arg, Attr);
 1267     Ptr = std::make_unique<SimpleArgument>(Arg, Attr, "FunctionDecl *");
 1269     Ptr = std::make_unique<SimpleArgument>(Arg, Attr, "NamedDecl *");
 1271     Ptr = std::make_unique<SimpleArgument>(Arg, Attr, "IdentifierInfo *");
 1273     Ptr = std::make_unique<DefaultSimpleArgument>(
 1276     Ptr = std::make_unique<SimpleArgument>(Arg, Attr, "bool");
 1278     Ptr = std::make_unique<DefaultSimpleArgument>(
 1281     Ptr = std::make_unique<SimpleArgument>(Arg, Attr, "int");
 1283     Ptr = std::make_unique<StringArgument>(Arg, Attr);
 1285     Ptr = std::make_unique<TypeArgument>(Arg, Attr);
 1287     Ptr = std::make_unique<SimpleArgument>(Arg, Attr, "unsigned");
 1289     Ptr = std::make_unique<VariadicArgument>(Arg, Attr, "unsigned");
 1291     Ptr = std::make_unique<VariadicStringArgument>(Arg, Attr);
 1293     Ptr = std::make_unique<VariadicEnumArgument>(Arg, Attr);
 1295     Ptr = std::make_unique<VariadicExprArgument>(Arg, Attr);
 1297     Ptr = std::make_unique<VariadicParamIdxArgument>(Arg, Attr);
 1299     Ptr = std::make_unique<VariadicParamOrParamIdxArgument>(Arg, Attr);
 1301     Ptr = std::make_unique<SimpleArgument>(Arg, Attr, "ParamIdx");
 1303     Ptr = std::make_unique<VariadicIdentifierArgument>(Arg, Attr);
 1305     Ptr = std::make_unique<VersionArgument>(Arg, Attr);

tools/lldb/source/API/SBStream.cpp

  100   m_opaque_up = std::make_unique<StreamFile>(std::move(file.get()));
  135   m_opaque_up = std::make_unique<StreamFile>(file_sp);
  156   m_opaque_up = std::make_unique<StreamFile>(fd, transfer_fh_ownership);

tools/lldb/source/Commands/CommandObjectMemory.cpp

  804           output_stream_storage = std::move(outfile_stream_up);

tools/lldb/source/Core/ValueObjectSyntheticFilter.cpp

  143     m_synth_filter_up = std::make_unique<DummySyntheticFrontEnd>(*m_parent);

tools/lldb/source/Expression/IRExecutionUnit.cpp

  319     m_object_cache_up = std::make_unique<ObjectDumper>();

tools/lldb/source/Host/common/Socket.cpp

  117     socket_up =
  121     socket_up =
  126     socket_up =
  135     socket_up =

tools/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp

 4591         output_stream_storage =

tools/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

  451     m_index = AppleDWARFIndex::Create(
  466         m_index = std::move(*index_or);
  474   m_index = std::make_unique<ManualDWARFIndex>(*GetObjectFile()->GetModule(),

tools/llvm-cov/CodeCoverage.cpp

 1043     Exporter = std::make_unique<CoverageExporterJson>(*Coverage.get(),
 1051     Exporter = std::make_unique<CoverageExporterLcov>(*Coverage.get(),

tools/llvm-objcopy/llvm-objcopy.cpp

  201     Member->Buf = MB.releaseMemoryBuffer();

tools/llvm-objdump/MachODump.cpp

 7413         DSYMBinary = std::move(*MachDSYM);
 7423     diContext = DWARFContext::create(*DbgObj);

tools/obj2yaml/wasm2yaml.cpp

   63     CustomSec = std::move(DylinkSec);
   73     CustomSec = std::move(NameSec);
  134     CustomSec = std::move(LinkingSec);
  157     CustomSec = std::move(ProducersSec);
  167     CustomSec = std::move(TargetFeaturesSec);
  192       S = dumpCustomSection(WasmSec);
  207       S = std::move(TypeSec);
  238       S = std::move(ImportSec);
  246       S = std::move(FuncSec);
  254       S = std::move(TableSec);
  262       S = std::move(MemorySec);
  275       S = std::move(GlobalSec);
  287       S = std::move(EventSec);
  293       S = std::move(StartSec);
  305       S = std::move(ExportSec);
  319       S = std::move(ElemSec);
  336       S = std::move(CodeSec);
  350       S = std::move(DataSec);
  356       S = std::move(DataCountSec);

unittests/ExecutionEngine/JITLink/JITLinkTestCommon.cpp

  136     MemMgr = std::make_unique<InProcessMemoryManager>();

unittests/Support/BinaryStreamTest.cpp

  151       Streams[I * 2].Input = std::move(InByteStream);
  152       Streams[I * 2 + 1].Input = std::move(InBrokenStream);
  161       Streams[I * 2].Output =
  163       Streams[I * 2 + 1].Output = std::make_unique<BrokenStream>(
  170       Streams[I * 2].Output =
  172       Streams[I * 2 + 1].Output = std::make_unique<BrokenStream>(
  179       Streams[I * 2].Input =
  181       Streams[I * 2 + 1].Input = std::make_unique<BrokenStream>(

unittests/Support/YAMLIOTest.cpp

 2844       N = std::make_unique<Scalar>();
 2850       N = std::make_unique<Seq>();
 2856       N = std::make_unique<Map>();
 2982     (*map)["foo"] = std::make_unique<Scalar>(false);
 2983     (*map)["bar"] = std::make_unique<Scalar>(2.0);

utils/TableGen/X86RecognizableInstr.cpp

  752     filter = std::make_unique<DumbFilter>();
  761     filter = std::make_unique<ModFilter>(true);
  770     filter = std::make_unique<ModFilter>(false);
  776     filter = std::make_unique<ExtendedFilter>(true, Form - X86Local::MRM0r);
  782     filter = std::make_unique<ExtendedFilter>(false, Form - X86Local::MRM0m);
  785     filter = std::make_unique<ExactFilter>(0xC0 + Form - X86Local::MRM_C0);