@@ -79,9 +79,9 @@ public:

   /// getEntryAlignment - Return the alignment of each entry in the jump table.

   unsigned getEntryAlignment(const TargetData &TD) const;

-  /// getJumpTableIndex - Create a new jump table or return an existing one.

+  /// createJumpTableIndex - Create a new jump table.

   ///

-  unsigned getJumpTableIndex(const std::vector<MachineBasicBlock*> &DestBBs);

+  unsigned createJumpTableIndex(const std::vector<MachineBasicBlock*> &DestBBs);

   /// isEmpty - Return true if there are no jump tables.

   ///

@@ -779,7 +779,7 @@ unsigned llvm::ComputeNumSignBits(Value *V, const TargetData *TD,

     for (unsigned i = 1, e = PN->getNumIncomingValues(); i != e; ++i) {

       if (Tmp == 1) return Tmp;

       Tmp = std::min(Tmp,

-                     ComputeNumSignBits(PN->getIncomingValue(1), TD, Depth+1));

+                     ComputeNumSignBits(PN->getIncomingValue(i), TD, Depth+1));

     }

     return Tmp;

   }

@@ -203,7 +203,7 @@ bool BranchFolder::OptimizeFunction(MachineFunction &MF,

     MadeChange |= MadeChangeThisIteration;

   }

-  // See if any jump tables have become mergable or dead as the code generator

+  // See if any jump tables have become dead as the code generator

   // did its thing.

   MachineJumpTableInfo *JTI = MF.getJumpTableInfo();

   if (JTI == 0) {

@@ -211,27 +211,8 @@ bool BranchFolder::OptimizeFunction(MachineFunction &MF,

     return MadeChange;

   }

-  const std::vector<MachineJumpTableEntry> &JTs = JTI->getJumpTables();

-  // Figure out how these jump tables should be merged.

-  std::vector<unsigned> JTMapping;

-  JTMapping.reserve(JTs.size());

-

-  // We always keep the 0th jump table.

-  JTMapping.push_back(0);

-

-  // Scan the jump tables, seeing if there are any duplicates.  Note that this

-  // is N^2, which should be fixed someday.

-  for (unsigned i = 1, e = JTs.size(); i != e; ++i) {

-    if (JTs[i].MBBs.empty())

-      JTMapping.push_back(i);

-    else

-      JTMapping.push_back(JTI->getJumpTableIndex(JTs[i].MBBs));

-  }

-

-  // If a jump table was merge with another one, walk the function rewriting

-  // references to jump tables to reference the new JT ID's.  Keep track of

-  // whether we see a jump table idx, if not, we can delete the JT.

-  BitVector JTIsLive(JTs.size());

+  // Walk the function to find jump tables that are live.

+  BitVector JTIsLive(JTI->getJumpTables().size());

   for (MachineFunction::iterator BB = MF.begin(), E = MF.end();

        BB != E; ++BB) {

     for (MachineBasicBlock::iterator I = BB->begin(), E = BB->end();

@@ -239,17 +220,14 @@ bool BranchFolder::OptimizeFunction(MachineFunction &MF,

       for (unsigned op = 0, e = I->getNumOperands(); op != e; ++op) {

         MachineOperand &Op = I->getOperand(op);

         if (!Op.isJTI()) continue;

-        unsigned NewIdx = JTMapping[Op.getIndex()];

-        Op.setIndex(NewIdx);

         // Remember that this JT is live.

-        JTIsLive.set(NewIdx);

+        JTIsLive.set(Op.getIndex());

       }

   }

-  // Finally, remove dead jump tables.  This happens either because the

-  // indirect jump was unreachable (and thus deleted) or because the jump

-  // table was merged with some other one.

+  // Finally, remove dead jump tables.  This happens when the

+  // indirect jump was unreachable (and thus deleted).

   for (unsigned i = 0, e = JTIsLive.size(); i != e; ++i)

     if (!JTIsLive.test(i)) {

       JTI->RemoveJumpTable(i);

@@ -594,17 +594,15 @@ unsigned MachineJumpTableInfo::getEntryAlignment(const TargetData &TD) const {

   return ~0;

 }

-/// getJumpTableIndex - Create a new jump table entry in the jump table info

-/// or return an existing one.

+/// createJumpTableIndex - Create a new jump table entry in the jump table info.

 ///

-unsigned MachineJumpTableInfo::getJumpTableIndex(

+unsigned MachineJumpTableInfo::createJumpTableIndex(

                                const std::vector<MachineBasicBlock*> &DestBBs) {

   assert(!DestBBs.empty() && "Cannot create an empty jump table!");

   JumpTables.push_back(MachineJumpTableEntry(DestBBs));

   return JumpTables.size()-1;

 }

-

 /// ReplaceMBBInJumpTables - If Old is the target of any jump tables, update

 /// the jump tables to branch to New instead.

 bool MachineJumpTableInfo::ReplaceMBBInJumpTables(MachineBasicBlock *Old,

@@ -1674,11 +1674,10 @@ bool SelectionDAGBuilder::handleJTSwitchCase(CaseRec& CR,

     }

   }

-  // Create a jump table index for this jump table, or return an existing

-  // one.

+  // Create a jump table index for this jump table.

   unsigned JTEncoding = TLI.getJumpTableEncoding();

   unsigned JTI = CurMF->getOrCreateJumpTableInfo(JTEncoding)

-                       ->getJumpTableIndex(DestBBs);

+                       ->createJumpTableIndex(DestBBs);

   // Set the jump table information so that we can codegen it as a second

   // MachineBasicBlock

@@ -1477,7 +1477,6 @@ X86TargetLowering::LowerFormalArguments(SDValue Chain,

                                         DebugLoc dl,

                                         SelectionDAG &DAG,

                                         SmallVectorImpl<SDValue> &InVals) {

-

   MachineFunction &MF = DAG.getMachineFunction();

   X86MachineFunctionInfo *FuncInfo = MF.getInfo<X86MachineFunctionInfo>();

@@ -1779,7 +1778,8 @@ X86TargetLowering::LowerCall(SDValue Chain, SDValue Callee,

   if (isTailCall) {

     // Check if it's really possible to do a tail call.

-    isTailCall = IsEligibleForTailCallOptimization(Callee, CallConv, isVarArg,

+    isTailCall = IsEligibleForTailCallOptimization(Callee, CallConv,

+                    isVarArg, IsStructRet, MF.getFunction()->hasStructRetAttr(),

                                                    Outs, Ins, DAG);

     // Sibcalls are automatically detected tailcalls which do not require

@@ -2297,6 +2297,8 @@ bool

 X86TargetLowering::IsEligibleForTailCallOptimization(SDValue Callee,

                                                      CallingConv::ID CalleeCC,

                                                      bool isVarArg,

+                                                     bool isCalleeStructRet,

+                                                     bool isCallerStructRet,

                                     const SmallVectorImpl<ISD::OutputArg> &Outs,

                                     const SmallVectorImpl<ISD::InputArg> &Ins,

                                                      SelectionDAG& DAG) const {

@@ -2316,10 +2318,37 @@ X86TargetLowering::IsEligibleForTailCallOptimization(SDValue Callee,

   // Look for obvious safe cases to perform tail call optimization that does not

   // requite ABI changes. This is what gcc calls sibcall.

-  // Do not tail call optimize vararg calls for now.

+  // Do not sibcall optimize vararg calls for now.

   if (isVarArg)

     return false;

+  // Also avoid sibcall optimization if either caller or callee uses struct

+  // return semantics.

+  if (isCalleeStructRet || isCallerStructRet)

+    return false;

+

+  // If the call result is in ST0 / ST1, it needs to be popped off the x87 stack.

+  // Therefore if it's not used by the call it is not safe to optimize this into

+  // a sibcall.

+  bool Unused = false;

+  for (unsigned i = 0, e = Ins.size(); i != e; ++i) {

+    if (!Ins[i].Used) {

+      Unused = true;

+      break;

+    }

+  }

+  if (Unused) {

+    SmallVector<CCValAssign, 16> RVLocs;

+    CCState CCInfo(CalleeCC, false, getTargetMachine(),

+                   RVLocs, *DAG.getContext());

+    CCInfo.AnalyzeCallResult(Ins, RetCC_X86);

+    for (unsigned i = 0; i != RVLocs.size(); ++i) {

+      CCValAssign &VA = RVLocs[i];

+      if (VA.getLocReg() == X86::ST0 || VA.getLocReg() == X86::ST1)

+        return false;

+    }

+  }

+

   // If the callee takes no arguments then go on to check the results of the

   // call.

   if (!Outs.empty()) {

@@ -637,6 +637,8 @@ namespace llvm {

     bool IsEligibleForTailCallOptimization(SDValue Callee,

                                            CallingConv::ID CalleeCC,

                                            bool isVarArg,

+                                           bool isCalleeStructRet,

+                                           bool isCallerStructRet,

                                     const SmallVectorImpl<ISD::OutputArg> &Outs,

                                     const SmallVectorImpl<ISD::InputArg> &Ins,

                                            SelectionDAG& DAG) const;