Home | History | Annotate | Download | only in PTX 
      1 //===-- PTXMCAsmStreamer.cpp - PTX Text Assembly Output -------------------===//
      2 //
      3 //                     The LLVM Compiler Infrastructure
      4 //
      5 // This file is distributed under the University of Illinois Open Source
      6 // License. See LICENSE.TXT for details.
      7 //
      8 //===----------------------------------------------------------------------===//
      9 
     10 #include "llvm/ADT/OwningPtr.h"
     11 #include "llvm/ADT/SmallString.h"
     12 #include "llvm/ADT/Twine.h"
     13 #include "llvm/MC/MCAsmInfo.h"
     14 #include "llvm/MC/MCCodeEmitter.h"
     15 #include "llvm/MC/MCContext.h"
     16 #include "llvm/MC/MCExpr.h"
     17 #include "llvm/MC/MCInst.h"
     18 #include "llvm/MC/MCInstPrinter.h"
     19 #include "llvm/MC/MCStreamer.h"
     20 #include "llvm/MC/MCSymbol.h"
     21 #include "llvm/Support/ErrorHandling.h"
     22 #include "llvm/Support/MathExtras.h"
     23 #include "llvm/Support/Format.h"
     24 #include "llvm/Support/FormattedStream.h"
     25 #include "llvm/Support/PathV2.h"
     26 #include "llvm/Support/raw_ostream.h"
     27 
     28 using namespace llvm;
     29 
     30 namespace {
     31 class PTXMCAsmStreamer : public MCStreamer {
     32   formatted_raw_ostream &OS;
     33   const MCAsmInfo &MAI;
     34   OwningPtr<MCInstPrinter> InstPrinter;
     35   OwningPtr<MCCodeEmitter> Emitter;
     36 
     37   SmallString<128> CommentToEmit;
     38   raw_svector_ostream CommentStream;
     39 
     40   unsigned IsVerboseAsm : 1;
     41   unsigned ShowInst : 1;
     42 
     43 public:
     44   PTXMCAsmStreamer(MCContext &Context,
     45                    formatted_raw_ostream &os,
     46                    bool isVerboseAsm, bool useLoc,
     47                    MCInstPrinter *printer,
     48                    MCCodeEmitter *emitter,
     49                    bool showInst)
     50     : MCStreamer(Context), OS(os), MAI(Context.getAsmInfo()),
     51       InstPrinter(printer), Emitter(emitter), CommentStream(CommentToEmit),
     52       IsVerboseAsm(isVerboseAsm),
     53       ShowInst(showInst) {
     54     if (InstPrinter && IsVerboseAsm)
     55       InstPrinter->setCommentStream(CommentStream);
     56   }
     57 
     58   ~PTXMCAsmStreamer() {}
     59 
     60   inline void EmitEOL() {
     61     // If we don't have any comments, just emit a \n.
     62     if (!IsVerboseAsm) {
     63       OS << '\n';
     64       return;
     65     }
     66     EmitCommentsAndEOL();
     67   }
     68   void EmitCommentsAndEOL();
     69 
     70   /// isVerboseAsm - Return true if this streamer supports verbose assembly at
     71   /// all.
     72   virtual bool isVerboseAsm() const { return IsVerboseAsm; }
     73 
     74   /// hasRawTextSupport - We support EmitRawText.
     75   virtual bool hasRawTextSupport() const { return true; }
     76 
     77   /// AddComment - Add a comment that can be emitted to the generated .s
     78   /// file if applicable as a QoI issue to make the output of the compiler
     79   /// more readable.  This only affects the MCAsmStreamer, and only when
     80   /// verbose assembly output is enabled.
     81   virtual void AddComment(const Twine &T);
     82 
     83   /// AddEncodingComment - Add a comment showing the encoding of an instruction.
     84   virtual void AddEncodingComment(const MCInst &Inst);
     85 
     86   /// GetCommentOS - Return a raw_ostream that comments can be written to.
     87   /// Unlike AddComment, you are required to terminate comments with \n if you
     88   /// use this method.
     89   virtual raw_ostream &GetCommentOS() {
     90     if (!IsVerboseAsm)
     91       return nulls();  // Discard comments unless in verbose asm mode.
     92     return CommentStream;
     93   }
     94 
     95   /// AddBlankLine - Emit a blank line to a .s file to pretty it up.
     96   virtual void AddBlankLine() {
     97     EmitEOL();
     98   }
     99 
    100   /// @name MCStreamer Interface
    101   /// @{
    102 
    103   virtual void ChangeSection(const MCSection *Section);
    104   virtual void InitSections() { /* PTX does not use sections */ }
    105 
    106   virtual void EmitLabel(MCSymbol *Symbol);
    107 
    108   virtual void EmitAssemblerFlag(MCAssemblerFlag Flag);
    109 
    110   virtual void EmitThumbFunc(MCSymbol *Func);
    111 
    112   virtual void EmitAssignment(MCSymbol *Symbol, const MCExpr *Value);
    113 
    114   virtual void EmitWeakReference(MCSymbol *Alias, const MCSymbol *Symbol);
    115 
    116   virtual void EmitDwarfAdvanceLineAddr(int64_t LineDelta,
    117                                         const MCSymbol *LastLabel,
    118                                         const MCSymbol *Label,
    119                                         unsigned PointerSize);
    120 
    121   virtual void EmitSymbolAttribute(MCSymbol *Symbol, MCSymbolAttr Attribute);
    122 
    123   virtual void EmitSymbolDesc(MCSymbol *Symbol, unsigned DescValue);
    124   virtual void BeginCOFFSymbolDef(const MCSymbol *Symbol);
    125   virtual void EmitCOFFSymbolStorageClass(int StorageClass);
    126   virtual void EmitCOFFSymbolType(int Type);
    127   virtual void EndCOFFSymbolDef();
    128   virtual void EmitELFSize(MCSymbol *Symbol, const MCExpr *Value);
    129   virtual void EmitCommonSymbol(MCSymbol *Symbol, uint64_t Size,
    130                                 unsigned ByteAlignment);
    131 
    132   /// EmitLocalCommonSymbol - Emit a local common (.lcomm) symbol.
    133   ///
    134   /// @param Symbol - The common symbol to emit.
    135   /// @param Size - The size of the common symbol.
    136   /// @param ByteAlignment - The alignment of the common symbol in bytes.
    137   virtual void EmitLocalCommonSymbol(MCSymbol *Symbol, uint64_t Size,
    138                                      unsigned ByteAlignment);
    139 
    140   virtual void EmitZerofill(const MCSection *Section, MCSymbol *Symbol = 0,
    141                             unsigned Size = 0, unsigned ByteAlignment = 0);
    142 
    143   virtual void EmitTBSSSymbol(const MCSection *Section, MCSymbol *Symbol,
    144                               uint64_t Size, unsigned ByteAlignment = 0);
    145 
    146   virtual void EmitBytes(StringRef Data, unsigned AddrSpace);
    147 
    148   virtual void EmitValueImpl(const MCExpr *Value, unsigned Size,
    149                              unsigned AddrSpace);
    150   virtual void EmitULEB128Value(const MCExpr *Value);
    151   virtual void EmitSLEB128Value(const MCExpr *Value);
    152   virtual void EmitGPRel32Value(const MCExpr *Value);
    153 
    154 
    155   virtual void EmitFill(uint64_t NumBytes, uint8_t FillValue,
    156                         unsigned AddrSpace);
    157 
    158   virtual void EmitValueToAlignment(unsigned ByteAlignment, int64_t Value = 0,
    159                                     unsigned ValueSize = 1,
    160                                     unsigned MaxBytesToEmit = 0);
    161 
    162   virtual void EmitCodeAlignment(unsigned ByteAlignment,
    163                                  unsigned MaxBytesToEmit = 0);
    164 
    165   virtual bool EmitValueToOffset(const MCExpr *Offset,
    166                                  unsigned char Value = 0);
    167 
    168   virtual void EmitFileDirective(StringRef Filename);
    169   virtual bool EmitDwarfFileDirective(unsigned FileNo, StringRef Directory,
    170                                       StringRef Filename);
    171 
    172   virtual void EmitInstruction(const MCInst &Inst);
    173 
    174   /// EmitRawText - If this file is backed by an assembly streamer, this dumps
    175   /// the specified string in the output .s file.  This capability is
    176   /// indicated by the hasRawTextSupport() predicate.
    177   virtual void EmitRawText(StringRef String);
    178 
    179   virtual void FinishImpl();
    180 
    181   /// @}
    182 
    183 }; // class PTXMCAsmStreamer
    184 
    185 }
    186 
    187 /// TODO: Add appropriate implementation of Emit*() methods when needed
    188 
    189 void PTXMCAsmStreamer::AddComment(const Twine &T) {
    190   if (!IsVerboseAsm) return;
    191 
    192   // Make sure that CommentStream is flushed.
    193   CommentStream.flush();
    194 
    195   T.toVector(CommentToEmit);
    196   // Each comment goes on its own line.
    197   CommentToEmit.push_back('\n');
    198 
    199   // Tell the comment stream that the vector changed underneath it.
    200   CommentStream.resync();
    201 }
    202 
    203 void PTXMCAsmStreamer::EmitCommentsAndEOL() {
    204   if (CommentToEmit.empty() && CommentStream.GetNumBytesInBuffer() == 0) {
    205     OS << '\n';
    206     return;
    207   }
    208 
    209   CommentStream.flush();
    210   StringRef Comments = CommentToEmit.str();
    211 
    212   assert(Comments.back() == '\n' &&
    213          "Comment array not newline terminated");
    214   do {
    215     // Emit a line of comments.
    216     OS.PadToColumn(MAI.getCommentColumn());
    217     size_t Position = Comments.find('\n');
    218     OS << MAI.getCommentString() << ' ' << Comments.substr(0, Position) << '\n';
    219 
    220     Comments = Comments.substr(Position+1);
    221   } while (!Comments.empty());
    222 
    223   CommentToEmit.clear();
    224   // Tell the comment stream that the vector changed underneath it.
    225   CommentStream.resync();
    226 }
    227 
    228 static inline int64_t truncateToSize(int64_t Value, unsigned Bytes) {
    229   assert(Bytes && "Invalid size!");
    230   return Value & ((uint64_t) (int64_t) -1 >> (64 - Bytes * 8));
    231 }
    232 
    233 void PTXMCAsmStreamer::ChangeSection(const MCSection *Section) {
    234   assert(Section && "Cannot switch to a null section!");
    235 }
    236 
    237 void PTXMCAsmStreamer::EmitLabel(MCSymbol *Symbol) {
    238   assert(Symbol->isUndefined() && "Cannot define a symbol twice!");
    239   assert(!Symbol->isVariable() && "Cannot emit a variable symbol!");
    240   assert(getCurrentSection() && "Cannot emit before setting section!");
    241 
    242   OS << *Symbol << MAI.getLabelSuffix();
    243   EmitEOL();
    244   Symbol->setSection(*getCurrentSection());
    245 }
    246 
    247 void PTXMCAsmStreamer::EmitAssemblerFlag(MCAssemblerFlag Flag) {}
    248 
    249 void PTXMCAsmStreamer::EmitThumbFunc(MCSymbol *Func) {}
    250 
    251 void PTXMCAsmStreamer::EmitAssignment(MCSymbol *Symbol, const MCExpr *Value) {
    252   OS << *Symbol << " = " << *Value;
    253   EmitEOL();
    254 
    255   // FIXME: Lift context changes into super class.
    256   Symbol->setVariableValue(Value);
    257 }
    258 
    259 void PTXMCAsmStreamer::EmitWeakReference(MCSymbol *Alias,
    260                                          const MCSymbol *Symbol) {
    261   OS << ".weakref " << *Alias << ", " << *Symbol;
    262   EmitEOL();
    263 }
    264 
    265 void PTXMCAsmStreamer::EmitDwarfAdvanceLineAddr(int64_t LineDelta,
    266                                                 const MCSymbol *LastLabel,
    267                                                 const MCSymbol *Label,
    268                                                 unsigned PointerSize) {
    269   report_fatal_error("Unimplemented.");
    270 }
    271 
    272 void PTXMCAsmStreamer::EmitSymbolAttribute(MCSymbol *Symbol,
    273                                            MCSymbolAttr Attribute) {}
    274 
    275 void PTXMCAsmStreamer::EmitSymbolDesc(MCSymbol *Symbol, unsigned DescValue) {}
    276 
    277 void PTXMCAsmStreamer::BeginCOFFSymbolDef(const MCSymbol *Symbol) {}
    278 
    279 void PTXMCAsmStreamer::EmitCOFFSymbolStorageClass (int StorageClass) {}
    280 
    281 void PTXMCAsmStreamer::EmitCOFFSymbolType (int Type) {}
    282 
    283 void PTXMCAsmStreamer::EndCOFFSymbolDef() {}
    284 
    285 void PTXMCAsmStreamer::EmitELFSize(MCSymbol *Symbol, const MCExpr *Value) {}
    286 
    287 void PTXMCAsmStreamer::EmitCommonSymbol(MCSymbol *Symbol, uint64_t Size,
    288                                         unsigned ByteAlignment) {}
    289 
    290 void PTXMCAsmStreamer::EmitLocalCommonSymbol(MCSymbol *Symbol, uint64_t Size,
    291                                              unsigned ByteAlignment) {}
    292 
    293 void PTXMCAsmStreamer::EmitZerofill(const MCSection *Section, MCSymbol *Symbol,
    294                                     unsigned Size, unsigned ByteAlignment) {}
    295 
    296 void PTXMCAsmStreamer::EmitTBSSSymbol(const MCSection *Section,
    297                                       MCSymbol *Symbol,
    298                                       uint64_t Size, unsigned ByteAlignment) {}
    299 
    300 static inline char toOctal(int X) { return (X&7)+'0'; }
    301 
    302 static void PrintQuotedString(StringRef Data, raw_ostream &OS) {
    303   OS << '"';
    304 
    305   for (unsigned i = 0, e = Data.size(); i != e; ++i) {
    306     unsigned char C = Data[i];
    307     if (C == '"' || C == '\\') {
    308       OS << '\\' << (char)C;
    309       continue;
    310     }
    311 
    312     if (isprint((unsigned char)C)) {
    313       OS << (char)C;
    314       continue;
    315     }
    316 
    317     switch (C) {
    318       case '\b': OS << "\\b"; break;
    319       case '\f': OS << "\\f"; break;
    320       case '\n': OS << "\\n"; break;
    321       case '\r': OS << "\\r"; break;
    322       case '\t': OS << "\\t"; break;
    323       default:
    324         OS << '\\';
    325         OS << toOctal(C >> 6);
    326         OS << toOctal(C >> 3);
    327         OS << toOctal(C >> 0);
    328         break;
    329     }
    330   }
    331 
    332   OS << '"';
    333 }
    334 
    335 void PTXMCAsmStreamer::EmitBytes(StringRef Data, unsigned AddrSpace) {
    336   assert(getCurrentSection() && "Cannot emit contents before setting section!");
    337   if (Data.empty()) return;
    338 
    339   if (Data.size() == 1) {
    340     OS << MAI.getData8bitsDirective(AddrSpace);
    341     OS << (unsigned)(unsigned char)Data[0];
    342     EmitEOL();
    343     return;
    344   }
    345 
    346   // If the data ends with 0 and the target supports .asciz, use it, otherwise
    347   // use .ascii
    348   if (MAI.getAscizDirective() && Data.back() == 0) {
    349     OS << MAI.getAscizDirective();
    350     Data = Data.substr(0, Data.size()-1);
    351   } else {
    352     OS << MAI.getAsciiDirective();
    353   }
    354 
    355   OS << ' ';
    356   PrintQuotedString(Data, OS);
    357   EmitEOL();
    358 }
    359 
    360 void PTXMCAsmStreamer::EmitValueImpl(const MCExpr *Value, unsigned Size,
    361                                      unsigned AddrSpace) {
    362   assert(getCurrentSection() && "Cannot emit contents before setting section!");
    363   const char *Directive = 0;
    364   switch (Size) {
    365   default: break;
    366   case 1: Directive = MAI.getData8bitsDirective(AddrSpace); break;
    367   case 2: Directive = MAI.getData16bitsDirective(AddrSpace); break;
    368   case 4: Directive = MAI.getData32bitsDirective(AddrSpace); break;
    369   case 8:
    370     Directive = MAI.getData64bitsDirective(AddrSpace);
    371     // If the target doesn't support 64-bit data, emit as two 32-bit halves.
    372     if (Directive) break;
    373     int64_t IntValue;
    374     if (!Value->EvaluateAsAbsolute(IntValue))
    375       report_fatal_error("Don't know how to emit this value.");
    376     if (getContext().getAsmInfo().isLittleEndian()) {
    377       EmitIntValue((uint32_t)(IntValue >> 0 ), 4, AddrSpace);
    378       EmitIntValue((uint32_t)(IntValue >> 32), 4, AddrSpace);
    379     } else {
    380       EmitIntValue((uint32_t)(IntValue >> 32), 4, AddrSpace);
    381       EmitIntValue((uint32_t)(IntValue >> 0 ), 4, AddrSpace);
    382     }
    383     return;
    384   }
    385 
    386   assert(Directive && "Invalid size for machine code value!");
    387   OS << Directive << *Value;
    388   EmitEOL();
    389 }
    390 
    391 void PTXMCAsmStreamer::EmitULEB128Value(const MCExpr *Value) {
    392   assert(MAI.hasLEB128() && "Cannot print a .uleb");
    393   OS << ".uleb128 " << *Value;
    394   EmitEOL();
    395 }
    396 
    397 void PTXMCAsmStreamer::EmitSLEB128Value(const MCExpr *Value) {
    398   assert(MAI.hasLEB128() && "Cannot print a .sleb");
    399   OS << ".sleb128 " << *Value;
    400   EmitEOL();
    401 }
    402 
    403 void PTXMCAsmStreamer::EmitGPRel32Value(const MCExpr *Value) {
    404   assert(MAI.getGPRel32Directive() != 0);
    405   OS << MAI.getGPRel32Directive() << *Value;
    406   EmitEOL();
    407 }
    408 
    409 
    410 /// EmitFill - Emit NumBytes bytes worth of the value specified by
    411 /// FillValue.  This implements directives such as '.space'.
    412 void PTXMCAsmStreamer::EmitFill(uint64_t NumBytes, uint8_t FillValue,
    413                                 unsigned AddrSpace) {
    414   if (NumBytes == 0) return;
    415 
    416   if (AddrSpace == 0)
    417     if (const char *ZeroDirective = MAI.getZeroDirective()) {
    418       OS << ZeroDirective << NumBytes;
    419       if (FillValue != 0)
    420         OS << ',' << (int)FillValue;
    421       EmitEOL();
    422       return;
    423     }
    424 
    425   // Emit a byte at a time.
    426   MCStreamer::EmitFill(NumBytes, FillValue, AddrSpace);
    427 }
    428 
    429 void PTXMCAsmStreamer::EmitValueToAlignment(unsigned ByteAlignment,
    430                                             int64_t Value,
    431                                             unsigned ValueSize,
    432                                             unsigned MaxBytesToEmit) {
    433   // Some assemblers don't support non-power of two alignments, so we always
    434   // emit alignments as a power of two if possible.
    435   if (isPowerOf2_32(ByteAlignment)) {
    436     switch (ValueSize) {
    437     default: llvm_unreachable("Invalid size for machine code value!");
    438     case 1: OS << MAI.getAlignDirective(); break;
    439     // FIXME: use MAI for this!
    440     case 2: OS << ".p2alignw "; break;
    441     case 4: OS << ".p2alignl "; break;
    442     case 8: llvm_unreachable("Unsupported alignment size!");
    443     }
    444 
    445     if (MAI.getAlignmentIsInBytes())
    446       OS << ByteAlignment;
    447     else
    448       OS << Log2_32(ByteAlignment);
    449 
    450     if (Value || MaxBytesToEmit) {
    451       OS << ", 0x";
    452       OS.write_hex(truncateToSize(Value, ValueSize));
    453 
    454       if (MaxBytesToEmit)
    455         OS << ", " << MaxBytesToEmit;
    456     }
    457     EmitEOL();
    458     return;
    459   }
    460 
    461   // Non-power of two alignment.  This is not widely supported by assemblers.
    462   // FIXME: Parameterize this based on MAI.
    463   switch (ValueSize) {
    464   default: llvm_unreachable("Invalid size for machine code value!");
    465   case 1: OS << ".balign";  break;
    466   case 2: OS << ".balignw"; break;
    467   case 4: OS << ".balignl"; break;
    468   case 8: llvm_unreachable("Unsupported alignment size!");
    469   }
    470 
    471   OS << ' ' << ByteAlignment;
    472   OS << ", " << truncateToSize(Value, ValueSize);
    473   if (MaxBytesToEmit)
    474     OS << ", " << MaxBytesToEmit;
    475   EmitEOL();
    476 }
    477 
    478 void PTXMCAsmStreamer::EmitCodeAlignment(unsigned ByteAlignment,
    479                                          unsigned MaxBytesToEmit) {}
    480 
    481 bool PTXMCAsmStreamer::EmitValueToOffset(const MCExpr *Offset,
    482                                          unsigned char Value) {return false;}
    483 
    484 
    485 void PTXMCAsmStreamer::EmitFileDirective(StringRef Filename) {
    486   assert(MAI.hasSingleParameterDotFile());
    487   OS << "\t.file\t";
    488   PrintQuotedString(Filename, OS);
    489   EmitEOL();
    490 }
    491 
    492 // FIXME: should we inherit from MCAsmStreamer?
    493 bool PTXMCAsmStreamer::EmitDwarfFileDirective(unsigned FileNo,
    494                                               StringRef Directory,
    495                                               StringRef Filename) {
    496   if (!Directory.empty()) {
    497     if (sys::path::is_absolute(Filename))
    498       return EmitDwarfFileDirective(FileNo, "", Filename);
    499     SmallString<128> FullPathName = Directory;
    500     sys::path::append(FullPathName, Filename);
    501     return EmitDwarfFileDirective(FileNo, "", FullPathName);
    502   }
    503 
    504   OS << "\t.file\t" << FileNo << ' ';
    505   PrintQuotedString(Filename, OS);
    506   EmitEOL();
    507   return this->MCStreamer::EmitDwarfFileDirective(FileNo, Directory, Filename);
    508 }
    509 
    510 void PTXMCAsmStreamer::AddEncodingComment(const MCInst &Inst) {}
    511 
    512 void PTXMCAsmStreamer::EmitInstruction(const MCInst &Inst) {
    513   assert(getCurrentSection() && "Cannot emit contents before setting section!");
    514 
    515   // Show the encoding in a comment if we have a code emitter.
    516   if (Emitter)
    517     AddEncodingComment(Inst);
    518 
    519   // Show the MCInst if enabled.
    520   if (ShowInst) {
    521     Inst.dump_pretty(GetCommentOS(), &MAI, InstPrinter.get(), "\n ");
    522     GetCommentOS() << "\n";
    523   }
    524 
    525   // If we have an AsmPrinter, use that to print, otherwise print the MCInst.
    526   if (InstPrinter)
    527     InstPrinter->printInst(&Inst, OS, "");
    528   else
    529     Inst.print(OS, &MAI);
    530   EmitEOL();
    531 }
    532 
    533 /// EmitRawText - If this file is backed by an assembly streamer, this dumps
    534 /// the specified string in the output .s file.  This capability is
    535 /// indicated by the hasRawTextSupport() predicate.
    536 void PTXMCAsmStreamer::EmitRawText(StringRef String) {
    537   if (!String.empty() && String.back() == '\n')
    538     String = String.substr(0, String.size()-1);
    539   OS << String;
    540   EmitEOL();
    541 }
    542 
    543 void PTXMCAsmStreamer::FinishImpl() {}
    544 
    545 namespace llvm {
    546   MCStreamer *createPTXAsmStreamer(MCContext &Context,
    547                                    formatted_raw_ostream &OS,
    548                                    bool isVerboseAsm, bool useLoc, bool useCFI,
    549                                    bool useDwarfDirectory,
    550                                    MCInstPrinter *IP,
    551                                    MCCodeEmitter *CE, MCAsmBackend *MAB,
    552                                    bool ShowInst) {
    553     return new PTXMCAsmStreamer(Context, OS, isVerboseAsm, useLoc,
    554                                 IP, CE, ShowInst);
    555   }
    556 }
    557