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/MCContext.h"
  11 #include "llvm/MC/MCStreamer.h"
  12 #include "llvm/MC/MCExpr.h"
  13 #include "llvm/MC/MCObjectWriter.h"
  14 #include "llvm/Support/ErrorHandling.h"
  15 #include "llvm/Support/raw_ostream.h"
  16 #include "llvm/ADT/SmallString.h"
  17 #include "llvm/ADT/Twine.h"
  18 #include <cstdlib>
  19 using namespace llvm;
  20
  21 MCStreamer::MCStreamer(MCContext &Ctx) : Context(Ctx), CurSection(0),
  22                                          PrevSection(0) {
  23 }
  24
  25 MCStreamer::~MCStreamer() {
  26 }
  27
  28 raw_ostream &MCStreamer::GetCommentOS() {
  29   // By default, discard comments.
  30   return nulls();
  31 }
  32
  33
  34 /// EmitIntValue - Special case of EmitValue that avoids the client having to
  35 /// pass in a MCExpr for constant integers.
  36 void MCStreamer::EmitIntValue(uint64_t Value, unsigned Size,
  37                               unsigned AddrSpace) {
  38   EmitValue(MCConstantExpr::Create(Value, getContext()), Size, AddrSpace);
  39 }
  40
  41 /// EmitULEB128Value - Special case of EmitULEB128Value that avoids the
  42 /// client having to pass in a MCExpr for constant integers.
  43 void MCStreamer::EmitULEB128IntValue(uint64_t Value, unsigned AddrSpace) {
  44   EmitULEB128Value(MCConstantExpr::Create(Value, getContext()), AddrSpace);
  45 }
  46
  47 /// EmitSLEB128Value - Special case of EmitSLEB128Value that avoids the
  48 /// client having to pass in a MCExpr for constant integers.
  49 void MCStreamer::EmitSLEB128IntValue(int64_t Value, unsigned AddrSpace) {
  50   EmitSLEB128Value(MCConstantExpr::Create(Value, getContext()), AddrSpace);
  51 }
  52
  53 void MCStreamer::EmitSymbolValue(const MCSymbol *Sym, unsigned Size,
  54                                  unsigned AddrSpace) {
  55   EmitValue(MCSymbolRefExpr::Create(Sym, getContext()), Size, AddrSpace);
  56 }
  57
  58 /// EmitFill - Emit NumBytes bytes worth of the value specified by
  59 /// FillValue.  This implements directives such as '.space'.
  60 void MCStreamer::EmitFill(uint64_t NumBytes, uint8_t FillValue,
  61                           unsigned AddrSpace) {
  62   const MCExpr *E = MCConstantExpr::Create(FillValue, getContext());
  63   for (uint64_t i = 0, e = NumBytes; i != e; ++i)
  64     EmitValue(E, 1, AddrSpace);
  65 }
  66
  67 bool MCStreamer::EmitDwarfFileDirective(unsigned FileNo,
  68                                         StringRef Filename) {
  69   return getContext().GetDwarfFile(Filename, FileNo) == 0;
  70 }
  71
  72 void MCStreamer::EmitDwarfLocDirective(unsigned FileNo, unsigned Line,
  73                                        unsigned Column, unsigned Flags,
  74                                        unsigned Isa,
  75                                        unsigned Discriminator) {
  76   getContext().setCurrentDwarfLoc(FileNo, Line, Column, Flags, Isa,
  77                                   Discriminator);
  78 }
  79
  80 bool MCStreamer::EmitCFIStartProc() {
  81   return false;
  82 }
  83
  84 bool MCStreamer::EmitCFIEndProc() {
  85   return false;
  86 }
  87
  88 bool MCStreamer::EmitCFIDefCfaOffset(int64_t Offset) {
  89   return false;
  90 }
  91
  92 bool MCStreamer::EmitCFIDefCfaRegister(int64_t Register) {
  93   return false;
  94 }
  95
  96 bool MCStreamer::EmitCFIOffset(int64_t Register, int64_t Offset) {
  97   return false;
  98 }
  99
 100 bool MCStreamer::EmitCFIPersonality(const MCSymbol *Sym) {
 101   return false;
 102 }
 103
 104 bool MCStreamer::EmitCFILsda(const MCSymbol *Sym) {
 105   return false;
 106 }
 107
 108 /// EmitRawText - If this file is backed by an assembly streamer, this dumps
 109 /// the specified string in the output .s file.  This capability is
 110 /// indicated by the hasRawTextSupport() predicate.
 111 void MCStreamer::EmitRawText(StringRef String) {
 112   errs() << "EmitRawText called on an MCStreamer that doesn't support it, "
 113   " something must not be fully mc'ized\n";
 114   abort();
 115 }
 116
 117 void MCStreamer::EmitRawText(const Twine &T) {
 118   SmallString<128> Str;
 119   T.toVector(Str);
 120   EmitRawText(Str.str());
 121 }