From 86584749b67dbae5132fd2dacadaf47883609bc9 Mon Sep 17 00:00:00 2001 From: Brian Gaeke Date: Fri, 10 Sep 2004 18:01:45 +0000 Subject: [PATCH] Roll back constant printing changes until the problems with larger programs and C++ can be looked at in detail. llvm-svn: 16266 --- llvm/lib/Target/SparcV9/SparcV9AsmPrinter.cpp | 467 ++++++++++++++++-- 1 file changed, 433 insertions(+), 34 deletions(-) diff --git a/llvm/lib/Target/SparcV9/SparcV9AsmPrinter.cpp b/llvm/lib/Target/SparcV9/SparcV9AsmPrinter.cpp index dbfc1e1e0ca1..9aa73ed4f8bb 100644 --- a/llvm/lib/Target/SparcV9/SparcV9AsmPrinter.cpp +++ b/llvm/lib/Target/SparcV9/SparcV9AsmPrinter.cpp @@ -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 @@ using namespace llvm; 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(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 ""; + default: + return ""; + } + } + + /// 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(CV)) { + const ArrayType *aty = cast(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(CV)) + if (ArrayTypeIsString(cast(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; + std::ostream &O; + const TargetMachine &TM; - 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 = "!"; + 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(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 @@ namespace { 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(CV) && ! isa(CV)) + && "Aggregate types should be handled outside this function"); + + O << "\t" << TypeToDataDirective(CV->getType()) << "\t"; + + if (const GlobalValue* GV = dyn_cast(CV)) { + O << getID(GV) << "\n"; + } else if (isa(CV)) { + // Null pointer value + O << "0\n"; + } else if (const ConstantExpr* CE = dyn_cast(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(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(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(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(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(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 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(V)) { + S += getID(GV); + } else if (const Constant* CV = dyn_cast(V)) { // symbolic or known + if (const ConstantBool *CB = dyn_cast(CV)) + S += std::string(CB == ConstantBool::True ? "1" : "0"); + else if (const ConstantSInt *CI = dyn_cast(CV)) + S += itostr(CI->getValue()); + else if (const ConstantUInt *CI = dyn_cast(CV)) + S += utostr(CI->getValue()); + else if (const ConstantFP *CFP = dyn_cast(CV)) + S += ftostr(CFP->getValue()); + else if (isa(CV)) + S += "0"; + else if (const ConstantExpr *CE = dyn_cast(CV)) + S += ConstantExprToString(CE, target); + else + failed = true; + } else + failed = true; + + if (failed) { + assert(0 && "Cannot convert value to string"); + S += ""; + } + 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 @@ SparcV9AsmPrinter::printOneOperand(const MachineOperand &mop, case MachineOperand::MO_ConstantPoolIndex: { - O << ".CPI_" << CurrentFnName << "_" << mop.getConstantPoolIndex(); + O << ".CPI_" << getID(currFunction) + << "_" << mop.getConstantPoolIndex(); break; } @@ -315,7 +712,9 @@ void SparcV9AsmPrinter::emitBasicBlock(const MachineBasicBlock &MBB) { 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 @@ void SparcV9AsmPrinter::printGlobalVariable(const GlobalVariable* GV) { 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"; } }