[dwarfdump] Implement extraction of file information referenced in .debug_info.

[friss]

Summary

This is the merge of 2 patches:

Pass the DWARFUnit to DWARFDebugLine::getFileNameByIndex().

This way it can query the compilation dir when it is referenced (when a file references directory index 0, it refers to the compilation dir).

and:

[dwarfdump] Implement extraction of file information referenced in .debug_info.

This patch pretty prints the contents of the DW_AT_decl_file, DW_AT_call_file, DW_AT_decl_line and DW_AT_call line attributes.
Drop the const on the passed DWARFUnit to be able to call getLineTableForUnit (the line table construction is lazy, thus the getter might modify the Unit).

[friss]

lib/DebugInfo/DWARFDebugInfoEntry.cpp

119

The more I look at it, the less I like it. I'll work on something a bit different.

[friss]

• [dwarfdump] Dump DW_AT_(decl|call)_line attribute values as decimal values.
• Turn DWARFContext helpers getFileNameForUnit() and getFileLineInfoForCompileUnit() into full blowm DWARFDebugLine::LineTable methods.
• [dwarfdump] Dump full filenames as DW_AT_(decl|call)_file attribute values

[friss]

I really have troubles to get arcanist do what I want. I hope this update won't lose the fist 2 patches...

• [dwarfdump] Dump full filenames as DW_AT_(decl|call)_file attribute values

[friss]

Sorry for the spam. I'm still learning to use arcanist, and I must say at this point it's more a burden that a help... This latest revision is the result of a small series of 3 commits that should be easy enough to distinguish. They aren't really intermingled except for the test updates.
The first just prints the line numbers in decimal and updates the tests.
The second moves some static helpers of DWARFContext.cpp into equivalent methods of LineTable. There should be no functional change though.
The third one uses the newly exposed method to find and print full names for files referenced by DW_AT_(decl|call)_file.

[dblaikie]

Please go ahead & commit the decl/call_line portion of this (I'll take your
word for it that these seem like the only ones that should be printed as
decimal, the rest as hex - and if we see other cases we can figure it out
at that point) & then rebase this patch.

The realpath piece of this is particularly interesting - I don't know what
that API is, where it comes from (why it might not always be available),
etc. Also, not sure it makes sense to canonicalize the paths based on the
actual filesystem, rather than just rendering what's in the line table...
maybe some examples would help me understand better. (is that codepath
tested? How do we test it on machines that don't have realpath?)

[friss]

The line number portion is in. Rebase:

• Turn DWARFContext helpers getFileNameForUnit() and getFileLineInfoForCompileUnit() into full blowm DWARFDebugLine::LineTable methods.
• [dwarfdump] Dump full filenames as DW_AT_(decl|call)_file attribute values

[dblaikie]

lib/DebugInfo/DWARFContext.cpp

458

you could roll this declaration into the if condition below (though I'm still trying to figure out if this is the changes below are the right API direction)

lib/DebugInfo/DWARFDebugInfoEntry.cpp

94

Presumably this could be an "else" to the new if you're introducing at 97 - since they are mutually exclusive (a decl_file/decl_line will never be decoded by AttributeValueString - so you might as well not call it & avoid all the switching, etc)

98

I probably wouldn't worry about the typedef for just one usage

99

This variable could be rolled into an if condition down on line 103:

if (auto *LT = ... getLineTableForUnit(...))

if (LT->getFileNameByIndex(...))
  File = '"' + ...

104

Do you have test coverage for the situation where the file name is not found in the line table? (testing the fallback to the old behavior)

106

Just for fun you could use std::move on the RHS here:

File = '"' + std::move(File) + '"';

to possibly reuse the storage.

107

this pointer will be dangling when used on line 111, outside the scope of the 'File' variable

lib/DebugInfo/DWARFDebugLine.cpp

674

test coverage for this? Some absolute and relative paths? (hopefully you can do this with just some hardcoded dwarf (not sure is is_relative will properly return false for "/foo/bar" on a Windows machine, though)

lib/DebugInfo/DWARFDebugLine.h

186

Moving these two functions may be better as a separate patch.

[friss]

lib/DebugInfo/DWARFContext.cpp

458

What I had in the first patch was basically a duplication of the getFileNameByIndex() helper. I needed to make the helper globally available, and I decided to put it in LineTable as it is a LineTable search function. I could have put it in the Context or the Unit also, I'm open to suggestions.

lib/DebugInfo/DWARFDebugInfoEntry.cpp

94

Yep, the comparison bellow is cheaper. I'll move that.

98

I did that just for the 80 characters limit. I can of course remove it.

104

The programming is defensive, but the false path should never trigger. If the attribute references a line table entry, it'd better be there. Testing that would mean generating a invalid dwarf file, by striping the .debug_line section for example. Is that what you have in mind?

107

Oops...

lib/DebugInfo/DWARFDebugLine.cpp

674

Note that the only added logic in this function is really the realpath stuff. The other added code comes from the wrapper I moved out of DWARFContext.cpp and as such is not really new. I can try to craft some tests anyway.

lib/DebugInfo/DWARFDebugLine.h

186

It is a separate patch. Arcanist/Phabricator presents it a merged revision, but the DebugInfoEntry.cpp modification is in a separate patch in my tree, and I intend to commit is as such.

[dblaikie]

Last iteration updated here still has the issues mentioned earlier (the "oops" in DWARFDebugInfoEntryMinimal::dumpAttribute) & some other bits & pieces.

Should be easier to see with a new version, with feedback addressed.

The general API change - I don't have a strong opinion/idea about (perhaps because my brain is a bit stuck trying to understand the smaller details of the patch) but it sounds reasonable.

lib/DebugInfo/DWARFContext.cpp

496

Why did this become conditional+continue?

lib/DebugInfo/DWARFDebugInfoEntry.cpp

98

I would assume clang-format would do something plausible with the long expression, but I could be wrong.

104

That (crafting a debug_info section without a debug_line) is what came to mind, yet. This is a case where "as a bug investigation aid" seems to come to mind, and accounting for invalid/broken inputs and verifying good behavior there seems appropriate.

I mean I doubt we're robust enough to handle all forms of mangled input, but I think, eventually that may be a reasonable goal (especially if you guys intend to ship this as a user-facing tool, it might be worth fuzzing it, making it actually robust, etc)

lib/DebugInfo/DWARFDebugLine.cpp

674

Fair enough - the simple code move might be easier to see as a separate patch & I wouldn't worry too much about existing untested code. That's up to you.

(oops, old comment I forgot to send)

lib/DebugInfo/DWARFDebugLine.h

186

Somewhat hard to review like this, I think.

At least for some of this it's probably best to send "simple mechanical move" then "change in behavior" (it's difficult to scroll up & down trying to visually inspect the changes you made to the chunks of code you moved around). I'm trying to review things as quickly as possible so that many small patches doesn't slow you down - it should, in theory, speed up review because it's easy to eyeball for correctness.

[friss]

I'm sorry that you spent time again reviewing this, but I hadn't actually uploaded a new version. I opened a new revision with just the API move from the context to the LineTable (D5354) and I was going to update this one with just the file printing once the other is approved.

[friss]

Rebased on trunk and addressed old review comments.

[dblaikie]

Looks good to me - thanks!

[samsonov]

Looks good modulo a couple of nits below.

lib/DebugInfo/DWARFDebugInfoEntry.cpp

96

You can rewrite it as:

if (const auto *LT = ...) {
  LT->getFileNameByIndex(...);
   ...
}

102

std::move looks confusing here.

[friss]

lib/DebugInfo/DWARFDebugInfoEntry.cpp

102

This was actually Dave's suggestion. I've backed it out from the patch I'm committing.

[friss]

Closed by commit rL218246 (authored by @friss).

lib/DebugInfo/DWARFContext.cpp

 
 DWARFCompileUnit *DWARFContext::getCompileUnitForAddress(uint64_t Address) {
   // First, get the offset of the compile unit.
   uint32_t CUOffset = getDebugAranges()->findAddress(Address);
   // Retrieve the compile unit.
   return getCompileUnitForOffset(CUOffset);
 }
 
-static bool getFileNameForUnit(DWARFCompileUnit *U,
-                               const DWARFLineTable *LineTable,
-                               uint64_t FileIndex, FileLineInfoKind Kind,
-                               std::string &FileName) {
-  if (!U || !LineTable || Kind == FileLineInfoKind::None ||
-      !LineTable->getFileNameByIndex(FileIndex, Kind, FileName))
-    return false;
-  if (Kind == FileLineInfoKind::AbsoluteFilePath &&
-      sys::path::is_relative(FileName)) {
-    // We may still need to append compilation directory of compile unit.
-    SmallString<16> AbsolutePath;
-    if (const char *CompilationDir = U->getCompilationDir()) {
-      sys::path::append(AbsolutePath, CompilationDir);
-    }
-    sys::path::append(AbsolutePath, FileName);
-    FileName = AbsolutePath.str();
-  }
-  return true;
-}
-
-static bool getFileLineInfoForCompileUnit(DWARFCompileUnit *CU,
-                                          const DWARFLineTable *LineTable,
-                                          uint64_t Address,
-                                          FileLineInfoKind Kind,
-                                          DILineInfo &Result) {
-  if (!CU || !LineTable)
-    return false;
-  // Get the index of row we're looking for in the line table.
-  uint32_t RowIndex = LineTable->lookupAddress(Address);
-  if (RowIndex == -1U)
-    return false;
-  // Take file number and line/column from the row.
-  const DWARFDebugLine::Row &Row = LineTable->Rows[RowIndex];
-  if (!getFileNameForUnit(CU, LineTable, Row.File, Kind,
-                          Result.FileName))
-    return false;
-  Result.Line = Row.Line;
-  Result.Column = Row.Column;
-  return true;
-}
-
 static bool getFunctionNameForAddress(DWARFCompileUnit *CU, uint64_t Address,
                                       FunctionNameKind Kind,
                                       std::string &FunctionName) {
   if (Kind == FunctionNameKind::None)
     return false;
   // The address may correspond to instruction in some inlined function,
   // so we have to build the chain of inlined functions and take the
   // name of the topmost function in it.
DILineInfo DWARFContext::getLineInfoForAddress(uint64_t Address,
                                                DILineInfoSpecifier Spec) {
   DILineInfo Result;
 
   DWARFCompileUnit *CU = getCompileUnitForAddress(Address);
   if (!CU)
     return Result;
   getFunctionNameForAddress(CU, Address, Spec.FNKind, Result.FunctionName);
   if (Spec.FLIKind != FileLineInfoKind::None) {
     const DWARFLineTable *LineTable = getLineTableForUnit(CU);
-    getFileLineInfoForCompileUnit(CU, LineTable, Address, Spec.FLIKind, Result);
+    if (LineTable)
+      LineTable->getFileLineInfoForCompileUnit(CU, Address, Spec.FLIKind, Result);
   }
   return Result;
 }
 
 DILineInfoTable
 DWARFContext::getLineInfoForAddressRange(uint64_t Address, uint64_t Size,
                                          DILineInfoSpecifier Spec) {
   DILineInfoTable  Lines;
DWARFContext::getLineInfoForAddressRange(uint64_t Address, uint64_t Size,
   std::vector<uint32_t> RowVector;
   if (!LineTable->lookupAddressRange(Address, Size, RowVector))
     return Lines;
 
   for (uint32_t RowIndex : RowVector) {
     // Take file number and line/column from the row.
     const DWARFDebugLine::Row &Row = LineTable->Rows[RowIndex];
     DILineInfo Result;
-    getFileNameForUnit(CU, LineTable, Row.File, Spec.FLIKind,
-                       Result.FileName);
+    if (!LineTable->getFileNameByIndex(Row.File, Spec.FLIKind,
+                                       Result.FileName, CU))
+      continue;
     Result.FunctionName = FunctionName;
     Result.Line = Row.Line;
     Result.Column = Row.Column;
     Lines.push_back(std::make_pair(Row.Address, Result));
   }
 
   return Lines;
 }
DWARFContext::getInliningInfoForAddress(uint64_t Address,
   const DWARFDebugInfoEntryInlinedChain &InlinedChain =
       CU->getInlinedChainForAddress(Address);
   if (InlinedChain.DIEs.size() == 0) {
     // If there is no DIE for address (e.g. it is in unavailable .dwo file),
     // try to at least get file/line info from symbol table.
     if (Spec.FLIKind != FileLineInfoKind::None) {
       DILineInfo Frame;
       LineTable = getLineTableForUnit(CU);
-      if (getFileLineInfoForCompileUnit(CU, LineTable, Address, Spec.FLIKind,
-                                        Frame)) {
+      if (LineTable &&
+          LineTable->getFileLineInfoForCompileUnit(CU, Address, Spec.FLIKind,
+                                                   Frame))
         InliningInfo.addFrame(Frame);
-      }
-    }
     return InliningInfo;
   }
 
   uint32_t CallFile = 0, CallLine = 0, CallColumn = 0;
   for (uint32_t i = 0, n = InlinedChain.DIEs.size(); i != n; i++) {
     const DWARFDebugInfoEntryMinimal &FunctionDIE = InlinedChain.DIEs[i];
     DILineInfo Frame;
     // Get function name if necessary.
     if (const char *Name =
             FunctionDIE.getSubroutineName(InlinedChain.U, Spec.FNKind))
       Frame.FunctionName = Name;
     if (Spec.FLIKind != FileLineInfoKind::None) {
       if (i == 0) {
         // For the topmost frame, initialize the line table of this
         // compile unit and fetch file/line info from it.
         LineTable = getLineTableForUnit(CU);
         // For the topmost routine, get file/line info from line table.
-        getFileLineInfoForCompileUnit(CU, LineTable, Address, Spec.FLIKind,
+        if (LineTable)
+          LineTable->getFileLineInfoForCompileUnit(CU, Address, Spec.FLIKind,
                                                    Frame);
       } else {
         // Otherwise, use call file, call line and call column from
         // previous DIE in inlined chain.
-        getFileNameForUnit(CU, LineTable, CallFile, Spec.FLIKind,
-                           Frame.FileName);
+        if (LineTable)
+          LineTable->getFileNameByIndex(CallFile, Spec.FLIKind,
+                                        Frame.FileName, CU);
         Frame.Line = CallLine;
         Frame.Column = CallColumn;
       }
       // Get call file/line/column of a current DIE.
       if (i + 1 < n) {
         FunctionDIE.getCallerFrame(InlinedChain.U, CallFile, CallLine,
                                    CallColumn);
       }

lib/DebugInfo/DWARFDebugInfoEntry.h

class DWARFDebugInfoEntryMinimal {
   /// How many to add to "this" to get the sibling.
   uint32_t SiblingIdx;
 
   const DWARFAbbreviationDeclaration *AbbrevDecl;
 public:
   DWARFDebugInfoEntryMinimal()
     : Offset(0), SiblingIdx(0), AbbrevDecl(nullptr) {}
 
-  void dump(raw_ostream &OS, const DWARFUnit *u, unsigned recurseDepth,
+  void dump(raw_ostream &OS, DWARFUnit *u, unsigned recurseDepth,
             unsigned indent = 0) const;
-  void dumpAttribute(raw_ostream &OS, const DWARFUnit *u, uint32_t *offset_ptr,
+  void dumpAttribute(raw_ostream &OS, DWARFUnit *u, uint32_t *offset_ptr,
                      uint16_t attr, uint16_t form, unsigned indent = 0) const;
 
   /// Extracts a debug info entry, which is a child of a given unit,
   /// starting at a given offset. If DIE can't be extracted, returns false and
   /// doesn't change OffsetPtr.
   bool extractFast(const DWARFUnit *U, uint32_t *OffsetPtr);
 
   uint32_t getTag() const { return AbbrevDecl ? AbbrevDecl->getTag() : 0; }

lib/DebugInfo/DWARFDebugInfoEntry.cpp

 #include "DWARFCompileUnit.h"
 #include "DWARFContext.h"
 #include "DWARFDebugAbbrev.h"
 #include "llvm/DebugInfo/DWARFFormValue.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Dwarf.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/raw_ostream.h"
+
+#include <cstdlib>
+
 using namespace llvm;
 using namespace dwarf;
 typedef DILineInfoSpecifier::FunctionNameKind FunctionNameKind;
 
-void DWARFDebugInfoEntryMinimal::dump(raw_ostream &OS, const DWARFUnit *u,
+void DWARFDebugInfoEntryMinimal::dump(raw_ostream &OS, DWARFUnit *u,
                                       unsigned recurseDepth,
                                       unsigned indent) const {
   DataExtractor debug_info_data = u->getDebugInfoExtractor();
   uint32_t offset = Offset;
 
   if (debug_info_data.isValidOffset(offset)) {
     uint32_t abbrCode = debug_info_data.getULEB128(&offset);
 
if (abbrCode) {
       }
     } else {
       OS.indent(indent) << "NULL\n";
     }
   }
 }
 
 void DWARFDebugInfoEntryMinimal::dumpAttribute(raw_ostream &OS,
-                                               const DWARFUnit *u,
+                                               DWARFUnit *u,
                                                uint32_t *offset_ptr,
                                                uint16_t attr, uint16_t form,
                                                unsigned indent) const {
   OS << "            ";
   OS.indent(indent+2);
   const char *attrString = AttributeString(attr);
   if (attrString)
     OS << attrString;
   else
     OS << format("DW_AT_Unknown_%x", attr);
   const char *formString = FormEncodingString(form);
   if (formString)
     OS << " [" << formString << ']';
   else
     OS << format(" [DW_FORM_Unknown_%x]", form);
 
   DWARFFormValue formValue(form);
 
   if (!formValue.extractValue(u->getDebugInfoExtractor(), offset_ptr, u))
     return;
 
   OS << "\t(";
   
   const char *Name = nullptr;
   if (Optional<uint64_t> Val = formValue.getAsUnsignedConstant())
     Name = AttributeValueString(attr, *Val);
 
+  if (attr == DW_AT_decl_file || attr == DW_AT_call_file) {
+    typedef DILineInfoSpecifier::FileLineInfoKind FileLineInfoKind;
+    const DWARFDebugLine::LineTable *LT;
+    std::string File;
+
+    LT = u->getContext().getLineTableForUnit(u);
+    if (LT &&
+        LT->getFileNameByIndex(formValue.getAsUnsignedConstant().getValue(),
+                               FileLineInfoKind::AbsoluteFilePath, File, u)) {
+      File = '"' + File + '"';
+      Name = File.c_str();
+    }
+  }
+
   if (Name) {
     OS << Name;
   } else if (attr == DW_AT_decl_line || attr == DW_AT_call_line) {
     OS << *formValue.getAsUnsignedConstant();
   } else {
     formValue.dump(OS, u);
   }
 
   OS << ")\n";
 }
 
 bool DWARFDebugInfoEntryMinimal::extractFast(const DWARFUnit *U,
                                              uint32_t *OffsetPtr) {
   Offset = *OffsetPtr;
   DataExtractor DebugInfoData = U->getDebugInfoExtractor();
   uint32_t UEndOffset = U->getNextUnitOffset();
   if (Offset >= UEndOffset || !DebugInfoData.isValidOffset(Offset))

lib/DebugInfo/DWARFDebugLine.h

 #include "llvm/Support/DataExtractor.h"
 #include <map>
 #include <string>
 #include <vector>
 
 namespace llvm {
 
 class raw_ostream;
+class DWARFUnit;
+class DWARFCompileUnit;
 
 class DWARFDebugLine {
 public:
   DWARFDebugLine(const RelocAddrMap* LineInfoRelocMap) : RelocMap(LineInfoRelocMap) {}
   struct FileNameEntry {
     FileNameEntry() : Name(nullptr), DirIdx(0), ModTime(0), Length(0) {}
 
     const char *Name;
struct LineTable {
 
     bool lookupAddressRange(uint64_t address, uint64_t size,
                             std::vector<uint32_t> &result) const;
 
     // Extracts filename by its index in filename table in prologue.
     // Returns true on success.
     bool getFileNameByIndex(uint64_t FileIndex,
                             DILineInfoSpecifier::FileLineInfoKind Kind,
-                            std::string &Result) const;
+                            std::string &Result, DWARFUnit *U = nullptr) const;
+
+    bool
+    getFileLineInfoForCompileUnit(DWARFCompileUnit *CU, uint64_t Address,
+                                  DILineInfoSpecifier::FileLineInfoKind Kind,
+                                  DILineInfo &Result) const;
 
     void dump(raw_ostream &OS) const;
     void clear();
 
     /// Parse prologue and all rows.
     bool parse(DataExtractor debug_line_data, const RelocAddrMap *RMap,
                uint32_t *offset_ptr);
 

lib/DebugInfo/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 "DWARFDebugLine.h"
+#include "DWARFCompileUnit.h"
+#include "DWARFUnit.h"
+#include "llvm/Config/config.h"
 #include "llvm/Support/Dwarf.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
+#include <cstdlib>
 using namespace llvm;
 using namespace dwarf;
 typedef DILineInfoSpecifier::FileLineInfoKind FileLineInfoKind;
 
 DWARFDebugLine::Prologue::Prologue() {
   clear();
 }
 
bool DWARFDebugLine::LineTable::lookupAddressRange(
   }
 
   return true;
 }
 
 bool
 DWARFDebugLine::LineTable::getFileNameByIndex(uint64_t FileIndex,
                                               FileLineInfoKind Kind,
-                                              std::string &Result) const {
+                                              std::string &Result,
+                                              DWARFUnit *U) const {
   if (FileIndex == 0 || FileIndex > Prologue.FileNames.size() ||
       Kind == FileLineInfoKind::None)
     return false;
   const FileNameEntry &Entry = Prologue.FileNames[FileIndex - 1];
   const char *FileName = Entry.Name;
   if (Kind != FileLineInfoKind::AbsoluteFilePath ||
       sys::path::is_absolute(FileName)) {
     Result = FileName;
     return true;
   }
   SmallString<16> FilePath;
   uint64_t IncludeDirIndex = Entry.DirIdx;
   // Be defensive about the contents of Entry.
   if (IncludeDirIndex > 0 &&
       IncludeDirIndex <= Prologue.IncludeDirectories.size()) {
     const char *IncludeDir = Prologue.IncludeDirectories[IncludeDirIndex - 1];
     sys::path::append(FilePath, IncludeDir);
   }
   sys::path::append(FilePath, FileName);
+
+  if (U && Kind == FileLineInfoKind::AbsoluteFilePath &&
+      sys::path::is_relative(FilePath.str())) {
+    // We may still need to append compilation directory of compile unit.
+    SmallString<16> AbsolutePath;
+    if (const char *CompilationDir = U->getCompilationDir()) {
+      sys::path::append(AbsolutePath, CompilationDir);
+    }
+    sys::path::append(AbsolutePath, FilePath.str());
+    FilePath = AbsolutePath.str();
+  }
+
+#ifdef HAVE_REALPATH
+  // Calling realpath will resolve any '..' in the path.
+  char ResolvedPath[PATH_MAX];
+  if (realpath(FilePath.c_str(), ResolvedPath))
+    Result = ResolvedPath;
+  else
+#endif
   Result = FilePath.str();
   return true;
 }
+
+bool
+DWARFDebugLine::LineTable::getFileLineInfoForCompileUnit(DWARFCompileUnit *CU,
+                                                         uint64_t Address,
+                                                         FileLineInfoKind Kind,
+                                                         DILineInfo &Result) const {
+  if (!CU)
+    return false;
+  // Get the index of row we're looking for in the line table.
+  uint32_t RowIndex = lookupAddress(Address);
+  if (RowIndex == -1U)
+    return false;
+  // Take file number and line/column from the row.
+  const DWARFDebugLine::Row &Row = Rows[RowIndex];
+  if (!getFileNameByIndex(Row.File, Kind, Result.FileName, CU))
+    return false;
+  Result.Line = Row.Line;
+  Result.Column = Row.Column;
+  return true;
+}

test/DebugInfo/X86/2011-09-26-GlobalVarContext.ll

 !18 = metadata !{i32 4, i32 23, metadata !16, null}
 !19 = metadata !{i32 5, i32 5, metadata !16, null}
 !20 = metadata !{metadata !"test.c", metadata !"/work/llvm/vanilla/test/DebugInfo"}
 
 ; CHECK: DW_TAG_variable
 ; CHECK-NOT: DW_TAG
 ; CHECK: DW_AT_name [DW_FORM_strp]       ( .debug_str[0x{{[0-9a-f]*}}] = "GLB")
 ; CHECK-NOT: DW_TAG
-; CHECK: DW_AT_decl_file [DW_FORM_data1] (0x01)
+; CHECK: DW_AT_decl_file [DW_FORM_data1] ("/work/llvm/vanilla/test/DebugInfo/test.c")
 ; CHECK-NOT: DW_TAG
 ; CHECK: DW_AT_decl_line [DW_FORM_data1] (1)
 
 ; CHECK: DW_TAG_variable
 ; CHECK-NOT: DW_TAG
 ; CHECK: DW_AT_name [DW_FORM_strp]   ( .debug_str[0x{{[0-9a-f]*}}] = "LOC")
 ; CHECK-NOT: DW_TAG
-; CHECK: DW_AT_decl_file [DW_FORM_data1]     (0x01)
+; CHECK: DW_AT_decl_file [DW_FORM_data1]     ("/work/llvm/vanilla/test/DebugInfo/test.c")
 ; CHECK-NOT: DW_TAG
 ; CHECK: DW_AT_decl_line [DW_FORM_data1]     (4)
 
 !21 = metadata !{i32 1, metadata !"Debug Info Version", i32 1}

test/DebugInfo/namespace.ll

 ; REQUIRES: object-emission
 
 ; RUN: %llc_dwarf -O0 -filetype=obj < %s > %t
 ; RUN: llvm-dwarfdump %t | FileCheck %s
 ; CHECK: debug_info contents
 ; CHECK: [[NS1:0x[0-9a-f]*]]:{{ *}}DW_TAG_namespace
 ; CHECK-NEXT: DW_AT_name{{.*}} = "A"
-; CHECK-NEXT: DW_AT_decl_file{{.*}}(0x0[[F1:[0-9]]])
+; CHECK-NEXT: DW_AT_decl_file{{.*}}([[F1:".*debug-info-namespace.cpp"]])
 ; CHECK-NEXT: DW_AT_decl_line{{.*}}(3)
 ; CHECK-NOT: NULL
 ; CHECK: [[NS2:0x[0-9a-f]*]]:{{ *}}DW_TAG_namespace
 ; CHECK-NEXT: DW_AT_name{{.*}} = "B"
-; CHECK-NEXT: DW_AT_decl_file{{.*}}(0x0[[F2:[0-9]]])
+; CHECK-NEXT: DW_AT_decl_file{{.*}}([[F2:".*foo.cpp"]])
 ; CHECK-NEXT: DW_AT_decl_line{{.*}}(1)
 ; CHECK-NOT: NULL
 ; CHECK: [[I:0x[0-9a-f]*]]:{{ *}}DW_TAG_variable
 ; CHECK-NEXT: DW_AT_name{{.*}}= "i"
 ; CHECK-NOT: NULL
 ; CHECK: [[FOO:0x[0-9a-f]*]]:{{ *}}DW_TAG_structure_type
 ; CHECK-NEXT: DW_AT_name{{.*}}= "foo"
 ; CHECK-NEXT: DW_AT_declaration

 ; CHECK-NOT: DW_TAG
 ; CHECK: DW_AT_name{{.*}}= "f1"
 ; CHECK: NULL
 
 ; CHECK-NOT: NULL
 ; CHECK: DW_TAG_imported_module
 ; This is a bug, it should be in F2 but it inherits the file from its
 ; enclosing scope
-; CHECK-NEXT: DW_AT_decl_file{{.*}}(0x0[[F1]])
+; CHECK-NEXT: DW_AT_decl_file{{.*}}([[F1]])
 ; CHECK-NEXT: DW_AT_decl_line{{.*}}(8)
 ; CHECK-NEXT: DW_AT_import{{.*}}=> {[[NS2]]})
 ; CHECK: NULL
 ; CHECK-NOT: NULL
 
 ; CHECK: DW_TAG_imported_module
 ; Same bug as above, this should be F2, not F1
-; CHECK-NEXT: DW_AT_decl_file{{.*}}(0x0[[F1]])
+; CHECK-NEXT: DW_AT_decl_file{{.*}}([[F1]])
 ; CHECK-NEXT: DW_AT_decl_line{{.*}}(11)
 ; CHECK-NEXT: DW_AT_import{{.*}}=> {[[NS1]]})
 ; CHECK-NOT: NULL
 
 ; CHECK: DW_TAG_subprogram
 ; CHECK-NOT: DW_TAG
 ; CHECK: DW_AT_MIPS_linkage_name
 ; CHECK-NOT: DW_TAG
 ; CHECK: DW_AT_name{{.*}}= "func"
 ; CHECK-NOT: NULL
 ; CHECK: DW_TAG_imported_module
-; CHECK-NEXT: DW_AT_decl_file{{.*}}(0x0[[F2]])
+; CHECK-NEXT: DW_AT_decl_file{{.*}}([[F2]])
 ; CHECK-NEXT: DW_AT_decl_line{{.*}}(18)
 ; CHECK-NEXT: DW_AT_import{{.*}}=> {[[NS1]]})
 ; CHECK-NOT: NULL
 ; CHECK: DW_TAG_imported_declaration
-; CHECK-NEXT: DW_AT_decl_file{{.*}}(0x0[[F2]])
+; CHECK-NEXT: DW_AT_decl_file{{.*}}([[F2]])
 ; CHECK-NEXT: DW_AT_decl_line{{.*}}(19)
 ; CHECK-NEXT: DW_AT_import{{.*}}=> {[[FOO]]})
 ; CHECK-NOT: NULL
 ; CHECK: DW_TAG_imported_declaration
-; CHECK-NEXT: DW_AT_decl_file{{.*}}(0x0[[F2]])
+; CHECK-NEXT: DW_AT_decl_file{{.*}}([[F2]])
 ; CHECK-NEXT: DW_AT_decl_line{{.*}}(20)
 ; CHECK-NEXT: DW_AT_import{{.*}}=> {[[BAR]]})
 ; CHECK-NOT: NULL
 ; CHECK: DW_TAG_imported_declaration
-; CHECK-NEXT: DW_AT_decl_file{{.*}}(0x0[[F2]])
+; CHECK-NEXT: DW_AT_decl_file{{.*}}([[F2]])
 ; CHECK-NEXT: DW_AT_decl_line{{.*}}(21)
 ; CHECK-NEXT: DW_AT_import{{.*}}=> {[[FUNC1]]})
 ; CHECK-NOT: NULL
 ; CHECK: DW_TAG_imported_declaration
-; CHECK-NEXT: DW_AT_decl_file{{.*}}(0x0[[F2]])
+; CHECK-NEXT: DW_AT_decl_file{{.*}}([[F2]])
 ; CHECK-NEXT: DW_AT_decl_line{{.*}}(22)
 ; CHECK-NEXT: DW_AT_import{{.*}}=> {[[I]]})
 ; CHECK-NOT: NULL
 ; CHECK: [[X:0x[0-9a-f]*]]:{{ *}}DW_TAG_imported_declaration
-; CHECK-NEXT: DW_AT_decl_file{{.*}}(0x0[[F2]])
+; CHECK-NEXT: DW_AT_decl_file{{.*}}([[F2]])
 ; CHECK-NEXT: DW_AT_decl_line{{.*}}(24)
 ; CHECK-NEXT: DW_AT_import{{.*}}=> {[[NS1]]})
 ; CHECK-NEXT: DW_AT_name{{.*}}"X"
 ; CHECK-NOT: NULL
 ; CHECK: DW_TAG_imported_declaration
-; CHECK-NEXT: DW_AT_decl_file{{.*}}(0x0[[F2]])
+; CHECK-NEXT: DW_AT_decl_file{{.*}}([[F2]])
 ; CHECK-NEXT: DW_AT_decl_line{{.*}}(25)
 ; CHECK-NEXT: DW_AT_import{{.*}}=> {[[X]]})
 ; CHECK-NEXT: DW_AT_name{{.*}}"Y"
 ; CHECK-NOT: NULL
 ; CHECK: DW_TAG_lexical_block
 ; CHECK-NOT: NULL
 ; CHECK: DW_TAG_imported_module
-; CHECK-NEXT: DW_AT_decl_file{{.*}}(0x0[[F2]])
+; CHECK-NEXT: DW_AT_decl_file{{.*}}([[F2]])
 ; CHECK-NEXT: DW_AT_decl_line{{.*}}(15)
 ; CHECK-NEXT: DW_AT_import{{.*}}=> {[[NS2]]})
 ; CHECK: NULL
 ; CHECK: NULL
 ; CHECK: NULL
 
-; CHECK: file_names[  [[F1]]]{{.*}}debug-info-namespace.cpp
-; CHECK: file_names[  [[F2]]]{{.*}}foo.cpp
-
 ; IR generated from clang/test/CodeGenCXX/debug-info-namespace.cpp, file paths
 ; changed to protect the guilty. The C++ source code is:
 ; namespace A {
 ; #line 1 "foo.cpp"
 ; namespace B {
 ; int i;
 ; void f1() { }
 ; void f1(int) { }

test/MC/MachO/gen-dwarf.s

 // We don't check the file name as it is a temp directory
 // CHECK:    DW_AT_name [DW_FORM_string]
 // We don't check the DW_AT_comp_dir which is the current working directory
 // CHECK:    DW_AT_producer [DW_FORM_string]  ("llvm-mc (based on {{.*}})")
 // CHECK:    DW_AT_language [DW_FORM_data2] (DW_LANG_Mips_Assembler)
 
 // CHECK:    DW_TAG_label [2] *
 // CHECK:      DW_AT_name [DW_FORM_string]  ("bar")
-// CHECK:      DW_AT_decl_file [DW_FORM_data4]  (0x00000001)
+// CHECK:      DW_AT_decl_file [DW_FORM_data4]  ([[FILE:".*gen-dwarf.s"]])
 // CHECK:      DW_AT_decl_line [DW_FORM_data4]  (5)
 // CHECK:      DW_AT_low_pc [DW_FORM_addr]  (0x0000000000000000)
 // CHECK:      DW_AT_prototyped [DW_FORM_flag]  (0x00)
 
 // CHECK:      DW_TAG_unspecified_parameters [3]  
 
 // CHECK:      NULL
 
 // CHECK:    DW_TAG_label [2] *
 // CHECK:      DW_AT_name [DW_FORM_string]  ("foo")
-// CHECK:      DW_AT_decl_file [DW_FORM_data4]  (0x00000001)
+// CHECK:      DW_AT_decl_file [DW_FORM_data4]  ([[FILE]])
 // CHECK:      DW_AT_decl_line [DW_FORM_data4]  (9)
 // CHECK:      DW_AT_low_pc [DW_FORM_addr]  (0x0000000000000007)
 // CHECK:      DW_AT_prototyped [DW_FORM_flag]  (0x00)
 
 // CHECK:      DW_TAG_unspecified_parameters [3]  
 
 // CHECK:      NULL
 
 // CHECK:    DW_TAG_label [2] *
 // CHECK:      DW_AT_name [DW_FORM_string]  ("baz")
-// CHECK:      DW_AT_decl_file [DW_FORM_data4]  (0x00000001)
+// CHECK:      DW_AT_decl_file [DW_FORM_data4]  ([[FILE]])
 // CHECK:      DW_AT_decl_line [DW_FORM_data4]  (10)
 // CHECK:      DW_AT_low_pc [DW_FORM_addr]  (0x0000000000000007)
 // CHECK:      DW_AT_prototyped [DW_FORM_flag]  (0x00)
 
 // CHECK:      DW_TAG_unspecified_parameters [3]  
 
 // CHECK:      NULL