blob: 3ff66ed395b9453cc63e0ea44cdca5612dfaf3f8 [file] [log] [blame]
Eugene Zelenkoffec81c2015-11-04 22:32:32 +00001//===- lib/MC/MCAsmStreamer.cpp - Text Assembly Output ----------*- C++ -*-===//
Daniel Dunbar9faf2732009-06-24 01:03:06 +00002//
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
David Blaikie293a2a32014-04-24 14:33:36 +000010#include "llvm/ADT/STLExtras.h"
Chandler Carruthd9903882015-01-14 11:23:27 +000011#include "llvm/ADT/SmallString.h"
Chandler Carruthed0881b2012-12-03 16:50:05 +000012#include "llvm/ADT/StringExtras.h"
13#include "llvm/ADT/Twine.h"
14#include "llvm/MC/MCAsmBackend.h"
Daniel Dunbar73da11e2009-08-31 08:08:38 +000015#include "llvm/MC/MCAsmInfo.h"
Daniel Dunbar65105172009-08-27 00:51:57 +000016#include "llvm/MC/MCCodeEmitter.h"
Daniel Dunbar9faf2732009-06-24 01:03:06 +000017#include "llvm/MC/MCContext.h"
Daniel Dunbar73da11e2009-08-31 08:08:38 +000018#include "llvm/MC/MCExpr.h"
Daniel Dunbar0c9d9fd2010-12-16 03:20:06 +000019#include "llvm/MC/MCFixupKindInfo.h"
Daniel Dunbar23a72aa2009-07-01 06:35:03 +000020#include "llvm/MC/MCInst.h"
Chris Lattner11b2fc92009-09-14 03:02:37 +000021#include "llvm/MC/MCInstPrinter.h"
Evan Cheng2833ad12011-07-26 20:57:44 +000022#include "llvm/MC/MCObjectFileInfo.h"
Evan Chengd60fa58b2011-07-18 20:57:22 +000023#include "llvm/MC/MCRegisterInfo.h"
Evan Cheng76792992011-07-20 05:58:47 +000024#include "llvm/MC/MCSectionCOFF.h"
Chris Lattner6c203912009-08-10 18:15:01 +000025#include "llvm/MC/MCSectionMachO.h"
Mehdi Aminib550cb12016-04-18 09:17:29 +000026#include "llvm/MC/MCStreamer.h"
Rafael Espindolaa8695762015-06-02 00:25:12 +000027#include "llvm/MC/MCSymbolELF.h"
Torok Edwin56d06592009-07-11 20:10:48 +000028#include "llvm/Support/ErrorHandling.h"
Daniel Dunbar65105172009-08-27 00:51:57 +000029#include "llvm/Support/Format.h"
Chris Lattner38e92192010-01-22 07:29:22 +000030#include "llvm/Support/FormattedStream.h"
Michael Kuperstein259f1502015-10-07 07:01:31 +000031#include "llvm/Support/LEB128.h"
Chandler Carruthed0881b2012-12-03 16:50:05 +000032#include "llvm/Support/MathExtras.h"
Rafael Espindola3bc8e712013-06-11 22:21:28 +000033#include "llvm/Support/Path.h"
Petr Hosek67a94a72016-05-28 05:57:48 +000034#include "llvm/Support/SourceMgr.h"
Nick Lewycky0de20af2010-12-19 20:43:38 +000035#include <cctype>
Eugene Zelenkoffec81c2015-11-04 22:32:32 +000036
Daniel Dunbar9faf2732009-06-24 01:03:06 +000037using namespace llvm;
38
39namespace {
40
Rafael Espindola3e608b02015-04-09 13:04:20 +000041class MCAsmStreamer final : public MCStreamer {
Rafael Espindola5682ce22015-04-09 21:06:08 +000042 std::unique_ptr<formatted_raw_ostream> OSOwner;
Chris Lattner38e92192010-01-22 07:29:22 +000043 formatted_raw_ostream &OS;
Bill Wendlingbc07a892013-06-18 07:20:20 +000044 const MCAsmInfo *MAI;
Ahmed Charles56440fd2014-03-06 05:51:42 +000045 std::unique_ptr<MCInstPrinter> InstPrinter;
46 std::unique_ptr<MCCodeEmitter> Emitter;
47 std::unique_ptr<MCAsmBackend> AsmBackend;
Jim Grosbach3bde49a2010-09-22 18:16:55 +000048
Chris Lattner38e92192010-01-22 07:29:22 +000049 SmallString<128> CommentToEmit;
Chris Lattner8fa0e352010-01-22 19:17:48 +000050 raw_svector_ostream CommentStream;
Daniel Dunbare3ee3322010-02-03 18:18:30 +000051
Daniel Dunbare3ee3322010-02-03 18:18:30 +000052 unsigned IsVerboseAsm : 1;
53 unsigned ShowInst : 1;
Nick Lewycky40f8f2f2011-10-17 23:05:28 +000054 unsigned UseDwarfDirectory : 1;
Daniel Dunbare3ee3322010-02-03 18:18:30 +000055
Rafael Espindola08600bc2011-05-30 20:20:15 +000056 void EmitRegisterName(int64_t Register);
Oliver Stannardcf6bfb12014-11-03 12:19:03 +000057 void EmitCFIStartProcImpl(MCDwarfFrameInfo &Frame) override;
Craig Topper34a61bc2014-03-08 07:02:02 +000058 void EmitCFIEndProcImpl(MCDwarfFrameInfo &Frame) override;
Rafael Espindola08600bc2011-05-30 20:20:15 +000059
Chris Lattner962c5bd82009-08-17 04:17:34 +000060public:
Rafael Espindola5682ce22015-04-09 21:06:08 +000061 MCAsmStreamer(MCContext &Context, std::unique_ptr<formatted_raw_ostream> os,
Rafael Espindola883cf7e62014-05-12 13:07:11 +000062 bool isVerboseAsm, bool useDwarfDirectory,
Rafael Espindolab4eec1d2014-02-05 18:00:21 +000063 MCInstPrinter *printer, MCCodeEmitter *emitter,
64 MCAsmBackend *asmbackend, bool showInst)
Rafael Espindola5682ce22015-04-09 21:06:08 +000065 : MCStreamer(Context), OSOwner(std::move(os)), OS(*OSOwner),
66 MAI(Context.getAsmInfo()), InstPrinter(printer), Emitter(emitter),
67 AsmBackend(asmbackend), CommentStream(CommentToEmit),
68 IsVerboseAsm(isVerboseAsm), ShowInst(showInst),
69 UseDwarfDirectory(useDwarfDirectory) {
Rafael Espindola691a5ad2015-05-27 12:13:06 +000070 assert(InstPrinter);
71 if (IsVerboseAsm)
72 InstPrinter->setCommentStream(CommentStream);
Chris Lattner482bf692010-02-10 00:10:18 +000073 }
Daniel Dunbar9faf2732009-06-24 01:03:06 +000074
Chris Lattner38e92192010-01-22 07:29:22 +000075 inline void EmitEOL() {
Chris Lattner8fa0e352010-01-22 19:17:48 +000076 // If we don't have any comments, just emit a \n.
77 if (!IsVerboseAsm) {
Chris Lattner38e92192010-01-22 07:29:22 +000078 OS << '\n';
79 return;
80 }
81 EmitCommentsAndEOL();
82 }
Michael Kuperstein23d952b2015-07-22 10:49:44 +000083
Chandler Carruth6fb9c082015-07-22 11:22:29 +000084 void EmitSyntaxDirective() override;
Michael Kuperstein23d952b2015-07-22 10:49:44 +000085
Chris Lattner38e92192010-01-22 07:29:22 +000086 void EmitCommentsAndEOL();
Chris Lattnerb0d44c32010-02-02 23:37:42 +000087
88 /// isVerboseAsm - Return true if this streamer supports verbose assembly at
89 /// all.
Craig Topper34a61bc2014-03-08 07:02:02 +000090 bool isVerboseAsm() const override { return IsVerboseAsm; }
Jim Grosbach3bde49a2010-09-22 18:16:55 +000091
Chris Lattner8a87fb72010-04-03 21:35:55 +000092 /// hasRawTextSupport - We support EmitRawText.
Craig Topper34a61bc2014-03-08 07:02:02 +000093 bool hasRawTextSupport() const override { return true; }
Daniel Dunbar9a0a4612010-02-09 23:00:14 +000094
Chris Lattnere1d8a312010-01-22 18:21:35 +000095 /// AddComment - Add a comment that can be emitted to the generated .s
Chris Lattner38e92192010-01-22 07:29:22 +000096 /// file if applicable as a QoI issue to make the output of the compiler
97 /// more readable. This only affects the MCAsmStreamer, and only when
98 /// verbose assembly output is enabled.
Craig Topper34a61bc2014-03-08 07:02:02 +000099 void AddComment(const Twine &T) override;
Daniel Dunbar9a0a4612010-02-09 23:00:14 +0000100
101 /// AddEncodingComment - Add a comment showing the encoding of an instruction.
Craig Topper12f0ca42014-03-08 07:07:08 +0000102 void AddEncodingComment(const MCInst &Inst, const MCSubtargetInfo &);
Daniel Dunbar9a0a4612010-02-09 23:00:14 +0000103
Chris Lattner8fa0e352010-01-22 19:17:48 +0000104 /// GetCommentOS - Return a raw_ostream that comments can be written to.
105 /// Unlike AddComment, you are required to terminate comments with \n if you
106 /// use this method.
Craig Topper34a61bc2014-03-08 07:02:02 +0000107 raw_ostream &GetCommentOS() override {
Chris Lattner8fa0e352010-01-22 19:17:48 +0000108 if (!IsVerboseAsm)
109 return nulls(); // Discard comments unless in verbose asm mode.
110 return CommentStream;
111 }
Daniel Dunbar9a0a4612010-02-09 23:00:14 +0000112
Craig Topper73156022014-03-02 09:09:27 +0000113 void emitRawComment(const Twine &T, bool TabPrefix = true) override;
Rafael Espindola0b694812014-01-16 16:28:37 +0000114
Chris Lattnera3eee3c2010-01-22 19:52:01 +0000115 /// AddBlankLine - Emit a blank line to a .s file to pretty it up.
Craig Topper34a61bc2014-03-08 07:02:02 +0000116 void AddBlankLine() override {
Chris Lattnera3eee3c2010-01-22 19:52:01 +0000117 EmitEOL();
118 }
Daniel Dunbar9a0a4612010-02-09 23:00:14 +0000119
Chris Lattner962c5bd82009-08-17 04:17:34 +0000120 /// @name MCStreamer Interface
121 /// @{
Daniel Dunbar9faf2732009-06-24 01:03:06 +0000122
Rafael Espindola0709a7b2015-05-21 19:20:38 +0000123 void ChangeSection(MCSection *Section, const MCExpr *Subsection) override;
Daniel Dunbar9faf2732009-06-24 01:03:06 +0000124
Tim Northover53d32512014-03-29 07:34:53 +0000125 void EmitLOHDirective(MCLOHType Kind, const MCLOHArgs &Args) override;
Craig Topper34a61bc2014-03-08 07:02:02 +0000126 void EmitLabel(MCSymbol *Symbol) override;
Reed Kotleraee4d5d12012-12-16 04:00:45 +0000127
Craig Topper34a61bc2014-03-08 07:02:02 +0000128 void EmitAssemblerFlag(MCAssemblerFlag Flag) override;
129 void EmitLinkerOptions(ArrayRef<std::string> Options) override;
130 void EmitDataRegion(MCDataRegionType Kind) override;
Jim Grosbach448334a2014-03-18 22:09:05 +0000131 void EmitVersionMin(MCVersionMinType Kind, unsigned Major, unsigned Minor,
132 unsigned Update) override;
Craig Topper34a61bc2014-03-08 07:02:02 +0000133 void EmitThumbFunc(MCSymbol *Func) override;
Daniel Dunbar9faf2732009-06-24 01:03:06 +0000134
Craig Topper34a61bc2014-03-08 07:02:02 +0000135 void EmitAssignment(MCSymbol *Symbol, const MCExpr *Value) override;
136 void EmitWeakReference(MCSymbol *Alias, const MCSymbol *Symbol) override;
Craig Topper34a61bc2014-03-08 07:02:02 +0000137 bool EmitSymbolAttribute(MCSymbol *Symbol, MCSymbolAttr Attribute) override;
Kevin Enderbyc9d93ef2009-07-13 21:03:15 +0000138
Craig Topper34a61bc2014-03-08 07:02:02 +0000139 void EmitSymbolDesc(MCSymbol *Symbol, unsigned DescValue) override;
140 void BeginCOFFSymbolDef(const MCSymbol *Symbol) override;
141 void EmitCOFFSymbolStorageClass(int StorageClass) override;
142 void EmitCOFFSymbolType(int Type) override;
143 void EndCOFFSymbolDef() override;
David Majnemer4eecd302015-05-30 04:56:02 +0000144 void EmitCOFFSafeSEH(MCSymbol const *Symbol) override;
Craig Topper34a61bc2014-03-08 07:02:02 +0000145 void EmitCOFFSectionIndex(MCSymbol const *Symbol) override;
146 void EmitCOFFSecRel32(MCSymbol const *Symbol) override;
Rafael Espindolaa8695762015-06-02 00:25:12 +0000147 void emitELFSize(MCSymbolELF *Symbol, const MCExpr *Value) override;
Craig Topper34a61bc2014-03-08 07:02:02 +0000148 void EmitCommonSymbol(MCSymbol *Symbol, uint64_t Size,
149 unsigned ByteAlignment) override;
Kevin Enderby4c21caa2009-07-14 18:17:10 +0000150
Chris Lattnerb1301f72010-01-23 07:47:02 +0000151 /// EmitLocalCommonSymbol - Emit a local common (.lcomm) symbol.
152 ///
153 /// @param Symbol - The common symbol to emit.
154 /// @param Size - The size of the common symbol.
Dmitri Gribenko65340a62012-08-23 16:54:08 +0000155 /// @param ByteAlignment - The alignment of the common symbol in bytes.
Craig Topper34a61bc2014-03-08 07:02:02 +0000156 void EmitLocalCommonSymbol(MCSymbol *Symbol, uint64_t Size,
157 unsigned ByteAlignment) override;
Jim Grosbach3bde49a2010-09-22 18:16:55 +0000158
Rafael Espindola0709a7b2015-05-21 19:20:38 +0000159 void EmitZerofill(MCSection *Section, MCSymbol *Symbol = nullptr,
Craig Topper34a61bc2014-03-08 07:02:02 +0000160 uint64_t Size = 0, unsigned ByteAlignment = 0) override;
Kevin Enderbycbe475d2009-07-14 21:35:03 +0000161
Rafael Espindola0709a7b2015-05-21 19:20:38 +0000162 void EmitTBSSSymbol(MCSection *Section, MCSymbol *Symbol, uint64_t Size,
163 unsigned ByteAlignment = 0) override;
Jim Grosbach3bde49a2010-09-22 18:16:55 +0000164
Reid Klecknerfbdbe9e2016-05-31 18:45:36 +0000165 void EmitBinaryData(StringRef Data) override;
166
Craig Topper34a61bc2014-03-08 07:02:02 +0000167 void EmitBytes(StringRef Data) override;
Chris Lattnera1e11f52009-07-07 20:30:46 +0000168
Kevin Enderby96918bc2014-04-22 17:27:29 +0000169 void EmitValueImpl(const MCExpr *Value, unsigned Size,
Craig Topper3c76c522015-09-20 23:35:59 +0000170 SMLoc Loc = SMLoc()) override;
Craig Topper34a61bc2014-03-08 07:02:02 +0000171 void EmitIntValue(uint64_t Value, unsigned Size) override;
Rafael Espindola5e874982010-11-02 17:22:24 +0000172
Craig Topper34a61bc2014-03-08 07:02:02 +0000173 void EmitULEB128Value(const MCExpr *Value) override;
Rafael Espindola5e874982010-11-02 17:22:24 +0000174
Craig Topper34a61bc2014-03-08 07:02:02 +0000175 void EmitSLEB128Value(const MCExpr *Value) override;
Rafael Espindola5e874982010-11-02 17:22:24 +0000176
Craig Topper34a61bc2014-03-08 07:02:02 +0000177 void EmitGPRel64Value(const MCExpr *Value) override;
Akira Hatanakaf0b08442012-02-03 04:33:00 +0000178
Craig Topper34a61bc2014-03-08 07:02:02 +0000179 void EmitGPRel32Value(const MCExpr *Value) override;
Jim Grosbach3bde49a2010-09-22 18:16:55 +0000180
Chris Lattnerdc50e5d2010-01-19 22:03:38 +0000181
Petr Hosekfaef3202016-06-01 01:59:58 +0000182 void emitFill(uint64_t NumBytes, uint8_t FillValue) override;
Chris Lattner07cadaf2009-07-10 22:20:30 +0000183
Petr Hosek67a94a72016-05-28 05:57:48 +0000184 void emitFill(const MCExpr &NumBytes, uint64_t FillValue,
185 SMLoc Loc = SMLoc()) override;
186
187 void emitFill(uint64_t NumValues, int64_t Size, int64_t Expr) override;
188
189 void emitFill(const MCExpr &NumValues, int64_t Size, int64_t Expr,
190 SMLoc Loc = SMLoc()) override;
191
Craig Topper34a61bc2014-03-08 07:02:02 +0000192 void EmitValueToAlignment(unsigned ByteAlignment, int64_t Value = 0,
193 unsigned ValueSize = 1,
194 unsigned MaxBytesToEmit = 0) override;
Daniel Dunbar9faf2732009-06-24 01:03:06 +0000195
Craig Topper34a61bc2014-03-08 07:02:02 +0000196 void EmitCodeAlignment(unsigned ByteAlignment,
197 unsigned MaxBytesToEmit = 0) override;
Kevin Enderbye83d74f2010-02-23 18:26:34 +0000198
Rafael Espindola7ae65d82015-11-04 23:59:18 +0000199 void emitValueToOffset(const MCExpr *Offset,
Craig Topper34a61bc2014-03-08 07:02:02 +0000200 unsigned char Value = 0) override;
Daniel Dunbar9faf2732009-06-24 01:03:06 +0000201
Craig Topper34a61bc2014-03-08 07:02:02 +0000202 void EmitFileDirective(StringRef Filename) override;
David Blaikiec714ef42014-03-17 01:52:11 +0000203 unsigned EmitDwarfFileDirective(unsigned FileNo, StringRef Directory,
204 StringRef Filename,
205 unsigned CUID = 0) override;
Craig Topper34a61bc2014-03-08 07:02:02 +0000206 void EmitDwarfLocDirective(unsigned FileNo, unsigned Line,
207 unsigned Column, unsigned Flags,
208 unsigned Isa, unsigned Discriminator,
209 StringRef FileName) override;
David Blaikie34641612014-04-01 08:07:52 +0000210 MCSymbol *getDwarfLineTableSymbol(unsigned CUID) override;
Chris Lattner601ef332010-01-25 18:58:59 +0000211
Reid Kleckner2214ed82016-01-29 00:49:42 +0000212 unsigned EmitCVFileDirective(unsigned FileNo, StringRef Filename) override;
213 void EmitCVLocDirective(unsigned FunctionId, unsigned FileNo, unsigned Line,
214 unsigned Column, bool PrologueEnd, bool IsStmt,
215 StringRef FileName) override;
216 void EmitCVLinetableDirective(unsigned FunctionId, const MCSymbol *FnStart,
217 const MCSymbol *FnEnd) override;
David Majnemer6fcbd7e2016-01-29 19:24:12 +0000218 void EmitCVInlineLinetableDirective(
219 unsigned PrimaryFunctionId, unsigned SourceFileId, unsigned SourceLineNum,
David Majnemerc9911f22016-02-02 19:22:34 +0000220 const MCSymbol *FnStartSym, const MCSymbol *FnEndSym,
David Majnemer6fcbd7e2016-01-29 19:24:12 +0000221 ArrayRef<unsigned> SecondaryFunctionIds) override;
David Majnemer408b5e62016-02-05 01:55:49 +0000222 void EmitCVDefRangeDirective(
223 ArrayRef<std::pair<const MCSymbol *, const MCSymbol *>> Ranges,
224 StringRef FixedSizePortion) override;
Reid Kleckner2214ed82016-01-29 00:49:42 +0000225 void EmitCVStringTableDirective() override;
226 void EmitCVFileChecksumsDirective() override;
227
Craig Topper34a61bc2014-03-08 07:02:02 +0000228 void EmitIdent(StringRef IdentString) override;
229 void EmitCFISections(bool EH, bool Debug) override;
230 void EmitCFIDefCfa(int64_t Register, int64_t Offset) override;
231 void EmitCFIDefCfaOffset(int64_t Offset) override;
232 void EmitCFIDefCfaRegister(int64_t Register) override;
233 void EmitCFIOffset(int64_t Register, int64_t Offset) override;
234 void EmitCFIPersonality(const MCSymbol *Sym, unsigned Encoding) override;
235 void EmitCFILsda(const MCSymbol *Sym, unsigned Encoding) override;
236 void EmitCFIRememberState() override;
237 void EmitCFIRestoreState() override;
238 void EmitCFISameValue(int64_t Register) override;
239 void EmitCFIRelOffset(int64_t Register, int64_t Offset) override;
240 void EmitCFIAdjustCfaOffset(int64_t Adjustment) override;
Michael Kuperstein259f1502015-10-07 07:01:31 +0000241 void EmitCFIEscape(StringRef Values) override;
242 void EmitCFIGnuArgsSize(int64_t Size) override;
Craig Topper34a61bc2014-03-08 07:02:02 +0000243 void EmitCFISignalFrame() override;
244 void EmitCFIUndefined(int64_t Register) override;
245 void EmitCFIRegister(int64_t Register1, int64_t Register2) override;
246 void EmitCFIWindowSave() override;
Rafael Espindola3c227b02010-11-22 14:27:24 +0000247
Saleem Abdulrasool7206a522014-06-29 01:52:01 +0000248 void EmitWinCFIStartProc(const MCSymbol *Symbol) override;
249 void EmitWinCFIEndProc() override;
250 void EmitWinCFIStartChained() override;
251 void EmitWinCFIEndChained() override;
252 void EmitWinCFIPushReg(unsigned Register) override;
253 void EmitWinCFISetFrame(unsigned Register, unsigned Offset) override;
254 void EmitWinCFIAllocStack(unsigned Size) override;
255 void EmitWinCFISaveReg(unsigned Register, unsigned Offset) override;
256 void EmitWinCFISaveXMM(unsigned Register, unsigned Offset) override;
257 void EmitWinCFIPushFrame(bool Code) override;
258 void EmitWinCFIEndProlog() override;
259
260 void EmitWinEHHandler(const MCSymbol *Sym, bool Unwind, bool Except) override;
261 void EmitWinEHHandlerData() override;
Charles Davis8d9c9902011-05-18 04:58:05 +0000262
Craig Topper34a61bc2014-03-08 07:02:02 +0000263 void EmitInstruction(const MCInst &Inst, const MCSubtargetInfo &STI) override;
Jim Grosbach3bde49a2010-09-22 18:16:55 +0000264
Craig Topper34a61bc2014-03-08 07:02:02 +0000265 void EmitBundleAlignMode(unsigned AlignPow2) override;
266 void EmitBundleLock(bool AlignToEnd) override;
267 void EmitBundleUnlock() override;
Eli Benderskyf483ff92012-12-20 19:05:53 +0000268
Daniel Sanders9f6ad492015-11-12 13:33:00 +0000269 bool EmitRelocDirective(const MCExpr &Offset, StringRef Name,
270 const MCExpr *Expr, SMLoc Loc) override;
271
Jim Grosbach6ebd7282010-09-22 18:18:30 +0000272 /// EmitRawText - If this file is backed by an assembly streamer, this dumps
Chris Lattner8a87fb72010-04-03 21:35:55 +0000273 /// the specified string in the output .s file. This capability is
274 /// indicated by the hasRawTextSupport() predicate.
Craig Topper34a61bc2014-03-08 07:02:02 +0000275 void EmitRawTextImpl(StringRef String) override;
Jim Grosbach3bde49a2010-09-22 18:16:55 +0000276
Craig Topper34a61bc2014-03-08 07:02:02 +0000277 void FinishImpl() override;
Chris Lattner962c5bd82009-08-17 04:17:34 +0000278};
Daniel Dunbar71ea89d2009-06-24 19:25:34 +0000279
Chris Lattner962c5bd82009-08-17 04:17:34 +0000280} // end anonymous namespace.
Daniel Dunbar9faf2732009-06-24 01:03:06 +0000281
Chris Lattnere1d8a312010-01-22 18:21:35 +0000282/// AddComment - Add a comment that can be emitted to the generated .s
Chris Lattner38e92192010-01-22 07:29:22 +0000283/// file if applicable as a QoI issue to make the output of the compiler
284/// more readable. This only affects the MCAsmStreamer, and only when
285/// verbose assembly output is enabled.
Chris Lattnere1d8a312010-01-22 18:21:35 +0000286void MCAsmStreamer::AddComment(const Twine &T) {
Chris Lattner38e92192010-01-22 07:29:22 +0000287 if (!IsVerboseAsm) return;
Jim Grosbach3bde49a2010-09-22 18:16:55 +0000288
Chris Lattner38e92192010-01-22 07:29:22 +0000289 T.toVector(CommentToEmit);
Chris Lattner8fa0e352010-01-22 19:17:48 +0000290 // Each comment goes on its own line.
291 CommentToEmit.push_back('\n');
Chris Lattner38e92192010-01-22 07:29:22 +0000292}
293
294void MCAsmStreamer::EmitCommentsAndEOL() {
Chris Lattner8fa0e352010-01-22 19:17:48 +0000295 if (CommentToEmit.empty() && CommentStream.GetNumBytesInBuffer() == 0) {
296 OS << '\n';
297 return;
298 }
Jim Grosbach3bde49a2010-09-22 18:16:55 +0000299
Yaron Keren92e1b622015-03-18 10:17:07 +0000300 StringRef Comments = CommentToEmit;
Jim Grosbach3bde49a2010-09-22 18:16:55 +0000301
Chris Lattner8fa0e352010-01-22 19:17:48 +0000302 assert(Comments.back() == '\n' &&
303 "Comment array not newline terminated");
304 do {
Chris Lattner38e92192010-01-22 07:29:22 +0000305 // Emit a line of comments.
Bill Wendlingbc07a892013-06-18 07:20:20 +0000306 OS.PadToColumn(MAI->getCommentColumn());
Chris Lattner38e92192010-01-22 07:29:22 +0000307 size_t Position = Comments.find('\n');
Bill Wendlingbc07a892013-06-18 07:20:20 +0000308 OS << MAI->getCommentString() << ' ' << Comments.substr(0, Position) <<'\n';
Jim Grosbach3bde49a2010-09-22 18:16:55 +0000309
Chris Lattner38e92192010-01-22 07:29:22 +0000310 Comments = Comments.substr(Position+1);
Chris Lattner8fa0e352010-01-22 19:17:48 +0000311 } while (!Comments.empty());
Jim Grosbach3bde49a2010-09-22 18:16:55 +0000312
Chris Lattner1386a882010-01-22 21:16:10 +0000313 CommentToEmit.clear();
Chris Lattner38e92192010-01-22 07:29:22 +0000314}
315
Daniel Dunbar188e87f2009-06-25 21:03:18 +0000316static inline int64_t truncateToSize(int64_t Value, unsigned Bytes) {
Petr Hosek17f7a242016-06-04 04:02:18 +0000317 assert(Bytes > 0 && Bytes <= 8 && "Invalid size!");
Daniel Dunbar188e87f2009-06-25 21:03:18 +0000318 return Value & ((uint64_t) (int64_t) -1 >> (64 - Bytes * 8));
319}
320
Rafael Espindola0b694812014-01-16 16:28:37 +0000321void MCAsmStreamer::emitRawComment(const Twine &T, bool TabPrefix) {
322 if (TabPrefix)
323 OS << '\t';
324 OS << MAI->getCommentString() << T;
325 EmitEOL();
326}
327
Rafael Espindola0709a7b2015-05-21 19:20:38 +0000328void MCAsmStreamer::ChangeSection(MCSection *Section,
Peter Collingbourne2f495b92013-04-17 21:18:16 +0000329 const MCExpr *Subsection) {
Chris Lattner4b7dadb2009-08-19 05:49:37 +0000330 assert(Section && "Cannot switch to a null section!");
Bill Wendlingbc07a892013-06-18 07:20:20 +0000331 Section->PrintSwitchToSection(*MAI, OS, Subsection);
Daniel Dunbar9faf2732009-06-24 01:03:06 +0000332}
333
334void MCAsmStreamer::EmitLabel(MCSymbol *Symbol) {
Daniel Dunbar6860ac72009-08-22 07:22:36 +0000335 assert(Symbol->isUndefined() && "Cannot define a symbol twice!");
Rafael Espindola27c0c9b2011-04-27 15:21:19 +0000336 MCStreamer::EmitLabel(Symbol);
Daniel Dunbarf782ebc2009-06-24 17:00:42 +0000337
Matt Arsenault8b643552015-06-09 00:31:39 +0000338 Symbol->print(OS, MAI);
339 OS << MAI->getLabelSuffix();
340
Chris Lattnercfa5ebc32010-01-22 07:36:39 +0000341 EmitEOL();
Daniel Dunbar9faf2732009-06-24 01:03:06 +0000342}
343
Tim Northover53d32512014-03-29 07:34:53 +0000344void MCAsmStreamer::EmitLOHDirective(MCLOHType Kind, const MCLOHArgs &Args) {
345 StringRef str = MCLOHIdToName(Kind);
346
347#ifndef NDEBUG
348 int NbArgs = MCLOHIdToNbArgs(Kind);
349 assert(NbArgs != -1 && ((size_t)NbArgs) == Args.size() && "Malformed LOH!");
350 assert(str != "" && "Invalid LOH name");
351#endif
352
353 OS << "\t" << MCLOHDirectiveName() << " " << str << "\t";
354 bool IsFirst = true;
Benjamin Kramer7b4658f2016-06-26 14:49:00 +0000355 for (const MCSymbol *Arg : Args) {
Tim Northover53d32512014-03-29 07:34:53 +0000356 if (!IsFirst)
357 OS << ", ";
358 IsFirst = false;
Benjamin Kramer7b4658f2016-06-26 14:49:00 +0000359 Arg->print(OS, MAI);
Tim Northover53d32512014-03-29 07:34:53 +0000360 }
361 EmitEOL();
362}
363
Chris Lattner685508c2010-01-23 06:39:22 +0000364void MCAsmStreamer::EmitAssemblerFlag(MCAssemblerFlag Flag) {
Kevin Enderbydd27e5e2009-07-16 17:56:39 +0000365 switch (Flag) {
Jason W Kim645f6c22010-09-30 02:45:56 +0000366 case MCAF_SyntaxUnified: OS << "\t.syntax unified"; break;
Chris Lattner685508c2010-01-23 06:39:22 +0000367 case MCAF_SubsectionsViaSymbols: OS << ".subsections_via_symbols"; break;
Bill Wendlingbc07a892013-06-18 07:20:20 +0000368 case MCAF_Code16: OS << '\t'<< MAI->getCode16Directive();break;
369 case MCAF_Code32: OS << '\t'<< MAI->getCode32Directive();break;
370 case MCAF_Code64: OS << '\t'<< MAI->getCode64Directive();break;
Kevin Enderbydd27e5e2009-07-16 17:56:39 +0000371 }
Chris Lattnercfa5ebc32010-01-22 07:36:39 +0000372 EmitEOL();
Kevin Enderbyc9d93ef2009-07-13 21:03:15 +0000373}
374
Daniel Dunbar16004b82013-01-18 01:25:48 +0000375void MCAsmStreamer::EmitLinkerOptions(ArrayRef<std::string> Options) {
376 assert(!Options.empty() && "At least one option is required!");
377 OS << "\t.linker_option \"" << Options[0] << '"';
378 for (ArrayRef<std::string>::iterator it = Options.begin() + 1,
379 ie = Options.end(); it != ie; ++it) {
380 OS << ", " << '"' << *it << '"';
381 }
Daniel Dunbar95856122013-01-18 19:37:00 +0000382 OS << "\n";
Daniel Dunbar16004b82013-01-18 01:25:48 +0000383}
384
Jim Grosbach4b63d2a2012-05-18 19:12:01 +0000385void MCAsmStreamer::EmitDataRegion(MCDataRegionType Kind) {
Bill Wendlingbc07a892013-06-18 07:20:20 +0000386 if (!MAI->doesSupportDataRegionDirectives())
Jim Grosbach4b63d2a2012-05-18 19:12:01 +0000387 return;
388 switch (Kind) {
389 case MCDR_DataRegion: OS << "\t.data_region"; break;
390 case MCDR_DataRegionJT8: OS << "\t.data_region jt8"; break;
391 case MCDR_DataRegionJT16: OS << "\t.data_region jt16"; break;
392 case MCDR_DataRegionJT32: OS << "\t.data_region jt32"; break;
393 case MCDR_DataRegionEnd: OS << "\t.end_data_region"; break;
394 }
395 EmitEOL();
396}
397
Jim Grosbach448334a2014-03-18 22:09:05 +0000398void MCAsmStreamer::EmitVersionMin(MCVersionMinType Kind, unsigned Major,
399 unsigned Minor, unsigned Update) {
400 switch (Kind) {
Tim Northover2d4d1612015-10-28 22:36:05 +0000401 case MCVM_WatchOSVersionMin: OS << "\t.watchos_version_min"; break;
402 case MCVM_TvOSVersionMin: OS << "\t.tvos_version_min"; break;
Jim Grosbach448334a2014-03-18 22:09:05 +0000403 case MCVM_IOSVersionMin: OS << "\t.ios_version_min"; break;
404 case MCVM_OSXVersionMin: OS << "\t.macosx_version_min"; break;
405 }
406 OS << " " << Major << ", " << Minor;
407 if (Update)
408 OS << ", " << Update;
409 EmitEOL();
410}
411
Jim Grosbach5a2c68d2010-11-05 22:08:08 +0000412void MCAsmStreamer::EmitThumbFunc(MCSymbol *Func) {
413 // This needs to emit to a temporary string to get properly quoted
414 // MCSymbols when they have spaces in them.
415 OS << "\t.thumb_func";
Rafael Espindolae90c1cb2011-05-16 16:17:21 +0000416 // Only Mach-O hasSubsectionsViaSymbols()
Matt Arsenault8b643552015-06-09 00:31:39 +0000417 if (MAI->hasSubsectionsViaSymbols()) {
418 OS << '\t';
419 Func->print(OS, MAI);
420 }
Jim Grosbach5a2c68d2010-11-05 22:08:08 +0000421 EmitEOL();
422}
423
Daniel Dunbar897ffad2009-08-31 08:09:28 +0000424void MCAsmStreamer::EmitAssignment(MCSymbol *Symbol, const MCExpr *Value) {
Matt Arsenault8b643552015-06-09 00:31:39 +0000425 Symbol->print(OS, MAI);
426 OS << " = ";
427 Value->print(OS, MAI);
428
Chris Lattnercfa5ebc32010-01-22 07:36:39 +0000429 EmitEOL();
Daniel Dunbard20cda02009-10-16 01:34:54 +0000430
Zoran Jovanovic28221d82014-03-20 09:44:49 +0000431 MCStreamer::EmitAssignment(Symbol, Value);
Daniel Dunbar9faf2732009-06-24 01:03:06 +0000432}
433
Rafael Espindola16145972010-11-01 14:28:48 +0000434void MCAsmStreamer::EmitWeakReference(MCSymbol *Alias, const MCSymbol *Symbol) {
Matt Arsenault8b643552015-06-09 00:31:39 +0000435 OS << ".weakref ";
436 Alias->print(OS, MAI);
437 OS << ", ";
438 Symbol->print(OS, MAI);
Rafael Espindola16145972010-11-01 14:28:48 +0000439 EmitEOL();
440}
441
Saleem Abdulrasool4208b612013-08-09 01:52:03 +0000442bool MCAsmStreamer::EmitSymbolAttribute(MCSymbol *Symbol,
Chris Lattner685508c2010-01-23 06:39:22 +0000443 MCSymbolAttr Attribute) {
Daniel Dunbar9faf2732009-06-24 01:03:06 +0000444 switch (Attribute) {
Craig Toppera2886c22012-02-07 05:05:23 +0000445 case MCSA_Invalid: llvm_unreachable("Invalid symbol attribute");
Chris Lattnerbc8f6382010-01-25 18:30:45 +0000446 case MCSA_ELF_TypeFunction: /// .type _foo, STT_FUNC # aka @function
447 case MCSA_ELF_TypeIndFunction: /// .type _foo, STT_GNU_IFUNC
448 case MCSA_ELF_TypeObject: /// .type _foo, STT_OBJECT # aka @object
449 case MCSA_ELF_TypeTLS: /// .type _foo, STT_TLS # aka @tls_object
450 case MCSA_ELF_TypeCommon: /// .type _foo, STT_COMMON # aka @common
451 case MCSA_ELF_TypeNoType: /// .type _foo, STT_NOTYPE # aka @notype
Rafael Espindola2d006b12010-11-13 04:55:06 +0000452 case MCSA_ELF_TypeGnuUniqueObject: /// .type _foo, @gnu_unique_object
Saleem Abdulrasool4208b612013-08-09 01:52:03 +0000453 if (!MAI->hasDotTypeDotSizeDirective())
454 return false; // Symbol attribute not supported
Matt Arsenault8b643552015-06-09 00:31:39 +0000455 OS << "\t.type\t";
456 Symbol->print(OS, MAI);
457 OS << ',' << ((MAI->getCommentString()[0] != '@') ? '@' : '%');
Chris Lattnerbc8f6382010-01-25 18:30:45 +0000458 switch (Attribute) {
Saleem Abdulrasool4208b612013-08-09 01:52:03 +0000459 default: return false;
Chris Lattnerbc8f6382010-01-25 18:30:45 +0000460 case MCSA_ELF_TypeFunction: OS << "function"; break;
461 case MCSA_ELF_TypeIndFunction: OS << "gnu_indirect_function"; break;
462 case MCSA_ELF_TypeObject: OS << "object"; break;
463 case MCSA_ELF_TypeTLS: OS << "tls_object"; break;
464 case MCSA_ELF_TypeCommon: OS << "common"; break;
465 case MCSA_ELF_TypeNoType: OS << "no_type"; break;
Rafael Espindola2d006b12010-11-13 04:55:06 +0000466 case MCSA_ELF_TypeGnuUniqueObject: OS << "gnu_unique_object"; break;
Chris Lattnerbc8f6382010-01-25 18:30:45 +0000467 }
468 EmitEOL();
Saleem Abdulrasool4208b612013-08-09 01:52:03 +0000469 return true;
Chris Lattnerbc8f6382010-01-25 18:30:45 +0000470 case MCSA_Global: // .globl/.global
Bill Wendlingbc07a892013-06-18 07:20:20 +0000471 OS << MAI->getGlobalDirective();
Chris Lattnerbc8f6382010-01-25 18:30:45 +0000472 break;
Chris Lattner79d20752010-06-21 20:35:01 +0000473 case MCSA_Hidden: OS << "\t.hidden\t"; break;
474 case MCSA_IndirectSymbol: OS << "\t.indirect_symbol\t"; break;
475 case MCSA_Internal: OS << "\t.internal\t"; break;
476 case MCSA_LazyReference: OS << "\t.lazy_reference\t"; break;
477 case MCSA_Local: OS << "\t.local\t"; break;
David Majnemer0fe246e2014-12-24 04:11:42 +0000478 case MCSA_NoDeadStrip:
479 if (!MAI->hasNoDeadStrip())
480 return false;
481 OS << "\t.no_dead_strip\t";
482 break;
Kevin Enderby8be14412010-11-19 18:39:33 +0000483 case MCSA_SymbolResolver: OS << "\t.symbol_resolver\t"; break;
Lang Hames1b640e02016-03-15 01:43:05 +0000484 case MCSA_AltEntry: OS << "\t.alt_entry\t"; break;
Rafael Espindolabde52bc2011-04-30 16:34:57 +0000485 case MCSA_PrivateExtern:
486 OS << "\t.private_extern\t";
Rafael Espindolabde52bc2011-04-30 16:34:57 +0000487 break;
Chris Lattner79d20752010-06-21 20:35:01 +0000488 case MCSA_Protected: OS << "\t.protected\t"; break;
489 case MCSA_Reference: OS << "\t.reference\t"; break;
Jingyue Wu5b62eb92014-12-01 21:16:17 +0000490 case MCSA_Weak: OS << MAI->getWeakDirective(); break;
Rafael Espindolabde52bc2011-04-30 16:34:57 +0000491 case MCSA_WeakDefinition:
492 OS << "\t.weak_definition\t";
Rafael Espindolabde52bc2011-04-30 16:34:57 +0000493 break;
Chris Lattner685508c2010-01-23 06:39:22 +0000494 // .weak_reference
Bill Wendlingbc07a892013-06-18 07:20:20 +0000495 case MCSA_WeakReference: OS << MAI->getWeakRefDirective(); break;
Kevin Enderby082d0fd2010-07-08 17:22:42 +0000496 case MCSA_WeakDefAutoPrivate: OS << "\t.weak_def_can_be_hidden\t"; break;
Daniel Dunbar9faf2732009-06-24 01:03:06 +0000497 }
498
Matt Arsenault8b643552015-06-09 00:31:39 +0000499 Symbol->print(OS, MAI);
Chris Lattnercfa5ebc32010-01-22 07:36:39 +0000500 EmitEOL();
Saleem Abdulrasool4208b612013-08-09 01:52:03 +0000501
502 return true;
Daniel Dunbar9faf2732009-06-24 01:03:06 +0000503}
504
Kevin Enderby4c21caa2009-07-14 18:17:10 +0000505void MCAsmStreamer::EmitSymbolDesc(MCSymbol *Symbol, unsigned DescValue) {
Matt Arsenault8b643552015-06-09 00:31:39 +0000506 OS << ".desc" << ' ';
507 Symbol->print(OS, MAI);
508 OS << ',' << DescValue;
Chris Lattnercfa5ebc32010-01-22 07:36:39 +0000509 EmitEOL();
Kevin Enderby4c21caa2009-07-14 18:17:10 +0000510}
511
Michael Kuperstein23d952b2015-07-22 10:49:44 +0000512void MCAsmStreamer::EmitSyntaxDirective() {
513 if (MAI->getAssemblerDialect() == 1)
514 OS << "\t.intel_syntax noprefix\n";
515 // FIXME: Currently emit unprefix'ed registers.
516 // The intel_syntax directive has one optional argument
517 // with may have a value of prefix or noprefix.
518}
519
Chris Lattner72afa952010-05-08 19:54:22 +0000520void MCAsmStreamer::BeginCOFFSymbolDef(const MCSymbol *Symbol) {
Matt Arsenault8b643552015-06-09 00:31:39 +0000521 OS << "\t.def\t ";
522 Symbol->print(OS, MAI);
523 OS << ';';
Chris Lattner72afa952010-05-08 19:54:22 +0000524 EmitEOL();
525}
526
527void MCAsmStreamer::EmitCOFFSymbolStorageClass (int StorageClass) {
528 OS << "\t.scl\t" << StorageClass << ';';
529 EmitEOL();
530}
531
532void MCAsmStreamer::EmitCOFFSymbolType (int Type) {
533 OS << "\t.type\t" << Type << ';';
534 EmitEOL();
535}
536
537void MCAsmStreamer::EndCOFFSymbolDef() {
538 OS << "\t.endef";
539 EmitEOL();
540}
541
David Majnemer4eecd302015-05-30 04:56:02 +0000542void MCAsmStreamer::EmitCOFFSafeSEH(MCSymbol const *Symbol) {
David Majnemer1305e2c2015-07-13 18:51:15 +0000543 OS << "\t.safeseh\t";
544 Symbol->print(OS, MAI);
David Majnemer4eecd302015-05-30 04:56:02 +0000545 EmitEOL();
546}
547
Timur Iskhodzhanovc1fb2d62013-12-20 18:15:00 +0000548void MCAsmStreamer::EmitCOFFSectionIndex(MCSymbol const *Symbol) {
Matt Arsenault8b643552015-06-09 00:31:39 +0000549 OS << "\t.secidx\t";
550 Symbol->print(OS, MAI);
Timur Iskhodzhanovc1fb2d62013-12-20 18:15:00 +0000551 EmitEOL();
552}
553
Rafael Espindolad3df3d32011-12-17 01:14:52 +0000554void MCAsmStreamer::EmitCOFFSecRel32(MCSymbol const *Symbol) {
Matt Arsenault8b643552015-06-09 00:31:39 +0000555 OS << "\t.secrel32\t";
556 Symbol->print(OS, MAI);
Rafael Espindolad3df3d32011-12-17 01:14:52 +0000557 EmitEOL();
558}
559
Rafael Espindolaa8695762015-06-02 00:25:12 +0000560void MCAsmStreamer::emitELFSize(MCSymbolELF *Symbol, const MCExpr *Value) {
Bill Wendlingbc07a892013-06-18 07:20:20 +0000561 assert(MAI->hasDotTypeDotSizeDirective());
Matt Arsenault8b643552015-06-09 00:31:39 +0000562 OS << "\t.size\t";
563 Symbol->print(OS, MAI);
564 OS << ", ";
565 Value->print(OS, MAI);
566 OS << '\n';
Chris Lattner91dac6d2010-01-25 07:52:13 +0000567}
568
Chris Lattnerb1301f72010-01-23 07:47:02 +0000569void MCAsmStreamer::EmitCommonSymbol(MCSymbol *Symbol, uint64_t Size,
Daniel Dunbar6a715dc2009-08-30 06:17:16 +0000570 unsigned ByteAlignment) {
Matt Arsenault8b643552015-06-09 00:31:39 +0000571 OS << "\t.comm\t";
572 Symbol->print(OS, MAI);
573 OS << ',' << Size;
574
Chris Lattner0375d2f2010-01-25 07:29:13 +0000575 if (ByteAlignment != 0) {
Bill Wendlingbc07a892013-06-18 07:20:20 +0000576 if (MAI->getCOMMDirectiveAlignmentIsInBytes())
Chris Lattner95b98952010-01-19 06:01:04 +0000577 OS << ',' << ByteAlignment;
578 else
579 OS << ',' << Log2_32(ByteAlignment);
580 }
Chris Lattnercfa5ebc32010-01-22 07:36:39 +0000581 EmitEOL();
Chris Lattnera1e11f52009-07-07 20:30:46 +0000582}
583
Chris Lattnerb1301f72010-01-23 07:47:02 +0000584/// EmitLocalCommonSymbol - Emit a local common (.lcomm) symbol.
585///
586/// @param Symbol - The common symbol to emit.
587/// @param Size - The size of the common symbol.
Benjamin Kramer63970512011-09-01 23:04:27 +0000588void MCAsmStreamer::EmitLocalCommonSymbol(MCSymbol *Symbol, uint64_t Size,
589 unsigned ByteAlign) {
Matt Arsenault8b643552015-06-09 00:31:39 +0000590 OS << "\t.lcomm\t";
591 Symbol->print(OS, MAI);
592 OS << ',' << Size;
593
Benjamin Kramer63970512011-09-01 23:04:27 +0000594 if (ByteAlign > 1) {
Bill Wendlingbc07a892013-06-18 07:20:20 +0000595 switch (MAI->getLCOMMDirectiveAlignmentType()) {
Benjamin Kramer68b9f052012-09-07 21:08:01 +0000596 case LCOMM::NoAlignment:
597 llvm_unreachable("alignment not supported on .lcomm!");
598 case LCOMM::ByteAlignment:
Benjamin Kramer47f9ec92012-09-07 17:25:13 +0000599 OS << ',' << ByteAlign;
Benjamin Kramer68b9f052012-09-07 21:08:01 +0000600 break;
601 case LCOMM::Log2Alignment:
Benjamin Kramer47f9ec92012-09-07 17:25:13 +0000602 assert(isPowerOf2_32(ByteAlign) && "alignment must be a power of 2");
603 OS << ',' << Log2_32(ByteAlign);
Benjamin Kramer68b9f052012-09-07 21:08:01 +0000604 break;
Benjamin Kramer47f9ec92012-09-07 17:25:13 +0000605 }
Benjamin Kramer63970512011-09-01 23:04:27 +0000606 }
Chris Lattnerb1301f72010-01-23 07:47:02 +0000607 EmitEOL();
608}
609
Rafael Espindola0709a7b2015-05-21 19:20:38 +0000610void MCAsmStreamer::EmitZerofill(MCSection *Section, MCSymbol *Symbol,
Evan Chengf5bd6c62012-06-22 20:14:46 +0000611 uint64_t Size, unsigned ByteAlignment) {
Richard Mitton21101b32013-09-19 23:21:01 +0000612 if (Symbol)
Rafael Espindolae3a20f52015-10-05 12:07:05 +0000613 AssignFragment(Symbol, &Section->getDummyFragment());
Richard Mitton21101b32013-09-19 23:21:01 +0000614
Daniel Dunbaraba5fb82009-08-13 23:36:34 +0000615 // Note: a .zerofill directive does not switch sections.
Chris Lattner591105c2009-08-08 23:39:42 +0000616 OS << ".zerofill ";
Jim Grosbach3bde49a2010-09-22 18:16:55 +0000617
Chris Lattner591105c2009-08-08 23:39:42 +0000618 // This is a mach-o specific directive.
Chris Lattnercb307a272009-08-10 01:39:42 +0000619 const MCSectionMachO *MOSection = ((const MCSectionMachO*)Section);
Daniel Dunbar563a7e82009-08-14 18:51:45 +0000620 OS << MOSection->getSegmentName() << "," << MOSection->getSectionName();
Jim Grosbach3bde49a2010-09-22 18:16:55 +0000621
Craig Topperbb694de2014-04-13 04:57:38 +0000622 if (Symbol) {
Matt Arsenault8b643552015-06-09 00:31:39 +0000623 OS << ',';
624 Symbol->print(OS, MAI);
625 OS << ',' << Size;
Daniel Dunbar6a715dc2009-08-30 06:17:16 +0000626 if (ByteAlignment != 0)
627 OS << ',' << Log2_32(ByteAlignment);
Chris Lattner07cadaf2009-07-10 22:20:30 +0000628 }
Chris Lattnercfa5ebc32010-01-22 07:36:39 +0000629 EmitEOL();
Chris Lattner07cadaf2009-07-10 22:20:30 +0000630}
631
Eric Christopher68b1bbe2010-05-17 02:13:02 +0000632// .tbss sym, size, align
633// This depends that the symbol has already been mangled from the original,
634// e.g. _a.
Rafael Espindola0709a7b2015-05-21 19:20:38 +0000635void MCAsmStreamer::EmitTBSSSymbol(MCSection *Section, MCSymbol *Symbol,
Eric Christopher5c87be72010-05-18 21:16:04 +0000636 uint64_t Size, unsigned ByteAlignment) {
Rafael Espindolae3a20f52015-10-05 12:07:05 +0000637 AssignFragment(Symbol, &Section->getDummyFragment());
Richard Mitton21101b32013-09-19 23:21:01 +0000638
Craig Topperbb694de2014-04-13 04:57:38 +0000639 assert(Symbol && "Symbol shouldn't be NULL!");
Eric Christopher5c87be72010-05-18 21:16:04 +0000640 // Instead of using the Section we'll just use the shortcut.
641 // This is a mach-o specific directive and section.
Matt Arsenault8b643552015-06-09 00:31:39 +0000642 OS << ".tbss ";
643 Symbol->print(OS, MAI);
644 OS << ", " << Size;
Jim Grosbach3bde49a2010-09-22 18:16:55 +0000645
Eric Christopher5c87be72010-05-18 21:16:04 +0000646 // Output align if we have it. We default to 1 so don't bother printing
647 // that.
648 if (ByteAlignment > 1) OS << ", " << Log2_32(ByteAlignment);
Jim Grosbach3bde49a2010-09-22 18:16:55 +0000649
Eric Christopher9fb6bb02010-05-14 01:50:28 +0000650 EmitEOL();
651}
652
Chris Lattnerded9af632010-01-23 00:15:00 +0000653static inline char toOctal(int X) { return (X&7)+'0'; }
654
Chris Lattner601ef332010-01-25 18:58:59 +0000655static void PrintQuotedString(StringRef Data, raw_ostream &OS) {
656 OS << '"';
Jim Grosbach3bde49a2010-09-22 18:16:55 +0000657
Chris Lattner601ef332010-01-25 18:58:59 +0000658 for (unsigned i = 0, e = Data.size(); i != e; ++i) {
659 unsigned char C = Data[i];
660 if (C == '"' || C == '\\') {
661 OS << '\\' << (char)C;
662 continue;
663 }
Jim Grosbach3bde49a2010-09-22 18:16:55 +0000664
Chris Lattner601ef332010-01-25 18:58:59 +0000665 if (isprint((unsigned char)C)) {
666 OS << (char)C;
667 continue;
668 }
Jim Grosbach3bde49a2010-09-22 18:16:55 +0000669
Chris Lattner601ef332010-01-25 18:58:59 +0000670 switch (C) {
671 case '\b': OS << "\\b"; break;
672 case '\f': OS << "\\f"; break;
673 case '\n': OS << "\\n"; break;
674 case '\r': OS << "\\r"; break;
675 case '\t': OS << "\\t"; break;
676 default:
677 OS << '\\';
678 OS << toOctal(C >> 6);
679 OS << toOctal(C >> 3);
680 OS << toOctal(C >> 0);
681 break;
682 }
683 }
Jim Grosbach3bde49a2010-09-22 18:16:55 +0000684
Chris Lattner601ef332010-01-25 18:58:59 +0000685 OS << '"';
686}
687
Rafael Espindola64e1af82013-07-02 15:49:13 +0000688void MCAsmStreamer::EmitBytes(StringRef Data) {
Peter Collingbourne2f495b92013-04-17 21:18:16 +0000689 assert(getCurrentSection().first &&
690 "Cannot emit contents before setting section!");
Chris Lattnerded9af632010-01-23 00:15:00 +0000691 if (Data.empty()) return;
Jim Grosbach3bde49a2010-09-22 18:16:55 +0000692
Chris Lattnerded9af632010-01-23 00:15:00 +0000693 if (Data.size() == 1) {
Rafael Espindola64e1af82013-07-02 15:49:13 +0000694 OS << MAI->getData8bitsDirective();
Chris Lattnerded9af632010-01-23 00:15:00 +0000695 OS << (unsigned)(unsigned char)Data[0];
Chris Lattnercfa5ebc32010-01-22 07:36:39 +0000696 EmitEOL();
Chris Lattnerded9af632010-01-23 00:15:00 +0000697 return;
Chris Lattnercfa5ebc32010-01-22 07:36:39 +0000698 }
Chris Lattnerded9af632010-01-23 00:15:00 +0000699
700 // If the data ends with 0 and the target supports .asciz, use it, otherwise
701 // use .ascii
Bill Wendlingbc07a892013-06-18 07:20:20 +0000702 if (MAI->getAscizDirective() && Data.back() == 0) {
703 OS << MAI->getAscizDirective();
Chris Lattnerded9af632010-01-23 00:15:00 +0000704 Data = Data.substr(0, Data.size()-1);
705 } else {
Bill Wendlingbc07a892013-06-18 07:20:20 +0000706 OS << MAI->getAsciiDirective();
Chris Lattnerded9af632010-01-23 00:15:00 +0000707 }
708
Chris Lattner601ef332010-01-25 18:58:59 +0000709 PrintQuotedString(Data, OS);
Chris Lattnerded9af632010-01-23 00:15:00 +0000710 EmitEOL();
Daniel Dunbar9faf2732009-06-24 01:03:06 +0000711}
712
Reid Klecknerfbdbe9e2016-05-31 18:45:36 +0000713void MCAsmStreamer::EmitBinaryData(StringRef Data) {
714 // This is binary data. Print it in a grid of hex bytes for readability.
715 const size_t Cols = 4;
716 for (size_t I = 0, EI = alignTo(Data.size(), Cols); I < EI; I += Cols) {
717 size_t J = I, EJ = std::min(I + Cols, Data.size());
718 assert(EJ > 0);
719 OS << MAI->getData8bitsDirective();
720 for (; J < EJ - 1; ++J)
721 OS << format("0x%02x", uint8_t(Data[J])) << ", ";
722 OS << format("0x%02x", uint8_t(Data[J]));
723 EmitEOL();
724 }
725}
726
Rafael Espindola64e1af82013-07-02 15:49:13 +0000727void MCAsmStreamer::EmitIntValue(uint64_t Value, unsigned Size) {
Jim Grosbach13760bd2015-05-30 01:25:56 +0000728 EmitValue(MCConstantExpr::create(Value, getContext()), Size);
Rafael Espindola4c70eea2010-12-03 02:54:21 +0000729}
730
Kevin Enderby96918bc2014-04-22 17:27:29 +0000731void MCAsmStreamer::EmitValueImpl(const MCExpr *Value, unsigned Size,
Craig Topper3c76c522015-09-20 23:35:59 +0000732 SMLoc Loc) {
David Majnemer522d3db2014-02-01 07:19:38 +0000733 assert(Size <= 8 && "Invalid size");
Peter Collingbourne2f495b92013-04-17 21:18:16 +0000734 assert(getCurrentSection().first &&
735 "Cannot emit contents before setting section!");
Craig Topperbb694de2014-04-13 04:57:38 +0000736 const char *Directive = nullptr;
Chris Lattnerdc50e5d2010-01-19 22:03:38 +0000737 switch (Size) {
738 default: break;
Rafael Espindola64e1af82013-07-02 15:49:13 +0000739 case 1: Directive = MAI->getData8bitsDirective(); break;
740 case 2: Directive = MAI->getData16bitsDirective(); break;
741 case 4: Directive = MAI->getData32bitsDirective(); break;
David Majnemer522d3db2014-02-01 07:19:38 +0000742 case 8: Directive = MAI->getData64bitsDirective(); break;
743 }
744
745 if (!Directive) {
Rafael Espindolae5e1f9a2010-11-28 23:22:44 +0000746 int64_t IntValue;
Jim Grosbach13760bd2015-05-30 01:25:56 +0000747 if (!Value->evaluateAsAbsolute(IntValue))
Rafael Espindolae5e1f9a2010-11-28 23:22:44 +0000748 report_fatal_error("Don't know how to emit this value.");
David Majnemer522d3db2014-02-01 07:19:38 +0000749
750 // We couldn't handle the requested integer size so we fallback by breaking
Rafael Espindola52570ea2016-02-01 20:36:49 +0000751 // the request down into several, smaller, integers.
752 // Since sizes greater or equal to "Size" are invalid, we use the greatest
753 // power of 2 that is less than "Size" as our largest piece of granularity.
David Majnemer522d3db2014-02-01 07:19:38 +0000754 bool IsLittleEndian = MAI->isLittleEndian();
755 for (unsigned Emitted = 0; Emitted != Size;) {
756 unsigned Remaining = Size - Emitted;
757 // The size of our partial emission must be a power of two less than
Rafael Espindola52570ea2016-02-01 20:36:49 +0000758 // Size.
759 unsigned EmissionSize = PowerOf2Floor(std::min(Remaining, Size - 1));
David Majnemer522d3db2014-02-01 07:19:38 +0000760 // Calculate the byte offset of our partial emission taking into account
761 // the endianness of the target.
762 unsigned ByteOffset =
763 IsLittleEndian ? Emitted : (Remaining - EmissionSize);
764 uint64_t ValueToEmit = IntValue >> (ByteOffset * 8);
765 // We truncate our partial emission to fit within the bounds of the
766 // emission domain. This produces nicer output and silences potential
767 // truncation warnings when round tripping through another assembler.
Michael Ilseman5be22a12014-12-12 21:48:03 +0000768 uint64_t Shift = 64 - EmissionSize * 8;
Aaron Ballman2d67fd62014-12-15 14:25:12 +0000769 assert(Shift < static_cast<uint64_t>(
Aaron Ballman786a86c2014-12-13 16:55:02 +0000770 std::numeric_limits<unsigned long long>::digits) &&
Michael Ilseman5be22a12014-12-12 21:48:03 +0000771 "undefined behavior");
772 ValueToEmit &= ~0ULL >> Shift;
David Majnemer522d3db2014-02-01 07:19:38 +0000773 EmitIntValue(ValueToEmit, EmissionSize);
774 Emitted += EmissionSize;
Chris Lattner45eeffc2010-01-20 06:45:39 +0000775 }
776 return;
Chris Lattnerdc50e5d2010-01-19 22:03:38 +0000777 }
Jim Grosbach3bde49a2010-09-22 18:16:55 +0000778
Chris Lattnerdc50e5d2010-01-19 22:03:38 +0000779 assert(Directive && "Invalid size for machine code value!");
Matt Arsenault8b643552015-06-09 00:31:39 +0000780 OS << Directive;
781 Value->print(OS, MAI);
Chris Lattner38e92192010-01-22 07:29:22 +0000782 EmitEOL();
Daniel Dunbar9faf2732009-06-24 01:03:06 +0000783}
784
Rafael Espindola6aea5922011-04-21 23:39:26 +0000785void MCAsmStreamer::EmitULEB128Value(const MCExpr *Value) {
Rafael Espindola92ca9332010-11-19 04:10:13 +0000786 int64_t IntValue;
Jim Grosbach13760bd2015-05-30 01:25:56 +0000787 if (Value->evaluateAsAbsolute(IntValue)) {
Rafael Espindola6aea5922011-04-21 23:39:26 +0000788 EmitULEB128IntValue(IntValue);
Rafael Espindola92ca9332010-11-19 04:10:13 +0000789 return;
790 }
Matt Arsenault8b643552015-06-09 00:31:39 +0000791 OS << ".uleb128 ";
792 Value->print(OS, MAI);
Rafael Espindola5e874982010-11-02 17:22:24 +0000793 EmitEOL();
794}
795
Rafael Espindola6aea5922011-04-21 23:39:26 +0000796void MCAsmStreamer::EmitSLEB128Value(const MCExpr *Value) {
Rafael Espindola92ca9332010-11-19 04:10:13 +0000797 int64_t IntValue;
Jim Grosbach13760bd2015-05-30 01:25:56 +0000798 if (Value->evaluateAsAbsolute(IntValue)) {
Rafael Espindola6aea5922011-04-21 23:39:26 +0000799 EmitSLEB128IntValue(IntValue);
Rafael Espindola92ca9332010-11-19 04:10:13 +0000800 return;
801 }
Matt Arsenault8b643552015-06-09 00:31:39 +0000802 OS << ".sleb128 ";
803 Value->print(OS, MAI);
Rafael Espindola5e874982010-11-02 17:22:24 +0000804 EmitEOL();
805}
806
Akira Hatanakaf0b08442012-02-03 04:33:00 +0000807void MCAsmStreamer::EmitGPRel64Value(const MCExpr *Value) {
Craig Topperbb694de2014-04-13 04:57:38 +0000808 assert(MAI->getGPRel64Directive() != nullptr);
Matt Arsenault8b643552015-06-09 00:31:39 +0000809 OS << MAI->getGPRel64Directive();
810 Value->print(OS, MAI);
Akira Hatanakaf0b08442012-02-03 04:33:00 +0000811 EmitEOL();
812}
813
Chris Lattner3cde7602010-01-25 21:28:50 +0000814void MCAsmStreamer::EmitGPRel32Value(const MCExpr *Value) {
Craig Topperbb694de2014-04-13 04:57:38 +0000815 assert(MAI->getGPRel32Directive() != nullptr);
Matt Arsenault8b643552015-06-09 00:31:39 +0000816 OS << MAI->getGPRel32Directive();
817 Value->print(OS, MAI);
Chris Lattner3cde7602010-01-25 21:28:50 +0000818 EmitEOL();
819}
820
Petr Hosekfaef3202016-06-01 01:59:58 +0000821/// emitFill - Emit NumBytes bytes worth of the value specified by
Chris Lattner4340cb32010-01-19 18:52:28 +0000822/// FillValue. This implements directives such as '.space'.
Petr Hosekfaef3202016-06-01 01:59:58 +0000823void MCAsmStreamer::emitFill(uint64_t NumBytes, uint8_t FillValue) {
Chris Lattnered89f602010-01-19 18:58:52 +0000824 if (NumBytes == 0) return;
Jim Grosbach3bde49a2010-09-22 18:16:55 +0000825
Petr Hosek67a94a72016-05-28 05:57:48 +0000826 const MCExpr *E = MCConstantExpr::create(NumBytes, getContext());
827 emitFill(*E, FillValue);
828}
829
830void MCAsmStreamer::emitFill(const MCExpr &NumBytes, uint64_t FillValue,
831 SMLoc Loc) {
Rafael Espindola64e1af82013-07-02 15:49:13 +0000832 if (const char *ZeroDirective = MAI->getZeroDirective()) {
Petr Hosek67a94a72016-05-28 05:57:48 +0000833 // FIXME: Emit location directives
834 OS << ZeroDirective;
835 NumBytes.print(OS, MAI);
Rafael Espindola64e1af82013-07-02 15:49:13 +0000836 if (FillValue != 0)
837 OS << ',' << (int)FillValue;
838 EmitEOL();
839 return;
840 }
Chris Lattnerc35681b2010-01-19 19:46:13 +0000841
Petr Hosek67a94a72016-05-28 05:57:48 +0000842 MCStreamer::emitFill(NumBytes, FillValue);
843}
844
845void MCAsmStreamer::emitFill(uint64_t NumValues, int64_t Size, int64_t Expr) {
846 if (NumValues == 0)
847 return;
848
849 const MCExpr *E = MCConstantExpr::create(NumValues, getContext());
850 emitFill(*E, Size, Expr);
851}
852
853void MCAsmStreamer::emitFill(const MCExpr &NumValues, int64_t Size,
854 int64_t Expr, SMLoc Loc) {
855 // FIXME: Emit location directives
856 OS << "\t.fill\t";
857 NumValues.print(OS, MAI);
858 OS << ", " << Size << ", 0x";
859 OS.write_hex(truncateToSize(Expr, 4));
860 EmitEOL();
Chris Lattner4340cb32010-01-19 18:52:28 +0000861}
862
Daniel Dunbar71ea89d2009-06-24 19:25:34 +0000863void MCAsmStreamer::EmitValueToAlignment(unsigned ByteAlignment, int64_t Value,
864 unsigned ValueSize,
865 unsigned MaxBytesToEmit) {
Chris Lattner37b72342009-08-19 06:12:02 +0000866 // Some assemblers don't support non-power of two alignments, so we always
867 // emit alignments as a power of two if possible.
868 if (isPowerOf2_32(ByteAlignment)) {
Chris Lattner78b23b02009-08-19 06:35:36 +0000869 switch (ValueSize) {
Rafael Espindola7cbbd282014-02-04 18:39:51 +0000870 default:
871 llvm_unreachable("Invalid size for machine code value!");
872 case 1:
Dan Gohman61d15ae2016-01-26 00:03:25 +0000873 OS << "\t.p2align\t";
Rafael Espindola7cbbd282014-02-04 18:39:51 +0000874 break;
875 case 2:
876 OS << ".p2alignw ";
877 break;
878 case 4:
879 OS << ".p2alignl ";
880 break;
881 case 8:
882 llvm_unreachable("Unsupported alignment size!");
Chris Lattner78b23b02009-08-19 06:35:36 +0000883 }
Jim Grosbach3bde49a2010-09-22 18:16:55 +0000884
Dan Gohman61d15ae2016-01-26 00:03:25 +0000885 OS << Log2_32(ByteAlignment);
Daniel Dunbar71ea89d2009-06-24 19:25:34 +0000886
Chris Lattner37b72342009-08-19 06:12:02 +0000887 if (Value || MaxBytesToEmit) {
Chris Lattnerf16a1222009-09-03 04:01:10 +0000888 OS << ", 0x";
889 OS.write_hex(truncateToSize(Value, ValueSize));
Chris Lattner37b72342009-08-19 06:12:02 +0000890
Jim Grosbach3bde49a2010-09-22 18:16:55 +0000891 if (MaxBytesToEmit)
Chris Lattner37b72342009-08-19 06:12:02 +0000892 OS << ", " << MaxBytesToEmit;
893 }
Chris Lattnercfa5ebc32010-01-22 07:36:39 +0000894 EmitEOL();
Chris Lattner37b72342009-08-19 06:12:02 +0000895 return;
896 }
Jim Grosbach3bde49a2010-09-22 18:16:55 +0000897
Chris Lattner37b72342009-08-19 06:12:02 +0000898 // Non-power of two alignment. This is not widely supported by assemblers.
Chris Lattnere9a75a62009-08-22 21:43:10 +0000899 // FIXME: Parameterize this based on MAI.
Daniel Dunbar71ea89d2009-06-24 19:25:34 +0000900 switch (ValueSize) {
Chris Lattner37b72342009-08-19 06:12:02 +0000901 default: llvm_unreachable("Invalid size for machine code value!");
902 case 1: OS << ".balign"; break;
903 case 2: OS << ".balignw"; break;
904 case 4: OS << ".balignl"; break;
905 case 8: llvm_unreachable("Unsupported alignment size!");
Daniel Dunbar71ea89d2009-06-24 19:25:34 +0000906 }
907
Chris Lattner37b72342009-08-19 06:12:02 +0000908 OS << ' ' << ByteAlignment;
Daniel Dunbar188e87f2009-06-25 21:03:18 +0000909 OS << ", " << truncateToSize(Value, ValueSize);
Jim Grosbach3bde49a2010-09-22 18:16:55 +0000910 if (MaxBytesToEmit)
Daniel Dunbar71ea89d2009-06-24 19:25:34 +0000911 OS << ", " << MaxBytesToEmit;
Chris Lattnercfa5ebc32010-01-22 07:36:39 +0000912 EmitEOL();
Daniel Dunbar71ea89d2009-06-24 19:25:34 +0000913}
914
Kevin Enderbye83d74f2010-02-23 18:26:34 +0000915void MCAsmStreamer::EmitCodeAlignment(unsigned ByteAlignment,
916 unsigned MaxBytesToEmit) {
Chris Lattnereebaf6a2010-02-23 18:44:31 +0000917 // Emit with a text fill value.
Bill Wendlingbc07a892013-06-18 07:20:20 +0000918 EmitValueToAlignment(ByteAlignment, MAI->getTextAlignFillValue(),
Chris Lattnereebaf6a2010-02-23 18:44:31 +0000919 1, MaxBytesToEmit);
Kevin Enderbye83d74f2010-02-23 18:26:34 +0000920}
921
Rafael Espindola7ae65d82015-11-04 23:59:18 +0000922void MCAsmStreamer::emitValueToOffset(const MCExpr *Offset,
Daniel Dunbar71ea89d2009-06-24 19:25:34 +0000923 unsigned char Value) {
924 // FIXME: Verify that Offset is associated with the current section.
Matt Arsenault8b643552015-06-09 00:31:39 +0000925 OS << ".org ";
926 Offset->print(OS, MAI);
927 OS << ", " << (unsigned)Value;
Chris Lattnercfa5ebc32010-01-22 07:36:39 +0000928 EmitEOL();
Daniel Dunbar71ea89d2009-06-24 19:25:34 +0000929}
930
Chris Lattner601ef332010-01-25 18:58:59 +0000931void MCAsmStreamer::EmitFileDirective(StringRef Filename) {
Bill Wendlingbc07a892013-06-18 07:20:20 +0000932 assert(MAI->hasSingleParameterDotFile());
Chris Lattner601ef332010-01-25 18:58:59 +0000933 OS << "\t.file\t";
934 PrintQuotedString(Filename, OS);
935 EmitEOL();
936}
937
David Blaikiec714ef42014-03-17 01:52:11 +0000938unsigned MCAsmStreamer::EmitDwarfFileDirective(unsigned FileNo,
939 StringRef Directory,
940 StringRef Filename,
941 unsigned CUID) {
David Blaikiec2df16b2014-03-17 18:13:58 +0000942 assert(CUID == 0);
943
944 MCDwarfLineTable &Table = getContext().getMCDwarfLineTable(CUID);
945 unsigned NumFiles = Table.getMCDwarfFiles().size();
946 FileNo = Table.getFile(Directory, Filename, FileNo);
947 if (FileNo == 0)
948 return 0;
949 if (NumFiles == Table.getMCDwarfFiles().size())
950 return FileNo;
951
952 SmallString<128> FullPathName;
953
Nick Lewycky40f8f2f2011-10-17 23:05:28 +0000954 if (!UseDwarfDirectory && !Directory.empty()) {
955 if (sys::path::is_absolute(Filename))
David Blaikiec2df16b2014-03-17 18:13:58 +0000956 Directory = "";
957 else {
958 FullPathName = Directory;
959 sys::path::append(FullPathName, Filename);
960 Directory = "";
961 Filename = FullPathName;
962 }
Nick Lewycky40f8f2f2011-10-17 23:05:28 +0000963 }
964
Rafael Espindolab4eec1d2014-02-05 18:00:21 +0000965 OS << "\t.file\t" << FileNo << ' ';
966 if (!Directory.empty()) {
967 PrintQuotedString(Directory, OS);
968 OS << ' ';
Rafael Espindolab58867c2010-11-19 02:26:16 +0000969 }
Rafael Espindolab4eec1d2014-02-05 18:00:21 +0000970 PrintQuotedString(Filename, OS);
971 EmitEOL();
Rafael Espindolab4eec1d2014-02-05 18:00:21 +0000972
David Blaikiec2df16b2014-03-17 18:13:58 +0000973 return FileNo;
Rafael Espindolac653a892010-11-16 21:20:32 +0000974}
975
976void MCAsmStreamer::EmitDwarfLocDirective(unsigned FileNo, unsigned Line,
977 unsigned Column, unsigned Flags,
978 unsigned Isa,
Devang Patel17740e72011-04-18 20:26:49 +0000979 unsigned Discriminator,
980 StringRef FileName) {
Rafael Espindolac653a892010-11-16 21:20:32 +0000981 OS << "\t.loc\t" << FileNo << " " << Line << " " << Column;
982 if (Flags & DWARF2_FLAG_BASIC_BLOCK)
983 OS << " basic_block";
984 if (Flags & DWARF2_FLAG_PROLOGUE_END)
985 OS << " prologue_end";
986 if (Flags & DWARF2_FLAG_EPILOGUE_BEGIN)
987 OS << " epilogue_begin";
988
989 unsigned OldFlags = getContext().getCurrentDwarfLoc().getFlags();
990 if ((Flags & DWARF2_FLAG_IS_STMT) != (OldFlags & DWARF2_FLAG_IS_STMT)) {
991 OS << " is_stmt ";
992
993 if (Flags & DWARF2_FLAG_IS_STMT)
994 OS << "1";
995 else
996 OS << "0";
997 }
998
999 if (Isa)
Diego Novillob1b50072014-02-13 20:05:03 +00001000 OS << " isa " << Isa;
Rafael Espindolac653a892010-11-16 21:20:32 +00001001 if (Discriminator)
Diego Novillob1b50072014-02-13 20:05:03 +00001002 OS << " discriminator " << Discriminator;
Devang Patel17740e72011-04-18 20:26:49 +00001003
1004 if (IsVerboseAsm) {
Bill Wendlingbc07a892013-06-18 07:20:20 +00001005 OS.PadToColumn(MAI->getCommentColumn());
1006 OS << MAI->getCommentString() << ' ' << FileName << ':'
Devang Patel17740e72011-04-18 20:26:49 +00001007 << Line << ':' << Column;
1008 }
Rafael Espindolac653a892010-11-16 21:20:32 +00001009 EmitEOL();
David Blaikieaeaa5bf2014-12-30 22:47:13 +00001010 this->MCStreamer::EmitDwarfLocDirective(FileNo, Line, Column, Flags,
1011 Isa, Discriminator, FileName);
Chris Lattner601ef332010-01-25 18:58:59 +00001012}
1013
David Blaikie34641612014-04-01 08:07:52 +00001014MCSymbol *MCAsmStreamer::getDwarfLineTableSymbol(unsigned CUID) {
1015 // Always use the zeroth line table, since asm syntax only supports one line
1016 // table for now.
1017 return MCStreamer::getDwarfLineTableSymbol(0);
1018}
1019
Reid Kleckner2214ed82016-01-29 00:49:42 +00001020unsigned MCAsmStreamer::EmitCVFileDirective(unsigned FileNo,
1021 StringRef Filename) {
1022 if (!getContext().getCVFile(Filename, FileNo))
1023 return 0;
1024
1025 OS << "\t.cv_file\t" << FileNo << ' ';
1026
1027 PrintQuotedString(Filename, OS);
1028 EmitEOL();
1029
1030 return FileNo;
1031}
1032
1033void MCAsmStreamer::EmitCVLocDirective(unsigned FunctionId, unsigned FileNo,
1034 unsigned Line, unsigned Column,
1035 bool PrologueEnd, bool IsStmt,
1036 StringRef FileName) {
1037 OS << "\t.cv_loc\t" << FunctionId << " " << FileNo << " " << Line << " "
1038 << Column;
1039 if (PrologueEnd)
1040 OS << " prologue_end";
1041
1042 unsigned OldIsStmt = getContext().getCurrentCVLoc().isStmt();
1043 if (IsStmt != OldIsStmt) {
1044 OS << " is_stmt ";
1045
1046 if (IsStmt)
1047 OS << "1";
1048 else
1049 OS << "0";
1050 }
1051
1052 if (IsVerboseAsm) {
1053 OS.PadToColumn(MAI->getCommentColumn());
1054 OS << MAI->getCommentString() << ' ' << FileName << ':'
1055 << Line << ':' << Column;
1056 }
1057 EmitEOL();
1058 this->MCStreamer::EmitCVLocDirective(FunctionId, FileNo, Line, Column,
1059 PrologueEnd, IsStmt, FileName);
1060}
1061
1062void MCAsmStreamer::EmitCVLinetableDirective(unsigned FunctionId,
1063 const MCSymbol *FnStart,
1064 const MCSymbol *FnEnd) {
1065 OS << "\t.cv_linetable\t" << FunctionId << ", ";
1066 FnStart->print(OS, MAI);
1067 OS << ", ";
1068 FnEnd->print(OS, MAI);
1069 EmitEOL();
1070 this->MCStreamer::EmitCVLinetableDirective(FunctionId, FnStart, FnEnd);
1071}
1072
David Majnemer6fcbd7e2016-01-29 19:24:12 +00001073void MCAsmStreamer::EmitCVInlineLinetableDirective(
1074 unsigned PrimaryFunctionId, unsigned SourceFileId, unsigned SourceLineNum,
David Majnemerc9911f22016-02-02 19:22:34 +00001075 const MCSymbol *FnStartSym, const MCSymbol *FnEndSym,
1076 ArrayRef<unsigned> SecondaryFunctionIds) {
David Majnemer6fcbd7e2016-01-29 19:24:12 +00001077 OS << "\t.cv_inline_linetable\t" << PrimaryFunctionId << ' ' << SourceFileId
Reid Kleckner1fcd6102016-02-02 17:41:18 +00001078 << ' ' << SourceLineNum << ' ';
1079 FnStartSym->print(OS, MAI);
David Majnemerc9911f22016-02-02 19:22:34 +00001080 OS << ' ';
1081 FnEndSym->print(OS, MAI);
David Majnemer6fcbd7e2016-01-29 19:24:12 +00001082 if (!SecondaryFunctionIds.empty()) {
1083 OS << " contains";
1084 for (unsigned SecondaryFunctionId : SecondaryFunctionIds)
1085 OS << ' ' << SecondaryFunctionId;
1086 }
1087 EmitEOL();
1088 this->MCStreamer::EmitCVInlineLinetableDirective(
David Majnemerc9911f22016-02-02 19:22:34 +00001089 PrimaryFunctionId, SourceFileId, SourceLineNum, FnStartSym, FnEndSym,
Reid Kleckner1fcd6102016-02-02 17:41:18 +00001090 SecondaryFunctionIds);
David Majnemer6fcbd7e2016-01-29 19:24:12 +00001091}
1092
David Majnemer408b5e62016-02-05 01:55:49 +00001093void MCAsmStreamer::EmitCVDefRangeDirective(
1094 ArrayRef<std::pair<const MCSymbol *, const MCSymbol *>> Ranges,
1095 StringRef FixedSizePortion) {
1096 OS << "\t.cv_def_range\t";
1097 for (std::pair<const MCSymbol *, const MCSymbol *> Range : Ranges) {
1098 OS << ' ';
1099 Range.first->print(OS, MAI);
1100 OS << ' ';
1101 Range.second->print(OS, MAI);
1102 }
1103 OS << ", ";
1104 PrintQuotedString(FixedSizePortion, OS);
1105 EmitEOL();
1106 this->MCStreamer::EmitCVDefRangeDirective(Ranges, FixedSizePortion);
1107}
1108
Reid Kleckner2214ed82016-01-29 00:49:42 +00001109void MCAsmStreamer::EmitCVStringTableDirective() {
1110 OS << "\t.cv_stringtable";
1111 EmitEOL();
1112}
1113
1114void MCAsmStreamer::EmitCVFileChecksumsDirective() {
1115 OS << "\t.cv_filechecksums";
1116 EmitEOL();
1117}
1118
Rafael Espindola5645bad2013-10-16 01:05:45 +00001119void MCAsmStreamer::EmitIdent(StringRef IdentString) {
1120 assert(MAI->hasIdentDirective() && ".ident directive not supported");
1121 OS << "\t.ident\t";
1122 PrintQuotedString(IdentString, OS);
1123 EmitEOL();
1124}
1125
Rafael Espindolaec53aa92011-05-10 13:39:48 +00001126void MCAsmStreamer::EmitCFISections(bool EH, bool Debug) {
1127 MCStreamer::EmitCFISections(EH, Debug);
Rafael Espindolaec53aa92011-05-10 13:39:48 +00001128 OS << "\t.cfi_sections ";
1129 if (EH) {
1130 OS << ".eh_frame";
1131 if (Debug)
1132 OS << ", .debug_frame";
1133 } else if (Debug) {
1134 OS << ".debug_frame";
1135 }
1136
1137 EmitEOL();
1138}
1139
Oliver Stannardcf6bfb12014-11-03 12:19:03 +00001140void MCAsmStreamer::EmitCFIStartProcImpl(MCDwarfFrameInfo &Frame) {
Anton Korobeynikove2bea1c2011-01-14 21:57:39 +00001141 OS << "\t.cfi_startproc";
David Majnemere035cf92014-01-27 17:20:25 +00001142 if (Frame.IsSimple)
1143 OS << " simple";
Rafael Espindola3c227b02010-11-22 14:27:24 +00001144 EmitEOL();
Rafael Espindola3c227b02010-11-22 14:27:24 +00001145}
1146
Rafael Espindolaf28213c2012-01-09 00:17:29 +00001147void MCAsmStreamer::EmitCFIEndProcImpl(MCDwarfFrameInfo &Frame) {
Rafael Espindola49bbfd02014-06-25 00:13:59 +00001148 MCStreamer::EmitCFIEndProcImpl(Frame);
Anton Korobeynikove2bea1c2011-01-14 21:57:39 +00001149 OS << "\t.cfi_endproc";
Rafael Espindola3c227b02010-11-22 14:27:24 +00001150 EmitEOL();
Rafael Espindola3c227b02010-11-22 14:27:24 +00001151}
1152
Rafael Espindola08600bc2011-05-30 20:20:15 +00001153void MCAsmStreamer::EmitRegisterName(int64_t Register) {
Rafael Espindola691a5ad2015-05-27 12:13:06 +00001154 if (!MAI->useDwarfRegNumForCFI()) {
Bill Wendlingbc07a892013-06-18 07:20:20 +00001155 const MCRegisterInfo *MRI = getContext().getRegisterInfo();
1156 unsigned LLVMRegister = MRI->getLLVMRegNum(Register, true);
Rafael Espindolad6860522011-06-02 02:34:55 +00001157 InstPrinter->printRegName(OS, LLVMRegister);
Rafael Espindola08600bc2011-05-30 20:20:15 +00001158 } else {
1159 OS << Register;
1160 }
1161}
1162
Rafael Espindola539d96f2011-04-12 23:59:07 +00001163void MCAsmStreamer::EmitCFIDefCfa(int64_t Register, int64_t Offset) {
Rafael Espindola6c961e12011-04-29 21:41:06 +00001164 MCStreamer::EmitCFIDefCfa(Register, Offset);
Rafael Espindola08600bc2011-05-30 20:20:15 +00001165 OS << "\t.cfi_def_cfa ";
1166 EmitRegisterName(Register);
1167 OS << ", " << Offset;
Rafael Espindola6c961e12011-04-29 21:41:06 +00001168 EmitEOL();
Rafael Espindola539d96f2011-04-12 23:59:07 +00001169}
1170
1171void MCAsmStreamer::EmitCFIDefCfaOffset(int64_t Offset) {
1172 MCStreamer::EmitCFIDefCfaOffset(Offset);
Anton Korobeynikove2bea1c2011-01-14 21:57:39 +00001173 OS << "\t.cfi_def_cfa_offset " << Offset;
Rafael Espindola3c227b02010-11-22 14:27:24 +00001174 EmitEOL();
Rafael Espindola3c227b02010-11-22 14:27:24 +00001175}
1176
Michael Kuperstein259f1502015-10-07 07:01:31 +00001177static void PrintCFIEscape(llvm::formatted_raw_ostream &OS, StringRef Values) {
1178 OS << "\t.cfi_escape ";
1179 if (!Values.empty()) {
1180 size_t e = Values.size() - 1;
1181 for (size_t i = 0; i < e; ++i)
1182 OS << format("0x%02x", uint8_t(Values[i])) << ", ";
1183 OS << format("0x%02x", uint8_t(Values[e]));
1184 }
1185}
1186
1187void MCAsmStreamer::EmitCFIEscape(StringRef Values) {
1188 MCStreamer::EmitCFIEscape(Values);
1189 PrintCFIEscape(OS, Values);
1190 EmitEOL();
1191}
1192
1193void MCAsmStreamer::EmitCFIGnuArgsSize(int64_t Size) {
1194 MCStreamer::EmitCFIGnuArgsSize(Size);
1195
1196 uint8_t Buffer[16] = { dwarf::DW_CFA_GNU_args_size };
1197 unsigned Len = encodeULEB128(Size, Buffer + 1) + 1;
1198
1199 PrintCFIEscape(OS, StringRef((const char *)&Buffer[0], Len));
1200 EmitEOL();
1201}
1202
Rafael Espindola539d96f2011-04-12 23:59:07 +00001203void MCAsmStreamer::EmitCFIDefCfaRegister(int64_t Register) {
1204 MCStreamer::EmitCFIDefCfaRegister(Register);
Rafael Espindola08600bc2011-05-30 20:20:15 +00001205 OS << "\t.cfi_def_cfa_register ";
1206 EmitRegisterName(Register);
Rafael Espindola3c227b02010-11-22 14:27:24 +00001207 EmitEOL();
Rafael Espindola3c227b02010-11-22 14:27:24 +00001208}
1209
Rafael Espindola539d96f2011-04-12 23:59:07 +00001210void MCAsmStreamer::EmitCFIOffset(int64_t Register, int64_t Offset) {
1211 this->MCStreamer::EmitCFIOffset(Register, Offset);
Rafael Espindola08600bc2011-05-30 20:20:15 +00001212 OS << "\t.cfi_offset ";
1213 EmitRegisterName(Register);
1214 OS << ", " << Offset;
Rafael Espindola3c227b02010-11-22 14:27:24 +00001215 EmitEOL();
Rafael Espindola3c227b02010-11-22 14:27:24 +00001216}
1217
Rafael Espindola539d96f2011-04-12 23:59:07 +00001218void MCAsmStreamer::EmitCFIPersonality(const MCSymbol *Sym,
Rafael Espindola2ac83552010-12-27 00:36:05 +00001219 unsigned Encoding) {
Rafael Espindola539d96f2011-04-12 23:59:07 +00001220 MCStreamer::EmitCFIPersonality(Sym, Encoding);
Matt Arsenault8b643552015-06-09 00:31:39 +00001221 OS << "\t.cfi_personality " << Encoding << ", ";
1222 Sym->print(OS, MAI);
Rafael Espindola3c227b02010-11-22 14:27:24 +00001223 EmitEOL();
Rafael Espindola3c227b02010-11-22 14:27:24 +00001224}
1225
Rafael Espindola539d96f2011-04-12 23:59:07 +00001226void MCAsmStreamer::EmitCFILsda(const MCSymbol *Sym, unsigned Encoding) {
1227 MCStreamer::EmitCFILsda(Sym, Encoding);
Matt Arsenault8b643552015-06-09 00:31:39 +00001228 OS << "\t.cfi_lsda " << Encoding << ", ";
1229 Sym->print(OS, MAI);
Rafael Espindola3c227b02010-11-22 14:27:24 +00001230 EmitEOL();
Rafael Espindola539d96f2011-04-12 23:59:07 +00001231}
Rafael Espindola3c227b02010-11-22 14:27:24 +00001232
Rafael Espindola539d96f2011-04-12 23:59:07 +00001233void MCAsmStreamer::EmitCFIRememberState() {
1234 MCStreamer::EmitCFIRememberState();
Rafael Espindola539d96f2011-04-12 23:59:07 +00001235 OS << "\t.cfi_remember_state";
1236 EmitEOL();
1237}
1238
1239void MCAsmStreamer::EmitCFIRestoreState() {
1240 MCStreamer::EmitCFIRestoreState();
Rafael Espindola539d96f2011-04-12 23:59:07 +00001241 OS << "\t.cfi_restore_state";
1242 EmitEOL();
1243}
1244
1245void MCAsmStreamer::EmitCFISameValue(int64_t Register) {
1246 MCStreamer::EmitCFISameValue(Register);
Rafael Espindola08600bc2011-05-30 20:20:15 +00001247 OS << "\t.cfi_same_value ";
1248 EmitRegisterName(Register);
Rafael Espindola539d96f2011-04-12 23:59:07 +00001249 EmitEOL();
1250}
1251
1252void MCAsmStreamer::EmitCFIRelOffset(int64_t Register, int64_t Offset) {
1253 MCStreamer::EmitCFIRelOffset(Register, Offset);
Rafael Espindola08600bc2011-05-30 20:20:15 +00001254 OS << "\t.cfi_rel_offset ";
1255 EmitRegisterName(Register);
1256 OS << ", " << Offset;
Rafael Espindola539d96f2011-04-12 23:59:07 +00001257 EmitEOL();
1258}
1259
1260void MCAsmStreamer::EmitCFIAdjustCfaOffset(int64_t Adjustment) {
1261 MCStreamer::EmitCFIAdjustCfaOffset(Adjustment);
Rafael Espindola539d96f2011-04-12 23:59:07 +00001262 OS << "\t.cfi_adjust_cfa_offset " << Adjustment;
1263 EmitEOL();
Rafael Espindola3c227b02010-11-22 14:27:24 +00001264}
1265
Rafael Espindola3c47e372012-01-23 21:51:52 +00001266void MCAsmStreamer::EmitCFISignalFrame() {
1267 MCStreamer::EmitCFISignalFrame();
Eric Christopher368461c2012-05-31 00:53:18 +00001268 OS << "\t.cfi_signal_frame";
Rafael Espindola3c47e372012-01-23 21:51:52 +00001269 EmitEOL();
1270}
1271
Rafael Espindola9bb24782012-11-23 16:59:41 +00001272void MCAsmStreamer::EmitCFIUndefined(int64_t Register) {
1273 MCStreamer::EmitCFIUndefined(Register);
Rafael Espindola9bb24782012-11-23 16:59:41 +00001274 OS << "\t.cfi_undefined " << Register;
1275 EmitEOL();
1276}
1277
Rafael Espindolacdb9a532012-11-25 15:14:49 +00001278void MCAsmStreamer::EmitCFIRegister(int64_t Register1, int64_t Register2) {
1279 MCStreamer::EmitCFIRegister(Register1, Register2);
Rafael Espindolacdb9a532012-11-25 15:14:49 +00001280 OS << "\t.cfi_register " << Register1 << ", " << Register2;
1281 EmitEOL();
1282}
1283
Venkatraman Govindaraju3816d432013-09-26 14:49:40 +00001284void MCAsmStreamer::EmitCFIWindowSave() {
1285 MCStreamer::EmitCFIWindowSave();
Venkatraman Govindaraju3816d432013-09-26 14:49:40 +00001286 OS << "\t.cfi_window_save";
1287 EmitEOL();
1288}
1289
Saleem Abdulrasool7206a522014-06-29 01:52:01 +00001290void MCAsmStreamer::EmitWinCFIStartProc(const MCSymbol *Symbol) {
1291 MCStreamer::EmitWinCFIStartProc(Symbol);
Charles Davis9a115a42011-05-20 18:19:22 +00001292
Matt Arsenault8b643552015-06-09 00:31:39 +00001293 OS << ".seh_proc ";
1294 Symbol->print(OS, MAI);
Charles Davis8d9c9902011-05-18 04:58:05 +00001295 EmitEOL();
1296}
1297
Saleem Abdulrasool7206a522014-06-29 01:52:01 +00001298void MCAsmStreamer::EmitWinCFIEndProc() {
1299 MCStreamer::EmitWinCFIEndProc();
Charles Davis9a115a42011-05-20 18:19:22 +00001300
Charles Davis4cd88562011-05-19 17:46:39 +00001301 OS << "\t.seh_endproc";
Charles Davis8d9c9902011-05-18 04:58:05 +00001302 EmitEOL();
1303}
1304
Saleem Abdulrasool7206a522014-06-29 01:52:01 +00001305void MCAsmStreamer::EmitWinCFIStartChained() {
1306 MCStreamer::EmitWinCFIStartChained();
Charles Davis9a115a42011-05-20 18:19:22 +00001307
Charles Davis4cd88562011-05-19 17:46:39 +00001308 OS << "\t.seh_startchained";
Charles Davis77e06102011-05-18 20:54:10 +00001309 EmitEOL();
1310}
1311
Saleem Abdulrasool7206a522014-06-29 01:52:01 +00001312void MCAsmStreamer::EmitWinCFIEndChained() {
1313 MCStreamer::EmitWinCFIEndChained();
Charles Davis9a115a42011-05-20 18:19:22 +00001314
Charles Davis4cd88562011-05-19 17:46:39 +00001315 OS << "\t.seh_endchained";
Charles Davis77e06102011-05-18 20:54:10 +00001316 EmitEOL();
1317}
1318
Saleem Abdulrasool7206a522014-06-29 01:52:01 +00001319void MCAsmStreamer::EmitWinEHHandler(const MCSymbol *Sym, bool Unwind,
1320 bool Except) {
1321 MCStreamer::EmitWinEHHandler(Sym, Unwind, Except);
Charles Davis9a115a42011-05-20 18:19:22 +00001322
Matt Arsenault8b643552015-06-09 00:31:39 +00001323 OS << "\t.seh_handler ";
1324 Sym->print(OS, MAI);
Charles Davis4cd88562011-05-19 17:46:39 +00001325 if (Unwind)
1326 OS << ", @unwind";
1327 if (Except)
1328 OS << ", @except";
Charles Davis77e06102011-05-18 20:54:10 +00001329 EmitEOL();
1330}
1331
Saleem Abdulrasool7206a522014-06-29 01:52:01 +00001332void MCAsmStreamer::EmitWinEHHandlerData() {
1333 MCStreamer::EmitWinEHHandlerData();
Charles Davis9a115a42011-05-20 18:19:22 +00001334
Charles Davis2f6ecea2011-05-25 21:43:45 +00001335 // Switch sections. Don't call SwitchSection directly, because that will
1336 // cause the section switch to be visible in the emitted assembly.
1337 // We only do this so the section switch that terminates the handler
1338 // data block is visible.
Saleem Abdulrasoolb3be7372014-08-03 18:51:17 +00001339 WinEH::FrameInfo *CurFrame = getCurrentWinFrameInfo();
Reid Kleckner97837b72016-05-02 23:22:18 +00001340 MCSection *TextSec = &CurFrame->Function->getSection();
1341 MCSection *XData = getAssociatedXDataSection(TextSec);
Reid Kleckner1d3d4ad2015-05-29 17:00:57 +00001342 SwitchSectionNoChange(XData);
Charles Davis2f6ecea2011-05-25 21:43:45 +00001343
Charles Davis4cd88562011-05-19 17:46:39 +00001344 OS << "\t.seh_handlerdata";
Charles Davis77e06102011-05-18 20:54:10 +00001345 EmitEOL();
1346}
1347
Saleem Abdulrasool7206a522014-06-29 01:52:01 +00001348void MCAsmStreamer::EmitWinCFIPushReg(unsigned Register) {
1349 MCStreamer::EmitWinCFIPushReg(Register);
Charles Davis9a115a42011-05-20 18:19:22 +00001350
Reid Klecknerb01961c2014-06-10 20:16:36 +00001351 OS << "\t.seh_pushreg " << Register;
Charles Davis8d9c9902011-05-18 04:58:05 +00001352 EmitEOL();
1353}
1354
Saleem Abdulrasool7206a522014-06-29 01:52:01 +00001355void MCAsmStreamer::EmitWinCFISetFrame(unsigned Register, unsigned Offset) {
1356 MCStreamer::EmitWinCFISetFrame(Register, Offset);
Charles Davis9a115a42011-05-20 18:19:22 +00001357
Reid Klecknerb01961c2014-06-10 20:16:36 +00001358 OS << "\t.seh_setframe " << Register << ", " << Offset;
Charles Davis8d9c9902011-05-18 04:58:05 +00001359 EmitEOL();
1360}
1361
Saleem Abdulrasool7206a522014-06-29 01:52:01 +00001362void MCAsmStreamer::EmitWinCFIAllocStack(unsigned Size) {
1363 MCStreamer::EmitWinCFIAllocStack(Size);
Charles Davis9a115a42011-05-20 18:19:22 +00001364
Charles Davis4cd88562011-05-19 17:46:39 +00001365 OS << "\t.seh_stackalloc " << Size;
Charles Davis8d9c9902011-05-18 04:58:05 +00001366 EmitEOL();
1367}
1368
Saleem Abdulrasool7206a522014-06-29 01:52:01 +00001369void MCAsmStreamer::EmitWinCFISaveReg(unsigned Register, unsigned Offset) {
1370 MCStreamer::EmitWinCFISaveReg(Register, Offset);
Charles Davis9a115a42011-05-20 18:19:22 +00001371
Reid Klecknerb01961c2014-06-10 20:16:36 +00001372 OS << "\t.seh_savereg " << Register << ", " << Offset;
Charles Davis4cd88562011-05-19 17:46:39 +00001373 EmitEOL();
1374}
1375
Saleem Abdulrasool7206a522014-06-29 01:52:01 +00001376void MCAsmStreamer::EmitWinCFISaveXMM(unsigned Register, unsigned Offset) {
1377 MCStreamer::EmitWinCFISaveXMM(Register, Offset);
Charles Davis9a115a42011-05-20 18:19:22 +00001378
Reid Klecknerb01961c2014-06-10 20:16:36 +00001379 OS << "\t.seh_savexmm " << Register << ", " << Offset;
Charles Davis8d9c9902011-05-18 04:58:05 +00001380 EmitEOL();
1381}
1382
Saleem Abdulrasool7206a522014-06-29 01:52:01 +00001383void MCAsmStreamer::EmitWinCFIPushFrame(bool Code) {
1384 MCStreamer::EmitWinCFIPushFrame(Code);
Charles Davis9a115a42011-05-20 18:19:22 +00001385
Charles Davis4cd88562011-05-19 17:46:39 +00001386 OS << "\t.seh_pushframe";
Charles Davis8d9c9902011-05-18 04:58:05 +00001387 if (Code)
Charles Davis4cd88562011-05-19 17:46:39 +00001388 OS << " @code";
Charles Davis8d9c9902011-05-18 04:58:05 +00001389 EmitEOL();
1390}
1391
Eugene Zelenkoffec81c2015-11-04 22:32:32 +00001392void MCAsmStreamer::EmitWinCFIEndProlog() {
Saleem Abdulrasool7206a522014-06-29 01:52:01 +00001393 MCStreamer::EmitWinCFIEndProlog();
Charles Davis9a115a42011-05-20 18:19:22 +00001394
Charles Davis4cd88562011-05-19 17:46:39 +00001395 OS << "\t.seh_endprologue";
Charles Davis8d9c9902011-05-18 04:58:05 +00001396 EmitEOL();
1397}
1398
David Woodhouse9784cef2014-01-28 23:13:07 +00001399void MCAsmStreamer::AddEncodingComment(const MCInst &Inst,
1400 const MCSubtargetInfo &STI) {
Daniel Dunbar9a0a4612010-02-09 23:00:14 +00001401 raw_ostream &OS = GetCommentOS();
1402 SmallString<256> Code;
1403 SmallVector<MCFixup, 4> Fixups;
Alp Tokere69170a2014-06-26 22:52:05 +00001404 raw_svector_ostream VecOS(Code);
Jim Grosbach91df21f2015-05-15 19:13:16 +00001405 Emitter->encodeInstruction(Inst, VecOS, Fixups, STI);
Chris Lattner601ef332010-01-25 18:58:59 +00001406
Daniel Dunbar9a0a4612010-02-09 23:00:14 +00001407 // If we are showing fixups, create symbolic markers in the encoded
1408 // representation. We do this by making a per-bit map to the fixup item index,
1409 // then trying to display it as nicely as possible.
Daniel Dunbar75c9a4e2010-02-10 01:41:14 +00001410 SmallVector<uint8_t, 64> FixupMap;
1411 FixupMap.resize(Code.size() * 8);
Daniel Dunbar9a0a4612010-02-09 23:00:14 +00001412 for (unsigned i = 0, e = Code.size() * 8; i != e; ++i)
1413 FixupMap[i] = 0;
1414
1415 for (unsigned i = 0, e = Fixups.size(); i != e; ++i) {
1416 MCFixup &F = Fixups[i];
Daniel Dunbar0c9d9fd2010-12-16 03:20:06 +00001417 const MCFixupKindInfo &Info = AsmBackend->getFixupKindInfo(F.getKind());
Daniel Dunbar9a0a4612010-02-09 23:00:14 +00001418 for (unsigned j = 0; j != Info.TargetSize; ++j) {
1419 unsigned Index = F.getOffset() * 8 + Info.TargetOffset + j;
1420 assert(Index < Code.size() * 8 && "Invalid offset in fixup!");
1421 FixupMap[Index] = 1 + i;
1422 }
1423 }
1424
Evan Cheng15bc70f2011-07-08 22:49:42 +00001425 // FIXME: Note the fixup comments for Thumb2 are completely bogus since the
Evan Cheng52899a92011-01-13 23:27:39 +00001426 // high order halfword of a 32-bit Thumb2 instruction is emitted first.
Daniel Dunbar9a0a4612010-02-09 23:00:14 +00001427 OS << "encoding: [";
1428 for (unsigned i = 0, e = Code.size(); i != e; ++i) {
1429 if (i)
1430 OS << ',';
1431
1432 // See if all bits are the same map entry.
1433 uint8_t MapEntry = FixupMap[i * 8 + 0];
1434 for (unsigned j = 1; j != 8; ++j) {
1435 if (FixupMap[i * 8 + j] == MapEntry)
1436 continue;
1437
1438 MapEntry = uint8_t(~0U);
1439 break;
1440 }
1441
1442 if (MapEntry != uint8_t(~0U)) {
1443 if (MapEntry == 0) {
1444 OS << format("0x%02x", uint8_t(Code[i]));
1445 } else {
Evan Cheng0447d302011-01-13 21:45:26 +00001446 if (Code[i]) {
Evan Cheng52899a92011-01-13 23:27:39 +00001447 // FIXME: Some of the 8 bits require fix up.
Evan Cheng0447d302011-01-13 21:45:26 +00001448 OS << format("0x%02x", uint8_t(Code[i])) << '\''
1449 << char('A' + MapEntry - 1) << '\'';
1450 } else
1451 OS << char('A' + MapEntry - 1);
Daniel Dunbar9a0a4612010-02-09 23:00:14 +00001452 }
1453 } else {
1454 // Otherwise, write out in binary.
1455 OS << "0b";
Jay Foad61ea0e42011-06-23 09:09:15 +00001456 for (unsigned j = 8; j--;) {
Daniel Dunbar9a0a4612010-02-09 23:00:14 +00001457 unsigned Bit = (Code[i] >> j) & 1;
NAKAMURA Takumiaf669802011-03-27 01:44:40 +00001458
Chris Lattner9e7d8c02010-11-15 05:56:19 +00001459 unsigned FixupBit;
Bill Wendlingbc07a892013-06-18 07:20:20 +00001460 if (MAI->isLittleEndian())
Chris Lattner9e7d8c02010-11-15 05:56:19 +00001461 FixupBit = i * 8 + j;
1462 else
1463 FixupBit = i * 8 + (7-j);
NAKAMURA Takumiaf669802011-03-27 01:44:40 +00001464
Jay Foad61ea0e42011-06-23 09:09:15 +00001465 if (uint8_t MapEntry = FixupMap[FixupBit]) {
1466 assert(Bit == 0 && "Encoder wrote into fixed up bit!");
1467 OS << char('A' + MapEntry - 1);
Daniel Dunbar9a0a4612010-02-09 23:00:14 +00001468 } else
1469 OS << Bit;
1470 }
1471 }
1472 }
1473 OS << "]\n";
1474
1475 for (unsigned i = 0, e = Fixups.size(); i != e; ++i) {
1476 MCFixup &F = Fixups[i];
Daniel Dunbar0c9d9fd2010-12-16 03:20:06 +00001477 const MCFixupKindInfo &Info = AsmBackend->getFixupKindInfo(F.getKind());
Daniel Dunbar9a0a4612010-02-09 23:00:14 +00001478 OS << " fixup " << char('A' + i) << " - " << "offset: " << F.getOffset()
Daniel Dunbar60547442010-02-10 04:47:08 +00001479 << ", value: " << *F.getValue() << ", kind: " << Info.Name << "\n";
Daniel Dunbar9a0a4612010-02-09 23:00:14 +00001480 }
1481}
1482
David Woodhousee6c13e42014-01-28 23:12:42 +00001483void MCAsmStreamer::EmitInstruction(const MCInst &Inst, const MCSubtargetInfo &STI) {
Peter Collingbourne2f495b92013-04-17 21:18:16 +00001484 assert(getCurrentSection().first &&
1485 "Cannot emit contents before setting section!");
Daniel Dunbar9a0a4612010-02-09 23:00:14 +00001486
1487 // Show the encoding in a comment if we have a code emitter.
1488 if (Emitter)
David Woodhouse9784cef2014-01-28 23:13:07 +00001489 AddEncodingComment(Inst, STI);
Daniel Dunbar9a0a4612010-02-09 23:00:14 +00001490
Chris Lattner89261502010-02-09 00:54:51 +00001491 // Show the MCInst if enabled.
Daniel Dunbar3627af52010-05-26 15:18:13 +00001492 if (ShowInst) {
Sean Silva0e1fe182015-02-05 00:58:51 +00001493 Inst.dump_pretty(GetCommentOS(), InstPrinter.get(), "\n ");
Daniel Dunbar3627af52010-05-26 15:18:13 +00001494 GetCommentOS() << "\n";
1495 }
1496
Colin LeMahieu48a9b712015-06-18 20:43:22 +00001497 if(getTargetStreamer())
1498 getTargetStreamer()->prettyPrintAsm(*InstPrinter, OS, Inst, STI);
1499 else
1500 InstPrinter->printInst(&Inst, OS, "", STI);
Rafael Espindola691a5ad2015-05-27 12:13:06 +00001501
Chris Lattnercfa5ebc32010-01-22 07:36:39 +00001502 EmitEOL();
Daniel Dunbar9faf2732009-06-24 01:03:06 +00001503}
1504
Eli Benderskyf483ff92012-12-20 19:05:53 +00001505void MCAsmStreamer::EmitBundleAlignMode(unsigned AlignPow2) {
1506 OS << "\t.bundle_align_mode " << AlignPow2;
1507 EmitEOL();
1508}
1509
Eli Bendersky802b6282013-01-07 21:51:08 +00001510void MCAsmStreamer::EmitBundleLock(bool AlignToEnd) {
Eli Benderskyf483ff92012-12-20 19:05:53 +00001511 OS << "\t.bundle_lock";
Eli Bendersky802b6282013-01-07 21:51:08 +00001512 if (AlignToEnd)
1513 OS << " align_to_end";
Eli Benderskyf483ff92012-12-20 19:05:53 +00001514 EmitEOL();
1515}
1516
1517void MCAsmStreamer::EmitBundleUnlock() {
1518 OS << "\t.bundle_unlock";
1519 EmitEOL();
1520}
1521
Daniel Sanders9f6ad492015-11-12 13:33:00 +00001522bool MCAsmStreamer::EmitRelocDirective(const MCExpr &Offset, StringRef Name,
1523 const MCExpr *Expr, SMLoc) {
1524 OS << "\t.reloc ";
1525 Offset.print(OS, MAI);
1526 OS << ", " << Name;
1527 if (Expr) {
1528 OS << ", ";
1529 Expr->print(OS, MAI);
1530 }
1531 EmitEOL();
1532 return false;
1533}
1534
Jim Grosbach6ebd7282010-09-22 18:18:30 +00001535/// EmitRawText - If this file is backed by an assembly streamer, this dumps
Chris Lattner8a87fb72010-04-03 21:35:55 +00001536/// the specified string in the output .s file. This capability is
1537/// indicated by the hasRawTextSupport() predicate.
David Blaikied8c5b4e2013-10-24 22:43:10 +00001538void MCAsmStreamer::EmitRawTextImpl(StringRef String) {
Chris Lattneraca014e2010-04-03 22:06:56 +00001539 if (!String.empty() && String.back() == '\n')
1540 String = String.substr(0, String.size()-1);
Chris Lattner8a87fb72010-04-03 21:35:55 +00001541 OS << String;
Chris Lattneraca014e2010-04-03 22:06:56 +00001542 EmitEOL();
Chris Lattner8a87fb72010-04-03 21:35:55 +00001543}
1544
Rafael Espindola07082092012-01-07 03:13:18 +00001545void MCAsmStreamer::FinishImpl() {
Kevin Enderbye7739d42011-12-09 18:09:40 +00001546 // If we are generating dwarf for assembly source files dump out the sections.
1547 if (getContext().getGenDwarfForAssembly())
David Blaikie8bf66c42014-04-01 07:35:52 +00001548 MCGenDwarfInfo::Emit(this);
1549
1550 // Emit the label for the line table, if requested - since the rest of the
1551 // line table will be defined by .loc/.file directives, and not emitted
1552 // directly, the label is the only work required here.
1553 auto &Tables = getContext().getMCDwarfLineTables();
1554 if (!Tables.empty()) {
David Blaikie34641612014-04-01 08:07:52 +00001555 assert(Tables.size() == 1 && "asm output only supports one line table");
David Blaikie8bf66c42014-04-01 07:35:52 +00001556 if (auto *Label = Tables.begin()->second.getLabel()) {
1557 SwitchSection(getContext().getObjectFileInfo()->getDwarfLineSection());
1558 EmitLabel(Label);
1559 }
1560 }
Daniel Dunbar9faf2732009-06-24 01:03:06 +00001561}
Bill Wendling550c76d2013-09-09 19:48:37 +00001562
Chris Lattner38e92192010-01-22 07:29:22 +00001563MCStreamer *llvm::createAsmStreamer(MCContext &Context,
Rafael Espindola5682ce22015-04-09 21:06:08 +00001564 std::unique_ptr<formatted_raw_ostream> OS,
Rafael Espindola566fcfe2014-05-07 13:00:43 +00001565 bool isVerboseAsm, bool useDwarfDirectory,
1566 MCInstPrinter *IP, MCCodeEmitter *CE,
1567 MCAsmBackend *MAB, bool ShowInst) {
Rafael Espindola5682ce22015-04-09 21:06:08 +00001568 return new MCAsmStreamer(Context, std::move(OS), isVerboseAsm,
1569 useDwarfDirectory, IP, CE, MAB, ShowInst);
Daniel Dunbar9faf2732009-06-24 01:03:06 +00001570}