6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-01-19 04:32:19 +00:00
Code Issues Projects Releases Wiki Activity

Add AsmPrinter::ConstantExprToString, which writes out a ConstantExpr

Browse Source 
as an expression.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@3442 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Vikram S. Adve 2002-08-22 02:58:36 +00:00
parent 30a6f49f09
commit e99941a931
1 changed files with 74 additions and 1 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

75
lib/Target/SparcV9/SparcV9AsmPrinter.cpp
View File

@ -185,6 +185,74 @@ public:
assert(0 && "Unexpected type of GlobalValue!");
return "";
}
// ConstantExprToString() - Convert a ConstantExpr to a C expression, and
// return this as a string.
//
std::string ConstantExprToString(const ConstantExpr* CE,
const TargetMachine& target) {
std::string S("");
switch(CE->getOpcode()) {
case Instruction::GetElementPtr:
{
const Value* ptrVal = CE->getOperand(0);
valToExprString(ptrVal, target, S);
std::vector<Value*> idxVec = CE->copyOperands();
idxVec.erase(idxVec.begin());
uint64_t byteOffset = target.DataLayout.getIndexedOffset(ptrVal->getType(),
idxVec);
uint64_t eltSize = target.DataLayout.getTypeSize(
cast<PointerType>(ptrVal->getType())->getElementType());
S += " + " + utostr(byteOffset / eltSize);
break;
}
default:
assert(0 && "Unsupported operator in ConstantExprToString()");
break;
}
return S;
}
// valToExprString - Helper function for ConstantExprToString().
// Appends result to argument string S.
//
void valToExprString(const Value* V, const TargetMachine& target,
std::string& S) {
bool failed = false;
if (const Constant* CV = dyn_cast<Constant>(V)) { // symbolic or known
if (const ConstantBool *CB = dyn_cast<ConstantBool>(CV))
S += std::string(CB == ConstantBool::True ? "1" : "0");
else if (const ConstantSInt *CI = dyn_cast<ConstantSInt>(CV))
S += itostr(CI->getValue());
else if (const ConstantUInt *CI = dyn_cast<ConstantUInt>(CV))
S += utostr(CI->getValue());
else if (const ConstantFP *CFP = dyn_cast<ConstantFP>(CV))
S += ftostr(CFP->getValue());
else if (isa<ConstantPointerNull>(CV))
S += "0";
else if (const ConstantPointerRef *CPR = dyn_cast<ConstantPointerRef>(CV))
valToExprString(CPR->getValue(), target, S);
else if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(CV))
S += ConstantExprToString(CE, target);
else
failed = true;
} else if (const GlobalValue* GV = dyn_cast<GlobalValue>(V)) {
S += getID(GV);
}
else
failed = true;
if (failed) {
assert(0 && "Cannot convert value to string");
S += "<illegal-value>";
}
}
};
@ -546,6 +614,7 @@ ArrayTypeIsString(const ArrayType* arrayType)
arrayType->getElementType() == Type::SByteTy);
}
inline const string
TypeToDataDirective(const Type* type)
{
@ -670,9 +739,13 @@ SparcModuleAsmPrinter::printSingleConstant(const Constant* CV)
toAsm << getID(CPR->getValue()) << "\n";
}
else if (isa<ConstantPointerNull>(CV))
{
{ // Null pointer value
toAsm << "0\n";
}
else if (const ConstantExpr* CE = dyn_cast<ConstantExpr>(CV))
{ // Constant expression built from operators, constants, and symbolic addrs
toAsm << ConstantExprToString(CE, Target) << "\n";
}
else
{
assert(0 && "Unknown elementary type for constant");