Move FN_NOTE_AlwaysInline and other out of ParamAttrs namespace.

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

diff --git a/lib/VMCore/AsmWriter.cpp b/lib/VMCore/AsmWriter.cpp
index 724b34f460e80dd2462e8fc2f453b10a78138e18..3b9b6690fe94b3352a981bd1203f62a451cec6c7 100644 (file)
--- a/lib/VMCore/AsmWriter.cpp
+++ b/lib/VMCore/AsmWriter.cpp
@@ -41,10 +41,10 @@ AssemblyAnnotationWriter::~AssemblyAnnotationWriter() {}
 
 char PrintModulePass::ID = 0;
 static RegisterPass<PrintModulePass>
-X("printm", "Print module to stderr");
+X("print-module", "Print module to stderr");
 char PrintFunctionPass::ID = 0;
 static RegisterPass<PrintFunctionPass>
-Y("print","Print function to stderr");
+Y("print-function","Print function to stderr");
 
 
 //===----------------------------------------------------------------------===//
@@ -777,15 +777,18 @@ static void WriteConstantInt(raw_ostream &Out, const Constant *CV,
       if (CA->getNumOperands()) {
         Out << ' ';
         printTypeInt(Out, ETy, TypeTable);
+        Out << ' ';
         WriteAsOperandInternal(Out, CA->getOperand(0),
                                TypeTable, Machine);
         for (unsigned i = 1, e = CA->getNumOperands(); i != e; ++i) {
           Out << ", ";
           printTypeInt(Out, ETy, TypeTable);
+          Out << ' ';
           WriteAsOperandInternal(Out, CA->getOperand(i), TypeTable, Machine);
         }
+        Out << ' ';
       }
-      Out << " ]";
+      Out << ']';
     }
     return;
   }
@@ -798,18 +801,21 @@ static void WriteConstantInt(raw_ostream &Out, const Constant *CV,
     if (N) {
       Out << ' ';
       printTypeInt(Out, CS->getOperand(0)->getType(), TypeTable);
+      Out << ' ';
 
       WriteAsOperandInternal(Out, CS->getOperand(0), TypeTable, Machine);
 
       for (unsigned i = 1; i < N; i++) {
         Out << ", ";
         printTypeInt(Out, CS->getOperand(i)->getType(), TypeTable);
+        Out << ' ';
 
         WriteAsOperandInternal(Out, CS->getOperand(i), TypeTable, Machine);
       }
+      Out << ' ';
     }
  
-    Out << " }";
+    Out << '}';
     if (CS->getType()->isPacked())
       Out << '>';
     return;
@@ -821,10 +827,12 @@ static void WriteConstantInt(raw_ostream &Out, const Constant *CV,
            "Number of operands for a PackedConst must be > 0");
     Out << "< ";
     printTypeInt(Out, ETy, TypeTable);
+    Out << ' ';
     WriteAsOperandInternal(Out, CP->getOperand(0), TypeTable, Machine);
     for (unsigned i = 1, e = CP->getNumOperands(); i != e; ++i) {
       Out << ", ";
       printTypeInt(Out, ETy, TypeTable);
+      Out << ' ';
       WriteAsOperandInternal(Out, CP->getOperand(i), TypeTable, Machine);
     }
     Out << " >";
@@ -849,6 +857,7 @@ static void WriteConstantInt(raw_ostream &Out, const Constant *CV,
 
     for (User::const_op_iterator OI=CE->op_begin(); OI != CE->op_end(); ++OI) {
       printTypeInt(Out, (*OI)->getType(), TypeTable);
+      Out << ' ';
       WriteAsOperandInternal(Out, *OI, TypeTable, Machine);
       if (OI+1 != CE->op_end())
         Out << ", ";
@@ -880,7 +889,6 @@ static void WriteConstantInt(raw_ostream &Out, const Constant *CV,
 static void WriteAsOperandInternal(raw_ostream &Out, const Value *V,
                                   std::map<const Type*, std::string> &TypeTable,
                                    SlotTracker *Machine) {
-  Out << ' ';
   if (V->hasName()) {
     PrintLLVMName(Out, V);
     return;
@@ -952,8 +960,10 @@ void llvm::WriteAsOperand(raw_ostream &Out, const Value *V, bool PrintType,
   if (Context)
     fillTypeNameTable(Context, TypeNames);
 
-  if (PrintType)
+  if (PrintType) {
     printTypeInt(Out, V->getType(), TypeNames);
+    Out << ' ';
+  }
 
   WriteAsOperandInternal(Out, V, TypeNames, 0);
 }
@@ -996,7 +1006,7 @@ public:
   void write(const Type *Ty)          { printType(Ty);        }
 
   void writeOperand(const Value *Op, bool PrintType);
-  void writeParamOperand(const Value *Operand, ParameterAttributes Attrs);
+  void writeParamOperand(const Value *Operand, Attributes Attrs);
 
   const Module* getModule() { return TheModule; }
 
@@ -1006,7 +1016,7 @@ private:
   void printGlobal(const GlobalVariable *GV);
   void printAlias(const GlobalAlias *GV);
   void printFunction(const Function *F);
-  void printArgument(const Argument *FA, ParameterAttributes Attrs);
+  void printArgument(const Argument *FA, Attributes Attrs);
   void printBasicBlock(const BasicBlock *BB);
   void printInstruction(const Instruction &I);
 
@@ -1108,24 +1118,24 @@ void AssemblyWriter::writeOperand(const Value *Operand, bool PrintType) {
     Out << "<null operand!>";
   } else {
     if (PrintType) {
-      Out << ' ';
       printType(Operand->getType());
+      Out << ' ';
     }
     WriteAsOperandInternal(Out, Operand, TypeNames, &Machine);
   }
 }
 
 void AssemblyWriter::writeParamOperand(const Value *Operand, 
-                                       ParameterAttributes Attrs) {
+                                       Attributes Attrs) {
   if (Operand == 0) {
     Out << "<null operand!>";
   } else {
-    Out << ' ';
     // Print the type
     printType(Operand->getType());
     // Print parameter attributes list
     if (Attrs != ParamAttr::None)
       Out << ' ' << ParamAttr::getAsString(Attrs);
+    Out << ' ';
     // Print the operand
     WriteAsOperandInternal(Out, Operand, TypeNames, &Machine);
   }
@@ -1239,8 +1249,10 @@ void AssemblyWriter::printGlobal(const GlobalVariable *GV) {
   Out << (GV->isConstant() ? "constant " : "global ");
   printType(GV->getType()->getElementType());
 
-  if (GV->hasInitializer())
+  if (GV->hasInitializer()) {
+    Out << ' ';
     writeOperand(GV->getInitializer(), false);
+  }
 
   if (unsigned AddressSpace = GV->getType()->getAddressSpace())
     Out << " addrspace(" << AddressSpace << ") ";
@@ -1374,7 +1386,7 @@ void AssemblyWriter::printFunction(const Function *F) {
       // Output type...
       printType(FT->getParamType(i));
       
-      ParameterAttributes ArgAttrs = Attrs.getParamAttrs(i+1);
+      Attributes ArgAttrs = Attrs.getParamAttrs(i+1);
       if (ArgAttrs != ParamAttr::None)
         Out << ' ' << ParamAttr::getAsString(ArgAttrs);
     }
@@ -1386,7 +1398,7 @@ void AssemblyWriter::printFunction(const Function *F) {
     Out << "...";  // Output varargs portion of signature!
   }
   Out << ')';
-  ParameterAttributes RetAttrs = Attrs.getParamAttrs(0);
+  Attributes RetAttrs = Attrs.getParamAttrs(0);
   if (RetAttrs != ParamAttr::None)
     Out << ' ' << ParamAttr::getAsString(Attrs.getParamAttrs(0));
   if (F->hasSection())
@@ -1395,18 +1407,37 @@ void AssemblyWriter::printFunction(const Function *F) {
     Out << " align " << F->getAlignment();
   if (F->hasGC())
     Out << " gc \"" << F->getGC() << '"';
-  FunctionNotes FNotes = F->getNotes();
-  if (FNotes != FP_None) {
-    Out << " notes(";
-    if (FNotes & FP_AlwaysInline)
-      Out << "inline=always";
-    else if (FNotes & FP_NoInline)
-      Out << "inline=never";
-    Out << ")";
-  }
   if (F->isDeclaration()) {
     Out << "\n";
   } else {
+
+    bool insideNotes = false;
+    if (F->hasNote(FN_NOTE_AlwaysInline)) {
+      Out << "notes(";
+      insideNotes = true;
+      Out << "inline=always";
+    }
+    if (F->hasNote(FN_NOTE_NoInline)) {
+      if (insideNotes) 
+        Out << ",";
+      else {
+        Out << "notes(";
+        insideNotes = true;
+      }
+      Out << "inline=never";
+    }
+    if (F->hasNote(FN_NOTE_OptimizeForSize)) {
+      if (insideNotes) 
+        Out << ",";
+      else {
+        Out << "notes(";
+        insideNotes = true;
+      }
+      Out << "opt_size";
+    }
+    if (insideNotes)
+      Out << ")";
+    
     Out << " {";
 
     // Output all of its basic blocks... for the function
@@ -1423,7 +1454,7 @@ void AssemblyWriter::printFunction(const Function *F) {
 /// the function.  Simply print it out
 ///
 void AssemblyWriter::printArgument(const Argument *Arg, 
-                                   ParameterAttributes Attrs) {
+                                   Attributes Attrs) {
   // Output type...
   printType(Arg->getType());
 
@@ -1464,10 +1495,10 @@ void AssemblyWriter::printBasicBlock(const BasicBlock *BB) {
     if (PI == PE) {
       Out << " No predecessors!";
     } else {
-      Out << " preds =";
+      Out << " preds = ";
       writeOperand(*PI, false);
       for (++PI; PI != PE; ++PI) {
-        Out << ',';
+        Out << ", ";
         writeOperand(*PI, false);
       }
     }
@@ -1549,23 +1580,25 @@ void AssemblyWriter::printInstruction(const Instruction &I) {
 
   // Special case conditional branches to swizzle the condition out to the front
   if (isa<BranchInst>(I) && I.getNumOperands() > 1) {
+    Out << ' ';
     writeOperand(I.getOperand(2), true);
-    Out << ',';
+    Out << ", ";
     writeOperand(Operand, true);
-    Out << ',';
+    Out << ", ";
     writeOperand(I.getOperand(1), true);
 
   } else if (isa<SwitchInst>(I)) {
     // Special case switch statement to get formatting nice and correct...
+    Out << ' ';
     writeOperand(Operand        , true);
-    Out << ',';
+    Out << ", ";
     writeOperand(I.getOperand(1), true);
     Out << " [";
 
     for (unsigned op = 2, Eop = I.getNumOperands(); op < Eop; op += 2) {
       Out << "\n\t\t";
       writeOperand(I.getOperand(op  ), true);
-      Out << ',';
+      Out << ", ";
       writeOperand(I.getOperand(op+1), true);
     }
     Out << "\n\t]";
@@ -1576,16 +1609,18 @@ void AssemblyWriter::printInstruction(const Instruction &I) {
 
     for (unsigned op = 0, Eop = I.getNumOperands(); op < Eop; op += 2) {
       if (op) Out << ", ";
-      Out << '[';
-      writeOperand(I.getOperand(op  ), false); Out << ',';
+      Out << "[ ";
+      writeOperand(I.getOperand(op  ), false); Out << ", ";
       writeOperand(I.getOperand(op+1), false); Out << " ]";
     }
   } else if (const ExtractValueInst *EVI = dyn_cast<ExtractValueInst>(&I)) {
+    Out << ' ';
     writeOperand(I.getOperand(0), true);
     for (const unsigned *i = EVI->idx_begin(), *e = EVI->idx_end(); i != e; ++i)
       Out << ", " << *i;
   } else if (const InsertValueInst *IVI = dyn_cast<InsertValueInst>(&I)) {
-    writeOperand(I.getOperand(0), true); Out << ',';
+    Out << ' ';
+    writeOperand(I.getOperand(0), true); Out << ", ";
     writeOperand(I.getOperand(1), true);
     for (const unsigned *i = IVI->idx_begin(), *e = IVI->idx_end(); i != e; ++i)
       Out << ", " << *i;
@@ -1612,10 +1647,12 @@ 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 {
       writeOperand(Operand, true);
@@ -1623,10 +1660,10 @@ void AssemblyWriter::printInstruction(const Instruction &I) {
     Out << '(';
     for (unsigned op = 1, Eop = I.getNumOperands(); op < Eop; ++op) {
       if (op > 1)
-        Out << ',';
+        Out << ", ";
       writeParamOperand(I.getOperand(op), PAL.getParamAttrs(op));
     }
-    Out << " )";
+    Out << ')';
     if (PAL.getParamAttrs(0) != ParamAttr::None)
       Out << ' ' << ParamAttr::getAsString(PAL.getParamAttrs(0));
   } else if (const InvokeInst *II = dyn_cast<InvokeInst>(&I)) {
@@ -1640,9 +1677,9 @@ void AssemblyWriter::printInstruction(const Instruction &I) {
     case CallingConv::C: break;   // default
     case CallingConv::Fast:  Out << " fastcc"; break;
     case CallingConv::Cold:  Out << " coldcc"; break;
-    case CallingConv::X86_StdCall:  Out << "x86_stdcallcc "; break;
-    case CallingConv::X86_FastCall: Out << "x86_fastcallcc "; break;
-    case CallingConv::X86_SSECall: Out << "x86_ssecallcc "; break;
+    case CallingConv::X86_StdCall:  Out << " x86_stdcallcc"; break;
+    case CallingConv::X86_FastCall: Out << " x86_fastcallcc"; break;
+    case CallingConv::X86_SSECall: Out << " x86_ssecallcc"; break;
     default: Out << " cc" << II->getCallingConv(); break;
     }
 
@@ -1656,40 +1693,47 @@ void AssemblyWriter::printInstruction(const Instruction &I) {
       Out << ' '; printType(RetTy);
       writeOperand(Operand, false);
     } else {
+      Out << ' ';
       writeOperand(Operand, true);
     }
 
     Out << '(';
     for (unsigned op = 3, Eop = I.getNumOperands(); op < Eop; ++op) {
       if (op > 3)
-        Out << ',';
+        Out << ", ";
       writeParamOperand(I.getOperand(op), PAL.getParamAttrs(op-2));
     }
 
-    Out << " )";
+    Out << ')';
     if (PAL.getParamAttrs(0) != ParamAttr::None)
       Out << ' ' << ParamAttr::getAsString(PAL.getParamAttrs(0));
-    Out << "\n\t\t\tto";
+    Out << "\n\t\t\tto ";
     writeOperand(II->getNormalDest(), true);
-    Out << " unwind";
+    Out << " unwind ";
     writeOperand(II->getUnwindDest(), true);
 
   } else if (const AllocationInst *AI = dyn_cast<AllocationInst>(&I)) {
     Out << ' ';
     printType(AI->getType()->getElementType());
     if (AI->isArrayAllocation()) {
-      Out << ',';
+      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
+    if (Operand) {
+      Out << ' ';
+      writeOperand(Operand, true);   // Work with broken code
+    }
     Out << " to ";
     printType(I.getType());
   } else if (isa<VAArgInst>(I)) {
-    if (Operand) writeOperand(Operand, true);   // Work with broken code
+    if (Operand) {
+      Out << ' ';
+      writeOperand(Operand, true);   // Work with broken code
+    }
     Out << ", ";
     printType(I.getType());
   } else if (Operand) {   // Print the normal way...
@@ -1719,8 +1763,9 @@ void AssemblyWriter::printInstruction(const Instruction &I) {
       printType(TheType);
     }
 
+    Out << ' ';
     for (unsigned i = 0, E = I.getNumOperands(); i != E; ++i) {
-      if (i) Out << ',';
+      if (i) Out << ", ";
       writeOperand(I.getOperand(i), PrintAllTypes);
     }
   }