[DebugInfo] Introduce DIConstant metadata for representing named constants

[SouraVX]

Summary

LLVM Debug metadata lacks the capability of representing named constants. Languages such as Fortran has named constants, and code written in Fortran extensively uses Constants, hence there's an inherent need to provide debug information support for Constants to aid Fortran programs debugging.

This patch introduces DIConstant, which at the moment, will serve the needs of Fortran frontends.

Support Notes:

• Only 64 bit Signed Integer supported for now.
• Fortran programs with constants can can be debugged using GDB, correct value of constants getting accessed/printed.
  
  Testing:
  • check-llvm
  • check-llvm-unit (2 unit tests added).

[SouraVX]

Rebase + clang-format

[SouraVX]

llvm/test/Assembler/diconstant.ll

6

You may notice un-related value (168), this could be due to in-correct signed and unsigned interpretation ?

[SouraVX]

Resolved the previous mentioned issue. Ready for review.

[aprantl]

Have you considered instead introducing a bool isConstant field in DILocalVariable? This way we could reuse all the machinery for local/global variables and only need to switch out the TAG in AsmPrinter.

[dblaikie]

In D97311#2588856, @aprantl wrote:

Have you considered instead introducing a bool isConstant field in DILocalVariable? This way we could reuse all the machinery for local/global variables and only need to switch out the TAG in AsmPrinter.

Guess it gets a bit complicated if it has to support non-local constants too.

& could potentially do this via adding a tag field to DILocalVariable (& DIGlobalVariable too), same as for DICompositeTypes - but a bool's probably more compact & covers the use cases for now.

[aprantl]

Guess it gets a bit complicated if it has to support non-local constants too.

We can already represent optimized out global variables with constant values as !DIGlobalVariableExpression(!DIGlobalVariable(...), !DIExpression(DW_OP_constu, ...)).
We would have to also add a bit to DIGlobalVariable, but other than that this seems perfectly feasible?

[dblaikie]

In D97311#2588877, @aprantl wrote:

Guess it gets a bit complicated if it has to support non-local constants too.

We can already represent optimized out global variables with constant values as !DIGlobalVariableExpression(!DIGlobalVariable(...), !DIExpression(DW_OP_constu, ...)).
We would have to also add a bit to DIGlobalVariable, but other than that this seems perfectly feasible?

Yeah, I'm certainly OK with that, if it sounds good to you to do that in those two places.

[SouraVX]

In D97311#2588856, @aprantl wrote:

Have you considered instead introducing a bool isConstant field in DILocalVariable? This way we could reuse all the machinery for local/global variables and only need to switch out the TAG in AsmPrinter.

Thanks for the review, @aprantl!
I considered this approach while hacking/iterating, but as mentioned here:
https://lists.llvm.org/pipermail/llvm-dev/2021-February/148447.html

A naïve attempt to represent it as GlobalVariable(or constant) as

!7 = !DIGlobalVariableExpression(var: !8, expr: !DIExpression(DW_OP_consts, 200))
!8 = distinct !DIGlobalVariable(name: "bar", scope: !2, file: !3, line: 3, type: !9, isLocal: false, isDefinition: true)

This will materialize in DWARF as:
0x0000004a:     DW_TAG_variable
                  DW_AT_name    ("bar")
                  ...
                 DW_AT_location        (DW_OP_addr 0x2007d4, DW_OP_consts +200)  // This is incorrect, pointing to data section

For DW_OP_consts case, it was creating an location entry like GlobalVariable, this wasn't making sense to me(at least), hence I thought of going this route.

Another motivating reason was: (well not an issue rather) introducing isConstant field is a bit non-trivial, considering tightly coupled nature of DILocalVariable and DIGlobalVariable with DIVariable. In my first attempt I introduced this isConstant field in DIVariable so that it can be utilized well for both situation. Obviously it worked - but broke some round tripping test cases.

I'll give it one more shot, if you have any ideas/suggestion WRT approach, please share I'll be happy to reason/iterate/implement.

[aprantl]

Here's an example that seems to work:

source_filename = "globalconst.c"
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.13.0"

!llvm.dbg.cu = !{!2}
!llvm.module.flags = !{!10, !11, !12, !13}

!2 = distinct !DICompileUnit(language: DW_LANG_C99, file: !3, producer: "clang", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !4, globals: !5)
!3 = !DIFile(filename: "globalconst.c", directory: "/")
!4 = !{}
!5 = !{!16}
!7 = distinct !DIGlobalVariable(name: "constant", scope: !2, file: !3, line: 2, type: !8, isLocal: false, isDefinition: true)
!8 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !9, size: 64)
!9 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
!10 = !{i32 2, !"Dwarf Version", i32 4}
!11 = !{i32 2, !"Debug Info Version", i32 3}
!12 = !{i32 1, !"wchar_size", i32 4}
!13 = !{i32 7, !"PIC Level", i32 2}
!16 = !DIGlobalVariableExpression(var: !7, expr: !DIExpression(DW_OP_constu, 1, DW_OP_stack_value))

$ bin/llc -filetype=obj /tmp/globalconst.ll -o - | dwarfdump -
0x0000001e:   DW_TAG_variable
                DW_AT_name	("constant")
                DW_AT_type	(0x0000002a "int*")
                DW_AT_external	(true)
                DW_AT_decl_file	("globalconst.c")
                DW_AT_decl_line	(2)
                DW_AT_const_value	(1)

[SouraVX]

In D97311#2590688, @aprantl wrote:

Here's an example that seems to work:

...

Thanks @aprantl for quick example. Apologies for delayed response, I got occupied with something else.
One question I have is for Signed constants Consider slightly tweaked version of sample provide by you.
I tried representing 10(for demonstration purpose only) as:

!DIGlobalVariableExpression(var: !7, expr: !DIExpression(DW_OP_consts, 10, DW_OP_stack_value))

Compiling this, as you may notice, results in no warning/error, but DW_AT_location or DW_AT_const_value is missing from the DWARF so variable not visible in debugger.

source_filename = "globalconst.c"
target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-apple-macosx10.13.0"

!llvm.dbg.cu = !{!2}
!llvm.module.flags = !{!10, !11, !12, !13}

!2 = distinct !DICompileUnit(language: DW_LANG_C99, file: !3, producer: "clang", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !4, globals: !5)
!3 = !DIFile(filename: "globalconst.c", directory: "/")
!4 = !{}
!5 = !{!16}
!7 = distinct !DIGlobalVariable(name: "constant", scope: !2, file: !3, line: 2, type: !8, isLocal: false, isDefinition: true)
!8 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !9, size: 64)
!9 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
!10 = !{i32 2, !"Dwarf Version", i32 4}
!11 = !{i32 2, !"Debug Info Version", i32 3}
!12 = !{i32 1, !"wchar_size", i32 4}
!13 = !{i32 7, !"PIC Level", i32 2}
!16 = !DIGlobalVariableExpression(var: !7, expr: !DIExpression(DW_OP_consts, 10, DW_OP_stack_value))  !Tweaked slightly, to check for negative constants

$ bin/llc -filetype=obj /tmp/globalconst.ll -o - | dwarfdump -
0x0000001e:   DW_TAG_variable
                DW_AT_name	("constant")
                DW_AT_type	(0x0000002a "int*")
                DW_AT_external	(true)
                DW_AT_decl_file	("globalconst.c")
                DW_AT_decl_line	(2)

[aprantl]

Yeah that's just because

void DwarfCompileUnit::addLocationAttribute()

checks for

if (GlobalExprs.size() == 1 && Expr && Expr->isConstant()) {

and

bool DIExpression::isConstant() const {
  // Recognize DW_OP_constu C DW_OP_stack_value (DW_OP_LLVM_fragment Len Ofs)?.
  if (getNumElements() != 3 && getNumElements() != 6)
    return false;
  if (getElement(0) != dwarf::DW_OP_constu ||
      getElement(2) != dwarf::DW_OP_stack_value)
    return false;
  if (getNumElements() == 6 && getElement(3) != dwarf::DW_OP_LLVM_fragment)
    return false;
  return true;
}

We could probably just make addLocationAttribute() also accept DIExpression::isSignedConstant() and handle that appropriately.

llvm/include/llvm-c/DebugInfo.h

enum {
   LLVMDILexicalBlockMetadataKind,
   LLVMDILexicalBlockFileMetadataKind,
   LLVMDINamespaceMetadataKind,
   LLVMDIModuleMetadataKind,
   LLVMDITemplateTypeParameterMetadataKind,
   LLVMDITemplateValueParameterMetadataKind,
   LLVMDIGlobalVariableMetadataKind,
   LLVMDILocalVariableMetadataKind,
+  LLVMDIConstantMetadataKind,
   LLVMDILabelMetadataKind,
   LLVMDIObjCPropertyMetadataKind,
   LLVMDIImportedEntityMetadataKind,
   LLVMDIMacroMetadataKind,
   LLVMDIMacroFileMetadataKind,
   LLVMDICommonBlockMetadataKind,
   LLVMDIStringTypeMetadataKind,
   LLVMDIGenericSubrangeMetadataKind

llvm/include/llvm/Bitcode/LLVMBitCodes.h

enum MetadataCodes {
   METADATA_GLOBAL_DECL_ATTACHMENT = 36, // [valueid, n x [id, mdnode]]
   METADATA_GLOBAL_VAR_EXPR = 37,        // [distinct, var, expr]
   METADATA_INDEX_OFFSET = 38,           // [offset]
   METADATA_INDEX = 39,                  // [bitpos]
   METADATA_LABEL = 40,                  // [distinct, scope, name, file, line]
   METADATA_STRING_TYPE = 41,            // [distinct, name, size, align,...]
   // Codes 42 and 43 are reserved for support for Fortran array specific debug
   // info.
-  METADATA_COMMON_BLOCK = 44,    // [distinct, scope, name, variable,...]
-  METADATA_GENERIC_SUBRANGE = 45 // [distinct, count, lo, up, stride]
+  METADATA_COMMON_BLOCK = 44,     // [distinct, scope, name, variable,...]
+  METADATA_GENERIC_SUBRANGE = 45, // [distinct, count, lo, up, stride]
+  METADATA_CONSTANT = 46
 };
 
 // The constants block (CONSTANTS_BLOCK_ID) describes emission for each
 // constant and maintains an implicit current type value.
 enum ConstantsCodes {
   CST_CODE_SETTYPE = 1,          // SETTYPE:       [typeid]
   CST_CODE_NULL = 2,             // NULL
   CST_CODE_UNDEF = 3,            // UNDEF

llvm/include/llvm/IR/DIBuilder.h

class DIBuilder {
     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;
+    SmallVector<Metadata *, 4> AllConstants;
 
     /// 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
public:
     /// \param Line       Source line number where the macro file is included.
     /// \param File       File descriptor containing the name of the macro file.
     DIMacroFile *createTempMacroFile(DIMacroFile *Parent, unsigned Line,
                                      DIFile *File);
 
     /// Create a single enumerator value.
     DIEnumerator *createEnumerator(StringRef Name, int64_t Val, bool IsUnsigned = false);
 
+    /// Create a named constant value.
+    /// \param Scope          Scope of the Constant.
+    /// \param Name           Name of the Constant.
+    /// \param File           File descriptor containing the Constant.
+    /// \param Line           Source Line number where the Constant is declared.
+    /// \param Type           Type of the Constant, (Only 64-bit Signed Integer
+    /// supported for now). \param IsLocalToUnit  Local to Current CU. \param
+    /// IsDefinition   Declaration or Definition. \param Val            Value of
+    /// the Constant.
+    DIConstant *createConstant(DIScope *Scope, StringRef Name, DIFile *File,
+                               unsigned Line, DIType *Type, bool IsLocalToUnit,
+                               bool IsDefinition, int64_t Val);
+
     /// Create a DWARF unspecified type.
     DIBasicType *createUnspecifiedType(StringRef Name);
 
     /// Create C++11 nullptr type.
     DIBasicType *createNullPtrType();
 
     /// Create debugging information entry for a basic
     /// type.

llvm/include/llvm/IR/DebugInfoMetadata.h

static bool classof(const Metadata *MD) {
     case DILexicalBlockKind:
     case DILexicalBlockFileKind:
     case DINamespaceKind:
     case DICommonBlockKind:
     case DITemplateTypeParameterKind:
     case DITemplateValueParameterKind:
     case DIGlobalVariableKind:
     case DILocalVariableKind:
+    case DIConstantKind:
     case DILabelKind:
     case DIObjCPropertyKind:
     case DIImportedEntityKind:
     case DIModuleKind:
     case DIGenericSubrangeKind:
       return true;
     }
   }
getImpl(LLVMContext &Context, unsigned SourceLanguage, DIFile *File,
           StringRef Producer, bool IsOptimized, StringRef Flags,
           unsigned RuntimeVersion, StringRef SplitDebugFilename,
           unsigned EmissionKind, DICompositeTypeArray EnumTypes,
           DIScopeArray RetainedTypes,
           DIGlobalVariableExpressionArray GlobalVariables,
           DIImportedEntityArray ImportedEntities, DIMacroNodeArray Macros,
           uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling,
           unsigned NameTableKind, bool RangesBaseAddress, StringRef SysRoot,
-          StringRef SDK, StorageType Storage, bool ShouldCreate = true) {
+          StringRef SDK, DINodeArray Constants, StorageType Storage,
+          bool ShouldCreate = true) {
     return getImpl(
         Context, SourceLanguage, File, getCanonicalMDString(Context, Producer),
         IsOptimized, getCanonicalMDString(Context, Flags), RuntimeVersion,
         getCanonicalMDString(Context, SplitDebugFilename), EmissionKind,
         EnumTypes.get(), RetainedTypes.get(), GlobalVariables.get(),
         ImportedEntities.get(), Macros.get(), DWOId, SplitDebugInlining,
         DebugInfoForProfiling, NameTableKind, RangesBaseAddress,
         getCanonicalMDString(Context, SysRoot),
-        getCanonicalMDString(Context, SDK), Storage, ShouldCreate);
+        getCanonicalMDString(Context, SDK), Constants.get(), Storage,
+        ShouldCreate);
   }
   static DICompileUnit *
   getImpl(LLVMContext &Context, unsigned SourceLanguage, Metadata *File,
           MDString *Producer, bool IsOptimized, MDString *Flags,
           unsigned RuntimeVersion, MDString *SplitDebugFilename,
           unsigned EmissionKind, Metadata *EnumTypes, Metadata *RetainedTypes,
           Metadata *GlobalVariables, Metadata *ImportedEntities,
           Metadata *Macros, uint64_t DWOId, bool SplitDebugInlining,
           bool DebugInfoForProfiling, unsigned NameTableKind,
           bool RangesBaseAddress, MDString *SysRoot, MDString *SDK,
-          StorageType Storage, bool ShouldCreate = true);
+          Metadata *Constants, StorageType Storage, bool ShouldCreate = true);
 
   TempDICompileUnit cloneImpl() const {
     return getTemporary(
         getContext(), getSourceLanguage(), getFile(), getProducer(),
         isOptimized(), getFlags(), getRuntimeVersion(), getSplitDebugFilename(),
         getEmissionKind(), getEnumTypes(), getRetainedTypes(),
         getGlobalVariables(), getImportedEntities(), getMacros(), DWOId,
         getSplitDebugInlining(), getDebugInfoForProfiling(), getNameTableKind(),
-        getRangesBaseAddress(), getSysRoot(), getSDK());
+        getRangesBaseAddress(), getSysRoot(), getSDK(), getConstants());
   }
 
 public:
   static void get() = delete;
   static void getIfExists() = delete;
 
   DEFINE_MDNODE_GET_DISTINCT_TEMPORARY(
       DICompileUnit,
       (unsigned SourceLanguage, DIFile *File, StringRef Producer,
        bool IsOptimized, StringRef Flags, unsigned RuntimeVersion,
        StringRef SplitDebugFilename, DebugEmissionKind EmissionKind,
        DICompositeTypeArray EnumTypes, DIScopeArray RetainedTypes,
        DIGlobalVariableExpressionArray GlobalVariables,
        DIImportedEntityArray ImportedEntities, DIMacroNodeArray Macros,
        uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling,
        DebugNameTableKind NameTableKind, bool RangesBaseAddress,
-       StringRef SysRoot, StringRef SDK),
+       StringRef SysRoot, StringRef SDK, DINodeArray Constants),
       (SourceLanguage, File, Producer, IsOptimized, Flags, RuntimeVersion,
        SplitDebugFilename, EmissionKind, EnumTypes, RetainedTypes,
        GlobalVariables, ImportedEntities, Macros, DWOId, SplitDebugInlining,
        DebugInfoForProfiling, (unsigned)NameTableKind, RangesBaseAddress,
-       SysRoot, SDK))
+       SysRoot, SDK, Constants))
   DEFINE_MDNODE_GET_DISTINCT_TEMPORARY(
       DICompileUnit,
       (unsigned SourceLanguage, Metadata *File, MDString *Producer,
        bool IsOptimized, MDString *Flags, unsigned RuntimeVersion,
        MDString *SplitDebugFilename, unsigned EmissionKind, Metadata *EnumTypes,
        Metadata *RetainedTypes, Metadata *GlobalVariables,
        Metadata *ImportedEntities, Metadata *Macros, uint64_t DWOId,
        bool SplitDebugInlining, bool DebugInfoForProfiling,
        unsigned NameTableKind, bool RangesBaseAddress, MDString *SysRoot,
-       MDString *SDK),
+       MDString *SDK, Metadata *Constants),
       (SourceLanguage, File, Producer, IsOptimized, Flags, RuntimeVersion,
        SplitDebugFilename, EmissionKind, EnumTypes, RetainedTypes,
        GlobalVariables, ImportedEntities, Macros, DWOId, SplitDebugInlining,
-       DebugInfoForProfiling, NameTableKind, RangesBaseAddress, SysRoot, SDK))
+       DebugInfoForProfiling, NameTableKind, RangesBaseAddress, SysRoot, SDK,
+       Constants))
 
   TempDICompileUnit clone() const { return cloneImpl(); }
 
   unsigned getSourceLanguage() const { return SourceLanguage; }
   bool isOptimized() const { return IsOptimized; }
   unsigned getRuntimeVersion() const { return RuntimeVersion; }
   DebugEmissionKind getEmissionKind() const {
     return (DebugEmissionKind)EmissionKind;
DIGlobalVariableExpressionArray getGlobalVariables() const {
     return cast_or_null<MDTuple>(getRawGlobalVariables());
   }
   DIImportedEntityArray getImportedEntities() const {
     return cast_or_null<MDTuple>(getRawImportedEntities());
   }
   DIMacroNodeArray getMacros() const {
     return cast_or_null<MDTuple>(getRawMacros());
   }
+  DINodeArray getConstants() const {
+    return cast_or_null<MDTuple>(getRawConstants());
+  }
   uint64_t getDWOId() const { return DWOId; }
   void setDWOId(uint64_t DwoId) { DWOId = DwoId; }
   bool getSplitDebugInlining() const { return SplitDebugInlining; }
   void setSplitDebugInlining(bool SplitDebugInlining) {
     this->SplitDebugInlining = SplitDebugInlining;
   }
   StringRef getSysRoot() const { return getStringOperand(9); }
   StringRef getSDK() const { return getStringOperand(10); }
 
   MDString *getRawProducer() const { return getOperandAs<MDString>(1); }
   MDString *getRawFlags() const { return getOperandAs<MDString>(2); }
   MDString *getRawSplitDebugFilename() const {
     return getOperandAs<MDString>(3);
   }
   Metadata *getRawEnumTypes() const { return getOperand(4); }
   Metadata *getRawRetainedTypes() const { return getOperand(5); }
   Metadata *getRawGlobalVariables() const { return getOperand(6); }
   Metadata *getRawImportedEntities() const { return getOperand(7); }
   Metadata *getRawMacros() const { return getOperand(8); }
   MDString *getRawSysRoot() const { return getOperandAs<MDString>(9); }
   MDString *getRawSDK() const { return getOperandAs<MDString>(10); }
+  Metadata *getRawConstants() const { return getOperand(11); }
 
   /// Replace arrays.
   ///
   /// If this \a isUniqued() and not \a isResolved(), it will be RAUW'ed and
   /// deleted on a uniquing collision.  In practice, uniquing collisions on \a
   /// DICompileUnit should be fairly rare.
   /// @{
   void replaceEnumTypes(DICompositeTypeArray N) {
     replaceOperandWith(4, N.get());
   }
   void replaceRetainedTypes(DITypeArray N) {
     replaceOperandWith(5, N.get());
   }
   void replaceGlobalVariables(DIGlobalVariableExpressionArray N) {
     replaceOperandWith(6, N.get());
   }
   void replaceImportedEntities(DIImportedEntityArray N) {
     replaceOperandWith(7, N.get());
   }
   void replaceMacros(DIMacroNodeArray N) { replaceOperandWith(8, N.get()); }
+  void replaceConstants(DINodeArray N) { replaceOperandWith(11, N.get()); }
   /// @}
 
   static bool classof(const Metadata *MD) {
     return MD->getMetadataID() == DICompileUnitKind;
   }
 };
 
 /// A scope for locals.
bool isValidLocationForIntrinsic(const DILocation *DL) const {
     return DL && getScope()->getSubprogram() == DL->getScope()->getSubprogram();
   }
 
   static bool classof(const Metadata *MD) {
     return MD->getMetadataID() == DILocalVariableKind;
   }
 };
 
+/// Represents a named constant in the programming language, for example a
+/// parameter construct in Fortran.
+class DIConstant : public DINode {
+  friend class LLVMContextImpl;
+  friend class MDNode;
+
+  unsigned Line;
+  bool IsLocalToUnit;
+  bool IsDefinition;
+  APInt Value;
+
+  DIConstant(LLVMContext &C, StorageType Storage, unsigned Line,
+             bool IsLocalToUnit, bool IsDefinition, const APInt &Value,
+             ArrayRef<Metadata *> Ops)
+      : DINode(C, DIConstantKind, Storage, dwarf::DW_TAG_constant, Ops),
+        Line(Line), IsLocalToUnit(IsLocalToUnit), IsDefinition(IsDefinition),
+        Value(Value) {}
+  ~DIConstant() = default;
+
+  static DIConstant *getImpl(LLVMContext &Context, DIScope *Scope,
+                             StringRef Name, DIFile *File, unsigned Line,
+                             DIType *Type, bool IsLocalToUnit,
+                             bool IsDefinition, const APInt &Value,
+                             StorageType Storage, bool ShouldCreate = true) {
+    return getImpl(Context, Scope, getCanonicalMDString(Context, Name), File,
+                   Line, Type, IsLocalToUnit, IsDefinition, Value, Storage,
+                   ShouldCreate);
+  }
+  static DIConstant *getImpl(LLVMContext &Context, Metadata *Scope,
+                             MDString *Name, Metadata *File, unsigned Line,
+                             Metadata *Type, bool IsLocalToUnit,
+                             bool IsDefinition, const APInt &Value,
+                             StorageType Storage, bool ShouldCreate = true);
+
+  TempDIConstant cloneImpl() const {
+    return getTemporary(getContext(), getScope(), getName(), getFile(),
+                        getLine(), getType(), isLocalToUnit(), isDefinition(),
+                        getValue());
+  }
+
+public:
+  DEFINE_MDNODE_GET(DIConstant,
+                    (DIScope * Scope, StringRef Name, DIFile *File,
+                     unsigned Line, DIType *Type, bool IsLocalToUnit,
+                     bool IsDefinition, APInt Value),
+                    (Scope, Name, File, Line, Type, IsLocalToUnit, IsDefinition,
+                     Value))
+  DEFINE_MDNODE_GET(DIConstant,
+                    (Metadata * Scope, MDString *Name, Metadata *File,
+                     unsigned Line, Metadata *Type, bool IsLocalToUnit,
+                     bool IsDefinition, APInt Value),
+                    (Scope, Name, File, Line, Type, IsLocalToUnit, IsDefinition,
+                     Value))
+
+  TempDIConstant clone() const { return cloneImpl(); }
+
+  unsigned getLine() const { return Line; }
+  bool isLocalToUnit() const { return IsLocalToUnit; }
+  bool isDefinition() const { return IsDefinition; }
+  const APInt &getValue() const { return Value; }
+  DIScope *getScope() const { return cast_or_null<DIScope>(getRawScope()); }
+  StringRef getName() const { return getStringOperand(1); }
+  DIFile *getFile() const { return cast_or_null<DIFile>(getRawFile()); }
+  DIType *getType() const { return cast_or_null<DIType>(getRawType()); }
+
+  Metadata *getRawScope() const { return getOperand(0); }
+  MDString *getRawName() const { return getOperandAs<MDString>(1); }
+  Metadata *getRawFile() const { return getOperand(2); }
+  Metadata *getRawType() const { return getOperand(3); }
+  static bool classof(const Metadata *MD) {
+    return MD->getMetadataID() == DIConstantKind;
+  }
+};
+
 /// Label.
 ///
 class DILabel : public DINode {
   friend class LLVMContextImpl;
   friend class MDNode;
 
   unsigned Line;
 

llvm/include/llvm/IR/Metadata.def

 HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DINamespace)
 HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DIModule)
 HANDLE_SPECIALIZED_MDNODE_BRANCH(DITemplateParameter)
 HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DITemplateTypeParameter)
 HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DITemplateValueParameter)
 HANDLE_SPECIALIZED_MDNODE_BRANCH(DIVariable)
 HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DIGlobalVariable)
 HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DILocalVariable)
+HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DIConstant)
 HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DILabel)
 HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DIObjCProperty)
 HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DIImportedEntity)
 HANDLE_SPECIALIZED_MDNODE_BRANCH(DIMacroNode)
 HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DIMacro)
 HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DIMacroFile)
 HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DICommonBlock)
 HANDLE_SPECIALIZED_MDNODE_LEAF_UNIQUABLE(DIStringType)

llvm/lib/AsmParser/LLParser.cpp

#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED)                                    \
   OPTIONAL(imports, MDField, );                                                \
   OPTIONAL(macros, MDField, );                                                 \
   OPTIONAL(dwoId, MDUnsignedField, );                                          \
   OPTIONAL(splitDebugInlining, MDBoolField, = true);                           \
   OPTIONAL(debugInfoForProfiling, MDBoolField, = false);                       \
   OPTIONAL(nameTableKind, NameTableKindField, );                               \
   OPTIONAL(rangesBaseAddress, MDBoolField, = false);                           \
   OPTIONAL(sysroot, MDStringField, );                                          \
-  OPTIONAL(sdk, MDStringField, );
+  OPTIONAL(sdk, MDStringField, );                                              \
+  OPTIONAL(constants, MDField, );
   PARSE_MD_FIELDS();
 #undef VISIT_MD_FIELDS
 
   Result = DICompileUnit::getDistinct(
       Context, language.Val, file.Val, producer.Val, isOptimized.Val, flags.Val,
       runtimeVersion.Val, splitDebugFilename.Val, emissionKind.Val, enums.Val,
       retainedTypes.Val, globals.Val, imports.Val, macros.Val, dwoId.Val,
       splitDebugInlining.Val, debugInfoForProfiling.Val, nameTableKind.Val,
-      rangesBaseAddress.Val, sysroot.Val, sdk.Val);
+      rangesBaseAddress.Val, sysroot.Val, sdk.Val, constants.Val);
   return false;
 }
 
 /// 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,

 #undef VISIT_MD_FIELDS
 
   Result = GET_OR_DISTINCT(DILocalVariable,
                            (Context, scope.Val, name.Val, file.Val, line.Val,
                             type.Val, arg.Val, flags.Val, align.Val));
   return false;
 }
 
+bool LLParser::parseDIConstant(MDNode *&Result, bool IsDistinct) {
+#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED)                                    \
+  REQUIRED(scope, MDField, (/* AllowNull */ false));                           \
+  OPTIONAL(name, MDStringField, );                                             \
+  OPTIONAL(file, MDField, );                                                   \
+  OPTIONAL(line, LineField, );                                                 \
+  OPTIONAL(type, MDField, );                                                   \
+  OPTIONAL(isLocal, MDBoolField, );                                            \
+  OPTIONAL(isDefinition, MDBoolField, (true));                                 \
+  OPTIONAL(value, MDAPSIntField, );
+  PARSE_MD_FIELDS();
+#undef VISIT_MD_FIELDS
+  APSInt Value(value.Val);
+  if (value.Val.isUnsigned() && value.Val.isSignBitSet())
+    Value = Value.zext(Value.getBitWidth() + 1);
+
+  Result = GET_OR_DISTINCT(DIConstant,
+                           (Context, scope.Val, name.Val, file.Val, line.Val,
+                            type.Val, isLocal.Val, isDefinition.Val, Value));
+  return false;
+}
+
 /// parseDILabel:
 ///   ::= !DILabel(scope: !0, name: "foo", file: !1, line: 7)
 bool LLParser::parseDILabel(MDNode *&Result, bool IsDistinct) {
 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED)                                    \
   REQUIRED(scope, MDField, (/* AllowNull */ false));                           \
   REQUIRED(name, MDStringField, );                                             \
   REQUIRED(file, MDField, );                                                   \
   REQUIRED(line, LineField, );

llvm/lib/Bitcode/Reader/MetadataLoader.cpp

#endif
       case bitc::METADATA_GLOBAL_VAR:
       case bitc::METADATA_LOCAL_VAR:
       case bitc::METADATA_LABEL:
       case bitc::METADATA_EXPRESSION:
       case bitc::METADATA_OBJC_PROPERTY:
       case bitc::METADATA_IMPORTED_ENTITY:
       case bitc::METADATA_GLOBAL_VAR_EXPR:
       case bitc::METADATA_GENERIC_SUBRANGE:
+      case bitc::METADATA_CONSTANT:
         // We don't expect to see any of these, if we see one, give up on
         // lazy-loading and fallback.
         MDStringRef.clear();
         GlobalMetadataBitPosIndex.clear();
         return false;
       }
       break;
     }
MetadataList.assignValue(
             (Context, getMDString(Record[1]), getMDString(Record[2]), Checksum,
              Record.size() > 5 ? Optional<MDString *>(getMDString(Record[5]))
                                : None)),
         NextMetadataNo);
     NextMetadataNo++;
     break;
   }
   case bitc::METADATA_COMPILE_UNIT: {
-    if (Record.size() < 14 || Record.size() > 22)
+    if (Record.size() < 14 || Record.size() > 23)
       return error("Invalid record");
 
     // Ignore Record[0], which indicates whether this compile unit is
     // distinct.  It's always distinct.
     IsDistinct = true;
     auto *CU = DICompileUnit::getDistinct(
         Context, Record[1], getMDOrNull(Record[2]), getMDString(Record[3]),
         Record[4], getMDString(Record[5]), Record[6], getMDString(Record[7]),
         Record[8], getMDOrNull(Record[9]), getMDOrNull(Record[10]),
         getMDOrNull(Record[12]), getMDOrNull(Record[13]),
         Record.size() <= 15 ? nullptr : getMDOrNull(Record[15]),
         Record.size() <= 14 ? 0 : Record[14],
         Record.size() <= 16 ? true : Record[16],
         Record.size() <= 17 ? false : Record[17],
         Record.size() <= 18 ? 0 : Record[18],
         Record.size() <= 19 ? 0 : Record[19],
         Record.size() <= 20 ? nullptr : getMDString(Record[20]),
-        Record.size() <= 21 ? nullptr : getMDString(Record[21]));
+        Record.size() <= 21 ? nullptr : getMDString(Record[21]),
+        Record.size() <= 22 ? nullptr : getMDOrNull(Record[22]));
 
     MetadataList.assignValue(CU, NextMetadataNo);
     NextMetadataNo++;
 
     // Move the Upgrade the list of subprograms.
     if (Metadata *SPs = getMDOrNullWithoutPlaceholders(Record[11]))
       CUSubprograms.push_back({CU, SPs});
     break;
if (!Expr)
       Expr = DIExpression::get(Context, {});
     MetadataList.assignValue(
         GET_OR_DISTINCT(DIGlobalVariableExpression,
                         (Context, getMDOrNull(Record[1]), Expr)),
         NextMetadataNo);
     NextMetadataNo++;
     break;
   }
+  case bitc::METADATA_CONSTANT: {
+    if (Record.size() != 9)
+      return error("Invalid record");
+
+    APInt Value;
+    Value = APInt(64, unrotateSign(Record[8]), true /*Signed*/);
+    LLVM_DEBUG(dbgs() << "Constant Value: "; Value.dump());
+    IsDistinct = Record[0];
+    MetadataList.assignValue(
+        GET_OR_DISTINCT(DIConstant,
+                        (Context, getMDOrNull(Record[1]),
+                         getMDString(Record[2]), getMDOrNull(Record[3]),
+                         Record[4], getMDOrNull(Record[5]), Record[6],
+                         Record[7], Value)),
+        NextMetadataNo);
+    NextMetadataNo++;
+    break;
+  }
   case bitc::METADATA_OBJC_PROPERTY: {
     if (Record.size() != 8)
       return error("Invalid record");
 
     IsDistinct = Record[0];
     MetadataList.assignValue(
         GET_OR_DISTINCT(DIObjCProperty,
                         (Context, getMDString(Record[1]),

llvm/lib/Bitcode/Writer/BitcodeWriter.cpp

private:
   void writeDITemplateValueParameter(const DITemplateValueParameter *N,
                                      SmallVectorImpl<uint64_t> &Record,
                                      unsigned Abbrev);
   void writeDIGlobalVariable(const DIGlobalVariable *N,
                              SmallVectorImpl<uint64_t> &Record,
                              unsigned Abbrev);
   void writeDILocalVariable(const DILocalVariable *N,
                             SmallVectorImpl<uint64_t> &Record, unsigned Abbrev);
+  void writeDIConstant(const DIConstant *N, SmallVectorImpl<uint64_t> &Record,
+                       unsigned Abbrev);
   void writeDILabel(const DILabel *N,
                     SmallVectorImpl<uint64_t> &Record, unsigned Abbrev);
   void writeDIExpression(const DIExpression *N,
                          SmallVectorImpl<uint64_t> &Record, unsigned Abbrev);
   void writeDIGlobalVariableExpression(const DIGlobalVariableExpression *N,
                                        SmallVectorImpl<uint64_t> &Record,
                                        unsigned Abbrev);
   void writeDIObjCProperty(const DIObjCProperty *N,
void ModuleBitcodeWriter::writeDICompileUnit(const DICompileUnit *N,
   Record.push_back(N->getDWOId());
   Record.push_back(VE.getMetadataOrNullID(N->getMacros().get()));
   Record.push_back(N->getSplitDebugInlining());
   Record.push_back(N->getDebugInfoForProfiling());
   Record.push_back((unsigned)N->getNameTableKind());
   Record.push_back(N->getRangesBaseAddress());
   Record.push_back(VE.getMetadataOrNullID(N->getRawSysRoot()));
   Record.push_back(VE.getMetadataOrNullID(N->getRawSDK()));
+  Record.push_back(VE.getMetadataOrNullID(N->getConstants().get()));
 
   Stream.EmitRecord(bitc::METADATA_COMPILE_UNIT, Record, Abbrev);
   Record.clear();
 }
 
 void ModuleBitcodeWriter::writeDISubprogram(const DISubprogram *N,
                                             SmallVectorImpl<uint64_t> &Record,
                                             unsigned Abbrev) {
void ModuleBitcodeWriter::writeDILocalVariable(
   Record.push_back(N->getArg());
   Record.push_back(N->getFlags());
   Record.push_back(N->getAlignInBits());
 
   Stream.EmitRecord(bitc::METADATA_LOCAL_VAR, Record, Abbrev);
   Record.clear();
 }
 
+void ModuleBitcodeWriter::writeDIConstant(const DIConstant *N,
+                                          SmallVectorImpl<uint64_t> &Record,
+                                          unsigned Abbrev) {
+  Record.push_back((uint64_t)N->isDistinct());
+  Record.push_back(VE.getMetadataOrNullID(N->getScope()));
+  Record.push_back(VE.getMetadataOrNullID(N->getRawName()));
+  Record.push_back(VE.getMetadataOrNullID(N->getFile()));
+  Record.push_back(N->getLine());
+  Record.push_back(VE.getMetadataOrNullID(N->getType()));
+  Record.push_back(N->isLocalToUnit());
+  Record.push_back(N->isDefinition());
+  emitWideAPInt(Record, N->getValue());
+
+  Stream.EmitRecord(bitc::METADATA_CONSTANT, Record, Abbrev);
+  Record.clear();
+}
+
 void ModuleBitcodeWriter::writeDILabel(
     const DILabel *N, SmallVectorImpl<uint64_t> &Record,
     unsigned Abbrev) {
   Record.push_back((uint64_t)N->isDistinct());
   Record.push_back(VE.getMetadataOrNullID(N->getScope()));
   Record.push_back(VE.getMetadataOrNullID(N->getRawName()));
   Record.push_back(VE.getMetadataOrNullID(N->getFile()));
   Record.push_back(N->getLine());

llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.h

public:
   /// Get or create global variable DIE.
   DIE *
   getOrCreateGlobalVariableDIE(const DIGlobalVariable *GV,
                                ArrayRef<GlobalExpr> GlobalExprs);
 
   DIE *getOrCreateCommonBlock(const DICommonBlock *CB,
                               ArrayRef<GlobalExpr> GlobalExprs);
 
+  DIE *getOrCreateConstantDIE(const DIConstant *C);
+
   void addLocationAttribute(DIE *ToDIE, const DIGlobalVariable *GV,
                             ArrayRef<GlobalExpr> GlobalExprs);
 
   /// addLabelAddress - Add a dwarf label attribute data and value using
   /// either DW_FORM_addr or DW_FORM_GNU_addr_index.
   void addLabelAddress(DIE &Die, dwarf::Attribute Attribute,
                        const MCSymbol *Label);
 

llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp

unsigned DwarfCompileUnit::getOrCreateSourceID(const DIFile *File) {
   if (!File)
     return Asm->OutStreamer->emitDwarfFileDirective(0, "", "", None, None,
                                                     CUID);
   return Asm->OutStreamer->emitDwarfFileDirective(
       0, File->getDirectory(), File->getFilename(), DD->getMD5AsBytes(File),
       File->getSource(), CUID);
 }
 
+DIE *DwarfCompileUnit::getOrCreateConstantDIE(const DIConstant *C) {
+  // Check for pre-existence.
+  if (DIE *Die = getDIE(C))
+    return Die;
+
+  assert(C);
+
+  auto *CContext = C->getScope();
+  const DIType *CTy = C->getType();
+
+  DIE *ContextDIE = getOrCreateContextDIE(CContext);
+  // Add to map.
+  DIE *ConstantDIE = &createAndAddDIE(C->getTag(), *ContextDIE, C);
+  // Add name and type.
+  addString(*ConstantDIE, dwarf::DW_AT_name, C->getName());
+  addSourceLine(*ConstantDIE, C);
+  addType(*ConstantDIE, CTy);
+  // Add scoping info.
+  if (!C->isLocalToUnit())
+    addFlag(*ConstantDIE, dwarf::DW_AT_external);
+  if (C->isDefinition())
+    addConstantValue(*ConstantDIE, C->getValue(), CTy);
+  else
+    addFlag(*ConstantDIE, dwarf::DW_AT_declaration);
+
+  return ConstantDIE;
+}
+
 DIE *DwarfCompileUnit::getOrCreateGlobalVariableDIE(
     const DIGlobalVariable *GV, ArrayRef<GlobalExpr> GlobalExprs) {
   // Check for pre-existence.
   if (DIE *Die = getDIE(GV))
     return Die;
 
   assert(GV);
 

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

for (DICompileUnit *CUNode : M->debug_compile_units()) {
     // getImportedEntities().empty() test should go below with the rest.
     bool HasNonLocalImportedEntities = llvm::any_of(
         CUNode->getImportedEntities(), [](const DIImportedEntity *IE) {
           return !isa<DILocalScope>(IE->getScope());
         });
 
     if (!HasNonLocalImportedEntities && CUNode->getEnumTypes().empty() &&
         CUNode->getRetainedTypes().empty() &&
-        CUNode->getGlobalVariables().empty() && CUNode->getMacros().empty())
+        CUNode->getGlobalVariables().empty() && CUNode->getMacros().empty() &&
+        CUNode->getConstants().empty())
       continue;
 
     DwarfCompileUnit &CU = getOrCreateDwarfCompileUnit(CUNode);
 
     // Global Variables.
     for (auto *GVE : CUNode->getGlobalVariables()) {
       // Don't bother adding DIGlobalVariableExpressions listed in the CU if we
       // already know about the variable and it isn't adding a constant
for (DICompileUnit *CUNode : M->debug_compile_units()) {
     }
     for (auto *Ty : CUNode->getRetainedTypes()) {
       // The retained types array by design contains pointers to
       // MDNodes rather than DIRefs. Unique them here.
       if (DIType *RT = dyn_cast<DIType>(Ty))
           // There is no point in force-emitting a forward declaration.
           CU.getOrCreateTypeDIE(RT);
     }
+    for (auto *CS : CUNode->getConstants()) {
+      CU.getOrCreateConstantDIE(cast<DIConstant>(CS));
+    }
     // Emit imported_modules last so that the relevant context is already
     // available.
     for (auto *IE : CUNode->getImportedEntities())
       constructAndAddImportedEntityDIE(CU, IE);
   }
 }
 
 void DwarfDebug::finishEntityDefinitions() {

llvm/lib/CodeGen/AsmPrinter/DwarfUnit.h

public:
 
   /// Add block data.
   void addBlock(DIE &Die, dwarf::Attribute Attribute, DIEBlock *Block);
   void addBlock(DIE &Die, dwarf::Attribute Attribute, dwarf::Form Form,
                 DIEBlock *Block);
 
   /// Add location information to specified debug information entry.
   void addSourceLine(DIE &Die, unsigned Line, const DIFile *File);
+  void addSourceLine(DIE &Die, const DIConstant *C);
   void addSourceLine(DIE &Die, const DILocalVariable *V);
   void addSourceLine(DIE &Die, const DIGlobalVariable *G);
   void addSourceLine(DIE &Die, const DISubprogram *SP);
   void addSourceLine(DIE &Die, const DILabel *L);
   void addSourceLine(DIE &Die, const DIType *Ty);
   void addSourceLine(DIE &Die, const DIObjCProperty *Ty);
 
   /// Add constant value entry in variable DIE.

llvm/lib/CodeGen/AsmPrinter/DwarfUnit.cpp

void DwarfUnit::addSourceLine(DIE &Die, unsigned Line, const DIFile *File) {
   if (Line == 0)
     return;
 
   unsigned FileID = getOrCreateSourceID(File);
   addUInt(Die, dwarf::DW_AT_decl_file, None, FileID);
   addUInt(Die, dwarf::DW_AT_decl_line, None, Line);
 }
 
+void DwarfUnit::addSourceLine(DIE &Die, const DIConstant *C) {
+  assert(C);
+
+  addSourceLine(Die, C->getLine(), C->getFile());
+}
+
 void DwarfUnit::addSourceLine(DIE &Die, const DILocalVariable *V) {
   assert(V);
 
   addSourceLine(Die, V->getLine(), V->getFile());
 }
 
 void DwarfUnit::addSourceLine(DIE &Die, const DIGlobalVariable *G) {
   assert(G);

llvm/lib/IR/AsmWriter.cpp

static void writeDICompileUnit(raw_ostream &Out, const DICompileUnit *N,
   Printer.printInt("dwoId", N->getDWOId());
   Printer.printBool("splitDebugInlining", N->getSplitDebugInlining(), true);
   Printer.printBool("debugInfoForProfiling", N->getDebugInfoForProfiling(),
                     false);
   Printer.printNameTableKind("nameTableKind", N->getNameTableKind());
   Printer.printBool("rangesBaseAddress", N->getRangesBaseAddress(), false);
   Printer.printString("sysroot", N->getSysRoot());
   Printer.printString("sdk", N->getSDK());
+  Printer.printMetadata("constants", N->getRawConstants());
   Out << ")";
 }
 
 static void writeDISubprogram(raw_ostream &Out, const DISubprogram *N,
                               TypePrinting *TypePrinter, SlotTracker *Machine,
                               const Module *Context) {
   Out << "!DISubprogram(";
   MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
static void writeDILocalVariable(raw_ostream &Out, const DILocalVariable *N,
   Printer.printMetadata("file", N->getRawFile());
   Printer.printInt("line", N->getLine());
   Printer.printMetadata("type", N->getRawType());
   Printer.printDIFlags("flags", N->getFlags());
   Printer.printInt("align", N->getAlignInBits());
   Out << ")";
 }
 
+static void writeDIConstant(raw_ostream &Out, const DIConstant *N,
+                            TypePrinting *TypePrinter, SlotTracker *Machine,
+                            const Module *Context) {
+  Out << "!DIConstant(";
+  MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
+  Printer.printString("name", N->getName());
+  Printer.printMetadata("scope", N->getRawScope(), /* ShouldSkipNull */ false);
+  Printer.printMetadata("file", N->getRawFile());
+  Printer.printInt("line", N->getLine());
+  Printer.printMetadata("type", N->getRawType());
+  Printer.printBool("isLocal", N->isLocalToUnit());
+  Printer.printBool("isDefinition", N->isDefinition());
+  Printer.printAPInt("value", N->getValue(), false, false);
+  Out << ")";
+}
+
 static void writeDILabel(raw_ostream &Out, const DILabel *N,
                          TypePrinting *TypePrinter,
                          SlotTracker *Machine, const Module *Context) {
   Out << "!DILabel(";
   MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
   Printer.printMetadata("scope", N->getRawScope(), /* ShouldSkipNull */ false);
   Printer.printString("name", N->getName());
   Printer.printMetadata("file", N->getRawFile());

llvm/lib/IR/DIBuilder.cpp

 void DIBuilder::finalize() {
   if (!CUNode) {
     assert(!AllowUnresolvedNodes &&
            "creating type nodes without a CU is not supported");
     return;
   }
 
   CUNode->replaceEnumTypes(MDTuple::get(VMContext, AllEnumTypes));
+  CUNode->replaceConstants(MDTuple::get(VMContext, AllConstants));
 
   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++)
assert(((Lang <= dwarf::DW_LANG_Fortran08 && Lang >= dwarf::DW_LANG_C89) ||
           (Lang <= dwarf::DW_LANG_hi_user && Lang >= dwarf::DW_LANG_lo_user)) &&
          "Invalid Language tag");
 
   assert(!CUNode && "Can only make one compile unit per DIBuilder instance");
   CUNode = DICompileUnit::getDistinct(
       VMContext, Lang, File, Producer, isOptimized, Flags, RunTimeVer,
       SplitName, Kind, nullptr, nullptr, nullptr, nullptr, nullptr, DWOId,
       SplitDebugInlining, DebugInfoForProfiling, NameTableKind,
-      RangesBaseAddress, SysRoot, SDK);
+      RangesBaseAddress, SysRoot, SDK, nullptr);
 
   // Create a named metadata so that it is easier to find cu in a module.
   NamedMDNode *NMD = M.getOrInsertNamedMetadata("llvm.dbg.cu");
   NMD->addOperand(CUNode);
   trackIfUnresolved(CUNode);
   return CUNode;
 }
 

 
 DIEnumerator *DIBuilder::createEnumerator(StringRef Name, int64_t Val,
                                           bool IsUnsigned) {
   assert(!Name.empty() && "Unable to create enumerator without name");
   return DIEnumerator::get(VMContext, APInt(64, Val, !IsUnsigned), IsUnsigned,
                            Name);
 }
 
+DIConstant *DIBuilder::createConstant(DIScope *Scope, StringRef Name,
+                                      DIFile *File, unsigned Line, DIType *Type,
+                                      bool IsLocalToUnit, bool IsDefinition,
+                                      int64_t Val) {
+  assert(Scope && "Unable to create constant without scope");
+  assert(!Name.empty() && "Unable to create constant without name");
+  return DIConstant::get(VMContext, Scope, Name, File, Line, Type,
+                         IsLocalToUnit, IsDefinition,
+                         APInt(64, Val, true /*Signed*/));
+}
+
 DIBasicType *DIBuilder::createUnspecifiedType(StringRef Name) {
   assert(!Name.empty() && "Unable to create type without name");
   return DIBasicType::get(VMContext, dwarf::DW_TAG_unspecified_type, Name);
 }
 
 DIBasicType *DIBuilder::createNullPtrType() {
   return createUnspecifiedType("decltype(nullptr)");
 }

llvm/lib/IR/DebugInfo.cpp

DICompileUnit *getReplacementCU(DICompileUnit *CU) {
     MDTuple *ImportedEntities = nullptr;
     return DICompileUnit::getDistinct(
         CU->getContext(), CU->getSourceLanguage(), File, CU->getProducer(),
         CU->isOptimized(), CU->getFlags(), CU->getRuntimeVersion(),
         CU->getSplitDebugFilename(), DICompileUnit::LineTablesOnly, EnumTypes,
         RetainedTypes, GlobalVariables, ImportedEntities, CU->getMacros(),
         CU->getDWOId(), CU->getSplitDebugInlining(),
         CU->getDebugInfoForProfiling(), CU->getNameTableKind(),
-        CU->getRangesBaseAddress(), CU->getSysRoot(), CU->getSDK());
+        CU->getRangesBaseAddress(), CU->getSysRoot(), CU->getSDK(),
+        CU->getConstants());
   }
 
   DILocation *getReplacementMDLocation(DILocation *MLD) {
     auto *Scope = map(MLD->getScope());
     auto *InlinedAt = map(MLD->getInlinedAt());
     if (MLD->isDistinct())
       return DILocation::getDistinct(MLD->getContext(), MLD->getLine(),
                                      MLD->getColumn(), Scope, InlinedAt);

llvm/lib/IR/DebugInfoMetadata.cpp

 DICompileUnit *DICompileUnit::getImpl(
     LLVMContext &Context, unsigned SourceLanguage, Metadata *File,
     MDString *Producer, bool IsOptimized, MDString *Flags,
     unsigned RuntimeVersion, MDString *SplitDebugFilename,
     unsigned EmissionKind, Metadata *EnumTypes, Metadata *RetainedTypes,
     Metadata *GlobalVariables, Metadata *ImportedEntities, Metadata *Macros,
     uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling,
     unsigned NameTableKind, bool RangesBaseAddress, MDString *SysRoot,
-    MDString *SDK, StorageType Storage, bool ShouldCreate) {
+    MDString *SDK, Metadata *Constants, StorageType Storage,
+    bool ShouldCreate) {
   assert(Storage != Uniqued && "Cannot unique DICompileUnit");
   assert(isCanonical(Producer) && "Expected canonical MDString");
   assert(isCanonical(Flags) && "Expected canonical MDString");
   assert(isCanonical(SplitDebugFilename) && "Expected canonical MDString");
 
   Metadata *Ops[] = {File,
                      Producer,
                      Flags,
                      SplitDebugFilename,
                      EnumTypes,
                      RetainedTypes,
                      GlobalVariables,
                      ImportedEntities,
                      Macros,
                      SysRoot,
-                     SDK};
+                     SDK,
+                     Constants};
   return storeImpl(new (array_lengthof(Ops)) DICompileUnit(
                        Context, Storage, SourceLanguage, IsOptimized,
                        RuntimeVersion, EmissionKind, DWOId, SplitDebugInlining,
                        DebugInfoForProfiling, NameTableKind, RangesBaseAddress,
                        Ops),
                    Storage);
 }
 
DILocalVariable *DILocalVariable::getImpl(LLVMContext &Context, Metadata *Scope,
   assert(isCanonical(Name) && "Expected canonical MDString");
   DEFINE_GETIMPL_LOOKUP(DILocalVariable,
                         (Scope, Name, File, Line, Type, Arg, Flags,
                          AlignInBits));
   Metadata *Ops[] = {Scope, Name, File, Type};
   DEFINE_GETIMPL_STORE(DILocalVariable, (Line, Arg, Flags, AlignInBits), Ops);
 }
 
+DIConstant *DIConstant::getImpl(LLVMContext &Context, Metadata *Scope,
+                                MDString *Name, Metadata *File, unsigned Line,
+                                Metadata *Type, bool IsLocalToUnit,
+                                bool IsDefinition, const APInt &Value,
+                                StorageType Storage, bool ShouldCreate) {
+  assert(Scope && "Expected scope");
+  assert(isCanonical(Name) && "Expected canonical MDString");
+  DEFINE_GETIMPL_LOOKUP(DIConstant, (Scope, Name, File, Line, Type,
+                                     IsLocalToUnit, IsDefinition, Value));
+  Metadata *Ops[] = {Scope, Name, File, Type};
+  DEFINE_GETIMPL_STORE(DIConstant, (Line, IsLocalToUnit, IsDefinition, Value),
+                       Ops);
+}
+
 Optional<uint64_t> DIVariable::getSizeInBits() const {
   // This is used by the Verifier so be mindful of broken types.
   const Metadata *RawType = getRawType();
   while (RawType) {
     // Try to get the size directly.
     if (auto *T = dyn_cast<DIType>(RawType))
       if (uint64_t Size = T->getSizeInBits())
         return Size;

llvm/lib/IR/LLVMContextImpl.h

unsigned getHashValue() const {
     // cases with lots of similar variables.
     // clang/test/CodeGen/debug-info-257-args.c is an example of this problem,
     // generated IR is random for each run and test fails with Align included.
     // TODO: make hashing work fine with such situations
     return hash_combine(Scope, Name, File, Line, Type, Arg, Flags);
   }
 };
 
+template <> struct MDNodeKeyImpl<DIConstant> {
+  Metadata *Scope;
+  MDString *Name;
+  Metadata *File;
+  unsigned Line;
+  Metadata *Type;
+  bool IsLocalToUnit;
+  bool IsDefinition;
+  APInt Value;
+
+  MDNodeKeyImpl(Metadata *Scope, MDString *Name, Metadata *File, unsigned Line,
+                Metadata *Type, bool IsLocalToUnit, bool IsDefinition,
+                APInt Value)
+      : Scope(Scope), Name(Name), File(File), Line(Line), Type(Type),
+        IsLocalToUnit(IsLocalToUnit), IsDefinition(IsDefinition), Value(Value) {
+  }
+  MDNodeKeyImpl(const DIConstant *N)
+      : Scope(N->getRawScope()), Name(N->getRawName()), File(N->getRawFile()),
+        Line(N->getLine()), Type(N->getRawType()),
+        IsLocalToUnit(N->isLocalToUnit()), IsDefinition(N->isDefinition()),
+        Value(N->getValue()) {}
+
+  bool isKeyOf(const DIConstant *RHS) const {
+    return Scope == RHS->getRawScope() && Name == RHS->getRawName() &&
+           File == RHS->getRawFile() && Line == RHS->getLine() &&
+           Type == RHS->getRawType() && IsLocalToUnit == RHS->isLocalToUnit() &&
+           IsDefinition == RHS->isDefinition();
+  }
+
+  unsigned getHashValue() const {
+    return hash_combine(Scope, Name, File, Line, Type, IsLocalToUnit,
+                        IsDefinition);
+  }
+};
+
 template <> struct MDNodeKeyImpl<DILabel> {
   Metadata *Scope;
   MDString *Name;
   Metadata *File;
   unsigned Line;
 
   MDNodeKeyImpl(Metadata *Scope, MDString *Name, Metadata *File, unsigned Line)
       : Scope(Scope), Name(Name), File(File), Line(Line) {}

llvm/lib/IR/Verifier.cpp

void Verifier::visitDILocalVariable(const DILocalVariable &N) {
   AssertDI(isType(N.getRawType()), "invalid type ref", &N, N.getRawType());
   AssertDI(N.getTag() == dwarf::DW_TAG_variable, "invalid tag", &N);
   AssertDI(N.getRawScope() && isa<DILocalScope>(N.getRawScope()),
            "local variable requires a valid scope", &N, N.getRawScope());
   if (auto Ty = N.getType())
     AssertDI(!isa<DISubroutineType>(Ty), "invalid type", &N, N.getType());
 }
 
+void Verifier::visitDIConstant(const DIConstant &N) {
+
+  AssertDI(isType(N.getRawType()), "invalid type ref", &N, N.getRawType());
+  AssertDI(N.getTag() == dwarf::DW_TAG_constant, "invalid tag", &N);
+  AssertDI(N.getRawScope() && isa<DIScope>(N.getRawScope()),
+           "constant requires a valid scope", &N, N.getRawScope());
+  if (auto Ty = N.getType())
+    AssertDI(!isa<DISubroutineType>(Ty), "invalid type", &N, N.getType());
+}
+
 void Verifier::visitDILabel(const DILabel &N) {
   if (auto *S = N.getRawScope())
     AssertDI(isa<DIScope>(S), "invalid scope", &N, S);
   if (auto *F = N.getRawFile())
     AssertDI(isa<DIFile>(F), "invalid file", &N, F);
 
   AssertDI(N.getTag() == dwarf::DW_TAG_label, "invalid tag", &N);
   AssertDI(N.getRawScope() && isa<DILocalScope>(N.getRawScope()),

llvm/test/Assembler/diconstant.ll

+; RUN: llvm-as < %s | llvm-dis | llvm-as | llvm-dis | FileCheck %s
+
+; CHECK-DAG: ![[MODULE_SCOPE:.*]] = !DIModule
+; CHECK-DAG: ![[SUBPROGRAM_SCOPE:.*]] = distinct !DISubprogram
+; CHECK-DAG: !{{.*}} = !DIConstant(name: "local_constant", scope: ![[SUBPROGRAM_SCOPE]], file: !3, line: 10, type: !{{.*}}, isLocal: true, isDefinition: true, value: 42)
+; CHECK-DAG: !{{.*}} = !DIConstant(name: "module_constant", scope: ![[MODULE_SCOPE]], file: !3, line: 4, type: !{{.*}}, isLocal: false, isDefinition: true, value: 24)
+
+!llvm.module.flags = !{!16, !17}
+!llvm.dbg.cu = !{!4}
+
+!0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
+!1 = distinct !DIGlobalVariable(name: "foo", linkageName: "_dummy_0_", scope: !2, file: !3, line: 2, type: !14, isLocal: false, isDefinition: true)
+!2 = !DIModule(scope: !4, name: "dummy", file: !3, line: 1)
+!3 = !DIFile(filename: "fortran-constant.f90", directory: "/home/sourabh/work/dwarf/fortran")
+!4 = distinct !DICompileUnit(language: DW_LANG_Fortran90, file: !3, producer: " F90 Flang - 1.5 2017-05-01", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !5, retainedTypes: !5, globals: !6, imports: !7, nameTableKind: None, constants: !12)
+!5 = !{}
+!6 = !{!0}
+!7 = !{!8}
+!8 = !DIImportedEntity(tag: DW_TAG_imported_module, scope: !9, entity: !2, file: !3, line: 9)
+!9 = distinct !DISubprogram(name: "main", scope: !4, file: !3, line: 9, type: !10, scopeLine: 9, flags: DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagMainSubprogram, unit: !4)
+!10 = !DISubroutineType(cc: DW_CC_program, types: !11)
+!11 = !{null}
+!12 = !{!13, !15}
+!13 = !DIConstant(name: "local_constant", scope: !9, file: !3, line: 10, type: !14, isLocal: true, isDefinition: true, value: 42)
+!14 = !DIBasicType(name: "integer", size: 32, align: 32, encoding: DW_ATE_signed)
+!15 = !DIConstant(name: "module_constant", scope: !2, file: !3, line: 4, type: !14, isLocal: false, isDefinition: true, value: 24)
+!16 = !{i32 2, !"Dwarf Version", i32 4}
+!17 = !{i32 2, !"Debug Info Version", i32 3}
+!18 = !DILocation(line: 12, column: 1, scope: !9)
+!19 = distinct !DILocalVariable(scope: !9, file: !3, line: 12, type: !14, flags: DIFlagArtificial)
+!20 = !DILocation(line: 0, scope: !9)
+!21 = !DILocation(line: 13, column: 1, scope: !9)

llvm/test/Bindings/llvm-c/debug_info.ll

 ; CHECK-NEXT: declare void @llvm.dbg.value(metadata, metadata, metadata) #0
 
 ; CHECK:      attributes #0 = { nofree nosync nounwind readnone speculatable willreturn }
 
 ; CHECK:      !llvm.dbg.cu = !{!0}
 ; CHECK-NEXT: !FooType = !{!28}
 ; CHECK-NEXT: !EnumTest = !{!3}
 
-; CHECK:      !0 = distinct !DICompileUnit(language: DW_LANG_C, file: !1, producer: "llvm-c-test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, globals: !11, imports: !19, macros: !23, splitDebugInlining: false, sysroot: "/")
+; CHECK:      !0 = distinct !DICompileUnit(language: DW_LANG_C, file: !1, producer: "llvm-c-test", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, globals: !11, imports: !19, macros: !23, splitDebugInlining: false, sysroot: "/", constants: !15)
 ; CHECK-NEXT: !1 = !DIFile(filename: "debuginfo.c", directory: ".")
 ; CHECK-NEXT: !2 = !{!3}
 ; CHECK-NEXT: !3 = !DICompositeType(tag: DW_TAG_enumeration_type, name: "EnumTest", scope: !4, file: !1, baseType: !6, size: 64, elements: !7)
 ; CHECK-NEXT: !4 = !DINamespace(name: "NameSpace", scope: !5)
 ; CHECK-NEXT: !5 = !DIModule(scope: null, name: "llvm-c-test", includePath: "/test/include/llvm-c-test.h")
 ; CHECK-NEXT: !6 = !DIBasicType(name: "Int64", size: 64)
 ; CHECK-NEXT: !7 = !{!8, !9, !10}
 ; CHECK-NEXT: !8 = !DIEnumerator(name: "Test_A", value: 0, isUnsigned: true)

llvm/test/DebugInfo/fortran-parameter.ll

+; RUN: %llc_dwarf -filetype=obj %s -o - | llvm-dwarfdump - | FileCheck %s
+
+;; This test check DebugInfo for fortran constants.
+;; Fortran code snip:
+;; ```
+;; module dummy
+;;         integer :: foo
+;;         integer, parameter:: module_constant = 24
+;; end module dummy
+;; program main
+;;         use dummy
+;;         integer, parameter :: local_constant = 42
+;;         print*, module_constant, local_constant
+;;         end
+;; ```  
+
+; CHECK-LABEL: DW_TAG_module
+; CHECK:   DW_TAG_constant
+; CHECK:                DW_AT_name    ("module_constant")
+; CHECK:                DW_AT_decl_file
+; CHECK:                DW_AT_decl_line       (4)
+; CHECK:                DW_AT_type    ({{.*}} "integer")
+; CHECK:                DW_AT_external        (true)
+; CHECK:                DW_AT_const_value     (24)
+
+; CHECK-LABEL: DW_TAG_subprogram
+; CHECK:   DW_TAG_constant
+; CHECK:     DW_AT_name    ("local_constant")
+; CHECK:     DW_AT_decl_file
+; CHECK:     DW_AT_decl_line       (10)
+; CHECK:     DW_AT_type    ({{.*}} "integer")
+; CHECK:     DW_AT_const_value     (42)
+
+!llvm.module.flags = !{!16, !17}
+!llvm.dbg.cu = !{!4}
+
+!0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
+!1 = distinct !DIGlobalVariable(name: "foo", linkageName: "_dummy_0_", scope: !2, file: !3, line: 2, type: !14, isLocal: false, isDefinition: true)
+!2 = !DIModule(scope: !4, name: "dummy", file: !3, line: 1)
+!3 = !DIFile(filename: "fortran-constant.f90", directory: "/home/sourabh/work/dwarf/fortran")
+!4 = distinct !DICompileUnit(language: DW_LANG_Fortran90, file: !3, producer: " F90 Flang - 1.5 2017-05-01", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !5, retainedTypes: !5, globals: !6, imports: !7, nameTableKind: None, constants: !12)
+!5 = !{}
+!6 = !{!0}
+!7 = !{!8}
+!8 = !DIImportedEntity(tag: DW_TAG_imported_module, scope: !9, entity: !2, file: !3, line: 9)
+!9 = distinct !DISubprogram(name: "main", scope: !4, file: !3, line: 9, type: !10, scopeLine: 9, flags: DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagMainSubprogram, unit: !4)
+!10 = !DISubroutineType(cc: DW_CC_program, types: !11)
+!11 = !{null}
+!12 = !{!13, !15}
+!13 = !DIConstant(name: "local_constant", scope: !9, file: !3, line: 10, type: !14, isLocal: true, isDefinition: true, value: 42)
+!14 = !DIBasicType(name: "integer", size: 32, align: 32, encoding: DW_ATE_signed)
+!15 = !DIConstant(name: "module_constant", scope: !2, file: !3, line: 4, type: !14, isLocal: false, isDefinition: true, value: 24)
+!16 = !{i32 2, !"Dwarf Version", i32 4}
+!17 = !{i32 2, !"Debug Info Version", i32 3}
+!18 = !DILocation(line: 12, column: 1, scope: !9)
+!19 = distinct !DILocalVariable(scope: !9, file: !3, line: 12, type: !14, flags: DIFlagArtificial)
+!20 = !DILocation(line: 0, scope: !9)
+!21 = !DILocation(line: 13, column: 1, scope: !9)

llvm/unittests/IR/MetadataTest.cpp

protected:
   DIFile *getFile() {
     return DIFile::getDistinct(Context, "file.c", "/path/to/dir");
   }
   DICompileUnit *getUnit() {
     return DICompileUnit::getDistinct(
         Context, 1, getFile(), "clang", false, "-g", 2, "",
         DICompileUnit::FullDebug, getTuple(), getTuple(), getTuple(),
         getTuple(), getTuple(), 0, true, false,
-        DICompileUnit::DebugNameTableKind::Default, false, "/", "");
+        DICompileUnit::DebugNameTableKind::Default, false, "/", "", getTuple());
   }
   DIType *getBasicType(StringRef Name) {
     return DIBasicType::get(Context, dwarf::DW_TAG_unspecified_type, Name);
   }
   DIType *getDerivedType() {
     return DIDerivedType::getDistinct(
         Context, dwarf::DW_TAG_pointer_type, "", nullptr, 0, nullptr,
         getBasicType("basictype"), 1, 2, 0, None, DINode::FlagZero);
TEST_F(DIEnumeratorTest, getWithLargeValues) {
   auto *N = DIEnumerator::get(Context, APInt::getMaxValue(128), false, "val");
   EXPECT_EQ(128U, N->getValue().countPopulation());
   EXPECT_EQ(N,
             DIEnumerator::get(Context, APInt::getMaxValue(128), false, "val"));
   EXPECT_NE(N,
             DIEnumerator::get(Context, APInt::getMinValue(128), false, "val"));
 }
 
+typedef MetadataTest DIConstantTest;
+
+TEST_F(DIConstantTest, getLocalConstant) {
+  DISubprogram *Subprogram = getSubprogram();
+  DIFile *File = getFile();
+  unsigned Line = 4;
+  DIType *Ty = DIBasicType::get(Context, dwarf::DW_TAG_base_type, "int", 32, 32,
+                                dwarf::DW_ATE_signed, DINode::FlagZero);
+  DIScope *Scope = DILexicalBlock::get(Context, Subprogram, File, Line, 2);
+  bool IsLocalToUnit = true;
+  bool IsDefinition = true;
+  auto *Const =
+      DIConstant::get(Context, Scope, "localConstant", File, 4, Ty,
+                      IsLocalToUnit, IsDefinition, APInt(64, 42, true));
+  EXPECT_EQ(dwarf::DW_TAG_constant, Const->getTag());
+  EXPECT_EQ(Scope, Const->getScope());
+  EXPECT_NE(File, Const->getScope());
+  EXPECT_EQ("localConstant", Const->getName());
+  EXPECT_EQ(File, Const->getFile());
+  EXPECT_EQ(Line, Const->getLine());
+  EXPECT_EQ(Ty, DIBasicType::get(Context, dwarf::DW_TAG_base_type, "int", 32,
+                                 32, dwarf::DW_ATE_signed, DINode::FlagZero));
+  EXPECT_EQ(IsLocalToUnit, Const->isLocalToUnit());
+  EXPECT_NE(false, Const->isLocalToUnit());
+  EXPECT_EQ(IsDefinition, Const->isDefinition());
+  EXPECT_NE(false, Const->isDefinition());
+  EXPECT_EQ(42, Const->getValue().getSExtValue());
+}
+
+TEST_F(DIConstantTest, getModuleConstant) {
+  DIScope *Scope = getFile();
+  DIFile *File = getFile();
+  unsigned Line = 4;
+  DIType *Ty = DIBasicType::get(Context, dwarf::DW_TAG_base_type, "int", 32, 32,
+                                dwarf::DW_ATE_signed, DINode::FlagZero);
+  auto *Module = DIModule::get(Context, File, Scope, StringRef("fortranModule"),
+                               "-DNDEBUG", "-I.", "/tmp/m.apinotes", 1, true);
+  bool IsLocalToUnit = false;
+  bool IsDefinition = true;
+  auto *Const =
+      DIConstant::get(Context, Module, "moduleConstant", File, 4, Ty,
+                      IsLocalToUnit, IsDefinition, APInt(64, 24, true));
+  EXPECT_EQ(dwarf::DW_TAG_constant, Const->getTag());
+  EXPECT_EQ(Module, Const->getScope());
+  EXPECT_NE(Scope, Const->getScope());
+  EXPECT_EQ("moduleConstant", Const->getName());
+  EXPECT_EQ(File, Const->getFile());
+  EXPECT_EQ(Line, Const->getLine());
+  EXPECT_EQ(Ty, DIBasicType::get(Context, dwarf::DW_TAG_base_type, "int", 32,
+                                 32, dwarf::DW_ATE_signed, DINode::FlagZero));
+  EXPECT_EQ(IsLocalToUnit, Const->isLocalToUnit());
+  EXPECT_NE(true, Const->isLocalToUnit());
+  EXPECT_EQ(IsDefinition, Const->isDefinition());
+  EXPECT_NE(false, Const->isDefinition());
+  EXPECT_EQ(24, Const->getValue().getSExtValue());
+}
+
 typedef MetadataTest DIBasicTypeTest;
 
 TEST_F(DIBasicTypeTest, get) {
   auto *N =
       DIBasicType::get(Context, dwarf::DW_TAG_base_type, "special", 33, 26, 7,
                         DINode::FlagZero);
   EXPECT_EQ(dwarf::DW_TAG_base_type, N->getTag());
   EXPECT_EQ("special", N->getName());
TEST_F(DICompileUnitTest, get) {
   MDTuple *EnumTypes = getTuple();
   MDTuple *RetainedTypes = getTuple();
   MDTuple *GlobalVariables = getTuple();
   MDTuple *ImportedEntities = getTuple();
   uint64_t DWOId = 0x10000000c0ffee;
   MDTuple *Macros = getTuple();
   StringRef SysRoot = "/";
   StringRef SDK = "MacOSX.sdk";
+  MDTuple *Constants = getTuple();
   auto *N = DICompileUnit::getDistinct(
       Context, SourceLanguage, File, Producer, IsOptimized, Flags,
       RuntimeVersion, SplitDebugFilename, EmissionKind, EnumTypes,
       RetainedTypes, GlobalVariables, ImportedEntities, Macros, DWOId, true,
-      false, DICompileUnit::DebugNameTableKind::Default, false, SysRoot, SDK);
+      false, DICompileUnit::DebugNameTableKind::Default, false, SysRoot, SDK,
+      Constants);
 
   EXPECT_EQ(dwarf::DW_TAG_compile_unit, N->getTag());
   EXPECT_EQ(SourceLanguage, N->getSourceLanguage());
   EXPECT_EQ(File, N->getFile());
   EXPECT_EQ(Producer, N->getProducer());
   EXPECT_EQ(IsOptimized, N->isOptimized());
   EXPECT_EQ(Flags, N->getFlags());
   EXPECT_EQ(RuntimeVersion, N->getRuntimeVersion());
   EXPECT_EQ(SplitDebugFilename, N->getSplitDebugFilename());
   EXPECT_EQ(EmissionKind, N->getEmissionKind());
   EXPECT_EQ(EnumTypes, N->getEnumTypes().get());
   EXPECT_EQ(RetainedTypes, N->getRetainedTypes().get());
   EXPECT_EQ(GlobalVariables, N->getGlobalVariables().get());
   EXPECT_EQ(ImportedEntities, N->getImportedEntities().get());
   EXPECT_EQ(Macros, N->getMacros().get());
   EXPECT_EQ(DWOId, N->getDWOId());
   EXPECT_EQ(SysRoot, N->getSysRoot());
   EXPECT_EQ(SDK, N->getSDK());
+  EXPECT_EQ(Constants, N->getConstants().get());
 
   TempDICompileUnit Temp = N->clone();
   EXPECT_EQ(dwarf::DW_TAG_compile_unit, Temp->getTag());
   EXPECT_EQ(SourceLanguage, Temp->getSourceLanguage());
   EXPECT_EQ(File, Temp->getFile());
   EXPECT_EQ(Producer, Temp->getProducer());
   EXPECT_EQ(IsOptimized, Temp->isOptimized());
   EXPECT_EQ(Flags, Temp->getFlags());
   EXPECT_EQ(RuntimeVersion, Temp->getRuntimeVersion());
   EXPECT_EQ(SplitDebugFilename, Temp->getSplitDebugFilename());
   EXPECT_EQ(EmissionKind, Temp->getEmissionKind());
   EXPECT_EQ(EnumTypes, Temp->getEnumTypes().get());
   EXPECT_EQ(RetainedTypes, Temp->getRetainedTypes().get());
   EXPECT_EQ(GlobalVariables, Temp->getGlobalVariables().get());
   EXPECT_EQ(ImportedEntities, Temp->getImportedEntities().get());
   EXPECT_EQ(Macros, Temp->getMacros().get());
   EXPECT_EQ(SysRoot, Temp->getSysRoot());
   EXPECT_EQ(SDK, Temp->getSDK());
+  EXPECT_EQ(Constants, Temp->getConstants().get());
 
   auto *TempAddress = Temp.get();
   auto *Clone = MDNode::replaceWithPermanent(std::move(Temp));
   EXPECT_TRUE(Clone->isDistinct());
   EXPECT_EQ(TempAddress, Clone);
 }
 
 TEST_F(DICompileUnitTest, replaceArrays) {
   unsigned SourceLanguage = 1;
   DIFile *File = getFile();
   StringRef Producer = "some producer";
   bool IsOptimized = false;
   StringRef Flags = "flag after flag";
   unsigned RuntimeVersion = 2;
   StringRef SplitDebugFilename = "another/file";
   auto EmissionKind = DICompileUnit::FullDebug;
   MDTuple *EnumTypes = MDTuple::getDistinct(Context, None);
   MDTuple *RetainedTypes = MDTuple::getDistinct(Context, None);
   MDTuple *ImportedEntities = MDTuple::getDistinct(Context, None);
   uint64_t DWOId = 0xc0ffee;
   StringRef SysRoot = "/";
   StringRef SDK = "MacOSX.sdk";
+  MDTuple *Constants = MDTuple::getDistinct(Context, None);
   auto *N = DICompileUnit::getDistinct(
       Context, SourceLanguage, File, Producer, IsOptimized, Flags,
       RuntimeVersion, SplitDebugFilename, EmissionKind, EnumTypes,
       RetainedTypes, nullptr, ImportedEntities, nullptr, DWOId, true, false,
-      DICompileUnit::DebugNameTableKind::Default, false, SysRoot, SDK);
+      DICompileUnit::DebugNameTableKind::Default, false, SysRoot, SDK,
+      Constants);
 
   auto *GlobalVariables = MDTuple::getDistinct(Context, None);
   EXPECT_EQ(nullptr, N->getGlobalVariables().get());
   N->replaceGlobalVariables(GlobalVariables);
   EXPECT_EQ(GlobalVariables, N->getGlobalVariables().get());
   N->replaceGlobalVariables(nullptr);
   EXPECT_EQ(nullptr, N->getGlobalVariables().get());