6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-03-06 05:33:28 +00:00
Code Issues Projects Releases Wiki Activity

Simplify code. No functionality change.

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@144012 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Benjamin Kramer 2011-11-07 21:00:43 +00:00
parent 32dd4eb204
commit 055a647a9d
1 changed files with 91 additions and 155 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

242
lib/Target/PTX/PTXAsmPrinter.cpp
View File

@ -25,7 +25,6 @@
#include "llvm/Function.h" #include "llvm/Function.h"
#include "llvm/Module.h" #include "llvm/Module.h"
#include "llvm/ADT/SmallString.h" #include "llvm/ADT/SmallString.h"
#include "llvm/ADT/StringExtras.h"
#include "llvm/ADT/Twine.h" #include "llvm/ADT/Twine.h"
#include "llvm/Analysis/DebugInfo.h" #include "llvm/Analysis/DebugInfo.h"
#include "llvm/CodeGen/AsmPrinter.h" #include "llvm/CodeGen/AsmPrinter.h"
@ -139,15 +138,15 @@ void PTXAsmPrinter::EmitStartOfAsmFile(Module &M)
const PTXSubtarget& ST = TM.getSubtarget<PTXSubtarget>(); const PTXSubtarget& ST = TM.getSubtarget<PTXSubtarget>();
// Emit the PTX .version and .target attributes // Emit the PTX .version and .target attributes
OutStreamer.EmitRawText(Twine("\t.version " + ST.getPTXVersionString())); OutStreamer.EmitRawText(Twine("\t.version ") + ST.getPTXVersionString());
OutStreamer.EmitRawText(Twine("\t.target " + ST.getTargetString() + OutStreamer.EmitRawText(Twine("\t.target ") + ST.getTargetString() +
(ST.supportsDouble() ? "" (ST.supportsDouble() ? ""
: ", map_f64_to_f32"))); : ", map_f64_to_f32"));
// .address_size directive is optional, but it must immediately follow // .address_size directive is optional, but it must immediately follow
// the .target directive if present within a module // the .target directive if present within a module
if (ST.supportsPTX23()) { if (ST.supportsPTX23()) {
std::string addrSize = ST.is64Bit() ? "64" : "32"; const char *addrSize = ST.is64Bit() ? "64" : "32";
OutStreamer.EmitRawText(Twine("\t.address_size " + addrSize)); OutStreamer.EmitRawText(Twine("\t.address_size ") + addrSize);
} }
OutStreamer.AddBlankLine(); OutStreamer.AddBlankLine();
@ -179,68 +178,47 @@ void PTXAsmPrinter::EmitFunctionBodyStart() {
const PTXParamManager &PM = MFI->getParamManager(); const PTXParamManager &PM = MFI->getParamManager();
// Print register definitions // Print register definitions
std::string regDefs; SmallString<128> regDefs;
raw_svector_ostream os(regDefs);
unsigned numRegs; unsigned numRegs;
// pred // pred
numRegs = MFI->getNumRegistersForClass(PTX::RegPredRegisterClass); numRegs = MFI->getNumRegistersForClass(PTX::RegPredRegisterClass);
if(numRegs > 0) { if(numRegs > 0)
regDefs += "\t.reg .pred %p<"; os << "\t.reg .pred %p<" << numRegs << ">;\n";
regDefs += utostr(numRegs);
regDefs += ">;\n";
}
// i16 // i16
numRegs = MFI->getNumRegistersForClass(PTX::RegI16RegisterClass); numRegs = MFI->getNumRegistersForClass(PTX::RegI16RegisterClass);
if(numRegs > 0) { if(numRegs > 0)
regDefs += "\t.reg .b16 %rh<"; os << "\t.reg .b16 %rh<" << numRegs << ">;\n";
regDefs += utostr(numRegs);
regDefs += ">;\n";
}
// i32 // i32
numRegs = MFI->getNumRegistersForClass(PTX::RegI32RegisterClass); numRegs = MFI->getNumRegistersForClass(PTX::RegI32RegisterClass);
if(numRegs > 0) { if(numRegs > 0)
regDefs += "\t.reg .b32 %r<"; os << "\t.reg .b32 %r<" << numRegs << ">;\n";
regDefs += utostr(numRegs);
regDefs += ">;\n";
}
// i64 // i64
numRegs = MFI->getNumRegistersForClass(PTX::RegI64RegisterClass); numRegs = MFI->getNumRegistersForClass(PTX::RegI64RegisterClass);
if(numRegs > 0) { if(numRegs > 0)
regDefs += "\t.reg .b64 %rd<"; os << "\t.reg .b64 %rd<" << numRegs << ">;\n";
regDefs += utostr(numRegs);
regDefs += ">;\n";
}
// f32 // f32
numRegs = MFI->getNumRegistersForClass(PTX::RegF32RegisterClass); numRegs = MFI->getNumRegistersForClass(PTX::RegF32RegisterClass);
if(numRegs > 0) { if(numRegs > 0)
regDefs += "\t.reg .f32 %f<"; os << "\t.reg .f32 %f<" << numRegs << ">;\n";
regDefs += utostr(numRegs);
regDefs += ">;\n";
}
// f64 // f64
numRegs = MFI->getNumRegistersForClass(PTX::RegF64RegisterClass); numRegs = MFI->getNumRegistersForClass(PTX::RegF64RegisterClass);
if(numRegs > 0) { if(numRegs > 0)
regDefs += "\t.reg .f64 %fd<"; os << "\t.reg .f64 %fd<" << numRegs << ">;\n";
regDefs += utostr(numRegs);
regDefs += ">;\n";
}
// Local params // Local params
for (PTXParamManager::param_iterator i = PM.local_begin(), e = PM.local_end(); for (PTXParamManager::param_iterator i = PM.local_begin(), e = PM.local_end();
i != e; ++i) { i != e; ++i)
regDefs += "\t.param .b"; os << "\t.param .b" << PM.getParamSize(*i) << ' ' << PM.getParamName(*i)
regDefs += utostr(PM.getParamSize(*i)); << ";\n";
regDefs += " ";
regDefs += PM.getParamName(*i);
regDefs += ";\n";
}
OutStreamer.EmitRawText(Twine(regDefs)); OutStreamer.EmitRawText(os.str());
const MachineFrameInfo* FrameInfo = MF->getFrameInfo(); const MachineFrameInfo* FrameInfo = MF->getFrameInfo();
@ -249,16 +227,13 @@ void PTXAsmPrinter::EmitFunctionBodyStart() {
for (unsigned i = 0, e = FrameInfo->getNumObjects(); i != e; ++i) { for (unsigned i = 0, e = FrameInfo->getNumObjects(); i != e; ++i) {
DEBUG(dbgs() << "Size of object: " << FrameInfo->getObjectSize(i) << "\n"); DEBUG(dbgs() << "Size of object: " << FrameInfo->getObjectSize(i) << "\n");
if (FrameInfo->getObjectSize(i) > 0) { if (FrameInfo->getObjectSize(i) > 0) {
std::string def = "\t.local .align "; OutStreamer.EmitRawText("\t.local .align " +
def += utostr(FrameInfo->getObjectAlignment(i)); Twine(FrameInfo->getObjectAlignment(i)) +
def += " .b8"; " .b8 __local" +
def += " __local"; Twine(i) +
def += utostr(i); "[" +
def += "["; Twine(FrameInfo->getObjectSize(i)) +
def += utostr(FrameInfo->getObjectSize(i)); // Convert to bits "];");
def += "]";
def += ";";
OutStreamer.EmitRawText(Twine(def));
} }
} }
@ -295,32 +270,27 @@ void PTXAsmPrinter::EmitVariableDeclaration(const GlobalVariable *gv) {
assert(gvsym->isUndefined() && "Cannot define a symbol twice!"); 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 // check if it is defined in some other translation unit
if (gv->isDeclaration()) if (gv->isDeclaration())
decl += ".extern "; os << ".extern ";
// state space: e.g., .global // state space: e.g., .global
decl += "."; os << '.' << getStateSpaceName(gv->getType()->getAddressSpace()) << ' ';
decl += getStateSpaceName(gv->getType()->getAddressSpace());
decl += " ";
// alignment (optional) // alignment (optional)
unsigned alignment = gv->getAlignment(); unsigned alignment = gv->getAlignment();
if (alignment != 0) { if (alignment != 0)
decl += ".align "; os << ".align " << gv->getAlignment() << ' ';
decl += utostr(gv->getAlignment());
decl += " ";
}
if (PointerType::classof(gv->getType())) { if (PointerType::classof(gv->getType())) {
PointerType* pointerTy = dyn_cast<PointerType>(gv->getType()); PointerType* pointerTy = dyn_cast<PointerType>(gv->getType());
Type* elementTy = pointerTy->getElementType(); Type* elementTy = pointerTy->getElementType();
if (elementTy->isArrayTy()) if (elementTy->isArrayTy()) {
{
assert(elementTy->isArrayTy() && "Only pointers to arrays are supported"); assert(elementTy->isArrayTy() && "Only pointers to arrays are supported");
ArrayType* arrayTy = dyn_cast<ArrayType>(elementTy); ArrayType* arrayTy = dyn_cast<ArrayType>(elementTy);
@ -329,7 +299,6 @@ void PTXAsmPrinter::EmitVariableDeclaration(const GlobalVariable *gv) {
unsigned numElements = arrayTy->getNumElements(); unsigned numElements = arrayTy->getNumElements();
while (elementTy->isArrayTy()) { while (elementTy->isArrayTy()) {
arrayTy = dyn_cast<ArrayType>(elementTy); arrayTy = dyn_cast<ArrayType>(elementTy);
elementTy = arrayTy->getElementType(); elementTy = arrayTy->getElementType();
@ -338,64 +307,46 @@ void PTXAsmPrinter::EmitVariableDeclaration(const GlobalVariable *gv) {
// FIXME: isPrimitiveType() == false for i16? // FIXME: isPrimitiveType() == false for i16?
assert(elementTy->isSingleValueType() && assert(elementTy->isSingleValueType() &&
"Non-primitive types are not handled"); "Non-primitive types are not handled");
// Find the size of the element in bits // Find the size of the element in bits
unsigned elementSize = elementTy->getPrimitiveSizeInBits(); unsigned elementSize = elementTy->getPrimitiveSizeInBits();
decl += ".b"; os << ".b" << elementSize << ' ' << gvsym->getName()
decl += utostr(elementSize); << '[' << numElements << ']';
decl += " "; } else {
decl += gvsym->getName(); os << ".b8" << gvsym->getName() << "[]";
decl += "[";
decl += utostr(numElements);
decl += "]";
}
else
{
decl += ".b8 ";
decl += gvsym->getName();
decl += "[]";
} }
// handle string constants (assume ConstantArray means string) // handle string constants (assume ConstantArray means string)
if (gv->hasInitializer()) {
if (gv->hasInitializer())
{
const Constant *C = gv->getInitializer(); const Constant *C = gv->getInitializer();
if (const ConstantArray *CA = dyn_cast<ConstantArray>(C)) if (const ConstantArray *CA = dyn_cast<ConstantArray>(C)) {
{ os << " = {";
decl += " = {";
for (unsigned i = 0, e = C->getNumOperands(); i != e; ++i) for (unsigned i = 0, e = C->getNumOperands(); i != e; ++i) {
{ if (i > 0)
if (i > 0) decl += ","; os << ',';
decl += "0x" + os << "0x";
utohexstr(cast<ConstantInt>(CA->getOperand(i))->getZExtValue()); 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 // Note: this is currently the fall-through case and most likely generates
// incorrect code. // incorrect code.
decl += getTypeName(gv->getType()); os << getTypeName(gv->getType()) << ' ' << gvsym->getName();
decl += " ";
decl += gvsym->getName(); if (isa<ArrayType>(gv->getType()) || isa<PointerType>(gv->getType()))
os << "[]";
if (ArrayType::classof(gv->getType()) ||
PointerType::classof(gv->getType()))
decl += "[]";
} }
decl += ";"; os << ';';
OutStreamer.EmitRawText(Twine(decl));
OutStreamer.EmitRawText(os.str());
OutStreamer.AddBlankLine(); OutStreamer.AddBlankLine();
} }
@ -414,43 +365,36 @@ void PTXAsmPrinter::EmitFunctionEntryLabel() {
const PTXSubtarget& ST = TM.getSubtarget<PTXSubtarget>(); const PTXSubtarget& ST = TM.getSubtarget<PTXSubtarget>();
const MachineRegisterInfo& MRI = MF->getRegInfo(); 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) { if (!isKernel) {
decl += " ("; os << " (";
if (ST.useParamSpaceForDeviceArgs()) { if (ST.useParamSpaceForDeviceArgs()) {
for (PTXParamManager::param_iterator i = PM.ret_begin(), e = PM.ret_end(), for (PTXParamManager::param_iterator i = PM.ret_begin(), e = PM.ret_end(),
b = i; i != e; ++i) { b = i; i != e; ++i) {
if (i != b) { if (i != b)
decl += ", "; os << ", ";
}
decl += ".param .b"; os << ".param .b" << PM.getParamSize(*i) << ' ' << PM.getParamName(*i);
decl += utostr(PM.getParamSize(*i));
decl += " ";
decl += PM.getParamName(*i);
} }
} else { } else {
for (PTXMachineFunctionInfo::reg_iterator for (PTXMachineFunctionInfo::reg_iterator
i = MFI->retreg_begin(), e = MFI->retreg_end(), b = i; i = MFI->retreg_begin(), e = MFI->retreg_end(), b = i;
i != e; ++i) { i != e; ++i) {
if (i != b) { if (i != b)
decl += ", "; os << ", ";
}
decl += ".reg ."; os << ".reg ." << getRegisterTypeName(*i, MRI) << ' '
decl += getRegisterTypeName(*i, MRI); << MFI->getRegisterName(*i);
decl += " ";
decl += MFI->getRegisterName(*i);
} }
} }
decl += ")"; os << ')';
} }
// Print function name // Print function name
decl += " "; os << ' ' << CurrentFnSym->getName() << " (";
decl += CurrentFnSym->getName().str();
decl += " (";
const Function *F = MF->getFunction(); const Function *F = MF->getFunction();
@ -458,64 +402,56 @@ void PTXAsmPrinter::EmitFunctionEntryLabel() {
if (isKernel || ST.useParamSpaceForDeviceArgs()) { 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) { b = i; i != e; ++i) {
if (i != b) { if (i != b)
decl += ", "; os << ", ";
}
decl += ".param .b"; os << ".param .b" << PM.getParamSize(*i) << ' ' << PM.getParamName(*i);
decl += utostr(PM.getParamSize(*i));
decl += " ";
decl += PM.getParamName(*i);
}*/ }*/
int Counter = 1; int Counter = 1;
for (Function::const_arg_iterator i = F->arg_begin(), e = F->arg_end(), for (Function::const_arg_iterator i = F->arg_begin(), e = F->arg_end(),
b = i; i != e; ++i) { b = i; i != e; ++i) {
if (i != b) if (i != b)
decl += ", "; os << ", ";
const Type *ArgType = (*i).getType(); const Type *ArgType = (*i).getType();
decl += ".param .b"; os << ".param .b";
if (ArgType->isPointerTy()) { if (ArgType->isPointerTy()) {
if (ST.is64Bit()) if (ST.is64Bit())
decl += "64"; os << "64";
else else
decl += "32"; os << "32";
} else { } else {
decl += utostr(ArgType->getPrimitiveSizeInBits()); os << ArgType->getPrimitiveSizeInBits();
} }
if (ArgType->isPointerTy() && ST.emitPtrAttribute()) { if (ArgType->isPointerTy() && ST.emitPtrAttribute()) {
const PointerType *PtrType = dyn_cast<const PointerType>(ArgType); const PointerType *PtrType = dyn_cast<const PointerType>(ArgType);
decl += " .ptr"; os << " .ptr";
switch (PtrType->getAddressSpace()) { switch (PtrType->getAddressSpace()) {
default: default:
llvm_unreachable("Unknown address space in argument"); llvm_unreachable("Unknown address space in argument");
case PTXStateSpace::Global: case PTXStateSpace::Global:
decl += " .global"; os << " .global";
break; break;
case PTXStateSpace::Shared: case PTXStateSpace::Shared:
decl += " .shared"; os << " .shared";
break; break;
} }
} }
decl += " __param_"; os << " __param_" << Counter++;
decl += utostr(Counter++);
} }
} else { } else {
for (PTXMachineFunctionInfo::reg_iterator for (PTXMachineFunctionInfo::reg_iterator
i = MFI->argreg_begin(), e = MFI->argreg_end(), b = i; i = MFI->argreg_begin(), e = MFI->argreg_end(), b = i;
i != e; ++i) { i != e; ++i) {
if (i != b) { if (i != b)
decl += ", "; os << ", ";
}
decl += ".reg ."; os << ".reg ." << getRegisterTypeName(*i, MRI) << ' '
decl += getRegisterTypeName(*i, MRI); << MFI->getRegisterName(*i);
decl += " ";
decl += MFI->getRegisterName(*i);
} }
} }
decl += ")"; os << ')';
OutStreamer.EmitRawText(Twine(decl)); OutStreamer.EmitRawText(os.str());
} }
unsigned PTXAsmPrinter::GetOrCreateSourceID(StringRef FileName, unsigned PTXAsmPrinter::GetOrCreateSourceID(StringRef FileName,