6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-01-05 12:31:33 +00:00
Code Issues Projects Releases Wiki Activity

Make BasicAliasAnalysis and Value::getUnderlyingObject use

Browse Source 
GEPOperator's hasNoPointer0verflow(), and make a few places in instcombine
that create GEPs that may overflow clear the NoOverflow value. Among
other things, this partially addresses PR2831.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@76252 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Dan Gohman 2009-07-17 22:25:10 +00:00
parent 8f080f0233
commit 3a7a68c108
3 changed files with 28 additions and 16 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
lib/Analysis/BasicAliasAnalysis.cpp
View File

@ -23,6 +23,7 @@
#include "llvm/Instructions.h" #include "llvm/Instructions.h"
#include "llvm/IntrinsicInst.h" #include "llvm/IntrinsicInst.h"
#include "llvm/LLVMContext.h" #include "llvm/LLVMContext.h"
#include "llvm/Operator.h"
#include "llvm/Pass.h" #include "llvm/Pass.h"
#include "llvm/Target/TargetData.h" #include "llvm/Target/TargetData.h"
#include "llvm/ADT/SmallVector.h" #include "llvm/ADT/SmallVector.h"
@ -38,10 +39,11 @@ using namespace llvm;
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
static const User *isGEP(const Value *V) { static const User *isGEP(const Value *V) {
if (isa<GetElementPtrInst>(V) || if (const GEPOperator *GEP = dyn_cast<GEPOperator>(V))
(isa<ConstantExpr>(V) && // For the purposes of BasicAliasAnalysis, if the GEP has overflow it
cast<ConstantExpr>(V)->getOpcode() == Instruction::GetElementPtr)) // could do crazy things.
return cast<User>(V); if (GEP->hasNoPointerOverflow())
return GEP;
return 0; return 0;
} }

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

@ -2310,7 +2310,10 @@ Instruction *InstCombiner::visitAdd(BinaryOperator &I) {
cast<PointerType>(CI->getOperand(0)->getType())->getAddressSpace(); cast<PointerType>(CI->getOperand(0)->getType())->getAddressSpace();
Value *I2 = InsertBitCastBefore(CI->getOperand(0), Value *I2 = InsertBitCastBefore(CI->getOperand(0),
Context->getPointerType(Type::Int8Ty, AS), I); Context->getPointerType(Type::Int8Ty, AS), I);
I2 = InsertNewInstBefore(GetElementPtrInst::Create(I2, Other, "ctg2"), I); GetElementPtrInst *GEP = GetElementPtrInst::Create(I2, Other, "ctg2");
// A GEP formed from an arbitrary add may overflow.
cast<GEPOperator>(GEP)->setHasNoPointerOverflow(false);
I2 = InsertNewInstBefore(GEP, I);
return new PtrToIntInst(I2, CI->getType()); return new PtrToIntInst(I2, CI->getType());
} }
} }
@ -8942,7 +8945,12 @@ Instruction *InstCombiner::visitIntToPtr(IntToPtrInst &CI) {
// If Offset is evenly divisible by Size, we can do this xform. // If Offset is evenly divisible by Size, we can do this xform.
if (Size && !APIntOps::srem(Offset, APInt(Offset.getBitWidth(), Size))){ if (Size && !APIntOps::srem(Offset, APInt(Offset.getBitWidth(), Size))){
Offset = APIntOps::sdiv(Offset, APInt(Offset.getBitWidth(), Size)); Offset = APIntOps::sdiv(Offset, APInt(Offset.getBitWidth(), Size));
return GetElementPtrInst::Create(X, Context->getConstantInt(Offset)); GetElementPtrInst *GEP =
GetElementPtrInst::Create(X, Context->getConstantInt(Offset));
// A gep synthesized from inttoptr+add+ptrtoint must be assumed to
// potentially overflow, in the absense of further analysis.
cast<GEPOperator>(GEP)->setHasNoPointerOverflow(false);
return GEP;
} }
} }
// TODO: Could handle other cases, e.g. where add is indexing into field of // TODO: Could handle other cases, e.g. where add is indexing into field of
@ -8966,8 +8974,12 @@ Instruction *InstCombiner::visitIntToPtr(IntToPtrInst &CI) {
Instruction *P = InsertNewInstBefore(new IntToPtrInst(X, CI.getType(), Instruction *P = InsertNewInstBefore(new IntToPtrInst(X, CI.getType(),
"tmp"), CI); "tmp"), CI);
return GetElementPtrInst::Create(P, GetElementPtrInst *GEP =
Context->getConstantInt(Offset), "tmp"); GetElementPtrInst::Create(P, Context->getConstantInt(Offset), "tmp");
// A gep synthesized from inttoptr+add+ptrtoint must be assumed to
// potentially overflow, in the absense of further analysis.
cast<GEPOperator>(GEP)->setHasNoPointerOverflow(false);
return GEP;
} }
} }
return 0; return 0;

14
lib/VMCore/Value.cpp
View File

@ -16,6 +16,7 @@
#include "llvm/DerivedTypes.h" #include "llvm/DerivedTypes.h"
#include "llvm/InstrTypes.h" #include "llvm/InstrTypes.h"
#include "llvm/Instructions.h" #include "llvm/Instructions.h"
#include "llvm/Operator.h"
#include "llvm/Module.h" #include "llvm/Module.h"
#include "llvm/ValueSymbolTable.h" #include "llvm/ValueSymbolTable.h"
#include "llvm/Support/Debug.h" #include "llvm/Support/Debug.h"
@ -372,15 +373,12 @@ Value *Value::getUnderlyingObject() {
Value *V = this; Value *V = this;
unsigned MaxLookup = 6; unsigned MaxLookup = 6;
do { do {
if (Instruction *I = dyn_cast<Instruction>(V)) { if (Operator *O = dyn_cast<Operator>(V)) {
if (!isa<BitCastInst>(I) && !isa<GetElementPtrInst>(I)) if (O->getOpcode() != Instruction::BitCast &&
(O->getOpcode() != Instruction::GetElementPtr ||
!cast<GEPOperator>(V)->hasNoPointerOverflow()))
return V; return V;
V = I->getOperand(0); V = O->getOperand(0);
} else if (ConstantExpr *CE = dyn_cast<ConstantExpr>(V)) {
if (CE->getOpcode() != Instruction::BitCast &&
CE->getOpcode() != Instruction::GetElementPtr)
return V;
V = CE->getOperand(0);
} else { } else {
return V; return V;
} }