Use LLVM's debug line parser in LLDB

[JDevlieghere]

Summary

The line number table header was substantially revised in DWARF 5, which is not supported by LLDB's current debug line parser. Given the relatively limited contact surface between the code to parse the debug line section and the rest of LLDB, this seems like a good candidate to replace with LLVM's implementation, which does support the new standard.

In its current state this patch is mostly a proof-of-concept to show that this transition is possible. There are currently 8 failing tests, all related to the file paths from the prologue. (I know because I did the change in two parts, first the line table entries, then the so-called *support files*) I have yet to look at the failures in detail, but they are related to rnglists and split DWARF. Additionally, I'll need to ensure that there's minimal duplicate work when creating an LLVM DWARFContext and CompileUnit. We should only be parsing the UnitDIE, which I think is reasonable.

[labath]

Interesting stuff. I was wondering why you even needed to construct the DWARFContext and DWARFUnit, so I looked around a bit. It looks like they are only used for calling DWARFFormValue::extract to fetch the strings from the string table in the V5 case. So, it sounds like we need the DWARFContext to reach the string table, but maybe we don't need to create the DWARFUnit ? After all, one of the main goals of DWARF5 debug_lines was to have them be independent of the debug_info section.

What I'm trying to get at here is that it may be possible to limit the amount of work being done in DWARFContext by passing it only the small set of sections that it needs to get this parsed (something like debug_line, debug_str, debug_line_str ?).

BTW, I am also going to be touching this code slightly, as I'm trying to make sure the "support file" lists are shared between the various type units. However, it hopefully won't conflict with this too much, as I mostly approach it from the "other end" (i.e., what happens to the file lists after they have been parsed).

[aprantl]

Very nice!

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

964

should this be a getAsLLVM() member function or even an operator()?

[clayborg]

overall looks good. See inlined comments.

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

985–994

Can we make a function out of this that just returns the "const llvm::DWARFDebugLine::LineTable *"? Or make a new location variable that is just a "const llvm::DWARFDebugLine::LineTable *" to avoid the "(*line_table)->" stuff below?

[grimar]

lldb/include/lldb/Core/FileSpecList.h

29

Seems you don't use iterator anywhere?

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

861

You do not use stmt_list anywhere else, so I would suggest to:

if (cu_die.GetAttributeValueAsUnsigned(DW_AT_stmt_list, DW_INVALID_OFFSET) ==
    DW_INVALID_OFFSET)
  continue;

962

AddSection->addSection?

985–994

+1 for new location variable.

1021

Seems you can avoid having found_original and found_remapped:
(assuming table is a new variable mentioned above)

if (!table->getFileNameByIndex(
        index + 1, compile_dir,
        llvm::DILineInfoSpecifier::FileLineInfoKind::Default, original_file))
  continue;

[labath]

BTW, how good is the llvm debug_line parser when it comes to handling invalid input? Looking through the asserts in the file, it looks like at least two of them can be tripped by feeding it bad data:

• I'm pretty sure the DW_LNCT_*** handling code can blow up if the data forms are not of the expected class, or if DW_LNCT_MD5 points to data of incorrect size https://github.com/llvm-mirror/llvm/blob/0d9a164240ed293701eea6af0ea338caf227c338/lib/DebugInfo/DWARF/DWARFDebugLine.cpp#L254
• possibly the header parsing code can assert if the header contains invalid address size (I'd have to check how exactly is the address size on the data extractor being set to be sure) https://github.com/llvm-mirror/llvm/blob/0d9a164240ed293701eea6af0ea338caf227c338/lib/DebugInfo/DWARF/DWARFDebugLine.cpp#L302

[JDevlieghere]

• Rebase on current master
• Fix bug where we weren't actually creating any sections in the LLVM DWARF Context
• Don't create an LLVM DWARFUnit
• Get rid of (*line_table)->
• Add logging instead of swallowing errors

[JDevlieghere]

lldb/include/lldb/Core/FileSpecList.h

29

It's used in the range-based for loop in ParseSupportFiles

[JDevlieghere]

• Address remaining comment from George

[labath]

lldb/include/lldb/Core/FileSpecList.h

199–200

If both of these are returning the const iterators, then you don't need non-const versions..

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

860

What's the reason for this global m_support_files map? Is it just because you cannot set the "support" file list from inside the ParseLineTable call, and parsing the line table produces the file list as a "side effect". I've ran into the same problem in SymbolFileBreakpad, and I've had to bend over backwards to ensure we don't store the file list twice, so maybe it's time to have a more general solution to that. I think it would suffice to add CompileUnit::SetSupportFiles (to complement CompileUnit::SetLineTable). That way, you could call both comp_unit->SetSupportFiles and ->SetLineTable regardless of which one was being asked for.

878

I guess here you ought to to something similar to the block of code on line 981. (i.e., parse the line table, fetch files from it, and remap them. The only difference would be that you don't use the compilation directory from the type unit to resolve relative paths (because type units have no DW_AT_comp_dir).

[JDevlieghere]

• Address code review feedback
• Fix support files for type units

[clayborg]

So in the actual line table parsing code it seems like we are creating a line table in LLVM format, complete with sequences and a bunch of LLVM data structures, and then copying the results over into LLDB and then throwing away the LLVM line table. It would be nicer to modify the LLVM line table code to be able to get a callback when a row was pushed (if it isn't already in that format) and expose that so clients, like LLDB, can just get a callback and only store the data structure we care about. This would allow us to share the llvm line table parsing code and re-use it in LLDB, but not require twice the memory and overhead. Symbolication tools could also take advantage of this by not storing any rows except the closest matching row.

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

201

I am worried about this continue stuff. If this fails, all of our file indexes will be off and nothing will make sense. We need the indexes in the support files to match those in the prologue.

208

Ditto

211

Is this FileSpec constructor going to do the right thing for all path types (windows, linux, etc)?

[JDevlieghere]

Keep the indices correct when remapping a file fails.

[clayborg]

We also need to test to ensure this doesn't regress parsing speed. Need a large C++ project, like LLDB with debug clang and debug llvm, and something that forces all line tables to be parsed (not just the prologues like when setting a breakpoint) and see how things compare between the two methods.

[JDevlieghere]

Rebase and fix a bug in the support file implementation. I'm not sure why this didn't manifest itself earlier.

I have a plan to benchmark this (using image dump line-table) but I probably won't get around to that today. Hopefully I'll have data by early next week.

[aprantl]

lldb/include/lldb/Core/FileSpecList.h

29

Technically I think these typedefs should use LLDB style

using Collection = std::vector<FileSpec>; / typedef std::vector<FileSpec> Collection.

Though not the const_iterator, that would be silly.

[JDevlieghere]

I used image dump line-table to benchmark the performance difference. I did a RelWithDebugInfo build of clang and picked 237 files to dump.

repeat 10 "time ./bin/lldb -b -o 'image dump line-table ARCMT.cpp ARCMTActions.cpp FileRemapper.cpp ObjCMT.cpp PlistReporter.cpp TransAPIUses.cpp TransARCAssign.cpp TransAutoreleasePool.cpp TransBlockObjCVariable.cpp TransEmptyStatementsAndDealloc.cpp TransGCAttrs.cpp TransGCCalls.cpp TransProperties.cpp TransProtectedScope.cpp TransRetainReleaseDealloc.cpp TransUnbridgedCasts.cpp TransUnusedInitDelegate.cpp TransZeroOutPropsInDealloc.cpp TransformActions.cpp Transforms.cpp APValue.cpp ASTConsumer.cpp ASTContext.cpp ASTDiagnostic.cpp ASTDumper.cpp ASTImporter.cpp ASTImporterLookupTable.cpp ASTStructuralEquivalence.cpp ASTTypeTraits.cpp AttrImpl.cpp CXXInheritance.cpp Comment.cpp CommentBriefParser.cpp CommentCommandTraits.cpp CommentLexer.cpp CommentParser.cpp CommentSema.cpp ComparisonCategories.cpp DataCollection.cpp Decl.cpp DeclBase.cpp DeclCXX.cpp DeclFriend.cpp DeclGroup.cpp DeclObjC.cpp DeclOpenMP.cpp DeclPrinter.cpp DeclTemplate.cpp DeclarationName.cpp Expr.cpp ExprCXX.cpp ExprClassification.cpp ExprConstant.cpp ExprObjC.cpp ExternalASTSource.cpp FormatString.cpp ItaniumCXXABI.cpp ItaniumMangle.cpp JSONNodeDumper.cpp Mangle.cpp MicrosoftCXXABI.cpp MicrosoftMangle.cpp NSAPI.cpp NestedNameSpecifier.cpp ODRHash.cpp OSLog.cpp OpenMPClause.cpp ParentMap.cpp PrintfFormatString.cpp QualTypeNames.cpp RawCommentList.cpp RecordLayout.cpp RecordLayoutBuilder.cpp ScanfFormatString.cpp SelectorLocationsKind.cpp Stmt.cpp StmtCXX.cpp StmtIterator.cpp StmtObjC.cpp StmtOpenMP.cpp StmtPrinter.cpp StmtProfile.cpp StmtViz.cpp TemplateBase.cpp TemplateName.cpp TextNodeDumper.cpp Type.cpp TypeLoc.cpp TypePrinter.cpp VTTBuilder.cpp VTableBuilder.cpp ASTMatchFinder.cpp ASTMatchersInternal.cpp Parser.cpp AnalysisDeclContext.cpp BodyFarm.cpp CFG.cpp CFGReachabilityAnalysis.cpp CFGStmtMap.cpp CallGraph.cpp CloneDetection.cpp CocoaConventions.cpp CodeInjector.cpp ConstructionContext.cpp Consumed.cpp Dominators.cpp ExprMutationAnalyzer.cpp LiveVariables.cpp ObjCNoReturn.cpp PostOrderCFGView.cpp ProgramPoint.cpp ReachableCode.cpp RetainSummaryManager.cpp ThreadSafety.cpp ThreadSafetyCommon.cpp ThreadSafetyTIL.cpp UninitializedValues.cpp Attributes.cpp Builtins.cpp CharInfo.cpp CodeGenOptions.cpp Cuda.cpp Diagnostic.cpp DiagnosticIDs.cpp DiagnosticOptions.cpp FileManager.cpp FileSystemStatCache.cpp FixedPoint.cpp IdentifierTable.cpp LangOptions.cpp LangStandards.cpp Module.cpp ObjCRuntime.cpp OpenMPKinds.cpp OperatorPrecedence.cpp SanitizerBlacklist.cpp SanitizerSpecialCaseList.cpp Sanitizers.cpp SourceLocation.cpp SourceManager.cpp TargetInfo.cpp AArch64.cpp AMDGPU.cpp ARC.cpp ARM.cpp AVR.cpp BPF.cpp Hexagon.cpp Lanai.cpp Le64.cpp MSP430.cpp Mips.cpp NVPTX.cpp OSTargets.cpp PNaCl.cpp PPC.cpp RISCV.cpp SPIR.cpp Sparc.cpp SystemZ.cpp TCE.cpp WebAssembly.cpp X86.cpp XCore.cpp Targets.cpp TokenKinds.cpp Version.cpp Warnings.cpp XRayInstr.cpp XRayLists.cpp BackendUtil.cpp CGAtomic.cpp CGBlocks.cpp CGBuiltin.cpp CGCUDANV.cpp CGCUDARuntime.cpp CGCXX.cpp CGCXXABI.cpp CGCall.cpp CGClass.cpp CGCleanup.cpp CGCoroutine.cpp CGDebugInfo.cpp CGDecl.cpp CGDeclCXX.cpp CGException.cpp CGExpr.cpp CGExprAgg.cpp CGExprCXX.cpp CGExprComplex.cpp CGExprConstant.cpp CGExprScalar.cpp CGGPUBuiltin.cpp CGLoopInfo.cpp CGNonTrivialStruct.cpp CGObjC.cpp CGObjCGNU.cpp CGObjCMac.cpp CGObjCRuntime.cpp CGOpenCLRuntime.cpp CGOpenMPRuntime.cpp CGOpenMPRuntimeNVPTX.cpp CGRecordLayoutBuilder.cpp CGStmt.cpp CGStmtOpenMP.cpp CGVTT.cpp CGVTables.cpp CodeGenAction.cpp CodeGenFunction.cpp CodeGenModule.cpp CodeGenPGO.cpp CodeGenTBAA.cpp CodeGenTypes.cpp ConstantInitBuilder.cpp CoverageMappingGen.cpp ItaniumCXXABI.cpp MacroPPCallbacks.cpp MicrosoftCXXABI.cpp ModuleBuilder.cpp ObjectFilePCHContainerOperations.cpp PatternInit.cpp SanitizerMetadata.cpp SwiftCallingConv.cpp TargetInfo.cpp VarBypassDetector.cpp CrossTranslationUnit.cpp Action.cpp Compilation.cpp DarwinSDKInfo.cpp Distro.cpp Driver.cpp DriverOptions.cpp Job.cpp Multilib.cpp Phases.cpp SanitizerArgs.cpp Tool.cpp' ~/llvm/build-benchmark/bin/clang > /dev/null"

LLDB Line Table Parser

6.13 real         4.97 user         1.13 sys
6.15 real         5.00 user         1.12 sys
6.11 real         4.96 user         1.11 sys
6.10 real         4.95 user         1.12 sys
6.14 real         4.98 user         1.13 sys
6.15 real         4.98 user         1.13 sys
6.10 real         4.94 user         1.13 sys
6.18 real         5.02 user         1.13 sys
6.15 real         4.95 user         1.16 sys
6.06 real         4.92 user         1.10 sys
--------------------------------------------
6.13 real

LLVM Line Table Parser

6.34 real         5.11 user         1.16 sys
6.34 real         5.13 user         1.17 sys
6.35 real         5.14 user         1.17 sys
6.29 real         5.09 user         1.15 sys
6.27 real         5.07 user         1.16 sys
6.32 real         5.13 user         1.15 sys
6.21 real         5.04 user         1.13 sys
6.13 real         4.99 user         1.11 sys
6.08 real         4.93 user         1.12 sys
6.13 real         4.97 user         1.12 sys
--------------------------------------------
6.25 real

There's a small slowdown (~1.9%) which is not unexpected given that we need to do bridging to LLVM.

[clayborg]

Thanks for running the perf tests, that will be great to keep handy somewhere. Might be good to check this test in somewhere. I still think that making changes to the llvm line parser might be a good idea where we can get a callback when a row is to be pushed with the current line table state. This would allow symbolication clients that need just one address, like in atos kind of cases, to not have to store an array of these things and then search them. It would also allow us to just populate our line table as we see fit without the need to have complete LLVM tables and then convert them. Shouldn't be very hard to modify the code in llvm. Let me know what you think.

[aprantl]

Two percent is a noticeable price tag, but since we are doing extra work with error handling and building a copy of the line table in memory first; understandable, I'm moderately optimistic that we could increase the performance a bit in the future by eliminating the extra copy step, though perhaps not with some larger changes to the LLVM interface. Since we need this for DWARF 5 support and the performance penalty isn't that bad, this patch gets a thumbs up from me. I ssume you profiled the code and there isn't any obvious silliness in the implementation?

[clayborg]

I agree with Adrian, this isn't something that needs to hold up this patch, but I do think it is worth doing soon in LLVM. The line table parsing code just needs to take a std::function (or llvm equivalent) that gets called like a lambda when a row is to be pushed. The current LLVM parsing code just has this callback create its own line tables as is currently done. We would just create our own line tables using our callback. So it won't take much work at all in llvm to make this happen and then be able to adopt it in LLDB.

[JDevlieghere]

Thank you! I agree that extending the LLVM parser is a good idea, especially if it's already using a callback internally. I'll add a comment in the code and spend some time looking at that in the coming days.

[labath]

Thank you for working on this.

lldb/include/lldb/Core/FileSpecList.h

 class Stream;
 
 /// \class FileSpecList FileSpecList.h "lldb/Core/FileSpecList.h"
 /// A file collection class.
 ///
 /// A class that contains a mutable list of FileSpec objects.
 class FileSpecList {
 public:
+  typedef std::vector<FileSpec> collection;
+  typedef collection::const_iterator const_iterator;
+
   /// Default constructor.
   ///
   /// Initialize this object with an empty file list.
   FileSpecList();
 
   /// Copy constructor.
   FileSpecList(const FileSpecList &rhs) = default;
 
if (idx < m_files.size()) {
       return true;
     }
     return false;
   }
 
   static size_t GetFilesMatchingPartialPath(const char *path, bool dir_okay,
                                             FileSpecList &matches);
 
+  const_iterator begin() const { return m_files.begin(); }
+  const_iterator end() const { return m_files.end(); }
+
 protected:
-  typedef std::vector<FileSpec>
-      collection;     ///< The collection type for the file list.
   collection m_files; ///< A collection of FileSpec objects.
 };
 
 } // namespace lldb_private
 
 #endif // #if defined(__cplusplus)
 #endif // liblldb_FileSpecList_h_

lldb/include/lldb/Symbol/CompileUnit.h

public:
   /// Called by the SymbolFile plug-in when if first parses the line table and
   /// hands ownership of the line table to this object. The compile unit owns
   /// the line table object and will delete the object when it is deleted.
   ///
   /// \param[in] line_table
   ///     A line table object pointer that this object now owns.
   void SetLineTable(LineTable *line_table);
 
+  void SetSupportFiles(const FileSpecList &support_files);
+
   void SetDebugMacros(const DebugMacrosSP &debug_macros);
 
   /// Set accessor for the variable list.
   ///
   /// Called by the SymbolFile plug-ins after they have parsed the variable
   /// lists and are ready to hand ownership of the list over to this object.
   ///
   /// \param[in] variable_list_sp

lldb/source/Plugins/SymbolFile/DWARF/CMakeLists.txt

 add_lldb_library(lldbPluginSymbolFileDWARF PLUGIN
   AppleDWARFIndex.cpp
   DebugNamesDWARFIndex.cpp
   DIERef.cpp
   DWARFAbbreviationDeclaration.cpp
   DWARFASTParserClang.cpp
   DWARFAttribute.cpp
   DWARFBaseDIE.cpp
   DWARFCompileUnit.cpp
   DWARFContext.cpp
   DWARFDataExtractor.cpp
   DWARFDebugAbbrev.cpp
   DWARFDebugAranges.cpp
   DWARFDebugArangeSet.cpp
   DWARFDebugInfo.cpp
   DWARFDebugInfoEntry.cpp
-  DWARFDebugLine.cpp
   DWARFDebugMacro.cpp
   DWARFDebugRanges.cpp
   DWARFDeclContext.cpp
   DWARFDefines.cpp
   DWARFDIE.cpp
   DWARFFormValue.cpp
   DWARFIndex.cpp
   DWARFTypeUnit.cpp

lldb/source/Plugins/SymbolFile/DWARF/DWARFDebugLine.h

-//===-- DWARFDebugLine.h ----------------------------------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#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;
-class SymbolFileDWARF;
-
-// DWARFDebugLine
-class DWARFDebugLine {
-public:
-  // FileNameEntry
-  struct FileNameEntry {
-    FileNameEntry()
-        : name(nullptr), dir_idx(0), mod_time(0), length(0), checksum() {}
-
-    const char *name;
-    dw_sleb128_t dir_idx;
-    dw_sleb128_t mod_time;
-    dw_sleb128_t length;
-    llvm::MD5::MD5Result checksum;
-  };
-
-  // Prologue
-  struct Prologue {
-
-    Prologue()
-        : total_length(0), version(0), prologue_length(0), min_inst_length(0),
-          default_is_stmt(0), line_base(0), line_range(0), opcode_base(0),
-          standard_opcode_lengths(), include_directories(), file_names() {}
-
-    typedef std::shared_ptr<Prologue> shared_ptr;
-
-    uint32_t total_length; // The size in bytes of the statement information for
-                           // this compilation unit (not including the
-                           // total_length field itself).
-    uint16_t
-        version; // Version identifier for the statement information format.
-
-    uint8_t address_size;
-    uint8_t segment_selector_size;
-
-    uint32_t prologue_length; // The number of bytes following the
-                              // prologue_length field to the beginning of the
-                              // first byte of the statement program itself.
-    uint8_t min_inst_length; // The size in bytes of the smallest target machine
-                             // instruction. Statement program opcodes that
-                             // alter the address register first multiply their
-                             // operands by this value.
-    uint8_t maximum_operations_per_instruction; // New in DWARF4. The maximum
-                                                // number of individual
-                                                // operations that may be
-                                                // encoded in an instruction.
-    uint8_t default_is_stmt; // The initial value of theis_stmtregister.
-    int8_t line_base;    // This parameter affects the meaning of the special
-                         // opcodes. See below.
-    uint8_t line_range;  // This parameter affects the meaning of the special
-                         // opcodes. See below.
-    uint8_t opcode_base; // The number assigned to the first special opcode.
-    std::vector<uint8_t> standard_opcode_lengths;
-    std::vector<const char *> include_directories;
-    std::vector<FileNameEntry> file_names;
-
-    int32_t MaxLineIncrementForSpecialOpcode() const {
-      return line_base + (int8_t)line_range - 1;
-    }
-    bool IsValid() const;
-    //      void Append(BinaryStreamBuf& buff) const;
-    void Dump(lldb_private::Log *log);
-    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;
-
-    Row(bool default_is_stmt = false);
-    virtual ~Row() {}
-    void PostAppend();
-    void Reset(bool default_is_stmt);
-    void Dump(lldb_private::Log *log) const;
-    static void Insert(Row::collection &state_coll, const Row &state);
-
-    dw_addr_t address; // The program-counter value corresponding to a machine
-                       // instruction generated by the compiler.
-    uint32_t line; // An unsigned integer indicating a source line number. Lines
-                   // are numbered beginning at 1. The compiler may emit the
-                   // value 0 in cases where an instruction cannot be attributed
-                   // to any source line.
-    uint16_t column; // An unsigned integer indicating a column number within a
-                     // source line. Columns are numbered beginning at 1. The
-                     // value 0 is reserved to indicate that a statement begins
-                     // at the 'left edge' of the line.
-    uint16_t file; // An unsigned integer indicating the identity of the source
-                   // file corresponding to a machine instruction.
-    uint8_t is_stmt : 1, // A boolean indicating that the current instruction is
-                         // the beginning of a statement.
-        basic_block : 1, // A boolean indicating that the current instruction is
-                         // the beginning of a basic block.
-        end_sequence : 1, // A boolean indicating that the current address is
-                          // that of the first byte after the end of a sequence
-                          // of target machine instructions.
-        prologue_end : 1, // A boolean indicating that the current address is
-                          // one (of possibly many) where execution should be
-                          // suspended for an entry breakpoint of a function.
-        epilogue_begin : 1; // A boolean indicating that the current address is
-                            // one (of possibly many) where execution should be
-                            // suspended for an exit breakpoint of a function.
-    uint32_t isa; // An unsigned integer whose value encodes the applicable
-                  // instruction set architecture for the current instruction.
-  };
-
-  // LineTable
-  struct LineTable {
-    typedef std::shared_ptr<LineTable> shared_ptr;
-
-    LineTable() : prologue(), rows() {}
-
-    void AppendRow(const DWARFDebugLine::Row &state);
-    void Clear() {
-      prologue.reset();
-      rows.clear();
-    }
-
-    uint32_t LookupAddress(dw_addr_t address, dw_addr_t cu_high_pc) const;
-
-    Prologue::shared_ptr prologue;
-    Row::collection rows;
-  };
-
-  // State
-  struct State : public Row {
-    typedef void (*Callback)(dw_offset_t offset, const State &state,
-                             void *userData);
-
-    // Special row codes used when calling the callback
-    enum { StartParsingLineTable = 0, DoneParsingLineTable = -1 };
-
-    State(Prologue::shared_ptr &prologue_sp, lldb_private::Log *log,
-          Callback callback, void *userData);
-
-    void AppendRowToMatrix(dw_offset_t offset);
-
-    void Finalize(dw_offset_t offset);
-
-    void Reset();
-
-    Prologue::shared_ptr prologue;
-    lldb_private::Log *log;
-    Callback callback; // Callback function that gets called each time an entry
-                       // is to be added to the matrix
-    void *callbackUserData;
-    int row; // The row number that starts at zero for the prologue, and
-             // increases for each row added to the matrix
-  private:
-    DISALLOW_COPY_AND_ASSIGN(State);
-  };
-
-  static bool
-  ParseSupportFiles(const lldb::ModuleSP &module_sp,
-                    const lldb_private::DWARFDataExtractor &debug_line_data,
-                    dw_offset_t stmt_list,
-                    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);
-  static bool
-  ParseStatementTable(const lldb_private::DWARFDataExtractor &debug_line_data,
-                      lldb::offset_t *offset_ptr, LineTable *line_table,
-                      DWARFUnit *dwarf_cu);
-  static void Parse(const lldb_private::DWARFDataExtractor &debug_line_data,
-                    DWARFDebugLine::State::Callback callback, void *userData);
-  //  static void AppendLineTableData(const DWARFDebugLine::Prologue* prologue,
-  //  const DWARFDebugLine::Row::collection& state_coll, const uint32_t
-  //  addr_size, BinaryStreamBuf &debug_line_data);
-
-  DWARFDebugLine() : m_lineTableMap() {}
-
-  void Parse(const lldb_private::DWARFDataExtractor &debug_line_data);
-  void ParseIfNeeded(const lldb_private::DWARFDataExtractor &debug_line_data);
-  LineTable::shared_ptr GetLineTable(const dw_offset_t offset) const;
-
-protected:
-  typedef std::map<dw_offset_t, LineTable::shared_ptr> LineTableMap;
-  typedef LineTableMap::iterator LineTableIter;
-  typedef LineTableMap::const_iterator LineTableConstIter;
-
-  LineTableMap m_lineTableMap;
-};
-
-#endif // SymbolFileDWARF_DWARFDebugLine_h_

lldb/source/Plugins/SymbolFile/DWARF/DWARFDebugLine.cpp

-//===-- DWARFDebugLine.cpp --------------------------------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#include "DWARFDebugLine.h"
-
-//#define ENABLE_DEBUG_PRINTF   // DO NOT LEAVE THIS DEFINED: DEBUG ONLY!!!
-#include <assert.h>
-
-#include <memory>
-
-#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;
-
-// Parse
-//
-// Parse all information in the debug_line_data into an internal
-// representation.
-void DWARFDebugLine::Parse(const DWARFDataExtractor &debug_line_data) {
-  m_lineTableMap.clear();
-  lldb::offset_t offset = 0;
-  LineTable::shared_ptr line_table_sp(new LineTable);
-  while (debug_line_data.ValidOffset(offset)) {
-    const lldb::offset_t debug_line_offset = offset;
-
-    if (line_table_sp.get() == nullptr)
-      break;
-
-    if (ParseStatementTable(debug_line_data, &offset, line_table_sp.get(), nullptr)) {
-      // Make sure we don't don't loop infinitely
-      if (offset <= debug_line_offset)
-        break;
-      // DEBUG_PRINTF("m_lineTableMap[0x%8.8x] = line_table_sp\n",
-      // debug_line_offset);
-      m_lineTableMap[debug_line_offset] = line_table_sp;
-      line_table_sp = std::make_shared<LineTable>();
-    } else
-      ++offset; // Try next byte in line table
-  }
-}
-
-void DWARFDebugLine::ParseIfNeeded(const DWARFDataExtractor &debug_line_data) {
-  if (m_lineTableMap.empty())
-    Parse(debug_line_data);
-}
-
-// DWARFDebugLine::GetLineTable
-DWARFDebugLine::LineTable::shared_ptr
-DWARFDebugLine::GetLineTable(const dw_offset_t offset) const {
-  DWARFDebugLine::LineTable::shared_ptr line_table_shared_ptr;
-  LineTableConstIter pos = m_lineTableMap.find(offset);
-  if (pos != m_lineTableMap.end())
-    line_table_shared_ptr = pos->second;
-  return line_table_shared_ptr;
-}
-
-// Parse
-//
-// Parse the entire line table contents calling callback each time a new
-// prologue is parsed and every time a new row is to be added to the line
-// table.
-void DWARFDebugLine::Parse(const DWARFDataExtractor &debug_line_data,
-                           DWARFDebugLine::State::Callback callback,
-                           void *userData) {
-  lldb::offset_t offset = 0;
-  if (debug_line_data.ValidOffset(offset)) {
-    if (!ParseStatementTable(debug_line_data, &offset, callback, userData, nullptr))
-      ++offset; // Skip to next byte in .debug_line section
-  }
-}
-
-namespace {
-struct EntryDescriptor {
-  dw_sleb128_t code;
-  dw_sleb128_t form;
-};
-
-static std::vector<EntryDescriptor>
-ReadDescriptors(const DWARFDataExtractor &debug_line_data,
-                lldb::offset_t *offset_ptr) {
-  std::vector<EntryDescriptor> ret;
-  uint8_t n = debug_line_data.GetU8(offset_ptr);
-  for (uint8_t i = 0; i < n; ++i) {
-    EntryDescriptor ent;
-    ent.code = debug_line_data.GetULEB128(offset_ptr);
-    ent.form = debug_line_data.GetULEB128(offset_ptr);
-    ret.push_back(ent);
-  }
-  return ret;
-}
-} // namespace
-
-// DWARFDebugLine::ParsePrologue
-bool DWARFDebugLine::ParsePrologue(const DWARFDataExtractor &debug_line_data,
-                                   lldb::offset_t *offset_ptr,
-                                   Prologue *prologue, DWARFUnit *dwarf_cu) {
-  const lldb::offset_t prologue_offset = *offset_ptr;
-
-  // DEBUG_PRINTF("0x%8.8x: ParsePrologue()\n", *offset_ptr);
-
-  prologue->Clear();
-  uint32_t i;
-  const char *s;
-  prologue->total_length = debug_line_data.GetDWARFInitialLength(offset_ptr);
-  prologue->version = debug_line_data.GetU16(offset_ptr);
-  if (prologue->version < 2 || prologue->version > 5)
-    return false;
-
-  if (prologue->version >= 5) {
-    prologue->address_size = debug_line_data.GetU8(offset_ptr);
-    prologue->segment_selector_size = debug_line_data.GetU8(offset_ptr);
-  }
-
-  prologue->prologue_length = debug_line_data.GetDWARFOffset(offset_ptr);
-  const lldb::offset_t end_prologue_offset =
-      prologue->prologue_length + *offset_ptr;
-  prologue->min_inst_length = debug_line_data.GetU8(offset_ptr);
-  if (prologue->version >= 4)
-    prologue->maximum_operations_per_instruction =
-        debug_line_data.GetU8(offset_ptr);
-  else
-    prologue->maximum_operations_per_instruction = 1;
-  prologue->default_is_stmt = debug_line_data.GetU8(offset_ptr);
-  prologue->line_base = debug_line_data.GetU8(offset_ptr);
-  prologue->line_range = debug_line_data.GetU8(offset_ptr);
-  prologue->opcode_base = debug_line_data.GetU8(offset_ptr);
-
-  prologue->standard_opcode_lengths.reserve(prologue->opcode_base - 1);
-
-  for (i = 1; i < prologue->opcode_base; ++i) {
-    uint8_t op_len = debug_line_data.GetU8(offset_ptr);
-    prologue->standard_opcode_lengths.push_back(op_len);
-  }
-
-  if (prologue->version >= 5) {
-    std::vector<EntryDescriptor> dirEntryFormatV =
-        ReadDescriptors(debug_line_data, offset_ptr);
-    uint8_t dirCount = debug_line_data.GetULEB128(offset_ptr);
-    for (int i = 0; i < dirCount; ++i) {
-      for (EntryDescriptor &ent : dirEntryFormatV) {
-        DWARFFormValue value(dwarf_cu, ent.form);
-        if (ent.code != DW_LNCT_path) {
-          if (!value.SkipValue(debug_line_data, offset_ptr))
-            return false;
-          continue;
-        }
-
-        if (!value.ExtractValue(debug_line_data, offset_ptr))
-          return false;
-        prologue->include_directories.push_back(value.AsCString());
-      }
-    }
-
-    std::vector<EntryDescriptor> filesEntryFormatV =
-        ReadDescriptors(debug_line_data, offset_ptr);
-    llvm::DenseSet<std::pair<uint64_t, uint64_t>> seen;
-    uint8_t n = debug_line_data.GetULEB128(offset_ptr);
-    for (int i = 0; i < n; ++i) {
-      FileNameEntry entry;
-      for (EntryDescriptor &ent : filesEntryFormatV) {
-        DWARFFormValue value(dwarf_cu, ent.form);
-        if (!value.ExtractValue(debug_line_data, offset_ptr))
-          return false;
-
-        switch (ent.code) {
-        case DW_LNCT_path:
-          entry.name = value.AsCString();
-          break;
-        case DW_LNCT_directory_index:
-          entry.dir_idx = value.Unsigned();
-          break;
-        case DW_LNCT_timestamp:
-          entry.mod_time = value.Unsigned();
-          break;
-        case DW_LNCT_size:
-          entry.length = value.Unsigned();
-          break;
-        case DW_LNCT_MD5:
-          assert(value.Unsigned() == 16);
-          std::uninitialized_copy_n(value.BlockData(), 16,
-                                    entry.checksum.Bytes.begin());
-          break;
-        default:
-          break;
-        }
-      }
-
-      if (seen.insert(entry.checksum.words()).second)
-        prologue->file_names.push_back(entry);
-    }
-  } else {
-    while (*offset_ptr < end_prologue_offset) {
-      s = debug_line_data.GetCStr(offset_ptr);
-      if (s && s[0])
-        prologue->include_directories.push_back(s);
-      else
-        break;
-    }
-
-    while (*offset_ptr < end_prologue_offset) {
-      const char *name = debug_line_data.GetCStr(offset_ptr);
-      if (name && name[0]) {
-        FileNameEntry fileEntry;
-        fileEntry.name = name;
-        fileEntry.dir_idx = debug_line_data.GetULEB128(offset_ptr);
-        fileEntry.mod_time = debug_line_data.GetULEB128(offset_ptr);
-        fileEntry.length = debug_line_data.GetULEB128(offset_ptr);
-        prologue->file_names.push_back(fileEntry);
-      } else
-        break;
-    }
-  }
-
-  // XXX GNU as is broken for 64-Bit DWARF
-  if (*offset_ptr != end_prologue_offset) {
-    Host::SystemLog(Host::eSystemLogWarning,
-                    "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",
-                    prologue_offset, end_prologue_offset, *offset_ptr);
-  }
-  return end_prologue_offset;
-}
-
-bool DWARFDebugLine::ParseSupportFiles(
-    const lldb::ModuleSP &module_sp, const DWARFDataExtractor &debug_line_data,
-    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, 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;
-}
-
-// ParseStatementTable
-//
-// Parse a single line table (prologue and all rows) and call the callback
-// function once for the prologue (row in state will be zero) and each time a
-// row is to be added to the line table.
-bool DWARFDebugLine::ParseStatementTable(
-    const DWARFDataExtractor &debug_line_data, lldb::offset_t *offset_ptr,
-    DWARFDebugLine::State::Callback callback, void *userData, DWARFUnit *dwarf_cu) {
-  Log *log(LogChannelDWARF::GetLogIfAll(DWARF_LOG_DEBUG_LINE));
-  Prologue::shared_ptr prologue(new Prologue());
-
-  const dw_offset_t debug_line_offset = *offset_ptr;
-
-  static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
-  Timer scoped_timer(
-      func_cat, "DWARFDebugLine::ParseStatementTable (.debug_line[0x%8.8x])",
-      debug_line_offset);
-
-  if (!ParsePrologue(debug_line_data, offset_ptr, prologue.get(), dwarf_cu)) {
-    if (log)
-      log->Error("failed to parse DWARF line table prologue");
-    // Restore our offset and return false to indicate failure!
-    *offset_ptr = debug_line_offset;
-    return false;
-  }
-
-  if (log)
-    prologue->Dump(log);
-
-  const dw_offset_t end_offset =
-      debug_line_offset + prologue->total_length +
-      (debug_line_data.GetDWARFSizeofInitialLength());
-
-  State state(prologue, log, callback, userData);
-
-  while (*offset_ptr < end_offset) {
-    // DEBUG_PRINTF("0x%8.8x: ", *offset_ptr);
-    uint8_t opcode = debug_line_data.GetU8(offset_ptr);
-
-    if (opcode == 0) {
-      // Extended Opcodes always start with a zero opcode followed by a uleb128
-      // length so you can skip ones you don't know about
-      lldb::offset_t ext_offset = *offset_ptr;
-      dw_uleb128_t len = debug_line_data.GetULEB128(offset_ptr);
-      dw_offset_t arg_size = len - (*offset_ptr - ext_offset);
-
-      // DEBUG_PRINTF("Extended: <%2u> ", len);
-      uint8_t sub_opcode = debug_line_data.GetU8(offset_ptr);
-      switch (sub_opcode) {
-      case DW_LNE_end_sequence:
-        // Set the end_sequence register of the state machine to true and
-        // append a row to the matrix using the current values of the state-
-        // machine registers. Then reset the registers to the initial values
-        // specified above. Every statement program sequence must end with a
-        // DW_LNE_end_sequence instruction which creates a row whose address is
-        // that of the byte after the last target machine instruction of the
-        // sequence.
-        state.end_sequence = true;
-        state.AppendRowToMatrix(*offset_ptr);
-        state.Reset();
-        break;
-
-      case DW_LNE_set_address:
-        // Takes a single relocatable address as an operand. The size of the
-        // operand is the size appropriate to hold an address on the target
-        // machine. Set the address register to the value given by the
-        // relocatable address. All of the other statement program opcodes that
-        // affect the address register add a delta to it. This instruction
-        // stores a relocatable value into it instead.
-        if (arg_size == 4)
-          state.address = debug_line_data.GetU32(offset_ptr);
-        else // arg_size == 8
-          state.address = debug_line_data.GetU64(offset_ptr);
-        break;
-
-      case DW_LNE_define_file:
-        // Takes 4 arguments. The first is a null terminated string containing
-        // a source file name. The second is an unsigned LEB128 number
-        // representing the directory index of the directory in which the file
-        // was found. The third is an unsigned LEB128 number representing the
-        // time of last modification of the file. The fourth is an unsigned
-        // LEB128 number representing the length in bytes of the file. The time
-        // and length fields may contain LEB128(0) if the information is not
-        // available.
-        //
-        // The directory index represents an entry in the include_directories
-        // section of the statement program prologue. The index is LEB128(0) if
-        // the file was found in the current directory of the compilation,
-        // LEB128(1) if it was found in the first directory in the
-        // include_directories section, and so on. The directory index is
-        // ignored for file names that represent full path names.
-        //
-        // The files are numbered, starting at 1, in the order in which they
-        // appear; the names in the prologue come before names defined by the
-        // DW_LNE_define_file instruction. These numbers are used in the file
-        // register of the state machine.
-        {
-          FileNameEntry fileEntry;
-          fileEntry.name = debug_line_data.GetCStr(offset_ptr);
-          fileEntry.dir_idx = debug_line_data.GetULEB128(offset_ptr);
-          fileEntry.mod_time = debug_line_data.GetULEB128(offset_ptr);
-          fileEntry.length = debug_line_data.GetULEB128(offset_ptr);
-          state.prologue->file_names.push_back(fileEntry);
-        }
-        break;
-
-      default:
-        // Length doesn't include the zero opcode byte or the length itself,
-        // but it does include the sub_opcode, so we have to adjust for that
-        // below
-        (*offset_ptr) += arg_size;
-        break;
-      }
-    } else if (opcode < prologue->opcode_base) {
-      switch (opcode) {
-      // Standard Opcodes
-      case DW_LNS_copy:
-        // Takes no arguments. Append a row to the matrix using the current
-        // values of the state-machine registers. Then set the basic_block
-        // register to false.
-        state.AppendRowToMatrix(*offset_ptr);
-        break;
-
-      case DW_LNS_advance_pc:
-        // Takes a single unsigned LEB128 operand, multiplies it by the
-        // min_inst_length field of the prologue, and adds the result to the
-        // address register of the state machine.
-        state.address +=
-            debug_line_data.GetULEB128(offset_ptr) * prologue->min_inst_length;
-        break;
-
-      case DW_LNS_advance_line:
-        // Takes a single signed LEB128 operand and adds that value to the line
-        // register of the state machine.
-        state.line += debug_line_data.GetSLEB128(offset_ptr);
-        break;
-
-      case DW_LNS_set_file:
-        // Takes a single unsigned LEB128 operand and stores it in the file
-        // register of the state machine.
-        state.file = debug_line_data.GetULEB128(offset_ptr);
-        break;
-
-      case DW_LNS_set_column:
-        // Takes a single unsigned LEB128 operand and stores it in the column
-        // register of the state machine.
-        state.column = debug_line_data.GetULEB128(offset_ptr);
-        break;
-
-      case DW_LNS_negate_stmt:
-        // Takes no arguments. Set the is_stmt register of the state machine to
-        // the logical negation of its current value.
-        state.is_stmt = !state.is_stmt;
-        break;
-
-      case DW_LNS_set_basic_block:
-        // Takes no arguments. Set the basic_block register of the state
-        // machine to true
-        state.basic_block = true;
-        break;
-
-      case DW_LNS_const_add_pc:
-        // Takes no arguments. Add to the address register of the state machine
-        // the address increment value corresponding to special opcode 255. The
-        // motivation for DW_LNS_const_add_pc is this: when the statement
-        // program needs to advance the address by a small amount, it can use a
-        // single special opcode, which occupies a single byte. When it needs
-        // to advance the address by up to twice the range of the last special
-        // opcode, it can use DW_LNS_const_add_pc followed by a special opcode,
-        // for a total of two bytes. Only if it needs to advance the address by
-        // more than twice that range will it need to use both
-        // DW_LNS_advance_pc and a special opcode, requiring three or more
-        // bytes.
-        {
-          uint8_t adjust_opcode = 255 - prologue->opcode_base;
-          dw_addr_t addr_offset = (adjust_opcode / prologue->line_range) *
-                                  prologue->min_inst_length;
-          state.address += addr_offset;
-        }
-        break;
-
-      case DW_LNS_fixed_advance_pc:
-        // Takes a single uhalf operand. Add to the address register of the
-        // state machine the value of the (unencoded) operand. This is the only
-        // extended opcode that takes an argument that is not a variable length
-        // number. The motivation for DW_LNS_fixed_advance_pc is this: existing
-        // assemblers cannot emit DW_LNS_advance_pc or special opcodes because
-        // they cannot encode LEB128 numbers or judge when the computation of a
-        // special opcode overflows and requires the use of DW_LNS_advance_pc.
-        // Such assemblers, however, can use DW_LNS_fixed_advance_pc instead,
-        // sacrificing compression.
-        state.address += debug_line_data.GetU16(offset_ptr);
-        break;
-
-      case DW_LNS_set_prologue_end:
-        // Takes no arguments. Set the prologue_end register of the state
-        // machine to true
-        state.prologue_end = true;
-        break;
-
-      case DW_LNS_set_epilogue_begin:
-        // Takes no arguments. Set the basic_block register of the state
-        // machine to true
-        state.epilogue_begin = true;
-        break;
-
-      case DW_LNS_set_isa:
-        // Takes a single unsigned LEB128 operand and stores it in the column
-        // register of the state machine.
-        state.isa = debug_line_data.GetULEB128(offset_ptr);
-        break;
-
-      default:
-        // Handle any unknown standard opcodes here. We know the lengths of
-        // such opcodes because they are specified in the prologue as a
-        // multiple of LEB128 operands for each opcode.
-        {
-          uint8_t i;
-          assert(static_cast<size_t>(opcode - 1) <
-                 prologue->standard_opcode_lengths.size());
-          const uint8_t opcode_length =
-              prologue->standard_opcode_lengths[opcode - 1];
-          for (i = 0; i < opcode_length; ++i)
-            debug_line_data.Skip_LEB128(offset_ptr);
-        }
-        break;
-      }
-    } else {
-      // Special Opcodes
-
-      // A special opcode value is chosen based on the amount that needs
-      // to be added to the line and address registers. The maximum line
-      // increment for a special opcode is the value of the line_base field in
-      // the header, plus the value of the line_range field, minus 1 (line base
-      // + line range - 1). If the desired line increment is greater than the
-      // maximum line increment, a standard opcode must be used instead of a
-      // special opcode. The "address advance" is calculated by dividing the
-      // desired address increment by the minimum_instruction_length field from
-      // the header. The special opcode is then calculated using the following
-      // formula:
-      //
-      //  opcode = (desired line increment - line_base) + (line_range * address
-      //  advance) + opcode_base
-      //
-      // If the resulting opcode is greater than 255, a standard opcode must be
-      // used instead.
-      //
-      // To decode a special opcode, subtract the opcode_base from the opcode
-      // itself to give the adjusted opcode. The amount to increment the
-      // address register is the result of the adjusted opcode divided by the
-      // line_range multiplied by the minimum_instruction_length field from the
-      // header. That is:
-      //
-      //  address increment = (adjusted opcode / line_range) *
-      //  minimum_instruction_length
-      //
-      // The amount to increment the line register is the line_base plus the
-      // result of the adjusted opcode modulo the line_range. That is:
-      //
-      // line increment = line_base + (adjusted opcode % line_range)
-
-      uint8_t adjust_opcode = opcode - prologue->opcode_base;
-      dw_addr_t addr_offset =
-          (adjust_opcode / prologue->line_range) * prologue->min_inst_length;
-      int32_t line_offset =
-          prologue->line_base + (adjust_opcode % prologue->line_range);
-      state.line += line_offset;
-      state.address += addr_offset;
-      state.AppendRowToMatrix(*offset_ptr);
-    }
-  }
-
-  state.Finalize(*offset_ptr);
-
-  return end_offset;
-}
-
-// ParseStatementTableCallback
-static void ParseStatementTableCallback(dw_offset_t offset,
-                                        const DWARFDebugLine::State &state,
-                                        void *userData) {
-  DWARFDebugLine::LineTable *line_table = (DWARFDebugLine::LineTable *)userData;
-  if (state.row == DWARFDebugLine::State::StartParsingLineTable) {
-    // Just started parsing the line table, so lets keep a reference to the
-    // prologue using the supplied shared pointer
-    line_table->prologue = state.prologue;
-  } else if (state.row == DWARFDebugLine::State::DoneParsingLineTable) {
-    // Done parsing line table, nothing to do for the cleanup
-  } else {
-    // We have a new row, lets append it
-    line_table->AppendRow(state);
-  }
-}
-
-// ParseStatementTable
-//
-// Parse a line table at offset and populate the LineTable class with the
-// prologue and all rows.
-bool DWARFDebugLine::ParseStatementTable(
-    const DWARFDataExtractor &debug_line_data, lldb::offset_t *offset_ptr,
-    LineTable *line_table, DWARFUnit *dwarf_cu) {
-  return ParseStatementTable(debug_line_data, offset_ptr,
-                             ParseStatementTableCallback, line_table, dwarf_cu);
-}
-
-inline bool DWARFDebugLine::Prologue::IsValid() const {
-  return SymbolFileDWARF::SupportedVersion(version);
-}
-
-// DWARFDebugLine::Prologue::Dump
-void DWARFDebugLine::Prologue::Dump(Log *log) {
-  uint32_t i;
-
-  log->Printf("Line table prologue:");
-  log->Printf("   total_length: 0x%8.8x", total_length);
-  log->Printf("        version: %u", version);
-  log->Printf("prologue_length: 0x%8.8x", prologue_length);
-  log->Printf("min_inst_length: %u", min_inst_length);
-  log->Printf("default_is_stmt: %u", default_is_stmt);
-  log->Printf("      line_base: %i", line_base);
-  log->Printf("     line_range: %u", line_range);
-  log->Printf("    opcode_base: %u", opcode_base);
-
-  for (i = 0; i < standard_opcode_lengths.size(); ++i) {
-    log->Printf("standard_opcode_lengths[%s] = %u", DW_LNS_value_to_name(i + 1),
-                standard_opcode_lengths[i]);
-  }
-
-  if (!include_directories.empty()) {
-    for (i = 0; i < include_directories.size(); ++i) {
-      log->Printf("include_directories[%3u] = '%s'", i + 1,
-                  include_directories[i]);
-    }
-  }
-
-  if (!file_names.empty()) {
-    log->PutCString("                Dir  Mod Time   File Len   File Name");
-    log->PutCString("                ---- ---------- ---------- "
-                    "---------------------------");
-    for (i = 0; i < file_names.size(); ++i) {
-      const FileNameEntry &fileEntry = file_names[i];
-      log->Printf("file_names[%3u] %4u 0x%8.8x 0x%8.8x %s", i + 1,
-                  fileEntry.dir_idx, fileEntry.mod_time, fileEntry.length,
-                  fileEntry.name);
-    }
-  }
-}
-
-// DWARFDebugLine::ParsePrologue::Append
-//
-// Append the contents of the prologue to the binary stream buffer
-// void
-// DWARFDebugLine::Prologue::Append(BinaryStreamBuf& buff) const
-//{
-//  uint32_t i;
-//
-//  buff.Append32(total_length);
-//  buff.Append16(version);
-//  buff.Append32(prologue_length);
-//  buff.Append8(min_inst_length);
-//  buff.Append8(default_is_stmt);
-//  buff.Append8(line_base);
-//  buff.Append8(line_range);
-//  buff.Append8(opcode_base);
-//
-//  for (i=0; i<standard_opcode_lengths.size(); ++i)
-//      buff.Append8(standard_opcode_lengths[i]);
-//
-//  for (i=0; i<include_directories.size(); ++i)
-//      buff.AppendCStr(include_directories[i].c_str());
-//  buff.Append8(0);    // Terminate the include directory section with empty
-//  string
-//
-//  for (i=0; i<file_names.size(); ++i)
-//  {
-//      buff.AppendCStr(file_names[i].name.c_str());
-//      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 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, 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;
-        }
-      }
-
-      if (comp_dir)
-        file.PrependPathComponent(comp_dir);
-    }
-    return true;
-  }
-  return false;
-}
-
-void DWARFDebugLine::LineTable::AppendRow(const DWARFDebugLine::Row &state) {
-  rows.push_back(state);
-}
-
-// Compare function for the binary search in
-// DWARFDebugLine::LineTable::LookupAddress()
-static bool FindMatchingAddress(const DWARFDebugLine::Row &row1,
-                                const DWARFDebugLine::Row &row2) {
-  return row1.address < row2.address;
-}
-
-// DWARFDebugLine::LineTable::LookupAddress
-uint32_t DWARFDebugLine::LineTable::LookupAddress(dw_addr_t address,
-                                                  dw_addr_t cu_high_pc) const {
-  uint32_t index = UINT32_MAX;
-  if (!rows.empty()) {
-    // Use the lower_bound algorithm to perform a binary search since we know
-    // that our line table data is ordered by address.
-    DWARFDebugLine::Row row;
-    row.address = address;
-    Row::const_iterator begin_pos = rows.begin();
-    Row::const_iterator end_pos = rows.end();
-    Row::const_iterator pos =
-        lower_bound(begin_pos, end_pos, row, FindMatchingAddress);
-    if (pos == end_pos) {
-      if (address < cu_high_pc)
-        return rows.size() - 1;
-    } else {
-      // Rely on fact that we are using a std::vector and we can do pointer
-      // arithmetic to find the row index (which will be one less that what we
-      // found since it will find the first position after the current address)
-      // since std::vector iterators are just pointers to the container type.
-      index = pos - begin_pos;
-      if (pos->address > address) {
-        if (index > 0)
-          --index;
-        else
-          index = UINT32_MAX;
-      }
-    }
-  }
-  return index; // Failed to find address
-}
-
-// DWARFDebugLine::Row::Row
-DWARFDebugLine::Row::Row(bool default_is_stmt)
-    : address(0), line(1), column(0), file(1), is_stmt(default_is_stmt),
-      basic_block(false), end_sequence(false), prologue_end(false),
-      epilogue_begin(false), isa(0) {}
-
-// Called after a row is appended to the matrix
-void DWARFDebugLine::Row::PostAppend() {
-  basic_block = false;
-  prologue_end = false;
-  epilogue_begin = false;
-}
-
-// DWARFDebugLine::Row::Reset
-void DWARFDebugLine::Row::Reset(bool default_is_stmt) {
-  address = 0;
-  line = 1;
-  column = 0;
-  file = 1;
-  is_stmt = default_is_stmt;
-  basic_block = false;
-  end_sequence = false;
-  prologue_end = false;
-  epilogue_begin = false;
-  isa = 0;
-}
-// DWARFDebugLine::Row::Dump
-void DWARFDebugLine::Row::Dump(Log *log) const {
-  log->Printf("0x%16.16" PRIx64 " %6u %6u %6u %3u %s%s%s%s%s", address, line,
-              column, file, isa, is_stmt ? " is_stmt" : "",
-              basic_block ? " basic_block" : "",
-              prologue_end ? " prologue_end" : "",
-              epilogue_begin ? " epilogue_begin" : "",
-              end_sequence ? " end_sequence" : "");
-}
-
-// Compare function LineTable structures
-static bool AddressLessThan(const DWARFDebugLine::Row &a,
-                            const DWARFDebugLine::Row &b) {
-  return a.address < b.address;
-}
-
-// Insert a row at the correct address if the addresses can be out of order
-// which can only happen when we are linking a line table that may have had
-// it's contents rearranged.
-void DWARFDebugLine::Row::Insert(Row::collection &state_coll,
-                                 const Row &state) {
-  // If we don't have anything yet, or if the address of the last state in our
-  // line table is less than the current one, just append the current state
-  if (state_coll.empty() || AddressLessThan(state_coll.back(), state)) {
-    state_coll.push_back(state);
-  } else {
-    // Do a binary search for the correct entry
-    pair<Row::iterator, Row::iterator> range(equal_range(
-        state_coll.begin(), state_coll.end(), state, AddressLessThan));
-
-    // If the addresses are equal, we can safely replace the previous entry
-    // with the current one if the one it is replacing is an end_sequence
-    // entry. We currently always place an extra end sequence when ever we exit
-    // a valid address range for a function in case the functions get
-    // rearranged by optimizations or by order specifications. These extra end
-    // sequences will disappear by getting replaced with valid consecutive
-    // entries within a compile unit if there are no gaps.
-    if (range.first == range.second) {
-      state_coll.insert(range.first, state);
-    } else {
-      if ((distance(range.first, range.second) == 1) &&
-          range.first->end_sequence == true) {
-        *range.first = state;
-      } else {
-        state_coll.insert(range.second, state);
-      }
-    }
-  }
-}
-
-// DWARFDebugLine::State::State
-DWARFDebugLine::State::State(Prologue::shared_ptr &p, Log *l,
-                             DWARFDebugLine::State::Callback cb, void *userData)
-    : Row(p->default_is_stmt), prologue(p), log(l), callback(cb),
-      callbackUserData(userData), row(StartParsingLineTable) {
-  // Call the callback with the initial row state of zero for the prologue
-  if (callback)
-    callback(0, *this, callbackUserData);
-}
-
-// DWARFDebugLine::State::Reset
-void DWARFDebugLine::State::Reset() { Row::Reset(prologue->default_is_stmt); }
-
-// DWARFDebugLine::State::AppendRowToMatrix
-void DWARFDebugLine::State::AppendRowToMatrix(dw_offset_t offset) {
-  // Each time we are to add an entry into the line table matrix call the
-  // callback function so that someone can do something with the current state
-  // of the state machine (like build a line table or dump the line table!)
-  if (log) {
-    if (row == 0) {
-      log->PutCString("Address            Line   Column File   ISA Flags");
-      log->PutCString(
-          "------------------ ------ ------ ------ --- -------------");
-    }
-    Dump(log);
-  }
-
-  ++row; // Increase the row number before we call our callback for a real row
-  if (callback)
-    callback(offset, *this, callbackUserData);
-  PostAppend();
-}
-
-// DWARFDebugLine::State::Finalize
-void DWARFDebugLine::State::Finalize(dw_offset_t offset) {
-  // Call the callback with a special row state when we are done parsing a line
-  // table
-  row = DoneParsingLineTable;
-  if (callback)
-    callback(offset, *this, callbackUserData);
-}
-
-// void
-// DWARFDebugLine::AppendLineTableData
-//(
-//  const DWARFDebugLine::Prologue* prologue,
-//  const DWARFDebugLine::Row::collection& state_coll,
-//  const uint32_t addr_size,
-//  BinaryStreamBuf &debug_line_data
-//)
-//{
-//  if (state_coll.empty())
-//  {
-//      // We have no entries, just make an empty line table
-//      debug_line_data.Append8(0);
-//      debug_line_data.Append8(1);
-//      debug_line_data.Append8(DW_LNE_end_sequence);
-//  }
-//  else
-//  {
-//      DWARFDebugLine::Row::const_iterator pos;
-//      Row::const_iterator end = state_coll.end();
-//      bool default_is_stmt = prologue->default_is_stmt;
-//      const DWARFDebugLine::Row reset_state(default_is_stmt);
-//      const DWARFDebugLine::Row* prev_state = &reset_state;
-//      const int32_t max_line_increment_for_special_opcode =
-//      prologue->MaxLineIncrementForSpecialOpcode();
-//      for (pos = state_coll.begin(); pos != end; ++pos)
-//      {
-//          const DWARFDebugLine::Row& curr_state = *pos;
-//          int32_t line_increment  = 0;
-//          dw_addr_t addr_offset   = curr_state.address - prev_state->address;
-//          dw_addr_t addr_advance  = (addr_offset) / prologue->min_inst_length;
-//          line_increment = (int32_t)(curr_state.line - prev_state->line);
-//
-//          // If our previous state was the reset state, then let's emit the
-//          // address to keep GDB's DWARF parser happy. If we don't start each
-//          // sequence with a DW_LNE_set_address opcode, the line table won't
-//          // get slid properly in GDB.
-//
-//          if (prev_state == &reset_state)
-//          {
-//              debug_line_data.Append8(0); // Extended opcode
-//              debug_line_data.Append32_as_ULEB128(addr_size + 1); // Length of
-//              opcode bytes
-//              debug_line_data.Append8(DW_LNE_set_address);
-//              debug_line_data.AppendMax64(curr_state.address, addr_size);
-//              addr_advance = 0;
-//          }
-//
-//          if (prev_state->file != curr_state.file)
-//          {
-//              debug_line_data.Append8(DW_LNS_set_file);
-//              debug_line_data.Append32_as_ULEB128(curr_state.file);
-//          }
-//
-//          if (prev_state->column != curr_state.column)
-//          {
-//              debug_line_data.Append8(DW_LNS_set_column);
-//              debug_line_data.Append32_as_ULEB128(curr_state.column);
-//          }
-//
-//          // Don't do anything fancy if we are at the end of a sequence
-//          // as we don't want to push any extra rows since the
-//          DW_LNE_end_sequence
-//          // will push a row itself!
-//          if (curr_state.end_sequence)
-//          {
-//              if (line_increment != 0)
-//              {
-//                  debug_line_data.Append8(DW_LNS_advance_line);
-//                  debug_line_data.Append32_as_SLEB128(line_increment);
-//              }
-//
-//              if (addr_advance > 0)
-//              {
-//                  debug_line_data.Append8(DW_LNS_advance_pc);
-//                  debug_line_data.Append32_as_ULEB128(addr_advance);
-//              }
-//
-//              // Now push the end sequence on!
-//              debug_line_data.Append8(0);
-//              debug_line_data.Append8(1);
-//              debug_line_data.Append8(DW_LNE_end_sequence);
-//
-//              prev_state = &reset_state;
-//          }
-//          else
-//          {
-//              if (line_increment || addr_advance)
-//              {
-//                  if (line_increment > max_line_increment_for_special_opcode)
-//                  {
-//                      debug_line_data.Append8(DW_LNS_advance_line);
-//                      debug_line_data.Append32_as_SLEB128(line_increment);
-//                      line_increment = 0;
-//                  }
-//
-//                  uint32_t special_opcode = (line_increment >=
-//                  prologue->line_base) ? ((line_increment -
-//                  prologue->line_base) + (prologue->line_range * addr_advance)
-//                  + prologue->opcode_base) : 256;
-//                  if (special_opcode > 255)
-//                  {
-//                      // Both the address and line won't fit in one special
-//                      opcode
-//                      // check to see if just the line advance will?
-//                      uint32_t special_opcode_line = ((line_increment >=
-//                      prologue->line_base) && (line_increment != 0)) ?
-//                              ((line_increment - prologue->line_base) +
-//                              prologue->opcode_base) : 256;
-//
-//
-//                      if (special_opcode_line > 255)
-//                      {
-//                          // Nope, the line advance won't fit by itself, check
-//                          the address increment by itself
-//                          uint32_t special_opcode_addr = addr_advance ?
-//                              ((0 - prologue->line_base) +
-//                              (prologue->line_range * addr_advance) +
-//                              prologue->opcode_base) : 256;
-//
-//                          if (special_opcode_addr > 255)
-//                          {
-//                              // Neither the address nor the line will fit in
-//                              a
-//                              // special opcode, we must manually enter both
-//                              then
-//                              // do a DW_LNS_copy to push a row (special
-//                              opcode
-//                              // automatically imply a new row is pushed)
-//                              if (line_increment != 0)
-//                              {
-//                                  debug_line_data.Append8(DW_LNS_advance_line);
-//                                  debug_line_data.Append32_as_SLEB128(line_increment);
-//                              }
-//
-//                              if (addr_advance > 0)
-//                              {
-//                                  debug_line_data.Append8(DW_LNS_advance_pc);
-//                                  debug_line_data.Append32_as_ULEB128(addr_advance);
-//                              }
-//
-//                              // Now push a row onto the line table manually
-//                              debug_line_data.Append8(DW_LNS_copy);
-//
-//                          }
-//                          else
-//                          {
-//                              // The address increment alone will fit into a
-//                              special opcode
-//                              // so modify our line change, then issue a
-//                              special opcode
-//                              // for the address increment and it will push a
-//                              row into the
-//                              // line table
-//                              if (line_increment != 0)
-//                              {
-//                                  debug_line_data.Append8(DW_LNS_advance_line);
-//                                  debug_line_data.Append32_as_SLEB128(line_increment);
-//                              }
-//
-//                              // Advance of line and address will fit into a
-//                              single byte special opcode
-//                              // and this will also push a row onto the line
-//                              table
-//                              debug_line_data.Append8(special_opcode_addr);
-//                          }
-//                      }
-//                      else
-//                      {
-//                          // The line change alone will fit into a special
-//                          opcode
-//                          // so modify our address increment first, then issue
-//                          a
-//                          // special opcode for the line change and it will
-//                          push
-//                          // a row into the line table
-//                          if (addr_advance > 0)
-//                          {
-//                              debug_line_data.Append8(DW_LNS_advance_pc);
-//                              debug_line_data.Append32_as_ULEB128(addr_advance);
-//                          }
-//
-//                          // Advance of line and address will fit into a
-//                          single byte special opcode
-//                          // and this will also push a row onto the line table
-//                          debug_line_data.Append8(special_opcode_line);
-//                      }
-//                  }
-//                  else
-//                  {
-//                      // Advance of line and address will fit into a single
-//                      byte special opcode
-//                      // and this will also push a row onto the line table
-//                      debug_line_data.Append8(special_opcode);
-//                  }
-//              }
-//              prev_state = &curr_state;
-//          }
-//      }
-//  }
-//}

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

 
 #include "AppleDWARFIndex.h"
 #include "DWARFASTParser.h"
 #include "DWARFASTParserClang.h"
 #include "DWARFCompileUnit.h"
 #include "DWARFDebugAbbrev.h"
 #include "DWARFDebugAranges.h"
 #include "DWARFDebugInfo.h"
-#include "DWARFDebugLine.h"
 #include "DWARFDebugMacro.h"
 #include "DWARFDebugRanges.h"
 #include "DWARFDeclContext.h"
 #include "DWARFFormValue.h"
 #include "DWARFTypeUnit.h"
 #include "DWARFUnit.h"
 #include "DebugNamesDWARFIndex.h"
 #include "LogChannelDWARF.h"
 #include "ManualDWARFIndex.h"
 #include "SymbolFileDWARFDebugMap.h"
 #include "SymbolFileDWARFDwo.h"
 #include "SymbolFileDWARFDwp.h"
 
+#include "llvm/DebugInfo/DWARF/DWARFContext.h"
 #include "llvm/Support/FileSystem.h"
 
 #include <algorithm>
 #include <map>
 #include <memory>
 
 #include <ctype.h>
 #include <string.h>

 
 static const SymbolFileDWARFPropertiesSP &GetGlobalPluginProperties() {
   static const auto g_settings_sp(std::make_shared<PluginProperties>());
   return g_settings_sp;
 }
 
 } // anonymous namespace end
 
+static const llvm::DWARFDebugLine::LineTable *
+ParseLLVMLineTable(lldb_private::DWARFContext &context,
+                   llvm::DWARFDebugLine &line, dw_offset_t line_offset,
+                   dw_offset_t unit_offset) {
+  Log *log = LogChannelDWARF::GetLogIfAll(DWARF_LOG_DEBUG_INFO);
+
+  llvm::DWARFDataExtractor data = context.getOrLoadLineData().GetAsLLVM();
+  llvm::DWARFContext &ctx = context.GetAsLLVM();
+  llvm::Expected<const llvm::DWARFDebugLine::LineTable *> line_table =
+      line.getOrParseLineTable(
+          data, line_offset, ctx, nullptr, [&](llvm::Error e) {
+            LLDB_LOG_ERROR(log, std::move(e),
+                           "SymbolFileDWARF::ParseLineTable failed to parse");
+          });
+
+  if (!line_table) {
+    LLDB_LOG_ERROR(log, line_table.takeError(),
+                   "SymbolFileDWARF::ParseLineTable failed to parse");
+    return nullptr;
+  }
+  return *line_table;
+}
+
+static void
+ParseSupportFilesFromPrologue(const lldb::ModuleSP &module,
+                              const llvm::DWARFDebugLine::Prologue &prologue,
+                              llvm::StringRef compile_dir,
+                              FileSpecList &support_files) {
+  support_files.EmplaceBack();
+
+  const size_t number_of_files = prologue.FileNames.size();
+  for (size_t idx = 1; idx <= number_of_files; ++idx) {
+    std::string original_file;
+    if (!prologue.getFileNameByIndex(
+            idx, compile_dir,
+            llvm::DILineInfoSpecifier::FileLineInfoKind::Default,
+            original_file)) {
+      // Always add an entry so the indexes remain correct.
+      support_files.EmplaceBack();
+      continue;
+    }
+
+    std::string remapped_file;
+    if (!prologue.getFileNameByIndex(
+            idx, compile_dir,
+            llvm::DILineInfoSpecifier::FileLineInfoKind::AbsoluteFilePath,
+            remapped_file)) {
+      // Always add an entry so the indexes remain correct.
+      support_files.EmplaceBack(original_file, FileSpec::Style::native);
+      continue;
+    }
+
+    module->RemapSourceFile(llvm::StringRef(original_file), remapped_file);
+    support_files.EmplaceBack(remapped_file, FileSpec::Style::native);
+  }
+}
+
 FileSpecList SymbolFileDWARF::GetSymlinkPaths() {
   return GetGlobalPluginProperties()->GetSymLinkPaths();
 }
 
 void SymbolFileDWARF::Initialize() {
   LogChannelDWARF::Initialize();
   PluginManager::RegisterPlugin(GetPluginNameStatic(),
                                 GetPluginDescriptionStatic(), CreateInstance,
if (ParseFunction(comp_unit, die))
       ++functions_added;
   }
   // FixupTypes();
   return functions_added;
 }
 
 bool SymbolFileDWARF::ParseSupportFiles(CompileUnit &comp_unit,
                                         FileSpecList &support_files) {
-  ASSERT_MODULE_LOCK(this);
-  if (DWARFUnit *unit = GetDWARFCompileUnit(&comp_unit)) {
-    const dw_offset_t stmt_list = unit->GetLineTableOffset();
-    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(),
-                                               m_context.getOrLoadLineData(),
-                                               stmt_list, support_files, unit);
-    }
-  }
-  return false;
+  if (!comp_unit.GetLineTable())
+    ParseLineTable(comp_unit);
+  return true;
 }
 
 FileSpec SymbolFileDWARF::GetFile(DWARFUnit &unit, size_t file_idx) {
   if (auto *dwarf_cu = llvm::dyn_cast<DWARFCompileUnit>(&unit)) {
     if (CompileUnit *lldb_cu = GetCompUnitForDWARFCompUnit(*dwarf_cu))
       return lldb_cu->GetSupportFiles().GetFileSpecAtIndex(file_idx);
     return FileSpec();
   }
 
   auto &tu = llvm::cast<DWARFTypeUnit>(unit);
   return GetTypeUnitSupportFiles(tu).GetFileSpecAtIndex(file_idx);
 }
 
 const FileSpecList &
 SymbolFileDWARF::GetTypeUnitSupportFiles(DWARFTypeUnit &tu) {
   static FileSpecList empty_list;
 
   dw_offset_t offset = tu.GetLineTableOffset();
   if (offset == DW_INVALID_OFFSET ||
       offset == llvm::DenseMapInfo<dw_offset_t>::getEmptyKey() ||
       offset == llvm::DenseMapInfo<dw_offset_t>::getTombstoneKey())
     return empty_list;
 
   // Many type units can share a line table, so parse the support file list
   // once, and cache it based on the offset field.
   auto iter_bool = m_type_unit_support_files.try_emplace(offset);
   FileSpecList &list = iter_bool.first->second;
   if (iter_bool.second) {
-    list.EmplaceBack();
-    DWARFDebugLine::ParseSupportFiles(GetObjectFile()->GetModule(),
-                                      m_context.getOrLoadLineData(), offset,
-                                      list, &tu);
+    llvm::DWARFDataExtractor data = m_context.getOrLoadLineData().GetAsLLVM();
+    llvm::DWARFContext &ctx = m_context.GetAsLLVM();
+    llvm::DWARFDebugLine::Prologue prologue;
+    llvm::Error error = prologue.parse(data, &offset, ctx);
+    if (error) {
+      Log *log = LogChannelDWARF::GetLogIfAll(DWARF_LOG_DEBUG_INFO);
+      LLDB_LOG_ERROR(log, std::move(error),
+                     "SymbolFileDWARF::GetTypeUnitSupportFiles failed to parse "
+                     "the line table prologue");
+    } else {
+      ParseSupportFilesFromPrologue(GetObjectFile()->GetModule(), prologue, {},
+                                    list);
+    }
   }
   return list;
 }
 
 bool SymbolFileDWARF::ParseIsOptimized(CompileUnit &comp_unit) {
   ASSERT_MODULE_LOCK(this);
   DWARFUnit *dwarf_cu = GetDWARFCompileUnit(&comp_unit);
   if (dwarf_cu)
if (const char *name =
               DW_AT_LLVM_isysroot, nullptr))
         module.sysroot = ConstString(sysroot);
       imported_modules.push_back(module);
     }
   }
   return true;
 }
 
-struct ParseDWARFLineTableCallbackInfo {
-  LineTable *line_table;
-  std::unique_ptr<LineSequence> sequence_up;
-  lldb::addr_t addr_mask;
-};
-
-// ParseStatementTableCallback
-static void ParseDWARFLineTableCallback(dw_offset_t offset,
-                                        const DWARFDebugLine::State &state,
-                                        void *userData) {
-  if (state.row == DWARFDebugLine::State::StartParsingLineTable) {
-    // Just started parsing the line table
-  } else if (state.row == DWARFDebugLine::State::DoneParsingLineTable) {
-    // Done parsing line table, nothing to do for the cleanup
-  } else {
-    ParseDWARFLineTableCallbackInfo *info =
-        (ParseDWARFLineTableCallbackInfo *)userData;
-    LineTable *line_table = info->line_table;
-
-    // If this is our first time here, we need to create a sequence container.
-    if (!info->sequence_up) {
-      info->sequence_up.reset(line_table->CreateLineSequenceContainer());
-      assert(info->sequence_up.get());
-    }
-    line_table->AppendLineEntryToSequence(
-        info->sequence_up.get(), state.address & info->addr_mask, state.line,
-        state.column, state.file, state.is_stmt, state.basic_block,
-        state.prologue_end, state.epilogue_begin, state.end_sequence);
-    if (state.end_sequence) {
-      // First, put the current sequence into the line table.
-      line_table->InsertSequence(info->sequence_up.get());
-      // Then, empty it to prepare for the next sequence.
-      info->sequence_up->Clear();
-    }
-  }
-}
-
 bool SymbolFileDWARF::ParseLineTable(CompileUnit &comp_unit) {
   ASSERT_MODULE_LOCK(this);
   if (comp_unit.GetLineTable() != nullptr)
     return true;
 
   DWARFUnit *dwarf_cu = GetDWARFCompileUnit(&comp_unit);
-  if (dwarf_cu) {
-    const DWARFBaseDIE dwarf_cu_die = dwarf_cu->GetUnitDIEOnly();
-    if (dwarf_cu_die) {
-      const dw_offset_t cu_line_offset =
-          dwarf_cu_die.GetAttributeValueAsUnsigned(DW_AT_stmt_list,
-                                                   DW_INVALID_OFFSET);
-      if (cu_line_offset != DW_INVALID_OFFSET) {
-        std::unique_ptr<LineTable> line_table_up(new LineTable(&comp_unit));
-        if (line_table_up) {
-          ParseDWARFLineTableCallbackInfo info;
-          info.line_table = line_table_up.get();
-
-          /*
-           * MIPS:
-           * The SymbolContext may not have a valid target, thus we may not be
-           * able
-           * to call Address::GetOpcodeLoadAddress() which would clear the bit
-           * #0
-           * for MIPS. Use ArchSpec to clear the bit #0.
-          */
-          switch (GetObjectFile()->GetArchitecture().GetMachine()) {
-          case llvm::Triple::mips:
-          case llvm::Triple::mipsel:
-          case llvm::Triple::mips64:
-          case llvm::Triple::mips64el:
-            info.addr_mask = ~((lldb::addr_t)1);
-            break;
-          default:
-            info.addr_mask = ~((lldb::addr_t)0);
-            break;
-          }
+  if (!dwarf_cu)
+    return false;
+
+  if (!dwarf_cu_die)
+    return false;
+
+  const dw_offset_t cu_line_offset = dwarf_cu_die.GetAttributeValueAsUnsigned(
+      DW_AT_stmt_list, DW_INVALID_OFFSET);
+  if (cu_line_offset == DW_INVALID_OFFSET)
+    return false;
+
+  llvm::DWARFDebugLine line;
+  const llvm::DWARFDebugLine::LineTable *line_table = ParseLLVMLineTable(
+      m_context, line, cu_line_offset, dwarf_cu->GetOffset());
+
+  if (!line_table)
+    return false;
+
+  std::unique_ptr<LineTable> line_table_up =
+      llvm::make_unique<LineTable>(&comp_unit);
+  LineSequence *sequence = line_table_up->CreateLineSequenceContainer();
+  for (auto &row : line_table->Rows) {
+    line_table_up->AppendLineEntryToSequence(
+        sequence, row.Address.Address, row.Line, row.Column, row.File,
+        row.IsStmt, row.BasicBlock, row.PrologueEnd, row.EpilogueBegin,
+        row.EndSequence);
+    if (row.EndSequence) {
+      line_table_up->InsertSequence(sequence);
+      sequence = line_table_up->CreateLineSequenceContainer();
+    }
 
-          lldb::offset_t offset = cu_line_offset;
-          DWARFDebugLine::ParseStatementTable(
-              m_context.getOrLoadLineData(), &offset,
-              ParseDWARFLineTableCallback, &info, dwarf_cu);
-          SymbolFileDWARFDebugMap *debug_map_symfile = GetDebugMapSymfile();
-          if (debug_map_symfile) {
-            // We have an object file that has a line table with addresses that
-            // are not linked. We need to link the line table and convert the
-            // addresses that are relative to the .o file into addresses for
-            // the main executable.
-            comp_unit.SetLineTable(
-                debug_map_symfile->LinkOSOLineTable(this, line_table_up.get()));
-          } else {
-            comp_unit.SetLineTable(line_table_up.release());
-            return true;
-          }
-        }
-      }
-    }
-  }
-  return false;
+  if (SymbolFileDWARFDebugMap *debug_map_symfile = GetDebugMapSymfile()) {
+
+  llvm::StringRef compile_dir =
+      dwarf_cu->GetCompilationDirectory().GetCString();
+  FileSpecList support_files;
+  ParseSupportFilesFromPrologue(comp_unit.GetModule(), line_table->Prologue,
+                                compile_dir, support_files);
+  comp_unit.SetSupportFiles(support_files);
+
+  return true;
 }
 
 lldb_private::DebugMacrosSP
 SymbolFileDWARF::ParseDebugMacros(lldb::offset_t *offset) {
   auto iter = m_debug_macros_map.find(*offset);
   if (iter != m_debug_macros_map.end())
     return iter->second;
 
   const DWARFDataExtractor &debug_macro_data = m_context.getOrLoadMacroData();
   if (debug_macro_data.GetByteSize() == 0)
     return DebugMacrosSP();
 

lldb/source/Symbol/CompileUnit.cpp

 void CompileUnit::SetLineTable(LineTable *line_table) {
   if (line_table == nullptr)
     m_flags.Clear(flagsParsedLineTable);
   else
     m_flags.Set(flagsParsedLineTable);
   m_line_table_up.reset(line_table);
 }
 
+void CompileUnit::SetSupportFiles(const FileSpecList &support_files) {
+  m_support_files = support_files;
+}
+
 DebugMacros *CompileUnit::GetDebugMacros() {
   if (m_debug_macros_sp.get() == nullptr) {
     if (m_flags.IsClear(flagsParsedDebugMacros)) {
       m_flags.Set(flagsParsedDebugMacros);
       SymbolVendor *symbol_vendor = GetModule()->GetSymbolVendor();
       if (symbol_vendor) {
         symbol_vendor->ParseDebugMacros(*this);
       }