[DebugInfo] Enhance DIImportedEntity to accept children entities for renamed variables

[alok]

Summary

This is needed to dump optimized debugging information where all names in a module are imported, but a few names are imported with overriding aliases

Please consider blow test case.

```````````````````

module mymod
   integer :: var1 = 11
   integer :: var2 = 12
   integer :: var3 = 13
 end module mymod

 Program main
   call use_renamed()
   contains
     subroutine use_renamed()
       use mymod, var4 => var1
       print *, var4
     end subroutine use_renamed
 end program main

```````````````````

Which currently produces IR as

```

 !0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
 !1 = distinct !DIGlobalVariable(name: "var1", scope: !2, file: !3, line: 2, type: !9, isLocal: false, isDefinition: true)
 !2 = !DIModule(scope: !4, name: "mymod", file: !3, line: 1)
 !3 = !DIFile(filename: "usemodulealias.f90", directory: "/tmp")
 !4 = distinct !DICompileUnit(language: DW_LANG_Fortran90, file: !3, producer: " F90 Flang - 1.5 2017-05-01", isOptimized: false, flags: "'+flang -g -S -emit-llvm usemodulealias.f90'", runtimeVersion: 0, emissionKind: FullDebug, enums: !5, retainedTypes: !5, globals: !6, **imports: !12**, nameTableKind: None)
 !5 = !{}
 !6 = !{!0, !7, !10}
 !7 = !DIGlobalVariableExpression(var: !8, expr: !DIExpression(DW_OP_plus_uconst, 4))
 !8 = distinct !DIGlobalVariable(name: "var2", scope: !2, file: !3, line: 3, type: !9, isLocal: false, isDefinition: true)
 !9 = !DIBasicType(name: "integer", size: 32, align: 32, encoding: DW_ATE_signed)
 !10 = !DIGlobalVariableExpression(var: !11, expr: !DIExpression(DW_OP_plus_uconst, 8))
 !11 = distinct !DIGlobalVariable(name: "var3", scope: !2, file: !3, line: 4, type: !9, isLocal: false, isDefinition: true)
** !12 = !{!13, !19, !20}**
 !13 = !**DIImportedEntity**(tag: DW_TAG_imported_declaration, scope: !14, entity: !11, file: !3, line: 10)
 !14 = distinct !DISubprogram(name: "use_renamed", scope: !15, file: !3, line: 10, type: !18, scopeLine: 10, flags: DIFlagAllCallsDescribed, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !4)
 !15 = distinct !DISubprogram(name: "main", scope: !4, file: !3, line: 7, type: !16, scopeLine: 7, flags: DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagMainSubprogram, unit: !4)
 !16 = !DISubroutineType(cc: DW_CC_program, types: !17)
 !17 = !{null}
 !18 = !DISubroutineType(types: !17)
 !19 = !**DIImportedEntity**(tag: DW_TAG_imported_declaration, scope: !14, entity: !8, file: !3, line: 10)
 !20 = !**DIImportedEntity**(tag: DW_TAG_imported_declaration, name: "var4", scope: !14, entity: !1, file: !3, line: 10)

``````

Please consider an imported Module having one renamed member out of
 total thousand members. With above representation we need to generate
thousand DIImportedEntity's for each member.
which can be optimize to

`````

 !0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
 !1 = distinct !DIGlobalVariable(name: "var1", scope: !2, file: !3, line: 2, type: !9, isLocal: false, isDefinition: true)
 !2 = !DIModule(scope: !4, name: "mymod", file: !3, line: 1)
 !3 = !DIFile(filename: "usemodulealias.f90", directory: "/tmp")
 !4 = distinct !DICompileUnit(language: DW_LANG_Fortran90, file: !3, producer: " F90 Flang - 1.5 2017-05-01", isOptimized: false, flags: "'+flang usemodulealias.f90 -g -S -emit-llvm'", runtimeVersion: 0, emissionKind: FullDebug, enums: !5, retainedTypes: !5, globals: !6, **imports: !12**, nameTableKind: None)
 !5 = !{}
 !6 = !{!0, !7, !10}
 !7 = !DIGlobalVariableExpression(var: !8, expr: !DIExpression(DW_OP_plus_uconst, 4))
 !8 = distinct !DIGlobalVariable(name: "var2", scope: !2, file: !3, line: 3, type: !9, isLocal: false, isDefinition: true)
 !9 = !DIBasicType(name: "integer", size: 32, align: 32, encoding: DW_ATE_signed)
 !10 = !DIGlobalVariableExpression(var: !11, expr: !DIExpression(DW_OP_plus_uconst, 8))
 !11 = distinct !DIGlobalVariable(name: "var3", scope: !2, file: !3, line: 4, type: !9, isLocal: false, isDefinition: true)
 **!12 = !{!13}**
 !13 = !**DIImportedEntity**(tag: DW_TAG_imported_module, scope: !14, entity: !2, file: !3, line: 10, **elements**: **!19**)
 !14 = distinct !DISubprogram(name: "use_renamed", scope: !15, file: !3, line: 10, type: !18, scopeLine: 10, flags: DIFlagAllCallsDescribed, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !4)
 **!19 = !{!20}**
** !20 = !DIImportedEntity**(tag: DW_TAG_imported_declaration, **name: "var4"**, scope: !14, entity: !1, file: !3, line: 10)

`````````````````

DIImportedEntity should include elements field which includes renamed variables only.

[alok]

Re-based and added backward comp test.

[alok]

Updated to satisfy clang-tidy for new code.

Warnings related to existing code is handled in separate patch as D109590

[dblaikie]

The subject might be slightly misleading - DIImportedEntity already supports importing variables (see C++ like this:

namespace ns {
extern int i;
int i;
}
namespace ns2 {
using ns::i;
}
int main() {
  return ns2::i;
}

which produces a DW_TAG_imported_declaration in DW_TAG_namespace ns2 that imports the DW_TAG_variable i from DW_TAG_namespace ns.

. This patch is specifically about supporting a single imported entity declaration importing multiple entities at the same time, but not a whole namespace of them?

Hmm, nope - it looks like it's only testing importing a single variable. What sort of DWARF are you expecting to generate when importing multiple variables (when "children" has a size greater than 1). Oh, in the implementation in DwarfDebug it's still generating separate DW_TAG_imported_declaration for each thing - so why not encode these as separate DIImportedDeclarations, which would already be supported in the current IR handling, so far as I can tell?

[alok]

In D109343#2998361, @dblaikie wrote:

The subject might be slightly misleading - DIImportedEntity already supports importing variables (see C++ like this:

namespace ns {
extern int i;
int i;
}
namespace ns2 {
using ns::i;
}
int main() {
  return ns2::i;
}

which produces a DW_TAG_imported_declaration in DW_TAG_namespace ns2 that imports the DW_TAG_variable i from DW_TAG_namespace ns.

. This patch is specifically about supporting a single imported entity declaration importing multiple entities at the same time, but not a whole namespace of them?

Hmm, nope - it looks like it's only testing importing a single variable. What sort of DWARF are you expecting to generate when importing multiple variables (when "children" has a size greater than 1). Oh, in the implementation in DwarfDebug it's still generating separate DW_TAG_imported_declaration for each thing - so why not encode these as separate DIImportedDeclarations, which would already be supported in the current IR handling, so far as I can tell?

I am sorry for not being clear earlier.

Please consider below testcase.

module mymod
  integer :: var1
  integer :: var2
  integer :: var3
  integer :: var4
  integer :: var5
end module mymod

Program main
  implicit none
  call use_renamed()
  contains
    subroutine use_renamed()
      use mymod, alias1 => var1, alias2 => var2
      print *, alias1
      print *, alias2
      print *, var3
      print *, var4
      print *, var5
    end subroutine use_renamed
end program main

Please note that inside subroutine "use_renamed", entire module "mymod" is imported but "var1" and "var2" are identified as "alias1" and "alias2".

Currently this can be represented in DWARF as

0x0000000b: DW_TAG_compile_unit
              DW_AT_language    (DW_LANG_Fortran90)
              DW_AT_name        ("mymoduse.f90")

0x0000002a:   DW_TAG_module
                DW_AT_name      ("mymod")

0x00000031:     DW_TAG_variable
                  DW_AT_name    ("var1")
                  DW_AT_location        (DW_OP_addr 0x0)

0x00000046:     DW_TAG_variable
                  DW_AT_name    ("var2")
                  DW_AT_location        (DW_OP_addr 0x0, DW_OP_plus_uconst 0x4)

0x0000005d:     DW_TAG_variable
                  DW_AT_name    ("var3")
                  DW_AT_location        (DW_OP_addr 0x0, DW_OP_plus_uconst 0x8)

0x00000074:     DW_TAG_variable
                  DW_AT_name    ("var4")
                  DW_AT_location        (DW_OP_addr 0x0, DW_OP_plus_uconst 0xc)

0x0000008b:     DW_TAG_variable
                  DW_AT_name    ("var5")
                  DW_AT_location        (DW_OP_addr 0x0, DW_OP_plus_uconst 0x10)

0x000000a2:     NULL


0x000000d4:     DW_TAG_subprogram
                  DW_AT_low_pc  (0x0000000000000030)
                  DW_AT_high_pc (0x0000000000000274)
                  DW_AT_frame_base      (DW_OP_reg7 RSP)
                  DW_AT_name    ("use_renamed")

0x000000fe:       DW_TAG_imported_declaration
                    DW_AT_import        (0x0000008b)

0x00000105:       DW_TAG_imported_declaration
                    DW_AT_import        (0x00000074)

0x0000010c:       DW_TAG_imported_declaration
                    DW_AT_import        (0x0000005d)

0x00000113:       DW_TAG_imported_declaration
                    DW_AT_import        (0x00000046)
                    DW_AT_name  ("alias2")

0x0000011e:       DW_TAG_imported_declaration
                    DW_AT_import        (0x00000031)
                    DW_AT_name  ("alias1")

0x00000129:       NULL

Please note that subroutine "use_rename" need to include 5 import entities here, just think about a module having 100 variables with 2 renamed entities will have to inlcude 100 "DW_TAG_imported_declaration".

gfortran dumps below DWARF for same case as,

0x000000d4:     DW_TAG_subprogram
                  DW_AT_name    ("use_renamed")
                  DW_AT_low_pc  (0x0000000000000000)
                  DW_AT_high_pc (0x000000000000020e)
                  DW_AT_frame_base      (DW_OP_call_frame_cfa)
                  DW_AT_static_link     (DW_OP_fbreg -504, DW_OP_deref, DW_OP_deref)

0x00000100:       DW_TAG_imported_module
                    DW_AT_import        (0x0000002a)

0x0000010b:          DW_TAG_imported_declaration
                       DW_AT_name        ("alias1")
                       DW_AT_import      (0x00000031)

0x00000116:          DW_TAG_imported_declaration
                       DW_AT_name        ("alias2")
                       DW_AT_import      (0x00000046)

0x00000121:         NULL

Please note that DW_TAG_imported_module has two child entities (for renamed variable), which denotes all variables in module (renamed entities are overridden). The case of module having 100 members and 2 renames can be represented with only 3 DIEs. (saving 97 DIEs).

The new representation (with DIImportedEntity having child) is surely going to save us some DWARF space in case of huge modules with few renames getting imported.

[dblaikie]

Ah, OK, thanks for explaining - sorry I wasn't following the fortran constructs.

Maybe the patch description could be updated a bit - this bit: " This is needed to dump optimized debugging information when imported entity
has renamed entities (member variables, subprograms)" perhaps along the lines of "where all names in a module are imported, but a few names are imported with overriding aliases"?

But yeah, the general direction seems reasonable to me.

[alok]

Re-based.

[dblaikie]

Generally looks OK to me.

llvm/docs/LangRef.rst

5793–5795

[alok]

In D109343#3002545, @dblaikie wrote:

Generally looks OK to me.

Thanks a lot @dblaikie . I shall merge the changes after including your comments.

llvm/docs/LangRef.rst

.. code-block:: text
 
     !3 = !DIObjCProperty(name: "foo", file: !1, line: 7, setter: "setFoo",
                          getter: "getFoo", attributes: 7, type: !2)
 
 DIImportedEntity
 """"""""""""""""
 
 ``DIImportedEntity`` nodes represent entities (such as modules) imported into a
-compile unit.
+compile unit. The ``elements`` field is list of renamed entities (such as
+variables and subprograms) in imported entity (such as module).
 
 .. code-block:: text
 
    !2 = !DIImportedEntity(tag: DW_TAG_imported_module, name: "foo", scope: !0,
-                          entity: !1, line: 7)
+                          entity: !1, line: 7, elements: !3)
+   !3 = !{!4}
+   !4 = !DIImportedEntity(tag: DW_TAG_imported_declaration, name: "bar", scope: !0,
+                          entity: !5, line: 7)
 
 DIMacro
 """""""
 
 ``DIMacro`` nodes represent definition or undefinition of a macro identifiers.
 The ``name:`` field is the macro identifier, followed by macro parameters when
 defining a function-like macro, and the ``value`` field is the token-string
 used to expand the macro identifier.

llvm/include/llvm-c/DebugInfo.h

 /**
  * Create a descriptor for an imported module that aliases another
  * imported entity descriptor.
  * \param Builder        The \c DIBuilder.
  * \param Scope          The scope this module is imported into
  * \param ImportedEntity Previous imported entity to alias.
  * \param File           File where the declaration is located.
  * \param Line           Line number of the declaration.
+ * \param Elements       Renamed elements.
+ * \param NumElements    Number of renamed elements.
  */
-LLVMMetadataRef
-LLVMDIBuilderCreateImportedModuleFromAlias(LLVMDIBuilderRef Builder,
-                                           LLVMMetadataRef Scope,
-                                           LLVMMetadataRef ImportedEntity,
-                                           LLVMMetadataRef File,
-                                           unsigned Line);
+LLVMMetadataRef LLVMDIBuilderCreateImportedModuleFromAlias(
+    LLVMDIBuilderRef Builder, LLVMMetadataRef Scope,
+    LLVMMetadataRef ImportedEntity, LLVMMetadataRef File, unsigned Line,
+    LLVMMetadataRef *Elements, unsigned NumElements);
 
 /**
  * Create a descriptor for an imported module.
- * \param Builder    The \c DIBuilder.
- * \param Scope      The scope this module is imported into
- * \param M          The module being imported here
- * \param File       File where the declaration is located.
- * \param Line       Line number of the declaration.
+ * \param Builder        The \c DIBuilder.
+ * \param Scope          The scope this module is imported into
+ * \param M              The module being imported here
+ * \param File           File where the declaration is located.
+ * \param Line           Line number of the declaration.
+ * \param Elements       Renamed elements.
+ * \param NumElements    Number of renamed elements.
  */
-LLVMMetadataRef
-LLVMDIBuilderCreateImportedModuleFromModule(LLVMDIBuilderRef Builder,
-                                            LLVMMetadataRef Scope,
-                                            LLVMMetadataRef M,
-                                            LLVMMetadataRef File,
-                                            unsigned Line);
+LLVMMetadataRef LLVMDIBuilderCreateImportedModuleFromModule(
+    LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, LLVMMetadataRef M,
+    LLVMMetadataRef File, unsigned Line, LLVMMetadataRef *Elements,
+    unsigned NumElements);
 
 /**
  * Create a descriptor for an imported function, type, or variable.  Suitable
  * for e.g. FORTRAN-style USE declarations.
- * \param Builder    The DIBuilder.
- * \param Scope      The scope this module is imported into.
- * \param Decl       The declaration (or definition) of a function, type,
+ * \param Builder        The DIBuilder.
+ * \param Scope          The scope this module is imported into.
+ * \param Decl           The declaration (or definition) of a function, type,
                          or variable.
- * \param File       File where the declaration is located.
- * \param Line       Line number of the declaration.
- * \param Name       A name that uniquely identifies this imported declaration.
- * \param NameLen    The length of the C string passed to \c Name.
+ * \param File           File where the declaration is located.
+ * \param Line           Line number of the declaration.
+ * \param Name           A name that uniquely identifies this imported
+ declaration.
+ * \param NameLen        The length of the C string passed to \c Name.
+ * \param Elements       Renamed elements.
+ * \param NumElements    Number of renamed elements.
  */
-LLVMMetadataRef
-LLVMDIBuilderCreateImportedDeclaration(LLVMDIBuilderRef Builder,
-                                       LLVMMetadataRef Scope,
-                                       LLVMMetadataRef Decl,
-                                       LLVMMetadataRef File,
-                                       unsigned Line,
-                                       const char *Name, size_t NameLen);
+LLVMMetadataRef LLVMDIBuilderCreateImportedDeclaration(
+    LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, LLVMMetadataRef Decl,
+    LLVMMetadataRef File, unsigned Line, const char *Name, size_t NameLen,
+    LLVMMetadataRef *Elements, unsigned NumElements);
 
 /**
  * Creates a new DebugLocation that describes a source location.
  * \param Line The line in the source file.
  * \param Column The column in the source file.
  * \param Scope The scope in which the location resides.
  * \param InlinedAt The scope where this location was inlined, if at all.
  *                  (optional).

llvm/include/llvm/IR/DIBuilder.h

public:
     /// \param Scope         Parent lexical scope.
     /// \param File          Source file.
     /// \param Line          Line number.
     /// \param Col           Column number.
     DILexicalBlock *createLexicalBlock(DIScope *Scope, DIFile *File,
                                        unsigned Line, unsigned Col);
 
     /// Create a descriptor for an imported module.
-    /// \param Context The scope this module is imported into
-    /// \param NS      The namespace being imported here.
-    /// \param File    File where the declaration is located.
-    /// \param Line    Line number of the declaration.
+    /// \param Context        The scope this module is imported into
+    /// \param NS             The namespace being imported here.
+    /// \param File           File where the declaration is located.
+    /// \param Line           Line number of the declaration.
+    /// \param Elements       Renamed elements.
     DIImportedEntity *createImportedModule(DIScope *Context, DINamespace *NS,
-                                           DIFile *File, unsigned Line);
+                                           DIFile *File, unsigned Line,
+                                           DINodeArray Elements = nullptr);
 
     /// Create a descriptor for an imported module.
     /// \param Context The scope this module is imported into.
     /// \param NS      An aliased namespace.
     /// \param File    File where the declaration is located.
     /// \param Line    Line number of the declaration.
+    /// \param Elements       Renamed elements.
     DIImportedEntity *createImportedModule(DIScope *Context,
                                            DIImportedEntity *NS, DIFile *File,
-                                           unsigned Line);
+                                           unsigned Line,
+                                           DINodeArray Elements = nullptr);
 
     /// Create a descriptor for an imported module.
-    /// \param Context The scope this module is imported into.
-    /// \param M       The module being imported here
-    /// \param File    File where the declaration is located.
-    /// \param Line    Line number of the declaration.
+    /// \param Context        The scope this module is imported into.
+    /// \param M              The module being imported here
+    /// \param File           File where the declaration is located.
+    /// \param Line           Line number of the declaration.
+    /// \param Elements       Renamed elements.
     DIImportedEntity *createImportedModule(DIScope *Context, DIModule *M,
-                                           DIFile *File, unsigned Line);
+                                           DIFile *File, unsigned Line,
+                                           DINodeArray Elements = nullptr);
 
     /// Create a descriptor for an imported function.
     /// \param Context The scope this module is imported into.
     /// \param Decl    The declaration (or definition) of a function, type, or
     ///                variable.
     /// \param File    File where the declaration is located.
     /// \param Line    Line number of the declaration.
+    /// \param Elements       Renamed elements.
     DIImportedEntity *createImportedDeclaration(DIScope *Context, DINode *Decl,
                                                 DIFile *File, unsigned Line,
-                                                StringRef Name = "");
+                                                StringRef Name = "",
+                                                DINodeArray Elements = nullptr);
 
     /// Insert a new llvm.dbg.declare intrinsic call.
     /// \param Storage     llvm::Value of the variable
     /// \param VarInfo     Variable's debug info descriptor.
     /// \param Expr        A complex location expression.
     /// \param DL          Debug info location.
     /// \param InsertAtEnd Location for the new intrinsic.
     Instruction *insertDeclare(llvm::Value *Storage, DILocalVariable *VarInfo,

llvm/include/llvm/IR/DebugInfoMetadata.h

class DIImportedEntity : public DINode {
   DIImportedEntity(LLVMContext &C, StorageType Storage, unsigned Tag,
                    unsigned Line, ArrayRef<Metadata *> Ops)
       : DINode(C, DIImportedEntityKind, Storage, Tag, Ops), Line(Line) {}
   ~DIImportedEntity() = default;
 
   static DIImportedEntity *getImpl(LLVMContext &Context, unsigned Tag,
                                    DIScope *Scope, DINode *Entity, DIFile *File,
                                    unsigned Line, StringRef Name,
-                                   StorageType Storage,
+                                   DINodeArray Elements, StorageType Storage,
                                    bool ShouldCreate = true) {
     return getImpl(Context, Tag, Scope, Entity, File, Line,
-                   getCanonicalMDString(Context, Name), Storage, ShouldCreate);
+                   getCanonicalMDString(Context, Name), Elements.get(), Storage,
+                   ShouldCreate);
   }
-  static DIImportedEntity *getImpl(LLVMContext &Context, unsigned Tag,
-                                   Metadata *Scope, Metadata *Entity,
-                                   Metadata *File, unsigned Line,
-                                   MDString *Name, StorageType Storage,
-                                   bool ShouldCreate = true);
+  static DIImportedEntity *
+  getImpl(LLVMContext &Context, unsigned Tag, Metadata *Scope, Metadata *Entity,
+          Metadata *File, unsigned Line, MDString *Name, Metadata *Elements,
+          StorageType Storage, bool ShouldCreate = true);
 
   TempDIImportedEntity cloneImpl() const {
     return getTemporary(getContext(), getTag(), getScope(), getEntity(),
-                        getFile(), getLine(), getName());
+                        getFile(), getLine(), getName(), getElements());
   }
 
 public:
   DEFINE_MDNODE_GET(DIImportedEntity,
                     (unsigned Tag, DIScope *Scope, DINode *Entity, DIFile *File,
-                     unsigned Line, StringRef Name = ""),
-                    (Tag, Scope, Entity, File, Line, Name))
+                     unsigned Line, StringRef Name = "",
+                     DINodeArray Elements = nullptr),
+                    (Tag, Scope, Entity, File, Line, Name, Elements))
   DEFINE_MDNODE_GET(DIImportedEntity,
                     (unsigned Tag, Metadata *Scope, Metadata *Entity,
-                     Metadata *File, unsigned Line, MDString *Name),
-                    (Tag, Scope, Entity, File, Line, Name))
+                     Metadata *File, unsigned Line, MDString *Name,
+                     Metadata *Elements = nullptr),
+                    (Tag, Scope, Entity, File, Line, Name, Elements))
 
   TempDIImportedEntity clone() const { return cloneImpl(); }
 
   unsigned getLine() const { return Line; }
   DIScope *getScope() const { return cast_or_null<DIScope>(getRawScope()); }
   DINode *getEntity() const { return cast_or_null<DINode>(getRawEntity()); }
   StringRef getName() const { return getStringOperand(2); }
   DIFile *getFile() const { return cast_or_null<DIFile>(getRawFile()); }
+  DINodeArray getElements() const {
+    return cast_or_null<MDTuple>(getRawElements());
+  }
 
   Metadata *getRawScope() const { return getOperand(0); }
   Metadata *getRawEntity() const { return getOperand(1); }
   MDString *getRawName() const { return getOperandAs<MDString>(2); }
   Metadata *getRawFile() const { return getOperand(3); }
+  Metadata *getRawElements() const { return getOperand(4); }
 
   static bool classof(const Metadata *MD) {
     return MD->getMetadataID() == DIImportedEntityKind;
   }
 };
 
 /// A pair of DIGlobalVariable and DIExpression.
 class DIGlobalVariableExpression : public MDNode {

llvm/lib/AsmParser/LLParser.cpp

#undef VISIT_MD_FIELDS
   Result = GET_OR_DISTINCT(DIObjCProperty,
                            (Context, name.Val, file.Val, line.Val, setter.Val,
                             getter.Val, attributes.Val, type.Val));
   return false;
 }
 
 /// parseDIImportedEntity:
 ///   ::= !DIImportedEntity(tag: DW_TAG_imported_module, scope: !0, entity: !1,
-///                         line: 7, name: "foo")
+///                         line: 7, name: "foo", elements: !2)
 bool LLParser::parseDIImportedEntity(MDNode *&Result, bool IsDistinct) {
 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED)                                    \
   REQUIRED(tag, DwarfTagField, );                                              \
   REQUIRED(scope, MDField, );                                                  \
   OPTIONAL(entity, MDField, );                                                 \
   OPTIONAL(file, MDField, );                                                   \
   OPTIONAL(line, LineField, );                                                 \
-  OPTIONAL(name, MDStringField, );
+  OPTIONAL(name, MDStringField, );                                             \
+  OPTIONAL(elements, MDField, );
   PARSE_MD_FIELDS();
 #undef VISIT_MD_FIELDS
 
-  Result = GET_OR_DISTINCT(
-      DIImportedEntity,
-      (Context, tag.Val, scope.Val, entity.Val, file.Val, line.Val, name.Val));
+  Result = GET_OR_DISTINCT(DIImportedEntity,
+                           (Context, tag.Val, scope.Val, entity.Val, file.Val,
+                            line.Val, name.Val, elements.Val));
   return false;
 }
 
 #undef PARSE_MD_FIELD
 #undef NOP_FIELD
 #undef REQUIRE_FIELD
 #undef DECLARE_FIELD
 

llvm/lib/Bitcode/Reader/MetadataLoader.cpp

MetadataList.assignValue(
                          getMDOrNull(Record[2]), Record[3],
                          getMDString(Record[4]), getMDString(Record[5]),
                          Record[6], getDITypeRefOrNull(Record[7]))),
         NextMetadataNo);
     NextMetadataNo++;
     break;
   }
   case bitc::METADATA_IMPORTED_ENTITY: {
-    if (Record.size() != 6 && Record.size() != 7)
+    if (Record.size() < 6 && Record.size() > 8)
       return error("Invalid record");
 
     IsDistinct = Record[0];
-    bool HasFile = (Record.size() == 7);
+    bool HasFile = (Record.size() >= 7);
+    bool HasElements = (Record.size() >= 8);
     MetadataList.assignValue(
         GET_OR_DISTINCT(DIImportedEntity,
                         (Context, Record[1], getMDOrNull(Record[2]),
                          getDITypeRefOrNull(Record[3]),
                          HasFile ? getMDOrNull(Record[6]) : nullptr,
-                         HasFile ? Record[4] : 0, getMDString(Record[5]))),
+                         HasFile ? Record[4] : 0, getMDString(Record[5]),
+                         HasElements ? getMDOrNull(Record[7]) : nullptr)),
         NextMetadataNo);
     NextMetadataNo++;
     break;
   }
   case bitc::METADATA_STRING_OLD: {
     std::string String(Record.begin(), Record.end());
 
     // Test for upgrading !llvm.loop.

llvm/lib/Bitcode/Writer/BitcodeWriter.cpp

void ModuleBitcodeWriter::writeDIImportedEntity(
     unsigned Abbrev) {
   Record.push_back(N->isDistinct());
   Record.push_back(N->getTag());
   Record.push_back(VE.getMetadataOrNullID(N->getScope()));
   Record.push_back(VE.getMetadataOrNullID(N->getEntity()));
   Record.push_back(N->getLine());
   Record.push_back(VE.getMetadataOrNullID(N->getRawName()));
   Record.push_back(VE.getMetadataOrNullID(N->getRawFile()));
+  Record.push_back(VE.getMetadataOrNullID(N->getElements().get()));
 
   Stream.EmitRecord(bitc::METADATA_IMPORTED_ENTITY, Record, Abbrev);
   Record.clear();
 }
 
 unsigned ModuleBitcodeWriter::createNamedMetadataAbbrev() {
   auto Abbv = std::make_shared<BitCodeAbbrev>();
   Abbv->Add(BitCodeAbbrevOp(bitc::METADATA_NAME));

llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp

else
     EntityDie = getDIE(Entity);
   assert(EntityDie);
   addSourceLine(*IMDie, Module->getLine(), Module->getFile());
   addDIEEntry(*IMDie, dwarf::DW_AT_import, *EntityDie);
   StringRef Name = Module->getName();
   if (!Name.empty())
     addString(*IMDie, dwarf::DW_AT_name, Name);
 
+  // This is for imported module with renamed entities (such as variables and
+  // subprograms).
+  DINodeArray Elements = Module->getElements();
+  for (const auto *Element : Elements) {
+    if (!Element)
+      continue;
+    IMDie->addChild(
+        constructImportedEntityDIE(cast<DIImportedEntity>(Element)));
+  }
+
   return IMDie;
 }
 
 void DwarfCompileUnit::finishSubprogramDefinition(const DISubprogram *SP) {
   DIE *D = getDIE(SP);
   if (DIE *AbsSPDIE = getAbstractSPDies().lookup(SP)) {
     if (D)
       // If this subprogram has an abstract definition, reference that

llvm/lib/IR/AsmWriter.cpp

static void writeDIImportedEntity(raw_ostream &Out, const DIImportedEntity *N,
   Out << "!DIImportedEntity(";
   MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
   Printer.printTag(N);
   Printer.printString("name", N->getName());
   Printer.printMetadata("scope", N->getRawScope(), /* ShouldSkipNull */ false);
   Printer.printMetadata("entity", N->getRawEntity());
   Printer.printMetadata("file", N->getRawFile());
   Printer.printInt("line", N->getLine());
+  Printer.printMetadata("elements", N->getRawElements());
   Out << ")";
 }
 
 static void WriteMDNodeBodyInternal(raw_ostream &Out, const MDNode *Node,
                                     TypePrinting *TypePrinter,
                                     SlotTracker *Machine,
                                     const Module *Context) {
   if (Node->isDistinct())

llvm/lib/IR/DIBuilder.cpp

DICompileUnit *DIBuilder::createCompileUnit(
   NMD->addOperand(CUNode);
   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) {
   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);
+                                  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);
   return M;
 }
 
 DIImportedEntity *DIBuilder::createImportedModule(DIScope *Context,
                                                   DINamespace *NS, DIFile *File,
-                                                  unsigned Line) {
+                                                  unsigned Line,
+                                                  DINodeArray Elements) {
   return ::createImportedModule(VMContext, dwarf::DW_TAG_imported_module,
-                                Context, NS, File, Line, StringRef(),
+                                Context, NS, File, Line, StringRef(), Elements,
                                 AllImportedModules);
 }
 
 DIImportedEntity *DIBuilder::createImportedModule(DIScope *Context,
                                                   DIImportedEntity *NS,
-                                                  DIFile *File, unsigned Line) {
+                                                  DIFile *File, unsigned Line,
+                                                  DINodeArray Elements) {
   return ::createImportedModule(VMContext, dwarf::DW_TAG_imported_module,
-                                Context, NS, File, Line, StringRef(),
+                                Context, NS, File, Line, StringRef(), Elements,
                                 AllImportedModules);
 }
 
 DIImportedEntity *DIBuilder::createImportedModule(DIScope *Context, DIModule *M,
-                                                  DIFile *File, unsigned Line) {
+                                                  DIFile *File, unsigned Line,
+                                                  DINodeArray Elements) {
   return ::createImportedModule(VMContext, dwarf::DW_TAG_imported_module,
-                                Context, M, File, Line, StringRef(),
+                                Context, M, File, Line, StringRef(), Elements,
                                 AllImportedModules);
 }
 
-DIImportedEntity *DIBuilder::createImportedDeclaration(DIScope *Context,
-                                                       DINode *Decl,
-                                                       DIFile *File,
-                                                       unsigned Line,
-                                                       StringRef Name) {
+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,
+                                Context, Decl, File, Line, Name, Elements,
                                 AllImportedModules);
 }
 
 DIFile *DIBuilder::createFile(StringRef Filename, StringRef Directory,
                               Optional<DIFile::ChecksumInfo<StringRef>> CS,
                               Optional<StringRef> Source) {
   return DIFile::get(VMContext, Filename, Directory, CS, Source);
 }

llvm/lib/IR/DebugInfo.cpp

LLVMDIBuilderCreateImportedModuleFromNamespace(LLVMDIBuilderRef Builder,
                                                LLVMMetadataRef File,
                                                unsigned Line) {
   return wrap(unwrap(Builder)->createImportedModule(unwrapDI<DIScope>(Scope),
                                                     unwrapDI<DINamespace>(NS),
                                                     unwrapDI<DIFile>(File),
                                                     Line));
 }
 
-LLVMMetadataRef
-LLVMDIBuilderCreateImportedModuleFromAlias(LLVMDIBuilderRef Builder,
-                                           LLVMMetadataRef Scope,
-                                           LLVMMetadataRef ImportedEntity,
-                                           LLVMMetadataRef File,
-                                           unsigned Line) {
+LLVMMetadataRef LLVMDIBuilderCreateImportedModuleFromAlias(
+    LLVMDIBuilderRef Builder, LLVMMetadataRef Scope,
+    LLVMMetadataRef ImportedEntity, LLVMMetadataRef File, unsigned Line,
+    LLVMMetadataRef *Elements, unsigned NumElements) {
+  auto Elts =
+      (NumElements > 0)
+          ? unwrap(Builder)->getOrCreateArray({unwrap(Elements), NumElements})
+          : nullptr;
   return wrap(unwrap(Builder)->createImportedModule(
-                  unwrapDI<DIScope>(Scope),
-                  unwrapDI<DIImportedEntity>(ImportedEntity),
-                  unwrapDI<DIFile>(File), Line));
+      unwrapDI<DIScope>(Scope), unwrapDI<DIImportedEntity>(ImportedEntity),
+      unwrapDI<DIFile>(File), Line, Elts));
 }
 
-LLVMMetadataRef
-LLVMDIBuilderCreateImportedModuleFromModule(LLVMDIBuilderRef Builder,
-                                            LLVMMetadataRef Scope,
-                                            LLVMMetadataRef M,
-                                            LLVMMetadataRef File,
-                                            unsigned Line) {
-  return wrap(unwrap(Builder)->createImportedModule(unwrapDI<DIScope>(Scope),
-                                                    unwrapDI<DIModule>(M),
-                                                    unwrapDI<DIFile>(File),
-                                                    Line));
+LLVMMetadataRef LLVMDIBuilderCreateImportedModuleFromModule(
+    LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, LLVMMetadataRef M,
+    LLVMMetadataRef File, unsigned Line, LLVMMetadataRef *Elements,
+    unsigned NumElements) {
+  auto Elts =
+      (NumElements > 0)
+          ? unwrap(Builder)->getOrCreateArray({unwrap(Elements), NumElements})
+          : nullptr;
+  return wrap(unwrap(Builder)->createImportedModule(
+      unwrapDI<DIScope>(Scope), unwrapDI<DIModule>(M), unwrapDI<DIFile>(File),
+      Line, Elts));
 }
 
-LLVMMetadataRef
-LLVMDIBuilderCreateImportedDeclaration(LLVMDIBuilderRef Builder,
-                                       LLVMMetadataRef Scope,
-                                       LLVMMetadataRef Decl,
-                                       LLVMMetadataRef File,
-                                       unsigned Line,
-                                       const char *Name, size_t NameLen) {
+LLVMMetadataRef LLVMDIBuilderCreateImportedDeclaration(
+    LLVMDIBuilderRef Builder, LLVMMetadataRef Scope, LLVMMetadataRef Decl,
+    LLVMMetadataRef File, unsigned Line, const char *Name, size_t NameLen,
+    LLVMMetadataRef *Elements, unsigned NumElements) {
+  auto Elts =
+      (NumElements > 0)
+          ? unwrap(Builder)->getOrCreateArray({unwrap(Elements), NumElements})
+          : nullptr;
   return wrap(unwrap(Builder)->createImportedDeclaration(
-                  unwrapDI<DIScope>(Scope),
-                  unwrapDI<DINode>(Decl),
-                  unwrapDI<DIFile>(File), Line, {Name, NameLen}));
+      unwrapDI<DIScope>(Scope), unwrapDI<DINode>(Decl), unwrapDI<DIFile>(File),
+      Line, {Name, NameLen}, Elts));
 }
 
 LLVMMetadataRef
 LLVMDIBuilderCreateDebugLocation(LLVMContextRef Ctx, unsigned Line,
                                  unsigned Column, LLVMMetadataRef Scope,
                                  LLVMMetadataRef InlinedAt) {
   return wrap(DILocation::get(*unwrap(Ctx), Line, Column, unwrap(Scope),
                               unwrap(InlinedAt)));

llvm/lib/IR/DebugInfoMetadata.cpp

DEFINE_GETIMPL_LOOKUP(DIObjCProperty, (Name, File, Line, GetterName,
                                          SetterName, Attributes, Type));
   Metadata *Ops[] = {Name, File, GetterName, SetterName, Type};
   DEFINE_GETIMPL_STORE(DIObjCProperty, (Line, Attributes), Ops);
 }
 
 DIImportedEntity *DIImportedEntity::getImpl(LLVMContext &Context, unsigned Tag,
                                             Metadata *Scope, Metadata *Entity,
                                             Metadata *File, unsigned Line,
-                                            MDString *Name, StorageType Storage,
+                                            MDString *Name, Metadata *Elements,
+                                            StorageType Storage,
                                             bool ShouldCreate) {
   assert(isCanonical(Name) && "Expected canonical MDString");
   DEFINE_GETIMPL_LOOKUP(DIImportedEntity,
-                        (Tag, Scope, Entity, File, Line, Name));
-  Metadata *Ops[] = {Scope, Entity, Name, File};
+                        (Tag, Scope, Entity, File, Line, Name, Elements));
+  Metadata *Ops[] = {Scope, Entity, Name, File, Elements};
   DEFINE_GETIMPL_STORE(DIImportedEntity, (Tag, Line), Ops);
 }
 
 DIMacro *DIMacro::getImpl(LLVMContext &Context, unsigned MIType,
                           unsigned Line, MDString *Name, MDString *Value,
                           StorageType Storage, bool ShouldCreate) {
   assert(isCanonical(Name) && "Expected canonical MDString");
   DEFINE_GETIMPL_LOOKUP(DIMacro, (MIType, Line, Name, Value));

llvm/lib/IR/LLVMContextImpl.h

 
 template <> struct MDNodeKeyImpl<DIImportedEntity> {
   unsigned Tag;
   Metadata *Scope;
   Metadata *Entity;
   Metadata *File;
   unsigned Line;
   MDString *Name;
+  Metadata *Elements;
 
   MDNodeKeyImpl(unsigned Tag, Metadata *Scope, Metadata *Entity, Metadata *File,
-                unsigned Line, MDString *Name)
+                unsigned Line, MDString *Name, Metadata *Elements)
       : Tag(Tag), Scope(Scope), Entity(Entity), File(File), Line(Line),
-        Name(Name) {}
+        Name(Name), Elements(Elements) {}
   MDNodeKeyImpl(const DIImportedEntity *N)
       : Tag(N->getTag()), Scope(N->getRawScope()), Entity(N->getRawEntity()),
-        File(N->getRawFile()), Line(N->getLine()), Name(N->getRawName()) {}
+        File(N->getRawFile()), Line(N->getLine()), Name(N->getRawName()),
+        Elements(N->getRawElements()) {}
 
   bool isKeyOf(const DIImportedEntity *RHS) const {
     return Tag == RHS->getTag() && Scope == RHS->getRawScope() &&
            Entity == RHS->getRawEntity() && File == RHS->getFile() &&
-           Line == RHS->getLine() && Name == RHS->getRawName();
+           Line == RHS->getLine() && Name == RHS->getRawName() &&
+           Elements == RHS->getRawElements();
   }
 
   unsigned getHashValue() const {
-    return hash_combine(Tag, Scope, Entity, File, Line, Name);
+    return hash_combine(Tag, Scope, Entity, File, Line, Name, Elements);
   }
 };
 
 template <> struct MDNodeKeyImpl<DIMacro> {
   unsigned MIType;
   unsigned Line;
   MDString *Name;
   MDString *Value;

llvm/test/Bitcode/DIImportedEntity_backward.ll

+;; This test checks Backward compatibility of DIImportedEntity
+; REQUIRES: x86_64-linux
+
+; RUN: llvm-dis -o - %s.bc | FileCheck %s
+
+;Test whether DIImportedEntity are generated correctly.
+; CHECK: distinct !DICompileUnit(language: DW_LANG_Fortran90
+; CHECK-SAME:  imports: [[IMPORTS:![0-9]+]]
+; CHECK: [[IMPORTS]] = !{[[IMPORT1:![0-9]+]], [[IMPORT2:![0-9]+]]}
+; CHECK: [[IMPORT1]] = !DIImportedEntity(tag: DW_TAG_imported_module, scope: {{![0-9]+}}, entity: {{![0-9]+}}, file: {{![0-9]+}}, line: {{[0-9]+}})
+; CHECK: [[IMPORT2]] = !DIImportedEntity(tag: DW_TAG_imported_declaration, name: "var4", scope: {{![0-9]+}}, entity: {{![0-9]+}}, file: {{![0-9]+}}, line: {{[0-9]+}})
+
+; ModuleID = 'DIImportedEntity_backward.bc'
+source_filename = "/tmp/usemodulealias.ll"
+
+%struct_mymod_8_ = type <{ [12 x i8] }>
+%struct.struct_ul_MAIN__348 = type { i8* }
+
+@_mymod_8_ = global %struct_mymod_8_ <{ [12 x i8] c"\0B\00\00\00\0C\00\00\00\0D\00\00\00" }>, align 64, !dbg !0, !dbg !7, !dbg !10
+@.C330_MAIN_ = internal constant i32 0
+@.C364_main_use_renamed = internal constant i32 25
+@.C330_main_use_renamed = internal constant i32 0
+@.C331_main_use_renamed = internal constant i64 0
+@.C359_main_use_renamed = internal constant i32 6
+@.C357_main_use_renamed = internal constant [18 x i8] c"usemodulealias.f90"
+@.C352_main_use_renamed = internal constant i32 12
+
+define i32 @mymod_() {
+.L.entry:
+  ret i32 undef
+}
+
+define void @MAIN_() !dbg !15 {
+L.entry:
+  %.S0000_353 = alloca %struct.struct_ul_MAIN__348, align 8
+  %0 = bitcast i32* @.C330_MAIN_ to i8*
+  %1 = bitcast void (...)* @fort_init to void (i8*, ...)*
+  call void (i8*, ...) %1(i8* %0)
+  br label %L.LB2_357
+
+L.LB2_357:                                        ; preds = %L.entry
+  %2 = bitcast %struct.struct_ul_MAIN__348* %.S0000_353 to i64*, !dbg !22
+  call void @main_use_renamed(i64* %2), !dbg !22
+  ret void, !dbg !23
+}
+
+define internal void @main_use_renamed(i64* noalias %.S0000) !dbg !14 {
+L.entry:
+  ret void, !dbg !24
+}
+
+declare void @fort_init(...)
+
+!llvm.module.flags = !{!20, !21}
+!llvm.dbg.cu = !{!4}
+
+!0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
+!1 = distinct !DIGlobalVariable(name: "var1", scope: !2, file: !3, line: 2, type: !9, isLocal: false, isDefinition: true)
+!2 = !DIModule(scope: !4, name: "mymod", file: !3, line: 1)
+!3 = !DIFile(filename: "DIImportedEntity_backward.f90", directory: "/tmp")
+!4 = distinct !DICompileUnit(language: DW_LANG_Fortran90, file: !3, producer: " F90 Flang - 1.5 2017-05-01", isOptimized: false, flags: "'+flang usemodulealias.f90 -g -S -emit-llvm'", runtimeVersion: 0, emissionKind: FullDebug, enums: !5, retainedTypes: !5, globals: !6, imports: !12, nameTableKind: None)
+!5 = !{}
+!6 = !{!0, !7, !10}
+!7 = !DIGlobalVariableExpression(var: !8, expr: !DIExpression(DW_OP_plus_uconst, 4))
+!8 = distinct !DIGlobalVariable(name: "var2", scope: !2, file: !3, line: 3, type: !9, isLocal: false, isDefinition: true)
+!9 = !DIBasicType(name: "integer", size: 32, align: 32, encoding: DW_ATE_signed)
+!10 = !DIGlobalVariableExpression(var: !11, expr: !DIExpression(DW_OP_plus_uconst, 8))
+!11 = distinct !DIGlobalVariable(name: "var3", scope: !2, file: !3, line: 4, type: !9, isLocal: false, isDefinition: true)
+!12 = !{!13, !19}
+!13 = !DIImportedEntity(tag: DW_TAG_imported_module, scope: !14, entity: !2, file: !3, line: 10)
+!14 = distinct !DISubprogram(name: "use_renamed", scope: !15, file: !3, line: 10, type: !18, scopeLine: 10, flags: DIFlagAllCallsDescribed, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !4)
+!15 = distinct !DISubprogram(name: "main", scope: !4, file: !3, line: 7, type: !16, scopeLine: 7, flags: DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagMainSubprogram, unit: !4)
+!16 = !DISubroutineType(cc: DW_CC_program, types: !17)
+!17 = !{null}
+!18 = !DISubroutineType(types: !17)
+!19 = !DIImportedEntity(tag: DW_TAG_imported_declaration, name: "var4", scope: !14, entity: !1, file: !3, line: 10)
+!20 = !{i32 2, !"Dwarf Version", i32 4}
+!21 = !{i32 2, !"Debug Info Version", i32 3}
+!22 = !DILocation(line: 8, column: 1, scope: !15)
+!23 = !DILocation(line: 9, column: 1, scope: !15)
+!24 = !DILocation(line: 13, column: 1, scope: !14)

llvm/test/Bitcode/DIImportedEntity_elements.ll

+;; This test checks processing of DIImportedEntity with elements field.
+; REQUIRES: x86_64-linux
+
+; RUN: llvm-as < %s | llvm-dis | llvm-as | llvm-dis | FileCheck %s
+
+; CHECK: !DIImportedEntity(tag: DW_TAG_imported_module
+; CHECK-SAME: elements: [[ELEMENTS:![0-9]+]]
+; CHECK: [[ELEMENTS]] = !{[[ELEMENT:![0-9]+]]}
+; CHECK: [[ELEMENT]] = !DIImportedEntity(tag: DW_TAG_imported_declaration, name: "var4"
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;This test case is generated from
+;;module mymod
+;;  integer :: var1 = 11
+;;  integer :: var2 = 12
+;;  integer :: var3 = 13
+;;end module mymod
+;;
+;;Program main
+;;  call use_renamed()
+;;  contains
+;;    subroutine use_renamed()
+;;      use mymod, var4 => var1
+;;      print *, var4
+;;    end subroutine use_renamed
+;;end program main
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+; ModuleID = 'DIImportedEntity_elements.ll'
+source_filename = "/tmp/usemodulealias.ll"
+
+%struct_mymod_8_ = type <{ [12 x i8] }>
+%struct.struct_ul_MAIN__348 = type { i8* }
+
+@_mymod_8_ = global %struct_mymod_8_ <{ [12 x i8] c"\0B\00\00\00\0C\00\00\00\0D\00\00\00" }>, align 64, !dbg !0, !dbg !7, !dbg !10
+@.C330_MAIN_ = internal constant i32 0
+@.C364_main_use_renamed = internal constant i32 25
+@.C330_main_use_renamed = internal constant i32 0
+@.C331_main_use_renamed = internal constant i64 0
+@.C359_main_use_renamed = internal constant i32 6
+@.C357_main_use_renamed = internal constant [18 x i8] c"usemodulealias.f90"
+@.C352_main_use_renamed = internal constant i32 12
+
+define i32 @mymod_() {
+.L.entry:
+  ret i32 undef
+}
+
+define void @MAIN_() !dbg !15 {
+L.entry:
+  %.S0000_353 = alloca %struct.struct_ul_MAIN__348, align 8
+  %0 = bitcast i32* @.C330_MAIN_ to i8*
+  %1 = bitcast void (...)* @fort_init to void (i8*, ...)*
+  call void (i8*, ...) %1(i8* %0)
+  br label %L.LB2_357
+
+L.LB2_357:                                        ; preds = %L.entry
+  %2 = bitcast %struct.struct_ul_MAIN__348* %.S0000_353 to i64*, !dbg !23
+  call void @main_use_renamed(i64* %2), !dbg !23
+  ret void, !dbg !24
+}
+
+define internal void @main_use_renamed(i64* noalias %.S0000) !dbg !14 {
+L.entry:
+  ret void, !dbg !25
+}
+
+declare void @fort_init(...)
+
+!llvm.module.flags = !{!21, !22}
+!llvm.dbg.cu = !{!4}
+
+!0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
+!1 = distinct !DIGlobalVariable(name: "var1", scope: !2, file: !3, line: 2, type: !9, isLocal: false, isDefinition: true)
+!2 = !DIModule(scope: !4, name: "mymod", file: !3, line: 1)
+!3 = !DIFile(filename: "DIImportedEntity_elements.f90", directory: "/tmp")
+!4 = distinct !DICompileUnit(language: DW_LANG_Fortran90, file: !3, producer: " F90 Flang - 1.5 2017-05-01", isOptimized: false, flags: "'+flang usemodulealias.f90 -g -S -emit-llvm'", runtimeVersion: 0, emissionKind: FullDebug, enums: !5, retainedTypes: !5, globals: !6, imports: !12, nameTableKind: None)
+!5 = !{}
+!6 = !{!0, !7, !10}
+!7 = !DIGlobalVariableExpression(var: !8, expr: !DIExpression(DW_OP_plus_uconst, 4))
+!8 = distinct !DIGlobalVariable(name: "var2", scope: !2, file: !3, line: 3, type: !9, isLocal: false, isDefinition: true)
+!9 = !DIBasicType(name: "integer", size: 32, align: 32, encoding: DW_ATE_signed)
+!10 = !DIGlobalVariableExpression(var: !11, expr: !DIExpression(DW_OP_plus_uconst, 8))
+!11 = distinct !DIGlobalVariable(name: "var3", scope: !2, file: !3, line: 4, type: !9, isLocal: false, isDefinition: true)
+!12 = !{!13}
+!13 = !DIImportedEntity(tag: DW_TAG_imported_module, scope: !14, entity: !2, file: !3, line: 10, elements: !19)
+!14 = distinct !DISubprogram(name: "use_renamed", scope: !15, file: !3, line: 10, type: !18, scopeLine: 10, flags: DIFlagAllCallsDescribed, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !4)
+!15 = distinct !DISubprogram(name: "main", scope: !4, file: !3, line: 7, type: !16, scopeLine: 7, flags: DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagMainSubprogram, unit: !4)
+!16 = !DISubroutineType(cc: DW_CC_program, types: !17)
+!17 = !{null}
+!18 = !DISubroutineType(types: !17)
+!19 = !{!20}
+!20 = !DIImportedEntity(tag: DW_TAG_imported_declaration, name: "var4", scope: !14, entity: !1, file: !3, line: 10)
+!21 = !{i32 2, !"Dwarf Version", i32 4}
+!22 = !{i32 2, !"Debug Info Version", i32 3}
+!23 = !DILocation(line: 8, column: 1, scope: !15)
+!24 = !DILocation(line: 9, column: 1, scope: !15)
+!25 = !DILocation(line: 13, column: 1, scope: !14)

llvm/test/DebugInfo/X86/dwarfdump-DIImportedEntity_elements.ll

+;; This test checks processing of DIImportedEntity with elements field.
+; REQUIRES: x86_64-linux
+
+; RUN: llc %s -filetype=obj -o - | llvm-dwarfdump - | FileCheck %s
+
+; CHECK: [[MYMOD:0x[0-9a-f]+]]: DW_TAG_module
+; CHECK:   DW_AT_name      ("mymod")
+; CHECK:   [[VAR1:0x[0-9a-f]+]]: DW_TAG_variable
+; CHECK:     DW_AT_name    ("var1")
+
+; CHECK: DW_TAG_subprogram
+; CHECK:   DW_AT_name      ("main")
+; CHECK:   DW_TAG_subprogram
+; CHECK:     DW_AT_name      ("use_renamed")
+; CHECK:     DW_TAG_imported_module
+; CHECK:       DW_AT_import ([[MYMOD]])
+; CHECK:       DW_TAG_imported_declaration
+; CHECK:         DW_AT_import ([[VAR1]])
+; CHECK:         DW_AT_name        ("var4")
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;This test case is generated from
+;;module mymod
+;;  integer :: var1 = 11
+;;  integer :: var2 = 12
+;;  integer :: var3 = 13
+;;end module mymod
+;;
+;;Program main
+;;  call use_renamed()
+;;  contains
+;;    subroutine use_renamed()
+;;      use mymod, var4 => var1
+;;      print *, var4
+;;    end subroutine use_renamed
+;;end program main
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+; ModuleID = 'DIImportedEntity_elements.ll'
+source_filename = "/tmp/usemodulealias.ll"
+
+%struct_mymod_8_ = type <{ [12 x i8] }>
+%struct.struct_ul_MAIN__348 = type { i8* }
+
+@_mymod_8_ = global %struct_mymod_8_ <{ [12 x i8] c"\0B\00\00\00\0C\00\00\00\0D\00\00\00" }>, align 64, !dbg !0, !dbg !7, !dbg !10
+@.C330_MAIN_ = internal constant i32 0
+@.C364_main_use_renamed = internal constant i32 25
+@.C330_main_use_renamed = internal constant i32 0
+@.C331_main_use_renamed = internal constant i64 0
+@.C359_main_use_renamed = internal constant i32 6
+@.C357_main_use_renamed = internal constant [18 x i8] c"usemodulealias.f90"
+@.C352_main_use_renamed = internal constant i32 12
+
+define i32 @mymod_() {
+.L.entry:
+  ret i32 undef
+}
+
+define void @MAIN_() !dbg !15 {
+L.entry:
+  %.S0000_353 = alloca %struct.struct_ul_MAIN__348, align 8
+  %0 = bitcast i32* @.C330_MAIN_ to i8*
+  %1 = bitcast void (...)* @fort_init to void (i8*, ...)*
+  call void (i8*, ...) %1(i8* %0)
+  br label %L.LB2_357
+
+L.LB2_357:                                        ; preds = %L.entry
+  %2 = bitcast %struct.struct_ul_MAIN__348* %.S0000_353 to i64*, !dbg !23
+  call void @main_use_renamed(i64* %2), !dbg !23
+  ret void, !dbg !24
+}
+
+define internal void @main_use_renamed(i64* noalias %.S0000) !dbg !14 {
+L.entry:
+  ret void, !dbg !25
+}
+
+declare void @fort_init(...)
+
+!llvm.module.flags = !{!21, !22}
+!llvm.dbg.cu = !{!4}
+
+!0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
+!1 = distinct !DIGlobalVariable(name: "var1", scope: !2, file: !3, line: 2, type: !9, isLocal: false, isDefinition: true)
+!2 = !DIModule(scope: !4, name: "mymod", file: !3, line: 1)
+!3 = !DIFile(filename: "DIImportedEntity_elements.f90", directory: "/tmp")
+!4 = distinct !DICompileUnit(language: DW_LANG_Fortran90, file: !3, producer: " F90 Flang - 1.5 2017-05-01", isOptimized: false, flags: "'+flang usemodulealias.f90 -g -S -emit-llvm'", runtimeVersion: 0, emissionKind: FullDebug, enums: !5, retainedTypes: !5, globals: !6, imports: !12, nameTableKind: None)
+!5 = !{}
+!6 = !{!0, !7, !10}
+!7 = !DIGlobalVariableExpression(var: !8, expr: !DIExpression(DW_OP_plus_uconst, 4))
+!8 = distinct !DIGlobalVariable(name: "var2", scope: !2, file: !3, line: 3, type: !9, isLocal: false, isDefinition: true)
+!9 = !DIBasicType(name: "integer", size: 32, align: 32, encoding: DW_ATE_signed)
+!10 = !DIGlobalVariableExpression(var: !11, expr: !DIExpression(DW_OP_plus_uconst, 8))
+!11 = distinct !DIGlobalVariable(name: "var3", scope: !2, file: !3, line: 4, type: !9, isLocal: false, isDefinition: true)
+!12 = !{!13}
+!13 = !DIImportedEntity(tag: DW_TAG_imported_module, scope: !14, entity: !2, file: !3, line: 10, elements: !19)
+!14 = distinct !DISubprogram(name: "use_renamed", scope: !15, file: !3, line: 10, type: !18, scopeLine: 10, flags: DIFlagAllCallsDescribed, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !4)
+!15 = distinct !DISubprogram(name: "main", scope: !4, file: !3, line: 7, type: !16, scopeLine: 7, flags: DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagMainSubprogram, unit: !4)
+!16 = !DISubroutineType(cc: DW_CC_program, types: !17)
+!17 = !{null}
+!18 = !DISubroutineType(types: !17)
+!19 = !{!20}
+!20 = !DIImportedEntity(tag: DW_TAG_imported_declaration, name: "var4", scope: !14, entity: !1, file: !3, line: 10)
+!21 = !{i32 2, !"Dwarf Version", i32 4}
+!22 = !{i32 2, !"Debug Info Version", i32 3}
+!23 = !DILocation(line: 8, column: 1, scope: !15)
+!24 = !DILocation(line: 9, column: 1, scope: !15)
+!25 = !DILocation(line: 13, column: 1, scope: !14)

llvm/tools/llvm-c-test/debuginfo.c

LLVMDIBuilderCreateModule(DIB, CompileUnit,
                               "", 0);
 
   LLVMMetadataRef OtherModule =
     LLVMDIBuilderCreateModule(DIB, CompileUnit,
                               "llvm-c-test-import", 18,
                               "", 0,
                               "/test/include/llvm-c-test-import.h", 34,
                               "", 0);
-  LLVMMetadataRef ImportedModule =
-    LLVMDIBuilderCreateImportedModuleFromModule(DIB, Module, OtherModule,
-                                                File, 42);
-  LLVMDIBuilderCreateImportedModuleFromAlias(DIB, Module, ImportedModule,
-                                             File, 42);
+  LLVMMetadataRef ImportedModule = LLVMDIBuilderCreateImportedModuleFromModule(
+      DIB, Module, OtherModule, File, 42, NULL, 0);
+  LLVMDIBuilderCreateImportedModuleFromAlias(DIB, Module, ImportedModule, File,
+                                             42, NULL, 0);
 
   LLVMMetadataRef ClassTy = declare_objc_class(DIB, File);
   LLVMMetadataRef GlobalClassValueExpr =
       LLVMDIBuilderCreateConstantValueExpression(DIB, 0);
   LLVMDIBuilderCreateGlobalVariableExpression(
       DIB, Module, "globalClass", 11, "", 0, File, 1, ClassTy, true,
       GlobalClassValueExpr, NULL, 0);
 

llvm/unittests/IR/IRBuilderTest.cpp

 
 TEST_F(IRBuilderTest, DIImportedEntity) {
   IRBuilder<> Builder(BB);
   DIBuilder DIB(*M);
   auto F = DIB.createFile("F.CBL", "/");
   auto CU = DIB.createCompileUnit(dwarf::DW_LANG_Cobol74,
                                   F, "llvm-cobol74",
                                   true, "", 0);
+  MDTuple *Elements = MDTuple::getDistinct(Ctx, None);
+
   DIB.createImportedDeclaration(CU, nullptr, F, 1);
   DIB.createImportedDeclaration(CU, nullptr, F, 1);
   DIB.createImportedModule(CU, (DIImportedEntity *)nullptr, F, 2);
   DIB.createImportedModule(CU, (DIImportedEntity *)nullptr, F, 2);
+  DIB.createImportedModule(CU, (DIImportedEntity *)nullptr, F, 2, Elements);
+  DIB.createImportedModule(CU, (DIImportedEntity *)nullptr, F, 2, Elements);
   DIB.finalize();
   EXPECT_TRUE(verifyModule(*M));
-  EXPECT_TRUE(CU->getImportedEntities().size() == 2);
+  EXPECT_TRUE(CU->getImportedEntities().size() == 3);
 }
 
 //  0: #define M0 V0          <-- command line definition
 //  0: main.c                 <-- main file
 //     3:   #define M1 V1     <-- M1 definition in main.c
 //     5:   #include "file.h" <-- inclusion of file.h from main.c
 //          1: #define M2     <-- M2 definition in file.h with no value
 //     7:   #undef M1 V1      <-- M1 un-definition in main.c

llvm/unittests/IR/MetadataTest.cpp

EXPECT_NE(N, DIImportedEntity::get(Context, Tag, Scope, Entity, nullptr, Line,
                                      Name));
   EXPECT_NE(N, DIImportedEntity::get(Context, Tag, Scope, Entity, File,
                                      Line + 1, Name));
   EXPECT_NE(N, DIImportedEntity::get(Context, Tag, Scope, Entity, File, Line,
                                      "other"));
 
   TempDIImportedEntity Temp = N->clone();
   EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
+
+  MDTuple *Elements1 = getTuple();
+  MDTuple *Elements2 = getTuple();
+  auto *Ne = DIImportedEntity::get(Context, Tag, Scope, Entity, File, Line,
+                                   Name, Elements1);
+
+  EXPECT_EQ(Elements1, Ne->getElements().get());
+
+  EXPECT_EQ(Ne, DIImportedEntity::get(Context, Tag, Scope, Entity, File, Line,
+                                      Name, Elements1));
+  EXPECT_NE(Ne, DIImportedEntity::get(Context, Tag, Scope, Entity, File, Line,
+                                      "ModOther", Elements1));
+  EXPECT_NE(Ne, DIImportedEntity::get(Context, Tag, Scope, Entity, File, Line,
+                                      Name, Elements2));
+  EXPECT_NE(
+      Ne, DIImportedEntity::get(Context, Tag, Scope, Entity, File, Line, Name));
+
+  TempDIImportedEntity Tempe = Ne->clone();
+  EXPECT_EQ(Ne, MDNode::replaceWithUniqued(std::move(Tempe)));
 }
 
 typedef MetadataTest MetadataAsValueTest;
 
 TEST_F(MetadataAsValueTest, MDNode) {
   MDNode *N = MDNode::get(Context, None);
   auto *V = MetadataAsValue::get(Context, N);
   EXPECT_TRUE(V->getType()->isMetadataTy());