[DebugInfo] Add localDecls field to DISubprogram and DILexicalBlock (1/5)

[krisb]

Summary

localDecls is intended to track static locals, function- (or lexical-block-) local types (plus typedefs, enums and unions) and imported entities.
Main motivation for adding new field for DISubprogram and DILexicalBlock is to implement more accurate handling for function-local declarations (types, imports and static locals) and support lexical block scopes for them (see D125693).

Thus static locals, function-local enums and imported entities are no longer go to compile unit's 'globals', 'enums' and 'imports'.
But if '-debug-info-kind' is specified as 'unused-types', function-local type-like entities will be referenced by CUs 'retainedTypes'.

This patch just adds localDecls field, corresponding clang/backend changes are in next patches.

[krisb]

Fix comment.

[aprantl]

Do you need to add any special handling to CloneFunction.cpp or will it work correctly?

[krisb]

In D125691#3580147, @aprantl wrote:

Do you need to add any special handling to CloneFunction.cpp or will it work correctly?

It will work correctly.
D125693 has a test case that checks that a function with 2 local 'global' variables gets properly cloned.

There is a corner case, though. It doesn't directly relate to this patch, but still needs to be mentioned. If to clone a function with other functions inlined into it within the same module, DISubprograms of the inlined functions will not be cloned. But DILexicalBlocks in scopes of such inlined functions will be duplicated which may cause problems later in AsmPrinter. D127102 proposes to skip cloning DILexicalBlocks if their parent DISubprogram was not cloned.

[krisb]

Ping

[krisb]

Tracking function-local entities per-scope is good from optimization point (we may remove DILexicalBlock if there are no instruction left in it), but it makes handling abstract trees in AsmPrinter difficult.
We want to create an abstract scope if it is a parent scope for any of tracked nodes (this is true for local variables/labels as well as for other local entities). Since there are no easy ways to find which DILexicalBlocks belong to a particular subprogram, I'm not sure this approach is profitable.

So, I give up on this and switch the implementation to per-subprogram field. See D125693 for details.

llvm/include/llvm/IR/DIBuilder.h

class DIBuilder {
     LLVMContext &VMContext;
 
     DICompileUnit *CUNode;   ///< The one compile unit created by this DIBuiler.
     Function *DeclareFn;     ///< llvm.dbg.declare
     Function *ValueFn;       ///< llvm.dbg.value
     Function *LabelFn;       ///< llvm.dbg.label
     Function *AddrFn;        ///< llvm.dbg.addr
 
-    SmallVector<Metadata *, 4> AllEnumTypes;
     /// Track the RetainTypes, since they can be updated later on.
     SmallVector<TrackingMDNodeRef, 4> AllRetainTypes;
     SmallVector<Metadata *, 4> AllSubprograms;
-    SmallVector<Metadata *, 4> AllGVs;
-    SmallVector<TrackingMDNodeRef, 4> AllImportedModules;
     /// Map Macro parent (which can be DIMacroFile or nullptr) to a list of
     /// Metadata all of type DIMacroNode.
     /// DIMacroNode's with nullptr parent are DICompileUnit direct children.
     MapVector<MDNode *, SetVector<Metadata *>> AllMacrosPerParent;
 
+    /// Module level global variables, enum types and imported entities.
+    SmallVector<Metadata *, 4> ModuleGVs;
+    SmallVector<Metadata *, 4> ModuleEnumTypes;
+    SmallVector<TrackingMDNodeRef, 4> ModuleImports;
+    /// Function-local static vars, types (including enums) and import.
+    DenseMap<MDNode *, SmallVector<TrackingMDNodeRef, 4>> LocalDecls;
+
     /// Track nodes that may be unresolved.
     SmallVector<TrackingMDNodeRef, 4> UnresolvedNodes;
     bool AllowUnresolvedNodes;
 
     /// Each subprogram's preserved local variables.
     ///
     /// Do not use a std::vector.  Some versions of libc++ apparently copy
     /// instead of move on grow operations, and TrackingMDRef is expensive to

llvm/include/llvm/IR/DebugInfoMetadata.h

 //===- llvm/IR/DebugInfoMetadata.h - Debug info metadata --------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // Declarations for metadata specific to debug info.
public:
   DISubprogram *getSubprogram() const;
 
   /// Get the first non DILexicalBlockFile scope of this scope.
   ///
   /// Return this if it's not a \a DILexicalBlockFIle; otherwise, look up the
   /// scope chain.
   DILocalScope *getNonLexicalBlockFileScope() const;
 
+  /// Get a list of function-local declarations for this scope.
+  ///
+  /// Return an array of static variables, types and imported entities
+  /// declarated in this scope for \a DISubprogram or \a DILexicalScope,
+  /// and nullptr for other scopes.
+  MDNodeArray getLocalDecls() const;
+
+  /// Replace a list of function-local declarations by the given one.
+  /// Assumes 'this' is either \a DISubprogram or \a DILexicalScope.
+  void replaceLocalDecls(MDNodeArray N);
+
   static bool classof(const Metadata *MD) {
     return MD->getMetadataID() == DISubprogramKind ||
            MD->getMetadataID() == DILexicalBlockKind ||
            MD->getMetadataID() == DILexicalBlockFileKind;
   }
 };
 
 /// Debug location.
private:
 
   static DISubprogram *
   getImpl(LLVMContext &Context, DIScope *Scope, StringRef Name,
           StringRef LinkageName, DIFile *File, unsigned Line,
           DISubroutineType *Type, unsigned ScopeLine, DIType *ContainingType,
           unsigned VirtualIndex, int ThisAdjustment, DIFlags Flags,
           DISPFlags SPFlags, DICompileUnit *Unit,
           DITemplateParameterArray TemplateParams, DISubprogram *Declaration,
-          DINodeArray RetainedNodes, DITypeArray ThrownTypes,
-          DINodeArray Annotations, StringRef TargetFuncName,
-          StorageType Storage, bool ShouldCreate = true) {
-    return getImpl(Context, Scope, getCanonicalMDString(Context, Name),
-                   getCanonicalMDString(Context, LinkageName), File, Line, Type,
-                   ScopeLine, ContainingType, VirtualIndex, ThisAdjustment,
-                   Flags, SPFlags, Unit, TemplateParams.get(), Declaration,
-                   RetainedNodes.get(), ThrownTypes.get(), Annotations.get(),
-                   getCanonicalMDString(Context, TargetFuncName),
-                   Storage, ShouldCreate);
+          DINodeArray RetainedNodes, MDNodeArray LocalDecls,
+          DITypeArray ThrownTypes, DINodeArray Annotations,
+          StringRef TargetFuncName, StorageType Storage,
+          bool ShouldCreate = true) {
+    return getImpl(
+        Context, Scope, getCanonicalMDString(Context, Name),
+        getCanonicalMDString(Context, LinkageName), File, Line, Type, ScopeLine,
+        ContainingType, VirtualIndex, ThisAdjustment, Flags, SPFlags, Unit,
+        TemplateParams.get(), Declaration, RetainedNodes.get(),
+        LocalDecls.get(), ThrownTypes.get(), Annotations.get(),
+        getCanonicalMDString(Context, TargetFuncName), Storage, ShouldCreate);
   }
   static DISubprogram *
   getImpl(LLVMContext &Context, Metadata *Scope, MDString *Name,
           MDString *LinkageName, Metadata *File, unsigned Line, Metadata *Type,
           unsigned ScopeLine, Metadata *ContainingType, unsigned VirtualIndex,
           int ThisAdjustment, DIFlags Flags, DISPFlags SPFlags, Metadata *Unit,
           Metadata *TemplateParams, Metadata *Declaration,
-          Metadata *RetainedNodes, Metadata *ThrownTypes, Metadata *Annotations,
-          MDString *TargetFuncName, StorageType Storage,
+          Metadata *RetainedNodes, Metadata *LocalDecls, Metadata *ThrownTypes,
+          Metadata *Annotations, MDString *TargetFuncName, StorageType Storage,
           bool ShouldCreate = true);
 
   TempDISubprogram cloneImpl() const {
     return getTemporary(getContext(), getScope(), getName(), getLinkageName(),
                         getFile(), getLine(), getType(), getScopeLine(),
                         getContainingType(), getVirtualIndex(),
                         getThisAdjustment(), getFlags(), getSPFlags(),
                         getUnit(), getTemplateParams(), getDeclaration(),
-                        getRetainedNodes(), getThrownTypes(), getAnnotations(),
-                        getTargetFuncName());
+                        getRetainedNodes(), getLocalDecls(), getThrownTypes(),
+                        getAnnotations(), getTargetFuncName());
   }
 
 public:
   DEFINE_MDNODE_GET(
       DISubprogram,
       (DIScope * Scope, StringRef Name, StringRef LinkageName, DIFile *File,
        unsigned Line, DISubroutineType *Type, unsigned ScopeLine,
        DIType *ContainingType, unsigned VirtualIndex, int ThisAdjustment,
        DIFlags Flags, DISPFlags SPFlags, DICompileUnit *Unit,
        DITemplateParameterArray TemplateParams = nullptr,
        DISubprogram *Declaration = nullptr, DINodeArray RetainedNodes = nullptr,
-       DITypeArray ThrownTypes = nullptr, DINodeArray Annotations = nullptr,
-       StringRef TargetFuncName = ""),
+       MDNodeArray LocalDecls = nullptr, DITypeArray ThrownTypes = nullptr,
+       DINodeArray Annotations = nullptr, StringRef TargetFuncName = ""),
       (Scope, Name, LinkageName, File, Line, Type, ScopeLine, ContainingType,
        VirtualIndex, ThisAdjustment, Flags, SPFlags, Unit, TemplateParams,
-       Declaration, RetainedNodes, ThrownTypes, Annotations, TargetFuncName))
+       Declaration, RetainedNodes, LocalDecls, ThrownTypes, Annotations,
+       TargetFuncName))
 
   DEFINE_MDNODE_GET(
       DISubprogram,
       (Metadata * Scope, MDString *Name, MDString *LinkageName, Metadata *File,
        unsigned Line, Metadata *Type, unsigned ScopeLine,
        Metadata *ContainingType, unsigned VirtualIndex, int ThisAdjustment,
        DIFlags Flags, DISPFlags SPFlags, Metadata *Unit,
        Metadata *TemplateParams = nullptr, Metadata *Declaration = nullptr,
-       Metadata *RetainedNodes = nullptr, Metadata *ThrownTypes = nullptr,
-       Metadata *Annotations = nullptr, MDString *TargetFuncName = nullptr),
+       Metadata *RetainedNodes = nullptr, Metadata *LocalDecls = nullptr,
+       Metadata *ThrownTypes = nullptr, Metadata *Annotations = nullptr,
+       MDString *TargetFuncName = nullptr),
       (Scope, Name, LinkageName, File, Line, Type, ScopeLine, ContainingType,
        VirtualIndex, ThisAdjustment, Flags, SPFlags, Unit, TemplateParams,
-       Declaration, RetainedNodes, ThrownTypes, Annotations, TargetFuncName))
+       Declaration, RetainedNodes, LocalDecls, ThrownTypes, Annotations,
+       TargetFuncName))
 
   TempDISubprogram clone() const { return cloneImpl(); }
 
   /// Returns a new temporary DISubprogram with updated Flags
   TempDISubprogram cloneWithFlags(DIFlags NewFlags) const {
     auto NewSP = clone();
     NewSP->Flags = NewFlags;
     return NewSP;
DITemplateParameterArray getTemplateParams() const {
     return cast_or_null<MDTuple>(getRawTemplateParams());
   }
   DISubprogram *getDeclaration() const {
     return cast_or_null<DISubprogram>(getRawDeclaration());
   }
   DINodeArray getRetainedNodes() const {
     return cast_or_null<MDTuple>(getRawRetainedNodes());
   }
+  MDNodeArray getLocalDecls() const {
+    return cast_or_null<MDTuple>(getRawLocalDecls());
+  }
   DITypeArray getThrownTypes() const {
     return cast_or_null<MDTuple>(getRawThrownTypes());
   }
   DINodeArray getAnnotations() const {
     return cast_or_null<MDTuple>(getRawAnnotations());
   }
   StringRef getTargetFuncName() const {
     return (getRawTargetFuncName()) ? getStringOperand(12) : StringRef();
   }
 
   Metadata *getRawScope() const { return getOperand(1); }
   MDString *getRawName() const { return getOperandAs<MDString>(2); }
   MDString *getRawLinkageName() const { return getOperandAs<MDString>(3); }
   Metadata *getRawType() const { return getOperand(4); }
   Metadata *getRawUnit() const { return getOperand(5); }
   Metadata *getRawDeclaration() const { return getOperand(6); }
   Metadata *getRawRetainedNodes() const { return getOperand(7); }
-  Metadata *getRawContainingType() const {
-    return getNumOperands() > 8 ? getOperandAs<Metadata>(8) : nullptr;
-  }
-  Metadata *getRawTemplateParams() const {
-    return getNumOperands() > 9 ? getOperandAs<Metadata>(9) : nullptr;
-  }
-  Metadata *getRawThrownTypes() const {
-    return getNumOperands() > 10 ? getOperandAs<Metadata>(10) : nullptr;
-  }
-  Metadata *getRawAnnotations() const {
-    return getNumOperands() > 11 ? getOperandAs<Metadata>(11) : nullptr;
-  }
-  MDString *getRawTargetFuncName() const {
-    return getNumOperands() > 12 ? getOperandAs<MDString>(12) : nullptr;
-  }
+  Metadata *getRawContainingType() const { return getOperandAs<Metadata>(8); }
+  Metadata *getRawTemplateParams() const { return getOperandAs<Metadata>(9); }
+  Metadata *getRawThrownTypes() const { return getOperandAs<Metadata>(10); }
+  Metadata *getRawAnnotations() const { return getOperandAs<Metadata>(11); }
+  MDString *getRawTargetFuncName() const { return getOperandAs<MDString>(12); }
+  Metadata *getRawLocalDecls() const { return getOperand(13); }
 
   void replaceRawLinkageName(MDString *LinkageName) {
     replaceOperandWith(3, LinkageName);
   }
+  void replaceLocalDecls(MDNodeArray N) {
+    replaceOperandWith(13, N.get());
+  }
 
   /// Check if this subprogram describes the given function.
   ///
   /// FIXME: Should this be looking through bitcasts?
   bool describes(const Function *F) const;
 
   static bool classof(const Metadata *MD) {
     return MD->getMetadataID() == DISubprogramKind;
DILexicalBlock(LLVMContext &C, StorageType Storage, unsigned Line,
       : DILexicalBlockBase(C, DILexicalBlockKind, Storage, Ops), Line(Line),
         Column(Column) {
     assert(Column < (1u << 16) && "Expected 16-bit column");
   }
   ~DILexicalBlock() = default;
 
   static DILexicalBlock *getImpl(LLVMContext &Context, DILocalScope *Scope,
                                  DIFile *File, unsigned Line, unsigned Column,
+                                 MDNodeArray LocalDecls,
                                  StorageType Storage,
                                  bool ShouldCreate = true) {
     return getImpl(Context, static_cast<Metadata *>(Scope),
-                   static_cast<Metadata *>(File), Line, Column, Storage,
-                   ShouldCreate);
+                   static_cast<Metadata *>(File), Line, Column,
+                   LocalDecls.get(), Storage, ShouldCreate);
   }
 
   static DILexicalBlock *getImpl(LLVMContext &Context, Metadata *Scope,
                                  Metadata *File, unsigned Line, unsigned Column,
+                                 Metadata *LocalDecls,
                                  StorageType Storage, bool ShouldCreate = true);
 
   TempDILexicalBlock cloneImpl() const {
     return getTemporary(getContext(), getScope(), getFile(), getLine(),
-                        getColumn());
+                        getColumn(), getLocalDecls());
   }
 
 public:
   DEFINE_MDNODE_GET(DILexicalBlock,
                     (DILocalScope * Scope, DIFile *File, unsigned Line,
-                     unsigned Column),
-                    (Scope, File, Line, Column))
+                     unsigned Column, MDNodeArray LocalDecls = nullptr),
+                    (Scope, File, Line, Column, LocalDecls))
   DEFINE_MDNODE_GET(DILexicalBlock,
                     (Metadata * Scope, Metadata *File, unsigned Line,
-                     unsigned Column),
-                    (Scope, File, Line, Column))
+                     unsigned Column, Metadata *LocalDecls = nullptr),
+                    (Scope, File, Line, Column, LocalDecls))
 
   TempDILexicalBlock clone() const { return cloneImpl(); }
 
   unsigned getLine() const { return Line; }
   unsigned getColumn() const { return Column; }
 
+  MDNodeArray getLocalDecls() const {
+    return cast_or_null<MDTuple>(getRawLocalDecls());
+  }
+  Metadata *getRawLocalDecls() const { return getOperand(2); }
+  void replaceLocalDecls(MDNodeArray N) {
+    replaceOperandWith(2, N.get());
+  }
+
   static bool classof(const Metadata *MD) {
     return MD->getMetadataID() == DILexicalBlockKind;
   }
 };
 
 class DILexicalBlockFile : public DILexicalBlockBase {
   friend class LLVMContextImpl;
   friend class MDNode;

llvm/lib/AsmParser/LLParser.cpp

 /// parseDISubprogram:
 ///   ::= !DISubprogram(scope: !0, name: "foo", linkageName: "_Zfoo",
 ///                     file: !1, line: 7, type: !2, isLocal: false,
 ///                     isDefinition: true, scopeLine: 8, containingType: !3,
 ///                     virtuality: DW_VIRTUALTIY_pure_virtual,
 ///                     virtualIndex: 10, thisAdjustment: 4, flags: 11,
 ///                     spFlags: 10, isOptimized: false, templateParams: !4,
 ///                     declaration: !5, retainedNodes: !6, thrownTypes: !7,
-///                     annotations: !8)
+///                     annotations: !8, localDecls: !9)
 bool LLParser::parseDISubprogram(MDNode *&Result, bool IsDistinct) {
   auto Loc = Lex.getLoc();
 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED)                                    \
   OPTIONAL(scope, MDField, );                                                  \
   OPTIONAL(name, MDStringField, );                                             \
   OPTIONAL(linkageName, MDStringField, );                                      \
   OPTIONAL(file, MDField, );                                                   \
   OPTIONAL(line, LineField, );                                                 \
#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED)                                    \
   OPTIONAL(spFlags, DISPFlagField, );                                          \
   OPTIONAL(isOptimized, MDBoolField, );                                        \
   OPTIONAL(unit, MDField, );                                                   \
   OPTIONAL(templateParams, MDField, );                                         \
   OPTIONAL(declaration, MDField, );                                            \
   OPTIONAL(retainedNodes, MDField, );                                          \
   OPTIONAL(thrownTypes, MDField, );                                            \
   OPTIONAL(annotations, MDField, );                                            \
-  OPTIONAL(targetFuncName, MDStringField, );
+  OPTIONAL(targetFuncName, MDStringField, );                                   \
+  OPTIONAL(localDecls, MDField, );
   PARSE_MD_FIELDS();
 #undef VISIT_MD_FIELDS
 
   // An explicit spFlags field takes precedence over individual fields in
   // older IR versions.
   DISubprogram::DISPFlags SPFlags =
       spFlags.Seen ? spFlags.Val
                    : DISubprogram::toSPFlags(isLocal.Val, isDefinition.Val,
                                              isOptimized.Val, virtuality.Val);
   if ((SPFlags & DISubprogram::SPFlagDefinition) && !IsDistinct)
     return Lex.Error(
         Loc,
         "missing 'distinct', required for !DISubprogram that is a Definition");
   Result = GET_OR_DISTINCT(
       DISubprogram,
       (Context, scope.Val, name.Val, linkageName.Val, file.Val, line.Val,
        type.Val, scopeLine.Val, containingType.Val, virtualIndex.Val,
        thisAdjustment.Val, flags.Val, SPFlags, unit.Val, templateParams.Val,
-       declaration.Val, retainedNodes.Val, thrownTypes.Val, annotations.Val,
-       targetFuncName.Val));
+       declaration.Val, retainedNodes.Val, localDecls.Val, thrownTypes.Val,
+       annotations.Val, targetFuncName.Val));
   return false;
 }
 
 /// parseDILexicalBlock:
-///   ::= !DILexicalBlock(scope: !0, file: !2, line: 7, column: 9)
+///   ::= !DILexicalBlock(scope: !0, file: !2, line: 7, column: 9,
+///                       localDecls: !1)
 bool LLParser::parseDILexicalBlock(MDNode *&Result, bool IsDistinct) {
 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED)                                    \
   REQUIRED(scope, MDField, (/* AllowNull */ false));                           \
   OPTIONAL(file, MDField, );                                                   \
   OPTIONAL(line, LineField, );                                                 \
-  OPTIONAL(column, ColumnField, );
+  OPTIONAL(column, ColumnField, );                                             \
+  OPTIONAL(localDecls, MDField, );
   PARSE_MD_FIELDS();
 #undef VISIT_MD_FIELDS
 
-  Result = GET_OR_DISTINCT(
-      DILexicalBlock, (Context, scope.Val, file.Val, line.Val, column.Val));
+  Result =
+      GET_OR_DISTINCT(DILexicalBlock, (Context, scope.Val, file.Val, line.Val,
+                                       column.Val, localDecls.Val));
   return false;
 }
 
 /// parseDILexicalBlockFile:
 ///   ::= !DILexicalBlockFile(scope: !0, file: !2, discriminator: 9)
 bool LLParser::parseDILexicalBlockFile(MDNode *&Result, bool IsDistinct) {
 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED)                                    \
   REQUIRED(scope, MDField, (/* AllowNull */ false));                           \

llvm/lib/Bitcode/Reader/MetadataLoader.cpp

 //===- MetadataLoader.cpp - Internal BitcodeReader implementation ---------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "MetadataLoader.h"
case bitc::METADATA_SUBPROGRAM: {
     if (!HasSPFlags && HasUnit && Record.size() < 19)
       return error("Invalid record");
     if (HasSPFlags && !HasUnit)
       return error("Invalid record");
     // Accommodate older formats.
     bool HasFn = false;
     bool HasThisAdj = true;
     bool HasThrownTypes = true;
+    bool HasLocalDecls = false;
     bool HasAnnotations = false;
     bool HasTargetFuncName = false;
     unsigned OffsetA = 0;
     unsigned OffsetB = 0;
     if (!HasSPFlags) {
       OffsetA = 2;
       OffsetB = 2;
       if (Record.size() >= 19) {
         HasFn = !HasUnit;
         OffsetB++;
       }
       HasThisAdj = Record.size() >= 20;
       HasThrownTypes = Record.size() >= 21;
     } else {
       HasAnnotations = Record.size() >= 19;
       HasTargetFuncName = Record.size() >= 20;
+      HasLocalDecls = Record.size() >= 21;
     }
     Metadata *CUorFn = getMDOrNull(Record[12 + OffsetB]);
     DISubprogram *SP = GET_OR_DISTINCT(
         DISubprogram,
         (Context,
          getDITypeRefOrNull(Record[1]),           // scope
          getMDString(Record[2]),                  // name
          getMDString(Record[3]),                  // linkageName
          getMDOrNull(Record[4]),                  // file
          Record[5],                               // line
          getMDOrNull(Record[6]),                  // type
          Record[7 + OffsetA],                     // scopeLine
          getDITypeRefOrNull(Record[8 + OffsetA]), // containingType
          Record[10 + OffsetA],                    // virtualIndex
          HasThisAdj ? Record[16 + OffsetB] : 0,   // thisAdjustment
          Flags,                                   // flags
          SPFlags,                                 // SPFlags
          HasUnit ? CUorFn : nullptr,              // unit
          getMDOrNull(Record[13 + OffsetB]),       // templateParams
          getMDOrNull(Record[14 + OffsetB]),       // declaration
          getMDOrNull(Record[15 + OffsetB]),       // retainedNodes
+         HasLocalDecls ? getMDOrNull(Record[20 + OffsetB])
+                       : nullptr, // localDecls
          HasThrownTypes ? getMDOrNull(Record[17 + OffsetB])
                         : nullptr, // thrownTypes
          HasAnnotations ? getMDOrNull(Record[18 + OffsetB])
                         : nullptr, // annotations
          HasTargetFuncName ? getMDString(Record[19 + OffsetB])
                            : nullptr // targetFuncName
          ));
     MetadataList.assignValue(SP, NextMetadataNo);
if (HasFn) {
             FunctionsWithSPs[F] = SP;
           else if (!F->empty())
             F->setSubprogram(SP);
         }
     }
     break;
   }
   case bitc::METADATA_LEXICAL_BLOCK: {
-    if (Record.size() != 5)
+    if (Record.size() > 6 || Record.size() < 5)
       return error("Invalid record");
 
     IsDistinct = Record[0];
-    MetadataList.assignValue(
-        GET_OR_DISTINCT(DILexicalBlock,
-                        (Context, getMDOrNull(Record[1]),
-                         getMDOrNull(Record[2]), Record[3], Record[4])),
+    bool HasLocalDecls = Record.size() >= 6;
+    MetadataList.assignValue(GET_OR_DISTINCT(
+        DILexicalBlock,
+        (Context,
+         getMDOrNull(Record[1]),
+         getMDOrNull(Record[2]),
+         Record[3],
+         Record[4],
+         HasLocalDecls ? getMDOrNull(Record[5]) : nullptr
+         )),
         NextMetadataNo);
     NextMetadataNo++;
     break;
   }
   case bitc::METADATA_LEXICAL_BLOCK_FILE: {
     if (Record.size() != 4)
       return error("Invalid record");
 

llvm/lib/Bitcode/Writer/BitcodeWriter.cpp

void ModuleBitcodeWriter::writeDISubprogram(const DISubprogram *N,
   Record.push_back(VE.getMetadataOrNullID(N->getRawUnit()));
   Record.push_back(VE.getMetadataOrNullID(N->getTemplateParams().get()));
   Record.push_back(VE.getMetadataOrNullID(N->getDeclaration()));
   Record.push_back(VE.getMetadataOrNullID(N->getRetainedNodes().get()));
   Record.push_back(N->getThisAdjustment());
   Record.push_back(VE.getMetadataOrNullID(N->getThrownTypes().get()));
   Record.push_back(VE.getMetadataOrNullID(N->getAnnotations().get()));
   Record.push_back(VE.getMetadataOrNullID(N->getRawTargetFuncName()));
+  Record.push_back(VE.getMetadataOrNullID(N->getLocalDecls().get()));
 
   Stream.EmitRecord(bitc::METADATA_SUBPROGRAM, Record, Abbrev);
   Record.clear();
 }
 
 void ModuleBitcodeWriter::writeDILexicalBlock(const DILexicalBlock *N,
                                               SmallVectorImpl<uint64_t> &Record,
                                               unsigned Abbrev) {
   Record.push_back(N->isDistinct());
   Record.push_back(VE.getMetadataOrNullID(N->getScope()));
   Record.push_back(VE.getMetadataOrNullID(N->getFile()));
   Record.push_back(N->getLine());
   Record.push_back(N->getColumn());
+  Record.push_back(VE.getMetadataOrNullID(N->getLocalDecls().get()));
 
   Stream.EmitRecord(bitc::METADATA_LEXICAL_BLOCK, Record, Abbrev);
   Record.clear();
 }
 
 void ModuleBitcodeWriter::writeDILexicalBlockFile(
     const DILexicalBlockFile *N, SmallVectorImpl<uint64_t> &Record,
     unsigned Abbrev) {

llvm/lib/IR/AsmWriter.cpp

if (N->getVirtuality() != dwarf::DW_VIRTUALITY_none ||
     Printer.printInt("virtualIndex", N->getVirtualIndex(), false);
   Printer.printInt("thisAdjustment", N->getThisAdjustment());
   Printer.printDIFlags("flags", N->getFlags());
   Printer.printDISPFlags("spFlags", N->getSPFlags());
   Printer.printMetadata("unit", N->getRawUnit());
   Printer.printMetadata("templateParams", N->getRawTemplateParams());
   Printer.printMetadata("declaration", N->getRawDeclaration());
   Printer.printMetadata("retainedNodes", N->getRawRetainedNodes());
+  Printer.printMetadata("localDecls", N->getRawLocalDecls());
   Printer.printMetadata("thrownTypes", N->getRawThrownTypes());
   Printer.printMetadata("annotations", N->getRawAnnotations());
   Printer.printString("targetFuncName", N->getTargetFuncName());
   Out << ")";
 }
 
 static void writeDILexicalBlock(raw_ostream &Out, const DILexicalBlock *N,
                                 AsmWriterContext &WriterCtx) {
   Out << "!DILexicalBlock(";
   MDFieldPrinter Printer(Out, WriterCtx);
   Printer.printMetadata("scope", N->getRawScope(), /* ShouldSkipNull */ false);
   Printer.printMetadata("file", N->getRawFile());
   Printer.printInt("line", N->getLine());
   Printer.printInt("column", N->getColumn());
+  Printer.printMetadata("localDecls", N->getRawLocalDecls());
   Out << ")";
 }
 
 static void writeDILexicalBlockFile(raw_ostream &Out,
                                     const DILexicalBlockFile *N,
                                     AsmWriterContext &WriterCtx) {
   Out << "!DILexicalBlockFile(";
   MDFieldPrinter Printer(Out, WriterCtx);

llvm/lib/IR/DIBuilder.cpp

 //===--- DIBuilder.cpp - Debug Information Builder ------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the DIBuilder.
UseDbgAddr("use-dbg-addr",
                cl::init(false), cl::Hidden);
 
 DIBuilder::DIBuilder(Module &m, bool AllowUnresolvedNodes, DICompileUnit *CU)
     : M(m), VMContext(M.getContext()), CUNode(CU), DeclareFn(nullptr),
       ValueFn(nullptr), LabelFn(nullptr), AddrFn(nullptr),
       AllowUnresolvedNodes(AllowUnresolvedNodes) {
   if (CUNode) {
     if (const auto &ETs = CUNode->getEnumTypes())
-      AllEnumTypes.assign(ETs.begin(), ETs.end());
+      ModuleEnumTypes.assign(ETs.begin(), ETs.end());
     if (const auto &RTs = CUNode->getRetainedTypes())
       AllRetainTypes.assign(RTs.begin(), RTs.end());
     if (const auto &GVs = CUNode->getGlobalVariables())
-      AllGVs.assign(GVs.begin(), GVs.end());
+      ModuleGVs.assign(GVs.begin(), GVs.end());
     if (const auto &IMs = CUNode->getImportedEntities())
-      AllImportedModules.assign(IMs.begin(), IMs.end());
+      ModuleImports.assign(IMs.begin(), IMs.end());
     if (const auto &MNs = CUNode->getMacros())
       AllMacrosPerParent.insert({nullptr, {MNs.begin(), MNs.end()}});
   }
 }
 
 void DIBuilder::trackIfUnresolved(MDNode *N) {
   if (!N)
     return;

 
 void DIBuilder::finalize() {
   if (!CUNode) {
     assert(!AllowUnresolvedNodes &&
            "creating type nodes without a CU is not supported");
     return;
   }
 
-  if (!AllEnumTypes.empty())
-    CUNode->replaceEnumTypes(MDTuple::get(VMContext, AllEnumTypes));
+  if (!ModuleEnumTypes.empty())
+    CUNode->replaceEnumTypes(MDTuple::get(VMContext, ModuleEnumTypes));
 
   SmallVector<Metadata *, 16> RetainValues;
   // Declarations and definitions of the same type may be retained. Some
   // clients RAUW these pairs, leaving duplicates in the retained types
   // list. Use a set to remove the duplicates while we transform the
   // TrackingVHs back into Values.
   SmallPtrSet<Metadata *, 16> RetainSet;
   for (unsigned I = 0, E = AllRetainTypes.size(); I < E; I++)
     if (RetainSet.insert(AllRetainTypes[I]).second)
       RetainValues.push_back(AllRetainTypes[I]);
 
   if (!RetainValues.empty())
     CUNode->replaceRetainedTypes(MDTuple::get(VMContext, RetainValues));
 
   DISubprogramArray SPs = MDTuple::get(VMContext, AllSubprograms);
   for (auto *SP : SPs)
     finalizeSubprogram(SP);
   for (auto *N : RetainValues)
     if (auto *SP = dyn_cast<DISubprogram>(N))
       finalizeSubprogram(SP);
 
-  if (!AllGVs.empty())
-    CUNode->replaceGlobalVariables(MDTuple::get(VMContext, AllGVs));
+  for (auto Scope : LocalDecls) {
+    auto *LScope = cast<DILocalScope>(Scope.first);
+    assert((isa<DISubprogram>(LScope) || isa<DILexicalBlock>(LScope)) &&
+           "Unexpected local scope!");
+    LScope->replaceLocalDecls(MDTuple::get(
+        VMContext, SmallVector<Metadata *, 16>(Scope.second.begin(),
+                                               Scope.second.end())));
+  }
+
+  if (!ModuleGVs.empty())
+    CUNode->replaceGlobalVariables(MDTuple::get(VMContext, ModuleGVs));
 
-  if (!AllImportedModules.empty())
+  if (!ModuleImports.empty())
     CUNode->replaceImportedEntities(MDTuple::get(
-        VMContext, SmallVector<Metadata *, 16>(AllImportedModules.begin(),
-                                               AllImportedModules.end())));
+        VMContext, SmallVector<Metadata *, 16>(ModuleImports.begin(),
+                                               ModuleImports.end())));
 
   for (const auto &I : AllMacrosPerParent) {
     // DIMacroNode's with nullptr parent are DICompileUnit direct children.
     if (!I.first) {
       CUNode->replaceMacros(MDTuple::get(VMContext, I.second.getArrayRef()));
       continue;
     }
     // Otherwise, it must be a temporary DIMacroFile that need to be resolved.
DICompileUnit *DIBuilder::createCompileUnit(
   trackIfUnresolved(CUNode);
   return CUNode;
 }
 
 static DIImportedEntity *
 createImportedModule(LLVMContext &C, dwarf::Tag Tag, DIScope *Context,
                      Metadata *NS, DIFile *File, unsigned Line, StringRef Name,
                      DINodeArray Elements,
-                     SmallVectorImpl<TrackingMDNodeRef> &AllImportedModules) {
+                     SmallVectorImpl<TrackingMDNodeRef> &ImportedEntities) {
   if (Line)
     assert(File && "Source location has line number but no file");
   unsigned EntitiesCount = C.pImpl->DIImportedEntitys.size();
   auto *M = DIImportedEntity::get(C, Tag, Context, cast_or_null<DINode>(NS),
                                   File, Line, Name, Elements);
   if (EntitiesCount < C.pImpl->DIImportedEntitys.size())
     // A new Imported Entity was just added to the context.
     // Add it to the Imported Modules list.
-    AllImportedModules.emplace_back(M);
+    ImportedEntities.emplace_back(M);
   return M;
 }
 
 DIImportedEntity *DIBuilder::createImportedModule(DIScope *Context,
                                                   DINamespace *NS, DIFile *File,
                                                   unsigned Line,
                                                   DINodeArray Elements) {
   return ::createImportedModule(VMContext, dwarf::DW_TAG_imported_module,
                                 Context, NS, File, Line, StringRef(), Elements,
-                                AllImportedModules);
+                                ModuleImports);
 }
 
 DIImportedEntity *DIBuilder::createImportedModule(DIScope *Context,
                                                   DIImportedEntity *NS,
                                                   DIFile *File, unsigned Line,
                                                   DINodeArray Elements) {
   return ::createImportedModule(VMContext, dwarf::DW_TAG_imported_module,
                                 Context, NS, File, Line, StringRef(), Elements,
-                                AllImportedModules);
+                                ModuleImports);
 }
 
 DIImportedEntity *DIBuilder::createImportedModule(DIScope *Context, DIModule *M,
                                                   DIFile *File, unsigned Line,
                                                   DINodeArray Elements) {
   return ::createImportedModule(VMContext, dwarf::DW_TAG_imported_module,
                                 Context, M, File, Line, StringRef(), Elements,
-                                AllImportedModules);
+                                ModuleImports);
 }
 
 DIImportedEntity *
 DIBuilder::createImportedDeclaration(DIScope *Context, DINode *Decl,
                                      DIFile *File, unsigned Line,
                                      StringRef Name, DINodeArray Elements) {
   // Make sure to use the unique identifier based metadata reference for
   // types that have one.
   return ::createImportedModule(VMContext, dwarf::DW_TAG_imported_declaration,
                                 Context, Decl, File, Line, Name, Elements,
-                                AllImportedModules);
+                                ModuleImports);
 }
 
 DIFile *DIBuilder::createFile(StringRef Filename, StringRef Directory,
                               Optional<DIFile::ChecksumInfo<StringRef>> CS,
                               Optional<StringRef> Source) {
   return DIFile::get(VMContext, Filename, Directory, CS, Source);
 }
 
DICompositeType *DIBuilder::createEnumerationType(
     DIScope *Scope, StringRef Name, DIFile *File, unsigned LineNumber,
     uint64_t SizeInBits, uint32_t AlignInBits, DINodeArray Elements,
     DIType *UnderlyingType, StringRef UniqueIdentifier, bool IsScoped) {
   auto *CTy = DICompositeType::get(
       VMContext, dwarf::DW_TAG_enumeration_type, Name, File, LineNumber,
       getNonCompileUnitScope(Scope), UnderlyingType, SizeInBits, AlignInBits, 0,
       IsScoped ? DINode::FlagEnumClass : DINode::FlagZero, Elements, 0, nullptr,
       nullptr, UniqueIdentifier);
-  AllEnumTypes.push_back(CTy);
+  ModuleEnumTypes.push_back(CTy);
   trackIfUnresolved(CTy);
   return CTy;
 }
 
 DIDerivedType *DIBuilder::createSetType(DIScope *Scope, StringRef Name,
                                         DIFile *File, unsigned LineNo,
                                         uint64_t SizeInBits,
                                         uint32_t AlignInBits, DIType *Ty) {
DIGlobalVariableExpression *DIBuilder::createGlobalVariableExpression(
   auto *GV = DIGlobalVariable::getDistinct(
       VMContext, cast_or_null<DIScope>(Context), Name, LinkageName, F,
       LineNumber, Ty, IsLocalToUnit, isDefined,
       cast_or_null<DIDerivedType>(Decl), TemplateParams, AlignInBits,
       Annotations);
   if (!Expr)
     Expr = createExpression();
   auto *N = DIGlobalVariableExpression::get(VMContext, GV, Expr);
-  AllGVs.push_back(N);
+  ModuleGVs.push_back(N);
   return N;
 }
 
 DIGlobalVariable *DIBuilder::createTempGlobalVariableFwdDecl(
     DIScope *Context, StringRef Name, StringRef LinkageName, DIFile *F,
     unsigned LineNumber, DIType *Ty, bool IsLocalToUnit, MDNode *Decl,
     MDTuple *TemplateParams, uint32_t AlignInBits) {
   checkGlobalVariableScope(Context);
DISubprogram *DIBuilder::createFunction(
     DITemplateParameterArray TParams, DISubprogram *Decl,
     DITypeArray ThrownTypes, DINodeArray Annotations,
     StringRef TargetFuncName) {
   bool IsDefinition = SPFlags & DISubprogram::SPFlagDefinition;
   auto *Node = getSubprogram(
       /*IsDistinct=*/IsDefinition, VMContext, getNonCompileUnitScope(Context),
       Name, LinkageName, File, LineNo, Ty, ScopeLine, nullptr, 0, 0, Flags,
       SPFlags, IsDefinition ? CUNode : nullptr, TParams, Decl,
-      MDTuple::getTemporary(VMContext, None).release(), ThrownTypes,
+      MDTuple::getTemporary(VMContext, None).release(), nullptr, ThrownTypes,
       Annotations, TargetFuncName);
 
   if (IsDefinition)
     AllSubprograms.push_back(Node);
   trackIfUnresolved(Node);
   return Node;
 }
 
 DISubprogram *DIBuilder::createTempFunctionFwdDecl(
     DIScope *Context, StringRef Name, StringRef LinkageName, DIFile *File,
     unsigned LineNo, DISubroutineType *Ty, unsigned ScopeLine,
     DINode::DIFlags Flags, DISubprogram::DISPFlags SPFlags,
     DITemplateParameterArray TParams, DISubprogram *Decl,
     DITypeArray ThrownTypes) {
   bool IsDefinition = SPFlags & DISubprogram::SPFlagDefinition;
   return DISubprogram::getTemporary(VMContext, getNonCompileUnitScope(Context),
                                     Name, LinkageName, File, LineNo, Ty,
                                     ScopeLine, nullptr, 0, 0, Flags, SPFlags,
                                     IsDefinition ? CUNode : nullptr, TParams,
-                                    Decl, nullptr, ThrownTypes)
+                                    Decl, nullptr, nullptr, ThrownTypes)
       .release();
 }
 
 DISubprogram *DIBuilder::createMethod(
     DIScope *Context, StringRef Name, StringRef LinkageName, DIFile *F,
     unsigned LineNo, DISubroutineType *Ty, unsigned VIndex, int ThisAdjustment,
     DIType *VTableHolder, DINode::DIFlags Flags,
     DISubprogram::DISPFlags SPFlags, DITemplateParameterArray TParams,
     DITypeArray ThrownTypes) {
   assert(getNonCompileUnitScope(Context) &&
          "Methods should have both a Context and a context that isn't "
          "the compile unit.");
   // FIXME: Do we want to use different scope/lines?
   bool IsDefinition = SPFlags & DISubprogram::SPFlagDefinition;
   auto *SP = getSubprogram(
       /*IsDistinct=*/IsDefinition, VMContext, cast<DIScope>(Context), Name,
       LinkageName, F, LineNo, Ty, LineNo, VTableHolder, VIndex, ThisAdjustment,
       Flags, SPFlags, IsDefinition ? CUNode : nullptr, TParams, nullptr,
-      nullptr, ThrownTypes);
+      nullptr, nullptr, ThrownTypes);
 
   if (IsDefinition)
     AllSubprograms.push_back(SP);
   trackIfUnresolved(SP);
   return SP;
 }
 
 DICommonBlock *DIBuilder::createCommonBlock(DIScope *Scope,
DILexicalBlockFile *DIBuilder::createLexicalBlockFile(DIScope *Scope,
   return DILexicalBlockFile::get(VMContext, Scope, File, Discriminator);
 }
 
 DILexicalBlock *DIBuilder::createLexicalBlock(DIScope *Scope, DIFile *File,
                                               unsigned Line, unsigned Col) {
   // Make these distinct, to avoid merging two lexical blocks on the same
   // file/line/column.
   return DILexicalBlock::getDistinct(VMContext, getNonCompileUnitScope(Scope),
-                                     File, Line, Col);
+                                     File, Line, Col, nullptr);
 }
 
 Instruction *DIBuilder::insertDeclare(Value *Storage, DILocalVariable *VarInfo,
                                       DIExpression *Expr, const DILocation *DL,
                                       Instruction *InsertBefore) {
   return insertDeclare(Storage, VarInfo, Expr, DL, InsertBefore->getParent(),
                        InsertBefore);
 }

llvm/lib/IR/DebugInfoMetadata.cpp

 }
 
 DILocalScope *DILocalScope::getNonLexicalBlockFileScope() const {
   if (auto *File = dyn_cast<DILexicalBlockFile>(this))
     return File->getScope()->getNonLexicalBlockFileScope();
   return const_cast<DILocalScope *>(this);
 }
 
+MDNodeArray DILocalScope::getLocalDecls() const {
+  if (auto *SP = dyn_cast<DISubprogram>(this))
+    return SP->getLocalDecls();
+  if (auto *LB = dyn_cast<DILexicalBlock>(this))
+    return LB->getLocalDecls();
+  return nullptr;
+}
+
+void DILocalScope::replaceLocalDecls(MDNodeArray N) {
+  if (auto *SP = dyn_cast<DISubprogram>(this))
+    SP->replaceLocalDecls(N);
+  else if (auto *LB = dyn_cast<DILexicalBlock>(this))
+    LB->replaceLocalDecls(N);
+  else
+    llvm_unreachable(
+        "replaceLocalDecls() for this node is not yet implemented.");
+}
+
 DISubprogram::DISPFlags DISubprogram::getFlag(StringRef Flag) {
   return StringSwitch<DISPFlags>(Flag)
 #define HANDLE_DISP_FLAG(ID, NAME) .Case("DISPFlag" #NAME, SPFlag##NAME)
 #include "llvm/IR/DebugInfoFlags.def"
       .Default(SPFlagZero);
 }
 
 StringRef DISubprogram::getFlagString(DISPFlags Flag) {

 }
 
 DISubprogram *DISubprogram::getImpl(
     LLVMContext &Context, Metadata *Scope, MDString *Name,
     MDString *LinkageName, Metadata *File, unsigned Line, Metadata *Type,
     unsigned ScopeLine, Metadata *ContainingType, unsigned VirtualIndex,
     int ThisAdjustment, DIFlags Flags, DISPFlags SPFlags, Metadata *Unit,
     Metadata *TemplateParams, Metadata *Declaration, Metadata *RetainedNodes,
-    Metadata *ThrownTypes, Metadata *Annotations, MDString *TargetFuncName,
-    StorageType Storage, bool ShouldCreate) {
+    Metadata *LocalDecls, Metadata *ThrownTypes, Metadata *Annotations,
+    MDString *TargetFuncName, StorageType Storage, bool ShouldCreate) {
   assert(isCanonical(Name) && "Expected canonical MDString");
   assert(isCanonical(LinkageName) && "Expected canonical MDString");
   assert(isCanonical(TargetFuncName) && "Expected canonical MDString");
-  DEFINE_GETIMPL_LOOKUP(DISubprogram,
-                        (Scope, Name, LinkageName, File, Line, Type, ScopeLine,
-                         ContainingType, VirtualIndex, ThisAdjustment, Flags,
-                         SPFlags, Unit, TemplateParams, Declaration,
-                         RetainedNodes, ThrownTypes, Annotations,
-                         TargetFuncName));
-  SmallVector<Metadata *, 13> Ops = {
-      File,           Scope,          Name,        LinkageName,
-      Type,           Unit,           Declaration, RetainedNodes,
-      ContainingType, TemplateParams, ThrownTypes, Annotations,
-      TargetFuncName};
-  if (!TargetFuncName) {
-    Ops.pop_back();
-    if (!Annotations) {
-      Ops.pop_back();
-      if (!ThrownTypes) {
-        Ops.pop_back();
-        if (!TemplateParams) {
-          Ops.pop_back();
-          if (!ContainingType)
-            Ops.pop_back();
-        }
-      }
-    }
-  }
+  DEFINE_GETIMPL_LOOKUP(
+      DISubprogram, (Scope, Name, LinkageName, File, Line, Type, ScopeLine,
+                     SPFlags, Unit, TemplateParams, Declaration, RetainedNodes,
+                     LocalDecls, ThrownTypes, Annotations, TargetFuncName));
+  SmallVector<Metadata *, 14> Ops = {
+      File,        Scope,       Name,           LinkageName,    Type,
+      Unit,        Declaration, RetainedNodes,  ContainingType, TemplateParams,
+      ThrownTypes, Annotations, TargetFuncName, LocalDecls};
   DEFINE_GETIMPL_STORE_N(
       DISubprogram,
       (Line, ScopeLine, VirtualIndex, ThisAdjustment, Flags, SPFlags), Ops,
       Ops.size());
 }
 
 bool DISubprogram::describes(const Function *F) const {
   assert(F && "Invalid function");
   return F->getSubprogram() == this;
 }
 DILexicalBlockBase::DILexicalBlockBase(LLVMContext &C, unsigned ID,
                                        StorageType Storage,
                                        ArrayRef<Metadata *> Ops)
     : DILocalScope(C, ID, Storage, dwarf::DW_TAG_lexical_block, Ops) {}
 
 DILexicalBlock *DILexicalBlock::getImpl(LLVMContext &Context, Metadata *Scope,
                                         Metadata *File, unsigned Line,
-                                        unsigned Column, StorageType Storage,
+                                        unsigned Column, Metadata *LocalDecls,
+                                        StorageType Storage,
                                         bool ShouldCreate) {
   // Fixup column.
   adjustColumn(Column);
 
   assert(Scope && "Expected scope");
-  DEFINE_GETIMPL_LOOKUP(DILexicalBlock, (Scope, File, Line, Column));
-  Metadata *Ops[] = {File, Scope};
-  DEFINE_GETIMPL_STORE(DILexicalBlock, (Line, Column), Ops);
+  DEFINE_GETIMPL_LOOKUP(DILexicalBlock,
+                        (Scope, File, Line, Column, LocalDecls));
+  SmallVector<Metadata *, 3> Ops = {File, Scope, LocalDecls};
+  DEFINE_GETIMPL_STORE_N(DILexicalBlock, (Line, Column), Ops, Ops.size());
 }
 
 DILexicalBlockFile *DILexicalBlockFile::getImpl(LLVMContext &Context,
                                                 Metadata *Scope, Metadata *File,
                                                 unsigned Discriminator,
                                                 StorageType Storage,
                                                 bool ShouldCreate) {
   assert(Scope && "Expected scope");

llvm/lib/IR/LLVMContextImpl.h

template <> struct MDNodeKeyImpl<DISubprogram> {
   unsigned VirtualIndex;
   int ThisAdjustment;
   unsigned Flags;
   unsigned SPFlags;
   Metadata *Unit;
   Metadata *TemplateParams;
   Metadata *Declaration;
   Metadata *RetainedNodes;
+  Metadata *LocalDecls;
   Metadata *ThrownTypes;
   Metadata *Annotations;
   MDString *TargetFuncName;
 
   MDNodeKeyImpl(Metadata *Scope, MDString *Name, MDString *LinkageName,
                 Metadata *File, unsigned Line, Metadata *Type,
                 unsigned ScopeLine, Metadata *ContainingType,
                 unsigned VirtualIndex, int ThisAdjustment, unsigned Flags,
                 unsigned SPFlags, Metadata *Unit, Metadata *TemplateParams,
                 Metadata *Declaration, Metadata *RetainedNodes,
-                Metadata *ThrownTypes, Metadata *Annotations,
-                MDString *TargetFuncName)
+                Metadata *LocalDecls, Metadata *ThrownTypes,
+                Metadata *Annotations, MDString *TargetFuncName)
       : Scope(Scope), Name(Name), LinkageName(LinkageName), File(File),
         Line(Line), Type(Type), ScopeLine(ScopeLine),
         ContainingType(ContainingType), VirtualIndex(VirtualIndex),
         ThisAdjustment(ThisAdjustment), Flags(Flags), SPFlags(SPFlags),
         Unit(Unit), TemplateParams(TemplateParams), Declaration(Declaration),
-        RetainedNodes(RetainedNodes), ThrownTypes(ThrownTypes),
-        Annotations(Annotations), TargetFuncName(TargetFuncName) {}
+        RetainedNodes(RetainedNodes), LocalDecls(LocalDecls),
+        ThrownTypes(ThrownTypes), Annotations(Annotations),
+        TargetFuncName(TargetFuncName) {}
   MDNodeKeyImpl(const DISubprogram *N)
       : Scope(N->getRawScope()), Name(N->getRawName()),
         LinkageName(N->getRawLinkageName()), File(N->getRawFile()),
         Line(N->getLine()), Type(N->getRawType()), ScopeLine(N->getScopeLine()),
         ContainingType(N->getRawContainingType()),
         VirtualIndex(N->getVirtualIndex()),
         ThisAdjustment(N->getThisAdjustment()), Flags(N->getFlags()),
         SPFlags(N->getSPFlags()), Unit(N->getRawUnit()),
         TemplateParams(N->getRawTemplateParams()),
         Declaration(N->getRawDeclaration()),
         RetainedNodes(N->getRawRetainedNodes()),
-        ThrownTypes(N->getRawThrownTypes()),
+        LocalDecls(N->getRawLocalDecls()), ThrownTypes(N->getRawThrownTypes()),
         Annotations(N->getRawAnnotations()),
         TargetFuncName(N->getRawTargetFuncName()) {}
 
   bool isKeyOf(const DISubprogram *RHS) const {
     return Scope == RHS->getRawScope() && Name == RHS->getRawName() &&
            LinkageName == RHS->getRawLinkageName() &&
            File == RHS->getRawFile() && Line == RHS->getLine() &&
            Type == RHS->getRawType() && ScopeLine == RHS->getScopeLine() &&
            ContainingType == RHS->getRawContainingType() &&
            VirtualIndex == RHS->getVirtualIndex() &&
            ThisAdjustment == RHS->getThisAdjustment() &&
            Flags == RHS->getFlags() && SPFlags == RHS->getSPFlags() &&
            Unit == RHS->getUnit() &&
            TemplateParams == RHS->getRawTemplateParams() &&
            Declaration == RHS->getRawDeclaration() &&
            RetainedNodes == RHS->getRawRetainedNodes() &&
+           LocalDecls == RHS->getRawLocalDecls() &&
            ThrownTypes == RHS->getRawThrownTypes() &&
            Annotations == RHS->getRawAnnotations() &&
            TargetFuncName == RHS->getRawTargetFuncName();
   }
 
   bool isDefinition() const { return SPFlags & DISubprogram::SPFlagDefinition; }
 
   unsigned getHashValue() const {
template <> struct MDNodeSubsetEqualImpl<DISubprogram> {
   }
 };
 
 template <> struct MDNodeKeyImpl<DILexicalBlock> {
   Metadata *Scope;
   Metadata *File;
   unsigned Line;
   unsigned Column;
+  Metadata *LocalDecls;
 
-  MDNodeKeyImpl(Metadata *Scope, Metadata *File, unsigned Line, unsigned Column)
-      : Scope(Scope), File(File), Line(Line), Column(Column) {}
+  MDNodeKeyImpl(Metadata *Scope, Metadata *File, unsigned Line, unsigned Column,
+                Metadata *LocalDecls)
+      : Scope(Scope), File(File), Line(Line), Column(Column),
+        LocalDecls(LocalDecls) {}
   MDNodeKeyImpl(const DILexicalBlock *N)
       : Scope(N->getRawScope()), File(N->getRawFile()), Line(N->getLine()),
-        Column(N->getColumn()) {}
+        Column(N->getColumn()), LocalDecls(N->getRawLocalDecls()) {}
 
   bool isKeyOf(const DILexicalBlock *RHS) const {
     return Scope == RHS->getRawScope() && File == RHS->getRawFile() &&
-           Line == RHS->getLine() && Column == RHS->getColumn();
+           Line == RHS->getLine() && Column == RHS->getColumn() &&
+           LocalDecls == RHS->getRawLocalDecls();
   }
 
   unsigned getHashValue() const {
     return hash_combine(Scope, File, Line, Column);
   }
 };
 
 template <> struct MDNodeKeyImpl<DILexicalBlockFile> {

llvm/test/Assembler/disubprogram-localdecls.ll

+; RUN: llvm-as < %s | llvm-dis | llvm-as | llvm-dis | FileCheck %s
+
+; Test localDecls field of DISubprogram and DILexicalBlock.
+
+; CHECK: = !DIGlobalVariableExpression
+; CHECK: = !DIGlobalVariableExpression
+; CHECK: [[AGVE:![0-9]+]] = !DIGlobalVariableExpression(var: [[AGV:![0-9]+]]
+; CHECK: [[AGV]] = distinct !DIGlobalVariable(name: "A", scope: [[SP:![0-9]+]]
+; CHECK: [[SP]] = distinct !DISubprogram(name: "foo"
+; CHECK-SAME:                            localDecls: [[SPDECLS:![0-9]+]])
+; CHECK: [[SPDECLS]] = !{[[AGVE]], [[NIE:![0-9]+]], [[SSTRUCT:![0-9]+]], [[EENUM:![0-9]+]], [[CTYPEDEF:![0-9]+]]}
+; CHECK: [[NIE]] = !DIImportedEntity(tag: DW_TAG_imported_declaration, scope: [[SP]]
+; CHECK: [[SSTRUCT]] = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "S", scope: [[SP]]
+; CHECK: [[EENUM]] = !DICompositeType(tag: DW_TAG_enumeration_type, name: "E", scope: [[SP]]
+; CHECK: [[CTYPEDEF]] = !DIDerivedType(tag: DW_TAG_typedef, name: "C", scope: [[SP]]
+; CHECK: [[BGVE:![0-9]+]] = !DIGlobalVariableExpression(var: [[BGV:![0-9]+]]
+; CHECK: [[BGV]] = distinct !DIGlobalVariable(name: "B", scope: [[LB:![0-9]+]]
+; CHECK: [[LB]] = distinct !DILexicalBlock(scope: [[SP]],
+; CHECK-SAME:                              localDecls: [[LBDECLS:![0-9]+]])
+; CHECK: [[LBDECLS]] = !{[[BGVE]], [[MIE:![0-9]+]], [[ITYPEDEF:![0-9]+]], [[TSTRUCT:![0-9]+]], [[UENUM:![0-9]+]]}
+; CHECK: [[MIE]] = !DIImportedEntity(tag: DW_TAG_imported_declaration, scope: [[LB]]
+; CHECK: [[ITYPEDEF]] = !DIDerivedType(tag: DW_TAG_typedef, name: "I", scope: [[LB]]
+; CHECK: [[TSTRUCT]] = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "T", scope: [[LB]]
+; CHECK: [[UENUM]] = !DICompositeType(tag: DW_TAG_enumeration_type, name: "U", scope: [[LB]]
+
+%struct.S = type { i8 }
+%struct.T = type { i8 }
+
+@_ZN1n1NE = dso_local global i32 0, align 4, !dbg !0
+@_ZN1m1ME = dso_local global i32 0, align 4, !dbg !5
+@_ZZ3foovE1A = internal global i32 0, align 4, !dbg !8
+@_ZZ3foovE1B = internal global i32 0, align 4, !dbg !25
+
+define dso_local void @_Z3foov() !dbg !10 {
+entry:
+  ret void
+}
+
+!llvm.dbg.cu = !{!13}
+!llvm.module.flags = !{!35, !36}
+
+!0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
+!1 = distinct !DIGlobalVariable(name: "N", linkageName: "_ZN1n1NE", scope: !2, file: !3, line: 2, type: !4, isLocal: false, isDefinition: true)
+!2 = !DINamespace(name: "n", scope: null)
+!3 = !DIFile(filename: "test.cpp", directory: "/home/kbessonova/workspace/llvm/llvm-project", checksumkind: CSK_MD5, checksum: "ab4cbaa2f798b8d5f15f2d3b1d5d396b")
+!4 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!5 = !DIGlobalVariableExpression(var: !6, expr: !DIExpression())
+!6 = distinct !DIGlobalVariable(name: "M", linkageName: "_ZN1m1ME", scope: !7, file: !3, line: 6, type: !4, isLocal: false, isDefinition: true)
+!7 = !DINamespace(name: "m", scope: null)
+!8 = !DIGlobalVariableExpression(var: !9, expr: !DIExpression())
+!9 = distinct !DIGlobalVariable(name: "A", scope: !10, file: !3, line: 10, type: !4, isLocal: true, isDefinition: true)
+!10 = distinct !DISubprogram(name: "foo", linkageName: "_Z3foov", scope: !3, file: !3, line: 9, type: !11, scopeLine: 9, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition, unit: !13, retainedNodes: !15, localDecls: !16)
+!11 = !DISubroutineType(types: !12)
+!12 = !{null}
+!13 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus_14, file: !3, producer: "clang version 15.0.0", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, globals: !14, splitDebugInlining: false, nameTableKind: None)
+!14 = !{!0, !5}
+!15 = !{}
+!16 = !{!8, !17, !18, !19, !23}
+!17 = !DIImportedEntity(tag: DW_TAG_imported_declaration, scope: !10, entity: !1, file: !3, line: 14)
+!18 = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "S", scope: !10, file: !3, line: 12, size: 8, flags: DIFlagTypePassByValue, elements: !15)
+!19 = !DICompositeType(tag: DW_TAG_enumeration_type, name: "E", scope: !10, file: !3, line: 13, baseType: !20, size: 32, elements: !21)
+!20 = !DIBasicType(name: "unsigned int", size: 32, encoding: DW_ATE_unsigned)
+!21 = !{!22}
+!22 = !DIEnumerator(name: "e", value: 0, isUnsigned: true)
+!23 = !DIDerivedType(tag: DW_TAG_typedef, name: "C", scope: !10, file: !3, line: 11, baseType: !24)
+!24 = !DIBasicType(name: "char", size: 8, encoding: DW_ATE_signed_char)
+!25 = !DIGlobalVariableExpression(var: !26, expr: !DIExpression())
+!26 = distinct !DIGlobalVariable(name: "B", scope: !27, file: !3, line: 21, type: !4, isLocal: true, isDefinition: true)
+!27 = distinct !DILexicalBlock(scope: !10, file: !3, line: 20, column: 3, localDecls: !28)
+!28 = !{!25, !29, !30, !31, !32}
+!29 = !DIImportedEntity(tag: DW_TAG_imported_declaration, scope: !27, entity: !6, file: !3, line: 25)
+!30 = !DIDerivedType(tag: DW_TAG_typedef, name: "I", scope: !27, file: !3, line: 22, baseType: !4)
+!31 = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "T", scope: !27, file: !3, line: 23, size: 8, flags: DIFlagTypePassByValue, elements: !15)
+!32 = !DICompositeType(tag: DW_TAG_enumeration_type, name: "U", scope: !27, file: !3, line: 24, baseType: !20, size: 32, elements: !33)
+!33 = !{!34}
+!34 = !DIEnumerator(name: "u", value: 0, isUnsigned: true)
+!35 = !{i32 7, !"Dwarf Version", i32 5}
+!36 = !{i32 2, !"Debug Info Version", i32 3}

llvm/unittests/IR/MetadataTest.cpp

 //===- unittests/IR/MetadataTest.cpp - Metadata unit tests ----------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/IR/Metadata.h"
TEST_F(DISubprogramTest, get) {
   unsigned Virtuality = 2;
   unsigned VirtualIndex = 5;
   int ThisAdjustment = -3;
   DINode::DIFlags Flags = static_cast<DINode::DIFlags>(6);
   bool IsOptimized = false;
   MDTuple *TemplateParams = getTuple();
   DISubprogram *Declaration = getSubprogram();
   MDTuple *RetainedNodes = getTuple();
+  MDTuple *LocalDecls = getTuple();
   MDTuple *ThrownTypes = getTuple();
   MDTuple *Annotations = getTuple();
   StringRef TargetFuncName = "target";
   DICompileUnit *Unit = getUnit();
   DISubprogram::DISPFlags SPFlags =
       static_cast<DISubprogram::DISPFlags>(Virtuality);
   assert(!IsLocalToUnit && IsDefinition && !IsOptimized &&
          "bools and SPFlags have to match");
   SPFlags |= DISubprogram::SPFlagDefinition;
 
   auto *N = DISubprogram::get(
       Context, Scope, Name, LinkageName, File, Line, Type, ScopeLine,
       ContainingType, VirtualIndex, ThisAdjustment, Flags, SPFlags, Unit,
-      TemplateParams, Declaration, RetainedNodes, ThrownTypes, Annotations,
-      TargetFuncName);
+      TemplateParams, Declaration, RetainedNodes, LocalDecls, ThrownTypes,
+      Annotations, TargetFuncName);
 
   EXPECT_EQ(dwarf::DW_TAG_subprogram, N->getTag());
   EXPECT_EQ(Scope, N->getScope());
   EXPECT_EQ(Name, N->getName());
   EXPECT_EQ(LinkageName, N->getLinkageName());
   EXPECT_EQ(File, N->getFile());
   EXPECT_EQ(Line, N->getLine());
   EXPECT_EQ(Type, N->getType());
TEST_F(DISubprogramTest, get) {
   EXPECT_EQ(RetainedNodes, N->getRetainedNodes().get());
   EXPECT_EQ(ThrownTypes, N->getThrownTypes().get());
   EXPECT_EQ(Annotations, N->getAnnotations().get());
   EXPECT_EQ(TargetFuncName, N->getTargetFuncName());
   EXPECT_EQ(N, DISubprogram::get(Context, Scope, Name, LinkageName, File, Line,
                                  Type, ScopeLine, ContainingType, VirtualIndex,
                                  ThisAdjustment, Flags, SPFlags, Unit,
                                  TemplateParams, Declaration, RetainedNodes,
-                                 ThrownTypes, Annotations, TargetFuncName));
+                                 LocalDecls, ThrownTypes, Annotations,
+                                 TargetFuncName));
 
   EXPECT_NE(N, DISubprogram::get(Context, getCompositeType(), Name, LinkageName,
                                  File, Line, Type, ScopeLine, ContainingType,
                                  VirtualIndex, ThisAdjustment, Flags, SPFlags,
                                  Unit, TemplateParams, Declaration,
-                                 RetainedNodes, ThrownTypes, Annotations,
-                                 TargetFuncName));
+                                 RetainedNodes, LocalDecls, ThrownTypes,
+                                 Annotations, TargetFuncName));
   EXPECT_NE(N, DISubprogram::get(Context, Scope, "other", LinkageName, File,
                                  Line, Type, ScopeLine, ContainingType,
                                  VirtualIndex, ThisAdjustment, Flags, SPFlags,
                                  Unit, TemplateParams, Declaration,
-                                 RetainedNodes, ThrownTypes, Annotations,
-                                 TargetFuncName));
+                                 RetainedNodes, LocalDecls, ThrownTypes,
+                                 Annotations, TargetFuncName));
   EXPECT_NE(N, DISubprogram::get(Context, Scope, Name, "other", File, Line,
                                  Type, ScopeLine, ContainingType, VirtualIndex,
                                  ThisAdjustment, Flags, SPFlags, Unit,
                                  TemplateParams, Declaration, RetainedNodes,
-                                 ThrownTypes, Annotations, TargetFuncName));
+                                 LocalDecls, ThrownTypes, Annotations,
+                                 TargetFuncName));
   EXPECT_NE(N, DISubprogram::get(Context, Scope, Name, LinkageName, getFile(),
                                  Line, Type, ScopeLine, ContainingType,
                                  VirtualIndex, ThisAdjustment, Flags, SPFlags,
                                  Unit, TemplateParams, Declaration,
-                                 RetainedNodes, ThrownTypes, Annotations,
-                                 TargetFuncName));
+                                 RetainedNodes, LocalDecls, ThrownTypes,
+                                 Annotations, TargetFuncName));
   EXPECT_NE(N, DISubprogram::get(Context, Scope, Name, LinkageName, File,
                                  Line + 1, Type, ScopeLine, ContainingType,
                                  VirtualIndex, ThisAdjustment, Flags, SPFlags,
                                  Unit, TemplateParams, Declaration,
-                                 RetainedNodes, ThrownTypes, Annotations,
-                                 TargetFuncName));
+                                 RetainedNodes, LocalDecls, ThrownTypes,
+                                 Annotations, TargetFuncName));
   EXPECT_NE(N, DISubprogram::get(Context, Scope, Name, LinkageName, File, Line,
                                  getSubroutineType(), ScopeLine, ContainingType,
                                  VirtualIndex, ThisAdjustment, Flags, SPFlags,
                                  Unit, TemplateParams, Declaration,
-                                 RetainedNodes, ThrownTypes, Annotations,
-                                 TargetFuncName));
+                                 RetainedNodes, LocalDecls, ThrownTypes,
+                                 Annotations, TargetFuncName));
   EXPECT_NE(N, DISubprogram::get(
                    Context, Scope, Name, LinkageName, File, Line, Type,
                    ScopeLine, ContainingType, VirtualIndex, ThisAdjustment,
                    Flags, SPFlags ^ DISubprogram::SPFlagLocalToUnit, Unit,
-                   TemplateParams, Declaration, RetainedNodes, ThrownTypes,
-                   Annotations, TargetFuncName));
+                   TemplateParams, Declaration, RetainedNodes, LocalDecls,
+                   ThrownTypes, Annotations, TargetFuncName));
   EXPECT_NE(N, DISubprogram::get(
                    Context, Scope, Name, LinkageName, File, Line, Type,
                    ScopeLine, ContainingType, VirtualIndex, ThisAdjustment,
                    Flags, SPFlags ^ DISubprogram::SPFlagDefinition, Unit,
-                   TemplateParams, Declaration, RetainedNodes, ThrownTypes,
-                   Annotations, TargetFuncName));
+                   TemplateParams, Declaration, RetainedNodes, LocalDecls,
+                   ThrownTypes, Annotations, TargetFuncName));
   EXPECT_NE(N, DISubprogram::get(Context, Scope, Name, LinkageName, File, Line,
                                  Type, ScopeLine + 1, ContainingType,
                                  VirtualIndex, ThisAdjustment, Flags, SPFlags,
                                  Unit, TemplateParams, Declaration,
-                                 RetainedNodes, ThrownTypes, Annotations,
-                                 TargetFuncName));
+                                 RetainedNodes, LocalDecls, ThrownTypes,
+                                 Annotations, TargetFuncName));
   EXPECT_NE(N, DISubprogram::get(Context, Scope, Name, LinkageName, File, Line,
                                  Type, ScopeLine, getCompositeType(),
                                  VirtualIndex, ThisAdjustment, Flags, SPFlags,
                                  Unit, TemplateParams, Declaration,
-                                 RetainedNodes, ThrownTypes, Annotations,
-                                 TargetFuncName));
+                                 RetainedNodes, LocalDecls, ThrownTypes,
+                                 Annotations, TargetFuncName));
   EXPECT_NE(N, DISubprogram::get(
                    Context, Scope, Name, LinkageName, File, Line, Type,
                    ScopeLine, ContainingType, VirtualIndex, ThisAdjustment,
                    Flags, SPFlags ^ DISubprogram::SPFlagVirtual, Unit,
-                   TemplateParams, Declaration, RetainedNodes, ThrownTypes,
-                   Annotations, TargetFuncName));
+                   TemplateParams, Declaration, RetainedNodes, LocalDecls,
+                   ThrownTypes, Annotations, TargetFuncName));
   EXPECT_NE(N, DISubprogram::get(Context, Scope, Name, LinkageName, File, Line,
                                  Type, ScopeLine, ContainingType,
                                  VirtualIndex + 1, ThisAdjustment, Flags,
                                  SPFlags, Unit, TemplateParams, Declaration,
-                                 RetainedNodes, ThrownTypes, Annotations,
-                                 TargetFuncName));
+                                 RetainedNodes, LocalDecls, ThrownTypes,
+                                 Annotations, TargetFuncName));
   EXPECT_NE(N, DISubprogram::get(
                    Context, Scope, Name, LinkageName, File, Line, Type,
                    ScopeLine, ContainingType, VirtualIndex, ThisAdjustment,
                    Flags, SPFlags ^ DISubprogram::SPFlagOptimized, Unit,
-                   TemplateParams, Declaration, RetainedNodes, ThrownTypes,
-                   Annotations, TargetFuncName));
+                   TemplateParams, Declaration, RetainedNodes, LocalDecls,
+                   ThrownTypes, Annotations, TargetFuncName));
   EXPECT_NE(N, DISubprogram::get(Context, Scope, Name, LinkageName, File, Line,
                                  Type, ScopeLine, ContainingType, VirtualIndex,
                                  ThisAdjustment, Flags, SPFlags, nullptr,
                                  TemplateParams, Declaration, RetainedNodes,
-                                 ThrownTypes, Annotations, TargetFuncName));
+                                 LocalDecls, ThrownTypes, Annotations,
+                                 TargetFuncName));
   EXPECT_NE(N,
             DISubprogram::get(Context, Scope, Name, LinkageName, File, Line,
                               Type, ScopeLine, ContainingType, VirtualIndex,
                               ThisAdjustment, Flags, SPFlags, Unit, getTuple(),
-                              Declaration, RetainedNodes, ThrownTypes,
-                              Annotations, TargetFuncName));
+                              Declaration, RetainedNodes, LocalDecls,
+                              ThrownTypes, Annotations, TargetFuncName));
   EXPECT_NE(N, DISubprogram::get(Context, Scope, Name, LinkageName, File, Line,
                                  Type, ScopeLine, ContainingType, VirtualIndex,
                                  ThisAdjustment, Flags, SPFlags, Unit,
                                  TemplateParams, getSubprogram(), RetainedNodes,
-                                 ThrownTypes, Annotations, TargetFuncName));
+                                 LocalDecls, ThrownTypes, Annotations,
+                                 TargetFuncName));
   EXPECT_NE(N, DISubprogram::get(Context, Scope, Name, LinkageName, File, Line,
                                  Type, ScopeLine, ContainingType, VirtualIndex,
                                  ThisAdjustment, Flags, SPFlags, Unit,
                                  TemplateParams, Declaration, getTuple(),
-                                 ThrownTypes, Annotations, TargetFuncName));
+                                 LocalDecls, ThrownTypes, Annotations,
+                                 TargetFuncName));
   EXPECT_NE(N, DISubprogram::get(Context, Scope, Name, LinkageName, File, Line,
                                  Type, ScopeLine, ContainingType, VirtualIndex,
                                  ThisAdjustment, Flags, SPFlags, Unit,
                                  TemplateParams, Declaration, RetainedNodes,
-                                 getTuple(), Annotations, TargetFuncName));
+                                 getTuple(), ThrownTypes, Annotations,
+                                 TargetFuncName));
   EXPECT_NE(N, DISubprogram::get(Context, Scope, Name, LinkageName, File, Line,
                                  Type, ScopeLine, ContainingType, VirtualIndex,
                                  ThisAdjustment, Flags, SPFlags, Unit,
                                  TemplateParams, Declaration, RetainedNodes,
-                                 ThrownTypes, getTuple(), TargetFuncName));
+                                 LocalDecls, getTuple(), Annotations,
+                                 TargetFuncName));
   EXPECT_NE(N, DISubprogram::get(Context, Scope, Name, LinkageName, File, Line,
                                  Type, ScopeLine, ContainingType, VirtualIndex,
                                  ThisAdjustment, Flags, SPFlags, Unit,
                                  TemplateParams, Declaration, RetainedNodes,
-                                 ThrownTypes, Annotations, "other"));
+                                 LocalDecls, ThrownTypes, getTuple(),
+                                 TargetFuncName));
+  EXPECT_NE(N, DISubprogram::get(Context, Scope, Name, LinkageName, File, Line,
+                                 Type, ScopeLine, ContainingType, VirtualIndex,
+                                 ThisAdjustment, Flags, SPFlags, Unit,
+                                 TemplateParams, Declaration, RetainedNodes,
+                                 LocalDecls, ThrownTypes, Annotations,
+                                 "other"));
 
   TempDISubprogram Temp = N->clone();
   EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
 }
 
 typedef MetadataTest DILexicalBlockTest;
 
 TEST_F(DILexicalBlockTest, get) {