Eugene Zelenko | ffec81c | 2015-11-04 22:32:32 +0000 | [diff] [blame] | 1 | //===- lib/MC/MCAsmStreamer.cpp - Text Assembly Output ----------*- C++ -*-===// |
Daniel Dunbar | 9faf273 | 2009-06-24 01:03:06 +0000 | [diff] [blame] | 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 | |
David Blaikie | 293a2a3 | 2014-04-24 14:33:36 +0000 | [diff] [blame] | 10 | #include "llvm/ADT/STLExtras.h" |
Chandler Carruth | d990388 | 2015-01-14 11:23:27 +0000 | [diff] [blame] | 11 | #include "llvm/ADT/SmallString.h" |
Chandler Carruth | ed0881b | 2012-12-03 16:50:05 +0000 | [diff] [blame] | 12 | #include "llvm/ADT/StringExtras.h" |
| 13 | #include "llvm/ADT/Twine.h" |
| 14 | #include "llvm/MC/MCAsmBackend.h" |
Daniel Dunbar | 73da11e | 2009-08-31 08:08:38 +0000 | [diff] [blame] | 15 | #include "llvm/MC/MCAsmInfo.h" |
Daniel Dunbar | 6510517 | 2009-08-27 00:51:57 +0000 | [diff] [blame] | 16 | #include "llvm/MC/MCCodeEmitter.h" |
Daniel Dunbar | 9faf273 | 2009-06-24 01:03:06 +0000 | [diff] [blame] | 17 | #include "llvm/MC/MCContext.h" |
Daniel Dunbar | 73da11e | 2009-08-31 08:08:38 +0000 | [diff] [blame] | 18 | #include "llvm/MC/MCExpr.h" |
Daniel Dunbar | 0c9d9fd | 2010-12-16 03:20:06 +0000 | [diff] [blame] | 19 | #include "llvm/MC/MCFixupKindInfo.h" |
Daniel Dunbar | 23a72aa | 2009-07-01 06:35:03 +0000 | [diff] [blame] | 20 | #include "llvm/MC/MCInst.h" |
Chris Lattner | 11b2fc9 | 2009-09-14 03:02:37 +0000 | [diff] [blame] | 21 | #include "llvm/MC/MCInstPrinter.h" |
Evan Cheng | 2833ad1 | 2011-07-26 20:57:44 +0000 | [diff] [blame] | 22 | #include "llvm/MC/MCObjectFileInfo.h" |
Evan Cheng | d60fa58b | 2011-07-18 20:57:22 +0000 | [diff] [blame] | 23 | #include "llvm/MC/MCRegisterInfo.h" |
Evan Cheng | 7679299 | 2011-07-20 05:58:47 +0000 | [diff] [blame] | 24 | #include "llvm/MC/MCSectionCOFF.h" |
Chris Lattner | 6c20391 | 2009-08-10 18:15:01 +0000 | [diff] [blame] | 25 | #include "llvm/MC/MCSectionMachO.h" |
Mehdi Amini | b550cb1 | 2016-04-18 09:17:29 +0000 | [diff] [blame] | 26 | #include "llvm/MC/MCStreamer.h" |
Rafael Espindola | a869576 | 2015-06-02 00:25:12 +0000 | [diff] [blame] | 27 | #include "llvm/MC/MCSymbolELF.h" |
Torok Edwin | 56d0659 | 2009-07-11 20:10:48 +0000 | [diff] [blame] | 28 | #include "llvm/Support/ErrorHandling.h" |
Daniel Dunbar | 6510517 | 2009-08-27 00:51:57 +0000 | [diff] [blame] | 29 | #include "llvm/Support/Format.h" |
Chris Lattner | 38e9219 | 2010-01-22 07:29:22 +0000 | [diff] [blame] | 30 | #include "llvm/Support/FormattedStream.h" |
Michael Kuperstein | 259f150 | 2015-10-07 07:01:31 +0000 | [diff] [blame] | 31 | #include "llvm/Support/LEB128.h" |
Chandler Carruth | ed0881b | 2012-12-03 16:50:05 +0000 | [diff] [blame] | 32 | #include "llvm/Support/MathExtras.h" |
Rafael Espindola | 3bc8e71 | 2013-06-11 22:21:28 +0000 | [diff] [blame] | 33 | #include "llvm/Support/Path.h" |
Petr Hosek | 67a94a7 | 2016-05-28 05:57:48 +0000 | [diff] [blame] | 34 | #include "llvm/Support/SourceMgr.h" |
Nick Lewycky | 0de20af | 2010-12-19 20:43:38 +0000 | [diff] [blame] | 35 | #include <cctype> |
Eugene Zelenko | ffec81c | 2015-11-04 22:32:32 +0000 | [diff] [blame] | 36 | |
Daniel Dunbar | 9faf273 | 2009-06-24 01:03:06 +0000 | [diff] [blame] | 37 | using namespace llvm; |
| 38 | |
| 39 | namespace { |
| 40 | |
Rafael Espindola | 3e608b0 | 2015-04-09 13:04:20 +0000 | [diff] [blame] | 41 | class MCAsmStreamer final : public MCStreamer { |
Rafael Espindola | 5682ce2 | 2015-04-09 21:06:08 +0000 | [diff] [blame] | 42 | std::unique_ptr<formatted_raw_ostream> OSOwner; |
Chris Lattner | 38e9219 | 2010-01-22 07:29:22 +0000 | [diff] [blame] | 43 | formatted_raw_ostream &OS; |
Bill Wendling | bc07a89 | 2013-06-18 07:20:20 +0000 | [diff] [blame] | 44 | const MCAsmInfo *MAI; |
Ahmed Charles | 56440fd | 2014-03-06 05:51:42 +0000 | [diff] [blame] | 45 | std::unique_ptr<MCInstPrinter> InstPrinter; |
| 46 | std::unique_ptr<MCCodeEmitter> Emitter; |
| 47 | std::unique_ptr<MCAsmBackend> AsmBackend; |
Jim Grosbach | 3bde49a | 2010-09-22 18:16:55 +0000 | [diff] [blame] | 48 | |
Chris Lattner | 38e9219 | 2010-01-22 07:29:22 +0000 | [diff] [blame] | 49 | SmallString<128> CommentToEmit; |
Chris Lattner | 8fa0e35 | 2010-01-22 19:17:48 +0000 | [diff] [blame] | 50 | raw_svector_ostream CommentStream; |
Daniel Dunbar | e3ee332 | 2010-02-03 18:18:30 +0000 | [diff] [blame] | 51 | |
Daniel Dunbar | e3ee332 | 2010-02-03 18:18:30 +0000 | [diff] [blame] | 52 | unsigned IsVerboseAsm : 1; |
| 53 | unsigned ShowInst : 1; |
Nick Lewycky | 40f8f2f | 2011-10-17 23:05:28 +0000 | [diff] [blame] | 54 | unsigned UseDwarfDirectory : 1; |
Daniel Dunbar | e3ee332 | 2010-02-03 18:18:30 +0000 | [diff] [blame] | 55 | |
Rafael Espindola | 08600bc | 2011-05-30 20:20:15 +0000 | [diff] [blame] | 56 | void EmitRegisterName(int64_t Register); |
Oliver Stannard | cf6bfb1 | 2014-11-03 12:19:03 +0000 | [diff] [blame] | 57 | void EmitCFIStartProcImpl(MCDwarfFrameInfo &Frame) override; |
Craig Topper | 34a61bc | 2014-03-08 07:02:02 +0000 | [diff] [blame] | 58 | void EmitCFIEndProcImpl(MCDwarfFrameInfo &Frame) override; |
Rafael Espindola | 08600bc | 2011-05-30 20:20:15 +0000 | [diff] [blame] | 59 | |
Chris Lattner | 962c5bd8 | 2009-08-17 04:17:34 +0000 | [diff] [blame] | 60 | public: |
Rafael Espindola | 5682ce2 | 2015-04-09 21:06:08 +0000 | [diff] [blame] | 61 | MCAsmStreamer(MCContext &Context, std::unique_ptr<formatted_raw_ostream> os, |
Rafael Espindola | 883cf7e6 | 2014-05-12 13:07:11 +0000 | [diff] [blame] | 62 | bool isVerboseAsm, bool useDwarfDirectory, |
Rafael Espindola | b4eec1d | 2014-02-05 18:00:21 +0000 | [diff] [blame] | 63 | MCInstPrinter *printer, MCCodeEmitter *emitter, |
| 64 | MCAsmBackend *asmbackend, bool showInst) |
Rafael Espindola | 5682ce2 | 2015-04-09 21:06:08 +0000 | [diff] [blame] | 65 | : 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 Espindola | 691a5ad | 2015-05-27 12:13:06 +0000 | [diff] [blame] | 70 | assert(InstPrinter); |
| 71 | if (IsVerboseAsm) |
| 72 | InstPrinter->setCommentStream(CommentStream); |
Chris Lattner | 482bf69 | 2010-02-10 00:10:18 +0000 | [diff] [blame] | 73 | } |
Daniel Dunbar | 9faf273 | 2009-06-24 01:03:06 +0000 | [diff] [blame] | 74 | |
Chris Lattner | 38e9219 | 2010-01-22 07:29:22 +0000 | [diff] [blame] | 75 | inline void EmitEOL() { |
Chris Lattner | 8fa0e35 | 2010-01-22 19:17:48 +0000 | [diff] [blame] | 76 | // If we don't have any comments, just emit a \n. |
| 77 | if (!IsVerboseAsm) { |
Chris Lattner | 38e9219 | 2010-01-22 07:29:22 +0000 | [diff] [blame] | 78 | OS << '\n'; |
| 79 | return; |
| 80 | } |
| 81 | EmitCommentsAndEOL(); |
| 82 | } |
Michael Kuperstein | 23d952b | 2015-07-22 10:49:44 +0000 | [diff] [blame] | 83 | |
Chandler Carruth | 6fb9c08 | 2015-07-22 11:22:29 +0000 | [diff] [blame] | 84 | void EmitSyntaxDirective() override; |
Michael Kuperstein | 23d952b | 2015-07-22 10:49:44 +0000 | [diff] [blame] | 85 | |
Chris Lattner | 38e9219 | 2010-01-22 07:29:22 +0000 | [diff] [blame] | 86 | void EmitCommentsAndEOL(); |
Chris Lattner | b0d44c3 | 2010-02-02 23:37:42 +0000 | [diff] [blame] | 87 | |
| 88 | /// isVerboseAsm - Return true if this streamer supports verbose assembly at |
| 89 | /// all. |
Craig Topper | 34a61bc | 2014-03-08 07:02:02 +0000 | [diff] [blame] | 90 | bool isVerboseAsm() const override { return IsVerboseAsm; } |
Jim Grosbach | 3bde49a | 2010-09-22 18:16:55 +0000 | [diff] [blame] | 91 | |
Chris Lattner | 8a87fb7 | 2010-04-03 21:35:55 +0000 | [diff] [blame] | 92 | /// hasRawTextSupport - We support EmitRawText. |
Craig Topper | 34a61bc | 2014-03-08 07:02:02 +0000 | [diff] [blame] | 93 | bool hasRawTextSupport() const override { return true; } |
Daniel Dunbar | 9a0a461 | 2010-02-09 23:00:14 +0000 | [diff] [blame] | 94 | |
Chris Lattner | e1d8a31 | 2010-01-22 18:21:35 +0000 | [diff] [blame] | 95 | /// AddComment - Add a comment that can be emitted to the generated .s |
Chris Lattner | 38e9219 | 2010-01-22 07:29:22 +0000 | [diff] [blame] | 96 | /// 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 Topper | 34a61bc | 2014-03-08 07:02:02 +0000 | [diff] [blame] | 99 | void AddComment(const Twine &T) override; |
Daniel Dunbar | 9a0a461 | 2010-02-09 23:00:14 +0000 | [diff] [blame] | 100 | |
| 101 | /// AddEncodingComment - Add a comment showing the encoding of an instruction. |
Craig Topper | 12f0ca4 | 2014-03-08 07:07:08 +0000 | [diff] [blame] | 102 | void AddEncodingComment(const MCInst &Inst, const MCSubtargetInfo &); |
Daniel Dunbar | 9a0a461 | 2010-02-09 23:00:14 +0000 | [diff] [blame] | 103 | |
Chris Lattner | 8fa0e35 | 2010-01-22 19:17:48 +0000 | [diff] [blame] | 104 | /// 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 Topper | 34a61bc | 2014-03-08 07:02:02 +0000 | [diff] [blame] | 107 | raw_ostream &GetCommentOS() override { |
Chris Lattner | 8fa0e35 | 2010-01-22 19:17:48 +0000 | [diff] [blame] | 108 | if (!IsVerboseAsm) |
| 109 | return nulls(); // Discard comments unless in verbose asm mode. |
| 110 | return CommentStream; |
| 111 | } |
Daniel Dunbar | 9a0a461 | 2010-02-09 23:00:14 +0000 | [diff] [blame] | 112 | |
Craig Topper | 7315602 | 2014-03-02 09:09:27 +0000 | [diff] [blame] | 113 | void emitRawComment(const Twine &T, bool TabPrefix = true) override; |
Rafael Espindola | 0b69481 | 2014-01-16 16:28:37 +0000 | [diff] [blame] | 114 | |
Chris Lattner | a3eee3c | 2010-01-22 19:52:01 +0000 | [diff] [blame] | 115 | /// AddBlankLine - Emit a blank line to a .s file to pretty it up. |
Craig Topper | 34a61bc | 2014-03-08 07:02:02 +0000 | [diff] [blame] | 116 | void AddBlankLine() override { |
Chris Lattner | a3eee3c | 2010-01-22 19:52:01 +0000 | [diff] [blame] | 117 | EmitEOL(); |
| 118 | } |
Daniel Dunbar | 9a0a461 | 2010-02-09 23:00:14 +0000 | [diff] [blame] | 119 | |
Chris Lattner | 962c5bd8 | 2009-08-17 04:17:34 +0000 | [diff] [blame] | 120 | /// @name MCStreamer Interface |
| 121 | /// @{ |
Daniel Dunbar | 9faf273 | 2009-06-24 01:03:06 +0000 | [diff] [blame] | 122 | |
Rafael Espindola | 0709a7b | 2015-05-21 19:20:38 +0000 | [diff] [blame] | 123 | void ChangeSection(MCSection *Section, const MCExpr *Subsection) override; |
Daniel Dunbar | 9faf273 | 2009-06-24 01:03:06 +0000 | [diff] [blame] | 124 | |
Tim Northover | 53d3251 | 2014-03-29 07:34:53 +0000 | [diff] [blame] | 125 | void EmitLOHDirective(MCLOHType Kind, const MCLOHArgs &Args) override; |
Craig Topper | 34a61bc | 2014-03-08 07:02:02 +0000 | [diff] [blame] | 126 | void EmitLabel(MCSymbol *Symbol) override; |
Reed Kotler | aee4d5d1 | 2012-12-16 04:00:45 +0000 | [diff] [blame] | 127 | |
Craig Topper | 34a61bc | 2014-03-08 07:02:02 +0000 | [diff] [blame] | 128 | void EmitAssemblerFlag(MCAssemblerFlag Flag) override; |
| 129 | void EmitLinkerOptions(ArrayRef<std::string> Options) override; |
| 130 | void EmitDataRegion(MCDataRegionType Kind) override; |
Jim Grosbach | 448334a | 2014-03-18 22:09:05 +0000 | [diff] [blame] | 131 | void EmitVersionMin(MCVersionMinType Kind, unsigned Major, unsigned Minor, |
| 132 | unsigned Update) override; |
Craig Topper | 34a61bc | 2014-03-08 07:02:02 +0000 | [diff] [blame] | 133 | void EmitThumbFunc(MCSymbol *Func) override; |
Daniel Dunbar | 9faf273 | 2009-06-24 01:03:06 +0000 | [diff] [blame] | 134 | |
Craig Topper | 34a61bc | 2014-03-08 07:02:02 +0000 | [diff] [blame] | 135 | void EmitAssignment(MCSymbol *Symbol, const MCExpr *Value) override; |
| 136 | void EmitWeakReference(MCSymbol *Alias, const MCSymbol *Symbol) override; |
Craig Topper | 34a61bc | 2014-03-08 07:02:02 +0000 | [diff] [blame] | 137 | bool EmitSymbolAttribute(MCSymbol *Symbol, MCSymbolAttr Attribute) override; |
Kevin Enderby | c9d93ef | 2009-07-13 21:03:15 +0000 | [diff] [blame] | 138 | |
Craig Topper | 34a61bc | 2014-03-08 07:02:02 +0000 | [diff] [blame] | 139 | 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 Majnemer | 4eecd30 | 2015-05-30 04:56:02 +0000 | [diff] [blame] | 144 | void EmitCOFFSafeSEH(MCSymbol const *Symbol) override; |
Craig Topper | 34a61bc | 2014-03-08 07:02:02 +0000 | [diff] [blame] | 145 | void EmitCOFFSectionIndex(MCSymbol const *Symbol) override; |
| 146 | void EmitCOFFSecRel32(MCSymbol const *Symbol) override; |
Rafael Espindola | a869576 | 2015-06-02 00:25:12 +0000 | [diff] [blame] | 147 | void emitELFSize(MCSymbolELF *Symbol, const MCExpr *Value) override; |
Craig Topper | 34a61bc | 2014-03-08 07:02:02 +0000 | [diff] [blame] | 148 | void EmitCommonSymbol(MCSymbol *Symbol, uint64_t Size, |
| 149 | unsigned ByteAlignment) override; |
Kevin Enderby | 4c21caa | 2009-07-14 18:17:10 +0000 | [diff] [blame] | 150 | |
Chris Lattner | b1301f7 | 2010-01-23 07:47:02 +0000 | [diff] [blame] | 151 | /// 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 Gribenko | 65340a6 | 2012-08-23 16:54:08 +0000 | [diff] [blame] | 155 | /// @param ByteAlignment - The alignment of the common symbol in bytes. |
Craig Topper | 34a61bc | 2014-03-08 07:02:02 +0000 | [diff] [blame] | 156 | void EmitLocalCommonSymbol(MCSymbol *Symbol, uint64_t Size, |
| 157 | unsigned ByteAlignment) override; |
Jim Grosbach | 3bde49a | 2010-09-22 18:16:55 +0000 | [diff] [blame] | 158 | |
Rafael Espindola | 0709a7b | 2015-05-21 19:20:38 +0000 | [diff] [blame] | 159 | void EmitZerofill(MCSection *Section, MCSymbol *Symbol = nullptr, |
Craig Topper | 34a61bc | 2014-03-08 07:02:02 +0000 | [diff] [blame] | 160 | uint64_t Size = 0, unsigned ByteAlignment = 0) override; |
Kevin Enderby | cbe475d | 2009-07-14 21:35:03 +0000 | [diff] [blame] | 161 | |
Rafael Espindola | 0709a7b | 2015-05-21 19:20:38 +0000 | [diff] [blame] | 162 | void EmitTBSSSymbol(MCSection *Section, MCSymbol *Symbol, uint64_t Size, |
| 163 | unsigned ByteAlignment = 0) override; |
Jim Grosbach | 3bde49a | 2010-09-22 18:16:55 +0000 | [diff] [blame] | 164 | |
Reid Kleckner | fbdbe9e | 2016-05-31 18:45:36 +0000 | [diff] [blame] | 165 | void EmitBinaryData(StringRef Data) override; |
| 166 | |
Craig Topper | 34a61bc | 2014-03-08 07:02:02 +0000 | [diff] [blame] | 167 | void EmitBytes(StringRef Data) override; |
Chris Lattner | a1e11f5 | 2009-07-07 20:30:46 +0000 | [diff] [blame] | 168 | |
Kevin Enderby | 96918bc | 2014-04-22 17:27:29 +0000 | [diff] [blame] | 169 | void EmitValueImpl(const MCExpr *Value, unsigned Size, |
Craig Topper | 3c76c52 | 2015-09-20 23:35:59 +0000 | [diff] [blame] | 170 | SMLoc Loc = SMLoc()) override; |
Craig Topper | 34a61bc | 2014-03-08 07:02:02 +0000 | [diff] [blame] | 171 | void EmitIntValue(uint64_t Value, unsigned Size) override; |
Rafael Espindola | 5e87498 | 2010-11-02 17:22:24 +0000 | [diff] [blame] | 172 | |
Craig Topper | 34a61bc | 2014-03-08 07:02:02 +0000 | [diff] [blame] | 173 | void EmitULEB128Value(const MCExpr *Value) override; |
Rafael Espindola | 5e87498 | 2010-11-02 17:22:24 +0000 | [diff] [blame] | 174 | |
Craig Topper | 34a61bc | 2014-03-08 07:02:02 +0000 | [diff] [blame] | 175 | void EmitSLEB128Value(const MCExpr *Value) override; |
Rafael Espindola | 5e87498 | 2010-11-02 17:22:24 +0000 | [diff] [blame] | 176 | |
Craig Topper | 34a61bc | 2014-03-08 07:02:02 +0000 | [diff] [blame] | 177 | void EmitGPRel64Value(const MCExpr *Value) override; |
Akira Hatanaka | f0b0844 | 2012-02-03 04:33:00 +0000 | [diff] [blame] | 178 | |
Craig Topper | 34a61bc | 2014-03-08 07:02:02 +0000 | [diff] [blame] | 179 | void EmitGPRel32Value(const MCExpr *Value) override; |
Jim Grosbach | 3bde49a | 2010-09-22 18:16:55 +0000 | [diff] [blame] | 180 | |
Chris Lattner | dc50e5d | 2010-01-19 22:03:38 +0000 | [diff] [blame] | 181 | |
Petr Hosek | faef320 | 2016-06-01 01:59:58 +0000 | [diff] [blame] | 182 | void emitFill(uint64_t NumBytes, uint8_t FillValue) override; |
Chris Lattner | 07cadaf | 2009-07-10 22:20:30 +0000 | [diff] [blame] | 183 | |
Petr Hosek | 67a94a7 | 2016-05-28 05:57:48 +0000 | [diff] [blame] | 184 | 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 Topper | 34a61bc | 2014-03-08 07:02:02 +0000 | [diff] [blame] | 192 | void EmitValueToAlignment(unsigned ByteAlignment, int64_t Value = 0, |
| 193 | unsigned ValueSize = 1, |
| 194 | unsigned MaxBytesToEmit = 0) override; |
Daniel Dunbar | 9faf273 | 2009-06-24 01:03:06 +0000 | [diff] [blame] | 195 | |
Craig Topper | 34a61bc | 2014-03-08 07:02:02 +0000 | [diff] [blame] | 196 | void EmitCodeAlignment(unsigned ByteAlignment, |
| 197 | unsigned MaxBytesToEmit = 0) override; |
Kevin Enderby | e83d74f | 2010-02-23 18:26:34 +0000 | [diff] [blame] | 198 | |
Rafael Espindola | 7ae65d8 | 2015-11-04 23:59:18 +0000 | [diff] [blame] | 199 | void emitValueToOffset(const MCExpr *Offset, |
Craig Topper | 34a61bc | 2014-03-08 07:02:02 +0000 | [diff] [blame] | 200 | unsigned char Value = 0) override; |
Daniel Dunbar | 9faf273 | 2009-06-24 01:03:06 +0000 | [diff] [blame] | 201 | |
Craig Topper | 34a61bc | 2014-03-08 07:02:02 +0000 | [diff] [blame] | 202 | void EmitFileDirective(StringRef Filename) override; |
David Blaikie | c714ef4 | 2014-03-17 01:52:11 +0000 | [diff] [blame] | 203 | unsigned EmitDwarfFileDirective(unsigned FileNo, StringRef Directory, |
| 204 | StringRef Filename, |
| 205 | unsigned CUID = 0) override; |
Craig Topper | 34a61bc | 2014-03-08 07:02:02 +0000 | [diff] [blame] | 206 | void EmitDwarfLocDirective(unsigned FileNo, unsigned Line, |
| 207 | unsigned Column, unsigned Flags, |
| 208 | unsigned Isa, unsigned Discriminator, |
| 209 | StringRef FileName) override; |
David Blaikie | 3464161 | 2014-04-01 08:07:52 +0000 | [diff] [blame] | 210 | MCSymbol *getDwarfLineTableSymbol(unsigned CUID) override; |
Chris Lattner | 601ef33 | 2010-01-25 18:58:59 +0000 | [diff] [blame] | 211 | |
Reid Kleckner | 2214ed8 | 2016-01-29 00:49:42 +0000 | [diff] [blame] | 212 | 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 Majnemer | 6fcbd7e | 2016-01-29 19:24:12 +0000 | [diff] [blame] | 218 | void EmitCVInlineLinetableDirective( |
| 219 | unsigned PrimaryFunctionId, unsigned SourceFileId, unsigned SourceLineNum, |
David Majnemer | c9911f2 | 2016-02-02 19:22:34 +0000 | [diff] [blame] | 220 | const MCSymbol *FnStartSym, const MCSymbol *FnEndSym, |
David Majnemer | 6fcbd7e | 2016-01-29 19:24:12 +0000 | [diff] [blame] | 221 | ArrayRef<unsigned> SecondaryFunctionIds) override; |
David Majnemer | 408b5e6 | 2016-02-05 01:55:49 +0000 | [diff] [blame] | 222 | void EmitCVDefRangeDirective( |
| 223 | ArrayRef<std::pair<const MCSymbol *, const MCSymbol *>> Ranges, |
| 224 | StringRef FixedSizePortion) override; |
Reid Kleckner | 2214ed8 | 2016-01-29 00:49:42 +0000 | [diff] [blame] | 225 | void EmitCVStringTableDirective() override; |
| 226 | void EmitCVFileChecksumsDirective() override; |
| 227 | |
Craig Topper | 34a61bc | 2014-03-08 07:02:02 +0000 | [diff] [blame] | 228 | 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 Kuperstein | 259f150 | 2015-10-07 07:01:31 +0000 | [diff] [blame] | 241 | void EmitCFIEscape(StringRef Values) override; |
| 242 | void EmitCFIGnuArgsSize(int64_t Size) override; |
Craig Topper | 34a61bc | 2014-03-08 07:02:02 +0000 | [diff] [blame] | 243 | 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 Espindola | 3c227b0 | 2010-11-22 14:27:24 +0000 | [diff] [blame] | 247 | |
Saleem Abdulrasool | 7206a52 | 2014-06-29 01:52:01 +0000 | [diff] [blame] | 248 | 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 Davis | 8d9c990 | 2011-05-18 04:58:05 +0000 | [diff] [blame] | 262 | |
Craig Topper | 34a61bc | 2014-03-08 07:02:02 +0000 | [diff] [blame] | 263 | void EmitInstruction(const MCInst &Inst, const MCSubtargetInfo &STI) override; |
Jim Grosbach | 3bde49a | 2010-09-22 18:16:55 +0000 | [diff] [blame] | 264 | |
Craig Topper | 34a61bc | 2014-03-08 07:02:02 +0000 | [diff] [blame] | 265 | void EmitBundleAlignMode(unsigned AlignPow2) override; |
| 266 | void EmitBundleLock(bool AlignToEnd) override; |
| 267 | void EmitBundleUnlock() override; |
Eli Bendersky | f483ff9 | 2012-12-20 19:05:53 +0000 | [diff] [blame] | 268 | |
Daniel Sanders | 9f6ad49 | 2015-11-12 13:33:00 +0000 | [diff] [blame] | 269 | bool EmitRelocDirective(const MCExpr &Offset, StringRef Name, |
| 270 | const MCExpr *Expr, SMLoc Loc) override; |
| 271 | |
Jim Grosbach | 6ebd728 | 2010-09-22 18:18:30 +0000 | [diff] [blame] | 272 | /// EmitRawText - If this file is backed by an assembly streamer, this dumps |
Chris Lattner | 8a87fb7 | 2010-04-03 21:35:55 +0000 | [diff] [blame] | 273 | /// the specified string in the output .s file. This capability is |
| 274 | /// indicated by the hasRawTextSupport() predicate. |
Craig Topper | 34a61bc | 2014-03-08 07:02:02 +0000 | [diff] [blame] | 275 | void EmitRawTextImpl(StringRef String) override; |
Jim Grosbach | 3bde49a | 2010-09-22 18:16:55 +0000 | [diff] [blame] | 276 | |
Craig Topper | 34a61bc | 2014-03-08 07:02:02 +0000 | [diff] [blame] | 277 | void FinishImpl() override; |
Chris Lattner | 962c5bd8 | 2009-08-17 04:17:34 +0000 | [diff] [blame] | 278 | }; |
Daniel Dunbar | 71ea89d | 2009-06-24 19:25:34 +0000 | [diff] [blame] | 279 | |
Chris Lattner | 962c5bd8 | 2009-08-17 04:17:34 +0000 | [diff] [blame] | 280 | } // end anonymous namespace. |
Daniel Dunbar | 9faf273 | 2009-06-24 01:03:06 +0000 | [diff] [blame] | 281 | |
Chris Lattner | e1d8a31 | 2010-01-22 18:21:35 +0000 | [diff] [blame] | 282 | /// AddComment - Add a comment that can be emitted to the generated .s |
Chris Lattner | 38e9219 | 2010-01-22 07:29:22 +0000 | [diff] [blame] | 283 | /// 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 Lattner | e1d8a31 | 2010-01-22 18:21:35 +0000 | [diff] [blame] | 286 | void MCAsmStreamer::AddComment(const Twine &T) { |
Chris Lattner | 38e9219 | 2010-01-22 07:29:22 +0000 | [diff] [blame] | 287 | if (!IsVerboseAsm) return; |
Jim Grosbach | 3bde49a | 2010-09-22 18:16:55 +0000 | [diff] [blame] | 288 | |
Chris Lattner | 38e9219 | 2010-01-22 07:29:22 +0000 | [diff] [blame] | 289 | T.toVector(CommentToEmit); |
Chris Lattner | 8fa0e35 | 2010-01-22 19:17:48 +0000 | [diff] [blame] | 290 | // Each comment goes on its own line. |
| 291 | CommentToEmit.push_back('\n'); |
Chris Lattner | 38e9219 | 2010-01-22 07:29:22 +0000 | [diff] [blame] | 292 | } |
| 293 | |
| 294 | void MCAsmStreamer::EmitCommentsAndEOL() { |
Chris Lattner | 8fa0e35 | 2010-01-22 19:17:48 +0000 | [diff] [blame] | 295 | if (CommentToEmit.empty() && CommentStream.GetNumBytesInBuffer() == 0) { |
| 296 | OS << '\n'; |
| 297 | return; |
| 298 | } |
Jim Grosbach | 3bde49a | 2010-09-22 18:16:55 +0000 | [diff] [blame] | 299 | |
Yaron Keren | 92e1b62 | 2015-03-18 10:17:07 +0000 | [diff] [blame] | 300 | StringRef Comments = CommentToEmit; |
Jim Grosbach | 3bde49a | 2010-09-22 18:16:55 +0000 | [diff] [blame] | 301 | |
Chris Lattner | 8fa0e35 | 2010-01-22 19:17:48 +0000 | [diff] [blame] | 302 | assert(Comments.back() == '\n' && |
| 303 | "Comment array not newline terminated"); |
| 304 | do { |
Chris Lattner | 38e9219 | 2010-01-22 07:29:22 +0000 | [diff] [blame] | 305 | // Emit a line of comments. |
Bill Wendling | bc07a89 | 2013-06-18 07:20:20 +0000 | [diff] [blame] | 306 | OS.PadToColumn(MAI->getCommentColumn()); |
Chris Lattner | 38e9219 | 2010-01-22 07:29:22 +0000 | [diff] [blame] | 307 | size_t Position = Comments.find('\n'); |
Bill Wendling | bc07a89 | 2013-06-18 07:20:20 +0000 | [diff] [blame] | 308 | OS << MAI->getCommentString() << ' ' << Comments.substr(0, Position) <<'\n'; |
Jim Grosbach | 3bde49a | 2010-09-22 18:16:55 +0000 | [diff] [blame] | 309 | |
Chris Lattner | 38e9219 | 2010-01-22 07:29:22 +0000 | [diff] [blame] | 310 | Comments = Comments.substr(Position+1); |
Chris Lattner | 8fa0e35 | 2010-01-22 19:17:48 +0000 | [diff] [blame] | 311 | } while (!Comments.empty()); |
Jim Grosbach | 3bde49a | 2010-09-22 18:16:55 +0000 | [diff] [blame] | 312 | |
Chris Lattner | 1386a88 | 2010-01-22 21:16:10 +0000 | [diff] [blame] | 313 | CommentToEmit.clear(); |
Chris Lattner | 38e9219 | 2010-01-22 07:29:22 +0000 | [diff] [blame] | 314 | } |
| 315 | |
Daniel Dunbar | 188e87f | 2009-06-25 21:03:18 +0000 | [diff] [blame] | 316 | static inline int64_t truncateToSize(int64_t Value, unsigned Bytes) { |
Petr Hosek | 17f7a24 | 2016-06-04 04:02:18 +0000 | [diff] [blame] | 317 | assert(Bytes > 0 && Bytes <= 8 && "Invalid size!"); |
Daniel Dunbar | 188e87f | 2009-06-25 21:03:18 +0000 | [diff] [blame] | 318 | return Value & ((uint64_t) (int64_t) -1 >> (64 - Bytes * 8)); |
| 319 | } |
| 320 | |
Rafael Espindola | 0b69481 | 2014-01-16 16:28:37 +0000 | [diff] [blame] | 321 | void MCAsmStreamer::emitRawComment(const Twine &T, bool TabPrefix) { |
| 322 | if (TabPrefix) |
| 323 | OS << '\t'; |
| 324 | OS << MAI->getCommentString() << T; |
| 325 | EmitEOL(); |
| 326 | } |
| 327 | |
Rafael Espindola | 0709a7b | 2015-05-21 19:20:38 +0000 | [diff] [blame] | 328 | void MCAsmStreamer::ChangeSection(MCSection *Section, |
Peter Collingbourne | 2f495b9 | 2013-04-17 21:18:16 +0000 | [diff] [blame] | 329 | const MCExpr *Subsection) { |
Chris Lattner | 4b7dadb | 2009-08-19 05:49:37 +0000 | [diff] [blame] | 330 | assert(Section && "Cannot switch to a null section!"); |
Bill Wendling | bc07a89 | 2013-06-18 07:20:20 +0000 | [diff] [blame] | 331 | Section->PrintSwitchToSection(*MAI, OS, Subsection); |
Daniel Dunbar | 9faf273 | 2009-06-24 01:03:06 +0000 | [diff] [blame] | 332 | } |
| 333 | |
| 334 | void MCAsmStreamer::EmitLabel(MCSymbol *Symbol) { |
Daniel Dunbar | 6860ac7 | 2009-08-22 07:22:36 +0000 | [diff] [blame] | 335 | assert(Symbol->isUndefined() && "Cannot define a symbol twice!"); |
Rafael Espindola | 27c0c9b | 2011-04-27 15:21:19 +0000 | [diff] [blame] | 336 | MCStreamer::EmitLabel(Symbol); |
Daniel Dunbar | f782ebc | 2009-06-24 17:00:42 +0000 | [diff] [blame] | 337 | |
Matt Arsenault | 8b64355 | 2015-06-09 00:31:39 +0000 | [diff] [blame] | 338 | Symbol->print(OS, MAI); |
| 339 | OS << MAI->getLabelSuffix(); |
| 340 | |
Chris Lattner | cfa5ebc3 | 2010-01-22 07:36:39 +0000 | [diff] [blame] | 341 | EmitEOL(); |
Daniel Dunbar | 9faf273 | 2009-06-24 01:03:06 +0000 | [diff] [blame] | 342 | } |
| 343 | |
Tim Northover | 53d3251 | 2014-03-29 07:34:53 +0000 | [diff] [blame] | 344 | void 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 Kramer | 7b4658f | 2016-06-26 14:49:00 +0000 | [diff] [blame^] | 355 | for (const MCSymbol *Arg : Args) { |
Tim Northover | 53d3251 | 2014-03-29 07:34:53 +0000 | [diff] [blame] | 356 | if (!IsFirst) |
| 357 | OS << ", "; |
| 358 | IsFirst = false; |
Benjamin Kramer | 7b4658f | 2016-06-26 14:49:00 +0000 | [diff] [blame^] | 359 | Arg->print(OS, MAI); |
Tim Northover | 53d3251 | 2014-03-29 07:34:53 +0000 | [diff] [blame] | 360 | } |
| 361 | EmitEOL(); |
| 362 | } |
| 363 | |
Chris Lattner | 685508c | 2010-01-23 06:39:22 +0000 | [diff] [blame] | 364 | void MCAsmStreamer::EmitAssemblerFlag(MCAssemblerFlag Flag) { |
Kevin Enderby | dd27e5e | 2009-07-16 17:56:39 +0000 | [diff] [blame] | 365 | switch (Flag) { |
Jason W Kim | 645f6c2 | 2010-09-30 02:45:56 +0000 | [diff] [blame] | 366 | case MCAF_SyntaxUnified: OS << "\t.syntax unified"; break; |
Chris Lattner | 685508c | 2010-01-23 06:39:22 +0000 | [diff] [blame] | 367 | case MCAF_SubsectionsViaSymbols: OS << ".subsections_via_symbols"; break; |
Bill Wendling | bc07a89 | 2013-06-18 07:20:20 +0000 | [diff] [blame] | 368 | 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 Enderby | dd27e5e | 2009-07-16 17:56:39 +0000 | [diff] [blame] | 371 | } |
Chris Lattner | cfa5ebc3 | 2010-01-22 07:36:39 +0000 | [diff] [blame] | 372 | EmitEOL(); |
Kevin Enderby | c9d93ef | 2009-07-13 21:03:15 +0000 | [diff] [blame] | 373 | } |
| 374 | |
Daniel Dunbar | 16004b8 | 2013-01-18 01:25:48 +0000 | [diff] [blame] | 375 | void 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 Dunbar | 9585612 | 2013-01-18 19:37:00 +0000 | [diff] [blame] | 382 | OS << "\n"; |
Daniel Dunbar | 16004b8 | 2013-01-18 01:25:48 +0000 | [diff] [blame] | 383 | } |
| 384 | |
Jim Grosbach | 4b63d2a | 2012-05-18 19:12:01 +0000 | [diff] [blame] | 385 | void MCAsmStreamer::EmitDataRegion(MCDataRegionType Kind) { |
Bill Wendling | bc07a89 | 2013-06-18 07:20:20 +0000 | [diff] [blame] | 386 | if (!MAI->doesSupportDataRegionDirectives()) |
Jim Grosbach | 4b63d2a | 2012-05-18 19:12:01 +0000 | [diff] [blame] | 387 | 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 Grosbach | 448334a | 2014-03-18 22:09:05 +0000 | [diff] [blame] | 398 | void MCAsmStreamer::EmitVersionMin(MCVersionMinType Kind, unsigned Major, |
| 399 | unsigned Minor, unsigned Update) { |
| 400 | switch (Kind) { |
Tim Northover | 2d4d161 | 2015-10-28 22:36:05 +0000 | [diff] [blame] | 401 | case MCVM_WatchOSVersionMin: OS << "\t.watchos_version_min"; break; |
| 402 | case MCVM_TvOSVersionMin: OS << "\t.tvos_version_min"; break; |
Jim Grosbach | 448334a | 2014-03-18 22:09:05 +0000 | [diff] [blame] | 403 | 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 Grosbach | 5a2c68d | 2010-11-05 22:08:08 +0000 | [diff] [blame] | 412 | void 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 Espindola | e90c1cb | 2011-05-16 16:17:21 +0000 | [diff] [blame] | 416 | // Only Mach-O hasSubsectionsViaSymbols() |
Matt Arsenault | 8b64355 | 2015-06-09 00:31:39 +0000 | [diff] [blame] | 417 | if (MAI->hasSubsectionsViaSymbols()) { |
| 418 | OS << '\t'; |
| 419 | Func->print(OS, MAI); |
| 420 | } |
Jim Grosbach | 5a2c68d | 2010-11-05 22:08:08 +0000 | [diff] [blame] | 421 | EmitEOL(); |
| 422 | } |
| 423 | |
Daniel Dunbar | 897ffad | 2009-08-31 08:09:28 +0000 | [diff] [blame] | 424 | void MCAsmStreamer::EmitAssignment(MCSymbol *Symbol, const MCExpr *Value) { |
Matt Arsenault | 8b64355 | 2015-06-09 00:31:39 +0000 | [diff] [blame] | 425 | Symbol->print(OS, MAI); |
| 426 | OS << " = "; |
| 427 | Value->print(OS, MAI); |
| 428 | |
Chris Lattner | cfa5ebc3 | 2010-01-22 07:36:39 +0000 | [diff] [blame] | 429 | EmitEOL(); |
Daniel Dunbar | d20cda0 | 2009-10-16 01:34:54 +0000 | [diff] [blame] | 430 | |
Zoran Jovanovic | 28221d8 | 2014-03-20 09:44:49 +0000 | [diff] [blame] | 431 | MCStreamer::EmitAssignment(Symbol, Value); |
Daniel Dunbar | 9faf273 | 2009-06-24 01:03:06 +0000 | [diff] [blame] | 432 | } |
| 433 | |
Rafael Espindola | 1614597 | 2010-11-01 14:28:48 +0000 | [diff] [blame] | 434 | void MCAsmStreamer::EmitWeakReference(MCSymbol *Alias, const MCSymbol *Symbol) { |
Matt Arsenault | 8b64355 | 2015-06-09 00:31:39 +0000 | [diff] [blame] | 435 | OS << ".weakref "; |
| 436 | Alias->print(OS, MAI); |
| 437 | OS << ", "; |
| 438 | Symbol->print(OS, MAI); |
Rafael Espindola | 1614597 | 2010-11-01 14:28:48 +0000 | [diff] [blame] | 439 | EmitEOL(); |
| 440 | } |
| 441 | |
Saleem Abdulrasool | 4208b61 | 2013-08-09 01:52:03 +0000 | [diff] [blame] | 442 | bool MCAsmStreamer::EmitSymbolAttribute(MCSymbol *Symbol, |
Chris Lattner | 685508c | 2010-01-23 06:39:22 +0000 | [diff] [blame] | 443 | MCSymbolAttr Attribute) { |
Daniel Dunbar | 9faf273 | 2009-06-24 01:03:06 +0000 | [diff] [blame] | 444 | switch (Attribute) { |
Craig Topper | a2886c2 | 2012-02-07 05:05:23 +0000 | [diff] [blame] | 445 | case MCSA_Invalid: llvm_unreachable("Invalid symbol attribute"); |
Chris Lattner | bc8f638 | 2010-01-25 18:30:45 +0000 | [diff] [blame] | 446 | 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 Espindola | 2d006b1 | 2010-11-13 04:55:06 +0000 | [diff] [blame] | 452 | case MCSA_ELF_TypeGnuUniqueObject: /// .type _foo, @gnu_unique_object |
Saleem Abdulrasool | 4208b61 | 2013-08-09 01:52:03 +0000 | [diff] [blame] | 453 | if (!MAI->hasDotTypeDotSizeDirective()) |
| 454 | return false; // Symbol attribute not supported |
Matt Arsenault | 8b64355 | 2015-06-09 00:31:39 +0000 | [diff] [blame] | 455 | OS << "\t.type\t"; |
| 456 | Symbol->print(OS, MAI); |
| 457 | OS << ',' << ((MAI->getCommentString()[0] != '@') ? '@' : '%'); |
Chris Lattner | bc8f638 | 2010-01-25 18:30:45 +0000 | [diff] [blame] | 458 | switch (Attribute) { |
Saleem Abdulrasool | 4208b61 | 2013-08-09 01:52:03 +0000 | [diff] [blame] | 459 | default: return false; |
Chris Lattner | bc8f638 | 2010-01-25 18:30:45 +0000 | [diff] [blame] | 460 | 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 Espindola | 2d006b1 | 2010-11-13 04:55:06 +0000 | [diff] [blame] | 466 | case MCSA_ELF_TypeGnuUniqueObject: OS << "gnu_unique_object"; break; |
Chris Lattner | bc8f638 | 2010-01-25 18:30:45 +0000 | [diff] [blame] | 467 | } |
| 468 | EmitEOL(); |
Saleem Abdulrasool | 4208b61 | 2013-08-09 01:52:03 +0000 | [diff] [blame] | 469 | return true; |
Chris Lattner | bc8f638 | 2010-01-25 18:30:45 +0000 | [diff] [blame] | 470 | case MCSA_Global: // .globl/.global |
Bill Wendling | bc07a89 | 2013-06-18 07:20:20 +0000 | [diff] [blame] | 471 | OS << MAI->getGlobalDirective(); |
Chris Lattner | bc8f638 | 2010-01-25 18:30:45 +0000 | [diff] [blame] | 472 | break; |
Chris Lattner | 79d2075 | 2010-06-21 20:35:01 +0000 | [diff] [blame] | 473 | 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 Majnemer | 0fe246e | 2014-12-24 04:11:42 +0000 | [diff] [blame] | 478 | case MCSA_NoDeadStrip: |
| 479 | if (!MAI->hasNoDeadStrip()) |
| 480 | return false; |
| 481 | OS << "\t.no_dead_strip\t"; |
| 482 | break; |
Kevin Enderby | 8be1441 | 2010-11-19 18:39:33 +0000 | [diff] [blame] | 483 | case MCSA_SymbolResolver: OS << "\t.symbol_resolver\t"; break; |
Lang Hames | 1b640e0 | 2016-03-15 01:43:05 +0000 | [diff] [blame] | 484 | case MCSA_AltEntry: OS << "\t.alt_entry\t"; break; |
Rafael Espindola | bde52bc | 2011-04-30 16:34:57 +0000 | [diff] [blame] | 485 | case MCSA_PrivateExtern: |
| 486 | OS << "\t.private_extern\t"; |
Rafael Espindola | bde52bc | 2011-04-30 16:34:57 +0000 | [diff] [blame] | 487 | break; |
Chris Lattner | 79d2075 | 2010-06-21 20:35:01 +0000 | [diff] [blame] | 488 | case MCSA_Protected: OS << "\t.protected\t"; break; |
| 489 | case MCSA_Reference: OS << "\t.reference\t"; break; |
Jingyue Wu | 5b62eb9 | 2014-12-01 21:16:17 +0000 | [diff] [blame] | 490 | case MCSA_Weak: OS << MAI->getWeakDirective(); break; |
Rafael Espindola | bde52bc | 2011-04-30 16:34:57 +0000 | [diff] [blame] | 491 | case MCSA_WeakDefinition: |
| 492 | OS << "\t.weak_definition\t"; |
Rafael Espindola | bde52bc | 2011-04-30 16:34:57 +0000 | [diff] [blame] | 493 | break; |
Chris Lattner | 685508c | 2010-01-23 06:39:22 +0000 | [diff] [blame] | 494 | // .weak_reference |
Bill Wendling | bc07a89 | 2013-06-18 07:20:20 +0000 | [diff] [blame] | 495 | case MCSA_WeakReference: OS << MAI->getWeakRefDirective(); break; |
Kevin Enderby | 082d0fd | 2010-07-08 17:22:42 +0000 | [diff] [blame] | 496 | case MCSA_WeakDefAutoPrivate: OS << "\t.weak_def_can_be_hidden\t"; break; |
Daniel Dunbar | 9faf273 | 2009-06-24 01:03:06 +0000 | [diff] [blame] | 497 | } |
| 498 | |
Matt Arsenault | 8b64355 | 2015-06-09 00:31:39 +0000 | [diff] [blame] | 499 | Symbol->print(OS, MAI); |
Chris Lattner | cfa5ebc3 | 2010-01-22 07:36:39 +0000 | [diff] [blame] | 500 | EmitEOL(); |
Saleem Abdulrasool | 4208b61 | 2013-08-09 01:52:03 +0000 | [diff] [blame] | 501 | |
| 502 | return true; |
Daniel Dunbar | 9faf273 | 2009-06-24 01:03:06 +0000 | [diff] [blame] | 503 | } |
| 504 | |
Kevin Enderby | 4c21caa | 2009-07-14 18:17:10 +0000 | [diff] [blame] | 505 | void MCAsmStreamer::EmitSymbolDesc(MCSymbol *Symbol, unsigned DescValue) { |
Matt Arsenault | 8b64355 | 2015-06-09 00:31:39 +0000 | [diff] [blame] | 506 | OS << ".desc" << ' '; |
| 507 | Symbol->print(OS, MAI); |
| 508 | OS << ',' << DescValue; |
Chris Lattner | cfa5ebc3 | 2010-01-22 07:36:39 +0000 | [diff] [blame] | 509 | EmitEOL(); |
Kevin Enderby | 4c21caa | 2009-07-14 18:17:10 +0000 | [diff] [blame] | 510 | } |
| 511 | |
Michael Kuperstein | 23d952b | 2015-07-22 10:49:44 +0000 | [diff] [blame] | 512 | void 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 Lattner | 72afa95 | 2010-05-08 19:54:22 +0000 | [diff] [blame] | 520 | void MCAsmStreamer::BeginCOFFSymbolDef(const MCSymbol *Symbol) { |
Matt Arsenault | 8b64355 | 2015-06-09 00:31:39 +0000 | [diff] [blame] | 521 | OS << "\t.def\t "; |
| 522 | Symbol->print(OS, MAI); |
| 523 | OS << ';'; |
Chris Lattner | 72afa95 | 2010-05-08 19:54:22 +0000 | [diff] [blame] | 524 | EmitEOL(); |
| 525 | } |
| 526 | |
| 527 | void MCAsmStreamer::EmitCOFFSymbolStorageClass (int StorageClass) { |
| 528 | OS << "\t.scl\t" << StorageClass << ';'; |
| 529 | EmitEOL(); |
| 530 | } |
| 531 | |
| 532 | void MCAsmStreamer::EmitCOFFSymbolType (int Type) { |
| 533 | OS << "\t.type\t" << Type << ';'; |
| 534 | EmitEOL(); |
| 535 | } |
| 536 | |
| 537 | void MCAsmStreamer::EndCOFFSymbolDef() { |
| 538 | OS << "\t.endef"; |
| 539 | EmitEOL(); |
| 540 | } |
| 541 | |
David Majnemer | 4eecd30 | 2015-05-30 04:56:02 +0000 | [diff] [blame] | 542 | void MCAsmStreamer::EmitCOFFSafeSEH(MCSymbol const *Symbol) { |
David Majnemer | 1305e2c | 2015-07-13 18:51:15 +0000 | [diff] [blame] | 543 | OS << "\t.safeseh\t"; |
| 544 | Symbol->print(OS, MAI); |
David Majnemer | 4eecd30 | 2015-05-30 04:56:02 +0000 | [diff] [blame] | 545 | EmitEOL(); |
| 546 | } |
| 547 | |
Timur Iskhodzhanov | c1fb2d6 | 2013-12-20 18:15:00 +0000 | [diff] [blame] | 548 | void MCAsmStreamer::EmitCOFFSectionIndex(MCSymbol const *Symbol) { |
Matt Arsenault | 8b64355 | 2015-06-09 00:31:39 +0000 | [diff] [blame] | 549 | OS << "\t.secidx\t"; |
| 550 | Symbol->print(OS, MAI); |
Timur Iskhodzhanov | c1fb2d6 | 2013-12-20 18:15:00 +0000 | [diff] [blame] | 551 | EmitEOL(); |
| 552 | } |
| 553 | |
Rafael Espindola | d3df3d3 | 2011-12-17 01:14:52 +0000 | [diff] [blame] | 554 | void MCAsmStreamer::EmitCOFFSecRel32(MCSymbol const *Symbol) { |
Matt Arsenault | 8b64355 | 2015-06-09 00:31:39 +0000 | [diff] [blame] | 555 | OS << "\t.secrel32\t"; |
| 556 | Symbol->print(OS, MAI); |
Rafael Espindola | d3df3d3 | 2011-12-17 01:14:52 +0000 | [diff] [blame] | 557 | EmitEOL(); |
| 558 | } |
| 559 | |
Rafael Espindola | a869576 | 2015-06-02 00:25:12 +0000 | [diff] [blame] | 560 | void MCAsmStreamer::emitELFSize(MCSymbolELF *Symbol, const MCExpr *Value) { |
Bill Wendling | bc07a89 | 2013-06-18 07:20:20 +0000 | [diff] [blame] | 561 | assert(MAI->hasDotTypeDotSizeDirective()); |
Matt Arsenault | 8b64355 | 2015-06-09 00:31:39 +0000 | [diff] [blame] | 562 | OS << "\t.size\t"; |
| 563 | Symbol->print(OS, MAI); |
| 564 | OS << ", "; |
| 565 | Value->print(OS, MAI); |
| 566 | OS << '\n'; |
Chris Lattner | 91dac6d | 2010-01-25 07:52:13 +0000 | [diff] [blame] | 567 | } |
| 568 | |
Chris Lattner | b1301f7 | 2010-01-23 07:47:02 +0000 | [diff] [blame] | 569 | void MCAsmStreamer::EmitCommonSymbol(MCSymbol *Symbol, uint64_t Size, |
Daniel Dunbar | 6a715dc | 2009-08-30 06:17:16 +0000 | [diff] [blame] | 570 | unsigned ByteAlignment) { |
Matt Arsenault | 8b64355 | 2015-06-09 00:31:39 +0000 | [diff] [blame] | 571 | OS << "\t.comm\t"; |
| 572 | Symbol->print(OS, MAI); |
| 573 | OS << ',' << Size; |
| 574 | |
Chris Lattner | 0375d2f | 2010-01-25 07:29:13 +0000 | [diff] [blame] | 575 | if (ByteAlignment != 0) { |
Bill Wendling | bc07a89 | 2013-06-18 07:20:20 +0000 | [diff] [blame] | 576 | if (MAI->getCOMMDirectiveAlignmentIsInBytes()) |
Chris Lattner | 95b9895 | 2010-01-19 06:01:04 +0000 | [diff] [blame] | 577 | OS << ',' << ByteAlignment; |
| 578 | else |
| 579 | OS << ',' << Log2_32(ByteAlignment); |
| 580 | } |
Chris Lattner | cfa5ebc3 | 2010-01-22 07:36:39 +0000 | [diff] [blame] | 581 | EmitEOL(); |
Chris Lattner | a1e11f5 | 2009-07-07 20:30:46 +0000 | [diff] [blame] | 582 | } |
| 583 | |
Chris Lattner | b1301f7 | 2010-01-23 07:47:02 +0000 | [diff] [blame] | 584 | /// 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 Kramer | 6397051 | 2011-09-01 23:04:27 +0000 | [diff] [blame] | 588 | void MCAsmStreamer::EmitLocalCommonSymbol(MCSymbol *Symbol, uint64_t Size, |
| 589 | unsigned ByteAlign) { |
Matt Arsenault | 8b64355 | 2015-06-09 00:31:39 +0000 | [diff] [blame] | 590 | OS << "\t.lcomm\t"; |
| 591 | Symbol->print(OS, MAI); |
| 592 | OS << ',' << Size; |
| 593 | |
Benjamin Kramer | 6397051 | 2011-09-01 23:04:27 +0000 | [diff] [blame] | 594 | if (ByteAlign > 1) { |
Bill Wendling | bc07a89 | 2013-06-18 07:20:20 +0000 | [diff] [blame] | 595 | switch (MAI->getLCOMMDirectiveAlignmentType()) { |
Benjamin Kramer | 68b9f05 | 2012-09-07 21:08:01 +0000 | [diff] [blame] | 596 | case LCOMM::NoAlignment: |
| 597 | llvm_unreachable("alignment not supported on .lcomm!"); |
| 598 | case LCOMM::ByteAlignment: |
Benjamin Kramer | 47f9ec9 | 2012-09-07 17:25:13 +0000 | [diff] [blame] | 599 | OS << ',' << ByteAlign; |
Benjamin Kramer | 68b9f05 | 2012-09-07 21:08:01 +0000 | [diff] [blame] | 600 | break; |
| 601 | case LCOMM::Log2Alignment: |
Benjamin Kramer | 47f9ec9 | 2012-09-07 17:25:13 +0000 | [diff] [blame] | 602 | assert(isPowerOf2_32(ByteAlign) && "alignment must be a power of 2"); |
| 603 | OS << ',' << Log2_32(ByteAlign); |
Benjamin Kramer | 68b9f05 | 2012-09-07 21:08:01 +0000 | [diff] [blame] | 604 | break; |
Benjamin Kramer | 47f9ec9 | 2012-09-07 17:25:13 +0000 | [diff] [blame] | 605 | } |
Benjamin Kramer | 6397051 | 2011-09-01 23:04:27 +0000 | [diff] [blame] | 606 | } |
Chris Lattner | b1301f7 | 2010-01-23 07:47:02 +0000 | [diff] [blame] | 607 | EmitEOL(); |
| 608 | } |
| 609 | |
Rafael Espindola | 0709a7b | 2015-05-21 19:20:38 +0000 | [diff] [blame] | 610 | void MCAsmStreamer::EmitZerofill(MCSection *Section, MCSymbol *Symbol, |
Evan Cheng | f5bd6c6 | 2012-06-22 20:14:46 +0000 | [diff] [blame] | 611 | uint64_t Size, unsigned ByteAlignment) { |
Richard Mitton | 21101b3 | 2013-09-19 23:21:01 +0000 | [diff] [blame] | 612 | if (Symbol) |
Rafael Espindola | e3a20f5 | 2015-10-05 12:07:05 +0000 | [diff] [blame] | 613 | AssignFragment(Symbol, &Section->getDummyFragment()); |
Richard Mitton | 21101b3 | 2013-09-19 23:21:01 +0000 | [diff] [blame] | 614 | |
Daniel Dunbar | aba5fb8 | 2009-08-13 23:36:34 +0000 | [diff] [blame] | 615 | // Note: a .zerofill directive does not switch sections. |
Chris Lattner | 591105c | 2009-08-08 23:39:42 +0000 | [diff] [blame] | 616 | OS << ".zerofill "; |
Jim Grosbach | 3bde49a | 2010-09-22 18:16:55 +0000 | [diff] [blame] | 617 | |
Chris Lattner | 591105c | 2009-08-08 23:39:42 +0000 | [diff] [blame] | 618 | // This is a mach-o specific directive. |
Chris Lattner | cb307a27 | 2009-08-10 01:39:42 +0000 | [diff] [blame] | 619 | const MCSectionMachO *MOSection = ((const MCSectionMachO*)Section); |
Daniel Dunbar | 563a7e8 | 2009-08-14 18:51:45 +0000 | [diff] [blame] | 620 | OS << MOSection->getSegmentName() << "," << MOSection->getSectionName(); |
Jim Grosbach | 3bde49a | 2010-09-22 18:16:55 +0000 | [diff] [blame] | 621 | |
Craig Topper | bb694de | 2014-04-13 04:57:38 +0000 | [diff] [blame] | 622 | if (Symbol) { |
Matt Arsenault | 8b64355 | 2015-06-09 00:31:39 +0000 | [diff] [blame] | 623 | OS << ','; |
| 624 | Symbol->print(OS, MAI); |
| 625 | OS << ',' << Size; |
Daniel Dunbar | 6a715dc | 2009-08-30 06:17:16 +0000 | [diff] [blame] | 626 | if (ByteAlignment != 0) |
| 627 | OS << ',' << Log2_32(ByteAlignment); |
Chris Lattner | 07cadaf | 2009-07-10 22:20:30 +0000 | [diff] [blame] | 628 | } |
Chris Lattner | cfa5ebc3 | 2010-01-22 07:36:39 +0000 | [diff] [blame] | 629 | EmitEOL(); |
Chris Lattner | 07cadaf | 2009-07-10 22:20:30 +0000 | [diff] [blame] | 630 | } |
| 631 | |
Eric Christopher | 68b1bbe | 2010-05-17 02:13:02 +0000 | [diff] [blame] | 632 | // .tbss sym, size, align |
| 633 | // This depends that the symbol has already been mangled from the original, |
| 634 | // e.g. _a. |
Rafael Espindola | 0709a7b | 2015-05-21 19:20:38 +0000 | [diff] [blame] | 635 | void MCAsmStreamer::EmitTBSSSymbol(MCSection *Section, MCSymbol *Symbol, |
Eric Christopher | 5c87be7 | 2010-05-18 21:16:04 +0000 | [diff] [blame] | 636 | uint64_t Size, unsigned ByteAlignment) { |
Rafael Espindola | e3a20f5 | 2015-10-05 12:07:05 +0000 | [diff] [blame] | 637 | AssignFragment(Symbol, &Section->getDummyFragment()); |
Richard Mitton | 21101b3 | 2013-09-19 23:21:01 +0000 | [diff] [blame] | 638 | |
Craig Topper | bb694de | 2014-04-13 04:57:38 +0000 | [diff] [blame] | 639 | assert(Symbol && "Symbol shouldn't be NULL!"); |
Eric Christopher | 5c87be7 | 2010-05-18 21:16:04 +0000 | [diff] [blame] | 640 | // Instead of using the Section we'll just use the shortcut. |
| 641 | // This is a mach-o specific directive and section. |
Matt Arsenault | 8b64355 | 2015-06-09 00:31:39 +0000 | [diff] [blame] | 642 | OS << ".tbss "; |
| 643 | Symbol->print(OS, MAI); |
| 644 | OS << ", " << Size; |
Jim Grosbach | 3bde49a | 2010-09-22 18:16:55 +0000 | [diff] [blame] | 645 | |
Eric Christopher | 5c87be7 | 2010-05-18 21:16:04 +0000 | [diff] [blame] | 646 | // 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 Grosbach | 3bde49a | 2010-09-22 18:16:55 +0000 | [diff] [blame] | 649 | |
Eric Christopher | 9fb6bb0 | 2010-05-14 01:50:28 +0000 | [diff] [blame] | 650 | EmitEOL(); |
| 651 | } |
| 652 | |
Chris Lattner | ded9af63 | 2010-01-23 00:15:00 +0000 | [diff] [blame] | 653 | static inline char toOctal(int X) { return (X&7)+'0'; } |
| 654 | |
Chris Lattner | 601ef33 | 2010-01-25 18:58:59 +0000 | [diff] [blame] | 655 | static void PrintQuotedString(StringRef Data, raw_ostream &OS) { |
| 656 | OS << '"'; |
Jim Grosbach | 3bde49a | 2010-09-22 18:16:55 +0000 | [diff] [blame] | 657 | |
Chris Lattner | 601ef33 | 2010-01-25 18:58:59 +0000 | [diff] [blame] | 658 | 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 Grosbach | 3bde49a | 2010-09-22 18:16:55 +0000 | [diff] [blame] | 664 | |
Chris Lattner | 601ef33 | 2010-01-25 18:58:59 +0000 | [diff] [blame] | 665 | if (isprint((unsigned char)C)) { |
| 666 | OS << (char)C; |
| 667 | continue; |
| 668 | } |
Jim Grosbach | 3bde49a | 2010-09-22 18:16:55 +0000 | [diff] [blame] | 669 | |
Chris Lattner | 601ef33 | 2010-01-25 18:58:59 +0000 | [diff] [blame] | 670 | 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 Grosbach | 3bde49a | 2010-09-22 18:16:55 +0000 | [diff] [blame] | 684 | |
Chris Lattner | 601ef33 | 2010-01-25 18:58:59 +0000 | [diff] [blame] | 685 | OS << '"'; |
| 686 | } |
| 687 | |
Rafael Espindola | 64e1af8 | 2013-07-02 15:49:13 +0000 | [diff] [blame] | 688 | void MCAsmStreamer::EmitBytes(StringRef Data) { |
Peter Collingbourne | 2f495b9 | 2013-04-17 21:18:16 +0000 | [diff] [blame] | 689 | assert(getCurrentSection().first && |
| 690 | "Cannot emit contents before setting section!"); |
Chris Lattner | ded9af63 | 2010-01-23 00:15:00 +0000 | [diff] [blame] | 691 | if (Data.empty()) return; |
Jim Grosbach | 3bde49a | 2010-09-22 18:16:55 +0000 | [diff] [blame] | 692 | |
Chris Lattner | ded9af63 | 2010-01-23 00:15:00 +0000 | [diff] [blame] | 693 | if (Data.size() == 1) { |
Rafael Espindola | 64e1af8 | 2013-07-02 15:49:13 +0000 | [diff] [blame] | 694 | OS << MAI->getData8bitsDirective(); |
Chris Lattner | ded9af63 | 2010-01-23 00:15:00 +0000 | [diff] [blame] | 695 | OS << (unsigned)(unsigned char)Data[0]; |
Chris Lattner | cfa5ebc3 | 2010-01-22 07:36:39 +0000 | [diff] [blame] | 696 | EmitEOL(); |
Chris Lattner | ded9af63 | 2010-01-23 00:15:00 +0000 | [diff] [blame] | 697 | return; |
Chris Lattner | cfa5ebc3 | 2010-01-22 07:36:39 +0000 | [diff] [blame] | 698 | } |
Chris Lattner | ded9af63 | 2010-01-23 00:15:00 +0000 | [diff] [blame] | 699 | |
| 700 | // If the data ends with 0 and the target supports .asciz, use it, otherwise |
| 701 | // use .ascii |
Bill Wendling | bc07a89 | 2013-06-18 07:20:20 +0000 | [diff] [blame] | 702 | if (MAI->getAscizDirective() && Data.back() == 0) { |
| 703 | OS << MAI->getAscizDirective(); |
Chris Lattner | ded9af63 | 2010-01-23 00:15:00 +0000 | [diff] [blame] | 704 | Data = Data.substr(0, Data.size()-1); |
| 705 | } else { |
Bill Wendling | bc07a89 | 2013-06-18 07:20:20 +0000 | [diff] [blame] | 706 | OS << MAI->getAsciiDirective(); |
Chris Lattner | ded9af63 | 2010-01-23 00:15:00 +0000 | [diff] [blame] | 707 | } |
| 708 | |
Chris Lattner | 601ef33 | 2010-01-25 18:58:59 +0000 | [diff] [blame] | 709 | PrintQuotedString(Data, OS); |
Chris Lattner | ded9af63 | 2010-01-23 00:15:00 +0000 | [diff] [blame] | 710 | EmitEOL(); |
Daniel Dunbar | 9faf273 | 2009-06-24 01:03:06 +0000 | [diff] [blame] | 711 | } |
| 712 | |
Reid Kleckner | fbdbe9e | 2016-05-31 18:45:36 +0000 | [diff] [blame] | 713 | void 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 Espindola | 64e1af8 | 2013-07-02 15:49:13 +0000 | [diff] [blame] | 727 | void MCAsmStreamer::EmitIntValue(uint64_t Value, unsigned Size) { |
Jim Grosbach | 13760bd | 2015-05-30 01:25:56 +0000 | [diff] [blame] | 728 | EmitValue(MCConstantExpr::create(Value, getContext()), Size); |
Rafael Espindola | 4c70eea | 2010-12-03 02:54:21 +0000 | [diff] [blame] | 729 | } |
| 730 | |
Kevin Enderby | 96918bc | 2014-04-22 17:27:29 +0000 | [diff] [blame] | 731 | void MCAsmStreamer::EmitValueImpl(const MCExpr *Value, unsigned Size, |
Craig Topper | 3c76c52 | 2015-09-20 23:35:59 +0000 | [diff] [blame] | 732 | SMLoc Loc) { |
David Majnemer | 522d3db | 2014-02-01 07:19:38 +0000 | [diff] [blame] | 733 | assert(Size <= 8 && "Invalid size"); |
Peter Collingbourne | 2f495b9 | 2013-04-17 21:18:16 +0000 | [diff] [blame] | 734 | assert(getCurrentSection().first && |
| 735 | "Cannot emit contents before setting section!"); |
Craig Topper | bb694de | 2014-04-13 04:57:38 +0000 | [diff] [blame] | 736 | const char *Directive = nullptr; |
Chris Lattner | dc50e5d | 2010-01-19 22:03:38 +0000 | [diff] [blame] | 737 | switch (Size) { |
| 738 | default: break; |
Rafael Espindola | 64e1af8 | 2013-07-02 15:49:13 +0000 | [diff] [blame] | 739 | case 1: Directive = MAI->getData8bitsDirective(); break; |
| 740 | case 2: Directive = MAI->getData16bitsDirective(); break; |
| 741 | case 4: Directive = MAI->getData32bitsDirective(); break; |
David Majnemer | 522d3db | 2014-02-01 07:19:38 +0000 | [diff] [blame] | 742 | case 8: Directive = MAI->getData64bitsDirective(); break; |
| 743 | } |
| 744 | |
| 745 | if (!Directive) { |
Rafael Espindola | e5e1f9a | 2010-11-28 23:22:44 +0000 | [diff] [blame] | 746 | int64_t IntValue; |
Jim Grosbach | 13760bd | 2015-05-30 01:25:56 +0000 | [diff] [blame] | 747 | if (!Value->evaluateAsAbsolute(IntValue)) |
Rafael Espindola | e5e1f9a | 2010-11-28 23:22:44 +0000 | [diff] [blame] | 748 | report_fatal_error("Don't know how to emit this value."); |
David Majnemer | 522d3db | 2014-02-01 07:19:38 +0000 | [diff] [blame] | 749 | |
| 750 | // We couldn't handle the requested integer size so we fallback by breaking |
Rafael Espindola | 52570ea | 2016-02-01 20:36:49 +0000 | [diff] [blame] | 751 | // 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 Majnemer | 522d3db | 2014-02-01 07:19:38 +0000 | [diff] [blame] | 754 | 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 Espindola | 52570ea | 2016-02-01 20:36:49 +0000 | [diff] [blame] | 758 | // Size. |
| 759 | unsigned EmissionSize = PowerOf2Floor(std::min(Remaining, Size - 1)); |
David Majnemer | 522d3db | 2014-02-01 07:19:38 +0000 | [diff] [blame] | 760 | // 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 Ilseman | 5be22a1 | 2014-12-12 21:48:03 +0000 | [diff] [blame] | 768 | uint64_t Shift = 64 - EmissionSize * 8; |
Aaron Ballman | 2d67fd6 | 2014-12-15 14:25:12 +0000 | [diff] [blame] | 769 | assert(Shift < static_cast<uint64_t>( |
Aaron Ballman | 786a86c | 2014-12-13 16:55:02 +0000 | [diff] [blame] | 770 | std::numeric_limits<unsigned long long>::digits) && |
Michael Ilseman | 5be22a1 | 2014-12-12 21:48:03 +0000 | [diff] [blame] | 771 | "undefined behavior"); |
| 772 | ValueToEmit &= ~0ULL >> Shift; |
David Majnemer | 522d3db | 2014-02-01 07:19:38 +0000 | [diff] [blame] | 773 | EmitIntValue(ValueToEmit, EmissionSize); |
| 774 | Emitted += EmissionSize; |
Chris Lattner | 45eeffc | 2010-01-20 06:45:39 +0000 | [diff] [blame] | 775 | } |
| 776 | return; |
Chris Lattner | dc50e5d | 2010-01-19 22:03:38 +0000 | [diff] [blame] | 777 | } |
Jim Grosbach | 3bde49a | 2010-09-22 18:16:55 +0000 | [diff] [blame] | 778 | |
Chris Lattner | dc50e5d | 2010-01-19 22:03:38 +0000 | [diff] [blame] | 779 | assert(Directive && "Invalid size for machine code value!"); |
Matt Arsenault | 8b64355 | 2015-06-09 00:31:39 +0000 | [diff] [blame] | 780 | OS << Directive; |
| 781 | Value->print(OS, MAI); |
Chris Lattner | 38e9219 | 2010-01-22 07:29:22 +0000 | [diff] [blame] | 782 | EmitEOL(); |
Daniel Dunbar | 9faf273 | 2009-06-24 01:03:06 +0000 | [diff] [blame] | 783 | } |
| 784 | |
Rafael Espindola | 6aea592 | 2011-04-21 23:39:26 +0000 | [diff] [blame] | 785 | void MCAsmStreamer::EmitULEB128Value(const MCExpr *Value) { |
Rafael Espindola | 92ca933 | 2010-11-19 04:10:13 +0000 | [diff] [blame] | 786 | int64_t IntValue; |
Jim Grosbach | 13760bd | 2015-05-30 01:25:56 +0000 | [diff] [blame] | 787 | if (Value->evaluateAsAbsolute(IntValue)) { |
Rafael Espindola | 6aea592 | 2011-04-21 23:39:26 +0000 | [diff] [blame] | 788 | EmitULEB128IntValue(IntValue); |
Rafael Espindola | 92ca933 | 2010-11-19 04:10:13 +0000 | [diff] [blame] | 789 | return; |
| 790 | } |
Matt Arsenault | 8b64355 | 2015-06-09 00:31:39 +0000 | [diff] [blame] | 791 | OS << ".uleb128 "; |
| 792 | Value->print(OS, MAI); |
Rafael Espindola | 5e87498 | 2010-11-02 17:22:24 +0000 | [diff] [blame] | 793 | EmitEOL(); |
| 794 | } |
| 795 | |
Rafael Espindola | 6aea592 | 2011-04-21 23:39:26 +0000 | [diff] [blame] | 796 | void MCAsmStreamer::EmitSLEB128Value(const MCExpr *Value) { |
Rafael Espindola | 92ca933 | 2010-11-19 04:10:13 +0000 | [diff] [blame] | 797 | int64_t IntValue; |
Jim Grosbach | 13760bd | 2015-05-30 01:25:56 +0000 | [diff] [blame] | 798 | if (Value->evaluateAsAbsolute(IntValue)) { |
Rafael Espindola | 6aea592 | 2011-04-21 23:39:26 +0000 | [diff] [blame] | 799 | EmitSLEB128IntValue(IntValue); |
Rafael Espindola | 92ca933 | 2010-11-19 04:10:13 +0000 | [diff] [blame] | 800 | return; |
| 801 | } |
Matt Arsenault | 8b64355 | 2015-06-09 00:31:39 +0000 | [diff] [blame] | 802 | OS << ".sleb128 "; |
| 803 | Value->print(OS, MAI); |
Rafael Espindola | 5e87498 | 2010-11-02 17:22:24 +0000 | [diff] [blame] | 804 | EmitEOL(); |
| 805 | } |
| 806 | |
Akira Hatanaka | f0b0844 | 2012-02-03 04:33:00 +0000 | [diff] [blame] | 807 | void MCAsmStreamer::EmitGPRel64Value(const MCExpr *Value) { |
Craig Topper | bb694de | 2014-04-13 04:57:38 +0000 | [diff] [blame] | 808 | assert(MAI->getGPRel64Directive() != nullptr); |
Matt Arsenault | 8b64355 | 2015-06-09 00:31:39 +0000 | [diff] [blame] | 809 | OS << MAI->getGPRel64Directive(); |
| 810 | Value->print(OS, MAI); |
Akira Hatanaka | f0b0844 | 2012-02-03 04:33:00 +0000 | [diff] [blame] | 811 | EmitEOL(); |
| 812 | } |
| 813 | |
Chris Lattner | 3cde760 | 2010-01-25 21:28:50 +0000 | [diff] [blame] | 814 | void MCAsmStreamer::EmitGPRel32Value(const MCExpr *Value) { |
Craig Topper | bb694de | 2014-04-13 04:57:38 +0000 | [diff] [blame] | 815 | assert(MAI->getGPRel32Directive() != nullptr); |
Matt Arsenault | 8b64355 | 2015-06-09 00:31:39 +0000 | [diff] [blame] | 816 | OS << MAI->getGPRel32Directive(); |
| 817 | Value->print(OS, MAI); |
Chris Lattner | 3cde760 | 2010-01-25 21:28:50 +0000 | [diff] [blame] | 818 | EmitEOL(); |
| 819 | } |
| 820 | |
Petr Hosek | faef320 | 2016-06-01 01:59:58 +0000 | [diff] [blame] | 821 | /// emitFill - Emit NumBytes bytes worth of the value specified by |
Chris Lattner | 4340cb3 | 2010-01-19 18:52:28 +0000 | [diff] [blame] | 822 | /// FillValue. This implements directives such as '.space'. |
Petr Hosek | faef320 | 2016-06-01 01:59:58 +0000 | [diff] [blame] | 823 | void MCAsmStreamer::emitFill(uint64_t NumBytes, uint8_t FillValue) { |
Chris Lattner | ed89f60 | 2010-01-19 18:58:52 +0000 | [diff] [blame] | 824 | if (NumBytes == 0) return; |
Jim Grosbach | 3bde49a | 2010-09-22 18:16:55 +0000 | [diff] [blame] | 825 | |
Petr Hosek | 67a94a7 | 2016-05-28 05:57:48 +0000 | [diff] [blame] | 826 | const MCExpr *E = MCConstantExpr::create(NumBytes, getContext()); |
| 827 | emitFill(*E, FillValue); |
| 828 | } |
| 829 | |
| 830 | void MCAsmStreamer::emitFill(const MCExpr &NumBytes, uint64_t FillValue, |
| 831 | SMLoc Loc) { |
Rafael Espindola | 64e1af8 | 2013-07-02 15:49:13 +0000 | [diff] [blame] | 832 | if (const char *ZeroDirective = MAI->getZeroDirective()) { |
Petr Hosek | 67a94a7 | 2016-05-28 05:57:48 +0000 | [diff] [blame] | 833 | // FIXME: Emit location directives |
| 834 | OS << ZeroDirective; |
| 835 | NumBytes.print(OS, MAI); |
Rafael Espindola | 64e1af8 | 2013-07-02 15:49:13 +0000 | [diff] [blame] | 836 | if (FillValue != 0) |
| 837 | OS << ',' << (int)FillValue; |
| 838 | EmitEOL(); |
| 839 | return; |
| 840 | } |
Chris Lattner | c35681b | 2010-01-19 19:46:13 +0000 | [diff] [blame] | 841 | |
Petr Hosek | 67a94a7 | 2016-05-28 05:57:48 +0000 | [diff] [blame] | 842 | MCStreamer::emitFill(NumBytes, FillValue); |
| 843 | } |
| 844 | |
| 845 | void 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 | |
| 853 | void 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 Lattner | 4340cb3 | 2010-01-19 18:52:28 +0000 | [diff] [blame] | 861 | } |
| 862 | |
Daniel Dunbar | 71ea89d | 2009-06-24 19:25:34 +0000 | [diff] [blame] | 863 | void MCAsmStreamer::EmitValueToAlignment(unsigned ByteAlignment, int64_t Value, |
| 864 | unsigned ValueSize, |
| 865 | unsigned MaxBytesToEmit) { |
Chris Lattner | 37b7234 | 2009-08-19 06:12:02 +0000 | [diff] [blame] | 866 | // 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 Lattner | 78b23b0 | 2009-08-19 06:35:36 +0000 | [diff] [blame] | 869 | switch (ValueSize) { |
Rafael Espindola | 7cbbd28 | 2014-02-04 18:39:51 +0000 | [diff] [blame] | 870 | default: |
| 871 | llvm_unreachable("Invalid size for machine code value!"); |
| 872 | case 1: |
Dan Gohman | 61d15ae | 2016-01-26 00:03:25 +0000 | [diff] [blame] | 873 | OS << "\t.p2align\t"; |
Rafael Espindola | 7cbbd28 | 2014-02-04 18:39:51 +0000 | [diff] [blame] | 874 | 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 Lattner | 78b23b0 | 2009-08-19 06:35:36 +0000 | [diff] [blame] | 883 | } |
Jim Grosbach | 3bde49a | 2010-09-22 18:16:55 +0000 | [diff] [blame] | 884 | |
Dan Gohman | 61d15ae | 2016-01-26 00:03:25 +0000 | [diff] [blame] | 885 | OS << Log2_32(ByteAlignment); |
Daniel Dunbar | 71ea89d | 2009-06-24 19:25:34 +0000 | [diff] [blame] | 886 | |
Chris Lattner | 37b7234 | 2009-08-19 06:12:02 +0000 | [diff] [blame] | 887 | if (Value || MaxBytesToEmit) { |
Chris Lattner | f16a122 | 2009-09-03 04:01:10 +0000 | [diff] [blame] | 888 | OS << ", 0x"; |
| 889 | OS.write_hex(truncateToSize(Value, ValueSize)); |
Chris Lattner | 37b7234 | 2009-08-19 06:12:02 +0000 | [diff] [blame] | 890 | |
Jim Grosbach | 3bde49a | 2010-09-22 18:16:55 +0000 | [diff] [blame] | 891 | if (MaxBytesToEmit) |
Chris Lattner | 37b7234 | 2009-08-19 06:12:02 +0000 | [diff] [blame] | 892 | OS << ", " << MaxBytesToEmit; |
| 893 | } |
Chris Lattner | cfa5ebc3 | 2010-01-22 07:36:39 +0000 | [diff] [blame] | 894 | EmitEOL(); |
Chris Lattner | 37b7234 | 2009-08-19 06:12:02 +0000 | [diff] [blame] | 895 | return; |
| 896 | } |
Jim Grosbach | 3bde49a | 2010-09-22 18:16:55 +0000 | [diff] [blame] | 897 | |
Chris Lattner | 37b7234 | 2009-08-19 06:12:02 +0000 | [diff] [blame] | 898 | // Non-power of two alignment. This is not widely supported by assemblers. |
Chris Lattner | e9a75a6 | 2009-08-22 21:43:10 +0000 | [diff] [blame] | 899 | // FIXME: Parameterize this based on MAI. |
Daniel Dunbar | 71ea89d | 2009-06-24 19:25:34 +0000 | [diff] [blame] | 900 | switch (ValueSize) { |
Chris Lattner | 37b7234 | 2009-08-19 06:12:02 +0000 | [diff] [blame] | 901 | 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 Dunbar | 71ea89d | 2009-06-24 19:25:34 +0000 | [diff] [blame] | 906 | } |
| 907 | |
Chris Lattner | 37b7234 | 2009-08-19 06:12:02 +0000 | [diff] [blame] | 908 | OS << ' ' << ByteAlignment; |
Daniel Dunbar | 188e87f | 2009-06-25 21:03:18 +0000 | [diff] [blame] | 909 | OS << ", " << truncateToSize(Value, ValueSize); |
Jim Grosbach | 3bde49a | 2010-09-22 18:16:55 +0000 | [diff] [blame] | 910 | if (MaxBytesToEmit) |
Daniel Dunbar | 71ea89d | 2009-06-24 19:25:34 +0000 | [diff] [blame] | 911 | OS << ", " << MaxBytesToEmit; |
Chris Lattner | cfa5ebc3 | 2010-01-22 07:36:39 +0000 | [diff] [blame] | 912 | EmitEOL(); |
Daniel Dunbar | 71ea89d | 2009-06-24 19:25:34 +0000 | [diff] [blame] | 913 | } |
| 914 | |
Kevin Enderby | e83d74f | 2010-02-23 18:26:34 +0000 | [diff] [blame] | 915 | void MCAsmStreamer::EmitCodeAlignment(unsigned ByteAlignment, |
| 916 | unsigned MaxBytesToEmit) { |
Chris Lattner | eebaf6a | 2010-02-23 18:44:31 +0000 | [diff] [blame] | 917 | // Emit with a text fill value. |
Bill Wendling | bc07a89 | 2013-06-18 07:20:20 +0000 | [diff] [blame] | 918 | EmitValueToAlignment(ByteAlignment, MAI->getTextAlignFillValue(), |
Chris Lattner | eebaf6a | 2010-02-23 18:44:31 +0000 | [diff] [blame] | 919 | 1, MaxBytesToEmit); |
Kevin Enderby | e83d74f | 2010-02-23 18:26:34 +0000 | [diff] [blame] | 920 | } |
| 921 | |
Rafael Espindola | 7ae65d8 | 2015-11-04 23:59:18 +0000 | [diff] [blame] | 922 | void MCAsmStreamer::emitValueToOffset(const MCExpr *Offset, |
Daniel Dunbar | 71ea89d | 2009-06-24 19:25:34 +0000 | [diff] [blame] | 923 | unsigned char Value) { |
| 924 | // FIXME: Verify that Offset is associated with the current section. |
Matt Arsenault | 8b64355 | 2015-06-09 00:31:39 +0000 | [diff] [blame] | 925 | OS << ".org "; |
| 926 | Offset->print(OS, MAI); |
| 927 | OS << ", " << (unsigned)Value; |
Chris Lattner | cfa5ebc3 | 2010-01-22 07:36:39 +0000 | [diff] [blame] | 928 | EmitEOL(); |
Daniel Dunbar | 71ea89d | 2009-06-24 19:25:34 +0000 | [diff] [blame] | 929 | } |
| 930 | |
Chris Lattner | 601ef33 | 2010-01-25 18:58:59 +0000 | [diff] [blame] | 931 | void MCAsmStreamer::EmitFileDirective(StringRef Filename) { |
Bill Wendling | bc07a89 | 2013-06-18 07:20:20 +0000 | [diff] [blame] | 932 | assert(MAI->hasSingleParameterDotFile()); |
Chris Lattner | 601ef33 | 2010-01-25 18:58:59 +0000 | [diff] [blame] | 933 | OS << "\t.file\t"; |
| 934 | PrintQuotedString(Filename, OS); |
| 935 | EmitEOL(); |
| 936 | } |
| 937 | |
David Blaikie | c714ef4 | 2014-03-17 01:52:11 +0000 | [diff] [blame] | 938 | unsigned MCAsmStreamer::EmitDwarfFileDirective(unsigned FileNo, |
| 939 | StringRef Directory, |
| 940 | StringRef Filename, |
| 941 | unsigned CUID) { |
David Blaikie | c2df16b | 2014-03-17 18:13:58 +0000 | [diff] [blame] | 942 | 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 Lewycky | 40f8f2f | 2011-10-17 23:05:28 +0000 | [diff] [blame] | 954 | if (!UseDwarfDirectory && !Directory.empty()) { |
| 955 | if (sys::path::is_absolute(Filename)) |
David Blaikie | c2df16b | 2014-03-17 18:13:58 +0000 | [diff] [blame] | 956 | Directory = ""; |
| 957 | else { |
| 958 | FullPathName = Directory; |
| 959 | sys::path::append(FullPathName, Filename); |
| 960 | Directory = ""; |
| 961 | Filename = FullPathName; |
| 962 | } |
Nick Lewycky | 40f8f2f | 2011-10-17 23:05:28 +0000 | [diff] [blame] | 963 | } |
| 964 | |
Rafael Espindola | b4eec1d | 2014-02-05 18:00:21 +0000 | [diff] [blame] | 965 | OS << "\t.file\t" << FileNo << ' '; |
| 966 | if (!Directory.empty()) { |
| 967 | PrintQuotedString(Directory, OS); |
| 968 | OS << ' '; |
Rafael Espindola | b58867c | 2010-11-19 02:26:16 +0000 | [diff] [blame] | 969 | } |
Rafael Espindola | b4eec1d | 2014-02-05 18:00:21 +0000 | [diff] [blame] | 970 | PrintQuotedString(Filename, OS); |
| 971 | EmitEOL(); |
Rafael Espindola | b4eec1d | 2014-02-05 18:00:21 +0000 | [diff] [blame] | 972 | |
David Blaikie | c2df16b | 2014-03-17 18:13:58 +0000 | [diff] [blame] | 973 | return FileNo; |
Rafael Espindola | c653a89 | 2010-11-16 21:20:32 +0000 | [diff] [blame] | 974 | } |
| 975 | |
| 976 | void MCAsmStreamer::EmitDwarfLocDirective(unsigned FileNo, unsigned Line, |
| 977 | unsigned Column, unsigned Flags, |
| 978 | unsigned Isa, |
Devang Patel | 17740e7 | 2011-04-18 20:26:49 +0000 | [diff] [blame] | 979 | unsigned Discriminator, |
| 980 | StringRef FileName) { |
Rafael Espindola | c653a89 | 2010-11-16 21:20:32 +0000 | [diff] [blame] | 981 | 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 Novillo | b1b5007 | 2014-02-13 20:05:03 +0000 | [diff] [blame] | 1000 | OS << " isa " << Isa; |
Rafael Espindola | c653a89 | 2010-11-16 21:20:32 +0000 | [diff] [blame] | 1001 | if (Discriminator) |
Diego Novillo | b1b5007 | 2014-02-13 20:05:03 +0000 | [diff] [blame] | 1002 | OS << " discriminator " << Discriminator; |
Devang Patel | 17740e7 | 2011-04-18 20:26:49 +0000 | [diff] [blame] | 1003 | |
| 1004 | if (IsVerboseAsm) { |
Bill Wendling | bc07a89 | 2013-06-18 07:20:20 +0000 | [diff] [blame] | 1005 | OS.PadToColumn(MAI->getCommentColumn()); |
| 1006 | OS << MAI->getCommentString() << ' ' << FileName << ':' |
Devang Patel | 17740e7 | 2011-04-18 20:26:49 +0000 | [diff] [blame] | 1007 | << Line << ':' << Column; |
| 1008 | } |
Rafael Espindola | c653a89 | 2010-11-16 21:20:32 +0000 | [diff] [blame] | 1009 | EmitEOL(); |
David Blaikie | aeaa5bf | 2014-12-30 22:47:13 +0000 | [diff] [blame] | 1010 | this->MCStreamer::EmitDwarfLocDirective(FileNo, Line, Column, Flags, |
| 1011 | Isa, Discriminator, FileName); |
Chris Lattner | 601ef33 | 2010-01-25 18:58:59 +0000 | [diff] [blame] | 1012 | } |
| 1013 | |
David Blaikie | 3464161 | 2014-04-01 08:07:52 +0000 | [diff] [blame] | 1014 | MCSymbol *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 Kleckner | 2214ed8 | 2016-01-29 00:49:42 +0000 | [diff] [blame] | 1020 | unsigned 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 | |
| 1033 | void 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 | |
| 1062 | void 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 Majnemer | 6fcbd7e | 2016-01-29 19:24:12 +0000 | [diff] [blame] | 1073 | void MCAsmStreamer::EmitCVInlineLinetableDirective( |
| 1074 | unsigned PrimaryFunctionId, unsigned SourceFileId, unsigned SourceLineNum, |
David Majnemer | c9911f2 | 2016-02-02 19:22:34 +0000 | [diff] [blame] | 1075 | const MCSymbol *FnStartSym, const MCSymbol *FnEndSym, |
| 1076 | ArrayRef<unsigned> SecondaryFunctionIds) { |
David Majnemer | 6fcbd7e | 2016-01-29 19:24:12 +0000 | [diff] [blame] | 1077 | OS << "\t.cv_inline_linetable\t" << PrimaryFunctionId << ' ' << SourceFileId |
Reid Kleckner | 1fcd610 | 2016-02-02 17:41:18 +0000 | [diff] [blame] | 1078 | << ' ' << SourceLineNum << ' '; |
| 1079 | FnStartSym->print(OS, MAI); |
David Majnemer | c9911f2 | 2016-02-02 19:22:34 +0000 | [diff] [blame] | 1080 | OS << ' '; |
| 1081 | FnEndSym->print(OS, MAI); |
David Majnemer | 6fcbd7e | 2016-01-29 19:24:12 +0000 | [diff] [blame] | 1082 | if (!SecondaryFunctionIds.empty()) { |
| 1083 | OS << " contains"; |
| 1084 | for (unsigned SecondaryFunctionId : SecondaryFunctionIds) |
| 1085 | OS << ' ' << SecondaryFunctionId; |
| 1086 | } |
| 1087 | EmitEOL(); |
| 1088 | this->MCStreamer::EmitCVInlineLinetableDirective( |
David Majnemer | c9911f2 | 2016-02-02 19:22:34 +0000 | [diff] [blame] | 1089 | PrimaryFunctionId, SourceFileId, SourceLineNum, FnStartSym, FnEndSym, |
Reid Kleckner | 1fcd610 | 2016-02-02 17:41:18 +0000 | [diff] [blame] | 1090 | SecondaryFunctionIds); |
David Majnemer | 6fcbd7e | 2016-01-29 19:24:12 +0000 | [diff] [blame] | 1091 | } |
| 1092 | |
David Majnemer | 408b5e6 | 2016-02-05 01:55:49 +0000 | [diff] [blame] | 1093 | void 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 Kleckner | 2214ed8 | 2016-01-29 00:49:42 +0000 | [diff] [blame] | 1109 | void MCAsmStreamer::EmitCVStringTableDirective() { |
| 1110 | OS << "\t.cv_stringtable"; |
| 1111 | EmitEOL(); |
| 1112 | } |
| 1113 | |
| 1114 | void MCAsmStreamer::EmitCVFileChecksumsDirective() { |
| 1115 | OS << "\t.cv_filechecksums"; |
| 1116 | EmitEOL(); |
| 1117 | } |
| 1118 | |
Rafael Espindola | 5645bad | 2013-10-16 01:05:45 +0000 | [diff] [blame] | 1119 | void 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 Espindola | ec53aa9 | 2011-05-10 13:39:48 +0000 | [diff] [blame] | 1126 | void MCAsmStreamer::EmitCFISections(bool EH, bool Debug) { |
| 1127 | MCStreamer::EmitCFISections(EH, Debug); |
Rafael Espindola | ec53aa9 | 2011-05-10 13:39:48 +0000 | [diff] [blame] | 1128 | 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 Stannard | cf6bfb1 | 2014-11-03 12:19:03 +0000 | [diff] [blame] | 1140 | void MCAsmStreamer::EmitCFIStartProcImpl(MCDwarfFrameInfo &Frame) { |
Anton Korobeynikov | e2bea1c | 2011-01-14 21:57:39 +0000 | [diff] [blame] | 1141 | OS << "\t.cfi_startproc"; |
David Majnemer | e035cf9 | 2014-01-27 17:20:25 +0000 | [diff] [blame] | 1142 | if (Frame.IsSimple) |
| 1143 | OS << " simple"; |
Rafael Espindola | 3c227b0 | 2010-11-22 14:27:24 +0000 | [diff] [blame] | 1144 | EmitEOL(); |
Rafael Espindola | 3c227b0 | 2010-11-22 14:27:24 +0000 | [diff] [blame] | 1145 | } |
| 1146 | |
Rafael Espindola | f28213c | 2012-01-09 00:17:29 +0000 | [diff] [blame] | 1147 | void MCAsmStreamer::EmitCFIEndProcImpl(MCDwarfFrameInfo &Frame) { |
Rafael Espindola | 49bbfd0 | 2014-06-25 00:13:59 +0000 | [diff] [blame] | 1148 | MCStreamer::EmitCFIEndProcImpl(Frame); |
Anton Korobeynikov | e2bea1c | 2011-01-14 21:57:39 +0000 | [diff] [blame] | 1149 | OS << "\t.cfi_endproc"; |
Rafael Espindola | 3c227b0 | 2010-11-22 14:27:24 +0000 | [diff] [blame] | 1150 | EmitEOL(); |
Rafael Espindola | 3c227b0 | 2010-11-22 14:27:24 +0000 | [diff] [blame] | 1151 | } |
| 1152 | |
Rafael Espindola | 08600bc | 2011-05-30 20:20:15 +0000 | [diff] [blame] | 1153 | void MCAsmStreamer::EmitRegisterName(int64_t Register) { |
Rafael Espindola | 691a5ad | 2015-05-27 12:13:06 +0000 | [diff] [blame] | 1154 | if (!MAI->useDwarfRegNumForCFI()) { |
Bill Wendling | bc07a89 | 2013-06-18 07:20:20 +0000 | [diff] [blame] | 1155 | const MCRegisterInfo *MRI = getContext().getRegisterInfo(); |
| 1156 | unsigned LLVMRegister = MRI->getLLVMRegNum(Register, true); |
Rafael Espindola | d686052 | 2011-06-02 02:34:55 +0000 | [diff] [blame] | 1157 | InstPrinter->printRegName(OS, LLVMRegister); |
Rafael Espindola | 08600bc | 2011-05-30 20:20:15 +0000 | [diff] [blame] | 1158 | } else { |
| 1159 | OS << Register; |
| 1160 | } |
| 1161 | } |
| 1162 | |
Rafael Espindola | 539d96f | 2011-04-12 23:59:07 +0000 | [diff] [blame] | 1163 | void MCAsmStreamer::EmitCFIDefCfa(int64_t Register, int64_t Offset) { |
Rafael Espindola | 6c961e1 | 2011-04-29 21:41:06 +0000 | [diff] [blame] | 1164 | MCStreamer::EmitCFIDefCfa(Register, Offset); |
Rafael Espindola | 08600bc | 2011-05-30 20:20:15 +0000 | [diff] [blame] | 1165 | OS << "\t.cfi_def_cfa "; |
| 1166 | EmitRegisterName(Register); |
| 1167 | OS << ", " << Offset; |
Rafael Espindola | 6c961e1 | 2011-04-29 21:41:06 +0000 | [diff] [blame] | 1168 | EmitEOL(); |
Rafael Espindola | 539d96f | 2011-04-12 23:59:07 +0000 | [diff] [blame] | 1169 | } |
| 1170 | |
| 1171 | void MCAsmStreamer::EmitCFIDefCfaOffset(int64_t Offset) { |
| 1172 | MCStreamer::EmitCFIDefCfaOffset(Offset); |
Anton Korobeynikov | e2bea1c | 2011-01-14 21:57:39 +0000 | [diff] [blame] | 1173 | OS << "\t.cfi_def_cfa_offset " << Offset; |
Rafael Espindola | 3c227b0 | 2010-11-22 14:27:24 +0000 | [diff] [blame] | 1174 | EmitEOL(); |
Rafael Espindola | 3c227b0 | 2010-11-22 14:27:24 +0000 | [diff] [blame] | 1175 | } |
| 1176 | |
Michael Kuperstein | 259f150 | 2015-10-07 07:01:31 +0000 | [diff] [blame] | 1177 | static 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 | |
| 1187 | void MCAsmStreamer::EmitCFIEscape(StringRef Values) { |
| 1188 | MCStreamer::EmitCFIEscape(Values); |
| 1189 | PrintCFIEscape(OS, Values); |
| 1190 | EmitEOL(); |
| 1191 | } |
| 1192 | |
| 1193 | void 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 Espindola | 539d96f | 2011-04-12 23:59:07 +0000 | [diff] [blame] | 1203 | void MCAsmStreamer::EmitCFIDefCfaRegister(int64_t Register) { |
| 1204 | MCStreamer::EmitCFIDefCfaRegister(Register); |
Rafael Espindola | 08600bc | 2011-05-30 20:20:15 +0000 | [diff] [blame] | 1205 | OS << "\t.cfi_def_cfa_register "; |
| 1206 | EmitRegisterName(Register); |
Rafael Espindola | 3c227b0 | 2010-11-22 14:27:24 +0000 | [diff] [blame] | 1207 | EmitEOL(); |
Rafael Espindola | 3c227b0 | 2010-11-22 14:27:24 +0000 | [diff] [blame] | 1208 | } |
| 1209 | |
Rafael Espindola | 539d96f | 2011-04-12 23:59:07 +0000 | [diff] [blame] | 1210 | void MCAsmStreamer::EmitCFIOffset(int64_t Register, int64_t Offset) { |
| 1211 | this->MCStreamer::EmitCFIOffset(Register, Offset); |
Rafael Espindola | 08600bc | 2011-05-30 20:20:15 +0000 | [diff] [blame] | 1212 | OS << "\t.cfi_offset "; |
| 1213 | EmitRegisterName(Register); |
| 1214 | OS << ", " << Offset; |
Rafael Espindola | 3c227b0 | 2010-11-22 14:27:24 +0000 | [diff] [blame] | 1215 | EmitEOL(); |
Rafael Espindola | 3c227b0 | 2010-11-22 14:27:24 +0000 | [diff] [blame] | 1216 | } |
| 1217 | |
Rafael Espindola | 539d96f | 2011-04-12 23:59:07 +0000 | [diff] [blame] | 1218 | void MCAsmStreamer::EmitCFIPersonality(const MCSymbol *Sym, |
Rafael Espindola | 2ac8355 | 2010-12-27 00:36:05 +0000 | [diff] [blame] | 1219 | unsigned Encoding) { |
Rafael Espindola | 539d96f | 2011-04-12 23:59:07 +0000 | [diff] [blame] | 1220 | MCStreamer::EmitCFIPersonality(Sym, Encoding); |
Matt Arsenault | 8b64355 | 2015-06-09 00:31:39 +0000 | [diff] [blame] | 1221 | OS << "\t.cfi_personality " << Encoding << ", "; |
| 1222 | Sym->print(OS, MAI); |
Rafael Espindola | 3c227b0 | 2010-11-22 14:27:24 +0000 | [diff] [blame] | 1223 | EmitEOL(); |
Rafael Espindola | 3c227b0 | 2010-11-22 14:27:24 +0000 | [diff] [blame] | 1224 | } |
| 1225 | |
Rafael Espindola | 539d96f | 2011-04-12 23:59:07 +0000 | [diff] [blame] | 1226 | void MCAsmStreamer::EmitCFILsda(const MCSymbol *Sym, unsigned Encoding) { |
| 1227 | MCStreamer::EmitCFILsda(Sym, Encoding); |
Matt Arsenault | 8b64355 | 2015-06-09 00:31:39 +0000 | [diff] [blame] | 1228 | OS << "\t.cfi_lsda " << Encoding << ", "; |
| 1229 | Sym->print(OS, MAI); |
Rafael Espindola | 3c227b0 | 2010-11-22 14:27:24 +0000 | [diff] [blame] | 1230 | EmitEOL(); |
Rafael Espindola | 539d96f | 2011-04-12 23:59:07 +0000 | [diff] [blame] | 1231 | } |
Rafael Espindola | 3c227b0 | 2010-11-22 14:27:24 +0000 | [diff] [blame] | 1232 | |
Rafael Espindola | 539d96f | 2011-04-12 23:59:07 +0000 | [diff] [blame] | 1233 | void MCAsmStreamer::EmitCFIRememberState() { |
| 1234 | MCStreamer::EmitCFIRememberState(); |
Rafael Espindola | 539d96f | 2011-04-12 23:59:07 +0000 | [diff] [blame] | 1235 | OS << "\t.cfi_remember_state"; |
| 1236 | EmitEOL(); |
| 1237 | } |
| 1238 | |
| 1239 | void MCAsmStreamer::EmitCFIRestoreState() { |
| 1240 | MCStreamer::EmitCFIRestoreState(); |
Rafael Espindola | 539d96f | 2011-04-12 23:59:07 +0000 | [diff] [blame] | 1241 | OS << "\t.cfi_restore_state"; |
| 1242 | EmitEOL(); |
| 1243 | } |
| 1244 | |
| 1245 | void MCAsmStreamer::EmitCFISameValue(int64_t Register) { |
| 1246 | MCStreamer::EmitCFISameValue(Register); |
Rafael Espindola | 08600bc | 2011-05-30 20:20:15 +0000 | [diff] [blame] | 1247 | OS << "\t.cfi_same_value "; |
| 1248 | EmitRegisterName(Register); |
Rafael Espindola | 539d96f | 2011-04-12 23:59:07 +0000 | [diff] [blame] | 1249 | EmitEOL(); |
| 1250 | } |
| 1251 | |
| 1252 | void MCAsmStreamer::EmitCFIRelOffset(int64_t Register, int64_t Offset) { |
| 1253 | MCStreamer::EmitCFIRelOffset(Register, Offset); |
Rafael Espindola | 08600bc | 2011-05-30 20:20:15 +0000 | [diff] [blame] | 1254 | OS << "\t.cfi_rel_offset "; |
| 1255 | EmitRegisterName(Register); |
| 1256 | OS << ", " << Offset; |
Rafael Espindola | 539d96f | 2011-04-12 23:59:07 +0000 | [diff] [blame] | 1257 | EmitEOL(); |
| 1258 | } |
| 1259 | |
| 1260 | void MCAsmStreamer::EmitCFIAdjustCfaOffset(int64_t Adjustment) { |
| 1261 | MCStreamer::EmitCFIAdjustCfaOffset(Adjustment); |
Rafael Espindola | 539d96f | 2011-04-12 23:59:07 +0000 | [diff] [blame] | 1262 | OS << "\t.cfi_adjust_cfa_offset " << Adjustment; |
| 1263 | EmitEOL(); |
Rafael Espindola | 3c227b0 | 2010-11-22 14:27:24 +0000 | [diff] [blame] | 1264 | } |
| 1265 | |
Rafael Espindola | 3c47e37 | 2012-01-23 21:51:52 +0000 | [diff] [blame] | 1266 | void MCAsmStreamer::EmitCFISignalFrame() { |
| 1267 | MCStreamer::EmitCFISignalFrame(); |
Eric Christopher | 368461c | 2012-05-31 00:53:18 +0000 | [diff] [blame] | 1268 | OS << "\t.cfi_signal_frame"; |
Rafael Espindola | 3c47e37 | 2012-01-23 21:51:52 +0000 | [diff] [blame] | 1269 | EmitEOL(); |
| 1270 | } |
| 1271 | |
Rafael Espindola | 9bb2478 | 2012-11-23 16:59:41 +0000 | [diff] [blame] | 1272 | void MCAsmStreamer::EmitCFIUndefined(int64_t Register) { |
| 1273 | MCStreamer::EmitCFIUndefined(Register); |
Rafael Espindola | 9bb2478 | 2012-11-23 16:59:41 +0000 | [diff] [blame] | 1274 | OS << "\t.cfi_undefined " << Register; |
| 1275 | EmitEOL(); |
| 1276 | } |
| 1277 | |
Rafael Espindola | cdb9a53 | 2012-11-25 15:14:49 +0000 | [diff] [blame] | 1278 | void MCAsmStreamer::EmitCFIRegister(int64_t Register1, int64_t Register2) { |
| 1279 | MCStreamer::EmitCFIRegister(Register1, Register2); |
Rafael Espindola | cdb9a53 | 2012-11-25 15:14:49 +0000 | [diff] [blame] | 1280 | OS << "\t.cfi_register " << Register1 << ", " << Register2; |
| 1281 | EmitEOL(); |
| 1282 | } |
| 1283 | |
Venkatraman Govindaraju | 3816d43 | 2013-09-26 14:49:40 +0000 | [diff] [blame] | 1284 | void MCAsmStreamer::EmitCFIWindowSave() { |
| 1285 | MCStreamer::EmitCFIWindowSave(); |
Venkatraman Govindaraju | 3816d43 | 2013-09-26 14:49:40 +0000 | [diff] [blame] | 1286 | OS << "\t.cfi_window_save"; |
| 1287 | EmitEOL(); |
| 1288 | } |
| 1289 | |
Saleem Abdulrasool | 7206a52 | 2014-06-29 01:52:01 +0000 | [diff] [blame] | 1290 | void MCAsmStreamer::EmitWinCFIStartProc(const MCSymbol *Symbol) { |
| 1291 | MCStreamer::EmitWinCFIStartProc(Symbol); |
Charles Davis | 9a115a4 | 2011-05-20 18:19:22 +0000 | [diff] [blame] | 1292 | |
Matt Arsenault | 8b64355 | 2015-06-09 00:31:39 +0000 | [diff] [blame] | 1293 | OS << ".seh_proc "; |
| 1294 | Symbol->print(OS, MAI); |
Charles Davis | 8d9c990 | 2011-05-18 04:58:05 +0000 | [diff] [blame] | 1295 | EmitEOL(); |
| 1296 | } |
| 1297 | |
Saleem Abdulrasool | 7206a52 | 2014-06-29 01:52:01 +0000 | [diff] [blame] | 1298 | void MCAsmStreamer::EmitWinCFIEndProc() { |
| 1299 | MCStreamer::EmitWinCFIEndProc(); |
Charles Davis | 9a115a4 | 2011-05-20 18:19:22 +0000 | [diff] [blame] | 1300 | |
Charles Davis | 4cd8856 | 2011-05-19 17:46:39 +0000 | [diff] [blame] | 1301 | OS << "\t.seh_endproc"; |
Charles Davis | 8d9c990 | 2011-05-18 04:58:05 +0000 | [diff] [blame] | 1302 | EmitEOL(); |
| 1303 | } |
| 1304 | |
Saleem Abdulrasool | 7206a52 | 2014-06-29 01:52:01 +0000 | [diff] [blame] | 1305 | void MCAsmStreamer::EmitWinCFIStartChained() { |
| 1306 | MCStreamer::EmitWinCFIStartChained(); |
Charles Davis | 9a115a4 | 2011-05-20 18:19:22 +0000 | [diff] [blame] | 1307 | |
Charles Davis | 4cd8856 | 2011-05-19 17:46:39 +0000 | [diff] [blame] | 1308 | OS << "\t.seh_startchained"; |
Charles Davis | 77e0610 | 2011-05-18 20:54:10 +0000 | [diff] [blame] | 1309 | EmitEOL(); |
| 1310 | } |
| 1311 | |
Saleem Abdulrasool | 7206a52 | 2014-06-29 01:52:01 +0000 | [diff] [blame] | 1312 | void MCAsmStreamer::EmitWinCFIEndChained() { |
| 1313 | MCStreamer::EmitWinCFIEndChained(); |
Charles Davis | 9a115a4 | 2011-05-20 18:19:22 +0000 | [diff] [blame] | 1314 | |
Charles Davis | 4cd8856 | 2011-05-19 17:46:39 +0000 | [diff] [blame] | 1315 | OS << "\t.seh_endchained"; |
Charles Davis | 77e0610 | 2011-05-18 20:54:10 +0000 | [diff] [blame] | 1316 | EmitEOL(); |
| 1317 | } |
| 1318 | |
Saleem Abdulrasool | 7206a52 | 2014-06-29 01:52:01 +0000 | [diff] [blame] | 1319 | void MCAsmStreamer::EmitWinEHHandler(const MCSymbol *Sym, bool Unwind, |
| 1320 | bool Except) { |
| 1321 | MCStreamer::EmitWinEHHandler(Sym, Unwind, Except); |
Charles Davis | 9a115a4 | 2011-05-20 18:19:22 +0000 | [diff] [blame] | 1322 | |
Matt Arsenault | 8b64355 | 2015-06-09 00:31:39 +0000 | [diff] [blame] | 1323 | OS << "\t.seh_handler "; |
| 1324 | Sym->print(OS, MAI); |
Charles Davis | 4cd8856 | 2011-05-19 17:46:39 +0000 | [diff] [blame] | 1325 | if (Unwind) |
| 1326 | OS << ", @unwind"; |
| 1327 | if (Except) |
| 1328 | OS << ", @except"; |
Charles Davis | 77e0610 | 2011-05-18 20:54:10 +0000 | [diff] [blame] | 1329 | EmitEOL(); |
| 1330 | } |
| 1331 | |
Saleem Abdulrasool | 7206a52 | 2014-06-29 01:52:01 +0000 | [diff] [blame] | 1332 | void MCAsmStreamer::EmitWinEHHandlerData() { |
| 1333 | MCStreamer::EmitWinEHHandlerData(); |
Charles Davis | 9a115a4 | 2011-05-20 18:19:22 +0000 | [diff] [blame] | 1334 | |
Charles Davis | 2f6ecea | 2011-05-25 21:43:45 +0000 | [diff] [blame] | 1335 | // 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 Abdulrasool | b3be737 | 2014-08-03 18:51:17 +0000 | [diff] [blame] | 1339 | WinEH::FrameInfo *CurFrame = getCurrentWinFrameInfo(); |
Reid Kleckner | 97837b7 | 2016-05-02 23:22:18 +0000 | [diff] [blame] | 1340 | MCSection *TextSec = &CurFrame->Function->getSection(); |
| 1341 | MCSection *XData = getAssociatedXDataSection(TextSec); |
Reid Kleckner | 1d3d4ad | 2015-05-29 17:00:57 +0000 | [diff] [blame] | 1342 | SwitchSectionNoChange(XData); |
Charles Davis | 2f6ecea | 2011-05-25 21:43:45 +0000 | [diff] [blame] | 1343 | |
Charles Davis | 4cd8856 | 2011-05-19 17:46:39 +0000 | [diff] [blame] | 1344 | OS << "\t.seh_handlerdata"; |
Charles Davis | 77e0610 | 2011-05-18 20:54:10 +0000 | [diff] [blame] | 1345 | EmitEOL(); |
| 1346 | } |
| 1347 | |
Saleem Abdulrasool | 7206a52 | 2014-06-29 01:52:01 +0000 | [diff] [blame] | 1348 | void MCAsmStreamer::EmitWinCFIPushReg(unsigned Register) { |
| 1349 | MCStreamer::EmitWinCFIPushReg(Register); |
Charles Davis | 9a115a4 | 2011-05-20 18:19:22 +0000 | [diff] [blame] | 1350 | |
Reid Kleckner | b01961c | 2014-06-10 20:16:36 +0000 | [diff] [blame] | 1351 | OS << "\t.seh_pushreg " << Register; |
Charles Davis | 8d9c990 | 2011-05-18 04:58:05 +0000 | [diff] [blame] | 1352 | EmitEOL(); |
| 1353 | } |
| 1354 | |
Saleem Abdulrasool | 7206a52 | 2014-06-29 01:52:01 +0000 | [diff] [blame] | 1355 | void MCAsmStreamer::EmitWinCFISetFrame(unsigned Register, unsigned Offset) { |
| 1356 | MCStreamer::EmitWinCFISetFrame(Register, Offset); |
Charles Davis | 9a115a4 | 2011-05-20 18:19:22 +0000 | [diff] [blame] | 1357 | |
Reid Kleckner | b01961c | 2014-06-10 20:16:36 +0000 | [diff] [blame] | 1358 | OS << "\t.seh_setframe " << Register << ", " << Offset; |
Charles Davis | 8d9c990 | 2011-05-18 04:58:05 +0000 | [diff] [blame] | 1359 | EmitEOL(); |
| 1360 | } |
| 1361 | |
Saleem Abdulrasool | 7206a52 | 2014-06-29 01:52:01 +0000 | [diff] [blame] | 1362 | void MCAsmStreamer::EmitWinCFIAllocStack(unsigned Size) { |
| 1363 | MCStreamer::EmitWinCFIAllocStack(Size); |
Charles Davis | 9a115a4 | 2011-05-20 18:19:22 +0000 | [diff] [blame] | 1364 | |
Charles Davis | 4cd8856 | 2011-05-19 17:46:39 +0000 | [diff] [blame] | 1365 | OS << "\t.seh_stackalloc " << Size; |
Charles Davis | 8d9c990 | 2011-05-18 04:58:05 +0000 | [diff] [blame] | 1366 | EmitEOL(); |
| 1367 | } |
| 1368 | |
Saleem Abdulrasool | 7206a52 | 2014-06-29 01:52:01 +0000 | [diff] [blame] | 1369 | void MCAsmStreamer::EmitWinCFISaveReg(unsigned Register, unsigned Offset) { |
| 1370 | MCStreamer::EmitWinCFISaveReg(Register, Offset); |
Charles Davis | 9a115a4 | 2011-05-20 18:19:22 +0000 | [diff] [blame] | 1371 | |
Reid Kleckner | b01961c | 2014-06-10 20:16:36 +0000 | [diff] [blame] | 1372 | OS << "\t.seh_savereg " << Register << ", " << Offset; |
Charles Davis | 4cd8856 | 2011-05-19 17:46:39 +0000 | [diff] [blame] | 1373 | EmitEOL(); |
| 1374 | } |
| 1375 | |
Saleem Abdulrasool | 7206a52 | 2014-06-29 01:52:01 +0000 | [diff] [blame] | 1376 | void MCAsmStreamer::EmitWinCFISaveXMM(unsigned Register, unsigned Offset) { |
| 1377 | MCStreamer::EmitWinCFISaveXMM(Register, Offset); |
Charles Davis | 9a115a4 | 2011-05-20 18:19:22 +0000 | [diff] [blame] | 1378 | |
Reid Kleckner | b01961c | 2014-06-10 20:16:36 +0000 | [diff] [blame] | 1379 | OS << "\t.seh_savexmm " << Register << ", " << Offset; |
Charles Davis | 8d9c990 | 2011-05-18 04:58:05 +0000 | [diff] [blame] | 1380 | EmitEOL(); |
| 1381 | } |
| 1382 | |
Saleem Abdulrasool | 7206a52 | 2014-06-29 01:52:01 +0000 | [diff] [blame] | 1383 | void MCAsmStreamer::EmitWinCFIPushFrame(bool Code) { |
| 1384 | MCStreamer::EmitWinCFIPushFrame(Code); |
Charles Davis | 9a115a4 | 2011-05-20 18:19:22 +0000 | [diff] [blame] | 1385 | |
Charles Davis | 4cd8856 | 2011-05-19 17:46:39 +0000 | [diff] [blame] | 1386 | OS << "\t.seh_pushframe"; |
Charles Davis | 8d9c990 | 2011-05-18 04:58:05 +0000 | [diff] [blame] | 1387 | if (Code) |
Charles Davis | 4cd8856 | 2011-05-19 17:46:39 +0000 | [diff] [blame] | 1388 | OS << " @code"; |
Charles Davis | 8d9c990 | 2011-05-18 04:58:05 +0000 | [diff] [blame] | 1389 | EmitEOL(); |
| 1390 | } |
| 1391 | |
Eugene Zelenko | ffec81c | 2015-11-04 22:32:32 +0000 | [diff] [blame] | 1392 | void MCAsmStreamer::EmitWinCFIEndProlog() { |
Saleem Abdulrasool | 7206a52 | 2014-06-29 01:52:01 +0000 | [diff] [blame] | 1393 | MCStreamer::EmitWinCFIEndProlog(); |
Charles Davis | 9a115a4 | 2011-05-20 18:19:22 +0000 | [diff] [blame] | 1394 | |
Charles Davis | 4cd8856 | 2011-05-19 17:46:39 +0000 | [diff] [blame] | 1395 | OS << "\t.seh_endprologue"; |
Charles Davis | 8d9c990 | 2011-05-18 04:58:05 +0000 | [diff] [blame] | 1396 | EmitEOL(); |
| 1397 | } |
| 1398 | |
David Woodhouse | 9784cef | 2014-01-28 23:13:07 +0000 | [diff] [blame] | 1399 | void MCAsmStreamer::AddEncodingComment(const MCInst &Inst, |
| 1400 | const MCSubtargetInfo &STI) { |
Daniel Dunbar | 9a0a461 | 2010-02-09 23:00:14 +0000 | [diff] [blame] | 1401 | raw_ostream &OS = GetCommentOS(); |
| 1402 | SmallString<256> Code; |
| 1403 | SmallVector<MCFixup, 4> Fixups; |
Alp Toker | e69170a | 2014-06-26 22:52:05 +0000 | [diff] [blame] | 1404 | raw_svector_ostream VecOS(Code); |
Jim Grosbach | 91df21f | 2015-05-15 19:13:16 +0000 | [diff] [blame] | 1405 | Emitter->encodeInstruction(Inst, VecOS, Fixups, STI); |
Chris Lattner | 601ef33 | 2010-01-25 18:58:59 +0000 | [diff] [blame] | 1406 | |
Daniel Dunbar | 9a0a461 | 2010-02-09 23:00:14 +0000 | [diff] [blame] | 1407 | // 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 Dunbar | 75c9a4e | 2010-02-10 01:41:14 +0000 | [diff] [blame] | 1410 | SmallVector<uint8_t, 64> FixupMap; |
| 1411 | FixupMap.resize(Code.size() * 8); |
Daniel Dunbar | 9a0a461 | 2010-02-09 23:00:14 +0000 | [diff] [blame] | 1412 | 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 Dunbar | 0c9d9fd | 2010-12-16 03:20:06 +0000 | [diff] [blame] | 1417 | const MCFixupKindInfo &Info = AsmBackend->getFixupKindInfo(F.getKind()); |
Daniel Dunbar | 9a0a461 | 2010-02-09 23:00:14 +0000 | [diff] [blame] | 1418 | 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 Cheng | 15bc70f | 2011-07-08 22:49:42 +0000 | [diff] [blame] | 1425 | // FIXME: Note the fixup comments for Thumb2 are completely bogus since the |
Evan Cheng | 52899a9 | 2011-01-13 23:27:39 +0000 | [diff] [blame] | 1426 | // high order halfword of a 32-bit Thumb2 instruction is emitted first. |
Daniel Dunbar | 9a0a461 | 2010-02-09 23:00:14 +0000 | [diff] [blame] | 1427 | 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 Cheng | 0447d30 | 2011-01-13 21:45:26 +0000 | [diff] [blame] | 1446 | if (Code[i]) { |
Evan Cheng | 52899a9 | 2011-01-13 23:27:39 +0000 | [diff] [blame] | 1447 | // FIXME: Some of the 8 bits require fix up. |
Evan Cheng | 0447d30 | 2011-01-13 21:45:26 +0000 | [diff] [blame] | 1448 | OS << format("0x%02x", uint8_t(Code[i])) << '\'' |
| 1449 | << char('A' + MapEntry - 1) << '\''; |
| 1450 | } else |
| 1451 | OS << char('A' + MapEntry - 1); |
Daniel Dunbar | 9a0a461 | 2010-02-09 23:00:14 +0000 | [diff] [blame] | 1452 | } |
| 1453 | } else { |
| 1454 | // Otherwise, write out in binary. |
| 1455 | OS << "0b"; |
Jay Foad | 61ea0e4 | 2011-06-23 09:09:15 +0000 | [diff] [blame] | 1456 | for (unsigned j = 8; j--;) { |
Daniel Dunbar | 9a0a461 | 2010-02-09 23:00:14 +0000 | [diff] [blame] | 1457 | unsigned Bit = (Code[i] >> j) & 1; |
NAKAMURA Takumi | af66980 | 2011-03-27 01:44:40 +0000 | [diff] [blame] | 1458 | |
Chris Lattner | 9e7d8c0 | 2010-11-15 05:56:19 +0000 | [diff] [blame] | 1459 | unsigned FixupBit; |
Bill Wendling | bc07a89 | 2013-06-18 07:20:20 +0000 | [diff] [blame] | 1460 | if (MAI->isLittleEndian()) |
Chris Lattner | 9e7d8c0 | 2010-11-15 05:56:19 +0000 | [diff] [blame] | 1461 | FixupBit = i * 8 + j; |
| 1462 | else |
| 1463 | FixupBit = i * 8 + (7-j); |
NAKAMURA Takumi | af66980 | 2011-03-27 01:44:40 +0000 | [diff] [blame] | 1464 | |
Jay Foad | 61ea0e4 | 2011-06-23 09:09:15 +0000 | [diff] [blame] | 1465 | if (uint8_t MapEntry = FixupMap[FixupBit]) { |
| 1466 | assert(Bit == 0 && "Encoder wrote into fixed up bit!"); |
| 1467 | OS << char('A' + MapEntry - 1); |
Daniel Dunbar | 9a0a461 | 2010-02-09 23:00:14 +0000 | [diff] [blame] | 1468 | } 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 Dunbar | 0c9d9fd | 2010-12-16 03:20:06 +0000 | [diff] [blame] | 1477 | const MCFixupKindInfo &Info = AsmBackend->getFixupKindInfo(F.getKind()); |
Daniel Dunbar | 9a0a461 | 2010-02-09 23:00:14 +0000 | [diff] [blame] | 1478 | OS << " fixup " << char('A' + i) << " - " << "offset: " << F.getOffset() |
Daniel Dunbar | 6054744 | 2010-02-10 04:47:08 +0000 | [diff] [blame] | 1479 | << ", value: " << *F.getValue() << ", kind: " << Info.Name << "\n"; |
Daniel Dunbar | 9a0a461 | 2010-02-09 23:00:14 +0000 | [diff] [blame] | 1480 | } |
| 1481 | } |
| 1482 | |
David Woodhouse | e6c13e4 | 2014-01-28 23:12:42 +0000 | [diff] [blame] | 1483 | void MCAsmStreamer::EmitInstruction(const MCInst &Inst, const MCSubtargetInfo &STI) { |
Peter Collingbourne | 2f495b9 | 2013-04-17 21:18:16 +0000 | [diff] [blame] | 1484 | assert(getCurrentSection().first && |
| 1485 | "Cannot emit contents before setting section!"); |
Daniel Dunbar | 9a0a461 | 2010-02-09 23:00:14 +0000 | [diff] [blame] | 1486 | |
| 1487 | // Show the encoding in a comment if we have a code emitter. |
| 1488 | if (Emitter) |
David Woodhouse | 9784cef | 2014-01-28 23:13:07 +0000 | [diff] [blame] | 1489 | AddEncodingComment(Inst, STI); |
Daniel Dunbar | 9a0a461 | 2010-02-09 23:00:14 +0000 | [diff] [blame] | 1490 | |
Chris Lattner | 8926150 | 2010-02-09 00:54:51 +0000 | [diff] [blame] | 1491 | // Show the MCInst if enabled. |
Daniel Dunbar | 3627af5 | 2010-05-26 15:18:13 +0000 | [diff] [blame] | 1492 | if (ShowInst) { |
Sean Silva | 0e1fe18 | 2015-02-05 00:58:51 +0000 | [diff] [blame] | 1493 | Inst.dump_pretty(GetCommentOS(), InstPrinter.get(), "\n "); |
Daniel Dunbar | 3627af5 | 2010-05-26 15:18:13 +0000 | [diff] [blame] | 1494 | GetCommentOS() << "\n"; |
| 1495 | } |
| 1496 | |
Colin LeMahieu | 48a9b71 | 2015-06-18 20:43:22 +0000 | [diff] [blame] | 1497 | if(getTargetStreamer()) |
| 1498 | getTargetStreamer()->prettyPrintAsm(*InstPrinter, OS, Inst, STI); |
| 1499 | else |
| 1500 | InstPrinter->printInst(&Inst, OS, "", STI); |
Rafael Espindola | 691a5ad | 2015-05-27 12:13:06 +0000 | [diff] [blame] | 1501 | |
Chris Lattner | cfa5ebc3 | 2010-01-22 07:36:39 +0000 | [diff] [blame] | 1502 | EmitEOL(); |
Daniel Dunbar | 9faf273 | 2009-06-24 01:03:06 +0000 | [diff] [blame] | 1503 | } |
| 1504 | |
Eli Bendersky | f483ff9 | 2012-12-20 19:05:53 +0000 | [diff] [blame] | 1505 | void MCAsmStreamer::EmitBundleAlignMode(unsigned AlignPow2) { |
| 1506 | OS << "\t.bundle_align_mode " << AlignPow2; |
| 1507 | EmitEOL(); |
| 1508 | } |
| 1509 | |
Eli Bendersky | 802b628 | 2013-01-07 21:51:08 +0000 | [diff] [blame] | 1510 | void MCAsmStreamer::EmitBundleLock(bool AlignToEnd) { |
Eli Bendersky | f483ff9 | 2012-12-20 19:05:53 +0000 | [diff] [blame] | 1511 | OS << "\t.bundle_lock"; |
Eli Bendersky | 802b628 | 2013-01-07 21:51:08 +0000 | [diff] [blame] | 1512 | if (AlignToEnd) |
| 1513 | OS << " align_to_end"; |
Eli Bendersky | f483ff9 | 2012-12-20 19:05:53 +0000 | [diff] [blame] | 1514 | EmitEOL(); |
| 1515 | } |
| 1516 | |
| 1517 | void MCAsmStreamer::EmitBundleUnlock() { |
| 1518 | OS << "\t.bundle_unlock"; |
| 1519 | EmitEOL(); |
| 1520 | } |
| 1521 | |
Daniel Sanders | 9f6ad49 | 2015-11-12 13:33:00 +0000 | [diff] [blame] | 1522 | bool 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 Grosbach | 6ebd728 | 2010-09-22 18:18:30 +0000 | [diff] [blame] | 1535 | /// EmitRawText - If this file is backed by an assembly streamer, this dumps |
Chris Lattner | 8a87fb7 | 2010-04-03 21:35:55 +0000 | [diff] [blame] | 1536 | /// the specified string in the output .s file. This capability is |
| 1537 | /// indicated by the hasRawTextSupport() predicate. |
David Blaikie | d8c5b4e | 2013-10-24 22:43:10 +0000 | [diff] [blame] | 1538 | void MCAsmStreamer::EmitRawTextImpl(StringRef String) { |
Chris Lattner | aca014e | 2010-04-03 22:06:56 +0000 | [diff] [blame] | 1539 | if (!String.empty() && String.back() == '\n') |
| 1540 | String = String.substr(0, String.size()-1); |
Chris Lattner | 8a87fb7 | 2010-04-03 21:35:55 +0000 | [diff] [blame] | 1541 | OS << String; |
Chris Lattner | aca014e | 2010-04-03 22:06:56 +0000 | [diff] [blame] | 1542 | EmitEOL(); |
Chris Lattner | 8a87fb7 | 2010-04-03 21:35:55 +0000 | [diff] [blame] | 1543 | } |
| 1544 | |
Rafael Espindola | 0708209 | 2012-01-07 03:13:18 +0000 | [diff] [blame] | 1545 | void MCAsmStreamer::FinishImpl() { |
Kevin Enderby | e7739d4 | 2011-12-09 18:09:40 +0000 | [diff] [blame] | 1546 | // If we are generating dwarf for assembly source files dump out the sections. |
| 1547 | if (getContext().getGenDwarfForAssembly()) |
David Blaikie | 8bf66c4 | 2014-04-01 07:35:52 +0000 | [diff] [blame] | 1548 | 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 Blaikie | 3464161 | 2014-04-01 08:07:52 +0000 | [diff] [blame] | 1555 | assert(Tables.size() == 1 && "asm output only supports one line table"); |
David Blaikie | 8bf66c4 | 2014-04-01 07:35:52 +0000 | [diff] [blame] | 1556 | if (auto *Label = Tables.begin()->second.getLabel()) { |
| 1557 | SwitchSection(getContext().getObjectFileInfo()->getDwarfLineSection()); |
| 1558 | EmitLabel(Label); |
| 1559 | } |
| 1560 | } |
Daniel Dunbar | 9faf273 | 2009-06-24 01:03:06 +0000 | [diff] [blame] | 1561 | } |
Bill Wendling | 550c76d | 2013-09-09 19:48:37 +0000 | [diff] [blame] | 1562 | |
Chris Lattner | 38e9219 | 2010-01-22 07:29:22 +0000 | [diff] [blame] | 1563 | MCStreamer *llvm::createAsmStreamer(MCContext &Context, |
Rafael Espindola | 5682ce2 | 2015-04-09 21:06:08 +0000 | [diff] [blame] | 1564 | std::unique_ptr<formatted_raw_ostream> OS, |
Rafael Espindola | 566fcfe | 2014-05-07 13:00:43 +0000 | [diff] [blame] | 1565 | bool isVerboseAsm, bool useDwarfDirectory, |
| 1566 | MCInstPrinter *IP, MCCodeEmitter *CE, |
| 1567 | MCAsmBackend *MAB, bool ShowInst) { |
Rafael Espindola | 5682ce2 | 2015-04-09 21:06:08 +0000 | [diff] [blame] | 1568 | return new MCAsmStreamer(Context, std::move(OS), isVerboseAsm, |
| 1569 | useDwarfDirectory, IP, CE, MAB, ShowInst); |
Daniel Dunbar | 9faf273 | 2009-06-24 01:03:06 +0000 | [diff] [blame] | 1570 | } |