This is an archive of the discontinued LLVM Phabricator instance.

Differential D68493

[PATCH 07/27] [noalias] simplify noalias intrinsics
Needs ReviewPublic

Authored by jeroen.dobbelaere on Oct 4 2019, 2:36 PM.

Details

Reviewers
hfinkel
jdoerfert
Summary

This is part of the series started by D68484.

Note: this is a stable point and tests should run fine with the patches applied up to this point.
Note: D68492 has been incorporated.

Diff Detail

Event Timeline

jeroen.dobbelaere created this revision.Oct 4 2019, 2:36 PM
Herald added a project: Restricted Project. · View Herald TranscriptOct 4 2019, 2:36 PM
Herald added subscribers: llvm-commits, hiraditya. · View Herald Transcript
lebedev.ri added a parent revision: D68492: [PATCH 09/38] [noalias] D9376: llvm.noalias - handling of dead intrinsics.Oct 5 2019, 9:46 AM
lebedev.ri added a child revision: D68494: [PATCH 11/38] [noalias] D9377: llvm.noalias - don't block EarlyCSE.
lebedev.ri added a subscriber: lebedev.ri.Oct 6 2019, 3:58 AM

Comments need more work i think. Also, they are phrases, they should be grammatically correct, start with Uppercase letter.

jeroen.dobbelaere mentioned this in D68492: [PATCH 09/38] [noalias] D9376: llvm.noalias - handling of dead intrinsics.Oct 14 2019, 4:51 AM
jeroen.dobbelaere marked 2 inline comments as done.Oct 14 2019, 4:54 AM
jeroen.dobbelaere added inline comments.
llvm/lib/Analysis/InstructionSimplify.cpp
5148

As mentioned by a.elivikov in D68492: we should not propagate null through the intrinsics.

5225

Also here, we should not propagate null.

jeroen.dobbelaere updated this revision to Diff 224847.Oct 14 2019, 6:32 AM

Do not propagate null. Improved tests.

jeroen.dobbelaere updated this revision to Diff 226792.Oct 28 2019, 5:31 PM

Rebased

jeroen.dobbelaere updated this revision to Diff 270420.Jun 12 2020, 9:15 AM
jeroen.dobbelaere retitled this revision from [PATCH 10/38] [noalias] simplify noalias intrinsics to [PATCH 6/26] [noalias] simplify noalias intrinsics.
jeroen.dobbelaere edited the summary of this revision. (Show Details)
jeroen.dobbelaere retitled this revision from [PATCH 6/26] [noalias] simplify noalias intrinsics to [PATCH 06/26] [noalias] simplify noalias intrinsics.Jun 12 2020, 9:18 AM
jeroen.dobbelaere added a parent revision: D68491: [PATCH 06/27] [noalias] [IR] IRBuilder support for noalias intrinsics..Jun 12 2020, 11:36 AM
jeroen.dobbelaere edited child revisions, added: D68495: [PATCH 08/27] [noalias] EarlyCSE: learn about noalias intrinsics; removed: D68494: [PATCH 11/38] [noalias] D9377: llvm.noalias - don't block EarlyCSE.
jeroen.dobbelaere removed a parent revision: D68492: [PATCH 09/38] [noalias] D9376: llvm.noalias - handling of dead intrinsics.Jun 12 2020, 11:45 AM
jeroen.dobbelaere updated this revision to Diff 277737.Jul 14 2020, 3:16 AM

Rebased to c06b7e2ab5167ad031745a706204abed1aefd823 (July 14, 2020)

jeroen.dobbelaere updated this revision to Diff 290347.Sep 7 2020, 2:06 PM
jeroen.dobbelaere retitled this revision from [PATCH 06/26] [noalias] simplify noalias intrinsics to [PATCH 07/27] [noalias] simplify noalias intrinsics.

Rebased to 9fb46a452d4e5666828c95610ceac8dcd9e4ce16 (September 7, 2020)

jeroen.dobbelaere updated this revision to Diff 346119.May 18 2021, 4:44 AM

Rebased to f8dbd61074176bae92ec360a093ac7bc498c9321.

Harbormaster completed remote builds in B104992: Diff 346119.May 18 2021, 6:40 AM

Revision Contents

PathSize
llvm/
lib/
Analysis/
55 lines
Transforms/
Utils/
19 lines
test/
Transforms/
InstSimplify/
163 lines

Diff 226792

llvm/lib/Analysis/InstructionSimplify.cpp

Show All 29 Lines
#include "llvm/Analysis/VectorUtils.h" #include "llvm/Analysis/VectorUtils.h"
#include "llvm/IR/ConstantRange.h" #include "llvm/IR/ConstantRange.h"
#include "llvm/IR/DataLayout.h" #include "llvm/IR/DataLayout.h"
#include "llvm/IR/Dominators.h" #include "llvm/IR/Dominators.h"
#include "llvm/IR/GetElementPtrTypeIterator.h" #include "llvm/IR/GetElementPtrTypeIterator.h"
#include "llvm/IR/GlobalAlias.h" #include "llvm/IR/GlobalAlias.h"
#include "llvm/IR/InstrTypes.h" #include "llvm/IR/InstrTypes.h"
#include "llvm/IR/Instructions.h" #include "llvm/IR/Instructions.h"
#include "llvm/IR/IntrinsicInst.h"
#include "llvm/IR/Operator.h" #include "llvm/IR/Operator.h"
#include "llvm/IR/PatternMatch.h" #include "llvm/IR/PatternMatch.h"
#include "llvm/IR/ValueHandle.h" #include "llvm/IR/ValueHandle.h"
#include "llvm/Support/KnownBits.h" #include "llvm/Support/KnownBits.h"
#include <algorithm> #include <algorithm>
using namespace llvm; using namespace llvm;
using namespace llvm::PatternMatch; using namespace llvm::PatternMatch;
▲ Show 20 Lines • Show All 5,079 Lines • ▼ Show 20 Lines if ((match(Op0, m_APFloat(C)) && C->isInfinity() &&
return ConstantFP::getInfinity(ReturnType, UseNegInf); return ConstantFP::getInfinity(ReturnType, UseNegInf);
// TODO: minnum(nnan x, inf) -> x // TODO: minnum(nnan x, inf) -> x
// TODO: minnum(nnan ninf x, flt_max) -> x // TODO: minnum(nnan ninf x, flt_max) -> x
// TODO: maxnum(nnan x, -inf) -> x // TODO: maxnum(nnan x, -inf) -> x
// TODO: maxnum(nnan ninf x, -flt_max) -> x // TODO: maxnum(nnan ninf x, -flt_max) -> x
break; break;
} }
case Intrinsic::noalias_arg_guard: {
// Only follow the plain path if undefined. Do not propagate null, that
// would incorrectly omit noalias information.
if (isa<UndefValue>(Op0))
return Op0;
break;
}
default: default:
break; break;
} }
return nullptr; return nullptr;
} }
static Value *simplifyIntrinsic(CallBase *Call, const SimplifyQuery &Q) { static Value *simplifySideNoalias(const Value *V) {
jeroen.dobbelaereAuthorUnsubmitted
Done
ReplyInline Actions

As mentioned by a.elivikov in D68492: we should not propagate null through the intrinsics.

jeroen.dobbelaere: As mentioned by a.elivikov in D68492: we should not propagate `null` through the intrinsics.
const IntrinsicInst *II = cast<IntrinsicInst>(V);
assert(II->getIntrinsicID() == Intrinsic::side_noalias);
// Only follow the plain path if undefined. Do not propagate null, that
// would incorrectly omit noalias information.
Value *Op0 = II->getOperand(0);
if (isa<UndefValue>(Op0)) {
return Op0;
}
// Check for compatibility: side_noalias(side_noalias) -> side_noalias
if (llvm::IntrinsicInst *DepII = dyn_cast<IntrinsicInst>(Op0)) {
if (DepII->getIntrinsicID() == Intrinsic::side_noalias) {
if (llvm::areSideNoaliasCompatible(DepII, II)) {
return DepII;
}
}
}
return nullptr;
}
static Value *simplifyIntrinsic(CallBase *Call, const SimplifyQuery &Q) {
// Intrinsics with no operands have some kind of side effect. Don't simplify. // Intrinsics with no operands have some kind of side effect. Don't simplify.
unsigned NumOperands = Call->getNumArgOperands(); unsigned NumOperands = Call->getNumArgOperands();
if (!NumOperands) if (!NumOperands)
return nullptr; return nullptr;
Function *F = cast<Function>(Call->getCalledFunction()); Function *F = cast<Function>(Call->getCalledFunction());
Intrinsic::ID IID = F->getIntrinsicID(); Intrinsic::ID IID = F->getIntrinsicID();
// We can remove a noalias intrinsic if the pointer value is undef (by
// forwarding the undef). The same goes for an address-space-zero null
// pointer.
if (IID == Intrinsic::noalias) {
Value *Arg0 = Call->getArgOperand(0);
if (isa<UndefValue>(Arg0) ||
(isa<ConstantPointerNull>(Arg0) &&
Arg0->getType()->getPointerAddressSpace() == 0))
return Arg0;
}
if (NumOperands == 1) if (NumOperands == 1)
return simplifyUnaryIntrinsic(F, Call->getArgOperand(0), Q); return simplifyUnaryIntrinsic(F, Call->getArgOperand(0), Q);
if (NumOperands == 2) if (NumOperands == 2)
return simplifyBinaryIntrinsic(F, Call->getArgOperand(0), return simplifyBinaryIntrinsic(F, Call->getArgOperand(0),
Call->getArgOperand(1), Q); Call->getArgOperand(1), Q);
// Handle intrinsics with 3 or more arguments. // Handle intrinsics with 3 or more arguments.
Show All 31 Linesstatic Value *simplifyIntrinsic(CallBase *Call, const SimplifyQuery &Q) {
} }
case Intrinsic::fma: case Intrinsic::fma:
case Intrinsic::fmuladd: { case Intrinsic::fmuladd: {
Value *Op0 = Call->getArgOperand(0); Value *Op0 = Call->getArgOperand(0);
Value *Op1 = Call->getArgOperand(1); Value *Op1 = Call->getArgOperand(1);
Value *Op2 = Call->getArgOperand(2); Value *Op2 = Call->getArgOperand(2);
if (Value *V = simplifyFPOp({ Op0, Op1, Op2 })) if (Value *V = simplifyFPOp({ Op0, Op1, Op2 }))
return V; return V;
return nullptr; return nullptr;
jeroen.dobbelaereAuthorUnsubmitted
Done
ReplyInline Actions

Also here, we should not propagate null.

jeroen.dobbelaere: Also here, we should not propagate `null`.
} }
case Intrinsic::noalias:
case Intrinsic::noalias_copy_guard: {
// Only follow the plain path if undefined. Do not propagate null, that
// would incorrectly omit noalias information.
if (auto Op0 = dyn_cast<UndefValue>(Call->getArgOperand(0))) {
return Op0;
}
return nullptr;
}
case Intrinsic::side_noalias: {
return simplifySideNoalias(Call);
}
default: default:
return nullptr; return nullptr;
} }
} }
Value *llvm::SimplifyCall(CallBase *Call, const SimplifyQuery &Q) { Value *llvm::SimplifyCall(CallBase *Call, const SimplifyQuery &Q) {
Value *Callee = Call->getCalledValue(); Value *Callee = Call->getCalledValue();
▲ Show 20 Lines • Show All 313 Lines • Show Last 20 Lines

llvm/lib/Transforms/Utils/Local.cpp

Show First 20 Lines • Show All 415 Lines • ▼ Show 20 Lines if (II->getIntrinsicID() == Intrinsic::assume ||
return !Cond->isZero(); return !Cond->isZero();
return false; return false;
} }
// noalias intrinsics are dead if they have no uses (they're tagged as // noalias intrinsics are dead if they have no uses (they're tagged as
// writing, but that is only to maintain control dependencies, not because // writing, but that is only to maintain control dependencies, not because
// they actually write anything). // they actually write anything).
if (II->getIntrinsicID() == Intrinsic::noalias) if (II->getIntrinsicID() == Intrinsic::noalias ||
II->getIntrinsicID() == Intrinsic::side_noalias ||
II->getIntrinsicID() == Intrinsic::noalias_copy_guard ||
II->getIntrinsicID() == Intrinsic::noalias_arg_guard)
return II->use_empty(); return II->use_empty();
// llvm.noalias.decl which operand only has a single use are trivially dead.
// NOTE: this assumes that noalias intrinsics nodes are never combined !
if (II->getIntrinsicID() == Intrinsic::noalias_decl) {
auto *DAA = II->getOperand(Intrinsic::NoAliasDeclAllocaArg);
if (isa<Constant>(DAA)) {
// no associated alloca -> if there are no uses, it is trivially dead
return II->getNumUses() == 0;
} else {
return (DAA->getNumUses() == 1) &&
(II->getOperand(Intrinsic::NoAliasDeclScopeArg)->getNumUses() ==
1);
}
}
} }
if (isAllocLikeFn(I, TLI)) if (isAllocLikeFn(I, TLI))
return true; return true;
if (CallInst *CI = isFreeCall(I, TLI)) if (CallInst *CI = isFreeCall(I, TLI))
if (Constant *C = dyn_cast<Constant>(CI->getArgOperand(0))) if (Constant *C = dyn_cast<Constant>(CI->getArgOperand(0)))
return C->isNullValue() || isa<UndefValue>(C); return C->isNullValue() || isa<UndefValue>(C);
▲ Show 20 Lines • Show All 2,564 Lines • Show Last 20 Lines

llvm/test/Transforms/InstSimplify/noalias.ll

; RUN: opt -instsimplify -S < %s | FileCheck %s ; RUN: opt -instsimplify -S < %s | FileCheck %s
define void @test1(i8* %ptr) { define void @test01(i8* %ptr) {
call i8* @llvm.noalias.p0i8(i8* %ptr, metadata !1) call i8* @llvm.noalias.p0i8.p0i8.p0p0i8.i32(i8* %ptr, i8* null, i8** null, i32 0, metadata !1)
ret void ret void
; CHECK-LABEL: @test1 ; CHECK-LABEL: @test01
; CHECK-NOT: llvm.noalias.p0i8 ; CHECK-NOT: llvm.noalias.p0i8
; CHECK: ret void ; CHECK: ret void
} }
define i8* @test2a() { define i8* @test02() {
%v = call i8* @llvm.noalias.p0i8(i8* null, metadata !1) %v = call i8* @llvm.noalias.p0i8.p0i8.p0p0i8.i32(i8* null, i8* null, i8** null, i32 0, metadata !1)
ret i8* %v ret i8* %v
; CHECK-LABEL: @test2a ; CHECK-LABEL: @test02
; CHECK-NOT: llvm.noalias.p0i8 ; CHECK: llvm.noalias.p0i8
; CHECK: ret i8* null ; CHECK: ret i8* %v
} }
define i8* @test2() { define i8* @test03() {
%v = call i8* @llvm.noalias.p0i8(i8* undef, metadata !1) %v = call i8* @llvm.noalias.p0i8.p0i8.p0p0i8.i32(i8* undef, i8* null, i8** null, i32 0, metadata !1)
ret i8* %v ret i8* %v
; CHECK-LABEL: @test2 ; CHECK-LABEL: @test03
; CHECK-NOT: llvm.noalias.p0i8 ; CHECK-NOT: llvm.noalias.p0i8
; CHECK: ret i8* undef ; CHECK: ret i8* undef
} }
declare i8* @llvm.noalias.p0i8(i8*, metadata) nounwind declare i8* @llvm.noalias.p0i8.p0i8.p0p0i8.i32(i8*, i8*, i8**, i32, metadata ) nounwind
define void @test11(i8* %ptr) {
call i8* @llvm.side.noalias.p0i8.p0i8.p0p0i8.p0p0i8.i32(i8* %ptr, i8* null, i8** null, i8** null, i32 0, metadata !1)
ret void
; CHECK-LABEL: @test11
; CHECK-NOT: llvm.side.noalias.p0i8
; CHECK: ret void
}
define i8* @test12() {
%v = call i8* @llvm.side.noalias.p0i8.p0i8.p0p0i8.p0p0i8.i32(i8* null, i8* null, i8** null, i8** null, i32 0, metadata !1)
ret i8* %v
; CHECK-LABEL: @test12
; CHECK: llvm.side.noalias.p0i8
; CHECK: ret i8* %v
}
define i8* @test13() {
%v = call i8* @llvm.side.noalias.p0i8.p0i8.p0p0i8.p0p0i8.i32(i8* undef, i8* null, i8** null, i8** null, i32 0, metadata !1)
ret i8* %v
; CHECK-LABEL: @test13
; CHECK-NOT: llvm.side.noalias.p0i8
; CHECK: ret i8* undef
}
define i8* @test14() {
%u = call i8* @llvm.side.noalias.p0i8.p0i8.p0p0i8.p0p0i8.i32(i8* null, i8* null, i8** null, i8** null, i32 0, metadata !1)
%v = call i8* @llvm.side.noalias.p0i8.p0i8.p0p0i8.p0p0i8.i32(i8* %u, i8* null, i8** null, i8** null, i32 0, metadata !1)
ret i8* %v
; CHECK-LABEL: @test14
; CHECK: llvm.side.noalias.p0i8
; CHECK-NOT: llvm.side.noalias.p0i8
; CHECK: ret i8* %u
}
define i8* @test15() {
%u = call i8* @llvm.side.noalias.p0i8.p0i8.p0p0i8.p0p0i8.i32(i8* null, i8* null, i8** null, i8** null, i32 1, metadata !1)
%v = call i8* @llvm.side.noalias.p0i8.p0i8.p0p0i8.p0p0i8.i32(i8* %u, i8* null, i8** null, i8** null, i32 0, metadata !1)
ret i8* %v
; CHECK-LABEL: @test15
; CHECK: llvm.side.noalias.p0i8
; CHECK: llvm.side.noalias.p0i8
; CHECK: ret i8* %v
}
define i8* @test20() {
%u = call i8* @llvm.side.noalias.p0i8.p0i8.p0p0i8.p0p0i8.i32(i8* null, i8* null, i8** null, i8** null, i32 0, metadata !1)
%v = call i8* @llvm.noalias.arg.guard.p0i8.p0i8(i8* null, i8* %u)
ret i8* %v
; CHECK-LABEL: @test20
; CHECK: llvm.side.noalias.p0i8
; CHECK: llvm.noalias.arg.guard.p0i8
; CHECK: ret i8* %v
}
define i8* @test21() {
%u = call i8* @llvm.side.noalias.p0i8.p0i8.p0p0i8.p0p0i8.i32(i8* null, i8* null, i8** null, i8** null, i32 0, metadata !1)
%v = call i8* @llvm.noalias.arg.guard.p0i8.p0i8(i8* undef, i8* %u)
ret i8* %v
; CHECK-LABEL: @test21
; CHECK-NOT: llvm.side.noalias.p0i8
; CHECK-NOT: llvm.noalias.arg.guard.p0i8
; CHECK: ret i8* undef
}
define i8* @test30() {
%v = call i8* @llvm.noalias.copy.guard.p0i8.p0i8(i8* null, i8* null, metadata !2, metadata !1)
ret i8* %v
; CHECK-LABEL: @test30
; CHECK: llvm.noalias.copy.guard.p0i8
; CHECK: ret i8* %v
}
define void @test31() {
%v = call i8* @llvm.noalias.copy.guard.p0i8.p0i8(i8* null, i8* null, metadata !2, metadata !1)
ret void
; CHECK-LABEL: @test31
; CHECK-NOT: llvm.noalias.copy.guard.p0i8
; CHECK: ret void
}
define i8* @test32() {
%v = call i8* @llvm.noalias.copy.guard.p0i8.p0i8(i8* undef, i8* null, metadata !2, metadata !1)
ret i8* %v
; CHECK-LABEL: @test32
; CHECK-NOT: llvm.noalias.copy.guard.p0i8
; CHECK: ret i8* undef
}
define void @test40() {
%v = call i8* @llvm.noalias.decl.p0i8.p0p0i32.i32(i8** null, i32 0, metadata !1)
ret void
; CHECK-LABEL: @test40
; CHECK-NOT: llvm.noalias.decl.p0i8
; CHECK: ret void
}
define void @test41() {
%u = alloca i8*
%v = call i8* @llvm.noalias.decl.p0i8.p0p0i32.i32(i8** %u, i32 0, metadata !4)
ret void
; CHECK-LABEL: @test41
; CHECK-NOT: alloca
; CHECK-NOT: llvm.noalias.decl.p0i8
; CHECK: ret void
}
define i8** @test42() {
%u = alloca i8*
%v = call i8* @llvm.noalias.decl.p0i8.p0p0i32.i32(i8** %u, i32 0, metadata !0)
ret i8** %u
; CHECK-LABEL: @test42
; CHECK: alloca
; CHECK: llvm.noalias.decl.p0i8
; CHECK: ret i8** %u
}
declare i8* @llvm.side.noalias.p0i8.p0i8.p0p0i8.p0p0i8.i32(i8*, i8*, i8**, i8**, i32, metadata ) nounwind
declare i8* @llvm.noalias.arg.guard.p0i8.p0i8(i8*, i8*) nounwind readnone
declare i8* @llvm.noalias.copy.guard.p0i8.p0i8(i8*, i8*, metadata, metadata)
declare i8* @llvm.noalias.decl.p0i8.p0p0i32.i32(i8**, i32, metadata) argmemonly nounwind
!0 = !{!0, !"some domain"} !0 = !{!0, !"some domain"}
!1 = !{!1, !0, !"some scope"} !1 = !{!1, !0, !"some scope"}
!2 = !{!3}
!3 = !{ i64 -1, i64 0 }
!4 = !{!4, !"some other domain"}
!5 = !{!5, !4, !"some other scope"}