MCStreamer.cpp revision 36b56886974eae4f9c5ebc96befd3e7bfe5de338
1//===- lib/MC/MCStreamer.cpp - Streaming Machine Code Output --------------===// 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/MCStreamer.h" 11#include "llvm/ADT/SmallString.h" 12#include "llvm/ADT/Twine.h" 13#include "llvm/MC/MCAsmBackend.h" 14#include "llvm/MC/MCAsmInfo.h" 15#include "llvm/MC/MCContext.h" 16#include "llvm/MC/MCExpr.h" 17#include "llvm/MC/MCObjectFileInfo.h" 18#include "llvm/MC/MCObjectWriter.h" 19#include "llvm/MC/MCSymbol.h" 20#include "llvm/Support/ErrorHandling.h" 21#include "llvm/Support/LEB128.h" 22#include "llvm/Support/raw_ostream.h" 23#include <cstdlib> 24using namespace llvm; 25 26// Pin the vtables to this file. 27MCTargetStreamer::~MCTargetStreamer() {} 28 29MCTargetStreamer::MCTargetStreamer(MCStreamer &S) : Streamer(S) { 30 S.setTargetStreamer(this); 31} 32 33void MCTargetStreamer::emitLabel(MCSymbol *Symbol) {} 34 35void MCTargetStreamer::finish() {} 36 37void MCTargetStreamer::emitAssignment(MCSymbol *Symbol, const MCExpr *Value) {} 38 39MCStreamer::MCStreamer(MCContext &Ctx) 40 : Context(Ctx), EmitEHFrame(true), EmitDebugFrame(false), 41 CurrentW64UnwindInfo(0), LastSymbol(0) { 42 SectionStack.push_back(std::pair<MCSectionSubPair, MCSectionSubPair>()); 43} 44 45MCStreamer::~MCStreamer() { 46 for (unsigned i = 0; i < getNumW64UnwindInfos(); ++i) 47 delete W64UnwindInfos[i]; 48} 49 50void MCStreamer::reset() { 51 for (unsigned i = 0; i < getNumW64UnwindInfos(); ++i) 52 delete W64UnwindInfos[i]; 53 W64UnwindInfos.clear(); 54 EmitEHFrame = true; 55 EmitDebugFrame = false; 56 CurrentW64UnwindInfo = 0; 57 LastSymbol = 0; 58 SectionStack.clear(); 59 SectionStack.push_back(std::pair<MCSectionSubPair, MCSectionSubPair>()); 60} 61 62const MCExpr *MCStreamer::BuildSymbolDiff(MCContext &Context, 63 const MCSymbol *A, 64 const MCSymbol *B) { 65 MCSymbolRefExpr::VariantKind Variant = MCSymbolRefExpr::VK_None; 66 const MCExpr *ARef = 67 MCSymbolRefExpr::Create(A, Variant, Context); 68 const MCExpr *BRef = 69 MCSymbolRefExpr::Create(B, Variant, Context); 70 const MCExpr *AddrDelta = 71 MCBinaryExpr::Create(MCBinaryExpr::Sub, ARef, BRef, Context); 72 return AddrDelta; 73} 74 75const MCExpr *MCStreamer::ForceExpAbs(const MCExpr* Expr) { 76 assert(!isa<MCSymbolRefExpr>(Expr)); 77 if (Context.getAsmInfo()->hasAggressiveSymbolFolding()) 78 return Expr; 79 80 MCSymbol *ABS = Context.CreateTempSymbol(); 81 EmitAssignment(ABS, Expr); 82 return MCSymbolRefExpr::Create(ABS, Context); 83} 84 85raw_ostream &MCStreamer::GetCommentOS() { 86 // By default, discard comments. 87 return nulls(); 88} 89 90void MCStreamer::emitRawComment(const Twine &T, bool TabPrefix) {} 91 92void MCStreamer::generateCompactUnwindEncodings(MCAsmBackend *MAB) { 93 for (std::vector<MCDwarfFrameInfo>::iterator I = FrameInfos.begin(), 94 E = FrameInfos.end(); I != E; ++I) 95 I->CompactUnwindEncoding = 96 (MAB ? MAB->generateCompactUnwindEncoding(I->Instructions) : 0); 97} 98 99void MCStreamer::EmitDwarfSetLineAddr(int64_t LineDelta, 100 const MCSymbol *Label, int PointerSize) { 101 // emit the sequence to set the address 102 EmitIntValue(dwarf::DW_LNS_extended_op, 1); 103 EmitULEB128IntValue(PointerSize + 1); 104 EmitIntValue(dwarf::DW_LNE_set_address, 1); 105 EmitSymbolValue(Label, PointerSize); 106 107 // emit the sequence for the LineDelta (from 1) and a zero address delta. 108 MCDwarfLineAddr::Emit(this, LineDelta, 0); 109} 110 111/// EmitIntValue - Special case of EmitValue that avoids the client having to 112/// pass in a MCExpr for constant integers. 113void MCStreamer::EmitIntValue(uint64_t Value, unsigned Size) { 114 assert(Size <= 8 && "Invalid size"); 115 assert((isUIntN(8 * Size, Value) || isIntN(8 * Size, Value)) && 116 "Invalid size"); 117 char buf[8]; 118 const bool isLittleEndian = Context.getAsmInfo()->isLittleEndian(); 119 for (unsigned i = 0; i != Size; ++i) { 120 unsigned index = isLittleEndian ? i : (Size - i - 1); 121 buf[i] = uint8_t(Value >> (index * 8)); 122 } 123 EmitBytes(StringRef(buf, Size)); 124} 125 126/// EmitULEB128Value - Special case of EmitULEB128Value that avoids the 127/// client having to pass in a MCExpr for constant integers. 128void MCStreamer::EmitULEB128IntValue(uint64_t Value, unsigned Padding) { 129 SmallString<128> Tmp; 130 raw_svector_ostream OSE(Tmp); 131 encodeULEB128(Value, OSE, Padding); 132 EmitBytes(OSE.str()); 133} 134 135/// EmitSLEB128Value - Special case of EmitSLEB128Value that avoids the 136/// client having to pass in a MCExpr for constant integers. 137void MCStreamer::EmitSLEB128IntValue(int64_t Value) { 138 SmallString<128> Tmp; 139 raw_svector_ostream OSE(Tmp); 140 encodeSLEB128(Value, OSE); 141 EmitBytes(OSE.str()); 142} 143 144void MCStreamer::EmitAbsValue(const MCExpr *Value, unsigned Size) { 145 const MCExpr *ABS = ForceExpAbs(Value); 146 EmitValue(ABS, Size); 147} 148 149 150void MCStreamer::EmitValue(const MCExpr *Value, unsigned Size) { 151 EmitValueImpl(Value, Size); 152} 153 154void MCStreamer::EmitSymbolValue(const MCSymbol *Sym, unsigned Size) { 155 EmitValueImpl(MCSymbolRefExpr::Create(Sym, getContext()), Size); 156} 157 158void MCStreamer::EmitGPRel64Value(const MCExpr *Value) { 159 report_fatal_error("unsupported directive in streamer"); 160} 161 162void MCStreamer::EmitGPRel32Value(const MCExpr *Value) { 163 report_fatal_error("unsupported directive in streamer"); 164} 165 166/// EmitFill - Emit NumBytes bytes worth of the value specified by 167/// FillValue. This implements directives such as '.space'. 168void MCStreamer::EmitFill(uint64_t NumBytes, uint8_t FillValue) { 169 const MCExpr *E = MCConstantExpr::Create(FillValue, getContext()); 170 for (uint64_t i = 0, e = NumBytes; i != e; ++i) 171 EmitValue(E, 1); 172} 173 174/// The implementation in this class just redirects to EmitFill. 175void MCStreamer::EmitZeros(uint64_t NumBytes) { 176 EmitFill(NumBytes, 0); 177} 178 179unsigned MCStreamer::EmitDwarfFileDirective(unsigned FileNo, 180 StringRef Directory, 181 StringRef Filename, unsigned CUID) { 182 return getContext().GetDwarfFile(Directory, Filename, FileNo, CUID); 183} 184 185void MCStreamer::EmitDwarfLocDirective(unsigned FileNo, unsigned Line, 186 unsigned Column, unsigned Flags, 187 unsigned Isa, 188 unsigned Discriminator, 189 StringRef FileName) { 190 getContext().setCurrentDwarfLoc(FileNo, Line, Column, Flags, Isa, 191 Discriminator); 192} 193 194MCSymbol *MCStreamer::getDwarfLineTableSymbol(unsigned CUID) { 195 MCDwarfLineTable &Table = getContext().getMCDwarfLineTable(CUID); 196 if (!Table.getLabel()) { 197 StringRef Prefix = Context.getAsmInfo()->getPrivateGlobalPrefix(); 198 Table.setLabel( 199 Context.GetOrCreateSymbol(Prefix + "line_table_start" + Twine(CUID))); 200 } 201 return Table.getLabel(); 202} 203 204MCDwarfFrameInfo *MCStreamer::getCurrentFrameInfo() { 205 if (FrameInfos.empty()) 206 return 0; 207 return &FrameInfos.back(); 208} 209 210void MCStreamer::EnsureValidFrame() { 211 MCDwarfFrameInfo *CurFrame = getCurrentFrameInfo(); 212 if (!CurFrame || CurFrame->End) 213 report_fatal_error("No open frame"); 214} 215 216void MCStreamer::EmitEHSymAttributes(const MCSymbol *Symbol, 217 MCSymbol *EHSymbol) { 218} 219 220void MCStreamer::InitSections() { 221 SwitchSection(getContext().getObjectFileInfo()->getTextSection()); 222} 223 224void MCStreamer::AssignSection(MCSymbol *Symbol, const MCSection *Section) { 225 if (Section) 226 Symbol->setSection(*Section); 227 else 228 Symbol->setUndefined(); 229 230 // As we emit symbols into a section, track the order so that they can 231 // be sorted upon later. Zero is reserved to mean 'unemitted'. 232 SymbolOrdering[Symbol] = 1 + SymbolOrdering.size(); 233} 234 235void MCStreamer::EmitLabel(MCSymbol *Symbol) { 236 assert(!Symbol->isVariable() && "Cannot emit a variable symbol!"); 237 assert(getCurrentSection().first && "Cannot emit before setting section!"); 238 AssignSection(Symbol, getCurrentSection().first); 239 LastSymbol = Symbol; 240 241 MCTargetStreamer *TS = getTargetStreamer(); 242 if (TS) 243 TS->emitLabel(Symbol); 244} 245 246void MCStreamer::EmitDebugLabel(MCSymbol *Symbol) { 247 assert(!Symbol->isVariable() && "Cannot emit a variable symbol!"); 248 assert(getCurrentSection().first && "Cannot emit before setting section!"); 249 AssignSection(Symbol, getCurrentSection().first); 250 LastSymbol = Symbol; 251} 252 253void MCStreamer::EmitCompactUnwindEncoding(uint32_t CompactUnwindEncoding) { 254 EnsureValidFrame(); 255 MCDwarfFrameInfo *CurFrame = getCurrentFrameInfo(); 256 CurFrame->CompactUnwindEncoding = CompactUnwindEncoding; 257} 258 259void MCStreamer::EmitCFISections(bool EH, bool Debug) { 260 assert(EH || Debug); 261 EmitEHFrame = EH; 262 EmitDebugFrame = Debug; 263} 264 265void MCStreamer::EmitCFIStartProc(bool IsSimple) { 266 MCDwarfFrameInfo *CurFrame = getCurrentFrameInfo(); 267 if (CurFrame && !CurFrame->End) 268 report_fatal_error("Starting a frame before finishing the previous one!"); 269 270 MCDwarfFrameInfo Frame; 271 Frame.IsSimple = IsSimple; 272 EmitCFIStartProcImpl(Frame); 273 274 FrameInfos.push_back(Frame); 275} 276 277void MCStreamer::EmitCFIStartProcImpl(MCDwarfFrameInfo &Frame) { 278} 279 280void MCStreamer::RecordProcStart(MCDwarfFrameInfo &Frame) { 281 Frame.Function = LastSymbol; 282 // We need to create a local symbol to avoid relocations. 283 Frame.Begin = getContext().CreateTempSymbol(); 284 EmitLabel(Frame.Begin); 285} 286 287void MCStreamer::EmitCFIEndProc() { 288 EnsureValidFrame(); 289 MCDwarfFrameInfo *CurFrame = getCurrentFrameInfo(); 290 EmitCFIEndProcImpl(*CurFrame); 291} 292 293void MCStreamer::EmitCFIEndProcImpl(MCDwarfFrameInfo &Frame) { 294} 295 296void MCStreamer::RecordProcEnd(MCDwarfFrameInfo &Frame) { 297 Frame.End = getContext().CreateTempSymbol(); 298 EmitLabel(Frame.End); 299} 300 301MCSymbol *MCStreamer::EmitCFICommon() { 302 EnsureValidFrame(); 303 MCSymbol *Label = getContext().CreateTempSymbol(); 304 EmitLabel(Label); 305 return Label; 306} 307 308void MCStreamer::EmitCFIDefCfa(int64_t Register, int64_t Offset) { 309 MCSymbol *Label = EmitCFICommon(); 310 MCCFIInstruction Instruction = 311 MCCFIInstruction::createDefCfa(Label, Register, Offset); 312 MCDwarfFrameInfo *CurFrame = getCurrentFrameInfo(); 313 CurFrame->Instructions.push_back(Instruction); 314} 315 316void MCStreamer::EmitCFIDefCfaOffset(int64_t Offset) { 317 MCSymbol *Label = EmitCFICommon(); 318 MCCFIInstruction Instruction = 319 MCCFIInstruction::createDefCfaOffset(Label, Offset); 320 MCDwarfFrameInfo *CurFrame = getCurrentFrameInfo(); 321 CurFrame->Instructions.push_back(Instruction); 322} 323 324void MCStreamer::EmitCFIAdjustCfaOffset(int64_t Adjustment) { 325 MCSymbol *Label = EmitCFICommon(); 326 MCCFIInstruction Instruction = 327 MCCFIInstruction::createAdjustCfaOffset(Label, Adjustment); 328 MCDwarfFrameInfo *CurFrame = getCurrentFrameInfo(); 329 CurFrame->Instructions.push_back(Instruction); 330} 331 332void MCStreamer::EmitCFIDefCfaRegister(int64_t Register) { 333 MCSymbol *Label = EmitCFICommon(); 334 MCCFIInstruction Instruction = 335 MCCFIInstruction::createDefCfaRegister(Label, Register); 336 MCDwarfFrameInfo *CurFrame = getCurrentFrameInfo(); 337 CurFrame->Instructions.push_back(Instruction); 338} 339 340void MCStreamer::EmitCFIOffset(int64_t Register, int64_t Offset) { 341 MCSymbol *Label = EmitCFICommon(); 342 MCCFIInstruction Instruction = 343 MCCFIInstruction::createOffset(Label, Register, Offset); 344 MCDwarfFrameInfo *CurFrame = getCurrentFrameInfo(); 345 CurFrame->Instructions.push_back(Instruction); 346} 347 348void MCStreamer::EmitCFIRelOffset(int64_t Register, int64_t Offset) { 349 MCSymbol *Label = EmitCFICommon(); 350 MCCFIInstruction Instruction = 351 MCCFIInstruction::createRelOffset(Label, Register, Offset); 352 MCDwarfFrameInfo *CurFrame = getCurrentFrameInfo(); 353 CurFrame->Instructions.push_back(Instruction); 354} 355 356void MCStreamer::EmitCFIPersonality(const MCSymbol *Sym, 357 unsigned Encoding) { 358 EnsureValidFrame(); 359 MCDwarfFrameInfo *CurFrame = getCurrentFrameInfo(); 360 CurFrame->Personality = Sym; 361 CurFrame->PersonalityEncoding = Encoding; 362} 363 364void MCStreamer::EmitCFILsda(const MCSymbol *Sym, unsigned Encoding) { 365 EnsureValidFrame(); 366 MCDwarfFrameInfo *CurFrame = getCurrentFrameInfo(); 367 CurFrame->Lsda = Sym; 368 CurFrame->LsdaEncoding = Encoding; 369} 370 371void MCStreamer::EmitCFIRememberState() { 372 MCSymbol *Label = EmitCFICommon(); 373 MCCFIInstruction Instruction = MCCFIInstruction::createRememberState(Label); 374 MCDwarfFrameInfo *CurFrame = getCurrentFrameInfo(); 375 CurFrame->Instructions.push_back(Instruction); 376} 377 378void MCStreamer::EmitCFIRestoreState() { 379 // FIXME: Error if there is no matching cfi_remember_state. 380 MCSymbol *Label = EmitCFICommon(); 381 MCCFIInstruction Instruction = MCCFIInstruction::createRestoreState(Label); 382 MCDwarfFrameInfo *CurFrame = getCurrentFrameInfo(); 383 CurFrame->Instructions.push_back(Instruction); 384} 385 386void MCStreamer::EmitCFISameValue(int64_t Register) { 387 MCSymbol *Label = EmitCFICommon(); 388 MCCFIInstruction Instruction = 389 MCCFIInstruction::createSameValue(Label, Register); 390 MCDwarfFrameInfo *CurFrame = getCurrentFrameInfo(); 391 CurFrame->Instructions.push_back(Instruction); 392} 393 394void MCStreamer::EmitCFIRestore(int64_t Register) { 395 MCSymbol *Label = EmitCFICommon(); 396 MCCFIInstruction Instruction = 397 MCCFIInstruction::createRestore(Label, Register); 398 MCDwarfFrameInfo *CurFrame = getCurrentFrameInfo(); 399 CurFrame->Instructions.push_back(Instruction); 400} 401 402void MCStreamer::EmitCFIEscape(StringRef Values) { 403 MCSymbol *Label = EmitCFICommon(); 404 MCCFIInstruction Instruction = MCCFIInstruction::createEscape(Label, Values); 405 MCDwarfFrameInfo *CurFrame = getCurrentFrameInfo(); 406 CurFrame->Instructions.push_back(Instruction); 407} 408 409void MCStreamer::EmitCFISignalFrame() { 410 EnsureValidFrame(); 411 MCDwarfFrameInfo *CurFrame = getCurrentFrameInfo(); 412 CurFrame->IsSignalFrame = true; 413} 414 415void MCStreamer::EmitCFIUndefined(int64_t Register) { 416 MCSymbol *Label = EmitCFICommon(); 417 MCCFIInstruction Instruction = 418 MCCFIInstruction::createUndefined(Label, Register); 419 MCDwarfFrameInfo *CurFrame = getCurrentFrameInfo(); 420 CurFrame->Instructions.push_back(Instruction); 421} 422 423void MCStreamer::EmitCFIRegister(int64_t Register1, int64_t Register2) { 424 MCSymbol *Label = EmitCFICommon(); 425 MCCFIInstruction Instruction = 426 MCCFIInstruction::createRegister(Label, Register1, Register2); 427 MCDwarfFrameInfo *CurFrame = getCurrentFrameInfo(); 428 CurFrame->Instructions.push_back(Instruction); 429} 430 431void MCStreamer::EmitCFIWindowSave() { 432 MCSymbol *Label = EmitCFICommon(); 433 MCCFIInstruction Instruction = 434 MCCFIInstruction::createWindowSave(Label); 435 MCDwarfFrameInfo *CurFrame = getCurrentFrameInfo(); 436 CurFrame->Instructions.push_back(Instruction); 437} 438 439void MCStreamer::setCurrentW64UnwindInfo(MCWin64EHUnwindInfo *Frame) { 440 W64UnwindInfos.push_back(Frame); 441 CurrentW64UnwindInfo = W64UnwindInfos.back(); 442} 443 444void MCStreamer::EnsureValidW64UnwindInfo() { 445 MCWin64EHUnwindInfo *CurFrame = CurrentW64UnwindInfo; 446 if (!CurFrame || CurFrame->End) 447 report_fatal_error("No open Win64 EH frame function!"); 448} 449 450void MCStreamer::EmitWin64EHStartProc(const MCSymbol *Symbol) { 451 MCWin64EHUnwindInfo *CurFrame = CurrentW64UnwindInfo; 452 if (CurFrame && !CurFrame->End) 453 report_fatal_error("Starting a function before ending the previous one!"); 454 MCWin64EHUnwindInfo *Frame = new MCWin64EHUnwindInfo; 455 Frame->Begin = getContext().CreateTempSymbol(); 456 Frame->Function = Symbol; 457 EmitLabel(Frame->Begin); 458 setCurrentW64UnwindInfo(Frame); 459} 460 461void MCStreamer::EmitWin64EHEndProc() { 462 EnsureValidW64UnwindInfo(); 463 MCWin64EHUnwindInfo *CurFrame = CurrentW64UnwindInfo; 464 if (CurFrame->ChainedParent) 465 report_fatal_error("Not all chained regions terminated!"); 466 CurFrame->End = getContext().CreateTempSymbol(); 467 EmitLabel(CurFrame->End); 468} 469 470void MCStreamer::EmitWin64EHStartChained() { 471 EnsureValidW64UnwindInfo(); 472 MCWin64EHUnwindInfo *Frame = new MCWin64EHUnwindInfo; 473 MCWin64EHUnwindInfo *CurFrame = CurrentW64UnwindInfo; 474 Frame->Begin = getContext().CreateTempSymbol(); 475 Frame->Function = CurFrame->Function; 476 Frame->ChainedParent = CurFrame; 477 EmitLabel(Frame->Begin); 478 setCurrentW64UnwindInfo(Frame); 479} 480 481void MCStreamer::EmitWin64EHEndChained() { 482 EnsureValidW64UnwindInfo(); 483 MCWin64EHUnwindInfo *CurFrame = CurrentW64UnwindInfo; 484 if (!CurFrame->ChainedParent) 485 report_fatal_error("End of a chained region outside a chained region!"); 486 CurFrame->End = getContext().CreateTempSymbol(); 487 EmitLabel(CurFrame->End); 488 CurrentW64UnwindInfo = CurFrame->ChainedParent; 489} 490 491void MCStreamer::EmitWin64EHHandler(const MCSymbol *Sym, bool Unwind, 492 bool Except) { 493 EnsureValidW64UnwindInfo(); 494 MCWin64EHUnwindInfo *CurFrame = CurrentW64UnwindInfo; 495 if (CurFrame->ChainedParent) 496 report_fatal_error("Chained unwind areas can't have handlers!"); 497 CurFrame->ExceptionHandler = Sym; 498 if (!Except && !Unwind) 499 report_fatal_error("Don't know what kind of handler this is!"); 500 if (Unwind) 501 CurFrame->HandlesUnwind = true; 502 if (Except) 503 CurFrame->HandlesExceptions = true; 504} 505 506void MCStreamer::EmitWin64EHHandlerData() { 507 EnsureValidW64UnwindInfo(); 508 MCWin64EHUnwindInfo *CurFrame = CurrentW64UnwindInfo; 509 if (CurFrame->ChainedParent) 510 report_fatal_error("Chained unwind areas can't have handlers!"); 511} 512 513void MCStreamer::EmitWin64EHPushReg(unsigned Register) { 514 EnsureValidW64UnwindInfo(); 515 MCWin64EHUnwindInfo *CurFrame = CurrentW64UnwindInfo; 516 MCSymbol *Label = getContext().CreateTempSymbol(); 517 MCWin64EHInstruction Inst(Win64EH::UOP_PushNonVol, Label, Register); 518 EmitLabel(Label); 519 CurFrame->Instructions.push_back(Inst); 520} 521 522void MCStreamer::EmitWin64EHSetFrame(unsigned Register, unsigned Offset) { 523 EnsureValidW64UnwindInfo(); 524 MCWin64EHUnwindInfo *CurFrame = CurrentW64UnwindInfo; 525 if (CurFrame->LastFrameInst >= 0) 526 report_fatal_error("Frame register and offset already specified!"); 527 if (Offset & 0x0F) 528 report_fatal_error("Misaligned frame pointer offset!"); 529 MCSymbol *Label = getContext().CreateTempSymbol(); 530 MCWin64EHInstruction Inst(Win64EH::UOP_SetFPReg, Label, Register, Offset); 531 EmitLabel(Label); 532 CurFrame->LastFrameInst = CurFrame->Instructions.size(); 533 CurFrame->Instructions.push_back(Inst); 534} 535 536void MCStreamer::EmitWin64EHAllocStack(unsigned Size) { 537 EnsureValidW64UnwindInfo(); 538 if (Size & 7) 539 report_fatal_error("Misaligned stack allocation!"); 540 MCWin64EHUnwindInfo *CurFrame = CurrentW64UnwindInfo; 541 MCSymbol *Label = getContext().CreateTempSymbol(); 542 MCWin64EHInstruction Inst(Label, Size); 543 EmitLabel(Label); 544 CurFrame->Instructions.push_back(Inst); 545} 546 547void MCStreamer::EmitWin64EHSaveReg(unsigned Register, unsigned Offset) { 548 EnsureValidW64UnwindInfo(); 549 if (Offset & 7) 550 report_fatal_error("Misaligned saved register offset!"); 551 MCWin64EHUnwindInfo *CurFrame = CurrentW64UnwindInfo; 552 MCSymbol *Label = getContext().CreateTempSymbol(); 553 MCWin64EHInstruction Inst( 554 Offset > 512*1024-8 ? Win64EH::UOP_SaveNonVolBig : Win64EH::UOP_SaveNonVol, 555 Label, Register, Offset); 556 EmitLabel(Label); 557 CurFrame->Instructions.push_back(Inst); 558} 559 560void MCStreamer::EmitWin64EHSaveXMM(unsigned Register, unsigned Offset) { 561 EnsureValidW64UnwindInfo(); 562 if (Offset & 0x0F) 563 report_fatal_error("Misaligned saved vector register offset!"); 564 MCWin64EHUnwindInfo *CurFrame = CurrentW64UnwindInfo; 565 MCSymbol *Label = getContext().CreateTempSymbol(); 566 MCWin64EHInstruction Inst( 567 Offset > 512*1024-16 ? Win64EH::UOP_SaveXMM128Big : Win64EH::UOP_SaveXMM128, 568 Label, Register, Offset); 569 EmitLabel(Label); 570 CurFrame->Instructions.push_back(Inst); 571} 572 573void MCStreamer::EmitWin64EHPushFrame(bool Code) { 574 EnsureValidW64UnwindInfo(); 575 MCWin64EHUnwindInfo *CurFrame = CurrentW64UnwindInfo; 576 if (CurFrame->Instructions.size() > 0) 577 report_fatal_error("If present, PushMachFrame must be the first UOP"); 578 MCSymbol *Label = getContext().CreateTempSymbol(); 579 MCWin64EHInstruction Inst(Win64EH::UOP_PushMachFrame, Label, Code); 580 EmitLabel(Label); 581 CurFrame->Instructions.push_back(Inst); 582} 583 584void MCStreamer::EmitWin64EHEndProlog() { 585 EnsureValidW64UnwindInfo(); 586 MCWin64EHUnwindInfo *CurFrame = CurrentW64UnwindInfo; 587 CurFrame->PrologEnd = getContext().CreateTempSymbol(); 588 EmitLabel(CurFrame->PrologEnd); 589} 590 591void MCStreamer::EmitCOFFSectionIndex(MCSymbol const *Symbol) { 592 llvm_unreachable("This file format doesn't support this directive"); 593} 594 595void MCStreamer::EmitCOFFSecRel32(MCSymbol const *Symbol) { 596 llvm_unreachable("This file format doesn't support this directive"); 597} 598 599/// EmitRawText - If this file is backed by an assembly streamer, this dumps 600/// the specified string in the output .s file. This capability is 601/// indicated by the hasRawTextSupport() predicate. 602void MCStreamer::EmitRawTextImpl(StringRef String) { 603 errs() << "EmitRawText called on an MCStreamer that doesn't support it, " 604 " something must not be fully mc'ized\n"; 605 abort(); 606} 607 608void MCStreamer::EmitRawText(const Twine &T) { 609 SmallString<128> Str; 610 EmitRawTextImpl(T.toStringRef(Str)); 611} 612 613void MCStreamer::EmitFrames(MCAsmBackend *MAB, bool usingCFI) { 614 if (!getNumFrameInfos()) 615 return; 616 617 if (EmitEHFrame) 618 MCDwarfFrameEmitter::Emit(*this, MAB, usingCFI, true); 619 620 if (EmitDebugFrame) 621 MCDwarfFrameEmitter::Emit(*this, MAB, usingCFI, false); 622} 623 624void MCStreamer::EmitW64Tables() { 625 if (!getNumW64UnwindInfos()) 626 return; 627 628 MCWin64EHUnwindEmitter::Emit(*this); 629} 630 631void MCStreamer::Finish() { 632 if (!FrameInfos.empty() && !FrameInfos.back().End) 633 report_fatal_error("Unfinished frame!"); 634 635 MCTargetStreamer *TS = getTargetStreamer(); 636 if (TS) 637 TS->finish(); 638 639 FinishImpl(); 640} 641 642MCSymbolData &MCStreamer::getOrCreateSymbolData(const MCSymbol *Symbol) { 643 report_fatal_error("Not supported!"); 644 return *(static_cast<MCSymbolData*>(0)); 645} 646 647void MCStreamer::EmitAssignment(MCSymbol *Symbol, const MCExpr *Value) { 648 Symbol->setVariableValue(Value); 649 650 MCTargetStreamer *TS = getTargetStreamer(); 651 if (TS) 652 TS->emitAssignment(Symbol, Value); 653} 654