LLDB  mainline
DWARFDebugLine.cpp
Go to the documentation of this file.
1 //===-- DWARFDebugLine.cpp --------------------------------------*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #include "DWARFDebugLine.h"
10 
11 //#define ENABLE_DEBUG_PRINTF // DO NOT LEAVE THIS DEFINED: DEBUG ONLY!!!
12 #include <assert.h>
13 
14 #include <memory>
15 
16 #include "lldb/Core/FileSpecList.h"
17 #include "lldb/Core/Module.h"
18 #include "lldb/Host/Host.h"
19 #include "lldb/Utility/Log.h"
20 #include "lldb/Utility/Timer.h"
21 
22 #include "DWARFUnit.h"
23 #include "LogChannelDWARF.h"
24 #include "SymbolFileDWARF.h"
25 
26 using namespace lldb;
27 using namespace lldb_private;
28 using namespace std;
29 
30 // Parse
31 //
32 // Parse all information in the debug_line_data into an internal
33 // representation.
34 void DWARFDebugLine::Parse(const DWARFDataExtractor &debug_line_data) {
35  m_lineTableMap.clear();
36  lldb::offset_t offset = 0;
37  LineTable::shared_ptr line_table_sp(new LineTable);
38  while (debug_line_data.ValidOffset(offset)) {
39  const lldb::offset_t debug_line_offset = offset;
40 
41  if (line_table_sp.get() == NULL)
42  break;
43 
44  if (ParseStatementTable(debug_line_data, &offset, line_table_sp.get(), nullptr)) {
45  // Make sure we don't don't loop infinitely
46  if (offset <= debug_line_offset)
47  break;
48  // DEBUG_PRINTF("m_lineTableMap[0x%8.8x] = line_table_sp\n",
49  // debug_line_offset);
50  m_lineTableMap[debug_line_offset] = line_table_sp;
51  line_table_sp = std::make_shared<LineTable>();
52  } else
53  ++offset; // Try next byte in line table
54  }
55 }
56 
57 void DWARFDebugLine::ParseIfNeeded(const DWARFDataExtractor &debug_line_data) {
58  if (m_lineTableMap.empty())
59  Parse(debug_line_data);
60 }
61 
62 // DWARFDebugLine::GetLineTable
65  DWARFDebugLine::LineTable::shared_ptr line_table_shared_ptr;
66  LineTableConstIter pos = m_lineTableMap.find(offset);
67  if (pos != m_lineTableMap.end())
68  line_table_shared_ptr = pos->second;
69  return line_table_shared_ptr;
70 }
71 
72 // Parse
73 //
74 // Parse the entire line table contents calling callback each time a new
75 // prologue is parsed and every time a new row is to be added to the line
76 // table.
77 void DWARFDebugLine::Parse(const DWARFDataExtractor &debug_line_data,
79  void *userData) {
80  lldb::offset_t offset = 0;
81  if (debug_line_data.ValidOffset(offset)) {
82  if (!ParseStatementTable(debug_line_data, &offset, callback, userData, nullptr))
83  ++offset; // Skip to next byte in .debug_line section
84  }
85 }
86 
87 namespace {
88 struct EntryDescriptor {
89  dw_sleb128_t code;
90  dw_sleb128_t form;
91 };
92 
93 static std::vector<EntryDescriptor>
94 ReadDescriptors(const DWARFDataExtractor &debug_line_data,
95  lldb::offset_t *offset_ptr) {
96  std::vector<EntryDescriptor> ret;
97  uint8_t n = debug_line_data.GetU8(offset_ptr);
98  for (uint8_t i = 0; i < n; ++i) {
99  EntryDescriptor ent;
100  ent.code = debug_line_data.GetULEB128(offset_ptr);
101  ent.form = debug_line_data.GetULEB128(offset_ptr);
102  ret.push_back(ent);
103  }
104  return ret;
105 }
106 } // namespace
107 
108 // DWARFDebugLine::ParsePrologue
110  lldb::offset_t *offset_ptr,
111  Prologue *prologue, DWARFUnit *dwarf_cu) {
112  const lldb::offset_t prologue_offset = *offset_ptr;
113 
114  // DEBUG_PRINTF("0x%8.8x: ParsePrologue()\n", *offset_ptr);
115 
116  prologue->Clear();
117  uint32_t i;
118  const char *s;
119  prologue->total_length = debug_line_data.GetDWARFInitialLength(offset_ptr);
120  prologue->version = debug_line_data.GetU16(offset_ptr);
121  if (prologue->version < 2 || prologue->version > 5)
122  return false;
123 
124  if (prologue->version >= 5) {
125  prologue->address_size = debug_line_data.GetU8(offset_ptr);
126  prologue->segment_selector_size = debug_line_data.GetU8(offset_ptr);
127  }
128 
129  prologue->prologue_length = debug_line_data.GetDWARFOffset(offset_ptr);
130  const lldb::offset_t end_prologue_offset =
131  prologue->prologue_length + *offset_ptr;
132  prologue->min_inst_length = debug_line_data.GetU8(offset_ptr);
133  if (prologue->version >= 4)
135  debug_line_data.GetU8(offset_ptr);
136  else
138  prologue->default_is_stmt = debug_line_data.GetU8(offset_ptr);
139  prologue->line_base = debug_line_data.GetU8(offset_ptr);
140  prologue->line_range = debug_line_data.GetU8(offset_ptr);
141  prologue->opcode_base = debug_line_data.GetU8(offset_ptr);
142 
143  prologue->standard_opcode_lengths.reserve(prologue->opcode_base - 1);
144 
145  for (i = 1; i < prologue->opcode_base; ++i) {
146  uint8_t op_len = debug_line_data.GetU8(offset_ptr);
147  prologue->standard_opcode_lengths.push_back(op_len);
148  }
149 
150  if (prologue->version >= 5) {
151  std::vector<EntryDescriptor> dirEntryFormatV =
152  ReadDescriptors(debug_line_data, offset_ptr);
153  uint8_t dirCount = debug_line_data.GetULEB128(offset_ptr);
154  for (int i = 0; i < dirCount; ++i) {
155  for (EntryDescriptor &ent : dirEntryFormatV) {
156  DWARFFormValue value(dwarf_cu, ent.form);
157  if (ent.code != DW_LNCT_path) {
158  if (!value.SkipValue(debug_line_data, offset_ptr))
159  return false;
160  continue;
161  }
162 
163  if (!value.ExtractValue(debug_line_data, offset_ptr))
164  return false;
165  prologue->include_directories.push_back(value.AsCString());
166  }
167  }
168 
169  std::vector<EntryDescriptor> filesEntryFormatV =
170  ReadDescriptors(debug_line_data, offset_ptr);
171  llvm::DenseSet<std::pair<uint64_t, uint64_t>> seen;
172  uint8_t n = debug_line_data.GetULEB128(offset_ptr);
173  for (int i = 0; i < n; ++i) {
174  FileNameEntry entry;
175  for (EntryDescriptor &ent : filesEntryFormatV) {
176  DWARFFormValue value(dwarf_cu, ent.form);
177  if (!value.ExtractValue(debug_line_data, offset_ptr))
178  return false;
179 
180  switch (ent.code) {
181  case DW_LNCT_path:
182  entry.name = value.AsCString();
183  break;
184  case DW_LNCT_directory_index:
185  entry.dir_idx = value.Unsigned();
186  break;
187  case DW_LNCT_timestamp:
188  entry.mod_time = value.Unsigned();
189  break;
190  case DW_LNCT_size:
191  entry.length = value.Unsigned();
192  break;
193  case DW_LNCT_MD5:
194  assert(value.Unsigned() == 16);
195  std::uninitialized_copy_n(value.BlockData(), 16,
196  entry.checksum.Bytes.begin());
197  break;
198  default:
199  break;
200  }
201  }
202 
203  if (seen.insert(entry.checksum.words()).second)
204  prologue->file_names.push_back(entry);
205  }
206  } else {
207  while (*offset_ptr < end_prologue_offset) {
208  s = debug_line_data.GetCStr(offset_ptr);
209  if (s && s[0])
210  prologue->include_directories.push_back(s);
211  else
212  break;
213  }
214 
215  while (*offset_ptr < end_prologue_offset) {
216  const char *name = debug_line_data.GetCStr(offset_ptr);
217  if (name && name[0]) {
218  FileNameEntry fileEntry;
219  fileEntry.name = name;
220  fileEntry.dir_idx = debug_line_data.GetULEB128(offset_ptr);
221  fileEntry.mod_time = debug_line_data.GetULEB128(offset_ptr);
222  fileEntry.length = debug_line_data.GetULEB128(offset_ptr);
223  prologue->file_names.push_back(fileEntry);
224  } else
225  break;
226  }
227  }
228 
229  // XXX GNU as is broken for 64-Bit DWARF
230  if (*offset_ptr != end_prologue_offset) {
231  Host::SystemLog(Host::eSystemLogWarning,
232  "warning: parsing line table prologue at 0x%8.8" PRIx64
233  " should have ended at 0x%8.8" PRIx64
234  " but it ended at 0x%8.8" PRIx64 "\n",
235  prologue_offset, end_prologue_offset, *offset_ptr);
236  }
237  return end_prologue_offset;
238 }
239 
241  const lldb::ModuleSP &module_sp, const DWARFDataExtractor &debug_line_data,
242  dw_offset_t stmt_list, FileSpecList &support_files, DWARFUnit *dwarf_cu) {
243  lldb::offset_t offset = stmt_list;
244 
245  Prologue prologue;
246  if (!ParsePrologue(debug_line_data, &offset, &prologue, dwarf_cu)) {
247  Host::SystemLog(Host::eSystemLogError, "error: parsing line table prologue "
248  "at 0x%8.8x (parsing ended around "
249  "0x%8.8" PRIx64 "\n",
250  stmt_list, offset);
251  return false;
252  }
253 
254  FileSpec file_spec;
255  std::string remapped_file;
256 
257  for (uint32_t file_idx = 1;
258  prologue.GetFile(file_idx, dwarf_cu->GetCompilationDirectory(),
259  dwarf_cu->GetPathStyle(), file_spec);
260  ++file_idx) {
261  if (module_sp->RemapSourceFile(file_spec.GetPath(), remapped_file))
262  file_spec.SetFile(remapped_file, FileSpec::Style::native);
263  support_files.Append(file_spec);
264  }
265  return true;
266 }
267 
268 // ParseStatementTable
269 //
270 // Parse a single line table (prologue and all rows) and call the callback
271 // function once for the prologue (row in state will be zero) and each time a
272 // row is to be added to the line table.
274  const DWARFDataExtractor &debug_line_data, lldb::offset_t *offset_ptr,
275  DWARFDebugLine::State::Callback callback, void *userData, DWARFUnit *dwarf_cu) {
276  Log *log(LogChannelDWARF::GetLogIfAll(DWARF_LOG_DEBUG_LINE));
277  Prologue::shared_ptr prologue(new Prologue());
278 
279  const dw_offset_t debug_line_offset = *offset_ptr;
280 
281  static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
282  Timer scoped_timer(
283  func_cat, "DWARFDebugLine::ParseStatementTable (.debug_line[0x%8.8x])",
284  debug_line_offset);
285 
286  if (!ParsePrologue(debug_line_data, offset_ptr, prologue.get(), dwarf_cu)) {
287  if (log)
288  log->Error("failed to parse DWARF line table prologue");
289  // Restore our offset and return false to indicate failure!
290  *offset_ptr = debug_line_offset;
291  return false;
292  }
293 
294  if (log)
295  prologue->Dump(log);
296 
297  const dw_offset_t end_offset =
298  debug_line_offset + prologue->total_length +
299  (debug_line_data.GetDWARFSizeofInitialLength());
300 
301  State state(prologue, log, callback, userData);
302 
303  while (*offset_ptr < end_offset) {
304  // DEBUG_PRINTF("0x%8.8x: ", *offset_ptr);
305  uint8_t opcode = debug_line_data.GetU8(offset_ptr);
306 
307  if (opcode == 0) {
308  // Extended Opcodes always start with a zero opcode followed by a uleb128
309  // length so you can skip ones you don't know about
310  lldb::offset_t ext_offset = *offset_ptr;
311  dw_uleb128_t len = debug_line_data.GetULEB128(offset_ptr);
312  dw_offset_t arg_size = len - (*offset_ptr - ext_offset);
313 
314  // DEBUG_PRINTF("Extended: <%2u> ", len);
315  uint8_t sub_opcode = debug_line_data.GetU8(offset_ptr);
316  switch (sub_opcode) {
317  case DW_LNE_end_sequence:
318  // Set the end_sequence register of the state machine to true and
319  // append a row to the matrix using the current values of the state-
320  // machine registers. Then reset the registers to the initial values
321  // specified above. Every statement program sequence must end with a
322  // DW_LNE_end_sequence instruction which creates a row whose address is
323  // that of the byte after the last target machine instruction of the
324  // sequence.
325  state.end_sequence = true;
326  state.AppendRowToMatrix(*offset_ptr);
327  state.Reset();
328  break;
329 
330  case DW_LNE_set_address:
331  // Takes a single relocatable address as an operand. The size of the
332  // operand is the size appropriate to hold an address on the target
333  // machine. Set the address register to the value given by the
334  // relocatable address. All of the other statement program opcodes that
335  // affect the address register add a delta to it. This instruction
336  // stores a relocatable value into it instead.
337  if (arg_size == 4)
338  state.address = debug_line_data.GetU32(offset_ptr);
339  else // arg_size == 8
340  state.address = debug_line_data.GetU64(offset_ptr);
341  break;
342 
343  case DW_LNE_define_file:
344  // Takes 4 arguments. The first is a null terminated string containing
345  // a source file name. The second is an unsigned LEB128 number
346  // representing the directory index of the directory in which the file
347  // was found. The third is an unsigned LEB128 number representing the
348  // time of last modification of the file. The fourth is an unsigned
349  // LEB128 number representing the length in bytes of the file. The time
350  // and length fields may contain LEB128(0) if the information is not
351  // available.
352  //
353  // The directory index represents an entry in the include_directories
354  // section of the statement program prologue. The index is LEB128(0) if
355  // the file was found in the current directory of the compilation,
356  // LEB128(1) if it was found in the first directory in the
357  // include_directories section, and so on. The directory index is
358  // ignored for file names that represent full path names.
359  //
360  // The files are numbered, starting at 1, in the order in which they
361  // appear; the names in the prologue come before names defined by the
362  // DW_LNE_define_file instruction. These numbers are used in the file
363  // register of the state machine.
364  {
365  FileNameEntry fileEntry;
366  fileEntry.name = debug_line_data.GetCStr(offset_ptr);
367  fileEntry.dir_idx = debug_line_data.GetULEB128(offset_ptr);
368  fileEntry.mod_time = debug_line_data.GetULEB128(offset_ptr);
369  fileEntry.length = debug_line_data.GetULEB128(offset_ptr);
370  state.prologue->file_names.push_back(fileEntry);
371  }
372  break;
373 
374  default:
375  // Length doesn't include the zero opcode byte or the length itself,
376  // but it does include the sub_opcode, so we have to adjust for that
377  // below
378  (*offset_ptr) += arg_size;
379  break;
380  }
381  } else if (opcode < prologue->opcode_base) {
382  switch (opcode) {
383  // Standard Opcodes
384  case DW_LNS_copy:
385  // Takes no arguments. Append a row to the matrix using the current
386  // values of the state-machine registers. Then set the basic_block
387  // register to false.
388  state.AppendRowToMatrix(*offset_ptr);
389  break;
390 
391  case DW_LNS_advance_pc:
392  // Takes a single unsigned LEB128 operand, multiplies it by the
393  // min_inst_length field of the prologue, and adds the result to the
394  // address register of the state machine.
395  state.address +=
396  debug_line_data.GetULEB128(offset_ptr) * prologue->min_inst_length;
397  break;
398 
399  case DW_LNS_advance_line:
400  // Takes a single signed LEB128 operand and adds that value to the line
401  // register of the state machine.
402  state.line += debug_line_data.GetSLEB128(offset_ptr);
403  break;
404 
405  case DW_LNS_set_file:
406  // Takes a single unsigned LEB128 operand and stores it in the file
407  // register of the state machine.
408  state.file = debug_line_data.GetULEB128(offset_ptr);
409  break;
410 
411  case DW_LNS_set_column:
412  // Takes a single unsigned LEB128 operand and stores it in the column
413  // register of the state machine.
414  state.column = debug_line_data.GetULEB128(offset_ptr);
415  break;
416 
417  case DW_LNS_negate_stmt:
418  // Takes no arguments. Set the is_stmt register of the state machine to
419  // the logical negation of its current value.
420  state.is_stmt = !state.is_stmt;
421  break;
422 
423  case DW_LNS_set_basic_block:
424  // Takes no arguments. Set the basic_block register of the state
425  // machine to true
426  state.basic_block = true;
427  break;
428 
429  case DW_LNS_const_add_pc:
430  // Takes no arguments. Add to the address register of the state machine
431  // the address increment value corresponding to special opcode 255. The
432  // motivation for DW_LNS_const_add_pc is this: when the statement
433  // program needs to advance the address by a small amount, it can use a
434  // single special opcode, which occupies a single byte. When it needs
435  // to advance the address by up to twice the range of the last special
436  // opcode, it can use DW_LNS_const_add_pc followed by a special opcode,
437  // for a total of two bytes. Only if it needs to advance the address by
438  // more than twice that range will it need to use both
439  // DW_LNS_advance_pc and a special opcode, requiring three or more
440  // bytes.
441  {
442  uint8_t adjust_opcode = 255 - prologue->opcode_base;
443  dw_addr_t addr_offset = (adjust_opcode / prologue->line_range) *
444  prologue->min_inst_length;
445  state.address += addr_offset;
446  }
447  break;
448 
449  case DW_LNS_fixed_advance_pc:
450  // Takes a single uhalf operand. Add to the address register of the
451  // state machine the value of the (unencoded) operand. This is the only
452  // extended opcode that takes an argument that is not a variable length
453  // number. The motivation for DW_LNS_fixed_advance_pc is this: existing
454  // assemblers cannot emit DW_LNS_advance_pc or special opcodes because
455  // they cannot encode LEB128 numbers or judge when the computation of a
456  // special opcode overflows and requires the use of DW_LNS_advance_pc.
457  // Such assemblers, however, can use DW_LNS_fixed_advance_pc instead,
458  // sacrificing compression.
459  state.address += debug_line_data.GetU16(offset_ptr);
460  break;
461 
462  case DW_LNS_set_prologue_end:
463  // Takes no arguments. Set the prologue_end register of the state
464  // machine to true
465  state.prologue_end = true;
466  break;
467 
468  case DW_LNS_set_epilogue_begin:
469  // Takes no arguments. Set the basic_block register of the state
470  // machine to true
471  state.epilogue_begin = true;
472  break;
473 
474  case DW_LNS_set_isa:
475  // Takes a single unsigned LEB128 operand and stores it in the column
476  // register of the state machine.
477  state.isa = debug_line_data.GetULEB128(offset_ptr);
478  break;
479 
480  default:
481  // Handle any unknown standard opcodes here. We know the lengths of
482  // such opcodes because they are specified in the prologue as a
483  // multiple of LEB128 operands for each opcode.
484  {
485  uint8_t i;
486  assert(static_cast<size_t>(opcode - 1) <
487  prologue->standard_opcode_lengths.size());
488  const uint8_t opcode_length =
489  prologue->standard_opcode_lengths[opcode - 1];
490  for (i = 0; i < opcode_length; ++i)
491  debug_line_data.Skip_LEB128(offset_ptr);
492  }
493  break;
494  }
495  } else {
496  // Special Opcodes
497 
498  // A special opcode value is chosen based on the amount that needs
499  // to be added to the line and address registers. The maximum line
500  // increment for a special opcode is the value of the line_base field in
501  // the header, plus the value of the line_range field, minus 1 (line base
502  // + line range - 1). If the desired line increment is greater than the
503  // maximum line increment, a standard opcode must be used instead of a
504  // special opcode. The "address advance" is calculated by dividing the
505  // desired address increment by the minimum_instruction_length field from
506  // the header. The special opcode is then calculated using the following
507  // formula:
508  //
509  // opcode = (desired line increment - line_base) + (line_range * address
510  // advance) + opcode_base
511  //
512  // If the resulting opcode is greater than 255, a standard opcode must be
513  // used instead.
514  //
515  // To decode a special opcode, subtract the opcode_base from the opcode
516  // itself to give the adjusted opcode. The amount to increment the
517  // address register is the result of the adjusted opcode divided by the
518  // line_range multiplied by the minimum_instruction_length field from the
519  // header. That is:
520  //
521  // address increment = (adjusted opcode / line_range) *
522  // minimum_instruction_length
523  //
524  // The amount to increment the line register is the line_base plus the
525  // result of the adjusted opcode modulo the line_range. That is:
526  //
527  // line increment = line_base + (adjusted opcode % line_range)
528 
529  uint8_t adjust_opcode = opcode - prologue->opcode_base;
530  dw_addr_t addr_offset =
531  (adjust_opcode / prologue->line_range) * prologue->min_inst_length;
532  int32_t line_offset =
533  prologue->line_base + (adjust_opcode % prologue->line_range);
534  state.line += line_offset;
535  state.address += addr_offset;
536  state.AppendRowToMatrix(*offset_ptr);
537  }
538  }
539 
540  state.Finalize(*offset_ptr);
541 
542  return end_offset;
543 }
544 
545 // ParseStatementTableCallback
547  const DWARFDebugLine::State &state,
548  void *userData) {
549  DWARFDebugLine::LineTable *line_table = (DWARFDebugLine::LineTable *)userData;
551  // Just started parsing the line table, so lets keep a reference to the
552  // prologue using the supplied shared pointer
553  line_table->prologue = state.prologue;
554  } else if (state.row == DWARFDebugLine::State::DoneParsingLineTable) {
555  // Done parsing line table, nothing to do for the cleanup
556  } else {
557  // We have a new row, lets append it
558  line_table->AppendRow(state);
559  }
560 }
561 
562 // ParseStatementTable
563 //
564 // Parse a line table at offset and populate the LineTable class with the
565 // prologue and all rows.
567  const DWARFDataExtractor &debug_line_data, lldb::offset_t *offset_ptr,
568  LineTable *line_table, DWARFUnit *dwarf_cu) {
569  return ParseStatementTable(debug_line_data, offset_ptr,
570  ParseStatementTableCallback, line_table, dwarf_cu);
571 }
572 
574  return SymbolFileDWARF::SupportedVersion(version);
575 }
576 
577 // DWARFDebugLine::Prologue::Dump
579  uint32_t i;
580 
581  log->Printf("Line table prologue:");
582  log->Printf(" total_length: 0x%8.8x", total_length);
583  log->Printf(" version: %u", version);
584  log->Printf("prologue_length: 0x%8.8x", prologue_length);
585  log->Printf("min_inst_length: %u", min_inst_length);
586  log->Printf("default_is_stmt: %u", default_is_stmt);
587  log->Printf(" line_base: %i", line_base);
588  log->Printf(" line_range: %u", line_range);
589  log->Printf(" opcode_base: %u", opcode_base);
590 
591  for (i = 0; i < standard_opcode_lengths.size(); ++i) {
592  log->Printf("standard_opcode_lengths[%s] = %u", DW_LNS_value_to_name(i + 1),
593  standard_opcode_lengths[i]);
594  }
595 
596  if (!include_directories.empty()) {
597  for (i = 0; i < include_directories.size(); ++i) {
598  log->Printf("include_directories[%3u] = '%s'", i + 1,
599  include_directories[i]);
600  }
601  }
602 
603  if (!file_names.empty()) {
604  log->PutCString(" Dir Mod Time File Len File Name");
605  log->PutCString(" ---- ---------- ---------- "
606  "---------------------------");
607  for (i = 0; i < file_names.size(); ++i) {
608  const FileNameEntry &fileEntry = file_names[i];
609  log->Printf("file_names[%3u] %4u 0x%8.8x 0x%8.8x %s", i + 1,
610  fileEntry.dir_idx, fileEntry.mod_time, fileEntry.length,
611  fileEntry.name);
612  }
613  }
614 }
615 
616 // DWARFDebugLine::ParsePrologue::Append
617 //
618 // Append the contents of the prologue to the binary stream buffer
619 // void
620 // DWARFDebugLine::Prologue::Append(BinaryStreamBuf& buff) const
621 //{
622 // uint32_t i;
623 //
624 // buff.Append32(total_length);
625 // buff.Append16(version);
626 // buff.Append32(prologue_length);
627 // buff.Append8(min_inst_length);
628 // buff.Append8(default_is_stmt);
629 // buff.Append8(line_base);
630 // buff.Append8(line_range);
631 // buff.Append8(opcode_base);
632 //
633 // for (i=0; i<standard_opcode_lengths.size(); ++i)
634 // buff.Append8(standard_opcode_lengths[i]);
635 //
636 // for (i=0; i<include_directories.size(); ++i)
637 // buff.AppendCStr(include_directories[i].c_str());
638 // buff.Append8(0); // Terminate the include directory section with empty
639 // string
640 //
641 // for (i=0; i<file_names.size(); ++i)
642 // {
643 // buff.AppendCStr(file_names[i].name.c_str());
644 // buff.Append32_as_ULEB128(file_names[i].dir_idx);
645 // buff.Append32_as_ULEB128(file_names[i].mod_time);
646 // buff.Append32_as_ULEB128(file_names[i].length);
647 // }
648 // buff.Append8(0); // Terminate the file names section with empty string
649 //}
650 
652  const FileSpec &comp_dir,
653  FileSpec::Style style,
654  FileSpec &file) const {
655  uint32_t idx = file_idx - 1; // File indexes are 1 based...
656  if (idx < file_names.size()) {
657  file.SetFile(file_names[idx].name, style);
658  if (file.IsRelative()) {
659  if (file_names[idx].dir_idx > 0) {
660  const uint32_t dir_idx = file_names[idx].dir_idx - 1;
661  if (dir_idx < include_directories.size()) {
662  file.PrependPathComponent(include_directories[dir_idx]);
663  if (!file.IsRelative())
664  return true;
665  }
666  }
667 
668  if (comp_dir)
669  file.PrependPathComponent(comp_dir);
670  }
671  return true;
672  }
673  return false;
674 }
675 
677  rows.push_back(state);
678 }
679 
680 // Compare function for the binary search in
681 // DWARFDebugLine::LineTable::LookupAddress()
682 static bool FindMatchingAddress(const DWARFDebugLine::Row &row1,
683  const DWARFDebugLine::Row &row2) {
684  return row1.address < row2.address;
685 }
686 
687 // DWARFDebugLine::LineTable::LookupAddress
689  dw_addr_t cu_high_pc) const {
690  uint32_t index = UINT32_MAX;
691  if (!rows.empty()) {
692  // Use the lower_bound algorithm to perform a binary search since we know
693  // that our line table data is ordered by address.
695  row.address = address;
696  Row::const_iterator begin_pos = rows.begin();
697  Row::const_iterator end_pos = rows.end();
698  Row::const_iterator pos =
699  lower_bound(begin_pos, end_pos, row, FindMatchingAddress);
700  if (pos == end_pos) {
701  if (address < cu_high_pc)
702  return rows.size() - 1;
703  } else {
704  // Rely on fact that we are using a std::vector and we can do pointer
705  // arithmetic to find the row index (which will be one less that what we
706  // found since it will find the first position after the current address)
707  // since std::vector iterators are just pointers to the container type.
708  index = pos - begin_pos;
709  if (pos->address > address) {
710  if (index > 0)
711  --index;
712  else
713  index = UINT32_MAX;
714  }
715  }
716  }
717  return index; // Failed to find address
718 }
719 
720 // DWARFDebugLine::Row::Row
721 DWARFDebugLine::Row::Row(bool default_is_stmt)
722  : address(0), line(1), column(0), file(1), is_stmt(default_is_stmt),
723  basic_block(false), end_sequence(false), prologue_end(false),
724  epilogue_begin(false), isa(0) {}
725 
726 // Called after a row is appended to the matrix
728  basic_block = false;
729  prologue_end = false;
730  epilogue_begin = false;
731 }
732 
733 // DWARFDebugLine::Row::Reset
734 void DWARFDebugLine::Row::Reset(bool default_is_stmt) {
735  address = 0;
736  line = 1;
737  column = 0;
738  file = 1;
739  is_stmt = default_is_stmt;
740  basic_block = false;
741  end_sequence = false;
742  prologue_end = false;
743  epilogue_begin = false;
744  isa = 0;
745 }
746 // DWARFDebugLine::Row::Dump
747 void DWARFDebugLine::Row::Dump(Log *log) const {
748  log->Printf("0x%16.16" PRIx64 " %6u %6u %6u %3u %s%s%s%s%s", address, line,
749  column, file, isa, is_stmt ? " is_stmt" : "",
750  basic_block ? " basic_block" : "",
751  prologue_end ? " prologue_end" : "",
752  epilogue_begin ? " epilogue_begin" : "",
753  end_sequence ? " end_sequence" : "");
754 }
755 
756 // Compare function LineTable structures
758  const DWARFDebugLine::Row &b) {
759  return a.address < b.address;
760 }
761 
762 // Insert a row at the correct address if the addresses can be out of order
763 // which can only happen when we are linking a line table that may have had
764 // it's contents rearranged.
766  const Row &state) {
767  // If we don't have anything yet, or if the address of the last state in our
768  // line table is less than the current one, just append the current state
769  if (state_coll.empty() || AddressLessThan(state_coll.back(), state)) {
770  state_coll.push_back(state);
771  } else {
772  // Do a binary search for the correct entry
773  pair<Row::iterator, Row::iterator> range(equal_range(
774  state_coll.begin(), state_coll.end(), state, AddressLessThan));
775 
776  // If the addresses are equal, we can safely replace the previous entry
777  // with the current one if the one it is replacing is an end_sequence
778  // entry. We currently always place an extra end sequence when ever we exit
779  // a valid address range for a function in case the functions get
780  // rearranged by optimizations or by order specifications. These extra end
781  // sequences will disappear by getting replaced with valid consecutive
782  // entries within a compile unit if there are no gaps.
783  if (range.first == range.second) {
784  state_coll.insert(range.first, state);
785  } else {
786  if ((distance(range.first, range.second) == 1) &&
787  range.first->end_sequence == true) {
788  *range.first = state;
789  } else {
790  state_coll.insert(range.second, state);
791  }
792  }
793  }
794 }
795 
796 // DWARFDebugLine::State::State
798  DWARFDebugLine::State::Callback cb, void *userData)
799  : Row(p->default_is_stmt), prologue(p), log(l), callback(cb),
800  callbackUserData(userData), row(StartParsingLineTable) {
801  // Call the callback with the initial row state of zero for the prologue
802  if (callback)
803  callback(0, *this, callbackUserData);
804 }
805 
806 // DWARFDebugLine::State::Reset
807 void DWARFDebugLine::State::Reset() { Row::Reset(prologue->default_is_stmt); }
808 
809 // DWARFDebugLine::State::AppendRowToMatrix
811  // Each time we are to add an entry into the line table matrix call the
812  // callback function so that someone can do something with the current state
813  // of the state machine (like build a line table or dump the line table!)
814  if (log) {
815  if (row == 0) {
816  log->PutCString("Address Line Column File ISA Flags");
817  log->PutCString(
818  "------------------ ------ ------ ------ --- -------------");
819  }
820  Dump(log);
821  }
822 
823  ++row; // Increase the row number before we call our callback for a real row
824  if (callback)
825  callback(offset, *this, callbackUserData);
826  PostAppend();
827 }
828 
829 // DWARFDebugLine::State::Finalize
831  // Call the callback with a special row state when we are done parsing a line
832  // table
834  if (callback)
835  callback(offset, *this, callbackUserData);
836 }
837 
838 // void
839 // DWARFDebugLine::AppendLineTableData
840 //(
841 // const DWARFDebugLine::Prologue* prologue,
842 // const DWARFDebugLine::Row::collection& state_coll,
843 // const uint32_t addr_size,
844 // BinaryStreamBuf &debug_line_data
845 //)
846 //{
847 // if (state_coll.empty())
848 // {
849 // // We have no entries, just make an empty line table
850 // debug_line_data.Append8(0);
851 // debug_line_data.Append8(1);
852 // debug_line_data.Append8(DW_LNE_end_sequence);
853 // }
854 // else
855 // {
856 // DWARFDebugLine::Row::const_iterator pos;
857 // Row::const_iterator end = state_coll.end();
858 // bool default_is_stmt = prologue->default_is_stmt;
859 // const DWARFDebugLine::Row reset_state(default_is_stmt);
860 // const DWARFDebugLine::Row* prev_state = &reset_state;
861 // const int32_t max_line_increment_for_special_opcode =
862 // prologue->MaxLineIncrementForSpecialOpcode();
863 // for (pos = state_coll.begin(); pos != end; ++pos)
864 // {
865 // const DWARFDebugLine::Row& curr_state = *pos;
866 // int32_t line_increment = 0;
867 // dw_addr_t addr_offset = curr_state.address - prev_state->address;
868 // dw_addr_t addr_advance = (addr_offset) / prologue->min_inst_length;
869 // line_increment = (int32_t)(curr_state.line - prev_state->line);
870 //
871 // // If our previous state was the reset state, then let's emit the
872 // // address to keep GDB's DWARF parser happy. If we don't start each
873 // // sequence with a DW_LNE_set_address opcode, the line table won't
874 // // get slid properly in GDB.
875 //
876 // if (prev_state == &reset_state)
877 // {
878 // debug_line_data.Append8(0); // Extended opcode
879 // debug_line_data.Append32_as_ULEB128(addr_size + 1); // Length of
880 // opcode bytes
881 // debug_line_data.Append8(DW_LNE_set_address);
882 // debug_line_data.AppendMax64(curr_state.address, addr_size);
883 // addr_advance = 0;
884 // }
885 //
886 // if (prev_state->file != curr_state.file)
887 // {
888 // debug_line_data.Append8(DW_LNS_set_file);
889 // debug_line_data.Append32_as_ULEB128(curr_state.file);
890 // }
891 //
892 // if (prev_state->column != curr_state.column)
893 // {
894 // debug_line_data.Append8(DW_LNS_set_column);
895 // debug_line_data.Append32_as_ULEB128(curr_state.column);
896 // }
897 //
898 // // Don't do anything fancy if we are at the end of a sequence
899 // // as we don't want to push any extra rows since the
900 // DW_LNE_end_sequence
901 // // will push a row itself!
902 // if (curr_state.end_sequence)
903 // {
904 // if (line_increment != 0)
905 // {
906 // debug_line_data.Append8(DW_LNS_advance_line);
907 // debug_line_data.Append32_as_SLEB128(line_increment);
908 // }
909 //
910 // if (addr_advance > 0)
911 // {
912 // debug_line_data.Append8(DW_LNS_advance_pc);
913 // debug_line_data.Append32_as_ULEB128(addr_advance);
914 // }
915 //
916 // // Now push the end sequence on!
917 // debug_line_data.Append8(0);
918 // debug_line_data.Append8(1);
919 // debug_line_data.Append8(DW_LNE_end_sequence);
920 //
921 // prev_state = &reset_state;
922 // }
923 // else
924 // {
925 // if (line_increment || addr_advance)
926 // {
927 // if (line_increment > max_line_increment_for_special_opcode)
928 // {
929 // debug_line_data.Append8(DW_LNS_advance_line);
930 // debug_line_data.Append32_as_SLEB128(line_increment);
931 // line_increment = 0;
932 // }
933 //
934 // uint32_t special_opcode = (line_increment >=
935 // prologue->line_base) ? ((line_increment -
936 // prologue->line_base) + (prologue->line_range * addr_advance)
937 // + prologue->opcode_base) : 256;
938 // if (special_opcode > 255)
939 // {
940 // // Both the address and line won't fit in one special
941 // opcode
942 // // check to see if just the line advance will?
943 // uint32_t special_opcode_line = ((line_increment >=
944 // prologue->line_base) && (line_increment != 0)) ?
945 // ((line_increment - prologue->line_base) +
946 // prologue->opcode_base) : 256;
947 //
948 //
949 // if (special_opcode_line > 255)
950 // {
951 // // Nope, the line advance won't fit by itself, check
952 // the address increment by itself
953 // uint32_t special_opcode_addr = addr_advance ?
954 // ((0 - prologue->line_base) +
955 // (prologue->line_range * addr_advance) +
956 // prologue->opcode_base) : 256;
957 //
958 // if (special_opcode_addr > 255)
959 // {
960 // // Neither the address nor the line will fit in
961 // a
962 // // special opcode, we must manually enter both
963 // then
964 // // do a DW_LNS_copy to push a row (special
965 // opcode
966 // // automatically imply a new row is pushed)
967 // if (line_increment != 0)
968 // {
969 // debug_line_data.Append8(DW_LNS_advance_line);
970 // debug_line_data.Append32_as_SLEB128(line_increment);
971 // }
972 //
973 // if (addr_advance > 0)
974 // {
975 // debug_line_data.Append8(DW_LNS_advance_pc);
976 // debug_line_data.Append32_as_ULEB128(addr_advance);
977 // }
978 //
979 // // Now push a row onto the line table manually
980 // debug_line_data.Append8(DW_LNS_copy);
981 //
982 // }
983 // else
984 // {
985 // // The address increment alone will fit into a
986 // special opcode
987 // // so modify our line change, then issue a
988 // special opcode
989 // // for the address increment and it will push a
990 // row into the
991 // // line table
992 // if (line_increment != 0)
993 // {
994 // debug_line_data.Append8(DW_LNS_advance_line);
995 // debug_line_data.Append32_as_SLEB128(line_increment);
996 // }
997 //
998 // // Advance of line and address will fit into a
999 // single byte special opcode
1000 // // and this will also push a row onto the line
1001 // table
1002 // debug_line_data.Append8(special_opcode_addr);
1003 // }
1004 // }
1005 // else
1006 // {
1007 // // The line change alone will fit into a special
1008 // opcode
1009 // // so modify our address increment first, then issue
1010 // a
1011 // // special opcode for the line change and it will
1012 // push
1013 // // a row into the line table
1014 // if (addr_advance > 0)
1015 // {
1016 // debug_line_data.Append8(DW_LNS_advance_pc);
1017 // debug_line_data.Append32_as_ULEB128(addr_advance);
1018 // }
1019 //
1020 // // Advance of line and address will fit into a
1021 // single byte special opcode
1022 // // and this will also push a row onto the line table
1023 // debug_line_data.Append8(special_opcode_line);
1024 // }
1025 // }
1026 // else
1027 // {
1028 // // Advance of line and address will fit into a single
1029 // byte special opcode
1030 // // and this will also push a row onto the line table
1031 // debug_line_data.Append8(special_opcode);
1032 // }
1033 // }
1034 // prev_state = &curr_state;
1035 // }
1036 // }
1037 // }
1038 //}
static void Insert(Row::collection &state_coll, const Row &state)
Enumerations for broadcasting.
Definition: SBLaunchInfo.h:14
const char * AsCString() const
static bool ParseStatementTable(const lldb_private::DWARFDataExtractor &debug_line_data, lldb::offset_t *offset_ptr, State::Callback callback, void *userData, DWARFUnit *dwarf_cu)
const char * DW_LNS_value_to_name(uint32_t val)
const char * GetCStr(lldb::offset_t *offset_ptr) const
Extract a C string from *offset_ptr.
std::vector< const char * > include_directories
uint32_t GetU32(lldb::offset_t *offset_ptr) const
Extract a uint32_t value from *offset_ptr.
void Error(const char *fmt,...) __attribute__((format(printf
Definition: Log.cpp:137
void PrependPathComponent(llvm::StringRef component)
Definition: FileSpec.cpp:449
State(Prologue::shared_ptr &prologue_sp, lldb_private::Log *log, Callback callback, void *userData)
static bool AddressLessThan(const DWARFDebugLine::Row &a, const DWARFDebugLine::Row &b)
collection::const_iterator const_iterator
A file utility class.
Definition: FileSpec.h:55
void ParseIfNeeded(const lldb_private::DWARFDataExtractor &debug_line_data)
A timer class that simplifies common timing metrics.
Definition: Timer.h:23
int64_t GetSLEB128(lldb::offset_t *offset_ptr) const
Extract a signed LEB128 value from *offset_ptr.
std::vector< uint8_t > standard_opcode_lengths
uint64_t dw_addr_t
Definition: dwarf.h:26
static bool SupportedVersion(uint16_t version)
lldb_private::FileSpec::Style GetPathStyle()
Definition: DWARFUnit.cpp:696
void(* Callback)(dw_offset_t offset, const State &state, void *userData)
std::vector< Row > collection
uint64_t GetDWARFInitialLength(lldb::offset_t *offset_ptr) const
static void ParseStatementTableCallback(dw_offset_t offset, const DWARFDebugLine::State &state, void *userData)
#define UINT32_MAX
Definition: lldb-defines.h:31
bool ExtractValue(const lldb_private::DWARFDataExtractor &data, lldb::offset_t *offset_ptr)
Node * Parse(llvm::StringRef expr, llvm::BumpPtrAllocator &alloc)
Parse the given postfix expression.
uint64_t offset_t
Definition: lldb-types.h:87
void AppendRow(const DWARFDebugLine::Row &state)
uint32_t LookupAddress(dw_addr_t address, dw_addr_t cu_high_pc) const
void Finalize(dw_offset_t offset)
LineTableMap::const_iterator LineTableConstIter
uint8_t maximum_operations_per_instruction
static bool ParsePrologue(const lldb_private::DWARFDataExtractor &debug_line_data, lldb::offset_t *offset_ptr, Prologue *prologue, DWARFUnit *dwarf_cu=nullptr)
lldb_private::Log * log
uint64_t Unsigned() const
void Dump(lldb_private::Log *log) const
std::shared_ptr< Prologue > shared_ptr
const lldb_private::FileSpec & GetCompilationDirectory()
Definition: DWARFUnit.cpp:702
Prologue::shared_ptr prologue
bool ValidOffset(lldb::offset_t offset) const
Test the validity of offset.
std::shared_ptr< LineTable > shared_ptr
llvm::sys::path::Style Style
Definition: FileSpec.h:57
void Dump(lldb_private::Log *log)
bool GetFile(uint32_t file_idx, const lldb_private::FileSpec &cu_comp_dir, lldb_private::FileSpec::Style style, lldb_private::FileSpec &file) const
void AppendRowToMatrix(dw_offset_t offset)
LineTable::shared_ptr GetLineTable(const dw_offset_t offset) const
void PutCString(const char *cstr)
Definition: Log.cpp:109
Definition: SBAddress.h:15
llvm::MD5::MD5Result checksum
dw_offset_t GetDWARFOffset(lldb::offset_t *offset_ptr) const
bool SkipValue(const lldb_private::DWARFDataExtractor &debug_info_data, lldb::offset_t *offset_ptr) const
#define DWARF_LOG_DEBUG_LINE
Prologue::shared_ptr prologue
int32_t dw_sleb128_t
Definition: dwarf.h:22
uint64_t GetULEB128(lldb::offset_t *offset_ptr) const
Extract a unsigned LEB128 value from *offset_ptr.
uint8_t GetU8(lldb::offset_t *offset_ptr) const
Extract a uint8_t value from *offset_ptr.
bool IsRelative() const
Returns true if the filespec represents a relative path.
Definition: FileSpec.cpp:503
uint32_t Skip_LEB128(lldb::offset_t *offset_ptr) const
Skip an LEB128 number at *offset_ptr.
void SetFile(llvm::StringRef path, Style style)
Change the file specified with a new path.
Definition: FileSpec.cpp:198
static void Parse(const lldb_private::DWARFDataExtractor &debug_line_data, DWARFDebugLine::State::Callback callback, void *userData)
static bool ParseSupportFiles(const lldb::ModuleSP &module_sp, const lldb_private::DWARFDataExtractor &debug_line_data, dw_offset_t stmt_list, lldb_private::FileSpecList &support_files, DWARFUnit *dwarf_cu)
size_t GetPath(char *path, size_t max_path_length, bool denormalize=true) const
Extract the full path to the file.
Definition: FileSpec.cpp:376
const uint8_t * BlockData() const
void Printf(const char *format,...) __attribute__((format(printf
Definition: Log.cpp:113
uint16_t GetU16(lldb::offset_t *offset_ptr) const
Extract a uint16_t value from *offset_ptr.
std::vector< FileNameEntry > file_names
Row(bool default_is_stmt=false)
void Reset(bool default_is_stmt)
uint64_t GetU64(lldb::offset_t *offset_ptr) const
Extract a uint64_t value from *offset_ptr.
static bool FindMatchingAddress(const DWARFDebugLine::Row &row1, const DWARFDebugLine::Row &row2)