Various random and minor code cleanups.

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

lib/Target/X86/X86ATTAsmPrinter.cpp

@@ -48,9 +48,8 @@ bool X86ATTAsmPrinter::runOnMachineFunction(MachineFunction &MF) {
 
   // Populate function information map.  Actually, We don't want to populate
   // non-stdcall or non-fastcall functions' information right now.
-  if (CC == CallingConv::X86_StdCall || CC == CallingConv::X86_FastCall) {
-    FunctionInfoMap[F] = *(MF.getInfo<X86FunctionInfo>());
-  }
+  if (CC == CallingConv::X86_StdCall || CC == CallingConv::X86_FastCall)
+    FunctionInfoMap[F] = *MF.getInfo<X86FunctionInfo>();
 
   X86SharedAsmPrinter::decorateName(CurrentFnName, F);
 
@@ -200,7 +199,7 @@ void X86ATTAsmPrinter::printOperand(const MachineInstr *MI, unsigned OpNo,
     bool isExt = (GV->isExternal() || GV->hasWeakLinkage() ||
                   GV->hasLinkOnceLinkage());
     
-    X86SharedAsmPrinter::decorateName(Name, (Function*)GV);
+    X86SharedAsmPrinter::decorateName(Name, GV);
     
     if (X86PICStyle == PICStyle::Stub &&
         TM.getRelocationModel() != Reloc::Static) {

lib/Target/X86/X86AsmPrinter.cpp

@@ -33,88 +33,75 @@ using namespace llvm;
 Statistic<> llvm::EmittedInsts("asm-printer",
                                "Number of machine instrs printed");
 
-static X86FunctionInfo calculateFunctionInfo(const Function* F,
-                                             const TargetData* TD) 
-{
+static X86FunctionInfo calculateFunctionInfo(const Function *F,
+                                             const TargetData *TD) {
   X86FunctionInfo Info;
-  uint64_t size = 0;
+  uint64_t Size = 0;
   
   switch (F->getCallingConv()) {
-   case CallingConv::X86_StdCall:
+  case CallingConv::X86_StdCall:
     Info.setDecorationStyle(StdCall);
     break;
-   case CallingConv::X86_FastCall:
+  case CallingConv::X86_FastCall:
     Info.setDecorationStyle(FastCall);
     break;
-   default:
+  default:
     return Info;
   }
 
-  for (Function::const_arg_iterator AI = F->arg_begin(),
-                                    AE = F->arg_end();
-       AI != AE;
-       ++AI) {
-    size += TD->getTypeSize(AI->getType());
-  }
+  for (Function::const_arg_iterator AI = F->arg_begin(), AE = F->arg_end();
+       AI != AE; ++AI)
+    Size += TD->getTypeSize(AI->getType());
 
   // We're not supporting tooooo huge arguments :)
-  Info.setBytesToPopOnReturn((unsigned int)size);
-    
+  Info.setBytesToPopOnReturn((unsigned int)Size);
   return Info;
 }
 
 
-// Query FunctionInfoMap and use this information for various name decoration
-void X86SharedAsmPrinter::decorateName(std::string& Name, const GlobalValue* GV)
-{
-  const X86FunctionInfo* Info;
-  const Function* F;
-  
-  if ((F = dyn_cast<Function>(GV)) == NULL) {
-    return;
-  }
-
-  unsigned CC = F->getCallingConv();
+/// decorateName - Query FunctionInfoMap and use this information for various
+/// name decoration.
+void X86SharedAsmPrinter::decorateName(std::string &Name,
+                                       const GlobalValue *GV) {
+  const Function *F = dyn_cast<Function>(GV);
+  if (!F) return;
 
   // We don't want to decorate non-stdcall or non-fastcall functions right now
-  if (CC != CallingConv::X86_StdCall && CC != CallingConv::X86_FastCall) {
+  unsigned CC = F->getCallingConv();
+  if (CC != CallingConv::X86_StdCall && CC != CallingConv::X86_FastCall)
     return;
-  }
     
   FMFInfoMap::const_iterator info_item = FunctionInfoMap.find(F);
 
+  const X86FunctionInfo *Info;
   if (info_item == FunctionInfoMap.end()) {
     // Calculate apropriate function info and populate map
     FunctionInfoMap[F] = calculateFunctionInfo(F, TM.getTargetData());
     Info = &FunctionInfoMap[F];
   } else {
-    Info = &(info_item->second);
+    Info = &info_item->second;
   }
         
   switch (Info->getDecorationStyle()) {
-   case None:
+  case None:
     break;
-   case StdCall:
-    if (!F->isVarArg()) {
-      // Variadic functions do not receive @0 suffix
+  case StdCall:
+    if (!F->isVarArg()) // Variadic functions do not receive @0 suffix.
       Name += '@' + utostr_32(Info->getBytesToPopOnReturn());
-    }    
     break;
-   case FastCall:
-    if (!F->isVarArg()) {
-      // Variadic functions do not receive @0 suffix
+  case FastCall:
+    if (!F->isVarArg()) // Variadic functions do not receive @0 suffix.
       Name += '@' + utostr_32(Info->getBytesToPopOnReturn());
-    }
+
     if (Name[0] == '_') {
       Name[0] = '@';
     } else {
       Name = '@' + Name;
     }    
     break;
-   default:
+  default:
     assert(0 && "Unsupported DecorationStyle");
   }
-    
 }
 
 /// doInitialization

lib/Target/X86/X86AsmPrinter.h

@@ -46,19 +46,18 @@ struct VISIBILITY_HIDDEN X86SharedAsmPrinter : public AsmPrinter {
     Subtarget = &TM.getSubtarget<X86Subtarget>();
   }
 
-  typedef std::map<const Function*, X86FunctionInfo> FMFInfoMap ;
-
   // We have to propagate some information about MachineFunction to
   // AsmPrinter. It's ok, when we're printing the function, since we have
-  // access to MachineFunction and can get the appropriate  MachineFunctionInfo.
+  // access to MachineFunction and can get the appropriate MachineFunctionInfo.
   // Unfortunately, this is not possible when we're printing reference to
   // Function (e.g. calling it and so on). Even more, there is no way to get the
   // corresponding MachineFunctions: it can even be not created at all. That's
   // why we should use additional structure, when we're collecting all necessary
   // information.
-
+  //
   // This structure is using e.g. for name decoration for stdcall & fastcall'ed
   // function, since we have to use arguments' size for decoration.
+  typedef std::map<const Function*, X86FunctionInfo> FMFInfoMap;
   FMFInfoMap FunctionInfoMap;
 
   void decorateName(std::string& Name, const GlobalValue* GV);

lib/Target/X86/X86ISelLowering.cpp

@@ -1523,9 +1523,8 @@ X86TargetLowering::LowerFastCCArguments(SDOperand Op, SelectionDAG &DAG) {
   return DAG.getNode(ISD::MERGE_VALUES, RetVTs, &ArgValues[0],ArgValues.size());
 }
 
-SDOperand X86TargetLowering::LowerFastCCCallTo(SDOperand Op,
-                                               SelectionDAG &DAG,
-                                               bool isFastCall){
+SDOperand X86TargetLowering::LowerFastCCCallTo(SDOperand Op, SelectionDAG &DAG,
+                                               bool isFastCall) {
   SDOperand Chain     = Op.getOperand(0);
   unsigned CallingConv= cast<ConstantSDNode>(Op.getOperand(1))->getValue();
   bool isVarArg       = cast<ConstantSDNode>(Op.getOperand(2))->getValue() != 0;

lib/Target/X86/X86IntelAsmPrinter.cpp

@@ -36,14 +36,13 @@ bool X86IntelAsmPrinter::runOnMachineFunction(MachineFunction &MF) {
   EmitConstantPool(MF.getConstantPool());
 
   // Print out labels for the function.
-  const Function* F = MF.getFunction();
+  const Function *F = MF.getFunction();
   unsigned CC = F->getCallingConv();
 
   // Populate function information map.  Actually, We don't want to populate
   // non-stdcall or non-fastcall functions' information right now.
-  if (CC == CallingConv::X86_StdCall || CC == CallingConv::X86_FastCall) {
-    FunctionInfoMap[F] = *(MF.getInfo<X86FunctionInfo>());
-  }
+  if (CC == CallingConv::X86_StdCall || CC == CallingConv::X86_FastCall)
+    FunctionInfoMap[F] = *MF.getInfo<X86FunctionInfo>();
 
   X86SharedAsmPrinter::decorateName(CurrentFnName, F);
 

lib/Target/X86/X86MachineFunctionInfo.h

@@ -46,7 +46,7 @@ public:
                       BytesToPopOnReturn(0),
                       DecorationStyle(None) {}
   
-  X86FunctionInfo(MachineFunction& MF) : ForceFramePointer(false),
+  X86FunctionInfo(MachineFunction &MF) : ForceFramePointer(false),
                                          BytesToPopOnReturn(0),
                                          DecorationStyle(None) {}