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, int 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 printParamName(Function::const_arg_iterator I, int paramIndex,
177                       raw_ostream &O);
178   void emitGlobals(const Module &M);
179   void emitHeader(Module &M, raw_ostream &O, const NVPTXSubtarget &STI);
180   void emitKernelFunctionDirectives(const Function &F, raw_ostream &O) const;
181   void emitVirtualRegister(unsigned int vr, raw_ostream &);
182   void emitFunctionParamList(const Function *, raw_ostream &O);
183   void emitFunctionParamList(const MachineFunction &MF, raw_ostream &O);
184   void setAndEmitFunctionVirtualRegisters(const MachineFunction &MF);
185   void printReturnValStr(const Function *, raw_ostream &O);
186   void printReturnValStr(const MachineFunction &MF, raw_ostream &O);
187   bool PrintAsmOperand(const MachineInstr *MI, unsigned OpNo,
188                        const char *ExtraCode, raw_ostream &) override;
189   void printOperand(const MachineInstr *MI, int opNum, raw_ostream &O);
190   bool PrintAsmMemoryOperand(const MachineInstr *MI, unsigned OpNo,
191                              const char *ExtraCode, raw_ostream &) override;
192 
193   const MCExpr *lowerConstantForGV(const Constant *CV, bool ProcessingGeneric);
194   void printMCExpr(const MCExpr &Expr, raw_ostream &OS);
195 
196 protected:
197   bool doInitialization(Module &M) override;
198   bool doFinalization(Module &M) override;
199 
200 private:
201   bool GlobalsEmitted;
202 
203   // This is specific per MachineFunction.
204   const MachineRegisterInfo *MRI;
205   // The contents are specific for each
206   // MachineFunction. But the size of the
207   // array is not.
208   typedef DenseMap<unsigned, unsigned> VRegMap;
209   typedef DenseMap<const TargetRegisterClass *, VRegMap> VRegRCMap;
210   VRegRCMap VRegMapping;
211 
212   // List of variables demoted to a function scope.
213   std::map<const Function *, std::vector<const GlobalVariable *>> localDecls;
214 
215   void emitPTXGlobalVariable(const GlobalVariable *GVar, raw_ostream &O,
216                              const NVPTXSubtarget &STI);
217   void emitPTXAddressSpace(unsigned int AddressSpace, raw_ostream &O) const;
218   std::string getPTXFundamentalTypeStr(Type *Ty, bool = true) const;
219   void printScalarConstant(const Constant *CPV, raw_ostream &O);
220   void printFPConstant(const ConstantFP *Fp, raw_ostream &O);
221   void bufferLEByte(const Constant *CPV, int Bytes, AggBuffer *aggBuffer);
222   void bufferAggregateConstant(const Constant *CV, AggBuffer *aggBuffer);
223 
224   void emitLinkageDirective(const GlobalValue *V, raw_ostream &O);
225   void emitDeclarations(const Module &, raw_ostream &O);
226   void emitDeclaration(const Function *, raw_ostream &O);
227   void emitDemotedVars(const Function *, raw_ostream &);
228 
229   bool lowerImageHandleOperand(const MachineInstr *MI, unsigned OpNo,
230                                MCOperand &MCOp);
231   void lowerImageHandleSymbol(unsigned Index, MCOperand &MCOp);
232 
233   bool isLoopHeaderOfNoUnroll(const MachineBasicBlock &MBB) const;
234 
235   // Used to control the need to emit .generic() in the initializer of
236   // module scope variables.
237   // Although ptx supports the hybrid mode like the following,
238   //    .global .u32 a;
239   //    .global .u32 b;
240   //    .global .u32 addr[] = {a, generic(b)}
241   // we have difficulty representing the difference in the NVVM IR.
242   //
243   // Since the address value should always be generic in CUDA C and always
244   // be specific in OpenCL, we use this simple control here.
245   //
246   bool EmitGeneric;
247 
248 public:
249   NVPTXAsmPrinter(TargetMachine &TM, std::unique_ptr<MCStreamer> Streamer)
250       : AsmPrinter(TM, std::move(Streamer)),
251         EmitGeneric(static_cast<NVPTXTargetMachine &>(TM).getDrvInterface() ==
252                     NVPTX::CUDA) {}
253 
254   bool runOnMachineFunction(MachineFunction &F) override;
255 
256   void getAnalysisUsage(AnalysisUsage &AU) const override {
257     AU.addRequired<MachineLoopInfo>();
258     AsmPrinter::getAnalysisUsage(AU);
259   }
260 
261   std::string getVirtualRegisterName(unsigned) const;
262 
263   const MCSymbol *getFunctionFrameSymbol() const override;
264 
265   // Make emitGlobalVariable() no-op for NVPTX.
266   // Global variables have been already emitted by the time the base AsmPrinter
267   // attempts to do so in doFinalization() (see NVPTXAsmPrinter::emitGlobals()).
268   void emitGlobalVariable(const GlobalVariable *GV) override {}
269 };
270 
271 } // end namespace llvm
272 
273 #endif // LLVM_LIB_TARGET_NVPTX_NVPTXASMPRINTER_H
274