[llvm-commits] CVS: llvm/lib/Target/SparcV9/SparcV9AsmPrinter.cpp
Brian Gaeke
gaeke at cs.uiuc.edu
Fri Sep 10 11:01:59 PDT 2004
Changes in directory llvm/lib/Target/SparcV9:
SparcV9AsmPrinter.cpp updated: 1.121 -> 1.122
---
Log message:
Roll back constant printing changes until the problems with larger
programs and C++ can be looked at in detail.
---
Diffs of the changes: (+434 -35)
Index: llvm/lib/Target/SparcV9/SparcV9AsmPrinter.cpp
diff -u llvm/lib/Target/SparcV9/SparcV9AsmPrinter.cpp:1.121 llvm/lib/Target/SparcV9/SparcV9AsmPrinter.cpp:1.122
--- llvm/lib/Target/SparcV9/SparcV9AsmPrinter.cpp:1.121 Wed Sep 1 17:55:36 2004
+++ llvm/lib/Target/SparcV9/SparcV9AsmPrinter.cpp Fri Sep 10 13:01:45 2004
@@ -23,7 +23,6 @@
#include "llvm/Module.h"
#include "llvm/Pass.h"
#include "llvm/Assembly/Writer.h"
-#include "llvm/CodeGen/AsmPrinter.h"
#include "llvm/CodeGen/MachineConstantPool.h"
#include "llvm/CodeGen/MachineFunction.h"
#include "llvm/CodeGen/MachineInstr.h"
@@ -37,45 +36,203 @@
namespace {
Statistic<> EmittedInsts("asm-printer", "Number of machine instrs printed");
-}
+
+ //===--------------------------------------------------------------------===//
+ // Utility functions
+
+ /// getAsCString - Return the specified array as a C compatible string, only
+ /// if the predicate isString() is true.
+ ///
+ std::string getAsCString(const ConstantArray *CVA) {
+ assert(CVA->isString() && "Array is not string compatible!");
+
+ std::string Result = "\"";
+ for (unsigned i = 0; i != CVA->getNumOperands(); ++i) {
+ unsigned char C = cast<ConstantInt>(CVA->getOperand(i))->getRawValue();
+
+ if (C == '"') {
+ Result += "\\\"";
+ } else if (C == '\\') {
+ Result += "\\\\";
+ } else if (isprint(C)) {
+ Result += C;
+ } else {
+ Result += '\\'; // print all other chars as octal value
+ // Convert C to octal representation
+ Result += ((C >> 6) & 7) + '0';
+ Result += ((C >> 3) & 7) + '0';
+ Result += ((C >> 0) & 7) + '0';
+ }
+ }
+ Result += "\"";
+
+ return Result;
+ }
+
+ inline bool ArrayTypeIsString(const ArrayType* arrayType) {
+ return (arrayType->getElementType() == Type::UByteTy ||
+ arrayType->getElementType() == Type::SByteTy);
+ }
+
+ unsigned findOptimalStorageSize(const TargetMachine &TM, const Type *Ty) {
+ // All integer types smaller than ints promote to 4 byte integers.
+ if (Ty->isIntegral() && Ty->getPrimitiveSize() < 4)
+ return 4;
+
+ return TM.getTargetData().getTypeSize(Ty);
+ }
+
+
+ inline const std::string
+ TypeToDataDirective(const Type* type) {
+ switch(type->getTypeID()) {
+ case Type::BoolTyID: case Type::UByteTyID: case Type::SByteTyID:
+ return ".byte";
+ case Type::UShortTyID: case Type::ShortTyID:
+ return ".half";
+ case Type::UIntTyID: case Type::IntTyID:
+ return ".word";
+ case Type::ULongTyID: case Type::LongTyID: case Type::PointerTyID:
+ return ".xword";
+ case Type::FloatTyID:
+ return ".word";
+ case Type::DoubleTyID:
+ return ".xword";
+ case Type::ArrayTyID:
+ if (ArrayTypeIsString((ArrayType*) type))
+ return ".ascii";
+ else
+ return "<InvaliDataTypeForPrinting>";
+ default:
+ return "<InvaliDataTypeForPrinting>";
+ }
+ }
+
+ /// Get the size of the constant for the given target.
+ /// If this is an unsized array, return 0.
+ ///
+ inline unsigned int
+ ConstantToSize(const Constant* CV, const TargetMachine& target) {
+ if (const ConstantArray* CVA = dyn_cast<ConstantArray>(CV)) {
+ const ArrayType *aty = cast<ArrayType>(CVA->getType());
+ if (ArrayTypeIsString(aty))
+ return 1 + CVA->getNumOperands();
+ }
+
+ return findOptimalStorageSize(target, CV->getType());
+ }
+
+ /// Align data larger than one L1 cache line on L1 cache line boundaries.
+ /// Align all smaller data on the next higher 2^x boundary (4, 8, ...).
+ ///
+ inline unsigned int
+ SizeToAlignment(unsigned int size, const TargetMachine& target) {
+ const unsigned short cacheLineSize = 16;
+ if (size > (unsigned) cacheLineSize / 2)
+ return cacheLineSize;
+ else
+ for (unsigned sz=1; /*no condition*/; sz *= 2)
+ if (sz >= size)
+ return sz;
+ }
+
+ /// Get the size of the type and then use SizeToAlignment.
+ ///
+ inline unsigned int
+ TypeToAlignment(const Type* type, const TargetMachine& target) {
+ return SizeToAlignment(findOptimalStorageSize(target, type), target);
+ }
+
+ /// Get the size of the constant and then use SizeToAlignment.
+ /// Handles strings as a special case;
+ inline unsigned int
+ ConstantToAlignment(const Constant* CV, const TargetMachine& target) {
+ if (const ConstantArray* CVA = dyn_cast<ConstantArray>(CV))
+ if (ArrayTypeIsString(cast<ArrayType>(CVA->getType())))
+ return SizeToAlignment(1 + CVA->getNumOperands(), target);
+
+ return TypeToAlignment(CV->getType(), target);
+ }
+
+} // End anonymous namespace
namespace {
- struct SparcV9AsmPrinter : public AsmPrinter {
+ enum Sections {
+ Unknown,
+ Text,
+ ReadOnlyData,
+ InitRWData,
+ ZeroInitRWData,
+ };
+
+ class AsmPrinter {
+ // Mangle symbol names appropriately
+ Mangler *Mang;
+
public:
- enum Sections {
- Unknown,
- Text,
- ReadOnlyData,
- InitRWData,
- ZeroInitRWData,
- } CurSection;
-
- SparcV9AsmPrinter(std::ostream &OS, TargetMachine &TM)
- : AsmPrinter(OS, TM), CurSection(Unknown) {
- ZeroDirective = 0; // No way to get zeros.
- Data16bitsDirective = "\t.half\t";
- Data32bitsDirective = "\t.word\t";
- Data64bitsDirective = "\t.xword\t";
- CommentString = "!";
+ std::ostream &O;
+ const TargetMachine &TM;
+
+ enum Sections CurSection;
+
+ AsmPrinter(std::ostream &os, const TargetMachine &T)
+ : /* idTable(0), */ O(os), TM(T), CurSection(Unknown) {}
+
+ ~AsmPrinter() {
+ delete Mang;
}
- const char *getPassName() const {
- return "SparcV9 Assembly Printer";
+ // (start|end)(Module|Function) - Callback methods invoked by subclasses
+ void startModule(Module &M) {
+ Mang = new Mangler(M);
+ }
+
+ void PrintZeroBytesToPad(int numBytes) {
+ //
+ // Always use single unsigned bytes for padding. We don't know upon
+ // what data size the beginning address is aligned, so using anything
+ // other than a byte may cause alignment errors in the assembler.
+ //
+ while (numBytes--)
+ printSingleConstantValue(Constant::getNullValue(Type::UByteTy));
}
+ /// Print a single constant value.
+ ///
+ void printSingleConstantValue(const Constant* CV);
+
+ /// Print a constant value or values (it may be an aggregate).
+ /// Uses printSingleConstantValue() to print each individual value.
+ ///
+ void printConstantValueOnly(const Constant* CV, int numPadBytesAfter = 0);
+
// Print a constant (which may be an aggregate) prefixed by all the
// appropriate directives. Uses printConstantValueOnly() to print the
// value or values.
- void printConstant(const Constant* CV, const std::string &valID) {
- emitAlignment(TM.getTargetData().getTypeAlignmentShift(CV->getType()));
+ void printConstant(const Constant* CV, std::string valID = "") {
+ if (valID.length() == 0)
+ valID = getID(CV);
+
+ O << "\t.align\t" << ConstantToAlignment(CV, TM) << "\n";
+
+ // Print .size and .type only if it is not a string.
+ if (const ConstantArray *CVA = dyn_cast<ConstantArray>(CV))
+ if (CVA->isString()) {
+ // print it as a string and return
+ O << valID << ":\n";
+ O << "\t" << ".ascii" << "\t" << getAsCString(CVA) << "\n";
+ return;
+ }
+
O << "\t.type" << "\t" << valID << ",#object\n";
- unsigned constSize = TM.getTargetData().getTypeSize(CV->getType());
- O << "\t.size" << "\t" << valID << "," << constSize << "\n";
+ unsigned int constSize = ConstantToSize(CV, TM);
+ if (constSize)
+ O << "\t.size" << "\t" << valID << "," << constSize << "\n";
O << valID << ":\n";
- emitGlobalConstant(CV);
+ printConstantValueOnly(CV);
}
// enterSection - Use this method to enter a different section of the output
@@ -122,19 +279,258 @@
return "";
}
- virtual bool runOnMachineFunction(MachineFunction &MF) {
- setupMachineFunction(MF);
- emitFunction(MF);
+ // Combines expressions
+ inline std::string ConstantArithExprToString(const ConstantExpr* CE,
+ const TargetMachine &TM,
+ const std::string &op) {
+ return "(" + valToExprString(CE->getOperand(0), TM) + op
+ + valToExprString(CE->getOperand(1), TM) + ")";
+ }
+
+ /// ConstantExprToString() - Convert a ConstantExpr to an asm expression
+ /// and return this as a string.
+ ///
+ std::string ConstantExprToString(const ConstantExpr* CE,
+ const TargetMachine& target);
+
+ /// valToExprString - Helper function for ConstantExprToString().
+ /// Appends result to argument string S.
+ ///
+ std::string valToExprString(const Value* V, const TargetMachine& target);
+ };
+} // End anonymous namespace
+
+
+/// Print a single constant value.
+///
+void AsmPrinter::printSingleConstantValue(const Constant* CV) {
+ assert(CV->getType() != Type::VoidTy &&
+ CV->getType() != Type::LabelTy &&
+ "Unexpected type for Constant");
+
+ assert((!isa<ConstantArray>(CV) && ! isa<ConstantStruct>(CV))
+ && "Aggregate types should be handled outside this function");
+
+ O << "\t" << TypeToDataDirective(CV->getType()) << "\t";
+
+ if (const GlobalValue* GV = dyn_cast<GlobalValue>(CV)) {
+ O << getID(GV) << "\n";
+ } else if (isa<ConstantPointerNull>(CV)) {
+ // Null pointer value
+ O << "0\n";
+ } else if (const ConstantExpr* CE = dyn_cast<ConstantExpr>(CV)) {
+ // Constant expression built from operators, constants, and symbolic addrs
+ O << ConstantExprToString(CE, TM) << "\n";
+ } else if (CV->getType()->isPrimitiveType()) {
+ // Check primitive types last
+ if (CV->getType()->isFloatingPoint()) {
+ // FP Constants are printed as integer constants to avoid losing
+ // precision...
+ double Val = cast<ConstantFP>(CV)->getValue();
+ if (CV->getType() == Type::FloatTy) {
+ float FVal = (float)Val;
+ char *ProxyPtr = (char*)&FVal; // Abide by C TBAA rules
+ O << *(unsigned int*)ProxyPtr;
+ } else if (CV->getType() == Type::DoubleTy) {
+ char *ProxyPtr = (char*)&Val; // Abide by C TBAA rules
+ O << *(uint64_t*)ProxyPtr;
+ } else {
+ assert(0 && "Unknown floating point type!");
+ }
+
+ O << "\t! " << CV->getType()->getDescription()
+ << " value: " << Val << "\n";
+ } else if (const ConstantBool *CB = dyn_cast<ConstantBool>(CV)) {
+ O << (int)CB->getValue() << "\n";
+ } else {
+ WriteAsOperand(O, CV, false, false) << "\n";
+ }
+ } else {
+ assert(0 && "Unknown elementary type for constant");
+ }
+}
+
+/// Print a constant value or values (it may be an aggregate).
+/// Uses printSingleConstantValue() to print each individual value.
+///
+void AsmPrinter::printConstantValueOnly(const Constant* CV,
+ int numPadBytesAfter) {
+ if (const ConstantArray *CVA = dyn_cast<ConstantArray>(CV)) {
+ if (CVA->isString()) {
+ // print the string alone and return
+ O << "\t" << ".ascii" << "\t" << getAsCString(CVA) << "\n";
+ } else {
+ // Not a string. Print the values in successive locations
+ for (unsigned i = 0, e = CVA->getNumOperands(); i != e; ++i)
+ printConstantValueOnly(CVA->getOperand(i));
+ }
+ } else if (const ConstantStruct *CVS = dyn_cast<ConstantStruct>(CV)) {
+ // Print the fields in successive locations. Pad to align if needed!
+ const StructLayout *cvsLayout =
+ TM.getTargetData().getStructLayout(CVS->getType());
+ unsigned sizeSoFar = 0;
+ for (unsigned i = 0, e = CVS->getNumOperands(); i != e; ++i) {
+ const Constant* field = CVS->getOperand(i);
+
+ // Check if padding is needed and insert one or more 0s.
+ unsigned fieldSize =
+ TM.getTargetData().getTypeSize(field->getType());
+ int padSize = ((i == e-1? cvsLayout->StructSize
+ : cvsLayout->MemberOffsets[i+1])
+ - cvsLayout->MemberOffsets[i]) - fieldSize;
+ sizeSoFar += (fieldSize + padSize);
+
+ // Now print the actual field value
+ printConstantValueOnly(field, padSize);
+ }
+ assert(sizeSoFar == cvsLayout->StructSize &&
+ "Layout of constant struct may be incorrect!");
+ } else if (isa<ConstantAggregateZero>(CV)) {
+ PrintZeroBytesToPad(TM.getTargetData().getTypeSize(CV->getType()));
+ } else
+ printSingleConstantValue(CV);
+
+ if (numPadBytesAfter)
+ PrintZeroBytesToPad(numPadBytesAfter);
+}
+
+/// ConstantExprToString() - Convert a ConstantExpr to an asm expression
+/// and return this as a string.
+///
+std::string AsmPrinter::ConstantExprToString(const ConstantExpr* CE,
+ const TargetMachine& target) {
+ std::string S;
+ switch(CE->getOpcode()) {
+ case Instruction::GetElementPtr:
+ { // generate a symbolic expression for the byte address
+ const Value* ptrVal = CE->getOperand(0);
+ std::vector<Value*> idxVec(CE->op_begin()+1, CE->op_end());
+ const TargetData &TD = target.getTargetData();
+ S += "(" + valToExprString(ptrVal, target) + ") + ("
+ + utostr(TD.getIndexedOffset(ptrVal->getType(),idxVec)) + ")";
+ break;
+ }
+
+ case Instruction::Cast:
+ // Support only non-converting casts for now, i.e., a no-op.
+ // This assertion is not a complete check.
+ assert(target.getTargetData().getTypeSize(CE->getType()) ==
+ target.getTargetData().getTypeSize(CE->getOperand(0)->getType()));
+ S += "(" + valToExprString(CE->getOperand(0), target) + ")";
+ break;
+
+ case Instruction::Add:
+ S += ConstantArithExprToString(CE, target, ") + (");
+ break;
+
+ case Instruction::Sub:
+ S += ConstantArithExprToString(CE, target, ") - (");
+ break;
+
+ case Instruction::Mul:
+ S += ConstantArithExprToString(CE, target, ") * (");
+ break;
+
+ case Instruction::Div:
+ S += ConstantArithExprToString(CE, target, ") / (");
+ break;
+
+ case Instruction::Rem:
+ S += ConstantArithExprToString(CE, target, ") % (");
+ break;
+
+ case Instruction::And:
+ // Logical && for booleans; bitwise & otherwise
+ S += ConstantArithExprToString(CE, target,
+ ((CE->getType() == Type::BoolTy)? ") && (" : ") & ("));
+ break;
+
+ case Instruction::Or:
+ // Logical || for booleans; bitwise | otherwise
+ S += ConstantArithExprToString(CE, target,
+ ((CE->getType() == Type::BoolTy)? ") || (" : ") | ("));
+ break;
+
+ case Instruction::Xor:
+ // Bitwise ^ for all types
+ S += ConstantArithExprToString(CE, target, ") ^ (");
+ break;
+
+ default:
+ assert(0 && "Unsupported operator in ConstantExprToString()");
+ break;
+ }
+
+ return S;
+}
+
+/// valToExprString - Helper function for ConstantExprToString().
+/// Appends result to argument string S.
+///
+std::string AsmPrinter::valToExprString(const Value* V,
+ const TargetMachine& target) {
+ std::string S;
+ bool failed = false;
+ if (const GlobalValue* GV = dyn_cast<GlobalValue>(V)) {
+ S += getID(GV);
+ } else 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 ConstantExpr *CE = dyn_cast<ConstantExpr>(CV))
+ S += ConstantExprToString(CE, target);
+ else
+ failed = true;
+ } else
+ failed = true;
+
+ if (failed) {
+ assert(0 && "Cannot convert value to string");
+ S += "<illegal-value>";
+ }
+ return S;
+}
+
+namespace {
+
+ struct SparcV9AsmPrinter : public FunctionPass, public AsmPrinter {
+ inline SparcV9AsmPrinter(std::ostream &os, const TargetMachine &t)
+ : AsmPrinter(os, t) {}
+
+ const Function *currFunction;
+
+ const char *getPassName() const {
+ return "Output SparcV9 Assembly for Functions";
+ }
+
+ virtual bool doInitialization(Module &M) {
+ startModule(M);
+ return false;
+ }
+
+ virtual bool runOnFunction(Function &F) {
+ currFunction = &F;
+ emitFunction(F);
return false;
}
virtual bool doFinalization(Module &M) {
emitGlobals(M);
- AsmPrinter::doFinalization(M);
return false;
}
- void emitFunction(MachineFunction &F);
+ virtual void getAnalysisUsage(AnalysisUsage &AU) const {
+ AU.setPreservesAll();
+ }
+
+ void emitFunction(const Function &F);
private :
void emitBasicBlock(const MachineBasicBlock &MBB);
void emitMachineInst(const MachineInstr *MI);
@@ -241,7 +637,8 @@
case MachineOperand::MO_ConstantPoolIndex:
{
- O << ".CPI_" << CurrentFnName << "_" << mop.getConstantPoolIndex();
+ O << ".CPI_" << getID(currFunction)
+ << "_" << mop.getConstantPoolIndex();
break;
}
@@ -315,7 +712,9 @@
O << "\n"; // Separate BB's with newlines
}
-void SparcV9AsmPrinter::emitFunction(MachineFunction &MF) {
+void SparcV9AsmPrinter::emitFunction(const Function &F) {
+ std::string CurrentFnName = getID(&F);
+ MachineFunction &MF = MachineFunction::get(&F);
O << "!****** Outputing Function: " << CurrentFnName << " ******\n";
// Emit constant pool for this function
@@ -354,11 +753,11 @@
if (GV->hasInitializer() && ! GV->getInitializer()->isNullValue()) {
printConstant(GV->getInitializer(), getID(GV));
} else {
- const Type *ValTy = GV->getType()->getElementType();
- emitAlignment(TM.getTargetData().getTypeAlignmentShift(ValTy));
+ O << "\t.align\t" << TypeToAlignment(GV->getType()->getElementType(),
+ TM) << "\n";
O << "\t.type\t" << getID(GV) << ",#object\n";
O << "\t.reserve\t" << getID(GV) << ","
- << TM.getTargetData().getTypeSize(GV->getType()->getElementType())
+ << findOptimalStorageSize(TM, GV->getType()->getElementType())
<< "\n";
}
}
More information about the llvm-commits
mailing list