Emit immediate call arguments locally to save stack size when compiling with -O0

lib/Target/X86/X86FastISel.cpp

 //===-- X86FastISel.cpp - X86 FastISel implementation ---------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines the X86-specific support for the FastISel class. Much
@@ skipping 1547 matching lines @@
       Flags.setByValAlign(FrameAlign);
       if (!IsMemcpySmall(FrameSize))
         return false;
     }
 
     if (CS.paramHasAttr(AttrInd, Attribute::InReg))
       Flags.setInReg();
     if (CS.paramHasAttr(AttrInd, Attribute::Nest))
       Flags.setNest();
 
-    // If this is an i1/i8/i16 argument, promote to i32 to avoid an extra
-    // instruction.  This is safe because it is common to all fastisel supported
-    // calling conventions on x86.
+    unsigned ArgReg;
+    MVT ArgVT;
     if (ConstantInt *CI = dyn_cast<ConstantInt>(ArgVal)) {
+      // If this is an i1/i8/i16 argument, promote to i32 to avoid an extra
+      // instruction.  This is safe because it is common to all fastisel
+      // supported calling conventions on x86.
       if (CI->getBitWidth() == 1 || CI->getBitWidth() == 8 ||
           CI->getBitWidth() == 16) {
         if (Flags.isSExt())
           ArgVal = ConstantExpr::getSExt(CI,Type::getInt32Ty(CI->getContext()));
         else
           ArgVal = ConstantExpr::getZExt(CI,Type::getInt32Ty(CI->getContext()));
       }
-    }
 
-    unsigned ArgReg;
-
+      // Emit immediate arguments for the call locally to avoid spilling.
+      if (!isTypeLegal(ArgVal->getType(), ArgVT)) return false;
+      uint64_t val;
+      if (Flags.isSExt())
+        val = CI->getSExtValue();
+      else
+        val = CI->getZExtValue();
+        ArgReg = FastEmit_i(ArgVT, ArgVT, ISD::Constant, val);
+      //      ArgReg = getRegForValue(ArgVal);

[nlewycky, 2011/08/01 20:49:28]

Don't send out a patch with a commented-out line.

[krasin, 2011/08/01 20:55:37]

Shame on me!
Done.

     // Passing bools around ends up doing a trunc to i1 and passing it.
     // Codegen this as an argument + "and 1".
-    if (ArgVal->getType()->isIntegerTy(1) && isa<TruncInst>(ArgVal) &&
+    } else if (ArgVal->getType()->isIntegerTy(1) && isa<TruncInst>(ArgVal) &&
         cast<TruncInst>(ArgVal)->getParent() == I->getParent() &&
         ArgVal->hasOneUse()) {
       ArgVal = cast<TruncInst>(ArgVal)->getOperand(0);
       ArgReg = getRegForValue(ArgVal);
       if (ArgReg == 0) return false;
 
-      MVT ArgVT;
       if (!isTypeLegal(ArgVal->getType(), ArgVT)) return false;
 
       ArgReg = FastEmit_ri(ArgVT, ArgVT, ISD::AND, ArgReg,
                            ArgVal->hasOneUse(), 1);
     } else {
       ArgReg = getRegForValue(ArgVal);
     }
 
     if (ArgReg == 0) return false;
 
     Type *ArgTy = ArgVal->getType();
-    MVT ArgVT;
     if (!isTypeLegal(ArgTy, ArgVT))
       return false;
     if (ArgVT == MVT::x86mmx)
       return false;
     unsigned OriginalAlignment = TD.getABITypeAlignment(ArgTy);
     Flags.setOrigAlign(OriginalAlignment);
 
     Args.push_back(ArgReg);
     ArgVals.push_back(ArgVal);
     ArgVTs.push_back(ArgVT);
@@ skipping 509 matching lines @@
   MI->eraseFromParent();
   return true;
 }
 
 
 namespace llvm {
   llvm::FastISel *X86::createFastISel(FunctionLoweringInfo &funcInfo) {
     return new X86FastISel(funcInfo);
   }
 }