llvm/lib/Target/NVPTX/NVPTXAsmPrinter.h

   1 //===-- NVPTXAsmPrinter.h - NVPTX LLVM assembly writer ----------*- C++ -*-===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 // This file contains a printer that converts from our internal representation
  10 // of machine-dependent LLVM code to NVPTX assembly language.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #ifndef LLVM_LIB_TARGET_NVPTX_NVPTXASMPRINTER_H
  15 #define LLVM_LIB_TARGET_NVPTX_NVPTXASMPRINTER_H
  16
  17 #include "NVPTX.h"
  18 #include "NVPTXSubtarget.h"
  19 #include "NVPTXTargetMachine.h"
  20 #include "llvm/ADT/DenseMap.h"
  21 #include "llvm/ADT/SmallVector.h"
  22 #include "llvm/ADT/StringRef.h"
  23 #include "llvm/CodeGen/AsmPrinter.h"
  24 #include "llvm/CodeGen/MachineFunction.h"
  25 #include "llvm/CodeGen/MachineLoopInfo.h"
  26 #include "llvm/IR/Constants.h"
  27 #include "llvm/IR/DebugLoc.h"
  28 #include "llvm/IR/DerivedTypes.h"
  29 #include "llvm/IR/Function.h"
  30 #include "llvm/IR/GlobalValue.h"
  31 #include "llvm/IR/Value.h"
  32 #include "llvm/MC/MCExpr.h"
  33 #include "llvm/MC/MCStreamer.h"
  34 #include "llvm/MC/MCSymbol.h"
  35 #include "llvm/Pass.h"
  36 #include "llvm/Support/Casting.h"
  37 #include "llvm/Support/Compiler.h"
  38 #include "llvm/Support/ErrorHandling.h"
  39 #include "llvm/Support/raw_ostream.h"
  40 #include "llvm/Target/TargetMachine.h"
  41 #include <algorithm>
  42 #include <cassert>
  43 #include <map>
  44 #include <memory>
  45 #include <string>
  46 #include <vector>
  47
  48 // The ptx syntax and format is very different from that usually seem in a .s
  49 // file,
  50 // therefore we are not able to use the MCAsmStreamer interface here.
  51 //
  52 // We are handcrafting the output method here.
  53 //
  54 // A better approach is to clone the MCAsmStreamer to a MCPTXAsmStreamer
  55 // (subclass of MCStreamer).
  56
  57 namespace llvm {
  58
  59 class MCOperand;
  60
  61 class LLVM_LIBRARY_VISIBILITY NVPTXAsmPrinter : public AsmPrinter {
  62
  63   class AggBuffer {
  64     // Used to buffer the emitted string for initializing global aggregates.
  65     //
  66     // Normally an aggregate (array, vector, or structure) is emitted as a u8[].
  67     // However, if either element/field of the aggregate is a non-NULL address,
  68     // and all such addresses are properly aligned, then the aggregate is
  69     // emitted as u32[] or u64[]. In the case of unaligned addresses, the
  70     // aggregate is emitted as u8[], and the mask() operator is used for all
  71     // pointers.
  72     //
  73     // We first layout the aggregate in 'buffer' in bytes, except for those
  74     // symbol addresses. For the i-th symbol address in the aggregate, its
  75     // corresponding 4-byte or 8-byte elements in 'buffer' are filled with 0s.
  76     // symbolPosInBuffer[i-1] records its position in 'buffer', and Symbols[i-1]
  77     // records the Value*.
  78     //
  79     // Once we have this AggBuffer setup, we can choose how to print it out.
  80   public:
  81     // number of symbol addresses
  82     unsigned numSymbols() const { return Symbols.size(); }
  83
  84     bool allSymbolsAligned(unsigned ptrSize) const {
  85       return llvm::all_of(symbolPosInBuffer,
  86                           [=](unsigned pos) { return pos % ptrSize == 0; });
  87     }
  88
  89   private:
  90     const unsigned size;   // size of the buffer in bytes
  91     std::vector<unsigned char> buffer; // the buffer
  92     SmallVector<unsigned, 4> symbolPosInBuffer;
  93     SmallVector<const Value *, 4> Symbols;
  94     // SymbolsBeforeStripping[i] is the original form of Symbols[i] before
  95     // stripping pointer casts, i.e.,
  96     // Symbols[i] == SymbolsBeforeStripping[i]->stripPointerCasts().
  97     //
  98     // We need to keep these values because AggBuffer::print decides whether to
  99     // emit a "generic()" cast for Symbols[i] depending on the address space of
 100     // SymbolsBeforeStripping[i].
 101     SmallVector<const Value *, 4> SymbolsBeforeStripping;
 102     unsigned curpos;
 103     NVPTXAsmPrinter &AP;
 104     bool EmitGeneric;
 105
 106   public:
 107     AggBuffer(unsigned size, NVPTXAsmPrinter &AP)
 108         : size(size), buffer(size), AP(AP) {
 109       curpos = 0;
 110       EmitGeneric = AP.EmitGeneric;
 111     }
 112
 113     // Copy Num bytes from Ptr.
 114     // if Bytes > Num, zero fill up to Bytes.
 115     unsigned addBytes(unsigned char *Ptr, int Num, int Bytes) {
 116       assert((curpos + Num) <= size);
 117       assert((curpos + Bytes) <= size);
 118       for (int i = 0; i < Num; ++i) {
 119         buffer[curpos] = Ptr[i];
 120         curpos++;
 121       }
 122       for (int i = Num; i < Bytes; ++i) {
 123         buffer[curpos] = 0;
 124         curpos++;
 125       }
 126       return curpos;
 127     }
 128
 129     unsigned addZeros(int Num) {
 130       assert((curpos + Num) <= size);
 131       for (int i = 0; i < Num; ++i) {
 132         buffer[curpos] = 0;
 133         curpos++;
 134       }
 135       return curpos;
 136     }
 137
 138     void addSymbol(const Value *GVar, const Value *GVarBeforeStripping) {
 139       symbolPosInBuffer.push_back(curpos);
 140       Symbols.push_back(GVar);
 141       SymbolsBeforeStripping.push_back(GVarBeforeStripping);
 142     }
 143
 144     void printBytes(raw_ostream &os);
 145     void printWords(raw_ostream &os);
 146
 147   private:
 148     void printSymbol(unsigned nSym, raw_ostream &os);
 149   };
 150
 151   friend class AggBuffer;
 152
 153 private:
 154   StringRef getPassName() const override { return "NVPTX Assembly Printer"; }
 155
 156   const Function *F;
 157   std::string CurrentFnName;
 158
 159   void emitStartOfAsmFile(Module &M) override;
 160   void emitBasicBlockStart(const MachineBasicBlock &MBB) override;
 161   void emitFunctionEntryLabel() override;
 162   void emitFunctionBodyStart() override;
 163   void emitFunctionBodyEnd() override;
 164   void emitImplicitDef(const MachineInstr *MI) const override;
 165
 166   void emitInstruction(const MachineInstr *) override;
 167   void lowerToMCInst(const MachineInstr *MI, MCInst &OutMI);
 168   bool lowerOperand(const MachineOperand &MO, MCOperand &MCOp);
 169   MCOperand GetSymbolRef(const MCSymbol *Symbol);
 170   unsigned encodeVirtualRegister(unsigned Reg);
 171
 172   void printMemOperand(const MachineInstr *MI, unsigned OpNum, raw_ostream &O,
 173                        const char *Modifier = nullptr);
 174   void printModuleLevelGV(const GlobalVariable *GVar, raw_ostream &O,
 175                           bool processDemoted, const NVPTXSubtarget &STI);
 176   void emitGlobals(const Module &M);
 177   void emitGlobalAlias(const Module &M, const GlobalAlias &GA);
 178   void emitHeader(Module &M, raw_ostream &O, const NVPTXSubtarget &STI);
 179   void emitKernelFunctionDirectives(const Function &F, raw_ostream &O) const;
 180   void emitVirtualRegister(unsigned int vr, raw_ostream &);
 181   void emitFunctionParamList(const Function *, raw_ostream &O);
 182   void setAndEmitFunctionVirtualRegisters(const MachineFunction &MF);
 183   void printReturnValStr(const Function *, raw_ostream &O);
 184   void printReturnValStr(const MachineFunction &MF, raw_ostream &O);
 185   bool PrintAsmOperand(const MachineInstr *MI, unsigned OpNo,
 186                        const char *ExtraCode, raw_ostream &) override;
 187   void printOperand(const MachineInstr *MI, unsigned OpNum, raw_ostream &O);
 188   bool PrintAsmMemoryOperand(const MachineInstr *MI, unsigned OpNo,
 189                              const char *ExtraCode, raw_ostream &) override;
 190
 191   const MCExpr *lowerConstantForGV(const Constant *CV, bool ProcessingGeneric);
 192   void printMCExpr(const MCExpr &Expr, raw_ostream &OS);
 193
 194 protected:
 195   bool doInitialization(Module &M) override;
 196   bool doFinalization(Module &M) override;
 197
 198 private:
 199   bool GlobalsEmitted;
 200
 201   // This is specific per MachineFunction.
 202   const MachineRegisterInfo *MRI;
 203   // The contents are specific for each
 204   // MachineFunction. But the size of the
 205   // array is not.
 206   typedef DenseMap<unsigned, unsigned> VRegMap;
 207   typedef DenseMap<const TargetRegisterClass *, VRegMap> VRegRCMap;
 208   VRegRCMap VRegMapping;
 209
 210   // List of variables demoted to a function scope.
 211   std::map<const Function *, std::vector<const GlobalVariable *>> localDecls;
 212
 213   void emitPTXGlobalVariable(const GlobalVariable *GVar, raw_ostream &O,
 214                              const NVPTXSubtarget &STI);
 215   void emitPTXAddressSpace(unsigned int AddressSpace, raw_ostream &O) const;
 216   std::string getPTXFundamentalTypeStr(Type *Ty, bool = true) const;
 217   void printScalarConstant(const Constant *CPV, raw_ostream &O);
 218   void printFPConstant(const ConstantFP *Fp, raw_ostream &O);
 219   void bufferLEByte(const Constant *CPV, int Bytes, AggBuffer *aggBuffer);
 220   void bufferAggregateConstant(const Constant *CV, AggBuffer *aggBuffer);
 221
 222   void emitLinkageDirective(const GlobalValue *V, raw_ostream &O);
 223   void emitDeclarations(const Module &, raw_ostream &O);
 224   void emitDeclaration(const Function *, raw_ostream &O);
 225   void emitDemotedVars(const Function *, raw_ostream &);
 226
 227   bool lowerImageHandleOperand(const MachineInstr *MI, unsigned OpNo,
 228                                MCOperand &MCOp);
 229   void lowerImageHandleSymbol(unsigned Index, MCOperand &MCOp);
 230
 231   bool isLoopHeaderOfNoUnroll(const MachineBasicBlock &MBB) const;
 232
 233   // Used to control the need to emit .generic() in the initializer of
 234   // module scope variables.
 235   // Although ptx supports the hybrid mode like the following,
 236   //    .global .u32 a;
 237   //    .global .u32 b;
 238   //    .global .u32 addr[] = {a, generic(b)}
 239   // we have difficulty representing the difference in the NVVM IR.
 240   //
 241   // Since the address value should always be generic in CUDA C and always
 242   // be specific in OpenCL, we use this simple control here.
 243   //
 244   bool EmitGeneric;
 245
 246 public:
 247   NVPTXAsmPrinter(TargetMachine &TM, std::unique_ptr<MCStreamer> Streamer)
 248       : AsmPrinter(TM, std::move(Streamer)),
 249         EmitGeneric(static_cast<NVPTXTargetMachine &>(TM).getDrvInterface() ==
 250                     NVPTX::CUDA) {}
 251
 252   bool runOnMachineFunction(MachineFunction &F) override;
 253
 254   void getAnalysisUsage(AnalysisUsage &AU) const override {
 255     AU.addRequired<MachineLoopInfo>();
 256     AsmPrinter::getAnalysisUsage(AU);
 257   }
 258
 259   std::string getVirtualRegisterName(unsigned) const;
 260
 261   const MCSymbol *getFunctionFrameSymbol() const override;
 262
 263   // Make emitGlobalVariable() no-op for NVPTX.
 264   // Global variables have been already emitted by the time the base AsmPrinter
 265   // attempts to do so in doFinalization() (see NVPTXAsmPrinter::emitGlobals()).
 266   void emitGlobalVariable(const GlobalVariable *GV) override {}
 267 };
 268
 269 } // end namespace llvm
 270
 271 #endif // LLVM_LIB_TARGET_NVPTX_NVPTXASMPRINTER_H