This is an archive of the discontinued LLVM Phabricator instance.

Differential D153773

ValueTracking: Handle ptrmask in computeKnownBits
ClosedPublic

Authored by arsenm on Jun 26 2023, 7:47 AM.

Details

Reviewers
fhahn
nikic
aeubanks
jdoerfert
sanjoy
nlopes
Summary

See also D153753

Diff Detail

Event Timeline

arsenm created this revision.Jun 26 2023, 7:47 AM
Herald added a project: Restricted Project. · View Herald TranscriptJun 26 2023, 7:47 AM
Herald added subscribers: foad, StephenFan, hiraditya. · View Herald Transcript
arsenm requested review of this revision.Jun 26 2023, 7:47 AM
Herald added a project: Restricted Project. · View Herald TranscriptJun 26 2023, 7:47 AM
Herald added a subscriber: wdng. · View Herald Transcript
Harbormaster completed remote builds in B241177: Diff 534556.Jun 26 2023, 7:57 AM
nikic added inline comments.Jun 26 2023, 8:02 AM
llvm/lib/Analysis/ValueTracking.cpp
1719

This will assert if ptrmask is working on vectors.

arsenm added inline comments.Jun 26 2023, 10:23 AM
llvm/lib/Analysis/ValueTracking.cpp
1719

It seems to not work on vectors:

declare <2 x ptr> @llvm.ptrmask.v2p0.v2i64(<2 x ptr>, <2 x i64>)
define <2 x ptr> @ptrmask_align4_ptr_align1_vector(<2 x ptr> %ptr) {
   %ptrmask = call <2 x ptr> @llvm.ptrmask.v2p0.v2i64(<2 x ptr> %ptr, <2 x i64> <i64 -4, i64 -4>)
   ret <2 x ptr> %ptrmask
}

Intrinsic has incorrect return type!
ptr @llvm.ptrmask.v2p0.v2i64
nikic accepted this revision.Jun 26 2023, 1:14 PM

LGTM

llvm/lib/Analysis/ValueTracking.cpp
1719

Interesting, that seems like an oversight.

I'd still suggest to use getScalarSizeInBits() here for robustness.

This revision is now accepted and ready to land.Jun 26 2023, 1:14 PM
arsenm closed this revision.Jun 28 2023, 4:25 AM
arsenm marked an inline comment as done.

f415563b48b48d5ad4ed4aeac68f630f8b7b9f53

Revision Contents

PathSize
llvm/
lib/
Analysis/
10 lines
test/
Transforms/
InstCombine/
16 lines

Diff 534556

llvm/lib/Analysis/ValueTracking.cpp

  • This file is larger than 256 KB, so syntax highlighting is disabled by default.
Show First 20 Lines • Show All 1,706 Lines • ▼ Show 20 Lines if (const IntrinsicInst *II = dyn_cast<IntrinsicInst>(I)) {
computeKnownBits(I->getOperand(1), Known2, Depth + 1, Q); computeKnownBits(I->getOperand(1), Known2, Depth + 1, Q);
Known = KnownBits::smin(Known, Known2); Known = KnownBits::smin(Known, Known2);
break; break;
case Intrinsic::smax: case Intrinsic::smax:
computeKnownBits(I->getOperand(0), Known, Depth + 1, Q); computeKnownBits(I->getOperand(0), Known, Depth + 1, Q);
computeKnownBits(I->getOperand(1), Known2, Depth + 1, Q); computeKnownBits(I->getOperand(1), Known2, Depth + 1, Q);
Known = KnownBits::smax(Known, Known2); Known = KnownBits::smax(Known, Known2);
break; break;
case Intrinsic::ptrmask: {
computeKnownBits(I->getOperand(0), Known, Depth + 1, Q);
const Value *Mask = I->getOperand(1);
Known2 = KnownBits(Mask->getType()->getIntegerBitWidth());
nikicUnsubmitted
Not Done
ReplyInline Actions

This will assert if ptrmask is working on vectors.

nikic: This will assert if ptrmask is working on vectors.
arsenmAuthorUnsubmitted
Done
ReplyInline Actions

It seems to not work on vectors:

declare <2 x ptr> @llvm.ptrmask.v2p0.v2i64(<2 x ptr>, <2 x i64>)
define <2 x ptr> @ptrmask_align4_ptr_align1_vector(<2 x ptr> %ptr) {
   %ptrmask = call <2 x ptr> @llvm.ptrmask.v2p0.v2i64(<2 x ptr> %ptr, <2 x i64> <i64 -4, i64 -4>)
   ret <2 x ptr> %ptrmask
}

Intrinsic has incorrect return type!
ptr @llvm.ptrmask.v2p0.v2i64
arsenm: It seems to not work on vectors: ``` declare <2 x ptr> @llvm.ptrmask.v2p0.v2i64(<2 x ptr>, <2…
nikicUnsubmitted
Done
ReplyInline Actions

Interesting, that seems like an oversight.

I'd still suggest to use getScalarSizeInBits() here for robustness.

nikic: Interesting, that seems like an oversight. I'd still suggest to use getScalarSizeInBits() here…
computeKnownBits(Mask, Known2, Depth + 1, Q);
// This is basically a pointer typed and.
Known &= Known2.zextOrTrunc(Known.getBitWidth());
break;
}
case Intrinsic::x86_sse42_crc32_64_64: case Intrinsic::x86_sse42_crc32_64_64:
Known.Zero.setBitsFrom(32); Known.Zero.setBitsFrom(32);
break; break;
case Intrinsic::riscv_vsetvli: case Intrinsic::riscv_vsetvli:
case Intrinsic::riscv_vsetvlimax: case Intrinsic::riscv_vsetvlimax:
// Assume that VL output is >= 65536. // Assume that VL output is >= 65536.
// TODO: Take SEW and LMUL into account. // TODO: Take SEW and LMUL into account.
if (BitWidth > 17) if (BitWidth > 17)
▲ Show 20 Lines • Show All 6,984 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/align-addr.ll

Show First 20 Lines • Show All 132 Lines • ▼ Show 20 Lines;
%aligned = call ptr @llvm.ptrmask.p0.i64(ptr %ptr, i64 %mask) %aligned = call ptr @llvm.ptrmask.p0.i64(ptr %ptr, i64 %mask)
%load = load <16 x i8>, ptr %aligned, align 1 %load = load <16 x i8>, ptr %aligned, align 1
ret <16 x i8> %load ret <16 x i8> %load
} }
define <16 x i8> @ptrmask_align_unknown_ptr_align8(ptr align 8 %ptr, i64 %mask) { define <16 x i8> @ptrmask_align_unknown_ptr_align8(ptr align 8 %ptr, i64 %mask) {
; CHECK-LABEL: @ptrmask_align_unknown_ptr_align8( ; CHECK-LABEL: @ptrmask_align_unknown_ptr_align8(
; CHECK-NEXT: [[ALIGNED:%.*]] = call ptr @llvm.ptrmask.p0.i64(ptr [[PTR:%.*]], i64 [[MASK:%.*]]) ; CHECK-NEXT: [[ALIGNED:%.*]] = call ptr @llvm.ptrmask.p0.i64(ptr [[PTR:%.*]], i64 [[MASK:%.*]])
; CHECK-NEXT: [[LOAD:%.*]] = load <16 x i8>, ptr [[ALIGNED]], align 1 ; CHECK-NEXT: [[LOAD:%.*]] = load <16 x i8>, ptr [[ALIGNED]], align 8
; CHECK-NEXT: ret <16 x i8> [[LOAD]] ; CHECK-NEXT: ret <16 x i8> [[LOAD]]
; ;
%aligned = call ptr @llvm.ptrmask.p0.i64(ptr %ptr, i64 %mask) %aligned = call ptr @llvm.ptrmask.p0.i64(ptr %ptr, i64 %mask)
%load = load <16 x i8>, ptr %aligned, align 1 %load = load <16 x i8>, ptr %aligned, align 1
ret <16 x i8> %load ret <16 x i8> %load
} }
; Increase load align from 1 to 2 ; Increase load align from 1 to 2
define <16 x i8> @ptrmask_align2_ptr_align1(ptr align 1 %ptr) { define <16 x i8> @ptrmask_align2_ptr_align1(ptr align 1 %ptr) {
; CHECK-LABEL: @ptrmask_align2_ptr_align1( ; CHECK-LABEL: @ptrmask_align2_ptr_align1(
; CHECK-NEXT: [[ALIGNED:%.*]] = call ptr @llvm.ptrmask.p0.i64(ptr [[PTR:%.*]], i64 -2) ; CHECK-NEXT: [[ALIGNED:%.*]] = call ptr @llvm.ptrmask.p0.i64(ptr [[PTR:%.*]], i64 -2)
; CHECK-NEXT: [[LOAD:%.*]] = load <16 x i8>, ptr [[ALIGNED]], align 1 ; CHECK-NEXT: [[LOAD:%.*]] = load <16 x i8>, ptr [[ALIGNED]], align 2
; CHECK-NEXT: ret <16 x i8> [[LOAD]] ; CHECK-NEXT: ret <16 x i8> [[LOAD]]
; ;
%aligned = call ptr @llvm.ptrmask.p0.i64(ptr %ptr, i64 -2) %aligned = call ptr @llvm.ptrmask.p0.i64(ptr %ptr, i64 -2)
%load = load <16 x i8>, ptr %aligned, align 1 %load = load <16 x i8>, ptr %aligned, align 1
ret <16 x i8> %load ret <16 x i8> %load
} }
; Increase load align from 1 to 4 ; Increase load align from 1 to 4
define <16 x i8> @ptrmask_align4_ptr_align1(ptr align 1 %ptr) { define <16 x i8> @ptrmask_align4_ptr_align1(ptr align 1 %ptr) {
; CHECK-LABEL: @ptrmask_align4_ptr_align1( ; CHECK-LABEL: @ptrmask_align4_ptr_align1(
; CHECK-NEXT: [[ALIGNED:%.*]] = call ptr @llvm.ptrmask.p0.i64(ptr [[PTR:%.*]], i64 -4) ; CHECK-NEXT: [[ALIGNED:%.*]] = call ptr @llvm.ptrmask.p0.i64(ptr [[PTR:%.*]], i64 -4)
; CHECK-NEXT: [[LOAD:%.*]] = load <16 x i8>, ptr [[ALIGNED]], align 1 ; CHECK-NEXT: [[LOAD:%.*]] = load <16 x i8>, ptr [[ALIGNED]], align 4
; CHECK-NEXT: ret <16 x i8> [[LOAD]] ; CHECK-NEXT: ret <16 x i8> [[LOAD]]
; ;
%aligned = call ptr @llvm.ptrmask.p0.i64(ptr %ptr, i64 -4) %aligned = call ptr @llvm.ptrmask.p0.i64(ptr %ptr, i64 -4)
%load = load <16 x i8>, ptr %aligned, align 1 %load = load <16 x i8>, ptr %aligned, align 1
ret <16 x i8> %load ret <16 x i8> %load
} }
; Increase load align from 1 to 8 ; Increase load align from 1 to 8
define <16 x i8> @ptrmask_align8_ptr_align1(ptr align 1 %ptr) { define <16 x i8> @ptrmask_align8_ptr_align1(ptr align 1 %ptr) {
; CHECK-LABEL: @ptrmask_align8_ptr_align1( ; CHECK-LABEL: @ptrmask_align8_ptr_align1(
; CHECK-NEXT: [[ALIGNED:%.*]] = call ptr @llvm.ptrmask.p0.i64(ptr [[PTR:%.*]], i64 -8) ; CHECK-NEXT: [[ALIGNED:%.*]] = call ptr @llvm.ptrmask.p0.i64(ptr [[PTR:%.*]], i64 -8)
; CHECK-NEXT: [[LOAD:%.*]] = load <16 x i8>, ptr [[ALIGNED]], align 1 ; CHECK-NEXT: [[LOAD:%.*]] = load <16 x i8>, ptr [[ALIGNED]], align 8
; CHECK-NEXT: ret <16 x i8> [[LOAD]] ; CHECK-NEXT: ret <16 x i8> [[LOAD]]
; ;
%aligned = call ptr @llvm.ptrmask.p0.i64(ptr %ptr, i64 -8) %aligned = call ptr @llvm.ptrmask.p0.i64(ptr %ptr, i64 -8)
%load = load <16 x i8>, ptr %aligned, align 1 %load = load <16 x i8>, ptr %aligned, align 1
ret <16 x i8> %load ret <16 x i8> %load
} }
; Underlying alignment already the same as forced alignment by ptrmask ; Underlying alignment already the same as forced alignment by ptrmask
; TODO: Should be able to drop the ptrmask ; TODO: Should be able to drop the ptrmask
define <16 x i8> @ptrmask_align8_ptr_align8(ptr align 8 %ptr) { define <16 x i8> @ptrmask_align8_ptr_align8(ptr align 8 %ptr) {
; CHECK-LABEL: @ptrmask_align8_ptr_align8( ; CHECK-LABEL: @ptrmask_align8_ptr_align8(
; CHECK-NEXT: [[ALIGNED:%.*]] = call ptr @llvm.ptrmask.p0.i64(ptr [[PTR:%.*]], i64 -8) ; CHECK-NEXT: [[ALIGNED:%.*]] = call ptr @llvm.ptrmask.p0.i64(ptr [[PTR:%.*]], i64 -8)
; CHECK-NEXT: [[LOAD:%.*]] = load <16 x i8>, ptr [[ALIGNED]], align 1 ; CHECK-NEXT: [[LOAD:%.*]] = load <16 x i8>, ptr [[ALIGNED]], align 8
; CHECK-NEXT: ret <16 x i8> [[LOAD]] ; CHECK-NEXT: ret <16 x i8> [[LOAD]]
; ;
%aligned = call ptr @llvm.ptrmask.p0.i64(ptr %ptr, i64 -8) %aligned = call ptr @llvm.ptrmask.p0.i64(ptr %ptr, i64 -8)
%load = load <16 x i8>, ptr %aligned, align 1 %load = load <16 x i8>, ptr %aligned, align 1
ret <16 x i8> %load ret <16 x i8> %load
} }
; Underlying alignment greater than alignment forced by ptrmask ; Underlying alignment greater than alignment forced by ptrmask
; TODO: Should be able to drop the ptrmask ; TODO: Should be able to drop the ptrmask
define <16 x i8> @ptrmask_align8_ptr_align16(ptr align 16 %ptr) { define <16 x i8> @ptrmask_align8_ptr_align16(ptr align 16 %ptr) {
; CHECK-LABEL: @ptrmask_align8_ptr_align16( ; CHECK-LABEL: @ptrmask_align8_ptr_align16(
; CHECK-NEXT: [[ALIGNED:%.*]] = call ptr @llvm.ptrmask.p0.i64(ptr [[PTR:%.*]], i64 -8) ; CHECK-NEXT: [[ALIGNED:%.*]] = call ptr @llvm.ptrmask.p0.i64(ptr [[PTR:%.*]], i64 -8)
; CHECK-NEXT: [[LOAD:%.*]] = load <16 x i8>, ptr [[ALIGNED]], align 1 ; CHECK-NEXT: [[LOAD:%.*]] = load <16 x i8>, ptr [[ALIGNED]], align 16
; CHECK-NEXT: ret <16 x i8> [[LOAD]] ; CHECK-NEXT: ret <16 x i8> [[LOAD]]
; ;
%aligned = call ptr @llvm.ptrmask.p0.i64(ptr %ptr, i64 -8) %aligned = call ptr @llvm.ptrmask.p0.i64(ptr %ptr, i64 -8)
%load = load <16 x i8>, ptr %aligned, align 1 %load = load <16 x i8>, ptr %aligned, align 1
ret <16 x i8> %load ret <16 x i8> %load
} }
; Increase load align from 1 to 8, and the mask type is smaller ; Increase load align from 1 to 8, and the mask type is smaller
; than the pointer size. ; than the pointer size.
define <16 x i8> @ptrmask_align8_ptr_align1_smallmask(ptr align 1 %ptr) { define <16 x i8> @ptrmask_align8_ptr_align1_smallmask(ptr align 1 %ptr) {
; CHECK-LABEL: @ptrmask_align8_ptr_align1_smallmask( ; CHECK-LABEL: @ptrmask_align8_ptr_align1_smallmask(
; CHECK-NEXT: [[ALIGNED:%.*]] = call ptr @llvm.ptrmask.p0.i32(ptr [[PTR:%.*]], i32 -8) ; CHECK-NEXT: [[ALIGNED:%.*]] = call ptr @llvm.ptrmask.p0.i32(ptr [[PTR:%.*]], i32 -8)
; CHECK-NEXT: [[LOAD:%.*]] = load <16 x i8>, ptr [[ALIGNED]], align 1 ; CHECK-NEXT: [[LOAD:%.*]] = load <16 x i8>, ptr [[ALIGNED]], align 8
; CHECK-NEXT: ret <16 x i8> [[LOAD]] ; CHECK-NEXT: ret <16 x i8> [[LOAD]]
; ;
%aligned = call ptr @llvm.ptrmask.p0.i32(ptr %ptr, i32 -8) %aligned = call ptr @llvm.ptrmask.p0.i32(ptr %ptr, i32 -8)
%load = load <16 x i8>, ptr %aligned, align 1 %load = load <16 x i8>, ptr %aligned, align 1
ret <16 x i8> %load ret <16 x i8> %load
} }
; Increase load align from 1 to 8, and the mask type is larger ; Increase load align from 1 to 8, and the mask type is larger
; than the pointer size. ; than the pointer size.
define <16 x i8> @ptrmask_align8_ptr_align1_bigmask(ptr align 1 %ptr) { define <16 x i8> @ptrmask_align8_ptr_align1_bigmask(ptr align 1 %ptr) {
; CHECK-LABEL: @ptrmask_align8_ptr_align1_bigmask( ; CHECK-LABEL: @ptrmask_align8_ptr_align1_bigmask(
; CHECK-NEXT: [[ALIGNED:%.*]] = call ptr @llvm.ptrmask.p0.i128(ptr [[PTR:%.*]], i128 -8) ; CHECK-NEXT: [[ALIGNED:%.*]] = call ptr @llvm.ptrmask.p0.i128(ptr [[PTR:%.*]], i128 -8)
; CHECK-NEXT: [[LOAD:%.*]] = load <16 x i8>, ptr [[ALIGNED]], align 1 ; CHECK-NEXT: [[LOAD:%.*]] = load <16 x i8>, ptr [[ALIGNED]], align 8
; CHECK-NEXT: ret <16 x i8> [[LOAD]] ; CHECK-NEXT: ret <16 x i8> [[LOAD]]
; ;
%aligned = call ptr @llvm.ptrmask.p0.i128(ptr %ptr, i128 -8) %aligned = call ptr @llvm.ptrmask.p0.i128(ptr %ptr, i128 -8)
%load = load <16 x i8>, ptr %aligned, align 1 %load = load <16 x i8>, ptr %aligned, align 1
ret <16 x i8> %load ret <16 x i8> %load
} }