[DebugInfo] Fortran module DebugInfo support in LLVM

[SouraVX]

Summary

This patch extends DIModule Debug metadata in LLVM to support Fortran modules. DIModule is extended to contain File and Line fields, these fields will be used by Flang FE to create debug information necessary for representing Fortran modules at IR level.
Furthermore DW_TAG_module is also extended to contain these fields. If these fields are missing, debuggers like GDB
won't be able to show Fortran modules information correctly.

[aprantl]

Generally, this sounds reasonable, thanks!

Is the line and file is necessary because in Fortran you may have more than one module declaration per file? Out of curiosity, what does the debugger use the line/file info for?

In addition to the inline comments:
Please make sure to provide a bitcode/assembler roundtrip test, maybe in test/Assembler/dimodule.ll
I'm unsure that the metadataloader implementation is correct. Can you also add a bitcode upgrade test to test/Bitcode/ that shows that the older, shorter format is handled correctly?

llvm/include/llvm/IR/DIBuilder.h

745

/// \param File Source file of the module declaration. Used for Fortran modules.

748

same here

752

This makes it quite opaque what the actual default value is.
LineNo = 0?

llvm/include/llvm/IR/DebugInfoMetadata.h

2081

/// Represents a module in the programming language, for example, a Clang module, or a Fortran module.

2139

The parent class DIScope already provides a getFile() method. Are we storing the file operand twice?

llvm/lib/Bitcode/Reader/MetadataLoader.cpp

1430

Will this crash when we get an input with only 6 records?

Is there a bitcode upgrade test that shows that the older, shorter format is handled gracefully?

llvm/lib/IR/LLVMContextImpl.h

849

How likely is it going to be that you have two fortran modules with the same name but a different, file or lineno? Is it necessary for performance to hash the file/line?

[SouraVX]

Thanks for review @aprantl .

Please make sure to provide a bitcode/assembler roundtrip test, maybe in test/Assembler/dimodule.ll

I worked on this too, Unfortunately due to messy workspace, I missed out to add this. Meanwhile I have this locally. I guess this test case addresses another concern of yours:

Will this crash when we get an input with only 6 records?

Is the line and file is necessary because in Fortran you may have more than one module declaration per file? Out of curiosity, what does the debugger use the line/file info for?

Yes this is necessary, GDB uses these line/file to display fortran modules info:

(gdb) info modules
File test.f90:
18:     mod2

[SouraVX]

llvm/include/llvm/IR/DebugInfoMetadata.h

2139

Didn't get you completely here, I think that's needed, if you're asking.
Is there better way to accomplish this ? I remember noting some failures when using parent DIScope getFile.

[SouraVX]

Addressed @aprantl comments, Thanks for this!

• Added bitcode round trip test cases to ensure backward compatibility and current version too.
• Added missing test case Assembler/dimodule.ll.
• Addressed other comments.

[SouraVX]

llvm/lib/IR/LLVMContextImpl.h

849

Thanks for pointing this out! This seems like an unlikely situation, therefore removed it.

[schweitz]

I assume there are corresponding changes to flang. Can you provide a link to them? Thanks.

llvm/lib/Bitcode/Reader/MetadataLoader.cpp

1421

It looks like 2 new fields are being added, but only 1 here.

[SouraVX]

I assume there are corresponding changes to flang. Can you provide a link to them? Thanks.

We're yet raise a PR on flang about the corresponding changes. Planning to do it soon, once this is in. BTW we tested flang internally after applying this patch, GDB is able show the modules info.

[SouraVX]

llvm/lib/Bitcode/Reader/MetadataLoader.cpp

1421

Sorry! didn't get you exactly. Two fields 6, 7 are added to capture file, line info.

[aprantl]

llvm/include/llvm/IR/DebugInfoMetadata.h

2139

I remember noting some failures when using parent DIScope getFile.

We'll have to figure that out first.
Looking at the definition of getRawFile() in DIScope, it expects the File to be Operand[0]. Did you take this into account? I think if you change the order of metadata operands to have the File first, you should be able to just use the parent DIScope's getFile functionality. Is that perhaps why it didn't work when you first tried it?

[SouraVX]

Addressed @aprantl review comments, Thanks for this!

• Made DIFile as first metadata operand and removed getFile from DIModule, now it's accessible via DIScope.

[aprantl]

llvm/include/llvm/IR/DIBuilder.h

746

Nit: /// Fortran modules.

748

indentation again

751

= nullptr is also more obvious

llvm/include/llvm/IR/DebugInfoMetadata.h

2081

double space after programming

llvm/lib/AsmParser/LLParser.cpp

4831

missing space after ,

llvm/lib/Bitcode/Reader/MetadataLoader.cpp

1430

This still looks wrong! This will access beyond Record.size() if Record.size() == 6.

llvm/lib/IR/LLVMContextImpl.h

843–844

Here you do need to compare all fields! It's just not necessary to hash them.

llvm/unittests/IR/MetadataTest.cpp

2062

let's use a real, nonzero number here

2085

You need to add two extra tests here. One where only File is different, one where only Line is different.

(We can skip the hashing for performance, but they still must *compare* differently)

[SouraVX]

Addressed @aprantl comments. Thanks for this!

• Added 2 unit test cases in MetadataTest.cpp
• Corrected Metadata loading based on record size.
• Corrected and added compare fields in LLVMContextImpl.
• Corrected all Nits.

[SouraVX]

llvm/lib/Bitcode/Reader/MetadataLoader.cpp

1430

Is this Okay ? if record size is 6 then let the other records null and only access them otherwise.
I didn't noticed any regression failure after this.

llvm/lib/IR/LLVMContextImpl.h

843–844

Thanks for correcting here. I've added the both fields for comparison.

llvm/unittests/IR/MetadataTest.cpp

2085

Done! Thanks!

[aprantl]

llvm/lib/Bitcode/Reader/MetadataLoader.cpp

1431

You could still attack the loader with malformed input here:

if (Record.size() < 5 || Record.size() > 8)

means we accept a size of 6, 7, or 8. That means that

Record.size() == 6 ? 0 : Record[7])),

will access Record[7] if the size is 7.

I would use Record.size() <= 6 ? nullptr : ... and Record.size() <= 7 ? 0 : ..., respectively.

[SouraVX]

Addressed @aprantl comments, Thanks for this!

[SouraVX]

llvm/lib/Bitcode/Reader/MetadataLoader.cpp

1431

Thanks! for the suggestion. Code seems more robust and consistent now.

[aprantl]

llvm/include/llvm/IR/DIBuilder.h

747

/// \param LineNo Source line number of the module declaration.

llvm/lib/Bitcode/Reader/MetadataLoader.cpp

1431

There is one last thing that I still don't understand:

The File is metadata operand 0 (= bitcode Record[1]), and the BitcodeWriter writes out the operands in order (as it should). How does this pass the bitcode upgrade test? Did you remember to create the .bc file with the unmodified llvm-as? Shouldn't the have to reader take into account that we inserted a field in the beginning and thus shift all records by one?

Maybe I'm missing something, but I would expect that we need something like:

unsigned Offset = Record.size() >= 7 ? 1 : 2;

Record[1+Offset], Record[2+Offset], ...

here

[djtodoro]

llvm/lib/IR/DebugInfoMetadata.cpp

744

Is this clang-formated ?

[SouraVX]

llvm/lib/IR/DebugInfoMetadata.cpp

744

Yes!

[SouraVX]

Addressed @aprantl comments, Thanks for this!

• Now Bitcode backward/forward compatibility is maintained.

[SouraVX]

llvm/lib/Bitcode/Reader/MetadataLoader.cpp

1431

Thanks for pointing this out!
That was indeed the problem, test case .bc file DIModule-clang-module.ll.bc was previously generated using modified( i.e after this patch)llvm-as, that's why the issue doesn't surfaced.

In this revision, this file is generated using unmodified(i.e before this patch) llvm-as, and llvm-dis is able to correctly disassemble it.

[aprantl]

I think this should work. Please watch the bots carefully, particularly the stage2 LTO ones after landing this.

llvm/lib/IR/DebugInfoMetadata.cpp

744

Yeah, that's something clang-format will actually do.

[thakis]

This breaks tests on Windows: http://45.33.8.238/win/15149/step_11.txt

Please take a look and revert if it takes a while to investigate.

[russell.gallop]

In D79484#2033645, @thakis wrote:

This breaks tests on Windows: http://45.33.8.238/win/15149/step_11.txt

Please take a look and revert if it takes a while to investigate.

I've pushed a fix for the test here: https://github.com/llvm/llvm-project/commit/a520c89a4768f1e2ad7012eb70ff05357fc5e985

[SouraVX]

In D79484#2033963, @russell.gallop wrote:

In D79484#2033645, @thakis wrote:

This breaks tests on Windows: http://45.33.8.238/win/15149/step_11.txt

Please take a look and revert if it takes a while to investigate.

I've pushed a fix for the test here: https://github.com/llvm/llvm-project/commit/a520c89a4768f1e2ad7012eb70ff05357fc5e985

Thanks for fixing this! Unfortunately didn't received for this failure. I didn't intend to run this on Windows that's why inserted the triple, Seem like %llc_dwarf automatically picks-up/append the systems default triple hence the overall test was failing.

[SouraVX]

@aprantl , Do we also need to upgrade release notes for this change? I mean DIModule has now 2 more fields compared to previous one.

[aprantl]

In the past I have never updated the release notes for debug info metadata changes, since it's a very specialized topic — that doesn't mean you have to follow my bad example, of course ;-)

[SouraVX]

In D79484#2051625, @aprantl wrote:

In the past I have never updated the release notes for debug info metadata changes, since it's a very specialized topic — that doesn't mean you have to follow my bad example, of course ;-)

Done!, please review D80614. Thanks!

llvm/include/llvm/IR/DIBuilder.h

public:
     /// parent scope.
     /// \param Scope       Parent scope
     /// \param Name        Name of this module
     /// \param ConfigurationMacros
     ///                    A space-separated shell-quoted list of -D macro
     ///                    definitions as they would appear on a command line.
     /// \param IncludePath The path to the module map file.
     /// \param APINotesFile The path to an API notes file for this module.
+    /// \param File        Source file of the module declaration. Used for
+    ///                    Fortran modules.
+    /// \param LineNo      Source line number of the  module declaration.
+    ///                    Used for Fortran modules.
     DIModule *createModule(DIScope *Scope, StringRef Name,
-                           StringRef ConfigurationMacros,
-                           StringRef IncludePath, StringRef APINotesFile = {});
+                           StringRef ConfigurationMacros, StringRef IncludePath,
+                           StringRef APINotesFile = {}, DIFile *File = nullptr,
+                           unsigned LineNo = 0);
 
     /// This creates a descriptor for a lexical block with a new file
     /// attached. This merely extends the existing
     /// lexical block as it crosses a file.
     /// \param Scope       Lexical block.
     /// \param File        Source file.
     /// \param Discriminator DWARF path discriminator value.
     DILexicalBlockFile *createLexicalBlockFile(DIScope *Scope, DIFile *File,

llvm/include/llvm/IR/DebugInfoMetadata.h

class DINamespace : public DIScope {
   TempDINamespace cloneImpl() const {
     return getTemporary(getContext(), getScope(), getName(),
                         getExportSymbols());
   }
 
 public:
   DEFINE_MDNODE_GET(DINamespace,
                     (DIScope *Scope, StringRef Name, bool ExportSymbols),
                     (Scope, Name, ExportSymbols))
   DEFINE_MDNODE_GET(DINamespace,
                     (Metadata *Scope, MDString *Name, bool ExportSymbols),
                     (Scope, Name, ExportSymbols))
 
   TempDINamespace clone() const { return cloneImpl(); }
 
   bool getExportSymbols() const { return ExportSymbols; }
   DIScope *getScope() const { return cast_or_null<DIScope>(getRawScope()); }
   StringRef getName() const { return getStringOperand(2); }
 
   Metadata *getRawScope() const { return getOperand(1); }
   MDString *getRawName() const { return getOperandAs<MDString>(2); }
 
   static bool classof(const Metadata *MD) {
     return MD->getMetadataID() == DINamespaceKind;
   }
 };
 
-/// A (clang) module that has been imported by the compile unit.
-///
+/// Represents a module in the programming language, for example, a Clang
+/// module, or a Fortran module.
 class DIModule : public DIScope {
   friend class LLVMContextImpl;
   friend class MDNode;
+  unsigned LineNo;
 
-  DIModule(LLVMContext &Context, StorageType Storage, ArrayRef<Metadata *> Ops)
-      : DIScope(Context, DIModuleKind, Storage, dwarf::DW_TAG_module, Ops) {}
+  DIModule(LLVMContext &Context, StorageType Storage, unsigned LineNo,
+           ArrayRef<Metadata *> Ops)
+      : DIScope(Context, DIModuleKind, Storage, dwarf::DW_TAG_module, Ops),
+        LineNo(LineNo) {}
   ~DIModule() = default;
 
-  static DIModule *getImpl(LLVMContext &Context, DIScope *Scope, StringRef Name,
-                           StringRef ConfigurationMacros, StringRef IncludePath,
-                           StringRef APINotesFile, StorageType Storage,
+  static DIModule *getImpl(LLVMContext &Context, DIFile *File, DIScope *Scope,
+                           StringRef Name, StringRef ConfigurationMacros,
+                           StringRef IncludePath, StringRef APINotesFile,
+                           unsigned LineNo, StorageType Storage,
                            bool ShouldCreate = true) {
-    return getImpl(Context, Scope, getCanonicalMDString(Context, Name),
+    return getImpl(Context, File, Scope, getCanonicalMDString(Context, Name),
                    getCanonicalMDString(Context, ConfigurationMacros),
                    getCanonicalMDString(Context, IncludePath),
-                   getCanonicalMDString(Context, APINotesFile),
-                   Storage, ShouldCreate);
+                   getCanonicalMDString(Context, APINotesFile), LineNo, Storage,
+                   ShouldCreate);
   }
-  static DIModule *getImpl(LLVMContext &Context, Metadata *Scope,
-                           MDString *Name, MDString *ConfigurationMacros,
-                           MDString *IncludePath, MDString *APINotesFile,
+  static DIModule *getImpl(LLVMContext &Context, Metadata *File,
+                           Metadata *Scope, MDString *Name,
+                           MDString *ConfigurationMacros, MDString *IncludePath,
+                           MDString *APINotesFile, unsigned LineNo,
                            StorageType Storage, bool ShouldCreate = true);
 
   TempDIModule cloneImpl() const {
-    return getTemporary(getContext(), getScope(), getName(),
+    return getTemporary(getContext(), getFile(), getScope(), getName(),
                         getConfigurationMacros(), getIncludePath(),
-                        getAPINotesFile());
+                        getAPINotesFile(), getLineNo());
   }
 
 public:
   DEFINE_MDNODE_GET(DIModule,
-                    (DIScope * Scope, StringRef Name,
+                    (DIFile * File, DIScope *Scope, StringRef Name,
                      StringRef ConfigurationMacros, StringRef IncludePath,
-                     StringRef APINotesFile),
-                    (Scope, Name, ConfigurationMacros, IncludePath,
-                     APINotesFile))
+                     StringRef APINotesFile, unsigned LineNo),
+                    (File, Scope, Name, ConfigurationMacros, IncludePath,
+                     APINotesFile, LineNo))
   DEFINE_MDNODE_GET(DIModule,
-                    (Metadata * Scope, MDString *Name,
+                    (Metadata * File, Metadata *Scope, MDString *Name,
                      MDString *ConfigurationMacros, MDString *IncludePath,
-                     MDString *APINotesFile),
-                    (Scope, Name, ConfigurationMacros, IncludePath,
-                     APINotesFile))
+                     MDString *APINotesFile, unsigned LineNo),
+                    (File, Scope, Name, ConfigurationMacros, IncludePath,
+                     APINotesFile, LineNo))
 
   TempDIModule clone() const { return cloneImpl(); }
 
   DIScope *getScope() const { return cast_or_null<DIScope>(getRawScope()); }
-  StringRef getName() const { return getStringOperand(1); }
-  StringRef getConfigurationMacros() const { return getStringOperand(2); }
-  StringRef getIncludePath() const { return getStringOperand(3); }
-  StringRef getAPINotesFile() const { return getStringOperand(4); }
+  StringRef getName() const { return getStringOperand(2); }
+  StringRef getConfigurationMacros() const { return getStringOperand(3); }
+  StringRef getIncludePath() const { return getStringOperand(4); }
+  StringRef getAPINotesFile() const { return getStringOperand(5); }
+  unsigned getLineNo() const { return LineNo; }
 
-  Metadata *getRawScope() const { return getOperand(0); }
-  MDString *getRawName() const { return getOperandAs<MDString>(1); }
-  MDString *getRawConfigurationMacros() const { return getOperandAs<MDString>(2); }
-  MDString *getRawIncludePath() const { return getOperandAs<MDString>(3); }
-  MDString *getRawAPINotesFile() const { return getOperandAs<MDString>(4); }
+  Metadata *getRawScope() const { return getOperand(1); }
+  MDString *getRawName() const { return getOperandAs<MDString>(2); }
+  MDString *getRawConfigurationMacros() const {
+    return getOperandAs<MDString>(3);
+  }
+  MDString *getRawIncludePath() const { return getOperandAs<MDString>(4); }
+  MDString *getRawAPINotesFile() const { return getOperandAs<MDString>(5); }
 
   static bool classof(const Metadata *MD) {
     return MD->getMetadataID() == DIModuleKind;
   }
 };
 
 /// Base class for template parameters.
 class DITemplateParameter : public DINode {

llvm/lib/AsmParser/LLParser.cpp

#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED)                                    \
   OPTIONAL(name, MDStringField, );                                             \
   OPTIONAL(file, MDField, );                                                   \
   OPTIONAL(line, LineField, );
   PARSE_MD_FIELDS();
 #undef VISIT_MD_FIELDS
 
   Result = GET_OR_DISTINCT(DICommonBlock,
                            (Context, scope.Val, declaration.Val, name.Val,
                             file.Val, line.Val));
   return false;
 }
 
 /// ParseDINamespace:
 ///   ::= !DINamespace(scope: !0, file: !2, name: "SomeNamespace", line: 9)
 bool LLParser::ParseDINamespace(MDNode *&Result, bool IsDistinct) {
 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED)                                    \
   REQUIRED(scope, MDField, );                                                  \

 #undef VISIT_MD_FIELDS
 
   Result = GET_OR_DISTINCT(DIMacroFile,
                            (Context, type.Val, line.Val, file.Val, nodes.Val));
   return false;
 }
 
 /// ParseDIModule:
-///   ::= !DIModule(scope: !0, name: "SomeModule", configMacros: "-DNDEBUG",
-///                 includePath: "/usr/include", apinotes: "module.apinotes")
+///   ::= !DIModule(scope: !0, name: "SomeModule", configMacros:
+///   "-DNDEBUG", includePath: "/usr/include", apinotes: "module.apinotes",
+///   file: !1, line: 4)
 bool LLParser::ParseDIModule(MDNode *&Result, bool IsDistinct) {
 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED)                                    \
   REQUIRED(scope, MDField, );                                                  \
   REQUIRED(name, MDStringField, );                                             \
   OPTIONAL(configMacros, MDStringField, );                                     \
   OPTIONAL(includePath, MDStringField, );                                      \
-  OPTIONAL(apinotes, MDStringField, );
+  OPTIONAL(apinotes, MDStringField, );                                         \
+  OPTIONAL(file, MDField, );                                                   \
+  OPTIONAL(line, LineField, );
   PARSE_MD_FIELDS();
 #undef VISIT_MD_FIELDS
 
-  Result =
-      GET_OR_DISTINCT(DIModule, (Context, scope.Val, name.Val, configMacros.Val,
-                                 includePath.Val, apinotes.Val));
+  Result = GET_OR_DISTINCT(DIModule, (Context, file.Val, scope.Val, name.Val,
+                                      configMacros.Val, includePath.Val,
+                                      apinotes.Val, line.Val));
   return false;
 }
 
 /// ParseDITemplateTypeParameter:
 ///   ::= !DITemplateTypeParameter(name: "Ty", type: !1, defaulted: false)
 bool LLParser::ParseDITemplateTypeParameter(MDNode *&Result, bool IsDistinct) {
 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED)                                    \
   OPTIONAL(name, MDStringField, );                                             \

llvm/lib/Bitcode/Reader/MetadataLoader.cpp

if (Record.size() < 3 || Record.size() > 4)
       return error("Invalid record");
     bool IsOldTypeRefArray = Record[0] < 2;
     unsigned CC = (Record.size() > 3) ? Record[3] : 0;
 
     IsDistinct = Record[0] & 0x1;
     DINode::DIFlags Flags = static_cast<DINode::DIFlags>(Record[1]);
     Metadata *Types = getMDOrNull(Record[2]);
     if (LLVM_UNLIKELY(IsOldTypeRefArray))
       Types = MetadataList.upgradeTypeRefArray(Types);
 
     MetadataList.assignValue(
         GET_OR_DISTINCT(DISubroutineType, (Context, Flags, CC, Types)),
         NextMetadataNo);
     NextMetadataNo++;
     break;
   }
 
   case bitc::METADATA_MODULE: {
-    if (Record.size() < 5 || Record.size() > 7)
+    if (Record.size() < 5 || Record.size() > 8)
       return error("Invalid record");
 
+    unsigned Offset = Record.size() >= 7 ? 2 : 1;
     IsDistinct = Record[0];
     MetadataList.assignValue(
-        GET_OR_DISTINCT(DIModule,
-                        (Context, getMDOrNull(Record[1]),
-                         getMDString(Record[2]), getMDString(Record[3]),
-                         getMDString(Record[4]), getMDString(Record[5]))),
+        GET_OR_DISTINCT(
+            DIModule,
+            (Context, Record.size() >= 7 ? getMDOrNull(Record[1]) : nullptr,
+             getMDOrNull(Record[0 + Offset]), getMDString(Record[1 + Offset]),
+             getMDString(Record[2 + Offset]), getMDString(Record[3 + Offset]),
+             getMDString(Record[4 + Offset]),
+             Record.size() <= 7 ? 0 : Record[7])),
         NextMetadataNo);
     NextMetadataNo++;
     break;
   }
 
   case bitc::METADATA_FILE: {
     if (Record.size() != 3 && Record.size() != 5 && Record.size() != 6)
       return error("Invalid record");

llvm/lib/Bitcode/Writer/BitcodeWriter.cpp

 }
 
 void ModuleBitcodeWriter::writeDIModule(const DIModule *N,
                                         SmallVectorImpl<uint64_t> &Record,
                                         unsigned Abbrev) {
   Record.push_back(N->isDistinct());
   for (auto &I : N->operands())
     Record.push_back(VE.getMetadataOrNullID(I));
+  Record.push_back(N->getLineNo());
 
   Stream.EmitRecord(bitc::METADATA_MODULE, Record, Abbrev);
   Record.clear();
 }
 
 void ModuleBitcodeWriter::writeDITemplateTypeParameter(
     const DITemplateTypeParameter *N, SmallVectorImpl<uint64_t> &Record,
     unsigned Abbrev) {

llvm/lib/CodeGen/AsmPrinter/DwarfUnit.cpp

DIE *DwarfUnit::getOrCreateModule(const DIModule *M) {
   }
   if (!M->getConfigurationMacros().empty())
     addString(MDie, dwarf::DW_AT_LLVM_config_macros,
               M->getConfigurationMacros());
   if (!M->getIncludePath().empty())
     addString(MDie, dwarf::DW_AT_LLVM_include_path, M->getIncludePath());
   if (!M->getAPINotesFile().empty())
     addString(MDie, dwarf::DW_AT_LLVM_apinotes, M->getAPINotesFile());
+  if (M->getFile())
+    addUInt(MDie, dwarf::DW_AT_decl_file, None,
+            getOrCreateSourceID(M->getFile()));
+  if (M->getLineNo())
+    addUInt(MDie, dwarf::DW_AT_decl_line, None, M->getLineNo());
 
   return &MDie;
 }
 
 DIE *DwarfUnit::getOrCreateSubprogramDIE(const DISubprogram *SP, bool Minimal) {
   // Construct the context before querying for the existence of the DIE in case
   // such construction creates the DIE (as is the case for member function
   // declarations).

llvm/lib/IR/AsmWriter.cpp

static void writeDIModule(raw_ostream &Out, const DIModule *N,
                           const Module *Context) {
   Out << "!DIModule(";
   MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);
   Printer.printMetadata("scope", N->getRawScope(), /* ShouldSkipNull */ false);
   Printer.printString("name", N->getName());
   Printer.printString("configMacros", N->getConfigurationMacros());
   Printer.printString("includePath", N->getIncludePath());
   Printer.printString("apinotes", N->getAPINotesFile());
+  Printer.printMetadata("file", N->getRawFile());
+  Printer.printInt("line", N->getLineNo());
   Out << ")";
 }
 
 
 static void writeDITemplateTypeParameter(raw_ostream &Out,
                                          const DITemplateTypeParameter *N,
                                          TypePrinting *TypePrinter,
                                          SlotTracker *Machine,

llvm/lib/IR/DIBuilder.cpp

DINamespace *DIBuilder::createNameSpace(DIScope *Scope, StringRef Name,
   // DICompileUnit. This decision is an explicit tradeoff of link time versus
   // memory usage versus code simplicity and may get revisited in the future.
   return DINamespace::get(VMContext, getNonCompileUnitScope(Scope), Name,
                           ExportSymbols);
 }
 
 DIModule *DIBuilder::createModule(DIScope *Scope, StringRef Name,
                                   StringRef ConfigurationMacros,
-                                  StringRef IncludePath,
-                                  StringRef APINotesFile) {
-  return DIModule::get(VMContext, getNonCompileUnitScope(Scope), Name,
-                       ConfigurationMacros, IncludePath, APINotesFile);
+                                  StringRef IncludePath, StringRef APINotesFile,
+                                  DIFile *File, unsigned LineNo) {
+  return DIModule::get(VMContext, File, getNonCompileUnitScope(Scope), Name,
+                       ConfigurationMacros, IncludePath, APINotesFile, LineNo);
 }
 
 DILexicalBlockFile *DIBuilder::createLexicalBlockFile(DIScope *Scope,
                                                       DIFile *File,
                                                       unsigned Discriminator) {
   return DILexicalBlockFile::get(VMContext, Scope, File, Discriminator);
 }
 

llvm/lib/IR/DebugInfoMetadata.cpp

DICommonBlock *DICommonBlock::getImpl(LLVMContext &Context, Metadata *Scope,
                                       StorageType Storage, bool ShouldCreate) {
   assert(isCanonical(Name) && "Expected canonical MDString");
   DEFINE_GETIMPL_LOOKUP(DICommonBlock, (Scope, Decl, Name, File, LineNo));
   // The nullptr is for DIScope's File operand. This should be refactored.
   Metadata *Ops[] = {Scope, Decl, Name, File};
   DEFINE_GETIMPL_STORE(DICommonBlock, (LineNo), Ops);
 }
 
-DIModule *DIModule::getImpl(LLVMContext &Context, Metadata *Scope,
-                            MDString *Name, MDString *ConfigurationMacros,
+DIModule *DIModule::getImpl(LLVMContext &Context, Metadata *File,
+                            Metadata *Scope, MDString *Name,
+                            MDString *ConfigurationMacros,
                             MDString *IncludePath, MDString *APINotesFile,
-                            StorageType Storage, bool ShouldCreate) {
+                            unsigned LineNo, StorageType Storage,
+                            bool ShouldCreate) {
   assert(isCanonical(Name) && "Expected canonical MDString");
-  DEFINE_GETIMPL_LOOKUP(
-      DIModule, (Scope, Name, ConfigurationMacros, IncludePath, APINotesFile));
-  Metadata *Ops[] = {Scope, Name, ConfigurationMacros, IncludePath,
-                     APINotesFile};
-  DEFINE_GETIMPL_STORE_NO_CONSTRUCTOR_ARGS(DIModule, Ops);
+  DEFINE_GETIMPL_LOOKUP(DIModule, (File, Scope, Name, ConfigurationMacros,
+                                   IncludePath, APINotesFile, LineNo));
+  Metadata *Ops[] = {File,        Scope,       Name, ConfigurationMacros,
+                     IncludePath, APINotesFile};
+  DEFINE_GETIMPL_STORE(DIModule, (LineNo), Ops);
 }
 
 DITemplateTypeParameter *
 DITemplateTypeParameter::getImpl(LLVMContext &Context, MDString *Name,
                                  Metadata *Type, bool isDefault,
                                  StorageType Storage, bool ShouldCreate) {
   assert(isCanonical(Name) && "Expected canonical MDString");
   DEFINE_GETIMPL_LOOKUP(DITemplateTypeParameter, (Name, Type, isDefault));

llvm/lib/IR/LLVMContextImpl.h

template <> struct MDNodeKeyImpl<DICommonBlock> {
   }
 
   unsigned getHashValue() const {
     return hash_combine(Scope, Decl, Name, File, LineNo);
   }
 };
 
 template <> struct MDNodeKeyImpl<DIModule> {
+  Metadata *File;
   Metadata *Scope;
   MDString *Name;
   MDString *ConfigurationMacros;
   MDString *IncludePath;
   MDString *APINotesFile;
+  unsigned LineNo;
 
-  MDNodeKeyImpl(Metadata *Scope, MDString *Name, MDString *ConfigurationMacros,
-                MDString *IncludePath, MDString *APINotesFile)
-      : Scope(Scope), Name(Name), ConfigurationMacros(ConfigurationMacros),
-        IncludePath(IncludePath), APINotesFile(APINotesFile) {}
+  MDNodeKeyImpl(Metadata *File, Metadata *Scope, MDString *Name,
+                MDString *ConfigurationMacros, MDString *IncludePath,
+                MDString *APINotesFile, unsigned LineNo)
+      : File(File), Scope(Scope), Name(Name),
+        ConfigurationMacros(ConfigurationMacros), IncludePath(IncludePath),
+        APINotesFile(APINotesFile), LineNo(LineNo) {}
   MDNodeKeyImpl(const DIModule *N)
-      : Scope(N->getRawScope()), Name(N->getRawName()),
+      : File(N->getRawFile()), Scope(N->getRawScope()), Name(N->getRawName()),
         ConfigurationMacros(N->getRawConfigurationMacros()),
         IncludePath(N->getRawIncludePath()),
-        APINotesFile(N->getRawAPINotesFile()) {}
+        APINotesFile(N->getRawAPINotesFile()), LineNo(N->getLineNo()) {}
 
   bool isKeyOf(const DIModule *RHS) const {
     return Scope == RHS->getRawScope() && Name == RHS->getRawName() &&
            ConfigurationMacros == RHS->getRawConfigurationMacros() &&
            IncludePath == RHS->getRawIncludePath() &&
-           APINotesFile == RHS->getRawAPINotesFile();
+           APINotesFile == RHS->getRawAPINotesFile() &&
+           File == RHS->getRawFile() && LineNo == RHS->getLineNo();
   }
 
   unsigned getHashValue() const {
     return hash_combine(Scope, Name, ConfigurationMacros, IncludePath);
   }
 };
 
 template <> struct MDNodeKeyImpl<DITemplateTypeParameter> {
   MDString *Name;
   Metadata *Type;
   bool IsDefault;
 
   MDNodeKeyImpl(MDString *Name, Metadata *Type, bool IsDefault)

llvm/test/Assembler/dimodule.ll

 ; RUN: llvm-as < %s | llvm-dis | llvm-as | llvm-dis | FileCheck %s
 ; RUN: verify-uselistorder %s
 
 ; CHECK: !named = !{!0, !1, !2, !1, !3}
 !named = !{!0, !1, !2, !3, !4}
 
 !0 = distinct !{}
 
 ; CHECK: !1 = !DIModule(scope: !0, name: "Module")
 !1 = !DIModule(scope: !0, name: "Module")
 
 ; CHECK: !2 = !DIModule(scope: !0, name: "Module", configMacros: "-DNDEBUG", includePath: "/usr/include")
 !2 = !DIModule(scope: !0, name: "Module", configMacros: "-DNDEBUG", includePath: "/usr/include")
 
 !3 = !DIModule(scope: !0, name: "Module", configMacros: "")
 
-; CHECK: !3 = !DIModule(scope: !0, name: "Module", configMacros: "-DNDEBUG", includePath: "/usr/include", apinotes: "/tmp/m.apinotes")
-!4 = !DIModule(scope: !0, name: "Module", configMacros: "-DNDEBUG", includePath: "/usr/include", apinotes: "/tmp/m.apinotes")
+; CHECK: !3 = !DIModule(scope: !0, name: "Module", configMacros: "-DNDEBUG", includePath: "/usr/include", apinotes: "/tmp/m.apinotes", file: !0, line: 1)
+!4 = !DIModule(scope: !0, name: "Module", configMacros: "-DNDEBUG", includePath: "/usr/include", apinotes: "/tmp/m.apinotes", file: !0, line: 1)

llvm/test/Bitcode/DIModule-clang-module.ll

+; RUN: llvm-dis -o - %s.bc | FileCheck %s
+
+; CHECK: DIModule(scope: null, name: "DebugModule", configMacros: "-DMODULES=0", includePath: "/", apinotes: "m.apinotes")
+
+; ModuleID = 'DIModule-clang-module.ll'
+
+target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux"
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!6, !7}
+!llvm.ident = !{!8}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_ObjC_plus_plus, file: !1, producer: "clang version 11.0.0", isOptimized: false, runtimeVersion: 2, emissionKind: FullDebug, enums: !2, retainedTypes: !2, globals: !2, imports: !3)
+!1 = !DIFile(filename: "/test.cpp", directory: "/")
+!2 = !{}
+!3 = !{!4}
+!4 = !DIImportedEntity(tag: DW_TAG_imported_declaration, scope: !0, entity: !5, file: !1, line: 5)
+!5 = !DIModule(scope: null, name: "DebugModule", configMacros: "-DMODULES=0", includePath: "/", apinotes: "m.apinotes")
+!6 = !{i32 2, !"Dwarf Version", i32 4}
+!7 = !{i32 2, !"Debug Info Version", i32 3}
+!8 = !{!"clang version 11.0.0"}

llvm/test/Bitcode/DIModule-fortran-module.ll

+; RUN: llvm-dis -o - %s.bc | FileCheck %s
+
+; CHECK: DIModule(scope: !4, name: "dummy", file: !3, line: 2)
+
+; ModuleID = 'DIModule-fortran-module.bc'
+source_filename = "/tmp/module-b198fa.ll"
+target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+%struct_dummy_0_ = type <{ [4 x i8] }>
+
+@_dummy_0_ = common global %struct_dummy_0_ zeroinitializer, align 64, !dbg !0
+
+; Function Attrs: noinline
+define float @dummy_() #0 {
+.L.entry:
+  ret float undef
+}
+
+attributes #0 = { noinline "target-cpu"="x86-64" "target-features"="+cx8,+fxsr,+mmx,+sse,+sse2,+x87" }
+
+!llvm.module.flags = !{!8, !9}
+!llvm.dbg.cu = !{!4}
+
+!0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
+!1 = distinct !DIGlobalVariable(name: "foo", scope: !2, file: !3, type: !7, isLocal: false, isDefinition: true)
+!2 = !DIModule(scope: !4, name: "dummy", file: !3, line: 2)
+!3 = !DIFile(filename: "module.f90", directory: "/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: !5)
+!5 = !{}
+!6 = !{!0}
+!7 = !DIBasicType(name: "integer", size: 32, align: 32, encoding: DW_ATE_signed)
+!8 = !{i32 2, !"Dwarf Version", i32 4}
+!9 = !{i32 2, !"Debug Info Version", i32 3}

llvm/test/DebugInfo/X86/Fortran-DIModule.ll

+; This test checks attributes of a Fortran module.
+; RUN: %llc_dwarf  %s -filetype=obj -o - | \
+; RUN:   llvm-dwarfdump - | FileCheck %s
+
+; CHECK: DW_TAG_module
+; CHECK-NEXT: DW_AT_name      ("dummy")
+; CHECK-NEXT: DW_AT_decl_file ("/fortran/module.f90")
+; CHECK-NEXT: DW_AT_decl_line (2)
+
+; Generated from flang compiler, Fortran source to regenerate:
+; module dummy
+;         integer :: foo
+; end module dummy
+
+; ModuleID = '/tmp/module-b198fa.ll'
+source_filename = "/tmp/module-b198fa.ll"
+target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+%struct_dummy_0_ = type <{ [4 x i8] }>
+
+@_dummy_0_ = common global %struct_dummy_0_ zeroinitializer, align 64, !dbg !0
+
+; Function Attrs: noinline
+define float @dummy_() #0 {
+.L.entry:
+  ret float undef
+}
+
+attributes #0 = { noinline "target-cpu"="x86-64" "target-features"="+cx8,+fxsr,+mmx,+sse,+sse2,+x87" }
+
+!llvm.module.flags = !{!8, !9}
+!llvm.dbg.cu = !{!3}
+
+!0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
+!1 = distinct !DIGlobalVariable(name: "foo", scope: !2, file: !4, type: !7, isLocal: false, isDefinition: true)
+!2 = !DIModule(scope: !3, name: "dummy", file: !4, line: 2)
+!3 = distinct !DICompileUnit(language: DW_LANG_Fortran90, file: !4, producer: " F90 Flang - 1.5 2017-05-01", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !5, retainedTypes: !5, globals: !6, imports: !5)
+!4 = !DIFile(filename: "module.f90", directory: "/fortran")
+!5 = !{}
+!6 = !{!0}
+!7 = !DIBasicType(name: "integer", size: 32, align: 32, encoding: DW_ATE_signed)
+!8 = !{i32 2, !"Dwarf Version", i32 4}
+!9 = !{i32 2, !"Debug Info Version", i32 3}

llvm/unittests/IR/MetadataTest.cpp

TEST_F(DINamespaceTest, get) {
   EXPECT_NE(N, DINamespace::get(Context, getFile(), Name, ExportSymbols));
   EXPECT_NE(N, DINamespace::get(Context, Scope, "other", ExportSymbols));
   EXPECT_NE(N, DINamespace::get(Context, Scope, Name, !ExportSymbols));
 
   TempDINamespace Temp = N->clone();
   EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
 }
 
 typedef MetadataTest DIModuleTest;
 
 TEST_F(DIModuleTest, get) {
+  DIFile *File = getFile();
   DIScope *Scope = getFile();
   StringRef Name = "module";
   StringRef ConfigMacro = "-DNDEBUG";
   StringRef Includes = "-I.";
   StringRef APINotes = "/tmp/m.apinotes";
+  unsigned LineNo = 4;
 
-  auto *N = DIModule::get(Context, Scope, Name, ConfigMacro, Includes, APINotes);
+  auto *N = DIModule::get(Context, File, Scope, Name, ConfigMacro, Includes,
+                          APINotes, LineNo);
 
   EXPECT_EQ(dwarf::DW_TAG_module, N->getTag());
+  EXPECT_EQ(File, N->getFile());
   EXPECT_EQ(Scope, N->getScope());
   EXPECT_EQ(Name, N->getName());
   EXPECT_EQ(ConfigMacro, N->getConfigurationMacros());
   EXPECT_EQ(Includes, N->getIncludePath());
   EXPECT_EQ(APINotes, N->getAPINotesFile());
-  EXPECT_EQ(
-      N, DIModule::get(Context, Scope, Name, ConfigMacro, Includes, APINotes));
-  EXPECT_NE(N, DIModule::get(Context, getFile(), Name, ConfigMacro, Includes,
-                             APINotes));
-  EXPECT_NE(N, DIModule::get(Context, Scope, "other", ConfigMacro, Includes,
-                             APINotes));
-  EXPECT_NE(N,
-            DIModule::get(Context, Scope, Name, "other", Includes, APINotes));
-  EXPECT_NE(
-      N, DIModule::get(Context, Scope, Name, ConfigMacro, "other", APINotes));
-  EXPECT_NE(
-      N, DIModule::get(Context, Scope, Name, ConfigMacro, Includes, "other"));
+  EXPECT_EQ(LineNo, N->getLineNo());
+  EXPECT_EQ(N, DIModule::get(Context, File, Scope, Name, ConfigMacro, Includes,
+                             APINotes, LineNo));
+  EXPECT_NE(N, DIModule::get(Context, getFile(), getFile(), Name, ConfigMacro,
+                             Includes, APINotes, LineNo));
+  EXPECT_NE(N, DIModule::get(Context, File, Scope, "other", ConfigMacro,
+                             Includes, APINotes, LineNo));
+  EXPECT_NE(N, DIModule::get(Context, File, Scope, Name, "other", Includes,
+                             APINotes, LineNo));
+  EXPECT_NE(N, DIModule::get(Context, File, Scope, Name, ConfigMacro, "other",
+                             APINotes, LineNo));
+  EXPECT_NE(N, DIModule::get(Context, File, Scope, Name, ConfigMacro, Includes,
+                             "other", LineNo));
+  EXPECT_NE(N, DIModule::get(Context, getFile(), Scope, Name, ConfigMacro,
+                             Includes, APINotes, LineNo));
+  EXPECT_NE(N, DIModule::get(Context, File, Scope, Name, ConfigMacro, Includes,
+                             APINotes, 5));
 
   TempDIModule Temp = N->clone();
   EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
 }
 
 typedef MetadataTest DITemplateTypeParameterTest;
 
 TEST_F(DITemplateTypeParameterTest, get) {