1 //===- lib/MC/MCAsmStreamer.cpp - Text Assembly Output --------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 #include "llvm/MC/MCStreamer.h"
11 #include "llvm/ADT/OwningPtr.h"
12 #include "llvm/ADT/SmallString.h"
13 #include "llvm/ADT/StringExtras.h"
14 #include "llvm/ADT/Twine.h"
15 #include "llvm/MC/MCAsmBackend.h"
16 #include "llvm/MC/MCAsmInfo.h"
17 #include "llvm/MC/MCCodeEmitter.h"
18 #include "llvm/MC/MCContext.h"
19 #include "llvm/MC/MCExpr.h"
20 #include "llvm/MC/MCFixupKindInfo.h"
21 #include "llvm/MC/MCInst.h"
22 #include "llvm/MC/MCInstPrinter.h"
23 #include "llvm/MC/MCObjectFileInfo.h"
24 #include "llvm/MC/MCRegisterInfo.h"
25 #include "llvm/MC/MCSectionCOFF.h"
26 #include "llvm/MC/MCSectionMachO.h"
27 #include "llvm/MC/MCSymbol.h"
28 #include "llvm/Support/ErrorHandling.h"
29 #include "llvm/Support/Format.h"
30 #include "llvm/Support/FormattedStream.h"
31 #include "llvm/Support/MathExtras.h"
32 #include "llvm/Support/PathV2.h"
38 class MCAsmStreamer : public MCStreamer {
40 formatted_raw_ostream &OS;
43 OwningPtr<MCInstPrinter> InstPrinter;
44 OwningPtr<MCCodeEmitter> Emitter;
45 OwningPtr<MCAsmBackend> AsmBackend;
47 SmallString<128> CommentToEmit;
48 raw_svector_ostream CommentStream;
50 unsigned IsVerboseAsm : 1;
51 unsigned ShowInst : 1;
54 unsigned UseDwarfDirectory : 1;
56 enum EHSymbolFlags { EHGlobal = 1,
57 EHWeakDefinition = 1 << 1,
58 EHPrivateExtern = 1 << 2 };
59 DenseMap<const MCSymbol*, unsigned> FlagMap;
61 bool needsSet(const MCExpr *Value);
63 void EmitRegisterName(int64_t Register);
64 virtual void EmitCFIStartProcImpl(MCDwarfFrameInfo &Frame);
65 virtual void EmitCFIEndProcImpl(MCDwarfFrameInfo &Frame);
68 MCAsmStreamer(MCContext &Context, formatted_raw_ostream &os,
69 bool isVerboseAsm, bool useLoc, bool useCFI,
70 bool useDwarfDirectory,
71 MCInstPrinter *printer, MCCodeEmitter *emitter,
72 MCAsmBackend *asmbackend,
74 : MCStreamer(SK_AsmStreamer, Context), OS(os), MAI(Context.getAsmInfo()),
75 InstPrinter(printer), Emitter(emitter), AsmBackend(asmbackend),
76 CommentStream(CommentToEmit), IsVerboseAsm(isVerboseAsm),
77 ShowInst(showInst), UseLoc(useLoc), UseCFI(useCFI),
78 UseDwarfDirectory(useDwarfDirectory) {
79 if (InstPrinter && IsVerboseAsm)
80 InstPrinter->setCommentStream(CommentStream);
84 inline void EmitEOL() {
85 // If we don't have any comments, just emit a \n.
92 void EmitCommentsAndEOL();
94 /// isVerboseAsm - Return true if this streamer supports verbose assembly at
96 virtual bool isVerboseAsm() const { return IsVerboseAsm; }
98 /// hasRawTextSupport - We support EmitRawText.
99 virtual bool hasRawTextSupport() const { return true; }
101 /// AddComment - Add a comment that can be emitted to the generated .s
102 /// file if applicable as a QoI issue to make the output of the compiler
103 /// more readable. This only affects the MCAsmStreamer, and only when
104 /// verbose assembly output is enabled.
105 virtual void AddComment(const Twine &T);
107 /// AddEncodingComment - Add a comment showing the encoding of an instruction.
108 virtual void AddEncodingComment(const MCInst &Inst);
110 /// GetCommentOS - Return a raw_ostream that comments can be written to.
111 /// Unlike AddComment, you are required to terminate comments with \n if you
113 virtual raw_ostream &GetCommentOS() {
115 return nulls(); // Discard comments unless in verbose asm mode.
116 return CommentStream;
119 /// AddBlankLine - Emit a blank line to a .s file to pretty it up.
120 virtual void AddBlankLine() {
124 /// @name MCStreamer Interface
127 virtual void ChangeSection(const MCSection *Section);
129 virtual void InitSections() {
133 virtual void InitToTextSection() {
134 // FIXME, this is MachO specific, but the testsuite
136 SwitchSection(getContext().getMachOSection(
138 MCSectionMachO::S_ATTR_PURE_INSTRUCTIONS,
139 0, SectionKind::getText()));
142 virtual void EmitLabel(MCSymbol *Symbol);
143 virtual void EmitDebugLabel(MCSymbol *Symbol);
145 virtual void EmitEHSymAttributes(const MCSymbol *Symbol,
147 virtual void EmitAssemblerFlag(MCAssemblerFlag Flag);
148 virtual void EmitLinkerOptions(ArrayRef<std::string> Options);
149 virtual void EmitDataRegion(MCDataRegionType Kind);
150 virtual void EmitThumbFunc(MCSymbol *Func);
152 virtual void EmitAssignment(MCSymbol *Symbol, const MCExpr *Value);
153 virtual void EmitWeakReference(MCSymbol *Alias, const MCSymbol *Symbol);
154 virtual void EmitDwarfAdvanceLineAddr(int64_t LineDelta,
155 const MCSymbol *LastLabel,
156 const MCSymbol *Label,
157 unsigned PointerSize);
158 virtual void EmitDwarfAdvanceFrameAddr(const MCSymbol *LastLabel,
159 const MCSymbol *Label);
161 virtual void EmitSymbolAttribute(MCSymbol *Symbol, MCSymbolAttr Attribute);
163 virtual void EmitSymbolDesc(MCSymbol *Symbol, unsigned DescValue);
164 virtual void BeginCOFFSymbolDef(const MCSymbol *Symbol);
165 virtual void EmitCOFFSymbolStorageClass(int StorageClass);
166 virtual void EmitCOFFSymbolType(int Type);
167 virtual void EndCOFFSymbolDef();
168 virtual void EmitCOFFSecRel32(MCSymbol const *Symbol);
169 virtual void EmitELFSize(MCSymbol *Symbol, const MCExpr *Value);
170 virtual void EmitCommonSymbol(MCSymbol *Symbol, uint64_t Size,
171 unsigned ByteAlignment);
173 /// EmitLocalCommonSymbol - Emit a local common (.lcomm) symbol.
175 /// @param Symbol - The common symbol to emit.
176 /// @param Size - The size of the common symbol.
177 /// @param ByteAlignment - The alignment of the common symbol in bytes.
178 virtual void EmitLocalCommonSymbol(MCSymbol *Symbol, uint64_t Size,
179 unsigned ByteAlignment);
181 virtual void EmitZerofill(const MCSection *Section, MCSymbol *Symbol = 0,
182 uint64_t Size = 0, unsigned ByteAlignment = 0);
184 virtual void EmitTBSSSymbol (const MCSection *Section, MCSymbol *Symbol,
185 uint64_t Size, unsigned ByteAlignment = 0);
187 virtual void EmitBytes(StringRef Data, unsigned AddrSpace);
189 virtual void EmitValueImpl(const MCExpr *Value, unsigned Size,
191 virtual void EmitIntValue(uint64_t Value, unsigned Size,
192 unsigned AddrSpace = 0);
194 virtual void EmitULEB128Value(const MCExpr *Value);
196 virtual void EmitSLEB128Value(const MCExpr *Value);
198 virtual void EmitGPRel64Value(const MCExpr *Value);
200 virtual void EmitGPRel32Value(const MCExpr *Value);
203 virtual void EmitFill(uint64_t NumBytes, uint8_t FillValue,
206 virtual void EmitValueToAlignment(unsigned ByteAlignment, int64_t Value = 0,
207 unsigned ValueSize = 1,
208 unsigned MaxBytesToEmit = 0);
210 virtual void EmitCodeAlignment(unsigned ByteAlignment,
211 unsigned MaxBytesToEmit = 0);
213 virtual bool EmitValueToOffset(const MCExpr *Offset,
214 unsigned char Value = 0);
216 virtual void EmitFileDirective(StringRef Filename);
217 virtual bool EmitDwarfFileDirective(unsigned FileNo, StringRef Directory,
219 virtual void EmitDwarfLocDirective(unsigned FileNo, unsigned Line,
220 unsigned Column, unsigned Flags,
221 unsigned Isa, unsigned Discriminator,
224 virtual void EmitCFISections(bool EH, bool Debug);
225 virtual void EmitCFIDefCfa(int64_t Register, int64_t Offset);
226 virtual void EmitCFIDefCfaOffset(int64_t Offset);
227 virtual void EmitCFIDefCfaRegister(int64_t Register);
228 virtual void EmitCFIOffset(int64_t Register, int64_t Offset);
229 virtual void EmitCFIPersonality(const MCSymbol *Sym, unsigned Encoding);
230 virtual void EmitCFILsda(const MCSymbol *Sym, unsigned Encoding);
231 virtual void EmitCFIRememberState();
232 virtual void EmitCFIRestoreState();
233 virtual void EmitCFISameValue(int64_t Register);
234 virtual void EmitCFIRelOffset(int64_t Register, int64_t Offset);
235 virtual void EmitCFIAdjustCfaOffset(int64_t Adjustment);
236 virtual void EmitCFISignalFrame();
237 virtual void EmitCFIUndefined(int64_t Register);
238 virtual void EmitCFIRegister(int64_t Register1, int64_t Register2);
240 virtual void EmitWin64EHStartProc(const MCSymbol *Symbol);
241 virtual void EmitWin64EHEndProc();
242 virtual void EmitWin64EHStartChained();
243 virtual void EmitWin64EHEndChained();
244 virtual void EmitWin64EHHandler(const MCSymbol *Sym, bool Unwind,
246 virtual void EmitWin64EHHandlerData();
247 virtual void EmitWin64EHPushReg(unsigned Register);
248 virtual void EmitWin64EHSetFrame(unsigned Register, unsigned Offset);
249 virtual void EmitWin64EHAllocStack(unsigned Size);
250 virtual void EmitWin64EHSaveReg(unsigned Register, unsigned Offset);
251 virtual void EmitWin64EHSaveXMM(unsigned Register, unsigned Offset);
252 virtual void EmitWin64EHPushFrame(bool Code);
253 virtual void EmitWin64EHEndProlog();
255 virtual void EmitFnStart();
256 virtual void EmitFnEnd();
257 virtual void EmitCantUnwind();
258 virtual void EmitPersonality(const MCSymbol *Personality);
259 virtual void EmitHandlerData();
260 virtual void EmitSetFP(unsigned FpReg, unsigned SpReg, int64_t Offset = 0);
261 virtual void EmitPad(int64_t Offset);
262 virtual void EmitRegSave(const SmallVectorImpl<unsigned> &RegList, bool);
264 virtual void EmitTCEntry(const MCSymbol &S);
266 virtual void EmitInstruction(const MCInst &Inst);
268 virtual void EmitBundleAlignMode(unsigned AlignPow2);
269 virtual void EmitBundleLock(bool AlignToEnd);
270 virtual void EmitBundleUnlock();
272 /// EmitRawText - If this file is backed by an assembly streamer, this dumps
273 /// the specified string in the output .s file. This capability is
274 /// indicated by the hasRawTextSupport() predicate.
275 virtual void EmitRawText(StringRef String);
277 virtual void FinishImpl();
281 static bool classof(const MCStreamer *S) {
282 return S->getKind() == SK_AsmStreamer;
286 } // end anonymous namespace.
288 /// AddComment - Add a comment that can be emitted to the generated .s
289 /// file if applicable as a QoI issue to make the output of the compiler
290 /// more readable. This only affects the MCAsmStreamer, and only when
291 /// verbose assembly output is enabled.
292 void MCAsmStreamer::AddComment(const Twine &T) {
293 if (!IsVerboseAsm) return;
295 // Make sure that CommentStream is flushed.
296 CommentStream.flush();
298 T.toVector(CommentToEmit);
299 // Each comment goes on its own line.
300 CommentToEmit.push_back('\n');
302 // Tell the comment stream that the vector changed underneath it.
303 CommentStream.resync();
306 void MCAsmStreamer::EmitCommentsAndEOL() {
307 if (CommentToEmit.empty() && CommentStream.GetNumBytesInBuffer() == 0) {
312 CommentStream.flush();
313 StringRef Comments = CommentToEmit.str();
315 assert(Comments.back() == '\n' &&
316 "Comment array not newline terminated");
318 // Emit a line of comments.
319 OS.PadToColumn(MAI.getCommentColumn());
320 size_t Position = Comments.find('\n');
321 OS << MAI.getCommentString() << ' ' << Comments.substr(0, Position) << '\n';
323 Comments = Comments.substr(Position+1);
324 } while (!Comments.empty());
326 CommentToEmit.clear();
327 // Tell the comment stream that the vector changed underneath it.
328 CommentStream.resync();
331 static inline int64_t truncateToSize(int64_t Value, unsigned Bytes) {
332 assert(Bytes && "Invalid size!");
333 return Value & ((uint64_t) (int64_t) -1 >> (64 - Bytes * 8));
336 void MCAsmStreamer::ChangeSection(const MCSection *Section) {
337 assert(Section && "Cannot switch to a null section!");
338 Section->PrintSwitchToSection(MAI, OS);
341 void MCAsmStreamer::EmitEHSymAttributes(const MCSymbol *Symbol,
342 MCSymbol *EHSymbol) {
346 unsigned Flags = FlagMap.lookup(Symbol);
348 if (Flags & EHGlobal)
349 EmitSymbolAttribute(EHSymbol, MCSA_Global);
350 if (Flags & EHWeakDefinition)
351 EmitSymbolAttribute(EHSymbol, MCSA_WeakDefinition);
352 if (Flags & EHPrivateExtern)
353 EmitSymbolAttribute(EHSymbol, MCSA_PrivateExtern);
356 void MCAsmStreamer::EmitLabel(MCSymbol *Symbol) {
357 assert(Symbol->isUndefined() && "Cannot define a symbol twice!");
358 MCStreamer::EmitLabel(Symbol);
360 OS << *Symbol << MAI.getLabelSuffix();
364 void MCAsmStreamer::EmitDebugLabel(MCSymbol *Symbol) {
365 assert(Symbol->isUndefined() && "Cannot define a symbol twice!");
366 MCStreamer::EmitDebugLabel(Symbol);
368 OS << *Symbol << MAI.getDebugLabelSuffix();
372 void MCAsmStreamer::EmitAssemblerFlag(MCAssemblerFlag Flag) {
374 case MCAF_SyntaxUnified: OS << "\t.syntax unified"; break;
375 case MCAF_SubsectionsViaSymbols: OS << ".subsections_via_symbols"; break;
376 case MCAF_Code16: OS << '\t'<< MAI.getCode16Directive(); break;
377 case MCAF_Code32: OS << '\t'<< MAI.getCode32Directive(); break;
378 case MCAF_Code64: OS << '\t'<< MAI.getCode64Directive(); break;
383 void MCAsmStreamer::EmitLinkerOptions(ArrayRef<std::string> Options) {
384 assert(!Options.empty() && "At least one option is required!");
385 OS << "\t.linker_option \"" << Options[0] << '"';
386 for (ArrayRef<std::string>::iterator it = Options.begin() + 1,
387 ie = Options.end(); it != ie; ++it) {
388 OS << ", " << '"' << *it << '"';
393 void MCAsmStreamer::EmitDataRegion(MCDataRegionType Kind) {
394 MCContext &Ctx = getContext();
395 const MCAsmInfo &MAI = Ctx.getAsmInfo();
396 if (!MAI.doesSupportDataRegionDirectives())
399 case MCDR_DataRegion: OS << "\t.data_region"; break;
400 case MCDR_DataRegionJT8: OS << "\t.data_region jt8"; break;
401 case MCDR_DataRegionJT16: OS << "\t.data_region jt16"; break;
402 case MCDR_DataRegionJT32: OS << "\t.data_region jt32"; break;
403 case MCDR_DataRegionEnd: OS << "\t.end_data_region"; break;
408 void MCAsmStreamer::EmitThumbFunc(MCSymbol *Func) {
409 // This needs to emit to a temporary string to get properly quoted
410 // MCSymbols when they have spaces in them.
411 OS << "\t.thumb_func";
412 // Only Mach-O hasSubsectionsViaSymbols()
413 if (MAI.hasSubsectionsViaSymbols())
418 void MCAsmStreamer::EmitAssignment(MCSymbol *Symbol, const MCExpr *Value) {
419 OS << *Symbol << " = " << *Value;
422 // FIXME: Lift context changes into super class.
423 Symbol->setVariableValue(Value);
426 void MCAsmStreamer::EmitWeakReference(MCSymbol *Alias, const MCSymbol *Symbol) {
427 OS << ".weakref " << *Alias << ", " << *Symbol;
431 void MCAsmStreamer::EmitDwarfAdvanceLineAddr(int64_t LineDelta,
432 const MCSymbol *LastLabel,
433 const MCSymbol *Label,
434 unsigned PointerSize) {
435 EmitDwarfSetLineAddr(LineDelta, Label, PointerSize);
438 void MCAsmStreamer::EmitDwarfAdvanceFrameAddr(const MCSymbol *LastLabel,
439 const MCSymbol *Label) {
440 EmitIntValue(dwarf::DW_CFA_advance_loc4, 1);
441 const MCExpr *AddrDelta = BuildSymbolDiff(getContext(), Label, LastLabel);
442 AddrDelta = ForceExpAbs(AddrDelta);
443 EmitValue(AddrDelta, 4);
447 void MCAsmStreamer::EmitSymbolAttribute(MCSymbol *Symbol,
448 MCSymbolAttr Attribute) {
450 case MCSA_Invalid: llvm_unreachable("Invalid symbol attribute");
451 case MCSA_ELF_TypeFunction: /// .type _foo, STT_FUNC # aka @function
452 case MCSA_ELF_TypeIndFunction: /// .type _foo, STT_GNU_IFUNC
453 case MCSA_ELF_TypeObject: /// .type _foo, STT_OBJECT # aka @object
454 case MCSA_ELF_TypeTLS: /// .type _foo, STT_TLS # aka @tls_object
455 case MCSA_ELF_TypeCommon: /// .type _foo, STT_COMMON # aka @common
456 case MCSA_ELF_TypeNoType: /// .type _foo, STT_NOTYPE # aka @notype
457 case MCSA_ELF_TypeGnuUniqueObject: /// .type _foo, @gnu_unique_object
458 assert(MAI.hasDotTypeDotSizeDirective() && "Symbol Attr not supported");
459 OS << "\t.type\t" << *Symbol << ','
460 << ((MAI.getCommentString()[0] != '@') ? '@' : '%');
462 default: llvm_unreachable("Unknown ELF .type");
463 case MCSA_ELF_TypeFunction: OS << "function"; break;
464 case MCSA_ELF_TypeIndFunction: OS << "gnu_indirect_function"; break;
465 case MCSA_ELF_TypeObject: OS << "object"; break;
466 case MCSA_ELF_TypeTLS: OS << "tls_object"; break;
467 case MCSA_ELF_TypeCommon: OS << "common"; break;
468 case MCSA_ELF_TypeNoType: OS << "no_type"; break;
469 case MCSA_ELF_TypeGnuUniqueObject: OS << "gnu_unique_object"; break;
473 case MCSA_Global: // .globl/.global
474 OS << MAI.getGlobalDirective();
475 FlagMap[Symbol] |= EHGlobal;
477 case MCSA_Hidden: OS << "\t.hidden\t"; break;
478 case MCSA_IndirectSymbol: OS << "\t.indirect_symbol\t"; break;
479 case MCSA_Internal: OS << "\t.internal\t"; break;
480 case MCSA_LazyReference: OS << "\t.lazy_reference\t"; break;
481 case MCSA_Local: OS << "\t.local\t"; break;
482 case MCSA_NoDeadStrip: OS << "\t.no_dead_strip\t"; break;
483 case MCSA_SymbolResolver: OS << "\t.symbol_resolver\t"; break;
484 case MCSA_PrivateExtern:
485 OS << "\t.private_extern\t";
486 FlagMap[Symbol] |= EHPrivateExtern;
488 case MCSA_Protected: OS << "\t.protected\t"; break;
489 case MCSA_Reference: OS << "\t.reference\t"; break;
490 case MCSA_Weak: OS << "\t.weak\t"; break;
491 case MCSA_WeakDefinition:
492 OS << "\t.weak_definition\t";
493 FlagMap[Symbol] |= EHWeakDefinition;
496 case MCSA_WeakReference: OS << MAI.getWeakRefDirective(); break;
497 case MCSA_WeakDefAutoPrivate: OS << "\t.weak_def_can_be_hidden\t"; break;
504 void MCAsmStreamer::EmitSymbolDesc(MCSymbol *Symbol, unsigned DescValue) {
505 OS << ".desc" << ' ' << *Symbol << ',' << DescValue;
509 void MCAsmStreamer::BeginCOFFSymbolDef(const MCSymbol *Symbol) {
510 OS << "\t.def\t " << *Symbol << ';';
514 void MCAsmStreamer::EmitCOFFSymbolStorageClass (int StorageClass) {
515 OS << "\t.scl\t" << StorageClass << ';';
519 void MCAsmStreamer::EmitCOFFSymbolType (int Type) {
520 OS << "\t.type\t" << Type << ';';
524 void MCAsmStreamer::EndCOFFSymbolDef() {
529 void MCAsmStreamer::EmitCOFFSecRel32(MCSymbol const *Symbol) {
530 OS << "\t.secrel32\t" << *Symbol << '\n';
534 void MCAsmStreamer::EmitELFSize(MCSymbol *Symbol, const MCExpr *Value) {
535 assert(MAI.hasDotTypeDotSizeDirective());
536 OS << "\t.size\t" << *Symbol << ", " << *Value << '\n';
539 void MCAsmStreamer::EmitCommonSymbol(MCSymbol *Symbol, uint64_t Size,
540 unsigned ByteAlignment) {
541 OS << "\t.comm\t" << *Symbol << ',' << Size;
542 if (ByteAlignment != 0) {
543 if (MAI.getCOMMDirectiveAlignmentIsInBytes())
544 OS << ',' << ByteAlignment;
546 OS << ',' << Log2_32(ByteAlignment);
551 /// EmitLocalCommonSymbol - Emit a local common (.lcomm) symbol.
553 /// @param Symbol - The common symbol to emit.
554 /// @param Size - The size of the common symbol.
555 void MCAsmStreamer::EmitLocalCommonSymbol(MCSymbol *Symbol, uint64_t Size,
556 unsigned ByteAlign) {
557 OS << "\t.lcomm\t" << *Symbol << ',' << Size;
559 switch (MAI.getLCOMMDirectiveAlignmentType()) {
560 case LCOMM::NoAlignment:
561 llvm_unreachable("alignment not supported on .lcomm!");
562 case LCOMM::ByteAlignment:
563 OS << ',' << ByteAlign;
565 case LCOMM::Log2Alignment:
566 assert(isPowerOf2_32(ByteAlign) && "alignment must be a power of 2");
567 OS << ',' << Log2_32(ByteAlign);
574 void MCAsmStreamer::EmitZerofill(const MCSection *Section, MCSymbol *Symbol,
575 uint64_t Size, unsigned ByteAlignment) {
576 // Note: a .zerofill directive does not switch sections.
579 // This is a mach-o specific directive.
580 const MCSectionMachO *MOSection = ((const MCSectionMachO*)Section);
581 OS << MOSection->getSegmentName() << "," << MOSection->getSectionName();
583 if (Symbol != NULL) {
584 OS << ',' << *Symbol << ',' << Size;
585 if (ByteAlignment != 0)
586 OS << ',' << Log2_32(ByteAlignment);
591 // .tbss sym, size, align
592 // This depends that the symbol has already been mangled from the original,
594 void MCAsmStreamer::EmitTBSSSymbol(const MCSection *Section, MCSymbol *Symbol,
595 uint64_t Size, unsigned ByteAlignment) {
596 assert(Symbol != NULL && "Symbol shouldn't be NULL!");
597 // Instead of using the Section we'll just use the shortcut.
598 // This is a mach-o specific directive and section.
599 OS << ".tbss " << *Symbol << ", " << Size;
601 // Output align if we have it. We default to 1 so don't bother printing
603 if (ByteAlignment > 1) OS << ", " << Log2_32(ByteAlignment);
608 static inline char toOctal(int X) { return (X&7)+'0'; }
610 static void PrintQuotedString(StringRef Data, raw_ostream &OS) {
613 for (unsigned i = 0, e = Data.size(); i != e; ++i) {
614 unsigned char C = Data[i];
615 if (C == '"' || C == '\\') {
616 OS << '\\' << (char)C;
620 if (isprint((unsigned char)C)) {
626 case '\b': OS << "\\b"; break;
627 case '\f': OS << "\\f"; break;
628 case '\n': OS << "\\n"; break;
629 case '\r': OS << "\\r"; break;
630 case '\t': OS << "\\t"; break;
633 OS << toOctal(C >> 6);
634 OS << toOctal(C >> 3);
635 OS << toOctal(C >> 0);
644 void MCAsmStreamer::EmitBytes(StringRef Data, unsigned AddrSpace) {
645 assert(getCurrentSection() && "Cannot emit contents before setting section!");
646 if (Data.empty()) return;
648 if (Data.size() == 1) {
649 OS << MAI.getData8bitsDirective(AddrSpace);
650 OS << (unsigned)(unsigned char)Data[0];
655 // If the data ends with 0 and the target supports .asciz, use it, otherwise
657 if (MAI.getAscizDirective() && Data.back() == 0) {
658 OS << MAI.getAscizDirective();
659 Data = Data.substr(0, Data.size()-1);
661 OS << MAI.getAsciiDirective();
665 PrintQuotedString(Data, OS);
669 void MCAsmStreamer::EmitIntValue(uint64_t Value, unsigned Size,
670 unsigned AddrSpace) {
671 EmitValue(MCConstantExpr::Create(Value, getContext()), Size, AddrSpace);
674 void MCAsmStreamer::EmitValueImpl(const MCExpr *Value, unsigned Size,
675 unsigned AddrSpace) {
676 assert(getCurrentSection() && "Cannot emit contents before setting section!");
677 const char *Directive = 0;
680 case 1: Directive = MAI.getData8bitsDirective(AddrSpace); break;
681 case 2: Directive = MAI.getData16bitsDirective(AddrSpace); break;
682 case 4: Directive = MAI.getData32bitsDirective(AddrSpace); break;
684 Directive = MAI.getData64bitsDirective(AddrSpace);
685 // If the target doesn't support 64-bit data, emit as two 32-bit halves.
686 if (Directive) break;
688 if (!Value->EvaluateAsAbsolute(IntValue))
689 report_fatal_error("Don't know how to emit this value.");
690 if (getContext().getAsmInfo().isLittleEndian()) {
691 EmitIntValue((uint32_t)(IntValue >> 0 ), 4, AddrSpace);
692 EmitIntValue((uint32_t)(IntValue >> 32), 4, AddrSpace);
694 EmitIntValue((uint32_t)(IntValue >> 32), 4, AddrSpace);
695 EmitIntValue((uint32_t)(IntValue >> 0 ), 4, AddrSpace);
700 assert(Directive && "Invalid size for machine code value!");
701 OS << Directive << *Value;
705 void MCAsmStreamer::EmitULEB128Value(const MCExpr *Value) {
707 if (Value->EvaluateAsAbsolute(IntValue)) {
708 EmitULEB128IntValue(IntValue);
711 assert(MAI.hasLEB128() && "Cannot print a .uleb");
712 OS << ".uleb128 " << *Value;
716 void MCAsmStreamer::EmitSLEB128Value(const MCExpr *Value) {
718 if (Value->EvaluateAsAbsolute(IntValue)) {
719 EmitSLEB128IntValue(IntValue);
722 assert(MAI.hasLEB128() && "Cannot print a .sleb");
723 OS << ".sleb128 " << *Value;
727 void MCAsmStreamer::EmitGPRel64Value(const MCExpr *Value) {
728 assert(MAI.getGPRel64Directive() != 0);
729 OS << MAI.getGPRel64Directive() << *Value;
733 void MCAsmStreamer::EmitGPRel32Value(const MCExpr *Value) {
734 assert(MAI.getGPRel32Directive() != 0);
735 OS << MAI.getGPRel32Directive() << *Value;
740 /// EmitFill - Emit NumBytes bytes worth of the value specified by
741 /// FillValue. This implements directives such as '.space'.
742 void MCAsmStreamer::EmitFill(uint64_t NumBytes, uint8_t FillValue,
743 unsigned AddrSpace) {
744 if (NumBytes == 0) return;
747 if (const char *ZeroDirective = MAI.getZeroDirective()) {
748 OS << ZeroDirective << NumBytes;
750 OS << ',' << (int)FillValue;
755 // Emit a byte at a time.
756 MCStreamer::EmitFill(NumBytes, FillValue, AddrSpace);
759 void MCAsmStreamer::EmitValueToAlignment(unsigned ByteAlignment, int64_t Value,
761 unsigned MaxBytesToEmit) {
762 // Some assemblers don't support non-power of two alignments, so we always
763 // emit alignments as a power of two if possible.
764 if (isPowerOf2_32(ByteAlignment)) {
766 default: llvm_unreachable("Invalid size for machine code value!");
767 case 1: OS << MAI.getAlignDirective(); break;
768 // FIXME: use MAI for this!
769 case 2: OS << ".p2alignw "; break;
770 case 4: OS << ".p2alignl "; break;
771 case 8: llvm_unreachable("Unsupported alignment size!");
774 if (MAI.getAlignmentIsInBytes())
777 OS << Log2_32(ByteAlignment);
779 if (Value || MaxBytesToEmit) {
781 OS.write_hex(truncateToSize(Value, ValueSize));
784 OS << ", " << MaxBytesToEmit;
790 // Non-power of two alignment. This is not widely supported by assemblers.
791 // FIXME: Parameterize this based on MAI.
793 default: llvm_unreachable("Invalid size for machine code value!");
794 case 1: OS << ".balign"; break;
795 case 2: OS << ".balignw"; break;
796 case 4: OS << ".balignl"; break;
797 case 8: llvm_unreachable("Unsupported alignment size!");
800 OS << ' ' << ByteAlignment;
801 OS << ", " << truncateToSize(Value, ValueSize);
803 OS << ", " << MaxBytesToEmit;
807 void MCAsmStreamer::EmitCodeAlignment(unsigned ByteAlignment,
808 unsigned MaxBytesToEmit) {
809 // Emit with a text fill value.
810 EmitValueToAlignment(ByteAlignment, MAI.getTextAlignFillValue(),
814 bool MCAsmStreamer::EmitValueToOffset(const MCExpr *Offset,
815 unsigned char Value) {
816 // FIXME: Verify that Offset is associated with the current section.
817 OS << ".org " << *Offset << ", " << (unsigned) Value;
823 void MCAsmStreamer::EmitFileDirective(StringRef Filename) {
824 assert(MAI.hasSingleParameterDotFile());
826 PrintQuotedString(Filename, OS);
830 bool MCAsmStreamer::EmitDwarfFileDirective(unsigned FileNo, StringRef Directory,
831 StringRef Filename) {
832 if (!UseDwarfDirectory && !Directory.empty()) {
833 if (sys::path::is_absolute(Filename))
834 return EmitDwarfFileDirective(FileNo, "", Filename);
836 SmallString<128> FullPathName = Directory;
837 sys::path::append(FullPathName, Filename);
838 return EmitDwarfFileDirective(FileNo, "", FullPathName);
842 OS << "\t.file\t" << FileNo << ' ';
843 if (!Directory.empty()) {
844 PrintQuotedString(Directory, OS);
847 PrintQuotedString(Filename, OS);
850 return this->MCStreamer::EmitDwarfFileDirective(FileNo, Directory, Filename);
853 void MCAsmStreamer::EmitDwarfLocDirective(unsigned FileNo, unsigned Line,
854 unsigned Column, unsigned Flags,
856 unsigned Discriminator,
857 StringRef FileName) {
858 this->MCStreamer::EmitDwarfLocDirective(FileNo, Line, Column, Flags,
859 Isa, Discriminator, FileName);
863 OS << "\t.loc\t" << FileNo << " " << Line << " " << Column;
864 if (Flags & DWARF2_FLAG_BASIC_BLOCK)
865 OS << " basic_block";
866 if (Flags & DWARF2_FLAG_PROLOGUE_END)
867 OS << " prologue_end";
868 if (Flags & DWARF2_FLAG_EPILOGUE_BEGIN)
869 OS << " epilogue_begin";
871 unsigned OldFlags = getContext().getCurrentDwarfLoc().getFlags();
872 if ((Flags & DWARF2_FLAG_IS_STMT) != (OldFlags & DWARF2_FLAG_IS_STMT)) {
875 if (Flags & DWARF2_FLAG_IS_STMT)
884 OS << "discriminator " << Discriminator;
887 OS.PadToColumn(MAI.getCommentColumn());
888 OS << MAI.getCommentString() << ' ' << FileName << ':'
889 << Line << ':' << Column;
894 void MCAsmStreamer::EmitCFISections(bool EH, bool Debug) {
895 MCStreamer::EmitCFISections(EH, Debug);
900 OS << "\t.cfi_sections ";
904 OS << ", .debug_frame";
906 OS << ".debug_frame";
912 void MCAsmStreamer::EmitCFIStartProcImpl(MCDwarfFrameInfo &Frame) {
914 RecordProcStart(Frame);
918 OS << "\t.cfi_startproc";
922 void MCAsmStreamer::EmitCFIEndProcImpl(MCDwarfFrameInfo &Frame) {
924 RecordProcEnd(Frame);
928 // Put a dummy non-null value in Frame.End to mark that this frame has been
930 Frame.End = (MCSymbol *) 1;
932 OS << "\t.cfi_endproc";
936 void MCAsmStreamer::EmitRegisterName(int64_t Register) {
937 if (InstPrinter && !MAI.useDwarfRegNumForCFI()) {
938 const MCRegisterInfo &MRI = getContext().getRegisterInfo();
939 unsigned LLVMRegister = MRI.getLLVMRegNum(Register, true);
940 InstPrinter->printRegName(OS, LLVMRegister);
946 void MCAsmStreamer::EmitCFIDefCfa(int64_t Register, int64_t Offset) {
947 MCStreamer::EmitCFIDefCfa(Register, Offset);
952 OS << "\t.cfi_def_cfa ";
953 EmitRegisterName(Register);
954 OS << ", " << Offset;
958 void MCAsmStreamer::EmitCFIDefCfaOffset(int64_t Offset) {
959 MCStreamer::EmitCFIDefCfaOffset(Offset);
964 OS << "\t.cfi_def_cfa_offset " << Offset;
968 void MCAsmStreamer::EmitCFIDefCfaRegister(int64_t Register) {
969 MCStreamer::EmitCFIDefCfaRegister(Register);
974 OS << "\t.cfi_def_cfa_register ";
975 EmitRegisterName(Register);
979 void MCAsmStreamer::EmitCFIOffset(int64_t Register, int64_t Offset) {
980 this->MCStreamer::EmitCFIOffset(Register, Offset);
985 OS << "\t.cfi_offset ";
986 EmitRegisterName(Register);
987 OS << ", " << Offset;
991 void MCAsmStreamer::EmitCFIPersonality(const MCSymbol *Sym,
993 MCStreamer::EmitCFIPersonality(Sym, Encoding);
998 OS << "\t.cfi_personality " << Encoding << ", " << *Sym;
1002 void MCAsmStreamer::EmitCFILsda(const MCSymbol *Sym, unsigned Encoding) {
1003 MCStreamer::EmitCFILsda(Sym, Encoding);
1008 OS << "\t.cfi_lsda " << Encoding << ", " << *Sym;
1012 void MCAsmStreamer::EmitCFIRememberState() {
1013 MCStreamer::EmitCFIRememberState();
1018 OS << "\t.cfi_remember_state";
1022 void MCAsmStreamer::EmitCFIRestoreState() {
1023 MCStreamer::EmitCFIRestoreState();
1028 OS << "\t.cfi_restore_state";
1032 void MCAsmStreamer::EmitCFISameValue(int64_t Register) {
1033 MCStreamer::EmitCFISameValue(Register);
1038 OS << "\t.cfi_same_value ";
1039 EmitRegisterName(Register);
1043 void MCAsmStreamer::EmitCFIRelOffset(int64_t Register, int64_t Offset) {
1044 MCStreamer::EmitCFIRelOffset(Register, Offset);
1049 OS << "\t.cfi_rel_offset ";
1050 EmitRegisterName(Register);
1051 OS << ", " << Offset;
1055 void MCAsmStreamer::EmitCFIAdjustCfaOffset(int64_t Adjustment) {
1056 MCStreamer::EmitCFIAdjustCfaOffset(Adjustment);
1061 OS << "\t.cfi_adjust_cfa_offset " << Adjustment;
1065 void MCAsmStreamer::EmitCFISignalFrame() {
1066 MCStreamer::EmitCFISignalFrame();
1071 OS << "\t.cfi_signal_frame";
1075 void MCAsmStreamer::EmitCFIUndefined(int64_t Register) {
1076 MCStreamer::EmitCFIUndefined(Register);
1081 OS << "\t.cfi_undefined " << Register;
1085 void MCAsmStreamer::EmitCFIRegister(int64_t Register1, int64_t Register2) {
1086 MCStreamer::EmitCFIRegister(Register1, Register2);
1091 OS << "\t.cfi_register " << Register1 << ", " << Register2;
1095 void MCAsmStreamer::EmitWin64EHStartProc(const MCSymbol *Symbol) {
1096 MCStreamer::EmitWin64EHStartProc(Symbol);
1098 OS << ".seh_proc " << *Symbol;
1102 void MCAsmStreamer::EmitWin64EHEndProc() {
1103 MCStreamer::EmitWin64EHEndProc();
1105 OS << "\t.seh_endproc";
1109 void MCAsmStreamer::EmitWin64EHStartChained() {
1110 MCStreamer::EmitWin64EHStartChained();
1112 OS << "\t.seh_startchained";
1116 void MCAsmStreamer::EmitWin64EHEndChained() {
1117 MCStreamer::EmitWin64EHEndChained();
1119 OS << "\t.seh_endchained";
1123 void MCAsmStreamer::EmitWin64EHHandler(const MCSymbol *Sym, bool Unwind,
1125 MCStreamer::EmitWin64EHHandler(Sym, Unwind, Except);
1127 OS << "\t.seh_handler " << *Sym;
1135 static const MCSection *getWin64EHTableSection(StringRef suffix,
1136 MCContext &context) {
1137 // FIXME: This doesn't belong in MCObjectFileInfo. However,
1138 /// this duplicate code in MCWin64EH.cpp.
1140 return context.getObjectFileInfo()->getXDataSection();
1141 return context.getCOFFSection((".xdata"+suffix).str(),
1142 COFF::IMAGE_SCN_CNT_INITIALIZED_DATA |
1143 COFF::IMAGE_SCN_MEM_READ |
1144 COFF::IMAGE_SCN_MEM_WRITE,
1145 SectionKind::getDataRel());
1148 void MCAsmStreamer::EmitWin64EHHandlerData() {
1149 MCStreamer::EmitWin64EHHandlerData();
1151 // Switch sections. Don't call SwitchSection directly, because that will
1152 // cause the section switch to be visible in the emitted assembly.
1153 // We only do this so the section switch that terminates the handler
1154 // data block is visible.
1155 MCWin64EHUnwindInfo *CurFrame = getCurrentW64UnwindInfo();
1156 StringRef suffix=MCWin64EHUnwindEmitter::GetSectionSuffix(CurFrame->Function);
1157 const MCSection *xdataSect = getWin64EHTableSection(suffix, getContext());
1159 SwitchSectionNoChange(xdataSect);
1161 OS << "\t.seh_handlerdata";
1165 void MCAsmStreamer::EmitWin64EHPushReg(unsigned Register) {
1166 MCStreamer::EmitWin64EHPushReg(Register);
1168 OS << "\t.seh_pushreg " << Register;
1172 void MCAsmStreamer::EmitWin64EHSetFrame(unsigned Register, unsigned Offset) {
1173 MCStreamer::EmitWin64EHSetFrame(Register, Offset);
1175 OS << "\t.seh_setframe " << Register << ", " << Offset;
1179 void MCAsmStreamer::EmitWin64EHAllocStack(unsigned Size) {
1180 MCStreamer::EmitWin64EHAllocStack(Size);
1182 OS << "\t.seh_stackalloc " << Size;
1186 void MCAsmStreamer::EmitWin64EHSaveReg(unsigned Register, unsigned Offset) {
1187 MCStreamer::EmitWin64EHSaveReg(Register, Offset);
1189 OS << "\t.seh_savereg " << Register << ", " << Offset;
1193 void MCAsmStreamer::EmitWin64EHSaveXMM(unsigned Register, unsigned Offset) {
1194 MCStreamer::EmitWin64EHSaveXMM(Register, Offset);
1196 OS << "\t.seh_savexmm " << Register << ", " << Offset;
1200 void MCAsmStreamer::EmitWin64EHPushFrame(bool Code) {
1201 MCStreamer::EmitWin64EHPushFrame(Code);
1203 OS << "\t.seh_pushframe";
1209 void MCAsmStreamer::EmitWin64EHEndProlog(void) {
1210 MCStreamer::EmitWin64EHEndProlog();
1212 OS << "\t.seh_endprologue";
1216 void MCAsmStreamer::AddEncodingComment(const MCInst &Inst) {
1217 raw_ostream &OS = GetCommentOS();
1218 SmallString<256> Code;
1219 SmallVector<MCFixup, 4> Fixups;
1220 raw_svector_ostream VecOS(Code);
1221 Emitter->EncodeInstruction(Inst, VecOS, Fixups);
1224 // If we are showing fixups, create symbolic markers in the encoded
1225 // representation. We do this by making a per-bit map to the fixup item index,
1226 // then trying to display it as nicely as possible.
1227 SmallVector<uint8_t, 64> FixupMap;
1228 FixupMap.resize(Code.size() * 8);
1229 for (unsigned i = 0, e = Code.size() * 8; i != e; ++i)
1232 for (unsigned i = 0, e = Fixups.size(); i != e; ++i) {
1233 MCFixup &F = Fixups[i];
1234 const MCFixupKindInfo &Info = AsmBackend->getFixupKindInfo(F.getKind());
1235 for (unsigned j = 0; j != Info.TargetSize; ++j) {
1236 unsigned Index = F.getOffset() * 8 + Info.TargetOffset + j;
1237 assert(Index < Code.size() * 8 && "Invalid offset in fixup!");
1238 FixupMap[Index] = 1 + i;
1242 // FIXME: Note the fixup comments for Thumb2 are completely bogus since the
1243 // high order halfword of a 32-bit Thumb2 instruction is emitted first.
1244 OS << "encoding: [";
1245 for (unsigned i = 0, e = Code.size(); i != e; ++i) {
1249 // See if all bits are the same map entry.
1250 uint8_t MapEntry = FixupMap[i * 8 + 0];
1251 for (unsigned j = 1; j != 8; ++j) {
1252 if (FixupMap[i * 8 + j] == MapEntry)
1255 MapEntry = uint8_t(~0U);
1259 if (MapEntry != uint8_t(~0U)) {
1260 if (MapEntry == 0) {
1261 OS << format("0x%02x", uint8_t(Code[i]));
1264 // FIXME: Some of the 8 bits require fix up.
1265 OS << format("0x%02x", uint8_t(Code[i])) << '\''
1266 << char('A' + MapEntry - 1) << '\'';
1268 OS << char('A' + MapEntry - 1);
1271 // Otherwise, write out in binary.
1273 for (unsigned j = 8; j--;) {
1274 unsigned Bit = (Code[i] >> j) & 1;
1277 if (getContext().getAsmInfo().isLittleEndian())
1278 FixupBit = i * 8 + j;
1280 FixupBit = i * 8 + (7-j);
1282 if (uint8_t MapEntry = FixupMap[FixupBit]) {
1283 assert(Bit == 0 && "Encoder wrote into fixed up bit!");
1284 OS << char('A' + MapEntry - 1);
1292 for (unsigned i = 0, e = Fixups.size(); i != e; ++i) {
1293 MCFixup &F = Fixups[i];
1294 const MCFixupKindInfo &Info = AsmBackend->getFixupKindInfo(F.getKind());
1295 OS << " fixup " << char('A' + i) << " - " << "offset: " << F.getOffset()
1296 << ", value: " << *F.getValue() << ", kind: " << Info.Name << "\n";
1300 void MCAsmStreamer::EmitFnStart() {
1305 void MCAsmStreamer::EmitFnEnd() {
1310 void MCAsmStreamer::EmitCantUnwind() {
1311 OS << "\t.cantunwind";
1315 void MCAsmStreamer::EmitHandlerData() {
1316 OS << "\t.handlerdata";
1320 void MCAsmStreamer::EmitPersonality(const MCSymbol *Personality) {
1321 OS << "\t.personality " << Personality->getName();
1325 void MCAsmStreamer::EmitSetFP(unsigned FpReg, unsigned SpReg, int64_t Offset) {
1327 InstPrinter->printRegName(OS, FpReg);
1329 InstPrinter->printRegName(OS, SpReg);
1331 OS << ", #" << Offset;
1335 void MCAsmStreamer::EmitPad(int64_t Offset) {
1336 OS << "\t.pad\t#" << Offset;
1340 void MCAsmStreamer::EmitRegSave(const SmallVectorImpl<unsigned> &RegList,
1342 assert(RegList.size() && "RegList should not be empty");
1344 OS << "\t.vsave\t{";
1348 InstPrinter->printRegName(OS, RegList[0]);
1350 for (unsigned i = 1, e = RegList.size(); i != e; ++i) {
1352 InstPrinter->printRegName(OS, RegList[i]);
1359 void MCAsmStreamer::EmitTCEntry(const MCSymbol &S) {
1367 void MCAsmStreamer::EmitInstruction(const MCInst &Inst) {
1368 assert(getCurrentSection() && "Cannot emit contents before setting section!");
1370 // Show the encoding in a comment if we have a code emitter.
1372 AddEncodingComment(Inst);
1374 // Show the MCInst if enabled.
1376 Inst.dump_pretty(GetCommentOS(), &MAI, InstPrinter.get(), "\n ");
1377 GetCommentOS() << "\n";
1380 // If we have an AsmPrinter, use that to print, otherwise print the MCInst.
1382 InstPrinter->printInst(&Inst, OS, "");
1384 Inst.print(OS, &MAI);
1388 void MCAsmStreamer::EmitBundleAlignMode(unsigned AlignPow2) {
1389 OS << "\t.bundle_align_mode " << AlignPow2;
1393 void MCAsmStreamer::EmitBundleLock(bool AlignToEnd) {
1394 OS << "\t.bundle_lock";
1396 OS << " align_to_end";
1400 void MCAsmStreamer::EmitBundleUnlock() {
1401 OS << "\t.bundle_unlock";
1405 /// EmitRawText - If this file is backed by an assembly streamer, this dumps
1406 /// the specified string in the output .s file. This capability is
1407 /// indicated by the hasRawTextSupport() predicate.
1408 void MCAsmStreamer::EmitRawText(StringRef String) {
1409 if (!String.empty() && String.back() == '\n')
1410 String = String.substr(0, String.size()-1);
1415 void MCAsmStreamer::FinishImpl() {
1416 // FIXME: This header is duplicated with MCObjectStreamer
1417 // Dump out the dwarf file & directory tables and line tables.
1418 const MCSymbol *LineSectionSymbol = NULL;
1419 if (getContext().hasDwarfFiles() && !UseLoc)
1420 LineSectionSymbol = MCDwarfFileTable::Emit(this);
1422 // If we are generating dwarf for assembly source files dump out the sections.
1423 if (getContext().getGenDwarfForAssembly())
1424 MCGenDwarfInfo::Emit(this, LineSectionSymbol);
1429 MCStreamer *llvm::createAsmStreamer(MCContext &Context,
1430 formatted_raw_ostream &OS,
1431 bool isVerboseAsm, bool useLoc,
1432 bool useCFI, bool useDwarfDirectory,
1433 MCInstPrinter *IP, MCCodeEmitter *CE,
1434 MCAsmBackend *MAB, bool ShowInst) {
1435 return new MCAsmStreamer(Context, OS, isVerboseAsm, useLoc, useCFI,
1436 useDwarfDirectory, IP, CE, MAB, ShowInst);