MCDwarf.cpp revision 203576aa0cb9d8bf2d2e4d910ebab4b7a63262ae
1//===- lib/MC/MCDwarf.cpp - MCDwarf implementation ------------------------===// 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#include "llvm/MC/MCDwarf.h" 11#include "llvm/MC/MCAsmInfo.h" 12#include "llvm/MC/MCContext.h" 13#include "llvm/MC/MCObjectFileInfo.h" 14#include "llvm/MC/MCObjectWriter.h" 15#include "llvm/MC/MCRegisterInfo.h" 16#include "llvm/MC/MCStreamer.h" 17#include "llvm/MC/MCSymbol.h" 18#include "llvm/MC/MCExpr.h" 19#include "llvm/Support/Debug.h" 20#include "llvm/Support/ErrorHandling.h" 21#include "llvm/Support/raw_ostream.h" 22#include "llvm/ADT/FoldingSet.h" 23#include "llvm/ADT/SmallString.h" 24#include "llvm/ADT/StringExtras.h" 25#include "llvm/ADT/Twine.h" 26using namespace llvm; 27 28// Given a special op, return the address skip amount (in units of 29// DWARF2_LINE_MIN_INSN_LENGTH. 30#define SPECIAL_ADDR(op) (((op) - DWARF2_LINE_OPCODE_BASE)/DWARF2_LINE_RANGE) 31 32// The maximum address skip amount that can be encoded with a special op. 33#define MAX_SPECIAL_ADDR_DELTA SPECIAL_ADDR(255) 34 35// First special line opcode - leave room for the standard opcodes. 36// Note: If you want to change this, you'll have to update the 37// "standard_opcode_lengths" table that is emitted in DwarfFileTable::Emit(). 38#define DWARF2_LINE_OPCODE_BASE 13 39 40// Minimum line offset in a special line info. opcode. This value 41// was chosen to give a reasonable range of values. 42#define DWARF2_LINE_BASE -5 43 44// Range of line offsets in a special line info. opcode. 45#define DWARF2_LINE_RANGE 14 46 47// Define the architecture-dependent minimum instruction length (in bytes). 48// This value should be rather too small than too big. 49#define DWARF2_LINE_MIN_INSN_LENGTH 1 50 51// Note: when DWARF2_LINE_MIN_INSN_LENGTH == 1 which is the current setting, 52// this routine is a nop and will be optimized away. 53static inline uint64_t ScaleAddrDelta(uint64_t AddrDelta) { 54 if (DWARF2_LINE_MIN_INSN_LENGTH == 1) 55 return AddrDelta; 56 if (AddrDelta % DWARF2_LINE_MIN_INSN_LENGTH != 0) { 57 // TODO: report this error, but really only once. 58 ; 59 } 60 return AddrDelta / DWARF2_LINE_MIN_INSN_LENGTH; 61} 62 63// 64// This is called when an instruction is assembled into the specified section 65// and if there is information from the last .loc directive that has yet to have 66// a line entry made for it is made. 67// 68void MCLineEntry::Make(MCStreamer *MCOS, const MCSection *Section) { 69 if (!MCOS->getContext().getDwarfLocSeen()) 70 return; 71 72 // Create a symbol at in the current section for use in the line entry. 73 MCSymbol *LineSym = MCOS->getContext().CreateTempSymbol(); 74 // Set the value of the symbol to use for the MCLineEntry. 75 MCOS->EmitLabel(LineSym); 76 77 // Get the current .loc info saved in the context. 78 const MCDwarfLoc &DwarfLoc = MCOS->getContext().getCurrentDwarfLoc(); 79 80 // Create a (local) line entry with the symbol and the current .loc info. 81 MCLineEntry LineEntry(LineSym, DwarfLoc); 82 83 // clear DwarfLocSeen saying the current .loc info is now used. 84 MCOS->getContext().ClearDwarfLocSeen(); 85 86 // Get the MCLineSection for this section, if one does not exist for this 87 // section create it. 88 const DenseMap<const MCSection *, MCLineSection *> &MCLineSections = 89 MCOS->getContext().getMCLineSections(); 90 MCLineSection *LineSection = MCLineSections.lookup(Section); 91 if (!LineSection) { 92 // Create a new MCLineSection. This will be deleted after the dwarf line 93 // table is created using it by iterating through the MCLineSections 94 // DenseMap. 95 LineSection = new MCLineSection; 96 // Save a pointer to the new LineSection into the MCLineSections DenseMap. 97 MCOS->getContext().addMCLineSection(Section, LineSection); 98 } 99 100 // Add the line entry to this section's entries. 101 LineSection->addLineEntry(LineEntry); 102} 103 104// 105// This helper routine returns an expression of End - Start + IntVal . 106// 107static inline const MCExpr *MakeStartMinusEndExpr(const MCStreamer &MCOS, 108 const MCSymbol &Start, 109 const MCSymbol &End, 110 int IntVal) { 111 MCSymbolRefExpr::VariantKind Variant = MCSymbolRefExpr::VK_None; 112 const MCExpr *Res = 113 MCSymbolRefExpr::Create(&End, Variant, MCOS.getContext()); 114 const MCExpr *RHS = 115 MCSymbolRefExpr::Create(&Start, Variant, MCOS.getContext()); 116 const MCExpr *Res1 = 117 MCBinaryExpr::Create(MCBinaryExpr::Sub, Res, RHS, MCOS.getContext()); 118 const MCExpr *Res2 = 119 MCConstantExpr::Create(IntVal, MCOS.getContext()); 120 const MCExpr *Res3 = 121 MCBinaryExpr::Create(MCBinaryExpr::Sub, Res1, Res2, MCOS.getContext()); 122 return Res3; 123} 124 125// 126// This emits the Dwarf line table for the specified section from the entries 127// in the LineSection. 128// 129static inline void EmitDwarfLineTable(MCStreamer *MCOS, 130 const MCSection *Section, 131 const MCLineSection *LineSection) { 132 unsigned FileNum = 1; 133 unsigned LastLine = 1; 134 unsigned Column = 0; 135 unsigned Flags = DWARF2_LINE_DEFAULT_IS_STMT ? DWARF2_FLAG_IS_STMT : 0; 136 unsigned Isa = 0; 137 MCSymbol *LastLabel = NULL; 138 139 // Loop through each MCLineEntry and encode the dwarf line number table. 140 for (MCLineSection::const_iterator 141 it = LineSection->getMCLineEntries()->begin(), 142 ie = LineSection->getMCLineEntries()->end(); it != ie; ++it) { 143 144 if (FileNum != it->getFileNum()) { 145 FileNum = it->getFileNum(); 146 MCOS->EmitIntValue(dwarf::DW_LNS_set_file, 1); 147 MCOS->EmitULEB128IntValue(FileNum); 148 } 149 if (Column != it->getColumn()) { 150 Column = it->getColumn(); 151 MCOS->EmitIntValue(dwarf::DW_LNS_set_column, 1); 152 MCOS->EmitULEB128IntValue(Column); 153 } 154 if (Isa != it->getIsa()) { 155 Isa = it->getIsa(); 156 MCOS->EmitIntValue(dwarf::DW_LNS_set_isa, 1); 157 MCOS->EmitULEB128IntValue(Isa); 158 } 159 if ((it->getFlags() ^ Flags) & DWARF2_FLAG_IS_STMT) { 160 Flags = it->getFlags(); 161 MCOS->EmitIntValue(dwarf::DW_LNS_negate_stmt, 1); 162 } 163 if (it->getFlags() & DWARF2_FLAG_BASIC_BLOCK) 164 MCOS->EmitIntValue(dwarf::DW_LNS_set_basic_block, 1); 165 if (it->getFlags() & DWARF2_FLAG_PROLOGUE_END) 166 MCOS->EmitIntValue(dwarf::DW_LNS_set_prologue_end, 1); 167 if (it->getFlags() & DWARF2_FLAG_EPILOGUE_BEGIN) 168 MCOS->EmitIntValue(dwarf::DW_LNS_set_epilogue_begin, 1); 169 170 int64_t LineDelta = static_cast<int64_t>(it->getLine()) - LastLine; 171 MCSymbol *Label = it->getLabel(); 172 173 // At this point we want to emit/create the sequence to encode the delta in 174 // line numbers and the increment of the address from the previous Label 175 // and the current Label. 176 const MCAsmInfo &asmInfo = MCOS->getContext().getAsmInfo(); 177 MCOS->EmitDwarfAdvanceLineAddr(LineDelta, LastLabel, Label, 178 asmInfo.getPointerSize()); 179 180 LastLine = it->getLine(); 181 LastLabel = Label; 182 } 183 184 // Emit a DW_LNE_end_sequence for the end of the section. 185 // Using the pointer Section create a temporary label at the end of the 186 // section and use that and the LastLabel to compute the address delta 187 // and use INT64_MAX as the line delta which is the signal that this is 188 // actually a DW_LNE_end_sequence. 189 190 // Switch to the section to be able to create a symbol at its end. 191 MCOS->SwitchSection(Section); 192 193 MCContext &context = MCOS->getContext(); 194 // Create a symbol at the end of the section. 195 MCSymbol *SectionEnd = context.CreateTempSymbol(); 196 // Set the value of the symbol, as we are at the end of the section. 197 MCOS->EmitLabel(SectionEnd); 198 199 // Switch back the the dwarf line section. 200 MCOS->SwitchSection(context.getObjectFileInfo()->getDwarfLineSection()); 201 202 const MCAsmInfo &asmInfo = MCOS->getContext().getAsmInfo(); 203 MCOS->EmitDwarfAdvanceLineAddr(INT64_MAX, LastLabel, SectionEnd, 204 asmInfo.getPointerSize()); 205} 206 207// 208// This emits the Dwarf file and the line tables. 209// 210void MCDwarfFileTable::Emit(MCStreamer *MCOS) { 211 MCContext &context = MCOS->getContext(); 212 // Switch to the section where the table will be emitted into. 213 MCOS->SwitchSection(context.getObjectFileInfo()->getDwarfLineSection()); 214 215 // Create a symbol at the beginning of this section. 216 MCSymbol *LineStartSym = context.CreateTempSymbol(); 217 // Set the value of the symbol, as we are at the start of the section. 218 MCOS->EmitLabel(LineStartSym); 219 220 // Create a symbol for the end of the section (to be set when we get there). 221 MCSymbol *LineEndSym = context.CreateTempSymbol(); 222 223 // The first 4 bytes is the total length of the information for this 224 // compilation unit (not including these 4 bytes for the length). 225 MCOS->EmitAbsValue(MakeStartMinusEndExpr(*MCOS, *LineStartSym, *LineEndSym,4), 226 4); 227 228 // Next 2 bytes is the Version, which is Dwarf 2. 229 MCOS->EmitIntValue(2, 2); 230 231 // Create a symbol for the end of the prologue (to be set when we get there). 232 MCSymbol *ProEndSym = context.CreateTempSymbol(); // Lprologue_end 233 234 // Length of the prologue, is the next 4 bytes. Which is the start of the 235 // section to the end of the prologue. Not including the 4 bytes for the 236 // total length, the 2 bytes for the version, and these 4 bytes for the 237 // length of the prologue. 238 MCOS->EmitAbsValue(MakeStartMinusEndExpr(*MCOS, *LineStartSym, *ProEndSym, 239 (4 + 2 + 4)), 240 4, 0); 241 242 // Parameters of the state machine, are next. 243 MCOS->EmitIntValue(DWARF2_LINE_MIN_INSN_LENGTH, 1); 244 MCOS->EmitIntValue(DWARF2_LINE_DEFAULT_IS_STMT, 1); 245 MCOS->EmitIntValue(DWARF2_LINE_BASE, 1); 246 MCOS->EmitIntValue(DWARF2_LINE_RANGE, 1); 247 MCOS->EmitIntValue(DWARF2_LINE_OPCODE_BASE, 1); 248 249 // Standard opcode lengths 250 MCOS->EmitIntValue(0, 1); // length of DW_LNS_copy 251 MCOS->EmitIntValue(1, 1); // length of DW_LNS_advance_pc 252 MCOS->EmitIntValue(1, 1); // length of DW_LNS_advance_line 253 MCOS->EmitIntValue(1, 1); // length of DW_LNS_set_file 254 MCOS->EmitIntValue(1, 1); // length of DW_LNS_set_column 255 MCOS->EmitIntValue(0, 1); // length of DW_LNS_negate_stmt 256 MCOS->EmitIntValue(0, 1); // length of DW_LNS_set_basic_block 257 MCOS->EmitIntValue(0, 1); // length of DW_LNS_const_add_pc 258 MCOS->EmitIntValue(1, 1); // length of DW_LNS_fixed_advance_pc 259 MCOS->EmitIntValue(0, 1); // length of DW_LNS_set_prologue_end 260 MCOS->EmitIntValue(0, 1); // length of DW_LNS_set_epilogue_begin 261 MCOS->EmitIntValue(1, 1); // DW_LNS_set_isa 262 263 // Put out the directory and file tables. 264 265 // First the directory table. 266 const std::vector<StringRef> &MCDwarfDirs = 267 context.getMCDwarfDirs(); 268 for (unsigned i = 0; i < MCDwarfDirs.size(); i++) { 269 MCOS->EmitBytes(MCDwarfDirs[i], 0); // the DirectoryName 270 MCOS->EmitBytes(StringRef("\0", 1), 0); // the null term. of the string 271 } 272 MCOS->EmitIntValue(0, 1); // Terminate the directory list 273 274 // Second the file table. 275 const std::vector<MCDwarfFile *> &MCDwarfFiles = 276 MCOS->getContext().getMCDwarfFiles(); 277 for (unsigned i = 1; i < MCDwarfFiles.size(); i++) { 278 MCOS->EmitBytes(MCDwarfFiles[i]->getName(), 0); // FileName 279 MCOS->EmitBytes(StringRef("\0", 1), 0); // the null term. of the string 280 // the Directory num 281 MCOS->EmitULEB128IntValue(MCDwarfFiles[i]->getDirIndex()); 282 MCOS->EmitIntValue(0, 1); // last modification timestamp (always 0) 283 MCOS->EmitIntValue(0, 1); // filesize (always 0) 284 } 285 MCOS->EmitIntValue(0, 1); // Terminate the file list 286 287 // This is the end of the prologue, so set the value of the symbol at the 288 // end of the prologue (that was used in a previous expression). 289 MCOS->EmitLabel(ProEndSym); 290 291 // Put out the line tables. 292 const DenseMap<const MCSection *, MCLineSection *> &MCLineSections = 293 MCOS->getContext().getMCLineSections(); 294 const std::vector<const MCSection *> &MCLineSectionOrder = 295 MCOS->getContext().getMCLineSectionOrder(); 296 for (std::vector<const MCSection*>::const_iterator it = 297 MCLineSectionOrder.begin(), ie = MCLineSectionOrder.end(); it != ie; 298 ++it) { 299 const MCSection *Sec = *it; 300 const MCLineSection *Line = MCLineSections.lookup(Sec); 301 EmitDwarfLineTable(MCOS, Sec, Line); 302 303 // Now delete the MCLineSections that were created in MCLineEntry::Make() 304 // and used to emit the line table. 305 delete Line; 306 } 307 308 if (MCOS->getContext().getAsmInfo().getLinkerRequiresNonEmptyDwarfLines() 309 && MCLineSectionOrder.begin() == MCLineSectionOrder.end()) { 310 // The darwin9 linker has a bug (see PR8715). For for 32-bit architectures 311 // it requires: 312 // total_length >= prologue_length + 10 313 // We are 4 bytes short, since we have total_length = 51 and 314 // prologue_length = 45 315 316 // The regular end_sequence should be sufficient. 317 MCDwarfLineAddr::Emit(MCOS, INT64_MAX, 0); 318 } 319 320 // This is the end of the section, so set the value of the symbol at the end 321 // of this section (that was used in a previous expression). 322 MCOS->EmitLabel(LineEndSym); 323} 324 325/// Utility function to write the encoding to an object writer. 326void MCDwarfLineAddr::Write(MCObjectWriter *OW, int64_t LineDelta, 327 uint64_t AddrDelta) { 328 SmallString<256> Tmp; 329 raw_svector_ostream OS(Tmp); 330 MCDwarfLineAddr::Encode(LineDelta, AddrDelta, OS); 331 OW->WriteBytes(OS.str()); 332} 333 334/// Utility function to emit the encoding to a streamer. 335void MCDwarfLineAddr::Emit(MCStreamer *MCOS, int64_t LineDelta, 336 uint64_t AddrDelta) { 337 SmallString<256> Tmp; 338 raw_svector_ostream OS(Tmp); 339 MCDwarfLineAddr::Encode(LineDelta, AddrDelta, OS); 340 MCOS->EmitBytes(OS.str(), /*AddrSpace=*/0); 341} 342 343/// Utility function to encode a Dwarf pair of LineDelta and AddrDeltas. 344void MCDwarfLineAddr::Encode(int64_t LineDelta, uint64_t AddrDelta, 345 raw_ostream &OS) { 346 uint64_t Temp, Opcode; 347 bool NeedCopy = false; 348 349 // Scale the address delta by the minimum instruction length. 350 AddrDelta = ScaleAddrDelta(AddrDelta); 351 352 // A LineDelta of INT64_MAX is a signal that this is actually a 353 // DW_LNE_end_sequence. We cannot use special opcodes here, since we want the 354 // end_sequence to emit the matrix entry. 355 if (LineDelta == INT64_MAX) { 356 if (AddrDelta == MAX_SPECIAL_ADDR_DELTA) 357 OS << char(dwarf::DW_LNS_const_add_pc); 358 else { 359 OS << char(dwarf::DW_LNS_advance_pc); 360 MCObjectWriter::EncodeULEB128(AddrDelta, OS); 361 } 362 OS << char(dwarf::DW_LNS_extended_op); 363 OS << char(1); 364 OS << char(dwarf::DW_LNE_end_sequence); 365 return; 366 } 367 368 // Bias the line delta by the base. 369 Temp = LineDelta - DWARF2_LINE_BASE; 370 371 // If the line increment is out of range of a special opcode, we must encode 372 // it with DW_LNS_advance_line. 373 if (Temp >= DWARF2_LINE_RANGE) { 374 OS << char(dwarf::DW_LNS_advance_line); 375 SmallString<32> Tmp; 376 raw_svector_ostream OSE(Tmp); 377 MCObjectWriter::EncodeSLEB128(LineDelta, OSE); 378 OS << OSE.str(); 379 380 LineDelta = 0; 381 Temp = 0 - DWARF2_LINE_BASE; 382 NeedCopy = true; 383 } 384 385 // Use DW_LNS_copy instead of a "line +0, addr +0" special opcode. 386 if (LineDelta == 0 && AddrDelta == 0) { 387 OS << char(dwarf::DW_LNS_copy); 388 return; 389 } 390 391 // Bias the opcode by the special opcode base. 392 Temp += DWARF2_LINE_OPCODE_BASE; 393 394 // Avoid overflow when addr_delta is large. 395 if (AddrDelta < 256 + MAX_SPECIAL_ADDR_DELTA) { 396 // Try using a special opcode. 397 Opcode = Temp + AddrDelta * DWARF2_LINE_RANGE; 398 if (Opcode <= 255) { 399 OS << char(Opcode); 400 return; 401 } 402 403 // Try using DW_LNS_const_add_pc followed by special op. 404 Opcode = Temp + (AddrDelta - MAX_SPECIAL_ADDR_DELTA) * DWARF2_LINE_RANGE; 405 if (Opcode <= 255) { 406 OS << char(dwarf::DW_LNS_const_add_pc); 407 OS << char(Opcode); 408 return; 409 } 410 } 411 412 // Otherwise use DW_LNS_advance_pc. 413 OS << char(dwarf::DW_LNS_advance_pc); 414 SmallString<32> Tmp; 415 raw_svector_ostream OSE(Tmp); 416 MCObjectWriter::EncodeULEB128(AddrDelta, OSE); 417 OS << OSE.str(); 418 419 if (NeedCopy) 420 OS << char(dwarf::DW_LNS_copy); 421 else 422 OS << char(Temp); 423} 424 425void MCDwarfFile::print(raw_ostream &OS) const { 426 OS << '"' << getName() << '"'; 427} 428 429void MCDwarfFile::dump() const { 430 print(dbgs()); 431} 432 433static int getDataAlignmentFactor(MCStreamer &streamer) { 434 MCContext &context = streamer.getContext(); 435 const MCAsmInfo &asmInfo = context.getAsmInfo(); 436 int size = asmInfo.getPointerSize(); 437 if (asmInfo.isStackGrowthDirectionUp()) 438 return size; 439 else 440 return -size; 441} 442 443static unsigned getSizeForEncoding(MCStreamer &streamer, 444 unsigned symbolEncoding) { 445 MCContext &context = streamer.getContext(); 446 unsigned format = symbolEncoding & 0x0f; 447 switch (format) { 448 default: 449 assert(0 && "Unknown Encoding"); 450 case dwarf::DW_EH_PE_absptr: 451 case dwarf::DW_EH_PE_signed: 452 return context.getAsmInfo().getPointerSize(); 453 case dwarf::DW_EH_PE_udata2: 454 case dwarf::DW_EH_PE_sdata2: 455 return 2; 456 case dwarf::DW_EH_PE_udata4: 457 case dwarf::DW_EH_PE_sdata4: 458 return 4; 459 case dwarf::DW_EH_PE_udata8: 460 case dwarf::DW_EH_PE_sdata8: 461 return 8; 462 } 463} 464 465static void EmitSymbol(MCStreamer &streamer, const MCSymbol &symbol, 466 unsigned symbolEncoding, const char *comment = 0) { 467 MCContext &context = streamer.getContext(); 468 const MCAsmInfo &asmInfo = context.getAsmInfo(); 469 const MCExpr *v = asmInfo.getExprForFDESymbol(&symbol, 470 symbolEncoding, 471 streamer); 472 unsigned size = getSizeForEncoding(streamer, symbolEncoding); 473 if (streamer.isVerboseAsm() && comment) streamer.AddComment(comment); 474 streamer.EmitAbsValue(v, size); 475} 476 477static void EmitPersonality(MCStreamer &streamer, const MCSymbol &symbol, 478 unsigned symbolEncoding) { 479 MCContext &context = streamer.getContext(); 480 const MCAsmInfo &asmInfo = context.getAsmInfo(); 481 const MCExpr *v = asmInfo.getExprForPersonalitySymbol(&symbol, 482 symbolEncoding, 483 streamer); 484 unsigned size = getSizeForEncoding(streamer, symbolEncoding); 485 streamer.EmitValue(v, size); 486} 487 488static const MachineLocation TranslateMachineLocation( 489 const MCRegisterInfo &MRI, 490 const MachineLocation &Loc) { 491 unsigned Reg = Loc.getReg() == MachineLocation::VirtualFP ? 492 MachineLocation::VirtualFP : 493 unsigned(MRI.getDwarfRegNum(Loc.getReg(), true)); 494 const MachineLocation &NewLoc = Loc.isReg() ? 495 MachineLocation(Reg) : MachineLocation(Reg, Loc.getOffset()); 496 return NewLoc; 497} 498 499namespace { 500 class FrameEmitterImpl { 501 int CFAOffset; 502 int CIENum; 503 bool UsingCFI; 504 bool IsEH; 505 const MCSymbol *SectionStart; 506 public: 507 FrameEmitterImpl(bool usingCFI, bool isEH, const MCSymbol *sectionStart) : 508 CFAOffset(0), CIENum(0), UsingCFI(usingCFI), IsEH(isEH), 509 SectionStart(sectionStart) { 510 } 511 512 /// EmitCompactUnwind - Emit the unwind information in a compact way. If 513 /// we're successful, return 'true'. Otherwise, return 'false' and it will 514 /// emit the normal CIE and FDE. 515 bool EmitCompactUnwind(MCStreamer &streamer, 516 const MCDwarfFrameInfo &frame); 517 518 const MCSymbol &EmitCIE(MCStreamer &streamer, 519 const MCSymbol *personality, 520 unsigned personalityEncoding, 521 const MCSymbol *lsda, 522 unsigned lsdaEncoding); 523 MCSymbol *EmitFDE(MCStreamer &streamer, 524 const MCSymbol &cieStart, 525 const MCDwarfFrameInfo &frame); 526 void EmitCFIInstructions(MCStreamer &streamer, 527 const std::vector<MCCFIInstruction> &Instrs, 528 MCSymbol *BaseLabel); 529 void EmitCFIInstruction(MCStreamer &Streamer, 530 const MCCFIInstruction &Instr); 531 }; 532 533} // end anonymous namespace 534 535static void EmitEncodingByte(MCStreamer &Streamer, unsigned Encoding, 536 StringRef Prefix) { 537 if (Streamer.isVerboseAsm()) { 538 const char *EncStr = 0; 539 switch (Encoding) { 540 default: EncStr = "<unknown encoding>"; 541 case dwarf::DW_EH_PE_absptr: EncStr = "absptr"; 542 case dwarf::DW_EH_PE_omit: EncStr = "omit"; 543 case dwarf::DW_EH_PE_pcrel: EncStr = "pcrel"; 544 case dwarf::DW_EH_PE_udata4: EncStr = "udata4"; 545 case dwarf::DW_EH_PE_udata8: EncStr = "udata8"; 546 case dwarf::DW_EH_PE_sdata4: EncStr = "sdata4"; 547 case dwarf::DW_EH_PE_sdata8: EncStr = "sdata8"; 548 case dwarf::DW_EH_PE_pcrel |dwarf::DW_EH_PE_udata4: EncStr = "pcrel udata4"; 549 case dwarf::DW_EH_PE_pcrel |dwarf::DW_EH_PE_sdata4: EncStr = "pcrel sdata4"; 550 case dwarf::DW_EH_PE_pcrel |dwarf::DW_EH_PE_udata8: EncStr = "pcrel udata8"; 551 case dwarf::DW_EH_PE_pcrel |dwarf::DW_EH_PE_sdata8: EncStr = "pcrel sdata8"; 552 case dwarf::DW_EH_PE_indirect |dwarf::DW_EH_PE_pcrel|dwarf::DW_EH_PE_udata4: 553 EncStr = "indirect pcrel udata4"; 554 case dwarf::DW_EH_PE_indirect |dwarf::DW_EH_PE_pcrel|dwarf::DW_EH_PE_sdata4: 555 EncStr = "indirect pcrel sdata4"; 556 case dwarf::DW_EH_PE_indirect |dwarf::DW_EH_PE_pcrel|dwarf::DW_EH_PE_udata8: 557 EncStr = "indirect pcrel udata8"; 558 case dwarf::DW_EH_PE_indirect |dwarf::DW_EH_PE_pcrel|dwarf::DW_EH_PE_sdata8: 559 EncStr = "indirect pcrel sdata8"; 560 } 561 562 Streamer.AddComment(Twine(Prefix) + " = " + EncStr); 563 } 564 565 Streamer.EmitIntValue(Encoding, 1); 566} 567 568void FrameEmitterImpl::EmitCFIInstruction(MCStreamer &Streamer, 569 const MCCFIInstruction &Instr) { 570 int dataAlignmentFactor = getDataAlignmentFactor(Streamer); 571 bool VerboseAsm = Streamer.isVerboseAsm(); 572 573 switch (Instr.getOperation()) { 574 case MCCFIInstruction::Move: 575 case MCCFIInstruction::RelMove: { 576 const MachineLocation &Dst = Instr.getDestination(); 577 const MachineLocation &Src = Instr.getSource(); 578 const bool IsRelative = Instr.getOperation() == MCCFIInstruction::RelMove; 579 580 // If advancing cfa. 581 if (Dst.isReg() && Dst.getReg() == MachineLocation::VirtualFP) { 582 if (Src.getReg() == MachineLocation::VirtualFP) { 583 if (VerboseAsm) Streamer.AddComment("DW_CFA_def_cfa_offset"); 584 Streamer.EmitIntValue(dwarf::DW_CFA_def_cfa_offset, 1); 585 } else { 586 if (VerboseAsm) Streamer.AddComment("DW_CFA_def_cfa"); 587 Streamer.EmitIntValue(dwarf::DW_CFA_def_cfa, 1); 588 if (VerboseAsm) Streamer.AddComment(Twine("Reg ") + 589 Twine(Src.getReg())); 590 Streamer.EmitULEB128IntValue(Src.getReg()); 591 } 592 593 if (IsRelative) 594 CFAOffset += Src.getOffset(); 595 else 596 CFAOffset = -Src.getOffset(); 597 598 if (VerboseAsm) Streamer.AddComment(Twine("Offset " + Twine(CFAOffset))); 599 Streamer.EmitULEB128IntValue(CFAOffset); 600 return; 601 } 602 603 if (Src.isReg() && Src.getReg() == MachineLocation::VirtualFP) { 604 assert(Dst.isReg() && "Machine move not supported yet."); 605 if (VerboseAsm) Streamer.AddComment("DW_CFA_def_cfa_register"); 606 Streamer.EmitIntValue(dwarf::DW_CFA_def_cfa_register, 1); 607 if (VerboseAsm) Streamer.AddComment(Twine("Reg ") + Twine(Dst.getReg())); 608 Streamer.EmitULEB128IntValue(Dst.getReg()); 609 return; 610 } 611 612 unsigned Reg = Src.getReg(); 613 int Offset = Dst.getOffset(); 614 if (IsRelative) 615 Offset -= CFAOffset; 616 Offset = Offset / dataAlignmentFactor; 617 618 if (Offset < 0) { 619 if (VerboseAsm) Streamer.AddComment("DW_CFA_offset_extended_sf"); 620 Streamer.EmitIntValue(dwarf::DW_CFA_offset_extended_sf, 1); 621 if (VerboseAsm) Streamer.AddComment(Twine("Reg ") + Twine(Reg)); 622 Streamer.EmitULEB128IntValue(Reg); 623 if (VerboseAsm) Streamer.AddComment(Twine("Offset ") + Twine(Offset)); 624 Streamer.EmitSLEB128IntValue(Offset); 625 } else if (Reg < 64) { 626 if (VerboseAsm) Streamer.AddComment(Twine("DW_CFA_offset + Reg(") + 627 Twine(Reg) + ")"); 628 Streamer.EmitIntValue(dwarf::DW_CFA_offset + Reg, 1); 629 if (VerboseAsm) Streamer.AddComment(Twine("Offset ") + Twine(Offset)); 630 Streamer.EmitULEB128IntValue(Offset); 631 } else { 632 if (VerboseAsm) Streamer.AddComment("DW_CFA_offset_extended"); 633 Streamer.EmitIntValue(dwarf::DW_CFA_offset_extended, 1); 634 if (VerboseAsm) Streamer.AddComment(Twine("Reg ") + Twine(Reg)); 635 Streamer.EmitULEB128IntValue(Reg); 636 if (VerboseAsm) Streamer.AddComment(Twine("Offset ") + Twine(Offset)); 637 Streamer.EmitULEB128IntValue(Offset); 638 } 639 return; 640 } 641 case MCCFIInstruction::Remember: 642 if (VerboseAsm) Streamer.AddComment("DW_CFA_remember_state"); 643 Streamer.EmitIntValue(dwarf::DW_CFA_remember_state, 1); 644 return; 645 case MCCFIInstruction::Restore: 646 if (VerboseAsm) Streamer.AddComment("DW_CFA_restore_state"); 647 Streamer.EmitIntValue(dwarf::DW_CFA_restore_state, 1); 648 return; 649 case MCCFIInstruction::SameValue: { 650 unsigned Reg = Instr.getDestination().getReg(); 651 if (VerboseAsm) Streamer.AddComment("DW_CFA_same_value"); 652 Streamer.EmitIntValue(dwarf::DW_CFA_same_value, 1); 653 if (VerboseAsm) Streamer.AddComment(Twine("Reg ") + Twine(Reg)); 654 Streamer.EmitULEB128IntValue(Reg); 655 return; 656 } 657 } 658 llvm_unreachable("Unhandled case in switch"); 659} 660 661/// EmitFrameMoves - Emit frame instructions to describe the layout of the 662/// frame. 663void FrameEmitterImpl::EmitCFIInstructions(MCStreamer &streamer, 664 const std::vector<MCCFIInstruction> &Instrs, 665 MCSymbol *BaseLabel) { 666 for (unsigned i = 0, N = Instrs.size(); i < N; ++i) { 667 const MCCFIInstruction &Instr = Instrs[i]; 668 MCSymbol *Label = Instr.getLabel(); 669 // Throw out move if the label is invalid. 670 if (Label && !Label->isDefined()) continue; // Not emitted, in dead code. 671 672 // Advance row if new location. 673 if (BaseLabel && Label) { 674 MCSymbol *ThisSym = Label; 675 if (ThisSym != BaseLabel) { 676 if (streamer.isVerboseAsm()) streamer.AddComment("DW_CFA_advance_loc4"); 677 streamer.EmitDwarfAdvanceFrameAddr(BaseLabel, ThisSym); 678 BaseLabel = ThisSym; 679 } 680 } 681 682 EmitCFIInstruction(streamer, Instr); 683 } 684} 685 686/// EmitCompactUnwind - Emit the unwind information in a compact way. If we're 687/// successful, return 'true'. Otherwise, return 'false' and it will emit the 688/// normal CIE and FDE. 689bool FrameEmitterImpl::EmitCompactUnwind(MCStreamer &Streamer, 690 const MCDwarfFrameInfo &Frame) { 691 MCContext &Context = Streamer.getContext(); 692 const MCObjectFileInfo *MOFI = Context.getObjectFileInfo(); 693 bool VerboseAsm = Streamer.isVerboseAsm(); 694 695 // range-start range-length compact-unwind-enc personality-func lsda 696 // _foo LfooEnd-_foo 0x00000023 0 0 697 // _bar LbarEnd-_bar 0x00000025 __gxx_personality except_tab1 698 // 699 // .section __LD,__compact_unwind,regular,debug 700 // 701 // # compact unwind for _foo 702 // .quad _foo 703 // .set L1,LfooEnd-_foo 704 // .long L1 705 // .long 0x01010001 706 // .quad 0 707 // .quad 0 708 // 709 // # compact unwind for _bar 710 // .quad _bar 711 // .set L2,LbarEnd-_bar 712 // .long L2 713 // .long 0x01020011 714 // .quad __gxx_personality 715 // .quad except_tab1 716 717 uint32_t Encoding = Frame.CompactUnwindEncoding; 718 if (!Encoding) return false; 719 720 // The encoding needs to know we have an LSDA. 721 if (Frame.Lsda) 722 Encoding |= 0x40000000; 723 724 Streamer.SwitchSection(MOFI->getCompactUnwindSection()); 725 726 // Range Start 727 unsigned FDEEncoding = MOFI->getFDEEncoding(UsingCFI); 728 unsigned Size = getSizeForEncoding(Streamer, FDEEncoding); 729 if (VerboseAsm) Streamer.AddComment("Range Start"); 730 Streamer.EmitSymbolValue(Frame.Function, Size); 731 732 // Range Length 733 const MCExpr *Range = MakeStartMinusEndExpr(Streamer, *Frame.Begin, 734 *Frame.End, 0); 735 if (VerboseAsm) Streamer.AddComment("Range Length"); 736 Streamer.EmitAbsValue(Range, 4); 737 738 // Compact Encoding 739 Size = getSizeForEncoding(Streamer, dwarf::DW_EH_PE_udata4); 740 if (VerboseAsm) Streamer.AddComment(Twine("Compact Unwind Encoding: 0x") + 741 Twine(llvm::utohexstr(Encoding))); 742 Streamer.EmitIntValue(Encoding, Size); 743 744 745 // Personality Function 746 Size = getSizeForEncoding(Streamer, dwarf::DW_EH_PE_absptr); 747 if (VerboseAsm) Streamer.AddComment("Personality Function"); 748 if (Frame.Personality) 749 Streamer.EmitSymbolValue(Frame.Personality, Size); 750 else 751 Streamer.EmitIntValue(0, Size); // No personality fn 752 753 // LSDA 754 Size = getSizeForEncoding(Streamer, Frame.LsdaEncoding); 755 if (VerboseAsm) Streamer.AddComment("LSDA"); 756 if (Frame.Lsda) 757 Streamer.EmitSymbolValue(Frame.Lsda, Size); 758 else 759 Streamer.EmitIntValue(0, Size); // No LSDA 760 761 return true; 762} 763 764const MCSymbol &FrameEmitterImpl::EmitCIE(MCStreamer &streamer, 765 const MCSymbol *personality, 766 unsigned personalityEncoding, 767 const MCSymbol *lsda, 768 unsigned lsdaEncoding) { 769 MCContext &context = streamer.getContext(); 770 const MCRegisterInfo &MRI = context.getRegisterInfo(); 771 const MCObjectFileInfo *MOFI = context.getObjectFileInfo(); 772 bool verboseAsm = streamer.isVerboseAsm(); 773 774 MCSymbol *sectionStart; 775 if (MOFI->isFunctionEHFrameSymbolPrivate() || !IsEH) 776 sectionStart = context.CreateTempSymbol(); 777 else 778 sectionStart = context.GetOrCreateSymbol(Twine("EH_frame") + Twine(CIENum)); 779 780 streamer.EmitLabel(sectionStart); 781 CIENum++; 782 783 MCSymbol *sectionEnd = context.CreateTempSymbol(); 784 785 // Length 786 const MCExpr *Length = MakeStartMinusEndExpr(streamer, *sectionStart, 787 *sectionEnd, 4); 788 if (verboseAsm) streamer.AddComment("CIE Length"); 789 streamer.EmitAbsValue(Length, 4); 790 791 // CIE ID 792 unsigned CIE_ID = IsEH ? 0 : -1; 793 if (verboseAsm) streamer.AddComment("CIE ID Tag"); 794 streamer.EmitIntValue(CIE_ID, 4); 795 796 // Version 797 if (verboseAsm) streamer.AddComment("DW_CIE_VERSION"); 798 streamer.EmitIntValue(dwarf::DW_CIE_VERSION, 1); 799 800 // Augmentation String 801 SmallString<8> Augmentation; 802 if (IsEH) { 803 if (verboseAsm) streamer.AddComment("CIE Augmentation"); 804 Augmentation += "z"; 805 if (personality) 806 Augmentation += "P"; 807 if (lsda) 808 Augmentation += "L"; 809 Augmentation += "R"; 810 streamer.EmitBytes(Augmentation.str(), 0); 811 } 812 streamer.EmitIntValue(0, 1); 813 814 // Code Alignment Factor 815 if (verboseAsm) streamer.AddComment("CIE Code Alignment Factor"); 816 streamer.EmitULEB128IntValue(1); 817 818 // Data Alignment Factor 819 if (verboseAsm) streamer.AddComment("CIE Data Alignment Factor"); 820 streamer.EmitSLEB128IntValue(getDataAlignmentFactor(streamer)); 821 822 // Return Address Register 823 if (verboseAsm) streamer.AddComment("CIE Return Address Column"); 824 streamer.EmitULEB128IntValue(MRI.getDwarfRegNum(MRI.getRARegister(), true)); 825 826 // Augmentation Data Length (optional) 827 828 unsigned augmentationLength = 0; 829 if (IsEH) { 830 if (personality) { 831 // Personality Encoding 832 augmentationLength += 1; 833 // Personality 834 augmentationLength += getSizeForEncoding(streamer, personalityEncoding); 835 } 836 if (lsda) 837 augmentationLength += 1; 838 // Encoding of the FDE pointers 839 augmentationLength += 1; 840 841 if (verboseAsm) streamer.AddComment("Augmentation Size"); 842 streamer.EmitULEB128IntValue(augmentationLength); 843 844 // Augmentation Data (optional) 845 if (personality) { 846 // Personality Encoding 847 EmitEncodingByte(streamer, personalityEncoding, 848 "Personality Encoding"); 849 // Personality 850 if (verboseAsm) streamer.AddComment("Personality"); 851 EmitPersonality(streamer, *personality, personalityEncoding); 852 } 853 854 if (lsda) 855 EmitEncodingByte(streamer, lsdaEncoding, "LSDA Encoding"); 856 857 // Encoding of the FDE pointers 858 EmitEncodingByte(streamer, MOFI->getFDEEncoding(UsingCFI), 859 "FDE Encoding"); 860 } 861 862 // Initial Instructions 863 864 const MCAsmInfo &MAI = context.getAsmInfo(); 865 const std::vector<MachineMove> &Moves = MAI.getInitialFrameState(); 866 std::vector<MCCFIInstruction> Instructions; 867 868 for (int i = 0, n = Moves.size(); i != n; ++i) { 869 MCSymbol *Label = Moves[i].getLabel(); 870 const MachineLocation &Dst = 871 TranslateMachineLocation(MRI, Moves[i].getDestination()); 872 const MachineLocation &Src = 873 TranslateMachineLocation(MRI, Moves[i].getSource()); 874 MCCFIInstruction Inst(Label, Dst, Src); 875 Instructions.push_back(Inst); 876 } 877 878 EmitCFIInstructions(streamer, Instructions, NULL); 879 880 // Padding 881 streamer.EmitValueToAlignment(IsEH 882 ? 4 : context.getAsmInfo().getPointerSize()); 883 884 streamer.EmitLabel(sectionEnd); 885 return *sectionStart; 886} 887 888MCSymbol *FrameEmitterImpl::EmitFDE(MCStreamer &streamer, 889 const MCSymbol &cieStart, 890 const MCDwarfFrameInfo &frame) { 891 MCContext &context = streamer.getContext(); 892 MCSymbol *fdeStart = context.CreateTempSymbol(); 893 MCSymbol *fdeEnd = context.CreateTempSymbol(); 894 const MCObjectFileInfo *MOFI = context.getObjectFileInfo(); 895 bool verboseAsm = streamer.isVerboseAsm(); 896 897 if (!MOFI->isFunctionEHFrameSymbolPrivate() && IsEH) { 898 MCSymbol *EHSym = 899 context.GetOrCreateSymbol(frame.Function->getName() + Twine(".eh")); 900 streamer.EmitEHSymAttributes(frame.Function, EHSym); 901 streamer.EmitLabel(EHSym); 902 } 903 904 // Length 905 const MCExpr *Length = MakeStartMinusEndExpr(streamer, *fdeStart, *fdeEnd, 0); 906 if (verboseAsm) streamer.AddComment("FDE Length"); 907 streamer.EmitAbsValue(Length, 4); 908 909 streamer.EmitLabel(fdeStart); 910 911 // CIE Pointer 912 const MCAsmInfo &asmInfo = context.getAsmInfo(); 913 if (IsEH) { 914 const MCExpr *offset = MakeStartMinusEndExpr(streamer, cieStart, *fdeStart, 915 0); 916 if (verboseAsm) streamer.AddComment("FDE CIE Offset"); 917 streamer.EmitAbsValue(offset, 4); 918 } else if (!asmInfo.doesDwarfRequireRelocationForSectionOffset()) { 919 const MCExpr *offset = MakeStartMinusEndExpr(streamer, *SectionStart, 920 cieStart, 0); 921 streamer.EmitAbsValue(offset, 4); 922 } else { 923 streamer.EmitSymbolValue(&cieStart, 4); 924 } 925 926 unsigned fdeEncoding = MOFI->getFDEEncoding(UsingCFI); 927 unsigned size = getSizeForEncoding(streamer, fdeEncoding); 928 929 // PC Begin 930 unsigned PCBeginEncoding = IsEH ? fdeEncoding : 931 (unsigned)dwarf::DW_EH_PE_absptr; 932 unsigned PCBeginSize = getSizeForEncoding(streamer, PCBeginEncoding); 933 EmitSymbol(streamer, *frame.Begin, PCBeginEncoding, "FDE initial location"); 934 935 // PC Range 936 const MCExpr *Range = MakeStartMinusEndExpr(streamer, *frame.Begin, 937 *frame.End, 0); 938 if (verboseAsm) streamer.AddComment("FDE address range"); 939 streamer.EmitAbsValue(Range, size); 940 941 if (IsEH) { 942 // Augmentation Data Length 943 unsigned augmentationLength = 0; 944 945 if (frame.Lsda) 946 augmentationLength += getSizeForEncoding(streamer, frame.LsdaEncoding); 947 948 if (verboseAsm) streamer.AddComment("Augmentation size"); 949 streamer.EmitULEB128IntValue(augmentationLength); 950 951 // Augmentation Data 952 if (frame.Lsda) 953 EmitSymbol(streamer, *frame.Lsda, frame.LsdaEncoding, 954 "Language Specific Data Area"); 955 } 956 957 // Call Frame Instructions 958 959 EmitCFIInstructions(streamer, frame.Instructions, frame.Begin); 960 961 // Padding 962 streamer.EmitValueToAlignment(PCBeginSize); 963 964 return fdeEnd; 965} 966 967namespace { 968 struct CIEKey { 969 static const CIEKey getEmptyKey() { return CIEKey(0, 0, -1); } 970 static const CIEKey getTombstoneKey() { return CIEKey(0, -1, 0); } 971 972 CIEKey(const MCSymbol* Personality_, unsigned PersonalityEncoding_, 973 unsigned LsdaEncoding_) : Personality(Personality_), 974 PersonalityEncoding(PersonalityEncoding_), 975 LsdaEncoding(LsdaEncoding_) { 976 } 977 const MCSymbol* Personality; 978 unsigned PersonalityEncoding; 979 unsigned LsdaEncoding; 980 }; 981} 982 983namespace llvm { 984 template <> 985 struct DenseMapInfo<CIEKey> { 986 static CIEKey getEmptyKey() { 987 return CIEKey::getEmptyKey(); 988 } 989 static CIEKey getTombstoneKey() { 990 return CIEKey::getTombstoneKey(); 991 } 992 static unsigned getHashValue(const CIEKey &Key) { 993 FoldingSetNodeID ID; 994 ID.AddPointer(Key.Personality); 995 ID.AddInteger(Key.PersonalityEncoding); 996 ID.AddInteger(Key.LsdaEncoding); 997 return ID.ComputeHash(); 998 } 999 static bool isEqual(const CIEKey &LHS, 1000 const CIEKey &RHS) { 1001 return LHS.Personality == RHS.Personality && 1002 LHS.PersonalityEncoding == RHS.PersonalityEncoding && 1003 LHS.LsdaEncoding == RHS.LsdaEncoding; 1004 } 1005 }; 1006} 1007 1008void MCDwarfFrameEmitter::Emit(MCStreamer &Streamer, 1009 bool UsingCFI, 1010 bool IsEH) { 1011 MCContext &Context = Streamer.getContext(); 1012 MCObjectFileInfo *MOFI = 1013 const_cast<MCObjectFileInfo*>(Context.getObjectFileInfo()); 1014 const MCSection &Section = IsEH ? *MOFI->getEHFrameSection() : 1015 *MOFI->getDwarfFrameSection(); 1016 Streamer.SwitchSection(&Section); 1017 MCSymbol *SectionStart = Context.CreateTempSymbol(); 1018 Streamer.EmitLabel(SectionStart); 1019 1020 MCSymbol *FDEEnd = NULL; 1021 DenseMap<CIEKey, const MCSymbol*> CIEStarts; 1022 FrameEmitterImpl Emitter(UsingCFI, IsEH, SectionStart); 1023 1024 const MCSymbol *DummyDebugKey = NULL; 1025 for (unsigned i = 0, n = Streamer.getNumFrameInfos(); i < n; ++i) { 1026 const MCDwarfFrameInfo &Frame = Streamer.getFrameInfo(i); 1027 if (IsEH && MOFI->getCompactUnwindSection() && 1028 Frame.CompactUnwindEncoding && 1029 Emitter.EmitCompactUnwind(Streamer, Frame)) { 1030 FDEEnd = NULL; 1031 continue; 1032 } 1033 1034 CIEKey Key(Frame.Personality, Frame.PersonalityEncoding, 1035 Frame.LsdaEncoding); 1036 const MCSymbol *&CIEStart = IsEH ? CIEStarts[Key] : DummyDebugKey; 1037 if (!CIEStart) 1038 CIEStart = &Emitter.EmitCIE(Streamer, Frame.Personality, 1039 Frame.PersonalityEncoding, Frame.Lsda, 1040 Frame.LsdaEncoding); 1041 1042 FDEEnd = Emitter.EmitFDE(Streamer, *CIEStart, Frame); 1043 1044 if (i != n - 1) 1045 Streamer.EmitLabel(FDEEnd); 1046 } 1047 1048 Streamer.EmitValueToAlignment(Context.getAsmInfo().getPointerSize()); 1049 if (FDEEnd) 1050 Streamer.EmitLabel(FDEEnd); 1051} 1052 1053void MCDwarfFrameEmitter::EmitAdvanceLoc(MCStreamer &Streamer, 1054 uint64_t AddrDelta) { 1055 SmallString<256> Tmp; 1056 raw_svector_ostream OS(Tmp); 1057 MCDwarfFrameEmitter::EncodeAdvanceLoc(AddrDelta, OS); 1058 Streamer.EmitBytes(OS.str(), /*AddrSpace=*/0); 1059} 1060 1061void MCDwarfFrameEmitter::EncodeAdvanceLoc(uint64_t AddrDelta, 1062 raw_ostream &OS) { 1063 // FIXME: Assumes the code alignment factor is 1. 1064 if (AddrDelta == 0) { 1065 } else if (isUIntN(6, AddrDelta)) { 1066 uint8_t Opcode = dwarf::DW_CFA_advance_loc | AddrDelta; 1067 OS << Opcode; 1068 } else if (isUInt<8>(AddrDelta)) { 1069 OS << uint8_t(dwarf::DW_CFA_advance_loc1); 1070 OS << uint8_t(AddrDelta); 1071 } else if (isUInt<16>(AddrDelta)) { 1072 // FIXME: check what is the correct behavior on a big endian machine. 1073 OS << uint8_t(dwarf::DW_CFA_advance_loc2); 1074 OS << uint8_t( AddrDelta & 0xff); 1075 OS << uint8_t((AddrDelta >> 8) & 0xff); 1076 } else { 1077 // FIXME: check what is the correct behavior on a big endian machine. 1078 assert(isUInt<32>(AddrDelta)); 1079 OS << uint8_t(dwarf::DW_CFA_advance_loc4); 1080 OS << uint8_t( AddrDelta & 0xff); 1081 OS << uint8_t((AddrDelta >> 8) & 0xff); 1082 OS << uint8_t((AddrDelta >> 16) & 0xff); 1083 OS << uint8_t((AddrDelta >> 24) & 0xff); 1084 1085 } 1086} 1087