[DebugInfo] Support DWARFv5 source code embedding extension

[scott.linder]

Summary

In DWARFv5 the Line Number Program Header is extensible, allowing values
with new content types. In this extension two new content types are
added: DW_LNCT_has_source indicates whether embedded source is available
for the file, and DW_LNCT_source contains the embedded source itself.

Add new optional attribute for !DIFile IR metadata called source which
contains source text. Use this to output the source to the DWARF line
table of code objects. Analogously extend METADATA_FILE in Bitcode and
.file directive in ASM to support optional source.

Teach llvm-dwarfdump and llvm-objdump about the new values. Output
the source below file_names entries in llvm-dwarfdump, and support
embedded sources for the -source option in llvm-objdump.

[aprantl]

include/llvm/BinaryFormat/Dwarf.def

750 ↗

(On Diff #132268)

How did you come up with the number?
Are you reasonably sure that no one else is using it?
Perhaps add a prefix like LLVM_ or AMDGPU_ to the constants?

test/Bitcode/metadata-source.ll

16 ↗

(On Diff #132268)

The test with the .bc file in test/Bitcode should be to make sure we correctly upgrade the old format.

To test the new format, there should be a round-trip test in test/IR that does llvm-as | llvm-dis | llvm-as | llvm-dis.

[aprantl]

include/llvm/IR/DebugInfoMetadata.h

512 ↗

(On Diff #132268)

It is probably better to make DIFile variable length so we don't have to pay for the extra pointer when we don't need it.

[JDevlieghere]

docs/AMDGPUUsage.rst

858 ↗

(On Diff #132268)

I learned yesterday that we stylize this as DWARF v5

include/llvm/DebugInfo/DWARF/DWARFDebugLine.h

40 ↗

(On Diff #132268)

Alignment-wise it might be better to swap these two.

76 ↗

(On Diff #132268)

Maybe add a comment like the one above. Now these two look grouped.

include/llvm/IR/DIBuilder.h

151 ↗

(On Diff #132268)

I'm not a fan of these two things not being consistent. Either both should be options or both should be empty StringRefs? This seems to be recurring throughout this patch. I think Optional better conveys the idea, but would require more API changes.

lib/DebugInfo/DWARF/DWARFDebugLine.cpp

923 ↗

(On Diff #132268)

else can be omitted here.

lib/MC/MCParser/AsmParser.cpp

3363 ↗

(On Diff #132268)

else can be omitted here too.

[scott.linder]

Thank you both for the comments, I am switching dev machines so I will be a bit slow to implement the necessary changes.

include/llvm/BinaryFormat/Dwarf.def

750 ↗

(On Diff #132268)

I am in the process of proposing this extension for inclusion in the next DWARF standard, but for now I will add a prefix.

I have not done much research on what values (if any) in the user-range are already in use, so I will try to find some references on that.

include/llvm/IR/DIBuilder.h

151 ↗

(On Diff #132268)

I agree, but would like feedback on the approach to fixing it.

The new code uses an Optional to explicitly support an empty source string, without it being assumed to simply be absent, so that None != "". While it may not have many practical uses, it seems better to be explicit.

The old code is also explicit, but the paired ChecksumKind is what encodes whether a checksum is available. I do not want to duplicate this, as it leads to inconsistencies when CSKind != CSK_None, but Checksum == None, or vice-versa.

The best option I see is to wrap the pair in an optional (Optional<pair<CSKind, Checksum>>), remove the CSK_None variant, and maybe make the pair an explicit struct with members for the kind and checksum. Would this be an acceptable fix?

[JDevlieghere]

include/llvm/IR/DIBuilder.h

151 ↗

(On Diff #132268)

I like the idea of the explicit struct (DIFile::Checksum?) wrapped in an optional. If it's not too big of a change we might as well move the ChecksumKind enum in there too?

[scott.linder]

include/llvm/IR/DIBuilder.h

151 ↗

(On Diff #132268)

I have started an implementation of this change, but am unsure how to deal with backwards compatibility.

The ChecksumKind values appear to map directly to the constants used in the Bitcode, and more critically to the constants used in CodeView debug info; I feel removing the CSK_None variant will obfuscate the relationship, prevent moving these constants to a .def file (a TODO in the code), and force some extra translation to retain compatibility.

If we are OK with this, I am still not certain where the relationship is actually defined; the current DIFile::ChecksumKind simply gets cast to unsigned before being passed to MCStreamer::EmitCVFileDirective. There is no mention of codeview::FileChecksumKind, which does not explicitly define what unsigned integer values map to each variant anyway. The current solution seems very implicit, but I am not confident enough to say it should be changed.

The issue also comes up with IR, as CSK_None will need to be accepted as a valid token, and will need to override any checksum string present.

Assuming these inconsistencies are OK, I don't know how to represent this explicitly in the code; where are "format upgrades" handled? Or should I just accept the old format when parsing (translating things where necessary) and only output the new format (essentially never outputting CSK_None).

The alternative is to retain the CSK_None variant, and wrap it in the Optional, which would allow something of the form of Some(None, "") to be represented, which I would like to avoid. Additionally, when encoding None the actual encoding would need to be defined for CodeView, and I have not yet found where that is explicitly stated.

include/llvm/IR/DebugInfoMetadata.h

512 ↗

(On Diff #132268)

I'm not sure I understand what you mean by variable length here; can you explain, or give me an example to reference?

lib/MC/MCParser/AsmParser.cpp

3363 ↗

(On Diff #132268)

The else here is required; the intent is to support any number of named keywords, while still rejecting unknown keywords. The alternative to the else is to continue at the end of each other branch, which I think is more confusing.

[scott.linder]

I addressed the API concerns in D43043 and it's matching clang patch.

The patch breaks textual IR compatibility, but keeps the Bitcode identical. The CSK_None variant is gone, so there can be no ambiguity with the new Optional.

I also took the opportunity to make the relationship between DIFile::ChecksumKind and codeview::FileChecksumKind explicit.

[scott.linder]

I opened D43623 to update the C-API with checksum support, as this patch adds source support to the same API.

[scott.linder]

The latest diff has a few changes:

• Add support for writing the source text to the .debug_line_str section, rather than inline in the .debug_line (using the recent work done by Paul Robinson).
• Require source text be present in all entries of a line table, or none of them, the same as with MD5. This removes the need for the DW_LNCT_has_source flag, which is removed.
• Add an LLVM_ prefix to the new content type, and confirm the encoding is not in use by GCC.
• Modify the format of file_names in llvm-dwarfdump to accommodate this patch and future changes. The new format places each column on a new line, so it can naturally accommodate new content types, even when they are variable length. Along with this, I updated the display of the .debug_line_str section to quote and escape its contents to prevent interpreting characters like newlines. Affected tests are updated.
• Remove C-API update.
• Update metadata unit test.

There is still an outstanding comment about making a struct variable-length, but I am still not clear what that entails. I believe all other feedback from the previous version of the patch has now been addressed.

[JDevlieghere]

Other than the one small nit about the \brief I have no complaints. So LGTM, but maybe give the others a chance to review this before landing.

include/llvm/MC/MCDwarf.h

60 ↗

(On Diff #135640)

We omit the brief for new/updated code as autobrief is now enabled.

include/llvm/MC/MCStreamer.h

755 ↗

(On Diff #135640)

Same here

[probinson]

It seems a little counter-intuitive for embedded source to have a filename, but I guess that's so the debugger has a familiar-looking handle to refer to it?

include/llvm/IR/DIBuilder.h

22 ↗

(On Diff #135640)

If you have Optional you can remove None.h.

include/llvm/MC/MCStreamer.h

20 ↗

(On Diff #135640)

Optional requires None so you shouldn't need to include None.h explicitly.

lib/Bitcode/Reader/MetadataLoader.cpp

1353 ↗

(On Diff #135640)

This used to error out if size == 4, now it does not?

lib/DebugInfo/DWARF/DWARFDebugLine.cpp

12 ↗

(On Diff #135640)

Optional requires None so you shouldn't need to include None.h explicitly.

lib/IR/DebugInfo.cpp

19 ↗

(On Diff #135640)

This is the only change to DebugInfo.cpp? You shouldn't have to do that.

lib/MC/MCAsmStreamer.cpp

10 ↗

(On Diff #135640)

Optional requires None so I think you don't need to include None.h explicitly.

lib/MC/MCDwarf.cpp

14 ↗

(On Diff #135640)

Adding Optional means you can remove None.h.

test/DebugInfo/X86/generate-odr-hash.ll

128 ↗

(On Diff #135640)

you don't need the trailing {{.*}} on these lines. Also, use SINGLE-NEXT and CHECK-NEXT to check the filenames?

141 ↗

(On Diff #135640)

Don't need the trailing {{.*}} on these checks. Also, use FISSION-NEXT to check the filenames?

test/Linker/subprogram-linkonce-weak.ll

162 ↗

(On Diff #135640)

Don't need the trailing {{.*}} on all the above. Also use -NEXT to check the filenames?

[scott.linder]

This revision addresses the latest round of feedback.

Currently the filename is still included in the line table because the embedded source is acting like a cache, and just makes source available even when the original filesystem is not. For the current implementations we have in mind with the extension, there is already a valid filename to populate here.

[probinson]

LGTM

llvm/trunk/docs/AMDGPUUsage.rst

.. table:: AMDGPU ELF Relocation Records
      ``R_AMDGPU_RELATIVE64``    Dynamic 13     ``word64``  B + A
      ========================== ======= =====  ==========  ==============================
 
 .. _amdgpu-dwarf:
 
 DWARF
 -----
 
-Standard DWARF [DWARF]_ Version 2 sections can be generated. These contain
+Standard DWARF [DWARF]_ Version 5 sections can be generated. These contain
 information that maps the code object executable code and data to the source
 language constructs. It can be used by tools such as debuggers and profilers.
 
 Address Space Mapping
 ~~~~~~~~~~~~~~~~~~~~~
 
 The following address space mapping is used:
 
.. TODO
    spilling). If choose a wide single register approach then use LANE in
    conjunction with PIECE operation to select the dword part of the register for
    the current lane. If the separate register approach then use LANE to select
    the register.
 
 Source Text
 ~~~~~~~~~~~
 
-*This section is WIP.*
+Source text for online-compiled programs (e.g. those compiled by the OpenCL
+runtime) may be embedded into the DWARF v5 line table using the ``clang
+-gembed-source`` option, described in table :ref:`amdgpu-debug-options`.
 
-.. TODO
-   DWARF extension to include runtime generated source text.
+For example:
+
+``-gembed-source``
+  Enable the embedded source DWARF v5 extension.
+``-gno-embed-source``
+  Disable the embedded source DWARF v5 extension.
+
+  .. table:: AMDGPU Debug Options
+     :name: amdgpu-debug-options
+
+     ==================== ==================================================
+     Debug Flag           Description
+     ==================== ==================================================
+     -g[no-]embed-source  Enable/disable embedding source text in DWARF
+                          debug sections. Useful for environments where
+                          source cannot be written to disk, such as
+                          when performing online compilation.
+     ==================== ==================================================
+
+This option enables one extended content types in the DWARF v5 Line Number
+Program Header, which is used to encode embedded source.
+
+  .. table:: AMDGPU DWARF Line Number Program Header Extended Content Types
+     :name: amdgpu-dwarf-extended-content-types
+
+     ============================  ======================
+     Content Type                  Form
+     ============================  ======================
+     ``DW_LNCT_LLVM_source``       ``DW_FORM_line_strp``
+     ============================  ======================
+
+The source field will contain the UTF-8 encoded, null-terminated source text
+with ``'\n'`` line endings. When the source field is present, consumers can use
+the embedded source instead of attempting to discover the source on disk. When
+the source field is absent, consumers can access the file to get the source
+text.
+
+The above content type appears in the ``file_name_entry_format`` field of the
+line table prologue, and its corresponding value appear in the ``file_names``
+field. The current encoding of the content type is documented in table
+:ref:`amdgpu-dwarf-extended-content-types-encoding`
+
+  .. table:: AMDGPU DWARF Line Number Program Header Extended Content Types Encoding
+     :name: amdgpu-dwarf-extended-content-types-encoding
+
+     ============================  ====================
+     Content Type                  Value
+     ============================  ====================
+     ``DW_LNCT_LLVM_source``       0x2001
+     ============================  ====================
 
 .. _amdgpu-code-conventions:
 
 Code Conventions
 ================
 
 This section provides code conventions used for each supported target triple OS
 (see :ref:`amdgpu-target-triples`).

llvm/trunk/include/llvm/BinaryFormat/Dwarf.def

 HANDLE_DW_LNS(0x0c, set_isa)
 
 // DWARF v5 Line number header entry format.
 HANDLE_DW_LNCT(0x01, path)
 HANDLE_DW_LNCT(0x02, directory_index)
 HANDLE_DW_LNCT(0x03, timestamp)
 HANDLE_DW_LNCT(0x04, size)
 HANDLE_DW_LNCT(0x05, MD5)
+// A vendor extension until http://dwarfstd.org/ShowIssue.php?issue=180201.1 is
+// accepted and incorporated into the next DWARF standard.
+HANDLE_DW_LNCT(0x2001, LLVM_source)
 
 // DWARF v5 Macro information.
 HANDLE_DW_MACRO(0x01, define)
 HANDLE_DW_MACRO(0x02, undef)
 HANDLE_DW_MACRO(0x03, start_file)
 HANDLE_DW_MACRO(0x04, end_file)
 HANDLE_DW_MACRO(0x05, define_strp)
 HANDLE_DW_MACRO(0x06, undef_strp)

llvm/trunk/include/llvm/DebugInfo/DIContext.h

 #include <utility>
 
 namespace llvm {
 
 /// A format-neutral container for source line information.
 struct DILineInfo {
   std::string FileName;
   std::string FunctionName;
+  Optional<StringRef> Source;
   uint32_t Line = 0;
   uint32_t Column = 0;
   uint32_t StartLine = 0;
 
   // DWARF-specific.
   uint32_t Discriminator = 0;
 
   DILineInfo() : FileName("<invalid>"), FunctionName("<invalid>") {}

llvm/trunk/include/llvm/DebugInfo/DWARF/DWARFDebugLine.h

 //===- DWARFDebugLine.h -----------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_DEBUGINFO_DWARFDEBUGLINE_H
 #define LLVM_DEBUGINFO_DWARFDEBUGLINE_H
 
+#include "llvm/ADT/Optional.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/DebugInfo/DIContext.h"
 #include "llvm/DebugInfo/DWARF/DWARFDataExtractor.h"
 #include "llvm/DebugInfo/DWARF/DWARFFormValue.h"
 #include "llvm/DebugInfo/DWARF/DWARFRelocMap.h"
 #include "llvm/Support/MD5.h"
 #include <cstdint>
 #include <map>
public:
   struct FileNameEntry {
     FileNameEntry() = default;
 
     DWARFFormValue Name;
     uint64_t DirIdx = 0;
     uint64_t ModTime = 0;
     uint64_t Length = 0;
     MD5::MD5Result Checksum;
+    DWARFFormValue Source;
+  };
+
+  /// Tracks which optional content types are present in a DWARF file name
+  /// entry format.
+  struct ContentTypeTracker {
+    ContentTypeTracker() = default;
+
+    /// Whether filename entries provide a modification timestamp.
+    bool HasModTime = false;
+    /// Whether filename entries provide a file size.
+    bool HasLength = false;
+    /// For v5, whether filename entries provide an MD5 checksum.
+    bool HasMD5 = false;
+    /// For v5, whether filename entries provide source text.
+    bool HasSource = false;
+
+    /// Update tracked content types with \p ContentType.
+    void trackContentType(dwarf::LineNumberEntryFormat ContentType);
   };
 
   struct Prologue {
     Prologue();
 
     /// The size in bytes of the statement information for this compilation unit
     /// (not including the total_length field itself).
     uint64_t TotalLength;
struct Prologue {
     /// The initial value of theis_stmtregister.
     uint8_t DefaultIsStmt;
     /// This parameter affects the meaning of the special opcodes. See below.
     int8_t LineBase;
     /// This parameter affects the meaning of the special opcodes. See below.
     uint8_t LineRange;
     /// The number assigned to the first special opcode.
     uint8_t OpcodeBase;
-    /// For v5, whether filename entries provide an MD5 checksum.
-    bool HasMD5;
+    /// This tracks which optional file format content types are present.
+    ContentTypeTracker ContentTypes;
     std::vector<uint8_t> StandardOpcodeLengths;
     std::vector<DWARFFormValue> IncludeDirectories;
     std::vector<FileNameEntry> FileNames;
 
     const DWARFFormParams getFormParams() const { return FormParams; }
     uint16_t getVersion() const { return FormParams.Version; }
     uint8_t getAddressSize() const { return FormParams.AddrSize; }
     bool isDWARF64() const { return FormParams.Format == dwarf::DWARF64; }
struct LineTable {
 
     struct Prologue Prologue;
     RowVector Rows;
     SequenceVector Sequences;
 
   private:
     uint32_t findRowInSeq(const DWARFDebugLine::Sequence &Seq,
                           uint64_t Address) const;
+    Optional<StringRef> getSourceByIndex(uint64_t FileIndex,
+                                         DILineInfoSpecifier::FileLineInfoKind Kind) const;
   };
 
   const LineTable *getLineTable(uint32_t Offset) const;
   const LineTable *getOrParseLineTable(DWARFDataExtractor &DebugLineData,
                                        uint32_t Offset, const DWARFContext &C,
                                        const DWARFUnit *U);
 
 private:

llvm/trunk/include/llvm/IR/DIBuilder.h

 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_IR_DIBUILDER_H
 #define LLVM_IR_DIBUILDER_H
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/MapVector.h"
-#include "llvm/ADT/None.h"
+#include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/IR/DebugInfo.h"
 #include "llvm/IR/DebugInfoMetadata.h"
 #include "llvm/IR/TrackingMDRef.h"
 #include "llvm/Support/Casting.h"
 #include <algorithm>
createCompileUnit(unsigned Lang, DIFile *File, StringRef Producer,
                           DICompileUnit::DebugEmissionKind::FullDebug,
                       uint64_t DWOId = 0, bool SplitDebugInlining = true,
                       bool DebugInfoForProfiling = false,
                       bool GnuPubnames = false);
 
     /// Create a file descriptor to hold debugging information for a file.
     /// \param Filename  File name.
     /// \param Directory Directory.
-    /// \param Checksum  Checksum kind (e.g. CSK_MD5, CSK_SHA1, etc.) and value.
+    /// \param Checksum  Optional checksum kind (e.g. CSK_MD5, CSK_SHA1, etc.)
+    ///                  and value.
+    /// \param Source    Optional source text.
     DIFile *
     createFile(StringRef Filename, StringRef Directory,
-               Optional<DIFile::ChecksumInfo<StringRef>> Checksum = None);
+               Optional<DIFile::ChecksumInfo<StringRef>> Checksum = None,
+               Optional<StringRef> Source = None);
 
     /// Create debugging information entry for a macro.
     /// \param Parent     Macro parent (could be nullptr).
     /// \param Line       Source line number where the macro is defined.
     /// \param MacroType  DW_MACINFO_define or DW_MACINFO_undef.
     /// \param Name       Macro name.
     /// \param Value      Macro value.
     DIMacro *createMacro(DIMacroFile *Parent, unsigned Line, unsigned MacroType,

llvm/trunk/include/llvm/IR/DebugInfoMetadata.h

DIScope(LLVMContext &C, unsigned ID, StorageType Storage, unsigned Tag,
       : DINode(C, ID, Storage, Tag, Ops) {}
   ~DIScope() = default;
 
 public:
   DIFile *getFile() const { return cast_or_null<DIFile>(getRawFile()); }
 
   inline StringRef getFilename() const;
   inline StringRef getDirectory() const;
+  inline Optional<StringRef> getSource() const;
 
   StringRef getName() const;
   DIScopeRef getScope() const;
 
   /// Return the raw underlying file.
   ///
   /// A \a DIFile is a \a DIScope, but it doesn't point at a separate file (it
   /// \em is the file).  If \c this is an \a DIFile, we need to return \c this.
bool operator==(const ChecksumInfo<T> &X) const {
       return Kind == X.Kind && Value == X.Value;
     }
     bool operator!=(const ChecksumInfo<T> &X) const { return !(*this == X); }
     StringRef getKindAsString() const { return getChecksumKindAsString(Kind); }
   };
 
 private:
   Optional<ChecksumInfo<MDString *>> Checksum;
+  Optional<MDString *> Source;
 
   DIFile(LLVMContext &C, StorageType Storage,
-         Optional<ChecksumInfo<MDString *>> CS,
+         Optional<ChecksumInfo<MDString *>> CS, Optional<MDString *> Src,
          ArrayRef<Metadata *> Ops)
       : DIScope(C, DIFileKind, Storage, dwarf::DW_TAG_file_type, Ops),
-        Checksum(CS) {}
+        Checksum(CS), Source(Src) {}
   ~DIFile() = default;
 
   static DIFile *getImpl(LLVMContext &Context, StringRef Filename,
                          StringRef Directory,
                          Optional<ChecksumInfo<StringRef>> CS,
+                         Optional<StringRef> Source,
                          StorageType Storage, bool ShouldCreate = true) {
     Optional<ChecksumInfo<MDString *>> MDChecksum;
     if (CS)
       MDChecksum.emplace(CS->Kind, getCanonicalMDString(Context, CS->Value));
     return getImpl(Context, getCanonicalMDString(Context, Filename),
                    getCanonicalMDString(Context, Directory), MDChecksum,
+                   Source ? Optional<MDString *>(getCanonicalMDString(Context, *Source)) : None,
                    Storage, ShouldCreate);
   }
   static DIFile *getImpl(LLVMContext &Context, MDString *Filename,
                          MDString *Directory,
                          Optional<ChecksumInfo<MDString *>> CS,
-                         StorageType Storage, bool ShouldCreate = true);
+                         Optional<MDString *> Source, StorageType Storage,
+                         bool ShouldCreate = true);
 
   TempDIFile cloneImpl() const {
     return getTemporary(getContext(), getFilename(), getDirectory(),
-                        getChecksum());
+                        getChecksum(), getSource());
   }
 
 public:
   DEFINE_MDNODE_GET(DIFile, (StringRef Filename, StringRef Directory,
-                             Optional<ChecksumInfo<StringRef>> CS = None),
-                    (Filename, Directory, CS))
+                             Optional<ChecksumInfo<StringRef>> CS = None,
+                             Optional<StringRef> Source = None),
+                    (Filename, Directory, CS, Source))
   DEFINE_MDNODE_GET(DIFile, (MDString * Filename, MDString *Directory,
-                             Optional<ChecksumInfo<MDString *>> CS = None),
-                    (Filename, Directory, CS))
+                             Optional<ChecksumInfo<MDString *>> CS = None,
+                             Optional<MDString *> Source = None),
+                    (Filename, Directory, CS, Source))
 
   TempDIFile clone() const { return cloneImpl(); }
 
   StringRef getFilename() const { return getStringOperand(0); }
   StringRef getDirectory() const { return getStringOperand(1); }
   Optional<ChecksumInfo<StringRef>> getChecksum() const {
     Optional<ChecksumInfo<StringRef>> StringRefChecksum;
     if (Checksum)
       StringRefChecksum.emplace(Checksum->Kind, Checksum->Value->getString());
     return StringRefChecksum;
   }
+  Optional<StringRef> getSource() const {
+    return Source ? Optional<StringRef>((*Source)->getString()) : None;
+  }
 
   MDString *getRawFilename() const { return getOperandAs<MDString>(0); }
   MDString *getRawDirectory() const { return getOperandAs<MDString>(1); }
   Optional<ChecksumInfo<MDString *>> getRawChecksum() const { return Checksum; }
+  Optional<MDString *> getRawSource() const { return Source; }
 
   static StringRef getChecksumKindAsString(ChecksumKind CSKind);
   static Optional<ChecksumKind> getChecksumKind(StringRef CSKindStr);
 
   static bool classof(const Metadata *MD) {
     return MD->getMetadataID() == DIFileKind;
   }
 };
 
 StringRef DIScope::getFilename() const {
   if (auto *F = getFile())
     return F->getFilename();
   return "";
 }
 
 StringRef DIScope::getDirectory() const {
   if (auto *F = getFile())
     return F->getDirectory();
   return "";
 }
 
+Optional<StringRef> DIScope::getSource() const {
+  if (auto *F = getFile())
+    return F->getSource();
+  return None;
+}
+
 /// Base class for types.
 ///
 /// TODO: Remove the hardcoded name and context, since many types don't use
 /// them.
 /// TODO: Split up flags.
 class DIType : public DIScope {
   unsigned Line;
   DIFlags Flags;
public:
 
   DILocation *getInlinedAt() const {
     return cast_or_null<DILocation>(getRawInlinedAt());
   }
 
   DIFile *getFile() const { return getScope()->getFile(); }
   StringRef getFilename() const { return getScope()->getFilename(); }
   StringRef getDirectory() const { return getScope()->getDirectory(); }
+  Optional<StringRef> getSource() const { return getScope()->getSource(); }
 
   /// Get the scope where this is inlined.
   ///
   /// Walk through \a getInlinedAt() and return \a getScope() from the deepest
   /// location.
   DILocalScope *getInlinedAtScope() const {
     if (auto *IA = getInlinedAt())
       return IA->getInlinedAtScope();
public:
   }
 
   StringRef getDirectory() const {
     if (auto *F = getFile())
       return F->getDirectory();
     return "";
   }
 
+  Optional<StringRef> getSource() const {
+    if (auto *F = getFile())
+      return F->getSource();
+    return None;
+  }
+
   Metadata *getRawScope() const { return getOperand(0); }
   MDString *getRawName() const { return getOperandAs<MDString>(1); }
   Metadata *getRawFile() const { return getOperand(2); }
   Metadata *getRawType() const { return getOperand(3); }
 
   static bool classof(const Metadata *MD) {
     return MD->getMetadataID() == DILocalVariableKind ||
            MD->getMetadataID() == DIGlobalVariableKind;
public:
   }
 
   StringRef getDirectory() const {
     if (auto *F = getFile())
       return F->getDirectory();
     return "";
   }
 
+  Optional<StringRef> getSource() const {
+    if (auto *F = getFile())
+      return F->getSource();
+    return None;
+  }
+
   MDString *getRawName() const { return getOperandAs<MDString>(0); }
   Metadata *getRawFile() const { return getOperand(1); }
   MDString *getRawGetterName() const { return getOperandAs<MDString>(2); }
   MDString *getRawSetterName() const { return getOperandAs<MDString>(3); }
   Metadata *getRawType() const { return getOperand(4); }
 
   static bool classof(const Metadata *MD) {
     return MD->getMetadataID() == DIObjCPropertyKind;

llvm/trunk/include/llvm/MC/MCContext.h

 //===- MCContext.h - Machine Code Context -----------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_MC_MCCONTEXT_H
 #define LLVM_MC_MCCONTEXT_H
 
 #include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/BinaryFormat/Dwarf.h"
 #include "llvm/MC/MCAsmMacro.h"
public:
     const std::string &getMainFileName() const { return MainFileName; }
 
     /// \brief Set the main file name and override the default.
     void setMainFileName(StringRef S) { MainFileName = S; }
 
     /// Creates an entry in the dwarf file and directory tables.
     Expected<unsigned> getDwarfFile(StringRef Directory, StringRef FileName,
                                     unsigned FileNumber,
-                                    MD5::MD5Result *Checksum, unsigned CUID);
+                                    MD5::MD5Result *Checksum,
+                                    Optional<StringRef> Source, unsigned CUID);
 
     bool isValidDwarfFileNumber(unsigned FileNumber, unsigned CUID = 0);
 
     const std::map<unsigned, MCDwarfLineTable> &getMCDwarfLineTables() const {
       return MCDwarfLineTablesCUMap;
     }
 
     MCDwarfLineTable &getMCDwarfLineTable(unsigned CUID) {

llvm/trunk/include/llvm/MC/MCDwarf.h

 // .file directive and the .loc directive.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_MC_MCDWARF_H
 #define LLVM_MC_MCDWARF_H
 
 #include "llvm/ADT/MapVector.h"
+#include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/MC/MCSection.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/MD5.h"
 #include <cassert>
 #include <cstdint>

 
 /// \brief Instances of this class represent the name of the dwarf
 /// .file directive and its associated dwarf file number in the MC file,
 /// and MCDwarfFile's are created and uniqued by the MCContext class where
 /// the file number for each is its index into the vector of DwarfFiles (note
 /// index 0 is not used and not a valid dwarf file number).
 struct MCDwarfFile {
   // \brief The base name of the file without its directory path.
-  // The StringRef references memory allocated in the MCContext.
   std::string Name;
 
   // \brief The index into the list of directory names for this file name.
   unsigned DirIndex;
 
   /// The MD5 checksum, if there is one. Non-owning pointer to data allocated
   /// in MCContext.
   MD5::MD5Result *Checksum = nullptr;
+
+  /// The source code of the file. Non-owning reference to data allocated in
+  /// MCContext.
+  Optional<StringRef> Source;
 };
 
 /// \brief Instances of this class represent the information from a
 /// dwarf .loc directive.
 class MCDwarfLoc {
   uint32_t FileNum;
   uint32_t Line;
   uint16_t Column;

 
 struct MCDwarfLineTableHeader {
   MCSymbol *Label = nullptr;
   SmallVector<std::string, 3> MCDwarfDirs;
   SmallVector<MCDwarfFile, 3> MCDwarfFiles;
   StringMap<unsigned> SourceIdMap;
   StringRef CompilationDir;
   bool HasMD5 = false;
+  bool HasSource = false;
 
   MCDwarfLineTableHeader() = default;
 
   Expected<unsigned> tryGetFile(StringRef &Directory, StringRef &FileName,
                                 MD5::MD5Result *Checksum,
+                                Optional<StringRef> &Source,
                                 unsigned FileNumber = 0);
   std::pair<MCSymbol *, MCSymbol *>
   Emit(MCStreamer *MCOS, MCDwarfLineTableParams Params,
        Optional<MCDwarfLineStr> &LineStr) const;
   std::pair<MCSymbol *, MCSymbol *>
   Emit(MCStreamer *MCOS, MCDwarfLineTableParams Params,
        ArrayRef<char> SpecialOpcodeLengths,
        Optional<MCDwarfLineStr> &LineStr) const;
 
 private:
   void emitV2FileDirTables(MCStreamer *MCOS) const;
   void emitV5FileDirTables(MCStreamer *MCOS,
                            Optional<MCDwarfLineStr> &LineStr) const;
 };
 
 class MCDwarfDwoLineTable {
   MCDwarfLineTableHeader Header;
 
 public:
   void setCompilationDir(StringRef CompilationDir) {
     Header.CompilationDir = CompilationDir;
   }
 
   unsigned getFile(StringRef Directory, StringRef FileName,
-                   MD5::MD5Result *Checksum) {
-    return cantFail(Header.tryGetFile(Directory, FileName, Checksum));
+                   MD5::MD5Result *Checksum, Optional<StringRef> Source) {
+    return cantFail(Header.tryGetFile(Directory, FileName, Checksum, Source));
   }
 
   void Emit(MCStreamer &MCOS, MCDwarfLineTableParams Params) const;
 };
 
 class MCDwarfLineTable {
   MCDwarfLineTableHeader Header;
   MCLineSection MCLineSections;
 
 public:
   // This emits the Dwarf file and the line tables for all Compile Units.
   static void Emit(MCObjectStreamer *MCOS, MCDwarfLineTableParams Params);
 
   // This emits the Dwarf file and the line tables for a given Compile Unit.
   void EmitCU(MCObjectStreamer *MCOS, MCDwarfLineTableParams Params,
               Optional<MCDwarfLineStr> &LineStr) const;
 
   Expected<unsigned> tryGetFile(StringRef &Directory, StringRef &FileName,
                                 MD5::MD5Result *Checksum,
+                                Optional<StringRef> Source,
                                 unsigned FileNumber = 0);
   unsigned getFile(StringRef &Directory, StringRef &FileName,
-                   MD5::MD5Result *Checksum, unsigned FileNumber = 0) {
-    return cantFail(tryGetFile(Directory, FileName, Checksum, FileNumber));
+                   MD5::MD5Result *Checksum, Optional<StringRef> &Source,
+                   unsigned FileNumber = 0) {
+    return cantFail(tryGetFile(Directory, FileName, Checksum, Source,
+                               FileNumber));
   }
 
   MCSymbol *getLabel() const {
     return Header.Label;
   }
 
   void setLabel(MCSymbol *Label) {
     Header.Label = Label;

llvm/trunk/include/llvm/MC/MCStreamer.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_MC_MCSTREAMER_H
 #define LLVM_MC_MCSTREAMER_H
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/MC/MCDirectives.h"
 #include "llvm/MC/MCDwarf.h"
 #include "llvm/MC/MCLinkerOptimizationHint.h"
 #include "llvm/MC/MCSymbol.h"
 #include "llvm/MC/MCWinEH.h"
 #include "llvm/Support/Error.h"
public:
   /// '.ident "version foo"' assembler directive.
   virtual void EmitIdent(StringRef IdentString) {}
 
   /// \brief Associate a filename with a specified logical file number.  This
   /// implements the DWARF2 '.file 4 "foo.c"' assembler directive.
   unsigned EmitDwarfFileDirective(unsigned FileNo, StringRef Directory,
                                   StringRef Filename,
                                   MD5::MD5Result *Checksum = nullptr,
+                                  Optional<StringRef> Source = None,
                                   unsigned CUID = 0) {
     return cantFail(
-        tryEmitDwarfFileDirective(FileNo, Directory, Filename, Checksum, CUID));
+        tryEmitDwarfFileDirective(FileNo, Directory, Filename, Checksum,
+                                  Source, CUID));
   }
 
-  /// Associate a filename with a specified logical file number.  Returns a
-  /// StringError for any problem, or the file number.  This implements the
-  /// DWARF2 '.file 4 "foo.c"' assembler directive.
+  /// Associate a filename with a specified logical file number.
+  /// Also associate a directory, optional checksum, and optional source
+  /// text with the logical file.  This implements the DWARF2
+  /// '.file 4 "dir/foo.c"' assembler directive, and the DWARF5
+  /// '.file 4 "dir/foo.c" md5 "..." source "..."' assembler directive.
   virtual Expected<unsigned> tryEmitDwarfFileDirective(
       unsigned FileNo, StringRef Directory, StringRef Filename,
-      MD5::MD5Result *Checksum = nullptr, unsigned CUID = 0);
+      MD5::MD5Result *Checksum = nullptr, Optional<StringRef> Source = None,
+      unsigned CUID = 0);
 
   /// \brief This implements the DWARF2 '.loc fileno lineno ...' assembler
   /// directive.
   virtual void EmitDwarfLocDirective(unsigned FileNo, unsigned Line,
                                      unsigned Column, unsigned Flags,
                                      unsigned Isa, unsigned Discriminator,
                                      StringRef FileName);
 

llvm/trunk/lib/AsmParser/LLParser.cpp

 #undef VISIT_MD_FIELDS
 
   Result = GET_OR_DISTINCT(DISubroutineType,
                            (Context, flags.Val, cc.Val, types.Val));
   return false;
 }
 
 /// ParseDIFileType:
-///   ::= !DIFileType(filename: "path/to/file", directory: "/path/to/dir"
+///   ::= !DIFileType(filename: "path/to/file", directory: "/path/to/dir",
 ///                   checksumkind: CSK_MD5,
-///                   checksum: "000102030405060708090a0b0c0d0e0f")
+///                   checksum: "000102030405060708090a0b0c0d0e0f",
+///                   source: "source file contents")
 bool LLParser::ParseDIFile(MDNode *&Result, bool IsDistinct) {
   // The default constructed value for checksumkind is required, but will never
   // be used, as the parser checks if the field was actually Seen before using
   // the Val.
 #define VISIT_MD_FIELDS(OPTIONAL, REQUIRED)                                    \
   REQUIRED(filename, MDStringField, );                                         \
   REQUIRED(directory, MDStringField, );                                        \
   OPTIONAL(checksumkind, ChecksumKindField, (DIFile::CSK_MD5));                \
-  OPTIONAL(checksum, MDStringField, );
+  OPTIONAL(checksum, MDStringField, );                                         \
+  OPTIONAL(source, MDStringField, );
   PARSE_MD_FIELDS();
 #undef VISIT_MD_FIELDS
 
   Optional<DIFile::ChecksumInfo<MDString *>> OptChecksum;
   if (checksumkind.Seen && checksum.Seen)
     OptChecksum.emplace(checksumkind.Val, checksum.Val);
   else if (checksumkind.Seen || checksum.Seen)
     return Lex.Error("'checksumkind' and 'checksum' must be provided together");
 
+  Optional<MDString *> OptSource;
+  if (source.Seen)
+    OptSource = source.Val;
   Result = GET_OR_DISTINCT(DIFile, (Context, filename.Val, directory.Val,
-                                    OptChecksum));
+                                    OptChecksum, OptSource));
   return false;
 }
 
 /// ParseDICompileUnit:
 ///   ::= !DICompileUnit(language: DW_LANG_C99, file: !0, producer: "clang",
 ///                      isOptimized: true, flags: "-O2", runtimeVersion: 1,
 ///                      splitDebugFilename: "abc.debug",
 ///                      emissionKind: FullDebug, enums: !1, retainedTypes: !2,

llvm/trunk/lib/Bitcode/Reader/MetadataLoader.cpp

MetadataList.assignValue(
                          getMDString(Record[2]), getMDString(Record[3]),
                          getMDString(Record[4]), getMDString(Record[5]))),
         NextMetadataNo);
     NextMetadataNo++;
     break;
   }
 
   case bitc::METADATA_FILE: {
-    if (Record.size() != 3 && Record.size() != 5)
+    if (Record.size() != 3 && Record.size() != 5 && Record.size() != 6)
       return error("Invalid record");
 
     IsDistinct = Record[0];
     Optional<DIFile::ChecksumInfo<MDString *>> Checksum;
     // The BitcodeWriter writes null bytes into Record[3:4] when the Checksum
     // is not present. This matches up with the old internal representation,
     // and the old encoding for CSK_None in the ChecksumKind. The new
     // representation reserves the value 0 in the ChecksumKind to continue to
     // encode None in a backwards-compatible way.
-    if (Record.size() == 5 && Record[3] && Record[4])
+    if (Record.size() > 4 && Record[3] && Record[4])
       Checksum.emplace(static_cast<DIFile::ChecksumKind>(Record[3]),
                        getMDString(Record[4]));
     MetadataList.assignValue(
         GET_OR_DISTINCT(
             DIFile,
-            (Context, getMDString(Record[1]), getMDString(Record[2]),
-             Checksum)),
+            (Context, getMDString(Record[1]), getMDString(Record[2]), Checksum,
+             Record.size() > 5 ? Optional<MDString *>(getMDString(Record[5]))
+                               : None)),
         NextMetadataNo);
     NextMetadataNo++;
     break;
   }
   case bitc::METADATA_COMPILE_UNIT: {
     if (Record.size() < 14 || Record.size() > 19)
       return error("Invalid record");
 

llvm/trunk/lib/Bitcode/Writer/BitcodeWriter.cpp

if (N->getRawChecksum()) {
     Record.push_back(N->getRawChecksum()->Kind);
     Record.push_back(VE.getMetadataOrNullID(N->getRawChecksum()->Value));
   } else {
     // Maintain backwards compatibility with the old internal representation of
     // CSK_None in ChecksumKind by writing nulls here when Checksum is None.
     Record.push_back(0);
     Record.push_back(VE.getMetadataOrNullID(nullptr));
   }
+  auto Source = N->getRawSource();
+  if (Source)
+    Record.push_back(VE.getMetadataOrNullID(*Source));
 
   Stream.EmitRecord(bitc::METADATA_FILE, Record, Abbrev);
   Record.clear();
 }
 
 void ModuleBitcodeWriter::writeDICompileUnit(const DICompileUnit *N,
                                              SmallVectorImpl<uint64_t> &Record,
                                              unsigned Abbrev) {

llvm/trunk/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp

 unsigned DwarfCompileUnit::getOrCreateSourceID(const DIFile *File) {
   // If we print assembly, we can't separate .file entries according to
   // compile units. Thus all files will belong to the default compile unit.
 
   // FIXME: add a better feature test than hasRawTextSupport. Even better,
   // extend .file to support this.
   unsigned CUID = Asm->OutStreamer->hasRawTextSupport() ? 0 : getUniqueID();
   if (!File)
-    return Asm->OutStreamer->EmitDwarfFileDirective(0, "", "", nullptr, CUID);
+    return Asm->OutStreamer->EmitDwarfFileDirective(0, "", "", nullptr, None, CUID);
   return Asm->OutStreamer->EmitDwarfFileDirective(
-      0, File->getDirectory(), File->getFilename(), getMD5AsBytes(File), CUID);
+      0, File->getDirectory(), File->getFilename(), getMD5AsBytes(File),
+      File->getSource(), CUID);
 }
 
 DIE *DwarfCompileUnit::getOrCreateGlobalVariableDIE(
     const DIGlobalVariable *GV, ArrayRef<GlobalExpr> GlobalExprs) {
   // Check for pre-existence.
   if (DIE *Die = getDIE(GV))
     return Die;
 

llvm/trunk/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

#endif
   CurFn = nullptr;
 }
 
 // Register a source line with debug info. Returns the  unique label that was
 // emitted and which provides correspondence to the source line list.
 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
                                   unsigned Flags) {
   StringRef Fn;
-  unsigned Src = 1;
+  unsigned FileNo = 1;
   unsigned Discriminator = 0;
   if (auto *Scope = cast_or_null<DIScope>(S)) {
     Fn = Scope->getFilename();
     if (Line != 0 && getDwarfVersion() >= 4)
       if (auto *LBF = dyn_cast<DILexicalBlockFile>(Scope))
         Discriminator = LBF->getDiscriminator();
 
     unsigned CUID = Asm->OutStreamer->getContext().getDwarfCompileUnitID();
-    Src = static_cast<DwarfCompileUnit &>(*InfoHolder.getUnits()[CUID])
+    FileNo = static_cast<DwarfCompileUnit &>(*InfoHolder.getUnits()[CUID])
               .getOrCreateSourceID(Scope->getFile());
   }
-  Asm->OutStreamer->EmitDwarfLocDirective(Src, Line, Col, Flags, 0,
+  Asm->OutStreamer->EmitDwarfLocDirective(FileNo, Line, Col, Flags, 0,
                                           Discriminator, Fn);
 }
 
 //===----------------------------------------------------------------------===//
 // Emit Methods
 //===----------------------------------------------------------------------===//
 
 // Emit the debug info section.

llvm/trunk/lib/CodeGen/AsmPrinter/DwarfUnit.cpp

MD5::MD5Result *DwarfUnit::getMD5AsBytes(const DIFile *File) {
   void *CKMem = Asm->OutStreamer->getContext().allocate(16, 1);
   memcpy(CKMem, ChecksumString.data(), 16);
   return reinterpret_cast<MD5::MD5Result *>(CKMem);
 }
 
 unsigned DwarfTypeUnit::getOrCreateSourceID(const DIFile *File) {
   return SplitLineTable
              ? SplitLineTable->getFile(File->getDirectory(),
-                                       File->getFilename(), getMD5AsBytes(File))
+                                       File->getFilename(),
+                                       getMD5AsBytes(File),
+                                       File->getSource())
              : getCU().getOrCreateSourceID(File);
 }
 
 void DwarfUnit::addOpAddress(DIELoc &Die, const MCSymbol *Sym) {
   if (!DD->useSplitDwarf()) {
     addUInt(Die, dwarf::DW_FORM_data1, dwarf::DW_OP_addr);
     addLabel(Die, dwarf::DW_FORM_udata, Sym);
   } else {

llvm/trunk/lib/DebugInfo/DWARF/DWARFContext.cpp

if (shouldDump(ExplicitDWO, ".debug_str.dwo", DIDT_ID_DebugStr,
     }
   }
   if (shouldDump(Explicit, ".debug_line_str", DIDT_ID_DebugLineStr,
                  DObj->getLineStringSection())) {
     DataExtractor strData(DObj->getLineStringSection(), isLittleEndian(), 0);
     uint32_t offset = 0;
     uint32_t strOffset = 0;
     while (const char *s = strData.getCStr(&offset)) {
-      OS << format("0x%8.8x: \"%s\"\n", strOffset, s);
+      OS << format("0x%8.8x: \"", strOffset);
+      OS.write_escaped(s);
+      OS << "\"\n";
       strOffset = offset;
     }
   }
 
   if (shouldDump(Explicit, ".debug_ranges", DIDT_ID_DebugRanges,
                  DObj->getRangeSection().Data)) {
     // In fact, different compile units may have different address byte
     // sizes, but for simplicity we just use the address byte size of the

llvm/trunk/lib/DebugInfo/DWARF/DWARFDebugLine.cpp

 //===- DWARFDebugLine.cpp -------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/DebugInfo/DWARF/DWARFDebugLine.h"
+#include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/BinaryFormat/Dwarf.h"
 #include "llvm/DebugInfo/DWARF/DWARFFormValue.h"
 #include "llvm/DebugInfo/DWARF/DWARFRelocMap.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/Path.h"
struct ContentDescriptor {
   dwarf::LineNumberEntryFormat Type;
   dwarf::Form Form;
 };
 
 using ContentDescriptors = SmallVector<ContentDescriptor, 4>;
 
 } // end anonmyous namespace
 
+void DWARFDebugLine::ContentTypeTracker::trackContentType(
+    dwarf::LineNumberEntryFormat ContentType) {
+  switch (ContentType) {
+  case dwarf::DW_LNCT_timestamp:
+    HasModTime = true;
+    break;
+  case dwarf::DW_LNCT_size:
+    HasLength = true;
+    break;
+  case dwarf::DW_LNCT_MD5:
+    HasMD5 = true;
+    break;
+  case dwarf::DW_LNCT_LLVM_source:
+    HasSource = true;
+    break;
+  default:
+    // We only care about values we consider optional, and new values may be
+    // added in the vendor extension range, so we do not match exhaustively.
+    break;
+  }
+}
+
 DWARFDebugLine::Prologue::Prologue() { clear(); }
 
 void DWARFDebugLine::Prologue::clear() {
   TotalLength = PrologueLength = 0;
   SegSelectorSize = 0;
   MinInstLength = MaxOpsPerInst = DefaultIsStmt = LineBase = LineRange = 0;
   OpcodeBase = 0;
   FormParams = DWARFFormParams({0, 0, DWARF32});
-  HasMD5 = false;
+  ContentTypes = ContentTypeTracker();
   StandardOpcodeLengths.clear();
   IncludeDirectories.clear();
   FileNames.clear();
 }
 
 void DWARFDebugLine::Prologue::dump(raw_ostream &OS,
                                     DIDumpOptions DumpOptions) const {
   OS << "Line table prologue:\n"
if (!IncludeDirectories.empty()) {
     for (uint32_t I = 0; I != IncludeDirectories.size(); ++I) {
       OS << format("include_directories[%3u] = ", I + DirBase);
       IncludeDirectories[I].dump(OS, DumpOptions);
       OS << '\n';
     }
   }
 
   if (!FileNames.empty()) {
-    if (HasMD5)
-      OS << "                Dir  MD5 Checksum                     File Name\n"
-         << "                ---- -------------------------------- -----------"
-            "---------------\n";
-    else
-      OS << "                Dir  Mod Time   File Len   File Name\n"
-         << "                ---- ---------- ---------- -----------"
-            "----------------\n";
     // DWARF v5 starts file indexes at 0.
     uint32_t FileBase = getVersion() >= 5 ? 0 : 1;
     for (uint32_t I = 0; I != FileNames.size(); ++I) {
       const FileNameEntry &FileEntry = FileNames[I];
-      OS << format("file_names[%3u] %4" PRIu64 " ", I + FileBase,
-                   FileEntry.DirIdx);
-      if (HasMD5)
-        OS << FileEntry.Checksum.digest();
-      else
-        OS << format("0x%8.8" PRIx64 " 0x%8.8" PRIx64, FileEntry.ModTime,
-                     FileEntry.Length);
-      OS << ' ';
+      OS <<   format("file_names[%3u]:\n", I + FileBase);
+      OS <<          "           name: ";
       FileEntry.Name.dump(OS, DumpOptions);
+      OS << '\n'
+         <<   format("      dir_index: %" PRIu64 "\n", FileEntry.DirIdx);
+      if (ContentTypes.HasMD5)
+        OS <<        "   md5_checksum: " << FileEntry.Checksum.digest() << '\n';
+      if (ContentTypes.HasModTime)
+        OS << format("       mod_time: 0x%8.8" PRIx64 "\n", FileEntry.ModTime);
+      if (ContentTypes.HasLength)
+        OS << format("         length: 0x%8.8" PRIx64 "\n", FileEntry.Length);
+      if (ContentTypes.HasSource) {
+        OS <<        "         source: ";
+        FileEntry.Source.dump(OS, DumpOptions);
         OS << '\n';
       }
     }
   }
+}
 
 // Parse v2-v4 directory and file tables.
 static void
 parseV2DirFileTables(const DWARFDataExtractor &DebugLineData,
                      uint32_t *OffsetPtr, uint64_t EndPrologueOffset,
+                     DWARFDebugLine::ContentTypeTracker &ContentTypes,
                      std::vector<DWARFFormValue> &IncludeDirectories,
                      std::vector<DWARFDebugLine::FileNameEntry> &FileNames) {
   while (*OffsetPtr < EndPrologueOffset) {
     StringRef S = DebugLineData.getCStrRef(OffsetPtr);
     if (S.empty())
       break;
     DWARFFormValue Dir(dwarf::DW_FORM_string);
     Dir.setPValue(S.data());
     IncludeDirectories.push_back(Dir);
   }
 
   while (*OffsetPtr < EndPrologueOffset) {
     StringRef Name = DebugLineData.getCStrRef(OffsetPtr);
     if (Name.empty())
       break;
     DWARFDebugLine::FileNameEntry FileEntry;
     FileEntry.Name.setForm(dwarf::DW_FORM_string);
     FileEntry.Name.setPValue(Name.data());
     FileEntry.DirIdx = DebugLineData.getULEB128(OffsetPtr);
     FileEntry.ModTime = DebugLineData.getULEB128(OffsetPtr);
     FileEntry.Length = DebugLineData.getULEB128(OffsetPtr);
     FileNames.push_back(FileEntry);
   }
+
+  ContentTypes.HasModTime = true;
+  ContentTypes.HasLength = true;
 }
 
 // Parse v5 directory/file entry content descriptions.
 // Returns the descriptors, or an empty vector if we did not find a path or
 // ran off the end of the prologue.
 static ContentDescriptors
-parseV5EntryFormat(const DWARFDataExtractor &DebugLineData, uint32_t *OffsetPtr,
-                   uint64_t EndPrologueOffset, bool *HasMD5) {
+parseV5EntryFormat(const DWARFDataExtractor &DebugLineData, uint32_t
+    *OffsetPtr, uint64_t EndPrologueOffset, DWARFDebugLine::ContentTypeTracker
+    *ContentTypes) {
   ContentDescriptors Descriptors;
   int FormatCount = DebugLineData.getU8(OffsetPtr);
   bool HasPath = false;
   for (int I = 0; I != FormatCount; ++I) {
     if (*OffsetPtr >= EndPrologueOffset)
       return ContentDescriptors();
     ContentDescriptor Descriptor;
     Descriptor.Type =
       dwarf::LineNumberEntryFormat(DebugLineData.getULEB128(OffsetPtr));
     Descriptor.Form = dwarf::Form(DebugLineData.getULEB128(OffsetPtr));
     if (Descriptor.Type == dwarf::DW_LNCT_path)
       HasPath = true;
-    else if (Descriptor.Type == dwarf::DW_LNCT_MD5 && HasMD5)
-      *HasMD5 = true;
+    if (ContentTypes)
+      ContentTypes->trackContentType(Descriptor.Type);
     Descriptors.push_back(Descriptor);
   }
   return HasPath ? Descriptors : ContentDescriptors();
 }
 
 static bool
 parseV5DirFileTables(const DWARFDataExtractor &DebugLineData,
                      uint32_t *OffsetPtr, uint64_t EndPrologueOffset,
-                     const DWARFFormParams &FormParams, const DWARFContext &Ctx,
-                     const DWARFUnit *U, bool &HasMD5,
+                     const DWARFFormParams &FormParams, const DWARFContext
+                     &Ctx, const DWARFUnit *U,
+                     DWARFDebugLine::ContentTypeTracker &ContentTypes,
                      std::vector<DWARFFormValue> &IncludeDirectories,
                      std::vector<DWARFDebugLine::FileNameEntry> &FileNames) {
   // Get the directory entry description.
   ContentDescriptors DirDescriptors =
       parseV5EntryFormat(DebugLineData, OffsetPtr, EndPrologueOffset, nullptr);
   if (DirDescriptors.empty())
     return false;
 
for (auto Descriptor : DirDescriptors) {
         if (!Value.skipValue(DebugLineData, OffsetPtr, FormParams))
           return false;
       }
     }
   }
 
   // Get the file entry description.
   ContentDescriptors FileDescriptors =
-      parseV5EntryFormat(DebugLineData, OffsetPtr, EndPrologueOffset, &HasMD5);
+      parseV5EntryFormat(DebugLineData, OffsetPtr, EndPrologueOffset,
+          &ContentTypes);
   if (FileDescriptors.empty())
     return false;
 
   // Get the file entries, according to the format described above.
   int FileEntryCount = DebugLineData.getU8(OffsetPtr);
   for (int I = 0; I != FileEntryCount; ++I) {
     if (*OffsetPtr >= EndPrologueOffset)
       return false;
     DWARFDebugLine::FileNameEntry FileEntry;
     for (auto Descriptor : FileDescriptors) {
       DWARFFormValue Value(Descriptor.Form);
       if (!Value.extractValue(DebugLineData, OffsetPtr, FormParams, &Ctx, U))
         return false;
       switch (Descriptor.Type) {
       case DW_LNCT_path:
         FileEntry.Name = Value;
         break;
+      case DW_LNCT_LLVM_source:
+        FileEntry.Source = Value;
+        break;
       case DW_LNCT_directory_index:
         FileEntry.DirIdx = Value.getAsUnsignedConstant().getValue();
         break;
       case DW_LNCT_timestamp:
         FileEntry.ModTime = Value.getAsUnsignedConstant().getValue();
         break;
       case DW_LNCT_size:
         FileEntry.Length = Value.getAsUnsignedConstant().getValue();
bool DWARFDebugLine::Prologue::parse(const DWARFDataExtractor &DebugLineData,
   StandardOpcodeLengths.reserve(OpcodeBase - 1);
   for (uint32_t I = 1; I < OpcodeBase; ++I) {
     uint8_t OpLen = DebugLineData.getU8(OffsetPtr);
     StandardOpcodeLengths.push_back(OpLen);
   }
 
   if (getVersion() >= 5) {
     if (!parseV5DirFileTables(DebugLineData, OffsetPtr, EndPrologueOffset,
-                              FormParams, Ctx, U, HasMD5, IncludeDirectories,
-                              FileNames)) {
+                              FormParams, Ctx, U, ContentTypes,
+                              IncludeDirectories, FileNames)) {
       fprintf(stderr,
               "warning: parsing line table prologue at 0x%8.8" PRIx64
               " found an invalid directory or file table description at"
               " 0x%8.8" PRIx64 "\n", PrologueOffset, (uint64_t)*OffsetPtr);
       return false;
     }
   } else
     parseV2DirFileTables(DebugLineData, OffsetPtr, EndPrologueOffset,
-                         IncludeDirectories, FileNames);
+                         ContentTypes, IncludeDirectories, FileNames);
 
   if (*OffsetPtr != EndPrologueOffset) {
     fprintf(stderr,
             "warning: parsing line table prologue at 0x%8.8" PRIx64
             " should have ended at 0x%8.8" PRIx64
             " but it ended at 0x%8.8" PRIx64 "\n",
             PrologueOffset, EndPrologueOffset, (uint64_t)*OffsetPtr);
     return false;
bool DWARFDebugLine::LineTable::lookupAddressRange(
 
   return true;
 }
 
 bool DWARFDebugLine::LineTable::hasFileAtIndex(uint64_t FileIndex) const {
   return FileIndex != 0 && FileIndex <= Prologue.FileNames.size();
 }
 
+Optional<StringRef> DWARFDebugLine::LineTable::getSourceByIndex(uint64_t FileIndex,
+                                                                FileLineInfoKind Kind) const {
+  if (Kind == FileLineInfoKind::None || !hasFileAtIndex(FileIndex))
+    return None;
+  const FileNameEntry &Entry = Prologue.FileNames[FileIndex - 1];
+  if (Optional<const char *> source = Entry.Source.getAsCString())
+    return StringRef(*source);
+  return None;
+}
+
 bool DWARFDebugLine::LineTable::getFileNameByIndex(uint64_t FileIndex,
                                                    const char *CompDir,
                                                    FileLineInfoKind Kind,
                                                    std::string &Result) const {
   if (Kind == FileLineInfoKind::None || !hasFileAtIndex(FileIndex))
     return false;
   const FileNameEntry &Entry = Prologue.FileNames[FileIndex - 1];
   StringRef FileName = Entry.Name.getAsCString().getValue();
if (RowIndex == -1U)
     return false;
   // Take file number and line/column from the row.
   const auto &Row = Rows[RowIndex];
   if (!getFileNameByIndex(Row.File, CompDir, Kind, Result.FileName))
     return false;
   Result.Line = Row.Line;
   Result.Column = Row.Column;
   Result.Discriminator = Row.Discriminator;
+  Result.Source = getSourceByIndex(Row.File, Kind);
   return true;
 }

llvm/trunk/lib/IR/AsmWriter.cpp

static void writeDIFile(raw_ostream &Out, const DIFile *N, TypePrinting *,
   MDFieldPrinter Printer(Out);
   Printer.printString("filename", N->getFilename(),
                       /* ShouldSkipEmpty */ false);
   Printer.printString("directory", N->getDirectory(),
                       /* ShouldSkipEmpty */ false);
   // Print all values for checksum together, or not at all.
   if (N->getChecksum())
     Printer.printChecksum(*N->getChecksum());
+  Printer.printString("source", N->getSource().getValueOr(StringRef()),
+                      /* ShouldSkipEmpty */ true);
   Out << ")";
 }
 
 static void writeDICompileUnit(raw_ostream &Out, const DICompileUnit *N,
                                TypePrinting *TypePrinter, SlotTracker *Machine,
                                const Module *Context) {
   Out << "!DICompileUnit(";
   MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);

llvm/trunk/lib/IR/DIBuilder.cpp

 //===--- DIBuilder.cpp - Debug Information Builder ------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the DIBuilder.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/IR/DIBuilder.h"
 #include "llvm/IR/IRBuilder.h"
 #include "LLVMContextImpl.h"
+#include "llvm/ADT/Optional.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/BinaryFormat/Dwarf.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DebugInfo.h"
 #include "llvm/IR/IntrinsicInst.h"
 #include "llvm/IR/Module.h"
 #include "llvm/Support/Debug.h"
 
DIImportedEntity *DIBuilder::createImportedDeclaration(DIScope *Context,
   // 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,
                                 AllImportedModules);
 }
 
 DIFile *DIBuilder::createFile(StringRef Filename, StringRef Directory,
-                              Optional<DIFile::ChecksumInfo<StringRef>> CS) {
-  return DIFile::get(VMContext, Filename, Directory, CS);
+                              Optional<DIFile::ChecksumInfo<StringRef>> CS,
+                              Optional<StringRef> Source) {
+  return DIFile::get(VMContext, Filename, Directory, CS, Source);
 }
 
 DIMacro *DIBuilder::createMacro(DIMacroFile *Parent, unsigned LineNumber,
                                 unsigned MacroType, StringRef Name,
                                 StringRef Value) {
   assert(!Name.empty() && "Unable to create macro without name");
   assert((MacroType == dwarf::DW_MACINFO_undef ||
           MacroType == dwarf::DW_MACINFO_define) &&

llvm/trunk/lib/IR/DebugInfoMetadata.cpp

return StringSwitch<Optional<DIFile::ChecksumKind>>(CSKindStr)
       .Case("CSK_MD5", DIFile::CSK_MD5)
       .Case("CSK_SHA1", DIFile::CSK_SHA1)
       .Default(None);
 }
 
 DIFile *DIFile::getImpl(LLVMContext &Context, MDString *Filename,
                         MDString *Directory,
                         Optional<DIFile::ChecksumInfo<MDString *>> CS,
-                        StorageType Storage, bool ShouldCreate) {
+                        Optional<MDString *> Source, StorageType Storage,
+                        bool ShouldCreate) {
   assert(isCanonical(Filename) && "Expected canonical MDString");
   assert(isCanonical(Directory) && "Expected canonical MDString");
   assert((!CS || isCanonical(CS->Value)) && "Expected canonical MDString");
-  DEFINE_GETIMPL_LOOKUP(DIFile, (Filename, Directory, CS));
-  Metadata *Ops[] = {Filename, Directory, CS ? CS->Value : nullptr};
-  DEFINE_GETIMPL_STORE(DIFile, (CS), Ops);
+  assert((!Source || isCanonical(*Source)) && "Expected canonical MDString");
+  DEFINE_GETIMPL_LOOKUP(DIFile, (Filename, Directory, CS, Source));
+  Metadata *Ops[] = {Filename, Directory, CS ? CS->Value : nullptr,
+                     Source.getValueOr(nullptr)};
+  DEFINE_GETIMPL_STORE(DIFile, (CS, Source), Ops);
 }
 
 DICompileUnit *DICompileUnit::getImpl(
     LLVMContext &Context, unsigned SourceLanguage, Metadata *File,
     MDString *Producer, bool IsOptimized, MDString *Flags,
     unsigned RuntimeVersion, MDString *SplitDebugFilename,
     unsigned EmissionKind, Metadata *EnumTypes, Metadata *RetainedTypes,
     Metadata *GlobalVariables, Metadata *ImportedEntities, Metadata *Macros,

llvm/trunk/lib/IR/LLVMContextImpl.h

template <> struct MDNodeKeyImpl<DISubroutineType> {
 
   unsigned getHashValue() const { return hash_combine(Flags, CC, TypeArray); }
 };
 
 template <> struct MDNodeKeyImpl<DIFile> {
   MDString *Filename;
   MDString *Directory;
   Optional<DIFile::ChecksumInfo<MDString *>> Checksum;
+  Optional<MDString *> Source;
 
   MDNodeKeyImpl(MDString *Filename, MDString *Directory,
-                Optional<DIFile::ChecksumInfo<MDString *>> Checksum)
-      : Filename(Filename), Directory(Directory), Checksum(Checksum) {}
+                Optional<DIFile::ChecksumInfo<MDString *>> Checksum,
+                Optional<MDString *> Source)
+      : Filename(Filename), Directory(Directory), Checksum(Checksum),
+        Source(Source) {}
   MDNodeKeyImpl(const DIFile *N)
       : Filename(N->getRawFilename()), Directory(N->getRawDirectory()),
-        Checksum(N->getRawChecksum()) {}
+        Checksum(N->getRawChecksum()), Source(N->getRawSource()) {}
 
   bool isKeyOf(const DIFile *RHS) const {
     return Filename == RHS->getRawFilename() &&
            Directory == RHS->getRawDirectory() &&
-           Checksum == RHS->getRawChecksum();
+           Checksum == RHS->getRawChecksum() &&
+           Source == RHS->getRawSource();
   }
 
   unsigned getHashValue() const {
-    if (Checksum)
-      return hash_combine(Filename, Directory, Checksum->Kind, Checksum->Value);
-    return hash_combine(Filename, Directory);
+    return hash_combine(
+        Filename, Directory, Checksum ? Checksum->Kind : 0,
+        Checksum ? Checksum->Value : nullptr, Source.getValueOr(nullptr));
   }
 };
 
 template <> struct MDNodeKeyImpl<DISubprogram> {
   Metadata *Scope;
   MDString *Name;
   MDString *LinkageName;
   Metadata *File;

llvm/trunk/lib/MC/MCAsmStreamer.cpp

 //===- lib/MC/MCAsmStreamer.cpp - Text Assembly Output ----------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
+#include "llvm/ADT/Optional.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/MC/MCAsmBackend.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCCodeEmitter.h"
 #include "llvm/MC/MCCodeView.h"
void emitValueToOffset(const MCExpr *Offset,
                          unsigned char Value,
                          SMLoc Loc) override;
 
   void EmitFileDirective(StringRef Filename) override;
   Expected<unsigned> tryEmitDwarfFileDirective(unsigned FileNo,
                                                StringRef Directory,
                                                StringRef Filename,
                                                MD5::MD5Result *Checksum = 0,
+                                               Optional<StringRef> Source = None,
                                                unsigned CUID = 0) override;
   void EmitDwarfLocDirective(unsigned FileNo, unsigned Line,
                              unsigned Column, unsigned Flags,
                              unsigned Isa, unsigned Discriminator,
                              StringRef FileName) override;
   MCSymbol *getDwarfLineTableSymbol(unsigned CUID) override;
 
   bool EmitCVFileDirective(unsigned FileNo, StringRef Filename,
void MCAsmStreamer::EmitFileDirective(StringRef Filename) {
   assert(MAI->hasSingleParameterDotFile());
   OS << "\t.file\t";
   PrintQuotedString(Filename, OS);
   EmitEOL();
 }
 
 Expected<unsigned> MCAsmStreamer::tryEmitDwarfFileDirective(
     unsigned FileNo, StringRef Directory, StringRef Filename,
-    MD5::MD5Result *Checksum, unsigned CUID) {
+    MD5::MD5Result *Checksum, Optional<StringRef> Source, unsigned CUID) {
   assert(CUID == 0);
 
   MCDwarfLineTable &Table = getContext().getMCDwarfLineTable(CUID);
   unsigned NumFiles = Table.getMCDwarfFiles().size();
   Expected<unsigned> FileNoOrErr =
-      Table.tryGetFile(Directory, Filename, Checksum, FileNo);
+      Table.tryGetFile(Directory, Filename, Checksum, Source, FileNo);
   if (!FileNoOrErr)
     return FileNoOrErr.takeError();
   FileNo = FileNoOrErr.get();
   if (NumFiles == Table.getMCDwarfFiles().size())
     return FileNo;
 
   SmallString<128> FullPathName;
 
if (!Directory.empty()) {
     PrintQuotedString(Directory, OS1);
     OS1 << ' ';
   }
   PrintQuotedString(Filename, OS1);
   if (Checksum) {
     OS1 << " md5 ";
     PrintQuotedString(Checksum->digest(), OS1);
   }
+  if (Source) {
+    OS1 << " source ";
+    PrintQuotedString(*Source, OS1);
+  }
   if (MCTargetStreamer *TS = getTargetStreamer()) {
     TS->emitDwarfFileDirective(OS1.str());
   } else {
     EmitRawText(OS1.str());
   }
 
   return FileNo;
 }

llvm/trunk/lib/MC/MCContext.cpp

 //===- lib/MC/MCContext.cpp - Machine Code Context ------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/MC/MCContext.h"
+#include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/BinaryFormat/COFF.h"
 #include "llvm/BinaryFormat/ELF.h"
 #include "llvm/MC/MCAsmInfo.h"

 MCSubtargetInfo &MCContext::getSubtargetCopy(const MCSubtargetInfo &STI) {
   return *new (MCSubtargetAllocator.Allocate()) MCSubtargetInfo(STI);
 }
 
 //===----------------------------------------------------------------------===//
 // Dwarf Management
 //===----------------------------------------------------------------------===//
 
-/// getDwarfFile - takes a file name an number to place in the dwarf file and
+/// getDwarfFile - takes a file name and number to place in the dwarf file and
 /// directory tables.  If the file number has already been allocated it is an
 /// error and zero is returned and the client reports the error, else the
 /// allocated file number is returned.  The file numbers may be in any order.
 Expected<unsigned> MCContext::getDwarfFile(StringRef Directory,
                                            StringRef FileName,
                                            unsigned FileNumber,
                                            MD5::MD5Result *Checksum,
+                                           Optional<StringRef> Source,
                                            unsigned CUID) {
   MCDwarfLineTable &Table = MCDwarfLineTablesCUMap[CUID];
-  return Table.tryGetFile(Directory, FileName, Checksum, FileNumber);
+  return Table.tryGetFile(Directory, FileName, Checksum, Source, FileNumber);
 }
 
 /// isValidDwarfFileNumber - takes a dwarf file number and returns true if it
 /// currently is assigned and false otherwise.
 bool MCContext::isValidDwarfFileNumber(unsigned FileNumber, unsigned CUID) {
   const SmallVectorImpl<MCDwarfFile> &MCDwarfFiles = getMCDwarfFiles(CUID);
   if (FileNumber == 0 || FileNumber >= MCDwarfFiles.size())
     return false;

llvm/trunk/lib/MC/MCDwarf.cpp

 //===- lib/MC/MCDwarf.cpp - MCDwarf implementation ------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/MC/MCDwarf.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/Hashing.h"
-#include "llvm/ADT/None.h"
+#include "llvm/ADT/Optional.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/BinaryFormat/Dwarf.h"
 #include "llvm/Config/config.h"
 #include "llvm/MC/MCAsmInfo.h"
if (LineStr) {
     for (auto &Dir : MCDwarfDirs) {
       MCOS->EmitBytes(Dir);                // The DirectoryName, and...
       MCOS->EmitBytes(StringRef("\0", 1)); // its null terminator.
     }
   }
 
   // The file format, which is the inline null-terminated filename and a
   // directory index.  We don't track file size/timestamp so don't emit them
-  // in the v5 table.  Emit MD5 checksums if we have them.
-  MCOS->EmitIntValue(HasMD5 ? 3 : 2, 1);
+  // in the v5 table.  Emit MD5 checksums and source if we have them.
+  uint64_t Entries = 2;
+  if (HasMD5)
+    Entries += 1;
+  if (HasSource)
+    Entries += 1;
+  MCOS->EmitIntValue(Entries, 1);
   MCOS->EmitULEB128IntValue(dwarf::DW_LNCT_path);
   MCOS->EmitULEB128IntValue(LineStr ? dwarf::DW_FORM_line_strp
                                     : dwarf::DW_FORM_string);
   MCOS->EmitULEB128IntValue(dwarf::DW_LNCT_directory_index);
   MCOS->EmitULEB128IntValue(dwarf::DW_FORM_udata);
   if (HasMD5) {
     MCOS->EmitULEB128IntValue(dwarf::DW_LNCT_MD5);
     MCOS->EmitULEB128IntValue(dwarf::DW_FORM_data16);
   }
+  if (HasSource) {
+    MCOS->EmitULEB128IntValue(dwarf::DW_LNCT_LLVM_source);
+    MCOS->EmitULEB128IntValue(LineStr ? dwarf::DW_FORM_line_strp
+                                      : dwarf::DW_FORM_string);
+  }
   // Then the list of file names. These start at 1.
   MCOS->EmitULEB128IntValue(MCDwarfFiles.size() - 1);
   for (unsigned i = 1; i < MCDwarfFiles.size(); ++i) {
     assert(!MCDwarfFiles[i].Name.empty());
     if (LineStr)
       LineStr->emitRef(MCOS, MCDwarfFiles[i].Name);
     else {
       MCOS->EmitBytes(MCDwarfFiles[i].Name); // FileName and...
       MCOS->EmitBytes(StringRef("\0", 1));   // its null terminator.
     }
     MCOS->EmitULEB128IntValue(MCDwarfFiles[i].DirIndex); // Directory number.
     if (HasMD5) {
       MD5::MD5Result *Cksum = MCDwarfFiles[i].Checksum;
       MCOS->EmitBinaryData(
           StringRef(reinterpret_cast<const char *>(Cksum->Bytes.data()),
                     Cksum->Bytes.size()));
     }
+    if (HasSource) {
+      if (LineStr)
+        LineStr->emitRef(MCOS, MCDwarfFiles[i].Source.getValueOr(StringRef()));
+      else {
+        MCOS->EmitBytes(
+            MCDwarfFiles[i].Source.getValueOr(StringRef())); // Source and...
+        MCOS->EmitBytes(StringRef("\0", 1)); // its null terminator.
+      }
+    }
   }
 }
 
 std::pair<MCSymbol *, MCSymbol *>
 MCDwarfLineTableHeader::Emit(MCStreamer *MCOS, MCDwarfLineTableParams Params,
                              ArrayRef<char> StandardOpcodeLengths,
                              Optional<MCDwarfLineStr> &LineStr) const {
   MCContext &context = MCOS->getContext();
void MCDwarfLineTable::EmitCU(MCObjectStreamer *MCOS,
   // This is the end of the section, so set the value of the symbol at the end
   // of this section (that was used in a previous expression).
   MCOS->EmitLabel(LineEndSym);
 }
 
 Expected<unsigned> MCDwarfLineTable::tryGetFile(StringRef &Directory,
                                                 StringRef &FileName,
                                                 MD5::MD5Result *Checksum,
+                                                Optional<StringRef> Source,
                                                 unsigned FileNumber) {
-  return Header.tryGetFile(Directory, FileName, Checksum, FileNumber);
+  return Header.tryGetFile(Directory, FileName, Checksum, Source, FileNumber);
 }
 
-Expected<unsigned> MCDwarfLineTableHeader::tryGetFile(StringRef &Directory,
-                                                      StringRef &FileName,
-                                                      MD5::MD5Result *Checksum,
-                                                      unsigned FileNumber) {
+Expected<unsigned>
+MCDwarfLineTableHeader::tryGetFile(StringRef &Directory,
+                                   Optional<StringRef> &Source,
   if (Directory == CompilationDir)
     Directory = "";
   if (FileName.empty()) {
     FileName = "<stdin>";
     Directory = "";
   }
   assert(!FileName.empty());
-  // If any files have an MD5 checksum, they all must.
-  if (MCDwarfFiles.empty())
+  // If any files have an MD5 checksum or embedded source, they all must.
+  if (MCDwarfFiles.empty()) {
     HasMD5 = (Checksum != nullptr);
+    HasSource = (Source != None);
+  }
   if (FileNumber == 0) {
     // File numbers start with 1 and/or after any file numbers
     // allocated by inline-assembler .file directives.
     FileNumber = MCDwarfFiles.empty() ? 1 : MCDwarfFiles.size();
     SmallString<256> Buffer;
     auto IterBool = SourceIdMap.insert(
         std::make_pair((Directory + Twine('\0') + FileName).toStringRef(Buffer),
                        FileNumber));
MCDwarfLineTableHeader::tryGetFile(StringRef &Directory,
   if (!File.Name.empty())
     return make_error<StringError>("file number already allocated",
                                    inconvertibleErrorCode());
 
   // If any files have an MD5 checksum, they all must.
   if (HasMD5 != (Checksum != nullptr))
     return make_error<StringError>("inconsistent use of MD5 checksums",
                                    inconvertibleErrorCode());
+  // If any files have embedded source, they all must.
+  if (HasSource != (Source != None))
+    return make_error<StringError>("inconsistent use of embedded source",
+                                   inconvertibleErrorCode());
 
   if (Directory.empty()) {
     // Separate the directory part from the basename of the FileName.
     StringRef tFileName = sys::path::filename(FileName);
     if (!tFileName.empty()) {
       Directory = sys::path::parent_path(FileName);
       if (!Directory.empty())
         FileName = tFileName;
if (Directory.empty()) {
     DirIndex++;
   }
 
   File.Name = FileName;
   File.DirIndex = DirIndex;
   File.Checksum = Checksum;
   if (Checksum)
     HasMD5 = true;
+  File.Source = Source;
+  if (Source)
+    HasSource = true;
 
   // return the allocated FileNumber.
   return FileNumber;
 }
 
 /// Utility function to emit the encoding to a streamer.
 void MCDwarfLineAddr::Emit(MCStreamer *MCOS, MCDwarfLineTableParams Params,
                            int64_t LineDelta, uint64_t AddrDelta) {

llvm/trunk/lib/MC/MCParser/AsmParser.cpp

getStreamer().EmitValueToAlignment(Alignment, FillExpr, ValueSize,
                                        MaxBytesToFill);
   }
 
   return ReturnVal;
 }
 
 /// parseDirectiveFile
 /// ::= .file filename
-/// ::= .file number [directory] filename [md5 checksum]
+/// ::= .file number [directory] filename [md5 checksum] [source source-text]
 bool AsmParser::parseDirectiveFile(SMLoc DirectiveLoc) {
   // FIXME: I'm not sure what this is.
   int64_t FileNumber = -1;
   if (getLexer().is(AsmToken::Integer)) {
     FileNumber = getTok().getIntVal();
     Lex();
 
     if (FileNumber < 1)
if (check(FileNumber == -1,
       return true;
     Filename = FilenameData;
     Directory = Path;
   } else {
     Filename = Path;
   }
 
   std::string Checksum;
-  if (!parseOptionalToken(AsmToken::EndOfStatement)) {
+
+  Optional<StringRef> Source;
+  bool HasSource = false;
+  std::string SourceString;
+
+  while (!parseOptionalToken(AsmToken::EndOfStatement)) {
     StringRef Keyword;
     if (check(getTok().isNot(AsmToken::Identifier),
               "unexpected token in '.file' directive") ||
-        parseIdentifier(Keyword) ||
-        check(Keyword != "md5", "unexpected token in '.file' directive"))
-      return true;
-    if (getLexer().is(AsmToken::String) &&
-        check(FileNumber == -1, "MD5 checksum specified, but no file number"))
+        parseIdentifier(Keyword))
       return true;
-    if (check(getTok().isNot(AsmToken::String),
+    if (Keyword == "md5") {
+      if (check(FileNumber == -1,
+                "MD5 checksum specified, but no file number") ||
+          check(getTok().isNot(AsmToken::String),
                 "unexpected token in '.file' directive") ||
           parseEscapedString(Checksum) ||
-        check(Checksum.size() != 32, "invalid MD5 checksum specified") ||
-        parseToken(AsmToken::EndOfStatement,
-                   "unexpected token in '.file' directive"))
+          check(Checksum.size() != 32, "invalid MD5 checksum specified"))
         return true;
+    } else if (Keyword == "source") {
+      HasSource = true;
+      if (check(FileNumber == -1,
+                "source specified, but no file number") ||
+          check(getTok().isNot(AsmToken::String),
+                "unexpected token in '.file' directive") ||
+          parseEscapedString(SourceString))
+        return true;
+    } else {
+      return TokError("unexpected token in '.file' directive");
+    }
   }
 
   if (FileNumber == -1)
     getStreamer().EmitFileDirective(Filename);
   else {
     MD5::MD5Result *CKMem = nullptr;
     if (!Checksum.empty()) {
       Checksum = fromHex(Checksum);
       if (check(Checksum.size() != 16, "invalid MD5 checksum specified"))
         return true;
       CKMem = (MD5::MD5Result *)Ctx.allocate(sizeof(MD5::MD5Result), 1);
       memcpy(&CKMem->Bytes, Checksum.data(), 16);
     }
+    if (HasSource) {
+      char *SourceBuf = static_cast<char *>(Ctx.allocate(SourceString.size()));
+      memcpy(SourceBuf, SourceString.data(), SourceString.size());
+      Source = StringRef(SourceBuf, SourceString.size());
+    }
     // If there is -g option as well as debug info from directive file,
     // we turn off -g option, directly use the existing debug info instead.
     if (getContext().getGenDwarfForAssembly())
       getContext().setGenDwarfForAssembly(false);
     else {
       Expected<unsigned> FileNumOrErr = getStreamer().tryEmitDwarfFileDirective(
-          FileNumber, Directory, Filename, CKMem);
+          FileNumber, Directory, Filename, CKMem, Source);
       if (!FileNumOrErr)
         return Error(DirectiveLoc, toString(FileNumOrErr.takeError()));
       FileNumber = FileNumOrErr.get();
     }
   }
 
   return false;
 }

llvm/trunk/lib/MC/MCStreamer.cpp

 //===- lib/MC/MCStreamer.cpp - Streaming Machine Code Output --------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/MC/MCStreamer.h"
+#include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/BinaryFormat/COFF.h"
 #include "llvm/MC/MCAsmBackend.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCCodeView.h"
 #include "llvm/MC/MCContext.h"

 /// The implementation in this class just redirects to emitFill.
 void MCStreamer::EmitZeros(uint64_t NumBytes) {
   emitFill(NumBytes, 0);
 }
 
 Expected<unsigned>
 MCStreamer::tryEmitDwarfFileDirective(unsigned FileNo, StringRef Directory,
                                       StringRef Filename,
-                                      MD5::MD5Result *Checksum, unsigned CUID) {
-  return getContext().getDwarfFile(Directory, Filename, FileNo, Checksum, CUID);
+                                      MD5::MD5Result *Checksum,
+                                      Optional<StringRef> Source,
+                                      unsigned CUID) {
+  return getContext().getDwarfFile(Directory, Filename, FileNo, Checksum,
+                                   Source, CUID);
 }
 
 void MCStreamer::EmitDwarfLocDirective(unsigned FileNo, unsigned Line,
                                        unsigned Column, unsigned Flags,
                                        unsigned Isa,
                                        unsigned Discriminator,
                                        StringRef FileName) {
   getContext().setCurrentDwarfLoc(FileNo, Line, Column, Flags, Isa,

llvm/trunk/test/Assembler/debug-info.ll

 ; RUN: llvm-as < %s | llvm-dis | llvm-as | llvm-dis | FileCheck %s
 ; RUN: verify-uselistorder %s
 
-; CHECK: !named = !{!0, !0, !1, !2, !3, !4, !5, !6, !7, !8, !8, !9, !10, !11, !12, !13, !14, !15, !16, !17, !18, !19, !20, !21, !22, !23, !24, !25, !26, !27, !27, !28, !29, !30, !31, !32, !33, !34, !35}
-!named = !{!0, !1, !2, !3, !4, !5, !6, !7, !8, !9, !10, !11, !12, !13, !14, !15, !16, !17, !18, !19, !20, !21, !22, !23, !24, !25, !26, !27, !28, !29, !30, !31, !32, !33, !34, !35, !36, !37, !38}
+; CHECK: !named = !{!0, !0, !1, !2, !3, !4, !5, !6, !7, !8, !8, !9, !10, !11, !12, !13, !14, !15, !16, !17, !18, !19, !20, !21, !22, !23, !24, !25, !26, !27, !27, !28, !29, !30, !31, !32, !33, !34, !35, !36, !37}
+!named = !{!0, !1, !2, !3, !4, !5, !6, !7, !8, !9, !10, !11, !12, !13, !14, !15, !16, !17, !18, !19, !20, !21, !22, !23, !24, !25, !26, !27, !28, !29, !30, !31, !32, !33, !34, !35, !36, !37, !38, !39, !40}
 
 ; CHECK:      !0 = !DISubrange(count: 3)
 ; CHECK-NEXT: !1 = !DISubrange(count: 3, lowerBound: 4)
 ; CHECK-NEXT: !2 = !DISubrange(count: 3, lowerBound: -5)
 !0 = !DISubrange(count: 3)
 !1 = !DISubrange(count: 3, lowerBound: 0)
 
 !2 = !DISubrange(count: 3, lowerBound: 4)

 !35 = !DIFile(filename: "file", directory: "dir", checksumkind: CSK_MD5, checksum: "000102030405060708090a0b0c0d0e0f")
 
 ; CHECK-NEXT: !33 = !DICompositeType(tag: DW_TAG_variant_part, name: "A", scope: !14, size: 64)
 ; CHECK-NEXT: !34 = !DIDerivedType(tag: DW_TAG_member, scope: !33, baseType: !35, size: 64, align: 64, flags: DIFlagArtificial)
 ; CHECK-NEXT: !35 = !DIBasicType(name: "u64", size: 64, encoding: DW_ATE_unsigned)
 !36 = !DICompositeType(tag: DW_TAG_variant_part, name: "A", scope: !16, size: 64, discriminator: !37)
 !37 = !DIDerivedType(tag: DW_TAG_member, scope: !36, baseType: !38, size: 64, align: 64, flags: DIFlagArtificial)
 !38 = !DIBasicType(name: "u64", size: 64, encoding: DW_ATE_unsigned)
+
+; CHECK-NEXT: !36 = !DIFile(filename: "file", directory: "dir", source: "int source() { }\0A")
+; CHECK-NEXT: !37 = !DIFile(filename: "file", directory: "dir", checksumkind: CSK_MD5, checksum: "3a420e2646916a475e68de8d48f779f5", source: "int source() { }\0A")
+!39 = !DIFile(filename: "file", directory: "dir", source: "int source() { }\0A")
+!40 = !DIFile(filename: "file", directory: "dir", checksumkind: CSK_MD5, checksum: "3a420e2646916a475e68de8d48f779f5", source: "int source() { }\0A")

llvm/trunk/test/CodeGen/BPF/dwarfdump.ll

 !21 = !{!"int", !22, i64 0}
 !22 = !{!"omnipotent char", !23, i64 0}
 !23 = !{!"Simple C/C++ TBAA"}
 !24 = !DILocation(line: 5, column: 27, scope: !2)
 !25 = !DILocation(line: 7, column: 27, scope: !2)
 !26 = !DILocation(line: 7, column: 17, scope: !2)
 !27 = !DILocation(line: 9, column: 9, scope: !2)
 
-; CHECK: file_names[  1]    0 0x00000000 0x00000000 "testprog.c"
+; CHECK: file_names[  1]:
+; CHECK-NEXT: name: "testprog.c"
+; CHECK-NEXT: dir_index: 0
 ; CHECK: 0x0000000000000000      2
 ; CHECK: 0x0000000000000028      7

llvm/trunk/test/CodeGen/Generic/dwarf-md5.ll

 ; RUN: llvm-dwarfdump -debug-line %t4.o | FileCheck %s --check-prefix=OBJ-4
 ; RUN: %llc_dwarf -dwarf-version 5 -filetype=obj -o %t5.o %s
 ; RUN: llvm-dwarfdump -debug-line %t5.o | FileCheck %s --check-prefix=OBJ-5
 
 ; FIXME: Need to convey the MD5 for the primary source file.
 ; ASM: .file 1 ".{{/|\\\\}}t1.h" md5 "11111111111111111111111111111111"
 ; ASM: .file 2 ".{{/|\\\\}}t2.h" md5 "22222222222222222222222222222222"
 
-; OBJ-4: Dir Mod Time File Len File Name
-; OBJ-4: file_names[ 1] 1 0x00000000 0x00000000 "t1.h"
-; OBJ-4: file_names[ 2] 1 0x00000000 0x00000000 "t2.h"
-
-; OBJ-5: Dir MD5 Checksum File Name
-; OBJ-5: file_names[ 0] 1 11111111111111111111111111111111 "t1.h"
-; OBJ-5: file_names[ 1] 1 22222222222222222222222222222222 "t2.h"
+; OBJ-4: file_names[ 1]:
+; OBJ-4-NEXT: name: "t1.h"
+; OBJ-4-NEXT: dir_index: 1
+; OBJ-4: file_names[ 2]:
+; OBJ-4-NEXT: name: "t2.h"
+; OBJ-4-NEXT: dir_index: 1
+
+; OBJ-5: file_names[ 0]:
+; OBJ-5-NEXT: name: "t1.h"
+; OBJ-5-NEXT: dir_index: 1
+; OBJ-5-NEXT: md5_checksum: 11111111111111111111111111111111
+; OBJ-5: file_names[ 1]:
+; OBJ-5-NEXT: name: "t2.h"
+; OBJ-5-NEXT: dir_index: 1
+; OBJ-5-NEXT: md5_checksum: 22222222222222222222222222222222
 
 ; ModuleID = 't.c'
 source_filename = "t.c"
 
 @t1 = global i32 1, align 4, !dbg !0
 @t2 = global i32 0, align 4, !dbg !6
 
 !llvm.dbg.cu = !{!2}

llvm/trunk/test/CodeGen/X86/dwarf-comp-dir.ll

 !0 = distinct !DICompileUnit(language: DW_LANG_C99, producer: "clang version 3.1 (trunk 143523)", isOptimized: true, emissionKind: FullDebug, file: !4, enums: !2, retainedTypes: !7, globals: !2)
 !2 = !{}
 !3 = !DIFile(filename: "empty.c", directory: "/home/nlewycky")
 !4 = !DIFile(filename: "empty.c", directory: "/home/nlewycky")
 !6 = !DICompositeType(tag: DW_TAG_structure_type, name: "foo", line: 1, size: 8, align: 8, file: !4, elements: !2, identifier: "_ZTS3foo")
 !7 = !{!6}
 
 ; The important part of the following check is that dir = #0.
-;                        Dir  Mod Time   File Len   File Name
-;                        ---- ---------- ---------- ---------------------------
-; CHECK: file_names[  1]    0 0x00000000 0x00000000 "empty.c"
+; CHECK: file_names[  1]:
+; CHECK-NEXT: name: "empty.c"
+; CHECK-NEXT: dir_index: 0
 !5 = !{i32 1, !"Debug Info Version", i32 3}

llvm/trunk/test/DebugInfo/AMDGPU/dwarfdump-relocs.ll

 ; RUN: llc -O0 -mtriple=amdgcn--amdhsa -mcpu=fiji -verify-machineinstrs -filetype=obj < %s | llvm-dwarfdump -v - 2>&1 | FileCheck %s
 
 ; LLVM IR generated with the following command and OpenCL source:
 ;
 ; $clang -cl-std=CL2.0 -g -O0 -target amdgcn-amd-amdhsa -S -emit-llvm <path-to-file>
 ;
 ; kernel void kernel1(global int  addrspace(5)*A) {
 ;   *A = 11;
 ; }
 ;
 ; kernel void kernel2(global int  addrspace(5)*B) {
 ;   *B = 12;
 ; }
 
 ; CHECK-NOT: failed to compute relocation
-; CHECK: file_names[  1] 0 0x00000000 0x00000000 "dwarfdump-relocs.cl"
+; CHECK: file_names[  1]:
+; CHECK-NEXT: name: "dwarfdump-relocs.cl"
+; CHECK-NEXT: dir_index: 0
 
 declare void @llvm.dbg.declare(metadata, metadata, metadata)
 
 define amdgpu_kernel void @kernel1(i32 addrspace(1)* %A) !dbg !7 {
 entry:
   %A.addr = alloca i32 addrspace(1)*, align 4, addrspace(5)
   store i32 addrspace(1)* %A, i32 addrspace(1)* addrspace(5)* %A.addr, align 4
   call void @llvm.dbg.declare(metadata i32 addrspace(1)* addrspace(5)* %A.addr, metadata !16, metadata !17), !dbg !18

llvm/trunk/test/DebugInfo/Generic/lto-comp-dir.ll

 ; REQUIRES: object-emission
 
 ; RUN: %llc_dwarf < %s -filetype=obj | llvm-dwarfdump -debug-line - | FileCheck %s
 ; RUN: %llc_dwarf < %s -filetype=asm | FileCheck --check-prefix=ASM %s
 
 ; If multiple line tables are emitted, one per CU, those line tables can
 ; unambiguously rely on the comp_dir of their owning CU and use directory '0'
 ; to refer to it.
 
 ; CHECK: .debug_line contents:
 ; CHECK-NEXT: debug_line[{{.*}}]
 ; CHECK-NEXT: Line table prologue:
 ; CHECK-NOT: include_directories
-; CHECK: file_names[   1]   0 {{.*}} "a.cpp"
+; CHECK: file_names[   1]
+; CHECK: name: "a.cpp"
+; CHECK-NEXT: dir_index: 0
 ; CHECK-NOT: file_names
 
 ; CHECK: debug_line[{{.*}}]
 ; CHECK-NEXT: Line table prologue:
 ; CHECK-NOT: include_directories
-; CHECK: file_names[   1]   0 {{.*}} "b.cpp"
+; CHECK: file_names[   1]
+; CHECK: name: "b.cpp"
+; CHECK-NEXT: dir_index: 0
 ; CHECK-NOT: file_names
 
 ; However, if a single line table is emitted and shared between CUs, the
 ; comp_dir is ambiguous and relying on it would lead to different path
 ; interpretations depending on which CU lead to the table - so ensure that
 ; full paths are always emitted in this case, never comp_dir relative.
 
 ; ASM: .file   1 "/tmp/dbginfo/a{{[/\\]+}}a.cpp"

llvm/trunk/test/DebugInfo/X86/debug-macro.ll

 ; CHECK-NEXT:     DW_MACINFO_undef - lineno: 11 macro: NameUndef
 ; CHECK-NEXT:   DW_MACINFO_end_file
 ; CHECK-NEXT:   DW_MACINFO_undef - lineno: 10 macro: NameUndef2
 ; CHECK-NEXT: DW_MACINFO_end_file
 ; CHECK-NEXT: DW_MACINFO_start_file - lineno: 0 filenum: 1
 ; CHECK-NEXT: DW_MACINFO_end_file
 
 ; CHECK-LABEL: .debug_line contents:
-; CHECK: Dir  Mod Time   File Len   File Name
-; CHECK: file_names[  1] {{.*}}debug-macro.cpp
-; CHECK: file_names[  2] {{.*}}debug-macro.h
-; CHECK: Dir  Mod Time   File Len   File Name
-; CHECK: file_names[  1] {{.*}}debug-macro1.cpp
+; CHECK: file_names[  1]:
+; CHECK: name: "debug-macro.cpp"
+; CHECK: file_names[  2]:
+; CHECK: name: "debug-macro.h"
+; CHECK: file_names[  1]:
+; CHECK: name: "debug-macro1.cpp"
 
 !llvm.dbg.cu = !{!0, !16, !20}
 !llvm.module.flags = !{!13, !14}
 !llvm.ident = !{!15}
 
 !0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, producer: "clang version 3.5.0 ", isOptimized: false, emissionKind: FullDebug, file: !1, enums: !2, retainedTypes: !2, globals: !2, imports: !2, macros: !3)
 !1 = !DIFile(filename: "debug-macro.cpp", directory: "/")
 !2 = !{}

llvm/trunk/test/DebugInfo/X86/dwarfdump-header-64.s

 # CHECK: version: 5
 # CHECK: address_size: 8
 # CHECK: seg_select_size: 0
 # CHECK: prologue_length: 0x00000044
 # CHECK: max_ops_per_inst: 1
 # CHECK: include_directories[  0] = .debug_str[0x00000028] = "Directory5a"
 # CHECK: include_directories[  1] = .debug_str[0x00000034] = "Directory5b"
 # CHECK-NOT: include_directories
-# CHECK: file_names[  0]    0 0x00000051 0x00000052 "File5a"
-# CHECK: file_names[  1]    1 0x00000053 0x00000054 "File5b"
+# CHECK: file_names[  0]:
+# CHECK-NEXT: name: "File5a"
+# CHECK-NEXT: dir_index: 0
+# CHECK-NEXT: mod_time: 0x00000051
+# CHECK-NEXT: length: 0x00000052
+# CHECK: file_names[  1]:
+# CHECK-NEXT: name: "File5b"
+# CHECK-NEXT: dir_index: 1
+# CHECK-NEXT: mod_time: 0x00000053
+# CHECK-NEXT: length: 0x00000054
 # CHECK-NOT: file_names

llvm/trunk/test/DebugInfo/X86/dwarfdump-header.s

 # CHECK: Line table prologue:
 # CHECK: version: 4
 # CHECK-NOT: address_size
 # CHECK-NOT: seg_select_size
 # CHECK: max_ops_per_inst: 1
 # CHECK: include_directories[  1] = "Directory4a"
 # CHECK: include_directories[  2] = "Directory4b"
 # CHECK-NOT: include_directories
-# CHECK: file_names[  1]    1 0x00000041 0x00000042 "File4a"
-# CHECK: file_names[  2]    0 0x00000043 0x00000044 "File4b"
+# CHECK: file_names[  1]:
+# CHECK-NEXT: name: "File4a"
+# CHECK-NEXT: dir_index: 1
+# CHECK-NEXT: mod_time: 0x00000041
+# CHECK-NEXT: length: 0x00000042
+# CHECK: file_names[  2]:
+# CHECK-NEXT: name: "File4b"
+# CHECK-NEXT: dir_index: 0
+# CHECK-NEXT: mod_time: 0x00000043
+# CHECK-NEXT: length: 0x00000044
 # CHECK-NOT: file_names
 
 # DWARF v5 line-table header.
 LH_5_start:
         .long   LH_5_end-LH_5_version   # Length of Unit
 LH_5_version:
         .short  5               # DWARF version number
         .byte   8               # Address Size

 # CHECK: address_size: 8
 # CHECK: seg_select_size: 0
 # CHECK: max_ops_per_inst: 1
 # Mixing .debug_str (here) with .debug_line_str (in file_names) is not
 # something a producer would do, but both are legal and we want to test them.
 # CHECK: include_directories[  0] = .debug_str[0x00000045] = "Directory5a"
 # CHECK: include_directories[  1] = .debug_str[0x00000051] = "Directory5b"
 # CHECK-NOT: include_directories
-# CHECK: MD5 Checksum
-# CHECK: file_names[  0]    0 00112233445566778899aabbccddeeff .debug_line_str[0x00000000] = "File5a"
-# CHECK: file_names[  1]    1 ffeeddccbbaa99887766554433221100 .debug_line_str[0x00000007] = "File5b"
+# CHECK: file_names[  0]:
+# CHECK-NEXT: name: .debug_line_str[0x00000000] = "File5a"
+# CHECK-NEXT: dir_index: 0
+# CHECK-NEXT: md5_checksum: 00112233445566778899aabbccddeeff
+# CHECK: file_names[  1]:
+# CHECK-NEXT: name: .debug_line_str[0x00000007] = "File5b"
+# CHECK-NEXT: dir_index: 1
+# CHECK-NEXT: md5_checksum: ffeeddccbbaa99887766554433221100
 # CHECK-NOT: file_names
 
         .section .debug_line_str,"MS",@progbits,1
 lstr_LT_5a:
         .asciz "File5a"
 lstr_LT_5b:
         .asciz "File5b"
 

 # CHECK: Line table prologue:
 # CHECK: version: 5
 # CHECK: address_size: 8
 # CHECK: seg_select_size: 0
 # CHECK: max_ops_per_inst: 1
 # CHECK: include_directories[  0] = .debug_str[0x0000003d] = "DWODirectory5a"
 # CHECK: include_directories[  1] = .debug_str[0x0000004c] = "DWODirectory5b"
 # CHECK-NOT: include_directories
-# CHECK: file_names[  0]    0 0x00000015 0x00000025 "DWOFile5a"
-# CHECK: file_names[  1]    1 0x00000035 0x00000045 "DWOFile5b"
+# CHECK: file_names[  0]:
+# CHECK-NEXT: name: "DWOFile5a"
+# CHECK-NEXT: dir_index: 0
+# CHECK-NEXT: mod_time: 0x00000015
+# CHECK-NEXT: length: 0x00000025
+# CHECK: file_names[  1]:
+# CHECK-NEXT: name: "DWOFile5b"
+# CHECK-NEXT: dir_index: 1
+# CHECK-NEXT: mod_time: 0x00000035
+# CHECK-NEXT: length: 0x00000045
 # CHECK-NOT: file_names

llvm/trunk/test/DebugInfo/X86/dwarfdump-line-dwo.s

LH_1_header_end:
         # Line number program, which is empty.
 LH_1_end:
 
 # PART1:      Line table prologue:
 # PART1-NEXT: total_length: 0x0000002e
 # PART1-NEXT: version: 4
 # PART1-NEXT: prologue_length: 0x00000028
 # PART1:      include_directories[  1] = "Directory1"
-# PART1:      file_names[  1] {{.*}} "File1"
+# PART1:      file_names[  1]
+# PART1:      name: "File1"
 
 # Second line table.
 LH_2_start:
         .long   LH_2_end-LH_2_version   # Length of Unit
 LH_2_version:
         .short  4               # DWARF version number
         .long   LH_2_header_end-LH_2_params     # Length of Prologue
 LH_2_params:

 LH_2_end:
 
 # PART2:      Line table prologue:
 # PART2-NEXT: total_length: 0x00000028
 # PART2-NEXT: version: 4
 # PART2-NEXT: prologue_length: 0x00000022
 # PART2-NOT:  prologue:
 # PART2:      include_directories[  1] = "Dir2"
-# PART2:      file_names[  1] {{.*}} "File2"
+# PART2:      file_names[  1]
+# PART2:      name: "File2"
 # PART2-NOT:  prologue:

llvm/trunk/test/DebugInfo/X86/dwarfdump-line-only.s

 # CHECK: Line table prologue:
 # CHECK: version: 5
 # CHECK: address_size: 8
 # CHECK: seg_select_size: 0
 # CHECK: max_ops_per_inst: 1
 # CHECK: include_directories[  0] = .debug_str[0x00000000] = "Directory1"
 # CHECK: include_directories[  1] = .debug_str[0x0000000b] = "Directory2"
 # CHECK-NOT: include_directories
-# CHECK: file_names[  0]    1 0x00000051 0x00000052 .debug_line_str[0x00000000] = "File1"
-# CHECK: file_names[  1]    0 0x00000053 0x00000054 .debug_line_str[0x00000006] = "File2"
+# CHECK: file_names[  0]:
+# CHECK-NEXT: name: .debug_line_str[0x00000000] = "File1"
+# CHECK-NEXT: dir_index: 1
+# CHECK-NEXT: mod_time: 0x00000051
+# CHECK-NEXT: length: 0x00000052
+# CHECK: file_names[  1]:
+# CHECK-NEXT: name: .debug_line_str[0x00000006] = "File2"
+# CHECK-NEXT: dir_index: 0
+# CHECK-NEXT: mod_time: 0x00000053
+# CHECK-NEXT: length: 0x00000054
 # CHECK-NOT: file_names
 # CHECK: 0x0000000000000000 {{.*}} is_stmt end_sequence

llvm/trunk/test/DebugInfo/X86/generate-odr-hash.ll

 ; CHECK-NOT: DW_AT_name
 ; CHECK-NOT: DW_AT_GNU_odr_signature
 ; CHECK: DW_TAG_member
 ; CHECK-NEXT: DW_AT_name{{.*}}"a"
 
 ; CHECK-LABEL: .debug_line contents:
 ; CHECK: Line table prologue
 ; CHECK-NOT: file_names[
-; SINGLE: file_names{{.*}} "bar.h"
-; CHECK: file_names{{.*}} "bar.cpp"
+; SINGLE: file_names[
+; SINGLE-NEXT: name: "bar.h"
+; CHECK: file_names[
+; CHECK-NEXT: name: "bar.cpp"
 ; CHECK-NOT: file_names[
 
 ; FISSION: .debug_line.dwo contents:
 ; CHECK-NOT: .debug_line.dwo contents:
 ; FISSION: Line table prologue
 ; FISSION: opcode_base: 1
 ; FISSION-NOT: standard_opcode_lengths
 ; FISSION-NOT: include_directories
 ; FISSION-NOT: file_names[
-; FISSION: file_names{{.*}} "bar.h"
-; FISSION: file_names{{.*}} "bar.cpp"
+; FISSION: file_names[
+; FISSION-NEXT: name: "bar.h"
+; FISSION: file_names[
+; FISSION-NEXT: name: "bar.cpp"
 ; FISSION-NOT: file_names[
 
 ; CHECK-LABEL: .debug_str contents:
 
 ; Use the unit size as a rough hash/identifier for the unit we're dealing with
 ; it happens to be unambiguous at the moment, but it's hardly ideal.
 ; CHECK-LABEL: .debug_pubtypes contents:
 ; Don't emit pubtype entries for type DIEs in the compile unit that just indirect to a type unit.

llvm/trunk/test/DebugInfo/X86/stmt-list-multiple-compile-units.ll

 ; CHECK: DW_AT_low_pc [DW_FORM_addr]            (0x0000000000000010)
 ; CHECK: DW_AT_high_pc [DW_FORM_data4]          (0x00000009)
 
 
 ; CHECK: .debug_line contents:
 ; CHECK-NEXT: debug_line[{{.*}}]
 ; CHECK-NEXT: Line table prologue:
 ; CHECK-NEXT: total_length: 0x00000038
-; CHECK: file_names[  1]    0 0x00000000 0x00000000 "simple.c"
+; CHECK: file_names[  1]:
+; CHECK-NEXT: name: "simple.c"
+; CHECK-NEXT: dir_index: 0
 ; CHECK: debug_line[{{.*}}]
 ; CHECK-NEXT: Line table prologue:
 ; CHECK-NEXT: total_length: 0x00000039
-; CHECK: file_names[  1]    0 0x00000000 0x00000000 "simple2.c"
+; CHECK: file_names[  1]:
+; CHECK-NEXT: name: "simple2.c"
+; CHECK-NEXT: dir_index: 0
 ; CHECK-NOT: file_names
 
 ; DWARF3: .debug_info contents:
 ; DWARF3: DW_TAG_compile_unit
 ; DWARF3: DW_AT_stmt_list [DW_FORM_data4]    (0x00000000)
 
 ; DWARF3: DW_TAG_compile_unit
 ; DWARF3: DW_AT_stmt_list [DW_FORM_data4]   (0x0000003c)
 
 
 ; DWARF3: .debug_line contents:
 ; DWARF3-NEXT: debug_line[{{.*}}]
 ; DWARF3-NEXT: Line table prologue:
 ; DWARF3-NEXT: total_length: 0x00000038
-; DWARF3: file_names[  1]    0 0x00000000 0x00000000 "simple.c"
+; DWARF3: file_names[  1]:
+; DWARF3-NEXT: name: "simple.c"
+; DWARF3-NEXT: dir_index: 0
 ; DWARF3: debug_line[{{.*}}]
 ; DWARF3-NEXT: Line table prologue:
 ; DWARF3-NEXT: total_length: 0x00000039
-; DWARF3: file_names[  1]    0 0x00000000 0x00000000 "simple2.c"
+; DWARF3: file_names[  1]:
+; DWARF3-NEXT: name: "simple2.c"
+; DWARF3-NEXT: dir_index: 0
 ; DWARF3-NOT: file_names
 
 ; PR15408
 ; ASM: Lcu_begin0:
 ; ASM-NOT: Lcu_begin
 ; ASM: Lset[[LT:[0-9]+]] = Lline_table_start0-Lsection_line ## DW_AT_stmt_list
 ; ASM-NEXT: .long   Lset[[LT]]
 ; ASM: Lcu_begin1:

llvm/trunk/test/DebugInfo/debugmacinfo.test

 TEST_MACINFO:   DW_MACINFO_start_file - lineno: 2 filenum: 3
 TEST_MACINFO:     DW_MACINFO_undef - lineno: 4 macro: M1
 TEST_MACINFO:     DW_MACINFO_define - lineno: 5 macro: M1 NewValue1
 TEST_MACINFO:   DW_MACINFO_end_file
 TEST_MACINFO:   DW_MACINFO_define - lineno: 3 macro: M2(x,y) ((x)+(y)* Value2)
 TEST_MACINFO: DW_MACINFO_end_file
 
 TEST_LINE: .debug_line contents:
-TEST_LINE: file_names[  1]    0 0x00000000 0x00000000 "dwarfdump-macro.cc"
-TEST_LINE: file_names[  2]    1 0x00000000 0x00000000 "dwarfdump-macro-cmd.h"
-TEST_LINE: file_names[  3]    0 0x00000000 0x00000000 "dwarfdump-macro.h"
+TEST_LINE: file_names[  1]:
+TEST_LINE-NEXT: name: "dwarfdump-macro.cc"
+TEST_LINE-NEXT: dir_index: 0
+TEST_LINE: file_names[  2]:
+TEST_LINE-NEXT: name: "dwarfdump-macro-cmd.h"
+TEST_LINE-NEXT: dir_index: 1
+TEST_LINE: file_names[  3]:
+TEST_LINE-NEXT: name: "dwarfdump-macro.h"
+TEST_LINE-NEXT: dir_index: 0

llvm/trunk/test/Linker/subprogram-linkonce-weak.ll

 ; DWWL:         DW_AT_decl_file {{.*}}"/path/to/dir{{/|\\}}bar.c"
 ; DWWL:         DW_AT_decl_line {{.*}}(11)
 ; DWWL:         DW_TAG_inlined_subroutine
 ; DWWL:           DW_AT_abstract_origin
 
 ; DW-LABEL:   .debug_line contents:
 ; Check that we have the right things in the line table as well.
 
-; DWLW-LABEL: file_names[{{ *}}1]{{.*}} "bar.c"
+; DWLW-LABEL: file_names[ 1]:
+; DWLW-NEXT: name: "bar.c"
 ; DWLW:        2 0 1 0 0 is_stmt prologue_end
-; DWLW-LABEL: file_names[{{ *}}1]{{.*}} "foo.c"
+; DWLW-LABEL: file_names[ 1]:
+; DWLW-NEXT: name: "foo.c"
 ; DWLW:       52 0 1 0 0 is_stmt prologue_end
 ; DWLW-NOT:                      prologue_end
 
-; DWWL-LABEL: file_names[{{ *}}1]{{.*}} "foo.c"
+; DWWL-LABEL: file_names[ 1]:
+; DWWL-NEXT: name: "foo.c"
 ; DWWL:       52 0 1 0 0 is_stmt prologue_end
-; DWWL-LABEL: file_names[{{ *}}1]{{.*}} "bar.c"
+; DWWL-LABEL: file_names[ 1]:
+; DWWL-NEXT: name: "bar.c"
 ; DWWL:        2 0 1 0 0 is_stmt prologue_end
 ; DWWL-NOT:                      prologue_end

llvm/trunk/test/MC/ARM/dwarf-asm-multiple-sections.s

 // DWARF-NEXT: [0x00000000, 0x00000004)
 // DWARF-NEXT: [0x00000000, 0x00000004)
 
 
 // DWARF-DL: .debug_line contents:
 // DWARF-DL: version: [[DWVER]]
 // DWARF-DL-5:    address_size: 4
 // DWARF-DL-5:    include_directories[  0] = ""
-// DWARF-DL:      file_names[  [[DWFILE]]] {{.*}} "<stdin>"
+// DWARF-DL:      file_names[  [[DWFILE]]]:
+// DWARF-DL:      name: "<stdin>"
 // DWARF-DL:      0x0000000000000000     17      0      1   0   0  is_stmt
 // DWARF-DL-NEXT: 0x0000000000000004     17      0      1   0   0  is_stmt end_sequence
 // DWARF-DL-NEXT: 0x0000000000000000     21      0      1   0   0  is_stmt
 // DWARF-DL-NEXT: 0x0000000000000004     21      0      1   0   0  is_stmt end_sequence
 
 
 // DWARF: .debug_ranges contents:
 // DWARF: 00000000 ffffffff 00000000

llvm/trunk/test/MC/ELF/debug-md5.s

 // RUN: llvm-mc -triple x86_64-unknown-unknown -dwarf-version 5 -filetype=obj %s -o - | llvm-dwarfdump --debug-line --debug-line-str -v - | FileCheck %s
 
         .file 1 "dir1/foo"   md5 "00112233445566778899aabbccddeeff"
         .file 2 "dir2" "bar" md5 "ffeeddccbbaa99887766554433221100"
         .loc 1 1 0
         nop
         .loc 2 1 0
         nop
 
 # CHECK: debug_line[0x00000000]
 # CHECK: version: 5
 # CHECK: include_directories[ 0] = .debug_line_str[0x[[DIR0:[0-9a-f]+]]] = ""
 # CHECK: include_directories[ 1] = .debug_line_str[0x[[DIR1:[0-9a-f]+]]] = "dir1"
 # CHECK: include_directories[ 2] = .debug_line_str[0x[[DIR2:[0-9a-f]+]]] = "dir2"
 # CHECK-NOT: include_directories
-# CHECK: Dir MD5 Checksum File Name
-# CHECK: file_names[ 0] 1 00112233445566778899aabbccddeeff .debug_line_str[0x[[FILE1:[0-9a-f]+]]] = "foo"
-# CHECK: file_names[ 1] 2 ffeeddccbbaa99887766554433221100 .debug_line_str[0x[[FILE2:[0-9a-f]+]]] = "bar"
+# CHECK: file_names[ 0]:
+# CHECK-NEXT: name: .debug_line_str[0x[[FILE1:[0-9a-f]+]]] = "foo"
+# CHECK-NEXT: dir_index: 1
+# CHECK-NEXT: md5_checksum: 00112233445566778899aabbccddeeff
+# CHECK: file_names[ 1]:
+# CHECK-NEXT: name: .debug_line_str[0x[[FILE2:[0-9a-f]+]]] = "bar"
+# CHECK-NEXT: dir_index: 2
+# CHECK-NEXT: md5_checksum: ffeeddccbbaa99887766554433221100
 
 # CHECK: .debug_line_str contents:
 # CHECK-NEXT: 0x[[DIR0]]: ""
 # CHECK-NEXT: 0x[[DIR1]]: "dir1"
 # CHECK-NEXT: 0x[[DIR2]]: "dir2"
 # CHECK-NEXT: 0x[[FILE1]]: "foo"
 # CHECK-NEXT: 0x[[FILE2]]: "bar"

llvm/trunk/test/MC/MachO/gen-dwarf-cpp.s

 # 42 "t.s"
   ret
 
 // rdar://9275556
 
 // We check that the source name "t.s" is picked up
 // CHECK: include_directories[  1] = "{{.*(/|\\\\)}}test{{(/|\\\\)}}MC{{(/|\\\\)}}MachO"
 // CHECK: include_directories[  2] = "inc"
-// CHECK:                 Dir  Mod Time   File Len   File Name
-// CHECK:                 ---- ---------- ---------- ---------------------------
-// CHECK: file_names[  1]    1 0x00000000 0x00000000 "gen-dwarf-cpp.s"
-// CHECK: file_names[  2]    0 0x00000000 0x00000000 "t.s"
-// CHECK: file_names[  3]    2 0x00000000 0x00000000 "g.s"
+// CHECK: file_names[  1]:
+// CHECK-NEXT: name: "gen-dwarf-cpp.s"
+// CHECK-NEXT: dir_index: 1
+// CHECK: file_names[  2]:
+// CHECK-NEXT: name: "t.s"
+// CHECK-NEXT: dir_index: 0
+// CHECK: file_names[  3]:
+// CHECK-NEXT: name: "g.s"
+// CHECK-NEXT: dir_index: 2
 // CHECK-NOT: file_names
 
 // We check that the source line number 100 is picked up before the "movl"
 // CHECK: Address            Line   Column File   ISA Discriminator Flags
 // CHECK: ------------------ ------ ------ ------ --- ------------- -------------
 // CHECK: 0x0000000000000000    102      0      2   0             0  is_stmt

llvm/trunk/test/MC/MachO/gen-dwarf-macro-cpp.s

 // RUN: llvm-mc -g -triple i386-apple-darwin10 %s -filetype=obj -o %t
 // RUN: llvm-dwarfdump -debug-line %t | FileCheck %s
 
 # 1 "foo.S" 2
 .macro switcher
         ljmp *0x38(%ecx)
 .endmacro
         switcher NaClSwitchNoSSE, 0
 
 // PR14264 was a crash in the code caused by the .macro not handled correctly
 // rdar://12637628
 
 // We check that the source name "foo.S" is picked up
-// CHECK:                 Dir  Mod Time   File Len   File Name
-// CHECK:                 ---- ---------- ---------- ---------------------------
-// CHECK: file_names[  1]    1 0x00000000 0x00000000 "gen-dwarf-macro-cpp.s"
-// CHECK: file_names[  2]    0 0x00000000 0x00000000 "foo.S"
+// CHECK: file_names[  1]:
+// CHECK-NEXT: name: "gen-dwarf-macro-cpp.s"
+// CHECK-NEXT: dir_index: 1
+// CHECK: file_names[  2]:
+// CHECK-NEXT: name: "foo.S"
+// CHECK-NEXT: dir_index: 0

llvm/trunk/test/MC/MachO/gen-dwarf.s

 // CHECK: standard_opcode_lengths[DW_LNS_negate_stmt] = 0
 // CHECK: standard_opcode_lengths[DW_LNS_set_basic_block] = 0
 // CHECK: standard_opcode_lengths[DW_LNS_const_add_pc] = 0
 // CHECK: standard_opcode_lengths[DW_LNS_fixed_advance_pc] = 1
 // CHECK: standard_opcode_lengths[DW_LNS_set_prologue_end] = 0
 // CHECK: standard_opcode_lengths[DW_LNS_set_epilogue_begin] = 0
 // CHECK: standard_opcode_lengths[DW_LNS_set_isa] = 1
 // We don't check include_directories as it has a temp path
-// CHECK:                 Dir  Mod Time   File Len   File Name
-// CHECK:                 ---- ---------- ---------- ---------------------------
-// CHECK: file_names[  1]    1 0x00000000 0x00000000 "gen-dwarf.s"
+// CHECK: file_names[  1]:
+// CHECK-NEXT: name: "gen-dwarf.s"
+// CHECK-NEXT: dir_index: 1
 
 // CHECK: Address            Line   Column File   ISA Discriminator Flags
 // CHECK: ------------------ ------ ------ ------ --- ------------- -------------
 // CHECK: 0x0000000000000000      6      0      1   0             0  is_stmt
 // CHECK: 0x0000000000000005      7      0      1   0             0  is_stmt
 // CHECK: 0x0000000000000006      8      0      1   0             0  is_stmt
 // CHECK: 0x0000000000000007     11      0      1   0             0  is_stmt
 // CHECK: 0x0000000000000008     11      0      1   0             0  is_stmt end_sequence

llvm/trunk/test/tools/dsymutil/X86/basic-linking-x86.test

 CHECK-NEXT:Address Range Header: length = 0x0000003c, version = 0x0002, cu_offset = 0x00000081, addr_size = 0x08, seg_size = 0x00
 CHECK-NEXT:[0x0000000100000ed0, 0x0000000100000f19)
 CHECK-NEXT:[0x0000000100000f20, 0x0000000100000f37)
 CHECK-NEXT:Address Range Header: length = 0x0000003c, version = 0x0002, cu_offset = 0x00000126, addr_size = 0x08, seg_size = 0x00
 CHECK-NEXT:[0x0000000100000f40, 0x0000000100000f84)
 CHECK-NEXT:[0x0000000100000f90, 0x0000000100000fa9)
 
 CHECK: .debug_line contents:
-CHECK:                Dir  Mod Time   File Len   File Name
-CHECK-NEXT:                 ---- ---------- ---------- ---------------------------
-CHECK-NEXT: file_names[  1]    0 0x00000000 0x00000000 "basic1.c"
+CHECK: file_names[  1]:
+CHECK-NEXT: name: "basic1.c"
+CHECK-NEXT: dir_index: 0
 CHECK: Address            Line   Column File   ISA Discriminator Flags
 CHECK-NEXT: ------------------ ------ ------ ------ --- ------------- -------------
 CHECK-NEXT: 0x0000000100000ea0     23      0      1   0             0  is_stmt
 CHECK-NEXT: 0x0000000100000eb6     24      0      1   0             0  is_stmt prologue_end
 CHECK-NEXT: 0x0000000100000ec4     24      0      1   0             0  is_stmt end_sequence
 
-CHECK:                 Dir  Mod Time   File Len   File Name
-CHECK-NEXT:                 ---- ---------- ---------- ---------------------------
-CHECK-NEXT: file_names[  1]    0 0x00000000 0x00000000 "basic2.c"
+CHECK: file_names[  1]:
+CHECK-NEXT: name: "basic2.c"
+CHECK-NEXT: dir_index: 0
 CHECK: Address            Line   Column File   ISA Discriminator Flags
 CHECK-NEXT: ------------------ ------ ------ ------ --- ------------- -------------
 CHECK-NEXT: 0x0000000100000ed0     19      0      1   0             0  is_stmt
 CHECK-NEXT: 0x0000000100000ee2     20      0      1   0             0  is_stmt prologue_end
 CHECK-NEXT: 0x0000000100000f19     20      0      1   0             0  is_stmt end_sequence
 CHECK-NEXT: 0x0000000100000f20     14      0      1   0             0  is_stmt
 CHECK-NEXT: 0x0000000100000f24     15      0      1   0             0  is_stmt prologue_end
 CHECK-NEXT: 0x0000000100000f37     15      0      1   0             0  is_stmt end_sequence
 
-CHECK:                 Dir  Mod Time   File Len   File Name
-CHECK-NEXT:                 ---- ---------- ---------- ---------------------------
-CHECK-NEXT: file_names[  1]    0 0x00000000 0x00000000 "basic3.c"
+CHECK: file_names[  1]:
+CHECK-NEXT: name: "basic3.c"
+CHECK-NEXT: dir_index: 0
 CHECK: Address            Line   Column File   ISA Discriminator Flags
 CHECK-NEXT: ------------------ ------ ------ ------ --- ------------- -------------
 CHECK-NEXT: 0x0000000100000f40     16      0      1   0             0  is_stmt
 CHECK-NEXT: 0x0000000100000f4b     17      0      1   0             0  is_stmt prologue_end
 CHECK-NEXT: 0x0000000100000f58     18      0      1   0             0  is_stmt
 CHECK-NEXT: 0x0000000100000f6c     19      0      1   0             0  is_stmt
 CHECK-NEXT: 0x0000000100000f7b     20      0      1   0             0  is_stmt
 CHECK-NEXT: 0x0000000100000f84     20      0      1   0             0  is_stmt end_sequence

llvm/trunk/test/tools/dsymutil/X86/basic-lto-dw4-linking-x86.test

 CHECK-NEXT: Address Range Header: length = 0x0000002c, version = 0x0002, cu_offset = 0x00000000, addr_size = 0x08, seg_size = 0x00
 CHECK-NEXT: [0x0000000100000f40,  0x0000000100000f4b)
 CHECK-NEXT: Address Range Header: length = 0x0000002c, version = 0x0002, cu_offset = 0x00000077, addr_size = 0x08, seg_size = 0x00
 CHECK-NEXT: [0x0000000100000f50, 0x0000000100000f87)
 CHECK-NEXT: Address Range Header: length = 0x0000002c, version = 0x0002, cu_offset = 0x0000011b, addr_size = 0x08, seg_size = 0x00
 CHECK-NEXT: [0x0000000100000f90, 0x0000000100000fb4)
 
 CHECK: .debug_line contents:
-CHECK:                 Dir  Mod Time   File Len   File Name
-CHECK-NEXT:                 ---- ---------- ---------- ---------------------------
-CHECK-NEXT: file_names[  1]    0 0x00000000 0x00000000 "basic1.c"
+CHECK: file_names[  1]:
+CHECK-NEXT: name: "basic1.c"
+CHECK-NEXT: dir_index: 0
 CHECK: Address            Line   Column File   ISA Discriminator Flags
 CHECK-NEXT: ------------------ ------ ------ ------ --- ------------- -------------
 CHECK-NEXT: 0x0000000100000f40     26      0      1   0             0  is_stmt
 CHECK-NEXT: 0x0000000100000f44     27     10      1   0             0  is_stmt prologue_end
 CHECK-NEXT: 0x0000000100000f49     27      3      1   0             0
 CHECK-NEXT: 0x0000000100000f4b     27      3      1   0             0  end_sequence
 
-CHECK:                 Dir  Mod Time   File Len   File Name
-CHECK-NEXT:                 ---- ---------- ---------- ---------------------------
-CHECK-NEXT: file_names[  1]    0 0x00000000 0x00000000 "basic2.c"
+CHECK: file_names[  1]:
+CHECK-NEXT: name: "basic2.c"
+CHECK-NEXT: dir_index: 0
 CHECK: Address            Line   Column File   ISA Discriminator Flags
 CHECK-NEXT: ------------------ ------ ------ ------ --- ------------- -------------
 CHECK-NEXT: 0x0000000100000f50     19      0      1   0             0  is_stmt
 CHECK-NEXT: 0x0000000100000f54     20     18      1   0             0  is_stmt prologue_end
 CHECK-NEXT: 0x0000000100000f5a     20     17      1   0             0
 CHECK-NEXT: 0x0000000100000f5c     20     10      1   0             0
 CHECK-NEXT: 0x0000000100000f61     15     10      1   0             0  is_stmt
 CHECK-NEXT: 0x0000000100000f70     20     23      1   0             0  is_stmt
 CHECK-NEXT: 0x0000000100000f74     20     36      1   0             0
 CHECK-NEXT: 0x0000000100000f83     20     31      1   0             0
 CHECK-NEXT: 0x0000000100000f85     20      3      1   0             0
 CHECK-NEXT: 0x0000000100000f87     20      3      1   0             0  end_sequence
 
-CHECK:                 Dir  Mod Time   File Len   File Name
-CHECK-NEXT:                 ---- ---------- ---------- ---------------------------
-CHECK-NEXT: file_names[  1]    0 0x00000000 0x00000000 "basic3.c"
+CHECK: file_names[  1]:
+CHECK-NEXT: name: "basic3.c"
+CHECK-NEXT: dir_index: 0
 CHECK: Address            Line   Column File   ISA Discriminator Flags
 CHECK-NEXT: ------------------ ------ ------ ------ --- ------------- -------------
 CHECK-NEXT: 0x0000000100000f90     16      0      1   0             0  is_stmt
 CHECK-NEXT: 0x0000000100000f94     12     10      1   0             0  is_stmt prologue_end
 CHECK-NEXT: 0x0000000100000f9a     17      7      1   0             0  is_stmt
 CHECK-NEXT: 0x0000000100000f9f     12     10      1   0             0  is_stmt
 CHECK-NEXT: 0x0000000100000fa7     20      1      1   0             0  is_stmt
 CHECK-NEXT: 0x0000000100000fa9     19     18      1   0             0  is_stmt

llvm/trunk/test/tools/dsymutil/X86/basic-lto-linking-x86.test

 CHECK-NEXT: [0x0000000100000f40, 0x0000000100000f4b)
 CHECK-NEXT: Address Range Header: length = 0x0000002c, version = 0x0002, cu_offset = 0x00000081, addr_size = 0x08, seg_size = 0x00
 CHECK-NEXT: [0x0000000100000f50, 0x0000000100000f89)
 CHECK-NEXT: Address Range Header: length = 0x0000002c, version = 0x0002, cu_offset = 0x0000013a, addr_size = 0x08, seg_size = 0x00
 CHECK-NEXT: [0x0000000100000f90, 0x0000000100000fb4)
 
 
 CHECK: .debug_line contents
-CHECK:                 Dir  Mod Time   File Len   File Name
-CHECK-NEXT:                 ---- ---------- ---------- ---------------------------
-CHECK-NEXT: file_names[  1]    0 0x00000000 0x00000000 "basic1.c"
+CHECK: file_names[  1]:
+CHECK-NEXT: name: "basic1.c"
+CHECK-NEXT: dir_index: 0
 CHECK: 0x0000000100000f40     23      0      1   0             0  is_stmt
 CHECK: 0x0000000100000f44     24      0      1   0             0  is_stmt prologue_end
 CHECK: 0x0000000100000f4b     24      0      1   0             0  is_stmt end_sequence
 
-CHECK:                 Dir  Mod Time   File Len   File Name
-CHECK-NEXT:                 ---- ---------- ---------- ---------------------------
-CHECK-NEXT: file_names[  1]    0 0x00000000 0x00000000 "basic2.c"
+CHECK: file_names[  1]:
+CHECK-NEXT: name: "basic2.c"
+CHECK-NEXT: dir_index: 0
 CHECK: 0x0000000100000f50     19      0      1   0             0  is_stmt
 CHECK: 0x0000000100000f54     20      0      1   0             0  is_stmt prologue_end
 CHECK: 0x0000000100000f63     15      0      1   0             0  is_stmt
 CHECK: 0x0000000100000f72     20      0      1   0             0  is_stmt
 CHECK: 0x0000000100000f89     20      0      1   0             0  is_stmt end_sequence
 
-CHECK:                 Dir  Mod Time   File Len   File Name
-CHECK-NEXT:                 ---- ---------- ---------- ---------------------------
-CHECK-NEXT: file_names[  1]    0 0x00000000 0x00000000 "basic3.c"
+CHECK: file_names[  1]:
+CHECK-NEXT: name: "basic3.c"
+CHECK-NEXT: dir_index: 0
 CHECK: 0x0000000100000f90     16      0      1   0             0  is_stmt
 CHECK: 0x0000000100000f94     12      0      1   0             0  is_stmt prologue_end
 CHECK: 0x0000000100000f9a     17      0      1   0             0  is_stmt
 CHECK: 0x0000000100000f9f     12      0      1   0             0  is_stmt
 CHECK: 0x0000000100000fa7     20      0      1   0             0  is_stmt
 CHECK: 0x0000000100000fa9     19      0      1   0             0  is_stmt
 CHECK: 0x0000000100000fb2     20      0      1   0             0  is_stmt
 CHECK: 0x0000000100000fb4     20      0      1   0             0  is_stmt end_sequence

llvm/trunk/tools/llvm-objdump/llvm-objdump.cpp

protected:
   const ObjectFile *Obj = nullptr;
   std::unique_ptr<symbolize::LLVMSymbolizer> Symbolizer;
   // File name to file contents of source
   std::unordered_map<std::string, std::unique_ptr<MemoryBuffer>> SourceCache;
   // Mark the line endings of the cached source
   std::unordered_map<std::string, std::vector<StringRef>> LineCache;
 
 private:
-  bool cacheSource(const std::string& File);
+  bool cacheSource(const DILineInfo& LineInfoFile);
 
 public:
   SourcePrinter() = default;
   SourcePrinter(const ObjectFile *Obj, StringRef DefaultArch) : Obj(Obj) {
     symbolize::LLVMSymbolizer::Options SymbolizerOpts(
         DILineInfoSpecifier::FunctionNameKind::None, true, false, false,
         DefaultArch);
     Symbolizer.reset(new symbolize::LLVMSymbolizer(SymbolizerOpts));
   }
   virtual ~SourcePrinter() = default;
   virtual void printSourceLine(raw_ostream &OS, uint64_t Address,
                                StringRef Delimiter = "; ");
 };
 
-bool SourcePrinter::cacheSource(const std::string& File) {
-  auto BufferOrError = MemoryBuffer::getFile(File);
+bool SourcePrinter::cacheSource(const DILineInfo &LineInfo) {
+  std::unique_ptr<MemoryBuffer> Buffer;
+  if (LineInfo.Source) {
+    Buffer = MemoryBuffer::getMemBuffer(*LineInfo.Source);
+  } else {
+    auto BufferOrError = MemoryBuffer::getFile(LineInfo.FileName);
     if (!BufferOrError)
       return false;
+    Buffer = std::move(*BufferOrError);
+  }
   // Chomp the file to get lines
-  size_t BufferSize = (*BufferOrError)->getBufferSize();
-  const char *BufferStart = (*BufferOrError)->getBufferStart();
+  size_t BufferSize = Buffer->getBufferSize();
+  const char *BufferStart = Buffer->getBufferStart();
   for (const char *Start = BufferStart, *End = BufferStart;
        End < BufferStart + BufferSize; End++)
     if (*End == '\n' || End == BufferStart + BufferSize - 1 ||
         (*End == '\r' && *(End + 1) == '\n')) {
-      LineCache[File].push_back(StringRef(Start, End - Start));
+      LineCache[LineInfo.FileName].push_back(StringRef(Start, End - Start));
       if (*End == '\r')
         End++;
       Start = End + 1;
     }
-  SourceCache[File] = std::move(*BufferOrError);
+  SourceCache[LineInfo.FileName] = std::move(Buffer);
   return true;
 }
 
 void SourcePrinter::printSourceLine(raw_ostream &OS, uint64_t Address,
                                     StringRef Delimiter) {
   if (!Symbolizer)
     return;
   DILineInfo LineInfo = DILineInfo();
   auto ExpectecLineInfo =
       Symbolizer->symbolizeCode(Obj->getFileName(), Address);
   if (!ExpectecLineInfo)
     consumeError(ExpectecLineInfo.takeError());
   else
     LineInfo = *ExpectecLineInfo;
 
   if ((LineInfo.FileName == "<invalid>") || OldLineInfo.Line == LineInfo.Line ||
       LineInfo.Line == 0)
     return;
 
   if (PrintLines)
     OS << Delimiter << LineInfo.FileName << ":" << LineInfo.Line << "\n";
   if (PrintSource) {
     if (SourceCache.find(LineInfo.FileName) == SourceCache.end())
-      if (!cacheSource(LineInfo.FileName))
+      if (!cacheSource(LineInfo))
         return;
     auto FileBuffer = SourceCache.find(LineInfo.FileName);
     if (FileBuffer != SourceCache.end()) {
       auto LineBuffer = LineCache.find(LineInfo.FileName);
       if (LineBuffer != LineCache.end()) {
         if (LineInfo.Line > LineBuffer->second.size())
           return;
         // Vector begins at 0, line numbers are non-zero

llvm/trunk/unittests/IR/MetadataTest.cpp

 typedef MetadataTest DIFileTest;
 
 TEST_F(DIFileTest, get) {
   StringRef Filename = "file";
   StringRef Directory = "dir";
   DIFile::ChecksumKind CSKind = DIFile::ChecksumKind::CSK_MD5;
   StringRef ChecksumString = "000102030405060708090a0b0c0d0e0f";
   DIFile::ChecksumInfo<StringRef> Checksum(CSKind, ChecksumString);
-  auto *N = DIFile::get(Context, Filename, Directory, Checksum);
+  StringRef Source = "source";
+  auto *N = DIFile::get(Context, Filename, Directory, Checksum, Source);
 
   EXPECT_EQ(dwarf::DW_TAG_file_type, N->getTag());
   EXPECT_EQ(Filename, N->getFilename());
   EXPECT_EQ(Directory, N->getDirectory());
   EXPECT_EQ(Checksum, N->getChecksum());
-  EXPECT_EQ(N, DIFile::get(Context, Filename, Directory, Checksum));
+  EXPECT_EQ(Source, N->getSource());
+  EXPECT_EQ(N, DIFile::get(Context, Filename, Directory, Checksum, Source));
 
-  EXPECT_NE(N, DIFile::get(Context, "other", Directory, Checksum));
-  EXPECT_NE(N, DIFile::get(Context, Filename, "other", Checksum));
+  EXPECT_NE(N, DIFile::get(Context, "other", Directory, Checksum, Source));
+  EXPECT_NE(N, DIFile::get(Context, Filename, "other", Checksum, Source));
   DIFile::ChecksumInfo<StringRef> OtherChecksum(DIFile::ChecksumKind::CSK_SHA1, ChecksumString);
   EXPECT_NE(
       N, DIFile::get(Context, Filename, Directory, OtherChecksum));
+  StringRef OtherSource = "other";
+  EXPECT_NE(N, DIFile::get(Context, Filename, Directory, Checksum, OtherSource));
+  EXPECT_NE(N, DIFile::get(Context, Filename, Directory, Checksum));
   EXPECT_NE(N, DIFile::get(Context, Filename, Directory));
 
   TempDIFile Temp = N->clone();
   EXPECT_EQ(N, MDNode::replaceWithUniqued(std::move(Temp)));
 }
 
 TEST_F(DIFileTest, ScopeGetFile) {
   // Ensure that DIScope::getFile() returns itself.