include/llvm/MC/MCDwarf.h

   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/StringRef.h"
  19 #include "llvm/ADT/MapVector.h"
  20 #include "llvm/Support/Compiler.h"
  21 #include "llvm/Support/Dwarf.h"
  22 #include "llvm/Support/raw_ostream.h"
  23 #include <map>
  24 #include <vector>
  25 #include <string>
  26 #include <utility>
  27
  28 namespace llvm {
  29 class MCAsmBackend;
  30 class MCContext;
  31 class MCSection;
  32 class MCStreamer;
  33 class MCSymbol;
  34 class SourceMgr;
  35 class SMLoc;
  36
  37 /// MCDwarfFile - Instances of this class represent the name of the dwarf
  38 /// .file directive and its associated dwarf file number in the MC file,
  39 /// and MCDwarfFile's are created and unique'd by the MCContext class where
  40 /// the file number for each is its index into the vector of DwarfFiles (note
  41 /// index 0 is not used and not a valid dwarf file number).
  42 struct MCDwarfFile {
  43   // Name - the base name of the file without its directory path.
  44   // The StringRef references memory allocated in the MCContext.
  45   std::string Name;
  46
  47   // DirIndex - the index into the list of directory names for this file name.
  48   unsigned DirIndex;
  49 };
  50
  51 /// MCDwarfLoc - Instances of this class represent the information from a
  52 /// dwarf .loc directive.
  53 class MCDwarfLoc {
  54   // FileNum - the file number.
  55   unsigned FileNum;
  56   // Line - the line number.
  57   unsigned Line;
  58   // Column - the column position.
  59   unsigned Column;
  60   // Flags (see #define's below)
  61   unsigned Flags;
  62   // Isa
  63   unsigned Isa;
  64   // Discriminator
  65   unsigned Discriminator;
  66
  67 // Flag that indicates the initial value of the is_stmt_start flag.
  68 #define DWARF2_LINE_DEFAULT_IS_STMT 1
  69
  70 #define DWARF2_FLAG_IS_STMT (1 << 0)
  71 #define DWARF2_FLAG_BASIC_BLOCK (1 << 1)
  72 #define DWARF2_FLAG_PROLOGUE_END (1 << 2)
  73 #define DWARF2_FLAG_EPILOGUE_BEGIN (1 << 3)
  74
  75 private: // MCContext manages these
  76   friend class MCContext;
  77   friend class MCLineEntry;
  78   MCDwarfLoc(unsigned fileNum, unsigned line, unsigned column, unsigned flags,
  79              unsigned isa, unsigned discriminator)
  80       : FileNum(fileNum), Line(line), Column(column), Flags(flags), Isa(isa),
  81         Discriminator(discriminator) {}
  82
  83   // Allow the default copy constructor and assignment operator to be used
  84   // for an MCDwarfLoc object.
  85
  86 public:
  87   /// getFileNum - Get the FileNum of this MCDwarfLoc.
  88   unsigned getFileNum() const { return FileNum; }
  89
  90   /// getLine - Get the Line of this MCDwarfLoc.
  91   unsigned getLine() const { return Line; }
  92
  93   /// getColumn - Get the Column of this MCDwarfLoc.
  94   unsigned getColumn() const { return Column; }
  95
  96   /// getFlags - Get the Flags of this MCDwarfLoc.
  97   unsigned getFlags() const { return Flags; }
  98
  99   /// getIsa - Get the Isa of this MCDwarfLoc.
 100   unsigned getIsa() const { return Isa; }
 101
 102   /// getDiscriminator - Get the Discriminator of this MCDwarfLoc.
 103   unsigned getDiscriminator() const { return Discriminator; }
 104
 105   /// setFileNum - Set the FileNum of this MCDwarfLoc.
 106   void setFileNum(unsigned fileNum) { FileNum = fileNum; }
 107
 108   /// setLine - Set the Line of this MCDwarfLoc.
 109   void setLine(unsigned line) { Line = line; }
 110
 111   /// setColumn - Set the Column of this MCDwarfLoc.
 112   void setColumn(unsigned column) { Column = column; }
 113
 114   /// setFlags - Set the Flags of this MCDwarfLoc.
 115   void setFlags(unsigned flags) { Flags = flags; }
 116
 117   /// setIsa - Set the Isa of this MCDwarfLoc.
 118   void setIsa(unsigned isa) { Isa = isa; }
 119
 120   /// setDiscriminator - Set the Discriminator of this MCDwarfLoc.
 121   void setDiscriminator(unsigned discriminator) {
 122     Discriminator = discriminator;
 123   }
 124 };
 125
 126 /// MCLineEntry - Instances of this class represent the line information for
 127 /// the dwarf line table entries.  Which is created after a machine
 128 /// instruction is assembled and uses an address from a temporary label
 129 /// created at the current address in the current section and the info from
 130 /// the last .loc directive seen as stored in the context.
 131 class MCLineEntry : public MCDwarfLoc {
 132   MCSymbol *Label;
 133
 134 private:
 135   // Allow the default copy constructor and assignment operator to be used
 136   // for an MCLineEntry object.
 137
 138 public:
 139   // Constructor to create an MCLineEntry given a symbol and the dwarf loc.
 140   MCLineEntry(MCSymbol *label, const MCDwarfLoc loc)
 141       : MCDwarfLoc(loc), Label(label) {}
 142
 143   MCSymbol *getLabel() const { return Label; }
 144
 145   // This is called when an instruction is assembled into the specified
 146   // section and if there is information from the last .loc directive that
 147   // has yet to have a line entry made for it is made.
 148   static void Make(MCStreamer *MCOS, const MCSection *Section);
 149 };
 150
 151 /// MCLineSection - Instances of this class represent the line information
 152 /// for a compile unit where machine instructions have been assembled after seeing
 153 /// .loc directives.  This is the information used to build the dwarf line
 154 /// table for a section.
 155 class MCLineSection {
 156 public:
 157   // addLineEntry - adds an entry to this MCLineSection's line entries
 158   void addLineEntry(const MCLineEntry &LineEntry, const MCSection *Sec) {
 159     MCLineDivisions[Sec].push_back(LineEntry);
 160   }
 161
 162   typedef std::vector<MCLineEntry> MCLineEntryCollection;
 163   typedef MCLineEntryCollection::iterator iterator;
 164   typedef MCLineEntryCollection::const_iterator const_iterator;
 165   typedef MapVector<const MCSection *, MCLineEntryCollection> MCLineDivisionMap;
 166
 167 private:
 168   // A collection of MCLineEntry for each section.
 169   MCLineDivisionMap MCLineDivisions;
 170
 171 public:
 172   // Returns the collection of MCLineEntry for a given Compile Unit ID.
 173   const MCLineDivisionMap &getMCLineEntries() const {
 174     return MCLineDivisions;
 175   }
 176 };
 177
 178 struct MCDwarfLineTableHeader {
 179   MCSymbol *Label;
 180   SmallVector<std::string, 3> MCDwarfDirs;
 181   SmallVector<MCDwarfFile, 3> MCDwarfFiles;
 182   MCDwarfLineTableHeader() : Label(nullptr) {}
 183   unsigned getFile(StringRef Directory, StringRef FileName, unsigned FileNumber);
 184   std::pair<MCSymbol *, MCSymbol *> Emit(MCStreamer *MCOS) const;
 185 };
 186
 187 class MCDwarfLineTable {
 188   MCDwarfLineTableHeader Header;
 189   MCLineSection MCLineSections;
 190
 191 public:
 192   // This emits the Dwarf file and the line tables for all Compile Units.
 193   static const MCSymbol *Emit(MCStreamer *MCOS);
 194
 195   // This emits the Dwarf file and the line tables for a given Compile Unit.
 196   const MCSymbol *EmitCU(MCStreamer *MCOS) const;
 197
 198   unsigned getFile(StringRef Directory, StringRef FileName, unsigned FileNumber);
 199
 200   MCSymbol *getLabel() const {
 201     return Header.Label;
 202   }
 203
 204   void setLabel(MCSymbol *Label) {
 205     Header.Label = Label;
 206   }
 207
 208   const SmallVectorImpl<std::string> &getMCDwarfDirs() const {
 209     return Header.MCDwarfDirs;
 210   }
 211
 212   SmallVectorImpl<std::string> &getMCDwarfDirs() {
 213     return Header.MCDwarfDirs;
 214   }
 215
 216   const SmallVectorImpl<MCDwarfFile> &getMCDwarfFiles() const {
 217     return Header.MCDwarfFiles;
 218   }
 219
 220   SmallVectorImpl<MCDwarfFile> &getMCDwarfFiles() {
 221     return Header.MCDwarfFiles;
 222   }
 223
 224   const MCLineSection &getMCLineSections() const {
 225     return MCLineSections;
 226   }
 227   MCLineSection &getMCLineSections() {
 228     return MCLineSections;
 229   }
 230 };
 231
 232 class MCDwarfLineAddr {
 233 public:
 234   /// Utility function to encode a Dwarf pair of LineDelta and AddrDeltas.
 235   static void Encode(MCContext &Context, int64_t LineDelta, uint64_t AddrDelta,
 236                      raw_ostream &OS);
 237
 238   /// Utility function to emit the encoding to a streamer.
 239   static void Emit(MCStreamer *MCOS, int64_t LineDelta, uint64_t AddrDelta);
 240 };
 241
 242 class MCGenDwarfInfo {
 243 public:
 244   //
 245   // When generating dwarf for assembly source files this emits the Dwarf
 246   // sections.
 247   //
 248   static void Emit(MCStreamer *MCOS, const MCSymbol *LineSectionSymbol);
 249 };
 250
 251 // When generating dwarf for assembly source files this is the info that is
 252 // needed to be gathered for each symbol that will have a dwarf label.
 253 class MCGenDwarfLabelEntry {
 254 private:
 255   // Name of the symbol without a leading underbar, if any.
 256   StringRef Name;
 257   // The dwarf file number this symbol is in.
 258   unsigned FileNumber;
 259   // The line number this symbol is at.
 260   unsigned LineNumber;
 261   // The low_pc for the dwarf label is taken from this symbol.
 262   MCSymbol *Label;
 263
 264 public:
 265   MCGenDwarfLabelEntry(StringRef name, unsigned fileNumber, unsigned lineNumber,
 266                        MCSymbol *label)
 267       : Name(name), FileNumber(fileNumber), LineNumber(lineNumber),
 268         Label(label) {}
 269
 270   StringRef getName() const { return Name; }
 271   unsigned getFileNumber() const { return FileNumber; }
 272   unsigned getLineNumber() const { return LineNumber; }
 273   MCSymbol *getLabel() const { return Label; }
 274
 275   // This is called when label is created when we are generating dwarf for
 276   // assembly source files.
 277   static void Make(MCSymbol *Symbol, MCStreamer *MCOS, SourceMgr &SrcMgr,
 278                    SMLoc &Loc);
 279 };
 280
 281 class MCCFIInstruction {
 282 public:
 283   enum OpType {
 284     OpSameValue,
 285     OpRememberState,
 286     OpRestoreState,
 287     OpOffset,
 288     OpDefCfaRegister,
 289     OpDefCfaOffset,
 290     OpDefCfa,
 291     OpRelOffset,
 292     OpAdjustCfaOffset,
 293     OpEscape,
 294     OpRestore,
 295     OpUndefined,
 296     OpRegister,
 297     OpWindowSave
 298   };
 299
 300 private:
 301   OpType Operation;
 302   MCSymbol *Label;
 303   unsigned Register;
 304   union {
 305     int Offset;
 306     unsigned Register2;
 307   };
 308   std::vector<char> Values;
 309
 310   MCCFIInstruction(OpType Op, MCSymbol *L, unsigned R, int O, StringRef V)
 311       : Operation(Op), Label(L), Register(R), Offset(O),
 312         Values(V.begin(), V.end()) {
 313     assert(Op != OpRegister);
 314   }
 315
 316   MCCFIInstruction(OpType Op, MCSymbol *L, unsigned R1, unsigned R2)
 317       : Operation(Op), Label(L), Register(R1), Register2(R2) {
 318     assert(Op == OpRegister);
 319   }
 320
 321 public:
 322   /// \brief .cfi_def_cfa defines a rule for computing CFA as: take address from
 323   /// Register and add Offset to it.
 324   static MCCFIInstruction createDefCfa(MCSymbol *L, unsigned Register,
 325                                        int Offset) {
 326     return MCCFIInstruction(OpDefCfa, L, Register, -Offset, "");
 327   }
 328
 329   /// \brief .cfi_def_cfa_register modifies a rule for computing CFA. From now
 330   /// on Register will be used instead of the old one. Offset remains the same.
 331   static MCCFIInstruction createDefCfaRegister(MCSymbol *L, unsigned Register) {
 332     return MCCFIInstruction(OpDefCfaRegister, L, Register, 0, "");
 333   }
 334
 335   /// \brief .cfi_def_cfa_offset modifies a rule for computing CFA. Register
 336   /// remains the same, but offset is new. Note that it is the absolute offset
 337   /// that will be added to a defined register to the compute CFA address.
 338   static MCCFIInstruction createDefCfaOffset(MCSymbol *L, int Offset) {
 339     return MCCFIInstruction(OpDefCfaOffset, L, 0, -Offset, "");
 340   }
 341
 342   /// \brief .cfi_adjust_cfa_offset Same as .cfi_def_cfa_offset, but
 343   /// Offset is a relative value that is added/subtracted from the previous
 344   /// offset.
 345   static MCCFIInstruction createAdjustCfaOffset(MCSymbol *L, int Adjustment) {
 346     return MCCFIInstruction(OpAdjustCfaOffset, L, 0, Adjustment, "");
 347   }
 348
 349   /// \brief .cfi_offset Previous value of Register is saved at offset Offset
 350   /// from CFA.
 351   static MCCFIInstruction createOffset(MCSymbol *L, unsigned Register,
 352                                        int Offset) {
 353     return MCCFIInstruction(OpOffset, L, Register, Offset, "");
 354   }
 355
 356   /// \brief .cfi_rel_offset Previous value of Register is saved at offset
 357   /// Offset from the current CFA register. This is transformed to .cfi_offset
 358   /// using the known displacement of the CFA register from the CFA.
 359   static MCCFIInstruction createRelOffset(MCSymbol *L, unsigned Register,
 360                                           int Offset) {
 361     return MCCFIInstruction(OpRelOffset, L, Register, Offset, "");
 362   }
 363
 364   /// \brief .cfi_register Previous value of Register1 is saved in
 365   /// register Register2.
 366   static MCCFIInstruction createRegister(MCSymbol *L, unsigned Register1,
 367                                          unsigned Register2) {
 368     return MCCFIInstruction(OpRegister, L, Register1, Register2);
 369   }
 370
 371   /// \brief .cfi_window_save SPARC register window is saved.
 372   static MCCFIInstruction createWindowSave(MCSymbol *L) {
 373     return MCCFIInstruction(OpWindowSave, L, 0, 0, "");
 374   }
 375
 376   /// \brief .cfi_restore says that the rule for Register is now the same as it
 377   /// was at the beginning of the function, after all initial instructions added
 378   /// by .cfi_startproc were executed.
 379   static MCCFIInstruction createRestore(MCSymbol *L, unsigned Register) {
 380     return MCCFIInstruction(OpRestore, L, Register, 0, "");
 381   }
 382
 383   /// \brief .cfi_undefined From now on the previous value of Register can't be
 384   /// restored anymore.
 385   static MCCFIInstruction createUndefined(MCSymbol *L, unsigned Register) {
 386     return MCCFIInstruction(OpUndefined, L, Register, 0, "");
 387   }
 388
 389   /// \brief .cfi_same_value Current value of Register is the same as in the
 390   /// previous frame. I.e., no restoration is needed.
 391   static MCCFIInstruction createSameValue(MCSymbol *L, unsigned Register) {
 392     return MCCFIInstruction(OpSameValue, L, Register, 0, "");
 393   }
 394
 395   /// \brief .cfi_remember_state Save all current rules for all registers.
 396   static MCCFIInstruction createRememberState(MCSymbol *L) {
 397     return MCCFIInstruction(OpRememberState, L, 0, 0, "");
 398   }
 399
 400   /// \brief .cfi_restore_state Restore the previously saved state.
 401   static MCCFIInstruction createRestoreState(MCSymbol *L) {
 402     return MCCFIInstruction(OpRestoreState, L, 0, 0, "");
 403   }
 404
 405   /// \brief .cfi_escape Allows the user to add arbitrary bytes to the unwind
 406   /// info.
 407   static MCCFIInstruction createEscape(MCSymbol *L, StringRef Vals) {
 408     return MCCFIInstruction(OpEscape, L, 0, 0, Vals);
 409   }
 410
 411   OpType getOperation() const { return Operation; }
 412   MCSymbol *getLabel() const { return Label; }
 413
 414   unsigned getRegister() const {
 415     assert(Operation == OpDefCfa || Operation == OpOffset ||
 416            Operation == OpRestore || Operation == OpUndefined ||
 417            Operation == OpSameValue || Operation == OpDefCfaRegister ||
 418            Operation == OpRelOffset || Operation == OpRegister);
 419     return Register;
 420   }
 421
 422   unsigned getRegister2() const {
 423     assert(Operation == OpRegister);
 424     return Register2;
 425   }
 426
 427   int getOffset() const {
 428     assert(Operation == OpDefCfa || Operation == OpOffset ||
 429            Operation == OpRelOffset || Operation == OpDefCfaOffset ||
 430            Operation == OpAdjustCfaOffset);
 431     return Offset;
 432   }
 433
 434   const StringRef getValues() const {
 435     assert(Operation == OpEscape);
 436     return StringRef(&Values[0], Values.size());
 437   }
 438 };
 439
 440 struct MCDwarfFrameInfo {
 441   MCDwarfFrameInfo()
 442       : Begin(0), End(0), Personality(0), Lsda(0), Function(0), Instructions(),
 443         PersonalityEncoding(), LsdaEncoding(0), CompactUnwindEncoding(0),
 444         IsSignalFrame(false), IsSimple(false) {}
 445   MCSymbol *Begin;
 446   MCSymbol *End;
 447   const MCSymbol *Personality;
 448   const MCSymbol *Lsda;
 449   const MCSymbol *Function;
 450   std::vector<MCCFIInstruction> Instructions;
 451   unsigned PersonalityEncoding;
 452   unsigned LsdaEncoding;
 453   uint32_t CompactUnwindEncoding;
 454   bool IsSignalFrame;
 455   bool IsSimple;
 456 };
 457
 458 class MCDwarfFrameEmitter {
 459 public:
 460   //
 461   // This emits the frame info section.
 462   //
 463   static void Emit(MCStreamer &streamer, MCAsmBackend *MAB,
 464                    bool usingCFI, bool isEH);
 465   static void EmitAdvanceLoc(MCStreamer &Streamer, uint64_t AddrDelta);
 466   static void EncodeAdvanceLoc(MCContext &Context, uint64_t AddrDelta,
 467                                raw_ostream &OS);
 468 };
 469 } // end namespace llvm
 470
 471 #endif