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