LLVM  3.7.0
NVPTXAsmPrinter.cpp
Go to the documentation of this file.
1 //===-- NVPTXAsmPrinter.cpp - NVPTX LLVM assembly writer ------------------===//
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 // This file contains a printer that converts from our internal representation
11 // of machine-dependent LLVM code to NVPTX assembly language.
12 //
13 //===----------------------------------------------------------------------===//
14 
15 #include "NVPTXAsmPrinter.h"
18 #include "NVPTX.h"
19 #include "NVPTXInstrInfo.h"
20 #include "NVPTXMCExpr.h"
22 #include "NVPTXRegisterInfo.h"
23 #include "NVPTXTargetMachine.h"
24 #include "NVPTXUtilities.h"
25 #include "cl_common_defines.h"
26 #include "llvm/ADT/StringExtras.h"
28 #include "llvm/CodeGen/Analysis.h"
33 #include "llvm/IR/DebugInfo.h"
34 #include "llvm/IR/DerivedTypes.h"
35 #include "llvm/IR/Function.h"
36 #include "llvm/IR/GlobalVariable.h"
37 #include "llvm/IR/Mangler.h"
38 #include "llvm/IR/Module.h"
39 #include "llvm/IR/Operator.h"
40 #include "llvm/MC/MCInst.h"
41 #include "llvm/MC/MCStreamer.h"
42 #include "llvm/MC/MCSymbol.h"
46 #include "llvm/Support/Path.h"
48 #include "llvm/Support/TimeValue.h"
51 #include <sstream>
52 using namespace llvm;
53 
54 #define DEPOTNAME "__local_depot"
55 
56 static cl::opt<bool>
57 EmitLineNumbers("nvptx-emit-line-numbers", cl::Hidden,
58  cl::desc("NVPTX Specific: Emit Line numbers even without -G"),
59  cl::init(true));
60 
61 static cl::opt<bool>
62 InterleaveSrc("nvptx-emit-src", cl::ZeroOrMore, cl::Hidden,
63  cl::desc("NVPTX Specific: Emit source line in ptx file"),
64  cl::init(false));
65 
66 namespace {
67 /// DiscoverDependentGlobals - Return a set of GlobalVariables on which \p V
68 /// depends.
69 void DiscoverDependentGlobals(const Value *V,
71  if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(V))
72  Globals.insert(GV);
73  else {
74  if (const User *U = dyn_cast<User>(V)) {
75  for (unsigned i = 0, e = U->getNumOperands(); i != e; ++i) {
76  DiscoverDependentGlobals(U->getOperand(i), Globals);
77  }
78  }
79  }
80 }
81 
82 /// VisitGlobalVariableForEmission - Add \p GV to the list of GlobalVariable
83 /// instances to be emitted, but only after any dependents have been added
84 /// first.
85 void VisitGlobalVariableForEmission(
89  // Have we already visited this one?
90  if (Visited.count(GV))
91  return;
92 
93  // Do we have a circular dependency?
94  if (!Visiting.insert(GV).second)
95  report_fatal_error("Circular dependency found in global variable set");
96 
97  // Make sure we visit all dependents first
99  for (unsigned i = 0, e = GV->getNumOperands(); i != e; ++i)
100  DiscoverDependentGlobals(GV->getOperand(i), Others);
101 
103  E = Others.end();
104  I != E; ++I)
105  VisitGlobalVariableForEmission(*I, Order, Visited, Visiting);
106 
107  // Now we can visit ourself
108  Order.push_back(GV);
109  Visited.insert(GV);
110  Visiting.erase(GV);
111 }
112 }
113 
115  if (!EmitLineNumbers)
116  return;
117  if (ignoreLoc(MI))
118  return;
119 
120  DebugLoc curLoc = MI.getDebugLoc();
121 
122  if (!prevDebugLoc && !curLoc)
123  return;
124 
125  if (prevDebugLoc == curLoc)
126  return;
127 
128  prevDebugLoc = curLoc;
129 
130  if (!curLoc)
131  return;
132 
133  auto *Scope = cast_or_null<DIScope>(curLoc.getScope());
134  if (!Scope)
135  return;
136 
137  StringRef fileName(Scope->getFilename());
138  StringRef dirName(Scope->getDirectory());
139  SmallString<128> FullPathName = dirName;
140  if (!dirName.empty() && !sys::path::is_absolute(fileName)) {
141  sys::path::append(FullPathName, fileName);
142  fileName = FullPathName;
143  }
144 
145  if (filenameMap.find(fileName) == filenameMap.end())
146  return;
147 
148  // Emit the line from the source file.
149  if (InterleaveSrc)
150  this->emitSrcInText(fileName, curLoc.getLine());
151 
152  std::stringstream temp;
153  temp << "\t.loc " << filenameMap[fileName] << " " << curLoc.getLine()
154  << " " << curLoc.getCol();
155  OutStreamer->EmitRawText(temp.str());
156 }
157 
158 void NVPTXAsmPrinter::EmitInstruction(const MachineInstr *MI) {
159  SmallString<128> Str;
160  raw_svector_ostream OS(Str);
161  if (static_cast<NVPTXTargetMachine &>(TM).getDrvInterface() == NVPTX::CUDA)
163 
164  MCInst Inst;
165  lowerToMCInst(MI, Inst);
166  EmitToStreamer(*OutStreamer, Inst);
167 }
168 
169 // Handle symbol backtracking for targets that do not support image handles
170 bool NVPTXAsmPrinter::lowerImageHandleOperand(const MachineInstr *MI,
171  unsigned OpNo, MCOperand &MCOp) {
172  const MachineOperand &MO = MI->getOperand(OpNo);
173  const MCInstrDesc &MCID = MI->getDesc();
174 
175  if (MCID.TSFlags & NVPTXII::IsTexFlag) {
176  // This is a texture fetch, so operand 4 is a texref and operand 5 is
177  // a samplerref
178  if (OpNo == 4 && MO.isImm()) {
179  lowerImageHandleSymbol(MO.getImm(), MCOp);
180  return true;
181  }
182  if (OpNo == 5 && MO.isImm() && !(MCID.TSFlags & NVPTXII::IsTexModeUnifiedFlag)) {
183  lowerImageHandleSymbol(MO.getImm(), MCOp);
184  return true;
185  }
186 
187  return false;
188  } else if (MCID.TSFlags & NVPTXII::IsSuldMask) {
189  unsigned VecSize =
190  1 << (((MCID.TSFlags & NVPTXII::IsSuldMask) >> NVPTXII::IsSuldShift) - 1);
191 
192  // For a surface load of vector size N, the Nth operand will be the surfref
193  if (OpNo == VecSize && MO.isImm()) {
194  lowerImageHandleSymbol(MO.getImm(), MCOp);
195  return true;
196  }
197 
198  return false;
199  } else if (MCID.TSFlags & NVPTXII::IsSustFlag) {
200  // This is a surface store, so operand 0 is a surfref
201  if (OpNo == 0 && MO.isImm()) {
202  lowerImageHandleSymbol(MO.getImm(), MCOp);
203  return true;
204  }
205 
206  return false;
207  } else if (MCID.TSFlags & NVPTXII::IsSurfTexQueryFlag) {
208  // This is a query, so operand 1 is a surfref/texref
209  if (OpNo == 1 && MO.isImm()) {
210  lowerImageHandleSymbol(MO.getImm(), MCOp);
211  return true;
212  }
213 
214  return false;
215  }
216 
217  return false;
218 }
219 
220 void NVPTXAsmPrinter::lowerImageHandleSymbol(unsigned Index, MCOperand &MCOp) {
221  // Ewwww
222  TargetMachine &TM = const_cast<TargetMachine&>(MF->getTarget());
223  NVPTXTargetMachine &nvTM = static_cast<NVPTXTargetMachine&>(TM);
225  const char *Sym = MFI->getImageHandleSymbol(Index);
226  std::string *SymNamePtr =
227  nvTM.getManagedStrPool()->getManagedString(Sym);
228  MCOp = GetSymbolRef(OutContext.getOrCreateSymbol(
229  StringRef(SymNamePtr->c_str())));
230 }
231 
232 void NVPTXAsmPrinter::lowerToMCInst(const MachineInstr *MI, MCInst &OutMI) {
233  OutMI.setOpcode(MI->getOpcode());
234  // Special: Do not mangle symbol operand of CALL_PROTOTYPE
235  if (MI->getOpcode() == NVPTX::CALL_PROTOTYPE) {
236  const MachineOperand &MO = MI->getOperand(0);
237  OutMI.addOperand(GetSymbolRef(
239  return;
240  }
241 
242  for (unsigned i = 0, e = MI->getNumOperands(); i != e; ++i) {
243  const MachineOperand &MO = MI->getOperand(i);
244 
245  MCOperand MCOp;
246  if (!nvptxSubtarget->hasImageHandles()) {
247  if (lowerImageHandleOperand(MI, i, MCOp)) {
248  OutMI.addOperand(MCOp);
249  continue;
250  }
251  }
252 
253  if (lowerOperand(MO, MCOp))
254  OutMI.addOperand(MCOp);
255  }
256 }
257 
258 bool NVPTXAsmPrinter::lowerOperand(const MachineOperand &MO,
259  MCOperand &MCOp) {
260  switch (MO.getType()) {
261  default: llvm_unreachable("unknown operand type");
263  MCOp = MCOperand::createReg(encodeVirtualRegister(MO.getReg()));
264  break;
266  MCOp = MCOperand::createImm(MO.getImm());
267  break;
270  MO.getMBB()->getSymbol(), OutContext));
271  break;
273  MCOp = GetSymbolRef(GetExternalSymbolSymbol(MO.getSymbolName()));
274  break;
276  MCOp = GetSymbolRef(getSymbol(MO.getGlobal()));
277  break;
279  const ConstantFP *Cnt = MO.getFPImm();
280  APFloat Val = Cnt->getValueAPF();
281 
282  switch (Cnt->getType()->getTypeID()) {
283  default: report_fatal_error("Unsupported FP type"); break;
284  case Type::FloatTyID:
285  MCOp = MCOperand::createExpr(
287  break;
288  case Type::DoubleTyID:
289  MCOp = MCOperand::createExpr(
291  break;
292  }
293  break;
294  }
295  }
296  return true;
297 }
298 
299 unsigned NVPTXAsmPrinter::encodeVirtualRegister(unsigned Reg) {
301  const TargetRegisterClass *RC = MRI->getRegClass(Reg);
302 
303  DenseMap<unsigned, unsigned> &RegMap = VRegMapping[RC];
304  unsigned RegNum = RegMap[Reg];
305 
306  // Encode the register class in the upper 4 bits
307  // Must be kept in sync with NVPTXInstPrinter::printRegName
308  unsigned Ret = 0;
309  if (RC == &NVPTX::Int1RegsRegClass) {
310  Ret = (1 << 28);
311  } else if (RC == &NVPTX::Int16RegsRegClass) {
312  Ret = (2 << 28);
313  } else if (RC == &NVPTX::Int32RegsRegClass) {
314  Ret = (3 << 28);
315  } else if (RC == &NVPTX::Int64RegsRegClass) {
316  Ret = (4 << 28);
317  } else if (RC == &NVPTX::Float32RegsRegClass) {
318  Ret = (5 << 28);
319  } else if (RC == &NVPTX::Float64RegsRegClass) {
320  Ret = (6 << 28);
321  } else {
322  report_fatal_error("Bad register class");
323  }
324 
325  // Insert the vreg number
326  Ret |= (RegNum & 0x0FFFFFFF);
327  return Ret;
328  } else {
329  // Some special-use registers are actually physical registers.
330  // Encode this as the register class ID of 0 and the real register ID.
331  return Reg & 0x0FFFFFFF;
332  }
333 }
334 
335 MCOperand NVPTXAsmPrinter::GetSymbolRef(const MCSymbol *Symbol) {
336  const MCExpr *Expr;
338  OutContext);
339  return MCOperand::createExpr(Expr);
340 }
341 
342 void NVPTXAsmPrinter::printReturnValStr(const Function *F, raw_ostream &O) {
343  const DataLayout &DL = getDataLayout();
344  const TargetLowering *TLI = nvptxSubtarget->getTargetLowering();
345 
346  Type *Ty = F->getReturnType();
347 
348  bool isABI = (nvptxSubtarget->getSmVersion() >= 20);
349 
350  if (Ty->getTypeID() == Type::VoidTyID)
351  return;
352 
353  O << " (";
354 
355  if (isABI) {
356  if (Ty->isFloatingPointTy() || Ty->isIntegerTy()) {
357  unsigned size = 0;
358  if (const IntegerType *ITy = dyn_cast<IntegerType>(Ty)) {
359  size = ITy->getBitWidth();
360  if (size < 32)
361  size = 32;
362  } else {
363  assert(Ty->isFloatingPointTy() && "Floating point type expected here");
364  size = Ty->getPrimitiveSizeInBits();
365  }
366 
367  O << ".param .b" << size << " func_retval0";
368  } else if (isa<PointerType>(Ty)) {
369  O << ".param .b" << TLI->getPointerTy(DL).getSizeInBits()
370  << " func_retval0";
371  } else if ((Ty->getTypeID() == Type::StructTyID) || isa<VectorType>(Ty)) {
372  unsigned totalsz = DL.getTypeAllocSize(Ty);
373  unsigned retAlignment = 0;
374  if (!llvm::getAlign(*F, 0, retAlignment))
375  retAlignment = DL.getABITypeAlignment(Ty);
376  O << ".param .align " << retAlignment << " .b8 func_retval0[" << totalsz
377  << "]";
378  } else
379  llvm_unreachable("Unknown return type");
380  } else {
381  SmallVector<EVT, 16> vtparts;
382  ComputeValueVTs(*TLI, DL, Ty, vtparts);
383  unsigned idx = 0;
384  for (unsigned i = 0, e = vtparts.size(); i != e; ++i) {
385  unsigned elems = 1;
386  EVT elemtype = vtparts[i];
387  if (vtparts[i].isVector()) {
388  elems = vtparts[i].getVectorNumElements();
389  elemtype = vtparts[i].getVectorElementType();
390  }
391 
392  for (unsigned j = 0, je = elems; j != je; ++j) {
393  unsigned sz = elemtype.getSizeInBits();
394  if (elemtype.isInteger() && (sz < 32))
395  sz = 32;
396  O << ".reg .b" << sz << " func_retval" << idx;
397  if (j < je - 1)
398  O << ", ";
399  ++idx;
400  }
401  if (i < e - 1)
402  O << ", ";
403  }
404  }
405  O << ") ";
406  return;
407 }
408 
409 void NVPTXAsmPrinter::printReturnValStr(const MachineFunction &MF,
410  raw_ostream &O) {
411  const Function *F = MF.getFunction();
412  printReturnValStr(F, O);
413 }
414 
415 // Return true if MBB is the header of a loop marked with
416 // llvm.loop.unroll.disable.
417 // TODO: consider "#pragma unroll 1" which is equivalent to "#pragma nounroll".
418 bool NVPTXAsmPrinter::isLoopHeaderOfNoUnroll(
419  const MachineBasicBlock &MBB) const {
420  MachineLoopInfo &LI = getAnalysis<MachineLoopInfo>();
421  // We insert .pragma "nounroll" only to the loop header.
422  if (!LI.isLoopHeader(&MBB))
423  return false;
424 
425  // llvm.loop.unroll.disable is marked on the back edges of a loop. Therefore,
426  // we iterate through each back edge of the loop with header MBB, and check
427  // whether its metadata contains llvm.loop.unroll.disable.
428  for (auto I = MBB.pred_begin(); I != MBB.pred_end(); ++I) {
429  const MachineBasicBlock *PMBB = *I;
430  if (LI.getLoopFor(PMBB) != LI.getLoopFor(&MBB)) {
431  // Edges from other loops to MBB are not back edges.
432  continue;
433  }
434  if (const BasicBlock *PBB = PMBB->getBasicBlock()) {
435  if (MDNode *LoopID = PBB->getTerminator()->getMetadata("llvm.loop")) {
436  if (GetUnrollMetadata(LoopID, "llvm.loop.unroll.disable"))
437  return true;
438  }
439  }
440  }
441  return false;
442 }
443 
444 void NVPTXAsmPrinter::EmitBasicBlockStart(const MachineBasicBlock &MBB) const {
446  if (isLoopHeaderOfNoUnroll(MBB))
447  OutStreamer->EmitRawText(StringRef("\t.pragma \"nounroll\";\n"));
448 }
449 
450 void NVPTXAsmPrinter::EmitFunctionEntryLabel() {
451  SmallString<128> Str;
452  raw_svector_ostream O(Str);
453 
454  if (!GlobalsEmitted) {
455  emitGlobals(*MF->getFunction()->getParent());
456  GlobalsEmitted = true;
457  }
458 
459  // Set up
460  MRI = &MF->getRegInfo();
461  F = MF->getFunction();
462  emitLinkageDirective(F, O);
463  if (llvm::isKernelFunction(*F))
464  O << ".entry ";
465  else {
466  O << ".func ";
467  printReturnValStr(*MF, O);
468  }
469 
470  CurrentFnSym->print(O, MAI);
471 
472  emitFunctionParamList(*MF, O);
473 
474  if (llvm::isKernelFunction(*F))
475  emitKernelFunctionDirectives(*F, O);
476 
477  OutStreamer->EmitRawText(O.str());
478 
480 }
481 
482 void NVPTXAsmPrinter::EmitFunctionBodyStart() {
483  VRegMapping.clear();
484  OutStreamer->EmitRawText(StringRef("{\n"));
485  setAndEmitFunctionVirtualRegisters(*MF);
486 
487  SmallString<128> Str;
488  raw_svector_ostream O(Str);
489  emitDemotedVars(MF->getFunction(), O);
490  OutStreamer->EmitRawText(O.str());
491 }
492 
493 void NVPTXAsmPrinter::EmitFunctionBodyEnd() {
494  OutStreamer->EmitRawText(StringRef("}\n"));
495  VRegMapping.clear();
496 }
497 
498 void NVPTXAsmPrinter::emitImplicitDef(const MachineInstr *MI) const {
499  unsigned RegNo = MI->getOperand(0).getReg();
501  OutStreamer->AddComment(Twine("implicit-def: ") +
502  getVirtualRegisterName(RegNo));
503  } else {
504  OutStreamer->AddComment(Twine("implicit-def: ") +
505  nvptxSubtarget->getRegisterInfo()->getName(RegNo));
506  }
507  OutStreamer->AddBlankLine();
508 }
509 
510 void NVPTXAsmPrinter::emitKernelFunctionDirectives(const Function &F,
511  raw_ostream &O) const {
512  // If the NVVM IR has some of reqntid* specified, then output
513  // the reqntid directive, and set the unspecified ones to 1.
514  // If none of reqntid* is specified, don't output reqntid directive.
515  unsigned reqntidx, reqntidy, reqntidz;
516  bool specified = false;
517  if (!llvm::getReqNTIDx(F, reqntidx))
518  reqntidx = 1;
519  else
520  specified = true;
521  if (!llvm::getReqNTIDy(F, reqntidy))
522  reqntidy = 1;
523  else
524  specified = true;
525  if (!llvm::getReqNTIDz(F, reqntidz))
526  reqntidz = 1;
527  else
528  specified = true;
529 
530  if (specified)
531  O << ".reqntid " << reqntidx << ", " << reqntidy << ", " << reqntidz
532  << "\n";
533 
534  // If the NVVM IR has some of maxntid* specified, then output
535  // the maxntid directive, and set the unspecified ones to 1.
536  // If none of maxntid* is specified, don't output maxntid directive.
537  unsigned maxntidx, maxntidy, maxntidz;
538  specified = false;
539  if (!llvm::getMaxNTIDx(F, maxntidx))
540  maxntidx = 1;
541  else
542  specified = true;
543  if (!llvm::getMaxNTIDy(F, maxntidy))
544  maxntidy = 1;
545  else
546  specified = true;
547  if (!llvm::getMaxNTIDz(F, maxntidz))
548  maxntidz = 1;
549  else
550  specified = true;
551 
552  if (specified)
553  O << ".maxntid " << maxntidx << ", " << maxntidy << ", " << maxntidz
554  << "\n";
555 
556  unsigned mincta;
557  if (llvm::getMinCTASm(F, mincta))
558  O << ".minnctapersm " << mincta << "\n";
559 }
560 
561 std::string
563  const TargetRegisterClass *RC = MRI->getRegClass(Reg);
564 
565  std::string Name;
566  raw_string_ostream NameStr(Name);
567 
568  VRegRCMap::const_iterator I = VRegMapping.find(RC);
569  assert(I != VRegMapping.end() && "Bad register class");
570  const DenseMap<unsigned, unsigned> &RegMap = I->second;
571 
572  VRegMap::const_iterator VI = RegMap.find(Reg);
573  assert(VI != RegMap.end() && "Bad virtual register");
574  unsigned MappedVR = VI->second;
575 
576  NameStr << getNVPTXRegClassStr(RC) << MappedVR;
577 
578  NameStr.flush();
579  return Name;
580 }
581 
582 void NVPTXAsmPrinter::emitVirtualRegister(unsigned int vr,
583  raw_ostream &O) {
584  O << getVirtualRegisterName(vr);
585 }
586 
587 void NVPTXAsmPrinter::printVecModifiedImmediate(
588  const MachineOperand &MO, const char *Modifier, raw_ostream &O) {
589  static const char vecelem[] = { '0', '1', '2', '3', '0', '1', '2', '3' };
590  int Imm = (int) MO.getImm();
591  if (0 == strcmp(Modifier, "vecelem"))
592  O << "_" << vecelem[Imm];
593  else if (0 == strcmp(Modifier, "vecv4comm1")) {
594  if ((Imm < 0) || (Imm > 3))
595  O << "//";
596  } else if (0 == strcmp(Modifier, "vecv4comm2")) {
597  if ((Imm < 4) || (Imm > 7))
598  O << "//";
599  } else if (0 == strcmp(Modifier, "vecv4pos")) {
600  if (Imm < 0)
601  Imm = 0;
602  O << "_" << vecelem[Imm % 4];
603  } else if (0 == strcmp(Modifier, "vecv2comm1")) {
604  if ((Imm < 0) || (Imm > 1))
605  O << "//";
606  } else if (0 == strcmp(Modifier, "vecv2comm2")) {
607  if ((Imm < 2) || (Imm > 3))
608  O << "//";
609  } else if (0 == strcmp(Modifier, "vecv2pos")) {
610  if (Imm < 0)
611  Imm = 0;
612  O << "_" << vecelem[Imm % 2];
613  } else
614  llvm_unreachable("Unknown Modifier on immediate operand");
615 }
616 
617 
618 
619 void NVPTXAsmPrinter::emitDeclaration(const Function *F, raw_ostream &O) {
620 
621  emitLinkageDirective(F, O);
622  if (llvm::isKernelFunction(*F))
623  O << ".entry ";
624  else
625  O << ".func ";
626  printReturnValStr(F, O);
627  getSymbol(F)->print(O, MAI);
628  O << "\n";
629  emitFunctionParamList(F, O);
630  O << ";\n";
631 }
632 
633 static bool usedInGlobalVarDef(const Constant *C) {
634  if (!C)
635  return false;
636 
637  if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(C)) {
638  if (GV->getName() == "llvm.used")
639  return false;
640  return true;
641  }
642 
643  for (const User *U : C->users())
644  if (const Constant *C = dyn_cast<Constant>(U))
645  if (usedInGlobalVarDef(C))
646  return true;
647 
648  return false;
649 }
650 
651 static bool usedInOneFunc(const User *U, Function const *&oneFunc) {
652  if (const GlobalVariable *othergv = dyn_cast<GlobalVariable>(U)) {
653  if (othergv->getName() == "llvm.used")
654  return true;
655  }
656 
657  if (const Instruction *instr = dyn_cast<Instruction>(U)) {
658  if (instr->getParent() && instr->getParent()->getParent()) {
659  const Function *curFunc = instr->getParent()->getParent();
660  if (oneFunc && (curFunc != oneFunc))
661  return false;
662  oneFunc = curFunc;
663  return true;
664  } else
665  return false;
666  }
667 
668  for (const User *UU : U->users())
669  if (!usedInOneFunc(UU, oneFunc))
670  return false;
671 
672  return true;
673 }
674 
675 /* Find out if a global variable can be demoted to local scope.
676  * Currently, this is valid for CUDA shared variables, which have local
677  * scope and global lifetime. So the conditions to check are :
678  * 1. Is the global variable in shared address space?
679  * 2. Does it have internal linkage?
680  * 3. Is the global variable referenced only in one function?
681  */
682 static bool canDemoteGlobalVar(const GlobalVariable *gv, Function const *&f) {
683  if (!gv->hasInternalLinkage())
684  return false;
685  const PointerType *Pty = gv->getType();
687  return false;
688 
689  const Function *oneFunc = nullptr;
690 
691  bool flag = usedInOneFunc(gv, oneFunc);
692  if (!flag)
693  return false;
694  if (!oneFunc)
695  return false;
696  f = oneFunc;
697  return true;
698 }
699 
700 static bool useFuncSeen(const Constant *C,
702  for (const User *U : C->users()) {
703  if (const Constant *cu = dyn_cast<Constant>(U)) {
704  if (useFuncSeen(cu, seenMap))
705  return true;
706  } else if (const Instruction *I = dyn_cast<Instruction>(U)) {
707  const BasicBlock *bb = I->getParent();
708  if (!bb)
709  continue;
710  const Function *caller = bb->getParent();
711  if (!caller)
712  continue;
713  if (seenMap.find(caller) != seenMap.end())
714  return true;
715  }
716  }
717  return false;
718 }
719 
720 void NVPTXAsmPrinter::emitDeclarations(const Module &M, raw_ostream &O) {
722  for (Module::const_iterator FI = M.begin(), FE = M.end(); FI != FE; ++FI) {
723  const Function *F = FI;
724 
725  if (F->isDeclaration()) {
726  if (F->use_empty())
727  continue;
728  if (F->getIntrinsicID())
729  continue;
730  emitDeclaration(F, O);
731  continue;
732  }
733  for (const User *U : F->users()) {
734  if (const Constant *C = dyn_cast<Constant>(U)) {
735  if (usedInGlobalVarDef(C)) {
736  // The use is in the initialization of a global variable
737  // that is a function pointer, so print a declaration
738  // for the original function
739  emitDeclaration(F, O);
740  break;
741  }
742  // Emit a declaration of this function if the function that
743  // uses this constant expr has already been seen.
744  if (useFuncSeen(C, seenMap)) {
745  emitDeclaration(F, O);
746  break;
747  }
748  }
749 
750  if (!isa<Instruction>(U))
751  continue;
752  const Instruction *instr = cast<Instruction>(U);
753  const BasicBlock *bb = instr->getParent();
754  if (!bb)
755  continue;
756  const Function *caller = bb->getParent();
757  if (!caller)
758  continue;
759 
760  // If a caller has already been seen, then the caller is
761  // appearing in the module before the callee. so print out
762  // a declaration for the callee.
763  if (seenMap.find(caller) != seenMap.end()) {
764  emitDeclaration(F, O);
765  break;
766  }
767  }
768  seenMap[F] = true;
769  }
770 }
771 
772 void NVPTXAsmPrinter::recordAndEmitFilenames(Module &M) {
773  DebugInfoFinder DbgFinder;
774  DbgFinder.processModule(M);
775 
776  unsigned i = 1;
777  for (const DICompileUnit *DIUnit : DbgFinder.compile_units()) {
778  StringRef Filename = DIUnit->getFilename();
779  StringRef Dirname = DIUnit->getDirectory();
780  SmallString<128> FullPathName = Dirname;
781  if (!Dirname.empty() && !sys::path::is_absolute(Filename)) {
782  sys::path::append(FullPathName, Filename);
783  Filename = FullPathName;
784  }
785  if (filenameMap.find(Filename) != filenameMap.end())
786  continue;
787  filenameMap[Filename] = i;
788  OutStreamer->EmitDwarfFileDirective(i, "", Filename);
789  ++i;
790  }
791 
792  for (DISubprogram *SP : DbgFinder.subprograms()) {
793  StringRef Filename = SP->getFilename();
794  StringRef Dirname = SP->getDirectory();
795  SmallString<128> FullPathName = Dirname;
796  if (!Dirname.empty() && !sys::path::is_absolute(Filename)) {
797  sys::path::append(FullPathName, Filename);
798  Filename = FullPathName;
799  }
800  if (filenameMap.find(Filename) != filenameMap.end())
801  continue;
802  filenameMap[Filename] = i;
803  ++i;
804  }
805 }
806 
808  // Construct a default subtarget off of the TargetMachine defaults. The
809  // rest of NVPTX isn't friendly to change subtargets per function and
810  // so the default TargetMachine will have all of the options.
811  const Triple &TT = TM.getTargetTriple();
812  StringRef CPU = TM.getTargetCPU();
814  const NVPTXTargetMachine &NTM = static_cast<const NVPTXTargetMachine &>(TM);
815  const NVPTXSubtarget STI(TT, CPU, FS, NTM);
816 
817  SmallString<128> Str1;
818  raw_svector_ostream OS1(Str1);
819 
820  MMI = getAnalysisIfAvailable<MachineModuleInfo>();
821 
822  // We need to call the parent's one explicitly.
823  //bool Result = AsmPrinter::doInitialization(M);
824 
825  // Initialize TargetLoweringObjectFile.
827  .Initialize(OutContext, TM);
828 
829  Mang = new Mangler();
830 
831  // Emit header before any dwarf directives are emitted below.
832  emitHeader(M, OS1, STI);
833  OutStreamer->EmitRawText(OS1.str());
834 
835  // Already commented out
836  //bool Result = AsmPrinter::doInitialization(M);
837 
838  // Emit module-level inline asm if it exists.
839  if (!M.getModuleInlineAsm().empty()) {
840  OutStreamer->AddComment("Start of file scope inline assembly");
841  OutStreamer->AddBlankLine();
842  OutStreamer->EmitRawText(StringRef(M.getModuleInlineAsm()));
843  OutStreamer->AddBlankLine();
844  OutStreamer->AddComment("End of file scope inline assembly");
845  OutStreamer->AddBlankLine();
846  }
847 
848  // If we're not NVCL we're CUDA, go ahead and emit filenames.
849  if (TM.getTargetTriple().getOS() != Triple::NVCL)
850  recordAndEmitFilenames(M);
851 
852  GlobalsEmitted = false;
853 
854  return false; // success
855 }
856 
857 void NVPTXAsmPrinter::emitGlobals(const Module &M) {
858  SmallString<128> Str2;
859  raw_svector_ostream OS2(Str2);
860 
861  emitDeclarations(M, OS2);
862 
863  // As ptxas does not support forward references of globals, we need to first
864  // sort the list of module-level globals in def-use order. We visit each
865  // global variable in order, and ensure that we emit it *after* its dependent
866  // globals. We use a little extra memory maintaining both a set and a list to
867  // have fast searches while maintaining a strict ordering.
871 
872  // Visit each global variable, in order
874  I != E; ++I)
875  VisitGlobalVariableForEmission(I, Globals, GVVisited, GVVisiting);
876 
877  assert(GVVisited.size() == M.getGlobalList().size() &&
878  "Missed a global variable");
879  assert(GVVisiting.size() == 0 && "Did not fully process a global variable");
880 
881  // Print out module-level global variables in proper order
882  for (unsigned i = 0, e = Globals.size(); i != e; ++i)
883  printModuleLevelGV(Globals[i], OS2);
884 
885  OS2 << '\n';
886 
887  OutStreamer->EmitRawText(OS2.str());
888 }
889 
890 void NVPTXAsmPrinter::emitHeader(Module &M, raw_ostream &O,
891  const NVPTXSubtarget &STI) {
892  O << "//\n";
893  O << "// Generated by LLVM NVPTX Back-End\n";
894  O << "//\n";
895  O << "\n";
896 
897  unsigned PTXVersion = STI.getPTXVersion();
898  O << ".version " << (PTXVersion / 10) << "." << (PTXVersion % 10) << "\n";
899 
900  O << ".target ";
901  O << STI.getTargetName();
902 
903  const NVPTXTargetMachine &NTM = static_cast<const NVPTXTargetMachine &>(TM);
904  if (NTM.getDrvInterface() == NVPTX::NVCL)
905  O << ", texmode_independent";
906  else {
907  if (!STI.hasDouble())
908  O << ", map_f64_to_f32";
909  }
910 
912  O << ", debug";
913 
914  O << "\n";
915 
916  O << ".address_size ";
917  if (NTM.is64Bit())
918  O << "64";
919  else
920  O << "32";
921  O << "\n";
922 
923  O << "\n";
924 }
925 
927  // If we did not emit any functions, then the global declarations have not
928  // yet been emitted.
929  if (!GlobalsEmitted) {
930  emitGlobals(M);
931  GlobalsEmitted = true;
932  }
933 
934  // XXX Temproarily remove global variables so that doFinalization() will not
935  // emit them again (global variables are emitted at beginning).
936 
937  Module::GlobalListType &global_list = M.getGlobalList();
938  int i, n = global_list.size();
939  GlobalVariable **gv_array = new GlobalVariable *[n];
940 
941  // first, back-up GlobalVariable in gv_array
942  i = 0;
943  for (Module::global_iterator I = global_list.begin(), E = global_list.end();
944  I != E; ++I)
945  gv_array[i++] = &*I;
946 
947  // second, empty global_list
948  while (!global_list.empty())
949  global_list.remove(global_list.begin());
950 
951  // call doFinalization
952  bool ret = AsmPrinter::doFinalization(M);
953 
954  // now we restore global variables
955  for (i = 0; i < n; i++)
956  global_list.insert(global_list.end(), gv_array[i]);
957 
959 
960  delete[] gv_array;
961  return ret;
962 
963  //bool Result = AsmPrinter::doFinalization(M);
964  // Instead of calling the parents doFinalization, we may
965  // clone parents doFinalization and customize here.
966  // Currently, we if NVISA out the EmitGlobals() in
967  // parent's doFinalization, which is too intrusive.
968  //
969  // Same for the doInitialization.
970  //return Result;
971 }
972 
973 // This function emits appropriate linkage directives for
974 // functions and global variables.
975 //
976 // extern function declaration -> .extern
977 // extern function definition -> .visible
978 // external global variable with init -> .visible
979 // external without init -> .extern
980 // appending -> not allowed, assert.
981 // for any linkage other than
982 // internal, private, linker_private,
983 // linker_private_weak, linker_private_weak_def_auto,
984 // we emit -> .weak.
985 
986 void NVPTXAsmPrinter::emitLinkageDirective(const GlobalValue *V,
987  raw_ostream &O) {
988  if (static_cast<NVPTXTargetMachine &>(TM).getDrvInterface() == NVPTX::CUDA) {
989  if (V->hasExternalLinkage()) {
990  if (isa<GlobalVariable>(V)) {
991  const GlobalVariable *GVar = cast<GlobalVariable>(V);
992  if (GVar) {
993  if (GVar->hasInitializer())
994  O << ".visible ";
995  else
996  O << ".extern ";
997  }
998  } else if (V->isDeclaration())
999  O << ".extern ";
1000  else
1001  O << ".visible ";
1002  } else if (V->hasAppendingLinkage()) {
1003  std::string msg;
1004  msg.append("Error: ");
1005  msg.append("Symbol ");
1006  if (V->hasName())
1007  msg.append(V->getName());
1008  msg.append("has unsupported appending linkage type");
1009  llvm_unreachable(msg.c_str());
1010  } else if (!V->hasInternalLinkage() &&
1011  !V->hasPrivateLinkage()) {
1012  O << ".weak ";
1013  }
1014  }
1015 }
1016 
1017 void NVPTXAsmPrinter::printModuleLevelGV(const GlobalVariable *GVar,
1018  raw_ostream &O,
1019  bool processDemoted) {
1020 
1021  // Skip meta data
1022  if (GVar->hasSection()) {
1023  if (GVar->getSection() == StringRef("llvm.metadata"))
1024  return;
1025  }
1026 
1027  // Skip LLVM intrinsic global variables
1028  if (GVar->getName().startswith("llvm.") ||
1029  GVar->getName().startswith("nvvm."))
1030  return;
1031 
1032  const DataLayout *TD = TM.getDataLayout();
1033 
1034  // GlobalVariables are always constant pointers themselves.
1035  const PointerType *PTy = GVar->getType();
1036  Type *ETy = PTy->getElementType();
1037 
1038  if (GVar->hasExternalLinkage()) {
1039  if (GVar->hasInitializer())
1040  O << ".visible ";
1041  else
1042  O << ".extern ";
1043  } else if (GVar->hasLinkOnceLinkage() || GVar->hasWeakLinkage() ||
1045  GVar->hasCommonLinkage()) {
1046  O << ".weak ";
1047  }
1048 
1049  if (llvm::isTexture(*GVar)) {
1050  O << ".global .texref " << llvm::getTextureName(*GVar) << ";\n";
1051  return;
1052  }
1053 
1054  if (llvm::isSurface(*GVar)) {
1055  O << ".global .surfref " << llvm::getSurfaceName(*GVar) << ";\n";
1056  return;
1057  }
1058 
1059  if (GVar->isDeclaration()) {
1060  // (extern) declarations, no definition or initializer
1061  // Currently the only known declaration is for an automatic __local
1062  // (.shared) promoted to global.
1063  emitPTXGlobalVariable(GVar, O);
1064  O << ";\n";
1065  return;
1066  }
1067 
1068  if (llvm::isSampler(*GVar)) {
1069  O << ".global .samplerref " << llvm::getSamplerName(*GVar);
1070 
1071  const Constant *Initializer = nullptr;
1072  if (GVar->hasInitializer())
1073  Initializer = GVar->getInitializer();
1074  const ConstantInt *CI = nullptr;
1075  if (Initializer)
1076  CI = dyn_cast<ConstantInt>(Initializer);
1077  if (CI) {
1078  unsigned sample = CI->getZExtValue();
1079 
1080  O << " = { ";
1081 
1082  for (int i = 0,
1083  addr = ((sample & __CLK_ADDRESS_MASK) >> __CLK_ADDRESS_BASE);
1084  i < 3; i++) {
1085  O << "addr_mode_" << i << " = ";
1086  switch (addr) {
1087  case 0:
1088  O << "wrap";
1089  break;
1090  case 1:
1091  O << "clamp_to_border";
1092  break;
1093  case 2:
1094  O << "clamp_to_edge";
1095  break;
1096  case 3:
1097  O << "wrap";
1098  break;
1099  case 4:
1100  O << "mirror";
1101  break;
1102  }
1103  O << ", ";
1104  }
1105  O << "filter_mode = ";
1106  switch ((sample & __CLK_FILTER_MASK) >> __CLK_FILTER_BASE) {
1107  case 0:
1108  O << "nearest";
1109  break;
1110  case 1:
1111  O << "linear";
1112  break;
1113  case 2:
1114  llvm_unreachable("Anisotropic filtering is not supported");
1115  default:
1116  O << "nearest";
1117  break;
1118  }
1119  if (!((sample & __CLK_NORMALIZED_MASK) >> __CLK_NORMALIZED_BASE)) {
1120  O << ", force_unnormalized_coords = 1";
1121  }
1122  O << " }";
1123  }
1124 
1125  O << ";\n";
1126  return;
1127  }
1128 
1129  if (GVar->hasPrivateLinkage()) {
1130 
1131  if (!strncmp(GVar->getName().data(), "unrollpragma", 12))
1132  return;
1133 
1134  // FIXME - need better way (e.g. Metadata) to avoid generating this global
1135  if (!strncmp(GVar->getName().data(), "filename", 8))
1136  return;
1137  if (GVar->use_empty())
1138  return;
1139  }
1140 
1141  const Function *demotedFunc = nullptr;
1142  if (!processDemoted && canDemoteGlobalVar(GVar, demotedFunc)) {
1143  O << "// " << GVar->getName() << " has been demoted\n";
1144  if (localDecls.find(demotedFunc) != localDecls.end())
1145  localDecls[demotedFunc].push_back(GVar);
1146  else {
1147  std::vector<const GlobalVariable *> temp;
1148  temp.push_back(GVar);
1149  localDecls[demotedFunc] = temp;
1150  }
1151  return;
1152  }
1153 
1154  O << ".";
1155  emitPTXAddressSpace(PTy->getAddressSpace(), O);
1156 
1157  if (isManaged(*GVar)) {
1158  O << " .attribute(.managed)";
1159  }
1160 
1161  if (GVar->getAlignment() == 0)
1162  O << " .align " << (int) TD->getPrefTypeAlignment(ETy);
1163  else
1164  O << " .align " << GVar->getAlignment();
1165 
1166  if (ETy->isFloatingPointTy() || ETy->isIntegerTy() || ETy->isPointerTy()) {
1167  O << " .";
1168  // Special case: ABI requires that we use .u8 for predicates
1169  if (ETy->isIntegerTy(1))
1170  O << "u8";
1171  else
1172  O << getPTXFundamentalTypeStr(ETy, false);
1173  O << " ";
1174  getSymbol(GVar)->print(O, MAI);
1175 
1176  // Ptx allows variable initilization only for constant and global state
1177  // spaces.
1178  if (GVar->hasInitializer()) {
1179  if ((PTy->getAddressSpace() == llvm::ADDRESS_SPACE_GLOBAL) ||
1181  const Constant *Initializer = GVar->getInitializer();
1182  // 'undef' is treated as there is no value specified.
1183  if (!Initializer->isNullValue() && !isa<UndefValue>(Initializer)) {
1184  O << " = ";
1185  printScalarConstant(Initializer, O);
1186  }
1187  } else {
1188  // The frontend adds zero-initializer to variables that don't have an
1189  // initial value, so skip warning for this case.
1190  if (!GVar->getInitializer()->isNullValue()) {
1191  report_fatal_error("initial value of '" + GVar->getName() +
1192  "' is not allowed in addrspace(" +
1193  Twine(PTy->getAddressSpace()) + ")");
1194  }
1195  }
1196  }
1197  } else {
1198  unsigned int ElementSize = 0;
1199 
1200  // Although PTX has direct support for struct type and array type and
1201  // LLVM IR is very similar to PTX, the LLVM CodeGen does not support for
1202  // targets that support these high level field accesses. Structs, arrays
1203  // and vectors are lowered into arrays of bytes.
1204  switch (ETy->getTypeID()) {
1205  case Type::StructTyID:
1206  case Type::ArrayTyID:
1207  case Type::VectorTyID:
1208  ElementSize = TD->getTypeStoreSize(ETy);
1209  // Ptx allows variable initilization only for constant and
1210  // global state spaces.
1211  if (((PTy->getAddressSpace() == llvm::ADDRESS_SPACE_GLOBAL) ||
1213  GVar->hasInitializer()) {
1214  const Constant *Initializer = GVar->getInitializer();
1215  if (!isa<UndefValue>(Initializer) && !Initializer->isNullValue()) {
1216  AggBuffer aggBuffer(ElementSize, O, *this);
1217  bufferAggregateConstant(Initializer, &aggBuffer);
1218  if (aggBuffer.numSymbols) {
1219  if (static_cast<const NVPTXTargetMachine &>(TM).is64Bit()) {
1220  O << " .u64 ";
1221  getSymbol(GVar)->print(O, MAI);
1222  O << "[";
1223  O << ElementSize / 8;
1224  } else {
1225  O << " .u32 ";
1226  getSymbol(GVar)->print(O, MAI);
1227  O << "[";
1228  O << ElementSize / 4;
1229  }
1230  O << "]";
1231  } else {
1232  O << " .b8 ";
1233  getSymbol(GVar)->print(O, MAI);
1234  O << "[";
1235  O << ElementSize;
1236  O << "]";
1237  }
1238  O << " = {";
1239  aggBuffer.print();
1240  O << "}";
1241  } else {
1242  O << " .b8 ";
1243  getSymbol(GVar)->print(O, MAI);
1244  if (ElementSize) {
1245  O << "[";
1246  O << ElementSize;
1247  O << "]";
1248  }
1249  }
1250  } else {
1251  O << " .b8 ";
1252  getSymbol(GVar)->print(O, MAI);
1253  if (ElementSize) {
1254  O << "[";
1255  O << ElementSize;
1256  O << "]";
1257  }
1258  }
1259  break;
1260  default:
1261  llvm_unreachable("type not supported yet");
1262  }
1263 
1264  }
1265  O << ";\n";
1266 }
1267 
1268 void NVPTXAsmPrinter::emitDemotedVars(const Function *f, raw_ostream &O) {
1269  if (localDecls.find(f) == localDecls.end())
1270  return;
1271 
1272  std::vector<const GlobalVariable *> &gvars = localDecls[f];
1273 
1274  for (unsigned i = 0, e = gvars.size(); i != e; ++i) {
1275  O << "\t// demoted variable\n\t";
1276  printModuleLevelGV(gvars[i], O, true);
1277  }
1278 }
1279 
1280 void NVPTXAsmPrinter::emitPTXAddressSpace(unsigned int AddressSpace,
1281  raw_ostream &O) const {
1282  switch (AddressSpace) {
1284  O << "local";
1285  break;
1287  O << "global";
1288  break;
1290  O << "const";
1291  break;
1293  O << "shared";
1294  break;
1295  default:
1296  report_fatal_error("Bad address space found while emitting PTX");
1297  break;
1298  }
1299 }
1300 
1301 std::string
1302 NVPTXAsmPrinter::getPTXFundamentalTypeStr(const Type *Ty, bool useB4PTR) const {
1303  switch (Ty->getTypeID()) {
1304  default:
1305  llvm_unreachable("unexpected type");
1306  break;
1307  case Type::IntegerTyID: {
1308  unsigned NumBits = cast<IntegerType>(Ty)->getBitWidth();
1309  if (NumBits == 1)
1310  return "pred";
1311  else if (NumBits <= 64) {
1312  std::string name = "u";
1313  return name + utostr(NumBits);
1314  } else {
1315  llvm_unreachable("Integer too large");
1316  break;
1317  }
1318  break;
1319  }
1320  case Type::FloatTyID:
1321  return "f32";
1322  case Type::DoubleTyID:
1323  return "f64";
1324  case Type::PointerTyID:
1325  if (static_cast<const NVPTXTargetMachine &>(TM).is64Bit())
1326  if (useB4PTR)
1327  return "b64";
1328  else
1329  return "u64";
1330  else if (useB4PTR)
1331  return "b32";
1332  else
1333  return "u32";
1334  }
1335  llvm_unreachable("unexpected type");
1336  return nullptr;
1337 }
1338 
1339 void NVPTXAsmPrinter::emitPTXGlobalVariable(const GlobalVariable *GVar,
1340  raw_ostream &O) {
1341 
1342  const DataLayout *TD = TM.getDataLayout();
1343 
1344  // GlobalVariables are always constant pointers themselves.
1345  const PointerType *PTy = GVar->getType();
1346  Type *ETy = PTy->getElementType();
1347 
1348  O << ".";
1349  emitPTXAddressSpace(PTy->getAddressSpace(), O);
1350  if (GVar->getAlignment() == 0)
1351  O << " .align " << (int) TD->getPrefTypeAlignment(ETy);
1352  else
1353  O << " .align " << GVar->getAlignment();
1354 
1355  if (ETy->isFloatingPointTy() || ETy->isIntegerTy() || ETy->isPointerTy()) {
1356  O << " .";
1357  O << getPTXFundamentalTypeStr(ETy);
1358  O << " ";
1359  getSymbol(GVar)->print(O, MAI);
1360  return;
1361  }
1362 
1363  int64_t ElementSize = 0;
1364 
1365  // Although PTX has direct support for struct type and array type and LLVM IR
1366  // is very similar to PTX, the LLVM CodeGen does not support for targets that
1367  // support these high level field accesses. Structs and arrays are lowered
1368  // into arrays of bytes.
1369  switch (ETy->getTypeID()) {
1370  case Type::StructTyID:
1371  case Type::ArrayTyID:
1372  case Type::VectorTyID:
1373  ElementSize = TD->getTypeStoreSize(ETy);
1374  O << " .b8 ";
1375  getSymbol(GVar)->print(O, MAI);
1376  O << "[";
1377  if (ElementSize) {
1378  O << ElementSize;
1379  }
1380  O << "]";
1381  break;
1382  default:
1383  llvm_unreachable("type not supported yet");
1384  }
1385  return;
1386 }
1387 
1388 static unsigned int getOpenCLAlignment(const DataLayout *TD, Type *Ty) {
1389  if (Ty->isSingleValueType())
1390  return TD->getPrefTypeAlignment(Ty);
1391 
1392  const ArrayType *ATy = dyn_cast<ArrayType>(Ty);
1393  if (ATy)
1394  return getOpenCLAlignment(TD, ATy->getElementType());
1395 
1396  const StructType *STy = dyn_cast<StructType>(Ty);
1397  if (STy) {
1398  unsigned int alignStruct = 1;
1399  // Go through each element of the struct and find the
1400  // largest alignment.
1401  for (unsigned i = 0, e = STy->getNumElements(); i != e; i++) {
1402  Type *ETy = STy->getElementType(i);
1403  unsigned int align = getOpenCLAlignment(TD, ETy);
1404  if (align > alignStruct)
1405  alignStruct = align;
1406  }
1407  return alignStruct;
1408  }
1409 
1410  const FunctionType *FTy = dyn_cast<FunctionType>(Ty);
1411  if (FTy)
1412  return TD->getPointerPrefAlignment();
1413  return TD->getPrefTypeAlignment(Ty);
1414 }
1415 
1416 void NVPTXAsmPrinter::printParamName(Function::const_arg_iterator I,
1417  int paramIndex, raw_ostream &O) {
1418  getSymbol(I->getParent())->print(O, MAI);
1419  O << "_param_" << paramIndex;
1420 }
1421 
1422 void NVPTXAsmPrinter::printParamName(int paramIndex, raw_ostream &O) {
1423  CurrentFnSym->print(O, MAI);
1424  O << "_param_" << paramIndex;
1425 }
1426 
1427 void NVPTXAsmPrinter::emitFunctionParamList(const Function *F, raw_ostream &O) {
1428  const DataLayout *TD = TM.getDataLayout();
1429  const AttributeSet &PAL = F->getAttributes();
1430  const TargetLowering *TLI = nvptxSubtarget->getTargetLowering();
1432  unsigned paramIndex = 0;
1433  bool first = true;
1434  bool isKernelFunc = llvm::isKernelFunction(*F);
1435  bool isABI = (nvptxSubtarget->getSmVersion() >= 20);
1436  MVT thePointerTy = TLI->getPointerTy(*TD);
1437 
1438  O << "(\n";
1439 
1440  for (I = F->arg_begin(), E = F->arg_end(); I != E; ++I, paramIndex++) {
1441  Type *Ty = I->getType();
1442 
1443  if (!first)
1444  O << ",\n";
1445 
1446  first = false;
1447 
1448  // Handle image/sampler parameters
1449  if (isKernelFunction(*F)) {
1450  if (isSampler(*I) || isImage(*I)) {
1451  if (isImage(*I)) {
1452  std::string sname = I->getName();
1453  if (isImageWriteOnly(*I) || isImageReadWrite(*I)) {
1454  if (nvptxSubtarget->hasImageHandles())
1455  O << "\t.param .u64 .ptr .surfref ";
1456  else
1457  O << "\t.param .surfref ";
1458  CurrentFnSym->print(O, MAI);
1459  O << "_param_" << paramIndex;
1460  }
1461  else { // Default image is read_only
1462  if (nvptxSubtarget->hasImageHandles())
1463  O << "\t.param .u64 .ptr .texref ";
1464  else
1465  O << "\t.param .texref ";
1466  CurrentFnSym->print(O, MAI);
1467  O << "_param_" << paramIndex;
1468  }
1469  } else {
1470  if (nvptxSubtarget->hasImageHandles())
1471  O << "\t.param .u64 .ptr .samplerref ";
1472  else
1473  O << "\t.param .samplerref ";
1474  CurrentFnSym->print(O, MAI);
1475  O << "_param_" << paramIndex;
1476  }
1477  continue;
1478  }
1479  }
1480 
1481  if (!PAL.hasAttribute(paramIndex + 1, Attribute::ByVal)) {
1482  if (Ty->isAggregateType() || Ty->isVectorTy()) {
1483  // Just print .param .align <a> .b8 .param[size];
1484  // <a> = PAL.getparamalignment
1485  // size = typeallocsize of element type
1486  unsigned align = PAL.getParamAlignment(paramIndex + 1);
1487  if (align == 0)
1488  align = TD->getABITypeAlignment(Ty);
1489 
1490  unsigned sz = TD->getTypeAllocSize(Ty);
1491  O << "\t.param .align " << align << " .b8 ";
1492  printParamName(I, paramIndex, O);
1493  O << "[" << sz << "]";
1494 
1495  continue;
1496  }
1497  // Just a scalar
1498  const PointerType *PTy = dyn_cast<PointerType>(Ty);
1499  if (isKernelFunc) {
1500  if (PTy) {
1501  // Special handling for pointer arguments to kernel
1502  O << "\t.param .u" << thePointerTy.getSizeInBits() << " ";
1503 
1504  if (static_cast<NVPTXTargetMachine &>(TM).getDrvInterface() !=
1505  NVPTX::CUDA) {
1506  Type *ETy = PTy->getElementType();
1507  int addrSpace = PTy->getAddressSpace();
1508  switch (addrSpace) {
1509  default:
1510  O << ".ptr ";
1511  break;
1513  O << ".ptr .const ";
1514  break;
1516  O << ".ptr .shared ";
1517  break;
1519  O << ".ptr .global ";
1520  break;
1521  }
1522  O << ".align " << (int) getOpenCLAlignment(TD, ETy) << " ";
1523  }
1524  printParamName(I, paramIndex, O);
1525  continue;
1526  }
1527 
1528  // non-pointer scalar to kernel func
1529  O << "\t.param .";
1530  // Special case: predicate operands become .u8 types
1531  if (Ty->isIntegerTy(1))
1532  O << "u8";
1533  else
1534  O << getPTXFundamentalTypeStr(Ty);
1535  O << " ";
1536  printParamName(I, paramIndex, O);
1537  continue;
1538  }
1539  // Non-kernel function, just print .param .b<size> for ABI
1540  // and .reg .b<size> for non-ABI
1541  unsigned sz = 0;
1542  if (isa<IntegerType>(Ty)) {
1543  sz = cast<IntegerType>(Ty)->getBitWidth();
1544  if (sz < 32)
1545  sz = 32;
1546  } else if (isa<PointerType>(Ty))
1547  sz = thePointerTy.getSizeInBits();
1548  else
1549  sz = Ty->getPrimitiveSizeInBits();
1550  if (isABI)
1551  O << "\t.param .b" << sz << " ";
1552  else
1553  O << "\t.reg .b" << sz << " ";
1554  printParamName(I, paramIndex, O);
1555  continue;
1556  }
1557 
1558  // param has byVal attribute. So should be a pointer
1559  const PointerType *PTy = dyn_cast<PointerType>(Ty);
1560  assert(PTy && "Param with byval attribute should be a pointer type");
1561  Type *ETy = PTy->getElementType();
1562 
1563  if (isABI || isKernelFunc) {
1564  // Just print .param .align <a> .b8 .param[size];
1565  // <a> = PAL.getparamalignment
1566  // size = typeallocsize of element type
1567  unsigned align = PAL.getParamAlignment(paramIndex + 1);
1568  if (align == 0)
1569  align = TD->getABITypeAlignment(ETy);
1570 
1571  unsigned sz = TD->getTypeAllocSize(ETy);
1572  O << "\t.param .align " << align << " .b8 ";
1573  printParamName(I, paramIndex, O);
1574  O << "[" << sz << "]";
1575  continue;
1576  } else {
1577  // Split the ETy into constituent parts and
1578  // print .param .b<size> <name> for each part.
1579  // Further, if a part is vector, print the above for
1580  // each vector element.
1581  SmallVector<EVT, 16> vtparts;
1582  ComputeValueVTs(*TLI, getDataLayout(), ETy, vtparts);
1583  for (unsigned i = 0, e = vtparts.size(); i != e; ++i) {
1584  unsigned elems = 1;
1585  EVT elemtype = vtparts[i];
1586  if (vtparts[i].isVector()) {
1587  elems = vtparts[i].getVectorNumElements();
1588  elemtype = vtparts[i].getVectorElementType();
1589  }
1590 
1591  for (unsigned j = 0, je = elems; j != je; ++j) {
1592  unsigned sz = elemtype.getSizeInBits();
1593  if (elemtype.isInteger() && (sz < 32))
1594  sz = 32;
1595  O << "\t.reg .b" << sz << " ";
1596  printParamName(I, paramIndex, O);
1597  if (j < je - 1)
1598  O << ",\n";
1599  ++paramIndex;
1600  }
1601  if (i < e - 1)
1602  O << ",\n";
1603  }
1604  --paramIndex;
1605  continue;
1606  }
1607  }
1608 
1609  O << "\n)\n";
1610 }
1611 
1612 void NVPTXAsmPrinter::emitFunctionParamList(const MachineFunction &MF,
1613  raw_ostream &O) {
1614  const Function *F = MF.getFunction();
1615  emitFunctionParamList(F, O);
1616 }
1617 
1618 void NVPTXAsmPrinter::setAndEmitFunctionVirtualRegisters(
1619  const MachineFunction &MF) {
1620  SmallString<128> Str;
1621  raw_svector_ostream O(Str);
1622 
1623  // Map the global virtual register number to a register class specific
1624  // virtual register number starting from 1 with that class.
1625  const TargetRegisterInfo *TRI = MF.getSubtarget().getRegisterInfo();
1626  //unsigned numRegClasses = TRI->getNumRegClasses();
1627 
1628  // Emit the Fake Stack Object
1629  const MachineFrameInfo *MFI = MF.getFrameInfo();
1630  int NumBytes = (int) MFI->getStackSize();
1631  if (NumBytes) {
1632  O << "\t.local .align " << MFI->getMaxAlignment() << " .b8 \t" << DEPOTNAME
1633  << getFunctionNumber() << "[" << NumBytes << "];\n";
1634  if (static_cast<const NVPTXTargetMachine &>(MF.getTarget()).is64Bit()) {
1635  O << "\t.reg .b64 \t%SP;\n";
1636  O << "\t.reg .b64 \t%SPL;\n";
1637  } else {
1638  O << "\t.reg .b32 \t%SP;\n";
1639  O << "\t.reg .b32 \t%SPL;\n";
1640  }
1641  }
1642 
1643  // Go through all virtual registers to establish the mapping between the
1644  // global virtual
1645  // register number and the per class virtual register number.
1646  // We use the per class virtual register number in the ptx output.
1647  unsigned int numVRs = MRI->getNumVirtRegs();
1648  for (unsigned i = 0; i < numVRs; i++) {
1649  unsigned int vr = TRI->index2VirtReg(i);
1650  const TargetRegisterClass *RC = MRI->getRegClass(vr);
1651  DenseMap<unsigned, unsigned> &regmap = VRegMapping[RC];
1652  int n = regmap.size();
1653  regmap.insert(std::make_pair(vr, n + 1));
1654  }
1655 
1656  // Emit register declarations
1657  // @TODO: Extract out the real register usage
1658  // O << "\t.reg .pred %p<" << NVPTXNumRegisters << ">;\n";
1659  // O << "\t.reg .s16 %rc<" << NVPTXNumRegisters << ">;\n";
1660  // O << "\t.reg .s16 %rs<" << NVPTXNumRegisters << ">;\n";
1661  // O << "\t.reg .s32 %r<" << NVPTXNumRegisters << ">;\n";
1662  // O << "\t.reg .s64 %rd<" << NVPTXNumRegisters << ">;\n";
1663  // O << "\t.reg .f32 %f<" << NVPTXNumRegisters << ">;\n";
1664  // O << "\t.reg .f64 %fd<" << NVPTXNumRegisters << ">;\n";
1665 
1666  // Emit declaration of the virtual registers or 'physical' registers for
1667  // each register class
1668  for (unsigned i=0; i< TRI->getNumRegClasses(); i++) {
1669  const TargetRegisterClass *RC = TRI->getRegClass(i);
1670  DenseMap<unsigned, unsigned> &regmap = VRegMapping[RC];
1671  std::string rcname = getNVPTXRegClassName(RC);
1672  std::string rcStr = getNVPTXRegClassStr(RC);
1673  int n = regmap.size();
1674 
1675  // Only declare those registers that may be used.
1676  if (n) {
1677  O << "\t.reg " << rcname << " \t" << rcStr << "<" << (n+1)
1678  << ">;\n";
1679  }
1680  }
1681 
1682  OutStreamer->EmitRawText(O.str());
1683 }
1684 
1685 void NVPTXAsmPrinter::printFPConstant(const ConstantFP *Fp, raw_ostream &O) {
1686  APFloat APF = APFloat(Fp->getValueAPF()); // make a copy
1687  bool ignored;
1688  unsigned int numHex;
1689  const char *lead;
1690 
1691  if (Fp->getType()->getTypeID() == Type::FloatTyID) {
1692  numHex = 8;
1693  lead = "0f";
1695  } else if (Fp->getType()->getTypeID() == Type::DoubleTyID) {
1696  numHex = 16;
1697  lead = "0d";
1699  } else
1700  llvm_unreachable("unsupported fp type");
1701 
1702  APInt API = APF.bitcastToAPInt();
1703  std::string hexstr(utohexstr(API.getZExtValue()));
1704  O << lead;
1705  if (hexstr.length() < numHex)
1706  O << std::string(numHex - hexstr.length(), '0');
1707  O << utohexstr(API.getZExtValue());
1708 }
1709 
1710 void NVPTXAsmPrinter::printScalarConstant(const Constant *CPV, raw_ostream &O) {
1711  if (const ConstantInt *CI = dyn_cast<ConstantInt>(CPV)) {
1712  O << CI->getValue();
1713  return;
1714  }
1715  if (const ConstantFP *CFP = dyn_cast<ConstantFP>(CPV)) {
1716  printFPConstant(CFP, O);
1717  return;
1718  }
1719  if (isa<ConstantPointerNull>(CPV)) {
1720  O << "0";
1721  return;
1722  }
1723  if (const GlobalValue *GVar = dyn_cast<GlobalValue>(CPV)) {
1724  PointerType *PTy = dyn_cast<PointerType>(GVar->getType());
1725  bool IsNonGenericPointer = false;
1726  if (PTy && PTy->getAddressSpace() != 0) {
1727  IsNonGenericPointer = true;
1728  }
1729  if (EmitGeneric && !isa<Function>(CPV) && !IsNonGenericPointer) {
1730  O << "generic(";
1731  getSymbol(GVar)->print(O, MAI);
1732  O << ")";
1733  } else {
1734  getSymbol(GVar)->print(O, MAI);
1735  }
1736  return;
1737  }
1738  if (const ConstantExpr *Cexpr = dyn_cast<ConstantExpr>(CPV)) {
1739  const Value *v = Cexpr->stripPointerCasts();
1740  PointerType *PTy = dyn_cast<PointerType>(Cexpr->getType());
1741  bool IsNonGenericPointer = false;
1742  if (PTy && PTy->getAddressSpace() != 0) {
1743  IsNonGenericPointer = true;
1744  }
1745  if (const GlobalValue *GVar = dyn_cast<GlobalValue>(v)) {
1746  if (EmitGeneric && !isa<Function>(v) && !IsNonGenericPointer) {
1747  O << "generic(";
1748  getSymbol(GVar)->print(O, MAI);
1749  O << ")";
1750  } else {
1751  getSymbol(GVar)->print(O, MAI);
1752  }
1753  return;
1754  } else {
1755  lowerConstant(CPV)->print(O, MAI);
1756  return;
1757  }
1758  }
1759  llvm_unreachable("Not scalar type found in printScalarConstant()");
1760 }
1761 
1762 // These utility functions assure we get the right sequence of bytes for a given
1763 // type even for big-endian machines
1764 template <typename T> static void ConvertIntToBytes(unsigned char *p, T val) {
1765  int64_t vp = (int64_t)val;
1766  for (unsigned i = 0; i < sizeof(T); ++i) {
1767  p[i] = (unsigned char)vp;
1768  vp >>= 8;
1769  }
1770 }
1771 static void ConvertFloatToBytes(unsigned char *p, float val) {
1772  int32_t *vp = (int32_t *)&val;
1773  for (unsigned i = 0; i < sizeof(int32_t); ++i) {
1774  p[i] = (unsigned char)*vp;
1775  *vp >>= 8;
1776  }
1777 }
1778 static void ConvertDoubleToBytes(unsigned char *p, double val) {
1779  int64_t *vp = (int64_t *)&val;
1780  for (unsigned i = 0; i < sizeof(int64_t); ++i) {
1781  p[i] = (unsigned char)*vp;
1782  *vp >>= 8;
1783  }
1784 }
1785 
1786 void NVPTXAsmPrinter::bufferLEByte(const Constant *CPV, int Bytes,
1787  AggBuffer *aggBuffer) {
1788 
1789  const DataLayout *TD = TM.getDataLayout();
1790 
1791  if (isa<UndefValue>(CPV) || CPV->isNullValue()) {
1792  int s = TD->getTypeAllocSize(CPV->getType());
1793  if (s < Bytes)
1794  s = Bytes;
1795  aggBuffer->addZeros(s);
1796  return;
1797  }
1798 
1799  unsigned char ptr[8];
1800  switch (CPV->getType()->getTypeID()) {
1801 
1802  case Type::IntegerTyID: {
1803  const Type *ETy = CPV->getType();
1804  if (ETy == Type::getInt8Ty(CPV->getContext())) {
1805  unsigned char c = (unsigned char)cast<ConstantInt>(CPV)->getZExtValue();
1806  ConvertIntToBytes<>(ptr, c);
1807  aggBuffer->addBytes(ptr, 1, Bytes);
1808  } else if (ETy == Type::getInt16Ty(CPV->getContext())) {
1809  short int16 = (short)cast<ConstantInt>(CPV)->getZExtValue();
1810  ConvertIntToBytes<>(ptr, int16);
1811  aggBuffer->addBytes(ptr, 2, Bytes);
1812  } else if (ETy == Type::getInt32Ty(CPV->getContext())) {
1813  if (const ConstantInt *constInt = dyn_cast<ConstantInt>(CPV)) {
1814  int int32 = (int)(constInt->getZExtValue());
1815  ConvertIntToBytes<>(ptr, int32);
1816  aggBuffer->addBytes(ptr, 4, Bytes);
1817  break;
1818  } else if (const ConstantExpr *Cexpr = dyn_cast<ConstantExpr>(CPV)) {
1819  if (const ConstantInt *constInt = dyn_cast<ConstantInt>(
1820  ConstantFoldConstantExpression(Cexpr, *TD))) {
1821  int int32 = (int)(constInt->getZExtValue());
1822  ConvertIntToBytes<>(ptr, int32);
1823  aggBuffer->addBytes(ptr, 4, Bytes);
1824  break;
1825  }
1826  if (Cexpr->getOpcode() == Instruction::PtrToInt) {
1827  Value *v = Cexpr->getOperand(0)->stripPointerCasts();
1828  aggBuffer->addSymbol(v, Cexpr->getOperand(0));
1829  aggBuffer->addZeros(4);
1830  break;
1831  }
1832  }
1833  llvm_unreachable("unsupported integer const type");
1834  } else if (ETy == Type::getInt64Ty(CPV->getContext())) {
1835  if (const ConstantInt *constInt = dyn_cast<ConstantInt>(CPV)) {
1836  long long int64 = (long long)(constInt->getZExtValue());
1837  ConvertIntToBytes<>(ptr, int64);
1838  aggBuffer->addBytes(ptr, 8, Bytes);
1839  break;
1840  } else if (const ConstantExpr *Cexpr = dyn_cast<ConstantExpr>(CPV)) {
1841  if (const ConstantInt *constInt = dyn_cast<ConstantInt>(
1842  ConstantFoldConstantExpression(Cexpr, *TD))) {
1843  long long int64 = (long long)(constInt->getZExtValue());
1844  ConvertIntToBytes<>(ptr, int64);
1845  aggBuffer->addBytes(ptr, 8, Bytes);
1846  break;
1847  }
1848  if (Cexpr->getOpcode() == Instruction::PtrToInt) {
1849  Value *v = Cexpr->getOperand(0)->stripPointerCasts();
1850  aggBuffer->addSymbol(v, Cexpr->getOperand(0));
1851  aggBuffer->addZeros(8);
1852  break;
1853  }
1854  }
1855  llvm_unreachable("unsupported integer const type");
1856  } else
1857  llvm_unreachable("unsupported integer const type");
1858  break;
1859  }
1860  case Type::FloatTyID:
1861  case Type::DoubleTyID: {
1862  const ConstantFP *CFP = dyn_cast<ConstantFP>(CPV);
1863  const Type *Ty = CFP->getType();
1864  if (Ty == Type::getFloatTy(CPV->getContext())) {
1865  float float32 = (float) CFP->getValueAPF().convertToFloat();
1866  ConvertFloatToBytes(ptr, float32);
1867  aggBuffer->addBytes(ptr, 4, Bytes);
1868  } else if (Ty == Type::getDoubleTy(CPV->getContext())) {
1869  double float64 = CFP->getValueAPF().convertToDouble();
1870  ConvertDoubleToBytes(ptr, float64);
1871  aggBuffer->addBytes(ptr, 8, Bytes);
1872  } else {
1873  llvm_unreachable("unsupported fp const type");
1874  }
1875  break;
1876  }
1877  case Type::PointerTyID: {
1878  if (const GlobalValue *GVar = dyn_cast<GlobalValue>(CPV)) {
1879  aggBuffer->addSymbol(GVar, GVar);
1880  } else if (const ConstantExpr *Cexpr = dyn_cast<ConstantExpr>(CPV)) {
1881  const Value *v = Cexpr->stripPointerCasts();
1882  aggBuffer->addSymbol(v, Cexpr);
1883  }
1884  unsigned int s = TD->getTypeAllocSize(CPV->getType());
1885  aggBuffer->addZeros(s);
1886  break;
1887  }
1888 
1889  case Type::ArrayTyID:
1890  case Type::VectorTyID:
1891  case Type::StructTyID: {
1892  if (isa<ConstantArray>(CPV) || isa<ConstantVector>(CPV) ||
1893  isa<ConstantStruct>(CPV) || isa<ConstantDataSequential>(CPV)) {
1894  int ElementSize = TD->getTypeAllocSize(CPV->getType());
1895  bufferAggregateConstant(CPV, aggBuffer);
1896  if (Bytes > ElementSize)
1897  aggBuffer->addZeros(Bytes - ElementSize);
1898  } else if (isa<ConstantAggregateZero>(CPV))
1899  aggBuffer->addZeros(Bytes);
1900  else
1901  llvm_unreachable("Unexpected Constant type");
1902  break;
1903  }
1904 
1905  default:
1906  llvm_unreachable("unsupported type");
1907  }
1908 }
1909 
1910 void NVPTXAsmPrinter::bufferAggregateConstant(const Constant *CPV,
1911  AggBuffer *aggBuffer) {
1912  const DataLayout *TD = TM.getDataLayout();
1913  int Bytes;
1914 
1915  // Old constants
1916  if (isa<ConstantArray>(CPV) || isa<ConstantVector>(CPV)) {
1917  if (CPV->getNumOperands())
1918  for (unsigned i = 0, e = CPV->getNumOperands(); i != e; ++i)
1919  bufferLEByte(cast<Constant>(CPV->getOperand(i)), 0, aggBuffer);
1920  return;
1921  }
1922 
1923  if (const ConstantDataSequential *CDS =
1924  dyn_cast<ConstantDataSequential>(CPV)) {
1925  if (CDS->getNumElements())
1926  for (unsigned i = 0; i < CDS->getNumElements(); ++i)
1927  bufferLEByte(cast<Constant>(CDS->getElementAsConstant(i)), 0,
1928  aggBuffer);
1929  return;
1930  }
1931 
1932  if (isa<ConstantStruct>(CPV)) {
1933  if (CPV->getNumOperands()) {
1934  StructType *ST = cast<StructType>(CPV->getType());
1935  for (unsigned i = 0, e = CPV->getNumOperands(); i != e; ++i) {
1936  if (i == (e - 1))
1937  Bytes = TD->getStructLayout(ST)->getElementOffset(0) +
1938  TD->getTypeAllocSize(ST) -
1939  TD->getStructLayout(ST)->getElementOffset(i);
1940  else
1941  Bytes = TD->getStructLayout(ST)->getElementOffset(i + 1) -
1942  TD->getStructLayout(ST)->getElementOffset(i);
1943  bufferLEByte(cast<Constant>(CPV->getOperand(i)), Bytes, aggBuffer);
1944  }
1945  }
1946  return;
1947  }
1948  llvm_unreachable("unsupported constant type in printAggregateConstant()");
1949 }
1950 
1951 // buildTypeNameMap - Run through symbol table looking for type names.
1952 //
1953 
1954 bool NVPTXAsmPrinter::isImageType(const Type *Ty) {
1955 
1956  std::map<const Type *, std::string>::iterator PI = TypeNameMap.find(Ty);
1957 
1958  if (PI != TypeNameMap.end() && (!PI->second.compare("struct._image1d_t") ||
1959  !PI->second.compare("struct._image2d_t") ||
1960  !PI->second.compare("struct._image3d_t")))
1961  return true;
1962 
1963  return false;
1964 }
1965 
1966 
1968  switch (MI.getOpcode()) {
1969  default:
1970  return false;
1971  case NVPTX::CallArgBeginInst:
1972  case NVPTX::CallArgEndInst0:
1973  case NVPTX::CallArgEndInst1:
1974  case NVPTX::CallArgF32:
1975  case NVPTX::CallArgF64:
1976  case NVPTX::CallArgI16:
1977  case NVPTX::CallArgI32:
1978  case NVPTX::CallArgI32imm:
1979  case NVPTX::CallArgI64:
1980  case NVPTX::CallArgParam:
1981  case NVPTX::CallVoidInst:
1982  case NVPTX::CallVoidInstReg:
1983  case NVPTX::Callseq_End:
1984  case NVPTX::CallVoidInstReg64:
1985  case NVPTX::DeclareParamInst:
1986  case NVPTX::DeclareRetMemInst:
1987  case NVPTX::DeclareRetRegInst:
1988  case NVPTX::DeclareRetScalarInst:
1989  case NVPTX::DeclareScalarParamInst:
1990  case NVPTX::DeclareScalarRegInst:
1991  case NVPTX::StoreParamF32:
1992  case NVPTX::StoreParamF64:
1993  case NVPTX::StoreParamI16:
1994  case NVPTX::StoreParamI32:
1995  case NVPTX::StoreParamI64:
1996  case NVPTX::StoreParamI8:
1997  case NVPTX::StoreRetvalF32:
1998  case NVPTX::StoreRetvalF64:
1999  case NVPTX::StoreRetvalI16:
2000  case NVPTX::StoreRetvalI32:
2001  case NVPTX::StoreRetvalI64:
2002  case NVPTX::StoreRetvalI8:
2003  case NVPTX::LastCallArgF32:
2004  case NVPTX::LastCallArgF64:
2005  case NVPTX::LastCallArgI16:
2006  case NVPTX::LastCallArgI32:
2007  case NVPTX::LastCallArgI32imm:
2008  case NVPTX::LastCallArgI64:
2009  case NVPTX::LastCallArgParam:
2010  case NVPTX::LoadParamMemF32:
2011  case NVPTX::LoadParamMemF64:
2012  case NVPTX::LoadParamMemI16:
2013  case NVPTX::LoadParamMemI32:
2014  case NVPTX::LoadParamMemI64:
2015  case NVPTX::LoadParamMemI8:
2016  case NVPTX::PrototypeInst:
2017  case NVPTX::DBG_VALUE:
2018  return true;
2019  }
2020  return false;
2021 }
2022 
2023 /// lowerConstantForGV - Return an MCExpr for the given Constant. This is mostly
2024 /// a copy from AsmPrinter::lowerConstant, except customized to only handle
2025 /// expressions that are representable in PTX and create
2026 /// NVPTXGenericMCSymbolRefExpr nodes for addrspacecast instructions.
2027 const MCExpr *
2028 NVPTXAsmPrinter::lowerConstantForGV(const Constant *CV, bool ProcessingGeneric) {
2029  MCContext &Ctx = OutContext;
2030 
2031  if (CV->isNullValue() || isa<UndefValue>(CV))
2032  return MCConstantExpr::create(0, Ctx);
2033 
2034  if (const ConstantInt *CI = dyn_cast<ConstantInt>(CV))
2035  return MCConstantExpr::create(CI->getZExtValue(), Ctx);
2036 
2037  if (const GlobalValue *GV = dyn_cast<GlobalValue>(CV)) {
2038  const MCSymbolRefExpr *Expr =
2040  if (ProcessingGeneric) {
2041  return NVPTXGenericMCSymbolRefExpr::create(Expr, Ctx);
2042  } else {
2043  return Expr;
2044  }
2045  }
2046 
2047  const ConstantExpr *CE = dyn_cast<ConstantExpr>(CV);
2048  if (!CE) {
2049  llvm_unreachable("Unknown constant value to lower!");
2050  }
2051 
2052  switch (CE->getOpcode()) {
2053  default:
2054  // If the code isn't optimized, there may be outstanding folding
2055  // opportunities. Attempt to fold the expression using DataLayout as a
2056  // last resort before giving up.
2058  if (C != CE)
2059  return lowerConstantForGV(C, ProcessingGeneric);
2060 
2061  // Otherwise report the problem to the user.
2062  {
2063  std::string S;
2064  raw_string_ostream OS(S);
2065  OS << "Unsupported expression in static initializer: ";
2066  CE->printAsOperand(OS, /*PrintType=*/false,
2067  !MF ? nullptr : MF->getFunction()->getParent());
2068  report_fatal_error(OS.str());
2069  }
2070 
2071  case Instruction::AddrSpaceCast: {
2072  // Strip the addrspacecast and pass along the operand
2073  PointerType *DstTy = cast<PointerType>(CE->getType());
2074  if (DstTy->getAddressSpace() == 0) {
2075  return lowerConstantForGV(cast<const Constant>(CE->getOperand(0)), true);
2076  }
2077  std::string S;
2078  raw_string_ostream OS(S);
2079  OS << "Unsupported expression in static initializer: ";
2080  CE->printAsOperand(OS, /*PrintType=*/ false,
2081  !MF ? 0 : MF->getFunction()->getParent());
2082  report_fatal_error(OS.str());
2083  }
2084 
2085  case Instruction::GetElementPtr: {
2086  const DataLayout &DL = *TM.getDataLayout();
2087 
2088  // Generate a symbolic expression for the byte address
2089  APInt OffsetAI(DL.getPointerTypeSizeInBits(CE->getType()), 0);
2090  cast<GEPOperator>(CE)->accumulateConstantOffset(DL, OffsetAI);
2091 
2092  const MCExpr *Base = lowerConstantForGV(CE->getOperand(0),
2093  ProcessingGeneric);
2094  if (!OffsetAI)
2095  return Base;
2096 
2097  int64_t Offset = OffsetAI.getSExtValue();
2098  return MCBinaryExpr::createAdd(Base, MCConstantExpr::create(Offset, Ctx),
2099  Ctx);
2100  }
2101 
2102  case Instruction::Trunc:
2103  // We emit the value and depend on the assembler to truncate the generated
2104  // expression properly. This is important for differences between
2105  // blockaddress labels. Since the two labels are in the same function, it
2106  // is reasonable to treat their delta as a 32-bit value.
2107  // FALL THROUGH.
2108  case Instruction::BitCast:
2109  return lowerConstantForGV(CE->getOperand(0), ProcessingGeneric);
2110 
2111  case Instruction::IntToPtr: {
2112  const DataLayout &DL = *TM.getDataLayout();
2113 
2114  // Handle casts to pointers by changing them into casts to the appropriate
2115  // integer type. This promotes constant folding and simplifies this code.
2116  Constant *Op = CE->getOperand(0);
2118  false/*ZExt*/);
2119  return lowerConstantForGV(Op, ProcessingGeneric);
2120  }
2121 
2122  case Instruction::PtrToInt: {
2123  const DataLayout &DL = *TM.getDataLayout();
2124 
2125  // Support only foldable casts to/from pointers that can be eliminated by
2126  // changing the pointer to the appropriately sized integer type.
2127  Constant *Op = CE->getOperand(0);
2128  Type *Ty = CE->getType();
2129 
2130  const MCExpr *OpExpr = lowerConstantForGV(Op, ProcessingGeneric);
2131 
2132  // We can emit the pointer value into this slot if the slot is an
2133  // integer slot equal to the size of the pointer.
2134  if (DL.getTypeAllocSize(Ty) == DL.getTypeAllocSize(Op->getType()))
2135  return OpExpr;
2136 
2137  // Otherwise the pointer is smaller than the resultant integer, mask off
2138  // the high bits so we are sure to get a proper truncation if the input is
2139  // a constant expr.
2140  unsigned InBits = DL.getTypeAllocSizeInBits(Op->getType());
2141  const MCExpr *MaskExpr = MCConstantExpr::create(~0ULL >> (64-InBits), Ctx);
2142  return MCBinaryExpr::createAnd(OpExpr, MaskExpr, Ctx);
2143  }
2144 
2145  // The MC library also has a right-shift operator, but it isn't consistently
2146  // signed or unsigned between different targets.
2147  case Instruction::Add: {
2148  const MCExpr *LHS = lowerConstantForGV(CE->getOperand(0), ProcessingGeneric);
2149  const MCExpr *RHS = lowerConstantForGV(CE->getOperand(1), ProcessingGeneric);
2150  switch (CE->getOpcode()) {
2151  default: llvm_unreachable("Unknown binary operator constant cast expr");
2152  case Instruction::Add: return MCBinaryExpr::createAdd(LHS, RHS, Ctx);
2153  }
2154  }
2155  }
2156 }
2157 
2158 // Copy of MCExpr::print customized for NVPTX
2159 void NVPTXAsmPrinter::printMCExpr(const MCExpr &Expr, raw_ostream &OS) {
2160  switch (Expr.getKind()) {
2161  case MCExpr::Target:
2162  return cast<MCTargetExpr>(&Expr)->printImpl(OS, MAI);
2163  case MCExpr::Constant:
2164  OS << cast<MCConstantExpr>(Expr).getValue();
2165  return;
2166 
2167  case MCExpr::SymbolRef: {
2168  const MCSymbolRefExpr &SRE = cast<MCSymbolRefExpr>(Expr);
2169  const MCSymbol &Sym = SRE.getSymbol();
2170  Sym.print(OS, MAI);
2171  return;
2172  }
2173 
2174  case MCExpr::Unary: {
2175  const MCUnaryExpr &UE = cast<MCUnaryExpr>(Expr);
2176  switch (UE.getOpcode()) {
2177  case MCUnaryExpr::LNot: OS << '!'; break;
2178  case MCUnaryExpr::Minus: OS << '-'; break;
2179  case MCUnaryExpr::Not: OS << '~'; break;
2180  case MCUnaryExpr::Plus: OS << '+'; break;
2181  }
2182  printMCExpr(*UE.getSubExpr(), OS);
2183  return;
2184  }
2185 
2186  case MCExpr::Binary: {
2187  const MCBinaryExpr &BE = cast<MCBinaryExpr>(Expr);
2188 
2189  // Only print parens around the LHS if it is non-trivial.
2190  if (isa<MCConstantExpr>(BE.getLHS()) || isa<MCSymbolRefExpr>(BE.getLHS()) ||
2191  isa<NVPTXGenericMCSymbolRefExpr>(BE.getLHS())) {
2192  printMCExpr(*BE.getLHS(), OS);
2193  } else {
2194  OS << '(';
2195  printMCExpr(*BE.getLHS(), OS);
2196  OS<< ')';
2197  }
2198 
2199  switch (BE.getOpcode()) {
2200  case MCBinaryExpr::Add:
2201  // Print "X-42" instead of "X+-42".
2202  if (const MCConstantExpr *RHSC = dyn_cast<MCConstantExpr>(BE.getRHS())) {
2203  if (RHSC->getValue() < 0) {
2204  OS << RHSC->getValue();
2205  return;
2206  }
2207  }
2208 
2209  OS << '+';
2210  break;
2211  default: llvm_unreachable("Unhandled binary operator");
2212  }
2213 
2214  // Only print parens around the LHS if it is non-trivial.
2215  if (isa<MCConstantExpr>(BE.getRHS()) || isa<MCSymbolRefExpr>(BE.getRHS())) {
2216  printMCExpr(*BE.getRHS(), OS);
2217  } else {
2218  OS << '(';
2219  printMCExpr(*BE.getRHS(), OS);
2220  OS << ')';
2221  }
2222  return;
2223  }
2224  }
2225 
2226  llvm_unreachable("Invalid expression kind!");
2227 }
2228 
2229 /// PrintAsmOperand - Print out an operand for an inline asm expression.
2230 ///
2231 bool NVPTXAsmPrinter::PrintAsmOperand(const MachineInstr *MI, unsigned OpNo,
2232  unsigned AsmVariant,
2233  const char *ExtraCode, raw_ostream &O) {
2234  if (ExtraCode && ExtraCode[0]) {
2235  if (ExtraCode[1] != 0)
2236  return true; // Unknown modifier.
2237 
2238  switch (ExtraCode[0]) {
2239  default:
2240  // See if this is a generic print operand
2241  return AsmPrinter::PrintAsmOperand(MI, OpNo, AsmVariant, ExtraCode, O);
2242  case 'r':
2243  break;
2244  }
2245  }
2246 
2247  printOperand(MI, OpNo, O);
2248 
2249  return false;
2250 }
2251 
2252 bool NVPTXAsmPrinter::PrintAsmMemoryOperand(
2253  const MachineInstr *MI, unsigned OpNo, unsigned AsmVariant,
2254  const char *ExtraCode, raw_ostream &O) {
2255  if (ExtraCode && ExtraCode[0])
2256  return true; // Unknown modifier
2257 
2258  O << '[';
2259  printMemOperand(MI, OpNo, O);
2260  O << ']';
2261 
2262  return false;
2263 }
2264 
2265 void NVPTXAsmPrinter::printOperand(const MachineInstr *MI, int opNum,
2266  raw_ostream &O, const char *Modifier) {
2267  const MachineOperand &MO = MI->getOperand(opNum);
2268  switch (MO.getType()) {
2271  if (MO.getReg() == NVPTX::VRDepot)
2272  O << DEPOTNAME << getFunctionNumber();
2273  else
2275  } else {
2276  emitVirtualRegister(MO.getReg(), O);
2277  }
2278  return;
2279 
2281  if (!Modifier)
2282  O << MO.getImm();
2283  else if (strstr(Modifier, "vec") == Modifier)
2284  printVecModifiedImmediate(MO, Modifier, O);
2285  else
2287  "Don't know how to handle modifier on immediate operand");
2288  return;
2289 
2291  printFPConstant(MO.getFPImm(), O);
2292  break;
2293 
2295  getSymbol(MO.getGlobal())->print(O, MAI);
2296  break;
2297 
2299  MO.getMBB()->getSymbol()->print(O, MAI);
2300  return;
2301 
2302  default:
2303  llvm_unreachable("Operand type not supported.");
2304  }
2305 }
2306 
2307 void NVPTXAsmPrinter::printMemOperand(const MachineInstr *MI, int opNum,
2308  raw_ostream &O, const char *Modifier) {
2309  printOperand(MI, opNum, O);
2310 
2311  if (Modifier && !strcmp(Modifier, "add")) {
2312  O << ", ";
2313  printOperand(MI, opNum + 1, O);
2314  } else {
2315  if (MI->getOperand(opNum + 1).isImm() &&
2316  MI->getOperand(opNum + 1).getImm() == 0)
2317  return; // don't print ',0' or '+0'
2318  O << "+";
2319  printOperand(MI, opNum + 1, O);
2320  }
2321 }
2322 
2323 void NVPTXAsmPrinter::emitSrcInText(StringRef filename, unsigned line) {
2324  std::stringstream temp;
2325  LineReader *reader = this->getReader(filename);
2326  temp << "\n//";
2327  temp << filename.str();
2328  temp << ":";
2329  temp << line;
2330  temp << " ";
2331  temp << reader->readLine(line);
2332  temp << "\n";
2333  this->OutStreamer->EmitRawText(temp.str());
2334 }
2335 
2336 LineReader *NVPTXAsmPrinter::getReader(std::string filename) {
2337  if (!reader) {
2338  reader = new LineReader(filename);
2339  }
2340 
2341  if (reader->fileName() != filename) {
2342  delete reader;
2343  reader = new LineReader(filename);
2344  }
2345 
2346  return reader;
2347 }
2348 
2349 std::string LineReader::readLine(unsigned lineNum) {
2350  if (lineNum < theCurLine) {
2351  theCurLine = 0;
2352  fstr.seekg(0, std::ios::beg);
2353  }
2354  while (theCurLine < lineNum) {
2355  fstr.getline(buff, 500);
2356  theCurLine++;
2357  }
2358  return buff;
2359 }
2360 
2361 // Force static initialization.
2365 }
static unsigned getBitWidth(Type *Ty, const DataLayout &DL)
Returns the bitwidth of the given scalar or pointer type (if unknown returns 0).
OSType getOS() const
getOS - Get the parsed operating system type of this triple.
Definition: Triple.h:251
static const NVPTXFloatMCExpr * createConstantFPDouble(APFloat Flt, MCContext &Ctx)
Definition: NVPTXMCExpr.h:47
bool doesSupportDebugInformation() const
Definition: MCAsmInfo.h:507
A parsed version of the target data layout string in and methods for querying it. ...
Definition: DataLayout.h:104
static cl::opt< bool > InterleaveSrc("nvptx-emit-src", cl::ZeroOrMore, cl::Hidden, cl::desc("NVPTX Specific: Emit source line in ptx file"), cl::init(false))
StringRef getTargetCPU() const
static Type * getDoubleTy(LLVMContext &C)
Definition: Type.cpp:229
const GlobalValue * getGlobal() const
uint64_t getZExtValue() const
Get zero extended value.
Definition: APInt.h:1327
Bitwise negation.
Definition: MCExpr.h:357
const MCSymbol & getSymbol() const
Definition: MCExpr.h:328
std::unique_ptr< MCStreamer > OutStreamer
This is the MCStreamer object for the file we are generating.
Definition: AsmPrinter.h:83
MCSymbol * getSymbol(const GlobalValue *GV) const
Definition: AsmPrinter.cpp:339
static const MCSymbolRefExpr * create(const MCSymbol *Symbol, MCContext &Ctx)
Definition: MCExpr.h:315
std::string getSurfaceName(const llvm::Value &)
bool hasName() const
Definition: Value.h:228
void print(raw_ostream &OS, const MCAsmInfo *MAI) const
print - Print the value to the stream OS.
Definition: MCSymbol.cpp:51
MDNode * getScope() const
Definition: DebugLoc.cpp:36
bool getReqNTIDy(const llvm::Function &, unsigned &)
static const fltSemantics IEEEdouble
Definition: APFloat.h:133
const ConstantFP * getFPImm() const
MachineBasicBlock * getMBB() const
MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...
Definition: MCSymbol.h:39
static unsigned index2VirtReg(unsigned Index)
index2VirtReg - Convert a 0-based index to a virtual register number.
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:114
const DataLayout & getDataLayout() const
Return information about data layout.
Definition: AsmPrinter.cpp:139
2: 32-bit floating point type
Definition: Type.h:58
bool doFinalization(Module &M) override
Shut down the asmprinter.
MCContext & OutContext
This is the context for the output file that we are streaming.
Definition: AsmPrinter.h:78
size_type size() const
Definition: DenseSet.h:53
static MCOperand createExpr(const MCExpr *Val)
Definition: MCInst.h:129
DenseSet - This implements a dense probed hash-table based set.
Definition: DenseSet.h:39
const GlobalListType & getGlobalList() const
Get the Module's list of global variables (constant).
Definition: Module.h:512
unsigned getNumOperands() const
Definition: User.h:138
unsigned getPointerTypeSizeInBits(Type *) const
Layout pointer size, in bits, based on the type.
Definition: DataLayout.cpp:602
unsigned getPrefTypeAlignment(Type *Ty) const
Returns the preferred stack/global alignment for the specified type.
Definition: DataLayout.cpp:684
Describe properties that are true of each instruction in the target description file.
Definition: MCInstrDesc.h:138
static bool isVirtualRegister(unsigned Reg)
isVirtualRegister - Return true if the specified register number is in the virtual register namespace...
bool hasAppendingLinkage() const
Definition: GlobalValue.h:277
unsigned getPointerPrefAlignment(unsigned AS=0) const
Return target's alignment for stack-based pointers FIXME: The defaults need to be removed once all of...
Definition: DataLayout.cpp:584
const MachineFunction * MF
The current machine function.
Definition: AsmPrinter.h:86
ExprKind getKind() const
Definition: MCExpr.h:69
unsigned getSizeInBits() const
bool hasAvailableExternallyLinkage() const
Definition: GlobalValue.h:261
Unary plus.
Definition: MCExpr.h:358
std::string str() const
str - Get the contents as an std::string.
Definition: StringRef.h:188
A raw_ostream that writes to an SmallVector or SmallString.
Definition: raw_ostream.h:488
const MCInstrDesc & getDesc() const
Returns the target instruction descriptor of this MachineInstr.
Definition: MachineInstr.h:264
Type * getReturnType() const
Definition: Function.cpp:233
bool isSurface(const llvm::Value &)
MachineBasicBlock reference.
const Function * getParent() const
Return the enclosing method, or null if none.
Definition: BasicBlock.h:111
arg_iterator arg_end()
Definition: Function.h:480
12: Structures
Definition: Type.h:71
bool isKernelFunction(const llvm::Function &)
unsigned getFunctionNumber() const
Return a unique ID for the current function.
Definition: AsmPrinter.cpp:130
const char * getSymbolName() const
unsigned getParamAlignment(unsigned Index) const
Return the alignment for the specified function parameter.
Definition: Attributes.cpp:997
A debug info location.
Definition: DebugLoc.h:34
Metadata node.
Definition: Metadata.h:740
static const MCBinaryExpr * createAnd(const MCExpr *LHS, const MCExpr *RHS, MCContext &Ctx)
Definition: MCExpr.h:450
F(f)
const Function * getFunction() const
getFunction - Return the LLVM function that this machine code represents
unsigned getAddressSpace() const
Return the address space of the Pointer type.
Definition: DerivedTypes.h:472
static IntegerType * getInt64Ty(LLVMContext &C)
Definition: Type.cpp:240
iterator begin()
Definition: ilist.h:359
14: Pointers
Definition: Type.h:73
static IntegerType * getInt16Ty(LLVMContext &C)
Definition: Type.cpp:238
const Constant * getInitializer() const
getInitializer - Return the initializer for this global variable.
bool hasAttribute(unsigned Index, Attribute::AttrKind Kind) const
Return true if the attribute exists at the given index.
Definition: Attributes.cpp:956
Constant * ConstantFoldConstantExpression(const ConstantExpr *CE, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr)
ConstantFoldConstantExpression - Attempt to fold the constant expression using the specified DataLayo...
unsigned getOpcode() const
getOpcode - Return the opcode at the root of this constant expression
Definition: Constants.h:1144
std::string getVirtualRegisterName(unsigned) const
std::string getTextureName(const llvm::Value &)
void processModule(const Module &M)
Process entire module and collect debug info anchors.
Definition: DebugInfo.cpp:122
LLVM_ATTRIBUTE_NORETURN void report_fatal_error(const char *reason, bool gen_crash_diag=true)
Reports a serious error, calling any installed error handler.
uint64_t getTypeAllocSizeInBits(Type *Ty) const
Returns the offset in bits between successive objects of the specified type, including alignment padd...
Definition: DataLayout.h:398
StringRef getName() const
Return a constant reference to the value's name.
Definition: Value.cpp:188
Target TheNVPTXTarget32
Definition: NVPTX.h:78
unsigned getMaxAlignment() const
Return the alignment in bytes that this function must be aligned to, which is greater than the defaul...
const Triple & getTargetTriple() const
bool isSingleValueType() const
isSingleValueType - Return true if the type is a valid type for a register in codegen.
Definition: Type.h:250
uint64_t getStackSize() const
Return the number of bytes that must be allocated to hold all of the fixed size frame objects...
std::string readLine(unsigned line)
std::pair< iterator, bool > insert(const std::pair< KeyT, ValueT > &KV)
Definition: DenseMap.h:169
bool getMaxNTIDz(const llvm::Function &, unsigned &)
unsigned getNumVirtRegs() const
getNumVirtRegs - Return the number of virtual registers created.
void append(SmallVectorImpl< char > &path, const Twine &a, const Twine &b="", const Twine &c="", const Twine &d="")
Append to path.
Definition: Path.cpp:443
static Constant * getIntegerCast(Constant *C, Type *Ty, bool isSigned)
Create a ZExt, Bitcast or Trunc for integer -> integer casts.
Definition: Constants.cpp:1674
bool hasCommonLinkage() const
Definition: GlobalValue.h:282
unsigned getNumRegClasses() const
const TargetSubtargetInfo & getSubtarget() const
getSubtarget - Return the subtarget for which this machine code is being compiled.
static MCOperand createReg(unsigned Reg)
Definition: MCInst.h:111
bool isManaged(const llvm::Value &)
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:79
const StructLayout * getStructLayout(StructType *Ty) const
Returns a StructLayout object, indicating the alignment of the struct, its size, and the offsets of i...
Definition: DataLayout.cpp:551
bool erase(const ValueT &V)
Definition: DenseSet.h:69
static Type * getFloatTy(LLVMContext &C)
Definition: Type.cpp:228
const APInt & getValue() const
Return the constant as an APInt value reference.
Definition: Constants.h:106
static bool usedInOneFunc(const User *U, Function const *&oneFunc)
StructType - Class to represent struct types.
Definition: DerivedTypes.h:191
bool isImm() const
isImm - Tests if this is a MO_Immediate operand.
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Definition: ErrorHandling.h:98
const TargetRegisterClass * getRegClass(unsigned i) const
getRegClass - Returns the register class associated with the enumeration value.
bool hasInternalLinkage() const
Definition: GlobalValue.h:278
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: APInt.h:33
Base class for the full range of assembler expressions which are needed for parsing.
Definition: MCExpr.h:33
const TargetRegisterClass * getRegClass(unsigned Reg) const
getRegClass - Return the register class of the specified virtual register.
Name of external global symbol.
Utility to find all debug info in a module.
Definition: DebugInfo.h:72
Reg
All possible values of the reg field in the ModR/M byte.
bool getReqNTIDx(const llvm::Function &, unsigned &)
Represent a reference to a symbol from inside an expression.
Definition: MCExpr.h:159
bool is_absolute(const Twine &path)
Is path absolute?
Definition: Path.cpp:650
The MachineFrameInfo class represents an abstract stack frame until prolog/epilog code is inserted...
const char * getImageHandleSymbol(unsigned Idx) const
Returns the symbol name at the given index.
Windows NT (Windows on ARM)
This class defines information used to lower LLVM code to legal SelectionDAG operators that the targe...
bool isInteger() const
isInteger - Return true if this is an integer, or a vector integer type.
Definition: ValueTypes.h:110
bool hasPrivateLinkage() const
Definition: GlobalValue.h:279
unsigned getNumOperands() const
Access to explicit operands of the instruction.
Definition: MachineInstr.h:271
uint64_t getZExtValue() const
Return the constant as a 64-bit unsigned integer value after it has been zero extended as appropriate...
Definition: Constants.h:117
global_iterator global_begin()
Definition: Module.h:552
bool ignoreLoc(const MachineInstr &)
Context object for machine code objects.
Definition: MCContext.h:48
Subprogram description.
ConstantExpr - a constant value that is initialized with an expression using other constant values...
Definition: Constants.h:852
FunctionType - Class to represent function types.
Definition: DerivedTypes.h:96
Mangler * Mang
Name-mangler for global names.
Definition: AsmPrinter.h:93
unsigned int getSmVersion() const
static const NVPTXFloatMCExpr * createConstantFPSingle(APFloat Flt, MCContext &Ctx)
Definition: NVPTXMCExpr.h:42
ConstantDataSequential - A vector or array constant whose element type is a simple 1/2/4/8-byte integ...
Definition: Constants.h:557
const char * data() const
data - Get a pointer to the start of the string (which may not be null terminated).
Definition: StringRef.h:107
void printAsOperand(raw_ostream &O, bool PrintType=true, const Module *M=nullptr) const
Print the name of this Value out to the specified raw_ostream.
Definition: AsmWriter.cpp:3287
#define T
unsigned getAlignment() const
Definition: GlobalObject.h:46
Unary assembler expressions.
Definition: MCExpr.h:352
ArrayType - Class to represent array types.
Definition: DerivedTypes.h:336
static std::string utostr(uint64_t X, bool isNeg=false)
Definition: StringExtras.h:93
double convertToDouble() const
Definition: APFloat.cpp:3116
TypeID getTypeID() const
getTypeID - Return the type id for the type.
Definition: Type.h:134
bool isFloatingPointTy() const
isFloatingPointTy - Return true if this is one of the six floating point types
Definition: Type.h:159
Pass structure by value.
Definition: Attributes.h:73
iterator_range< compile_unit_iterator > compile_units() const
Definition: DebugInfo.h:110
bool isImageReadWrite(const llvm::Value &)
int64_t getImm() const
#define DEPOTNAME
static const MCBinaryExpr * createAdd(const MCExpr *LHS, const MCExpr *RHS, MCContext &Ctx)
Definition: MCExpr.h:446
Type * getElementType() const
Definition: DerivedTypes.h:323
void ComputeValueVTs(const TargetLowering &TLI, const DataLayout &DL, Type *Ty, SmallVectorImpl< EVT > &ValueVTs, SmallVectorImpl< uint64_t > *Offsets=nullptr, uint64_t StartingOffset=0)
ComputeValueVTs - Given an LLVM IR type, compute a sequence of EVTs that represent all the individual...
Unary expressions.
Definition: MCExpr.h:39
MachineModuleInfo * MMI
This is a pointer to the current MachineModuleInfo.
Definition: AsmPrinter.h:89
Instances of this class represent a single low-level machine instruction.
Definition: MCInst.h:150
static const NVPTXGenericMCSymbolRefExpr * create(const MCSymbolRefExpr *SymExpr, MCContext &Ctx)
Definition: NVPTXMCExpr.cpp:50
PointerType - Class to represent pointers.
Definition: DerivedTypes.h:449
const BasicBlock * getBasicBlock() const
getBasicBlock - Return the LLVM basic block that this instance corresponded to originally.
iterator_range< subprogram_iterator > subprograms() const
Definition: DebugInfo.h:114
unsigned getOpcode() const
Returns the opcode of this MachineInstr.
Definition: MachineInstr.h:267
bool hasDouble() const
uint64_t getElementOffset(unsigned Idx) const
Definition: DataLayout.h:491
10: Arbitrary bit width integers
Definition: Type.h:69
bool hasSection() const
Definition: GlobalObject.h:56
DBG_VALUE - a mapping of the llvm.dbg.value intrinsic.
Definition: TargetOpcodes.h:69
unsigned getLine() const
Definition: DebugLoc.cpp:26
MachineLoop * getLoopFor(const MachineBasicBlock *BB) const
getLoopFor - Return the inner most loop that BB lives in.
A self-contained host- and target-independent arbitrary-precision floating-point software implementat...
Definition: APFloat.h:122
void clearAnnotationCache(const llvm::Module *)
const MCExpr * getLHS() const
Get the left-hand side expression of the binary operator.
Definition: MCExpr.h:531
0: type with no size
Definition: Type.h:56
StringRef filename(StringRef path)
Get filename.
Definition: Path.cpp:548
Address of a global value.
initializer< Ty > init(const Ty &Val)
Definition: CommandLine.h:325
void print(raw_ostream &OS, const MCAsmInfo *MAI) const
Definition: MCExpr.cpp:33
bool getMaxNTIDy(const llvm::Function &, unsigned &)
MCSymbol * CurrentFnSym
The symbol for the current function.
Definition: AsmPrinter.h:98
MVT - Machine Value Type.
LLVM Basic Block Representation.
Definition: BasicBlock.h:65
const MCAsmInfo * MAI
Target Asm Printer information.
Definition: AsmPrinter.h:74
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:45
size_type count(const ValueT &V) const
Return 1 if the specified key is in the set, 0 otherwise.
Definition: DenseSet.h:65
bool isVectorTy() const
isVectorTy - True if this is an instance of VectorType.
Definition: Type.h:226
size_type LLVM_ATTRIBUTE_UNUSED_RESULT size() const
Definition: ilist.h:539
This is an important base class in LLVM.
Definition: Constant.h:41
static bool is64Bit(const char *name)
bool isImageWriteOnly(const llvm::Value &)
const MachineOperand & getOperand(unsigned i) const
Definition: MachineInstr.h:273
const NVPTXTargetLowering * getTargetLowering() const override
virtual bool PrintAsmOperand(const MachineInstr *MI, unsigned OpNo, unsigned AsmVariant, const char *ExtraCode, raw_ostream &OS)
Print the specified operand of MI, an INLINEASM instruction, using the specified assembler variant...
ConstantFP - Floating Point Values [float, double].
Definition: Constants.h:233
TargetMachine & TM
Target machine description.
Definition: AsmPrinter.h:70
Target TheNVPTXTarget64
Definition: NVPTX.h:79
static GCMetadataPrinterRegistry::Add< ErlangGCPrinter > X("erlang","erlang-compatible garbage collector")
static const char * getRegisterName(unsigned RegNo)
iterator insert(iterator where, NodeTy *New)
Definition: ilist.h:412
Ty * getInfo()
getInfo - Keep track of various per-function pieces of information for backends that would like to do...
opStatus convert(const fltSemantics &, roundingMode, bool *)
APFloat::convert - convert a value of one floating point type to another.
Definition: APFloat.cpp:1972
ManagedStringPool * getManagedStrPool() const
Value * getOperand(unsigned i) const
Definition: User.h:118
arg_iterator arg_begin()
Definition: Function.h:472
Class to represent integer types.
Definition: DerivedTypes.h:37
Logical negation.
Definition: MCExpr.h:355
void emitLineNumberAsDotLoc(const MachineInstr &)
bool getReqNTIDz(const llvm::Function &, unsigned &)
EVT - Extended Value Type.
Definition: ValueTypes.h:31
bool isPointerTy() const
isPointerTy - True if this is an instance of PointerType.
Definition: Type.h:217
bool hasWeakLinkage() const
Definition: GlobalValue.h:268
Binary assembler expressions.
Definition: MCExpr.h:405
TargetRegisterInfo base class - We assume that the target defines a static array of TargetRegisterDes...
LLVMContext & getContext() const
All values hold a context through their type.
Definition: Value.cpp:519
MCSymbol * getSymbol() const
getSymbol - Return the MCSymbol for this basic block.
static bool useFuncSeen(const Constant *C, llvm::DenseMap< const Function *, bool > &seenMap)
Triple - Helper class for working with autoconf configuration names.
Definition: Triple.h:44
const std::string & getModuleInlineAsm() const
Get any module-scope inline assembly blocks.
Definition: Module.h:269
unsigned getCol() const
Definition: DebugLoc.cpp:31
global_iterator global_end()
Definition: Module.h:554
static cl::opt< bool > EmitLineNumbers("nvptx-emit-line-numbers", cl::Hidden, cl::desc("NVPTX Specific: Emit Line numbers even without -G"), cl::init(true))
const char * getSection() const
Definition: GlobalObject.h:57
13: Arrays
Definition: Type.h:72
iterator begin()
Definition: DenseSet.h:122
IntegerType * getIntPtrType(LLVMContext &C, unsigned AddressSpace=0) const
Returns an integer type with size at least as big as that of a pointer in the given address space...
Definition: DataLayout.cpp:694
unsigned getABITypeAlignment(Type *Ty) const
Returns the minimum ABI-required alignment for the specified type.
Definition: DataLayout.cpp:674
bool hasExternalLinkage() const
Definition: GlobalValue.h:260
std::pair< iterator, bool > insert(const ValueT &V)
Definition: DenseSet.h:147
void setOpcode(unsigned Op)
Definition: MCInst.h:158
bool startswith(StringRef Prefix) const
Check if this string starts with the given Prefix.
Definition: StringRef.h:215
This is the shared class of boolean and integer constants.
Definition: Constants.h:47
static void ConvertFloatToBytes(unsigned char *p, float val)
std::string * getManagedString(const char *S)
StringRef getTargetFeatureString() const
15: SIMD 'packed' format, or other vector type
Definition: Type.h:74
uint64_t getTypeAllocSize(Type *Ty) const
Returns the offset in bytes between successive objects of the specified type, including alignment pad...
Definition: DataLayout.h:388
const DataLayout * getDataLayout() const
Deprecated in 3.7, will be removed in 3.8.
const MCExpr * lowerConstant(const Constant *CV)
Lower the specified LLVM Constant to an MCExpr.
MachineOperand class - Representation of each machine instruction operand.
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:861
Module.h This file contains the declarations for the Module class.
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:222
AddressSpace
Definition: NVPTXBaseInfo.h:22
bool getAlign(const llvm::Function &, unsigned index, unsigned &)
void EmitToStreamer(MCStreamer &S, const MCInst &Inst)
Definition: AsmPrinter.cpp:148
bool doInitialization(Module &M) override
Set up the AsmPrinter when we are working on a new module.
bool LLVM_ATTRIBUTE_UNUSED_RESULT empty() const
Definition: ilist.h:385
std::string getTargetName() const
Value * stripPointerCasts()
Strip off pointer casts, all-zero GEPs, and aliases.
Definition: Value.cpp:458
MachineFrameInfo * getFrameInfo()
getFrameInfo - Return the frame info object for the current function.
bool isNullValue() const
isNullValue - Return true if this is the value that would be returned by getNullValue.
Definition: Constants.cpp:75
Intrinsic::ID getIntrinsicID() const LLVM_READONLY
getIntrinsicID - This method returns the ID number of the specified function, or Intrinsic::not_intri...
Definition: Function.h:159
AttributeSet getAttributes() const
Return the attribute list for this Function.
Definition: Function.h:181
bool getMinCTASm(const llvm::Function &, unsigned &)
virtual void EmitBasicBlockStart(const MachineBasicBlock &MBB) const
Targets can override this to emit stuff at the start of a basic block.
Class for arbitrary precision integers.
Definition: APInt.h:73
bool hasInitializer() const
Definitions have initializers, declarations don't.
bool isIntegerTy() const
isIntegerTy - True if this is an instance of IntegerType.
Definition: Type.h:193
iterator_range< user_iterator > users()
Definition: Value.h:300
bool isImage(const llvm::Value &)
APInt bitcastToAPInt() const
Definition: APFloat.cpp:3084
LLVM_ATTRIBUTE_UNUSED_RESULT std::enable_if< !is_simple_type< Y >::value, typename cast_retty< X, const Y >::ret_type >::type dyn_cast(const Y &Val)
Definition: Casting.h:285
const DebugLoc & getDebugLoc() const
Returns the debug location id of this MachineInstr.
Definition: MachineInstr.h:238
MDNode * GetUnrollMetadata(MDNode *LoopID, StringRef Name)
Given an llvm.loop loop id metadata node, returns the loop hint metadata node with the given name (fo...
Definition: LoopUnroll.cpp:564
bool isSampler(const llvm::Value &)
const MCExpr * getRHS() const
Get the right-hand side expression of the binary operator.
Definition: MCExpr.h:534
StringRef str()
Flushes the stream contents to the target vector and return a StringRef for the vector contents...
bool hasLinkOnceLinkage() const
Definition: GlobalValue.h:264
Representation of each machine instruction.
Definition: MachineInstr.h:51
MachineOperandType getType() const
getType - Returns the MachineOperandType for this operand.
static bool isPhysicalRegister(unsigned Reg)
isPhysicalRegister - Return true if the specified register number is in the physical register namespa...
PointerType * getType() const
Global values are always pointers.
Definition: GlobalValue.h:185
NVPTXTargetMachine.
static const fltSemantics IEEEsingle
Definition: APFloat.h:132
const MCExpr * getSubExpr() const
Get the child of this unary expression.
Definition: MCExpr.h:395
unsigned size() const
Definition: DenseMap.h:82
iterator end()
Definition: Module.h:571
bool isAggregateType() const
isAggregateType - Return true if the type is an aggregate type.
Definition: Type.h:260
std::string getNVPTXRegClassStr(TargetRegisterClass const *RC)
MachineRegisterInfo & getRegInfo()
getRegInfo - Return information about the registers currently in use.
static IntegerType * getInt32Ty(LLVMContext &C)
Definition: Type.cpp:239
MCSymbol * getOrCreateSymbol(const Twine &Name)
Lookup the symbol inside with the specified Name.
Definition: MCContext.cpp:111
bool isDeclaration() const
Return true if the primary definition of this global value is outside of the current translation unit...
Definition: Globals.cpp:128
static bool usedInGlobalVarDef(const Constant *C)
std::string getSamplerName(const llvm::Value &)
unsigned getSizeInBits() const
getSizeInBits - Return the size of the specified value type in bits.
Definition: ValueTypes.h:233
#define I(x, y, z)
Definition: MD5.cpp:54
Opcode getOpcode() const
Get the kind of this binary expression.
Definition: MCExpr.h:528
std::string getNVPTXRegClassName(TargetRegisterClass const *RC)
iterator begin()
Definition: Module.h:569
iterator end()
Definition: DenseMap.h:68
static unsigned int getOpenCLAlignment(const DataLayout *TD, Type *Ty)
iterator find(const KeyT &Val)
Definition: DenseMap.h:124
float convertToFloat() const
Definition: APFloat.cpp:3107
const TargetMachine & getTarget() const
getTarget - Return the target machine this machine code is compiled with
void size_t size
References to labels and assigned expressions.
Definition: MCExpr.h:38
Unary minus.
Definition: MCExpr.h:356
uint64_t getTypeStoreSize(Type *Ty) const
Returns the maximum number of bytes that may be overwritten by storing the specified type...
Definition: DataLayout.h:371
static bool canDemoteGlobalVar(const GlobalVariable *gv, Function const *&f)
bool isLoopHeader(const MachineBasicBlock *BB) const
static std::string utohexstr(uint64_t X, bool LowerCase=false)
Definition: StringExtras.h:72
const APFloat & getValueAPF() const
Definition: Constants.h:270
3: 64-bit floating point type
Definition: Type.h:59
unsigned getReg() const
getReg - Returns the register number.
bool use_empty() const
Definition: Value.h:275
const TargetLoweringObjectFile & getObjFileLowering() const
Return information about object file lowering.
Definition: AsmPrinter.cpp:134
bool isTexture(const llvm::Value &)
iterator end()
Definition: ilist.h:367
bool hasImageHandles() const
A raw_ostream that writes to an std::string.
Definition: raw_ostream.h:465
MVT getPointerTy(const DataLayout &DL, uint32_t AS=0) const
Return the pointer type for the given address space, defaults to the pointer type from the data layou...
unsigned getPrimitiveSizeInBits() const LLVM_READONLY
getPrimitiveSizeInBits - Return the basic size of this type if it is a primitive type.
Definition: Type.cpp:121
Module * getParent()
Get the module that this global value is contained inside of...
Definition: GlobalValue.h:365
LLVM Value Representation.
Definition: Value.h:69
static const char * name
Floating-point immediate operand.
RegisterAsmPrinter - Helper template for registering a target specific assembly printer, for use in the target machine initialization function.
Constant expressions.
Definition: MCExpr.h:37
Binary expressions.
Definition: MCExpr.h:36
This class implements an extremely fast bulk output stream that can only output to a stream...
Definition: raw_ostream.h:38
Primary interface to the complete machine description for the target machine.
static void ConvertDoubleToBytes(unsigned char *p, double val)
virtual const TargetRegisterInfo * getRegisterInfo() const
getRegisterInfo - If register information is available, return it.
void addOperand(const MCOperand &Op)
Definition: MCInst.h:168
virtual void print(raw_ostream &O, const Module *M) const
print - Print out the internal state of the pass.
Definition: Pass.cpp:111
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:40
Target specific expression.
Definition: MCExpr.h:40
static GCMetadataPrinterRegistry::Add< OcamlGCMetadataPrinter > Y("ocaml","ocaml 3.10-compatible collector")
iterator end()
Definition: DenseSet.h:123
static void ConvertIntToBytes(unsigned char *p, T val)
bool getMaxNTIDx(const llvm::Function &, unsigned &)
Instances of this class represent operands of the MCInst class.
Definition: MCInst.h:33
MCSymbol * GetExternalSymbolSymbol(StringRef Sym) const
Return the MCSymbol for the specified ExternalSymbol.
NodeTy * remove(iterator &IT)
Definition: ilist.h:435
static MCOperand createImm(int64_t Val)
Definition: MCInst.h:117
static IntegerType * getInt8Ty(LLVMContext &C)
Definition: Type.cpp:237
const BasicBlock * getParent() const
Definition: Instruction.h:72
static const MCConstantExpr * create(int64_t Value, MCContext &Ctx)
Definition: MCExpr.cpp:150
NVPTX::DrvInterface getDrvInterface() const
void LLVMInitializeNVPTXAsmPrinter()
bool doFinalization(Module &M) override
Shut down the asmprinter.
unsigned getPTXVersion() const
std::string fileName()
void * addr
const NVPTXRegisterInfo * getRegisterInfo() const override
bool empty() const
empty - Check if the string is empty.
Definition: StringRef.h:110
Opcode getOpcode() const
Get the kind of this unary expression.
Definition: MCExpr.h:392
const char * getName(unsigned RegNo) const