LLVM  8.0.0svn
MCDwarf.h
Go to the documentation of this file.
1 //===- MCDwarf.h - Machine Code Dwarf support -------------------*- C++ -*-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file contains the declaration of the MCDwarfFile to support the dwarf
11 // .file directive and the .loc directive.
12 //
13 //===----------------------------------------------------------------------===//
14 
15 #ifndef LLVM_MC_MCDWARF_H
16 #define LLVM_MC_MCDWARF_H
17 
18 #include "llvm/ADT/MapVector.h"
19 #include "llvm/ADT/Optional.h"
20 #include "llvm/ADT/SmallVector.h"
21 #include "llvm/ADT/StringMap.h"
22 #include "llvm/ADT/StringRef.h"
23 #include "llvm/MC/MCSection.h"
24 #include "llvm/Support/Error.h"
25 #include "llvm/Support/MD5.h"
26 #include <cassert>
27 #include <cstdint>
28 #include <string>
29 #include <utility>
30 #include <vector>
31 
32 namespace llvm {
33 
34 template <typename T> class ArrayRef;
35 class MCAsmBackend;
36 class MCContext;
37 class MCDwarfLineStr;
38 class MCObjectStreamer;
39 class MCStreamer;
40 class MCSymbol;
41 class raw_ostream;
42 class SMLoc;
43 class SourceMgr;
44 
45 /// Instances of this class represent the name of the dwarf
46 /// .file directive and its associated dwarf file number in the MC file,
47 /// and MCDwarfFile's are created and uniqued by the MCContext class where
48 /// the file number for each is its index into the vector of DwarfFiles (note
49 /// index 0 is not used and not a valid dwarf file number).
50 struct MCDwarfFile {
51  // The base name of the file without its directory path.
52  std::string Name;
53 
54  // The index into the list of directory names for this file name.
55  unsigned DirIndex;
56 
57  /// The MD5 checksum, if there is one. Non-owning pointer to data allocated
58  /// in MCContext.
60 
61  /// The source code of the file. Non-owning reference to data allocated in
62  /// MCContext.
64 };
65 
66 /// Instances of this class represent the information from a
67 /// dwarf .loc directive.
68 class MCDwarfLoc {
69  uint32_t FileNum;
70  uint32_t Line;
71  uint16_t Column;
72  // Flags (see #define's below)
73  uint8_t Flags;
74  uint8_t Isa;
75  uint32_t Discriminator;
76 
77 // Flag that indicates the initial value of the is_stmt_start flag.
78 #define DWARF2_LINE_DEFAULT_IS_STMT 1
79 
80 #define DWARF2_FLAG_IS_STMT (1 << 0)
81 #define DWARF2_FLAG_BASIC_BLOCK (1 << 1)
82 #define DWARF2_FLAG_PROLOGUE_END (1 << 2)
83 #define DWARF2_FLAG_EPILOGUE_BEGIN (1 << 3)
84 
85 private: // MCContext manages these
86  friend class MCContext;
87  friend class MCDwarfLineEntry;
88 
89  MCDwarfLoc(unsigned fileNum, unsigned line, unsigned column, unsigned flags,
90  unsigned isa, unsigned discriminator)
91  : FileNum(fileNum), Line(line), Column(column), Flags(flags), Isa(isa),
92  Discriminator(discriminator) {}
93 
94  // Allow the default copy constructor and assignment operator to be used
95  // for an MCDwarfLoc object.
96 
97 public:
98  /// Get the FileNum of this MCDwarfLoc.
99  unsigned getFileNum() const { return FileNum; }
100 
101  /// Get the Line of this MCDwarfLoc.
102  unsigned getLine() const { return Line; }
103 
104  /// Get the Column of this MCDwarfLoc.
105  unsigned getColumn() const { return Column; }
106 
107  /// Get the Flags of this MCDwarfLoc.
108  unsigned getFlags() const { return Flags; }
109 
110  /// Get the Isa of this MCDwarfLoc.
111  unsigned getIsa() const { return Isa; }
112 
113  /// Get the Discriminator of this MCDwarfLoc.
114  unsigned getDiscriminator() const { return Discriminator; }
115 
116  /// Set the FileNum of this MCDwarfLoc.
117  void setFileNum(unsigned fileNum) { FileNum = fileNum; }
118 
119  /// Set the Line of this MCDwarfLoc.
120  void setLine(unsigned line) { Line = line; }
121 
122  /// Set the Column of this MCDwarfLoc.
123  void setColumn(unsigned column) {
124  assert(column <= UINT16_MAX);
125  Column = column;
126  }
127 
128  /// Set the Flags of this MCDwarfLoc.
129  void setFlags(unsigned flags) {
130  assert(flags <= UINT8_MAX);
131  Flags = flags;
132  }
133 
134  /// Set the Isa of this MCDwarfLoc.
135  void setIsa(unsigned isa) {
136  assert(isa <= UINT8_MAX);
137  Isa = isa;
138  }
139 
140  /// Set the Discriminator of this MCDwarfLoc.
141  void setDiscriminator(unsigned discriminator) {
142  Discriminator = discriminator;
143  }
144 };
145 
146 /// Instances of this class represent the line information for
147 /// the dwarf line table entries. Which is created after a machine
148 /// instruction is assembled and uses an address from a temporary label
149 /// created at the current address in the current section and the info from
150 /// the last .loc directive seen as stored in the context.
151 class MCDwarfLineEntry : public MCDwarfLoc {
152  MCSymbol *Label;
153 
154 private:
155  // Allow the default copy constructor and assignment operator to be used
156  // for an MCDwarfLineEntry object.
157 
158 public:
159  // Constructor to create an MCDwarfLineEntry given a symbol and the dwarf loc.
161  : MCDwarfLoc(loc), Label(label) {}
162 
163  MCSymbol *getLabel() const { return Label; }
164 
165  // This is called when an instruction is assembled into the specified
166  // section and if there is information from the last .loc directive that
167  // has yet to have a line entry made for it is made.
168  static void Make(MCObjectStreamer *MCOS, MCSection *Section);
169 };
170 
171 /// Instances of this class represent the line information for a compile
172 /// unit where machine instructions have been assembled after seeing .loc
173 /// directives. This is the information used to build the dwarf line
174 /// table for a section.
176 public:
177  // Add an entry to this MCLineSection's line entries.
178  void addLineEntry(const MCDwarfLineEntry &LineEntry, MCSection *Sec) {
179  MCLineDivisions[Sec].push_back(LineEntry);
180  }
181 
182  using MCDwarfLineEntryCollection = std::vector<MCDwarfLineEntry>;
183  using iterator = MCDwarfLineEntryCollection::iterator;
184  using const_iterator = MCDwarfLineEntryCollection::const_iterator;
186 
187 private:
188  // A collection of MCDwarfLineEntry for each section.
189  MCLineDivisionMap MCLineDivisions;
190 
191 public:
192  // Returns the collection of MCDwarfLineEntry for a given Compile Unit ID.
194  return MCLineDivisions;
195  }
196 };
197 
199  /// First special line opcode - leave room for the standard opcodes.
200  /// Note: If you want to change this, you'll have to update the
201  /// "StandardOpcodeLengths" table that is emitted in
202  /// \c Emit().
203  uint8_t DWARF2LineOpcodeBase = 13;
204  /// Minimum line offset in a special line info. opcode. The value
205  /// -5 was chosen to give a reasonable range of values.
206  int8_t DWARF2LineBase = -5;
207  /// Range of line offsets in a special line info. opcode.
208  uint8_t DWARF2LineRange = 14;
209 };
210 
212  MCSymbol *Label = nullptr;
216  std::string CompilationDir;
218  bool HasSource = false;
219 private:
220  bool HasAllMD5 = true;
221  bool HasAnyMD5 = false;
222 
223 public:
224  MCDwarfLineTableHeader() = default;
225 
226  Expected<unsigned> tryGetFile(StringRef &Directory, StringRef &FileName,
229  unsigned FileNumber = 0);
230  std::pair<MCSymbol *, MCSymbol *>
231  Emit(MCStreamer *MCOS, MCDwarfLineTableParams Params,
232  Optional<MCDwarfLineStr> &LineStr) const;
233  std::pair<MCSymbol *, MCSymbol *>
234  Emit(MCStreamer *MCOS, MCDwarfLineTableParams Params,
235  ArrayRef<char> SpecialOpcodeLengths,
236  Optional<MCDwarfLineStr> &LineStr) const;
237  void resetMD5Usage() {
238  HasAllMD5 = true;
239  HasAnyMD5 = false;
240  }
241  void trackMD5Usage(bool MD5Used) {
242  HasAllMD5 &= MD5Used;
243  HasAnyMD5 |= MD5Used;
244  }
245  bool isMD5UsageConsistent() const {
246  return MCDwarfFiles.empty() || (HasAllMD5 == HasAnyMD5);
247  }
248 
249 private:
250  void emitV2FileDirTables(MCStreamer *MCOS) const;
251  void emitV5FileDirTables(MCStreamer *MCOS, Optional<MCDwarfLineStr> &LineStr,
252  StringRef CtxCompilationDir) const;
253 };
254 
256  MCDwarfLineTableHeader Header;
257 
258 public:
259  void maybeSetRootFile(StringRef Directory, StringRef FileName,
261  if (!Header.RootFile.Name.empty())
262  return;
263  Header.CompilationDir = Directory;
264  Header.RootFile.Name = FileName;
265  Header.RootFile.DirIndex = 0;
266  Header.RootFile.Checksum = Checksum;
267  Header.RootFile.Source = Source;
268  Header.trackMD5Usage(Checksum);
269  Header.HasSource = Source.hasValue();
270  }
271 
272  unsigned getFile(StringRef Directory, StringRef FileName,
274  return cantFail(Header.tryGetFile(Directory, FileName, Checksum, Source));
275  }
276 
277  void Emit(MCStreamer &MCOS, MCDwarfLineTableParams Params,
278  MCSection *Section) const;
279 };
280 
282  MCDwarfLineTableHeader Header;
283  MCLineSection MCLineSections;
284 
285 public:
286  // This emits the Dwarf file and the line tables for all Compile Units.
287  static void Emit(MCObjectStreamer *MCOS, MCDwarfLineTableParams Params);
288 
289  // This emits the Dwarf file and the line tables for a given Compile Unit.
290  void EmitCU(MCObjectStreamer *MCOS, MCDwarfLineTableParams Params,
291  Optional<MCDwarfLineStr> &LineStr) const;
292 
293  Expected<unsigned> tryGetFile(StringRef &Directory, StringRef &FileName,
296  unsigned FileNumber = 0);
297  unsigned getFile(StringRef &Directory, StringRef &FileName,
298  MD5::MD5Result *Checksum, Optional<StringRef> &Source,
299  unsigned FileNumber = 0) {
300  return cantFail(tryGetFile(Directory, FileName, Checksum, Source,
301  FileNumber));
302  }
303 
304  void setRootFile(StringRef Directory, StringRef FileName,
305  MD5::MD5Result *Checksum, Optional<StringRef> Source) {
306  Header.CompilationDir = Directory;
307  Header.RootFile.Name = FileName;
308  Header.RootFile.DirIndex = 0;
309  Header.RootFile.Checksum = Checksum;
310  Header.RootFile.Source = Source;
311  Header.trackMD5Usage(Checksum);
312  Header.HasSource = Source.hasValue();
313  }
314 
315  void resetRootFile() {
316  assert(Header.MCDwarfFiles.empty());
317  Header.RootFile.Name.clear();
318  Header.resetMD5Usage();
319  Header.HasSource = false;
320  }
321 
322  bool hasRootFile() const { return !Header.RootFile.Name.empty(); }
323 
324  // Report whether MD5 usage has been consistent (all-or-none).
325  bool isMD5UsageConsistent() const { return Header.isMD5UsageConsistent(); }
326 
327  MCSymbol *getLabel() const {
328  return Header.Label;
329  }
330 
331  void setLabel(MCSymbol *Label) {
332  Header.Label = Label;
333  }
334 
336  return Header.MCDwarfDirs;
337  }
338 
340  return Header.MCDwarfDirs;
341  }
342 
344  return Header.MCDwarfFiles;
345  }
346 
348  return Header.MCDwarfFiles;
349  }
350 
352  return MCLineSections;
353  }
355  return MCLineSections;
356  }
357 };
358 
360 public:
361  /// Utility function to encode a Dwarf pair of LineDelta and AddrDeltas.
362  static void Encode(MCContext &Context, MCDwarfLineTableParams Params,
363  int64_t LineDelta, uint64_t AddrDelta, raw_ostream &OS);
364 
365  /// Utility function to encode a Dwarf pair of LineDelta and AddrDeltas using
366  /// fixed length operands.
367  static bool FixedEncode(MCContext &Context,
368  MCDwarfLineTableParams Params,
369  int64_t LineDelta, uint64_t AddrDelta,
371 
372  /// Utility function to emit the encoding to a streamer.
373  static void Emit(MCStreamer *MCOS, MCDwarfLineTableParams Params,
374  int64_t LineDelta, uint64_t AddrDelta);
375 };
376 
378 public:
379  //
380  // When generating dwarf for assembly source files this emits the Dwarf
381  // sections.
382  //
383  static void Emit(MCStreamer *MCOS);
384 };
385 
386 // When generating dwarf for assembly source files this is the info that is
387 // needed to be gathered for each symbol that will have a dwarf label.
389 private:
390  // Name of the symbol without a leading underbar, if any.
391  StringRef Name;
392  // The dwarf file number this symbol is in.
393  unsigned FileNumber;
394  // The line number this symbol is at.
395  unsigned LineNumber;
396  // The low_pc for the dwarf label is taken from this symbol.
397  MCSymbol *Label;
398 
399 public:
400  MCGenDwarfLabelEntry(StringRef name, unsigned fileNumber, unsigned lineNumber,
401  MCSymbol *label)
402  : Name(name), FileNumber(fileNumber), LineNumber(lineNumber),
403  Label(label) {}
404 
405  StringRef getName() const { return Name; }
406  unsigned getFileNumber() const { return FileNumber; }
407  unsigned getLineNumber() const { return LineNumber; }
408  MCSymbol *getLabel() const { return Label; }
409 
410  // This is called when label is created when we are generating dwarf for
411  // assembly source files.
412  static void Make(MCSymbol *Symbol, MCStreamer *MCOS, SourceMgr &SrcMgr,
413  SMLoc &Loc);
414 };
415 
417 public:
418  enum OpType {
433  OpGnuArgsSize
434  };
435 
436 private:
438  MCSymbol *Label;
439  unsigned Register;
440  union {
441  int Offset;
442  unsigned Register2;
443  };
444  std::vector<char> Values;
445 
446  MCCFIInstruction(OpType Op, MCSymbol *L, unsigned R, int O, StringRef V)
447  : Operation(Op), Label(L), Register(R), Offset(O),
448  Values(V.begin(), V.end()) {
449  assert(Op != OpRegister);
450  }
451 
452  MCCFIInstruction(OpType Op, MCSymbol *L, unsigned R1, unsigned R2)
453  : Operation(Op), Label(L), Register(R1), Register2(R2) {
454  assert(Op == OpRegister);
455  }
456 
457 public:
458  /// .cfi_def_cfa defines a rule for computing CFA as: take address from
459  /// Register and add Offset to it.
460  static MCCFIInstruction createDefCfa(MCSymbol *L, unsigned Register,
461  int Offset) {
462  return MCCFIInstruction(OpDefCfa, L, Register, -Offset, "");
463  }
464 
465  /// .cfi_def_cfa_register modifies a rule for computing CFA. From now
466  /// on Register will be used instead of the old one. Offset remains the same.
467  static MCCFIInstruction createDefCfaRegister(MCSymbol *L, unsigned Register) {
468  return MCCFIInstruction(OpDefCfaRegister, L, Register, 0, "");
469  }
470 
471  /// .cfi_def_cfa_offset modifies a rule for computing CFA. Register
472  /// remains the same, but offset is new. Note that it is the absolute offset
473  /// that will be added to a defined register to the compute CFA address.
475  return MCCFIInstruction(OpDefCfaOffset, L, 0, -Offset, "");
476  }
477 
478  /// .cfi_adjust_cfa_offset Same as .cfi_def_cfa_offset, but
479  /// Offset is a relative value that is added/subtracted from the previous
480  /// offset.
481  static MCCFIInstruction createAdjustCfaOffset(MCSymbol *L, int Adjustment) {
482  return MCCFIInstruction(OpAdjustCfaOffset, L, 0, Adjustment, "");
483  }
484 
485  /// .cfi_offset Previous value of Register is saved at offset Offset
486  /// from CFA.
487  static MCCFIInstruction createOffset(MCSymbol *L, unsigned Register,
488  int Offset) {
489  return MCCFIInstruction(OpOffset, L, Register, Offset, "");
490  }
491 
492  /// .cfi_rel_offset Previous value of Register is saved at offset
493  /// Offset from the current CFA register. This is transformed to .cfi_offset
494  /// using the known displacement of the CFA register from the CFA.
495  static MCCFIInstruction createRelOffset(MCSymbol *L, unsigned Register,
496  int Offset) {
497  return MCCFIInstruction(OpRelOffset, L, Register, Offset, "");
498  }
499 
500  /// .cfi_register Previous value of Register1 is saved in
501  /// register Register2.
502  static MCCFIInstruction createRegister(MCSymbol *L, unsigned Register1,
503  unsigned Register2) {
504  return MCCFIInstruction(OpRegister, L, Register1, Register2);
505  }
506 
507  /// .cfi_window_save SPARC register window is saved.
509  return MCCFIInstruction(OpWindowSave, L, 0, 0, "");
510  }
511 
512  /// .cfi_restore says that the rule for Register is now the same as it
513  /// was at the beginning of the function, after all initial instructions added
514  /// by .cfi_startproc were executed.
515  static MCCFIInstruction createRestore(MCSymbol *L, unsigned Register) {
516  return MCCFIInstruction(OpRestore, L, Register, 0, "");
517  }
518 
519  /// .cfi_undefined From now on the previous value of Register can't be
520  /// restored anymore.
521  static MCCFIInstruction createUndefined(MCSymbol *L, unsigned Register) {
522  return MCCFIInstruction(OpUndefined, L, Register, 0, "");
523  }
524 
525  /// .cfi_same_value Current value of Register is the same as in the
526  /// previous frame. I.e., no restoration is needed.
527  static MCCFIInstruction createSameValue(MCSymbol *L, unsigned Register) {
528  return MCCFIInstruction(OpSameValue, L, Register, 0, "");
529  }
530 
531  /// .cfi_remember_state Save all current rules for all registers.
533  return MCCFIInstruction(OpRememberState, L, 0, 0, "");
534  }
535 
536  /// .cfi_restore_state Restore the previously saved state.
538  return MCCFIInstruction(OpRestoreState, L, 0, 0, "");
539  }
540 
541  /// .cfi_escape Allows the user to add arbitrary bytes to the unwind
542  /// info.
544  return MCCFIInstruction(OpEscape, L, 0, 0, Vals);
545  }
546 
547  /// A special wrapper for .cfi_escape that indicates GNU_ARGS_SIZE
549  return MCCFIInstruction(OpGnuArgsSize, L, 0, Size, "");
550  }
551 
552  OpType getOperation() const { return Operation; }
553  MCSymbol *getLabel() const { return Label; }
554 
555  unsigned getRegister() const {
556  assert(Operation == OpDefCfa || Operation == OpOffset ||
557  Operation == OpRestore || Operation == OpUndefined ||
558  Operation == OpSameValue || Operation == OpDefCfaRegister ||
559  Operation == OpRelOffset || Operation == OpRegister);
560  return Register;
561  }
562 
563  unsigned getRegister2() const {
564  assert(Operation == OpRegister);
565  return Register2;
566  }
567 
568  int getOffset() const {
569  assert(Operation == OpDefCfa || Operation == OpOffset ||
570  Operation == OpRelOffset || Operation == OpDefCfaOffset ||
571  Operation == OpAdjustCfaOffset || Operation == OpGnuArgsSize);
572  return Offset;
573  }
574 
576  assert(Operation == OpEscape);
577  return StringRef(&Values[0], Values.size());
578  }
579 };
580 
582  MCDwarfFrameInfo() = default;
583 
584  MCSymbol *Begin = nullptr;
585  MCSymbol *End = nullptr;
586  const MCSymbol *Personality = nullptr;
587  const MCSymbol *Lsda = nullptr;
588  std::vector<MCCFIInstruction> Instructions;
589  unsigned CurrentCfaRegister = 0;
590  unsigned PersonalityEncoding = 0;
591  unsigned LsdaEncoding = 0;
592  uint32_t CompactUnwindEncoding = 0;
593  bool IsSignalFrame = false;
594  bool IsSimple = false;
595  unsigned RAReg = static_cast<unsigned>(INT_MAX);
596 };
597 
599 public:
600  //
601  // This emits the frame info section.
602  //
603  static void Emit(MCObjectStreamer &streamer, MCAsmBackend *MAB, bool isEH);
604  static void EmitAdvanceLoc(MCObjectStreamer &Streamer, uint64_t AddrDelta);
605  static void EncodeAdvanceLoc(MCContext &Context, uint64_t AddrDelta,
606  raw_ostream &OS);
607 };
608 
609 } // end namespace llvm
610 
611 #endif // LLVM_MC_MCDWARF_H
void cantFail(Error Err, const char *Msg=nullptr)
Report a fatal error if Err is a failure value.
Definition: Error.h:704
Instances of this class represent a uniqued identifier for a section in the current translation unit...
Definition: MCSection.h:39
const_iterator end(StringRef path)
Get end iterator over path.
Definition: Path.cpp:259
unsigned getLine() const
Get the Line of this MCDwarfLoc.
Definition: MCDwarf.h:102
LLVMContext & Context
const_iterator begin(StringRef path, Style style=Style::native)
Get begin iterator over path.
Definition: Path.cpp:250
MCDwarfLineEntryCollection::iterator iterator
Definition: MCDwarf.h:183
Optional< StringRef > Source
The source code of the file.
Definition: MCDwarf.h:63
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
SmallVectorImpl< std::string > & getMCDwarfDirs()
Definition: MCDwarf.h:339
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition: MCSymbol.h:42
static MCCFIInstruction createRememberState(MCSymbol *L)
.cfi_remember_state Save all current rules for all registers.
Definition: MCDwarf.h:532
SourceMgr SrcMgr
Definition: Error.cpp:24
static MCCFIInstruction createOffset(MCSymbol *L, unsigned Register, int Offset)
.cfi_offset Previous value of Register is saved at offset Offset from CFA.
Definition: MCDwarf.h:487
const SmallVectorImpl< std::string > & getMCDwarfDirs() const
Definition: MCDwarf.h:335
unsigned getFlags() const
Get the Flags of this MCDwarfLoc.
Definition: MCDwarf.h:108
SmallVectorImpl< MCDwarfFile > & getMCDwarfFiles()
Definition: MCDwarf.h:347
#define R2(n)
void setIsa(unsigned isa)
Set the Isa of this MCDwarfLoc.
Definition: MCDwarf.h:135
static MCCFIInstruction createDefCfaOffset(MCSymbol *L, int Offset)
.cfi_def_cfa_offset modifies a rule for computing CFA.
Definition: MCDwarf.h:474
static MCCFIInstruction createAdjustCfaOffset(MCSymbol *L, int Adjustment)
.cfi_adjust_cfa_offset Same as .cfi_def_cfa_offset, but Offset is a relative value that is added/subt...
Definition: MCDwarf.h:481
std::vector< MCDwarfLineEntry > MCDwarfLineEntryCollection
Definition: MCDwarf.h:182
MCDwarfLineEntry(MCSymbol *label, const MCDwarfLoc loc)
Definition: MCDwarf.h:160
std::vector< MCCFIInstruction > Instructions
Definition: MCDwarf.h:588
static MCCFIInstruction createUndefined(MCSymbol *L, unsigned Register)
.cfi_undefined From now on the previous value of Register can&#39;t be restored anymore.
Definition: MCDwarf.h:521
std::string Name
Definition: MCDwarf.h:52
bool isMD5UsageConsistent() const
Definition: MCDwarf.h:325
StringRef getName() const
Definition: MCDwarf.h:405
const MCLineDivisionMap & getMCLineEntries() const
Definition: MCDwarf.h:193
Tagged union holding either a T or a Error.
Definition: CachePruning.h:23
unsigned getFile(StringRef &Directory, StringRef &FileName, MD5::MD5Result *Checksum, Optional< StringRef > &Source, unsigned FileNumber=0)
Definition: MCDwarf.h:297
Context object for machine code objects.
Definition: MCContext.h:63
void setLine(unsigned line)
Set the Line of this MCDwarfLoc.
Definition: MCDwarf.h:120
unsigned getFile(StringRef Directory, StringRef FileName, MD5::MD5Result *Checksum, Optional< StringRef > Source)
Definition: MCDwarf.h:272
Streaming object file generation interface.
Instances of this class represent the information from a dwarf .loc directive.
Definition: MCDwarf.h:68
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory)...
Definition: APInt.h:33
unsigned getFileNumber() const
Definition: MCDwarf.h:406
MCSymbol * getLabel() const
Definition: MCDwarf.h:553
unsigned getFileNum() const
Get the FileNum of this MCDwarfLoc.
Definition: MCDwarf.h:99
static MCCFIInstruction createSameValue(MCSymbol *L, unsigned Register)
.cfi_same_value Current value of Register is the same as in the previous frame.
Definition: MCDwarf.h:527
const SmallVectorImpl< MCDwarfFile > & getMCDwarfFiles() const
Definition: MCDwarf.h:343
Streaming machine code generation interface.
Definition: MCStreamer.h:183
static MCCFIInstruction createDefCfa(MCSymbol *L, unsigned Register, int Offset)
.cfi_def_cfa defines a rule for computing CFA as: take address from Register and add Offset to it...
Definition: MCDwarf.h:460
unsigned getRegister2() const
Definition: MCDwarf.h:563
static MCCFIInstruction createDefCfaRegister(MCSymbol *L, unsigned Register)
.cfi_def_cfa_register modifies a rule for computing CFA.
Definition: MCDwarf.h:467
PowerPC Reduce CR logical Operation
Instances of this class represent the line information for a compile unit where machine instructions ...
Definition: MCDwarf.h:175
static MCCFIInstruction createWindowSave(MCSymbol *L)
.cfi_window_save SPARC register window is saved.
Definition: MCDwarf.h:508
void maybeSetRootFile(StringRef Directory, StringRef FileName, MD5::MD5Result *Checksum, Optional< StringRef > Source)
Definition: MCDwarf.h:259
void addLineEntry(const MCDwarfLineEntry &LineEntry, MCSection *Sec)
Definition: MCDwarf.h:178
static MCCFIInstruction createGnuArgsSize(MCSymbol *L, int Size)
A special wrapper for .cfi_escape that indicates GNU_ARGS_SIZE.
Definition: MCDwarf.h:548
int getOffset() const
Definition: MCDwarf.h:568
OpType getOperation() const
Definition: MCDwarf.h:552
static MCCFIInstruction createRelOffset(MCSymbol *L, unsigned Register, int Offset)
.cfi_rel_offset Previous value of Register is saved at offset Offset from the current CFA register...
Definition: MCDwarf.h:495
static MCCFIInstruction createRestore(MCSymbol *L, unsigned Register)
.cfi_restore says that the rule for Register is now the same as it was at the beginning of the functi...
Definition: MCDwarf.h:515
unsigned getDiscriminator() const
Get the Discriminator of this MCDwarfLoc.
Definition: MCDwarf.h:114
This owns the files read by a parser, handles include stacks, and handles diagnostic wrangling...
Definition: SourceMgr.h:42
StringRef getValues() const
Definition: MCDwarf.h:575
const MCLineSection & getMCLineSections() const
Definition: MCDwarf.h:351
static MCCFIInstruction createRestoreState(MCSymbol *L)
.cfi_restore_state Restore the previously saved state.
Definition: MCDwarf.h:537
unsigned getIsa() const
Get the Isa of this MCDwarfLoc.
Definition: MCDwarf.h:111
bool hasRootFile() const
Definition: MCDwarf.h:322
unsigned getRegister() const
Definition: MCDwarf.h:555
void trackMD5Usage(bool MD5Used)
Definition: MCDwarf.h:241
MCDwarfLineEntryCollection::const_iterator const_iterator
Definition: MCDwarf.h:184
Promote Memory to Register
Definition: Mem2Reg.cpp:110
std::string CompilationDir
Definition: MCDwarf.h:216
LLVM_NODISCARD bool isa(const Y &Val)
Definition: Casting.h:142
Instances of this class represent the line information for the dwarf line table entries.
Definition: MCDwarf.h:151
bool hasValue() const
Definition: Optional.h:184
MCLineSection & getMCLineSections()
Definition: MCDwarf.h:354
MCSymbol * getLabel() const
Definition: MCDwarf.h:163
MCSymbol * getLabel() const
Definition: MCDwarf.h:408
StringMap< unsigned > SourceIdMap
Definition: MCDwarf.h:215
void setRootFile(StringRef Directory, StringRef FileName, MD5::MD5Result *Checksum, Optional< StringRef > Source)
Definition: MCDwarf.h:304
LLVM_NODISCARD bool empty() const
Definition: SmallVector.h:56
unsigned getColumn() const
Get the Column of this MCDwarfLoc.
Definition: MCDwarf.h:105
uint32_t Size
Definition: Profile.cpp:47
void setFileNum(unsigned fileNum)
Set the FileNum of this MCDwarfLoc.
Definition: MCDwarf.h:117
void setFlags(unsigned flags)
Set the Flags of this MCDwarfLoc.
Definition: MCDwarf.h:129
MD5::MD5Result * Checksum
The MD5 checksum, if there is one.
Definition: MCDwarf.h:59
unsigned DirIndex
Definition: MCDwarf.h:55
MCSymbol * getLabel() const
Definition: MCDwarf.h:327
MCGenDwarfLabelEntry(StringRef name, unsigned fileNumber, unsigned lineNumber, MCSymbol *label)
Definition: MCDwarf.h:400
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
Generic interface to target specific assembler backends.
Definition: MCAsmBackend.h:42
static const char * name
This class implements an extremely fast bulk output stream that can only output to a stream...
Definition: raw_ostream.h:46
SmallVector< MCDwarfFile, 3 > MCDwarfFiles
Definition: MCDwarf.h:214
void setColumn(unsigned column)
Set the Column of this MCDwarfLoc.
Definition: MCDwarf.h:123
bool isMD5UsageConsistent() const
Definition: MCDwarf.h:245
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:49
Instances of this class represent the name of the dwarf .file directive and its associated dwarf file...
Definition: MCDwarf.h:50
Represents a location in source code.
Definition: SMLoc.h:24
Expected< unsigned > tryGetFile(StringRef &Directory, StringRef &FileName, MD5::MD5Result *Checksum, Optional< StringRef > &Source, unsigned FileNumber=0)
Definition: MCDwarf.cpp:543
static MCCFIInstruction createEscape(MCSymbol *L, StringRef Vals)
.cfi_escape Allows the user to add arbitrary bytes to the unwind info.
Definition: MCDwarf.h:543
unsigned getLineNumber() const
Definition: MCDwarf.h:407
SmallVector< std::string, 3 > MCDwarfDirs
Definition: MCDwarf.h:213
void setDiscriminator(unsigned discriminator)
Set the Discriminator of this MCDwarfLoc.
Definition: MCDwarf.h:141
void setLabel(MCSymbol *Label)
Definition: MCDwarf.h:331
static MCCFIInstruction createRegister(MCSymbol *L, unsigned Register1, unsigned Register2)
.cfi_register Previous value of Register1 is saved in register Register2.
Definition: MCDwarf.h:502