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

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 {
+  // FIXME: These methods should be inline once we eliminate
-    return dyn_cast<Function>(Operands[0].get());
+  // ConstantPointerRefs!
-  }
+  const Function *getCalledFunction() const;
-  Function *getCalledFunction() {
+  Function *getCalledFunction();
-    return dyn_cast<Function>(Operands[0].get());
-  }
 
   // getCalledValue - Get a pointer to a method that is invoked by this inst.
   inline const Value *getCalledValue() const { return Operands[0]; }

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
+  /// getCalledFunction - Return the function called, or null if this is an
-  // indirect function invocation...
+  /// indirect function invocation... 
-  //
+  ///
-  inline const Function *getCalledFunction() const {
+  /// FIXME: These should be inlined once we get rid of ConstantPointerRefs!
-    return dyn_cast<Function>(Operands[0].get());
+  ///
-  }
+  const Function *getCalledFunction() const;
-  inline Function *getCalledFunction() {
+  Function *getCalledFunction();
-    return dyn_cast<Function>(Operands[0].get());
-  }
 
   // getCalledValue - Get a pointer to a function that is invoked by this inst.
   inline const Value *getCalledValue() const { return Operands[0]; }

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;
+}