X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FVMCore%2FAsmWriter.cpp;h=cc8c5a12324fa78dc28f4b6182dad9ef83c3b160;hb=4460f4058fb33e468358f85c7f0925fc0e69e16c;hp=22a0ca001a106ac4051e4aa17049c73e3f812bbc;hpb=3c8f2c66e585f946569fa62cbf26509009d2df93;p=oota-llvm.git

diff --git a/lib/VMCore/AsmWriter.cpp b/lib/VMCore/AsmWriter.cpp
index 22a0ca001a1..cc8c5a12324 100644
--- a/lib/VMCore/AsmWriter.cpp
+++ b/lib/VMCore/AsmWriter.cpp
@@ -1,10 +1,10 @@
 //===-- AsmWriter.cpp - Printing LLVM as an assembly file -----------------===//
-// 
+//
 //                     The LLVM Compiler Infrastructure
 //
 // This file was developed by the LLVM research group and is distributed under
 // the University of Illinois Open Source License. See LICENSE.TXT for details.
-// 
+//
 //===----------------------------------------------------------------------===//
 //
 // This library implements the functionality defined in llvm/Assembly/Writer.h
@@ -18,21 +18,26 @@
 #include "llvm/Assembly/Writer.h"
 #include "llvm/Assembly/PrintModulePass.h"
 #include "llvm/Assembly/AsmAnnotationWriter.h"
+#include "llvm/CallingConv.h"
 #include "llvm/Constants.h"
 #include "llvm/DerivedTypes.h"
+#include "llvm/InlineAsm.h"
 #include "llvm/Instruction.h"
 #include "llvm/Instructions.h"
 #include "llvm/Module.h"
 #include "llvm/SymbolTable.h"
-#include "llvm/Assembly/Writer.h"
 #include "llvm/Support/CFG.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/STLExtras.h"
+#include "llvm/Support/MathExtras.h"
 #include <algorithm>
 using namespace llvm;
 
 namespace llvm {
 
+// Make virtual table appear in this compilation unit.
+AssemblyAnnotationWriter::~AssemblyAnnotationWriter() {}
+
 /// This class provides computation of slot numbers for LLVM Assembly writing.
 /// @brief LLVM Assembly Writing Slot Computation.
 class SlotMachine {
@@ -46,7 +51,7 @@ public:
   typedef std::map<const Type*, unsigned> TypeMap;
 
   /// @brief A plane with next slot number and ValueMap
-  struct ValuePlane { 
+  struct ValuePlane {
     unsigned next_slot;        ///< The next slot number to use
     ValueMap map;              ///< The map of Value* -> unsigned
     ValuePlane() { next_slot = 0; } ///< Make sure we start at 0
@@ -90,15 +95,15 @@ public:
 /// @name Mutators
 /// @{
 public:
-  /// If you'd like to deal with a function instead of just a module, use 
+  /// If you'd like to deal with a function instead of just a module, use
   /// this method to get its data into the SlotMachine.
-  void incorporateFunction(const Function *F) { 
-    TheFunction = F;  
+  void incorporateFunction(const Function *F) {
+    TheFunction = F;
     FunctionProcessed = false;
   }
 
-  /// After calling incorporateFunction, use this method to remove the 
-  /// most recently incorporated function from the SlotMachine. This 
+  /// After calling incorporateFunction, use this method to remove the
+  /// most recently incorporated function from the SlotMachine. This
   /// will reset the state of the machine back to just the module contents.
   void purgeFunction();
 
@@ -109,7 +114,7 @@ private:
   /// This function does the actual initialization.
   inline void initialize();
 
-  /// Values can be crammed into here at will. If they haven't 
+  /// Values can be crammed into here at will. If they haven't
   /// been inserted already, they get inserted, otherwise they are ignored.
   /// Either way, the slot number for the Value* is returned.
   unsigned createSlot(const Value *V);
@@ -117,7 +122,7 @@ private:
 
   /// Insert a value into the value table. Return the slot number
   /// that it now occupies.  BadThings(TM) will happen if you insert a
-  /// Value that's already been inserted. 
+  /// Value that's already been inserted.
   unsigned insertValue( const Value *V );
   unsigned insertValue( const Type* Ty);
 
@@ -162,12 +167,12 @@ X("printm", "Print module to stderr",PassInfo::Analysis|PassInfo::Optimization);
 static RegisterPass<PrintFunctionPass>
 Y("print","Print function to stderr",PassInfo::Analysis|PassInfo::Optimization);
 
-static void WriteAsOperandInternal(std::ostream &Out, const Value *V, 
+static void WriteAsOperandInternal(std::ostream &Out, const Value *V,
                                    bool PrintName,
                                  std::map<const Type *, std::string> &TypeTable,
                                    SlotMachine *Machine);
 
-static void WriteAsOperandInternal(std::ostream &Out, const Type *T, 
+static void WriteAsOperandInternal(std::ostream &Out, const Type *T,
                                    bool PrintName,
                                  std::map<const Type *, std::string> &TypeTable,
                                    SlotMachine *Machine);
@@ -203,7 +208,8 @@ static SlotMachine *createSlotMachine(const Value *V) {
 // getLLVMName - Turn the specified string into an 'LLVM name', which is either
 // prefixed with % (if the string only contains simple characters) or is
 // surrounded with ""'s (if it has special chars in it).
-static std::string getLLVMName(const std::string &Name) {
+static std::string getLLVMName(const std::string &Name,
+                               bool prefixName = true) {
   assert(!Name.empty() && "Cannot get empty name!");
 
   // First character cannot start with a number...
@@ -218,9 +224,12 @@ static std::string getLLVMName(const std::string &Name) {
         C != '-' && C != '.' && C != '_')
       return "\"" + Name + "\"";
   }
-  
+
   // If we get here, then the identifier is legal to use as a "VarID".
-  return "%"+Name;
+  if (prefixName)
+    return "%"+Name;
+  else
+    return Name;
 }
 
 
@@ -246,7 +255,7 @@ static void fillTypeNameTable(const Module *M,
 
 
 
-static void calcTypeName(const Type *Ty, 
+static void calcTypeName(const Type *Ty,
                          std::vector<const Type *> &TypeStack,
                          std::map<const Type *, std::string> &TypeNames,
                          std::string & Result){
@@ -271,7 +280,7 @@ static void calcTypeName(const Type *Ty,
   unsigned Slot = 0, CurSize = TypeStack.size();
   while (Slot < CurSize && TypeStack[Slot] != Ty) ++Slot; // Scan for type
 
-  // This is another base case for the recursion.  In this case, we know 
+  // This is another base case for the recursion.  In this case, we know
   // that we have looped back to a type that we have previously visited.
   // Generate the appropriate upreference to handle this.
   if (Slot < CurSize) {
@@ -280,7 +289,7 @@ static void calcTypeName(const Type *Ty,
   }
 
   TypeStack.push_back(Ty);    // Recursive case: Add us to the stack..
-  
+
   switch (Ty->getTypeID()) {
   case Type::FunctionTyID: {
     const FunctionType *FTy = cast<FunctionType>(Ty);
@@ -312,7 +321,7 @@ static void calcTypeName(const Type *Ty,
     break;
   }
   case Type::PointerTyID:
-    calcTypeName(cast<PointerType>(Ty)->getElementType(), 
+    calcTypeName(cast<PointerType>(Ty)->getElementType(),
                           TypeStack, TypeNames, Result);
     Result += "*";
     break;
@@ -375,25 +384,42 @@ static std::ostream &printTypeInt(std::ostream &Out, const Type *Ty,
 ///
 std::ostream &llvm::WriteTypeSymbolic(std::ostream &Out, const Type *Ty,
                                       const Module *M) {
-  Out << ' '; 
+  Out << ' ';
 
   // If they want us to print out a type, attempt to make it symbolic if there
   // is a symbol table in the module...
   if (M) {
     std::map<const Type *, std::string> TypeNames;
     fillTypeNameTable(M, TypeNames);
-    
+
     return printTypeInt(Out, Ty, TypeNames);
   } else {
     return Out << Ty->getDescription();
   }
 }
 
-/// @brief Internal constant writer. 
-static void WriteConstantInt(std::ostream &Out, const Constant *CV, 
+// PrintEscapedString - Print each character of the specified string, escaping
+// it if it is not printable or if it is an escape char.
+static void PrintEscapedString(const std::string &Str, std::ostream &Out) {
+  for (unsigned i = 0, e = Str.size(); i != e; ++i) {
+    unsigned char C = Str[i];
+    if (isprint(C) && C != '"' && C != '\\') {
+      Out << C;
+    } else {
+      Out << '\\'
+          << (char) ((C/16  < 10) ? ( C/16 +'0') : ( C/16 -10+'A'))
+          << (char)(((C&15) < 10) ? ((C&15)+'0') : ((C&15)-10+'A'));
+    }
+  }
+}
+
+/// @brief Internal constant writer.
+static void WriteConstantInt(std::ostream &Out, const Constant *CV,
                              bool PrintName,
                              std::map<const Type *, std::string> &TypeTable,
                              SlotMachine *Machine) {
+  const int IndentSize = 4;
+  static std::string Indent = "\n";
   if (const ConstantBool *CB = dyn_cast<ConstantBool>(CV)) {
     Out << (CB == ConstantBool::True ? "true" : "false");
   } else if (const ConstantSInt *CI = dyn_cast<ConstantSInt>(CV)) {
@@ -417,51 +443,26 @@ static void WriteConstantInt(std::ostream &Out, const Constant *CV,
          (StrVal[1] >= '0' && StrVal[1] <= '9')))
       // Reparse stringized version!
       if (atof(StrVal.c_str()) == CFP->getValue()) {
-        Out << StrVal; return;
+        Out << StrVal;
+        return;
       }
-    
+
     // Otherwise we could not reparse it to exactly the same value, so we must
     // output the string in hexadecimal format!
-    //
-    // Behave nicely in the face of C TBAA rules... see:
-    // http://www.nullstone.com/htmls/category/aliastyp.htm
-    //
-    double Val = CFP->getValue();
-    char *Ptr = (char*)&Val;
-    assert(sizeof(double) == sizeof(uint64_t) && sizeof(double) == 8 &&
+    assert(sizeof(double) == sizeof(uint64_t) &&
            "assuming that double is 64 bits!");
-    Out << "0x" << utohexstr(*(uint64_t*)Ptr);
+    Out << "0x" << utohexstr(DoubleToBits(CFP->getValue()));
 
   } else if (isa<ConstantAggregateZero>(CV)) {
     Out << "zeroinitializer";
   } else if (const ConstantArray *CA = dyn_cast<ConstantArray>(CV)) {
     // As a special case, print the array as a string if it is an array of
     // ubytes or an array of sbytes with positive values.
-    // 
+    //
     const Type *ETy = CA->getType()->getElementType();
-    bool isString = (ETy == Type::SByteTy || ETy == Type::UByteTy);
-
-    if (ETy == Type::SByteTy)
-      for (unsigned i = 0; i < CA->getNumOperands(); ++i)
-        if (cast<ConstantSInt>(CA->getOperand(i))->getValue() < 0) {
-          isString = false;
-          break;
-        }
-
-    if (isString) {
+    if (CA->isString()) {
       Out << "c\"";
-      for (unsigned i = 0; i < CA->getNumOperands(); ++i) {
-        unsigned char C = 
-          (unsigned char)cast<ConstantInt>(CA->getOperand(i))->getRawValue();
-        
-        if (isprint(C) && C != '"' && C != '\\') {
-          Out << C;
-        } else {
-          Out << '\\'
-              << (char) ((C/16  < 10) ? ( C/16 +'0') : ( C/16 -10+'A'))
-              << (char)(((C&15) < 10) ? ((C&15)+'0') : ((C&15)-10+'A'));
-        }
-      }
+      PrintEscapedString(CA->getAsString(), Out);
       Out << "\"";
 
     } else {                // Cannot output in string format...
@@ -482,26 +483,34 @@ static void WriteConstantInt(std::ostream &Out, const Constant *CV,
     }
   } else if (const ConstantStruct *CS = dyn_cast<ConstantStruct>(CV)) {
     Out << '{';
-    if (CS->getNumOperands()) {
-      Out << ' ';
+    unsigned N = CS->getNumOperands();
+    if (N) {
+      if (N > 2) {
+        Indent += std::string(IndentSize, ' ');
+        Out << Indent;
+      } else {
+        Out << ' ';
+      }
       printTypeInt(Out, CS->getOperand(0)->getType(), TypeTable);
 
       WriteAsOperandInternal(Out, CS->getOperand(0),
                              PrintName, TypeTable, Machine);
 
-      for (unsigned i = 1; i < CS->getNumOperands(); i++) {
+      for (unsigned i = 1; i < N; i++) {
         Out << ", ";
+        if (N > 2) Out << Indent;
         printTypeInt(Out, CS->getOperand(i)->getType(), TypeTable);
 
         WriteAsOperandInternal(Out, CS->getOperand(i),
                                PrintName, TypeTable, Machine);
       }
+      if (N > 2) Indent.resize(Indent.size() - IndentSize);
     }
-
+ 
     Out << " }";
   } else if (const ConstantPacked *CP = dyn_cast<ConstantPacked>(CV)) {
       const Type *ETy = CP->getType()->getElementType();
-      assert(CP->getNumOperands() > 0 && 
+      assert(CP->getNumOperands() > 0 &&
              "Number of operands for a PackedConst must be > 0");
       Out << '<';
       Out << ' ';
@@ -523,14 +532,14 @@ static void WriteConstantInt(std::ostream &Out, const Constant *CV,
 
   } else if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(CV)) {
     Out << CE->getOpcodeName() << " (";
-    
+
     for (User::const_op_iterator OI=CE->op_begin(); OI != CE->op_end(); ++OI) {
       printTypeInt(Out, (*OI)->getType(), TypeTable);
       WriteAsOperandInternal(Out, *OI, PrintName, TypeTable, Machine);
       if (OI+1 != CE->op_end())
         Out << ", ";
     }
-    
+
     if (CE->getOpcode() == Instruction::Cast) {
       Out << " to ";
       printTypeInt(Out, CE->getType(), TypeTable);
@@ -547,7 +556,7 @@ static void WriteConstantInt(std::ostream &Out, const Constant *CV,
 /// ostream.  This can be useful when you just want to print int %reg126, not
 /// the whole instruction that generated it.
 ///
-static void WriteAsOperandInternal(std::ostream &Out, const Value *V, 
+static void WriteAsOperandInternal(std::ostream &Out, const Value *V,
                                    bool PrintName,
                                   std::map<const Type*, std::string> &TypeTable,
                                    SlotMachine *Machine) {
@@ -556,15 +565,24 @@ static void WriteAsOperandInternal(std::ostream &Out, const Value *V,
     Out << getLLVMName(V->getName());
   else {
     const Constant *CV = dyn_cast<Constant>(V);
-    if (CV && !isa<GlobalValue>(CV))
+    if (CV && !isa<GlobalValue>(CV)) {
       WriteConstantInt(Out, CV, PrintName, TypeTable, Machine);
-    else {
+    } else if (const InlineAsm *IA = dyn_cast<InlineAsm>(V)) {
+      Out << "asm ";
+      if (IA->hasSideEffects())
+        Out << "sideeffect ";
+      Out << '"';
+      PrintEscapedString(IA->getAsmString(), Out);
+      Out << "\", \"";
+      PrintEscapedString(IA->getConstraintString(), Out);
+      Out << '"';
+    } else {
       int Slot;
       if (Machine) {
         Slot = Machine->getSlot(V);
       } else {
         Machine = createSlotMachine(V);
-        if (Machine == 0) 
+        if (Machine == 0)
           Slot = Machine->getSlot(V);
         else
           Slot = -1;
@@ -583,7 +601,7 @@ static void WriteAsOperandInternal(std::ostream &Out, const Value *V,
 /// the whole instruction that generated it.
 ///
 std::ostream &llvm::WriteAsOperand(std::ostream &Out, const Value *V,
-                                   bool PrintType, bool PrintName, 
+                                   bool PrintType, bool PrintName,
                                    const Module *Context) {
   std::map<const Type *, std::string> TypeNames;
   if (Context == 0) Context = getModuleFromVal(V);
@@ -593,16 +611,16 @@ std::ostream &llvm::WriteAsOperand(std::ostream &Out, const Value *V,
 
   if (PrintType)
     printTypeInt(Out, V->getType(), TypeNames);
-  
+
   WriteAsOperandInternal(Out, V, PrintName, TypeNames, 0);
   return Out;
 }
 
-/// WriteAsOperandInternal - Write the name of the specified value out to 
-/// the specified ostream.  This can be useful when you just want to print 
+/// WriteAsOperandInternal - Write the name of the specified value out to
+/// the specified ostream.  This can be useful when you just want to print
 /// int %reg126, not the whole instruction that generated it.
 ///
-static void WriteAsOperandInternal(std::ostream &Out, const Type *T, 
+static void WriteAsOperandInternal(std::ostream &Out, const Type *T,
                                    bool PrintName,
                                   std::map<const Type*, std::string> &TypeTable,
                                    SlotMachine *Machine) {
@@ -624,7 +642,7 @@ static void WriteAsOperandInternal(std::ostream &Out, const Type *T,
 /// the whole instruction that generated it.
 ///
 std::ostream &llvm::WriteAsOperand(std::ostream &Out, const Type *Ty,
-                                   bool PrintType, bool PrintName, 
+                                   bool PrintType, bool PrintName,
                                    const Module *Context) {
   std::map<const Type *, std::string> TypeNames;
   assert(Context != 0 && "Can't write types as operand without module context");
@@ -633,7 +651,7 @@ std::ostream &llvm::WriteAsOperand(std::ostream &Out, const Type *Ty,
 
   // if (PrintType)
     // printTypeInt(Out, V->getType(), TypeNames);
-  
+
   printTypeInt(Out, Ty, TypeNames);
 
   WriteAsOperandInternal(Out, Ty, PrintName, TypeNames, 0);
@@ -671,7 +689,7 @@ public:
 
   const Module* getModule() { return TheModule; }
 
-private :
+private:
   void printModule(const Module *M);
   void printSymbolTable(const SymbolTable &ST);
   void printConstant(const Constant *CPV);
@@ -745,15 +763,24 @@ std::ostream &AssemblyWriter::printTypeAtLeastOneLevel(const Type *Ty) {
 }
 
 
-void AssemblyWriter::writeOperand(const Value *Operand, bool PrintType, 
+void AssemblyWriter::writeOperand(const Value *Operand, bool PrintType,
                                   bool PrintName) {
-  assert(Operand != 0 && "Illegal Operand");
-  if (PrintType) { Out << ' '; printType(Operand->getType()); }
-  WriteAsOperandInternal(Out, Operand, PrintName, TypeNames, &Machine);
+  if (Operand != 0) {
+    if (PrintType) { Out << ' '; printType(Operand->getType()); }
+    WriteAsOperandInternal(Out, Operand, PrintName, TypeNames, &Machine);
+  } else {
+    Out << "<null operand!>";
+  }
 }
 
 
 void AssemblyWriter::printModule(const Module *M) {
+  if (!M->getModuleIdentifier().empty() &&
+      // Don't print the ID if it will start a new line (which would
+      // require a comment char before it).
+      M->getModuleIdentifier().find('\n') == std::string::npos)
+    Out << "; ModuleID = '" << M->getModuleIdentifier() << "'\n";
+
   switch (M->getEndianness()) {
   case Module::LittleEndian: Out << "target endian = little\n"; break;
   case Module::BigEndian:    Out << "target endian = big\n";    break;
@@ -766,6 +793,26 @@ void AssemblyWriter::printModule(const Module *M) {
   }
   if (!M->getTargetTriple().empty())
     Out << "target triple = \"" << M->getTargetTriple() << "\"\n";
+
+  if (!M->getModuleInlineAsm().empty()) {
+    // Split the string into lines, to make it easier to read the .ll file.
+    std::string Asm = M->getModuleInlineAsm();
+    size_t CurPos = 0;
+    size_t NewLine = Asm.find_first_of('\n', CurPos);
+    while (NewLine != std::string::npos) {
+      // We found a newline, print the portion of the asm string from the
+      // last newline up to this newline.
+      Out << "module asm \"";
+      PrintEscapedString(std::string(Asm.begin()+CurPos, Asm.begin()+NewLine),
+                         Out);
+      Out << "\"\n";
+      CurPos = NewLine+1;
+      NewLine = Asm.find_first_of('\n', CurPos);
+    }
+    Out << "module asm \"";
+    PrintEscapedString(std::string(Asm.begin()+CurPos, Asm.end()), Out);
+    Out << "\"\n";
+  }
   
   // Loop over the dependent libraries and emit them.
   Module::lib_iterator LI = M->lib_begin();
@@ -783,12 +830,12 @@ void AssemblyWriter::printModule(const Module *M) {
 
   // Loop over the symbol table, emitting all named constants.
   printSymbolTable(M->getSymbolTable());
-  
-  for (Module::const_giterator I = M->gbegin(), E = M->gend(); I != E; ++I)
+
+  for (Module::const_global_iterator I = M->global_begin(), E = M->global_end(); I != E; ++I)
     printGlobal(I);
 
   Out << "\nimplementation   ; Functions:\n";
-  
+
   // Output all of the functions.
   for (Module::const_iterator I = M->begin(), E = M->end(); I != E; ++I)
     printFunction(I);
@@ -797,7 +844,7 @@ void AssemblyWriter::printModule(const Module *M) {
 void AssemblyWriter::printGlobal(const GlobalVariable *GV) {
   if (GV->hasName()) Out << getLLVMName(GV->getName()) << " = ";
 
-  if (!GV->hasInitializer()) 
+  if (!GV->hasInitializer())
     Out << "external ";
   else
     switch (GV->getLinkage()) {
@@ -819,7 +866,12 @@ void AssemblyWriter::printGlobal(const GlobalVariable *GV) {
     assert(C &&  "GlobalVar initializer isn't constant?");
     writeOperand(GV->getInitializer(), false, isa<GlobalValue>(C));
   }
-
+  
+  if (GV->hasSection())
+    Out << ", section \"" << GV->getSection() << '"';
+  if (GV->getAlignment())
+    Out << ", align " << GV->getAlignment();
+  
   printInfoComment(*GV);
   Out << "\n";
 }
@@ -839,7 +891,7 @@ void AssemblyWriter::printSymbolTable(const SymbolTable &ST) {
     //
     printTypeAtLeastOneLevel(TI->second) << "\n";
   }
-    
+
   // Print the constants, in type plane order.
   for (SymbolTable::plane_const_iterator PI = ST.plane_begin();
        PI != ST.plane_end(); ++PI ) {
@@ -879,6 +931,9 @@ void AssemblyWriter::printFunction(const Function *F) {
   // Print out the return type and name...
   Out << "\n";
 
+  // Ensure that no local symbols conflict with global symbols.
+  const_cast<Function*>(F)->renameLocalSymbols();
+
   if (AnnotationWriter) AnnotationWriter->emitFunctionAnnot(F, Out);
 
   if (F->isExternal())
@@ -895,6 +950,14 @@ void AssemblyWriter::printFunction(const Function *F) {
       abort();
     }
 
+  // Print the calling convention.
+  switch (F->getCallingConv()) {
+  case CallingConv::C: break;   // default
+  case CallingConv::Fast: Out << "fastcc "; break;
+  case CallingConv::Cold: Out << "coldcc "; break;
+  default: Out << "cc" << F->getCallingConv() << " "; break;
+  }
+
   printType(F->getReturnType()) << ' ';
   if (!F->getName().empty())
     Out << getLLVMName(F->getName());
@@ -906,7 +969,7 @@ void AssemblyWriter::printFunction(const Function *F) {
   // Loop over the arguments, printing them...
   const FunctionType *FT = F->getFunctionType();
 
-  for(Function::const_aiterator I = F->abegin(), E = F->aend(); I != E; ++I)
+  for(Function::const_arg_iterator I = F->arg_begin(), E = F->arg_end(); I != E; ++I)
     printArgument(I);
 
   // Finish printing arguments...
@@ -916,11 +979,16 @@ void AssemblyWriter::printFunction(const Function *F) {
   }
   Out << ')';
 
+  if (F->hasSection())
+    Out << " section \"" << F->getSection() << '"';
+  if (F->getAlignment())
+    Out << " align " << F->getAlignment();
+
   if (F->isExternal()) {
     Out << "\n";
   } else {
     Out << " {";
-  
+
     // Output all of its basic blocks... for the function
     for (Function::const_iterator I = F->begin(), E = F->end(); I != E; ++I)
       printBasicBlock(I);
@@ -936,11 +1004,11 @@ void AssemblyWriter::printFunction(const Function *F) {
 ///
 void AssemblyWriter::printArgument(const Argument *Arg) {
   // Insert commas as we go... the first arg doesn't get a comma
-  if (Arg != &Arg->getParent()->afront()) Out << ", ";
+  if (Arg != Arg->getParent()->arg_begin()) Out << ", ";
 
   // Output type...
   printType(Arg->getType());
-  
+
   // Output name, if available...
   if (Arg->hasName())
     Out << ' ' << getLLVMName(Arg->getName());
@@ -950,7 +1018,7 @@ void AssemblyWriter::printArgument(const Argument *Arg) {
 ///
 void AssemblyWriter::printBasicBlock(const BasicBlock *BB) {
   if (BB->hasName()) {              // Print out the label if it exists...
-    Out << "\n" << BB->getName() << ':';
+    Out << "\n" << getLLVMName(BB->getName(), false) << ':';
   } else if (!BB->use_empty()) {      // Don't print block # of no uses...
     Out << "\n; <label>:";
     int Slot = Machine.getSlot(BB);
@@ -967,7 +1035,7 @@ void AssemblyWriter::printBasicBlock(const BasicBlock *BB) {
       // Output predecessors for the block...
       Out << "\t\t;";
       pred_const_iterator PI = pred_begin(BB), PE = pred_end(BB);
-      
+
       if (PI == PE) {
         Out << " No predecessors!";
       } else {
@@ -980,7 +1048,7 @@ void AssemblyWriter::printBasicBlock(const BasicBlock *BB) {
       }
     }
   }
-  
+
   Out << "\n";
 
   if (AnnotationWriter) AnnotationWriter->emitBasicBlockStartAnnot(BB, Out);
@@ -1008,7 +1076,7 @@ void AssemblyWriter::printInfoComment(const Value &V) {
       else
         Out << ':' << SlotNum; // Print out the def slot taken.
     }
-    Out << " [#uses=" << V.use_size() << ']';  // Output # uses
+    Out << " [#uses=" << V.getNumUses() << ']';  // Output # uses
   }
 }
 
@@ -1023,10 +1091,14 @@ void AssemblyWriter::printInstruction(const Instruction &I) {
   if (I.hasName())
     Out << getLLVMName(I.getName()) << " = ";
 
-  // If this is a volatile load or store, print out the volatile marker
+  // If this is a volatile load or store, print out the volatile marker.
   if ((isa<LoadInst>(I)  && cast<LoadInst>(I).isVolatile()) ||
-      (isa<StoreInst>(I) && cast<StoreInst>(I).isVolatile()))
+      (isa<StoreInst>(I) && cast<StoreInst>(I).isVolatile())) {
       Out << "volatile ";
+  } else if (isa<CallInst>(I) && cast<CallInst>(I).isTailCall()) {
+    // If this is a call, check if it's a tail call.
+    Out << "tail ";
+  }
 
   // Print out the opcode...
   Out << I.getOpcodeName();
@@ -1060,13 +1132,21 @@ void AssemblyWriter::printInstruction(const Instruction &I) {
 
     for (unsigned op = 0, Eop = I.getNumOperands(); op < Eop; op += 2) {
       if (op) Out << ", ";
-      Out << '[';  
+      Out << '[';
       writeOperand(I.getOperand(op  ), false); Out << ',';
       writeOperand(I.getOperand(op+1), false); Out << " ]";
     }
   } else if (isa<ReturnInst>(I) && !Operand) {
     Out << " void";
-  } else if (isa<CallInst>(I)) {
+  } else if (const CallInst *CI = dyn_cast<CallInst>(&I)) {
+    // Print the calling convention being used.
+    switch (CI->getCallingConv()) {
+    case CallingConv::C: break;   // default
+    case CallingConv::Fast: Out << " fastcc"; break;
+    case CallingConv::Cold: Out << " coldcc"; break;
+    default: Out << " cc" << CI->getCallingConv(); break;
+    }
+
     const PointerType  *PTy = cast<PointerType>(Operand->getType());
     const FunctionType *FTy = cast<FunctionType>(PTy->getElementType());
     const Type       *RetTy = FTy->getReturnType();
@@ -1076,7 +1156,7 @@ void AssemblyWriter::printInstruction(const Instruction &I) {
     // and if the return type is not a pointer to a function.
     //
     if (!FTy->isVarArg() &&
-        (!isa<PointerType>(RetTy) || 
+        (!isa<PointerType>(RetTy) ||
          !isa<FunctionType>(cast<PointerType>(RetTy)->getElementType()))) {
       Out << ' '; printType(RetTy);
       writeOperand(Operand, false);
@@ -1084,7 +1164,7 @@ void AssemblyWriter::printInstruction(const Instruction &I) {
       writeOperand(Operand, true);
     }
     Out << '(';
-    if (I.getNumOperands() > 1) writeOperand(I.getOperand(1), true);
+    if (CI->getNumOperands() > 1) writeOperand(CI->getOperand(1), true);
     for (unsigned op = 2, Eop = I.getNumOperands(); op < Eop; ++op) {
       Out << ',';
       writeOperand(I.getOperand(op), true);
@@ -1096,12 +1176,20 @@ void AssemblyWriter::printInstruction(const Instruction &I) {
     const FunctionType *FTy = cast<FunctionType>(PTy->getElementType());
     const Type       *RetTy = FTy->getReturnType();
 
+    // Print the calling convention being used.
+    switch (II->getCallingConv()) {
+    case CallingConv::C: break;   // default
+    case CallingConv::Fast: Out << " fastcc"; break;
+    case CallingConv::Cold: Out << " coldcc"; break;
+    default: Out << " cc" << II->getCallingConv(); break;
+    }
+
     // If possible, print out the short form of the invoke instruction. We can
     // only do this if the first argument is a pointer to a nonvararg function,
     // and if the return type is not a pointer to a function.
     //
     if (!FTy->isVarArg() &&
-        (!isa<PointerType>(RetTy) || 
+        (!isa<PointerType>(RetTy) ||
          !isa<FunctionType>(cast<PointerType>(RetTy)->getElementType()))) {
       Out << ' '; printType(RetTy);
       writeOperand(Operand, false);
@@ -1128,6 +1216,9 @@ void AssemblyWriter::printInstruction(const Instruction &I) {
       Out << ',';
       writeOperand(AI->getArraySize(), true);
     }
+    if (AI->getAlignment()) {
+      Out << ", align " << AI->getAlignment();
+    }
   } else if (isa<CastInst>(I)) {
     if (Operand) writeOperand(Operand, true);   // Work with broken code
     Out << " to ";
@@ -1136,13 +1227,9 @@ void AssemblyWriter::printInstruction(const Instruction &I) {
     if (Operand) writeOperand(Operand, true);   // Work with broken code
     Out << ", ";
     printType(I.getType());
-  } else if (const VANextInst *VAN = dyn_cast<VANextInst>(&I)) {
-    if (Operand) writeOperand(Operand, true);   // Work with broken code
-    Out << ", ";
-    printType(VAN->getArgType());
   } else if (Operand) {   // Print the normal way...
 
-    // PrintAllTypes - Instructions who have operands of all the same type 
+    // PrintAllTypes - Instructions who have operands of all the same type
     // omit the type from all but the first operand.  If the instruction has
     // different type operands (for example br), then they are all printed.
     bool PrintAllTypes = false;
@@ -1150,7 +1237,7 @@ void AssemblyWriter::printInstruction(const Instruction &I) {
 
     // Shift Left & Right print both types even for Ubyte LHS, and select prints
     // types even if all operands are bools.
-    if (isa<ShiftInst>(I) || isa<SelectInst>(I)) {
+    if (isa<ShiftInst>(I) || isa<SelectInst>(I) || isa<StoreInst>(I)) {
       PrintAllTypes = true;
     } else {
       for (unsigned i = 1, E = I.getNumOperands(); i != E; ++i) {
@@ -1161,7 +1248,7 @@ void AssemblyWriter::printInstruction(const Instruction &I) {
         }
       }
     }
-    
+
     if (!PrintAllTypes) {
       Out << ' ';
       printType(TheType);
@@ -1201,9 +1288,13 @@ void Function::print(std::ostream &o, AssemblyAnnotationWriter *AAW) const {
   W.write(this);
 }
 
+void InlineAsm::print(std::ostream &o, AssemblyAnnotationWriter *AAW) const {
+  WriteAsOperand(o, this, true, true, 0);
+}
+
 void BasicBlock::print(std::ostream &o, AssemblyAnnotationWriter *AAW) const {
   SlotMachine SlotTable(getParent());
-  AssemblyWriter W(o, SlotTable, 
+  AssemblyWriter W(o, SlotTable,
                    getParent() ? getParent()->getParent() : 0, AAW);
   W.write(this);
 }
@@ -1225,7 +1316,7 @@ void Constant::print(std::ostream &o) const {
   WriteConstantInt(o, this, false, TypeTable, 0);
 }
 
-void Type::print(std::ostream &o) const { 
+void Type::print(std::ostream &o) const {
   if (this == 0)
     o << "<null Type>";
   else
@@ -1274,7 +1365,7 @@ CachedWriter &CachedWriter::operator<<(const Value &V) {
     AW->write(F);
   else if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(&V))
     AW->write(GV);
-  else 
+  else
     AW->writeOperand(&V, true, true);
   return *this;
 }
@@ -1301,7 +1392,7 @@ CachedWriter& CachedWriter::operator<<(const Type &Ty) {
 
 // Module level constructor. Causes the contents of the Module (sans functions)
 // to be added to the slot table.
-SlotMachine::SlotMachine(const Module *M) 
+SlotMachine::SlotMachine(const Module *M)
   : TheModule(M)    ///< Saved for lazy initialization.
   , TheFunction(0)
   , FunctionProcessed(false)
@@ -1314,7 +1405,7 @@ SlotMachine::SlotMachine(const Module *M)
 
 // Function level constructor. Causes the contents of the Module and the one
 // function provided to be added to the slot table.
-SlotMachine::SlotMachine(const Function *F ) 
+SlotMachine::SlotMachine(const Function *F )
   : TheModule( F ? F->getParent() : 0 ) ///< Saved for lazy initialization
   , TheFunction(F) ///< Saved for lazy initialization
   , FunctionProcessed(false)
@@ -1326,22 +1417,22 @@ SlotMachine::SlotMachine(const Function *F )
 }
 
 inline void SlotMachine::initialize(void) {
-  if ( TheModule) { 
-    processModule(); 
+  if ( TheModule) {
+    processModule();
     TheModule = 0; ///< Prevent re-processing next time we're called.
   }
-  if ( TheFunction && ! FunctionProcessed) { 
-    processFunction(); 
+  if ( TheFunction && ! FunctionProcessed) {
+    processFunction();
   }
 }
 
 // Iterate through all the global variables, functions, and global
-// variable initializers and create slots for them. 
+// variable initializers and create slots for them.
 void SlotMachine::processModule() {
   SC_DEBUG("begin processModule!\n");
 
   // Add all of the global variables to the value table...
-  for (Module::const_giterator I = TheModule->gbegin(), E = TheModule->gend();
+  for (Module::const_global_iterator I = TheModule->global_begin(), E = TheModule->global_end();
        I != E; ++I)
     createSlot(I);
 
@@ -1359,14 +1450,14 @@ void SlotMachine::processFunction() {
   SC_DEBUG("begin processFunction!\n");
 
   // Add all the function arguments
-  for(Function::const_aiterator AI = TheFunction->abegin(), 
-      AE = TheFunction->aend(); AI != AE; ++AI)
+  for(Function::const_arg_iterator AI = TheFunction->arg_begin(),
+      AE = TheFunction->arg_end(); AI != AE; ++AI)
     createSlot(AI);
 
   SC_DEBUG("Inserting Instructions:\n");
 
   // Add all of the basic blocks and instructions
-  for (Function::const_iterator BB = TheFunction->begin(), 
+  for (Function::const_iterator BB = TheFunction->begin(),
        E = TheFunction->end(); BB != E; ++BB) {
     createSlot(BB);
     for (BasicBlock::const_iterator I = BB->begin(), E = BB->end(); I!=E; ++I) {
@@ -1397,8 +1488,8 @@ void SlotMachine::purgeFunction() {
 /// Types are forbidden because Type does not inherit from Value (any more).
 int SlotMachine::getSlot(const Value *V) {
   assert( V && "Can't get slot for null Value" );
-  assert(!isa<Constant>(V) || isa<GlobalValue>(V) && 
-    "Can't insert a non-GlobalValue Constant into SlotMachine"); 
+  assert(!isa<Constant>(V) || isa<GlobalValue>(V) &&
+    "Can't insert a non-GlobalValue Constant into SlotMachine");
 
   // Check for uninitialized state and do lazy initialization
   this->initialize();
@@ -1425,7 +1516,7 @@ int SlotMachine::getSlot(const Value *V) {
         if (MVI == MI->second.map.end()) return -1;
         assert( MVI != MI->second.map.end() && "Value not found");
         // We found it only at the module level
-        return MVI->second; 
+        return MVI->second;
 
       // else the value exists in the function map
       } else {
@@ -1469,10 +1560,10 @@ int SlotMachine::getSlot(const Type *Ty) {
     if ( FTI == fTypes.map.end() ) {
       TypeMap::const_iterator MTI = mTypes.map.find(Ty);
       // If we didn't find it, it wasn't inserted
-      if (MTI == mTypes.map.end()) 
+      if (MTI == mTypes.map.end())
         return -1;
       // We found it only at the module level
-      return MTI->second; 
+      return MTI->second;
 
     // else the value exists in the function map
     } else {
@@ -1498,8 +1589,8 @@ int SlotMachine::getSlot(const Type *Ty) {
 // of asserting when the Value* isn't found, it inserts the value.
 unsigned SlotMachine::createSlot(const Value *V) {
   assert( V && "Can't insert a null Value to SlotMachine");
-  assert(!isa<Constant>(V) || isa<GlobalValue>(V) && 
-    "Can't insert a non-GlobalValue Constant into SlotMachine"); 
+  assert(!isa<Constant>(V) || isa<GlobalValue>(V) &&
+    "Can't insert a non-GlobalValue Constant into SlotMachine");
 
   const Type* VTy = V->getType();
 
@@ -1567,7 +1658,7 @@ unsigned SlotMachine::createSlot(const Value *V) {
   if ( MI != mMap.end() ) {
     // Lookup the value in the module's map
     ValueMap::const_iterator MVI = MI->second.map.find(V);
-    if ( MVI != MI->second.map.end() ) 
+    if ( MVI != MI->second.map.end() )
       return MVI->second;
   }
 
@@ -1607,7 +1698,7 @@ unsigned SlotMachine::createSlot(const Type *Ty) {
 
   // Lookup the type in the module's map
   TypeMap::const_iterator MTI = mTypes.map.find(Ty);
-  if ( MTI != mTypes.map.end() ) 
+  if ( MTI != mTypes.map.end() )
     return MTI->second;
 
   return insertValue(Ty);
@@ -1617,11 +1708,11 @@ unsigned SlotMachine::createSlot(const Type *Ty) {
 // function is just for the convenience of createSlot (above).
 unsigned SlotMachine::insertValue(const Value *V ) {
   assert(V && "Can't insert a null Value into SlotMachine!");
-  assert(!isa<Constant>(V) || isa<GlobalValue>(V) && 
-    "Can't insert a non-GlobalValue Constant into SlotMachine"); 
+  assert(!isa<Constant>(V) || isa<GlobalValue>(V) &&
+    "Can't insert a non-GlobalValue Constant into SlotMachine");
 
   // If this value does not contribute to a plane (is void)
-  // or if the value already has a name then ignore it. 
+  // or if the value already has a name then ignore it.
   if (V->getType() == Type::VoidTy || V->hasName() ) {
       SC_DEBUG("ignored value " << *V << "\n");
       return 0;   // FIXME: Wrong return value
@@ -1632,7 +1723,7 @@ unsigned SlotMachine::insertValue(const Value *V ) {
 
   if ( TheFunction ) {
     TypedPlanes::iterator I = fMap.find( VTy );
-    if ( I == fMap.end() ) 
+    if ( I == fMap.end() )
       I = fMap.insert(std::make_pair(VTy,ValuePlane())).first;
     DestSlot = I->second.map[V] = I->second.next_slot++;
   } else {
@@ -1642,10 +1733,10 @@ unsigned SlotMachine::insertValue(const Value *V ) {
     DestSlot = I->second.map[V] = I->second.next_slot++;
   }
 
-  SC_DEBUG("  Inserting value [" << VTy << "] = " << V << " slot=" << 
+  SC_DEBUG("  Inserting value [" << VTy << "] = " << V << " slot=" <<
            DestSlot << " [");
   // G = Global, C = Constant, T = Type, F = Function, o = other
-  SC_DEBUG((isa<GlobalVariable>(V) ? 'G' : (isa<Function>(V) ? 'F' : 
+  SC_DEBUG((isa<GlobalVariable>(V) ? 'G' : (isa<Function>(V) ? 'F' :
            (isa<Constant>(V) ? 'C' : 'o'))));
   SC_DEBUG("]\n");
   return DestSlot;