This is an archive of the discontinued LLVM Phabricator instance.

Differential D87964

[MemLoc] Support bcmp in MemoryLocation::getForArgument
ClosedPublic

Authored by xbolva00 on Sep 19 2020, 7:20 AM.

Details

Reviewers
fhahn
Commits
rGd716f1608cf3: [MemLoc] Support bcmp in MemoryLocation::getForArgument

Diff Detail

Event Timeline

xbolva00 created this revision.Sep 19 2020, 7:20 AM
Herald added a project: Restricted Project. · View Herald TranscriptSep 19 2020, 7:20 AM
Herald added subscribers: llvm-commits, hiraditya. · View Herald Transcript
xbolva00 requested review of this revision.Sep 19 2020, 7:20 AM
xbolva00 mentioned this in D86725: [MemLoc] Support memcmp in MemoryLocation::getForArgument..Sep 19 2020, 7:21 AM
xbolva00 updated this revision to Diff 292959.Sep 19 2020, 7:23 AM

Fixed test name.

fhahn added a comment.Sep 19 2020, 7:33 AM

Could you also add a test for BasicAA, in llvm/test/Analysis/BasicAA/libfuncs.ll?

xbolva00 updated this revision to Diff 292961.Sep 19 2020, 7:56 AM

Added testcase

xbolva00 added a comment.Sep 19 2020, 7:57 AM
In D87964#2283510, @fhahn wrote:

Could you also add a test for BasicAA, in llvm/test/Analysis/BasicAA/libfuncs.ll?

Sure! I had to change test case "setup" (we need the gnu triple to recognize bcmp).

xbolva00 updated this revision to Diff 292962.Sep 19 2020, 7:58 AM
fhahn accepted this revision.Sep 19 2020, 8:07 AM

LGTM, thanks!

llvm/test/Analysis/BasicAA/libfuncs.ll
89

nit: trailing empty line.

llvm/test/Transforms/DeadStoreElimination/MSSA/libcalls.ll
134

nit: just 1 empty line?

This revision is now accepted and ready to land.Sep 19 2020, 8:07 AM
Closed by commit rGd716f1608cf3: [MemLoc] Support bcmp in MemoryLocation::getForArgument (authored by xbolva00). · Explain WhySep 19 2020, 8:13 AM
This revision was automatically updated to reflect the committed changes.
xbolva00 added a commit: rGd716f1608cf3: [MemLoc] Support bcmp in MemoryLocation::getForArgument.

Revision Contents

PathSize
llvm/
lib/
Analysis/
3 lines
test/
Analysis/
BasicAA/
49 lines
Transforms/
DeadStoreElimination/
MSSA/
60 lines

Diff 292964

llvm/lib/Analysis/MemoryLocation.cpp

Show First 20 Lines • Show All 231 Lines • ▼ Show 20 Lines case LibFunc_memset_pattern16:
"Invalid argument index for memset_pattern16"); "Invalid argument index for memset_pattern16");
if (ArgIdx == 1) if (ArgIdx == 1)
return MemoryLocation(Arg, LocationSize::precise(16), AATags); return MemoryLocation(Arg, LocationSize::precise(16), AATags);
if (const ConstantInt *LenCI = if (const ConstantInt *LenCI =
dyn_cast<ConstantInt>(Call->getArgOperand(2))) dyn_cast<ConstantInt>(Call->getArgOperand(2)))
return MemoryLocation(Arg, LocationSize::precise(LenCI->getZExtValue()), return MemoryLocation(Arg, LocationSize::precise(LenCI->getZExtValue()),
AATags); AATags);
break; break;
case LibFunc_bcmp:
case LibFunc_memcmp: case LibFunc_memcmp:
assert((ArgIdx == 0 || ArgIdx == 1) && assert((ArgIdx == 0 || ArgIdx == 1) &&
"Invalid argument index for memcmp"); "Invalid argument index for memcmp/bcmp");
if (const ConstantInt *LenCI = if (const ConstantInt *LenCI =
dyn_cast<ConstantInt>(Call->getArgOperand(2))) dyn_cast<ConstantInt>(Call->getArgOperand(2)))
return MemoryLocation(Arg, LocationSize::precise(LenCI->getZExtValue()), return MemoryLocation(Arg, LocationSize::precise(LenCI->getZExtValue()),
AATags); AATags);
break; break;
default: default:
break; break;
}; };
} }
// FIXME: Handle memset_pattern4 and memset_pattern8 also. // FIXME: Handle memset_pattern4 and memset_pattern8 also.
return MemoryLocation(Call->getArgOperand(ArgIdx), LocationSize::unknown(), return MemoryLocation(Call->getArgOperand(ArgIdx), LocationSize::unknown(),
AATags); AATags);
} }

llvm/test/Analysis/BasicAA/libfuncs.ll

; RUN: opt -inferattrs -basic-aa -aa-eval -print-all-alias-modref-info -disable-output 2>&1 %s | FileCheck %s ; RUN: opt -mtriple=i386-pc-linux-gnu -inferattrs -basic-aa -aa-eval -print-all-alias-modref-info -disable-output 2>&1 %s | FileCheck %s
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64"
target triple = "x86_64-apple-macosx10.7"
; CHECK-LABEL: Function: test_memcmp_const_size ; CHECK-LABEL: Function: test_memcmp_const_size
; CHECK: Just Ref: Ptr: i8* %a <-> %res = tail call i32 @memcmp(i8* %a, i8* %b, i64 4) ; CHECK: Just Ref: Ptr: i8* %a <-> %res = tail call i32 @memcmp(i8* %a, i8* %b, i64 4)
; CHECK-NEXT: Just Ref: Ptr: i8* %b <-> %res = tail call i32 @memcmp(i8* %a, i8* %b, i64 4) ; CHECK-NEXT: Just Ref: Ptr: i8* %b <-> %res = tail call i32 @memcmp(i8* %a, i8* %b, i64 4)
; CHECK-NEXT: Just Ref: Ptr: i8* %a.gep.1 <-> %res = tail call i32 @memcmp(i8* %a, i8* %b, i64 4) ; CHECK-NEXT: Just Ref: Ptr: i8* %a.gep.1 <-> %res = tail call i32 @memcmp(i8* %a, i8* %b, i64 4)
; CHECK-NEXT: NoModRef: Ptr: i8* %a.gep.5 <-> %res = tail call i32 @memcmp(i8* %a, i8* %b, i64 4) ; CHECK-NEXT: NoModRef: Ptr: i8* %a.gep.5 <-> %res = tail call i32 @memcmp(i8* %a, i8* %b, i64 4)
; CHECK-NEXT: Just Ref: Ptr: i8* %b.gep.1 <-> %res = tail call i32 @memcmp(i8* %a, i8* %b, i64 4) ; CHECK-NEXT: Just Ref: Ptr: i8* %b.gep.1 <-> %res = tail call i32 @memcmp(i8* %a, i8* %b, i64 4)
; CHECK-NEXT: NoModRef: Ptr: i8* %b.gep.5 <-> %res = tail call i32 @memcmp(i8* %a, i8* %b, i64 4) ; CHECK-NEXT: NoModRef: Ptr: i8* %b.gep.5 <-> %res = tail call i32 @memcmp(i8* %a, i8* %b, i64 4)
Show All 27 Linesentry:
store i8 1, i8* %a.gep.5 store i8 1, i8* %a.gep.5
%b.gep.1 = getelementptr i8, i8* %b, i32 1 %b.gep.1 = getelementptr i8, i8* %b, i32 1
store i8 2, i8* %b.gep.1 store i8 2, i8* %b.gep.1
%b.gep.5 = getelementptr i8, i8* %b, i32 5 %b.gep.5 = getelementptr i8, i8* %b, i32 5
store i8 3, i8* %b.gep.5 store i8 3, i8* %b.gep.5
ret i32 %res ret i32 %res
} }
declare i32 @memcmp(i8*, i8*, i64) declare i32 @memcmp(i8*, i8*, i64)
declare i32 @bcmp(i8*, i8*, i64)
; CHECK-LABEL: Function: test_bcmp_const_size
; CHECK: Just Ref: Ptr: i8* %a <-> %res = tail call i32 @bcmp(i8* %a, i8* %b, i64 4)
; CHECK-NEXT: Just Ref: Ptr: i8* %b <-> %res = tail call i32 @bcmp(i8* %a, i8* %b, i64 4)
; CHECK-NEXT: Just Ref: Ptr: i8* %a.gep.1 <-> %res = tail call i32 @bcmp(i8* %a, i8* %b, i64 4)
; CHECK-NEXT: NoModRef: Ptr: i8* %a.gep.5 <-> %res = tail call i32 @bcmp(i8* %a, i8* %b, i64 4)
; CHECK-NEXT: Just Ref: Ptr: i8* %b.gep.1 <-> %res = tail call i32 @bcmp(i8* %a, i8* %b, i64 4)
; CHECK-NEXT: NoModRef: Ptr: i8* %b.gep.5 <-> %res = tail call i32 @bcmp(i8* %a, i8* %b, i64 4)
define i32 @test_bcmp_const_size(i8* noalias %a, i8* noalias %b) {
entry:
%res = tail call i32 @bcmp(i8* %a, i8* %b, i64 4)
%a.gep.1 = getelementptr i8, i8* %a, i32 1
store i8 0, i8* %a.gep.1
%a.gep.5 = getelementptr i8, i8* %a, i32 5
store i8 1, i8* %a.gep.5
%b.gep.1 = getelementptr i8, i8* %b, i32 1
store i8 2, i8* %b.gep.1
%b.gep.5 = getelementptr i8, i8* %b, i32 5
store i8 3, i8* %b.gep.5
ret i32 %res
}
; CHECK-LABEL: Function: test_bcmp_variable_size
; CHECK: Just Ref: Ptr: i8* %a <-> %res = tail call i32 @bcmp(i8* %a, i8* %b, i64 %n)
; CHECK-NEXT: Just Ref: Ptr: i8* %b <-> %res = tail call i32 @bcmp(i8* %a, i8* %b, i64 %n)
; CHECK-NEXT: Just Ref: Ptr: i8* %a.gep.1 <-> %res = tail call i32 @bcmp(i8* %a, i8* %b, i64 %n)
; CHECK-NEXT: Just Ref: Ptr: i8* %a.gep.5 <-> %res = tail call i32 @bcmp(i8* %a, i8* %b, i64 %n)
; CHECK-NEXT: Just Ref: Ptr: i8* %b.gep.1 <-> %res = tail call i32 @bcmp(i8* %a, i8* %b, i64 %n)
; CHECK-NEXT: Just Ref: Ptr: i8* %b.gep.5 <-> %res = tail call i32 @bcmp(i8* %a, i8* %b, i64 %n)
define i32 @test_bcmp_variable_size(i8* noalias %a, i8* noalias %b, i64 %n) {
entry:
%res = tail call i32 @bcmp(i8* %a, i8* %b, i64 %n)
%a.gep.1 = getelementptr i8, i8* %a, i32 1
store i8 0, i8* %a.gep.1
%a.gep.5 = getelementptr i8, i8* %a, i32 5
store i8 1, i8* %a.gep.5
%b.gep.1 = getelementptr i8, i8* %b, i32 1
store i8 2, i8* %b.gep.1
%b.gep.5 = getelementptr i8, i8* %b, i32 5
store i8 3, i8* %b.gep.5
ret i32 %res
}
fhahnUnsubmitted
Not Done
ReplyInline Actions

nit: trailing empty line.

fhahn: nit: trailing empty line.

llvm/test/Transforms/DeadStoreElimination/MSSA/libcalls.ll

Show First 20 Lines • Show All 124 Lines • ▼ Show 20 Linesentry:
store i8 50, i8* %gep.1, align 1 store i8 50, i8* %gep.1, align 1
%gep.2 = getelementptr i8, i8* %stack.ptr, i64 2 %gep.2 = getelementptr i8, i8* %stack.ptr, i64 2
store i8 51, i8* %gep.2, align 1 store i8 51, i8* %gep.2, align 1
%gep.3 = getelementptr i8, i8* %stack.ptr, i64 3 %gep.3 = getelementptr i8, i8* %stack.ptr, i64 3
store i8 52, i8* %gep.3, align 1 store i8 52, i8* %gep.3, align 1
%res = call i32 @memcmp(i8* nonnull %foo, i8* nonnull %stack.ptr, i64 %n) %res = call i32 @memcmp(i8* nonnull %foo, i8* nonnull %stack.ptr, i64 %n)
ret i32 %res ret i32 %res
} }
declare i32 @bcmp(i8*, i8*, i64)
fhahnUnsubmitted
Not Done
ReplyInline Actions

nit: just 1 empty line?

fhahn: nit: just 1 empty line?
define i1 @test_bcmp_const_size(i8* noalias %foo) {
; CHECK-LABEL: @test_bcmp_const_size(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[STACK:%.*]] = alloca [10 x i8], align 1
; CHECK-NEXT: [[STACK_PTR:%.*]] = bitcast [10 x i8]* [[STACK]] to i8*
; CHECK-NEXT: store i8 49, i8* [[STACK_PTR]], align 1
; CHECK-NEXT: [[GEP_1:%.*]] = getelementptr i8, i8* [[STACK_PTR]], i64 1
; CHECK-NEXT: store i8 50, i8* [[GEP_1]], align 1
; CHECK-NEXT: [[CALL:%.*]] = call i32 @bcmp(i8* nonnull dereferenceable(2) [[FOO:%.*]], i8* nonnull dereferenceable(2) [[STACK_PTR]], i64 2)
; CHECK-NEXT: [[RES:%.*]] = icmp eq i32 [[CALL]], 0
; CHECK-NEXT: ret i1 [[RES]]
;
entry:
%stack = alloca [10 x i8]
%stack.ptr = bitcast [10 x i8]* %stack to i8*
store i8 49, i8* %stack.ptr, align 1
%gep.1 = getelementptr i8, i8* %stack.ptr, i64 1
store i8 50, i8* %gep.1, align 1
%gep.2 = getelementptr i8, i8* %stack.ptr, i64 2
store i8 51, i8* %gep.2, align 1
%gep.3 = getelementptr i8, i8* %stack.ptr, i64 3
store i8 52, i8* %gep.3, align 1
%call = call i32 @bcmp(i8* nonnull dereferenceable(2) %foo, i8* nonnull dereferenceable(2) %stack.ptr, i64 2)
%res = icmp eq i32 %call, 0
ret i1 %res
}
define i1 @test_bcmp_variable_size(i8* noalias %foo, i64 %n) {
; CHECK-LABEL: @test_bcmp_variable_size(
; CHECK-NEXT: entry:
; CHECK-NEXT: [[STACK:%.*]] = alloca [10 x i8], align 1
; CHECK-NEXT: [[STACK_PTR:%.*]] = bitcast [10 x i8]* [[STACK]] to i8*
; CHECK-NEXT: store i8 49, i8* [[STACK_PTR]], align 1
; CHECK-NEXT: [[GEP_1:%.*]] = getelementptr i8, i8* [[STACK_PTR]], i64 1
; CHECK-NEXT: store i8 50, i8* [[GEP_1]], align 1
; CHECK-NEXT: [[GEP_2:%.*]] = getelementptr i8, i8* [[STACK_PTR]], i64 2
; CHECK-NEXT: store i8 51, i8* [[GEP_2]], align 1
; CHECK-NEXT: [[GEP_3:%.*]] = getelementptr i8, i8* [[STACK_PTR]], i64 3
; CHECK-NEXT: store i8 52, i8* [[GEP_3]], align 1
; CHECK-NEXT: [[CALL:%.*]] = call i32 @bcmp(i8* nonnull [[FOO:%.*]], i8* nonnull [[STACK_PTR]], i64 [[N:%.*]])
; CHECK-NEXT: [[RES:%.*]] = icmp eq i32 [[CALL]], 0
; CHECK-NEXT: ret i1 [[RES]]
;
entry:
%stack = alloca [10 x i8]
%stack.ptr = bitcast [10 x i8]* %stack to i8*
store i8 49, i8* %stack.ptr, align 1
%gep.1 = getelementptr i8, i8* %stack.ptr, i64 1
store i8 50, i8* %gep.1, align 1
%gep.2 = getelementptr i8, i8* %stack.ptr, i64 2
store i8 51, i8* %gep.2, align 1
%gep.3 = getelementptr i8, i8* %stack.ptr, i64 3
store i8 52, i8* %gep.3, align 1
%call = call i32 @bcmp(i8* nonnull %foo, i8* nonnull %stack.ptr, i64 %n)
%res = icmp eq i32 %call, 0
ret i1 %res
}