Various random and minor code cleanups.

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

diff --git a/lib/Target/X86/X86ATTAsmPrinter.cpp b/lib/Target/X86/X86ATTAsmPrinter.cpp
index 093940f0854830823962695d4de446126bbc7837..6f34ca5c1341584d309587ef52e7de88468fa6af 100755 (executable)
--- a/lib/Target/X86/X86ATTAsmPrinter.cpp
+++ b/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) {

diff --git a/lib/Target/X86/X86AsmPrinter.cpp b/lib/Target/X86/X86AsmPrinter.cpp
index 7dcdd96592d8fa7019aebbce8cc1f48f5078ff25..4ab72eef8ef167d6473961a2f900af1eb87ed04c 100644 (file)
--- a/lib/Target/X86/X86AsmPrinter.cpp
+++ b/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

diff --git a/lib/Target/X86/X86AsmPrinter.h b/lib/Target/X86/X86AsmPrinter.h
index 3222da5717d2bd93c4baabe6e734e46a3601491f..1bbfa559e6e9ace06175284b2e079af09b04d991 100755 (executable)
--- a/lib/Target/X86/X86AsmPrinter.h
+++ b/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);

diff --git a/lib/Target/X86/X86ISelLowering.cpp b/lib/Target/X86/X86ISelLowering.cpp
index 446ec15c3b9781dd97d5825ae172af845e7cb2c4..6154595ed6d2f5c7d94312ca1821bcff19daa825 100644 (file)
--- a/lib/Target/X86/X86ISelLowering.cpp
+++ b/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;

diff --git a/lib/Target/X86/X86IntelAsmPrinter.cpp b/lib/Target/X86/X86IntelAsmPrinter.cpp
index ddbe2e0530ff02acf3f908872871eb22b0ba3497..705488a6c2f356e47704d692500a41897a948186 100755 (executable)
--- a/lib/Target/X86/X86IntelAsmPrinter.cpp
+++ b/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);
 

diff --git a/lib/Target/X86/X86MachineFunctionInfo.h b/lib/Target/X86/X86MachineFunctionInfo.h
index 3fa4fadeb81f507649e604b0badb8ddf6bde0a57..4ec3ba3fd3d6e83b8df93deac58471561a88bf4a 100644 (file)
--- a/lib/Target/X86/X86MachineFunctionInfo.h
+++ b/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) {}