#include "PTXParamManager.h"
#include "PTXRegisterInfo.h"
#include "PTXTargetMachine.h"
+#include "llvm/Argument.h"
#include "llvm/DerivedTypes.h"
+#include "llvm/Function.h"
#include "llvm/Module.h"
#include "llvm/ADT/SmallString.h"
-#include "llvm/ADT/StringExtras.h"
#include "llvm/ADT/Twine.h"
#include "llvm/Analysis/DebugInfo.h"
#include "llvm/CodeGen/AsmPrinter.h"
static const char PARAM_PREFIX[] = "__param_";
static const char RETURN_PREFIX[] = "__ret_";
-static const char *getRegisterTypeName(unsigned RegNo,
- const MachineRegisterInfo& MRI) {
- const TargetRegisterClass *TRC = MRI.getRegClass(RegNo);
-
-#define TEST_REGCLS(cls, clsstr) \
- if (PTX::cls ## RegisterClass == TRC) return # clsstr;
-
- TEST_REGCLS(RegPred, pred);
- TEST_REGCLS(RegI16, b16);
- TEST_REGCLS(RegI32, b32);
- TEST_REGCLS(RegI64, b64);
- TEST_REGCLS(RegF32, b32);
- TEST_REGCLS(RegF64, b64);
-#undef TEST_REGCLS
-
- llvm_unreachable("Not in any register class!");
- return NULL;
+static const char *getRegisterTypeName(unsigned RegType) {
+ switch (RegType) {
+ default:
+ llvm_unreachable("Unknown register type");
+ case PTXRegisterType::Pred:
+ return ".pred";
+ case PTXRegisterType::B16:
+ return ".b16";
+ case PTXRegisterType::B32:
+ return ".b32";
+ case PTXRegisterType::B64:
+ return ".b64";
+ case PTXRegisterType::F32:
+ return ".f32";
+ case PTXRegisterType::F64:
+ return ".f64";
+ }
}
static const char *getStateSpaceName(unsigned addressSpace) {
switch (addressSpace) {
default: llvm_unreachable("Unknown state space");
- case PTX::GLOBAL: return "global";
- case PTX::CONSTANT: return "const";
- case PTX::LOCAL: return "local";
- case PTX::PARAMETER: return "param";
- case PTX::SHARED: return "shared";
+ case PTXStateSpace::Global: return "global";
+ case PTXStateSpace::Constant: return "const";
+ case PTXStateSpace::Local: return "local";
+ case PTXStateSpace::Parameter: return "param";
+ case PTXStateSpace::Shared: return "shared";
}
- return NULL;
}
static const char *getTypeName(Type* type) {
const PTXSubtarget& ST = TM.getSubtarget<PTXSubtarget>();
// Emit the PTX .version and .target attributes
- OutStreamer.EmitRawText(Twine("\t.version " + ST.getPTXVersionString()));
- OutStreamer.EmitRawText(Twine("\t.target " + ST.getTargetString() +
+ OutStreamer.EmitRawText(Twine("\t.version ") + ST.getPTXVersionString());
+ OutStreamer.EmitRawText(Twine("\t.target ") + ST.getTargetString() +
(ST.supportsDouble() ? ""
- : ", map_f64_to_f32")));
+ : ", map_f64_to_f32"));
// .address_size directive is optional, but it must immediately follow
// the .target directive if present within a module
if (ST.supportsPTX23()) {
- std::string addrSize = ST.is64Bit() ? "64" : "32";
- OutStreamer.EmitRawText(Twine("\t.address_size " + addrSize));
+ const char *addrSize = ST.is64Bit() ? "64" : "32";
+ OutStreamer.EmitRawText(Twine("\t.address_size ") + addrSize);
}
OutStreamer.AddBlankLine();
OutStreamer.AddBlankLine();
+ // declare external functions
+ for (Module::const_iterator i = M.begin(), e = M.end();
+ i != e; ++i)
+ EmitFunctionDeclaration(i);
+
// declare global variables
for (Module::const_global_iterator i = M.global_begin(), e = M.global_end();
i != e; ++i)
const PTXParamManager &PM = MFI->getParamManager();
// Print register definitions
- std::string regDefs;
+ SmallString<128> regDefs;
+ raw_svector_ostream os(regDefs);
unsigned numRegs;
// pred
- numRegs = MFI->getNumRegistersForClass(PTX::RegPredRegisterClass);
- if(numRegs > 0) {
- regDefs += "\t.reg .pred %p<";
- regDefs += utostr(numRegs);
- regDefs += ">;\n";
- }
+ numRegs = MFI->countRegisters(PTXRegisterType::Pred, PTXRegisterSpace::Reg);
+ if(numRegs > 0)
+ os << "\t.reg .pred %p<" << numRegs << ">;\n";
// i16
- numRegs = MFI->getNumRegistersForClass(PTX::RegI16RegisterClass);
- if(numRegs > 0) {
- regDefs += "\t.reg .b16 %rh<";
- regDefs += utostr(numRegs);
- regDefs += ">;\n";
- }
+ numRegs = MFI->countRegisters(PTXRegisterType::B16, PTXRegisterSpace::Reg);
+ if(numRegs > 0)
+ os << "\t.reg .b16 %rh<" << numRegs << ">;\n";
// i32
- numRegs = MFI->getNumRegistersForClass(PTX::RegI32RegisterClass);
- if(numRegs > 0) {
- regDefs += "\t.reg .b32 %r<";
- regDefs += utostr(numRegs);
- regDefs += ">;\n";
- }
+ numRegs = MFI->countRegisters(PTXRegisterType::B32, PTXRegisterSpace::Reg);
+ if(numRegs > 0)
+ os << "\t.reg .b32 %r<" << numRegs << ">;\n";
// i64
- numRegs = MFI->getNumRegistersForClass(PTX::RegI64RegisterClass);
- if(numRegs > 0) {
- regDefs += "\t.reg .b64 %rd<";
- regDefs += utostr(numRegs);
- regDefs += ">;\n";
- }
+ numRegs = MFI->countRegisters(PTXRegisterType::B64, PTXRegisterSpace::Reg);
+ if(numRegs > 0)
+ os << "\t.reg .b64 %rd<" << numRegs << ">;\n";
// f32
- numRegs = MFI->getNumRegistersForClass(PTX::RegF32RegisterClass);
- if(numRegs > 0) {
- regDefs += "\t.reg .f32 %f<";
- regDefs += utostr(numRegs);
- regDefs += ">;\n";
- }
+ numRegs = MFI->countRegisters(PTXRegisterType::F32, PTXRegisterSpace::Reg);
+ if(numRegs > 0)
+ os << "\t.reg .f32 %f<" << numRegs << ">;\n";
// f64
- numRegs = MFI->getNumRegistersForClass(PTX::RegF64RegisterClass);
- if(numRegs > 0) {
- regDefs += "\t.reg .f64 %fd<";
- regDefs += utostr(numRegs);
- regDefs += ">;\n";
- }
+ numRegs = MFI->countRegisters(PTXRegisterType::F64, PTXRegisterSpace::Reg);
+ if(numRegs > 0)
+ os << "\t.reg .f64 %fd<" << numRegs << ">;\n";
// Local params
for (PTXParamManager::param_iterator i = PM.local_begin(), e = PM.local_end();
- i != e; ++i) {
- regDefs += "\t.param .b";
- regDefs += utostr(PM.getParamSize(*i));
- regDefs += " ";
- regDefs += PM.getParamName(*i);
- regDefs += ";\n";
- }
+ i != e; ++i)
+ os << "\t.param .b" << PM.getParamSize(*i) << ' ' << PM.getParamName(*i)
+ << ";\n";
- OutStreamer.EmitRawText(Twine(regDefs));
+ OutStreamer.EmitRawText(os.str());
const MachineFrameInfo* FrameInfo = MF->getFrameInfo();
for (unsigned i = 0, e = FrameInfo->getNumObjects(); i != e; ++i) {
DEBUG(dbgs() << "Size of object: " << FrameInfo->getObjectSize(i) << "\n");
if (FrameInfo->getObjectSize(i) > 0) {
- std::string def = "\t.local .align ";
- def += utostr(FrameInfo->getObjectAlignment(i));
- def += " .b8";
- def += " __local";
- def += utostr(i);
- def += "[";
- def += utostr(FrameInfo->getObjectSize(i)); // Convert to bits
- def += "]";
- def += ";";
- OutStreamer.EmitRawText(Twine(def));
+ OutStreamer.EmitRawText("\t.local .align " +
+ Twine(FrameInfo->getObjectAlignment(i)) +
+ " .b8 __local" +
+ Twine(i) +
+ "[" +
+ Twine(FrameInfo->getObjectSize(i)) +
+ "];");
}
}
}
void PTXAsmPrinter::EmitInstruction(const MachineInstr *MI) {
-#if 0
- std::string str;
- str.reserve(64);
-
- raw_string_ostream OS(str);
-
- DebugLoc DL = MI->getDebugLoc();
- if (!DL.isUnknown()) {
-
- const MDNode *S = DL.getScope(MF->getFunction()->getContext());
-
- // This is taken from DwarfDebug.cpp, which is conveniently not a public
- // LLVM class.
- StringRef Fn;
- StringRef Dir;
- unsigned Src = 1;
- if (S) {
- DIDescriptor Scope(S);
- if (Scope.isCompileUnit()) {
- DICompileUnit CU(S);
- Fn = CU.getFilename();
- Dir = CU.getDirectory();
- } else if (Scope.isFile()) {
- DIFile F(S);
- Fn = F.getFilename();
- Dir = F.getDirectory();
- } else if (Scope.isSubprogram()) {
- DISubprogram SP(S);
- Fn = SP.getFilename();
- Dir = SP.getDirectory();
- } else if (Scope.isLexicalBlock()) {
- DILexicalBlock DB(S);
- Fn = DB.getFilename();
- Dir = DB.getDirectory();
- } else
- assert(0 && "Unexpected scope info");
-
- Src = GetOrCreateSourceID(Fn, Dir);
- }
- OutStreamer.EmitDwarfLocDirective(Src, DL.getLine(), DL.getCol(),
- 0, 0, 0, Fn);
-
- const MCDwarfLoc& MDL = OutContext.getCurrentDwarfLoc();
-
- OS << "\t.loc ";
- OS << utostr(MDL.getFileNum());
- OS << " ";
- OS << utostr(MDL.getLine());
- OS << " ";
- OS << utostr(MDL.getColumn());
- OS << "\n";
- }
-
-
- // Emit predicate
- printPredicateOperand(MI, OS);
-
- // Write instruction to str
- if (MI->getOpcode() == PTX::CALL) {
- printCall(MI, OS);
- } else {
- printInstruction(MI, OS);
- }
- OS << ';';
- OS.flush();
-
- StringRef strref = StringRef(str);
- OutStreamer.EmitRawText(strref);
-#endif
-
MCInst TmpInst;
LowerPTXMachineInstrToMCInst(MI, TmpInst, *this);
OutStreamer.EmitInstruction(TmpInst);
}
-void PTXAsmPrinter::printOperand(const MachineInstr *MI, int opNum,
- raw_ostream &OS) {
- const MachineOperand &MO = MI->getOperand(opNum);
- const PTXMachineFunctionInfo *MFI = MF->getInfo<PTXMachineFunctionInfo>();
-
- switch (MO.getType()) {
- default:
- llvm_unreachable("<unknown operand type>");
- break;
- case MachineOperand::MO_GlobalAddress:
- OS << *Mang->getSymbol(MO.getGlobal());
- break;
- case MachineOperand::MO_Immediate:
- OS << (long) MO.getImm();
- break;
- case MachineOperand::MO_MachineBasicBlock:
- OS << *MO.getMBB()->getSymbol();
- break;
- case MachineOperand::MO_Register:
- OS << MFI->getRegisterName(MO.getReg());
- break;
- case MachineOperand::MO_ExternalSymbol:
- OS << MO.getSymbolName();
- break;
- case MachineOperand::MO_FPImmediate:
- APInt constFP = MO.getFPImm()->getValueAPF().bitcastToAPInt();
- bool isFloat = MO.getFPImm()->getType()->getTypeID() == Type::FloatTyID;
- // Emit 0F for 32-bit floats and 0D for 64-bit doubles.
- if (isFloat) {
- OS << "0F";
- }
- else {
- OS << "0D";
- }
- // Emit the encoded floating-point value.
- if (constFP.getZExtValue() > 0) {
- OS << constFP.toString(16, false);
- }
- else {
- OS << "00000000";
- // If We have a double-precision zero, pad to 8-bytes.
- if (!isFloat) {
- OS << "00000000";
- }
- }
- break;
- }
-}
-
-void PTXAsmPrinter::printMemOperand(const MachineInstr *MI, int opNum,
- raw_ostream &OS, const char *Modifier) {
- printOperand(MI, opNum, OS);
-
- if (MI->getOperand(opNum+1).isImm() && MI->getOperand(opNum+1).getImm() == 0)
- return; // don't print "+0"
-
- OS << "+";
- printOperand(MI, opNum+1, OS);
-}
-
-void PTXAsmPrinter::printReturnOperand(const MachineInstr *MI, int opNum,
- raw_ostream &OS, const char *Modifier) {
- //OS << RETURN_PREFIX << (int) MI->getOperand(opNum).getImm() + 1;
- OS << "__ret";
-}
-
void PTXAsmPrinter::EmitVariableDeclaration(const GlobalVariable *gv) {
// Check to see if this is a special global used by LLVM, if so, emit it.
if (EmitSpecialLLVMGlobal(gv))
assert(gvsym->isUndefined() && "Cannot define a symbol twice!");
- std::string decl;
+ SmallString<128> decl;
+ raw_svector_ostream os(decl);
// check if it is defined in some other translation unit
if (gv->isDeclaration())
- decl += ".extern ";
+ os << ".extern ";
// state space: e.g., .global
- decl += ".";
- decl += getStateSpaceName(gv->getType()->getAddressSpace());
- decl += " ";
+ os << '.' << getStateSpaceName(gv->getType()->getAddressSpace()) << ' ';
// alignment (optional)
unsigned alignment = gv->getAlignment();
- if (alignment != 0) {
- decl += ".align ";
- decl += utostr(gv->getAlignment());
- decl += " ";
- }
+ if (alignment != 0)
+ os << ".align " << gv->getAlignment() << ' ';
if (PointerType::classof(gv->getType())) {
PointerType* pointerTy = dyn_cast<PointerType>(gv->getType());
Type* elementTy = pointerTy->getElementType();
- decl += ".b8 ";
- decl += gvsym->getName();
- decl += "[";
-
- if (elementTy->isArrayTy())
- {
+ if (elementTy->isArrayTy()) {
assert(elementTy->isArrayTy() && "Only pointers to arrays are supported");
ArrayType* arrayTy = dyn_cast<ArrayType>(elementTy);
unsigned numElements = arrayTy->getNumElements();
while (elementTy->isArrayTy()) {
-
arrayTy = dyn_cast<ArrayType>(elementTy);
elementTy = arrayTy->getElementType();
// FIXME: isPrimitiveType() == false for i16?
assert(elementTy->isSingleValueType() &&
- "Non-primitive types are not handled");
+ "Non-primitive types are not handled");
- // Compute the size of the array, in bytes.
- uint64_t arraySize = (elementTy->getPrimitiveSizeInBits() >> 3)
- * numElements;
+ // Find the size of the element in bits
+ unsigned elementSize = elementTy->getPrimitiveSizeInBits();
- decl += utostr(arraySize);
+ os << ".b" << elementSize << ' ' << gvsym->getName()
+ << '[' << numElements << ']';
+ } else {
+ os << ".b8" << gvsym->getName() << "[]";
}
- decl += "]";
-
// handle string constants (assume ConstantArray means string)
-
- if (gv->hasInitializer())
- {
+ if (gv->hasInitializer()) {
const Constant *C = gv->getInitializer();
- if (const ConstantArray *CA = dyn_cast<ConstantArray>(C))
- {
- decl += " = {";
+ if (const ConstantArray *CA = dyn_cast<ConstantArray>(C)) {
+ os << " = {";
- for (unsigned i = 0, e = C->getNumOperands(); i != e; ++i)
- {
- if (i > 0) decl += ",";
+ for (unsigned i = 0, e = C->getNumOperands(); i != e; ++i) {
+ if (i > 0)
+ os << ',';
- decl += "0x" +
- utohexstr(cast<ConstantInt>(CA->getOperand(i))->getZExtValue());
+ os << "0x";
+ os.write_hex(cast<ConstantInt>(CA->getOperand(i))->getZExtValue());
}
- decl += "}";
+ os << '}';
}
}
- }
- else {
+ } else {
// Note: this is currently the fall-through case and most likely generates
// incorrect code.
- decl += getTypeName(gv->getType());
- decl += " ";
-
- decl += gvsym->getName();
+ os << getTypeName(gv->getType()) << ' ' << gvsym->getName();
- if (ArrayType::classof(gv->getType()) ||
- PointerType::classof(gv->getType()))
- decl += "[]";
+ if (isa<ArrayType>(gv->getType()) || isa<PointerType>(gv->getType()))
+ os << "[]";
}
- decl += ";";
-
- OutStreamer.EmitRawText(Twine(decl));
+ os << ';';
+ OutStreamer.EmitRawText(os.str());
OutStreamer.AddBlankLine();
}
void PTXAsmPrinter::EmitFunctionEntryLabel() {
// The function label could have already been emitted if two symbols end up
// conflicting due to asm renaming. Detect this and emit an error.
- if (!CurrentFnSym->isUndefined()) {
+ if (!CurrentFnSym->isUndefined())
report_fatal_error("'" + Twine(CurrentFnSym->getName()) +
"' label emitted multiple times to assembly file");
- return;
- }
const PTXMachineFunctionInfo *MFI = MF->getInfo<PTXMachineFunctionInfo>();
const PTXParamManager &PM = MFI->getParamManager();
const bool isKernel = MFI->isKernel();
const PTXSubtarget& ST = TM.getSubtarget<PTXSubtarget>();
- const MachineRegisterInfo& MRI = MF->getRegInfo();
- std::string decl = isKernel ? ".entry" : ".func";
+ SmallString<128> decl;
+ raw_svector_ostream os(decl);
+ os << (isKernel ? ".entry" : ".func");
if (!isKernel) {
- decl += " (";
+ os << " (";
if (ST.useParamSpaceForDeviceArgs()) {
for (PTXParamManager::param_iterator i = PM.ret_begin(), e = PM.ret_end(),
b = i; i != e; ++i) {
- if (i != b) {
- decl += ", ";
- }
+ if (i != b)
+ os << ", ";
- decl += ".param .b";
- decl += utostr(PM.getParamSize(*i));
- decl += " ";
- decl += PM.getParamName(*i);
+ os << ".param .b" << PM.getParamSize(*i) << ' ' << PM.getParamName(*i);
}
} else {
for (PTXMachineFunctionInfo::reg_iterator
i = MFI->retreg_begin(), e = MFI->retreg_end(), b = i;
i != e; ++i) {
- if (i != b) {
- decl += ", ";
- }
- decl += ".reg .";
- decl += getRegisterTypeName(*i, MRI);
- decl += " ";
- decl += MFI->getRegisterName(*i);
+ if (i != b)
+ os << ", ";
+
+ os << ".reg " << getRegisterTypeName(MFI->getRegisterType(*i)) << ' '
+ << MFI->getRegisterName(*i);
}
}
- decl += ")";
+ os << ')';
}
// Print function name
- decl += " ";
- decl += CurrentFnSym->getName().str();
+ os << ' ' << CurrentFnSym->getName() << " (";
- decl += " (";
+ const Function *F = MF->getFunction();
// Print parameters
if (isKernel || ST.useParamSpaceForDeviceArgs()) {
- for (PTXParamManager::param_iterator i = PM.arg_begin(), e = PM.arg_end(),
+ /*for (PTXParamManager::param_iterator i = PM.arg_begin(), e = PM.arg_end(),
b = i; i != e; ++i) {
- if (i != b) {
- decl += ", ";
- }
+ if (i != b)
+ os << ", ";
- decl += ".param .b";
- decl += utostr(PM.getParamSize(*i));
- decl += " ";
- decl += PM.getParamName(*i);
+ os << ".param .b" << PM.getParamSize(*i) << ' ' << PM.getParamName(*i);
+ }*/
+ int Counter = 1;
+ for (Function::const_arg_iterator i = F->arg_begin(), e = F->arg_end(),
+ b = i; i != e; ++i) {
+ if (i != b)
+ os << ", ";
+ const Type *ArgType = (*i).getType();
+ os << ".param .b";
+ if (ArgType->isPointerTy()) {
+ if (ST.is64Bit())
+ os << "64";
+ else
+ os << "32";
+ } else {
+ os << ArgType->getPrimitiveSizeInBits();
+ }
+ if (ArgType->isPointerTy() && ST.emitPtrAttribute()) {
+ const PointerType *PtrType = dyn_cast<const PointerType>(ArgType);
+ os << " .ptr";
+ switch (PtrType->getAddressSpace()) {
+ default:
+ llvm_unreachable("Unknown address space in argument");
+ case PTXStateSpace::Global:
+ os << " .global";
+ break;
+ case PTXStateSpace::Shared:
+ os << " .shared";
+ break;
+ }
+ }
+ os << " __param_" << Counter++;
}
} else {
for (PTXMachineFunctionInfo::reg_iterator
i = MFI->argreg_begin(), e = MFI->argreg_end(), b = i;
i != e; ++i) {
- if (i != b) {
- decl += ", ";
- }
+ if (i != b)
+ os << ", ";
- decl += ".reg .";
- decl += getRegisterTypeName(*i, MRI);
- decl += " ";
- decl += MFI->getRegisterName(*i);
+ os << ".reg " << getRegisterTypeName(MFI->getRegisterType(*i)) << ' '
+ << MFI->getRegisterName(*i);
}
}
- decl += ")";
-
- OutStreamer.EmitRawText(Twine(decl));
-}
+ os << ')';
-void PTXAsmPrinter::
-printPredicateOperand(const MachineInstr *MI, raw_ostream &O) {
- int i = MI->findFirstPredOperandIdx();
- if (i == -1)
- llvm_unreachable("missing predicate operand");
-
- unsigned reg = MI->getOperand(i).getReg();
- int predOp = MI->getOperand(i+1).getImm();
- const PTXMachineFunctionInfo *MFI = MF->getInfo<PTXMachineFunctionInfo>();
-
- DEBUG(dbgs() << "predicate: (" << reg << ", " << predOp << ")\n");
-
- if (reg != PTX::NoRegister) {
- O << '@';
- if (predOp == PTX::PRED_NEGATE)
- O << '!';
- O << MFI->getRegisterName(reg);
- }
+ OutStreamer.EmitRawText(os.str());
}
-void PTXAsmPrinter::
-printCall(const MachineInstr *MI, raw_ostream &O) {
- O << "\tcall.uni\t";
- // The first two operands are the predicate slot
- unsigned Index = 2;
- while (!MI->getOperand(Index).isGlobal()) {
- if (Index == 2) {
- O << "(";
- } else {
- O << ", ";
- }
- printOperand(MI, Index, O);
- Index++;
- }
-
- if (Index != 2) {
- O << "), ";
- }
-
- assert(MI->getOperand(Index).isGlobal() &&
- "A GlobalAddress must follow the return arguments");
-
- const GlobalValue *Address = MI->getOperand(Index).getGlobal();
- O << Address->getName() << ", (";
- Index++;
-
- while (Index < MI->getNumOperands()) {
- printOperand(MI, Index, O);
- if (Index < MI->getNumOperands()-1) {
- O << ", ";
- }
- Index++;
+void PTXAsmPrinter::EmitFunctionDeclaration(const Function* func)
+{
+ const PTXSubtarget& ST = TM.getSubtarget<PTXSubtarget>();
+
+ std::string decl = "";
+
+ // hard-coded emission of extern vprintf function
+
+ if (func->getName() == "printf" || func->getName() == "puts") {
+ decl += ".extern .func (.param .b32 __param_1) vprintf (.param .b";
+ if (ST.is64Bit())
+ decl += "64";
+ else
+ decl += "32";
+ decl += " __param_2, .param .b";
+ if (ST.is64Bit())
+ decl += "64";
+ else
+ decl += "32";
+ decl += " __param_3)\n";
}
-
- O << ")";
+
+ OutStreamer.EmitRawText(Twine(decl));
}
unsigned PTXAsmPrinter::GetOrCreateSourceID(StringRef FileName,
Entry.setValue(SrcId);
// Print out a .file directive to specify files for .loc directives.
- OutStreamer.EmitDwarfFileDirective(SrcId, Entry.getKey());
+ OutStreamer.EmitDwarfFileDirective(SrcId, "", Entry.getKey());
return SrcId;
}
return MCOperand::CreateExpr(Expr);
}
-bool PTXAsmPrinter::lowerOperand(const MachineOperand &MO, MCOperand &MCOp) {
+MCOperand PTXAsmPrinter::lowerOperand(const MachineOperand &MO) {
+ MCOperand MCOp;
const PTXMachineFunctionInfo *MFI = MF->getInfo<PTXMachineFunctionInfo>();
- const MCExpr *Expr;
- const char *RegSymbolName;
+ unsigned EncodedReg;
switch (MO.getType()) {
default:
llvm_unreachable("Unknown operand type");
case MachineOperand::MO_Register:
- // We create register operands as symbols, since the PTXInstPrinter class
- // has no way to map virtual registers back to a name without some ugly
- // hacks.
- // FIXME: Figure out a better way to handle virtual register naming.
- RegSymbolName = MFI->getRegisterName(MO.getReg());
- Expr = MCSymbolRefExpr::Create(RegSymbolName, MCSymbolRefExpr::VK_None,
- OutContext);
- MCOp = MCOperand::CreateExpr(Expr);
+ if (MO.getReg() > 0) {
+ // Encode the register
+ EncodedReg = MFI->getEncodedRegister(MO.getReg());
+ } else {
+ EncodedReg = 0;
+ }
+ MCOp = MCOperand::CreateReg(EncodedReg);
break;
case MachineOperand::MO_Immediate:
MCOp = MCOperand::CreateImm(MO.getImm());
break;
}
- return true;
+ return MCOp;
}
// Force static initialization.
RegisterAsmPrinter<PTXAsmPrinter> X(ThePTX32Target);
RegisterAsmPrinter<PTXAsmPrinter> Y(ThePTX64Target);
}
-
projects / oota-llvm.git / blobdiff