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