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