Turn StripPointerCast() into a method

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

include/llvm/IntrinsicInst.h

@@ -183,7 +183,7 @@ namespace llvm {
     /// getDest - This is just like getRawDest, but it strips off any cast
     /// instructions that feed it, giving the original input.  The returned
     /// value is guaranteed to be a pointer.
-    Value *getDest() const { return StripPointerCasts(getRawDest()); }
+    Value *getDest() const { return getRawDest()->stripPointerCasts(); }
 
     /// set* - Set the specified arguments of the instruction.
     ///
@@ -234,7 +234,7 @@ namespace llvm {
     /// getSource - This is just like getRawSource, but it strips off any cast
     /// instructions that feed it, giving the original input.  The returned
     /// value is guaranteed to be a pointer.
-    Value *getSource() const { return StripPointerCasts(getRawSource()); }
+    Value *getSource() const { return getRawSource()->stripPointerCasts(); }
 
 
     void setSource(Value *Ptr) {
@@ -264,7 +264,7 @@ namespace llvm {
     /// getSource - This is just like getRawSource, but it strips off any cast
     /// instructions that feed it, giving the original input.  The returned
     /// value is guaranteed to be a pointer.
-    Value *getSource() const { return StripPointerCasts(getRawSource()); }
+    Value *getSource() const { return getRawSource()->stripPointerCasts(); }
 
     void setSource(Value *Ptr) {
       assert(getRawSource()->getType() == Ptr->getType() &&

include/llvm/Value.h

@@ -220,6 +220,11 @@ public:
   /// getRawType - This should only be used to implement the vmcore library.
   ///
   const Type *getRawType() const { return Ty.getRawType(); }
+
+  /// stripPointerCasts - This method strips off any unneeded pointer
+  /// casts from the specified value, returning the original uncasted value.
+  /// Note that the returned value is guaranteed to have pointer type.
+  Value *stripPointerCasts();
 };
 
 inline std::ostream &operator<<(std::ostream &OS, const Value &V) {
@@ -272,11 +277,6 @@ template <> inline bool isa_impl<GlobalValue, Value>(const Value &Val) {
   return isa<GlobalVariable>(Val) || isa<Function>(Val) || isa<GlobalAlias>(Val);
 }
 
-/// StripPointerCasts - This function strips off any unneeded pointer
-/// casts from the specified value, returning the original uncasted value.
-/// Note that the returned value is guaranteed to have pointer type.
-Value *StripPointerCasts(Value *Ptr);
-
 } // End llvm namespace
 
 #endif

lib/CodeGen/Collector.cpp

@@ -179,7 +179,7 @@ bool LowerIntrinsics::InsertRootInitializers(Function &F, AllocaInst **Roots,
   for (; !CouldBecomeSafePoint(IP); ++IP)
     if (StoreInst *SI = dyn_cast<StoreInst>(IP))
       if (AllocaInst *AI =
-          dyn_cast<AllocaInst>(StripPointerCasts(SI->getOperand(1))))
+          dyn_cast<AllocaInst>(SI->getOperand(1)->stripPointerCasts()))
         InitedRoots.insert(AI);
   
   // Add root initializers.
@@ -294,7 +294,7 @@ bool LowerIntrinsics::PerformDefaultLowering(Function &F, Collector &Coll) {
             // Initialize the GC root, but do not delete the intrinsic. The
             // backend needs the intrinsic to flag the stack slot.
             Roots.push_back(cast<AllocaInst>(
-                              StripPointerCasts(CI->getOperand(1))));
+                              CI->getOperand(1)->stripPointerCasts()));
           }
           break;
         default:

lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp

@@ -2712,7 +2712,7 @@ void SelectionDAGLowering::visitTargetIntrinsic(CallInst &I,
 
 /// ExtractTypeInfo - Returns the type info, possibly bitcast, encoded in V.
 static GlobalVariable *ExtractTypeInfo (Value *V) {
-  V = StripPointerCasts(V);
+  V = V->stripPointerCasts();
   GlobalVariable *GV = dyn_cast<GlobalVariable>(V);
   assert ((GV || isa<ConstantPointerNull>(V)) &&
           "TypeInfo must be a global variable or NULL");
@@ -3150,7 +3150,7 @@ SelectionDAGLowering::visitIntrinsicCall(CallInst &I, unsigned Intrinsic) {
     return 0;
 
   case Intrinsic::init_trampoline: {
-    const Function *F = cast<Function>(StripPointerCasts(I.getOperand(2)));
+    const Function *F = cast<Function>(I.getOperand(2)->stripPointerCasts());
 
     SDOperand Ops[6];
     Ops[0] = getRoot();

lib/CodeGen/ShadowStackCollector.cpp

@@ -325,7 +325,7 @@ void ShadowStackCollector::CollectRoots(Function &F) {
         if (Function *F = CI->getCalledFunction())
           if (F->getIntrinsicID() == Intrinsic::gcroot) {
             std::pair<CallInst*,AllocaInst*> Pair = std::make_pair(
-              CI, cast<AllocaInst>(StripPointerCasts(CI->getOperand(1))));
+              CI, cast<AllocaInst>(CI->getOperand(1)->stripPointerCasts()));
             if (IsNullValue(CI->getOperand(2)))
               Roots.push_back(Pair);
             else

lib/Linker/LinkModules.cpp

@@ -758,7 +758,8 @@ static bool LinkGlobalInits(Module *Dest, const Module *Src,
       Constant *SInit =
         cast<Constant>(RemapOperand(SGV->getInitializer(), ValueMap));
 
-      GlobalVariable *DGV = cast<GlobalVariable>(StripPointerCasts(ValueMap[SGV]));
+      GlobalVariable *DGV =
+        cast<GlobalVariable>(ValueMap[SGV]->stripPointerCasts());
       if (DGV->hasInitializer()) {
         if (SGV->hasExternalLinkage()) {
           if (DGV->getInitializer() != SInit)

lib/Transforms/Scalar/InstructionCombining.cpp

@@ -9131,7 +9131,7 @@ Instruction *InstCombiner::transformCallThroughTrampoline(CallSite CS) {
   IntrinsicInst *Tramp =
     cast<IntrinsicInst>(cast<BitCastInst>(Callee)->getOperand(0));
 
-  Function *NestF = cast<Function>(StripPointerCasts(Tramp->getOperand(2)));
+  Function *NestF = cast<Function>(Tramp->getOperand(2)->stripPointerCasts());
   const PointerType *NestFPTy = cast<PointerType>(NestF->getType());
   const FunctionType *NestFTy = cast<FunctionType>(NestFPTy->getElementType());
 

lib/VMCore/Value.cpp

@@ -310,6 +310,30 @@ void Value::replaceAllUsesWith(Value *New) {
   uncheckedReplaceAllUsesWith(New);
 }
 
+Value *Value::stripPointerCasts() {
+  if (ConstantExpr *CE = dyn_cast<ConstantExpr>(this)) {
+    if (CE->getOpcode() == Instruction::BitCast) {
+      if (isa<PointerType>(CE->getOperand(0)->getType()))
+        return CE->getOperand(0)->stripPointerCasts();
+    } else if (CE->getOpcode() == Instruction::GetElementPtr) {
+      for (unsigned i = 1, e = CE->getNumOperands(); i != e; ++i)
+        if (!CE->getOperand(i)->isNullValue())
+          return this;
+      return CE->getOperand(0)->stripPointerCasts();
+    }
+    return this;
+  }
+
+  if (BitCastInst *CI = dyn_cast<BitCastInst>(this)) {
+    if (isa<PointerType>(CI->getOperand(0)->getType()))
+      return CI->getOperand(0)->stripPointerCasts();
+  } else if (GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(this)) {
+    if (GEP->hasAllZeroIndices())
+      return GEP->getOperand(0)->stripPointerCasts();
+  }
+  return this;
+}
+
 //===----------------------------------------------------------------------===//
 //                                 User Class
 //===----------------------------------------------------------------------===//
@@ -331,31 +355,3 @@ void User::replaceUsesOfWith(Value *From, Value *To) {
       setOperand(i, To); // Fix it now...
     }
 }
-
-//===----------------------------------------------------------------------===//
-//                            Utility functions
-//===----------------------------------------------------------------------===//
-
-Value *llvm::StripPointerCasts(Value *Ptr) {
-  if (ConstantExpr *CE = dyn_cast<ConstantExpr>(Ptr)) {
-    if (CE->getOpcode() == Instruction::BitCast) {
-      if (isa<PointerType>(CE->getOperand(0)->getType()))
-        return StripPointerCasts(CE->getOperand(0));
-    } else if (CE->getOpcode() == Instruction::GetElementPtr) {
-      for (unsigned i = 1, e = CE->getNumOperands(); i != e; ++i)
-        if (!CE->getOperand(i)->isNullValue())
-          return Ptr;
-      return StripPointerCasts(CE->getOperand(0));
-    }
-    return Ptr;
-  }
-
-  if (BitCastInst *CI = dyn_cast<BitCastInst>(Ptr)) {
-    if (isa<PointerType>(CI->getOperand(0)->getType()))
-      return StripPointerCasts(CI->getOperand(0));
-  } else if (GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(Ptr)) {
-    if (GEP->hasAllZeroIndices())
-      return StripPointerCasts(GEP->getOperand(0));
-  }
-  return Ptr;
-}

lib/VMCore/Verifier.cpp

@@ -1271,7 +1271,7 @@ void Verifier::visitIntrinsicFunctionCall(Intrinsic::ID ID, CallInst &CI) {
                 "Intrinsic parameter #1 is not i8**.", &CI);
         Assert1(CI.getOperand(2)->getType() == PtrTy,
                 "Intrinsic parameter #2 is not i8*.", &CI);
-        Assert1(isa<AllocaInst>(StripPointerCasts(CI.getOperand(1))),
+        Assert1(isa<AllocaInst>(CI.getOperand(1)->stripPointerCasts()),
                 "llvm.gcroot parameter #1 must be an alloca.", &CI);
         Assert1(isa<Constant>(CI.getOperand(2)),
                 "llvm.gcroot parameter #2 must be a constant.", &CI);
@@ -1297,7 +1297,7 @@ void Verifier::visitIntrinsicFunctionCall(Intrinsic::ID ID, CallInst &CI) {
               &CI);
     } break;
   case Intrinsic::init_trampoline:
-    Assert1(isa<Function>(StripPointerCasts(CI.getOperand(2))),
+    Assert1(isa<Function>(CI.getOperand(2)->stripPointerCasts()),
             "llvm.init_trampoline parameter #2 must resolve to a function.",
             &CI);
     break;