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/MCStreamer.h"
     11 #include "llvm/ADT/SmallString.h"
     12 #include "llvm/ADT/Twine.h"
     13 #include "llvm/MC/MCAsmBackend.h"
     14 #include "llvm/MC/MCAsmInfo.h"
     15 #include "llvm/MC/MCContext.h"
     16 #include "llvm/MC/MCExpr.h"
     17 #include "llvm/MC/MCObjectFileInfo.h"
     18 #include "llvm/MC/MCObjectWriter.h"
     19 #include "llvm/MC/MCSection.h"
     20 #include "llvm/MC/MCSymbol.h"
     21 #include "llvm/MC/MCWin64EH.h"
     22 #include "llvm/Support/ErrorHandling.h"
     23 #include "llvm/Support/LEB128.h"
     24 #include "llvm/Support/raw_ostream.h"
     25 #include <cstdlib>
     26 using namespace llvm;
     27 
     28 // Pin the vtables to this file.
     29 MCTargetStreamer::~MCTargetStreamer() {}
     30 
     31 MCTargetStreamer::MCTargetStreamer(MCStreamer &S) : Streamer(S) {
     32   S.setTargetStreamer(this);
     33 }
     34 
     35 void MCTargetStreamer::emitLabel(MCSymbol *Symbol) {}
     36 
     37 void MCTargetStreamer::finish() {}
     38 
     39 void MCTargetStreamer::emitAssignment(MCSymbol *Symbol, const MCExpr *Value) {}
     40 
     41 MCStreamer::MCStreamer(MCContext &Ctx)
     42     : Context(Ctx), CurrentWinFrameInfo(nullptr) {
     43   SectionStack.push_back(std::pair<MCSectionSubPair, MCSectionSubPair>());
     44 }
     45 
     46 MCStreamer::~MCStreamer() {
     47   for (unsigned i = 0; i < getNumWinFrameInfos(); ++i)
     48     delete WinFrameInfos[i];
     49 }
     50 
     51 void MCStreamer::reset() {
     52   DwarfFrameInfos.clear();
     53   for (unsigned i = 0; i < getNumWinFrameInfos(); ++i)
     54     delete WinFrameInfos[i];
     55   WinFrameInfos.clear();
     56   CurrentWinFrameInfo = nullptr;
     57   SymbolOrdering.clear();
     58   SectionStack.clear();
     59   SectionStack.push_back(std::pair<MCSectionSubPair, MCSectionSubPair>());
     60 }
     61 
     62 raw_ostream &MCStreamer::GetCommentOS() {
     63   // By default, discard comments.
     64   return nulls();
     65 }
     66 
     67 void MCStreamer::emitRawComment(const Twine &T, bool TabPrefix) {}
     68 
     69 void MCStreamer::generateCompactUnwindEncodings(MCAsmBackend *MAB) {
     70   for (auto &FI : DwarfFrameInfos)
     71     FI.CompactUnwindEncoding =
     72         (MAB ? MAB->generateCompactUnwindEncoding(FI.Instructions) : 0);
     73 }
     74 
     75 /// EmitIntValue - Special case of EmitValue that avoids the client having to
     76 /// pass in a MCExpr for constant integers.
     77 void MCStreamer::EmitIntValue(uint64_t Value, unsigned Size) {
     78   assert(1 <= Size && Size <= 8 && "Invalid size");
     79   assert((isUIntN(8 * Size, Value) || isIntN(8 * Size, Value)) &&
     80          "Invalid size");
     81   char buf[8];
     82   const bool isLittleEndian = Context.getAsmInfo()->isLittleEndian();
     83   for (unsigned i = 0; i != Size; ++i) {
     84     unsigned index = isLittleEndian ? i : (Size - i - 1);
     85     buf[i] = uint8_t(Value >> (index * 8));
     86   }
     87   EmitBytes(StringRef(buf, Size));
     88 }
     89 
     90 /// EmitULEB128Value - Special case of EmitULEB128Value that avoids the
     91 /// client having to pass in a MCExpr for constant integers.
     92 void MCStreamer::EmitULEB128IntValue(uint64_t Value, unsigned Padding) {
     93   SmallString<128> Tmp;
     94   raw_svector_ostream OSE(Tmp);
     95   encodeULEB128(Value, OSE, Padding);
     96   EmitBytes(OSE.str());
     97 }
     98 
     99 /// EmitSLEB128Value - Special case of EmitSLEB128Value that avoids the
    100 /// client having to pass in a MCExpr for constant integers.
    101 void MCStreamer::EmitSLEB128IntValue(int64_t Value) {
    102   SmallString<128> Tmp;
    103   raw_svector_ostream OSE(Tmp);
    104   encodeSLEB128(Value, OSE);
    105   EmitBytes(OSE.str());
    106 }
    107 
    108 void MCStreamer::EmitValue(const MCExpr *Value, unsigned Size,
    109                            const SMLoc &Loc) {
    110   EmitValueImpl(Value, Size, Loc);
    111 }
    112 
    113 void MCStreamer::EmitSymbolValue(const MCSymbol *Sym, unsigned Size,
    114                                  bool IsSectionRelative) {
    115   assert((!IsSectionRelative || Size == 4) &&
    116          "SectionRelative value requires 4-bytes");
    117 
    118   if (!IsSectionRelative)
    119     EmitValueImpl(MCSymbolRefExpr::Create(Sym, getContext()), Size);
    120   else
    121     EmitCOFFSecRel32(Sym);
    122 }
    123 
    124 void MCStreamer::EmitGPRel64Value(const MCExpr *Value) {
    125   report_fatal_error("unsupported directive in streamer");
    126 }
    127 
    128 void MCStreamer::EmitGPRel32Value(const MCExpr *Value) {
    129   report_fatal_error("unsupported directive in streamer");
    130 }
    131 
    132 /// EmitFill - Emit NumBytes bytes worth of the value specified by
    133 /// FillValue.  This implements directives such as '.space'.
    134 void MCStreamer::EmitFill(uint64_t NumBytes, uint8_t FillValue) {
    135   const MCExpr *E = MCConstantExpr::Create(FillValue, getContext());
    136   for (uint64_t i = 0, e = NumBytes; i != e; ++i)
    137     EmitValue(E, 1);
    138 }
    139 
    140 /// The implementation in this class just redirects to EmitFill.
    141 void MCStreamer::EmitZeros(uint64_t NumBytes) {
    142   EmitFill(NumBytes, 0);
    143 }
    144 
    145 unsigned MCStreamer::EmitDwarfFileDirective(unsigned FileNo,
    146                                             StringRef Directory,
    147                                             StringRef Filename, unsigned CUID) {
    148   return getContext().GetDwarfFile(Directory, Filename, FileNo, CUID);
    149 }
    150 
    151 void MCStreamer::EmitDwarfLocDirective(unsigned FileNo, unsigned Line,
    152                                        unsigned Column, unsigned Flags,
    153                                        unsigned Isa,
    154                                        unsigned Discriminator,
    155                                        StringRef FileName) {
    156   getContext().setCurrentDwarfLoc(FileNo, Line, Column, Flags, Isa,
    157                                   Discriminator);
    158 }
    159 
    160 MCSymbol *MCStreamer::getDwarfLineTableSymbol(unsigned CUID) {
    161   MCDwarfLineTable &Table = getContext().getMCDwarfLineTable(CUID);
    162   if (!Table.getLabel()) {
    163     StringRef Prefix = Context.getAsmInfo()->getPrivateGlobalPrefix();
    164     Table.setLabel(
    165         Context.GetOrCreateSymbol(Prefix + "line_table_start" + Twine(CUID)));
    166   }
    167   return Table.getLabel();
    168 }
    169 
    170 MCDwarfFrameInfo *MCStreamer::getCurrentDwarfFrameInfo() {
    171   if (DwarfFrameInfos.empty())
    172     return nullptr;
    173   return &DwarfFrameInfos.back();
    174 }
    175 
    176 void MCStreamer::EnsureValidDwarfFrame() {
    177   MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
    178   if (!CurFrame || CurFrame->End)
    179     report_fatal_error("No open frame");
    180 }
    181 
    182 void MCStreamer::EmitEHSymAttributes(const MCSymbol *Symbol,
    183                                      MCSymbol *EHSymbol) {
    184 }
    185 
    186 void MCStreamer::InitSections(bool NoExecStack) {
    187   SwitchSection(getContext().getObjectFileInfo()->getTextSection());
    188 }
    189 
    190 void MCStreamer::AssignSection(MCSymbol *Symbol, const MCSection *Section) {
    191   if (Section)
    192     Symbol->setSection(*Section);
    193   else
    194     Symbol->setUndefined();
    195 
    196   // As we emit symbols into a section, track the order so that they can
    197   // be sorted upon later. Zero is reserved to mean 'unemitted'.
    198   SymbolOrdering[Symbol] = 1 + SymbolOrdering.size();
    199 }
    200 
    201 void MCStreamer::EmitLabel(MCSymbol *Symbol) {
    202   assert(!Symbol->isVariable() && "Cannot emit a variable symbol!");
    203   assert(getCurrentSection().first && "Cannot emit before setting section!");
    204   AssignSection(Symbol, getCurrentSection().first);
    205 
    206   MCTargetStreamer *TS = getTargetStreamer();
    207   if (TS)
    208     TS->emitLabel(Symbol);
    209 }
    210 
    211 void MCStreamer::EmitCFISections(bool EH, bool Debug) {
    212   assert(EH || Debug);
    213 }
    214 
    215 void MCStreamer::EmitCFIStartProc(bool IsSimple) {
    216   MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
    217   if (CurFrame && !CurFrame->End)
    218     report_fatal_error("Starting a frame before finishing the previous one!");
    219 
    220   MCDwarfFrameInfo Frame;
    221   Frame.IsSimple = IsSimple;
    222   EmitCFIStartProcImpl(Frame);
    223 
    224   const MCAsmInfo* MAI = Context.getAsmInfo();
    225   if (MAI) {
    226     for (const MCCFIInstruction& Inst : MAI->getInitialFrameState()) {
    227       if (Inst.getOperation() == MCCFIInstruction::OpDefCfa ||
    228           Inst.getOperation() == MCCFIInstruction::OpDefCfaRegister) {
    229         Frame.CurrentCfaRegister = Inst.getRegister();
    230       }
    231     }
    232   }
    233 
    234   DwarfFrameInfos.push_back(Frame);
    235 }
    236 
    237 void MCStreamer::EmitCFIStartProcImpl(MCDwarfFrameInfo &Frame) {
    238 }
    239 
    240 void MCStreamer::EmitCFIEndProc() {
    241   EnsureValidDwarfFrame();
    242   MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
    243   EmitCFIEndProcImpl(*CurFrame);
    244 }
    245 
    246 void MCStreamer::EmitCFIEndProcImpl(MCDwarfFrameInfo &Frame) {
    247   // Put a dummy non-null value in Frame.End to mark that this frame has been
    248   // closed.
    249   Frame.End = (MCSymbol *) 1;
    250 }
    251 
    252 MCSymbol *MCStreamer::EmitCFICommon() {
    253   EnsureValidDwarfFrame();
    254   MCSymbol *Label = getContext().CreateTempSymbol();
    255   EmitLabel(Label);
    256   return Label;
    257 }
    258 
    259 void MCStreamer::EmitCFIDefCfa(int64_t Register, int64_t Offset) {
    260   MCSymbol *Label = EmitCFICommon();
    261   MCCFIInstruction Instruction =
    262     MCCFIInstruction::createDefCfa(Label, Register, Offset);
    263   MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
    264   CurFrame->Instructions.push_back(Instruction);
    265   CurFrame->CurrentCfaRegister = static_cast<unsigned>(Register);
    266 }
    267 
    268 void MCStreamer::EmitCFIDefCfaOffset(int64_t Offset) {
    269   MCSymbol *Label = EmitCFICommon();
    270   MCCFIInstruction Instruction =
    271     MCCFIInstruction::createDefCfaOffset(Label, Offset);
    272   MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
    273   CurFrame->Instructions.push_back(Instruction);
    274 }
    275 
    276 void MCStreamer::EmitCFIAdjustCfaOffset(int64_t Adjustment) {
    277   MCSymbol *Label = EmitCFICommon();
    278   MCCFIInstruction Instruction =
    279     MCCFIInstruction::createAdjustCfaOffset(Label, Adjustment);
    280   MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
    281   CurFrame->Instructions.push_back(Instruction);
    282 }
    283 
    284 void MCStreamer::EmitCFIDefCfaRegister(int64_t Register) {
    285   MCSymbol *Label = EmitCFICommon();
    286   MCCFIInstruction Instruction =
    287     MCCFIInstruction::createDefCfaRegister(Label, Register);
    288   MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
    289   CurFrame->Instructions.push_back(Instruction);
    290   CurFrame->CurrentCfaRegister = static_cast<unsigned>(Register);
    291 }
    292 
    293 void MCStreamer::EmitCFIOffset(int64_t Register, int64_t Offset) {
    294   MCSymbol *Label = EmitCFICommon();
    295   MCCFIInstruction Instruction =
    296     MCCFIInstruction::createOffset(Label, Register, Offset);
    297   MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
    298   CurFrame->Instructions.push_back(Instruction);
    299 }
    300 
    301 void MCStreamer::EmitCFIRelOffset(int64_t Register, int64_t Offset) {
    302   MCSymbol *Label = EmitCFICommon();
    303   MCCFIInstruction Instruction =
    304     MCCFIInstruction::createRelOffset(Label, Register, Offset);
    305   MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
    306   CurFrame->Instructions.push_back(Instruction);
    307 }
    308 
    309 void MCStreamer::EmitCFIPersonality(const MCSymbol *Sym,
    310                                     unsigned Encoding) {
    311   EnsureValidDwarfFrame();
    312   MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
    313   CurFrame->Personality = Sym;
    314   CurFrame->PersonalityEncoding = Encoding;
    315 }
    316 
    317 void MCStreamer::EmitCFILsda(const MCSymbol *Sym, unsigned Encoding) {
    318   EnsureValidDwarfFrame();
    319   MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
    320   CurFrame->Lsda = Sym;
    321   CurFrame->LsdaEncoding = Encoding;
    322 }
    323 
    324 void MCStreamer::EmitCFIRememberState() {
    325   MCSymbol *Label = EmitCFICommon();
    326   MCCFIInstruction Instruction = MCCFIInstruction::createRememberState(Label);
    327   MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
    328   CurFrame->Instructions.push_back(Instruction);
    329 }
    330 
    331 void MCStreamer::EmitCFIRestoreState() {
    332   // FIXME: Error if there is no matching cfi_remember_state.
    333   MCSymbol *Label = EmitCFICommon();
    334   MCCFIInstruction Instruction = MCCFIInstruction::createRestoreState(Label);
    335   MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
    336   CurFrame->Instructions.push_back(Instruction);
    337 }
    338 
    339 void MCStreamer::EmitCFISameValue(int64_t Register) {
    340   MCSymbol *Label = EmitCFICommon();
    341   MCCFIInstruction Instruction =
    342     MCCFIInstruction::createSameValue(Label, Register);
    343   MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
    344   CurFrame->Instructions.push_back(Instruction);
    345 }
    346 
    347 void MCStreamer::EmitCFIRestore(int64_t Register) {
    348   MCSymbol *Label = EmitCFICommon();
    349   MCCFIInstruction Instruction =
    350     MCCFIInstruction::createRestore(Label, Register);
    351   MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
    352   CurFrame->Instructions.push_back(Instruction);
    353 }
    354 
    355 void MCStreamer::EmitCFIEscape(StringRef Values) {
    356   MCSymbol *Label = EmitCFICommon();
    357   MCCFIInstruction Instruction = MCCFIInstruction::createEscape(Label, Values);
    358   MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
    359   CurFrame->Instructions.push_back(Instruction);
    360 }
    361 
    362 void MCStreamer::EmitCFISignalFrame() {
    363   EnsureValidDwarfFrame();
    364   MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
    365   CurFrame->IsSignalFrame = true;
    366 }
    367 
    368 void MCStreamer::EmitCFIUndefined(int64_t Register) {
    369   MCSymbol *Label = EmitCFICommon();
    370   MCCFIInstruction Instruction =
    371     MCCFIInstruction::createUndefined(Label, Register);
    372   MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
    373   CurFrame->Instructions.push_back(Instruction);
    374 }
    375 
    376 void MCStreamer::EmitCFIRegister(int64_t Register1, int64_t Register2) {
    377   MCSymbol *Label = EmitCFICommon();
    378   MCCFIInstruction Instruction =
    379     MCCFIInstruction::createRegister(Label, Register1, Register2);
    380   MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
    381   CurFrame->Instructions.push_back(Instruction);
    382 }
    383 
    384 void MCStreamer::EmitCFIWindowSave() {
    385   MCSymbol *Label = EmitCFICommon();
    386   MCCFIInstruction Instruction =
    387     MCCFIInstruction::createWindowSave(Label);
    388   MCDwarfFrameInfo *CurFrame = getCurrentDwarfFrameInfo();
    389   CurFrame->Instructions.push_back(Instruction);
    390 }
    391 
    392 void MCStreamer::EnsureValidWinFrameInfo() {
    393   if (!CurrentWinFrameInfo || CurrentWinFrameInfo->End)
    394     report_fatal_error("No open Win64 EH frame function!");
    395 }
    396 
    397 void MCStreamer::EmitWinCFIStartProc(const MCSymbol *Symbol) {
    398   if (CurrentWinFrameInfo && !CurrentWinFrameInfo->End)
    399     report_fatal_error("Starting a function before ending the previous one!");
    400 
    401   MCSymbol *StartProc = getContext().CreateTempSymbol();
    402   EmitLabel(StartProc);
    403 
    404   WinFrameInfos.push_back(new WinEH::FrameInfo(Symbol, StartProc));
    405   CurrentWinFrameInfo = WinFrameInfos.back();
    406 }
    407 
    408 void MCStreamer::EmitWinCFIEndProc() {
    409   EnsureValidWinFrameInfo();
    410   if (CurrentWinFrameInfo->ChainedParent)
    411     report_fatal_error("Not all chained regions terminated!");
    412 
    413   MCSymbol *Label = getContext().CreateTempSymbol();
    414   EmitLabel(Label);
    415   CurrentWinFrameInfo->End = Label;
    416 }
    417 
    418 void MCStreamer::EmitWinCFIStartChained() {
    419   EnsureValidWinFrameInfo();
    420 
    421   MCSymbol *StartProc = getContext().CreateTempSymbol();
    422   EmitLabel(StartProc);
    423 
    424   WinFrameInfos.push_back(new WinEH::FrameInfo(CurrentWinFrameInfo->Function,
    425                                                StartProc, CurrentWinFrameInfo));
    426   CurrentWinFrameInfo = WinFrameInfos.back();
    427 }
    428 
    429 void MCStreamer::EmitWinCFIEndChained() {
    430   EnsureValidWinFrameInfo();
    431   if (!CurrentWinFrameInfo->ChainedParent)
    432     report_fatal_error("End of a chained region outside a chained region!");
    433 
    434   MCSymbol *Label = getContext().CreateTempSymbol();
    435   EmitLabel(Label);
    436 
    437   CurrentWinFrameInfo->End = Label;
    438   CurrentWinFrameInfo =
    439       const_cast<WinEH::FrameInfo *>(CurrentWinFrameInfo->ChainedParent);
    440 }
    441 
    442 void MCStreamer::EmitWinEHHandler(const MCSymbol *Sym, bool Unwind,
    443                                   bool Except) {
    444   EnsureValidWinFrameInfo();
    445   if (CurrentWinFrameInfo->ChainedParent)
    446     report_fatal_error("Chained unwind areas can't have handlers!");
    447   CurrentWinFrameInfo->ExceptionHandler = Sym;
    448   if (!Except && !Unwind)
    449     report_fatal_error("Don't know what kind of handler this is!");
    450   if (Unwind)
    451     CurrentWinFrameInfo->HandlesUnwind = true;
    452   if (Except)
    453     CurrentWinFrameInfo->HandlesExceptions = true;
    454 }
    455 
    456 void MCStreamer::EmitWinEHHandlerData() {
    457   EnsureValidWinFrameInfo();
    458   if (CurrentWinFrameInfo->ChainedParent)
    459     report_fatal_error("Chained unwind areas can't have handlers!");
    460 }
    461 
    462 void MCStreamer::EmitWinCFIPushReg(unsigned Register) {
    463   EnsureValidWinFrameInfo();
    464 
    465   MCSymbol *Label = getContext().CreateTempSymbol();
    466   EmitLabel(Label);
    467 
    468   WinEH::Instruction Inst = Win64EH::Instruction::PushNonVol(Label, Register);
    469   CurrentWinFrameInfo->Instructions.push_back(Inst);
    470 }
    471 
    472 void MCStreamer::EmitWinCFISetFrame(unsigned Register, unsigned Offset) {
    473   EnsureValidWinFrameInfo();
    474   if (CurrentWinFrameInfo->LastFrameInst >= 0)
    475     report_fatal_error("Frame register and offset already specified!");
    476   if (Offset & 0x0F)
    477     report_fatal_error("Misaligned frame pointer offset!");
    478   if (Offset > 240)
    479     report_fatal_error("Frame offset must be less than or equal to 240!");
    480 
    481   MCSymbol *Label = getContext().CreateTempSymbol();
    482   EmitLabel(Label);
    483 
    484   WinEH::Instruction Inst =
    485       Win64EH::Instruction::SetFPReg(Label, Register, Offset);
    486   CurrentWinFrameInfo->LastFrameInst = CurrentWinFrameInfo->Instructions.size();
    487   CurrentWinFrameInfo->Instructions.push_back(Inst);
    488 }
    489 
    490 void MCStreamer::EmitWinCFIAllocStack(unsigned Size) {
    491   EnsureValidWinFrameInfo();
    492   if (Size == 0)
    493     report_fatal_error("Allocation size must be non-zero!");
    494   if (Size & 7)
    495     report_fatal_error("Misaligned stack allocation!");
    496 
    497   MCSymbol *Label = getContext().CreateTempSymbol();
    498   EmitLabel(Label);
    499 
    500   WinEH::Instruction Inst = Win64EH::Instruction::Alloc(Label, Size);
    501   CurrentWinFrameInfo->Instructions.push_back(Inst);
    502 }
    503 
    504 void MCStreamer::EmitWinCFISaveReg(unsigned Register, unsigned Offset) {
    505   EnsureValidWinFrameInfo();
    506   if (Offset & 7)
    507     report_fatal_error("Misaligned saved register offset!");
    508 
    509   MCSymbol *Label = getContext().CreateTempSymbol();
    510   EmitLabel(Label);
    511 
    512   WinEH::Instruction Inst =
    513       Win64EH::Instruction::SaveNonVol(Label, Register, Offset);
    514   CurrentWinFrameInfo->Instructions.push_back(Inst);
    515 }
    516 
    517 void MCStreamer::EmitWinCFISaveXMM(unsigned Register, unsigned Offset) {
    518   EnsureValidWinFrameInfo();
    519   if (Offset & 0x0F)
    520     report_fatal_error("Misaligned saved vector register offset!");
    521 
    522   MCSymbol *Label = getContext().CreateTempSymbol();
    523   EmitLabel(Label);
    524 
    525   WinEH::Instruction Inst =
    526       Win64EH::Instruction::SaveXMM(Label, Register, Offset);
    527   CurrentWinFrameInfo->Instructions.push_back(Inst);
    528 }
    529 
    530 void MCStreamer::EmitWinCFIPushFrame(bool Code) {
    531   EnsureValidWinFrameInfo();
    532   if (CurrentWinFrameInfo->Instructions.size() > 0)
    533     report_fatal_error("If present, PushMachFrame must be the first UOP");
    534 
    535   MCSymbol *Label = getContext().CreateTempSymbol();
    536   EmitLabel(Label);
    537 
    538   WinEH::Instruction Inst = Win64EH::Instruction::PushMachFrame(Label, Code);
    539   CurrentWinFrameInfo->Instructions.push_back(Inst);
    540 }
    541 
    542 void MCStreamer::EmitWinCFIEndProlog() {
    543   EnsureValidWinFrameInfo();
    544 
    545   MCSymbol *Label = getContext().CreateTempSymbol();
    546   EmitLabel(Label);
    547 
    548   CurrentWinFrameInfo->PrologEnd = Label;
    549 }
    550 
    551 void MCStreamer::EmitCOFFSectionIndex(MCSymbol const *Symbol) {
    552 }
    553 
    554 void MCStreamer::EmitCOFFSecRel32(MCSymbol const *Symbol) {
    555 }
    556 
    557 /// EmitRawText - If this file is backed by an assembly streamer, this dumps
    558 /// the specified string in the output .s file.  This capability is
    559 /// indicated by the hasRawTextSupport() predicate.
    560 void MCStreamer::EmitRawTextImpl(StringRef String) {
    561   errs() << "EmitRawText called on an MCStreamer that doesn't support it, "
    562   " something must not be fully mc'ized\n";
    563   abort();
    564 }
    565 
    566 void MCStreamer::EmitRawText(const Twine &T) {
    567   SmallString<128> Str;
    568   EmitRawTextImpl(T.toStringRef(Str));
    569 }
    570 
    571 void MCStreamer::EmitWindowsUnwindTables() {
    572 }
    573 
    574 void MCStreamer::Finish() {
    575   if (!DwarfFrameInfos.empty() && !DwarfFrameInfos.back().End)
    576     report_fatal_error("Unfinished frame!");
    577 
    578   MCTargetStreamer *TS = getTargetStreamer();
    579   if (TS)
    580     TS->finish();
    581 
    582   FinishImpl();
    583 }
    584 
    585 void MCStreamer::EmitAssignment(MCSymbol *Symbol, const MCExpr *Value) {
    586   visitUsedExpr(*Value);
    587   Symbol->setVariableValue(Value);
    588 
    589   MCTargetStreamer *TS = getTargetStreamer();
    590   if (TS)
    591     TS->emitAssignment(Symbol, Value);
    592 }
    593 
    594 void MCStreamer::visitUsedSymbol(const MCSymbol &Sym) {
    595 }
    596 
    597 void MCStreamer::visitUsedExpr(const MCExpr &Expr) {
    598   switch (Expr.getKind()) {
    599   case MCExpr::Target:
    600     cast<MCTargetExpr>(Expr).visitUsedExpr(*this);
    601     break;
    602 
    603   case MCExpr::Constant:
    604     break;
    605 
    606   case MCExpr::Binary: {
    607     const MCBinaryExpr &BE = cast<MCBinaryExpr>(Expr);
    608     visitUsedExpr(*BE.getLHS());
    609     visitUsedExpr(*BE.getRHS());
    610     break;
    611   }
    612 
    613   case MCExpr::SymbolRef:
    614     visitUsedSymbol(cast<MCSymbolRefExpr>(Expr).getSymbol());
    615     break;
    616 
    617   case MCExpr::Unary:
    618     visitUsedExpr(*cast<MCUnaryExpr>(Expr).getSubExpr());
    619     break;
    620   }
    621 }
    622 
    623 void MCStreamer::EmitInstruction(const MCInst &Inst,
    624                                  const MCSubtargetInfo &STI) {
    625   // Scan for values.
    626   for (unsigned i = Inst.getNumOperands(); i--;)
    627     if (Inst.getOperand(i).isExpr())
    628       visitUsedExpr(*Inst.getOperand(i).getExpr());
    629 }
    630 
    631 void MCStreamer::EmitAssemblerFlag(MCAssemblerFlag Flag) {}
    632 void MCStreamer::EmitThumbFunc(MCSymbol *Func) {}
    633 void MCStreamer::EmitSymbolDesc(MCSymbol *Symbol, unsigned DescValue) {}
    634 void MCStreamer::BeginCOFFSymbolDef(const MCSymbol *Symbol) {}
    635 void MCStreamer::EndCOFFSymbolDef() {}
    636 void MCStreamer::EmitFileDirective(StringRef Filename) {}
    637 void MCStreamer::EmitCOFFSymbolStorageClass(int StorageClass) {}
    638 void MCStreamer::EmitCOFFSymbolType(int Type) {}
    639 void MCStreamer::EmitELFSize(MCSymbol *Symbol, const MCExpr *Value) {}
    640 void MCStreamer::EmitLocalCommonSymbol(MCSymbol *Symbol, uint64_t Size,
    641                                        unsigned ByteAlignment) {}
    642 void MCStreamer::EmitTBSSSymbol(const MCSection *Section, MCSymbol *Symbol,
    643                                 uint64_t Size, unsigned ByteAlignment) {}
    644 void MCStreamer::ChangeSection(const MCSection *, const MCExpr *) {}
    645 void MCStreamer::EmitWeakReference(MCSymbol *Alias, const MCSymbol *Symbol) {}
    646 void MCStreamer::EmitBytes(StringRef Data) {}
    647 void MCStreamer::EmitValueImpl(const MCExpr *Value, unsigned Size,
    648                                const SMLoc &Loc) {
    649   visitUsedExpr(*Value);
    650 }
    651 void MCStreamer::EmitULEB128Value(const MCExpr *Value) {}
    652 void MCStreamer::EmitSLEB128Value(const MCExpr *Value) {}
    653 void MCStreamer::EmitValueToAlignment(unsigned ByteAlignment, int64_t Value,
    654                                       unsigned ValueSize,
    655                                       unsigned MaxBytesToEmit) {}
    656 void MCStreamer::EmitCodeAlignment(unsigned ByteAlignment,
    657                                    unsigned MaxBytesToEmit) {}
    658 bool MCStreamer::EmitValueToOffset(const MCExpr *Offset, unsigned char Value) {
    659   return false;
    660 }
    661 void MCStreamer::EmitBundleAlignMode(unsigned AlignPow2) {}
    662 void MCStreamer::EmitBundleLock(bool AlignToEnd) {}
    663 void MCStreamer::FinishImpl() {}
    664 void MCStreamer::EmitBundleUnlock() {}
    665 
    666 void MCStreamer::SwitchSection(const MCSection *Section,
    667                                const MCExpr *Subsection) {
    668   assert(Section && "Cannot switch to a null section!");
    669   MCSectionSubPair curSection = SectionStack.back().first;
    670   SectionStack.back().second = curSection;
    671   if (MCSectionSubPair(Section, Subsection) != curSection) {
    672     SectionStack.back().first = MCSectionSubPair(Section, Subsection);
    673     assert(!Section->hasEnded() && "Section already ended");
    674     ChangeSection(Section, Subsection);
    675     MCSymbol *Sym = Section->getBeginSymbol();
    676     if (Sym && !Sym->isInSection())
    677       EmitLabel(Sym);
    678   }
    679 }
    680 
    681 MCSymbol *MCStreamer::endSection(const MCSection *Section) {
    682   // TODO: keep track of the last subsection so that this symbol appears in the
    683   // correct place.
    684   MCSymbol *Sym = Section->getEndSymbol(Context);
    685   if (Sym->isInSection())
    686     return Sym;
    687 
    688   SwitchSection(Section);
    689   EmitLabel(Sym);
    690   return Sym;
    691 }
    692