1//===- lib/MC/MCPureStreamer.cpp - MC "Pure" Object 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/MC/MCAssembler.h"
12#include "llvm/MC/MCCodeEmitter.h"
13#include "llvm/MC/MCContext.h"
14#include "llvm/MC/MCExpr.h"
15#include "llvm/MC/MCObjectStreamer.h"
16// FIXME: Remove this.
17#include "llvm/MC/MCSectionMachO.h"
18#include "llvm/MC/MCSymbol.h"
19#include "llvm/Support/ErrorHandling.h"
20
21using namespace llvm;
22
23namespace {
24
25class MCPureStreamer : public MCObjectStreamer {
26private:
27  virtual void EmitInstToFragment(const MCInst &Inst);
28  virtual void EmitInstToData(const MCInst &Inst);
29
30public:
31  MCPureStreamer(MCContext &Context, MCAsmBackend &TAB,
32                 raw_ostream &OS, MCCodeEmitter *Emitter)
33    : MCObjectStreamer(Context, TAB, OS, Emitter) {}
34
35  /// @name MCStreamer Interface
36  /// @{
37
38  virtual void InitSections();
39  virtual void EmitLabel(MCSymbol *Symbol);
40  virtual void EmitAssignment(MCSymbol *Symbol, const MCExpr *Value);
41  virtual void EmitZerofill(const MCSection *Section, MCSymbol *Symbol = 0,
42                            unsigned Size = 0, unsigned ByteAlignment = 0);
43  virtual void EmitBytes(StringRef Data, unsigned AddrSpace);
44  virtual void EmitValueToAlignment(unsigned ByteAlignment, int64_t Value = 0,
45                                    unsigned ValueSize = 1,
46                                    unsigned MaxBytesToEmit = 0);
47  virtual void EmitCodeAlignment(unsigned ByteAlignment,
48                                 unsigned MaxBytesToEmit = 0);
49  virtual bool EmitValueToOffset(const MCExpr *Offset,
50                                 unsigned char Value = 0);
51  virtual void FinishImpl();
52
53
54  virtual void EmitSymbolAttribute(MCSymbol *Symbol, MCSymbolAttr Attribute) {
55    report_fatal_error("unsupported directive in pure streamer");
56  }
57  virtual void EmitAssemblerFlag(MCAssemblerFlag Flag) {
58    report_fatal_error("unsupported directive in pure streamer");
59  }
60  virtual void EmitTBSSSymbol(const MCSection *Section, MCSymbol *Symbol,
61                              uint64_t Size, unsigned ByteAlignment = 0) {
62    report_fatal_error("unsupported directive in pure streamer");
63  }
64  virtual void EmitSymbolDesc(MCSymbol *Symbol, unsigned DescValue) {
65    report_fatal_error("unsupported directive in pure streamer");
66  }
67  virtual void EmitCommonSymbol(MCSymbol *Symbol, uint64_t Size,
68                                unsigned ByteAlignment) {
69    report_fatal_error("unsupported directive in pure streamer");
70  }
71  virtual void EmitThumbFunc(MCSymbol *Func) {
72    report_fatal_error("unsupported directive in pure streamer");
73  }
74  virtual void BeginCOFFSymbolDef(const MCSymbol *Symbol) {
75    report_fatal_error("unsupported directive in pure streamer");
76  }
77  virtual void EmitCOFFSymbolStorageClass(int StorageClass) {
78    report_fatal_error("unsupported directive in pure streamer");
79  }
80  virtual void EmitCOFFSymbolType(int Type) {
81    report_fatal_error("unsupported directive in pure streamer");
82  }
83  virtual void EndCOFFSymbolDef() {
84    report_fatal_error("unsupported directive in pure streamer");
85  }
86  virtual void EmitELFSize(MCSymbol *Symbol, const MCExpr *Value) {
87    report_fatal_error("unsupported directive in pure streamer");
88  }
89  virtual void EmitLocalCommonSymbol(MCSymbol *Symbol, uint64_t Size,
90                                     unsigned ByteAlignment) {
91    report_fatal_error("unsupported directive in pure streamer");
92  }
93  virtual void EmitFileDirective(StringRef Filename) {
94    report_fatal_error("unsupported directive in pure streamer");
95  }
96  virtual bool EmitDwarfFileDirective(unsigned FileNo, StringRef Directory,
97                                      StringRef Filename) {
98    report_fatal_error("unsupported directive in pure streamer");
99  }
100
101  /// @}
102};
103
104} // end anonymous namespace.
105
106void MCPureStreamer::InitSections() {
107  // FIMXE: To what!?
108  SwitchSection(getContext().getMachOSection("__TEXT", "__text",
109                                    MCSectionMachO::S_ATTR_PURE_INSTRUCTIONS,
110                                    0, SectionKind::getText()));
111
112}
113
114void MCPureStreamer::EmitLabel(MCSymbol *Symbol) {
115  assert(Symbol->isUndefined() && "Cannot define a symbol twice!");
116  assert(!Symbol->isVariable() && "Cannot emit a variable symbol!");
117  assert(getCurrentSection() && "Cannot emit before setting section!");
118
119  Symbol->setSection(*getCurrentSection());
120
121  MCSymbolData &SD = getAssembler().getOrCreateSymbolData(*Symbol);
122
123  // We have to create a new fragment if this is an atom defining symbol,
124  // fragments cannot span atoms.
125  if (getAssembler().isSymbolLinkerVisible(SD.getSymbol()))
126    new MCDataFragment(getCurrentSectionData());
127
128  // FIXME: This is wasteful, we don't necessarily need to create a data
129  // fragment. Instead, we should mark the symbol as pointing into the data
130  // fragment if it exists, otherwise we should just queue the label and set its
131  // fragment pointer when we emit the next fragment.
132  MCDataFragment *F = getOrCreateDataFragment();
133  assert(!SD.getFragment() && "Unexpected fragment on symbol data!");
134  SD.setFragment(F);
135  SD.setOffset(F->getContents().size());
136}
137
138void MCPureStreamer::EmitAssignment(MCSymbol *Symbol, const MCExpr *Value) {
139  // TODO: This is exactly the same as WinCOFFStreamer. Consider merging into
140  // MCObjectStreamer.
141  // FIXME: Lift context changes into super class.
142  getAssembler().getOrCreateSymbolData(*Symbol);
143  Symbol->setVariableValue(AddValueSymbols(Value));
144}
145
146void MCPureStreamer::EmitZerofill(const MCSection *Section, MCSymbol *Symbol,
147                                  unsigned Size, unsigned ByteAlignment) {
148  report_fatal_error("not yet implemented in pure streamer");
149}
150
151void MCPureStreamer::EmitBytes(StringRef Data, unsigned AddrSpace) {
152  // TODO: This is exactly the same as WinCOFFStreamer. Consider merging into
153  // MCObjectStreamer.
154  getOrCreateDataFragment()->getContents().append(Data.begin(), Data.end());
155}
156
157void MCPureStreamer::EmitValueToAlignment(unsigned ByteAlignment,
158                                          int64_t Value, unsigned ValueSize,
159                                          unsigned MaxBytesToEmit) {
160  // TODO: This is exactly the same as WinCOFFStreamer. Consider merging into
161  // MCObjectStreamer.
162  if (MaxBytesToEmit == 0)
163    MaxBytesToEmit = ByteAlignment;
164  new MCAlignFragment(ByteAlignment, Value, ValueSize, MaxBytesToEmit,
165                      getCurrentSectionData());
166
167  // Update the maximum alignment on the current section if necessary.
168  if (ByteAlignment > getCurrentSectionData()->getAlignment())
169    getCurrentSectionData()->setAlignment(ByteAlignment);
170}
171
172void MCPureStreamer::EmitCodeAlignment(unsigned ByteAlignment,
173                                       unsigned MaxBytesToEmit) {
174  // TODO: This is exactly the same as WinCOFFStreamer. Consider merging into
175  // MCObjectStreamer.
176  if (MaxBytesToEmit == 0)
177    MaxBytesToEmit = ByteAlignment;
178  MCAlignFragment *F = new MCAlignFragment(ByteAlignment, 0, 1, MaxBytesToEmit,
179                                           getCurrentSectionData());
180  F->setEmitNops(true);
181
182  // Update the maximum alignment on the current section if necessary.
183  if (ByteAlignment > getCurrentSectionData()->getAlignment())
184    getCurrentSectionData()->setAlignment(ByteAlignment);
185}
186
187bool MCPureStreamer::EmitValueToOffset(const MCExpr *Offset,
188                                       unsigned char Value) {
189  new MCOrgFragment(*Offset, Value, getCurrentSectionData());
190  return false;
191}
192
193void MCPureStreamer::EmitInstToFragment(const MCInst &Inst) {
194  MCInstFragment *IF = new MCInstFragment(Inst, getCurrentSectionData());
195
196  // Add the fixups and data.
197  //
198  // FIXME: Revisit this design decision when relaxation is done, we may be
199  // able to get away with not storing any extra data in the MCInst.
200  SmallVector<MCFixup, 4> Fixups;
201  SmallString<256> Code;
202  raw_svector_ostream VecOS(Code);
203  getAssembler().getEmitter().EncodeInstruction(Inst, VecOS, Fixups);
204  VecOS.flush();
205
206  IF->getCode() = Code;
207  IF->getFixups() = Fixups;
208}
209
210void MCPureStreamer::EmitInstToData(const MCInst &Inst) {
211  MCDataFragment *DF = getOrCreateDataFragment();
212
213  SmallVector<MCFixup, 4> Fixups;
214  SmallString<256> Code;
215  raw_svector_ostream VecOS(Code);
216  getAssembler().getEmitter().EncodeInstruction(Inst, VecOS, Fixups);
217  VecOS.flush();
218
219  // Add the fixups and data.
220  for (unsigned i = 0, e = Fixups.size(); i != e; ++i) {
221    Fixups[i].setOffset(Fixups[i].getOffset() + DF->getContents().size());
222    DF->addFixup(Fixups[i]);
223  }
224  DF->getContents().append(Code.begin(), Code.end());
225}
226
227void MCPureStreamer::FinishImpl() {
228  // FIXME: Handle DWARF tables?
229
230  this->MCObjectStreamer::FinishImpl();
231}
232
233MCStreamer *llvm::createPureStreamer(MCContext &Context, MCAsmBackend &MAB,
234                                     raw_ostream &OS, MCCodeEmitter *CE) {
235  return new MCPureStreamer(Context, MAB, OS, CE);
236}
237