Rearrange code to reduce the nesting level. No functionality change.

[oota-llvm.git] / lib / VMCore / AsmWriter.cpp

diff --git a/lib/VMCore/AsmWriter.cpp b/lib/VMCore/AsmWriter.cpp
index 0080d63b63a0ce43d9e5403265f93204b21dd98e..2f6c1cc0f27b71a32a42a652d82c452e9f9729a1 100644 (file)
--- a/lib/VMCore/AsmWriter.cpp
+++ b/lib/VMCore/AsmWriter.cpp
@@ -39,14 +39,6 @@ using namespace llvm;
 // Make virtual table appear in this compilation unit.
 AssemblyAnnotationWriter::~AssemblyAnnotationWriter() {}
 
-char PrintModulePass::ID = 0;
-static RegisterPass<PrintModulePass>
-X("print-module", "Print module to stderr");
-char PrintFunctionPass::ID = 0;
-static RegisterPass<PrintFunctionPass>
-Y("print-function","Print function to stderr");
-
-
 //===----------------------------------------------------------------------===//
 // Helper Functions
 //===----------------------------------------------------------------------===//
@@ -68,6 +60,25 @@ static const Module *getModuleFromVal(const Value *V) {
   return 0;
 }
 
+// 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 char *Str, unsigned Length,
+                               raw_ostream &Out) {
+  for (unsigned i = 0; i != Length; ++i) {
+    unsigned char C = Str[i];
+    if (isprint(C) && C != '\\' && C != '"' && isprint(C))
+      Out << C;
+    else
+      Out << '\\' << hexdigit(C >> 4) << hexdigit(C & 0x0F);
+  }
+}
+
+// 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, raw_ostream &Out) {
+  PrintEscapedString(Str.c_str(), Str.size(), Out);
+}
+
 enum PrefixType {
   GlobalPrefix,
   LabelPrefix,
@@ -90,7 +101,7 @@ static void PrintLLVMName(raw_ostream &OS, const char *NameStr,
   }      
   
   // Scan the name to see if it needs quotes first.
-  bool NeedsQuotes = NameStr[0] >= '0' && NameStr[0] <= '9';
+  bool NeedsQuotes = isdigit(NameStr[0]);
   if (!NeedsQuotes) {
     for (unsigned i = 0; i != NameLen; ++i) {
       char C = NameStr[i];
@@ -110,18 +121,7 @@ static void PrintLLVMName(raw_ostream &OS, const char *NameStr,
   // Okay, we need quotes.  Output the quotes and escape any scary characters as
   // needed.
   OS << '"';
-  for (unsigned i = 0; i != NameLen; ++i) {
-    char C = NameStr[i];
-    if (C == '\\') {
-      OS << "\\\\";
-    } else if (C != '"' && isprint(C)) {
-      OS << C;
-    } else {
-      OS << '\\';
-      OS << hexdigit((C >> 4) & 0x0F);
-      OS << hexdigit((C >> 0) & 0x0F);
-    }
-  }
+  PrintEscapedString(NameStr, NameLen, OS);
   OS << '"';
 }
 
@@ -587,21 +587,6 @@ void llvm::WriteTypeSymbolic(raw_ostream &Out, const Type *Ty, const Module *M){
   }
 }
 
-// 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, raw_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'));
-    }
-  }
-}
-
 static const char *getPredicateText(unsigned predicate) {
   const char * pred = "unknown";
   switch (predicate) {
@@ -677,7 +662,8 @@ static void WriteConstantInt(raw_ostream &Out, const Constant *CV,
       // output the string in hexadecimal format!
       assert(sizeof(double) == sizeof(uint64_t) &&
              "assuming that double is 64 bits!");
-      Out << "0x" << utohexstr(DoubleToBits(Val));
+      char Buffer[40];
+      Out << "0x" << utohex_buffer(uint64_t(DoubleToBits(Val)), Buffer+40);
       return;
     }
     
@@ -1621,16 +1607,16 @@ void AssemblyWriter::printInstruction(const Instruction &I) {
     // 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.
     //
+    Out << ' ';
     if (!FTy->isVarArg() &&
         (!isa<PointerType>(RetTy) ||
          !isa<FunctionType>(cast<PointerType>(RetTy)->getElementType()))) {
-      Out << ' '; printType(RetTy);
+      printType(RetTy);
+      Out << ' ';
       writeOperand(Operand, false);
     } else {
-      Out << ' ';
       writeOperand(Operand, true);
     }
-
     Out << '(';
     for (unsigned op = 3, Eop = I.getNumOperands(); op < Eop; ++op) {
       if (op > 3)