[RFC][Draft] Enable primitive support for Two-Level Line Tables in LLVM

[StephenTozer]

Summary

NOTE: This is not intended to be merged into LLVM, as the implementation is incomplete and hacked-in and is not being actively developed; the intention is simply to provide a basic working implementation that can be analyzed and potentially expanded on by any interested parties. For more information see this discourse post.

This patch implements the Two-Level Line Tables (TLLT) proposal currently aiming for Dwarf 6. This proposal allows the line table, which is DWARF's data structure used to map instructions to source locations and vice versa, to be emitted as a pair of tables instead of one, one of which maps source locations to instructions (the Logicals table) and the other of which maps instructions to source locations (the Actuals table). The proposal then extends the Logicals table by adding a context column, allowing entries in that table that represent inlined instructions to refer to another Logicals entry as being the inlined call location for that instruction, creating records for an inlined call stack in the line table and allowing the inlined callsites to be mapped to an instruction in the debugger.

This solves one of the current weaknesses in DWARF debugging, which is the inability to set breakpoints or step onto inlined callsites. However, there are other proposals (such as Location View Numbering) that could achieve the same thing, and the costs of TLLT in storage size and design complexity may make it a non-ideal solution to this problem. We currently have no plans to develop this implementation further, but this small demo may be useful to other developers who have an interest in pursuing this, and it is still possible that a good case may be made for TLLT as the best solution to the problem of representing inlined callsites.

As mentioned in the header, this patch was the result of aiming to get a basic functioning implementation in a very short time; it is not intended to be merged and is not of suitable quality, particularly in LLDB (with which we have no familiarity).

[aprantl]

Thanks for prototyping this!

[dblaikie]

Really appreciate you providing this prototype.

This solves one of the current weaknesses in DWARF debugging, which is the inability to set breakpoints or step onto inlined callsites. However, there are other proposals (such as Location View Numbering) that could achieve the same thing, and the costs of TLLT in storage size and design complexity may make it a non-ideal solution to this problem.

FWIW, one of the major motivations for this was not only to include the stop points, but also to allow symbolizing including stack frames - so you'd need to know that all the inlined instructions come from the inlined call site. I think, maybe, my vague understanding of Location View Numbering wouldn't cover that case, and only covers the "how do I describe the variable when I'm stopped at this synthetic location that exists just before or after the call", for instance?

It is unfortunate to hear that TLLT are a significant size increase, though not entirely surprising - it's a bunch of extra info to encode. I'll be glad to have this example to experiment with.

[dblaikie]

Are there any known (or vague/unknown) limitations on the implementation with respect to the actual output/on-disk representation? (like, would doing some kind of size analysis of the output when using this patch/feature lead to incorrect conclusions about the cost of the feature?)

[StephenTozer]

In D152708#4414402, @dblaikie wrote:

It is unfortunate to hear that TLLT are a significant size increase, though not entirely surprising - it's a bunch of extra info to encode. I'll be glad to have this example to experiment with.

For what it's worth, we haven't tested this with any larger programs, so this is more of a rough estimate of size, but the .debug_line section increased in size on the order of 50% for our small test cases. On the other hand, I think that in larger programs the .debug_line section is likely be significantly smaller than the .debug_info section anyway, so if you are interested in producing inline frames without using .debug_info it is probably an improvement in most respects - as an example with a single-source input, flops.c (taken from the LLVM test suite repo), the .debug_line section increased from 3338 to 4758 bytes, and the overall size of the DWARF output from 9467 to 10893.

Are there any known (or vague/unknown) limitations on the implementation with respect to the actual output/on-disk representation?

This patch should follow the spec faithfully - it was written over the span of 4 days so doubtless there are inefficiencies in the program itself and there may be bugs in the output (especially if you try it on a larger codebase), but in theory the output should be an accurate representation of the proposal. With that said, the main cause of the size increase isn't really the amount of additional information encoded, but the fact that the TLLT format does repeat itself a lot by design; generally speaking most instructions are not inlined callsites, and so the additional information for those lines (the context and subprogram fields) has a much smaller impact on size than the fact that we are emitting the (InstructionAddress, SourceLocation) pair twice for every instruction.

We didn't dig deeper into why the representation needs to be split into two separate line number programs rather than either a single line table with some additional column to convey the Instruction->SourceLocation attribution, or keeping two line tables but using a single line number program that can emit Logical and Actual rows simultaneously. Either of these methods would reduce the repetition.

clang/include/clang/Basic/CodeGenOptions.def

 CODEGENOPT(FatalWarnings     , 1, 0) ///< Set when -Wa,--fatal-warnings is
                                      ///< enabled.
 CODEGENOPT(NoWarn            , 1, 0) ///< Set when -Wa,--no-warn is enabled.
 CODEGENOPT(NoTypeCheck       , 1, 0) ///< Set when -Wa,--no-type-check is enabled.
 CODEGENOPT(MisExpect         , 1, 0) ///< Set when -Wmisexpect is enabled
 CODEGENOPT(EnableSegmentedStacks , 1, 0) ///< Set when -fsplit-stack is enabled.
 CODEGENOPT(NoInlineLineTables, 1, 0) ///< Whether debug info should contain
                                      ///< inline line tables.
+CODEGENOPT(EnableTwoLevelLineTables, 1, 0) ///< Emit Two Level Line Tables
 CODEGENOPT(StackClashProtector, 1, 0) ///< Set when -fstack-clash-protection is enabled.
 CODEGENOPT(NoImplicitFloat   , 1, 0) ///< Set when -mno-implicit-float is enabled.
 CODEGENOPT(NullPointerIsValid , 1, 0) ///< Assume Null pointer deference is defined.
 CODEGENOPT(OpenCLCorrectlyRoundedDivSqrt, 1, 0) ///< -cl-fp32-correctly-rounded-divide-sqrt
 CODEGENOPT(HIPCorrectlyRoundedDivSqrt, 1, 1) ///< -fno-hip-fp32-correctly-rounded-divide-sqrt
 CODEGENOPT(HIPSaveKernelArgName, 1, 0) ///< Set when -fhip-kernel-arg-name is enabled.
 CODEGENOPT(UniqueInternalLinkageNames, 1, 0) ///< Internal Linkage symbols get unique names.
 CODEGENOPT(SplitMachineFunctions, 1, 0) ///< Split machine functions using profile information.

clang/include/clang/Driver/Options.td

defm codeview_command_line : BoolOption<"g", "codeview-command-line",
   CodeGenOpts<"CodeViewCommandLine">, DefaultTrue,
   PosFlag<SetTrue, [], "Emit compiler path and command line into CodeView debug information">,
   NegFlag<SetFalse, [], "Don't emit compiler path and command line into CodeView debug information">,
   BothFlags<[CoreOption, CC1Option]>>;
 defm inline_line_tables : BoolGOption<"inline-line-tables",
   CodeGenOpts<"NoInlineLineTables">, DefaultFalse,
   NegFlag<SetTrue, [CC1Option], "Don't emit inline line tables.">,
   PosFlag<SetFalse>, BothFlags<[CoreOption]>>;
+defm two_level_line_tables : BoolGOption<"two-level-line-tables",
+  CodeGenOpts<"EnableTwoLevelLineTables">, DefaultFalse,
+  PosFlag<SetTrue, [CC1Option]>, NegFlag<SetFalse>, BothFlags<[CoreOption]>>;
 
 def gfull : Flag<["-"], "gfull">, Group<g_Group>;
 def gused : Flag<["-"], "gused">, Group<g_Group>;
 def gstabs : Joined<["-"], "gstabs">, Group<g_Group>, Flags<[Unsupported]>;
 def gcoff : Joined<["-"], "gcoff">, Group<g_Group>, Flags<[Unsupported]>;
 def gxcoff : Joined<["-"], "gxcoff">, Group<g_Group>, Flags<[Unsupported]>;
 def gvms : Joined<["-"], "gvms">, Group<g_Group>, Flags<[Unsupported]>;
 def gtoggle : Flag<["-"], "gtoggle">, Group<g_flags_Group>, Flags<[Unsupported]>;

clang/lib/CodeGen/BackendUtil.cpp

static bool initTargetOptions(DiagnosticsEngine &Diags,
   Options.EnableAIXExtendedAltivecABI = LangOpts.EnableAIXExtendedAltivecABI;
   Options.XRayOmitFunctionIndex = CodeGenOpts.XRayOmitFunctionIndex;
   Options.LoopAlignment = CodeGenOpts.LoopAlignment;
   Options.DebugStrictDwarf = CodeGenOpts.DebugStrictDwarf;
   Options.ObjectFilenameForDebug = CodeGenOpts.ObjectFilenameForDebug;
   Options.Hotpatch = CodeGenOpts.HotPatch;
   Options.JMCInstrument = CodeGenOpts.JMCInstrument;
   Options.XCOFFReadOnlyPointers = CodeGenOpts.XCOFFReadOnlyPointers;
+  Options.EnableTwoLevelLineTables = CodeGenOpts.EnableTwoLevelLineTables;
 
   switch (CodeGenOpts.getSwiftAsyncFramePointer()) {
   case CodeGenOptions::SwiftAsyncFramePointerKind::Auto:
     Options.SwiftAsyncFramePointer =
         SwiftAsyncFramePointerMode::DeploymentBased;
     break;
 
   case CodeGenOptions::SwiftAsyncFramePointerKind::Always:

clang/lib/CodeGen/ObjectFilePCHContainerOperations.cpp

PCHContainerGenerator(CompilerInstance &CI, const std::string &MainFileName,
     // When building a module MainFileName is the name of the modulemap file.
     CodeGenOpts.MainFileName =
         LangOpts.CurrentModule.empty() ? MainFileName : LangOpts.CurrentModule;
     CodeGenOpts.setDebugInfo(llvm::codegenoptions::FullDebugInfo);
     CodeGenOpts.setDebuggerTuning(CI.getCodeGenOpts().getDebuggerTuning());
     CodeGenOpts.DebugPrefixMap =
         CI.getInvocation().getCodeGenOpts().DebugPrefixMap;
     CodeGenOpts.DebugStrictDwarf = CI.getCodeGenOpts().DebugStrictDwarf;
+    CodeGenOpts.EnableTwoLevelLineTables =
+        CI.getCodeGenOpts().EnableTwoLevelLineTables;
   }
 
   ~PCHContainerGenerator() override = default;
 
   void Initialize(ASTContext &Context) override {
     assert(!Ctx && "initialized multiple times");
 
     Ctx = &Context;

clang/lib/Driver/ToolChains/Clang.cpp

renderDebugOptions(const ToolChain &TC, const Driver &D, const llvm::Triple &T,
   // strict DWARF is set to false by default. But for DBX, we need it to be set
   // as true by default.
   if (const Arg *A = Args.getLastArg(options::OPT_gstrict_dwarf))
     (void)checkDebugInfoOption(A, Args, D, TC);
   if (Args.hasFlag(options::OPT_gstrict_dwarf, options::OPT_gno_strict_dwarf,
                    DebuggerTuning == llvm::DebuggerKind::DBX))
     CmdArgs.push_back("-gstrict-dwarf");
 
+  if (const Arg *A = Args.getLastArg(options::OPT_gtwo_level_line_tables))
+    (void)checkDebugInfoOption(A, Args, D, TC);
+  if (Args.hasFlag(options::OPT_gtwo_level_line_tables,
+                   options::OPT_gnotwo_level_line_tables, false))
+    CmdArgs.push_back("-gtwo-level-line-tables");
+
   // And we handle flag -grecord-gcc-switches later with DWARFDebugFlags.
   Args.ClaimAllArgs(options::OPT_g_flags_Group);
 
   // Column info is included by default for everything except SCE and
   // CodeView. Clang doesn't track end columns, just starting columns, which,
   // in theory, is fine for CodeView (and PDB).  In practice, however, the
   // Microsoft debuggers don't handle missing end columns well, and the AIX
   // debugger DBX also doesn't handle the columns well, so it's better not to

lldb/include/lldb/Symbol/LineTable.h

public:
 
   /// Construct with entries found in \a sequences.
   ///
   /// \param[in] sequences
   ///     Unsorted list of line sequences.
   LineTable(CompileUnit *comp_unit,
             std::vector<std::unique_ptr<LineSequence>> &&sequences);
 
+  /// TLLT: Construct with entries.
+  ///
+  /// \param[in] sequences
+  ///     Unsorted list of line sequences.
+  LineTable(CompileUnit *comp_unit,
+            std::vector<std::unique_ptr<LineSequence>> &&logicals,
+            std::vector<std::unique_ptr<LineSequence>> &&actuals);
+
   /// Destructor.
   ~LineTable();
 
   /// Adds a new line entry to this line table.
   ///
   /// All line entries are maintained in file address order.
   ///
   /// \param[in] line_entry
void InsertLineEntry(lldb::addr_t file_addr, uint32_t line, uint16_t column,
                        bool is_start_of_basic_block, bool is_prologue_end,
                        bool is_epilogue_begin, bool is_terminal_entry);
 
   // Used to instantiate the LineSequence helper class
   static std::unique_ptr<LineSequence> CreateLineSequenceContainer();
 
   // Append an entry to a caller-provided collection that will later be
   // inserted in this line table.
-  static void AppendLineEntryToSequence(LineSequence *sequence, lldb::addr_t file_addr,
-                                 uint32_t line, uint16_t column,
-                                 uint16_t file_idx, bool is_start_of_statement,
-                                 bool is_start_of_basic_block,
-                                 bool is_prologue_end, bool is_epilogue_begin,
-                                 bool is_terminal_entry);
+  static void
+  AppendLineEntryToSequence(LineSequence *sequence, lldb::addr_t file_addr,
+                            uint32_t line, uint16_t column, uint16_t file_idx,
+                            bool is_start_of_statement,
+                            bool is_start_of_basic_block, bool is_prologue_end,
+                            bool is_epilogue_begin, bool is_terminal_entry,
+                            bool merge_adjacent_equ_file_addr = true);
 
   // Insert a sequence of entries into this line table.
   void InsertSequence(LineSequence *sequence);
 
   /// Dump all line entries in this line table to the stream \a s.
   ///
   /// \param[in] s
   ///     The stream to which to dump the object description.
#undef SCALAR_COMPARE
     /// of a sequence of target machine instructions.
     uint32_t is_terminal_entry : 1;
     /// The column number of the source line, or zero if there is no
     /// column information.
     uint16_t column = 0;
     /// The file index into CompileUnit's file table, or zero if there
     /// is no file information.
     uint16_t file_idx = 0;
+    /// TLLT Context.
+    uint32_t Context;
+    /// TLLT TODO: FunctionName.
   };
 
 protected:
   struct EntrySearchInfo {
     LineTable *line_table;
     lldb_private::Section *a_section;
     Entry *a_entry;
   };
 
   // Types
   typedef std::vector<lldb_private::Section *>
       section_collection; ///< The collection type for the sections.
   typedef std::vector<Entry>
       entry_collection; ///< The collection type for the line entries.
   // Member variables.
   CompileUnit
       *m_comp_unit; ///< The compile unit that this line table belongs to.
   entry_collection
       m_entries; ///< The collection of line entries in this line table.
 
+  entry_collection &get_default_table() {
+    if (m_isTLLT)
+      return m_TLLTLogicals;
+    return m_entries;
+  }
+
+  // TLLT NOTE: Very experimental stuff here.
+  entry_collection m_TLLTLogicals; //< Logicals table entries.
+  entry_collection m_TLLTActuals;  //< Actuals table entries.
+
+  bool m_isTLLT = false;
+
   // Helper class
   class LineSequenceImpl : public LineSequence {
   public:
     LineSequenceImpl() = default;
 
     ~LineSequenceImpl() override = default;
 
     void Clear() override;
 
     entry_collection
         m_entries; ///< The collection of line entries in this sequence.
   };
 
   bool ConvertEntryAtIndexToLineEntry(uint32_t idx, LineEntry &line_entry);
 
 private:
   LineTable(const LineTable &) = delete;
   const LineTable &operator=(const LineTable &) = delete;
 
   template <typename T>
   uint32_t FindLineEntryIndexByFileIndexImpl(
       uint32_t start_idx, T file_idx,
       const SourceLocationSpec &src_location_spec, LineEntry *line_entry_ptr,
       std::function<bool(T, uint16_t)> file_idx_matcher) {
-    const size_t count = m_entries.size();
+    auto &table = get_default_table();
+    const size_t count = table.size();
     size_t best_match = UINT32_MAX;
 
     if (!line_entry_ptr)
       return best_match;
 
     const uint32_t line = src_location_spec.GetLine().value_or(0);
     const uint16_t column =
         src_location_spec.GetColumn().value_or(LLDB_INVALID_COLUMN_NUMBER);
     const bool exact_match = src_location_spec.GetExactMatch();
 
     for (size_t idx = start_idx; idx < count; ++idx) {
       // Skip line table rows that terminate the previous row (is_terminal_entry
       // is non-zero)
-      if (m_entries[idx].is_terminal_entry)
+      if (table[idx].is_terminal_entry)
         continue;
 
-      if (!file_idx_matcher(file_idx, m_entries[idx].file_idx))
+      if (!file_idx_matcher(file_idx, table[idx].file_idx))
         continue;
 
       // Exact match always wins.  Otherwise try to find the closest line > the
       // desired line.
       // FIXME: Maybe want to find the line closest before and the line closest
       // after and if they're not in the same function, don't return a match.
 
       if (column == LLDB_INVALID_COLUMN_NUMBER) {
-        if (m_entries[idx].line < line) {
+        if (table[idx].line < line) {
           continue;
-        } else if (m_entries[idx].line == line) {
+        } else if (table[idx].line == line) {
           ConvertEntryAtIndexToLineEntry(idx, *line_entry_ptr);
           return idx;
         } else if (!exact_match) {
           if (best_match == UINT32_MAX ||
-              m_entries[idx].line < m_entries[best_match].line)
+              table[idx].line < table[best_match].line)
             best_match = idx;
         }
       } else {
-        if (m_entries[idx].line < line) {
+        if (table[idx].line < line) {
           continue;
-        } else if (m_entries[idx].line == line &&
-                   m_entries[idx].column == column) {
+        } else if (table[idx].line == line &&
+                   table[idx].column == column) {
           ConvertEntryAtIndexToLineEntry(idx, *line_entry_ptr);
           return idx;
         } else if (!exact_match) {
           if (best_match == UINT32_MAX)
             best_match = idx;
-          else if (m_entries[idx].line < m_entries[best_match].line)
+          else if (table[idx].line < table[best_match].line)
             best_match = idx;
-          else if (m_entries[idx].line == m_entries[best_match].line)
-            if (m_entries[idx].column &&
-                m_entries[idx].column < m_entries[best_match].column)
+          else if (table[idx].line == table[best_match].line)
+            if (table[idx].column &&
+                table[idx].column < table[best_match].column)
               best_match = idx;
         }
       }
     }
 
     if (best_match != UINT32_MAX) {
       if (line_entry_ptr)
         ConvertEntryAtIndexToLineEntry(best_match, *line_entry_ptr);

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

bool SymbolFileDWARF::ParseLineTable(CompileUnit &comp_unit) {
   ElapsedTime elapsed(m_parse_time);
   llvm::DWARFDebugLine line;
   const llvm::DWARFDebugLine::LineTable *line_table =
       ParseLLVMLineTable(m_context, line, offset, dwarf_cu->GetOffset());
 
   if (!line_table)
     return false;
 
+  std::unique_ptr<LineTable> line_table_up;
+  if (line_table->isTLLT()) {
+    // TLLT Note: This is experimental / untested!
+    std::vector<std::unique_ptr<LineSequence>> logicals_sequences;
+    std::vector<std::unique_ptr<LineSequence>> actuals_sequences;
+
+    // Logicals:
+    for (const llvm::DWARFDebugLine::Sequence &seq : line_table->Sequences) {
+      // TLLT FIXME: Do we want to do what this comment below says? Or do we
+      // want to ignore addresses, so that we can find all inline contexts?
+      // I think it doesn't matter for setting a breakpoint but will matter for
+      // stepping.
+
+      // Ignore line sequences that do not start after the first code address.
+      // All addresses generated in a sequence are incremental so we only need
+      // to check the first one of the sequence. Check the comment at the
+      // m_first_code_address declaration for more details on this.
+      if (seq.LowPC < m_first_code_address)
+        continue;
+      std::unique_ptr<LineSequence> sequence =
+          LineTable::CreateLineSequenceContainer();
+      for (unsigned idx = seq.FirstRowIndex; idx < seq.LastRowIndex; ++idx) {
+        const llvm::DWARFDebugLine::Row &row = line_table->getRows(
+            llvm::DWARFDebugLine::LineTableType::LogicalTable)[idx];
+        LineTable::AppendLineEntryToSequence(
+            sequence.get(), row.Address.Address, row.Line, row.Column, row.File,
+            row.IsStmt, row.BasicBlock, row.PrologueEnd, row.EpilogueBegin,
+            row.EndSequence, /*merge_adjacent_equ_file_addr*/ false);
+      }
+      logicals_sequences.push_back(std::move(sequence));
+    }
+
+    // Actuals:
+    for (const llvm::DWARFDebugLine::Sequence &seq : line_table->Sequences) {
+      // Ignore line sequences that do not start after the first code address.
+      // All addresses generated in a sequence are incremental so we only need
+      // to check the first one of the sequence. Check the comment at the
+      // m_first_code_address declaration for more details on this.
+      if (seq.LowPC < m_first_code_address)
+        continue;
+      std::unique_ptr<LineSequence> sequence =
+          LineTable::CreateLineSequenceContainer();
+      for (unsigned idx = seq.FirstRowIndex; idx < seq.LastRowIndex; ++idx) {
+        const llvm::DWARFDebugLine::Row &row = line_table->getRows(
+            llvm::DWARFDebugLine::LineTableType::ActualTable)[idx];
+        LineTable::AppendLineEntryToSequence(
+            sequence.get(), row.Address.Address, row.Line, row.Column, row.File,
+            row.IsStmt, row.BasicBlock, row.PrologueEnd, row.EpilogueBegin,
+            row.EndSequence, /*merge_adjacent_equ_file_addr*/ true);
+      }
+      actuals_sequences.push_back(std::move(sequence));
+    }
+
+    line_table_up =
+        std::make_unique<LineTable>(&comp_unit, std::move(logicals_sequences),
+                                    std::move(actuals_sequences));
+  } else {
     // FIXME: Rather than parsing the whole line table and then copying it over
     // into LLDB, we should explore using a callback to populate the line table
     // while we parse to reduce memory usage.
     std::vector<std::unique_ptr<LineSequence>> sequences;
     // The Sequences view contains only valid line sequences. Don't iterate over
     // the Rows directly.
     for (const llvm::DWARFDebugLine::Sequence &seq : line_table->Sequences) {
       // Ignore line sequences that do not start after the first code address.
       // All addresses generated in a sequence are incremental so we only need
       // to check the first one of the sequence. Check the comment at the
       // m_first_code_address declaration for more details on this.
       if (seq.LowPC < m_first_code_address)
         continue;
       std::unique_ptr<LineSequence> sequence =
           LineTable::CreateLineSequenceContainer();
       for (unsigned idx = seq.FirstRowIndex; idx < seq.LastRowIndex; ++idx) {
-      const llvm::DWARFDebugLine::Row &row = line_table->Rows[idx];
+        const llvm::DWARFDebugLine::Row &row = line_table->getRows(
+            llvm::DWARFDebugLine::LineTableType::SingleLevelLineTable)[idx];
         LineTable::AppendLineEntryToSequence(
             sequence.get(), row.Address.Address, row.Line, row.Column, row.File,
             row.IsStmt, row.BasicBlock, row.PrologueEnd, row.EpilogueBegin,
             row.EndSequence);
       }
       sequences.push_back(std::move(sequence));
     }
 
-  std::unique_ptr<LineTable> line_table_up =
+    line_table_up =
         std::make_unique<LineTable>(&comp_unit, std::move(sequences));
+  }
 
+  assert(line_table_up);
   if (SymbolFileDWARFDebugMap *debug_map_symfile = GetDebugMapSymfile()) {
-    // 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.
+    // 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;
 }
 
 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;

lldb/source/Symbol/LineTable.cpp

 
 LineTable::LineTable(CompileUnit *comp_unit,
                      std::vector<std::unique_ptr<LineSequence>> &&sequences)
     : m_comp_unit(comp_unit), m_entries() {
   LineTable::Entry::LessThanBinaryPredicate less_than_bp(this);
   llvm::stable_sort(sequences, less_than_bp);
   for (const auto &sequence : sequences) {
     LineSequenceImpl *seq = static_cast<LineSequenceImpl *>(sequence.get());
-    m_entries.insert(m_entries.end(), seq->m_entries.begin(),
+    get_default_table().insert(get_default_table().end(),
+                               seq->m_entries.begin(), seq->m_entries.end());
+  }
+}
+
+LineTable::LineTable(CompileUnit *comp_unit,
+                     std::vector<std::unique_ptr<LineSequence>> &&logicals,
+                     std::vector<std::unique_ptr<LineSequence>> &&actuals)
+    : m_comp_unit(comp_unit), m_TLLTLogicals(), m_TLLTActuals(),
+      m_isTLLT(true) {
+  LineTable::Entry::LessThanBinaryPredicate less_than_bp(this);
+
+  // TLLT: Do not re-order the logicals table or everything will be broken
+  // since actuals use row-based index into it. Furthermore, the address-order
+  // of these entries shouldn't matter since stepping will use the actuals
+  // table rather than logical.
+  // NOTE: This probably causes loads of assumption violations in LLDB so we'll
+  // have to be really careful here.
+  // llvm::stable_sort(logicals, less_than_bp);
+
+  for (const auto &sequence : logicals) {
+    LineSequenceImpl *seq = static_cast<LineSequenceImpl *>(sequence.get());
+    m_TLLTLogicals.insert(m_TLLTLogicals.end(), seq->m_entries.begin(),
+                          seq->m_entries.end());
+  }
+  // It's okay to sort the actuals table.
+  llvm::stable_sort(actuals, less_than_bp);
+  for (const auto &sequence : actuals) {
+    LineSequenceImpl *seq = static_cast<LineSequenceImpl *>(sequence.get());
+    m_TLLTActuals.insert(m_TLLTActuals.end(), seq->m_entries.begin(),
                          seq->m_entries.end());
   }
 }
 
 // Destructor
 LineTable::~LineTable() = default;
 
 void LineTable::InsertLineEntry(lldb::addr_t file_addr, uint32_t line,
                                 uint16_t column, uint16_t file_idx,
                                 bool is_start_of_statement,
                                 bool is_start_of_basic_block,
                                 bool is_prologue_end, bool is_epilogue_begin,
                                 bool is_terminal_entry) {
   Entry entry(file_addr, line, column, file_idx, is_start_of_statement,
               is_start_of_basic_block, is_prologue_end, is_epilogue_begin,
               is_terminal_entry);
 
   LineTable::Entry::LessThanBinaryPredicate less_than_bp(this);
   entry_collection::iterator pos =
-      llvm::upper_bound(m_entries, entry, less_than_bp);
+      llvm::upper_bound(get_default_table(), entry, less_than_bp);
 
   //  Stream s(stdout);
   //  s << "\n\nBefore:\n";
   //  Dump (&s, Address::DumpStyleFileAddress);
-  m_entries.insert(pos, entry);
+  get_default_table().insert(pos, entry);
   //  s << "After:\n";
   //  Dump (&s, Address::DumpStyleFileAddress);
 }
 
 LineSequence::LineSequence() = default;
 
 void LineTable::LineSequenceImpl::Clear() { m_entries.clear(); }
 
 std::unique_ptr<LineSequence> LineTable::CreateLineSequenceContainer() {
   return std::make_unique<LineTable::LineSequenceImpl>();
 }
 
 void LineTable::AppendLineEntryToSequence(
     LineSequence *sequence, lldb::addr_t file_addr, uint32_t line,
     uint16_t column, uint16_t file_idx, bool is_start_of_statement,
     bool is_start_of_basic_block, bool is_prologue_end, bool is_epilogue_begin,
-    bool is_terminal_entry) {
+    bool is_terminal_entry, bool merge_adjacent_equ_file_addr) {
   assert(sequence != nullptr);
   LineSequenceImpl *seq = reinterpret_cast<LineSequenceImpl *>(sequence);
   Entry entry(file_addr, line, column, file_idx, is_start_of_statement,
               is_start_of_basic_block, is_prologue_end, is_epilogue_begin,
               is_terminal_entry);
   entry_collection &entries = seq->m_entries;
   // Replace the last entry if the address is the same, otherwise append it. If
   // we have multiple line entries at the same address, this!indicates illegal
   // DWARF so this "fixes" the line table to be correct. If not fixed this can
   // cause a line entry's address that when resolved back to a symbol context,
   // could resolve to a different line entry. We really want a
   // 1 to 1 mapping
   // here to avoid these kinds of inconsistencies. We will need tor revisit
   // this if the DWARF line tables are updated to allow multiple entries at the
   // same address legally.
-  if (!entries.empty() && entries.back().file_addr == file_addr) {
+
+  // TLLT: merge_adjacent_equ_file_addr is false for the logicals table, in
+  // which we expect to see entries with the same file_addr (e.g. both for an
+  // inlined call site and the inlined source line).
+  if (merge_adjacent_equ_file_addr && !entries.empty() &&
+      entries.back().file_addr == file_addr) {
     // GCC don't use the is_prologue_end flag to mark the first instruction
     // after the prologue.
     // Instead of it it is issuing a line table entry for the first instruction
     // of the prologue and one for the first instruction after the prologue. If
     // the size of the prologue is 0 instruction then the 2 line entry will
     // have the same file address. Removing it will remove our ability to
     // properly detect the location of the end of prologe so we set the
     // prologue_end flag to preserve this information (setting the prologue_end
     // flag for an entry what is after the prologue end don't have any effect)
     entry.is_prologue_end = entry.file_idx == entries.back().file_idx;
     entries.back() = entry;
   } else
     entries.push_back(entry);
 }
 
 void LineTable::InsertSequence(LineSequence *sequence) {
   assert(sequence != nullptr);
   LineSequenceImpl *seq = reinterpret_cast<LineSequenceImpl *>(sequence);
   if (seq->m_entries.empty())
     return;
   Entry &entry = seq->m_entries.front();
 
   // If the first entry address in this sequence is greater than or equal to
   // the address of the last item in our entry collection, just append.
-  if (m_entries.empty() ||
-      !Entry::EntryAddressLessThan(entry, m_entries.back())) {
-    m_entries.insert(m_entries.end(), seq->m_entries.begin(),
-                     seq->m_entries.end());
+  if (get_default_table().empty() ||
+      !Entry::EntryAddressLessThan(entry, get_default_table().back())) {
+    get_default_table().insert(get_default_table().end(),
+                               seq->m_entries.begin(), seq->m_entries.end());
     return;
   }
 
   // Otherwise, find where this belongs in the collection
-  entry_collection::iterator begin_pos = m_entries.begin();
-  entry_collection::iterator end_pos = m_entries.end();
+  entry_collection::iterator begin_pos = get_default_table().begin();
+  entry_collection::iterator end_pos = get_default_table().end();
   LineTable::Entry::LessThanBinaryPredicate less_than_bp(this);
   entry_collection::iterator pos =
       upper_bound(begin_pos, end_pos, entry, less_than_bp);
 
   // We should never insert a sequence in the middle of another sequence
   if (pos != begin_pos) {
     while (pos < end_pos && !((pos - 1)->is_terminal_entry))
       pos++;
   }
 
 #ifndef NDEBUG
   // If we aren't inserting at the beginning, the previous entry should
   // terminate a sequence.
   if (pos != begin_pos) {
     entry_collection::iterator prev_pos = pos - 1;
     assert(prev_pos->is_terminal_entry);
   }
 #endif
-  m_entries.insert(pos, seq->m_entries.begin(), seq->m_entries.end());
+  get_default_table().insert(pos, seq->m_entries.begin(), seq->m_entries.end());
 }
 
 LineTable::Entry::LessThanBinaryPredicate::LessThanBinaryPredicate(
     LineTable *line_table)
     : m_line_table(line_table) {}
 
 bool LineTable::Entry::LessThanBinaryPredicate::
 operator()(const LineTable::Entry &a, const LineTable::Entry &b) const {
operator()(const std::unique_ptr<LineSequence> &sequence_a,
   auto *seq_a = static_cast<const LineSequenceImpl *>(sequence_a.get());
   auto *seq_b = static_cast<const LineSequenceImpl *>(sequence_b.get());
   return (*this)(seq_a->m_entries.front(), seq_b->m_entries.front());
 }
 
 uint32_t LineTable::GetSize() const { return m_entries.size(); }
 
 bool LineTable::GetLineEntryAtIndex(uint32_t idx, LineEntry &line_entry) {
-  if (idx < m_entries.size()) {
+  if (idx < get_default_table().size()) {
     ConvertEntryAtIndexToLineEntry(idx, line_entry);
     return true;
   }
   line_entry.Clear();
   return false;
 }
 
 bool LineTable::FindLineEntryByAddress(const Address &so_addr,
                                        LineEntry &line_entry,
                                        uint32_t *index_ptr) {
   if (index_ptr != nullptr)
     *index_ptr = UINT32_MAX;
 
   bool success = false;
 
   if (so_addr.GetModule().get() == m_comp_unit->GetModule().get()) {
     Entry search_entry;
     search_entry.file_addr = so_addr.GetFileAddress();
     if (search_entry.file_addr != LLDB_INVALID_ADDRESS) {
-      entry_collection::const_iterator begin_pos = m_entries.begin();
-      entry_collection::const_iterator end_pos = m_entries.end();
+      entry_collection::const_iterator begin_pos = get_default_table().begin();
+      entry_collection::const_iterator end_pos = get_default_table().end();
       entry_collection::const_iterator pos = lower_bound(
           begin_pos, end_pos, search_entry, Entry::EntryAddressLessThan);
       if (pos != end_pos) {
         if (pos != begin_pos) {
           if (pos->file_addr != search_entry.file_addr)
             --pos;
           else if (pos->file_addr == search_entry.file_addr) {
             // If this is a termination entry, it shouldn't match since entries
if (search_entry.file_addr != LLDB_INVALID_ADDRESS) {
       }
     }
   }
   return success;
 }
 
 bool LineTable::ConvertEntryAtIndexToLineEntry(uint32_t idx,
                                                LineEntry &line_entry) {
-  if (idx >= m_entries.size())
+  if (idx >= get_default_table().size())
     return false;
 
-  const Entry &entry = m_entries[idx];
+  const Entry &entry = get_default_table()[idx];
   ModuleSP module_sp(m_comp_unit->GetModule());
   if (!module_sp)
     return false;
 
   addr_t file_addr = entry.file_addr;
 
   // A terminal entry can point outside of a module or a section. Decrement the
   // address to ensure it resolves correctly.
   if (entry.is_terminal_entry)
     --file_addr;
 
   if (!module_sp->ResolveFileAddress(file_addr,
                                      line_entry.range.GetBaseAddress()))
     return false;
 
   // Now undo the decrement above.
   if (entry.is_terminal_entry)
     line_entry.range.GetBaseAddress().Slide(1);
 
-  if (!entry.is_terminal_entry && idx + 1 < m_entries.size())
-    line_entry.range.SetByteSize(m_entries[idx + 1].file_addr -
+  if (!entry.is_terminal_entry && idx + 1 < get_default_table().size())
+    line_entry.range.SetByteSize(get_default_table()[idx + 1].file_addr -
                                  entry.file_addr);
   else
     line_entry.range.SetByteSize(0);
 
   line_entry.file =
       m_comp_unit->GetSupportFiles().GetFileSpecAtIndex(entry.file_idx);
   line_entry.original_file =
       m_comp_unit->GetSupportFiles().GetFileSpecAtIndex(entry.file_idx);

 
 size_t LineTable::FindLineEntriesForFileIndex(uint32_t file_idx, bool append,
                                               SymbolContextList &sc_list) {
 
   if (!append)
     sc_list.Clear();
 
   size_t num_added = 0;
-  const size_t count = m_entries.size();
+  const size_t count = get_default_table().size();
   if (count > 0) {
     SymbolContext sc(m_comp_unit);
 
     for (size_t idx = 0; idx < count; ++idx) {
       // Skip line table rows that terminate the previous row
       // (is_terminal_entry is non-zero)
-      if (m_entries[idx].is_terminal_entry)
+      if (get_default_table()[idx].is_terminal_entry)
         continue;
 
-      if (m_entries[idx].file_idx == file_idx) {
+      if (get_default_table()[idx].file_idx == file_idx) {
         if (ConvertEntryAtIndexToLineEntry(idx, sc.line_entry)) {
           ++num_added;
           sc_list.Append(sc);
         }
       }
     }
   }
   return num_added;
 }
 
 void LineTable::Dump(Stream *s, Target *target, Address::DumpStyle style,
                      Address::DumpStyle fallback_style, bool show_line_ranges) {
-  const size_t count = m_entries.size();
+  const size_t count = get_default_table().size();
   LineEntry line_entry;
   FileSpec prev_file;
   for (size_t idx = 0; idx < count; ++idx) {
     ConvertEntryAtIndexToLineEntry(idx, line_entry);
     line_entry.Dump(s, target, prev_file != line_entry.original_file, style,
                     fallback_style, show_line_ranges);
     s->EOL();
     prev_file = line_entry.original_file;
   }
 }
 
 void LineTable::GetDescription(Stream *s, Target *target,
                                DescriptionLevel level) {
-  const size_t count = m_entries.size();
+  const size_t count = get_default_table().size();
   LineEntry line_entry;
   for (size_t idx = 0; idx < count; ++idx) {
     ConvertEntryAtIndexToLineEntry(idx, line_entry);
     line_entry.GetDescription(s, level, m_comp_unit, target, true);
     s->EOL();
   }
 }
 
 size_t LineTable::GetContiguousFileAddressRanges(FileAddressRanges &file_ranges,
                                                  bool append) {
   if (!append)
     file_ranges.Clear();
   const size_t initial_count = file_ranges.GetSize();
 
-  const size_t count = m_entries.size();
+  const size_t count = get_default_table().size();
   LineEntry line_entry;
   FileAddressRanges::Entry range(LLDB_INVALID_ADDRESS, 0);
   for (size_t idx = 0; idx < count; ++idx) {
-    const Entry &entry = m_entries[idx];
+    const Entry &entry = get_default_table()[idx];
 
     if (entry.is_terminal_entry) {
       if (range.GetRangeBase() != LLDB_INVALID_ADDRESS) {
         range.SetRangeEnd(entry.file_addr);
         file_ranges.Append(range);
         range.Clear(LLDB_INVALID_ADDRESS);
       }
     } else if (range.GetRangeBase() == LLDB_INVALID_ADDRESS) {
       range.SetRangeBase(entry.file_addr);
     }
   }
   return file_ranges.GetSize() - initial_count;
 }
 
 LineTable *LineTable::LinkLineTable(const FileRangeMap &file_range_map) {
   std::unique_ptr<LineTable> line_table_up(new LineTable(m_comp_unit));
   LineSequenceImpl sequence;
-  const size_t count = m_entries.size();
+  const size_t count = get_default_table().size();
   LineEntry line_entry;
   const FileRangeMap::Entry *file_range_entry = nullptr;
   const FileRangeMap::Entry *prev_file_range_entry = nullptr;
   lldb::addr_t prev_file_addr = LLDB_INVALID_ADDRESS;
   bool prev_entry_was_linked = false;
   bool range_changed = false;
   for (size_t idx = 0; idx < count; ++idx) {
-    const Entry &entry = m_entries[idx];
+    const Entry &entry = get_default_table()[idx];
 
     const bool end_sequence = entry.is_terminal_entry;
     const lldb::addr_t lookup_file_addr =
         entry.file_addr - (end_sequence ? 1 : 0);
     if (file_range_entry == nullptr ||
         !file_range_entry->Contains(lookup_file_addr)) {
       prev_file_range_entry = file_range_entry;
       file_range_entry = file_range_map.FindEntryThatContains(lookup_file_addr);
if (!sequence.m_entries.empty() &&
       sequence.Clear();
       prev_entry_was_linked = false;
     } else {
       prev_entry_was_linked = file_range_entry != nullptr;
     }
     prev_file_addr = entry.file_addr;
     range_changed = false;
   }
-  if (line_table_up->m_entries.empty())
+  if (line_table_up->get_default_table().empty())
     return nullptr;
   return line_table_up.release();
 }

llvm/include/llvm/BinaryFormat/Dwarf.def

 HANDLE_DW_CC(0xff, GDB_IBM_OpenCL)
 
 // Line Number Extended Opcode Encodings
 HANDLE_DW_LNE(0x01, end_sequence)
 HANDLE_DW_LNE(0x02, set_address)
 HANDLE_DW_LNE(0x03, define_file)
 // New in DWARF v4:
 HANDLE_DW_LNE(0x04, set_discriminator)
+// Experimental, proposed for DWARF v6:
+HANDLE_DW_LNE(0x05, set_function_name)
 
 // Line Number Standard Opcode Encodings.
 HANDLE_DW_LNS(0x00, extended_op)
 HANDLE_DW_LNS(0x01, copy)
 HANDLE_DW_LNS(0x02, advance_pc)
 HANDLE_DW_LNS(0x03, advance_line)
 HANDLE_DW_LNS(0x04, set_file)
 HANDLE_DW_LNS(0x05, set_column)
 HANDLE_DW_LNS(0x06, negate_stmt)
 HANDLE_DW_LNS(0x07, set_basic_block)
 HANDLE_DW_LNS(0x08, const_add_pc)
 HANDLE_DW_LNS(0x09, fixed_advance_pc)
 // New in DWARF v3:
 HANDLE_DW_LNS(0x0a, set_prologue_end)
 HANDLE_DW_LNS(0x0b, set_epilogue_begin)
 HANDLE_DW_LNS(0x0c, set_isa)
+// Experimental, proposed for DWARF v6:
+HANDLE_DW_LNS(0x0d, inlined_call)
 
 // DWARF v5 Line number header entry format.
 HANDLE_DW_LNCT(0x01, path)
 HANDLE_DW_LNCT(0x02, directory_index)
 HANDLE_DW_LNCT(0x03, timestamp)
 HANDLE_DW_LNCT(0x04, size)
 HANDLE_DW_LNCT(0x05, MD5)
 // A vendor extension until http://dwarfstd.org/ShowIssue.php?issue=180201.1 is

llvm/include/llvm/CodeGen/CommandFlags.h

 bool getEnableAddrsig();
 
 bool getEmitCallSiteInfo();
 
 bool getEnableMachineFunctionSplitter();
 
 bool getEnableDebugEntryValues();
 
+bool getEnableTwoLevelLineTables();
+
 bool getValueTrackingVariableLocations();
 std::optional<bool> getExplicitValueTrackingVariableLocations();
 
 bool getForceDwarfFrameSection();
 
 bool getXRayOmitFunctionIndex();
 
 bool getDebugStrictDwarf();

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

 #include <vector>
 
 namespace llvm {
 
 class raw_ostream;
 
 class DWARFDebugLine {
 public:
+  enum class LineTableType {
+    SingleLevelLineTable,
+    LogicalTable,
+    ActualTable,
+  };
+
   struct FileNameEntry {
     FileNameEntry() = default;
 
     DWARFFormValue Name;
     uint64_t DirIdx = 0;
     uint64_t ModTime = 0;
     uint64_t Length = 0;
     MD5::MD5Result Checksum;
struct Prologue {
     uint64_t TotalLength;
     /// Version, address size (starting in v5), and DWARF32/64 format; these
     /// parameters affect interpretation of forms (used in the directory and
     /// file tables starting with v5).
     dwarf::FormParams FormParams;
     /// The number of bytes following the prologue_length field to the beginning
     /// of the first byte of the statement program itself.
     uint64_t PrologueLength;
+    /// In v6, the number of bytes following the first byte of the Logical
+    /// statement program to the first byte of the Actuals statement program if
+    /// this is a TLLT, or 0 otherwise.
+    uint64_t LogicalTableLength;
+    /// In v6, the format of the function name register in the Logical statement
+    /// program.
+    dwarf::Form FunctionNameForm;
     /// In v5, size in bytes of a segment selector.
     uint8_t SegSelectorSize;
     /// 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 MinInstLength;
     /// The maximum number of individual operations that may be encoded in an
     /// instruction.
public:
   /// Standard .debug_line state machine structure.
   struct Row {
     explicit Row(bool DefaultIsStmt = false);
 
     /// Called after a row is appended to the matrix.
     void postAppend();
     void reset(bool DefaultIsStmt);
     void dump(raw_ostream &OS) const;
+    void dumpLogical(raw_ostream &OS) const;
+    void dumpActual(raw_ostream &OS) const;
 
     static void dumpTableHeader(raw_ostream &OS, unsigned Indent);
+    static void dumpLogicalTableHeader(raw_ostream &OS, unsigned Indent);
+    static void dumpActualTableHeader(raw_ostream &OS, unsigned Indent);
 
     static bool orderByAddress(const Row &LHS, const Row &RHS) {
       return std::tie(LHS.Address.SectionIndex, LHS.Address.Address) <
              std::tie(RHS.Address.SectionIndex, RHS.Address.Address);
     }
 
+    /// The row index that this occupies in the Logical table if it is a Logical
+    /// row, or zero otherwise.
+    uint32_t LogicalIndex;
+    /// The logical index that this is inlined at.
+    uint32_t Context;
+    /// The offset into .debug_line_str of this inlined instruction's function
+    /// name, or 0 otherwise.
+    DWARFFormValue SubprogramOffset;
     /// The program-counter value corresponding to a machine instruction
     /// generated by the compiler and section index pointing to the section
     /// containg this PC. If relocation information is present then section
     /// index is the index of the section which contains above address.
     /// Otherwise this is object::SectionedAddress::Undef value.
     object::SectionedAddress Address;
     /// 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
uint8_t IsStmt : 1,
         /// many) where execution should be suspended for an exit breakpoint
         /// of a function.
         EpilogueBegin : 1;
   };
 
   /// Represents a series of contiguous machine instructions. Line table for
   /// each compilation unit may consist of multiple sequences, which are not
   /// guaranteed to be in the order of ascending instruction address.
+  /// Applies to either the Single-Level Line Table or the Actuals table.
   struct Sequence {
     Sequence();
 
     /// Sequence describes instructions at address range [LowPC, HighPC)
     /// and is described by line table rows [FirstRowIndex, LastRowIndex).
     uint64_t LowPC;
     uint64_t HighPC;
     /// If relocation information is present then this is the index of the
public:
   };
 
   struct LineTable {
     LineTable();
 
     /// Represents an invalid row
     const uint32_t UnknownRowIndex = UINT32_MAX;
 
-    void appendRow(const DWARFDebugLine::Row &R) { Rows.push_back(R); }
+    void appendRow(const DWARFDebugLine::Row &R, LineTableType Type) {
+      getRows(Type).push_back(R);
+    }
 
     void appendSequence(const DWARFDebugLine::Sequence &S) {
       Sequences.push_back(S);
     }
 
     /// Returns the index of the row with file/line info for a given address,
     /// or UnknownRowIndex if there is no such row.
     uint32_t lookupAddress(object::SectionedAddress Address) const;
bool getFileLineInfoForAddress(object::SectionedAddress Address,
                                    DILineInfoSpecifier::FileLineInfoKind Kind,
                                    DILineInfo &Result) const;
 
     /// Extracts directory name by its Entry in include directories table
     /// in prologue. Returns true on success.
     bool getDirectoryForEntry(const FileNameEntry &Entry,
                               std::string &Directory) const;
 
+    bool isTLLT() const { return Prologue.LogicalTableLength != 0; }
+
     void dump(raw_ostream &OS, DIDumpOptions DumpOptions) const;
     void clear();
 
     /// Parse prologue and all rows.
     Error parse(DWARFDataExtractor &DebugLineData, uint64_t *OffsetPtr,
                 const DWARFContext &Ctx, const DWARFUnit *U,
                 function_ref<void(Error)> RecoverableErrorHandler,
                 raw_ostream *OS = nullptr, bool Verbose = false);
 
     using RowVector = std::vector<Row>;
     using RowIter = RowVector::const_iterator;
     using SequenceVector = std::vector<Sequence>;
     using SequenceIter = SequenceVector::const_iterator;
 
+    const RowVector &getRows(LineTableType RowType) const {
+      if (RowType == LineTableType::SingleLevelLineTable)
+        return SLLTRows;
+      if (RowType == LineTableType::LogicalTable)
+        return LogicalRows;
+      if (RowType == LineTableType::ActualTable)
+        return ActualRows;
+      llvm_unreachable("Unsupported line table type");
+    }
+    RowVector &getRows(LineTableType RowType) {
+      if (RowType == LineTableType::SingleLevelLineTable)
+        return SLLTRows;
+      if (RowType == LineTableType::LogicalTable)
+        return LogicalRows;
+      if (RowType == LineTableType::ActualTable)
+        return ActualRows;
+      llvm_unreachable("Unsupported line table type");
+    }
+
     struct Prologue Prologue;
-    RowVector Rows;
+    RowVector SLLTRows;
+    RowVector LogicalRows;
+    RowVector ActualRows;
     SequenceVector Sequences;
 
   private:
     uint32_t findRowInSeq(const DWARFDebugLine::Sequence &Seq,
                           object::SectionedAddress Address) const;
     std::optional<StringRef>
     getSourceByIndex(uint64_t FileIndex,
                      DILineInfoSpecifier::FileLineInfoKind Kind) const;
public:
   };
 
 private:
   struct ParsingState {
     ParsingState(struct LineTable *LT, uint64_t TableOffset,
                  function_ref<void(Error)> ErrorHandler);
 
     void resetRowAndSequence();
-    void appendRowToMatrix();
+    void appendRowToMatrix(LineTableType RowType);
 
     /// Advance the address by the \p OperationAdvance value. \returns the
     /// amount advanced by.
     uint64_t advanceAddr(uint64_t OperationAdvance, uint8_t Opcode,
                          uint64_t OpcodeOffset);
 
     struct AddrAndAdjustedOpcode {
       uint64_t AddrDelta;

llvm/include/llvm/DebugInfo/DWARF/DWARFFormValue.h

public:
   static DWARFFormValue createFromBlockValue(dwarf::Form F,
                                              ArrayRef<uint8_t> D);
   static DWARFFormValue createFromUnit(dwarf::Form F, const DWARFUnit *Unit,
                                        uint64_t *OffsetPtr);
 
   dwarf::Form getForm() const { return Form; }
   uint64_t getRawUValue() const { return Value.uval; }
 
+  void setContextAndUnit(const DWARFContext *c, const DWARFUnit *u) { U = u; C = c; }
+
   bool isFormClass(FormClass FC) const;
   const DWARFUnit *getUnit() const { return U; }
   void dump(raw_ostream &OS, DIDumpOptions DumpOpts = DIDumpOptions()) const;
   void dumpSectionedAddress(raw_ostream &OS, DIDumpOptions DumpOpts,
                             object::SectionedAddress SA) const;
   void dumpAddress(raw_ostream &OS, uint64_t Address) const;
   static void dumpAddress(raw_ostream &OS, uint8_t AddressSize,
                           uint64_t Address);

llvm/include/llvm/MC/MCContext.h

private:
   /// size of each line table, the files and directories used by each compile
   /// unit are separated.
   std::map<unsigned, MCDwarfLineTable> MCDwarfLineTablesCUMap;
 
   /// The current dwarf line information from the last dwarf .loc directive.
   MCDwarfLoc CurrentDwarfLoc;
   bool DwarfLocSeen = false;
 
+  SmallVector<MCDwarfLoc> CurrentDwarfLogicalLocs;
+
+  MCDwarfLoc CurrentDwarfActualLoc;
+  bool DwarfActualLocSeen = false;
+
   /// Generate dwarf debugging info for assembly source files.
   bool GenDwarfForAssembly = false;
 
   /// The current dwarf file number when generate dwarf debugging info for
   /// assembly source files.
   unsigned GenDwarfFileNumber = 0;
 
   /// Sections for generating the .debug_ranges and .debug_aranges sections.
private:
 
   /// The string to embed in as the dwarf AT_producer for the compile unit, if
   /// non-empty.
   StringRef DwarfDebugProducer;
 
   /// The maximum version of dwarf that we should emit.
   uint16_t DwarfVersion = 4;
 
+  bool EnableTwoLevelLineTables = false;
+
   /// The format of dwarf that we emit.
   dwarf::DwarfFormat DwarfFormat = dwarf::DWARF32;
 
   /// Honor temporary labels, this is useful for debugging semantic
   /// differences between temporary and non-temporary labels (primarily on
   /// Darwin).
   bool AllowTemporaryLabels = true;
   bool UseNamesOnTempLabels = false;
void setCurrentDwarfLoc(unsigned FileNum, unsigned Line, unsigned Column,
                           unsigned Flags, unsigned Isa,
                           unsigned Discriminator) {
     CurrentDwarfLoc.setFileNum(FileNum);
     CurrentDwarfLoc.setLine(Line);
     CurrentDwarfLoc.setColumn(Column);
     CurrentDwarfLoc.setFlags(Flags);
     CurrentDwarfLoc.setIsa(Isa);
     CurrentDwarfLoc.setDiscriminator(Discriminator);
+    CurrentDwarfLoc.setContext(0);
+    CurrentDwarfLoc.setFunctionName("");
     DwarfLocSeen = true;
   }
 
+  /// TLLT - Set info for logicals table entry.
+  /// FIXME: Merge this with setCurrentDwarfLoc?
+  void addCurrentDwarfLogicalLoc(unsigned FileNum, unsigned Line,
+                                 unsigned Column, unsigned Flags, unsigned Isa,
+                                 unsigned Discriminator, unsigned Context,
+                                 StringRef FunctionName) {
+    MCDwarfLoc Loc;
+    Loc.setFileNum(FileNum);
+    Loc.setLine(Line);
+    Loc.setColumn(Column);
+    Loc.setFlags(Flags);
+    Loc.setIsa(Isa);
+    Loc.setDiscriminator(Discriminator);
+    Loc.setContext(Context);
+    Loc.setFunctionName(FunctionName);
+    CurrentDwarfLogicalLocs.push_back(Loc);
+  }
+
+  /// TLLT - Set info for actuals table entry.
+  /// FIXME: Do we need FileNum?
+  void setCurrentDwarfActualLoc(unsigned Line, unsigned Flags) {
+    CurrentDwarfActualLoc.setFileNum(0);
+    CurrentDwarfActualLoc.setLine(Line);
+    CurrentDwarfActualLoc.setColumn(0);
+    CurrentDwarfActualLoc.setFlags(Flags);
+    CurrentDwarfActualLoc.setIsa(0);
+    CurrentDwarfActualLoc.setDiscriminator(0);
+    CurrentDwarfActualLoc.setContext(0);
+    CurrentDwarfActualLoc.setFunctionName("");
+    DwarfActualLocSeen = true;
+  }
+
   void clearDwarfLocSeen() { DwarfLocSeen = false; }
 
   bool getDwarfLocSeen() { return DwarfLocSeen; }
   const MCDwarfLoc &getCurrentDwarfLoc() { return CurrentDwarfLoc; }
 
+  void clearDwarfLogicalLocsSeen() { CurrentDwarfLogicalLocs.clear(); }
+  bool getDwarfLogicalLocsSeen() { return !CurrentDwarfLogicalLocs.empty(); }
+  const SmallVectorImpl<MCDwarfLoc> &getCurrentDwarfLogicalsLoc() {
+    return CurrentDwarfLogicalLocs;
+  }
+
+  void clearDwarfActualLocSeen() { DwarfActualLocSeen = false; }
+  bool getDwarfActualLocSeen() { return DwarfActualLocSeen; }
+  const MCDwarfLoc &getCurrentDwarfActualLoc() { return CurrentDwarfActualLoc; }
+
   bool getGenDwarfForAssembly() { return GenDwarfForAssembly; }
   void setGenDwarfForAssembly(bool Value) { GenDwarfForAssembly = Value; }
   unsigned getGenDwarfFileNumber() { return GenDwarfFileNumber; }
   EmitDwarfUnwindType emitDwarfUnwindInfo() const;
 
   void setGenDwarfFileNumber(unsigned FileNumber) {
     GenDwarfFileNumber = FileNumber;
   }
public:
   StringRef getDwarfDebugProducer() { return DwarfDebugProducer; }
 
   void setDwarfFormat(dwarf::DwarfFormat f) { DwarfFormat = f; }
   dwarf::DwarfFormat getDwarfFormat() const { return DwarfFormat; }
 
   void setDwarfVersion(uint16_t v) { DwarfVersion = v; }
   uint16_t getDwarfVersion() const { return DwarfVersion; }
 
+  void setEnableTwoLevelLineTables(bool tllt) {
+    EnableTwoLevelLineTables = tllt;
+  }
+  bool getEnableTwoLevelLineTables() const { return EnableTwoLevelLineTables; }
+
   /// @}
 
   StringRef getSecureLogFile() { return SecureLogFile; }
   raw_fd_ostream *getSecureLog() { return SecureLog.get(); }
 
   void setSecureLog(std::unique_ptr<raw_fd_ostream> Value) {
     SecureLog = std::move(Value);
   }

llvm/include/llvm/MC/MCDwarf.h

 //===- MCDwarf.h - Machine Code Dwarf support -------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file contains the declaration of the MCDwarfFile to support the dwarf
 // .file directive and the .loc directive.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_MC_MCDWARF_H
 #define LLVM_MC_MCDWARF_H
 
+#include "llvm/ADT/DenseMapInfo.h"
 #include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringRef.h"
+#include "llvm/IR/DebugInfoMetadata.h"
+#include "llvm/IR/Metadata.h"
 #include "llvm/MC/StringTableBuilder.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/MD5.h"
 #include "llvm/Support/StringSaver.h"
 #include <cassert>
 #include <cstdint>
 #include <optional>
 #include <string>
 #include <utility>
 #include <vector>
 
 namespace llvm {
 
 template <typename T> class ArrayRef;
+class AsmPrinter;
 class MCAsmBackend;
 class MCContext;
 class MCObjectStreamer;
 class MCSection;
 class MCStreamer;
 class MCSymbol;
 class raw_ostream;
 class SMLoc;
public:
   /// Construct an instance that can emit .debug_line_str (for use in a normal
   /// v5 line table).
   explicit MCDwarfLineStr(MCContext &Ctx);
 
   StringSaver &getSaver() { return Saver; }
 
   /// Emit a reference to the string.
   void emitRef(MCStreamer *MCOS, StringRef Path);
+  /// Add the string to .debug_line_str and return a reference to it.
+  size_t getRef(MCStreamer *MCOS, StringRef Path);
 
   /// Emit the .debug_line_str section if appropriate.
   void emitSection(MCStreamer *MCOS);
 
   /// Returns finalized section.
   SmallString<0> getFinalizedData();
 };
 

 class MCDwarfLoc {
   uint32_t FileNum;
   uint32_t Line;
   uint16_t Column;
   // Flags (see #define's below)
   uint8_t Flags;
   uint8_t Isa;
   uint32_t Discriminator;
+  uint32_t Context;
+  StringRef FunctionName;
 
 // Flag that indicates the initial value of the is_stmt_start flag.
 #define DWARF2_LINE_DEFAULT_IS_STMT 1
 
 #define DWARF2_FLAG_IS_STMT (1 << 0)
 #define DWARF2_FLAG_BASIC_BLOCK (1 << 1)
 #define DWARF2_FLAG_PROLOGUE_END (1 << 2)
 #define DWARF2_FLAG_EPILOGUE_BEGIN (1 << 3)
 
 private: // MCContext manages these
   friend class MCContext;
   friend class MCDwarfLineEntry;
+  // Allow the default copy constructor and assignment operator to be used
+  // for an MCDwarfLoc object.
 
+public:
+  // TLLT FIXME: This was private - and should probably be returned to private.
   MCDwarfLoc(unsigned fileNum, unsigned line, unsigned column, unsigned flags,
-             unsigned isa, unsigned discriminator)
+             unsigned isa, unsigned discriminator, unsigned Context = 0,
+             StringRef FunctionName = StringRef())
       : FileNum(fileNum), Line(line), Column(column), Flags(flags), Isa(isa),
-        Discriminator(discriminator) {}
+        Discriminator(discriminator), Context(Context),
+        FunctionName(FunctionName) {}
 
-  // Allow the default copy constructor and assignment operator to be used
-  // for an MCDwarfLoc object.
+  MCDwarfLoc() = default; ///< TLLT: For usage in containers.
+  static MCDwarfLoc getTombstoneKey() {
+    return MCDwarfLoc(-1, -1, -1, -1, -1, -1, -1);
+  }
+  static MCDwarfLoc getEmptyKey() {
+    return MCDwarfLoc(-2, -2, -2, -2, -2, -2, -2);
+  }
+  friend DenseMapInfo<MCDwarfLoc>;
 
-public:
   /// Get the FileNum of this MCDwarfLoc.
   unsigned getFileNum() const { return FileNum; }
 
   /// Get the Line of this MCDwarfLoc.
   unsigned getLine() const { return Line; }
 
   /// Get the Column of this MCDwarfLoc.
   unsigned getColumn() const { return Column; }
 
   /// Get the Flags of this MCDwarfLoc.
   unsigned getFlags() const { return Flags; }
 
   /// Get the Isa of this MCDwarfLoc.
   unsigned getIsa() const { return Isa; }
 
   /// Get the Discriminator of this MCDwarfLoc.
   unsigned getDiscriminator() const { return Discriminator; }
 
+  /// Get the Context of this MCDwarfLoc.
+  unsigned getContext() const { return Context; }
+
+  /// Get the FunctionName of this MCDwarfLoc.
+  StringRef getFunctionName() const { return FunctionName; }
+
   /// Set the FileNum of this MCDwarfLoc.
   void setFileNum(unsigned fileNum) { FileNum = fileNum; }
 
   /// Set the Line of this MCDwarfLoc.
   void setLine(unsigned line) { Line = line; }
 
   /// Set the Column of this MCDwarfLoc.
   void setColumn(unsigned column) {
void setIsa(unsigned isa) {
     assert(isa <= UINT8_MAX);
     Isa = isa;
   }
 
   /// Set the Discriminator of this MCDwarfLoc.
   void setDiscriminator(unsigned discriminator) {
     Discriminator = discriminator;
   }
+
+  /// Set the Context of this MCDwarfLoc.
+  void setContext(unsigned context) {
+    Context = context;
+  }
+
+  /// Set the FunctionName of this MCDwarfLoc.
+  void setFunctionName(StringRef functionName) { FunctionName = functionName; }
+};
+
+template <> struct DenseMapInfo<MCDwarfLoc> {
+  static inline MCDwarfLoc getEmptyKey() { return MCDwarfLoc::getEmptyKey(); }
+  static inline MCDwarfLoc getTombstoneKey() {
+    return MCDwarfLoc::getTombstoneKey();
+  }
+  static unsigned getHashValue(const MCDwarfLoc &Val) {
+    return hash_combine(Val.getFileNum(), Val.Line, Val.Column, Val.Flags,
+                        Val.Isa, Val.Discriminator, Val.Context);
+  }
+  static bool isEqual(const MCDwarfLoc &LHS, const MCDwarfLoc &RHS) {
+    return LHS.FileNum == RHS.FileNum && LHS.Line == RHS.Line &&
+           LHS.Column == RHS.Column && LHS.Flags == RHS.Flags &&
+           LHS.Isa == RHS.Isa && LHS.Discriminator == RHS.Discriminator &&
+           LHS.Context == RHS.Context;
+    // TLLT Note: FunctionName should be equal if Context is equal,
+    // so we shouldn't need to compare it.
+  }
 };
 
 /// Instances of this class represent the line information for
 /// the dwarf line table entries.  Which is created after a machine
 /// instruction is assembled and uses an address from a temporary label
 /// created at the current address in the current section and the info from
 /// the last .loc directive seen as stored in the context.
 class MCDwarfLineEntry : public MCDwarfLoc {

 /// directives.  This is the information used to build the dwarf line
 /// table for a section.
 class MCLineSection {
 public:
   // Add an entry to this MCLineSection's line entries.
   void addLineEntry(const MCDwarfLineEntry &LineEntry, MCSection *Sec) {
     MCLineDivisions[Sec].push_back(LineEntry);
   }
+  void addActualLineEntry(const MCDwarfLineEntry &LineEntry, MCSection *Sec) {
+    MCActualLineDivisions[Sec].push_back(LineEntry);
+  }
+  void addLogicalLineEntry(const MCDwarfLineEntry &LineEntry, MCSection *Sec) {
+    MCLogicalLineDivisions[Sec].push_back(LineEntry);
+  }
 
   // Add an end entry by cloning the last entry, if exists, for the section
   // the given EndLabel belongs to. The label is replaced by the given EndLabel.
   void addEndEntry(MCSymbol *EndLabel);
 
   using MCDwarfLineEntryCollection = std::vector<MCDwarfLineEntry>;
   using iterator = MCDwarfLineEntryCollection::iterator;
   using const_iterator = MCDwarfLineEntryCollection::const_iterator;
   using MCLineDivisionMap = MapVector<MCSection *, MCDwarfLineEntryCollection>;
 
 private:
   // A collection of MCDwarfLineEntry for each section.
   MCLineDivisionMap MCLineDivisions;
+  MCLineDivisionMap MCLogicalLineDivisions;
+  MCLineDivisionMap MCActualLineDivisions;
 
 public:
   // Returns the collection of MCDwarfLineEntry for a given Compile Unit ID.
   const MCLineDivisionMap &getMCLineEntries() const {
     return MCLineDivisions;
   }
+  const MCLineDivisionMap &getMCLogicalLineEntries() const {
+    return MCLogicalLineDivisions;
+  }
+  const MCLineDivisionMap &getMCActualLineEntries() const {
+    return MCActualLineDivisions;
+  }
 };
 
 struct MCDwarfLineTableParams {
   /// First special line opcode - leave room for the standard opcodes.
   /// Note: If you want to change this, you'll have to update the
   /// "StandardOpcodeLengths" table that is emitted in
   /// \c Emit().
-  uint8_t DWARF2LineOpcodeBase = 13;
+  uint8_t DWARF2LineOpcodeBase = 14;
   /// Minimum line offset in a special line info. opcode.  The value
   /// -5 was chosen to give a reasonable range of values.
   int8_t DWARF2LineBase = -5;
   /// Range of line offsets in a special line info. opcode.
   uint8_t DWARF2LineRange = 14;
 };
 
 struct MCDwarfLineTableHeader {

 
 public:
   MCDwarfLineTableHeader() = default;
 
   Expected<unsigned> tryGetFile(StringRef &Directory, StringRef &FileName,
                                 std::optional<MD5::MD5Result> Checksum,
                                 std::optional<StringRef> Source,
                                 uint16_t DwarfVersion, unsigned FileNumber = 0);
-  std::pair<MCSymbol *, MCSymbol *>
+  std::tuple<MCSymbol *, MCSymbol *, MCSymbol *>
   Emit(MCStreamer *MCOS, MCDwarfLineTableParams Params,
        std::optional<MCDwarfLineStr> &LineStr) const;
-  std::pair<MCSymbol *, MCSymbol *>
+  std::tuple<MCSymbol *, MCSymbol *, MCSymbol *>
   Emit(MCStreamer *MCOS, MCDwarfLineTableParams Params,
        ArrayRef<char> SpecialOpcodeLengths,
        std::optional<MCDwarfLineStr> &LineStr) const;
   void resetMD5Usage() {
     HasAllMD5 = true;
     HasAnyMD5 = false;
   }
   void trackMD5Usage(bool MD5Used) {
public:
 
   // This emits the Dwarf file and the line tables for a given Compile Unit.
   void emitCU(MCStreamer *MCOS, MCDwarfLineTableParams Params,
               std::optional<MCDwarfLineStr> &LineStr) const;
 
   // This emits a single line table associated with a given Section.
   static void
   emitOne(MCStreamer *MCOS, MCSection *Section,
-          const MCLineSection::MCDwarfLineEntryCollection &LineEntries);
+          const MCLineSection::MCDwarfLineEntryCollection &LineEntries,
+          std::optional<MCDwarfLineStr> &LineStr);
 
   Expected<unsigned> tryGetFile(StringRef &Directory, StringRef &FileName,
                                 std::optional<MD5::MD5Result> Checksum,
                                 std::optional<StringRef> Source,
                                 uint16_t DwarfVersion, unsigned FileNumber = 0);
   unsigned getFile(StringRef &Directory, StringRef &FileName,
                    std::optional<MD5::MD5Result> Checksum,
                    std::optional<StringRef> Source, uint16_t DwarfVersion,

llvm/include/llvm/MC/MCStreamer.h

public:
 
   /// This implements the DWARF2 '.loc fileno lineno ...' assembler
   /// directive.
   virtual void emitDwarfLocDirective(unsigned FileNo, unsigned Line,
                                      unsigned Column, unsigned Flags,
                                      unsigned Isa, unsigned Discriminator,
                                      StringRef FileName);
 
+  virtual void
+  emitDwarfLogicalLocDirective(unsigned FileNo, unsigned Line, unsigned Column,
+                               unsigned Flags, unsigned Isa,
+                               unsigned Discriminator, StringRef FileName,
+                               unsigned Context, StringRef FunctionName);
+  virtual void emitDwarfActualLocDirective(unsigned Line, unsigned Flags);
+
   /// Associate a filename with a specified logical file number, and also
   /// specify that file's checksum information.  This implements the '.cv_file 4
   /// "foo.c"' assembler directive. Returns true on success.
   virtual bool emitCVFileDirective(unsigned FileNo, StringRef Filename,
                                    ArrayRef<uint8_t> Checksum,
                                    unsigned ChecksumKind);
 
   /// Introduces a function id for use with .cv_loc.

llvm/include/llvm/Target/TargetOptions.h

TargetOptions()
           FunctionSections(false), DataSections(false),
           IgnoreXCOFFVisibility(false), XCOFFTracebackTable(true),
           UniqueSectionNames(true), UniqueBasicBlockSectionNames(false),
           TrapUnreachable(false), NoTrapAfterNoreturn(false), TLSSize(0),
           EmulatedTLS(false), EnableIPRA(false), EmitStackSizeSection(false),
           EnableMachineOutliner(false), EnableMachineFunctionSplitter(false),
           SupportsDefaultOutlining(false), EmitAddrsig(false),
           EmitCallSiteInfo(false), SupportsDebugEntryValues(false),
-          EnableDebugEntryValues(false), ValueTrackingVariableLocations(false),
+          EnableDebugEntryValues(false), EnableTwoLevelLineTables(false),
+          ValueTrackingVariableLocations(false),
           ForceDwarfFrameSection(false), XRayOmitFunctionIndex(false),
           DebugStrictDwarf(false), Hotpatch(false),
           PPCGenScalarMASSEntries(false), JMCInstrument(false),
           EnableCFIFixup(false), MisExpect(false), XCOFFReadOnlyPointers(false),
           FPDenormalMode(DenormalMode::IEEE, DenormalMode::IEEE) {}
 
     /// DisableFramePointerElim - This returns true if frame pointer elimination
     /// optimization should be disabled for the given machine function.
public:
     /// something else, so that should be controlled in the frontend.
     unsigned EmitCallSiteInfo : 1;
     /// Set if the target supports the debug entry values by default.
     unsigned SupportsDebugEntryValues : 1;
     /// When set to true, the EnableDebugEntryValues option forces production
     /// of debug entry values even if the target does not officially support
     /// it. Useful for testing purposes only. This flag should never be checked
     /// directly, always use \ref ShouldEmitDebugEntryValues instead.
-     unsigned EnableDebugEntryValues : 1;
     /// NOTE: There are targets that still do not support the debug entry values
     /// production.
     bool ShouldEmitDebugEntryValues() const;
 
+    unsigned EnableTwoLevelLineTables : 1;
+
     // When set to true, use experimental new debug variable location tracking,
     // which seeks to follow the values of variables rather than their location,
     // post isel.
     unsigned ValueTrackingVariableLocations : 1;
 
     /// Emit DWARF debug frame section.
     unsigned ForceDwarfFrameSection : 1;
 

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.h

enum class AccelTableKind {
   Default, ///< Platform default.
   None,    ///< None.
   Apple,   ///< .apple_names, .apple_namespaces, .apple_types, .apple_objc.
   Dwarf,   ///< DWARF v5 .debug_names.
 };
 
 /// Collects and handles dwarf debug information.
 class DwarfDebug : public DebugHandlerBase {
+  /// TLLT: Current logical location table size.
+  unsigned LogicalsTableSize = 0;
+  /// TLLT: The logical line number associated with the current actual entry.
+  unsigned LastActualEntryLogicalLineRefernce = 0;
+  /// TLLT: Look-up map for existing logical locations.
+  DenseMap<MCDwarfLoc, uint64_t> LogicalsLookup;
+  /// TLLT: Look-up map for inlined call site logical locations.
+  DenseMap<const DILocation *, uint64_t> LogicalsContextLookup;
+
+  /// Reset TLLT state.
+  void TLLTReset();
+  /// Called from TLLTGetOrCreateLogicalsEntryIdx to recursively create logicals
+  /// entries. Does not update the index for the last logical entry; that should
+  /// be set from the caller so that only the outermost line is remembered.
+  uint32_t TLLTGetOrCreateLogicalsEntryIdxImpl(
+      unsigned DwarfVersion, AsmPrinter *Asm, unsigned Line, unsigned Column,
+      unsigned Flags, unsigned Isa, const MDNode *Scope,
+      const DILocation *InlinedAt, DwarfCompileUnit *CU);
+
+public:
+  /// Create a TLLT logical entry if one doesn't already exist for this
+  /// location. Recursively create logical entries for inline callsites if
+  /// needed.
+  uint32_t TLLTGetOrCreateLogicalsEntryIdx(unsigned DwarfVersion,
+                                           AsmPrinter *Asm, unsigned Line,
+                                           unsigned Column, unsigned Flags,
+                                           unsigned Isa, const MDNode *Scope,
+                                           const DILocation *InlinedAt,
+                                           DwarfCompileUnit *CU);
+  /// Return the logical line number associated with the current actual entry.
+  uint32_t TLLTGetCurrentLine() { return LastActualEntryLogicalLineRefernce; }
+
+private:
   /// All DIEValues are allocated through this allocator.
   BumpPtrAllocator DIEValueAllocator;
 
   /// Maps MDNode with its corresponding DwarfCompileUnit.
   MapVector<const MDNode *, DwarfCompileUnit *> CUMap;
 
   /// Maps a CU DIE with its corresponding DwarfCompileUnit.
   DenseMap<const DIE *, DwarfCompileUnit *> CUDieMap;
private:
   /// Construct imported_module or imported_declaration DIE.
   void constructAndAddImportedEntityDIE(DwarfCompileUnit &TheCU,
                                         const DIImportedEntity *N);
 
   /// Register a source line with debug info. Returns the unique
   /// label that was emitted and which provides correspondence to the
   /// source line list.
   void recordSourceLine(unsigned Line, unsigned Col, const MDNode *Scope,
-                        unsigned Flags);
+                        unsigned Flags, const DILocation *InlinedAt);
 
   /// Populate LexicalScope entries with variables' info.
   void collectEntityInfo(DwarfCompileUnit &TheCU, const DISubprogram *SP,
                          DenseSet<InlinedEntity> &ProcessedVars);
 
   /// Build the location list for all DBG_VALUEs in the
   /// function that describe the same variable. If the resulting
   /// list has only one entry that is valid for entire variable's
bool useOpConvert() const {
     return EnableOpConvert;
   }
 
   bool shareAcrossDWOCUs() const;
 
   /// Returns the Dwarf Version.
   uint16_t getDwarfVersion() const;
 
+  /// Returns whether we'd like to emit TLLT.
+  bool getEnableTwoLevelLineTables() const;
+
   /// Returns a suitable DWARF form to represent a section offset, i.e.
   /// * DW_FORM_sec_offset for DWARF version >= 4;
   /// * DW_FORM_data8 for 64-bit DWARFv3;
   /// * DW_FORM_data4 for 32-bit DWARFv3 and DWARFv2.
   dwarf::Form getDwarfSectionOffsetForm() const;
 
   /// Returns the previous CU that was being updated
   const DwarfCompileUnit *getPrevCU() const { return PrevCU; }

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

DwarfDebug::DwarfDebug(AsmPrinter *A)
   // Split DWARF would benefit object size significantly by trading reductions
   // in address pool usage for slightly increased range list encodings.
   if (DwarfVersion >= 5)
     MinimizeAddr = MinimizeAddrInV5Option;
 
   Asm->OutStreamer->getContext().setDwarfVersion(DwarfVersion);
   Asm->OutStreamer->getContext().setDwarfFormat(Dwarf64 ? dwarf::DWARF64
                                                         : dwarf::DWARF32);
+  Asm->OutStreamer->getContext().setEnableTwoLevelLineTables(
+      Asm->TM.Options.EnableTwoLevelLineTables);
 }
 
 // Define out of line so we don't have to include DwarfUnit.h in DwarfDebug.h.
 DwarfDebug::~DwarfDebug() = default;
 
 static bool isObjCClass(StringRef Name) {
   return Name.startswith("+") || Name.startswith("-");
 }
GVEs.erase(std::unique(GVEs.begin(), GVEs.end(),
                          [](DwarfCompileUnit::GlobalExpr A,
                             DwarfCompileUnit::GlobalExpr B) {
                            return A.Expr == B.Expr;
                          }),
              GVEs.end());
   return GVEs;
 }
 
+void DwarfDebug::TLLTReset() {
+  LastActualEntryLogicalLineRefernce = 0;
+  LogicalsTableSize = 0;
+  LogicalsLookup.clear();
+  LogicalsContextLookup.clear();
+}
+
+struct DwarfLocBlockAndFile {
+  StringRef FileName;
+  unsigned FileNo = 1;
+  unsigned Discriminator = 0;
+};
+
+DwarfLocBlockAndFile getDwarfLocBlockAndFile(const MDNode *ScopeMD,
+                                             unsigned Line,
+                                             unsigned DwarfVersion,
+                                             DwarfCompileUnit *CU) {
+  DwarfLocBlockAndFile Data;
+  if (auto *Scope = cast_or_null<DIScope>(ScopeMD)) {
+    Data.FileName = Scope->getFilename();
+    if (Line != 0 && DwarfVersion >= 4)
+      if (auto *LBF = dyn_cast<DILexicalBlockFile>(Scope))
+        Data.Discriminator = LBF->getDiscriminator();
+
+    Data.FileNo = CU->getOrCreateSourceID(Scope->getFile());
+  }
+  return Data;
+}
+
+uint32_t DwarfDebug::TLLTGetOrCreateLogicalsEntryIdx(
+    unsigned DwarfVersion, AsmPrinter *Asm, unsigned Line, unsigned Column,
+    unsigned Flags, unsigned Isa, const MDNode *Scope,
+    const DILocation *InlinedAt, DwarfCompileUnit *CU) {
+  LastActualEntryLogicalLineRefernce = Line;
+  return TLLTGetOrCreateLogicalsEntryIdxImpl(DwarfVersion, Asm, Line, Column,
+                                             Flags, Isa, Scope, InlinedAt, CU);
+}
+
+uint32_t DwarfDebug::TLLTGetOrCreateLogicalsEntryIdxImpl(
+    unsigned DwarfVersion, AsmPrinter *Asm, unsigned Line, unsigned Column,
+    unsigned Flags, unsigned Isa, const MDNode *Scope,
+    const DILocation *InlinedAt, DwarfCompileUnit *CU) {
+  StringRef FunctionName;
+  uint32_t CC = 0;
+  // Check if this is an inlined instruction.
+  if (InlinedAt) {
+    auto R = LogicalsContextLookup.find(InlinedAt);
+    if (R == LogicalsContextLookup.end()) {
+      // TLLT FIXME: Unsure how the CU comes into play if the function has been
+      // inlined from another CU. Leave it unhandled for now.
+      CC = TLLTGetOrCreateLogicalsEntryIdxImpl(
+          DwarfVersion, Asm, InlinedAt->getLine(), InlinedAt->getColumn(),
+          Flags, Isa, Scope, InlinedAt->getInlinedAt(), CU);
+      LogicalsContextLookup.insert(std::make_pair(InlinedAt, CC));
+    } else {
+      CC = R->second;
+    }
+    if (const auto *LocalScope = cast_or_null<DILocalScope>(Scope)) {
+      if (auto *Subprg = LocalScope->getSubprogram())
+        FunctionName = Subprg->getName();
+    } else {
+      static const char *UnknownFunctionName = "???";
+      FunctionName = UnknownFunctionName;
+    }
+  }
+
+  // TLLT FIXME: Unnecessarily constructing and deconstructing this repeatedly.
+  DwarfLocBlockAndFile BlockAndFileData =
+      getDwarfLocBlockAndFile(Scope, Line, DwarfVersion, CU);
+  MCDwarfLoc Loc = MCDwarfLoc(BlockAndFileData.FileNo, Line, Column, Flags, Isa,
+                              BlockAndFileData.Discriminator, CC, FunctionName);
+
+  auto R = LogicalsLookup.find(Loc);
+  if (R == LogicalsLookup.end()) {
+    uint32_t Index = ++LogicalsTableSize;
+    LogicalsLookup.insert(std::make_pair(Loc, Index));
+    Asm->OutStreamer->emitDwarfLogicalLocDirective(
+        Loc.getFileNum(), Loc.getLine(), Loc.getColumn(), Loc.getFlags(),
+        Loc.getIsa(), Loc.getDiscriminator(), BlockAndFileData.FileName,
+        Loc.getContext(), Loc.getFunctionName());
+    return Index;
+  } else {
+    return R->second;
+  }
+}
+
 // Emit all Dwarf sections that should come prior to the content. Create
 // global DIEs and emit initial debug info sections. This is invoked by
 // the target AsmPrinter.
 void DwarfDebug::beginModule(Module *M) {
   DebugHandlerBase::beginModule(M);
-
+  // TLLT FIXME: This may not be the correct/only place to reset?
+  TLLTReset();
   if (!Asm || !MMI->hasDebugInfo())
     return;
 
   unsigned NumDebugCUs = std::distance(M->debug_compile_units_begin(),
                                        M->debug_compile_units_end());
   assert(NumDebugCUs > 0 && "Asm unexpectedly initialized");
   assert(MMI->hasDebugInfo() &&
          "DebugInfoAvailabilty unexpectedly not initialized");
if (MBB && (MBB != EpilogBeginBlock)) {
       EpilogBeginBlock = MBB;
       Flags |= DWARF2_FLAG_EPILOGUE_BEGIN;
     }
   }
 
   // When we emit a line-0 record, we don't update PrevInstLoc; so look at
   // the last line number actually emitted, to see if it was line 0.
   unsigned LastAsmLine =
-      Asm->OutStreamer->getContext().getCurrentDwarfLoc().getLine();
+      getDwarfVersion() >= 5 && getEnableTwoLevelLineTables()
+          ? TLLTGetCurrentLine()
+          : Asm->OutStreamer->getContext().getCurrentDwarfLoc().getLine();
 
   bool PrevInstInSameSection =
       (!PrevInstBB ||
        PrevInstBB->getSectionIDNum() == MI->getParent()->getSectionIDNum());
   if (DL == PrevInstLoc && PrevInstInSameSection) {
     // If we have an ongoing unspecified location, nothing to do here.
     if (!DL)
       return;
     // We have an explicit location, same as the previous location.
     // But we might be coming back to it after a line 0 record.
     if ((LastAsmLine == 0 && DL.getLine() != 0) || Flags) {
       // Reinstate the source location but not marked as a statement.
       const MDNode *Scope = DL.getScope();
-      recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
+      recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags,
+                       DL.getInlinedAt());
     }
     return;
   }
 
   if (!DL) {
     // We have an unspecified location, which might want to be line 0.
     // If we have already emitted a line-0 record, don't repeat it.
     if (LastAsmLine == 0)
if (!DL) {
     //   location from the physically previous (maybe unrelated) block.
     if (UnknownLocations == Enable || PrevLabel ||
         (PrevInstBB && PrevInstBB != MI->getParent())) {
       // Preserve the file and column numbers, if we can, to save space in
       // the encoded line table.
       // Do not update PrevInstLoc, it remembers the last non-0 line.
       const MDNode *Scope = nullptr;
       unsigned Column = 0;
+      const DILocation *InlinedAt = nullptr;
       if (PrevInstLoc) {
         Scope = PrevInstLoc.getScope();
         Column = PrevInstLoc.getCol();
+        InlinedAt = PrevInstLoc.getInlinedAt();
       }
-      recordSourceLine(/*Line=*/0, Column, Scope, /*Flags=*/0);
+      recordSourceLine(/*Line=*/0, Column, Scope, /*Flags=*/0, InlinedAt);
     }
     return;
   }
 
   // We have an explicit location, different from the previous location.
   // Don't repeat a line-0 record, but otherwise emit the new location.
   // (The new location might be an explicit line 0, which we do emit.)
   if (DL.getLine() == 0 && LastAsmLine == 0)
     return;
   if (DL == PrologEndLoc) {
     Flags |= DWARF2_FLAG_PROLOGUE_END | DWARF2_FLAG_IS_STMT;
     PrologEndLoc = DebugLoc();
   }
   // If the line changed, we call that a new statement; unless we went to
   // line 0 and came back, in which case it is not a new statement.
   unsigned OldLine = PrevInstLoc ? PrevInstLoc.getLine() : LastAsmLine;
   if (DL.getLine() && DL.getLine() != OldLine)
     Flags |= DWARF2_FLAG_IS_STMT;
 
   const MDNode *Scope = DL.getScope();
-  recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags);
+  recordSourceLine(DL.getLine(), DL.getCol(), Scope, Flags, DL.getInlinedAt());
 
   // If we're not at line 0, remember this location.
   if (DL.getLine())
     PrevInstLoc = DL;
 }
 
 static std::pair<DebugLoc, bool> findPrologueEndLoc(const MachineFunction *MF) {
   // First known non-DBG_VALUE and non-frame setup location marks
for (const auto &MI : MBB) {
       }
     }
   }
   return std::make_pair(LineZeroLoc, IsEmptyPrologue);
 }
 
 /// Register a source line with debug info. Returns the  unique label that was
 /// emitted and which provides correspondence to the source line list.
-static void recordSourceLine(AsmPrinter &Asm, unsigned Line, unsigned Col,
-                             const MDNode *S, unsigned Flags, unsigned CUID,
-                             uint16_t DwarfVersion,
-                             ArrayRef<std::unique_ptr<DwarfCompileUnit>> DCUs) {
-  StringRef Fn;
-  unsigned FileNo = 1;
-  unsigned Discriminator = 0;
-  if (auto *Scope = cast_or_null<DIScope>(S)) {
-    Fn = Scope->getFilename();
-    if (Line != 0 && DwarfVersion >= 4)
-      if (auto *LBF = dyn_cast<DILexicalBlockFile>(Scope))
-        Discriminator = LBF->getDiscriminator();
-
-    FileNo = static_cast<DwarfCompileUnit &>(*DCUs[CUID])
-                 .getOrCreateSourceID(Scope->getFile());
+static void recordSourceLine(DwarfDebug *DD, AsmPrinter &Asm, unsigned Line,
+                             unsigned Col, const MDNode *S, unsigned Flags,
+                             unsigned CUID, uint16_t DwarfVersion,
+                             ArrayRef<std::unique_ptr<DwarfCompileUnit>> DCUs,
+                             const DILocation *InlinedAt) {
+  if (DwarfVersion < 5 || !DD->getEnableTwoLevelLineTables()) {
+    auto FileBlockData =
+        getDwarfLocBlockAndFile(S, Line, DwarfVersion, DCUs[CUID].get());
+    Asm.OutStreamer->emitDwarfLocDirective(
+        FileBlockData.FileNo, Line, Col, Flags, 0, FileBlockData.Discriminator,
+        FileBlockData.FileName);
+  } else {
+    const MDNode *Scope = cast_or_null<DIScope>(S);
+    auto LogicalsIndex = DD->TLLTGetOrCreateLogicalsEntryIdx(
+        DwarfVersion, &Asm, Line, Col, Flags, /*Isa=*/0, Scope, InlinedAt,
+        DCUs[CUID].get());
+    Asm.OutStreamer->emitDwarfActualLocDirective(LogicalsIndex, Flags);
   }
-  Asm.OutStreamer->emitDwarfLocDirective(FileNo, Line, Col, Flags, 0,
-                                         Discriminator, Fn);
 }
 
 DebugLoc DwarfDebug::emitInitialLocDirective(const MachineFunction &MF,
                                              unsigned CUID) {
   std::pair<DebugLoc, bool> PrologEnd = findPrologueEndLoc(&MF);
   DebugLoc PrologEndLoc = PrologEnd.first;
   bool IsEmptyPrologue = PrologEnd.second;
 
   // Get beginning of function.
   if (PrologEndLoc) {
     // If the prolog is empty, no need to generate scope line for the proc.
     if (IsEmptyPrologue)
       return PrologEndLoc;
 
     // Ensure the compile unit is created if the function is called before
     // beginFunction().
     (void)getOrCreateDwarfCompileUnit(
         MF.getFunction().getSubprogram()->getUnit());
     // We'd like to list the prologue as "not statements" but GDB behaves
     // poorly if we do that. Revisit this with caution/GDB (7.5+) testing.
     const DISubprogram *SP = PrologEndLoc->getInlinedAtScope()->getSubprogram();
-    ::recordSourceLine(*Asm, SP->getScopeLine(), 0, SP, DWARF2_FLAG_IS_STMT,
-                       CUID, getDwarfVersion(), getUnits());
+    ::recordSourceLine(this, *Asm, SP->getScopeLine(), 0, SP,
+                       DWARF2_FLAG_IS_STMT, CUID, getDwarfVersion(), getUnits(),
+                       PrologEndLoc->getInlinedAt());
     return PrologEndLoc;
   }
   return DebugLoc();
 }
 
 // Gather pre-function debug information.  Assumes being called immediately
 // after the function entry point has been emitted.
 void DwarfDebug::beginFunctionImpl(const MachineFunction *MF) {
#endif
   InfoHolder.getScopeLabels().clear();
   PrevLabel = nullptr;
   CurFn = nullptr;
 }
 
 // Register a source line with debug info. Returns the  unique label that was
 // emitted and which provides correspondence to the source line list.
 void DwarfDebug::recordSourceLine(unsigned Line, unsigned Col, const MDNode *S,
-                                  unsigned Flags) {
-  ::recordSourceLine(*Asm, Line, Col, S, Flags,
+                                  unsigned Flags, const DILocation *InlinedAt) {
+  ::recordSourceLine(this, *Asm, Line, Col, S, Flags,
                      Asm->OutStreamer->getContext().getDwarfCompileUnitID(),
-                     getDwarfVersion(), getUnits());
+                     getDwarfVersion(), getUnits(), InlinedAt);
 }
 
 //===----------------------------------------------------------------------===//
 // Emit Methods
 //===----------------------------------------------------------------------===//
 
 // Emit the debug info section.
 void DwarfDebug::emitDebugInfo() {

 void DwarfDebug::addAccelType(const DICompileUnit &CU, StringRef Name,
                               const DIE &Die, char Flags) {
   addAccelNameImpl(CU, AccelTypes, Name, Die);
 }
 
 uint16_t DwarfDebug::getDwarfVersion() const {
   return Asm->OutStreamer->getContext().getDwarfVersion();
 }
+bool DwarfDebug::getEnableTwoLevelLineTables() const {
+  return Asm->OutStreamer->getContext().getEnableTwoLevelLineTables();
+}
 
 dwarf::Form DwarfDebug::getDwarfSectionOffsetForm() const {
   if (Asm->getDwarfVersion() >= 4)
     return dwarf::Form::DW_FORM_sec_offset;
   assert((!Asm->isDwarf64() || (Asm->getDwarfVersion() == 3)) &&
          "DWARF64 is not defined prior DWARFv3");
   return Asm->isDwarf64() ? dwarf::Form::DW_FORM_data8
                           : dwarf::Form::DW_FORM_data4;

llvm/lib/CodeGen/CommandFlags.cpp

 CGOPT(bool, UniqueBasicBlockSectionNames)
 CGOPT(EABI, EABIVersion)
 CGOPT(DebuggerKind, DebuggerTuningOpt)
 CGOPT(bool, EnableStackSizeSection)
 CGOPT(bool, EnableAddrsig)
 CGOPT(bool, EmitCallSiteInfo)
 CGOPT(bool, EnableMachineFunctionSplitter)
 CGOPT(bool, EnableDebugEntryValues)
+CGOPT(bool, EnableTwoLevelLineTables)
 CGOPT(bool, ForceDwarfFrameSection)
 CGOPT(bool, XRayOmitFunctionIndex)
 CGOPT(bool, DebugStrictDwarf)
 CGOPT(unsigned, AlignLoops)
 CGOPT(bool, JMCInstrument)
 CGOPT(bool, XCOFFReadOnlyPointers)
 
 codegen::RegisterCodeGenFlags::RegisterCodeGenFlags() {
#define CGBINDOPT(NAME)                                                        \
   CGBINDOPT(EmitCallSiteInfo);
 
   static cl::opt<bool> EnableDebugEntryValues(
       "debug-entry-values",
       cl::desc("Enable debug info for the debug entry values."),
       cl::init(false));
   CGBINDOPT(EnableDebugEntryValues);
 
+  static cl::opt<bool> EnableTwoLevelLineTables(
+      "two-level-line-tables",
+      cl::desc("Enable the emission of Two-Level Line Tables for Dwarf5."),
+      cl::init(false));
+  CGBINDOPT(EnableTwoLevelLineTables);
+
   static cl::opt<bool> EnableMachineFunctionSplitter(
       "split-machine-functions",
       cl::desc("Split out cold basic blocks from machine functions based on "
                "profile information"),
       cl::init(false));
   CGBINDOPT(EnableMachineFunctionSplitter);
 
   static cl::opt<bool> ForceDwarfFrameSection(
codegen::InitTargetOptionsFromCodeGenFlags(const Triple &TheTriple) {
   Options.EmulatedTLS =
       getExplicitEmulatedTLS().value_or(TheTriple.hasDefaultEmulatedTLS());
   Options.ExceptionModel = getExceptionModel();
   Options.EmitStackSizeSection = getEnableStackSizeSection();
   Options.EnableMachineFunctionSplitter = getEnableMachineFunctionSplitter();
   Options.EmitAddrsig = getEnableAddrsig();
   Options.EmitCallSiteInfo = getEmitCallSiteInfo();
   Options.EnableDebugEntryValues = getEnableDebugEntryValues();
+  Options.EnableTwoLevelLineTables = getEnableTwoLevelLineTables();
   Options.ForceDwarfFrameSection = getForceDwarfFrameSection();
   Options.XRayOmitFunctionIndex = getXRayOmitFunctionIndex();
   Options.DebugStrictDwarf = getDebugStrictDwarf();
   Options.LoopAlignment = getAlignLoops();
   Options.JMCInstrument = getJMCInstrument();
   Options.XCOFFReadOnlyPointers = getXCOFFReadOnlyPointers();
 
   Options.MCOptions = mc::InitMCTargetOptionsFromFlags();

llvm/lib/DebugInfo/DWARF/DWARFContext.cpp

DILineInfoTable DWARFContext::getLineInfoForAddressRange(
   std::vector<uint32_t> RowVector;
   if (!LineTable->lookupAddressRange({Address.Address, Address.SectionIndex},
                                      Size, RowVector)) {
     return Lines;
   }
 
   for (uint32_t RowIndex : RowVector) {
     // Take file number and line/column from the row.
-    const DWARFDebugLine::Row &Row = LineTable->Rows[RowIndex];
+    // TLLT: We need to take the line number from the Logicals table.
+    const DWARFDebugLine::Row &Row =
+        LineTable->isTLLT()
+            ? LineTable->LogicalRows[LineTable->ActualRows[RowIndex].Line - 1]
+            : LineTable->SLLTRows[RowIndex];
     DILineInfo Result;
     LineTable->getFileNameByIndex(Row.File, CU->getCompilationDir(),
                                   Spec.FLIKind, Result.FileName);
     Result.FunctionName = FunctionName;
     Result.Line = Row.Line;
     Result.Column = Row.Column;
     Result.StartFileName = StartFileName;
     Result.StartLine = StartLine;

llvm/lib/DebugInfo/DWARF/DWARFDebugLine.cpp

struct ContentDescriptor {
   dwarf::Form Form;
 };
 
 using ContentDescriptors = SmallVector<ContentDescriptor, 4>;
 
 } // end anonymous namespace
 
 static bool versionIsSupported(uint16_t Version) {
-  return Version >= 2 && Version <= 5;
+  return Version >= 2 && Version <= 6;
 }
 
 void DWARFDebugLine::ContentTypeTracker::trackContentType(
     dwarf::LineNumberEntryFormat ContentType) {
   switch (ContentType) {
   case dwarf::DW_LNCT_timestamp:
     HasModTime = true;
     break;
assert(DwarfVersion != 0 &&
          "line table prologue has no dwarf version information");
   // In DWARF v5 the file names are 0-indexed.
   if (DwarfVersion >= 5)
     return FileNames[Index];
   return FileNames[Index - 1];
 }
 
 void DWARFDebugLine::Prologue::clear() {
-  TotalLength = PrologueLength = 0;
+  TotalLength = PrologueLength = LogicalTableLength = 0;
   SegSelectorSize = 0;
   MinInstLength = MaxOpsPerInst = DefaultIsStmt = LineBase = LineRange = 0;
   OpcodeBase = 0;
+  FunctionNameForm = dwarf::Form::DW_FORM_line_strp;
   FormParams = dwarf::FormParams({0, 0, DWARF32});
   ContentTypes = ContentTypeTracker();
   StandardOpcodeLengths.clear();
   IncludeDirectories.clear();
   FileNames.clear();
 }
 
 void DWARFDebugLine::Prologue::dump(raw_ostream &OS,
                                     DIDumpOptions DumpOptions) const {
   if (!totalLengthIsValid())
     return;
   int OffsetDumpWidth = 2 * dwarf::getDwarfOffsetByteSize(FormParams.Format);
   OS << "Line table prologue:\n"
      << format("    total_length: 0x%0*" PRIx64 "\n", OffsetDumpWidth,
                TotalLength)
      << "          format: " << dwarf::FormatString(FormParams.Format) << "\n"
      << format("         version: %u\n", getVersion());
   if (!versionIsSupported(getVersion()))
     return;
   if (getVersion() >= 5)
     OS << format("    address_size: %u\n", getAddressSize())
        << format(" seg_select_size: %u\n", SegSelectorSize);
   OS << format(" prologue_length: 0x%0*" PRIx64 "\n", OffsetDumpWidth,
-               PrologueLength)
-     << format(" min_inst_length: %u\n", MinInstLength)
+               PrologueLength);
+  // TLLT Note: The proposal isn't actually confirmed for version 6 yet, but we
+  // are using it to indicate the TLLT extension is in effect, though a SLLT
+  // may still be present.
+  if (getVersion() == 6)
+    OS << format("  actuals_offset: 0x%0*" PRIx64 "\n", OffsetDumpWidth,
+                 LogicalTableLength)
+       << "    fn_name_form: " << dwarf::FormEncodingString(FunctionNameForm)
+       << "\n";
+  OS << format(" min_inst_length: %u\n", MinInstLength)
      << format(getVersion() >= 4 ? "max_ops_per_inst: %u\n" : "", MaxOpsPerInst)
      << format(" default_is_stmt: %u\n", DefaultIsStmt)
      << format("       line_base: %i\n", LineBase)
      << format("      line_range: %u\n", LineRange)
      << format("     opcode_base: %u\n", OpcodeBase);
 
   for (uint32_t I = 0; I != StandardOpcodeLengths.size(); ++I)
     OS << formatv("standard_opcode_lengths[{0}] = {1}\n",
if (getVersion() >= 5) {
     assert((!Cursor || DebugLineData.getAddressSize() == 0 ||
             DebugLineData.getAddressSize() == getAddressSize()) &&
            "Line table header and data extractor disagree");
     SegSelectorSize = DebugLineData.getU8(Cursor);
   }
 
   PrologueLength =
       DebugLineData.getRelocatedValue(Cursor, sizeofPrologueLength());
+
   const uint64_t EndPrologueOffset = PrologueLength + Cursor.tell();
+
+  // TLLT Note: Version 6 is being used to indicate TLLT proposal is in effect
+  // (whether or not TLLT are being emitted here).
+  if (getVersion() == 6) {
+    LogicalTableLength =
+        DebugLineData.getRelocatedValue(Cursor, sizeofPrologueLength());
+    FunctionNameForm = dwarf::Form(DebugLineData.getU8(Cursor));
+  }
+
   DebugLineData = DWARFDataExtractor(DebugLineData, EndPrologueOffset);
   MinInstLength = DebugLineData.getU8(Cursor);
   if (getVersion() >= 4)
     MaxOpsPerInst = DebugLineData.getU8(Cursor);
   DefaultIsStmt = DebugLineData.getU8(Cursor);
   LineBase = DebugLineData.getU8(Cursor);
   LineRange = DebugLineData.getU8(Cursor);
   OpcodeBase = DebugLineData.getU8(Cursor);
void DWARFDebugLine::Row::postAppend() {
   BasicBlock = false;
   PrologueEnd = false;
   EpilogueBegin = false;
 }
 
 void DWARFDebugLine::Row::reset(bool DefaultIsStmt) {
   Address.Address = 0;
   Address.SectionIndex = object::SectionedAddress::UndefSection;
+  Context = 0;
+  LogicalIndex = 0;
+  SubprogramOffset = DWARFFormValue();
   Line = 1;
   Column = 0;
   File = 1;
   Isa = 0;
   Discriminator = 0;
   IsStmt = DefaultIsStmt;
   BasicBlock = false;
   EndSequence = false;
   PrologueEnd = false;
   EpilogueBegin = false;
 }
 
 void DWARFDebugLine::Row::dumpTableHeader(raw_ostream &OS, unsigned Indent) {
   OS.indent(Indent)
       << "Address            Line   Column File   ISA Discriminator Flags\n";
   OS.indent(Indent)
       << "------------------ ------ ------ ------ --- ------------- "
          "-------------\n";
 }
 
+void DWARFDebugLine::Row::dumpLogicalTableHeader(raw_ostream &OS,
+                                                 unsigned Indent) {
+  OS.indent(Indent) << "Logicals Table:\n";
+  OS.indent(Indent)
+      << "Row    Address            Line   Column File   Discriminator "
+         "Context Flags                Subprogram         \n";
+  OS.indent(Indent)
+      << "------ ------------------ ------ ------ ------ ------------- "
+         "------- -------------------- ------------------\n";
+}
+void DWARFDebugLine::Row::dumpActualTableHeader(raw_ostream &OS,
+                                                unsigned Indent) {
+  OS.indent(Indent) << "Actuals Table:\n";
+  OS.indent(Indent) << "Address            Logical Row ISA Flags\n";
+  OS.indent(Indent) << "------------------ ----------- --- -------------\n";
+}
+
 void DWARFDebugLine::Row::dump(raw_ostream &OS) const {
   OS << format("0x%16.16" PRIx64 " %6u %6u", Address.Address, Line, Column)
      << format(" %6u %3u %13u ", File, Isa, Discriminator)
      << (IsStmt ? " is_stmt" : "") << (BasicBlock ? " basic_block" : "")
      << (PrologueEnd ? " prologue_end" : "")
      << (EpilogueBegin ? " epilogue_begin" : "")
      << (EndSequence ? " end_sequence" : "") << '\n';
 }
+void DWARFDebugLine::Row::dumpLogical(raw_ostream &OS) const {
+  OS << format("%6u 0x%16.16" PRIx64, LogicalIndex, Address.Address)
+     << format(" %6u %6u %6u %13u", Line, Column, File, Discriminator)
+     << format(" %7u", Context);
+  OS << (IsStmt ? " is_stmt" : "") << (PrologueEnd ? " prologue_end" : "")
+    << (EpilogueBegin ? " epilogue_begin" : "");
+  unsigned TrailingSpaces = 20;
+  if (IsStmt)
+    TrailingSpaces -= 8;
+  if (PrologueEnd)
+    TrailingSpaces -= 12;
+  for (unsigned idx = 0; idx < TrailingSpaces; ++idx)
+    OS << " ";
+  if (SubprogramOffset.getForm() != 0) {
+    OS << "  "; SubprogramOffset.dump(OS);
+  }
+  else {
+    OS << "                   ";
+  }
+  OS << "\n";
+}
+void DWARFDebugLine::Row::dumpActual(raw_ostream &OS) const {
+  OS << format("0x%16.16" PRIx64 " %11u %3u", Address.Address, Line, Isa)
+     << (BasicBlock ? " basic_block" : "")
+     << (EndSequence ? " end_sequence" : "") << '\n';
+}
 
 DWARFDebugLine::Sequence::Sequence() { reset(); }
 
 void DWARFDebugLine::Sequence::reset() {
   LowPC = 0;
   HighPC = 0;
   SectionIndex = object::SectionedAddress::UndefSection;
   FirstRowIndex = 0;
   LastRowIndex = 0;
   Empty = true;
 }
 
 DWARFDebugLine::LineTable::LineTable() { clear(); }
 
 void DWARFDebugLine::LineTable::dump(raw_ostream &OS,
                                      DIDumpOptions DumpOptions) const {
   Prologue.dump(OS, DumpOptions);
 
-  if (!Rows.empty()) {
+  if (!SLLTRows.empty()) {
     OS << '\n';
     Row::dumpTableHeader(OS, 0);
-    for (const Row &R : Rows) {
+    for (const Row &R : SLLTRows) {
       R.dump(OS);
     }
   }
+  if (!LogicalRows.empty()) {
+    OS << '\n';
+    Row::dumpLogicalTableHeader(OS, 0);
+    for (const Row &R : LogicalRows) {
+      R.dumpLogical(OS);
+    }
+  }
+  if (!ActualRows.empty()) {
+    OS << '\n';
+    Row::dumpActualTableHeader(OS, 0);
+    for (const Row &R : ActualRows) {
+      R.dumpActual(OS);
+    }
+  }
 
   // Terminate the table with a final blank line to clearly delineate it from
   // later dumps.
   OS << '\n';
 }
 
 void DWARFDebugLine::LineTable::clear() {
   Prologue.clear();
-  Rows.clear();
+  SLLTRows.clear();
+  ActualRows.clear();
+  LogicalRows.clear();
   Sequences.clear();
 }
 
 DWARFDebugLine::ParsingState::ParsingState(
     struct LineTable *LT, uint64_t TableOffset,
     function_ref<void(Error)> ErrorHandler)
     : LineTable(LT), LineTableOffset(TableOffset), ErrorHandler(ErrorHandler) {
   resetRowAndSequence();
 }
 
 void DWARFDebugLine::ParsingState::resetRowAndSequence() {
   Row.reset(LineTable->Prologue.DefaultIsStmt);
   Sequence.reset();
 }
 
-void DWARFDebugLine::ParsingState::appendRowToMatrix() {
-  unsigned RowNumber = LineTable->Rows.size();
-  if (Sequence.Empty) {
+void DWARFDebugLine::ParsingState::appendRowToMatrix(LineTableType RowType) {
+  unsigned RowNumber = LineTable->getRows(RowType).size();
+  if (RowType != LineTableType::LogicalTable && Sequence.Empty) {
     // Record the beginning of instruction sequence.
     Sequence.Empty = false;
     Sequence.LowPC = Row.Address.Address;
     Sequence.FirstRowIndex = RowNumber;
   }
-  LineTable->appendRow(Row);
-  if (Row.EndSequence) {
+  LineTable->appendRow(Row, RowType);
+  if (RowType != LineTableType::LogicalTable && Row.EndSequence) {
     // Record the end of instruction sequence.
     Sequence.HighPC = Row.Address.Address;
     Sequence.LastRowIndex = RowNumber + 1;
     Sequence.SectionIndex = Row.Address.SectionIndex;
     if (Sequence.isValid())
       LineTable->appendSequence(Sequence);
     Sequence.reset();
   }
Error DWARFDebugLine::LineTable::parse(
 
   // See if we should tell the data extractor the address size.
   if (TableData.getAddressSize() == 0)
     TableData.setAddressSize(Prologue.getAddressSize());
   else
     assert(Prologue.getAddressSize() == 0 ||
            Prologue.getAddressSize() == TableData.getAddressSize());
 
+  int OffsetDumpWidth = 2 * dwarf::getDwarfOffsetByteSize(Prologue.FormParams.Format);
+
   ParsingState State(this, DebugLineOffset, RecoverableErrorHandler);
 
   *OffsetPtr = DebugLineOffset + Prologue.getLength();
+  // TLLT support...
+  uint64_t LogicalEndOffset = *OffsetPtr + Prologue.LogicalTableLength;
+  LineTableType TableType = Prologue.LogicalTableLength > 0
+                                ? LineTableType::LogicalTable
+                                : LineTableType::SingleLevelLineTable;
   if (OS && *OffsetPtr < EndOffset) {
     *OS << '\n';
+    if (TableType == LineTableType::SingleLevelLineTable)
       Row::dumpTableHeader(*OS, /*Indent=*/Verbose ? 12 : 0);
+    else
+      Row::dumpLogicalTableHeader(*OS, /*Indent=*/Verbose ? 12 : 0);
   }
   bool TombstonedAddress = false;
   auto EmitRow = [&] {
     if (!TombstonedAddress) {
+      if (TableType == LineTableType::LogicalTable)
+        State.Row.LogicalIndex = State.LineTable->LogicalRows.size() + 1;
       if (Verbose) {
         *OS << "\n";
         OS->indent(12);
       }
-      if (OS)
+      if (OS) {
+        if (TableType == LineTableType::SingleLevelLineTable)
           State.Row.dump(*OS);
-      State.appendRowToMatrix();
+        else if (TableType == LineTableType::LogicalTable)
+          State.Row.dumpLogical(*OS);
+        else
+          State.Row.dumpActual(*OS);
+      }
+      State.appendRowToMatrix(TableType);
     }
   };
+
   while (*OffsetPtr < EndOffset) {
     DataExtractor::Cursor Cursor(*OffsetPtr);
 
+    // If we're printing the Logical table and have reached the end, switch to
+    // printing the Actual table.
+    if (TableType == LineTableType::LogicalTable &&
+        *OffsetPtr >= LogicalEndOffset) {
+      if (OS) {
+        *OS << '\n';
+        Row::dumpActualTableHeader(*OS, /*Indent=*/Verbose ? 12 : 0);
+      }
+      TableType = LineTableType::ActualTable;
+      State.resetRowAndSequence();
+    }
+
     if (Verbose)
       *OS << format("0x%08.08" PRIx64 ": ", *OffsetPtr);
 
     uint64_t OpcodeOffset = *OffsetPtr;
     uint8_t Opcode = TableData.getU8(Cursor);
-    size_t RowCount = Rows.size();
+    size_t RowCount = getRows(TableType).size();
 
     if (Cursor && Verbose)
       *OS << format("%02.02" PRIx8 " ", Opcode);
 
     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
       uint64_t Len = TableData.getULEB128(Cursor);
if (Opcode == 0) {
         if (std::optional<uint8_t> Isa =
                 parseULEB128<uint8_t>(TableData, Cursor)) {
           State.Row.Isa = *Isa;
           if (Verbose)
             *OS << " (" << (uint64_t)State.Row.Isa << ")";
         }
         break;
 
+      case DW_LNS_inlined_call:
+        if (std::optional<uint32_t> Context =
+                parseULEB128<uint32_t>(TableData, Cursor)) {
+          State.Row.Context = *Context;
+          if (Verbose)
+            *OS << " (" << (uint64_t)State.Row.Context << ")";
+        }
+        if (std::optional<uint64_t> SubprogramOffset =
+                parseULEB128<uint64_t>(TableData, Cursor)) {
+          if (*SubprogramOffset == 0) {
+            State.Row.SubprogramOffset = DWARFFormValue();
+          }
+          else {
+            State.Row.SubprogramOffset =
+              DWARFFormValue::createFromUValue(dwarf::Form::DW_FORM_line_strp,
+                *SubprogramOffset);
+            State.Row.SubprogramOffset.setContextAndUnit(&Ctx, U);
+          }
+          if (Verbose)
+            *OS << format(" (0x%0*" PRIx64 ")", OffsetDumpWidth,
+              (uint64_t)*SubprogramOffset);
+        }
+        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.
         {
           assert(Opcode - 1U < Prologue.StandardOpcodeLengths.size());
           if (Verbose)
             *OS << "Unrecognized standard opcode";
if (Opcode == 0) {
       if (Verbose)
         *OS << "address += " << Delta.Address << ",  line += " << Delta.Line;
       EmitRow();
       *OffsetPtr = Cursor.tell();
     }
 
     // When a row is added to the matrix, it is also dumped, which includes a
     // new line already, so don't add an extra one.
-    if (Verbose && Rows.size() == RowCount)
+    if (Verbose && getRows(TableType).size() == RowCount)
       *OS << "\n";
 
     // Most parse failures other than when parsing extended opcodes are due to
     // failures to read ULEBs. Bail out of parsing, since we don't know where to
     // continue reading from as there is no stated length for such byte
     // sequences. Print the final trailing new line if needed before doing so.
     if (!Cursor && Opcode != 0) {
       if (Verbose)
uint32_t DWARFDebugLine::LineTable::findRowInSeq(
   assert(Seq.SectionIndex == Address.SectionIndex);
   // In some cases, e.g. first instruction in a function, the compiler generates
   // two entries, both with the same address. We want the last one.
   //
   // In general we want a non-empty range: the last row whose address is less
   // than or equal to Address. This can be computed as upper_bound - 1.
   DWARFDebugLine::Row Row;
   Row.Address = Address;
+  const RowVector &Rows = isTLLT() ? ActualRows : SLLTRows;
   RowIter FirstRow = Rows.begin() + Seq.FirstRowIndex;
   RowIter LastRow = Rows.begin() + Seq.LastRowIndex;
   assert(FirstRow->Address.Address <= Row.Address.Address &&
          Row.Address.Address < LastRow[-1].Address.Address);
   RowIter RowPos = std::upper_bound(FirstRow + 1, LastRow - 1, Row,
                                     DWARFDebugLine::Row::orderByAddress) -
                    1;
   assert(Seq.SectionIndex == RowPos->Address.SectionIndex);

 bool DWARFDebugLine::LineTable::getFileLineInfoForAddress(
     object::SectionedAddress Address, const char *CompDir,
     FileLineInfoKind Kind, DILineInfo &Result) const {
   // Get the index of row we're looking for in the line table.
   uint32_t RowIndex = lookupAddress(Address);
   if (RowIndex == -1U)
     return false;
   // Take file number and line/column from the row.
+  const RowVector &Rows = isTLLT() ? ActualRows : SLLTRows;
   const auto &Row = Rows[RowIndex];
   if (!getFileNameByIndex(Row.File, CompDir, Kind, Result.FileName))
     return false;
   Result.Line = Row.Line;
   Result.Column = Row.Column;
   Result.Discriminator = Row.Discriminator;
   Result.Source = getSourceByIndex(Row.File, Kind);
   return true;

llvm/lib/DebugInfo/DWARF/DWARFVerifier.cpp

for (const auto &FileName : LineTable->Prologue.FileNames) {
       }
 
       FileIndex++;
     }
 
     // Verify rows.
     uint64_t PrevAddress = 0;
     uint32_t RowIndex = 0;
-    for (const auto &Row : LineTable->Rows) {
+    // FIXME TLLT: We would eventually verify the TLLT rows as well, with
+    // slightly different validation rules.
+    for (const auto &Row : LineTable->SLLTRows) {
       // Verify row address.
       if (Row.Address.Address < PrevAddress) {
         ++NumDebugLineErrors;
         error() << ".debug_line["
                 << format("0x%08" PRIx64,
                           *toSectionOffset(Die.find(DW_AT_stmt_list)))
                 << "] row[" << RowIndex
                 << "] decreases in address from previous row:\n";
 
         DWARFDebugLine::Row::dumpTableHeader(OS, 0);
         if (RowIndex > 0)
-          LineTable->Rows[RowIndex - 1].dump(OS);
+          LineTable->SLLTRows[RowIndex - 1].dump(OS);
         Row.dump(OS);
         OS << '\n';
       }
 
       // Verify file index.
       if (!LineTable->hasFileAtIndex(Row.File)) {
         ++NumDebugLineErrors;
         error() << ".debug_line["

llvm/lib/MC/MCContext.cpp

MCContext::MCContext(const Triple &TheTriple, const MCAsmInfo *mai,
                      const MCRegisterInfo *mri, const MCSubtargetInfo *msti,
                      const SourceMgr *mgr, MCTargetOptions const *TargetOpts,
                      bool DoAutoReset, StringRef Swift5ReflSegmentName)
     : Swift5ReflectionSegmentName(Swift5ReflSegmentName), TT(TheTriple),
       SrcMgr(mgr), InlineSrcMgr(nullptr), DiagHandler(defaultDiagHandler),
       MAI(mai), MRI(mri), MSTI(msti), Symbols(Allocator), UsedNames(Allocator),
       InlineAsmUsedLabelNames(Allocator),
       CurrentDwarfLoc(0, 0, 0, DWARF2_FLAG_IS_STMT, 0, 0),
+      CurrentDwarfActualLoc(0, 0, 0, DWARF2_FLAG_IS_STMT, 0, 0),
       AutoReset(DoAutoReset), TargetOptions(TargetOpts) {
   SecureLogFile = TargetOptions ? TargetOptions->AsSecureLogFile : "";
 
   if (SrcMgr && SrcMgr->getNumBuffers())
     MainFileName = std::string(SrcMgr->getMemoryBuffer(SrcMgr->getMainFileID())
                                    ->getBufferIdentifier());
 
   switch (TheTriple.getObjectFormat()) {

llvm/lib/MC/MCDwarf.cpp

 }
 
 //
 // This is called when an instruction is assembled into the specified section
 // and if there is information from the last .loc directive that has yet to have
 // a line entry made for it is made.
 //
 void MCDwarfLineEntry::make(MCStreamer *MCOS, MCSection *Section) {
+  uint16_t VersionNumber = MCOS->getContext().getDwarfVersion();
+  // If we're emitting TLLT, it should be sufficient to check DwarfActualLocSeen
+  // only, as we will always emit 1 Actual entry if there is anything to emit,
+  // while Logical entries are 0..many.
+  bool EnableTwoLevelLineTables =
+      MCOS->getContext().getEnableTwoLevelLineTables();
+  if (VersionNumber < 5 || !EnableTwoLevelLineTables) {
     if (!MCOS->getContext().getDwarfLocSeen())
       return;
+  } else {
+    if (!MCOS->getContext().getDwarfActualLocSeen())
+      return;
+  }
 
   // Create a symbol at in the current section for use in the line entry.
   MCSymbol *LineSym = MCOS->getContext().createTempSymbol();
   // Set the value of the symbol to use for the MCDwarfLineEntry.
   MCOS->emitLabel(LineSym);
 
+  // Emit SLLT.
+  if (VersionNumber < 5 || !EnableTwoLevelLineTables) {
     // Get the current .loc info saved in the context.
     const MCDwarfLoc &DwarfLoc = MCOS->getContext().getCurrentDwarfLoc();
 
     // Create a (local) line entry with the symbol and the current .loc info.
     MCDwarfLineEntry LineEntry(LineSym, DwarfLoc);
 
     // clear DwarfLocSeen saying the current .loc info is now used.
     MCOS->getContext().clearDwarfLocSeen();
 
     // Add the line entry to this section's entries.
     MCOS->getContext()
       .getMCDwarfLineTable(MCOS->getContext().getDwarfCompileUnitID())
       .getMCLineSections()
       .addLineEntry(LineEntry, Section);
+    return;
+  }
+
+  //// Emit TLLT.
+  // Emit Logicals.
+  for (const MCDwarfLoc &DwarfLogicalLoc : MCOS->getContext().getCurrentDwarfLogicalsLoc()) {
+    // Create a logical line entry with the symbol and the current .loc info.
+    MCDwarfLineEntry LineEntry(LineSym, DwarfLogicalLoc);
+    // Add the line entry to this section's entries.
+    MCOS->getContext()
+      .getMCDwarfLineTable(MCOS->getContext().getDwarfCompileUnitID())
+      .getMCLineSections()
+      .addLogicalLineEntry(LineEntry, Section);
+  }
+  MCOS->getContext().clearDwarfLogicalLocsSeen();
+
+  // Emit Actual.
+  // Get the current .loc info saved in the context.
+  const MCDwarfLoc &DwarfActualLoc = MCOS->getContext().getCurrentDwarfActualLoc();
+  // Create a (local) line entry with the symbol and the current .loc info.
+  MCDwarfLineEntry LineEntry(LineSym, DwarfActualLoc);
+  // clear DwarfLocSeen saying the current .loc info is now used.
+  MCOS->getContext().clearDwarfActualLocSeen();
+  // Add the line entry to this section's entries.
+  MCOS->getContext()
+    .getMCDwarfLineTable(MCOS->getContext().getDwarfCompileUnitID())
+    .getMCLineSections()
+    .addActualLineEntry(LineEntry, Section);
 }
 
 //
 // This helper routine returns an expression of End - Start - IntVal .
 //
 static inline const MCExpr *makeEndMinusStartExpr(MCContext &Ctx,
                                                   const MCSymbol &Start,
                                                   const MCSymbol &End,

 }
 
 //
 // This emits the Dwarf line table for the specified section from the entries
 // in the LineSection.
 //
 void MCDwarfLineTable::emitOne(
     MCStreamer *MCOS, MCSection *Section,
-    const MCLineSection::MCDwarfLineEntryCollection &LineEntries) {
+    const MCLineSection::MCDwarfLineEntryCollection &LineEntries,
+    std::optional<MCDwarfLineStr> &LineStr) {
 
-  unsigned FileNum, LastLine, Column, Flags, Isa, Discriminator;
+  // TLLT FIXME: FunctionName might need to be size_t, not clear why unsigned
+  // is used for other types currently.
+  unsigned FileNum, LastLine, Column, Flags, Isa, Discriminator, Context, FunctionName;
   MCSymbol *LastLabel;
   auto init = [&]() {
     FileNum = 1;
     LastLine = 1;
     Column = 0;
     Flags = DWARF2_LINE_DEFAULT_IS_STMT ? DWARF2_FLAG_IS_STMT : 0;
     Isa = 0;
     Discriminator = 0;
     LastLabel = nullptr;
+    Context = 0;
+    FunctionName = 0;
   };
   init();
 
   // Loop through each MCDwarfLineEntry and encode the dwarf line number table.
   bool EndEntryEmitted = false;
   for (const MCDwarfLineEntry &LineEntry : LineEntries) {
     MCSymbol *Label = LineEntry.getLabel();
     const MCAsmInfo *asmInfo = MCOS->getContext().getAsmInfo();
if ((LineEntry.getFlags() ^ Flags) & DWARF2_FLAG_IS_STMT) {
       MCOS->emitInt8(dwarf::DW_LNS_negate_stmt);
     }
     if (LineEntry.getFlags() & DWARF2_FLAG_BASIC_BLOCK)
       MCOS->emitInt8(dwarf::DW_LNS_set_basic_block);
     if (LineEntry.getFlags() & DWARF2_FLAG_PROLOGUE_END)
       MCOS->emitInt8(dwarf::DW_LNS_set_prologue_end);
     if (LineEntry.getFlags() & DWARF2_FLAG_EPILOGUE_BEGIN)
       MCOS->emitInt8(dwarf::DW_LNS_set_epilogue_begin);
+    // Special case: We always update subprogram and function name at the same
+    // time.
+    if (Context != LineEntry.getContext()) {
+      Context = LineEntry.getContext();
+      FunctionName = Context == 0 ? 0 : LineStr->getRef(MCOS, LineEntry.getFunctionName());
+      MCOS->emitInt8(dwarf::DW_LNS_inlined_call);
+      MCOS->emitULEB128IntValue(Context);
+      MCOS->emitULEB128IntValue(FunctionName);
+    }
 
     // At this point we want to emit/create the sequence to encode the delta in
     // line numbers and the increment of the address from the previous Label
     // and the current Label.
     MCOS->emitDwarfAdvanceLineAddr(LineDelta, LastLabel, Label,
                                    asmInfo->getCodePointerSize());
 
     Discriminator = 0;

 }
 
 void MCDwarfDwoLineTable::Emit(MCStreamer &MCOS, MCDwarfLineTableParams Params,
                                MCSection *Section) const {
   if (!HasSplitLineTable)
     return;
   std::optional<MCDwarfLineStr> NoLineStr(std::nullopt);
   MCOS.switchSection(Section);
-  MCOS.emitLabel(Header.Emit(&MCOS, Params, std::nullopt, NoLineStr).second);
+  MCOS.emitLabel(std::get<1>(Header.Emit(&MCOS, Params, std::nullopt, NoLineStr)));
 }
 
-std::pair<MCSymbol *, MCSymbol *>
+std::tuple<MCSymbol *, MCSymbol *, MCSymbol *>
 MCDwarfLineTableHeader::Emit(MCStreamer *MCOS, MCDwarfLineTableParams Params,
                              std::optional<MCDwarfLineStr> &LineStr) const {
   static const char StandardOpcodeLengths[] = {
       0, // length of DW_LNS_copy
       1, // length of DW_LNS_advance_pc
       1, // length of DW_LNS_advance_line
       1, // length of DW_LNS_set_file
       1, // length of DW_LNS_set_column
       0, // length of DW_LNS_negate_stmt
       0, // length of DW_LNS_set_basic_block
       0, // length of DW_LNS_const_add_pc
       1, // length of DW_LNS_fixed_advance_pc
       0, // length of DW_LNS_set_prologue_end
       0, // length of DW_LNS_set_epilogue_begin
-      1  // DW_LNS_set_isa
+      1, // DW_LNS_set_isa
+      2  // length of DW_LNS_inlined_call
   };
   assert(std::size(StandardOpcodeLengths) >=
          (Params.DWARF2LineOpcodeBase - 1U));
   return Emit(MCOS, Params,
               ArrayRef(StandardOpcodeLengths, Params.DWARF2LineOpcodeBase - 1),
               LineStr);
 }
 
int RefSize =
       dwarf::getDwarfOffsetByteSize(MCOS->getContext().getDwarfFormat());
   size_t Offset = LineStrings.add(Path);
   if (UseRelocs) {
     MCContext &Ctx = MCOS->getContext();
     MCOS->emitValue(makeStartPlusIntExpr(Ctx, *LineStrLabel, Offset), RefSize);
   } else
     MCOS->emitIntValue(Offset, RefSize);
 }
+size_t MCDwarfLineStr::getRef(MCStreamer *MCOS, StringRef Path) {
+  int RefSize =
+      dwarf::getDwarfOffsetByteSize(MCOS->getContext().getDwarfFormat());
+  return LineStrings.add(Path);
+}
 
 void MCDwarfLineTableHeader::emitV2FileDirTables(MCStreamer *MCOS) const {
   // First the directory table.
   for (auto &Dir : MCDwarfDirs) {
     MCOS->emitBytes(Dir);                // The DirectoryName, and...
     MCOS->emitBytes(StringRef("\0", 1)); // its null terminator.
   }
   MCOS->emitInt8(0); // Terminate the directory list.
void MCDwarfLineTableHeader::emitV5FileDirTables(
   assert((!RootFile.Name.empty() || MCDwarfFiles.size() >= 1) &&
          "No root file and no .file directives");
   emitOneV5FileEntry(MCOS, RootFile.Name.empty() ? MCDwarfFiles[1] : RootFile,
                      HasAllMD5, HasSource, LineStr);
   for (unsigned i = 1; i < MCDwarfFiles.size(); ++i)
     emitOneV5FileEntry(MCOS, MCDwarfFiles[i], HasAllMD5, HasSource, LineStr);
 }
 
-std::pair<MCSymbol *, MCSymbol *>
+std::tuple<MCSymbol *, MCSymbol *, MCSymbol *>
 MCDwarfLineTableHeader::Emit(MCStreamer *MCOS, MCDwarfLineTableParams Params,
                              ArrayRef<char> StandardOpcodeLengths,
                              std::optional<MCDwarfLineStr> &LineStr) const {
   MCContext &context = MCOS->getContext();
 
   // Create a symbol at the beginning of the line table.
   MCSymbol *LineStartSym = Label;
   if (!LineStartSym)
     LineStartSym = context.createTempSymbol();
 
   // Set the value of the symbol, as we are at the start of the line table.
   MCOS->emitDwarfLineStartLabel(LineStartSym);
 
   unsigned OffsetSize = dwarf::getDwarfOffsetByteSize(context.getDwarfFormat());
 
   MCSymbol *LineEndSym = MCOS->emitDwarfUnitLength("debug_line", "unit length");
 
   // Next 2 bytes is the Version.
   unsigned LineTableVersion = context.getDwarfVersion();
+  // TLLT Note: Version "6" is acting something like a magic number here to
+  // indicate the TLLT extension is being used.
+  if (LineTableVersion >= 5 && context.getEnableTwoLevelLineTables())
+    LineTableVersion = 6;
   MCOS->emitInt16(LineTableVersion);
 
   // In v5, we get address info next.
   if (LineTableVersion >= 5) {
     MCOS->emitInt8(context.getAsmInfo()->getCodePointerSize());
     MCOS->emitInt8(0); // Segment selector; same as EmitGenDwarfAranges.
   }
 
   // Create symbols for the start/end of the prologue.
   MCSymbol *ProStartSym = context.createTempSymbol("prologue_start");
   MCSymbol *ProEndSym = context.createTempSymbol("prologue_end");
 
   // Length of the prologue, is the next 4 bytes (8 bytes for DWARF64). This is
   // actually the length from after the length word, to the end of the prologue.
   MCOS->emitAbsoluteSymbolDiff(ProEndSym, ProStartSym, OffsetSize);
 
   MCOS->emitLabel(ProStartSym);
 
+  MCSymbol *ActualsStartSym = ProEndSym;
+  bool EnableTwoLevelLineTables =
+      MCOS->getContext().getEnableTwoLevelLineTables();
+  if (LineTableVersion >= 5 && EnableTwoLevelLineTables) {
+    // Skip this assignment if we are emitting a SLLT in Dwarf 6 (i.e. TLLT are
+    // supported but not being used).
+    ActualsStartSym = context.createTempSymbol("actuals_start");
+    // Distance from prologue_end to the start of the Actuals table.
+    MCOS->emitAbsoluteSymbolDiff(ActualsStartSym, ProEndSym, OffsetSize);
+    // Form of strings references in the FunctionName line register.
+    MCOS->emitInt8((uint8_t)dwarf::DW_FORM_line_strp);
+  }
   // Parameters of the state machine, are next.
   MCOS->emitInt8(context.getAsmInfo()->getMinInstAlignment());
   // maximum_operations_per_instruction
   // For non-VLIW architectures this field is always 1.
   // FIXME: VLIW architectures need to update this field accordingly.
   if (LineTableVersion >= 4)
     MCOS->emitInt8(1);
   MCOS->emitInt8(DWARF2_LINE_DEFAULT_IS_STMT);
if (LineTableVersion >= 5)
     emitV5FileDirTables(MCOS, LineStr);
   else
     emitV2FileDirTables(MCOS);
 
   // This is the end of the prologue, so set the value of the symbol at the
   // end of the prologue (that was used in a previous expression).
   MCOS->emitLabel(ProEndSym);
 
-  return std::make_pair(LineStartSym, LineEndSym);
+  return std::make_tuple(LineStartSym, LineEndSym, ActualsStartSym);
 }
 
 void MCDwarfLineTable::emitCU(MCStreamer *MCOS, MCDwarfLineTableParams Params,
                               std::optional<MCDwarfLineStr> &LineStr) const {
-  MCSymbol *LineEndSym = Header.Emit(MCOS, Params, LineStr).second;
+  auto RecordedSymbols = Header.Emit(MCOS, Params, LineStr);
+  MCSymbol *LineEndSym = std::get<1>(RecordedSymbols);
+  MCSymbol *ActualsStartSym = std::get<2>(RecordedSymbols);
 
   // Put out the line tables.
-  for (const auto &LineSec : MCLineSections.getMCLineEntries())
-    emitOne(MCOS, LineSec.first, LineSec.second);
+  MCContext &context = MCOS->getContext();
+  bool UseTLLT =
+      context.getDwarfVersion() >= 5 && context.getEnableTwoLevelLineTables();
+  bool EmittedAlready = false;
+  if (!UseTLLT) {
+    for (const auto &LineSec : MCLineSections.getMCLineEntries()) {
+      assert(!EmittedAlready && "Only one set of line entries should be emitted!");
+      emitOne(MCOS, LineSec.first, LineSec.second, LineStr);
+      EmittedAlready = true;
+    }
+  } else {
+    for (const auto &LineSec : MCLineSections.getMCLogicalLineEntries()) {
+      assert(!EmittedAlready && "Only one set of line entries should be emitted!");
+      emitOne(MCOS, LineSec.first, LineSec.second, LineStr);
+      EmittedAlready = true;
+    }
+    MCOS->emitLabel(ActualsStartSym);
+    // Emit Actuals Table here.
+    for (const auto &LineSec : MCLineSections.getMCActualLineEntries())
+      emitOne(MCOS, LineSec.first, LineSec.second, LineStr);
+  }
 
   // This is the end of the section, so set the value of the symbol at the end
   // of this section (that was used in a previous expression).
   MCOS->emitLabel(LineEndSym);
 }
 
 Expected<unsigned>
 MCDwarfLineTable::tryGetFile(StringRef &Directory, StringRef &FileName,

llvm/lib/MC/MCStreamer.cpp

 void MCStreamer::emitDwarfLocDirective(unsigned FileNo, unsigned Line,
                                        unsigned Column, unsigned Flags,
                                        unsigned Isa, unsigned Discriminator,
                                        StringRef FileName) {
   getContext().setCurrentDwarfLoc(FileNo, Line, Column, Flags, Isa,
                                   Discriminator);
 }
 
+void MCStreamer::emitDwarfLogicalLocDirective(
+    unsigned FileNo, unsigned Line, unsigned Column, unsigned Flags,
+    unsigned Isa, unsigned Discriminator, StringRef FileName, unsigned Context,
+    StringRef FunctionName) {
+  getContext().addCurrentDwarfLogicalLoc(FileNo, Line, Column, Flags, Isa,
+                                         Discriminator, Context, FunctionName);
+}
+
+void MCStreamer::emitDwarfActualLocDirective(unsigned Line, unsigned Flags) {
+  getContext().setCurrentDwarfActualLoc(Line, Flags);
+}
+
 MCSymbol *MCStreamer::getDwarfLineTableSymbol(unsigned CUID) {
   MCDwarfLineTable &Table = getContext().getMCDwarfLineTable(CUID);
   if (!Table.getLabel()) {
     StringRef Prefix = Context.getAsmInfo()->getPrivateGlobalPrefix();
     Table.setLabel(
         Context.getOrCreateSymbol(Prefix + "line_table_start" + Twine(CUID)));
   }
   return Table.getLabel();