6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-07-23 01:30:19 +00:00
Code Issues Projects Releases Wiki Activity

Turn StripPointerCast() into a method

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@50836 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Anton Korobeynikov 2008-05-07 22:54:15 +00:00
parent 4561ab5d81
commit 0b12ecf6ff
9 changed files with 42 additions and 45 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
include/llvm/IntrinsicInst.h
View File

@ -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() &&

10
include/llvm/Value.h
View File

@ -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

4
lib/CodeGen/Collector.cpp
View File

@ -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:

4
lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp
View File

@ -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();

2
lib/CodeGen/ShadowStackCollector.cpp
View File

@ -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

3
lib/Linker/LinkModules.cpp
View File

@ -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)

2
lib/Transforms/Scalar/InstructionCombining.cpp
View File

@ -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());

52
lib/VMCore/Value.cpp
View File

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

4
lib/VMCore/Verifier.cpp
View File

@ -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;