This is an archive of the discontinued LLVM Phabricator instance.

Differential D76759

[AssumeBundles] Preserve Information from Load/Store
ClosedPublic

Authored by Tyker on Mar 25 2020, 2:28 AM.

Details

Reviewers
jdoerfert
Commits
rG7093b92a136b: [AssumeBundles] Preserve Information from Load/Store
Summary

This patch preserve dereferenceable, nonnull and alignment from loads and stores.

Diff Detail

Unit TestsFailed

TimeTest
660 msdebuginfo-tests.dexter-tests::Unknown Unit Message ("")
600 msdebuginfo-tests.llgdb-tests::Unknown Unit Message ("")
70 msdebuginfo-tests.llgdb-tests::Unknown Unit Message ("")
130 msdebuginfo-tests.llgdb-tests::Unknown Unit Message ("")
170 msdebuginfo-tests.llgdb-tests::Unknown Unit Message ("")
View Full Test Results (9 Failed)

Event Timeline

Tyker created this revision.Mar 25 2020, 2:28 AM
Herald added a project: Restricted Project. · View Herald TranscriptMar 25 2020, 2:28 AM
Herald added subscribers: llvm-commits, hiraditya. · View Herald Transcript
Harbormaster failed remote builds in B50371: Diff 252521!Mar 25 2020, 3:45 AM
Tyker added a parent revision: D76149: [AssumeBundles] Use assume bundles in isKnownNonZero.Mar 25 2020, 3:53 AM
Tyker added a child revision: D76769: [AssumeBundles] Preserve information in EarlyCSE.Mar 25 2020, 6:16 AM
jdoerfert added a comment.Mar 25 2020, 8:18 AM

I love the progress :) Some comments below.

llvm/include/llvm/IR/KnowledgeRetention.h
35 ↗(On Diff #252521)

Feel free to commit this as NFC right away.

llvm/lib/IR/KnowledgeRetention.cpp
234

Let's make this a member function like addCall. We should also merge this with existing logic and put it as a helper somewhere. Given an instruction, and potentially a set of attributes as filter, determine all attributes we can derive from the instruction. I might look into this as the attributor should use that as well to cut down on duplication.

238

I'd switch on the opcodes, use if-else-if, or early returns.

Tyker updated this revision to Diff 252666.Mar 25 2020, 2:00 PM
Tyker marked 3 inline comments as done.

fixed comments.

llvm/lib/IR/KnowledgeRetention.cpp
234

I agree we should try to prevent duplication but we will need to be careful not to be too restrictive about the representation the caller can use such that it can be used widely.

an issue which is hopefully going to get resolved soon. i think this API should reside in Analysis and there are some issues with dependencies for KnowledgeRetention see D76149#inline-701084 for details.

Harbormaster failed remote builds in B50434: Diff 252666!Mar 25 2020, 2:38 PM
jdoerfert added a comment.Mar 25 2020, 10:26 PM

I only have coding style comments left. Providing the logic in a more general way will be future work.

llvm/lib/IR/KnowledgeRetention.cpp
189

Nit:
We can have non pointer attributes (later).
-Ptr
+V or Val
(Then we'll also need to rename setPointer)

200

The above two lines is T, isn't it?

213

Style: TBH, I'm not necessarily a fan of the overloading via lambda idea. Couldn't we pass all necessary information to addLoadOrStore. I mean, we make it addAccessedPtr(Instruction &Inst, Value &Ptr, Type &AccTy, MaybeAlign Alignment)
and pass the appropriate values.

Tyker updated this revision to Diff 253340.EditedMar 28 2020, 6:37 AM
Tyker marked 4 inline comments as done.

addressed comments

llvm/lib/IR/KnowledgeRetention.cpp
189

setPointer is just the function from PointerIntPair, Pointer isn't associated with the llvm type of the Value* but the actual C++ type.

200

they aren't the same, MemInst->getPointerOperand()->getType() is usually a pointer on the type of T.

Harbormaster failed remote builds in B50806: Diff 253340!Mar 28 2020, 8:04 AM
jdoerfert added a comment.Mar 30 2020, 7:59 AM

One last question

llvm/lib/IR/KnowledgeRetention.cpp
202

I wonder if we have to guard the nonnull stuff with DerefSize != 0. This is only needed if we have "no-op" 0-length accesses, I think. I doubt those exist. Wdyt?

Tyker marked an inline comment as done.Mar 31 2020, 7:40 AM
Tyker added inline comments.
llvm/lib/IR/KnowledgeRetention.cpp
202

i have not seen an example where DerefSize is 0 but since we obtain a minimum size it wouldn't surprise me if it did exist.
if you think it is fine without the check i can remove it.

jdoerfert accepted this revision.Mar 31 2020, 7:58 AM

LGTM

llvm/lib/IR/KnowledgeRetention.cpp
202

Your right, it seems unlikely. Let's keep it like this.

This revision is now accepted and ready to land.Mar 31 2020, 7:58 AM
Closed by commit rG7093b92a136b: [AssumeBundles] Preserve Information from Load/Store (authored by Tyker). · Explain WhyMar 31 2020, 8:53 AM
This revision was automatically updated to reflect the committed changes.
Tyker removed a parent revision: D76149: [AssumeBundles] Use assume bundles in isKnownNonZero.Mar 31 2020, 1:56 PM

Revision Contents

PathSize
llvm/
lib/
IR/
45 lines
test/
IR/
258 lines

Diff 252666

llvm/lib/IR/KnowledgeRetention.cpp

//===- KnowledgeRetention.h - utilities to preserve informations *- C++ -*-===// //===- KnowledgeRetention.h - utilities to preserve informations *- C++ -*-===//
// //
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information. // See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
// //
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
#include "llvm/IR/KnowledgeRetention.h" #include "llvm/IR/KnowledgeRetention.h"
#include "llvm/ADT/DenseSet.h" #include "llvm/ADT/DenseSet.h"
#include "llvm/IR/Function.h"
#include "llvm/IR/InstIterator.h" #include "llvm/IR/InstIterator.h"
#include "llvm/IR/IntrinsicInst.h" #include "llvm/IR/IntrinsicInst.h"
#include "llvm/IR/Module.h" #include "llvm/IR/Module.h"
#include "llvm/Support/CommandLine.h" #include "llvm/Support/CommandLine.h"
using namespace llvm; using namespace llvm;
cl::opt<bool> ShouldPreserveAllAttributes( cl::opt<bool> ShouldPreserveAllAttributes(
▲ Show 20 Lines • Show All 149 Lines • ▼ Show 20 Lines for (const AssumedKnowledge &Elem : AssumedKnowledgeSet) {
Args.push_back(Elem.Argument); Args.push_back(Elem.Argument);
OpBundle.push_back(OperandBundleDefT<Value *>(Elem.Name, Args)); OpBundle.push_back(OperandBundleDefT<Value *>(Elem.Name, Args));
} }
llvm::sort(OpBundle, isLowerOpBundle); llvm::sort(OpBundle, isLowerOpBundle);
return cast<IntrinsicInst>(CallInst::Create( return cast<IntrinsicInst>(CallInst::Create(
FnAssume, ArrayRef<Value *>({ConstantInt::getTrue(C)}), OpBundle)); FnAssume, ArrayRef<Value *>({ConstantInt::getTrue(C)}), OpBundle));
} }
void addInstruction(const Instruction *I) { void addAttr(Attribute::AttrKind Kind, Value *Ptr, unsigned Argument = 0) {
AssumedKnowledge AK;
AK.Name = Attribute::getNameFromAttrKind(Kind).data();
AK.WasOn.setPointer(Ptr);
if (Attribute::doesAttrKindHaveArgument(Kind)) {
AK.Argument =
ConstantInt::get(Type::getInt64Ty(M->getContext()), Argument);
} else {
AK.Argument = nullptr;
assert(Argument == 0 && "there should be no argument");
}
AssumedKnowledgeSet.insert(AK);
};
jdoerfertUnsubmitted
Done
ReplyInline Actions

Nit:
We can have non pointer attributes (later).
-Ptr
+V or Val
(Then we'll also need to rename setPointer)

jdoerfert: Nit: We can have non pointer attributes (later). -`Ptr` +`V` or `Val` (Then we'll also need to…
TykerAuthorUnsubmitted
Done
ReplyInline Actions

setPointer is just the function from PointerIntPair, Pointer isn't associated with the llvm type of the Value* but the actual C++ type.

Tyker: setPointer is just the function from PointerIntPair, Pointer isn't associated with the llvm…
void addLoadOrStore(Instruction *I) {
auto Impl = [&](auto *MemInst, Type *T) {
uint64_t DerefSize =
I->getModule()->getDataLayout().getTypeStoreSize(T).getKnownMinSize();
if (DerefSize != 0) {
addAttr(Attribute::Dereferenceable, MemInst->getPointerOperand(),
DerefSize);
if (!NullPointerIsDefined(MemInst->getFunction(),
MemInst->getPointerOperand()
->getType()
jdoerfertUnsubmitted
Done
ReplyInline Actions

The above two lines is T, isn't it?

jdoerfert: The above two lines is `T`, isn't it?
TykerAuthorUnsubmitted
Done
ReplyInline Actions

they aren't the same, MemInst->getPointerOperand()->getType() is usually a pointer on the type of T.

Tyker: they aren't the same, MemInst->getPointerOperand()->getType() is usually a pointer on the type…
->getPointerAddressSpace()))
addAttr(Attribute::NonNull, MemInst->getPointerOperand());
jdoerfertUnsubmitted
Not Done
ReplyInline Actions

I wonder if we have to guard the nonnull stuff with DerefSize != 0. This is only needed if we have "no-op" 0-length accesses, I think. I doubt those exist. Wdyt?

jdoerfert: I wonder if we have to guard the `nonnull` stuff with `DerefSize != 0`. This is only needed if…
TykerAuthorUnsubmitted
Done
ReplyInline Actions

i have not seen an example where DerefSize is 0 but since we obtain a minimum size it wouldn't surprise me if it did exist.
if you think it is fine without the check i can remove it.

Tyker: i have not seen an example where DerefSize is 0 but since we obtain a minimum size it wouldn't…
jdoerfertUnsubmitted
Not Done
ReplyInline Actions

Your right, it seems unlikely. Let's keep it like this.

jdoerfert: Your right, it seems unlikely. Let's keep it like this.
}
MaybeAlign MA = MemInst->getAlign();
if (MA.valueOrOne() > 1)
addAttr(Attribute::Alignment, MemInst->getPointerOperand(),
MA.valueOrOne().value());
};
if (auto *Load = dyn_cast<LoadInst>(I))
Impl(Load, Load->getType());
if (auto *Store = dyn_cast<StoreInst>(I))
Impl(Store, Store->getValueOperand()->getType());
}
jdoerfertUnsubmitted
Not Done
ReplyInline Actions

Style: TBH, I'm not necessarily a fan of the overloading via lambda idea. Couldn't we pass all necessary information to addLoadOrStore. I mean, we make it addAccessedPtr(Instruction &Inst, Value &Ptr, Type &AccTy, MaybeAlign Alignment)
and pass the appropriate values.

jdoerfert: Style: TBH, I'm not necessarily a fan of the overloading via lambda idea. Couldn't we pass all…
void addInstruction(Instruction *I) {
if (auto *Call = dyn_cast<CallBase>(I)) if (auto *Call = dyn_cast<CallBase>(I))
addCall(Call); return addCall(Call);
if (isa<LoadInst>(I) || isa<StoreInst>(I))
return addLoadOrStore(I);
// TODO: Add support for the other Instructions. // TODO: Add support for the other Instructions.
// TODO: Maybe we should look around and merge with other llvm.assume. // TODO: Maybe we should look around and merge with other llvm.assume.
} }
}; };
} // namespace } // namespace
IntrinsicInst *llvm::buildAssumeFromInst(Instruction *I) { IntrinsicInst *llvm::buildAssumeFromInst(Instruction *I) {
if (!EnableKnowledgeRetention) if (!EnableKnowledgeRetention)
return nullptr; return nullptr;
AssumeBuilderState Builder(I->getModule()); AssumeBuilderState Builder(I->getModule());
Builder.addInstruction(I); Builder.addInstruction(I);
return Builder.build(); return Builder.build();
} }
jdoerfertUnsubmitted
Not Done
ReplyInline Actions

Let's make this a member function like addCall. We should also merge this with existing logic and put it as a helper somewhere. Given an instruction, and potentially a set of attributes as filter, determine all attributes we can derive from the instruction. I might look into this as the attributor should use that as well to cut down on duplication.

jdoerfert: Let's make this a member function like `addCall`. We should also merge this with existing logic…
TykerAuthorUnsubmitted
Done
ReplyInline Actions

I agree we should try to prevent duplication but we will need to be careful not to be too restrictive about the representation the caller can use such that it can be used widely.

an issue which is hopefully going to get resolved soon. i think this API should reside in Analysis and there are some issues with dependencies for KnowledgeRetention see D76149#inline-701084 for details.

Tyker: I agree we should try to prevent duplication but we will need to be careful not to be too…
static bool bundleHasArgument(const CallBase::BundleOpInfo &BOI, static bool bundleHasArgument(const CallBase::BundleOpInfo &BOI,
unsigned Idx) { unsigned Idx) {
return BOI.End - BOI.Begin > Idx; return BOI.End - BOI.Begin > Idx;
} }
jdoerfertUnsubmitted
Done
ReplyInline Actions

I'd switch on the opcodes, use if-else-if, or early returns.

jdoerfert: I'd switch on the opcodes, use `if-else-if`, or early returns.
static Value *getValueFromBundleOpInfo(IntrinsicInst &Assume, static Value *getValueFromBundleOpInfo(IntrinsicInst &Assume,
const CallBase::BundleOpInfo &BOI, const CallBase::BundleOpInfo &BOI,
unsigned Idx) { unsigned Idx) {
assert(bundleHasArgument(BOI, Idx) && "index out of range"); assert(bundleHasArgument(BOI, Idx) && "index out of range");
return (Assume.op_begin() + BOI.Begin + Idx)->get(); return (Assume.op_begin() + BOI.Begin + Idx)->get();
} }
▲ Show 20 Lines • Show All 128 Lines • Show Last 20 Lines

llvm/test/IR/assume-builder.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 -passes='assume-builder,verify' --enable-knowledge-retention -S %s | FileCheck %s --check-prefixes=BASIC ; RUN: opt -passes='assume-builder,verify' --enable-knowledge-retention -S %s | FileCheck %s --check-prefixes=BASIC
; RUN: opt -passes='assume-builder,verify' --enable-knowledge-retention --assume-preserve-all -S %s | FileCheck %s --check-prefixes=ALL ; RUN: opt -passes='assume-builder,verify' --enable-knowledge-retention --assume-preserve-all -S %s | FileCheck %s --check-prefixes=ALL
target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
declare void @func(i32*, i32*) declare void @func(i32*, i32*)
declare void @func_cold(i32*) cold declare void @func_cold(i32*) cold
declare void @func_strbool(i32*) "no-jump-tables" declare void @func_strbool(i32*) "no-jump-tables"
declare void @func_many(i32*) "no-jump-tables" nounwind "less-precise-fpmad" willreturn norecurse declare void @func_many(i32*) "no-jump-tables" nounwind "less-precise-fpmad" willreturn norecurse
declare void @func_argattr(i32* align 8, i32* nonnull) nounwind declare void @func_argattr(i32* align 8, i32* nonnull) nounwind
define void @test(i32* %P, i32* %P1, i32* %P2, i32* %P3) { define void @test(i32* %P, i32* %P1, i32* %P2, i32* %P3) {
; BASIC-LABEL: @test( ; BASIC-LABEL: @test(
▲ Show 20 Lines • Show All 46 Lines • ▼ Show 20 Lines;
call void @func(i32* %P1, i32* %P) call void @func(i32* %P1, i32* %P)
call void @func_strbool(i32* %P1) call void @func_strbool(i32* %P1)
call void @func(i32* dereferenceable(16) %P, i32* dereferenceable(8) %P) call void @func(i32* dereferenceable(16) %P, i32* dereferenceable(8) %P)
call void @func_many(i32* align 8 %P1) call void @func_many(i32* align 8 %P1)
call void @func_argattr(i32* %P2, i32* %P3) call void @func_argattr(i32* %P2, i32* %P3)
call void @func(i32* nonnull %P1, i32* nonnull %P) call void @func(i32* nonnull %P1, i32* nonnull %P)
ret void ret void
} }
%struct.S = type { i32, i8, i32* }
define i32 @test2(%struct.S* %0, i32* %1, i8* %2) {
; BASIC-LABEL: @test2(
; BASIC-NEXT: [[TMP4:%.*]] = alloca %struct.S*, align 8
; BASIC-NEXT: [[TMP5:%.*]] = alloca i32*, align 8
; BASIC-NEXT: [[TMP6:%.*]] = alloca i8*, align 8
; BASIC-NEXT: [[TMP7:%.*]] = alloca [[STRUCT_S:%.*]], align 8
; BASIC-NEXT: call void @llvm.assume(i1 true) [ "align"(%struct.S** [[TMP4]], i64 8), "dereferenceable"(%struct.S** [[TMP4]], i64 8), "nonnull"(%struct.S** [[TMP4]]) ]
; BASIC-NEXT: store %struct.S* [[TMP0:%.*]], %struct.S** [[TMP4]], align 8
; BASIC-NEXT: call void @llvm.assume(i1 true) [ "align"(i32** [[TMP5]], i64 8), "dereferenceable"(i32** [[TMP5]], i64 8), "nonnull"(i32** [[TMP5]]) ]
; BASIC-NEXT: store i32* [[TMP1:%.*]], i32** [[TMP5]], align 8
; BASIC-NEXT: call void @llvm.assume(i1 true) [ "dereferenceable"(i8** [[TMP6]], i64 8), "nonnull"(i8** [[TMP6]]) ]
; BASIC-NEXT: store i8* [[TMP2:%.*]], i8** [[TMP6]]
; BASIC-NEXT: call void @llvm.assume(i1 true) [ "align"(i32** [[TMP5]], i64 8), "dereferenceable"(i32** [[TMP5]], i64 8), "nonnull"(i32** [[TMP5]]) ]
; BASIC-NEXT: [[TMP8:%.*]] = load i32*, i32** [[TMP5]], align 8
; BASIC-NEXT: call void @llvm.assume(i1 true) [ "align"(i32* [[TMP8]], i64 4), "dereferenceable"(i32* [[TMP8]], i64 4), "nonnull"(i32* [[TMP8]]) ]
; BASIC-NEXT: [[TMP9:%.*]] = load i32, i32* [[TMP8]], align 4
; BASIC-NEXT: [[TMP10:%.*]] = trunc i32 [[TMP9]] to i8
; BASIC-NEXT: call void @llvm.assume(i1 true) [ "align"(i8** [[TMP6]], i64 8), "dereferenceable"(i8** [[TMP6]], i64 8), "nonnull"(i8** [[TMP6]]) ]
; BASIC-NEXT: [[TMP11:%.*]] = load i8*, i8** [[TMP6]], align 8
; BASIC-NEXT: call void @llvm.assume(i1 true) [ "dereferenceable"(i8* [[TMP11]], i64 1), "nonnull"(i8* [[TMP11]]) ]
; BASIC-NEXT: store i8 [[TMP10]], i8* [[TMP11]], align 1
; BASIC-NEXT: [[TMP12:%.*]] = bitcast %struct.S* [[TMP7]] to i8*
; BASIC-NEXT: call void @llvm.assume(i1 true) [ "dereferenceable"(%struct.S** [[TMP4]], i64 8), "nonnull"(%struct.S** [[TMP4]]) ]
; BASIC-NEXT: [[TMP13:%.*]] = load %struct.S*, %struct.S** [[TMP4]]
; BASIC-NEXT: [[TMP14:%.*]] = bitcast %struct.S* [[TMP13]] to i8*
; BASIC-NEXT: [[TMP15:%.*]] = bitcast %struct.S* [[TMP7]] to i8*
; BASIC-NEXT: call void @llvm.assume(i1 true) [ "align"(%struct.S** [[TMP4]], i64 8), "dereferenceable"(%struct.S** [[TMP4]], i64 8), "nonnull"(%struct.S** [[TMP4]]) ]
; BASIC-NEXT: [[TMP16:%.*]] = load %struct.S*, %struct.S** [[TMP4]], align 8
; BASIC-NEXT: [[TMP17:%.*]] = getelementptr inbounds [[STRUCT_S]], %struct.S* [[TMP16]], i32 0, i32 0
; BASIC-NEXT: call void @llvm.assume(i1 true) [ "align"(i32* [[TMP17]], i64 8), "dereferenceable"(i32* [[TMP17]], i64 4), "nonnull"(i32* [[TMP17]]) ]
; BASIC-NEXT: [[TMP18:%.*]] = load i32, i32* [[TMP17]], align 8
; BASIC-NEXT: call void @llvm.assume(i1 true) [ "align"(%struct.S** [[TMP4]], i64 8), "dereferenceable"(%struct.S** [[TMP4]], i64 8), "nonnull"(%struct.S** [[TMP4]]) ]
; BASIC-NEXT: [[TMP19:%.*]] = load %struct.S*, %struct.S** [[TMP4]], align 8
; BASIC-NEXT: [[TMP20:%.*]] = getelementptr inbounds [[STRUCT_S]], %struct.S* [[TMP19]], i32 0, i32 1
; BASIC-NEXT: call void @llvm.assume(i1 true) [ "align"(i8* [[TMP20]], i64 4), "dereferenceable"(i8* [[TMP20]], i64 1), "nonnull"(i8* [[TMP20]]) ]
; BASIC-NEXT: [[TMP21:%.*]] = load i8, i8* [[TMP20]], align 4
; BASIC-NEXT: [[TMP22:%.*]] = sext i8 [[TMP21]] to i32
; BASIC-NEXT: [[TMP23:%.*]] = add nsw i32 [[TMP18]], [[TMP22]]
; BASIC-NEXT: call void @llvm.assume(i1 true) [ "align"(%struct.S** [[TMP4]], i64 8), "dereferenceable"(%struct.S** [[TMP4]], i64 8), "nonnull"(%struct.S** [[TMP4]]) ]
; BASIC-NEXT: [[TMP24:%.*]] = load %struct.S*, %struct.S** [[TMP4]], align 8
; BASIC-NEXT: [[TMP25:%.*]] = getelementptr inbounds [[STRUCT_S]], %struct.S* [[TMP24]], i32 0, i32 2
; BASIC-NEXT: call void @llvm.assume(i1 true) [ "align"(i32** [[TMP25]], i64 8), "dereferenceable"(i32** [[TMP25]], i64 8), "nonnull"(i32** [[TMP25]]) ]
; BASIC-NEXT: [[TMP26:%.*]] = load i32*, i32** [[TMP25]], align 8
; BASIC-NEXT: call void @llvm.assume(i1 true) [ "align"(i32* [[TMP26]], i64 4), "dereferenceable"(i32* [[TMP26]], i64 4), "nonnull"(i32* [[TMP26]]) ]
; BASIC-NEXT: [[TMP27:%.*]] = load i32, i32* [[TMP26]], align 4
; BASIC-NEXT: [[TMP28:%.*]] = add nsw i32 [[TMP23]], [[TMP27]]
; BASIC-NEXT: ret i32 [[TMP28]]
;
; ALL-LABEL: @test2(
; ALL-NEXT: [[TMP4:%.*]] = alloca %struct.S*, align 8
; ALL-NEXT: [[TMP5:%.*]] = alloca i32*, align 8
; ALL-NEXT: [[TMP6:%.*]] = alloca i8*, align 8
; ALL-NEXT: [[TMP7:%.*]] = alloca [[STRUCT_S:%.*]], align 8
; ALL-NEXT: call void @llvm.assume(i1 true) [ "align"(%struct.S** [[TMP4]], i64 8), "dereferenceable"(%struct.S** [[TMP4]], i64 8), "nonnull"(%struct.S** [[TMP4]]) ]
; ALL-NEXT: store %struct.S* [[TMP0:%.*]], %struct.S** [[TMP4]], align 8
; ALL-NEXT: call void @llvm.assume(i1 true) [ "align"(i32** [[TMP5]], i64 8), "dereferenceable"(i32** [[TMP5]], i64 8), "nonnull"(i32** [[TMP5]]) ]
; ALL-NEXT: store i32* [[TMP1:%.*]], i32** [[TMP5]], align 8
; ALL-NEXT: call void @llvm.assume(i1 true) [ "dereferenceable"(i8** [[TMP6]], i64 8), "nonnull"(i8** [[TMP6]]) ]
; ALL-NEXT: store i8* [[TMP2:%.*]], i8** [[TMP6]]
; ALL-NEXT: call void @llvm.assume(i1 true) [ "align"(i32** [[TMP5]], i64 8), "dereferenceable"(i32** [[TMP5]], i64 8), "nonnull"(i32** [[TMP5]]) ]
; ALL-NEXT: [[TMP8:%.*]] = load i32*, i32** [[TMP5]], align 8
; ALL-NEXT: call void @llvm.assume(i1 true) [ "align"(i32* [[TMP8]], i64 4), "dereferenceable"(i32* [[TMP8]], i64 4), "nonnull"(i32* [[TMP8]]) ]
; ALL-NEXT: [[TMP9:%.*]] = load i32, i32* [[TMP8]], align 4
; ALL-NEXT: [[TMP10:%.*]] = trunc i32 [[TMP9]] to i8
; ALL-NEXT: call void @llvm.assume(i1 true) [ "align"(i8** [[TMP6]], i64 8), "dereferenceable"(i8** [[TMP6]], i64 8), "nonnull"(i8** [[TMP6]]) ]
; ALL-NEXT: [[TMP11:%.*]] = load i8*, i8** [[TMP6]], align 8
; ALL-NEXT: call void @llvm.assume(i1 true) [ "dereferenceable"(i8* [[TMP11]], i64 1), "nonnull"(i8* [[TMP11]]) ]
; ALL-NEXT: store i8 [[TMP10]], i8* [[TMP11]], align 1
; ALL-NEXT: [[TMP12:%.*]] = bitcast %struct.S* [[TMP7]] to i8*
; ALL-NEXT: call void @llvm.assume(i1 true) [ "dereferenceable"(%struct.S** [[TMP4]], i64 8), "nonnull"(%struct.S** [[TMP4]]) ]
; ALL-NEXT: [[TMP13:%.*]] = load %struct.S*, %struct.S** [[TMP4]]
; ALL-NEXT: [[TMP14:%.*]] = bitcast %struct.S* [[TMP13]] to i8*
; ALL-NEXT: [[TMP15:%.*]] = bitcast %struct.S* [[TMP7]] to i8*
; ALL-NEXT: call void @llvm.assume(i1 true) [ "align"(%struct.S** [[TMP4]], i64 8), "dereferenceable"(%struct.S** [[TMP4]], i64 8), "nonnull"(%struct.S** [[TMP4]]) ]
; ALL-NEXT: [[TMP16:%.*]] = load %struct.S*, %struct.S** [[TMP4]], align 8
; ALL-NEXT: [[TMP17:%.*]] = getelementptr inbounds [[STRUCT_S]], %struct.S* [[TMP16]], i32 0, i32 0
; ALL-NEXT: call void @llvm.assume(i1 true) [ "align"(i32* [[TMP17]], i64 8), "dereferenceable"(i32* [[TMP17]], i64 4), "nonnull"(i32* [[TMP17]]) ]
; ALL-NEXT: [[TMP18:%.*]] = load i32, i32* [[TMP17]], align 8
; ALL-NEXT: call void @llvm.assume(i1 true) [ "align"(%struct.S** [[TMP4]], i64 8), "dereferenceable"(%struct.S** [[TMP4]], i64 8), "nonnull"(%struct.S** [[TMP4]]) ]
; ALL-NEXT: [[TMP19:%.*]] = load %struct.S*, %struct.S** [[TMP4]], align 8
; ALL-NEXT: [[TMP20:%.*]] = getelementptr inbounds [[STRUCT_S]], %struct.S* [[TMP19]], i32 0, i32 1
; ALL-NEXT: call void @llvm.assume(i1 true) [ "align"(i8* [[TMP20]], i64 4), "dereferenceable"(i8* [[TMP20]], i64 1), "nonnull"(i8* [[TMP20]]) ]
; ALL-NEXT: [[TMP21:%.*]] = load i8, i8* [[TMP20]], align 4
; ALL-NEXT: [[TMP22:%.*]] = sext i8 [[TMP21]] to i32
; ALL-NEXT: [[TMP23:%.*]] = add nsw i32 [[TMP18]], [[TMP22]]
; ALL-NEXT: call void @llvm.assume(i1 true) [ "align"(%struct.S** [[TMP4]], i64 8), "dereferenceable"(%struct.S** [[TMP4]], i64 8), "nonnull"(%struct.S** [[TMP4]]) ]
; ALL-NEXT: [[TMP24:%.*]] = load %struct.S*, %struct.S** [[TMP4]], align 8
; ALL-NEXT: [[TMP25:%.*]] = getelementptr inbounds [[STRUCT_S]], %struct.S* [[TMP24]], i32 0, i32 2
; ALL-NEXT: call void @llvm.assume(i1 true) [ "align"(i32** [[TMP25]], i64 8), "dereferenceable"(i32** [[TMP25]], i64 8), "nonnull"(i32** [[TMP25]]) ]
; ALL-NEXT: [[TMP26:%.*]] = load i32*, i32** [[TMP25]], align 8
; ALL-NEXT: call void @llvm.assume(i1 true) [ "align"(i32* [[TMP26]], i64 4), "dereferenceable"(i32* [[TMP26]], i64 4), "nonnull"(i32* [[TMP26]]) ]
; ALL-NEXT: [[TMP27:%.*]] = load i32, i32* [[TMP26]], align 4
; ALL-NEXT: [[TMP28:%.*]] = add nsw i32 [[TMP23]], [[TMP27]]
; ALL-NEXT: ret i32 [[TMP28]]
;
%4 = alloca %struct.S*, align 8
%5 = alloca i32*, align 8
%6 = alloca i8*, align 8
%7 = alloca %struct.S, align 8
store %struct.S* %0, %struct.S** %4, align 8
store i32* %1, i32** %5, align 8
store i8* %2, i8** %6
%8 = load i32*, i32** %5, align 8
%9 = load i32, i32* %8, align 4
%10 = trunc i32 %9 to i8
%11 = load i8*, i8** %6, align 8
store i8 %10, i8* %11, align 1
%12 = bitcast %struct.S* %7 to i8*
%13 = load %struct.S*, %struct.S** %4
%14 = bitcast %struct.S* %13 to i8*
%15 = bitcast %struct.S* %7 to i8*
%16 = load %struct.S*, %struct.S** %4, align 8
%17 = getelementptr inbounds %struct.S, %struct.S* %16, i32 0, i32 0
%18 = load i32, i32* %17, align 8
%19 = load %struct.S*, %struct.S** %4, align 8
%20 = getelementptr inbounds %struct.S, %struct.S* %19, i32 0, i32 1
%21 = load i8, i8* %20, align 4
%22 = sext i8 %21 to i32
%23 = add nsw i32 %18, %22
%24 = load %struct.S*, %struct.S** %4, align 8
%25 = getelementptr inbounds %struct.S, %struct.S* %24, i32 0, i32 2
%26 = load i32*, i32** %25, align 8
%27 = load i32, i32* %26, align 4
%28 = add nsw i32 %23, %27
ret i32 %28
}
define i32 @test3(%struct.S* %0, i32* %1, i8* %2) "null-pointer-is-valid"="true" {
; BASIC-LABEL: @test3(
; BASIC-NEXT: [[TMP4:%.*]] = alloca %struct.S*, align 8
; BASIC-NEXT: [[TMP5:%.*]] = alloca i32*, align 8
; BASIC-NEXT: [[TMP6:%.*]] = alloca i8*, align 8
; BASIC-NEXT: [[TMP7:%.*]] = alloca [[STRUCT_S:%.*]], align 8
; BASIC-NEXT: call void @llvm.assume(i1 true) [ "align"(%struct.S** [[TMP4]], i64 8), "dereferenceable"(%struct.S** [[TMP4]], i64 8) ]
; BASIC-NEXT: store %struct.S* [[TMP0:%.*]], %struct.S** [[TMP4]], align 8
; BASIC-NEXT: call void @llvm.assume(i1 true) [ "align"(i32** [[TMP5]], i64 8), "dereferenceable"(i32** [[TMP5]], i64 8) ]
; BASIC-NEXT: store i32* [[TMP1:%.*]], i32** [[TMP5]], align 8
; BASIC-NEXT: call void @llvm.assume(i1 true) [ "align"(i8** [[TMP6]], i64 8), "dereferenceable"(i8** [[TMP6]], i64 8) ]
; BASIC-NEXT: store i8* [[TMP2:%.*]], i8** [[TMP6]], align 8
; BASIC-NEXT: call void @llvm.assume(i1 true) [ "align"(i32** [[TMP5]], i64 8), "dereferenceable"(i32** [[TMP5]], i64 8) ]
; BASIC-NEXT: [[TMP8:%.*]] = load i32*, i32** [[TMP5]], align 8
; BASIC-NEXT: call void @llvm.assume(i1 true) [ "align"(i32* [[TMP8]], i64 4), "dereferenceable"(i32* [[TMP8]], i64 4) ]
; BASIC-NEXT: [[TMP9:%.*]] = load i32, i32* [[TMP8]], align 4
; BASIC-NEXT: [[TMP10:%.*]] = trunc i32 [[TMP9]] to i8
; BASIC-NEXT: call void @llvm.assume(i1 true) [ "dereferenceable"(i8** [[TMP6]], i64 8) ]
; BASIC-NEXT: [[TMP11:%.*]] = load i8*, i8** [[TMP6]]
; BASIC-NEXT: call void @llvm.assume(i1 true) [ "dereferenceable"(i8* [[TMP11]], i64 1) ]
; BASIC-NEXT: store i8 [[TMP10]], i8* [[TMP11]], align 1
; BASIC-NEXT: [[TMP12:%.*]] = bitcast %struct.S* [[TMP7]] to i8*
; BASIC-NEXT: call void @llvm.assume(i1 true) [ "align"(%struct.S** [[TMP4]], i64 8), "dereferenceable"(%struct.S** [[TMP4]], i64 8) ]
; BASIC-NEXT: [[TMP13:%.*]] = load %struct.S*, %struct.S** [[TMP4]], align 8
; BASIC-NEXT: [[TMP14:%.*]] = bitcast %struct.S* [[TMP13]] to i8*
; BASIC-NEXT: [[TMP15:%.*]] = bitcast %struct.S* [[TMP7]] to i8*
; BASIC-NEXT: call void @llvm.assume(i1 true) [ "align"(%struct.S** [[TMP4]], i64 8), "dereferenceable"(%struct.S** [[TMP4]], i64 8) ]
; BASIC-NEXT: [[TMP16:%.*]] = load %struct.S*, %struct.S** [[TMP4]], align 8
; BASIC-NEXT: [[TMP17:%.*]] = getelementptr inbounds [[STRUCT_S]], %struct.S* [[TMP16]], i32 0, i32 0
; BASIC-NEXT: call void @llvm.assume(i1 true) [ "align"(i32* [[TMP17]], i64 8), "dereferenceable"(i32* [[TMP17]], i64 4) ]
; BASIC-NEXT: [[TMP18:%.*]] = load i32, i32* [[TMP17]], align 8
; BASIC-NEXT: call void @llvm.assume(i1 true) [ "align"(%struct.S** [[TMP4]], i64 8), "dereferenceable"(%struct.S** [[TMP4]], i64 8) ]
; BASIC-NEXT: [[TMP19:%.*]] = load %struct.S*, %struct.S** [[TMP4]], align 8
; BASIC-NEXT: [[TMP20:%.*]] = getelementptr inbounds [[STRUCT_S]], %struct.S* [[TMP19]], i32 0, i32 1
; BASIC-NEXT: call void @llvm.assume(i1 true) [ "align"(i8* [[TMP20]], i64 4), "dereferenceable"(i8* [[TMP20]], i64 1) ]
; BASIC-NEXT: [[TMP21:%.*]] = load i8, i8* [[TMP20]], align 4
; BASIC-NEXT: [[TMP22:%.*]] = sext i8 [[TMP21]] to i32
; BASIC-NEXT: [[TMP23:%.*]] = add nsw i32 [[TMP18]], [[TMP22]]
; BASIC-NEXT: call void @llvm.assume(i1 true) [ "align"(%struct.S** [[TMP4]], i64 8), "dereferenceable"(%struct.S** [[TMP4]], i64 8) ]
; BASIC-NEXT: [[TMP24:%.*]] = load %struct.S*, %struct.S** [[TMP4]], align 8
; BASIC-NEXT: [[TMP25:%.*]] = getelementptr inbounds [[STRUCT_S]], %struct.S* [[TMP24]], i32 0, i32 2
; BASIC-NEXT: call void @llvm.assume(i1 true) [ "dereferenceable"(i32** [[TMP25]], i64 8) ]
; BASIC-NEXT: [[TMP26:%.*]] = load i32*, i32** [[TMP25]]
; BASIC-NEXT: call void @llvm.assume(i1 true) [ "align"(i32* [[TMP26]], i64 4), "dereferenceable"(i32* [[TMP26]], i64 4) ]
; BASIC-NEXT: [[TMP27:%.*]] = load i32, i32* [[TMP26]], align 4
; BASIC-NEXT: [[TMP28:%.*]] = add nsw i32 [[TMP23]], [[TMP27]]
; BASIC-NEXT: ret i32 [[TMP28]]
;
; ALL-LABEL: @test3(
; ALL-NEXT: [[TMP4:%.*]] = alloca %struct.S*, align 8
; ALL-NEXT: [[TMP5:%.*]] = alloca i32*, align 8
; ALL-NEXT: [[TMP6:%.*]] = alloca i8*, align 8
; ALL-NEXT: [[TMP7:%.*]] = alloca [[STRUCT_S:%.*]], align 8
; ALL-NEXT: call void @llvm.assume(i1 true) [ "align"(%struct.S** [[TMP4]], i64 8), "dereferenceable"(%struct.S** [[TMP4]], i64 8) ]
; ALL-NEXT: store %struct.S* [[TMP0:%.*]], %struct.S** [[TMP4]], align 8
; ALL-NEXT: call void @llvm.assume(i1 true) [ "align"(i32** [[TMP5]], i64 8), "dereferenceable"(i32** [[TMP5]], i64 8) ]
; ALL-NEXT: store i32* [[TMP1:%.*]], i32** [[TMP5]], align 8
; ALL-NEXT: call void @llvm.assume(i1 true) [ "align"(i8** [[TMP6]], i64 8), "dereferenceable"(i8** [[TMP6]], i64 8) ]
; ALL-NEXT: store i8* [[TMP2:%.*]], i8** [[TMP6]], align 8
; ALL-NEXT: call void @llvm.assume(i1 true) [ "align"(i32** [[TMP5]], i64 8), "dereferenceable"(i32** [[TMP5]], i64 8) ]
; ALL-NEXT: [[TMP8:%.*]] = load i32*, i32** [[TMP5]], align 8
; ALL-NEXT: call void @llvm.assume(i1 true) [ "align"(i32* [[TMP8]], i64 4), "dereferenceable"(i32* [[TMP8]], i64 4) ]
; ALL-NEXT: [[TMP9:%.*]] = load i32, i32* [[TMP8]], align 4
; ALL-NEXT: [[TMP10:%.*]] = trunc i32 [[TMP9]] to i8
; ALL-NEXT: call void @llvm.assume(i1 true) [ "dereferenceable"(i8** [[TMP6]], i64 8) ]
; ALL-NEXT: [[TMP11:%.*]] = load i8*, i8** [[TMP6]]
; ALL-NEXT: call void @llvm.assume(i1 true) [ "dereferenceable"(i8* [[TMP11]], i64 1) ]
; ALL-NEXT: store i8 [[TMP10]], i8* [[TMP11]], align 1
; ALL-NEXT: [[TMP12:%.*]] = bitcast %struct.S* [[TMP7]] to i8*
; ALL-NEXT: call void @llvm.assume(i1 true) [ "align"(%struct.S** [[TMP4]], i64 8), "dereferenceable"(%struct.S** [[TMP4]], i64 8) ]
; ALL-NEXT: [[TMP13:%.*]] = load %struct.S*, %struct.S** [[TMP4]], align 8
; ALL-NEXT: [[TMP14:%.*]] = bitcast %struct.S* [[TMP13]] to i8*
; ALL-NEXT: [[TMP15:%.*]] = bitcast %struct.S* [[TMP7]] to i8*
; ALL-NEXT: call void @llvm.assume(i1 true) [ "align"(%struct.S** [[TMP4]], i64 8), "dereferenceable"(%struct.S** [[TMP4]], i64 8) ]
; ALL-NEXT: [[TMP16:%.*]] = load %struct.S*, %struct.S** [[TMP4]], align 8
; ALL-NEXT: [[TMP17:%.*]] = getelementptr inbounds [[STRUCT_S]], %struct.S* [[TMP16]], i32 0, i32 0
; ALL-NEXT: call void @llvm.assume(i1 true) [ "align"(i32* [[TMP17]], i64 8), "dereferenceable"(i32* [[TMP17]], i64 4) ]
; ALL-NEXT: [[TMP18:%.*]] = load i32, i32* [[TMP17]], align 8
; ALL-NEXT: call void @llvm.assume(i1 true) [ "align"(%struct.S** [[TMP4]], i64 8), "dereferenceable"(%struct.S** [[TMP4]], i64 8) ]
; ALL-NEXT: [[TMP19:%.*]] = load %struct.S*, %struct.S** [[TMP4]], align 8
; ALL-NEXT: [[TMP20:%.*]] = getelementptr inbounds [[STRUCT_S]], %struct.S* [[TMP19]], i32 0, i32 1
; ALL-NEXT: call void @llvm.assume(i1 true) [ "align"(i8* [[TMP20]], i64 4), "dereferenceable"(i8* [[TMP20]], i64 1) ]
; ALL-NEXT: [[TMP21:%.*]] = load i8, i8* [[TMP20]], align 4
; ALL-NEXT: [[TMP22:%.*]] = sext i8 [[TMP21]] to i32
; ALL-NEXT: [[TMP23:%.*]] = add nsw i32 [[TMP18]], [[TMP22]]
; ALL-NEXT: call void @llvm.assume(i1 true) [ "align"(%struct.S** [[TMP4]], i64 8), "dereferenceable"(%struct.S** [[TMP4]], i64 8) ]
; ALL-NEXT: [[TMP24:%.*]] = load %struct.S*, %struct.S** [[TMP4]], align 8
; ALL-NEXT: [[TMP25:%.*]] = getelementptr inbounds [[STRUCT_S]], %struct.S* [[TMP24]], i32 0, i32 2
; ALL-NEXT: call void @llvm.assume(i1 true) [ "dereferenceable"(i32** [[TMP25]], i64 8) ]
; ALL-NEXT: [[TMP26:%.*]] = load i32*, i32** [[TMP25]]
; ALL-NEXT: call void @llvm.assume(i1 true) [ "align"(i32* [[TMP26]], i64 4), "dereferenceable"(i32* [[TMP26]], i64 4) ]
; ALL-NEXT: [[TMP27:%.*]] = load i32, i32* [[TMP26]], align 4
; ALL-NEXT: [[TMP28:%.*]] = add nsw i32 [[TMP23]], [[TMP27]]
; ALL-NEXT: ret i32 [[TMP28]]
;
%4 = alloca %struct.S*, align 8
%5 = alloca i32*, align 8
%6 = alloca i8*, align 8
%7 = alloca %struct.S, align 8
store %struct.S* %0, %struct.S** %4, align 8
store i32* %1, i32** %5, align 8
store i8* %2, i8** %6, align 8
%8 = load i32*, i32** %5, align 8
%9 = load i32, i32* %8, align 4
%10 = trunc i32 %9 to i8
%11 = load i8*, i8** %6
store i8 %10, i8* %11, align 1
%12 = bitcast %struct.S* %7 to i8*
%13 = load %struct.S*, %struct.S** %4, align 8
%14 = bitcast %struct.S* %13 to i8*
%15 = bitcast %struct.S* %7 to i8*
%16 = load %struct.S*, %struct.S** %4, align 8
%17 = getelementptr inbounds %struct.S, %struct.S* %16, i32 0, i32 0
%18 = load i32, i32* %17, align 8
%19 = load %struct.S*, %struct.S** %4, align 8
%20 = getelementptr inbounds %struct.S, %struct.S* %19, i32 0, i32 1
%21 = load i8, i8* %20, align 4
%22 = sext i8 %21 to i32
%23 = add nsw i32 %18, %22
%24 = load %struct.S*, %struct.S** %4, align 8
%25 = getelementptr inbounds %struct.S, %struct.S* %24, i32 0, i32 2
%26 = load i32*, i32** %25
%27 = load i32, i32* %26, align 4
%28 = add nsw i32 %23, %27
ret i32 %28
}