lib/Target/NVPTX/NVPTXAsmPrinter.cpp

   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"
  16 #include "NVPTX.h"
  17 #include "NVPTXInstrInfo.h"
  18 #include "NVPTXTargetMachine.h"
  19 #include "NVPTXRegisterInfo.h"
  20 #include "NVPTXUtilities.h"
  21 #include "MCTargetDesc/NVPTXMCAsmInfo.h"
  22 #include "NVPTXNumRegisters.h"
  23 #include "llvm/ADT/StringExtras.h"
  24 #include "llvm/DebugInfo.h"
  25 #include "llvm/Function.h"
  26 #include "llvm/GlobalVariable.h"
  27 #include "llvm/Module.h"
  28 #include "llvm/CodeGen/Analysis.h"
  29 #include "llvm/CodeGen/MachineRegisterInfo.h"
  30 #include "llvm/CodeGen/MachineFrameInfo.h"
  31 #include "llvm/CodeGen/MachineModuleInfo.h"
  32 #include "llvm/MC/MCStreamer.h"
  33 #include "llvm/MC/MCSymbol.h"
  34 #include "llvm/Target/Mangler.h"
  35 #include "llvm/Target/TargetLoweringObjectFile.h"
  36 #include "llvm/Support/TargetRegistry.h"
  37 #include "llvm/Support/ErrorHandling.h"
  38 #include "llvm/Support/FormattedStream.h"
  39 #include "llvm/DerivedTypes.h"
  40 #include "llvm/Support/TimeValue.h"
  41 #include "llvm/Support/CommandLine.h"
  42 #include "llvm/Analysis/ConstantFolding.h"
  43 #include "llvm/Support/Path.h"
  44 #include "llvm/Assembly/Writer.h"
  45 #include "cl_common_defines.h"
  46 #include <sstream>
  47 using namespace llvm;
  48
  49
  50 #include "NVPTXGenAsmWriter.inc"
  51
  52 bool RegAllocNilUsed = true;
  53
  54 #define DEPOTNAME "__local_depot"
  55
  56 static cl::opt<bool>
  57 EmitLineNumbers("nvptx-emit-line-numbers",
  58                 cl::desc("NVPTX Specific: Emit Line numbers even without -G"),
  59                 cl::init(true));
  60
  61 namespace llvm  {
  62 bool InterleaveSrcInPtx = false;
  63 }
  64
  65 static cl::opt<bool, true>InterleaveSrc("nvptx-emit-src",
  66                                         cl::ZeroOrMore,
  67                        cl::desc("NVPTX Specific: Emit source line in ptx file"),
  68                                         cl::location(llvm::InterleaveSrcInPtx));
  69
  70
  71
  72
  73 // @TODO: This is a copy from AsmPrinter.cpp.  The function is static, so we
  74 // cannot just link to the existing version.
  75 /// LowerConstant - Lower the specified LLVM Constant to an MCExpr.
  76 ///
  77 using namespace nvptx;
  78 const MCExpr *nvptx::LowerConstant(const Constant *CV, AsmPrinter &AP) {
  79   MCContext &Ctx = AP.OutContext;
  80
  81   if (CV->isNullValue() || isa<UndefValue>(CV))
  82     return MCConstantExpr::Create(0, Ctx);
  83
  84   if (const ConstantInt *CI = dyn_cast<ConstantInt>(CV))
  85     return MCConstantExpr::Create(CI->getZExtValue(), Ctx);
  86
  87   if (const GlobalValue *GV = dyn_cast<GlobalValue>(CV))
  88     return MCSymbolRefExpr::Create(AP.Mang->getSymbol(GV), Ctx);
  89
  90   if (const BlockAddress *BA = dyn_cast<BlockAddress>(CV))
  91     return MCSymbolRefExpr::Create(AP.GetBlockAddressSymbol(BA), Ctx);
  92
  93   const ConstantExpr *CE = dyn_cast<ConstantExpr>(CV);
  94   if (CE == 0)
  95     llvm_unreachable("Unknown constant value to lower!");
  96
  97
  98   switch (CE->getOpcode()) {
  99   default:
 100     // If the code isn't optimized, there may be outstanding folding
 101     // opportunities. Attempt to fold the expression using DataLayout as a
 102     // last resort before giving up.
 103     if (Constant *C =
 104         ConstantFoldConstantExpression(CE, AP.TM.getDataLayout()))
 105       if (C != CE)
 106         return LowerConstant(C, AP);
 107
 108     // Otherwise report the problem to the user.
 109     {
 110         std::string S;
 111         raw_string_ostream OS(S);
 112         OS << "Unsupported expression in static initializer: ";
 113         WriteAsOperand(OS, CE, /*PrintType=*/false,
 114                        !AP.MF ? 0 : AP.MF->getFunction()->getParent());
 115         report_fatal_error(OS.str());
 116     }
 117   case Instruction::GetElementPtr: {
 118     const DataLayout &TD = *AP.TM.getDataLayout();
 119     // Generate a symbolic expression for the byte address
 120     const Constant *PtrVal = CE->getOperand(0);
 121     SmallVector<Value*, 8> IdxVec(CE->op_begin()+1, CE->op_end());
 122     int64_t Offset = TD.getIndexedOffset(PtrVal->getType(), IdxVec);
 123
 124     const MCExpr *Base = LowerConstant(CE->getOperand(0), AP);
 125     if (Offset == 0)
 126       return Base;
 127
 128     // Truncate/sext the offset to the pointer size.
 129     unsigned AS = cast<GetElementPtrInst>(CE)->getPointerAddressSpace();
 130     if (TD.getPointerSizeInBits(AS) != 64) {
 131       int SExtAmount = 64-TD.getPointerSizeInBits(AS);
 132       Offset = (Offset << SExtAmount) >> SExtAmount;
 133     }
 134
 135     return MCBinaryExpr::CreateAdd(Base, MCConstantExpr::Create(Offset, Ctx),
 136                                    Ctx);
 137   }
 138
 139   case Instruction::Trunc:
 140     // We emit the value and depend on the assembler to truncate the generated
 141     // expression properly.  This is important for differences between
 142     // blockaddress labels.  Since the two labels are in the same function, it
 143     // is reasonable to treat their delta as a 32-bit value.
 144     // FALL THROUGH.
 145   case Instruction::BitCast:
 146     return LowerConstant(CE->getOperand(0), AP);
 147
 148   case Instruction::IntToPtr: {
 149     const DataLayout &TD = *AP.TM.getDataLayout();
 150     // Handle casts to pointers by changing them into casts to the appropriate
 151     // integer type.  This promotes constant folding and simplifies this code.
 152     Constant *Op = CE->getOperand(0);
 153     Op = ConstantExpr::getIntegerCast(Op, TD.getIntPtrType(CV->getContext()),
 154                                       false/*ZExt*/);
 155     return LowerConstant(Op, AP);
 156   }
 157
 158   case Instruction::PtrToInt: {
 159     const DataLayout &TD = *AP.TM.getDataLayout();
 160     // Support only foldable casts to/from pointers that can be eliminated by
 161     // changing the pointer to the appropriately sized integer type.
 162     Constant *Op = CE->getOperand(0);
 163     Type *Ty = CE->getType();
 164
 165     const MCExpr *OpExpr = LowerConstant(Op, AP);
 166
 167     // We can emit the pointer value into this slot if the slot is an
 168     // integer slot equal to the size of the pointer.
 169     if (TD.getTypeAllocSize(Ty) == TD.getTypeAllocSize(Op->getType()))
 170       return OpExpr;
 171
 172     // Otherwise the pointer is smaller than the resultant integer, mask off
 173     // the high bits so we are sure to get a proper truncation if the input is
 174     // a constant expr.
 175     unsigned InBits = TD.getTypeAllocSizeInBits(Op->getType());
 176     const MCExpr *MaskExpr = MCConstantExpr::Create(~0ULL >> (64-InBits), Ctx);
 177     return MCBinaryExpr::CreateAnd(OpExpr, MaskExpr, Ctx);
 178   }
 179
 180   // The MC library also has a right-shift operator, but it isn't consistently
 181   // signed or unsigned between different targets.
 182   case Instruction::Add:
 183   case Instruction::Sub:
 184   case Instruction::Mul:
 185   case Instruction::SDiv:
 186   case Instruction::SRem:
 187   case Instruction::Shl:
 188   case Instruction::And:
 189   case Instruction::Or:
 190   case Instruction::Xor: {
 191     const MCExpr *LHS = LowerConstant(CE->getOperand(0), AP);
 192     const MCExpr *RHS = LowerConstant(CE->getOperand(1), AP);
 193     switch (CE->getOpcode()) {
 194     default: llvm_unreachable("Unknown binary operator constant cast expr");
 195     case Instruction::Add: return MCBinaryExpr::CreateAdd(LHS, RHS, Ctx);
 196     case Instruction::Sub: return MCBinaryExpr::CreateSub(LHS, RHS, Ctx);
 197     case Instruction::Mul: return MCBinaryExpr::CreateMul(LHS, RHS, Ctx);
 198     case Instruction::SDiv: return MCBinaryExpr::CreateDiv(LHS, RHS, Ctx);
 199     case Instruction::SRem: return MCBinaryExpr::CreateMod(LHS, RHS, Ctx);
 200     case Instruction::Shl: return MCBinaryExpr::CreateShl(LHS, RHS, Ctx);
 201     case Instruction::And: return MCBinaryExpr::CreateAnd(LHS, RHS, Ctx);
 202     case Instruction::Or:  return MCBinaryExpr::CreateOr (LHS, RHS, Ctx);
 203     case Instruction::Xor: return MCBinaryExpr::CreateXor(LHS, RHS, Ctx);
 204     }
 205   }
 206   }
 207 }
 208
 209
 210 void NVPTXAsmPrinter::emitLineNumberAsDotLoc(const MachineInstr &MI)
 211 {
 212   if (!EmitLineNumbers)
 213     return;
 214   if (ignoreLoc(MI))
 215     return;
 216
 217   DebugLoc curLoc = MI.getDebugLoc();
 218
 219   if (prevDebugLoc.isUnknown() && curLoc.isUnknown())
 220     return;
 221
 222   if (prevDebugLoc == curLoc)
 223     return;
 224
 225   prevDebugLoc = curLoc;
 226
 227   if (curLoc.isUnknown())
 228     return;
 229
 230
 231   const MachineFunction *MF = MI.getParent()->getParent();
 232   //const TargetMachine &TM = MF->getTarget();
 233
 234   const LLVMContext &ctx = MF->getFunction()->getContext();
 235   DIScope Scope(curLoc.getScope(ctx));
 236
 237   if (!Scope.Verify())
 238     return;
 239
 240   StringRef fileName(Scope.getFilename());
 241   StringRef dirName(Scope.getDirectory());
 242   SmallString<128> FullPathName = dirName;
 243   if (!dirName.empty() && !sys::path::is_absolute(fileName)) {
 244     sys::path::append(FullPathName, fileName);
 245     fileName = FullPathName.str();
 246   }
 247
 248   if (filenameMap.find(fileName.str()) == filenameMap.end())
 249     return;
 250
 251
 252   // Emit the line from the source file.
 253   if (llvm::InterleaveSrcInPtx)
 254     this->emitSrcInText(fileName.str(), curLoc.getLine());
 255
 256   std::stringstream temp;
 257   temp << "\t.loc " << filenameMap[fileName.str()]
 258        << " " << curLoc.getLine() << " " << curLoc.getCol();
 259   OutStreamer.EmitRawText(Twine(temp.str().c_str()));
 260 }
 261
 262 void NVPTXAsmPrinter::EmitInstruction(const MachineInstr *MI) {
 263   SmallString<128> Str;
 264   raw_svector_ostream OS(Str);
 265   if (nvptxSubtarget.getDrvInterface() == NVPTX::CUDA)
 266     emitLineNumberAsDotLoc(*MI);
 267   printInstruction(MI, OS);
 268   OutStreamer.EmitRawText(OS.str());
 269 }
 270
 271 void NVPTXAsmPrinter::printReturnValStr(const Function *F,
 272                                         raw_ostream &O)
 273 {
 274   const DataLayout *TD = TM.getDataLayout();
 275   const TargetLowering *TLI = TM.getTargetLowering();
 276
 277   Type *Ty = F->getReturnType();
 278
 279   bool isABI = (nvptxSubtarget.getSmVersion() >= 20);
 280
 281   if (Ty->getTypeID() == Type::VoidTyID)
 282     return;
 283
 284   O << " (";
 285
 286   if (isABI) {
 287     if (Ty->isPrimitiveType() || Ty->isIntegerTy()) {
 288       unsigned size = 0;
 289       if (const IntegerType *ITy = dyn_cast<IntegerType>(Ty)) {
 290         size = ITy->getBitWidth();
 291         if (size < 32) size = 32;
 292       } else {
 293         assert(Ty->isFloatingPointTy() &&
 294                "Floating point type expected here");
 295         size = Ty->getPrimitiveSizeInBits();
 296       }
 297
 298       O << ".param .b" << size << " func_retval0";
 299     }
 300     else if (isa<PointerType>(Ty)) {
 301       O << ".param .b" << TLI->getPointerTy().getSizeInBits()
 302             << " func_retval0";
 303     } else {
 304       if ((Ty->getTypeID() == Type::StructTyID) ||
 305           isa<VectorType>(Ty)) {
 306         SmallVector<EVT, 16> vtparts;
 307         ComputeValueVTs(*TLI, Ty, vtparts);
 308         unsigned totalsz = 0;
 309         for (unsigned i=0,e=vtparts.size(); i!=e; ++i) {
 310           unsigned elems = 1;
 311           EVT elemtype = vtparts[i];
 312           if (vtparts[i].isVector()) {
 313             elems = vtparts[i].getVectorNumElements();
 314             elemtype = vtparts[i].getVectorElementType();
 315           }
 316           for (unsigned j=0, je=elems; j!=je; ++j) {
 317             unsigned sz = elemtype.getSizeInBits();
 318             if (elemtype.isInteger() && (sz < 8)) sz = 8;
 319             totalsz += sz/8;
 320           }
 321         }
 322         unsigned retAlignment = 0;
 323         if (!llvm::getAlign(*F, 0, retAlignment))
 324           retAlignment = TD->getABITypeAlignment(Ty);
 325         O << ".param .align "
 326             << retAlignment
 327             << " .b8 func_retval0["
 328             << totalsz << "]";
 329       } else
 330         assert(false &&
 331                "Unknown return type");
 332     }
 333   } else {
 334     SmallVector<EVT, 16> vtparts;
 335     ComputeValueVTs(*TLI, Ty, vtparts);
 336     unsigned idx = 0;
 337     for (unsigned i=0,e=vtparts.size(); i!=e; ++i) {
 338       unsigned elems = 1;
 339       EVT elemtype = vtparts[i];
 340       if (vtparts[i].isVector()) {
 341         elems = vtparts[i].getVectorNumElements();
 342         elemtype = vtparts[i].getVectorElementType();
 343       }
 344
 345       for (unsigned j=0, je=elems; j!=je; ++j) {
 346         unsigned sz = elemtype.getSizeInBits();
 347         if (elemtype.isInteger() && (sz < 32)) sz = 32;
 348         O << ".reg .b" << sz << " func_retval" << idx;
 349         if (j<je-1) O << ", ";
 350         ++idx;
 351       }
 352       if (i < e-1)
 353         O << ", ";
 354     }
 355   }
 356   O << ") ";
 357   return;
 358 }
 359
 360 void NVPTXAsmPrinter::printReturnValStr(const MachineFunction &MF,
 361                                         raw_ostream &O) {
 362   const Function *F = MF.getFunction();
 363   printReturnValStr(F, O);
 364 }
 365
 366 void NVPTXAsmPrinter::EmitFunctionEntryLabel() {
 367   SmallString<128> Str;
 368   raw_svector_ostream O(Str);
 369
 370   // Set up
 371   MRI = &MF->getRegInfo();
 372   F = MF->getFunction();
 373   emitLinkageDirective(F,O);
 374   if (llvm::isKernelFunction(*F))
 375     O << ".entry ";
 376   else {
 377     O << ".func ";
 378     printReturnValStr(*MF, O);
 379   }
 380
 381   O << *CurrentFnSym;
 382
 383   emitFunctionParamList(*MF, O);
 384
 385   if (llvm::isKernelFunction(*F))
 386     emitKernelFunctionDirectives(*F, O);
 387
 388   OutStreamer.EmitRawText(O.str());
 389
 390   prevDebugLoc = DebugLoc();
 391 }
 392
 393 void NVPTXAsmPrinter::EmitFunctionBodyStart() {
 394   const TargetRegisterInfo &TRI = *TM.getRegisterInfo();
 395   unsigned numRegClasses = TRI.getNumRegClasses();
 396   VRidGlobal2LocalMap = new std::map<unsigned, unsigned>[numRegClasses+1];
 397   OutStreamer.EmitRawText(StringRef("{\n"));
 398   setAndEmitFunctionVirtualRegisters(*MF);
 399
 400   SmallString<128> Str;
 401   raw_svector_ostream O(Str);
 402   emitDemotedVars(MF->getFunction(), O);
 403   OutStreamer.EmitRawText(O.str());
 404 }
 405
 406 void NVPTXAsmPrinter::EmitFunctionBodyEnd() {
 407   OutStreamer.EmitRawText(StringRef("}\n"));
 408   delete []VRidGlobal2LocalMap;
 409 }
 410
 411
 412 void
 413 NVPTXAsmPrinter::emitKernelFunctionDirectives(const Function& F,
 414                                               raw_ostream &O) const {
 415   // If the NVVM IR has some of reqntid* specified, then output
 416   // the reqntid directive, and set the unspecified ones to 1.
 417   // If none of reqntid* is specified, don't output reqntid directive.
 418   unsigned reqntidx, reqntidy, reqntidz;
 419   bool specified = false;
 420   if (llvm::getReqNTIDx(F, reqntidx) == false) reqntidx = 1;
 421   else specified = true;
 422   if (llvm::getReqNTIDy(F, reqntidy) == false) reqntidy = 1;
 423   else specified = true;
 424   if (llvm::getReqNTIDz(F, reqntidz) == false) reqntidz = 1;
 425   else specified = true;
 426
 427   if (specified)
 428     O << ".reqntid " << reqntidx << ", "
 429     << reqntidy << ", " << reqntidz << "\n";
 430
 431   // If the NVVM IR has some of maxntid* specified, then output
 432   // the maxntid directive, and set the unspecified ones to 1.
 433   // If none of maxntid* is specified, don't output maxntid directive.
 434   unsigned maxntidx, maxntidy, maxntidz;
 435   specified = false;
 436   if (llvm::getMaxNTIDx(F, maxntidx) == false) maxntidx = 1;
 437   else specified = true;
 438   if (llvm::getMaxNTIDy(F, maxntidy) == false) maxntidy = 1;
 439   else specified = true;
 440   if (llvm::getMaxNTIDz(F, maxntidz) == false) maxntidz = 1;
 441   else specified = true;
 442
 443   if (specified)
 444     O << ".maxntid " << maxntidx << ", "
 445     << maxntidy << ", " << maxntidz << "\n";
 446
 447   unsigned mincta;
 448   if (llvm::getMinCTASm(F, mincta))
 449     O << ".minnctapersm " << mincta << "\n";
 450 }
 451
 452 void
 453 NVPTXAsmPrinter::getVirtualRegisterName(unsigned vr, bool isVec,
 454                                         raw_ostream &O) {
 455   const TargetRegisterClass * RC = MRI->getRegClass(vr);
 456   unsigned id = RC->getID();
 457
 458   std::map<unsigned, unsigned> &regmap = VRidGlobal2LocalMap[id];
 459   unsigned mapped_vr = regmap[vr];
 460
 461   if (!isVec) {
 462     O << getNVPTXRegClassStr(RC) << mapped_vr;
 463     return;
 464   }
 465   // Vector virtual register
 466   if (getNVPTXVectorSize(RC) == 4)
 467     O << "{"
 468     << getNVPTXRegClassStr(RC) << mapped_vr << "_0, "
 469     << getNVPTXRegClassStr(RC) << mapped_vr << "_1, "
 470     << getNVPTXRegClassStr(RC) << mapped_vr << "_2, "
 471     << getNVPTXRegClassStr(RC) << mapped_vr << "_3"
 472     << "}";
 473   else if (getNVPTXVectorSize(RC) == 2)
 474     O << "{"
 475     << getNVPTXRegClassStr(RC) << mapped_vr << "_0, "
 476     << getNVPTXRegClassStr(RC) << mapped_vr << "_1"
 477     << "}";
 478   else
 479     llvm_unreachable("Unsupported vector size");
 480 }
 481
 482 void
 483 NVPTXAsmPrinter::emitVirtualRegister(unsigned int vr, bool isVec,
 484                                      raw_ostream &O) {
 485   getVirtualRegisterName(vr, isVec, O);
 486 }
 487
 488 void NVPTXAsmPrinter::printVecModifiedImmediate(const MachineOperand &MO,
 489                                                 const char *Modifier,
 490                                                 raw_ostream &O) {
 491   static const char vecelem[] = {'0', '1', '2', '3', '0', '1', '2', '3'};
 492   int Imm = (int)MO.getImm();
 493   if(0 == strcmp(Modifier, "vecelem"))
 494     O << "_" << vecelem[Imm];
 495   else if(0 == strcmp(Modifier, "vecv4comm1")) {
 496     if((Imm < 0) || (Imm > 3))
 497       O << "//";
 498   }
 499   else if(0 == strcmp(Modifier, "vecv4comm2")) {
 500     if((Imm < 4) || (Imm > 7))
 501       O << "//";
 502   }
 503   else if(0 == strcmp(Modifier, "vecv4pos")) {
 504     if(Imm < 0) Imm = 0;
 505     O << "_" << vecelem[Imm%4];
 506   }
 507   else if(0 == strcmp(Modifier, "vecv2comm1")) {
 508     if((Imm < 0) || (Imm > 1))
 509       O << "//";
 510   }
 511   else if(0 == strcmp(Modifier, "vecv2comm2")) {
 512     if((Imm < 2) || (Imm > 3))
 513       O << "//";
 514   }
 515   else if(0 == strcmp(Modifier, "vecv2pos")) {
 516     if(Imm < 0) Imm = 0;
 517     O << "_" << vecelem[Imm%2];
 518   }
 519   else
 520     llvm_unreachable("Unknown Modifier on immediate operand");
 521 }
 522
 523 void NVPTXAsmPrinter::printOperand(const MachineInstr *MI, int opNum,
 524                                    raw_ostream &O, const char *Modifier) {
 525   const MachineOperand &MO = MI->getOperand(opNum);
 526   switch (MO.getType()) {
 527   case MachineOperand::MO_Register:
 528     if (TargetRegisterInfo::isPhysicalRegister(MO.getReg())) {
 529       if (MO.getReg() == NVPTX::VRDepot)
 530         O << DEPOTNAME << getFunctionNumber();
 531       else
 532         O << getRegisterName(MO.getReg());
 533     } else {
 534       if (!Modifier)
 535         emitVirtualRegister(MO.getReg(), false, O);
 536       else {
 537         if (strcmp(Modifier, "vecfull") == 0)
 538           emitVirtualRegister(MO.getReg(), true, O);
 539         else
 540           llvm_unreachable(
 541                  "Don't know how to handle the modifier on virtual register.");
 542       }
 543     }
 544     return;
 545
 546   case MachineOperand::MO_Immediate:
 547     if (!Modifier)
 548       O << MO.getImm();
 549     else if (strstr(Modifier, "vec") == Modifier)
 550       printVecModifiedImmediate(MO, Modifier, O);
 551     else
 552       llvm_unreachable("Don't know how to handle modifier on immediate operand");
 553     return;
 554
 555   case MachineOperand::MO_FPImmediate:
 556     printFPConstant(MO.getFPImm(), O);
 557     break;
 558
 559   case MachineOperand::MO_GlobalAddress:
 560     O << *Mang->getSymbol(MO.getGlobal());
 561     break;
 562
 563   case MachineOperand::MO_ExternalSymbol: {
 564     const char * symbname = MO.getSymbolName();
 565     if (strstr(symbname, ".PARAM") == symbname) {
 566       unsigned index;
 567       sscanf(symbname+6, "%u[];", &index);
 568       printParamName(index, O);
 569     }
 570     else if (strstr(symbname, ".HLPPARAM") == symbname) {
 571       unsigned index;
 572       sscanf(symbname+9, "%u[];", &index);
 573       O << *CurrentFnSym << "_param_" << index << "_offset";
 574     }
 575     else
 576       O << symbname;
 577     break;
 578   }
 579
 580   case MachineOperand::MO_MachineBasicBlock:
 581     O << *MO.getMBB()->getSymbol();
 582     return;
 583
 584   default:
 585     llvm_unreachable("Operand type not supported.");
 586   }
 587 }
 588
 589 void NVPTXAsmPrinter::
 590 printImplicitDef(const MachineInstr *MI, raw_ostream &O) const {
 591 #ifndef __OPTIMIZE__
 592   O << "\t// Implicit def :";
 593   //printOperand(MI, 0);
 594   O << "\n";
 595 #endif
 596 }
 597
 598 void NVPTXAsmPrinter::printMemOperand(const MachineInstr *MI, int opNum,
 599                                       raw_ostream &O, const char *Modifier) {
 600   printOperand(MI, opNum, O);
 601
 602   if (Modifier && !strcmp(Modifier, "add")) {
 603     O << ", ";
 604     printOperand(MI, opNum+1, O);
 605   } else {
 606     if (MI->getOperand(opNum+1).isImm() &&
 607         MI->getOperand(opNum+1).getImm() == 0)
 608       return; // don't print ',0' or '+0'
 609     O << "+";
 610     printOperand(MI, opNum+1, O);
 611   }
 612 }
 613
 614 void NVPTXAsmPrinter::printLdStCode(const MachineInstr *MI, int opNum,
 615                                     raw_ostream &O, const char *Modifier)
 616 {
 617   if (Modifier) {
 618     const MachineOperand &MO = MI->getOperand(opNum);
 619     int Imm = (int)MO.getImm();
 620     if (!strcmp(Modifier, "volatile")) {
 621       if (Imm)
 622         O << ".volatile";
 623     } else if (!strcmp(Modifier, "addsp")) {
 624       switch (Imm) {
 625       case NVPTX::PTXLdStInstCode::GLOBAL: O << ".global"; break;
 626       case NVPTX::PTXLdStInstCode::SHARED: O << ".shared"; break;
 627       case NVPTX::PTXLdStInstCode::LOCAL: O << ".local"; break;
 628       case NVPTX::PTXLdStInstCode::PARAM: O << ".param"; break;
 629       case NVPTX::PTXLdStInstCode::CONSTANT: O << ".const"; break;
 630       case NVPTX::PTXLdStInstCode::GENERIC:
 631         if (!nvptxSubtarget.hasGenericLdSt())
 632           O << ".global";
 633         break;
 634       default:
 635         assert("wrong value");
 636       }
 637     }
 638     else if (!strcmp(Modifier, "sign")) {
 639       if (Imm==NVPTX::PTXLdStInstCode::Signed)
 640         O << "s";
 641       else if (Imm==NVPTX::PTXLdStInstCode::Unsigned)
 642         O << "u";
 643       else
 644         O << "f";
 645     }
 646     else if (!strcmp(Modifier, "vec")) {
 647       if (Imm==NVPTX::PTXLdStInstCode::V2)
 648         O << ".v2";
 649       else if (Imm==NVPTX::PTXLdStInstCode::V4)
 650         O << ".v4";
 651     }
 652     else
 653       assert("unknown modifier");
 654   }
 655   else
 656     assert("unknown modifier");
 657 }
 658
 659 void NVPTXAsmPrinter::emitDeclaration (const Function *F, raw_ostream &O) {
 660
 661   emitLinkageDirective(F,O);
 662   if (llvm::isKernelFunction(*F))
 663     O << ".entry ";
 664   else
 665     O << ".func ";
 666   printReturnValStr(F, O);
 667   O << *CurrentFnSym << "\n";
 668   emitFunctionParamList(F, O);
 669   O << ";\n";
 670 }
 671
 672 static bool usedInGlobalVarDef(const Constant *C)
 673 {
 674   if (!C)
 675     return false;
 676
 677   if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(C)) {
 678     if (GV->getName().str() == "llvm.used")
 679       return false;
 680     return true;
 681   }
 682
 683   for (Value::const_use_iterator ui=C->use_begin(), ue=C->use_end();
 684       ui!=ue; ++ui) {
 685     const Constant *C = dyn_cast<Constant>(*ui);
 686     if (usedInGlobalVarDef(C))
 687       return true;
 688   }
 689   return false;
 690 }
 691
 692 static bool usedInOneFunc(const User *U, Function const *&oneFunc)
 693 {
 694   if (const GlobalVariable *othergv = dyn_cast<GlobalVariable>(U)) {
 695     if (othergv->getName().str() == "llvm.used")
 696       return true;
 697   }
 698
 699   if (const Instruction *instr = dyn_cast<Instruction>(U)) {
 700     if (instr->getParent() && instr->getParent()->getParent()) {
 701       const Function *curFunc = instr->getParent()->getParent();
 702       if (oneFunc && (curFunc != oneFunc))
 703         return false;
 704       oneFunc = curFunc;
 705       return true;
 706     }
 707     else
 708       return false;
 709   }
 710
 711   if (const MDNode *md = dyn_cast<MDNode>(U))
 712     if (md->hasName() && ((md->getName().str() == "llvm.dbg.gv") ||
 713         (md->getName().str() == "llvm.dbg.sp")))
 714       return true;
 715
 716
 717   for (User::const_use_iterator ui=U->use_begin(), ue=U->use_end();
 718       ui!=ue; ++ui) {
 719     if (usedInOneFunc(*ui, oneFunc) == false)
 720       return false;
 721   }
 722   return true;
 723 }
 724
 725 /* Find out if a global variable can be demoted to local scope.
 726  * Currently, this is valid for CUDA shared variables, which have local
 727  * scope and global lifetime. So the conditions to check are :
 728  * 1. Is the global variable in shared address space?
 729  * 2. Does it have internal linkage?
 730  * 3. Is the global variable referenced only in one function?
 731  */
 732 static bool canDemoteGlobalVar(const GlobalVariable *gv, Function const *&f) {
 733   if (gv->hasInternalLinkage() == false)
 734     return false;
 735   const PointerType *Pty = gv->getType();
 736   if (Pty->getAddressSpace() != llvm::ADDRESS_SPACE_SHARED)
 737     return false;
 738
 739   const Function *oneFunc = 0;
 740
 741   bool flag = usedInOneFunc(gv, oneFunc);
 742   if (flag == false)
 743     return false;
 744   if (!oneFunc)
 745     return false;
 746   f = oneFunc;
 747   return true;
 748 }
 749
 750 static bool useFuncSeen(const Constant *C,
 751                         llvm::DenseMap<const Function *, bool> &seenMap) {
 752   for (Value::const_use_iterator ui=C->use_begin(), ue=C->use_end();
 753       ui!=ue; ++ui) {
 754     if (const Constant *cu = dyn_cast<Constant>(*ui)) {
 755       if (useFuncSeen(cu, seenMap))
 756         return true;
 757     } else if (const Instruction *I = dyn_cast<Instruction>(*ui)) {
 758       const BasicBlock *bb = I->getParent();
 759       if (!bb) continue;
 760       const Function *caller = bb->getParent();
 761       if (!caller) continue;
 762       if (seenMap.find(caller) != seenMap.end())
 763         return true;
 764     }
 765   }
 766   return false;
 767 }
 768
 769 void NVPTXAsmPrinter::emitDeclarations (Module &M, raw_ostream &O) {
 770   llvm::DenseMap<const Function *, bool> seenMap;
 771   for (Module::const_iterator FI=M.begin(), FE=M.end();
 772       FI!=FE; ++FI) {
 773     const Function *F = FI;
 774
 775     if (F->isDeclaration()) {
 776       if (F->use_empty())
 777         continue;
 778       if (F->getIntrinsicID())
 779         continue;
 780       CurrentFnSym = Mang->getSymbol(F);
 781       emitDeclaration(F, O);
 782       continue;
 783     }
 784     for (Value::const_use_iterator iter=F->use_begin(),
 785         iterEnd=F->use_end(); iter!=iterEnd; ++iter) {
 786       if (const Constant *C = dyn_cast<Constant>(*iter)) {
 787         if (usedInGlobalVarDef(C)) {
 788           // The use is in the initialization of a global variable
 789           // that is a function pointer, so print a declaration
 790           // for the original function
 791           CurrentFnSym = Mang->getSymbol(F);
 792           emitDeclaration(F, O);
 793           break;
 794         }
 795         // Emit a declaration of this function if the function that
 796         // uses this constant expr has already been seen.
 797         if (useFuncSeen(C, seenMap)) {
 798           CurrentFnSym = Mang->getSymbol(F);
 799           emitDeclaration(F, O);
 800           break;
 801         }
 802       }
 803
 804       if (!isa<Instruction>(*iter)) continue;
 805       const Instruction *instr = cast<Instruction>(*iter);
 806       const BasicBlock *bb = instr->getParent();
 807       if (!bb) continue;
 808       const Function *caller = bb->getParent();
 809       if (!caller) continue;
 810
 811       // If a caller has already been seen, then the caller is
 812       // appearing in the module before the callee. so print out
 813       // a declaration for the callee.
 814       if (seenMap.find(caller) != seenMap.end()) {
 815         CurrentFnSym = Mang->getSymbol(F);
 816         emitDeclaration(F, O);
 817         break;
 818       }
 819     }
 820     seenMap[F] = true;
 821   }
 822 }
 823
 824 void NVPTXAsmPrinter::recordAndEmitFilenames(Module &M) {
 825   DebugInfoFinder DbgFinder;
 826   DbgFinder.processModule(M);
 827
 828   unsigned i=1;
 829   for (DebugInfoFinder::iterator I = DbgFinder.compile_unit_begin(),
 830       E = DbgFinder.compile_unit_end(); I != E; ++I) {
 831     DICompileUnit DIUnit(*I);
 832     StringRef Filename(DIUnit.getFilename());
 833     StringRef Dirname(DIUnit.getDirectory());
 834     SmallString<128> FullPathName = Dirname;
 835     if (!Dirname.empty() && !sys::path::is_absolute(Filename)) {
 836       sys::path::append(FullPathName, Filename);
 837       Filename = FullPathName.str();
 838     }
 839     if (filenameMap.find(Filename.str()) != filenameMap.end())
 840       continue;
 841     filenameMap[Filename.str()] = i;
 842     OutStreamer.EmitDwarfFileDirective(i, "", Filename.str());
 843     ++i;
 844   }
 845
 846   for (DebugInfoFinder::iterator I = DbgFinder.subprogram_begin(),
 847       E = DbgFinder.subprogram_end(); I != E; ++I) {
 848     DISubprogram SP(*I);
 849     StringRef Filename(SP.getFilename());
 850     StringRef Dirname(SP.getDirectory());
 851     SmallString<128> FullPathName = Dirname;
 852     if (!Dirname.empty() && !sys::path::is_absolute(Filename)) {
 853       sys::path::append(FullPathName, Filename);
 854       Filename = FullPathName.str();
 855     }
 856     if (filenameMap.find(Filename.str()) != filenameMap.end())
 857       continue;
 858     filenameMap[Filename.str()] = i;
 859     ++i;
 860   }
 861 }
 862
 863 bool NVPTXAsmPrinter::doInitialization (Module &M) {
 864
 865   SmallString<128> Str1;
 866   raw_svector_ostream OS1(Str1);
 867
 868   MMI = getAnalysisIfAvailable<MachineModuleInfo>();
 869   MMI->AnalyzeModule(M);
 870
 871   // We need to call the parent's one explicitly.
 872   //bool Result = AsmPrinter::doInitialization(M);
 873
 874   // Initialize TargetLoweringObjectFile.
 875   const_cast<TargetLoweringObjectFile&>(getObjFileLowering())
 876           .Initialize(OutContext, TM);
 877
 878   Mang = new Mangler(OutContext, *TM.getDataLayout());
 879
 880   // Emit header before any dwarf directives are emitted below.
 881   emitHeader(M, OS1);
 882   OutStreamer.EmitRawText(OS1.str());
 883
 884
 885   // Already commented out
 886   //bool Result = AsmPrinter::doInitialization(M);
 887
 888
 889   if (nvptxSubtarget.getDrvInterface() == NVPTX::CUDA)
 890     recordAndEmitFilenames(M);
 891
 892   SmallString<128> Str2;
 893   raw_svector_ostream OS2(Str2);
 894
 895   emitDeclarations(M, OS2);
 896
 897   // Print out module-level global variables here.
 898   for (Module::global_iterator I = M.global_begin(), E = M.global_end();
 899       I != E; ++I)
 900     printModuleLevelGV(I, OS2);
 901
 902   OS2 << '\n';
 903
 904   OutStreamer.EmitRawText(OS2.str());
 905   return false;  // success
 906 }
 907
 908 void NVPTXAsmPrinter::emitHeader (Module &M, raw_ostream &O) {
 909   O << "//\n";
 910   O << "// Generated by LLVM NVPTX Back-End\n";
 911   O << "//\n";
 912   O << "\n";
 913
 914   O << ".version 3.0\n";
 915
 916   O << ".target ";
 917   O << nvptxSubtarget.getTargetName();
 918
 919   if (nvptxSubtarget.getDrvInterface() == NVPTX::NVCL)
 920     O << ", texmode_independent";
 921   if (nvptxSubtarget.getDrvInterface() == NVPTX::CUDA) {
 922     if (!nvptxSubtarget.hasDouble())
 923       O << ", map_f64_to_f32";
 924   }
 925
 926   if (MAI->doesSupportDebugInformation())
 927     O << ", debug";
 928
 929   O << "\n";
 930
 931   O << ".address_size ";
 932   if (nvptxSubtarget.is64Bit())
 933     O << "64";
 934   else
 935     O << "32";
 936   O << "\n";
 937
 938   O << "\n";
 939 }
 940
 941 bool NVPTXAsmPrinter::doFinalization(Module &M) {
 942   // XXX Temproarily remove global variables so that doFinalization() will not
 943   // emit them again (global variables are emitted at beginning).
 944
 945   Module::GlobalListType &global_list = M.getGlobalList();
 946   int i, n = global_list.size();
 947   GlobalVariable **gv_array = new GlobalVariable* [n];
 948
 949   // first, back-up GlobalVariable in gv_array
 950   i = 0;
 951   for (Module::global_iterator I = global_list.begin(), E = global_list.end();
 952       I != E; ++I)
 953     gv_array[i++] = &*I;
 954
 955   // second, empty global_list
 956   while (!global_list.empty())
 957     global_list.remove(global_list.begin());
 958
 959   // call doFinalization
 960   bool ret = AsmPrinter::doFinalization(M);
 961
 962   // now we restore global variables
 963   for (i = 0; i < n; i ++)
 964     global_list.insert(global_list.end(), gv_array[i]);
 965
 966   delete[] gv_array;
 967   return ret;
 968
 969
 970   //bool Result = AsmPrinter::doFinalization(M);
 971   // Instead of calling the parents doFinalization, we may
 972   // clone parents doFinalization and customize here.
 973   // Currently, we if NVISA out the EmitGlobals() in
 974   // parent's doFinalization, which is too intrusive.
 975   //
 976   // Same for the doInitialization.
 977   //return Result;
 978 }
 979
 980 // This function emits appropriate linkage directives for
 981 // functions and global variables.
 982 //
 983 // extern function declaration            -> .extern
 984 // extern function definition             -> .visible
 985 // external global variable with init     -> .visible
 986 // external without init                  -> .extern
 987 // appending                              -> not allowed, assert.
 988
 989 void NVPTXAsmPrinter::emitLinkageDirective(const GlobalValue* V, raw_ostream &O)
 990 {
 991   if (nvptxSubtarget.getDrvInterface() == NVPTX::CUDA) {
 992     if (V->hasExternalLinkage()) {
 993       if (isa<GlobalVariable>(V)) {
 994         const GlobalVariable *GVar = cast<GlobalVariable>(V);
 995         if (GVar) {
 996           if (GVar->hasInitializer())
 997             O << ".visible ";
 998           else
 999             O << ".extern ";
1000         }
1001       } else if (V->isDeclaration())
1002         O << ".extern ";
1003       else
1004         O << ".visible ";
1005     } else if (V->hasAppendingLinkage()) {
1006       std::string msg;
1007       msg.append("Error: ");
1008       msg.append("Symbol ");
1009       if (V->hasName())
1010         msg.append(V->getName().str());
1011       msg.append("has unsupported appending linkage type");
1012       llvm_unreachable(msg.c_str());
1013     }
1014   }
1015 }
1016
1017
1018 void NVPTXAsmPrinter::printModuleLevelGV(GlobalVariable* GVar, raw_ostream &O,
1019                                          bool processDemoted) {
1020
1021   // Skip meta data
1022   if (GVar->hasSection()) {
1023     if (GVar->getSection() == "llvm.metadata")
1024       return;
1025   }
1026
1027   const DataLayout *TD = TM.getDataLayout();
1028
1029   // GlobalVariables are always constant pointers themselves.
1030   const PointerType *PTy = GVar->getType();
1031   Type *ETy = PTy->getElementType();
1032
1033   if (GVar->hasExternalLinkage()) {
1034     if (GVar->hasInitializer())
1035       O << ".visible ";
1036     else
1037       O << ".extern ";
1038   }
1039
1040   if (llvm::isTexture(*GVar)) {
1041     O << ".global .texref " << llvm::getTextureName(*GVar) << ";\n";
1042     return;
1043   }
1044
1045   if (llvm::isSurface(*GVar)) {
1046     O << ".global .surfref " << llvm::getSurfaceName(*GVar) << ";\n";
1047     return;
1048   }
1049
1050   if (GVar->isDeclaration()) {
1051     // (extern) declarations, no definition or initializer
1052     // Currently the only known declaration is for an automatic __local
1053     // (.shared) promoted to global.
1054     emitPTXGlobalVariable(GVar, O);
1055     O << ";\n";
1056     return;
1057   }
1058
1059   if (llvm::isSampler(*GVar)) {
1060     O << ".global .samplerref " << llvm::getSamplerName(*GVar);
1061
1062     Constant *Initializer = NULL;
1063     if (GVar->hasInitializer())
1064       Initializer = GVar->getInitializer();
1065     ConstantInt *CI = NULL;
1066     if (Initializer)
1067       CI = dyn_cast<ConstantInt>(Initializer);
1068     if (CI) {
1069       unsigned sample=CI->getZExtValue();
1070
1071       O << " = { ";
1072
1073       for (int i =0, addr=((sample & __CLK_ADDRESS_MASK ) >>
1074           __CLK_ADDRESS_BASE) ; i < 3 ; i++) {
1075         O << "addr_mode_" << i << " = ";
1076         switch (addr) {
1077         case 0: O << "wrap"; break;
1078         case 1: O << "clamp_to_border"; break;
1079         case 2: O << "clamp_to_edge"; break;
1080         case 3: O << "wrap"; break;
1081         case 4: O << "mirror"; break;
1082         }
1083         O <<", ";
1084       }
1085       O << "filter_mode = ";
1086       switch (( sample & __CLK_FILTER_MASK ) >> __CLK_FILTER_BASE ) {
1087       case 0: O << "nearest"; break;
1088       case 1: O << "linear";  break;
1089       case 2: assert ( 0 && "Anisotropic filtering is not supported");
1090       default: O << "nearest"; break;
1091       }
1092       if (!(( sample &__CLK_NORMALIZED_MASK ) >> __CLK_NORMALIZED_BASE)) {
1093         O << ", force_unnormalized_coords = 1";
1094       }
1095       O << " }";
1096     }
1097
1098     O << ";\n";
1099     return;
1100   }
1101
1102   if (GVar->hasPrivateLinkage()) {
1103
1104     if (!strncmp(GVar->getName().data(), "unrollpragma", 12))
1105       return;
1106
1107     // FIXME - need better way (e.g. Metadata) to avoid generating this global
1108     if (!strncmp(GVar->getName().data(), "filename", 8))
1109       return;
1110     if (GVar->use_empty())
1111       return;
1112   }
1113
1114   const Function *demotedFunc = 0;
1115   if (!processDemoted && canDemoteGlobalVar(GVar, demotedFunc)) {
1116     O << "// " << GVar->getName().str() << " has been demoted\n";
1117     if (localDecls.find(demotedFunc) != localDecls.end())
1118       localDecls[demotedFunc].push_back(GVar);
1119     else {
1120       std::vector<GlobalVariable *> temp;
1121       temp.push_back(GVar);
1122       localDecls[demotedFunc] = temp;
1123     }
1124     return;
1125   }
1126
1127   O << ".";
1128   emitPTXAddressSpace(PTy->getAddressSpace(), O);
1129   if (GVar->getAlignment() == 0)
1130     O << " .align " << (int) TD->getPrefTypeAlignment(ETy);
1131   else
1132     O << " .align " << GVar->getAlignment();
1133
1134
1135   if (ETy->isPrimitiveType() || ETy->isIntegerTy() || isa<PointerType>(ETy)) {
1136     O << " .";
1137     O << getPTXFundamentalTypeStr(ETy, false);
1138     O << " ";
1139     O << *Mang->getSymbol(GVar);
1140
1141     // Ptx allows variable initilization only for constant and global state
1142     // spaces.
1143     if (((PTy->getAddressSpace() == llvm::ADDRESS_SPACE_GLOBAL) ||
1144         (PTy->getAddressSpace() == llvm::ADDRESS_SPACE_CONST_NOT_GEN) ||
1145         (PTy->getAddressSpace() == llvm::ADDRESS_SPACE_CONST))
1146         && GVar->hasInitializer()) {
1147       Constant *Initializer = GVar->getInitializer();
1148       if (!Initializer->isNullValue()) {
1149         O << " = " ;
1150         printScalarConstant(Initializer, O);
1151       }
1152     }
1153   } else {
1154     unsigned int ElementSize =0;
1155
1156     // Although PTX has direct support for struct type and array type and
1157     // LLVM IR is very similar to PTX, the LLVM CodeGen does not support for
1158     // targets that support these high level field accesses. Structs, arrays
1159     // and vectors are lowered into arrays of bytes.
1160     switch (ETy->getTypeID()) {
1161     case Type::StructTyID:
1162     case Type::ArrayTyID:
1163     case Type::VectorTyID:
1164       ElementSize = TD->getTypeStoreSize(ETy);
1165       // Ptx allows variable initilization only for constant and
1166       // global state spaces.
1167       if (((PTy->getAddressSpace() == llvm::ADDRESS_SPACE_GLOBAL) ||
1168           (PTy->getAddressSpace() == llvm::ADDRESS_SPACE_CONST_NOT_GEN) ||
1169           (PTy->getAddressSpace() == llvm::ADDRESS_SPACE_CONST))
1170           && GVar->hasInitializer()) {
1171         Constant *Initializer = GVar->getInitializer();
1172         if (!isa<UndefValue>(Initializer) &&
1173             !Initializer->isNullValue()) {
1174           AggBuffer aggBuffer(ElementSize, O, *this);
1175           bufferAggregateConstant(Initializer, &aggBuffer);
1176           if (aggBuffer.numSymbols) {
1177             if (nvptxSubtarget.is64Bit()) {
1178               O << " .u64 " << *Mang->getSymbol(GVar) <<"[" ;
1179               O << ElementSize/8;
1180             }
1181             else {
1182               O << " .u32 " << *Mang->getSymbol(GVar) <<"[" ;
1183               O << ElementSize/4;
1184             }
1185             O << "]";
1186           }
1187           else {
1188             O << " .b8 " << *Mang->getSymbol(GVar) <<"[" ;
1189             O << ElementSize;
1190             O << "]";
1191           }
1192           O << " = {" ;
1193           aggBuffer.print();
1194           O << "}";
1195         }
1196         else {
1197           O << " .b8 " << *Mang->getSymbol(GVar) ;
1198           if (ElementSize) {
1199             O <<"[" ;
1200             O << ElementSize;
1201             O << "]";
1202           }
1203         }
1204       }
1205       else {
1206         O << " .b8 " << *Mang->getSymbol(GVar);
1207         if (ElementSize) {
1208           O <<"[" ;
1209           O << ElementSize;
1210           O << "]";
1211         }
1212       }
1213       break;
1214     default:
1215       assert( 0 && "type not supported yet");
1216     }
1217
1218   }
1219   O << ";\n";
1220 }
1221
1222 void NVPTXAsmPrinter::emitDemotedVars(const Function *f, raw_ostream &O) {
1223   if (localDecls.find(f) == localDecls.end())
1224     return;
1225
1226   std::vector<GlobalVariable *> &gvars = localDecls[f];
1227
1228   for (unsigned i=0, e=gvars.size(); i!=e; ++i) {
1229     O << "\t// demoted variable\n\t";
1230     printModuleLevelGV(gvars[i], O, true);
1231   }
1232 }
1233
1234 void NVPTXAsmPrinter::emitPTXAddressSpace(unsigned int AddressSpace,
1235                                           raw_ostream &O) const {
1236   switch (AddressSpace) {
1237   case llvm::ADDRESS_SPACE_LOCAL:
1238     O << "local" ;
1239     break;
1240   case llvm::ADDRESS_SPACE_GLOBAL:
1241     O << "global" ;
1242     break;
1243   case llvm::ADDRESS_SPACE_CONST:
1244     // This logic should be consistent with that in
1245     // getCodeAddrSpace() (NVPTXISelDATToDAT.cpp)
1246     if (nvptxSubtarget.hasGenericLdSt())
1247       O << "global" ;
1248     else
1249       O << "const" ;
1250     break;
1251   case llvm::ADDRESS_SPACE_CONST_NOT_GEN:
1252     O << "const" ;
1253     break;
1254   case llvm::ADDRESS_SPACE_SHARED:
1255     O << "shared" ;
1256     break;
1257   default:
1258     llvm_unreachable("unexpected address space");
1259   }
1260 }
1261
1262 std::string NVPTXAsmPrinter::getPTXFundamentalTypeStr(const Type *Ty,
1263                                                       bool useB4PTR) const {
1264   switch (Ty->getTypeID()) {
1265   default:
1266     llvm_unreachable("unexpected type");
1267     break;
1268   case Type::IntegerTyID: {
1269     unsigned NumBits = cast<IntegerType>(Ty)->getBitWidth();
1270     if (NumBits == 1)
1271       return "pred";
1272     else if (NumBits <= 64) {
1273       std::string name = "u";
1274       return name + utostr(NumBits);
1275     } else {
1276       llvm_unreachable("Integer too large");
1277       break;
1278     }
1279     break;
1280   }
1281   case Type::FloatTyID:
1282     return "f32";
1283   case Type::DoubleTyID:
1284     return "f64";
1285   case Type::PointerTyID:
1286     if (nvptxSubtarget.is64Bit())
1287       if (useB4PTR) return "b64";
1288       else return "u64";
1289     else
1290       if (useB4PTR) return "b32";
1291       else return "u32";
1292   }
1293   llvm_unreachable("unexpected type");
1294   return NULL;
1295 }
1296
1297 void NVPTXAsmPrinter::emitPTXGlobalVariable(const GlobalVariable* GVar,
1298                                             raw_ostream &O) {
1299
1300   const DataLayout *TD = TM.getDataLayout();
1301
1302   // GlobalVariables are always constant pointers themselves.
1303   const PointerType *PTy = GVar->getType();
1304   Type *ETy = PTy->getElementType();
1305
1306   O << ".";
1307   emitPTXAddressSpace(PTy->getAddressSpace(), O);
1308   if (GVar->getAlignment() == 0)
1309     O << " .align " << (int) TD->getPrefTypeAlignment(ETy);
1310   else
1311     O << " .align " << GVar->getAlignment();
1312
1313   if (ETy->isPrimitiveType() || ETy->isIntegerTy() || isa<PointerType>(ETy)) {
1314     O << " .";
1315     O << getPTXFundamentalTypeStr(ETy);
1316     O << " ";
1317     O << *Mang->getSymbol(GVar);
1318     return;
1319   }
1320
1321   int64_t ElementSize =0;
1322
1323   // Although PTX has direct support for struct type and array type and LLVM IR
1324   // is very similar to PTX, the LLVM CodeGen does not support for targets that
1325   // support these high level field accesses. Structs and arrays are lowered
1326   // into arrays of bytes.
1327   switch (ETy->getTypeID()) {
1328   case Type::StructTyID:
1329   case Type::ArrayTyID:
1330   case Type::VectorTyID:
1331     ElementSize = TD->getTypeStoreSize(ETy);
1332     O << " .b8 " << *Mang->getSymbol(GVar) <<"[" ;
1333     if (ElementSize) {
1334       O << itostr(ElementSize) ;
1335     }
1336     O << "]";
1337     break;
1338   default:
1339     assert( 0 && "type not supported yet");
1340   }
1341   return ;
1342 }
1343
1344
1345 static unsigned int
1346 getOpenCLAlignment(const DataLayout *TD,
1347                    Type *Ty) {
1348   if (Ty->isPrimitiveType() || Ty->isIntegerTy() || isa<PointerType>(Ty))
1349     return TD->getPrefTypeAlignment(Ty);
1350
1351   const ArrayType *ATy = dyn_cast<ArrayType>(Ty);
1352   if (ATy)
1353     return getOpenCLAlignment(TD, ATy->getElementType());
1354
1355   const VectorType *VTy = dyn_cast<VectorType>(Ty);
1356   if (VTy) {
1357     Type *ETy = VTy->getElementType();
1358     unsigned int numE = VTy->getNumElements();
1359     unsigned int alignE = TD->getPrefTypeAlignment(ETy);
1360     if (numE == 3)
1361       return 4*alignE;
1362     else
1363       return numE*alignE;
1364   }
1365
1366   const StructType *STy = dyn_cast<StructType>(Ty);
1367   if (STy) {
1368     unsigned int alignStruct = 1;
1369     // Go through each element of the struct and find the
1370     // largest alignment.
1371     for (unsigned i=0, e=STy->getNumElements(); i != e; i++) {
1372       Type *ETy = STy->getElementType(i);
1373       unsigned int align = getOpenCLAlignment(TD, ETy);
1374       if (align > alignStruct)
1375         alignStruct = align;
1376     }
1377     return alignStruct;
1378   }
1379
1380   const FunctionType *FTy = dyn_cast<FunctionType>(Ty);
1381   if (FTy)
1382     return TD->getPointerPrefAlignment(0);
1383   return TD->getPrefTypeAlignment(Ty);
1384 }
1385
1386 void NVPTXAsmPrinter::printParamName(Function::const_arg_iterator I,
1387                                      int paramIndex, raw_ostream &O) {
1388   if ((nvptxSubtarget.getDrvInterface() == NVPTX::NVCL) ||
1389       (nvptxSubtarget.getDrvInterface() == NVPTX::CUDA))
1390     O << *CurrentFnSym << "_param_" << paramIndex;
1391   else {
1392     std::string argName = I->getName();
1393     const char *p = argName.c_str();
1394     while (*p) {
1395       if (*p == '.')
1396         O << "_";
1397       else
1398         O << *p;
1399       p++;
1400     }
1401   }
1402 }
1403
1404 void NVPTXAsmPrinter::printParamName(int paramIndex, raw_ostream &O) {
1405   Function::const_arg_iterator I, E;
1406   int i = 0;
1407
1408   if ((nvptxSubtarget.getDrvInterface() == NVPTX::NVCL) ||
1409       (nvptxSubtarget.getDrvInterface() == NVPTX::CUDA)) {
1410     O << *CurrentFnSym << "_param_" << paramIndex;
1411     return;
1412   }
1413
1414   for (I = F->arg_begin(), E = F->arg_end(); I != E; ++I, i++) {
1415     if (i==paramIndex) {
1416       printParamName(I, paramIndex, O);
1417       return;
1418     }
1419   }
1420   llvm_unreachable("paramIndex out of bound");
1421 }
1422
1423 void NVPTXAsmPrinter::emitFunctionParamList(const Function *F,
1424                                             raw_ostream &O) {
1425   const DataLayout *TD = TM.getDataLayout();
1426   const AttrListPtr &PAL = F->getAttributes();
1427   const TargetLowering *TLI = TM.getTargetLowering();
1428   Function::const_arg_iterator I, E;
1429   unsigned paramIndex = 0;
1430   bool first = true;
1431   bool isKernelFunc = llvm::isKernelFunction(*F);
1432   bool isABI = (nvptxSubtarget.getSmVersion() >= 20);
1433   MVT thePointerTy = TLI->getPointerTy();
1434
1435   O << "(\n";
1436
1437   for (I = F->arg_begin(), E = F->arg_end(); I != E; ++I, paramIndex++) {
1438     const Type *Ty = I->getType();
1439
1440     if (!first)
1441       O << ",\n";
1442
1443     first = false;
1444
1445     // Handle image/sampler parameters
1446     if (llvm::isSampler(*I) || llvm::isImage(*I)) {
1447       if (llvm::isImage(*I)) {
1448         std::string sname = I->getName();
1449         if (llvm::isImageWriteOnly(*I))
1450           O << "\t.param .surfref " << *CurrentFnSym << "_param_" << paramIndex;
1451         else // Default image is read_only
1452           O << "\t.param .texref " << *CurrentFnSym << "_param_" << paramIndex;
1453       }
1454       else // Should be llvm::isSampler(*I)
1455         O << "\t.param .samplerref " << *CurrentFnSym << "_param_"
1456         << paramIndex;
1457       continue;
1458     }
1459
1460     if (PAL.getParamAttributes(paramIndex+1).
1461           hasAttribute(Attributes::ByVal) == false) {
1462       // Just a scalar
1463       const PointerType *PTy = dyn_cast<PointerType>(Ty);
1464       if (isKernelFunc) {
1465         if (PTy) {
1466           // Special handling for pointer arguments to kernel
1467           O << "\t.param .u" << thePointerTy.getSizeInBits() << " ";
1468
1469           if (nvptxSubtarget.getDrvInterface() != NVPTX::CUDA) {
1470             Type *ETy = PTy->getElementType();
1471             int addrSpace = PTy->getAddressSpace();
1472             switch(addrSpace) {
1473             default:
1474               O << ".ptr ";
1475               break;
1476             case llvm::ADDRESS_SPACE_CONST_NOT_GEN:
1477               O << ".ptr .const ";
1478               break;
1479             case llvm::ADDRESS_SPACE_SHARED:
1480               O << ".ptr .shared ";
1481               break;
1482             case llvm::ADDRESS_SPACE_GLOBAL:
1483             case llvm::ADDRESS_SPACE_CONST:
1484               O << ".ptr .global ";
1485               break;
1486             }
1487             O << ".align " << (int)getOpenCLAlignment(TD, ETy) << " ";
1488           }
1489           printParamName(I, paramIndex, O);
1490           continue;
1491         }
1492
1493         // non-pointer scalar to kernel func
1494         O << "\t.param ."
1495             << getPTXFundamentalTypeStr(Ty) << " ";
1496         printParamName(I, paramIndex, O);
1497         continue;
1498       }
1499       // Non-kernel function, just print .param .b<size> for ABI
1500       // and .reg .b<size> for non ABY
1501       unsigned sz = 0;
1502       if (isa<IntegerType>(Ty)) {
1503         sz = cast<IntegerType>(Ty)->getBitWidth();
1504         if (sz < 32) sz = 32;
1505       }
1506       else if (isa<PointerType>(Ty))
1507         sz = thePointerTy.getSizeInBits();
1508       else
1509         sz = Ty->getPrimitiveSizeInBits();
1510       if (isABI)
1511         O << "\t.param .b" << sz << " ";
1512       else
1513         O << "\t.reg .b" << sz << " ";
1514       printParamName(I, paramIndex, O);
1515       continue;
1516     }
1517
1518     // param has byVal attribute. So should be a pointer
1519     const PointerType *PTy = dyn_cast<PointerType>(Ty);
1520     assert(PTy &&
1521            "Param with byval attribute should be a pointer type");
1522     Type *ETy = PTy->getElementType();
1523
1524     if (isABI || isKernelFunc) {
1525       // Just print .param .b8 .align <a> .param[size];
1526       // <a> = PAL.getparamalignment
1527       // size = typeallocsize of element type
1528       unsigned align = PAL.getParamAlignment(paramIndex+1);
1529       unsigned sz = TD->getTypeAllocSize(ETy);
1530       O << "\t.param .align " << align
1531           << " .b8 ";
1532       printParamName(I, paramIndex, O);
1533       O << "[" << sz << "]";
1534       continue;
1535     } else {
1536       // Split the ETy into constituent parts and
1537       // print .param .b<size> <name> for each part.
1538       // Further, if a part is vector, print the above for
1539       // each vector element.
1540       SmallVector<EVT, 16> vtparts;
1541       ComputeValueVTs(*TLI, ETy, vtparts);
1542       for (unsigned i=0,e=vtparts.size(); i!=e; ++i) {
1543         unsigned elems = 1;
1544         EVT elemtype = vtparts[i];
1545         if (vtparts[i].isVector()) {
1546           elems = vtparts[i].getVectorNumElements();
1547           elemtype = vtparts[i].getVectorElementType();
1548         }
1549
1550         for (unsigned j=0,je=elems; j!=je; ++j) {
1551           unsigned sz = elemtype.getSizeInBits();
1552           if (elemtype.isInteger() && (sz < 32)) sz = 32;
1553           O << "\t.reg .b" << sz << " ";
1554           printParamName(I, paramIndex, O);
1555           if (j<je-1) O << ",\n";
1556           ++paramIndex;
1557         }
1558         if (i<e-1)
1559           O << ",\n";
1560       }
1561       --paramIndex;
1562       continue;
1563     }
1564   }
1565
1566   O << "\n)\n";
1567 }
1568
1569 void NVPTXAsmPrinter::emitFunctionParamList(const MachineFunction &MF,
1570                                             raw_ostream &O) {
1571   const Function *F = MF.getFunction();
1572   emitFunctionParamList(F, O);
1573 }
1574
1575
1576 void NVPTXAsmPrinter::
1577 setAndEmitFunctionVirtualRegisters(const MachineFunction &MF) {
1578   SmallString<128> Str;
1579   raw_svector_ostream O(Str);
1580
1581   // Map the global virtual register number to a register class specific
1582   // virtual register number starting from 1 with that class.
1583   const TargetRegisterInfo *TRI = MF.getTarget().getRegisterInfo();
1584   //unsigned numRegClasses = TRI->getNumRegClasses();
1585
1586   // Emit the Fake Stack Object
1587   const MachineFrameInfo *MFI = MF.getFrameInfo();
1588   int NumBytes = (int) MFI->getStackSize();
1589   if (NumBytes) {
1590     O << "\t.local .align " << MFI->getMaxAlignment() << " .b8 \t"
1591         << DEPOTNAME
1592         << getFunctionNumber() << "[" << NumBytes << "];\n";
1593     if (nvptxSubtarget.is64Bit()) {
1594       O << "\t.reg .b64 \t%SP;\n";
1595       O << "\t.reg .b64 \t%SPL;\n";
1596     }
1597     else {
1598       O << "\t.reg .b32 \t%SP;\n";
1599       O << "\t.reg .b32 \t%SPL;\n";
1600     }
1601   }
1602
1603   // Go through all virtual registers to establish the mapping between the
1604   // global virtual
1605   // register number and the per class virtual register number.
1606   // We use the per class virtual register number in the ptx output.
1607   unsigned int numVRs = MRI->getNumVirtRegs();
1608   for (unsigned i=0; i< numVRs; i++) {
1609     unsigned int vr = TRI->index2VirtReg(i);
1610     const TargetRegisterClass *RC = MRI->getRegClass(vr);
1611     std::map<unsigned, unsigned> &regmap = VRidGlobal2LocalMap[RC->getID()];
1612     int n = regmap.size();
1613     regmap.insert(std::make_pair(vr, n+1));
1614   }
1615
1616   // Emit register declarations
1617   // @TODO: Extract out the real register usage
1618   O << "\t.reg .pred %p<" << NVPTXNumRegisters << ">;\n";
1619   O << "\t.reg .s16 %rc<" << NVPTXNumRegisters << ">;\n";
1620   O << "\t.reg .s16 %rs<" << NVPTXNumRegisters << ">;\n";
1621   O << "\t.reg .s32 %r<" << NVPTXNumRegisters << ">;\n";
1622   O << "\t.reg .s64 %rl<" << NVPTXNumRegisters << ">;\n";
1623   O << "\t.reg .f32 %f<" << NVPTXNumRegisters << ">;\n";
1624   O << "\t.reg .f64 %fl<" << NVPTXNumRegisters << ">;\n";
1625
1626   // Emit declaration of the virtual registers or 'physical' registers for
1627   // each register class
1628   //for (unsigned i=0; i< numRegClasses; i++) {
1629   //    std::map<unsigned, unsigned> &regmap = VRidGlobal2LocalMap[i];
1630   //    const TargetRegisterClass *RC = TRI->getRegClass(i);
1631   //    std::string rcname = getNVPTXRegClassName(RC);
1632   //    std::string rcStr = getNVPTXRegClassStr(RC);
1633   //    //int n = regmap.size();
1634   //    if (!isNVPTXVectorRegClass(RC)) {
1635   //      O << "\t.reg " << rcname << " \t" << rcStr << "<"
1636   //        << NVPTXNumRegisters << ">;\n";
1637   //    }
1638
1639   // Only declare those registers that may be used. And do not emit vector
1640   // registers as
1641   // they are all elementized to scalar registers.
1642   //if (n && !isNVPTXVectorRegClass(RC)) {
1643   //    if (RegAllocNilUsed) {
1644   //        O << "\t.reg " << rcname << " \t" << rcStr << "<" << (n+1)
1645   //          << ">;\n";
1646   //    }
1647   //    else {
1648   //        O << "\t.reg " << rcname << " \t" << StrToUpper(rcStr)
1649   //          << "<" << 32 << ">;\n";
1650   //    }
1651   //}
1652   //}
1653
1654   OutStreamer.EmitRawText(O.str());
1655 }
1656
1657
1658 void NVPTXAsmPrinter::printFPConstant(const ConstantFP *Fp, raw_ostream &O) {
1659   APFloat APF = APFloat(Fp->getValueAPF());  // make a copy
1660   bool ignored;
1661   unsigned int numHex;
1662   const char *lead;
1663
1664   if (Fp->getType()->getTypeID()==Type::FloatTyID) {
1665     numHex = 8;
1666     lead = "0f";
1667     APF.convert(APFloat::IEEEsingle, APFloat::rmNearestTiesToEven,
1668                 &ignored);
1669   } else if (Fp->getType()->getTypeID() == Type::DoubleTyID) {
1670     numHex = 16;
1671     lead = "0d";
1672     APF.convert(APFloat::IEEEdouble, APFloat::rmNearestTiesToEven,
1673                 &ignored);
1674   } else
1675     llvm_unreachable("unsupported fp type");
1676
1677   APInt API = APF.bitcastToAPInt();
1678   std::string hexstr(utohexstr(API.getZExtValue()));
1679   O << lead;
1680   if (hexstr.length() < numHex)
1681     O << std::string(numHex - hexstr.length(), '0');
1682   O << utohexstr(API.getZExtValue());
1683 }
1684
1685 void NVPTXAsmPrinter::printScalarConstant(Constant *CPV, raw_ostream &O) {
1686   if (ConstantInt *CI = dyn_cast<ConstantInt>(CPV)) {
1687     O << CI->getValue();
1688     return;
1689   }
1690   if (ConstantFP *CFP = dyn_cast<ConstantFP>(CPV)) {
1691     printFPConstant(CFP, O);
1692     return;
1693   }
1694   if (isa<ConstantPointerNull>(CPV)) {
1695     O << "0";
1696     return;
1697   }
1698   if (GlobalValue *GVar = dyn_cast<GlobalValue>(CPV)) {
1699     O << *Mang->getSymbol(GVar);
1700     return;
1701   }
1702   if (ConstantExpr *Cexpr = dyn_cast<ConstantExpr>(CPV)) {
1703     Value *v = Cexpr->stripPointerCasts();
1704     if (GlobalValue *GVar = dyn_cast<GlobalValue>(v)) {
1705       O << *Mang->getSymbol(GVar);
1706       return;
1707     } else {
1708       O << *LowerConstant(CPV, *this);
1709       return;
1710     }
1711   }
1712   llvm_unreachable("Not scalar type found in printScalarConstant()");
1713 }
1714
1715
1716 void NVPTXAsmPrinter::bufferLEByte(Constant *CPV, int Bytes,
1717                                    AggBuffer *aggBuffer) {
1718
1719   const DataLayout *TD = TM.getDataLayout();
1720
1721   if (isa<UndefValue>(CPV) || CPV->isNullValue()) {
1722     int s = TD->getTypeAllocSize(CPV->getType());
1723     if (s<Bytes)
1724       s = Bytes;
1725     aggBuffer->addZeros(s);
1726     return;
1727   }
1728
1729   unsigned char *ptr;
1730   switch (CPV->getType()->getTypeID()) {
1731
1732   case Type::IntegerTyID: {
1733     const Type *ETy = CPV->getType();
1734     if ( ETy == Type::getInt8Ty(CPV->getContext()) ){
1735       unsigned char c =
1736           (unsigned char)(dyn_cast<ConstantInt>(CPV))->getZExtValue();
1737       ptr = &c;
1738       aggBuffer->addBytes(ptr, 1, Bytes);
1739     } else if ( ETy == Type::getInt16Ty(CPV->getContext()) ) {
1740       short int16 =
1741           (short)(dyn_cast<ConstantInt>(CPV))->getZExtValue();
1742       ptr = (unsigned char*)&int16;
1743       aggBuffer->addBytes(ptr, 2, Bytes);
1744     } else if ( ETy == Type::getInt32Ty(CPV->getContext()) ) {
1745       if (ConstantInt *constInt = dyn_cast<ConstantInt>(CPV)) {
1746         int int32 =(int)(constInt->getZExtValue());
1747         ptr = (unsigned char*)&int32;
1748         aggBuffer->addBytes(ptr, 4, Bytes);
1749         break;
1750       } else if (ConstantExpr *Cexpr = dyn_cast<ConstantExpr>(CPV)) {
1751         if (ConstantInt *constInt =
1752             dyn_cast<ConstantInt>(ConstantFoldConstantExpression(
1753                 Cexpr, TD))) {
1754           int int32 =(int)(constInt->getZExtValue());
1755           ptr = (unsigned char*)&int32;
1756           aggBuffer->addBytes(ptr, 4, Bytes);
1757           break;
1758         }
1759         if (Cexpr->getOpcode() == Instruction::PtrToInt) {
1760           Value *v = Cexpr->getOperand(0)->stripPointerCasts();
1761           aggBuffer->addSymbol(v);
1762           aggBuffer->addZeros(4);
1763           break;
1764         }
1765       }
1766       llvm_unreachable("unsupported integer const type");
1767     } else if (ETy == Type::getInt64Ty(CPV->getContext()) ) {
1768       if (ConstantInt *constInt = dyn_cast<ConstantInt>(CPV)) {
1769         long long int64 =(long long)(constInt->getZExtValue());
1770         ptr = (unsigned char*)&int64;
1771         aggBuffer->addBytes(ptr, 8, Bytes);
1772         break;
1773       } else if (ConstantExpr *Cexpr = dyn_cast<ConstantExpr>(CPV)) {
1774         if (ConstantInt *constInt = dyn_cast<ConstantInt>(
1775             ConstantFoldConstantExpression(Cexpr, TD))) {
1776           long long int64 =(long long)(constInt->getZExtValue());
1777           ptr = (unsigned char*)&int64;
1778           aggBuffer->addBytes(ptr, 8, Bytes);
1779           break;
1780         }
1781         if (Cexpr->getOpcode() == Instruction::PtrToInt) {
1782           Value *v = Cexpr->getOperand(0)->stripPointerCasts();
1783           aggBuffer->addSymbol(v);
1784           aggBuffer->addZeros(8);
1785           break;
1786         }
1787       }
1788       llvm_unreachable("unsupported integer const type");
1789     } else
1790       llvm_unreachable("unsupported integer const type");
1791     break;
1792   }
1793   case Type::FloatTyID:
1794   case Type::DoubleTyID: {
1795     ConstantFP *CFP = dyn_cast<ConstantFP>(CPV);
1796     const Type* Ty = CFP->getType();
1797     if (Ty == Type::getFloatTy(CPV->getContext())) {
1798       float float32 = (float)CFP->getValueAPF().convertToFloat();
1799       ptr = (unsigned char*)&float32;
1800       aggBuffer->addBytes(ptr, 4, Bytes);
1801     } else if (Ty == Type::getDoubleTy(CPV->getContext())) {
1802       double float64 = CFP->getValueAPF().convertToDouble();
1803       ptr = (unsigned char*)&float64;
1804       aggBuffer->addBytes(ptr, 8, Bytes);
1805     }
1806     else {
1807       llvm_unreachable("unsupported fp const type");
1808     }
1809     break;
1810   }
1811   case Type::PointerTyID: {
1812     if (GlobalValue *GVar = dyn_cast<GlobalValue>(CPV)) {
1813       aggBuffer->addSymbol(GVar);
1814     }
1815     else if (ConstantExpr *Cexpr = dyn_cast<ConstantExpr>(CPV)) {
1816       Value *v = Cexpr->stripPointerCasts();
1817       aggBuffer->addSymbol(v);
1818     }
1819     unsigned int s = TD->getTypeAllocSize(CPV->getType());
1820     aggBuffer->addZeros(s);
1821     break;
1822   }
1823
1824   case Type::ArrayTyID:
1825   case Type::VectorTyID:
1826   case Type::StructTyID: {
1827     if (isa<ConstantArray>(CPV) || isa<ConstantVector>(CPV) ||
1828         isa<ConstantStruct>(CPV)) {
1829       int ElementSize = TD->getTypeAllocSize(CPV->getType());
1830       bufferAggregateConstant(CPV, aggBuffer);
1831       if ( Bytes > ElementSize )
1832         aggBuffer->addZeros(Bytes-ElementSize);
1833     }
1834     else if (isa<ConstantAggregateZero>(CPV))
1835       aggBuffer->addZeros(Bytes);
1836     else
1837       llvm_unreachable("Unexpected Constant type");
1838     break;
1839   }
1840
1841   default:
1842     llvm_unreachable("unsupported type");
1843   }
1844 }
1845
1846 void NVPTXAsmPrinter::bufferAggregateConstant(Constant *CPV,
1847                                               AggBuffer *aggBuffer) {
1848   const DataLayout *TD = TM.getDataLayout();
1849   int Bytes;
1850
1851   // Old constants
1852   if (isa<ConstantArray>(CPV) || isa<ConstantVector>(CPV)) {
1853     if (CPV->getNumOperands())
1854       for (unsigned i = 0, e = CPV->getNumOperands(); i != e; ++i)
1855         bufferLEByte(cast<Constant>(CPV->getOperand(i)), 0, aggBuffer);
1856     return;
1857   }
1858
1859   if (const ConstantDataSequential *CDS =
1860       dyn_cast<ConstantDataSequential>(CPV)) {
1861     if (CDS->getNumElements())
1862       for (unsigned i = 0; i < CDS->getNumElements(); ++i)
1863         bufferLEByte(cast<Constant>(CDS->getElementAsConstant(i)), 0,
1864                      aggBuffer);
1865     return;
1866   }
1867
1868
1869   if (isa<ConstantStruct>(CPV)) {
1870     if (CPV->getNumOperands()) {
1871       StructType *ST = cast<StructType>(CPV->getType());
1872       for (unsigned i = 0, e = CPV->getNumOperands(); i != e; ++i) {
1873         if ( i == (e - 1))
1874           Bytes = TD->getStructLayout(ST)->getElementOffset(0) +
1875           TD->getTypeAllocSize(ST)
1876           - TD->getStructLayout(ST)->getElementOffset(i);
1877         else
1878           Bytes = TD->getStructLayout(ST)->getElementOffset(i+1) -
1879           TD->getStructLayout(ST)->getElementOffset(i);
1880         bufferLEByte(cast<Constant>(CPV->getOperand(i)), Bytes,
1881                      aggBuffer);
1882       }
1883     }
1884     return;
1885   }
1886   llvm_unreachable("unsupported constant type in printAggregateConstant()");
1887 }
1888
1889 // buildTypeNameMap - Run through symbol table looking for type names.
1890 //
1891
1892
1893 bool NVPTXAsmPrinter::isImageType(const Type *Ty) {
1894
1895   std::map<const Type *, std::string>::iterator PI = TypeNameMap.find(Ty);
1896
1897   if (PI != TypeNameMap.end() &&
1898       (!PI->second.compare("struct._image1d_t") ||
1899           !PI->second.compare("struct._image2d_t") ||
1900           !PI->second.compare("struct._image3d_t")))
1901     return true;
1902
1903   return false;
1904 }
1905
1906 /// PrintAsmOperand - Print out an operand for an inline asm expression.
1907 ///
1908 bool NVPTXAsmPrinter::PrintAsmOperand(const MachineInstr *MI, unsigned OpNo,
1909                                       unsigned AsmVariant,
1910                                       const char *ExtraCode,
1911                                       raw_ostream &O) {
1912   if (ExtraCode && ExtraCode[0]) {
1913     if (ExtraCode[1] != 0) return true; // Unknown modifier.
1914
1915     switch (ExtraCode[0]) {
1916     default:
1917       // See if this is a generic print operand
1918       return AsmPrinter::PrintAsmOperand(MI, OpNo, AsmVariant, ExtraCode, O);
1919     case 'r':
1920       break;
1921     }
1922   }
1923
1924   printOperand(MI, OpNo, O);
1925
1926   return false;
1927 }
1928
1929 bool NVPTXAsmPrinter::PrintAsmMemoryOperand(const MachineInstr *MI,
1930                                             unsigned OpNo,
1931                                             unsigned AsmVariant,
1932                                             const char *ExtraCode,
1933                                             raw_ostream &O) {
1934   if (ExtraCode && ExtraCode[0])
1935     return true;  // Unknown modifier
1936
1937   O << '[';
1938   printMemOperand(MI, OpNo, O);
1939   O << ']';
1940
1941   return false;
1942 }
1943
1944 bool NVPTXAsmPrinter::ignoreLoc(const MachineInstr &MI)
1945 {
1946   switch(MI.getOpcode()) {
1947   default:
1948     return false;
1949   case NVPTX::CallArgBeginInst:  case NVPTX::CallArgEndInst0:
1950   case NVPTX::CallArgEndInst1:  case NVPTX::CallArgF32:
1951   case NVPTX::CallArgF64:  case NVPTX::CallArgI16:
1952   case NVPTX::CallArgI32:  case NVPTX::CallArgI32imm:
1953   case NVPTX::CallArgI64:  case NVPTX::CallArgI8:
1954   case NVPTX::CallArgParam:  case NVPTX::CallVoidInst:
1955   case NVPTX::CallVoidInstReg:  case NVPTX::Callseq_End:
1956   case NVPTX::CallVoidInstReg64:
1957   case NVPTX::DeclareParamInst:  case NVPTX::DeclareRetMemInst:
1958   case NVPTX::DeclareRetRegInst:  case NVPTX::DeclareRetScalarInst:
1959   case NVPTX::DeclareScalarParamInst:  case NVPTX::DeclareScalarRegInst:
1960   case NVPTX::StoreParamF32:  case NVPTX::StoreParamF64:
1961   case NVPTX::StoreParamI16:  case NVPTX::StoreParamI32:
1962   case NVPTX::StoreParamI64:  case NVPTX::StoreParamI8:
1963   case NVPTX::StoreParamS32I8:  case NVPTX::StoreParamU32I8:
1964   case NVPTX::StoreParamS32I16:  case NVPTX::StoreParamU32I16:
1965   case NVPTX::StoreParamScalar2F32:  case NVPTX::StoreParamScalar2F64:
1966   case NVPTX::StoreParamScalar2I16:  case NVPTX::StoreParamScalar2I32:
1967   case NVPTX::StoreParamScalar2I64:  case NVPTX::StoreParamScalar2I8:
1968   case NVPTX::StoreParamScalar4F32:  case NVPTX::StoreParamScalar4I16:
1969   case NVPTX::StoreParamScalar4I32:  case NVPTX::StoreParamScalar4I8:
1970   case NVPTX::StoreParamV2F32:  case NVPTX::StoreParamV2F64:
1971   case NVPTX::StoreParamV2I16:  case NVPTX::StoreParamV2I32:
1972   case NVPTX::StoreParamV2I64:  case NVPTX::StoreParamV2I8:
1973   case NVPTX::StoreParamV4F32:  case NVPTX::StoreParamV4I16:
1974   case NVPTX::StoreParamV4I32:  case NVPTX::StoreParamV4I8:
1975   case NVPTX::StoreRetvalF32:  case NVPTX::StoreRetvalF64:
1976   case NVPTX::StoreRetvalI16:  case NVPTX::StoreRetvalI32:
1977   case NVPTX::StoreRetvalI64:  case NVPTX::StoreRetvalI8:
1978   case NVPTX::StoreRetvalScalar2F32:  case NVPTX::StoreRetvalScalar2F64:
1979   case NVPTX::StoreRetvalScalar2I16:  case NVPTX::StoreRetvalScalar2I32:
1980   case NVPTX::StoreRetvalScalar2I64:  case NVPTX::StoreRetvalScalar2I8:
1981   case NVPTX::StoreRetvalScalar4F32:  case NVPTX::StoreRetvalScalar4I16:
1982   case NVPTX::StoreRetvalScalar4I32:  case NVPTX::StoreRetvalScalar4I8:
1983   case NVPTX::StoreRetvalV2F32:  case NVPTX::StoreRetvalV2F64:
1984   case NVPTX::StoreRetvalV2I16:  case NVPTX::StoreRetvalV2I32:
1985   case NVPTX::StoreRetvalV2I64:  case NVPTX::StoreRetvalV2I8:
1986   case NVPTX::StoreRetvalV4F32:  case NVPTX::StoreRetvalV4I16:
1987   case NVPTX::StoreRetvalV4I32:  case NVPTX::StoreRetvalV4I8:
1988   case NVPTX::LastCallArgF32:  case NVPTX::LastCallArgF64:
1989   case NVPTX::LastCallArgI16:  case NVPTX::LastCallArgI32:
1990   case NVPTX::LastCallArgI32imm:  case NVPTX::LastCallArgI64:
1991   case NVPTX::LastCallArgI8:  case NVPTX::LastCallArgParam:
1992   case NVPTX::LoadParamMemF32:  case NVPTX::LoadParamMemF64:
1993   case NVPTX::LoadParamMemI16:  case NVPTX::LoadParamMemI32:
1994   case NVPTX::LoadParamMemI64:  case NVPTX::LoadParamMemI8:
1995   case NVPTX::LoadParamRegF32:  case NVPTX::LoadParamRegF64:
1996   case NVPTX::LoadParamRegI16:  case NVPTX::LoadParamRegI32:
1997   case NVPTX::LoadParamRegI64:  case NVPTX::LoadParamRegI8:
1998   case NVPTX::LoadParamScalar2F32:  case NVPTX::LoadParamScalar2F64:
1999   case NVPTX::LoadParamScalar2I16:  case NVPTX::LoadParamScalar2I32:
2000   case NVPTX::LoadParamScalar2I64:  case NVPTX::LoadParamScalar2I8:
2001   case NVPTX::LoadParamScalar4F32:  case NVPTX::LoadParamScalar4I16:
2002   case NVPTX::LoadParamScalar4I32:  case NVPTX::LoadParamScalar4I8:
2003   case NVPTX::LoadParamV2F32:  case NVPTX::LoadParamV2F64:
2004   case NVPTX::LoadParamV2I16:  case NVPTX::LoadParamV2I32:
2005   case NVPTX::LoadParamV2I64:  case NVPTX::LoadParamV2I8:
2006   case NVPTX::LoadParamV4F32:  case NVPTX::LoadParamV4I16:
2007   case NVPTX::LoadParamV4I32:  case NVPTX::LoadParamV4I8:
2008   case NVPTX::PrototypeInst:   case NVPTX::DBG_VALUE:
2009     return true;
2010   }
2011   return false;
2012 }
2013
2014 // Force static initialization.
2015 extern "C" void LLVMInitializeNVPTXBackendAsmPrinter() {
2016   RegisterAsmPrinter<NVPTXAsmPrinter> X(TheNVPTXTarget32);
2017   RegisterAsmPrinter<NVPTXAsmPrinter> Y(TheNVPTXTarget64);
2018 }
2019
2020
2021 void NVPTXAsmPrinter::emitSrcInText(StringRef filename, unsigned line) {
2022   std::stringstream temp;
2023   LineReader * reader = this->getReader(filename.str());
2024   temp << "\n//";
2025   temp << filename.str();
2026   temp << ":";
2027   temp << line;
2028   temp << " ";
2029   temp << reader->readLine(line);
2030   temp << "\n";
2031   this->OutStreamer.EmitRawText(Twine(temp.str()));
2032 }
2033
2034
2035 LineReader *NVPTXAsmPrinter::getReader(std::string filename) {
2036   if (reader == NULL)  {
2037     reader =  new LineReader(filename);
2038   }
2039
2040   if (reader->fileName() != filename) {
2041     delete reader;
2042     reader =  new LineReader(filename);
2043   }
2044
2045   return reader;
2046 }
2047
2048
2049 std::string
2050 LineReader::readLine(unsigned lineNum) {
2051   if (lineNum < theCurLine) {
2052     theCurLine = 0;
2053     fstr.seekg(0,std::ios::beg);
2054   }
2055   while (theCurLine < lineNum) {
2056     fstr.getline(buff,500);
2057     theCurLine++;
2058   }
2059   return buff;
2060 }
2061
2062 // Force static initialization.
2063 extern "C" void LLVMInitializeNVPTXAsmPrinter() {
2064   RegisterAsmPrinter<NVPTXAsmPrinter> X(TheNVPTXTarget32);
2065   RegisterAsmPrinter<NVPTXAsmPrinter> Y(TheNVPTXTarget64);
2066 }