Now that we have the ReturnsTwice function attribute, this method is

obsolete. Check the attribute instead.
<rdar://problem/8031714>

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

diff --git a/include/llvm/Function.h b/include/llvm/Function.h
index 678651bbf1f8d75a3eb7292f82d429097a265d3d..4386249f5f2d33e39e2946cdd961125d18838db0 100644 (file)
--- a/include/llvm/Function.h
+++ b/include/llvm/Function.h
@@ -425,10 +425,6 @@ public:
   ///
   bool hasAddressTaken(const User** = 0) const;
 
-  /// callsFunctionThatReturnsTwice - Return true if the function has a call to
-  /// setjmp or other function that gcc recognizes as "returning twice".
-  bool callsFunctionThatReturnsTwice() const;
-
 private:
   // Shadow Value::setValueSubclassData with a private forwarding method so that
   // subclasses cannot accidentally use it.

diff --git a/lib/Analysis/InlineCost.cpp b/lib/Analysis/InlineCost.cpp
index e12e322c2a99441b0fe716c5c4f2bf255b85d34a..65db33cdc4d1c90c2aa5119cd79c6206404cf3f1 100644 (file)
--- a/lib/Analysis/InlineCost.cpp
+++ b/lib/Analysis/InlineCost.cpp
@@ -225,12 +225,11 @@ unsigned CodeMetrics::CountCodeReductionForAlloca(Value *V) {
 /// analyzeFunction - Fill in the current structure with information gleaned
 /// from the specified function.
 void CodeMetrics::analyzeFunction(Function *F, const TargetData *TD) {
-  // If this function contains a call to setjmp or _setjmp, never inline
-  // it.  This is a hack because we depend on the user marking their local
-  // variables as volatile if they are live across a setjmp call, and they
-  // probably won't do this in callers.
-  if (F->callsFunctionThatReturnsTwice())
-    callsSetJmp = true;
+  // If this function contains a call that "returns twice" (e.g., setjmp or
+  // _setjmp), never inline it. This is a hack because we depend on the user
+  // marking their local variables as volatile if they are live across a setjmp
+  // call, and they probably won't do this in callers.
+  callsSetJmp = F->hasFnAttr(Attribute::ReturnsTwice);
 
   // Look at the size of the callee.
   for (Function::const_iterator BB = F->begin(), E = F->end(); BB != E; ++BB)

diff --git a/lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp b/lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp
index 68b9146adfe1ad96d41f8d34ef4905dd41ae4957..2db91ea40b634cfbe2d6cb778ef87646a0fdca11 100644 (file)
--- a/lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp
+++ b/lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp
@@ -374,7 +374,7 @@ bool SelectionDAGISel::runOnMachineFunction(MachineFunction &mf) {
   }
 
   // Determine if there is a call to setjmp in the machine function.
-  MF->setCallsSetJmp(Fn.callsFunctionThatReturnsTwice());
+  MF->setCallsSetJmp(Fn.hasFnAttr(Attribute::ReturnsTwice));
 
   // Replace forward-declared registers with the registers containing
   // the desired value.

diff --git a/lib/Transforms/Scalar/TailRecursionElimination.cpp b/lib/Transforms/Scalar/TailRecursionElimination.cpp
index e21eb9dca270097ab13fdcfecb20a671940d1cfe..1022485a948560f10240b612705572fa13d68c71 100644 (file)
--- a/lib/Transforms/Scalar/TailRecursionElimination.cpp
+++ b/lib/Transforms/Scalar/TailRecursionElimination.cpp
@@ -213,7 +213,7 @@ bool TailCallElim::runOnFunction(Function &F) {
   // Finally, if this function contains no non-escaping allocas, or calls
   // setjmp, mark all calls in the function as eligible for tail calls
   //(there is no stack memory for them to access).
-  if (!FunctionContainsEscapingAllocas && !F.callsFunctionThatReturnsTwice())
+  if (!FunctionContainsEscapingAllocas && !F.hasFnAttr(Attribute::ReturnsTwice))
     for (Function::iterator BB = F.begin(), E = F.end(); BB != E; ++BB)
       for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; ++I)
         if (CallInst *CI = dyn_cast<CallInst>(I)) {

diff --git a/lib/VMCore/Function.cpp b/lib/VMCore/Function.cpp
index 1215e6a57ced2034d8728714cf7d007f407e0983..975ec83b4df8d07ce2f9f087369207c9456c0f6a 100644 (file)
--- a/lib/VMCore/Function.cpp
+++ b/lib/VMCore/Function.cpp
@@ -411,44 +411,4 @@ bool Function::hasAddressTaken(const User* *PutOffender) const {
   return false;
 }
 
-/// callsFunctionThatReturnsTwice - Return true if the function has a call to
-/// setjmp or other function that gcc recognizes as "returning twice".
-///
-/// FIXME: Remove after <rdar://problem/8031714> is fixed.
-/// FIXME: Is the above FIXME valid?
-bool Function::callsFunctionThatReturnsTwice() const {
-  static const char *const ReturnsTwiceFns[] = {
-    "_setjmp",
-    "setjmp",
-    "sigsetjmp",
-    "setjmp_syscall",
-    "savectx",
-    "qsetjmp",
-    "vfork",
-    "getcontext"
-  };
-
-  for (const_inst_iterator I = inst_begin(this), E = inst_end(this); I != E;
-       ++I) {
-    const CallInst* callInst = dyn_cast<CallInst>(&*I);
-    if (!callInst)
-      continue;
-    if (callInst->canReturnTwice())
-      return true;
-
-    // check for known function names.
-    // FIXME: move this to clang.
-    Function *F = callInst->getCalledFunction();
-    if (!F)
-      continue;
-    StringRef Name = F->getName();
-    for (unsigned J = 0, e = array_lengthof(ReturnsTwiceFns); J != e; ++J) {
-      if (Name == ReturnsTwiceFns[J])
-        return true;
-    }
-  }
-
-  return false;
-}
-
 // vim: sw=2 ai