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

@@ -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<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 {
+    std::ostream &O;
-      Unknown,
+    const TargetMachine &TM;
-      Text,
-      ReadOnlyData,
-      InitRWData,
-      ZeroInitRWData,
-    } CurSection;
 
-    SparcV9AsmPrinter(std::ostream &OS, TargetMachine &TM)
+    enum Sections CurSection;
-      : AsmPrinter(OS, TM), CurSection(Unknown) {
+
-      ZeroDirective       = 0;  // No way to get zeros.
+    AsmPrinter(std::ostream &os, const TargetMachine &T)
-      Data16bitsDirective = "\t.half\t";
+      : /* idTable(0), */ O(os), TM(T), CurSection(Unknown) {}
-      Data32bitsDirective = "\t.word\t";
+  
-      Data64bitsDirective = "\t.xword\t";
+    ~AsmPrinter() {
-      CommentString = "!";
+      delete Mang;
     }
 
-    const char *getPassName() const {
+    // (start|end)(Module|Function) - Callback methods invoked by subclasses
-      return "SparcV9 Assembly Printer";
+    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) {
+    void printConstant(const Constant* CV, std::string valID = "") {
-      emitAlignment(TM.getTargetData().getTypeAlignmentShift(CV->getType()));
+      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());
+      unsigned int constSize = ConstantToSize(CV, TM);
-      O << "\t.size" << "\t" << valID << "," << constSize << "\n";
+      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) {
+    // Combines expressions 
-      setupMachineFunction(MF);
+    inline std::string ConstantArithExprToString(const ConstantExpr* CE,
-      emitFunction(MF);
+                                                 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 @@ 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();
+    O << "\t.align\t" << TypeToAlignment(GV->getType()->getElementType(),
-    emitAlignment(TM.getTargetData().getTypeAlignmentShift(ValTy));
+                                                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";
   }
 }