This is an archive of the discontinued LLVM Phabricator instance.

Differential D100862

[InstCombine] Teach LLVM about guaranteed alignment for malloc and others
AbandonedPublic

Authored by xbolva00 on Apr 20 2021, 9:04 AM.

Details

Reviewers
jdoerfert
rjmccall
efriedma
Summary

LLVM should be smarter about *known* malloc's alignment and this knowledge may enable other optimizations.

Diff Detail

Event Timeline

xbolva00 created this revision.Apr 20 2021, 9:04 AM
Herald added a subscriber: hiraditya. · View Herald TranscriptApr 20 2021, 9:04 AM
xbolva00 requested review of this revision.Apr 20 2021, 9:04 AM
Herald added a project: Restricted Project. · View Herald TranscriptApr 20 2021, 9:04 AM
Herald added a subscriber: llvm-commits. · View Herald Transcript
xbolva00 added inline comments.Apr 20 2021, 9:07 AM
llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp
2052

Basically reused info from Clang:
https://github.com/llvm/llvm-project/blob/d480f968ad8b56d3ee4a6b6df5532d485b0ad01e/clang/lib/Basic/TargetInfo.cpp#L72

2068

Open question for review

lebedev.ri added a subscriber: lebedev.ri.Apr 20 2021, 9:25 AM

I do not believe we should be doing this in LLVM middle-end.

xbolva00 added a comment.Apr 20 2021, 9:33 AM
In D100862#2702017, @lebedev.ri wrote:

I do not believe we should be doing this in LLVM middle-end.

Yeah. But on the other side, LLVM already does a lot ot work with libcalls and attrs (it should be Clang job, but...).

But yes, doing this in Clang seems to be a better idea.

xbolva00 added reviewers: rjmccall, efriedma.Apr 20 2021, 9:34 AM
Harbormaster completed remote builds in B99732: Diff 338888.Apr 20 2021, 9:47 AM
xbolva00 mentioned this in D100879: [Clang] Propagate guaranteed alignment for malloc and others .Apr 20 2021, 11:54 AM
xbolva00 abandoned this revision.Apr 20 2021, 12:01 PM

Abandoned, posted Clang patch. https://reviews.llvm.org/D100879

xbolva00 mentioned this in rGc2297544c047: [Clang] Propagate guaranteed alignment for malloc and others.Apr 23 2021, 2:07 AM

Revision Contents

PathSize
llvm/
lib/
Transforms/
InstCombine/
46 lines
test/
Transforms/
InstCombine/
284 lines

Diff 338888

llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp

Show First 20 Lines • Show All 991 Lines • ▼ Show 20 Lines
if (IntrinsicInst *IT = findInitTrampolineFromAlloca(TrampMem)) if (IntrinsicInst *IT = findInitTrampolineFromAlloca(TrampMem))
return IT; return IT;
if (IntrinsicInst *IT = findInitTrampolineFromBB(AdjustTramp, TrampMem)) if (IntrinsicInst *IT = findInitTrampolineFromBB(AdjustTramp, TrampMem))
return IT; return IT;
return nullptr; return nullptr;
} }
void InstCombinerImpl::annotateAnyAllocSite(CallBase &Call, const TargetLibraryInfo *TLI) { static unsigned GuaranteedAlignmentForAllocFns(CallBase &Call) {
Lint: Pre-merge checks
Inline Actions

clang-tidy: warning: invalid case style for function 'GuaranteedAlignmentForAllocFns' [readability-identifier-naming]
not useful

Lint: Pre-merge checks: clang-tidy: warning: invalid case style for function 'GuaranteedAlignmentForAllocFns'…
xbolva00AuthorUnsubmitted
Done
ReplyInline Actions

Basically reused info from Clang:
https://github.com/llvm/llvm-project/blob/d480f968ad8b56d3ee4a6b6df5532d485b0ad01e/clang/lib/Basic/TargetInfo.cpp#L72

xbolva00: Basically reused info from Clang: https://github.com/llvm/llvm…
Triple T(Call.getModule()->getTargetTriple());
// From the glibc documentation, on GNU systems, malloc guarantees 16-byte
// alignment on 64-bit systems and 8-byte alignment on 32-bit systems. See
// https://www.gnu.org/software/libc/manual/html_node/Malloc-Examples.html.
// This alignment guarantee also applies to Windows and Android. On Darwin,
// the alignment is 16 bytes on both 64-bit and 32-bit systems.
if (T.isGNUEnvironment() || T.isWindowsMSVCEnvironment() || T.isAndroid()) {
if (T.isArch64Bit())
return 16;
if (T.isArch32Bit())
return 8;
}
if (T.isOSDarwin())
return 16;
return 0; // Unknown. Can we assume 8 ???
xbolva00AuthorUnsubmitted
Done
ReplyInline Actions

Open question for review

xbolva00: Open question for review
}
void InstCombinerImpl::annotateAnyAllocSite(CallBase &Call,
const TargetLibraryInfo *TLI) {
unsigned NumArgs = Call.getNumArgOperands(); unsigned NumArgs = Call.getNumArgOperands();
ConstantInt *Op0C = dyn_cast<ConstantInt>(Call.getOperand(0)); ConstantInt *Op0C = dyn_cast<ConstantInt>(Call.getOperand(0));
ConstantInt *Op1C = ConstantInt *Op1C =
(NumArgs == 1) ? nullptr : dyn_cast<ConstantInt>(Call.getOperand(1)); (NumArgs == 1) ? nullptr : dyn_cast<ConstantInt>(Call.getOperand(1));
// Bail out if the allocation size is zero (or an invalid alignment of zero // Bail out if the allocation size is zero (or an invalid alignment of zero
// with aligned_alloc). // with aligned_alloc).
if ((Op0C && Op0C->isNullValue()) || (Op1C && Op1C->isNullValue())) if ((Op0C && Op0C->isNullValue()) || (Op1C && Op1C->isNullValue()))
return; return;
unsigned AlignmentForAlloc = GuaranteedAlignmentForAllocFns(Call);
if (isMallocLikeFn(&Call, TLI) && Op0C) { if (isMallocLikeFn(&Call, TLI) && Op0C) {
if (isOpNewLikeFn(&Call, TLI)) if (isOpNewLikeFn(&Call, TLI))
Call.addAttribute(AttributeList::ReturnIndex, Call.addAttribute(AttributeList::ReturnIndex,
Attribute::getWithDereferenceableBytes( Attribute::getWithDereferenceableBytes(
Call.getContext(), Op0C->getZExtValue())); Call.getContext(), Op0C->getZExtValue()));
else else
Call.addAttribute(AttributeList::ReturnIndex, Call.addAttribute(AttributeList::ReturnIndex,
Attribute::getWithDereferenceableOrNullBytes( Attribute::getWithDereferenceableOrNullBytes(
Call.getContext(), Op0C->getZExtValue())); Call.getContext(), Op0C->getZExtValue()));
if (AlignmentForAlloc)
Call.addAttribute(AttributeList::ReturnIndex,
Attribute::getWithAlignment(Call.getContext(),
Align(AlignmentForAlloc)));
} else if (isAlignedAllocLikeFn(&Call, TLI)) { } else if (isAlignedAllocLikeFn(&Call, TLI)) {
if (Op1C) if (Op1C)
Call.addAttribute(AttributeList::ReturnIndex, Call.addAttribute(AttributeList::ReturnIndex,
Attribute::getWithDereferenceableOrNullBytes( Attribute::getWithDereferenceableOrNullBytes(
Call.getContext(), Op1C->getZExtValue())); Call.getContext(), Op1C->getZExtValue()));
// Add alignment attribute if alignment is a power of two constant. // Add alignment attribute if alignment is a power of two constant.
if (Op0C && Op0C->getValue().ult(llvm::Value::MaximumAlignment) && if (Op0C && Op0C->getValue().ult(llvm::Value::MaximumAlignment) &&
isKnownNonZero(Call.getOperand(1), DL, 0, &AC, &Call, &DT)) { isKnownNonZero(Call.getOperand(1), DL, 0, &AC, &Call, &DT)) {
uint64_t AlignmentVal = Op0C->getZExtValue(); uint64_t AlignmentVal = Op0C->getZExtValue();
if (llvm::isPowerOf2_64(AlignmentVal)) if (llvm::isPowerOf2_64(AlignmentVal))
Call.addAttribute(AttributeList::ReturnIndex, Call.addAttribute(AttributeList::ReturnIndex,
Attribute::getWithAlignment(Call.getContext(), Attribute::getWithAlignment(Call.getContext(),
Align(AlignmentVal))); Align(AlignmentVal)));
} else if (AlignmentForAlloc) {
Call.addAttribute(AttributeList::ReturnIndex,
Attribute::getWithAlignment(Call.getContext(),
Align(AlignmentForAlloc)));
} }
} else if (isReallocLikeFn(&Call, TLI) && Op1C) { } else if (isReallocLikeFn(&Call, TLI) && Op1C) {
Call.addAttribute(AttributeList::ReturnIndex, Call.addAttribute(AttributeList::ReturnIndex,
Attribute::getWithDereferenceableOrNullBytes( Attribute::getWithDereferenceableOrNullBytes(
Call.getContext(), Op1C->getZExtValue())); Call.getContext(), Op1C->getZExtValue()));
if (AlignmentForAlloc)
Call.addAttribute(AttributeList::ReturnIndex,
Attribute::getWithAlignment(Call.getContext(),
Lint: Pre-merge checks
Inline Actions

clang-format: please reformat the code

-                       Attribute::getWithAlignment(Call.getContext(),
-                                                   Align(AlignmentForAlloc)));
+                        Attribute::getWithAlignment(Call.getContext(),
+                                                    Align(AlignmentForAlloc)));
Lint: Pre-merge checks: clang-format: please reformat the code ``` - Attribute::getWithAlignment…
Align(AlignmentForAlloc)));
} else if (isCallocLikeFn(&Call, TLI) && Op0C && Op1C) { } else if (isCallocLikeFn(&Call, TLI) && Op0C && Op1C) {
bool Overflow; bool Overflow;
const APInt &N = Op0C->getValue(); const APInt &N = Op0C->getValue();
APInt Size = N.umul_ov(Op1C->getValue(), Overflow); APInt Size = N.umul_ov(Op1C->getValue(), Overflow);
if (!Overflow) if (!Overflow)
Call.addAttribute(AttributeList::ReturnIndex, Call.addAttribute(AttributeList::ReturnIndex,
Attribute::getWithDereferenceableOrNullBytes( Attribute::getWithDereferenceableOrNullBytes(
Call.getContext(), Size.getZExtValue())); Call.getContext(), Size.getZExtValue()));
if (AlignmentForAlloc)
Call.addAttribute(AttributeList::ReturnIndex,
Attribute::getWithAlignment(Call.getContext(),
Lint: Pre-merge checks
Inline Actions

clang-format: please reformat the code

-                       Attribute::getWithAlignment(Call.getContext(),
-                                                   Align(AlignmentForAlloc)));
+                        Attribute::getWithAlignment(Call.getContext(),
+                                                    Align(AlignmentForAlloc)));
Lint: Pre-merge checks: clang-format: please reformat the code ``` - Attribute::getWithAlignment…
Align(AlignmentForAlloc)));
} else if (isStrdupLikeFn(&Call, TLI)) { } else if (isStrdupLikeFn(&Call, TLI)) {
uint64_t Len = GetStringLength(Call.getOperand(0)); uint64_t Len = GetStringLength(Call.getOperand(0));
if (Len) { if (Len) {
// strdup // strdup
if (NumArgs == 1) if (NumArgs == 1)
Call.addAttribute(AttributeList::ReturnIndex, Call.addAttribute(AttributeList::ReturnIndex,
Attribute::getWithDereferenceableOrNullBytes( Attribute::getWithDereferenceableOrNullBytes(
Call.getContext(), Len)); Call.getContext(), Len));
// strndup // strndup
else if (NumArgs == 2 && Op1C) else if (NumArgs == 2 && Op1C)
Call.addAttribute( Call.addAttribute(
AttributeList::ReturnIndex, AttributeList::ReturnIndex,
Attribute::getWithDereferenceableOrNullBytes( Attribute::getWithDereferenceableOrNullBytes(
Call.getContext(), std::min(Len, Op1C->getZExtValue() + 1))); Call.getContext(), std::min(Len, Op1C->getZExtValue() + 1)));
} }
if (AlignmentForAlloc)
Call.addAttribute(AttributeList::ReturnIndex,
Attribute::getWithAlignment(Call.getContext(),
Lint: Pre-merge checks
Inline Actions

clang-format: please reformat the code

-                       Attribute::getWithAlignment(Call.getContext(),
-                                                   Align(AlignmentForAlloc)));
+                        Attribute::getWithAlignment(Call.getContext(),
+                                                    Align(AlignmentForAlloc)));
Lint: Pre-merge checks: clang-format: please reformat the code ``` - Attribute::getWithAlignment…
Align(AlignmentForAlloc)));
} }
} }
/// Improvements for call, callbr and invoke instructions. /// Improvements for call, callbr and invoke instructions.
Instruction *InstCombinerImpl::visitCallBase(CallBase &Call) { Instruction *InstCombinerImpl::visitCallBase(CallBase &Call) {
if (isAllocationFn(&Call, &TLI)) if (isAllocationFn(&Call, &TLI))
annotateAnyAllocSite(Call, &TLI); annotateAnyAllocSite(Call, &TLI);
▲ Show 20 Lines • Show All 684 Lines • Show Last 20 Lines

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

; NOTE: Assertions have been autogenerated by utils/update_test_checks.py ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
; RUN: opt -instcombine -S < %s | FileCheck %s ; RUN: opt -instcombine -S < %s | FileCheck %s
; RUN: opt -mtriple=x86_64-unknown-linux-gnu < %s -instcombine -S | FileCheck %s --check-prefixes=CHECK,GNU ; RUN: opt -instcombine -S < %s -mtriple=x86_64-unknown-linux-gnu | FileCheck %s --check-prefixes=CHECK,GNU64
; RUN: opt -instcombine -S < %s -mtriple=i386-unknown-linux-gnu | FileCheck %s --check-prefixes=CHECK,GNU32
; RUN: opt -instcombine -S < %s -mtriple=x86_64-pc-windows-msvc | FileCheck %s --check-prefixes=CHECK,MSVC
declare noalias i8* @malloc(i64) declare noalias i8* @malloc(i64)
declare noalias i8* @calloc(i64, i64) declare noalias i8* @calloc(i64, i64)
declare noalias i8* @realloc(i8* nocapture, i64) declare noalias i8* @realloc(i8* nocapture, i64)
declare noalias nonnull i8* @_Znam(i64) ; throwing version of 'new' declare noalias nonnull i8* @_Znam(i64) ; throwing version of 'new'
declare noalias nonnull i8* @_Znwm(i64) ; throwing version of 'new' declare noalias nonnull i8* @_Znwm(i64) ; throwing version of 'new'
declare noalias i8* @strdup(i8*) declare noalias i8* @strdup(i8*)
declare noalias i8* @aligned_alloc(i64, i64) declare noalias i8* @aligned_alloc(i64, i64)
declare noalias i8* @memalign(i64, i64) declare noalias i8* @memalign(i64, i64)
@.str = private unnamed_addr constant [6 x i8] c"hello\00", align 1 @.str = private unnamed_addr constant [6 x i8] c"hello\00", align 1
define noalias i8* @malloc_nonconstant_size(i64 %n) { define noalias i8* @malloc_nonconstant_size(i64 %n) {
; CHECK-LABEL: @malloc_nonconstant_size( ; CHECK-LABEL: @malloc_nonconstant_size(
; CHECK-NEXT: [[CALL:%.*]] = tail call noalias i8* @malloc(i64 [[N:%.*]]) ; CHECK-NEXT: [[CALL:%.*]] = tail call noalias i8* @malloc(i64 [[N:%.*]])
; CHECK-NEXT: ret i8* [[CALL]] ; CHECK-NEXT: ret i8* [[CALL]]
; ;
%call = tail call noalias i8* @malloc(i64 %n) %call = tail call noalias i8* @malloc(i64 %n)
ret i8* %call ret i8* %call
} }
define noalias i8* @malloc_constant_size() { define noalias i8* @malloc_constant_size() {
; CHECK-LABEL: @malloc_constant_size( ; GNU64-LABEL: @malloc_constant_size(
; CHECK-NEXT: [[CALL:%.*]] = tail call noalias dereferenceable_or_null(40) i8* @malloc(i64 40) ; GNU64-NEXT: [[CALL:%.*]] = tail call noalias align 16 dereferenceable_or_null(40) i8* @malloc(i64 40)
; CHECK-NEXT: ret i8* [[CALL]] ; GNU64-NEXT: ret i8* [[CALL]]
;
; GNU32-LABEL: @malloc_constant_size(
; GNU32-NEXT: [[CALL:%.*]] = tail call noalias align 8 dereferenceable_or_null(40) i8* @malloc(i64 40)
; GNU32-NEXT: ret i8* [[CALL]]
;
; MSVC-LABEL: @malloc_constant_size(
; MSVC-NEXT: [[CALL:%.*]] = tail call noalias align 16 dereferenceable_or_null(40) i8* @malloc(i64 40)
; MSVC-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 32, i64 512)
Show All 10 Lines
; 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 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( ; GNU64-LABEL: @aligned_alloc_unknown_size_possibly_zero(
; CHECK-NEXT: [[SIZE:%.*]] = select i1 [[C:%.*]], i64 64, i64 0 ; GNU64-NEXT: [[SIZE:%.*]] = select i1 [[C:%.*]], i64 64, i64 0
; CHECK-NEXT: [[CALL:%.*]] = tail call noalias i8* @aligned_alloc(i64 32, i64 [[SIZE]]) ; GNU64-NEXT: [[CALL:%.*]] = tail call noalias align 16 i8* @aligned_alloc(i64 32, i64 [[SIZE]])
; CHECK-NEXT: ret i8* [[CALL]] ; GNU64-NEXT: ret i8* [[CALL]]
;
; GNU32-LABEL: @aligned_alloc_unknown_size_possibly_zero(
; GNU32-NEXT: [[SIZE:%.*]] = select i1 [[C:%.*]], i64 64, i64 0
; GNU32-NEXT: [[CALL:%.*]] = tail call noalias align 8 i8* @aligned_alloc(i64 32, i64 [[SIZE]])
; GNU32-NEXT: ret i8* [[CALL]]
;
; MSVC-LABEL: @aligned_alloc_unknown_size_possibly_zero(
; MSVC-NEXT: [[SIZE:%.*]] = select i1 [[C:%.*]], i64 64, i64 0
; MSVC-NEXT: [[CALL:%.*]] = tail call noalias align 16 i8* @aligned_alloc(i64 32, i64 [[SIZE]])
; MSVC-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 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( ; GNU64-LABEL: @aligned_alloc_unknown_align(
; CHECK-NEXT: [[CALL:%.*]] = tail call noalias dereferenceable_or_null(128) i8* @aligned_alloc(i64 [[ALIGN:%.*]], i64 128) ; GNU64-NEXT: [[CALL:%.*]] = tail call noalias align 16 dereferenceable_or_null(128) i8* @aligned_alloc(i64 [[ALIGN:%.*]], i64 128)
; CHECK-NEXT: ret i8* [[CALL]] ; GNU64-NEXT: ret i8* [[CALL]]
;
; GNU32-LABEL: @aligned_alloc_unknown_align(
; GNU32-NEXT: [[CALL:%.*]] = tail call noalias align 8 dereferenceable_or_null(128) i8* @aligned_alloc(i64 [[ALIGN:%.*]], i64 128)
; GNU32-NEXT: ret i8* [[CALL]]
;
; MSVC-LABEL: @aligned_alloc_unknown_align(
; MSVC-NEXT: [[CALL:%.*]] = tail call noalias align 16 dereferenceable_or_null(128) i8* @aligned_alloc(i64 [[ALIGN:%.*]], i64 128)
; MSVC-NEXT: ret i8* [[CALL]]
; ;
%call = tail call noalias i8* @aligned_alloc(i64 %align, i64 128) %call = tail call noalias i8* @aligned_alloc(i64 %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( ; GNU64-LABEL: @aligned_alloc_dynamic_args(
; CHECK-NEXT: [[CALL:%.*]] = tail call noalias dereferenceable_or_null(1024) i8* @aligned_alloc(i64 [[ALIGN:%.*]], i64 1024) ; GNU64-NEXT: [[CALL:%.*]] = tail call noalias align 16 dereferenceable_or_null(1024) i8* @aligned_alloc(i64 [[ALIGN:%.*]], i64 1024)
; CHECK-NEXT: [[CALL_1:%.*]] = tail call noalias i8* @aligned_alloc(i64 0, i64 1024) ; GNU64-NEXT: [[CALL_1:%.*]] = tail call noalias i8* @aligned_alloc(i64 0, i64 1024)
; CHECK-NEXT: [[CALL_2:%.*]] = tail call noalias i8* @aligned_alloc(i64 32, i64 [[SIZE:%.*]]) ; GNU64-NEXT: [[CALL_2:%.*]] = tail call noalias align 16 i8* @aligned_alloc(i64 32, i64 [[SIZE:%.*]])
; CHECK-NEXT: [[TMP1:%.*]] = call i8* @foo(i8* [[CALL]], i8* [[CALL_1]], i8* [[CALL_2]]) ; GNU64-NEXT: [[TMP1:%.*]] = call i8* @foo(i8* [[CALL]], i8* [[CALL_1]], i8* [[CALL_2]])
; CHECK-NEXT: ret i8* [[CALL]] ; GNU64-NEXT: ret i8* [[CALL]]
;
; GNU32-LABEL: @aligned_alloc_dynamic_args(
; GNU32-NEXT: [[CALL:%.*]] = tail call noalias align 8 dereferenceable_or_null(1024) i8* @aligned_alloc(i64 [[ALIGN:%.*]], i64 1024)
; GNU32-NEXT: [[CALL_1:%.*]] = tail call noalias i8* @aligned_alloc(i64 0, i64 1024)
; GNU32-NEXT: [[CALL_2:%.*]] = tail call noalias align 8 i8* @aligned_alloc(i64 32, i64 [[SIZE:%.*]])
; GNU32-NEXT: [[TMP1:%.*]] = call i8* @foo(i8* [[CALL]], i8* [[CALL_1]], i8* [[CALL_2]])
; GNU32-NEXT: ret i8* [[CALL]]
;
; MSVC-LABEL: @aligned_alloc_dynamic_args(
; MSVC-NEXT: [[CALL:%.*]] = tail call noalias align 16 dereferenceable_or_null(1024) i8* @aligned_alloc(i64 [[ALIGN:%.*]], i64 1024)
; MSVC-NEXT: [[CALL_1:%.*]] = tail call noalias i8* @aligned_alloc(i64 0, i64 1024)
; MSVC-NEXT: [[CALL_2:%.*]] = tail call noalias align 16 i8* @aligned_alloc(i64 32, i64 [[SIZE:%.*]])
; MSVC-NEXT: [[TMP1:%.*]] = call i8* @foo(i8* [[CALL]], i8* [[CALL_1]], i8* [[CALL_2]])
; MSVC-NEXT: ret i8* [[CALL]]
; ;
%call = tail call noalias i8* @aligned_alloc(i64 %align, i64 1024) %call = tail call noalias i8* @aligned_alloc(i64 %align, i64 1024)
%call_1 = tail call noalias i8* @aligned_alloc(i64 0, i64 1024) %call_1 = tail call noalias i8* @aligned_alloc(i64 0, i64 1024)
%call_2 = tail call noalias i8* @aligned_alloc(i64 32, i64 %size) %call_2 = tail call noalias i8* @aligned_alloc(i64 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( ; GNU64-LABEL: @memalign_constant_size(
; GNU-NEXT: [[CALL:%.*]] = tail call noalias align 32 dereferenceable_or_null(512) i8* @memalign(i64 32, i64 512) ; GNU64-NEXT: [[CALL:%.*]] = tail call noalias align 32 dereferenceable_or_null(512) i8* @memalign(i64 32, i64 512)
; GNU-NEXT: ret i8* [[CALL]] ; GNU64-NEXT: ret i8* [[CALL]]
;
; GNU32-LABEL: @memalign_constant_size(
; GNU32-NEXT: [[CALL:%.*]] = tail call noalias align 32 dereferenceable_or_null(512) i8* @memalign(i64 32, i64 512)
; GNU32-NEXT: ret i8* [[CALL]]
;
; MSVC-LABEL: @memalign_constant_size(
; MSVC-NEXT: [[CALL:%.*]] = tail call noalias i8* @memalign(i64 32, i64 512)
; MSVC-NEXT: ret i8* [[CALL]]
; ;
%call = tail call noalias i8* @memalign(i64 32, i64 512) %call = tail call noalias i8* @memalign(i64 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( ; GNU64-LABEL: @memalign_unknown_size_nonzero(
; GNU-NEXT: [[SIZE:%.*]] = select i1 [[C:%.*]], i64 64, i64 128 ; GNU64-NEXT: [[SIZE:%.*]] = select i1 [[C:%.*]], i64 64, i64 128
; GNU-NEXT: [[CALL:%.*]] = tail call noalias align 32 i8* @memalign(i64 32, i64 [[SIZE]]) ; GNU64-NEXT: [[CALL:%.*]] = tail call noalias align 32 i8* @memalign(i64 32, i64 [[SIZE]])
; GNU-NEXT: ret i8* [[CALL]] ; GNU64-NEXT: ret i8* [[CALL]]
;
; GNU32-LABEL: @memalign_unknown_size_nonzero(
; GNU32-NEXT: [[SIZE:%.*]] = select i1 [[C:%.*]], i64 64, i64 128
; GNU32-NEXT: [[CALL:%.*]] = tail call noalias align 32 i8* @memalign(i64 32, i64 [[SIZE]])
; GNU32-NEXT: ret i8* [[CALL]]
;
; MSVC-LABEL: @memalign_unknown_size_nonzero(
; MSVC-NEXT: [[SIZE:%.*]] = select i1 [[C:%.*]], i64 64, i64 128
; MSVC-NEXT: [[CALL:%.*]] = tail call noalias i8* @memalign(i64 32, i64 [[SIZE]])
; MSVC-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 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) {
; CHECK-LABEL: @memalign_unknown_size_possibly_zero( ; GNU64-LABEL: @memalign_unknown_size_possibly_zero(
; CHECK-NEXT: [[SIZE:%.*]] = select i1 [[C:%.*]], i64 64, i64 0 ; GNU64-NEXT: [[SIZE:%.*]] = select i1 [[C:%.*]], i64 64, i64 0
; CHECK-NEXT: [[CALL:%.*]] = tail call noalias i8* @memalign(i64 32, i64 [[SIZE]]) ; GNU64-NEXT: [[CALL:%.*]] = tail call noalias align 16 i8* @memalign(i64 32, i64 [[SIZE]])
; CHECK-NEXT: ret i8* [[CALL]] ; GNU64-NEXT: ret i8* [[CALL]]
;
; GNU32-LABEL: @memalign_unknown_size_possibly_zero(
; GNU32-NEXT: [[SIZE:%.*]] = select i1 [[C:%.*]], i64 64, i64 0
; GNU32-NEXT: [[CALL:%.*]] = tail call noalias align 8 i8* @memalign(i64 32, i64 [[SIZE]])
; GNU32-NEXT: ret i8* [[CALL]]
;
; MSVC-LABEL: @memalign_unknown_size_possibly_zero(
; MSVC-NEXT: [[SIZE:%.*]] = select i1 [[C:%.*]], i64 64, i64 0
; MSVC-NEXT: [[CALL:%.*]] = tail call noalias i8* @memalign(i64 32, i64 [[SIZE]])
; MSVC-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 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( ; GNU64-LABEL: @memalign_unknown_align(
; GNU-NEXT: [[CALL:%.*]] = tail call noalias dereferenceable_or_null(128) i8* @memalign(i64 [[ALIGN:%.*]], i64 128) ; GNU64-NEXT: [[CALL:%.*]] = tail call noalias align 16 dereferenceable_or_null(128) i8* @memalign(i64 [[ALIGN:%.*]], i64 128)
; GNU-NEXT: ret i8* [[CALL]] ; GNU64-NEXT: ret i8* [[CALL]]
;
; GNU32-LABEL: @memalign_unknown_align(
; GNU32-NEXT: [[CALL:%.*]] = tail call noalias align 8 dereferenceable_or_null(128) i8* @memalign(i64 [[ALIGN:%.*]], i64 128)
; GNU32-NEXT: ret i8* [[CALL]]
;
; MSVC-LABEL: @memalign_unknown_align(
; MSVC-NEXT: [[CALL:%.*]] = tail call noalias i8* @memalign(i64 [[ALIGN:%.*]], i64 128)
; MSVC-NEXT: ret i8* [[CALL]]
; ;
%call = tail call noalias i8* @memalign(i64 %align, i64 128) %call = tail call noalias i8* @memalign(i64 %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( ; GNU64-LABEL: @malloc_constant_size2(
; CHECK-NEXT: [[CALL:%.*]] = tail call noalias dereferenceable_or_null(80) i8* @malloc(i64 40) ; GNU64-NEXT: [[CALL:%.*]] = tail call noalias align 16 dereferenceable_or_null(80) i8* @malloc(i64 40)
; CHECK-NEXT: ret i8* [[CALL]] ; GNU64-NEXT: ret i8* [[CALL]]
;
; GNU32-LABEL: @malloc_constant_size2(
; GNU32-NEXT: [[CALL:%.*]] = tail call noalias align 8 dereferenceable_or_null(80) i8* @malloc(i64 40)
; GNU32-NEXT: ret i8* [[CALL]]
;
; MSVC-LABEL: @malloc_constant_size2(
; MSVC-NEXT: [[CALL:%.*]] = tail call noalias align 16 dereferenceable_or_null(80) i8* @malloc(i64 40)
; MSVC-NEXT: ret i8* [[CALL]]
; ;
%call = tail call noalias dereferenceable_or_null(80) i8* @malloc(i64 40) %call = tail call noalias dereferenceable_or_null(80) i8* @malloc(i64 40)
ret i8* %call ret i8* %call
} }
define noalias i8* @malloc_constant_size3() { define noalias i8* @malloc_constant_size3() {
; CHECK-LABEL: @malloc_constant_size3( ; GNU64-LABEL: @malloc_constant_size3(
; CHECK-NEXT: [[CALL:%.*]] = tail call noalias dereferenceable(80) dereferenceable_or_null(40) i8* @malloc(i64 40) ; GNU64-NEXT: [[CALL:%.*]] = tail call noalias align 16 dereferenceable(80) dereferenceable_or_null(40) i8* @malloc(i64 40)
; CHECK-NEXT: ret i8* [[CALL]] ; GNU64-NEXT: ret i8* [[CALL]]
;
; GNU32-LABEL: @malloc_constant_size3(
; GNU32-NEXT: [[CALL:%.*]] = tail call noalias align 8 dereferenceable(80) dereferenceable_or_null(40) i8* @malloc(i64 40)
; GNU32-NEXT: ret i8* [[CALL]]
;
; MSVC-LABEL: @malloc_constant_size3(
; MSVC-NEXT: [[CALL:%.*]] = tail call noalias align 16 dereferenceable(80) dereferenceable_or_null(40) i8* @malloc(i64 40)
; MSVC-NEXT: ret i8* [[CALL]]
; ;
%call = tail call noalias dereferenceable(80) i8* @malloc(i64 40) %call = tail call noalias dereferenceable(80) i8* @malloc(i64 40)
ret i8* %call ret i8* %call
} }
define noalias i8* @malloc_constant_zero_size() { define noalias i8* @malloc_constant_zero_size() {
; CHECK-LABEL: @malloc_constant_zero_size( ; CHECK-LABEL: @malloc_constant_zero_size(
; CHECK-NEXT: [[CALL:%.*]] = tail call noalias i8* @malloc(i64 0) ; CHECK-NEXT: [[CALL:%.*]] = tail call noalias i8* @malloc(i64 0)
Show All 17 Lines
; CHECK-NEXT: [[CALL:%.*]] = tail call noalias i8* @realloc(i8* [[P:%.*]], i64 0) ; CHECK-NEXT: [[CALL:%.*]] = tail call noalias i8* @realloc(i8* [[P:%.*]], i64 0)
; CHECK-NEXT: ret i8* [[CALL]] ; CHECK-NEXT: ret i8* [[CALL]]
; ;
%call = tail call noalias i8* @realloc(i8* %p, i64 0) %call = tail call noalias i8* @realloc(i8* %p, i64 0)
ret i8* %call ret i8* %call
} }
define noalias i8* @realloc_constant_size(i8* %p) { define noalias i8* @realloc_constant_size(i8* %p) {
; CHECK-LABEL: @realloc_constant_size( ; GNU64-LABEL: @realloc_constant_size(
; CHECK-NEXT: [[CALL:%.*]] = tail call noalias dereferenceable_or_null(40) i8* @realloc(i8* [[P:%.*]], i64 40) ; GNU64-NEXT: [[CALL:%.*]] = tail call noalias align 16 dereferenceable_or_null(40) i8* @realloc(i8* [[P:%.*]], i64 40)
; CHECK-NEXT: ret i8* [[CALL]] ; GNU64-NEXT: ret i8* [[CALL]]
;
; GNU32-LABEL: @realloc_constant_size(
; GNU32-NEXT: [[CALL:%.*]] = tail call noalias align 8 dereferenceable_or_null(40) i8* @realloc(i8* [[P:%.*]], i64 40)
; GNU32-NEXT: ret i8* [[CALL]]
;
; MSVC-LABEL: @realloc_constant_size(
; MSVC-NEXT: [[CALL:%.*]] = tail call noalias align 16 dereferenceable_or_null(40) i8* @realloc(i8* [[P:%.*]], i64 40)
; MSVC-NEXT: ret i8* [[CALL]]
; ;
%call = tail call noalias i8* @realloc(i8* %p, i64 40) %call = tail call noalias i8* @realloc(i8* %p, i64 40)
ret i8* %call ret i8* %call
} }
define noalias i8* @calloc_nonconstant_size(i64 %n) { define noalias i8* @calloc_nonconstant_size(i64 %n) {
; CHECK-LABEL: @calloc_nonconstant_size( ; CHECK-LABEL: @calloc_nonconstant_size(
; CHECK-NEXT: [[CALL:%.*]] = tail call noalias i8* @calloc(i64 1, i64 [[N:%.*]]) ; CHECK-NEXT: [[CALL:%.*]] = tail call noalias i8* @calloc(i64 1, i64 [[N:%.*]])
▲ Show 20 Lines • Show All 63 Lines • ▼ Show 20 Lines
; CHECK-NEXT: [[CALL:%.*]] = tail call noalias i8* @calloc(i64 1, i64 0) ; CHECK-NEXT: [[CALL:%.*]] = tail call noalias i8* @calloc(i64 1, i64 0)
; CHECK-NEXT: ret i8* [[CALL]] ; CHECK-NEXT: ret i8* [[CALL]]
; ;
%call = tail call noalias i8* @calloc(i64 1, i64 0) %call = tail call noalias i8* @calloc(i64 1, i64 0)
ret i8* %call ret i8* %call
} }
define noalias i8* @calloc_constant_size() { define noalias i8* @calloc_constant_size() {
; CHECK-LABEL: @calloc_constant_size( ; GNU64-LABEL: @calloc_constant_size(
; CHECK-NEXT: [[CALL:%.*]] = tail call noalias dereferenceable_or_null(128) i8* @calloc(i64 16, i64 8) ; GNU64-NEXT: [[CALL:%.*]] = tail call noalias align 16 dereferenceable_or_null(128) i8* @calloc(i64 16, i64 8)
; CHECK-NEXT: ret i8* [[CALL]] ; GNU64-NEXT: ret i8* [[CALL]]
;
; GNU32-LABEL: @calloc_constant_size(
; GNU32-NEXT: [[CALL:%.*]] = tail call noalias align 8 dereferenceable_or_null(128) i8* @calloc(i64 16, i64 8)
; GNU32-NEXT: ret i8* [[CALL]]
;
; MSVC-LABEL: @calloc_constant_size(
; MSVC-NEXT: [[CALL:%.*]] = tail call noalias align 16 dereferenceable_or_null(128) i8* @calloc(i64 16, i64 8)
; MSVC-NEXT: ret i8* [[CALL]]
; ;
%call = tail call noalias i8* @calloc(i64 16, i64 8) %call = tail call noalias i8* @calloc(i64 16, i64 8)
ret i8* %call ret i8* %call
} }
define noalias i8* @calloc_constant_size_overflow() { define noalias i8* @calloc_constant_size_overflow() {
; CHECK-LABEL: @calloc_constant_size_overflow( ; GNU64-LABEL: @calloc_constant_size_overflow(
; CHECK-NEXT: [[CALL:%.*]] = tail call noalias i8* @calloc(i64 2000000000000, i64 80000000000) ; GNU64-NEXT: [[CALL:%.*]] = tail call noalias align 16 i8* @calloc(i64 2000000000000, i64 80000000000)
; CHECK-NEXT: ret i8* [[CALL]] ; GNU64-NEXT: ret i8* [[CALL]]
;
; GNU32-LABEL: @calloc_constant_size_overflow(
; GNU32-NEXT: [[CALL:%.*]] = tail call noalias align 8 i8* @calloc(i64 2000000000000, i64 80000000000)
; GNU32-NEXT: ret i8* [[CALL]]
;
; MSVC-LABEL: @calloc_constant_size_overflow(
; MSVC-NEXT: [[CALL:%.*]] = tail call noalias align 16 i8* @calloc(i64 2000000000000, i64 80000000000)
; MSVC-NEXT: ret i8* [[CALL]]
; ;
%call = tail call noalias i8* @calloc(i64 2000000000000, i64 80000000000) %call = tail call noalias i8* @calloc(i64 2000000000000, i64 80000000000)
ret i8* %call ret i8* %call
} }
define noalias i8* @op_new_nonconstant_size(i64 %n) { define noalias i8* @op_new_nonconstant_size(i64 %n) {
; CHECK-LABEL: @op_new_nonconstant_size( ; CHECK-LABEL: @op_new_nonconstant_size(
; CHECK-NEXT: [[CALL:%.*]] = tail call i8* @_Znam(i64 [[N:%.*]]) ; CHECK-NEXT: [[CALL:%.*]] = tail call i8* @_Znam(i64 [[N:%.*]])
; CHECK-NEXT: ret i8* [[CALL]] ; CHECK-NEXT: ret i8* [[CALL]]
; ;
%call = tail call i8* @_Znam(i64 %n) %call = tail call i8* @_Znam(i64 %n)
ret i8* %call ret i8* %call
} }
define noalias i8* @op_new_constant_size() { define noalias i8* @op_new_constant_size() {
; CHECK-LABEL: @op_new_constant_size( ; GNU64-LABEL: @op_new_constant_size(
; CHECK-NEXT: [[CALL:%.*]] = tail call dereferenceable(40) i8* @_Znam(i64 40) ; GNU64-NEXT: [[CALL:%.*]] = tail call align 16 dereferenceable(40) i8* @_Znam(i64 40)
; CHECK-NEXT: ret i8* [[CALL]] ; GNU64-NEXT: ret i8* [[CALL]]
;
; GNU32-LABEL: @op_new_constant_size(
; GNU32-NEXT: [[CALL:%.*]] = tail call align 8 dereferenceable(40) i8* @_Znam(i64 40)
; GNU32-NEXT: ret i8* [[CALL]]
;
; MSVC-LABEL: @op_new_constant_size(
; MSVC-NEXT: [[CALL:%.*]] = tail call align 16 dereferenceable(40) i8* @_Znam(i64 40)
; MSVC-NEXT: ret i8* [[CALL]]
; ;
%call = tail call i8* @_Znam(i64 40) %call = tail call i8* @_Znam(i64 40)
ret i8* %call ret i8* %call
} }
define noalias i8* @op_new_constant_size2() { define noalias i8* @op_new_constant_size2() {
; CHECK-LABEL: @op_new_constant_size2( ; GNU64-LABEL: @op_new_constant_size2(
; CHECK-NEXT: [[CALL:%.*]] = tail call dereferenceable(40) i8* @_Znwm(i64 40) ; GNU64-NEXT: [[CALL:%.*]] = tail call align 16 dereferenceable(40) i8* @_Znwm(i64 40)
; CHECK-NEXT: ret i8* [[CALL]] ; GNU64-NEXT: ret i8* [[CALL]]
;
; GNU32-LABEL: @op_new_constant_size2(
; GNU32-NEXT: [[CALL:%.*]] = tail call align 8 dereferenceable(40) i8* @_Znwm(i64 40)
; GNU32-NEXT: ret i8* [[CALL]]
;
; MSVC-LABEL: @op_new_constant_size2(
; MSVC-NEXT: [[CALL:%.*]] = tail call align 16 dereferenceable(40) i8* @_Znwm(i64 40)
; MSVC-NEXT: ret i8* [[CALL]]
; ;
%call = tail call i8* @_Znwm(i64 40) %call = tail call i8* @_Znwm(i64 40)
ret i8* %call ret i8* %call
} }
define noalias i8* @op_new_constant_zero_size() { define noalias i8* @op_new_constant_zero_size() {
; CHECK-LABEL: @op_new_constant_zero_size( ; CHECK-LABEL: @op_new_constant_zero_size(
; CHECK-NEXT: [[CALL:%.*]] = tail call i8* @_Znam(i64 0) ; CHECK-NEXT: [[CALL:%.*]] = tail call i8* @_Znam(i64 0)
; CHECK-NEXT: ret i8* [[CALL]] ; CHECK-NEXT: ret i8* [[CALL]]
; ;
%call = tail call i8* @_Znam(i64 0) %call = tail call i8* @_Znam(i64 0)
ret i8* %call ret i8* %call
} }
define noalias i8* @strdup_constant_str() { define noalias i8* @strdup_constant_str() {
; CHECK-LABEL: @strdup_constant_str( ; GNU64-LABEL: @strdup_constant_str(
; CHECK-NEXT: [[CALL:%.*]] = tail call noalias dereferenceable_or_null(6) i8* @strdup(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str, i64 0, i64 0)) ; GNU64-NEXT: [[CALL:%.*]] = tail call noalias align 16 dereferenceable_or_null(6) i8* @strdup(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str, i64 0, i64 0))
; CHECK-NEXT: ret i8* [[CALL]] ; GNU64-NEXT: ret i8* [[CALL]]
;
; GNU32-LABEL: @strdup_constant_str(
; GNU32-NEXT: [[CALL:%.*]] = tail call noalias align 8 dereferenceable_or_null(6) i8* @strdup(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str, i64 0, i64 0))
; GNU32-NEXT: ret i8* [[CALL]]
;
; MSVC-LABEL: @strdup_constant_str(
; MSVC-NEXT: [[CALL:%.*]] = tail call noalias align 16 dereferenceable_or_null(6) i8* @strdup(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str, i64 0, i64 0))
; MSVC-NEXT: ret i8* [[CALL]]
; ;
%call = tail call noalias i8* @strdup(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str, i64 0, i64 0)) %call = tail call noalias i8* @strdup(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str, i64 0, i64 0))
ret i8* %call ret i8* %call
} }
define noalias i8* @strdup_notconstant_str(i8 * %str) { define noalias i8* @strdup_notconstant_str(i8 * %str) {
; CHECK-LABEL: @strdup_notconstant_str( ; GNU64-LABEL: @strdup_notconstant_str(
; CHECK-NEXT: [[CALL:%.*]] = tail call noalias i8* @strdup(i8* [[STR:%.*]]) ; GNU64-NEXT: [[CALL:%.*]] = tail call noalias align 16 i8* @strdup(i8* [[STR:%.*]])
; CHECK-NEXT: ret i8* [[CALL]] ; GNU64-NEXT: ret i8* [[CALL]]
;
; GNU32-LABEL: @strdup_notconstant_str(
; GNU32-NEXT: [[CALL:%.*]] = tail call noalias align 8 i8* @strdup(i8* [[STR:%.*]])
; GNU32-NEXT: ret i8* [[CALL]]
;
; MSVC-LABEL: @strdup_notconstant_str(
; MSVC-NEXT: [[CALL:%.*]] = tail call noalias align 16 i8* @strdup(i8* [[STR:%.*]])
; MSVC-NEXT: ret i8* [[CALL]]
; ;
%call = tail call noalias i8* @strdup(i8* %str) %call = tail call noalias i8* @strdup(i8* %str)
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( ; GNU64-LABEL: @ossfuzz_23214(
; CHECK-NEXT: bb: ; GNU64-NEXT: bb:
; CHECK-NEXT: [[CALL:%.*]] = tail call noalias dereferenceable_or_null(512) i8* @aligned_alloc(i64 -9223372036854775808, i64 512) ; GNU64-NEXT: [[CALL:%.*]] = tail call noalias align 16 dereferenceable_or_null(512) i8* @aligned_alloc(i64 -9223372036854775808, i64 512)
; CHECK-NEXT: ret i8* [[CALL]] ; GNU64-NEXT: ret i8* [[CALL]]
;
; GNU32-LABEL: @ossfuzz_23214(
; GNU32-NEXT: bb:
; GNU32-NEXT: [[CALL:%.*]] = tail call noalias align 8 dereferenceable_or_null(512) i8* @aligned_alloc(i64 -9223372036854775808, i64 512)
; GNU32-NEXT: ret i8* [[CALL]]
;
; MSVC-LABEL: @ossfuzz_23214(
; MSVC-NEXT: bb:
; MSVC-NEXT: [[CALL:%.*]] = tail call noalias align 16 dereferenceable_or_null(512) i8* @aligned_alloc(i64 -9223372036854775808, i64 512)
; MSVC-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 %and, i64 512)
ret i8* %call ret i8* %call
} }