maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

Revert "[InstSimplify] Add support for bitcasts" 

This reverts commit r276698.  Clang has tests which rely on the
optimizer :(

llvm-svn: 276700
This commit is contained in:
David Majnemer 2016-07-25 22:24:59 +00:00
parent 62611fd3f7
commit 6e06b577cc
4 changed files with 3 additions and 64 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
llvm/include/llvm/Analysis/InstructionSimplify.h
View File

@ -245,13 +245,6 @@ namespace llvm {
AssumptionCache *AC = nullptr,
const Instruction *CxtI = nullptr);
/// Given operands for an BitCastInst, fold the result or return null.
Value *SimplifyBitCastInst(Value *Op, Type *Ty, const DataLayout &DL,
const TargetLibraryInfo *TLI = nullptr,
const DominatorTree *DT = nullptr,
AssumptionCache *AC = nullptr,
const Instruction *CxtI = nullptr);
//=== Helper functions for higher up the class hierarchy.

29
llvm/lib/Analysis/InstructionSimplify.cpp
View File

@ -70,7 +70,6 @@ static Value *SimplifyCmpInst(unsigned, Value *, Value *, const Query &,
static Value *SimplifyOrInst(Value *, Value *, const Query &, unsigned);
static Value *SimplifyXorInst(Value *, Value *, const Query &, unsigned);
static Value *SimplifyTruncInst(Value *, Type *, const Query &, unsigned);
static Value *SimplifyBitCastInst(Value *, Type *, const Query &, unsigned);
/// For a boolean type, or a vector of boolean type, return false, or
/// a vector with every element false, as appropriate for the type.
@ -3811,30 +3810,6 @@ Value *llvm::SimplifyTruncInst(Value *Op, Type *Ty, const DataLayout &DL,
RecursionLimit);
}
static Value *SimplifyBitCastInst(Value *Op, Type *Ty, const Query &Q, unsigned) {
if (auto *C = dyn_cast<Constant>(Op))
return ConstantFoldCastOperand(Instruction::BitCast, C, Ty, Q.DL);
// bitcast x -> x
if (Op->getType() == Ty)
return Op;
// bitcast(bitcast x) -> x
if (auto *BC = dyn_cast<BitCastInst>(Op))
if (BC->getOperand(0)->getType() == Ty)
return BC->getOperand(0);
return nullptr;
}
Value *llvm::SimplifyBitCastInst(Value *Op, Type *Ty, const DataLayout &DL,
const TargetLibraryInfo *TLI,
const DominatorTree *DT, AssumptionCache *AC,
const Instruction *CxtI) {
return ::SimplifyBitCastInst(Op, Ty, Query(DL, TLI, DT, AC, CxtI),
RecursionLimit);
}
//=== Helper functions for higher up the class hierarchy.
/// Given operands for a BinaryOperator, see if we can fold the result.
@ -4305,10 +4280,6 @@ Value *llvm::SimplifyInstruction(Instruction *I, const DataLayout &DL,
Result =
SimplifyTruncInst(I->getOperand(0), I->getType(), DL, TLI, DT, AC, I);
break;
case Instruction::BitCast:
Result =
SimplifyBitCastInst(I->getOperand(0), I->getType(), DL, TLI, DT, AC, I);
break;
}
// In general, it is possible for computeKnownBits to determine all bits in a

4
llvm/test/Transforms/GVN/pr14166.ll
View File

@ -18,7 +18,9 @@ define <2 x i32> @test1() {
; CHECK: %v4 = bitcast <2 x i32>* %v1 to <2 x i8*>*
; CHECK: store <2 x i8*> %v3, <2 x i8*>* %v4
; CHECK: %1 = ptrtoint <2 x i8*> %v3 to <2 x i32>
; CHECK: ret <2 x i32> %1
; CHECK: %2 = bitcast <2 x i32> %1 to i64
; CHECK: %3 = bitcast i64 %2 to <2 x i32>
; CHECK: ret <2 x i32> %3
}
declare void @anything(<2 x i32>*)

27
llvm/test/Transforms/InstSimplify/cast.ll
View File

@ -1,27 +0,0 @@
; RUN: opt -S -instsimplify < %s | FileCheck %s
define i1 @test1(i1 %V) {
entry:
%Z = zext i1 %V to i32
%T = trunc i32 %Z to i1
ret i1 %T
; CHECK-LABEL: define i1 @test1(
; CHECK: ret i1 %V
}
define i8* @test2(i8* %V) {
entry:
%BC1 = bitcast i8* %V to i32*
%BC2 = bitcast i32* %BC1 to i8*
ret i8* %BC2
; CHECK-LABEL: define i8* @test2(
; CHECK: ret i8* %V
}
define i8* @test3(i8* %V) {
entry:
%BC = bitcast i8* %V to i8*
ret i8* %BC
; CHECK-LABEL: define i8* @test3(
; CHECK: ret i8* %V
}