lib/MC/MCStreamer.cpp

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