Index: bindings/go/llvm/dibuilder.go =================================================================== --- bindings/go/llvm/dibuilder.go +++ bindings/go/llvm/dibuilder.go @@ -243,10 +243,14 @@ v.File.C, C.unsigned(v.Line), v.Type.C, - C.LLVMBool(boolToCInt(v.AlwaysPreserve)), C.LLVMDIFlags(v.Flags), C.uint32_t(v.AlignInBits), ) + + if C.LLVMBool(boolToCInt(v.AlwaysPreserve)) { + C.LLVMDIBuilderPreserveVariable(d.ref, scope.C, result.ref) + } + return Metadata{C: result} } @@ -276,9 +280,13 @@ v.File.C, C.unsigned(v.Line), v.Type.C, - C.LLVMBool(boolToCInt(v.AlwaysPreserve)), C.LLVMDIFlags(v.Flags), ) + + if C.LLVMBool(boolToCInt(v.AlwaysPreserve)) { + C.LLVMDIBuilderPreserveVariable(d.ref, scope.C, result.ref) + } + return Metadata{C: result} } Index: include/llvm-c/DebugInfo.h =================================================================== --- include/llvm-c/DebugInfo.h +++ include/llvm-c/DebugInfo.h @@ -1131,6 +1131,16 @@ LLVMMetadataRef DebugLoc, LLVMBasicBlockRef Block); +/** + * Preserve a variable's debug info metadata in optimized code. + * \param Builder The DIBuilder. + * \param Scope The local scope the variable is declared in. + * \param DL The variable's debug info descriptor. + */ +void LLVMDIBuilderPreserveVariable(LLVMDIBuilderRef Builder, + LLVMMetadataRef Scope, + LLVMMetadataRef DL); + /** * Create a new descriptor for a local auto variable. * \param Builder The DIBuilder. @@ -1140,14 +1150,13 @@ * \param File File where this variable is defined. * \param LineNo Line number. * \param Ty Metadata describing the type of the variable. - * \param AlwaysPreserve If true, this descriptor will survive optimizations. * \param Flags Flags. * \param AlignInBits Variable alignment. */ LLVMMetadataRef LLVMDIBuilderCreateAutoVariable( LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name, size_t NameLen, LLVMMetadataRef File, unsigned LineNo, LLVMMetadataRef Ty, - LLVMBool AlwaysPreserve, LLVMDIFlags Flags, uint32_t AlignInBits); + LLVMDIFlags Flags, uint32_t AlignInBits); /** * Create a new descriptor for a function parameter variable. @@ -1159,13 +1168,12 @@ * \param File File where this variable is defined. * \param LineNo Line number. * \param Ty Metadata describing the type of the variable. - * \param AlwaysPreserve If true, this descriptor will survive optimizations. * \param Flags Flags. */ LLVMMetadataRef LLVMDIBuilderCreateParameterVariable( LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name, size_t NameLen, unsigned ArgNo, LLVMMetadataRef File, unsigned LineNo, - LLVMMetadataRef Ty, LLVMBool AlwaysPreserve, LLVMDIFlags Flags); + LLVMMetadataRef Ty, LLVMDIFlags Flags); /** * Get the metadata of the subprogram attached to a function. Index: include/llvm/IR/DIBuilder.h =================================================================== --- include/llvm/IR/DIBuilder.h +++ include/llvm/IR/DIBuilder.h @@ -67,7 +67,20 @@ /// Do not use a std::vector. Some versions of libc++ apparently copy /// instead of move on grow operations, and TrackingMDRef is expensive to /// copy. - DenseMap> PreservedVariables; + DenseMap > PreservedVariables; + + /// Key of the map represents variable's declaration pointer. Value of the + /// map represent pair of variable's ID in second operand's function's scope + /// presreved variables. + /// Such pair tracking is needed bacause CXXOperatorCallExpr can refer + /// outer scope's variable by refrence. + using VarDecl = const void*; + using VarIDScopePair = std::pair; + using VarDeclIDMap = DenseMap ; + VarDeclIDMap VarDeclIDs; + + /// Each subprogram's preserved call sites. + DenseMap> PreservedCallSites; /// Each subprogram's preserved labels. DenseMap> PreservedLabels; @@ -592,6 +605,22 @@ unsigned LineNo, DIType *Ty, bool isLocalToUnit, MDNode *Decl = nullptr, MDTuple *templateParams = nullptr, uint32_t AlignInBits = 0); + /// Save variable in container that keeps all variable's debug information. + /// \param Scope Variable scope that is used to get function scope. + /// \param DL Debug information for variable + /// \param VD Variable declaration pointer. This param is used for + /// faster search for certain variable. + void preserveVariable(const DIScope *Scope, DILocalVariable *DL, + VarDecl VD = nullptr); + + /// Find debug info for given variable declaration with specific function + /// scope. + /// \param Scope Scope that is used to determine function scope of + /// searched variable. + /// \param VD Address of searched variable's declaration. + DILocalVariable* getVariableLocation(const DIScope *Scope, VarDecl VD); + + /// Create a new descriptor for an auto variable. This is a local variable /// that is not a subprogram parameter. /// @@ -602,7 +631,7 @@ /// containing subprogram, and will survive some optimizations. DILocalVariable * createAutoVariable(DIScope *Scope, StringRef Name, DIFile *File, - unsigned LineNo, DIType *Ty, bool AlwaysPreserve = false, + unsigned LineNo, DIType *Ty, DINode::DIFlags Flags = DINode::FlagZero, uint32_t AlignInBits = 0); @@ -628,7 +657,6 @@ DILocalVariable * createParameterVariable(DIScope *Scope, StringRef Name, unsigned ArgNo, DIFile *File, unsigned LineNo, DIType *Ty, - bool AlwaysPreserve = false, DINode::DIFlags Flags = DINode::FlagZero); /// Create a new descriptor for the specified @@ -665,7 +693,8 @@ DISubprogram::DISPFlags SPFlags = DISubprogram::SPFlagZero, DITemplateParameterArray TParams = nullptr, DISubprogram *Decl = nullptr, - DITypeArray ThrownTypes = nullptr); + DITypeArray ThrownTypes = nullptr, + bool isDeclForCallSite = false); /// Identical to createFunction, /// except that the resulting DbgNode is meant to be RAUWed. @@ -706,6 +735,37 @@ DITemplateParameterArray TParams = nullptr, DITypeArray ThrownTypes = nullptr); + /// Creates a descriptor for a call site with the + /// specified context. + /// \param Scope Scope of called function. + /// \param Line Line of called function. + /// \param CalledSubprogram Called function metadata. + /// \param Params Array of DICallSiteParam that describe + /// function arguments. + DICallSite *createCallSite(DIScope *Scope, DIFile *File, + unsigned Line, + DISubprogram* CalledSubprogram, + DINodeArray Params, + bool AlwaysPreserve = false); + + /// Creates new call site function parameter. It can only describe simple + /// parameters that consists only of variable and some constant. It is not + /// meant to describe parameter that is evaluated by another function + /// call. If argument is constant value only third parameter that describes + /// it is provided. + /// \param ArgNo Order number of argument that new call site param + /// will describe. + /// \param DIExpr Expression over the passed variable. If no variable + /// is passed then it is expression for constant value. + /// \param Scope A variables scope that is used to get function + /// scope. + /// \param VD A variable declaration pointer trough which is + /// argument passed. + DICallSiteParam * createCallSiteParam(unsigned ArgNo, + DIExpression *DIExpr, + DIScope *Scope = nullptr, + VarDecl VD = nullptr); + /// This creates new descriptor for a namespace with the specified /// parent scope. /// \param Scope Namespace scope Index: include/llvm/IR/LLVMContext.h =================================================================== --- include/llvm/IR/LLVMContext.h +++ include/llvm/IR/LLVMContext.h @@ -103,6 +103,7 @@ MD_irr_loop = 24, // "irr_loop" MD_access_group = 25, // "llvm.access.group" MD_callback = 26, // "callback" + MD_call_site = 27, // "call_site" }; /// Known operand bundle tag IDs, which always have the same value. All Index: lib/IR/DIBuilder.cpp =================================================================== --- lib/IR/DIBuilder.cpp +++ lib/IR/DIBuilder.cpp @@ -56,6 +56,12 @@ if (PV != PreservedVariables.end()) RetainedNodes.append(PV->second.begin(), PV->second.end()); + auto PCS = PreservedCallSites.find(SP); + if (PCS != PreservedCallSites.end()) { + SP->setIsDesribedByCallSites(); + RetainedNodes.append(PCS->second.begin(), PCS->second.end()); + } + auto PL = PreservedLabels.find(SP); if (PL != PreservedLabels.end()) RetainedNodes.append(PL->second.begin(), PL->second.end()); @@ -666,11 +672,41 @@ .release(); } +DILocalVariable *DIBuilder::getVariableLocation(const DIScope *Scope, + VarDecl VD) { + DISubprogram *Fn = getDISubprogram(Scope); + assert(Fn && "Missing subprogram for local variable"); + VarIDScopePair VarIDScope = VarDeclIDs[VD]; + if (VarIDScope.second == Fn) + return dyn_cast(PreservedVariables[Fn][VarIDScope.first]); + return nullptr; +} + +/// The optimizer may remove local variables. If there is an interest +/// to preserve variable info in such situation then stash it in a +/// named mdnode. +void DIBuilder::preserveVariable(const DIScope *Scope, DILocalVariable *DL, + VarDecl VD) { + DISubprogram *Fn = getDISubprogram(Scope); + assert(Fn && "Missing subprogram for local variable"); + + // Variables that don't have declaration. + if (!VD) { + PreservedVariables[Fn].emplace_back(DL); + } else { + VarIDScopePair &IDScope = VarDeclIDs[VD]; + if (!IDScope.first) { + PreservedVariables[Fn].emplace_back(DL); + IDScope.first = PreservedVariables[Fn].size() - 1; + IDScope.second = Fn; + } + } +} + static DILocalVariable *createLocalVariable( LLVMContext &VMContext, - DenseMap> &PreservedVariables, DIScope *Scope, StringRef Name, unsigned ArgNo, DIFile *File, - unsigned LineNo, DIType *Ty, bool AlwaysPreserve, DINode::DIFlags Flags, + unsigned LineNo, DIType *Ty, DINode::DIFlags Flags, uint32_t AlignInBits) { // FIXME: Why getNonCompileUnitScope()? // FIXME: Why is "!Context" okay here? @@ -678,36 +714,27 @@ // the only valid scopes)? DIScope *Context = getNonCompileUnitScope(Scope); - auto *Node = - DILocalVariable::get(VMContext, cast_or_null(Context), Name, - File, LineNo, Ty, ArgNo, Flags, AlignInBits); - if (AlwaysPreserve) { - // The optimizer may remove local variables. If there is an interest - // to preserve variable info in such situation then stash it in a - // named mdnode. - DISubprogram *Fn = getDISubprogram(Scope); - assert(Fn && "Missing subprogram for local variable"); - PreservedVariables[Fn].emplace_back(Node); - } - return Node; + return DILocalVariable::get(VMContext, cast_or_null(Context), + Name, File, LineNo, Ty, ArgNo, Flags, + AlignInBits); } DILocalVariable *DIBuilder::createAutoVariable(DIScope *Scope, StringRef Name, DIFile *File, unsigned LineNo, - DIType *Ty, bool AlwaysPreserve, + DIType *Ty, DINode::DIFlags Flags, uint32_t AlignInBits) { - return createLocalVariable(VMContext, PreservedVariables, Scope, Name, - /* ArgNo */ 0, File, LineNo, Ty, AlwaysPreserve, + return createLocalVariable(VMContext, Scope, Name, + /* ArgNo */ 0, File, LineNo, Ty, Flags, AlignInBits); } DILocalVariable *DIBuilder::createParameterVariable( DIScope *Scope, StringRef Name, unsigned ArgNo, DIFile *File, - unsigned LineNo, DIType *Ty, bool AlwaysPreserve, DINode::DIFlags Flags) { + unsigned LineNo, DIType *Ty, DINode::DIFlags Flags) { assert(ArgNo && "Expected non-zero argument number for parameter"); - return createLocalVariable(VMContext, PreservedVariables, Scope, Name, ArgNo, - File, LineNo, Ty, AlwaysPreserve, Flags, + return createLocalVariable(VMContext, Scope, Name, ArgNo, + File, LineNo, Ty, Flags, /* AlignInBits */0); } @@ -753,7 +780,7 @@ unsigned LineNo, DISubroutineType *Ty, unsigned ScopeLine, DINode::DIFlags Flags, DISubprogram::DISPFlags SPFlags, DITemplateParameterArray TParams, DISubprogram *Decl, - DITypeArray ThrownTypes) { + DITypeArray ThrownTypes, bool isDeclForCallSite) { bool IsDefinition = SPFlags & DISubprogram::SPFlagDefinition; auto *Node = getSubprogram( /*IsDistinct=*/IsDefinition, VMContext, getNonCompileUnitScope(Context), @@ -761,12 +788,50 @@ SPFlags, IsDefinition ? CUNode : nullptr, TParams, Decl, MDTuple::getTemporary(VMContext, None).release(), ThrownTypes); - if (IsDefinition) + if (isDeclForCallSite) + Node->setIsDeclForCallSite(); + if (IsDefinition || isDeclForCallSite) AllSubprograms.push_back(Node); trackIfUnresolved(Node); return Node; } +DICallSite *DIBuilder::createCallSite(DIScope *Scope, DIFile *File, + unsigned Line, + DISubprogram *CalledSubprogram, + DINodeArray Params, bool AlwaysPreserve) { + DIScope *Context = getNonCompileUnitScope(Scope); + auto *Node = DICallSite::get(VMContext, cast_or_null(Context), + File, Params, Line, CalledSubprogram); + if (AlwaysPreserve) { + // The optimizer may remove callsite. If there is an interest + // to preserve callsite info in such situation then append it to + // the list of retained nodes of the DISubprogram. + DISubprogram *Fn = getDISubprogram(Scope); + assert(Fn && "Missing subprogram for callsite"); + PreservedCallSites[Fn].emplace_back(Node); + } + + return Node; +} + +DICallSiteParam *DIBuilder::createCallSiteParam(unsigned ArgNo, + DIExpression *Expr, + DIScope *Scope, VarDecl VD) { + if (VD != nullptr) { + DILocalVariable *DILV = getVariableLocation(Scope, VD); + // If we can't find DILocalVariable for variable declaration, currently + // we can't find it for global variables (including functions), we will + // emit simple call site with empty expression and leave space for other + // approach to find expression for this call site parameter. + if (!DILV) + Expr = DIExpression::get(VMContext, {}); + else + return DICallSiteParam::get(VMContext, ArgNo, DILV, Expr); + } + return DICallSiteParam::get(VMContext, ArgNo, Expr); +} + DISubprogram *DIBuilder::createTempFunctionFwdDecl( DIScope *Context, StringRef Name, StringRef LinkageName, DIFile *File, unsigned LineNo, DISubroutineType *Ty, unsigned ScopeLine, Index: lib/IR/DebugInfo.cpp =================================================================== --- lib/IR/DebugInfo.cpp +++ lib/IR/DebugInfo.cpp @@ -1307,23 +1307,30 @@ unwrap(Block))); } +void LLVMDIBuilderPreserveVariable(LLVMDIBuilderRef Builder, + LLVMMetadataRef Scope, + LLVMMetadataRef DL) { + unwrap(Builder)->preserveVariable(unwrap(Scope), + unwrap(DL)); +} + LLVMMetadataRef LLVMDIBuilderCreateAutoVariable( LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name, size_t NameLen, LLVMMetadataRef File, unsigned LineNo, LLVMMetadataRef Ty, - LLVMBool AlwaysPreserve, LLVMDIFlags Flags, uint32_t AlignInBits) { + LLVMDIFlags Flags, uint32_t AlignInBits) { return wrap(unwrap(Builder)->createAutoVariable( unwrap(Scope), {Name, NameLen}, unwrap(File), - LineNo, unwrap(Ty), AlwaysPreserve, + LineNo, unwrap(Ty), map_from_llvmDIFlags(Flags), AlignInBits)); } LLVMMetadataRef LLVMDIBuilderCreateParameterVariable( LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, const char *Name, size_t NameLen, unsigned ArgNo, LLVMMetadataRef File, unsigned LineNo, - LLVMMetadataRef Ty, LLVMBool AlwaysPreserve, LLVMDIFlags Flags) { + LLVMMetadataRef Ty, LLVMDIFlags Flags) { return wrap(unwrap(Builder)->createParameterVariable( unwrap(Scope), {Name, NameLen}, ArgNo, unwrap(File), - LineNo, unwrap(Ty), AlwaysPreserve, + LineNo, unwrap(Ty), map_from_llvmDIFlags(Flags))); } Index: lib/IR/DebugInfoMetadata.cpp =================================================================== --- lib/IR/DebugInfoMetadata.cpp +++ lib/IR/DebugInfoMetadata.cpp @@ -851,8 +851,11 @@ if (I->get() + I->getSize() > E->get()) return false; + uint64_t Op = I->getOp(); + if (Op >= dwarf::DW_OP_lit0 && Op <= dwarf::DW_OP_lit31) + continue; // Check that the operand is valid. - switch (I->getOp()) { + switch (Op) { default: return false; case dwarf::DW_OP_LLVM_fragment: @@ -880,6 +883,7 @@ break; } case dwarf::DW_OP_constu: + case dwarf::DW_OP_consts: case dwarf::DW_OP_plus_uconst: case dwarf::DW_OP_plus: case dwarf::DW_OP_minus: @@ -894,7 +898,8 @@ case dwarf::DW_OP_shra: case dwarf::DW_OP_deref: case dwarf::DW_OP_xderef: - case dwarf::DW_OP_lit0: + case dwarf::DW_OP_neg: + case dwarf::DW_OP_push_object_address: case dwarf::DW_OP_not: case dwarf::DW_OP_dup: break; Index: lib/IR/LLVMContext.cpp =================================================================== --- lib/IR/LLVMContext.cpp +++ lib/IR/LLVMContext.cpp @@ -62,6 +62,7 @@ {MD_irr_loop, "irr_loop"}, {MD_access_group, "llvm.access.group"}, {MD_callback, "callback"}, + {MD_call_site, "call_site"}, }; for (auto &MDKind : MDKinds) { Index: lib/IR/Verifier.cpp =================================================================== --- lib/IR/Verifier.cpp +++ lib/IR/Verifier.cpp @@ -1103,8 +1103,10 @@ auto *Node = dyn_cast(RawNode); AssertDI(Node, "invalid retained nodes list", &N, RawNode); for (Metadata *Op : Node->operands()) { - AssertDI(Op && (isa(Op) || isa(Op)), - "invalid retained nodes, expected DILocalVariable or DILabel", + AssertDI(Op && (isa(Op) || isa(Op) || + isa(Op)), + "invalid retained nodes, expected DILocalVariable or DILabel" + " or DICallSite", &N, Node, Op); } } Index: test/ThinLTO/X86/lazyload_metadata.ll =================================================================== --- test/ThinLTO/X86/lazyload_metadata.ll +++ test/ThinLTO/X86/lazyload_metadata.ll @@ -10,13 +10,13 @@ ; RUN: llvm-lto -thinlto-action=import %t2.bc -thinlto-index=%t3.bc \ ; RUN: -o /dev/null -stats \ ; RUN: 2>&1 | FileCheck %s -check-prefix=LAZY -; LAZY: 59 bitcode-reader - Number of Metadata records loaded +; LAZY: 61 bitcode-reader - Number of Metadata records loaded ; LAZY: 2 bitcode-reader - Number of MDStrings loaded ; RUN: llvm-lto -thinlto-action=import %t2.bc -thinlto-index=%t3.bc \ ; RUN: -o /dev/null -disable-ondemand-mds-loading -stats \ ; RUN: 2>&1 | FileCheck %s -check-prefix=NOTLAZY -; NOTLAZY: 68 bitcode-reader - Number of Metadata records loaded +; NOTLAZY: 70 bitcode-reader - Number of Metadata records loaded ; NOTLAZY: 7 bitcode-reader - Number of MDStrings loaded Index: tools/llvm-c-test/debuginfo.c =================================================================== --- tools/llvm-c-test/debuginfo.c +++ tools/llvm-c-test/debuginfo.c @@ -134,19 +134,22 @@ LLVMDIBuilderCreateExpression(DIB, NULL, 0); LLVMMetadataRef FooParamVar1 = LLVMDIBuilderCreateParameterVariable(DIB, FunctionMetadata, "a", 1, 1, File, - 42, Int64Ty, true, 0); + 42, Int64Ty, 0); + LLVMDIBuilderPreserveVariable(DIB, FunctionMetadata, FooParamVar1); LLVMDIBuilderInsertDeclareAtEnd(DIB, LLVMConstInt(LLVMInt64Type(), 0, false), FooParamVar1, FooParamExpression, FooParamLocation, FooEntryBlock); LLVMMetadataRef FooParamVar2 = LLVMDIBuilderCreateParameterVariable(DIB, FunctionMetadata, "b", 1, 2, File, - 42, Int64Ty, true, 0); + 42, Int64Ty, 0); + LLVMDIBuilderPreserveVariable(DIB, FunctionMetadata, FooParamVar2); LLVMDIBuilderInsertDeclareAtEnd(DIB, LLVMConstInt(LLVMInt64Type(), 0, false), FooParamVar2, FooParamExpression, FooParamLocation, FooEntryBlock); LLVMMetadataRef FooParamVar3 = LLVMDIBuilderCreateParameterVariable(DIB, FunctionMetadata, "c", 1, 3, File, - 42, VectorTy, true, 0); + 42, VectorTy, 0); + LLVMDIBuilderPreserveVariable(DIB, FunctionMetadata, FooParamVar3); LLVMDIBuilderInsertDeclareAtEnd(DIB, LLVMConstInt(LLVMInt64Type(), 0, false), FooParamVar3, FooParamExpression, FooParamLocation, FooEntryBlock); @@ -162,7 +165,8 @@ FunctionMetadata, NULL); LLVMMetadataRef FooVar1 = LLVMDIBuilderCreateAutoVariable(DIB, FooLexicalBlock, "d", 1, File, - 43, Int64Ty, true, 0, 0); + 43, Int64Ty, 0, 0); + LLVMDIBuilderPreserveVariable(DIB, FunctionMetadata, FooVar1); LLVMValueRef FooVal1 = LLVMConstInt(LLVMInt64Type(), 0, false); LLVMMetadataRef FooVarValueExpr = LLVMDIBuilderCreateConstantValueExpression(DIB, 0); Index: tools/opt/Debugify.cpp =================================================================== --- tools/opt/Debugify.cpp +++ tools/opt/Debugify.cpp @@ -136,8 +136,8 @@ std::string Name = utostr(NextVar++); const DILocation *Loc = I->getDebugLoc().get(); auto LocalVar = DIB.createAutoVariable(SP, Name, File, Loc->getLine(), - getCachedDIType(I->getType()), - /*AlwaysPreserve=*/true); + getCachedDIType(I->getType())); + DIB.preserveVariable(Loc->getScope(), LocalVar); DIB.insertDbgValueIntrinsic(I, LocalVar, DIB.createExpression(), Loc, InsertBefore); } Index: unittests/Transforms/Utils/CloningTest.cpp =================================================================== --- unittests/Transforms/Utils/CloningTest.cpp +++ unittests/Transforms/Utils/CloningTest.cpp @@ -410,7 +410,8 @@ auto *IntType = DBuilder.createBasicType("int", 32, dwarf::DW_ATE_signed); auto *E = DBuilder.createExpression(); auto *Variable = - DBuilder.createAutoVariable(Subprogram, "x", File, 5, IntType, true); + DBuilder.createAutoVariable(Subprogram, "x", File, 5, IntType); + DBuilder.preserveVariable(cast(Loc->getScope()), Variable); auto *DL = DILocation::get(Subprogram->getContext(), 5, 0, Subprogram); DBuilder.insertDeclare(Alloca, Variable, E, DL, Store); DBuilder.insertDbgValueIntrinsic(AllocaContent, Variable, E, DL, Entry); @@ -424,7 +425,8 @@ CU, "inlined", "inlined", File, 8, FuncType, 9, DINode::FlagZero, DISubprogram::SPFlagLocalToUnit | DISubprogram::SPFlagDefinition); auto *InlinedVar = - DBuilder.createAutoVariable(InlinedSP, "inlined", File, 5, StructType, true); + DBuilder.createAutoVariable(InlinedSP, "inlined", File, 5, StructType); + DBuilder.preserveVariable(cast(InlinedSP), InlinedVar); auto *Scope = DBuilder.createLexicalBlock( DBuilder.createLexicalBlockFile(InlinedSP, File), File, 1, 1); auto InlinedDL =