Substantially re-organized this file:

* There is now only one pass to print out assembly instead of two
* It is a FunctionPass
* The Module-level printing of globals is now in doFinalization() method of the
  FunctionPass
* The code has been reformatted to follow LLVM coding standards
* Some comments, not all, were doxygenified
* Last but not least, the function to create an instance of this pass is also no
  longer a method in the UltraSparc class.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@9953 91177308-0d34-0410-b5e6-96231b3b80d8

1 files changed, 554 insertions, 600 deletions

diff --git a/lib/Target/SparcV9/SparcV9AsmPrinter.cpp b/lib/Target/SparcV9/SparcV9AsmPrinter.cpp
index 6af9836e29..1e75acabbe 100644
--- a/lib/Target/SparcV9/SparcV9AsmPrinter.cpp
+++ b/lib/Target/SparcV9/SparcV9AsmPrinter.cpp
@@ -33,91 +33,88 @@
 #include "SparcInternals.h"
 #include <string>
 
+using namespace llvm;
+
 namespace llvm {
 
 namespace {
 
-Statistic<> EmittedInsts("asm-printer", "Number of machine instrs printed");
+  Statistic<> EmittedInsts("asm-printer", "Number of machine instrs printed");
 
-class GlobalIdTable: public Annotation {
-  static AnnotationID AnnotId;
-  friend class AsmPrinter;              // give access to AnnotId
-  
-  typedef hash_map<const Value*, int> ValIdMap;
-  typedef ValIdMap::const_iterator ValIdMapConstIterator;
-  typedef ValIdMap::      iterator ValIdMapIterator;
-public:
-  SlotCalculator Table;    // map anonymous values to unique integer IDs
-  ValIdMap valToIdMap;     // used for values not handled by SlotCalculator 
+  class GlobalIdTable: public Annotation {
+    static AnnotationID AnnotId;
+    friend class AsmPrinter;              // give access to AnnotId
   
-  GlobalIdTable(Module* M) : Annotation(AnnotId), Table(M, true) {}
-};
+    typedef hash_map<const Value*, int> ValIdMap;
+    typedef ValIdMap::const_iterator ValIdMapConstIterator;
+    typedef ValIdMap::      iterator ValIdMapIterator;
+  public:
+    SlotCalculator Table;    // map anonymous values to unique integer IDs
+    ValIdMap valToIdMap;     // used for values not handled by SlotCalculator 
+    
+    GlobalIdTable(Module* M) : Annotation(AnnotId), Table(M, true) {}
+  };
 
-AnnotationID GlobalIdTable::AnnotId =
+  AnnotationID GlobalIdTable::AnnotId = 
   AnnotationManager::getID("ASM PRINTER GLOBAL TABLE ANNOT");
+  
+  //===--------------------------------------------------------------------===//
+  // Utility functions
 
-// Can we treat the specified array as a string?  Only if it is an array of
-// ubytes or non-negative sbytes.
-//
-static bool isStringCompatible(const ConstantArray *CVA) {
-  const Type *ETy = cast<ArrayType>(CVA->getType())->getElementType();
-  if (ETy == Type::UByteTy) return true;
-  if (ETy != Type::SByteTy) return false;
+  /// Can we treat the specified array as a string?  Only if it is an array of
+  /// ubytes or non-negative sbytes.
+  ///
+  bool isStringCompatible(const ConstantArray *CVA) {
+    const Type *ETy = cast<ArrayType>(CVA->getType())->getElementType();
+    if (ETy == Type::UByteTy) return true;
+    if (ETy != Type::SByteTy) return false;
 
-  for (unsigned i = 0; i < CVA->getNumOperands(); ++i)
-    if (cast<ConstantSInt>(CVA->getOperand(i))->getValue() < 0)
-      return false;
+    for (unsigned i = 0; i < CVA->getNumOperands(); ++i)
+      if (cast<ConstantSInt>(CVA->getOperand(i))->getValue() < 0)
+        return false;
 
-  return true;
-}
+    return true;
+  }
 
-// toOctal - Convert the low order bits of X into an octal letter
-static inline char toOctal(int X) {
-  return (X&7)+'0';
-}
+  /// getAsCString - Return the specified array as a C compatible string, only
+  /// if the predicate isStringCompatible is true.
+  ///
+  std::string getAsCString(const ConstantArray *CVA) {
+    assert(isStringCompatible(CVA) && "Array is not string compatible!");
 
-// getAsCString - Return the specified array as a C compatible string, only if
-// the predicate isStringCompatible is true.
-//
-static std::string getAsCString(const ConstantArray *CVA) {
-  assert(isStringCompatible(CVA) && "Array is not string compatible!");
-
-  std::string Result;
-  const Type *ETy = cast<ArrayType>(CVA->getType())->getElementType();
-  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
-      Result += toOctal(C >> 6);
-      Result += toOctal(C >> 3);
-      Result += toOctal(C >> 0);
+    std::string Result;
+    const Type *ETy = cast<ArrayType>(CVA->getType())->getElementType();
+    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 += "\"";
+    Result += "\"";
 
-  return Result;
-}
-
-inline bool
-ArrayTypeIsString(const ArrayType* arrayType)
-{
-  return (arrayType->getElementType() == Type::UByteTy ||
-          arrayType->getElementType() == Type::SByteTy);
-}
+    return Result;
+  }
 
+  inline bool ArrayTypeIsString(const ArrayType* arrayType) {
+    return (arrayType->getElementType() == Type::UByteTy ||
+            arrayType->getElementType() == Type::SByteTy);
+  }
 
-inline const std::string
-TypeToDataDirective(const Type* type)
-{
-  switch(type->getPrimitiveID())
+  inline const std::string
+  TypeToDataDirective(const Type* type) {
+    switch(type->getPrimitiveID())
     {
     case Type::BoolTyID: case Type::UByteTyID: case Type::SByteTyID:
       return ".byte";
@@ -139,274 +136,169 @@ TypeToDataDirective(const Type* type)
     default:
       return "<InvaliDataTypeForPrinting>";
     }
-}
-
-// Get the size of the type
-// 
-inline unsigned int
-TypeToSize(const Type* type, const TargetMachine& target)
-{
-  return target.findOptimalStorageSize(type);
-}
+  }
 
-// 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))
-    {
+  /// 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 TypeToSize(CV->getType(), target);
-}
-
-// 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)
-{
-  unsigned short cacheLineSize = target.getCacheInfo().getCacheLineSize(1); 
-  if (size > (unsigned) cacheLineSize / 2)
-    return cacheLineSize;
-  else
-    for (unsigned sz=1; /*no condition*/; sz *= 2)
-      if (sz >= size)
-        return sz;
-}
+    return target.findOptimalStorageSize(CV->getType());
+  }
 
-// Get the size of the type and then use SizeToAlignment.
-// 
-inline unsigned int
-TypeToAlignment(const Type* type, const TargetMachine& target)
-{
-  return SizeToAlignment(TypeToSize(type, target), target);
-}
+  /// 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) {
+    unsigned short cacheLineSize = target.getCacheInfo().getCacheLineSize(1); 
+    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 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);
-}
-  
-//===---------------------------------------------------------------------===//
-//   Code Shared By the two printer passes, as a mixin
-//===---------------------------------------------------------------------===//
+  /// Get the size of the type and then use SizeToAlignment.
+  /// 
+  inline unsigned int
+  TypeToAlignment(const Type* type, const TargetMachine& target) {
+    return SizeToAlignment(target.findOptimalStorageSize(type), target);
+  }
 
-class AsmPrinter {
-  GlobalIdTable* idTable;
-public:
-  std::ostream &toAsm;
-  const TargetMachine &Target;
-  
-  enum Sections {
-    Unknown,
-    Text,
-    ReadOnlyData,
-    InitRWData,
-    ZeroInitRWData,
-  } CurSection;
-
-  AsmPrinter(std::ostream &os, const TargetMachine &T)
-    : idTable(0), toAsm(os), Target(T), CurSection(Unknown) {}
+  /// 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);
   
-  // (start|end)(Module|Function) - Callback methods to be invoked by subclasses
-  void startModule(Module &M) {
-    // Create the global id table if it does not already exist
-    idTable = (GlobalIdTable*)M.getAnnotation(GlobalIdTable::AnnotId);
-    if (idTable == NULL) {
-      idTable = new GlobalIdTable(&M);
-      M.addAnnotation(idTable);
-    }
+    return TypeToAlignment(CV->getType(), target);
   }
 
-  void
-  PrintZeroBytesToPad(int numBytes)
-  {
-    for ( ; numBytes >= 8; numBytes -= 8)
-      printSingleConstantValue(Constant::getNullValue(Type::ULongTy));
+} // End anonymous namespace
 
-    if (numBytes >= 4)
-    {
-      printSingleConstantValue(Constant::getNullValue(Type::UIntTy));
-      numBytes -= 4;
-    }
+} // End namespace llvm
 
-    while (numBytes--)
-      printSingleConstantValue(Constant::getNullValue(Type::UByteTy));
-  }
 
-  // Print a single constant value.
-  void printSingleConstantValue(const Constant* CV)
-  {
-    assert(CV->getType() != Type::VoidTy &&
-           CV->getType() != Type::TypeTy &&
-           CV->getType() != Type::LabelTy &&
-           "Unexpected type for Constant");
-  
-    assert((!isa<ConstantArray>(CV) && ! isa<ConstantStruct>(CV))
-           && "Aggregate types should be handled outside this function");
+
+//===---------------------------------------------------------------------===//
+//   Code abstracted away from the AsmPrinter
+//===---------------------------------------------------------------------===//
+
+namespace llvm {
+
+namespace {
+
+  class AsmPrinter {
+    GlobalIdTable* idTable;
+  public:
+    std::ostream &toAsm;
+    const TargetMachine &Target;
   
-    toAsm << "\t" << TypeToDataDirective(CV->getType()) << "\t";
+    enum Sections {
+      Unknown,
+      Text,
+      ReadOnlyData,
+      InitRWData,
+      ZeroInitRWData,
+    } CurSection;
+
+    AsmPrinter(std::ostream &os, const TargetMachine &T)
+      : idTable(0), toAsm(os), Target(T), CurSection(Unknown) {}
   
-    if (const ConstantPointerRef* CPR = dyn_cast<ConstantPointerRef>(CV))
-    { // This is a constant address for a global variable or method.
-      // Use the name of the variable or method as the address value.
-      assert(isa<GlobalValue>(CPR->getValue()) && "Unexpected non-global");
-      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 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
-          toAsm << *(unsigned int*)ProxyPtr;            
-        } else if (CV->getType() == Type::DoubleTy) {
-          char *ProxyPtr = (char*)&Val;         // Abide by C TBAA rules
-          toAsm << *(uint64_t*)ProxyPtr;            
-        } else {
-          assert(0 && "Unknown floating point type!");
-        }
-        
-        toAsm << "\t! " << CV->getType()->getDescription()
-              << " value: " << Val << "\n";
-      } else {
-        WriteAsOperand(toAsm, CV, false, false) << "\n";
+    // (start|end)(Module|Function) - Callback methods invoked by subclasses
+    void startModule(Module &M) {
+      // Create the global id table if it does not already exist
+      idTable = (GlobalIdTable*)M.getAnnotation(GlobalIdTable::AnnotId);
+      if (idTable == NULL) {
+        idTable = new GlobalIdTable(&M);
+        M.addAnnotation(idTable);
       }
     }
-    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
-  printConstantValueOnly(const Constant* CV,
-                         int numPadBytesAfter = 0)
-  {
-    const ConstantArray *CVA = dyn_cast<ConstantArray>(CV);
-
-    if (CVA && isStringCompatible(CVA))
-    { // print the string alone and return
-      toAsm << "\t" << ".ascii" << "\t" << getAsCString(CVA) << "\n";
-    }
-    else if (CVA)
-    { // Not a string.  Print the values in successive locations
-      const std::vector<Use> &constValues = CVA->getValues();
-      for (unsigned i=0; i < constValues.size(); i++)
-        printConstantValueOnly(cast<Constant>(constValues[i].get()));
-    }
-    else if (const ConstantStruct *CVS = dyn_cast<ConstantStruct>(CV))
-    { // Print the fields in successive locations. Pad to align if needed!
-      const StructLayout *cvsLayout =
-        Target.getTargetData().getStructLayout(CVS->getType());
-      const std::vector<Use>& constValues = CVS->getValues();
-      unsigned sizeSoFar = 0;
-      for (unsigned i=0, N = constValues.size(); i < N; i++)
-      {
-        const Constant* field = cast<Constant>(constValues[i].get());
-
-        // Check if padding is needed and insert one or more 0s.
-        unsigned fieldSize =
-          Target.getTargetData().getTypeSize(field->getType());
-        int padSize = ((i == N-1? cvsLayout->StructSize
-                        : cvsLayout->MemberOffsets[i+1])
-                       - cvsLayout->MemberOffsets[i]) - fieldSize;
-        sizeSoFar += (fieldSize + padSize);
-
-        // Now print the actual field value
-        printConstantValueOnly(field, padSize);
+    void PrintZeroBytesToPad(int numBytes) {
+      for (/* no init */; numBytes >= 8; numBytes -= 8)
+        printSingleConstantValue(Constant::getNullValue(Type::ULongTy));
+
+      if (numBytes >= 4) {
+        printSingleConstantValue(Constant::getNullValue(Type::UIntTy));
+        numBytes -= 4;
       }
-      assert(sizeSoFar == cvsLayout->StructSize &&
-             "Layout of constant struct may be incorrect!");
-    }
-    else
-      printSingleConstantValue(CV);
 
-    if (numPadBytesAfter)
-      PrintZeroBytesToPad(numPadBytesAfter);
-  }
+      while (numBytes--)
+        printSingleConstantValue(Constant::getNullValue(Type::UByteTy));
+    }
 
-  // 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, std::string valID = "")
-  {
-    if (valID.length() == 0)
-      valID = getID(CV);
+    /// 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, std::string valID = "") {
+      if (valID.length() == 0)
+        valID = getID(CV);
   
-    toAsm << "\t.align\t" << ConstantToAlignment(CV, Target) << "\n";
+      toAsm << "\t.align\t" << ConstantToAlignment(CV, Target) << "\n";
   
-    // Print .size and .type only if it is not a string.
-    const ConstantArray *CVA = dyn_cast<ConstantArray>(CV);
-    if (CVA && isStringCompatible(CVA))
-    { // print it as a string and return
-      toAsm << valID << ":\n";
-      toAsm << "\t" << ".ascii" << "\t" << getAsCString(CVA) << "\n";
-      return;
-    }
+      // Print .size and .type only if it is not a string.
+      const ConstantArray *CVA = dyn_cast<ConstantArray>(CV);
+      if (CVA && isStringCompatible(CVA)) {
+        // print it as a string and return
+        toAsm << valID << ":\n";
+        toAsm << "\t" << ".ascii" << "\t" << getAsCString(CVA) << "\n";
+        return;
+      }
   
-    toAsm << "\t.type" << "\t" << valID << ",#object\n";
+      toAsm << "\t.type" << "\t" << valID << ",#object\n";
 
-    unsigned int constSize = ConstantToSize(CV, Target);
-    if (constSize)
-      toAsm << "\t.size" << "\t" << valID << "," << constSize << "\n";
+      unsigned int constSize = ConstantToSize(CV, Target);
+      if (constSize)
+        toAsm << "\t.size" << "\t" << valID << "," << constSize << "\n";
   
-    toAsm << valID << ":\n";
+      toAsm << valID << ":\n";
   
-    printConstantValueOnly(CV);
-  }
+      printConstantValueOnly(CV);
+    }
 
-  void startFunction(Function &F) {
-    // Make sure the slot table has information about this function...
-    idTable->Table.incorporateFunction(&F);
-  }
-  void endFunction(Function &) {
-    idTable->Table.purgeFunction();  // Forget all about F
-  }
-  void endModule() {
-  }
+    void startFunction(Function &F) {
+      // Make sure the slot table has information about this function...
+      idTable->Table.incorporateFunction(&F);
+    }
+    void endFunction(Function &) {
+      idTable->Table.purgeFunction();  // Forget all about F
+    }
 
-  // Check if a value is external or accessible from external code.
-  bool isExternal(const Value* V) {
-    const GlobalValue *GV = dyn_cast<GlobalValue>(V);
-    return GV && GV->hasExternalLinkage();
-  }
+    // Check if a value is external or accessible from external code.
+    bool isExternal(const Value* V) {
+      const GlobalValue *GV = dyn_cast<GlobalValue>(V);
+      return GV && GV->hasExternalLinkage();
+    }
   
-  // enterSection - Use this method to enter a different section of the output
-  // executable.  This is used to only output necessary section transitions.
-  //
-  void enterSection(enum Sections S) {
-    if (S == CurSection) return;        // Only switch section if necessary
-    CurSection = S;
-
-    toAsm << "\n\t.section ";
-    switch (S)
+    // enterSection - Use this method to enter a different section of the output
+    // executable.  This is used to only output necessary section transitions.
+    //
+    void enterSection(enum Sections S) {
+      if (S == CurSection) return;        // Only switch section if necessary
+      CurSection = S;
+
+      toAsm << "\n\t.section ";
+      switch (S)
       {
       default: assert(0 && "Bad section name!");
       case Text:         toAsm << "\".text\""; break;
@@ -414,264 +306,381 @@ public:
       case InitRWData:   toAsm << "\".data\",#alloc,#write"; break;
       case ZeroInitRWData: toAsm << "\".bss\",#alloc,#write"; break;
       }
-    toAsm << "\n";
-  }
+      toAsm << "\n";
+    }
 
-  static std::string getValidSymbolName(const std::string &S) {
-    std::string Result;
+    static std::string getValidSymbolName(const std::string &S) {
+      std::string Result;
     
-    // Symbol names in Sparc assembly language have these rules:
-    // (a) Must match { letter | _ | . | $ } { letter | _ | . | $ | digit }*
-    // (b) A name beginning in "." is treated as a local name.
-    // 
-    if (isdigit(S[0]))
-      Result = "ll";
+      // Symbol names in Sparc assembly language have these rules:
+      // (a) Must match { letter | _ | . | $ } { letter | _ | . | $ | digit }*
+      // (b) A name beginning in "." is treated as a local name.
+      // 
+      if (isdigit(S[0]))
+        Result = "ll";
     
-    for (unsigned i = 0; i < S.size(); ++i)
-      {
+      for (unsigned i = 0; i < S.size(); ++i) {
         char C = S[i];
         if (C == '_' || C == '.' || C == '$' || isalpha(C) || isdigit(C))
           Result += C;
-        else
-          {
-            Result += '_';
-            Result += char('0' + ((unsigned char)C >> 4));
-            Result += char('0' + (C & 0xF));
-          }
+        else {
+          Result += '_';
+          Result += char('0' + ((unsigned char)C >> 4));
+          Result += char('0' + (C & 0xF));
+        }
       }
-    return Result;
-  }
+      return Result;
+    }
 
-  // getID - Return a valid identifier for the specified value.  Base it on
-  // the name of the identifier if possible (qualified by the type), and
-  // use a numbered value based on prefix otherwise.
-  // FPrefix is always prepended to the output identifier.
-  //
-  std::string getID(const Value *V, const char *Prefix, const char *FPrefix = 0) {
-    std::string Result = FPrefix ? FPrefix : "";  // "Forced prefix"
-
-    Result += V->hasName() ? V->getName() : std::string(Prefix);
-
-    // Qualify all internal names with a unique id.
-    if (!isExternal(V)) {
-      int valId = idTable->Table.getSlot(V);
-      if (valId == -1) {
-        GlobalIdTable::ValIdMapConstIterator I = idTable->valToIdMap.find(V);
-        if (I == idTable->valToIdMap.end())
-          valId = idTable->valToIdMap[V] = idTable->valToIdMap.size();
-        else
-          valId = I->second;
+    // getID - Return a valid identifier for the specified value.  Base it on
+    // the name of the identifier if possible (qualified by the type), and
+    // use a numbered value based on prefix otherwise.
+    // FPrefix is always prepended to the output identifier.
+    //
+    std::string getID(const Value *V, const char *Prefix,
+                      const char *FPrefix = 0)
+    {
+      std::string Result = FPrefix ? FPrefix : "";  // "Forced prefix"
+
+      Result += V->hasName() ? V->getName() : std::string(Prefix);
+
+      // Qualify all internal names with a unique id.
+      if (!isExternal(V)) {
+        int valId = idTable->Table.getSlot(V);
+        if (valId == -1) {
+          GlobalIdTable::ValIdMapConstIterator I = idTable->valToIdMap.find(V);
+          if (I == idTable->valToIdMap.end())
+            valId = idTable->valToIdMap[V] = idTable->valToIdMap.size();
+          else
+            valId = I->second;
+        }
+        Result = Result + "_" + itostr(valId);
+
+        // Replace or prefix problem characters in the name
+        Result = getValidSymbolName(Result);
       }
-      Result = Result + "_" + itostr(valId);
 
-      // Replace or prefix problem characters in the name
-      Result = getValidSymbolName(Result);
+      return Result;
     }
-
-    return Result;
-  }
   
-  // getID Wrappers - Ensure consistent usage...
-  std::string getID(const Function *F) {
-    return getID(F, "LLVMFunction_");
-  }
-  std::string getID(const BasicBlock *BB) {
-    return getID(BB, "LL", (".L_"+getID(BB->getParent())+"_").c_str());
-  }
-  std::string getID(const GlobalVariable *GV) {
-    return getID(GV, "LLVMGlobal_");
-  }
-  std::string getID(const Constant *CV) {
-    return getID(CV, "LLVMConst_", ".C_");
-  }
-  std::string getID(const GlobalValue *GV) {
-    if (const GlobalVariable *V = dyn_cast<GlobalVariable>(GV))
-      return getID(V);
-    else if (const Function *F = dyn_cast<Function>(GV))
-      return getID(F);
-    assert(0 && "Unexpected type of GlobalValue!");
-    return "";
-  }
+    // getID Wrappers - Ensure consistent usage...
+    std::string getID(const Function *F) {
+      return getID(F, "LLVMFunction_");
+    }
+    std::string getID(const BasicBlock *BB) {
+      return getID(BB, "LL", (".L_"+getID(BB->getParent())+"_").c_str());
+    }
+    std::string getID(const GlobalVariable *GV) {
+      return getID(GV, "LLVMGlobal_");
+    }
+    std::string getID(const Constant *CV) {
+      return getID(CV, "LLVMConst_", ".C_");
+    }
+    std::string getID(const GlobalValue *GV) {
+      if (const GlobalVariable *V = dyn_cast<GlobalVariable>(GV))
+        return getID(V);
+      else if (const Function *F = dyn_cast<Function>(GV))
+        return getID(F);
+      assert(0 && "Unexpected type of GlobalValue!");
+      return "";
+    }
 
-  // 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) + ")";
-  }
+    // 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) {
-    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;
+    /// 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
+
+} // End namespace llvm
+
+/// Print a single constant value.
+///
+void AsmPrinter::printSingleConstantValue(const Constant* CV) {
+  assert(CV->getType() != Type::VoidTy &&
+         CV->getType() != Type::TypeTy &&
+         CV->getType() != Type::LabelTy &&
+         "Unexpected type for Constant");
+  
+  assert((!isa<ConstantArray>(CV) && ! isa<ConstantStruct>(CV))
+         && "Aggregate types should be handled outside this function");
+  
+  toAsm << "\t" << TypeToDataDirective(CV->getType()) << "\t";
+  
+  if (const ConstantPointerRef* CPR = dyn_cast<ConstantPointerRef>(CV)) {
+    // This is a constant address for a global variable or method.
+    // Use the name of the variable or method as the address value.
+    assert(isa<GlobalValue>(CPR->getValue()) && "Unexpected non-global");
+    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 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
+        toAsm << *(unsigned int*)ProxyPtr;            
+      } else if (CV->getType() == Type::DoubleTy) {
+        char *ProxyPtr = (char*)&Val;         // Abide by C TBAA rules
+        toAsm << *(uint64_t*)ProxyPtr;            
+      } else {
+        assert(0 && "Unknown floating point type!");
       }
+        
+      toAsm << "\t! " << CV->getType()->getDescription()
+            << " value: " << Val << "\n";
+    } else {
+      WriteAsOperand(toAsm, CV, false, false) << "\n";
+    }
+  } else {
+    assert(0 && "Unknown elementary type for constant");
+  }
+}
 
-    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;
+/// 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)
+{
+  const ConstantArray *CVA = dyn_cast<ConstantArray>(CV);
+
+  if (CVA && isStringCompatible(CVA)) {
+    // print the string alone and return
+    toAsm << "\t" << ".ascii" << "\t" << getAsCString(CVA) << "\n";
+  } else if (CVA) { 
+    // Not a string.  Print the values in successive locations
+    const std::vector<Use> &constValues = CVA->getValues();
+    for (unsigned i=0; i < constValues.size(); i++)
+      printConstantValueOnly(cast<Constant>(constValues[i].get()));
+  } else if (const ConstantStruct *CVS = dyn_cast<ConstantStruct>(CV)) {
+    // Print the fields in successive locations. Pad to align if needed!
+    const StructLayout *cvsLayout =
+      Target.getTargetData().getStructLayout(CVS->getType());
+    const std::vector<Use>& constValues = CVS->getValues();
+    unsigned sizeSoFar = 0;
+    for (unsigned i=0, N = constValues.size(); i < N; i++) {
+      const Constant* field = cast<Constant>(constValues[i].get());
+
+      // Check if padding is needed and insert one or more 0s.
+      unsigned fieldSize =
+        Target.getTargetData().getTypeSize(field->getType());
+      int padSize = ((i == N-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
+    printSingleConstantValue(CV);
 
-    case Instruction::Xor:
-      // Bitwise ^ for all types
-      S += ConstantArithExprToString(CE, target, ") ^ (");
-      break;
+  if (numPadBytesAfter)
+    PrintZeroBytesToPad(numPadBytesAfter);
+}
 
-    default:
-      assert(0 && "Unsupported operator in ConstantExprToString()");
+/// 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;
     }
 
-    return S;
+  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;