1 //===- lib/MC/MCWasmStreamer.cpp - Wasm 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 // This file assembles .s files and emits Wasm .o object files.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "llvm/MC/MCWasmStreamer.h"
15 #include "llvm/ADT/STLExtras.h"
16 #include "llvm/ADT/SmallPtrSet.h"
17 #include "llvm/MC/MCAsmBackend.h"
18 #include "llvm/MC/MCAsmInfo.h"
19 #include "llvm/MC/MCAsmLayout.h"
20 #include "llvm/MC/MCAssembler.h"
21 #include "llvm/MC/MCCodeEmitter.h"
22 #include "llvm/MC/MCContext.h"
23 #include "llvm/MC/MCExpr.h"
24 #include "llvm/MC/MCInst.h"
25 #include "llvm/MC/MCObjectFileInfo.h"
26 #include "llvm/MC/MCObjectStreamer.h"
27 #include "llvm/MC/MCObjectWriter.h"
28 #include "llvm/MC/MCSection.h"
29 #include "llvm/MC/MCSectionWasm.h"
30 #include "llvm/MC/MCSymbol.h"
31 #include "llvm/MC/MCSymbolWasm.h"
32 #include "llvm/MC/MCValue.h"
33 #include "llvm/Support/Casting.h"
34 #include "llvm/Support/Debug.h"
35 #include "llvm/Support/ErrorHandling.h"
36 #include "llvm/Support/TargetRegistry.h"
37 #include "llvm/Support/raw_ostream.h"
38 
39 using namespace llvm;
40 
41 MCWasmStreamer::~MCWasmStreamer() {}
42 
43 void MCWasmStreamer::mergeFragment(MCDataFragment *DF, MCDataFragment *EF) {
44   flushPendingLabels(DF, DF->getContents().size());
45 
46   for (unsigned i = 0, e = EF->getFixups().size(); i != e; ++i) {
47     EF->getFixups()[i].setOffset(EF->getFixups()[i].getOffset() +
48                                  DF->getContents().size());
49     DF->getFixups().push_back(EF->getFixups()[i]);
50   }
51   DF->setHasInstructions(true);
52   DF->getContents().append(EF->getContents().begin(), EF->getContents().end());
53 }
54 
55 void MCWasmStreamer::EmitAssemblerFlag(MCAssemblerFlag Flag) {
56   // Let the target do whatever target specific stuff it needs to do.
57   getAssembler().getBackend().handleAssemblerFlag(Flag);
58 
59   // Do any generic stuff we need to do.
60   llvm_unreachable("invalid assembler flag!");
61 }
62 
63 void MCWasmStreamer::ChangeSection(MCSection *Section,
64                                    const MCExpr *Subsection) {
65   MCAssembler &Asm = getAssembler();
66   auto *SectionWasm = static_cast<const MCSectionWasm *>(Section);
67   const MCSymbol *Grp = SectionWasm->getGroup();
68   if (Grp)
69     Asm.registerSymbol(*Grp);
70 
71   this->MCObjectStreamer::ChangeSection(Section, Subsection);
72 }
73 
74 void MCWasmStreamer::EmitWeakReference(MCSymbol *Alias,
75                                        const MCSymbol *Symbol) {
76   getAssembler().registerSymbol(*Symbol);
77   const MCExpr *Value = MCSymbolRefExpr::create(
78       Symbol, MCSymbolRefExpr::VK_WEAKREF, getContext());
79   Alias->setVariableValue(Value);
80 }
81 
82 bool MCWasmStreamer::EmitSymbolAttribute(MCSymbol *S, MCSymbolAttr Attribute) {
83   assert(Attribute != MCSA_IndirectSymbol && "indirect symbols not supported");
84 
85   auto *Symbol = cast<MCSymbolWasm>(S);
86 
87   // Adding a symbol attribute always introduces the symbol, note that an
88   // important side effect of calling registerSymbol here is to register
89   // the symbol with the assembler.
90   getAssembler().registerSymbol(*Symbol);
91 
92   switch (Attribute) {
93   case MCSA_LazyReference:
94   case MCSA_Reference:
95   case MCSA_SymbolResolver:
96   case MCSA_PrivateExtern:
97   case MCSA_WeakDefinition:
98   case MCSA_WeakDefAutoPrivate:
99   case MCSA_Invalid:
100   case MCSA_IndirectSymbol:
101     return false;
102   case MCSA_Global:
103     Symbol->setExternal(true);
104     break;
105   case MCSA_ELF_TypeFunction:
106     Symbol->setIsFunction(true);
107     break;
108   case MCSA_ELF_TypeObject:
109     Symbol->setIsFunction(false);
110     break;
111   default:
112     // unrecognized directive
113     return false;
114   }
115 
116   return true;
117 }
118 
119 void MCWasmStreamer::EmitCommonSymbol(MCSymbol *S, uint64_t Size,
120                                       unsigned ByteAlignment) {
121   llvm_unreachable("Common symbols are not yet implemented for Wasm");
122 }
123 
124 void MCWasmStreamer::emitELFSize(MCSymbol *Symbol, const MCExpr *Value) {
125   cast<MCSymbolWasm>(Symbol)->setSize(Value);
126 }
127 
128 void MCWasmStreamer::EmitLocalCommonSymbol(MCSymbol *S, uint64_t Size,
129                                            unsigned ByteAlignment) {
130   llvm_unreachable("Local common symbols are not yet implemented for Wasm");
131 }
132 
133 void MCWasmStreamer::EmitValueImpl(const MCExpr *Value, unsigned Size,
134                                    SMLoc Loc) {
135   MCObjectStreamer::EmitValueImpl(Value, Size, Loc);
136 }
137 
138 void MCWasmStreamer::EmitValueToAlignment(unsigned ByteAlignment, int64_t Value,
139                                           unsigned ValueSize,
140                                           unsigned MaxBytesToEmit) {
141   MCObjectStreamer::EmitValueToAlignment(ByteAlignment, Value, ValueSize,
142                                          MaxBytesToEmit);
143 }
144 
145 // Add a symbol for the file name of this module. They start after the
146 // null symbol and don't count as normal symbol, i.e. a non-STT_FILE symbol
147 // with the same name may appear.
148 void MCWasmStreamer::EmitFileDirective(StringRef Filename) {
149   getAssembler().addFileName(Filename);
150 }
151 
152 void MCWasmStreamer::EmitIdent(StringRef IdentString) {
153   MCSection *Comment = getAssembler().getContext().getWasmSection(
154       ".comment", 0, 0);
155   PushSection();
156   SwitchSection(Comment);
157   if (!SeenIdent) {
158     EmitIntValue(0, 1);
159     SeenIdent = true;
160   }
161   EmitBytes(IdentString);
162   EmitIntValue(0, 1);
163   PopSection();
164 }
165 
166 void MCWasmStreamer::EmitInstToFragment(const MCInst &Inst,
167                                         const MCSubtargetInfo &STI) {
168   this->MCObjectStreamer::EmitInstToFragment(Inst, STI);
169 }
170 
171 void MCWasmStreamer::EmitInstToData(const MCInst &Inst,
172                                     const MCSubtargetInfo &STI) {
173   MCAssembler &Assembler = getAssembler();
174   SmallVector<MCFixup, 4> Fixups;
175   SmallString<256> Code;
176   raw_svector_ostream VecOS(Code);
177   Assembler.getEmitter().encodeInstruction(Inst, VecOS, Fixups, STI);
178 
179   // Append the encoded instruction to the current data fragment (or create a
180   // new such fragment if the current fragment is not a data fragment).
181   MCDataFragment *DF = getOrCreateDataFragment();
182 
183   // Add the fixups and data.
184   for (unsigned i = 0, e = Fixups.size(); i != e; ++i) {
185     Fixups[i].setOffset(Fixups[i].getOffset() + DF->getContents().size());
186     DF->getFixups().push_back(Fixups[i]);
187   }
188   DF->setHasInstructions(true);
189   DF->getContents().append(Code.begin(), Code.end());
190 }
191 
192 void MCWasmStreamer::FinishImpl() {
193   EmitFrames(nullptr);
194 
195   this->MCObjectStreamer::FinishImpl();
196 }
197 
198 MCStreamer *llvm::createWasmStreamer(MCContext &Context, MCAsmBackend &MAB,
199                                      raw_pwrite_stream &OS, MCCodeEmitter *CE,
200                                      bool RelaxAll) {
201   MCWasmStreamer *S = new MCWasmStreamer(Context, MAB, OS, CE);
202   if (RelaxAll)
203     S->getAssembler().setRelaxAll(true);
204   return S;
205 }
206 
207 void MCWasmStreamer::EmitThumbFunc(MCSymbol *Func) {
208   llvm_unreachable("Generic Wasm doesn't support this directive");
209 }
210 
211 void MCWasmStreamer::EmitSymbolDesc(MCSymbol *Symbol, unsigned DescValue) {
212   llvm_unreachable("Wasm doesn't support this directive");
213 }
214 
215 void MCWasmStreamer::EmitZerofill(MCSection *Section, MCSymbol *Symbol,
216                                   uint64_t Size, unsigned ByteAlignment) {
217   llvm_unreachable("Wasm doesn't support this directive");
218 }
219 
220 void MCWasmStreamer::EmitTBSSSymbol(MCSection *Section, MCSymbol *Symbol,
221                                     uint64_t Size, unsigned ByteAlignment) {
222   llvm_unreachable("Wasm doesn't support this directive");
223 }
224