Constant pointer refs are causing these to fail unnecessarily, which is causing

a lot of code to be pessimized.  I hate CPRs.  :(


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

3 files changed, 42 insertions, 15 deletions

diff --git a/include/llvm/iOther.h b/include/llvm/iOther.h
index e5c3e7d7a3..4e23afdc89 100644
--- a/include/llvm/iOther.h
+++ b/include/llvm/iOther.h
@@ -69,12 +69,10 @@ public:
   virtual Instruction *clone() const { return new CallInst(*this); }
   bool mayWriteToMemory() const { return true; }
 
-  const Function *getCalledFunction() const {
-    return dyn_cast<Function>(Operands[0].get());
-  }
-  Function *getCalledFunction() {
-    return dyn_cast<Function>(Operands[0].get());
-  }
+  // FIXME: These methods should be inline once we eliminate
+  // ConstantPointerRefs!
+  const Function *getCalledFunction() const;
+  Function *getCalledFunction();
 
   // getCalledValue - Get a pointer to a method that is invoked by this inst.
   inline const Value *getCalledValue() const { return Operands[0]; }
diff --git a/include/llvm/iTerminators.h b/include/llvm/iTerminators.h
index 9a40b37e9e..5f435a05c6 100644
--- a/include/llvm/iTerminators.h
+++ b/include/llvm/iTerminators.h
@@ -214,15 +214,13 @@ public:
 
   bool mayWriteToMemory() const { return true; }
 
-  // getCalledFunction - Return the function called, or null if this is an
-  // indirect function invocation...
-  //
-  inline const Function *getCalledFunction() const {
-    return dyn_cast<Function>(Operands[0].get());
-  }
-  inline Function *getCalledFunction() {
-    return dyn_cast<Function>(Operands[0].get());
-  }
+  /// getCalledFunction - Return the function called, or null if this is an
+  /// indirect function invocation... 
+  ///
+  /// FIXME: These should be inlined once we get rid of ConstantPointerRefs!
+  ///
+  const Function *getCalledFunction() const;
+  Function *getCalledFunction();
 
   // getCalledValue - Get a pointer to a function that is invoked by this inst.
   inline const Value *getCalledValue() const { return Operands[0]; }
diff --git a/lib/VMCore/iCall.cpp b/lib/VMCore/iCall.cpp
index e0f99785a5..fcaa1e1930 100644
--- a/lib/VMCore/iCall.cpp
+++ b/lib/VMCore/iCall.cpp
@@ -13,6 +13,7 @@
 
 #include "llvm/iOther.h"
 #include "llvm/iTerminators.h"
+#include "llvm/Constants.h"
 #include "llvm/DerivedTypes.h"
 #include "llvm/Function.h"
 
@@ -78,6 +79,22 @@ CallInst::CallInst(const CallInst &CI)
     Operands.push_back(Use(CI.Operands[i], this));
 }
 
+const Function *CallInst::getCalledFunction() const {
+  if (const Function *F = dyn_cast<Function>(Operands[0]))
+    return F;
+  if (const ConstantPointerRef *CPR = dyn_cast<ConstantPointerRef>(Operands[0]))
+    return cast<Function>(CPR->getValue());
+  return 0;
+}
+Function *CallInst::getCalledFunction() {
+  if (Function *F = dyn_cast<Function>(Operands[0]))
+    return F;
+  if (ConstantPointerRef *CPR = dyn_cast<ConstantPointerRef>(Operands[0]))
+    return cast<Function>(CPR->getValue());
+  return 0;
+}
+
+
 //===----------------------------------------------------------------------===//
 //                        InvokeInst Implementation
 //===----------------------------------------------------------------------===//
@@ -112,3 +129,17 @@ InvokeInst::InvokeInst(const InvokeInst &CI)
     Operands.push_back(Use(CI.Operands[i], this));
 }
 
+const Function *InvokeInst::getCalledFunction() const {
+  if (const Function *F = dyn_cast<Function>(Operands[0]))
+    return F;
+  if (const ConstantPointerRef *CPR = dyn_cast<ConstantPointerRef>(Operands[0]))
+    return cast<Function>(CPR->getValue());
+  return 0;
+}
+Function *InvokeInst::getCalledFunction() {
+  if (Function *F = dyn_cast<Function>(Operands[0]))
+    return F;
+  if (ConstantPointerRef *CPR = dyn_cast<ConstantPointerRef>(Operands[0]))
+    return cast<Function>(CPR->getValue());
+  return 0;
+}