DWARF: Add some support for non-native directory separators

[labath]

Summary

If we opened a file which was produced on system with different path
syntax, we would parse the paths from the debug info incorrectly.

The reason for that is that we would parse the paths as they were
native. For example this meant that on linux we would treat the entire
windows path as a single file name with no directory component, and then
we would concatenate that with the single directory component from the
DW_AT_comp_dir attribute. When parsing posix paths on windows, we would
at least get the directory separators right, but we still would treat
the posix paths as relative, and concatenate them where we shouldn't.

This patch attempts to remedy this by guessing the path syntax used in
each compile unit. (Unfortunately, there is no info in DWARF which would
give the definitive path style used by the produces, so guessing is all
we can do.) Currently, this guessing is based on the DW_AT_comp_dir
attribute of the compile unit, but this can be refined later if needed
(for example, the DW_AT_name of the compile unit may also contain some
useful info). This style is then used when parsing the line table of
that compile unit.

This patch is sufficient to make the line tables come out right, and
enable breakpoint setting by file name work correctly. Setting a
breakpoint by full path still has some kinks (specifically, using a
windows-style full path will not work on linux because the path will be
parsed as a linux path), but this will require larger changes in how
breakpoint setting works.

[aprantl]

source/Plugins/SymbolFile/DWARF/DWARFUnit.h

256

I would probably call this DetectPathStyle() since it's more a heuristic?

[zturner]

source/Plugins/SymbolFile/DWARF/DWARFUnit.h

256

Maybe even Guess since Compute implies absolute certainty.

[clayborg]

DW_AT_comp_dir isn't enough. See inline suggestions.

source/Plugins/SymbolFile/DWARF/DWARFUnit.cpp

775–787

I would suggest adding a "FileSpec DWARFUnit::GetFileSpec()" and moving code from SymbolFileDWARF::ParseCompileUnit into this function:

FileSpec cu_file_spec(cu_die.GetName());
if (cu_file_spec) {
  // If we have a full path to the compile unit, we don't need to
  // resolve the file.  This can be expensive e.g. when the source
  // files are
  // NFS mounted.
  if (cu_file_spec.IsRelative()) {
    const char *cu_comp_dir{
        cu_die.GetAttributeValueAsString(DW_AT_comp_dir, nullptr)};
    cu_file_spec.PrependPathComponent(resolveCompDir(cu_comp_dir));
  }

We might even cache the FileSpec object inside DWARFUnit so it doesn't have to be recomputed?

Then use this resolved path. DW_AT_comp_dir isn't always there, sometimes the DW_AT_name is a full path only. So we should centralize this in DWARFUnit. We might want to make a function like:

void DWARFUnit::ResolveCompileUnitDirectoryRelativeFile(FileSpec &spec);

And then have "FileSpec DWARFUnit::GetFileSpec()" call it. I was looking at the other uses of DW_AT_comp_dir in the source, and the line tables tend to need to resolve relative paths. A few other locations. Might be nice to get the DWARFUnit and resolve the path using that? We can add "FileSpec DWARFDie::GetPath()" accessor, could even add a "void DWARFDie::ResolveRelativePath(FileSpec &)"

[labath]

• move the comp_dir resolution logic from SymbolFileDWARF to DWARFUnit
• this required the addition on an accessor to the "comp_dir_symlinks" setting, which is used in the full comp_dir resolution
• add FileSpec::MakeAbsolute() to simplify bits of code
• determine the path style from the DW_AT_name field if DW_AT_comp_dir is missing (I recall that it is possible to get a CU without a comp_dir in some circumstances, but I wasn't able to get my compiler to do that).

[labath]

source/Plugins/SymbolFile/DWARF/DWARFUnit.cpp

775–787

I think this version mostly implements what you had in mind. I added a DWARFUnit::GetCompilationDirectory() which returns the DW_AT_comp_dir attribute (I would expect that DWARFUnit::GetFileSpec() would return DW_AT_name, which is not useful for relative path resolution, except as a hint for the path style).

I've also added FileSpec::MakeAbsolute to shorten the if(!spec.relative()) spec.prepend(dir)) pattern we had in some places. I didn't add any special FileSpec accessor to DWARFDie, as it didn't seem particularly useful (at this point). The only place where that's used now is for the computation of the name of the compile unit, and that's pretty concise now anyway.

source/Plugins/SymbolFile/DWARF/DWARFUnit.h

256

With all the other changes, this is now called ComputeCompDirAndGuessPathStyle. Note that this is just a private helper function and the public accessor is still called GetPathStyle()

[clayborg]

source/Plugins/SymbolFile/DWARF/DWARFUnit.cpp

769–774

Remove?

777

Just move contents of ComputeCompDirAndGuessPathStyle() to this function now that we don't have GetPathStyle?

818

Move contents to DWARFUnit::GetCompilationDirectory?

source/Plugins/SymbolFile/DWARF/DWARFUnit.h

173

Is GetPathStyle() needed? Seems like we should be able to grab the style from:

auto style = unit->GetCompilationDirectory().GetPathStyle();

256

If we remove GetPathStyle above, should this be removed and just put into the code for GetCompilationDirectory() now that we don't have two accessors?

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

757

Not sure how we would resolve this one. What if dwarf_cu doesn't have a DW_AT_comp_dir? Maybe we add a FileSpec constructor that takes a string and a FileSpec &relative_dir so this would would just become:

FileSpec cu_fs(cu_die.GetName(), dwarf_cu->GetCompilationDirectory());

The proto would be something like:

explicit FileSpec::FileSpec(llvm::StringRef path, const FileSpec &relative_root);

Then the if statement below goes away.

source/Utility/FileSpec.cpp

560

Should this be "bool FileSpec::ResolveRelativePath(const FileSpec &dir)"? Returns true if this path was relative and it was resolved, and false otherwise?

[labath]

source/Plugins/SymbolFile/DWARF/DWARFUnit.h

173

I'd like to avoid that for two reasons:

• I think this documents the intent better. Logically, the "path style" is a property of the compile unit and the fact that the compilation directory (and everything else) uses this path style is a consequence of that. The fact that we actually get the path style from the compilation directory is an implementation detail that users should not care about and may in fact change in the future e.g. if DWARF develops an ability to explicitly signal this information.
• I'm not thrilled by the fact that we can have an empty (invalid) FileSpec, whose path style still has some significance (this happens if the CU does not have a comp_dir attribute, and we guess the style from the. In fact I even considered getting rid of that and having an explicit path style member). In the end I decided it's not too bad if it's internal to DWARFCompileUnit, but I would not want to expose this quirk to the outside world. So if anything, I'd actually go for making the path style a separate member.

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

757

That would work if we say that we do support having empty/invalid FileSpec objects with certain PathStyle. However, as I said above, I am not entirely thrilled by that. FWIW, I don't think having this if is bad, as it makes it clear that how you're intending to handle the case when the CU has no name.

source/Utility/FileSpec.cpp

560

I called this MakeAbsolute because that's how the equivalent llvm function is called (llvm::sys::fs::make_absolute). I think it would be good to stay consistent here.

[clayborg]

Ok, thanks for explaining. Your reasoning makes sense.

[clayborg]

Might be good to have a test where we have a relative DW_AT_name and not DW_AT_comp_dir? Just in case?

[labath]

• add a test for the no-DW_AT_comp_dir + relative-DW_AT_name case

[stella.stamenova]

The Windows Buildbot is failing because of one of the tests (SymbolFile/DWARF/dir-separator-no-comp-dir-relative-name.s) added in this change. You can see the failure here: http://lab.llvm.org:8011/builders/lldb-x64-windows-ninja/builds/666. It looks like it is checking for the wrong path on Windows:

# CHECK: Line table for foo/a.c

         ^

<stdin>:11:1: note: scanning from here

Line table for foo\a.c in `dir-separator-no-comp-dir-relative-name.s.tmp

^


error: command failed with exit status: 1

include/lldb/Utility/FileSpec.h

public:
   /// Returns true if the filespec represents an absolute path.
   ///
   /// @return
   ///     \b true if the filespec represents an absolute path,
   ///     \b false otherwise.
   //------------------------------------------------------------------
   bool IsAbsolute() const;
 
+  /// Make the FileSpec absolute by treating it relative to \a dir. Absolute
+  /// FileSpecs are never changed by this function.
+  void MakeAbsolute(const FileSpec &dir);
+
   /// Temporary helper for FileSystem change.
   void SetPath(llvm::StringRef p) { SetFile(p); }
 
   //------------------------------------------------------------------
   /// Extract the full path to the file.
   ///
   /// Extract the directory and path into a fixed buffer. This is needed as
   /// the directory and path are stored in separate string values.

lit/SymbolFile/DWARF/Inputs/dir-separator-no-comp-dir-relative-name.lldbinit

+image dump line-table a.c
+breakpoint set -f a.c -l 1
+breakpoint set -f foo/b.c -l 1

lit/SymbolFile/DWARF/Inputs/dir-separator-posix.lldbinit

+image dump line-table a.c
+breakpoint set -f a.c -l 1
+breakpoint set -f /tmp/b.c -l 1

lit/SymbolFile/DWARF/Inputs/dir-separator-windows.lldbinit

+image dump line-table a.c
+breakpoint set -f a.c -l 1
+breakpoint set -f C:/tmp/b.c -l 1
+
+# This will fail on non-windows systems because the path will by parsed
+# according to posix rules
+# breakpoint set -f 'C:\tmp\b.c' -l 1

lit/SymbolFile/DWARF/dir-separator-no-comp-dir-relative-name.s

+# Test that parsing of line tables works reasonably, even if the host directory
+# separator does not match the separator of the compile unit.
+
+# REQUIRES: lld
+
+# RUN: llvm-mc -triple x86_64-pc-linux %s -filetype=obj > %t.o
+# RUN: ld.lld %t.o -o %t
+# RUN: %lldb %t -s %S/Inputs/dir-separator-no-comp-dir-relative-name.lldbinit -o exit | FileCheck %s
+
+# CHECK-LABEL: image dump line-table a.c
+# CHECK: Line table for foo/a.c
+# CHECK-NEXT: 0x0000000000201000: foo/a.c:1
+# CHECK-NEXT: 0x0000000000201001: foo/b.c:1
+# CHECK-NEXT: 0x0000000000201002: foo/b.c:1
+# CHECK-EMPTY:
+
+# CHECK-LABEL: breakpoint set -f a.c -l 1
+# CHECK: Breakpoint 1: {{.*}}`_start,
+
+# CHECK-LABEL: breakpoint set -f foo/b.c -l 1
+# CHECK: Breakpoint 2: {{.*}}`_start + 1,
+
+  .text
+  .globl  _start
+_start:
+  .file 1 "foo/a.c"
+  .loc  1 1 0
+        nop
+  .file 2 "foo/b.c"
+  .loc  2 1 0
+        nop
+
+  .section  .debug_str,"MS",@progbits,1
+.Linfo_string1:
+  .asciz  "foo/a.c"
+  .section  .debug_abbrev,"",@progbits
+  .byte 1                       # Abbreviation Code
+  .byte 17                      # DW_TAG_compile_unit
+  .byte 0                       # DW_CHILDREN_no
+  .byte 19                      # DW_AT_language
+  .byte 5                       # DW_FORM_data2
+  .byte 3                       # DW_AT_name
+  .byte 14                      # DW_FORM_strp
+  .byte 16                      # DW_AT_stmt_list
+  .byte 23                      # DW_FORM_sec_offset
+  .byte 0                       # EOM(1)
+  .byte 0                       # EOM(2)
+  .byte 0                       # EOM(3)
+  .section  .debug_info,"",@progbits
+.Lcu_begin0:
+  .long .Lcu_end0-.Lcu_start0   # Length of Unit
+.Lcu_start0:
+  .short  4                       # DWARF version number
+  .long .debug_abbrev           # Offset Into Abbrev. Section
+  .byte 8                       # Address Size (in bytes)
+  .byte 1                       # Abbrev [1] 0xb:0x1f DW_TAG_compile_unit
+  .short  12                      # DW_AT_language
+  .long .Linfo_string1          # DW_AT_name
+  .long .Lline_table_start0     # DW_AT_stmt_list
+.Lcu_end0:
+  .section  .debug_line,"",@progbits
+.Lline_table_start0:

lit/SymbolFile/DWARF/dir-separator-no-comp-dir.s

+# Test that we properly determine the path syntax of a compile unit even if the
+# compile unit does not have a DW_AT_comp_dir attribute.
+
+# REQUIRES: lld
+
+# RUN: llvm-mc -triple x86_64-pc-linux %s -filetype=obj > %t.o
+# RUN: ld.lld %t.o -o %t
+# RUN: %lldb %t -s %S/Inputs/dir-separator-windows.lldbinit -o exit | FileCheck %s
+
+# CHECK-LABEL: image dump line-table a.c
+# CHECK: Line table for C:\tmp\a.c
+# CHECK-NEXT: 0x0000000000201000: C:\tmp\a.c:1
+# CHECK-NEXT: 0x0000000000201001: C:\tmp\b.c:1
+# CHECK-NEXT: 0x0000000000201002: C:\tmp\b.c:1
+# CHECK-EMPTY:
+
+# CHECK-LABEL: breakpoint set -f a.c -l 1
+# CHECK: Breakpoint 1: {{.*}}`_start,
+
+# CHECK-LABEL: breakpoint set -f C:/tmp/b.c -l 1
+# CHECK: Breakpoint 2: {{.*}}`_start + 1,
+
+  .text
+  .globl  _start
+_start:
+  .file 1 "C:\\tmp\\a.c"
+  .loc  1 1 0
+        nop
+  .file 2 "C:\\tmp\\b.c"
+  .loc  2 1 0
+        nop
+
+  .section  .debug_str,"MS",@progbits,1
+.Linfo_string1:
+  .asciz  "C:\\tmp\\a.c"
+  .section  .debug_abbrev,"",@progbits
+  .byte 1                       # Abbreviation Code
+  .byte 17                      # DW_TAG_compile_unit
+  .byte 0                       # DW_CHILDREN_no
+  .byte 19                      # DW_AT_language
+  .byte 5                       # DW_FORM_data2
+  .byte 3                       # DW_AT_name
+  .byte 14                      # DW_FORM_strp
+  .byte 16                      # DW_AT_stmt_list
+  .byte 23                      # DW_FORM_sec_offset
+  .byte 0                       # EOM(1)
+  .byte 0                       # EOM(2)
+  .byte 0                       # EOM(3)
+  .section  .debug_info,"",@progbits
+.Lcu_begin0:
+  .long .Lcu_end0-.Lcu_start0   # Length of Unit
+.Lcu_start0:
+  .short  4                       # DWARF version number
+  .long .debug_abbrev           # Offset Into Abbrev. Section
+  .byte 8                       # Address Size (in bytes)
+  .byte 1                       # Abbrev [1] 0xb:0x1f DW_TAG_compile_unit
+  .short  12                      # DW_AT_language
+  .long .Linfo_string1          # DW_AT_name
+  .long .Lline_table_start0     # DW_AT_stmt_list
+.Lcu_end0:
+  .section  .debug_line,"",@progbits
+.Lline_table_start0:

lit/SymbolFile/DWARF/dir-separator-posix.s

+# Test that parsing of line tables works reasonably, even if the host directory
+# separator does not match the separator of the compile unit.
+
+# REQUIRES: lld
+
+# RUN: llvm-mc -triple x86_64-pc-linux %s -filetype=obj > %t.o
+# RUN: ld.lld %t.o -o %t
+# RUN: %lldb %t -s %S/Inputs/dir-separator-posix.lldbinit -o exit | FileCheck %s
+
+# CHECK-LABEL: image dump line-table a.c
+# CHECK: Line table for /tmp/a.c
+# CHECK-NEXT: 0x0000000000201000: /tmp/a.c:1
+# CHECK-NEXT: 0x0000000000201001: /tmp/b.c:1
+# CHECK-NEXT: 0x0000000000201002: /tmp/b.c:1
+# CHECK-EMPTY:
+
+# CHECK-LABEL: breakpoint set -f a.c -l 1
+# CHECK: Breakpoint 1: {{.*}}`_start,
+
+# CHECK-LABEL: breakpoint set -f /tmp/b.c -l 1
+# CHECK: Breakpoint 2: {{.*}}`_start + 1,
+
+  .text
+  .globl  _start
+_start:
+  .file 1 "/tmp/a.c"
+  .loc  1 1 0
+        nop
+  .file 2 "/tmp/b.c"
+  .loc  2 1 0
+        nop
+
+  .section  .debug_str,"MS",@progbits,1
+.Linfo_string1:
+  .asciz  "a.c"
+.Linfo_string2:
+  .asciz  "/tmp"
+  .section  .debug_abbrev,"",@progbits
+  .byte 1                       # Abbreviation Code
+  .byte 17                      # DW_TAG_compile_unit
+  .byte 0                       # DW_CHILDREN_no
+  .byte 19                      # DW_AT_language
+  .byte 5                       # DW_FORM_data2
+  .byte 3                       # DW_AT_name
+  .byte 14                      # DW_FORM_strp
+  .byte 16                      # DW_AT_stmt_list
+  .byte 23                      # DW_FORM_sec_offset
+  .byte 27                      # DW_AT_comp_dir
+  .byte 14                      # DW_FORM_strp
+  .byte 0                       # EOM(1)
+  .byte 0                       # EOM(2)
+  .byte 0                       # EOM(3)
+  .section  .debug_info,"",@progbits
+.Lcu_begin0:
+  .long .Lcu_end0-.Lcu_start0   # Length of Unit
+.Lcu_start0:
+  .short  4                       # DWARF version number
+  .long .debug_abbrev           # Offset Into Abbrev. Section
+  .byte 8                       # Address Size (in bytes)
+  .byte 1                       # Abbrev [1] 0xb:0x1f DW_TAG_compile_unit
+  .short  12                      # DW_AT_language
+  .long .Linfo_string1          # DW_AT_name
+  .long .Lline_table_start0     # DW_AT_stmt_list
+  .long .Linfo_string2          # DW_AT_comp_dir
+.Lcu_end0:
+  .section  .debug_line,"",@progbits
+.Lline_table_start0:

lit/SymbolFile/DWARF/dir-separator-windows.s

+# Test that parsing of line tables works reasonably, even if the host directory
+# separator does not match the separator of the compile unit.
+
+# REQUIRES: lld
+
+# RUN: llvm-mc -triple x86_64-pc-linux %s -filetype=obj > %t.o
+# RUN: ld.lld %t.o -o %t
+# RUN: %lldb %t -s %S/Inputs/dir-separator-windows.lldbinit -o exit | FileCheck %s
+
+# CHECK-LABEL: image dump line-table a.c
+# CHECK: Line table for C:\tmp\a.c
+# CHECK-NEXT: 0x0000000000201000: C:\tmp\a.c:1
+# CHECK-NEXT: 0x0000000000201001: C:\tmp\b.c:1
+# CHECK-NEXT: 0x0000000000201002: C:\tmp\b.c:1
+# CHECK-EMPTY:
+
+# CHECK-LABEL: breakpoint set -f a.c -l 1
+# CHECK: Breakpoint 1: {{.*}}`_start,
+
+# CHECK-LABEL: breakpoint set -f C:/tmp/b.c -l 1
+# CHECK: Breakpoint 2: {{.*}}`_start + 1,
+
+  .text
+  .globl  _start
+_start:
+  .file 1 "C:\\tmp\\a.c"
+  .loc  1 1 0
+        nop
+  .file 2 "C:\\tmp\\b.c"
+  .loc  2 1 0
+        nop
+
+  .section  .debug_str,"MS",@progbits,1
+.Linfo_string1:
+  .asciz  "a.c"
+.Linfo_string2:
+  .asciz  "C:\\tmp"
+  .section  .debug_abbrev,"",@progbits
+  .byte 1                       # Abbreviation Code
+  .byte 17                      # DW_TAG_compile_unit
+  .byte 0                       # DW_CHILDREN_no
+  .byte 19                      # DW_AT_language
+  .byte 5                       # DW_FORM_data2
+  .byte 3                       # DW_AT_name
+  .byte 14                      # DW_FORM_strp
+  .byte 16                      # DW_AT_stmt_list
+  .byte 23                      # DW_FORM_sec_offset
+  .byte 27                      # DW_AT_comp_dir
+  .byte 14                      # DW_FORM_strp
+  .byte 0                       # EOM(1)
+  .byte 0                       # EOM(2)
+  .byte 0                       # EOM(3)
+  .section  .debug_info,"",@progbits
+.Lcu_begin0:
+  .long .Lcu_end0-.Lcu_start0   # Length of Unit
+.Lcu_start0:
+  .short  4                       # DWARF version number
+  .long .debug_abbrev           # Offset Into Abbrev. Section
+  .byte 8                       # Address Size (in bytes)
+  .byte 1                       # Abbrev [1] 0xb:0x1f DW_TAG_compile_unit
+  .short  12                      # DW_AT_language
+  .long .Linfo_string1          # DW_AT_name
+  .long .Lline_table_start0     # DW_AT_stmt_list
+  .long .Linfo_string2          # DW_AT_comp_dir
+.Lcu_end0:
+  .section  .debug_line,"",@progbits
+.Lline_table_start0:

source/Plugins/SymbolFile/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 SymbolFileDWARF_DWARFDebugLine_h_
 #define SymbolFileDWARF_DWARFDebugLine_h_
 
 #include <map>
 #include <string>
 #include <vector>
 
+#include "lldb/Utility/FileSpec.h"
 #include "lldb/lldb-private.h"
 
 #include "DWARFDataExtractor.h"
 #include "DWARFDefines.h"
 
 #include "llvm/Support/MD5.h"
 
 class DWARFUnit;
void Clear() {
       total_length = version = prologue_length = min_inst_length = line_base =
           line_range = opcode_base = 0;
       line_base = 0;
       standard_opcode_lengths.clear();
       include_directories.clear();
       file_names.clear();
     }
     bool GetFile(uint32_t file_idx, const lldb_private::FileSpec &cu_comp_dir,
+                 lldb_private::FileSpec::Style style,
                  lldb_private::FileSpec &file) const;
   };
 
   // Standard .debug_line state machine structure
   struct Row {
     typedef std::vector<Row> collection;
     typedef collection::iterator iterator;
     typedef collection::const_iterator const_iterator;
static bool DumpOpcodes(
       uint32_t dump_flags = 0); // If line_offset is invalid, dump everything
   static bool DumpLineTableRows(
       lldb_private::Log *log, SymbolFileDWARF *dwarf2Data,
       dw_offset_t line_offset =
           DW_INVALID_OFFSET); // If line_offset is invalid, dump everything
   static bool
   ParseSupportFiles(const lldb::ModuleSP &module_sp,
                     const lldb_private::DWARFDataExtractor &debug_line_data,
-                    const lldb_private::FileSpec &cu_comp_dir,
                     dw_offset_t stmt_list,
-                    lldb_private::FileSpecList &support_files, DWARFUnit *dwarf_cu);
+                    lldb_private::FileSpecList &support_files,
+                    DWARFUnit *dwarf_cu);
   static bool
   ParsePrologue(const lldb_private::DWARFDataExtractor &debug_line_data,
                 lldb::offset_t *offset_ptr, Prologue *prologue,
                 DWARFUnit *dwarf_cu = nullptr);
   static bool
   ParseStatementTable(const lldb_private::DWARFDataExtractor &debug_line_data,
                       lldb::offset_t *offset_ptr, State::Callback callback,
                       void *userData, DWARFUnit *dwarf_cu);

source/Plugins/SymbolFile/DWARF/DWARFDebugLine.cpp

 #include <assert.h>
 
 #include "lldb/Core/FileSpecList.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Timer.h"
 
+#include "DWARFUnit.h"
 #include "LogChannelDWARF.h"
 #include "SymbolFileDWARF.h"
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace std;
 
 //----------------------------------------------------------------------
Host::SystemLog(Host::eSystemLogWarning,
                     " but it ended at 0x%8.8" PRIx64 "\n",
                     prologue_offset, end_prologue_offset, *offset_ptr);
   }
   return end_prologue_offset;
 }
 
 bool DWARFDebugLine::ParseSupportFiles(
     const lldb::ModuleSP &module_sp, const DWARFDataExtractor &debug_line_data,
-    const lldb_private::FileSpec &cu_comp_dir, dw_offset_t stmt_list,
-    FileSpecList &support_files, DWARFUnit *dwarf_cu) {
+    dw_offset_t stmt_list, FileSpecList &support_files, DWARFUnit *dwarf_cu) {
   lldb::offset_t offset = stmt_list;
 
   Prologue prologue;
   if (!ParsePrologue(debug_line_data, &offset, &prologue, dwarf_cu)) {
     Host::SystemLog(Host::eSystemLogError, "error: parsing line table prologue "
                                            "at 0x%8.8x (parsing ended around "
                                            "0x%8.8" PRIx64 "\n",
                     stmt_list, offset);
     return false;
   }
 
   FileSpec file_spec;
   std::string remapped_file;
 
   for (uint32_t file_idx = 1;
-       prologue.GetFile(file_idx, cu_comp_dir, file_spec); ++file_idx) {
+       prologue.GetFile(file_idx, dwarf_cu->GetCompilationDirectory(),
+                        dwarf_cu->GetPathStyle(), file_spec);
+       ++file_idx) {
     if (module_sp->RemapSourceFile(file_spec.GetPath(), remapped_file))
       file_spec.SetFile(remapped_file, FileSpec::Style::native);
     support_files.Append(file_spec);
   }
   return true;
 }
 
 //----------------------------------------------------------------------

 //      buff.Append32_as_ULEB128(file_names[i].dir_idx);
 //      buff.Append32_as_ULEB128(file_names[i].mod_time);
 //      buff.Append32_as_ULEB128(file_names[i].length);
 //  }
 //  buff.Append8(0);    // Terminate the file names section with empty string
 //}
 
 bool DWARFDebugLine::Prologue::GetFile(uint32_t file_idx,
-    const lldb_private::FileSpec &comp_dir, FileSpec &file) const {
+                                       const FileSpec &comp_dir,
+                                       FileSpec::Style style,
+                                       FileSpec &file) const {
   uint32_t idx = file_idx - 1; // File indexes are 1 based...
   if (idx < file_names.size()) {
-    file.SetFile(file_names[idx].name, FileSpec::Style::native);
+    file.SetFile(file_names[idx].name, style);
     if (file.IsRelative()) {
       if (file_names[idx].dir_idx > 0) {
         const uint32_t dir_idx = file_names[idx].dir_idx - 1;
         if (dir_idx < include_directories.size()) {
           file.PrependPathComponent(include_directories[dir_idx]);
           if (!file.IsRelative())
             return true;
         }

source/Plugins/SymbolFile/DWARF/DWARFUnit.h

public:
   static lldb::LanguageType LanguageTypeFromDWARF(uint64_t val);
 
   lldb::LanguageType GetLanguageType();
 
   bool IsDWARF64() const { return m_is_dwarf64; }
 
   bool GetIsOptimized();
 
+  const lldb_private::FileSpec &GetCompilationDirectory();
+  lldb_private::FileSpec::Style GetPathStyle();
+
   SymbolFileDWARFDwo *GetDwoSymbolFile() const;
 
   dw_offset_t GetBaseObjOffset() const;
 
   die_iterator_range dies() {
     ExtractDIEsIfNeeded();
     return die_iterator_range(m_die_array.begin(), m_die_array.end());
   }
protected:
   uint64_t m_dwo_id = 0;
   DWARFProducer m_producer = eProducerInvalid;
   uint32_t m_producer_version_major = 0;
   uint32_t m_producer_version_minor = 0;
   uint32_t m_producer_version_update = 0;
   lldb::LanguageType m_language_type = lldb::eLanguageTypeUnknown;
   bool m_is_dwarf64 = false;
   lldb_private::LazyBool m_is_optimized = lldb_private::eLazyBoolCalculate;
+  llvm::Optional<lldb_private::FileSpec> m_comp_dir;
   dw_addr_t m_addr_base = 0;   // Value of DW_AT_addr_base
   dw_addr_t m_ranges_base = 0; // Value of DW_AT_ranges_base
   // If this is a dwo compile unit this is the offset of the base compile unit
   // in the main object file
   dw_offset_t m_base_obj_offset = DW_INVALID_OFFSET;
   dw_offset_t m_str_offsets_base = 0; // Value of DW_AT_str_offsets_base.
   // Offset of the initial length field.
   dw_offset_t m_offset;
const DWARFDebugInfoEntry *DIEPtr() {
     if (m_die_array.empty())
       return NULL;
     return &m_die_array[0];
   }
 
   void AddUnitDIE(const DWARFDebugInfoEntry &cu_die);
   void ExtractDIEsEndCheck(lldb::offset_t offset) const;
 
+  void ComputeCompDirAndGuessPathStyle();
+
   DISALLOW_COPY_AND_ASSIGN(DWARFUnit);
 };
 
 #endif // SymbolFileDWARF_DWARFUnit_h_

source/Plugins/SymbolFile/DWARF/DWARFUnit.cpp

if (die) {
                                            0) == 1) {
         m_is_optimized = eLazyBoolYes;
       }
     }
   }
   return m_is_optimized == eLazyBoolYes;
 }
 
+FileSpec::Style DWARFUnit::GetPathStyle() {
+  if (!m_comp_dir)
+    ComputeCompDirAndGuessPathStyle();
+  return m_comp_dir->GetPathStyle();
+}
+
+const FileSpec &DWARFUnit::GetCompilationDirectory() {
+  if (!m_comp_dir)
+    ComputeCompDirAndGuessPathStyle();
+  return *m_comp_dir;
+}
+
+// DWARF2/3 suggests the form hostname:pathname for compilation directory.
+// Remove the host part if present.
+static llvm::StringRef
+removeHostnameFromPathname(llvm::StringRef path_from_dwarf) {
+  llvm::StringRef host, path;
+  std::tie(host, path) = path_from_dwarf.split(':');
+
+  if (host.contains('/'))
+    return path_from_dwarf;
+
+  // check whether we have a windows path, and so the first character is a
+  // drive-letter not a hostname.
+  if (host.size() == 1 && llvm::isAlpha(host[0]) && path.startswith("\\"))
+    return path_from_dwarf;
+
+  return path;
+}
+
+static FileSpec resolveCompDir(const FileSpec &path) {
+  bool is_symlink = SymbolFileDWARF::GetSymlinkPaths().FindFileIndex(
+                        0, path, /*full*/ true) != UINT32_MAX;
+
+  if (!is_symlink)
+    return path;
+
+  namespace fs = llvm::sys::fs;
+  if (fs::get_file_type(path.GetPath(), false) != fs::file_type::symlink_file)
+    return path;
+
+  FileSpec resolved_symlink;
+  const auto error = FileSystem::Instance().Readlink(path, resolved_symlink);
+  if (error.Success())
+    return resolved_symlink;
+
+  return path;
+}
+
+void DWARFUnit::ComputeCompDirAndGuessPathStyle() {
+  m_comp_dir = FileSpec();
+  const DWARFDebugInfoEntry *die = GetUnitDIEPtrOnly();
+  if (!die)
+    return;
+
+  auto guess = [](llvm::StringRef str) {
+    if (str.startswith("/"))
+      return FileSpec::Style::posix;
+    if (str.size() > 3 && llvm::isAlpha(str[0]) && str.substr(1, 2) == ":\\")
+      return FileSpec::Style::windows;
+    return FileSpec::Style::native;
+  };
+  llvm::StringRef comp_dir = removeHostnameFromPathname(
+      die->GetAttributeValueAsString(m_dwarf, this, DW_AT_comp_dir, NULL));
+  if (!comp_dir.empty()) {
+    m_comp_dir = resolveCompDir(FileSpec(comp_dir, guess(comp_dir)));
+  } else {
+    // Try to detect the style based on the DW_AT_name attribute, but just store
+    // the detected style in the m_comp_dir field.
+    m_comp_dir = FileSpec("", guess(die->GetAttributeValueAsString(
+                                  m_dwarf, this, DW_AT_name, NULL)));
+  }
+}
+
 SymbolFileDWARFDwo *DWARFUnit::GetDwoSymbolFile() const {
   return m_dwo_symbol_file.get();
 }
 
 dw_offset_t DWARFUnit::GetBaseObjOffset() const { return m_base_obj_offset; }
 
 const DWARFDebugAranges &DWARFUnit::GetFunctionAranges() {
   if (m_func_aranges_ap.get() == NULL) {

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h

public:
 
   static lldb_private::ConstString GetPluginNameStatic();
 
   static const char *GetPluginDescriptionStatic();
 
   static lldb_private::SymbolFile *
   CreateInstance(lldb_private::ObjectFile *obj_file);
 
+  static const lldb_private::FileSpecList &GetSymlinkPaths();
+
   //------------------------------------------------------------------
   // Constructors and Destructors
   //------------------------------------------------------------------
 
   SymbolFileDWARF(lldb_private::ObjectFile *ofile);
 
   ~SymbolFileDWARF() override;
 

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

 
 static const SymbolFileDWARFPropertiesSP &GetGlobalPluginProperties() {
   static const auto g_settings_sp(std::make_shared<PluginProperties>());
   return g_settings_sp;
 }
 
 } // anonymous namespace end
 
-static const char *removeHostnameFromPathname(const char *path_from_dwarf) {
-  if (!path_from_dwarf || !path_from_dwarf[0]) {
-    return path_from_dwarf;
-  }
-
-  const char *colon_pos = strchr(path_from_dwarf, ':');
-  if (nullptr == colon_pos) {
-    return path_from_dwarf;
-  }
-
-  const char *slash_pos = strchr(path_from_dwarf, '/');
-  if (slash_pos && (slash_pos < colon_pos)) {
-    return path_from_dwarf;
-  }
-
-  // check whether we have a windows path, and so the first character is a
-  // drive-letter not a hostname.
-  if (colon_pos == path_from_dwarf + 1 && isalpha(*path_from_dwarf) &&
-      strlen(path_from_dwarf) > 2 && '\\' == path_from_dwarf[2]) {
-    return path_from_dwarf;
-  }
-
-  return colon_pos + 1;
-}
-
-static FileSpec resolveCompDir(const char *path_from_dwarf) {
-  if (!path_from_dwarf)
-    return FileSpec();
-
-  // DWARF2/3 suggests the form hostname:pathname for compilation directory.
-  // Remove the host part if present.
-  const char *local_path = removeHostnameFromPathname(path_from_dwarf);
-  if (!local_path)
-    return FileSpec();
-
-  bool is_symlink = false;
-  // Always normalize our compile unit directory to get rid of redundant
-  // slashes and other path anomalies before we use it for path prepending
-  FileSpec local_spec(local_path);
-  const auto &file_specs = GetGlobalPluginProperties()->GetSymLinkPaths();
-  for (size_t i = 0; i < file_specs.GetSize() && !is_symlink; ++i)
-    is_symlink = FileSpec::Equal(file_specs.GetFileSpecAtIndex(i),
-                                 local_spec, true);
-
-  if (!is_symlink)
-    return local_spec;
-
-  namespace fs = llvm::sys::fs;
-  if (fs::get_file_type(local_spec.GetPath(), false) !=
-      fs::file_type::symlink_file)
-    return local_spec;
-
-  FileSpec resolved_symlink;
-  const auto error = FileSystem::Instance().Readlink(local_spec, resolved_symlink);
-  if (error.Success())
-    return resolved_symlink;
-
-  return local_spec;
+const FileSpecList &SymbolFileDWARF::GetSymlinkPaths() {
+  return GetGlobalPluginProperties()->GetSymLinkPaths();
 }
 
 DWARFUnit *SymbolFileDWARF::GetBaseCompileUnit() {
   return nullptr;
 }
 
 void SymbolFileDWARF::Initialize() {
   LogChannelDWARF::Initialize();
if (comp_unit) {
         // Let the debug map create the compile unit
         cu_sp = m_debug_map_symfile->GetCompileUnit(this);
         dwarf_cu->SetUserData(cu_sp.get());
       } else {
         ModuleSP module_sp(m_obj_file->GetModule());
         if (module_sp) {
           const DWARFDIE cu_die = dwarf_cu->DIE();
           if (cu_die) {
-            FileSpec cu_file_spec(cu_die.GetName());
+            FileSpec cu_file_spec(cu_die.GetName(), dwarf_cu->GetPathStyle());
             if (cu_file_spec) {
               // If we have a full path to the compile unit, we don't need to
               // resolve the file.  This can be expensive e.g. when the source
-              // files are
-              // NFS mounted.
-              if (cu_file_spec.IsRelative()) {
-                const char *cu_comp_dir{
-                    cu_die.GetAttributeValueAsString(DW_AT_comp_dir, nullptr)};
-                cu_file_spec.PrependPathComponent(resolveCompDir(cu_comp_dir));
-              }
+              // files are NFS mounted.
+              cu_file_spec.MakeAbsolute(dwarf_cu->GetCompilationDirectory());
 
               std::string remapped_file;
               if (module_sp->RemapSourceFile(cu_file_spec.GetPath(),
                                              remapped_file))
                 cu_file_spec.SetFile(remapped_file, FileSpec::Style::native);
             }
 
             LanguageType cu_language = DWARFUnit::LanguageTypeFromDWARF(

 bool SymbolFileDWARF::ParseSupportFiles(CompileUnit &comp_unit,
                                         FileSpecList &support_files) {
   ASSERT_MODULE_LOCK(this);
   DWARFUnit *dwarf_cu = GetDWARFCompileUnit(&comp_unit);
   if (dwarf_cu) {
     const DWARFBaseDIE cu_die = dwarf_cu->GetUnitDIEOnly();
 
     if (cu_die) {
-      FileSpec cu_comp_dir = resolveCompDir(
-          cu_die.GetAttributeValueAsString(DW_AT_comp_dir, nullptr));
       const dw_offset_t stmt_list = cu_die.GetAttributeValueAsUnsigned(
           DW_AT_stmt_list, DW_INVALID_OFFSET);
       if (stmt_list != DW_INVALID_OFFSET) {
         // All file indexes in DWARF are one based and a file of index zero is
         // supposed to be the compile unit itself.
         support_files.Append(comp_unit);
         return DWARFDebugLine::ParseSupportFiles(
-            comp_unit.GetModule(), get_debug_line_data(), cu_comp_dir,
-            stmt_list, support_files, dwarf_cu);
+            comp_unit.GetModule(), get_debug_line_data(), stmt_list,
+            support_files, dwarf_cu);
       }
     }
   }
   return false;
 }
 
 bool SymbolFileDWARF::ParseIsOptimized(CompileUnit &comp_unit) {
   ASSERT_MODULE_LOCK(this);

source/Utility/FileSpec.cpp

bool FileSpec::IsAbsolute() const {
 
   // We consider paths starting with ~ to be absolute.
   if (current_path[0] == '~')
     return true;
 
   return llvm::sys::path::is_absolute(current_path, m_style);
 }
 
+void FileSpec::MakeAbsolute(const FileSpec &dir) {
+  if (IsRelative())
+    PrependPathComponent(dir);
+}
+
 void llvm::format_provider<FileSpec>::format(const FileSpec &F,
                                              raw_ostream &Stream,
                                              StringRef Style) {
   assert(
       (Style.empty() || Style.equals_lower("F") || Style.equals_lower("D")) &&
       "Invalid FileSpec style!");
 
   StringRef dir = F.GetDirectory().GetStringRef();