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