This is an archive of the discontinued LLVM Phabricator instance.

Differential D119272

llvm: add missing `allocalign` attributes
AbandonedPublic

Authored by durin42 on Feb 8 2022, 11:58 AM.

Details

Reviewers
jdoerfert
sstefan1
baziotis
jyknight
nikic
Summary

clang now emits these, so update calls to match what clang
would produce.

Diff Detail

Unit TestsFailed

TimeTest
60,200 msx64 debian > Clang.CodeGen/RISCV/rvv-intrinsics::vloxseg.c
60,290 msx64 debian > Clang.CodeGen/RISCV/rvv-intrinsics::vlseg.c
60,300 msx64 debian > Clang.CodeGen/RISCV/rvv-intrinsics::vlsegff.c
60,220 msx64 debian > Clang.CodeGen/RISCV/rvv-intrinsics::vluxseg.c
60,310 msx64 debian > Clang.CodeGen/RISCV/rvv-intrinsics::vsoxseg.c
View Full Test Results (22 Failed)

Event Timeline

durin42 created this revision.Feb 8 2022, 11:58 AM
Herald added subscribers: okura, kuter. · View Herald TranscriptFeb 8 2022, 11:58 AM
durin42 requested review of this revision.Feb 8 2022, 11:58 AM
Herald added a reviewer: jdoerfert. · View Herald TranscriptFeb 8 2022, 11:58 AM
Herald added a reviewer: sstefan1. · View Herald Transcript
Herald added a reviewer: baziotis. · View Herald Transcript
Herald added a project: Restricted Project. · View Herald Transcript
Herald added a subscriber: llvm-commits. · View Herald Transcript
durin42 added a child revision: D119273: llvm: only use allocalign for allocation functions.Feb 8 2022, 11:58 AM
Harbormaster completed remote builds in B148320: Diff 406917.Feb 8 2022, 12:00 PM
durin42 added a reviewer: jyknight.Feb 8 2022, 12:00 PM
durin42 updated this revision to Diff 408020.Feb 11 2022, 1:13 PM
durin42 edited the summary of this revision. (Show Details)
Harbormaster completed remote builds in B149082: Diff 408020.Feb 11 2022, 1:14 PM
durin42 updated this revision to Diff 408098.Feb 11 2022, 4:15 PM
durin42 updated this revision to Diff 408117.Feb 11 2022, 5:07 PM
Harbormaster completed remote builds in B149156: Diff 408117.Feb 11 2022, 6:34 PM
nikic accepted this revision.Feb 12 2022, 12:59 AM
nikic added a subscriber: nikic.

LGTM

This revision is now accepted and ready to land.Feb 12 2022, 12:59 AM
durin42 updated this revision to Diff 410059.Feb 18 2022, 7:34 PM
Harbormaster completed remote builds in B150517: Diff 410059.Feb 18 2022, 8:29 PM
durin42 updated this revision to Diff 410560.Feb 22 2022, 9:02 AM
Harbormaster completed remote builds in B150882: Diff 410560.Feb 22 2022, 10:32 AM
durin42 updated this revision to Diff 410897.Feb 23 2022, 11:58 AM
Harbormaster completed remote builds in B151113: Diff 410897.Feb 23 2022, 12:37 PM
jyknight accepted this revision.Mar 4 2022, 8:25 AM
Herald added a project: Restricted Project. · View Herald TranscriptMar 4 2022, 8:25 AM
durin42 updated this revision to Diff 415231.Mar 14 2022, 2:25 PM
Harbormaster completed remote builds in B154194: Diff 415231.Mar 14 2022, 2:27 PM
durin42 abandoned this revision.May 3 2022, 10:53 AM

Revision Contents

PathSize
llvm/
test/
Transforms/
Attributor/
8 lines
InstCombine/
52 lines

Diff 410560

llvm/test/Transforms/Attributor/heap_to_stack.ll

Show First 20 Lines • Show All 182 Lines • ▼ Show 20 Lines;
ret void ret void
} }
declare noalias i8* @aligned_alloc(i64, i64) declare noalias i8* @aligned_alloc(i64, i64)
define void @test3b(i8* %p) { define void @test3b(i8* %p) {
; IS________OPM-LABEL: define {{[^@]+}}@test3b ; IS________OPM-LABEL: define {{[^@]+}}@test3b
; IS________OPM-SAME: (i8* nocapture [[P:%.*]]) { ; IS________OPM-SAME: (i8* nocapture [[P:%.*]]) {
; IS________OPM-NEXT: [[TMP1:%.*]] = tail call noalias i8* @aligned_alloc(i64 noundef 32, i64 noundef 128) ; IS________OPM-NEXT: [[TMP1:%.*]] = tail call noalias i8* @aligned_alloc(i64 allocalign noundef 32, i64 noundef 128)
; IS________OPM-NEXT: tail call void @nofree_arg_only(i8* nocapture nofree [[TMP1]], i8* nocapture [[P]]) ; IS________OPM-NEXT: tail call void @nofree_arg_only(i8* nocapture nofree [[TMP1]], i8* nocapture [[P]])
; IS________OPM-NEXT: tail call void @free(i8* noalias nocapture [[TMP1]]) ; IS________OPM-NEXT: tail call void @free(i8* noalias nocapture [[TMP1]])
; IS________OPM-NEXT: ret void ; IS________OPM-NEXT: ret void
; ;
; IS________NPM-LABEL: define {{[^@]+}}@test3b ; IS________NPM-LABEL: define {{[^@]+}}@test3b
; IS________NPM-SAME: (i8* nocapture [[P:%.*]]) { ; IS________NPM-SAME: (i8* nocapture [[P:%.*]]) {
; IS________NPM-NEXT: [[TMP1:%.*]] = alloca i8, i64 128, align 32 ; IS________NPM-NEXT: [[TMP1:%.*]] = alloca i8, i64 128, align 32
; IS________NPM-NEXT: tail call void @nofree_arg_only(i8* noalias nocapture nofree [[TMP1]], i8* nocapture [[P]]) ; IS________NPM-NEXT: tail call void @nofree_arg_only(i8* noalias nocapture nofree [[TMP1]], i8* nocapture [[P]])
; IS________NPM-NEXT: ret void ; IS________NPM-NEXT: ret void
; ;
%1 = tail call noalias i8* @aligned_alloc(i64 32, i64 128) %1 = tail call noalias i8* @aligned_alloc(i64 allocalign 32, i64 128)
tail call void @nofree_arg_only(i8* %1, i8* %p) tail call void @nofree_arg_only(i8* %1, i8* %p)
tail call void @free(i8* %1) tail call void @free(i8* %1)
ret void ret void
} }
; leave alone non-constant alignments. ; leave alone non-constant alignments.
define void @test3c(i64 %alignment) { define void @test3c(i64 %alignment) {
; CHECK-LABEL: define {{[^@]+}}@test3c ; CHECK-LABEL: define {{[^@]+}}@test3c
; CHECK-SAME: (i64 [[ALIGNMENT:%.*]]) { ; CHECK-SAME: (i64 [[ALIGNMENT:%.*]]) {
; CHECK-NEXT: [[TMP1:%.*]] = tail call noalias i8* @aligned_alloc(i64 [[ALIGNMENT]], i64 noundef 128) ; CHECK-NEXT: [[TMP1:%.*]] = tail call noalias i8* @aligned_alloc(i64 allocalign [[ALIGNMENT]], i64 noundef 128)
; CHECK-NEXT: tail call void @free(i8* noalias nocapture [[TMP1]]) ; CHECK-NEXT: tail call void @free(i8* noalias nocapture [[TMP1]])
; CHECK-NEXT: ret void ; CHECK-NEXT: ret void
; ;
%1 = tail call noalias i8* @aligned_alloc(i64 %alignment, i64 128) %1 = tail call noalias i8* @aligned_alloc(i64 allocalign %alignment, i64 128)
tail call void @free(i8* %1) tail call void @free(i8* %1)
ret void ret void
} }
declare noalias i8* @calloc(i64, i64) declare noalias i8* @calloc(i64, i64)
define void @test0() { define void @test0() {
; IS________OPM-LABEL: define {{[^@]+}}@test0() { ; IS________OPM-LABEL: define {{[^@]+}}@test0() {
▲ Show 20 Lines • Show All 619 Lines • Show Last 20 Lines

llvm/test/Transforms/InstCombine/deref-alloc-fns.ll

Show All 30 Lines
; CHECK-NEXT: ret i8* [[CALL]] ; CHECK-NEXT: ret i8* [[CALL]]
; ;
%call = tail call noalias i8* @malloc(i64 40) %call = tail call noalias i8* @malloc(i64 40)
ret i8* %call ret i8* %call
} }
define noalias i8* @aligned_alloc_constant_size() { define noalias i8* @aligned_alloc_constant_size() {
; CHECK-LABEL: @aligned_alloc_constant_size( ; CHECK-LABEL: @aligned_alloc_constant_size(
; CHECK-NEXT: [[CALL:%.*]] = tail call noalias align 32 dereferenceable_or_null(512) i8* @aligned_alloc(i64 32, i64 512) ; CHECK-NEXT: [[CALL:%.*]] = tail call noalias align 32 dereferenceable_or_null(512) i8* @aligned_alloc(i64 allocalign 32, i64 512)
; CHECK-NEXT: ret i8* [[CALL]] ; CHECK-NEXT: ret i8* [[CALL]]
; ;
%call = tail call noalias i8* @aligned_alloc(i64 32, i64 512) %call = tail call noalias i8* @aligned_alloc(i64 allocalign 32, i64 512)
ret i8* %call ret i8* %call
} }
define noalias i8* @aligned_alloc_unknown_size_nonzero(i1 %c) { define noalias i8* @aligned_alloc_unknown_size_nonzero(i1 %c) {
; CHECK-LABEL: @aligned_alloc_unknown_size_nonzero( ; CHECK-LABEL: @aligned_alloc_unknown_size_nonzero(
; CHECK-NEXT: [[SIZE:%.*]] = select i1 [[C:%.*]], i64 64, i64 128 ; CHECK-NEXT: [[SIZE:%.*]] = select i1 [[C:%.*]], i64 64, i64 128
; CHECK-NEXT: [[CALL:%.*]] = tail call noalias align 32 i8* @aligned_alloc(i64 32, i64 [[SIZE]]) ; CHECK-NEXT: [[CALL:%.*]] = tail call noalias align 32 i8* @aligned_alloc(i64 allocalign 32, i64 [[SIZE]])
; CHECK-NEXT: ret i8* [[CALL]] ; CHECK-NEXT: ret i8* [[CALL]]
; ;
%size = select i1 %c, i64 64, i64 128 %size = select i1 %c, i64 64, i64 128
%call = tail call noalias i8* @aligned_alloc(i64 32, i64 %size) %call = tail call noalias i8* @aligned_alloc(i64 allocalign 32, i64 %size)
ret i8* %call ret i8* %call
} }
define noalias i8* @aligned_alloc_unknown_size_possibly_zero(i1 %c) { define noalias i8* @aligned_alloc_unknown_size_possibly_zero(i1 %c) {
; CHECK-LABEL: @aligned_alloc_unknown_size_possibly_zero( ; CHECK-LABEL: @aligned_alloc_unknown_size_possibly_zero(
; CHECK-NEXT: [[SIZE:%.*]] = select i1 [[C:%.*]], i64 64, i64 0 ; CHECK-NEXT: [[SIZE:%.*]] = select i1 [[C:%.*]], i64 64, i64 0
; CHECK-NEXT: [[CALL:%.*]] = tail call noalias align 32 i8* @aligned_alloc(i64 32, i64 [[SIZE]]) ; CHECK-NEXT: [[CALL:%.*]] = tail call noalias align 32 i8* @aligned_alloc(i64 allocalign 32, i64 [[SIZE]])
; CHECK-NEXT: ret i8* [[CALL]] ; CHECK-NEXT: ret i8* [[CALL]]
; ;
%size = select i1 %c, i64 64, i64 0 %size = select i1 %c, i64 64, i64 0
%call = tail call noalias i8* @aligned_alloc(i64 32, i64 %size) %call = tail call noalias i8* @aligned_alloc(i64 allocalign 32, i64 %size)
ret i8* %call ret i8* %call
} }
define noalias i8* @aligned_alloc_unknown_align(i64 %align) { define noalias i8* @aligned_alloc_unknown_align(i64 %align) {
; CHECK-LABEL: @aligned_alloc_unknown_align( ; CHECK-LABEL: @aligned_alloc_unknown_align(
; CHECK-NEXT: [[CALL:%.*]] = tail call noalias dereferenceable_or_null(128) i8* @aligned_alloc(i64 [[ALIGN:%.*]], i64 128) ; CHECK-NEXT: [[CALL:%.*]] = tail call noalias dereferenceable_or_null(128) i8* @aligned_alloc(i64 allocalign [[ALIGN:%.*]], i64 128)
; CHECK-NEXT: ret i8* [[CALL]] ; CHECK-NEXT: ret i8* [[CALL]]
; ;
%call = tail call noalias i8* @aligned_alloc(i64 %align, i64 128) %call = tail call noalias i8* @aligned_alloc(i64 allocalign %align, i64 128)
ret i8* %call ret i8* %call
} }
declare noalias i8* @foo(i8*, i8*, i8*) declare noalias i8* @foo(i8*, i8*, i8*)
define noalias i8* @aligned_alloc_dynamic_args(i64 %align, i64 %size) { define noalias i8* @aligned_alloc_dynamic_args(i64 %align, i64 %size) {
; CHECK-LABEL: @aligned_alloc_dynamic_args( ; CHECK-LABEL: @aligned_alloc_dynamic_args(
; CHECK-NEXT: [[CALL:%.*]] = tail call noalias dereferenceable_or_null(1024) i8* @aligned_alloc(i64 [[ALIGN:%.*]], i64 1024) ; CHECK-NEXT: [[CALL:%.*]] = tail call noalias dereferenceable_or_null(1024) i8* @aligned_alloc(i64 allocalign [[ALIGN:%.*]], i64 1024)
; CHECK-NEXT: [[CALL_1:%.*]] = tail call noalias dereferenceable_or_null(1024) i8* @aligned_alloc(i64 0, i64 1024) ; CHECK-NEXT: [[CALL_1:%.*]] = tail call noalias dereferenceable_or_null(1024) i8* @aligned_alloc(i64 allocalign 0, i64 1024)
; CHECK-NEXT: [[CALL_2:%.*]] = tail call noalias align 32 i8* @aligned_alloc(i64 32, i64 [[SIZE:%.*]]) ; CHECK-NEXT: [[CALL_2:%.*]] = tail call noalias align 32 i8* @aligned_alloc(i64 allocalign 32, i64 [[SIZE:%.*]])
; CHECK-NEXT: [[TMP1:%.*]] = call i8* @foo(i8* [[CALL]], i8* [[CALL_1]], i8* [[CALL_2]]) ; CHECK-NEXT: [[TMP1:%.*]] = call i8* @foo(i8* [[CALL]], i8* [[CALL_1]], i8* [[CALL_2]])
; CHECK-NEXT: ret i8* [[CALL]] ; CHECK-NEXT: ret i8* [[CALL]]
; ;
%call = tail call noalias i8* @aligned_alloc(i64 %align, i64 1024) %call = tail call noalias i8* @aligned_alloc(i64 allocalign %align, i64 1024)
%call_1 = tail call noalias i8* @aligned_alloc(i64 0, i64 1024) %call_1 = tail call noalias i8* @aligned_alloc(i64 allocalign 0, i64 1024)
%call_2 = tail call noalias i8* @aligned_alloc(i64 32, i64 %size) %call_2 = tail call noalias i8* @aligned_alloc(i64 allocalign 32, i64 %size)
call i8* @foo(i8* %call, i8* %call_1, i8* %call_2) call i8* @foo(i8* %call, i8* %call_1, i8* %call_2)
ret i8* %call ret i8* %call
} }
define noalias i8* @memalign_constant_size() { define noalias i8* @memalign_constant_size() {
; GNU-LABEL: @memalign_constant_size( ; GNU-LABEL: @memalign_constant_size(
; GNU-NEXT: [[CALL:%.*]] = tail call noalias align 32 dereferenceable_or_null(512) i8* @memalign(i64 32, i64 512) ; GNU-NEXT: [[CALL:%.*]] = tail call noalias align 32 dereferenceable_or_null(512) i8* @memalign(i64 allocalign 32, i64 512)
; GNU-NEXT: ret i8* [[CALL]] ; GNU-NEXT: ret i8* [[CALL]]
; ;
%call = tail call noalias i8* @memalign(i64 32, i64 512) %call = tail call noalias i8* @memalign(i64 allocalign 32, i64 512)
ret i8* %call ret i8* %call
} }
define noalias i8* @memalign_unknown_size_nonzero(i1 %c) { define noalias i8* @memalign_unknown_size_nonzero(i1 %c) {
; GNU-LABEL: @memalign_unknown_size_nonzero( ; GNU-LABEL: @memalign_unknown_size_nonzero(
; GNU-NEXT: [[SIZE:%.*]] = select i1 [[C:%.*]], i64 64, i64 128 ; GNU-NEXT: [[SIZE:%.*]] = select i1 [[C:%.*]], i64 64, i64 128
; GNU-NEXT: [[CALL:%.*]] = tail call noalias align 32 i8* @memalign(i64 32, i64 [[SIZE]]) ; GNU-NEXT: [[CALL:%.*]] = tail call noalias align 32 i8* @memalign(i64 allocalign 32, i64 [[SIZE]])
; GNU-NEXT: ret i8* [[CALL]] ; GNU-NEXT: ret i8* [[CALL]]
; ;
%size = select i1 %c, i64 64, i64 128 %size = select i1 %c, i64 64, i64 128
%call = tail call noalias i8* @memalign(i64 32, i64 %size) %call = tail call noalias i8* @memalign(i64 allocalign 32, i64 %size)
ret i8* %call ret i8* %call
} }
define noalias i8* @memalign_unknown_size_possibly_zero(i1 %c) { define noalias i8* @memalign_unknown_size_possibly_zero(i1 %c) {
; GNU-LABEL: @memalign_unknown_size_possibly_zero( ; GNU-LABEL: @memalign_unknown_size_possibly_zero(
; GNU-NEXT: [[SIZE:%.*]] = select i1 [[C:%.*]], i64 64, i64 0 ; GNU-NEXT: [[SIZE:%.*]] = select i1 [[C:%.*]], i64 64, i64 0
; GNU-NEXT: [[CALL:%.*]] = tail call noalias align 32 i8* @memalign(i64 32, i64 [[SIZE]]) ; GNU-NEXT: [[CALL:%.*]] = tail call noalias align 32 i8* @memalign(i64 allocalign 32, i64 [[SIZE]])
; GNU-NEXT: ret i8* [[CALL]] ; GNU-NEXT: ret i8* [[CALL]]
; ;
%size = select i1 %c, i64 64, i64 0 %size = select i1 %c, i64 64, i64 0
%call = tail call noalias i8* @memalign(i64 32, i64 %size) %call = tail call noalias i8* @memalign(i64 allocalign 32, i64 %size)
ret i8* %call ret i8* %call
} }
define noalias i8* @memalign_unknown_align(i64 %align) { define noalias i8* @memalign_unknown_align(i64 %align) {
; GNU-LABEL: @memalign_unknown_align( ; GNU-LABEL: @memalign_unknown_align(
; GNU-NEXT: [[CALL:%.*]] = tail call noalias dereferenceable_or_null(128) i8* @memalign(i64 [[ALIGN:%.*]], i64 128) ; GNU-NEXT: [[CALL:%.*]] = tail call noalias dereferenceable_or_null(128) i8* @memalign(i64 allocalign [[ALIGN:%.*]], i64 128)
; GNU-NEXT: ret i8* [[CALL]] ; GNU-NEXT: ret i8* [[CALL]]
; ;
%call = tail call noalias i8* @memalign(i64 %align, i64 128) %call = tail call noalias i8* @memalign(i64 allocalign %align, i64 128)
ret i8* %call ret i8* %call
} }
define noalias i8* @malloc_constant_size2() { define noalias i8* @malloc_constant_size2() {
; CHECK-LABEL: @malloc_constant_size2( ; CHECK-LABEL: @malloc_constant_size2(
; CHECK-NEXT: [[CALL:%.*]] = tail call noalias dereferenceable_or_null(40) i8* @malloc(i64 40) ; CHECK-NEXT: [[CALL:%.*]] = tail call noalias dereferenceable_or_null(40) i8* @malloc(i64 40)
; CHECK-NEXT: ret i8* [[CALL]] ; CHECK-NEXT: ret i8* [[CALL]]
; ;
▲ Show 20 Lines • Show All 191 Lines • ▼ Show 20 Lines;
ret i8* %call ret i8* %call
} }
; OSS-Fuzz #23214 ; OSS-Fuzz #23214
; https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=23214 ; https://bugs.chromium.org/p/oss-fuzz/issues/detail?id=23214
define noalias i8* @ossfuzz_23214() { define noalias i8* @ossfuzz_23214() {
; CHECK-LABEL: @ossfuzz_23214( ; CHECK-LABEL: @ossfuzz_23214(
; CHECK-NEXT: bb: ; CHECK-NEXT: bb:
; CHECK-NEXT: [[CALL:%.*]] = tail call noalias dereferenceable_or_null(512) i8* @aligned_alloc(i64 -9223372036854775808, i64 512) ; CHECK-NEXT: [[CALL:%.*]] = tail call noalias dereferenceable_or_null(512) i8* @aligned_alloc(i64 allocalign -9223372036854775808, i64 512)
; CHECK-NEXT: ret i8* [[CALL]] ; CHECK-NEXT: ret i8* [[CALL]]
; ;
bb: bb:
%and = and i64 -1, -9223372036854775808 %and = and i64 -1, -9223372036854775808
%call = tail call noalias i8* @aligned_alloc(i64 %and, i64 512) %call = tail call noalias i8* @aligned_alloc(i64 allocalign %and, i64 512)
ret i8* %call ret i8* %call
} }
define noalias i8* @op_new_align() { define noalias i8* @op_new_align() {
; CHECK-LABEL: @op_new_align( ; CHECK-LABEL: @op_new_align(
; CHECK-NEXT: [[CALL:%.*]] = tail call align 32 dereferenceable_or_null(32) i8* @_ZnajSt11align_val_t(i64 32, i64 32) ; CHECK-NEXT: [[CALL:%.*]] = tail call align 32 dereferenceable_or_null(32) i8* @_ZnajSt11align_val_t(i64 32, i64 allocalign 32)
; CHECK-NEXT: ret i8* [[CALL]] ; CHECK-NEXT: ret i8* [[CALL]]
; ;
%call = tail call i8* @_ZnajSt11align_val_t(i64 32, i64 32) %call = tail call i8* @_ZnajSt11align_val_t(i64 32, i64 allocalign 32)
ret i8* %call ret i8* %call
} }