Skip to content
This commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.

Commit 0f152a5

Browse files
dc03dc03
committedSep 20, 2023
[InferAlignment] Implement InferAlignmentPass
This pass aims to infer alignment for instructions as a separate pass, to reduce redundant work done by InstCombine running multiple times. It runs late in the pipeline, just before the back-end passes where this information is most useful. Differential Revision: https://reviews.llvm.org/D158529
1 parent 3978f37 commit 0f152a5

File tree

20 files changed

+250
-117
lines changed

20 files changed

+250
-117
lines changed
 

‎llvm/include/llvm/Transforms/Scalar/InferAlignment.h

Lines changed: 27 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,27 @@
1+
//===- InferAlignment.h -----------------------------------------*- C++ -*-===//
2+
//
3+
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4+
// See https://llvm.org/LICENSE.txt for license information.
5+
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6+
//
7+
//===----------------------------------------------------------------------===//
8+
//
9+
// Infer alignment for load, stores and other memory operations based on
10+
// trailing zero known bits information.
11+
//
12+
//===----------------------------------------------------------------------===//
13+
14+
#ifndef LLVM_TRANSFORMS_SCALAR_INFERALIGNMENT_H
15+
#define LLVM_TRANSFORMS_SCALAR_INFERALIGNMENT_H
16+
17+
#include "llvm/IR/PassManager.h"
18+
19+
namespace llvm {
20+
21+
struct InferAlignmentPass : public PassInfoMixin<InferAlignmentPass> {
22+
PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
23+
};
24+
25+
} // namespace llvm
26+
27+
#endif // LLVM_TRANSFORMS_SCALAR_INFERALIGNMENT_H

‎llvm/include/llvm/Transforms/Utils/Local.h

Lines changed: 9 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -213,6 +213,15 @@ AllocaInst *DemoteRegToStack(Instruction &X,
213213
/// deleted and it returns the pointer to the alloca inserted.
214214
AllocaInst *DemotePHIToStack(PHINode *P, Instruction *AllocaPoint = nullptr);
215215

216+
/// If the specified pointer points to an object that we control, try to modify
217+
/// the object's alignment to PrefAlign. Returns a minimum known alignment of
218+
/// the value after the operation, which may be lower than PrefAlign.
219+
///
220+
/// Increating value alignment isn't often possible though. If alignment is
221+
/// important, a more reliable approach is to simply align all global variables
222+
/// and allocation instructions to their preferred alignment from the beginning.
223+
Align tryEnforceAlignment(Value *V, Align PrefAlign, const DataLayout &DL);
224+
216225
/// Try to ensure that the alignment of \p V is at least \p PrefAlign bytes. If
217226
/// the owning object can be modified and has an alignment less than \p
218227
/// PrefAlign, it will be increased and \p PrefAlign returned. If the alignment

‎llvm/lib/Passes/PassBuilder.cpp

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -171,6 +171,7 @@
171171
#include "llvm/Transforms/Scalar/IndVarSimplify.h"
172172
#include "llvm/Transforms/Scalar/InductiveRangeCheckElimination.h"
173173
#include "llvm/Transforms/Scalar/InferAddressSpaces.h"
174+
#include "llvm/Transforms/Scalar/InferAlignment.h"
174175
#include "llvm/Transforms/Scalar/InstSimplifyPass.h"
175176
#include "llvm/Transforms/Scalar/JumpThreading.h"
176177
#include "llvm/Transforms/Scalar/LICM.h"

‎llvm/lib/Passes/PassBuilderPipelines.cpp

Lines changed: 10 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -88,6 +88,7 @@
8888
#include "llvm/Transforms/Scalar/Float2Int.h"
8989
#include "llvm/Transforms/Scalar/GVN.h"
9090
#include "llvm/Transforms/Scalar/IndVarSimplify.h"
91+
#include "llvm/Transforms/Scalar/InferAlignment.h"
9192
#include "llvm/Transforms/Scalar/InstSimplifyPass.h"
9293
#include "llvm/Transforms/Scalar/JumpThreading.h"
9394
#include "llvm/Transforms/Scalar/LICM.h"
@@ -274,6 +275,11 @@ cl::opt<bool> EnableMemProfContextDisambiguation(
274275
"enable-memprof-context-disambiguation", cl::init(false), cl::Hidden,
275276
cl::ZeroOrMore, cl::desc("Enable MemProf context disambiguation"));
276277

278+
cl::opt<bool> EnableInferAlignmentPass(
279+
"enable-infer-alignment-pass", cl::init(false), cl::Hidden, cl::ZeroOrMore,
280+
cl::desc("Enable the InferAlignment pass, disabling alignment inference in "
281+
"InstCombine"));
282+
277283
PipelineTuningOptions::PipelineTuningOptions() {
278284
LoopInterleaving = true;
279285
LoopVectorization = true;
@@ -1140,6 +1146,8 @@ void PassBuilder::addVectorPasses(OptimizationLevel Level,
11401146
FPM.addPass(LoopVectorizePass(
11411147
LoopVectorizeOptions(!PTO.LoopInterleaving, !PTO.LoopVectorization)));
11421148

1149+
if (EnableInferAlignmentPass)
1150+
FPM.addPass(InferAlignmentPass());
11431151
if (IsFullLTO) {
11441152
// The vectorizer may have significantly shortened a loop body; unroll
11451153
// again. Unroll small loops to hide loop backedge latency and saturate any
@@ -1257,6 +1265,8 @@ void PassBuilder::addVectorPasses(OptimizationLevel Level,
12571265
FPM.addPass(SROAPass(SROAOptions::PreserveCFG));
12581266
}
12591267

1268+
if (EnableInferAlignmentPass)
1269+
FPM.addPass(InferAlignmentPass());
12601270
FPM.addPass(InstCombinePass());
12611271

12621272
// This is needed for two reasons:

‎llvm/lib/Passes/PassRegistry.def

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -337,6 +337,7 @@ FUNCTION_PASS("gvn-hoist", GVNHoistPass())
337337
FUNCTION_PASS("gvn-sink", GVNSinkPass())
338338
FUNCTION_PASS("helloworld", HelloWorldPass())
339339
FUNCTION_PASS("infer-address-spaces", InferAddressSpacesPass())
340+
FUNCTION_PASS("infer-alignment", InferAlignmentPass())
340341
FUNCTION_PASS("instcount", InstCountPass())
341342
FUNCTION_PASS("instsimplify", InstSimplifyPass())
342343
FUNCTION_PASS("invalidate<all>", InvalidateAllAnalysesPass())

‎llvm/lib/Transforms/Scalar/CMakeLists.txt

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -22,6 +22,7 @@ add_llvm_component_library(LLVMScalarOpts
2222
InductiveRangeCheckElimination.cpp
2323
IndVarSimplify.cpp
2424
InferAddressSpaces.cpp
25+
InferAlignment.cpp
2526
InstSimplifyPass.cpp
2627
JumpThreading.cpp
2728
LICM.cpp

‎llvm/lib/Transforms/Scalar/InferAlignment.cpp

Lines changed: 91 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,91 @@
1+
//===- InferAlignment.cpp -------------------------------------------------===//
2+
//
3+
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4+
// See https://llvm.org/LICENSE.txt for license information.
5+
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6+
//
7+
//===----------------------------------------------------------------------===//
8+
//
9+
// Infer alignment for load, stores and other memory operations based on
10+
// trailing zero known bits information.
11+
//
12+
//===----------------------------------------------------------------------===//
13+
14+
#include "llvm/Transforms/Scalar/InferAlignment.h"
15+
#include "llvm/Analysis/AssumptionCache.h"
16+
#include "llvm/Analysis/ValueTracking.h"
17+
#include "llvm/IR/Instructions.h"
18+
#include "llvm/InitializePasses.h"
19+
#include "llvm/Support/KnownBits.h"
20+
#include "llvm/Transforms/Scalar.h"
21+
#include "llvm/Transforms/Utils/Local.h"
22+
23+
using namespace llvm;
24+
25+
static bool tryToImproveAlign(
26+
const DataLayout &DL, Instruction *I,
27+
function_ref<Align(Value *PtrOp, Align OldAlign, Align PrefAlign)> Fn) {
28+
if (auto *LI = dyn_cast<LoadInst>(I)) {
29+
Value *PtrOp = LI->getPointerOperand();
30+
Align OldAlign = LI->getAlign();
31+
Align NewAlign = Fn(PtrOp, OldAlign, DL.getPrefTypeAlign(LI->getType()));
32+
if (NewAlign > OldAlign) {
33+
LI->setAlignment(NewAlign);
34+
return true;
35+
}
36+
} else if (auto *SI = dyn_cast<StoreInst>(I)) {
37+
Value *PtrOp = SI->getPointerOperand();
38+
Value *ValOp = SI->getValueOperand();
39+
Align OldAlign = SI->getAlign();
40+
Align NewAlign = Fn(PtrOp, OldAlign, DL.getPrefTypeAlign(ValOp->getType()));
41+
if (NewAlign > OldAlign) {
42+
SI->setAlignment(NewAlign);
43+
return true;
44+
}
45+
}
46+
// TODO: Also handle memory intrinsics.
47+
return false;
48+
}
49+
50+
bool inferAlignment(Function &F, AssumptionCache &AC, DominatorTree &DT) {
51+
const DataLayout &DL = F.getParent()->getDataLayout();
52+
bool Changed = false;
53+
54+
// Enforce preferred type alignment if possible. We do this as a separate
55+
// pass first, because it may improve the alignments we infer below.
56+
for (BasicBlock &BB : F) {
57+
for (Instruction &I : BB) {
58+
Changed |= tryToImproveAlign(
59+
DL, &I, [&](Value *PtrOp, Align OldAlign, Align PrefAlign) {
60+
if (PrefAlign > OldAlign)
61+
return std::max(OldAlign,
62+
tryEnforceAlignment(PtrOp, PrefAlign, DL));
63+
return OldAlign;
64+
});
65+
}
66+
}
67+
68+
// Compute alignment from known bits.
69+
for (BasicBlock &BB : F) {
70+
for (Instruction &I : BB) {
71+
Changed |= tryToImproveAlign(
72+
DL, &I, [&](Value *PtrOp, Align OldAlign, Align PrefAlign) {
73+
KnownBits Known = computeKnownBits(PtrOp, DL, 0, &AC, &I, &DT);
74+
unsigned TrailZ = std::min(Known.countMinTrailingZeros(),
75+
+Value::MaxAlignmentExponent);
76+
return Align(1ull << std::min(Known.getBitWidth() - 1, TrailZ));
77+
});
78+
}
79+
}
80+
81+
return Changed;
82+
}
83+
84+
PreservedAnalyses InferAlignmentPass::run(Function &F,
85+
FunctionAnalysisManager &AM) {
86+
AssumptionCache &AC = AM.getResult<AssumptionAnalysis>(F);
87+
DominatorTree &DT = AM.getResult<DominatorTreeAnalysis>(F);
88+
inferAlignment(F, AC, DT);
89+
// Changes to alignment shouldn't invalidated analyses.
90+
return PreservedAnalyses::all();
91+
}

‎llvm/lib/Transforms/Utils/Local.cpp

Lines changed: 2 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -1388,15 +1388,8 @@ bool llvm::EliminateDuplicatePHINodes(BasicBlock *BB) {
13881388
return Changed;
13891389
}
13901390

1391-
/// If the specified pointer points to an object that we control, try to modify
1392-
/// the object's alignment to PrefAlign. Returns a minimum known alignment of
1393-
/// the value after the operation, which may be lower than PrefAlign.
1394-
///
1395-
/// Increating value alignment isn't often possible though. If alignment is
1396-
/// important, a more reliable approach is to simply align all global variables
1397-
/// and allocation instructions to their preferred alignment from the beginning.
1398-
static Align tryEnforceAlignment(Value *V, Align PrefAlign,
1399-
const DataLayout &DL) {
1391+
Align llvm::tryEnforceAlignment(Value *V, Align PrefAlign,
1392+
const DataLayout &DL) {
14001393
V = V->stripPointerCasts();
14011394

14021395
if (AllocaInst *AI = dyn_cast<AllocaInst>(V)) {

‎llvm/test/Transforms/InferAlignment/alloca.ll

Lines changed: 10 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,5 @@
11
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 2
2-
; RUN: opt < %s -passes=no-op-function -S | FileCheck %s
2+
; RUN: opt < %s -passes=infer-alignment -S | FileCheck %s
33

44
; ------------------------------------------------------------------------------
55
; Scalar type
@@ -8,11 +8,11 @@
88
define void @alloca_local(i8 %x, i32 %y) {
99
; CHECK-LABEL: define void @alloca_local
1010
; CHECK-SAME: (i8 [[X:%.*]], i32 [[Y:%.*]]) {
11-
; CHECK-NEXT: [[ALLOCA:%.*]] = alloca i32, align 1
12-
; CHECK-NEXT: [[LOAD_I8:%.*]] = load i8, ptr [[ALLOCA]], align 1
13-
; CHECK-NEXT: [[LOAD_I32:%.*]] = load i32, ptr [[ALLOCA]], align 1
14-
; CHECK-NEXT: store i8 [[X]], ptr [[ALLOCA]], align 1
15-
; CHECK-NEXT: store i32 [[Y]], ptr [[ALLOCA]], align 1
11+
; CHECK-NEXT: [[ALLOCA:%.*]] = alloca i32, align 4
12+
; CHECK-NEXT: [[LOAD_I8:%.*]] = load i8, ptr [[ALLOCA]], align 4
13+
; CHECK-NEXT: [[LOAD_I32:%.*]] = load i32, ptr [[ALLOCA]], align 4
14+
; CHECK-NEXT: store i8 [[X]], ptr [[ALLOCA]], align 4
15+
; CHECK-NEXT: store i32 [[Y]], ptr [[ALLOCA]], align 4
1616
; CHECK-NEXT: ret void
1717
;
1818
%alloca = alloca i32, align 1
@@ -38,10 +38,10 @@ define void @alloca_struct(i32 %x) {
3838
; CHECK-NEXT: [[ALLOCA_STRUCT:%.*]] = alloca [[STRUCT_PAIR:%.*]], align 8
3939
; CHECK-NEXT: [[GEP_0:%.*]] = getelementptr [[STRUCT_PAIR]], ptr [[ALLOCA_STRUCT]], i64 0, i32 1
4040
; CHECK-NEXT: [[GEP_1:%.*]] = getelementptr { i32, i32 }, ptr [[GEP_0]], i64 0, i32 1
41-
; CHECK-NEXT: [[LOAD_2:%.*]] = load i32, ptr [[GEP_0]], align 1
42-
; CHECK-NEXT: store i32 0, ptr [[GEP_0]], align 1
43-
; CHECK-NEXT: [[LOAD_1:%.*]] = load i32, ptr [[GEP_1]], align 1
44-
; CHECK-NEXT: store i32 0, ptr [[GEP_1]], align 1
41+
; CHECK-NEXT: [[LOAD_2:%.*]] = load i32, ptr [[GEP_0]], align 8
42+
; CHECK-NEXT: store i32 0, ptr [[GEP_0]], align 8
43+
; CHECK-NEXT: [[LOAD_1:%.*]] = load i32, ptr [[GEP_1]], align 4
44+
; CHECK-NEXT: store i32 0, ptr [[GEP_1]], align 4
4545
; CHECK-NEXT: ret void
4646
;
4747
%alloca.struct = alloca %struct.pair

‎llvm/test/Transforms/InferAlignment/atomic.ll

Lines changed: 19 additions & 19 deletions
Original file line numberDiff line numberDiff line change
@@ -1,15 +1,15 @@
11
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 2
2-
; RUN: opt -S < %s -passes=no-op-function | FileCheck %s
2+
; RUN: opt -S < %s -passes=infer-alignment | FileCheck %s
33

44
; ------------------------------------------------------------------------------
55
; load/store of null
66
; ------------------------------------------------------------------------------
77

88
define void @load_null() {
99
; CHECK-LABEL: define void @load_null() {
10-
; CHECK-NEXT: [[X_0:%.*]] = load atomic i32, ptr null unordered, align 4
11-
; CHECK-NEXT: [[X_1:%.*]] = load atomic i32, ptr null monotonic, align 4
12-
; CHECK-NEXT: [[X_2:%.*]] = load atomic i32, ptr null seq_cst, align 4
10+
; CHECK-NEXT: [[X_0:%.*]] = load atomic i32, ptr null unordered, align 4294967296
11+
; CHECK-NEXT: [[X_1:%.*]] = load atomic i32, ptr null monotonic, align 4294967296
12+
; CHECK-NEXT: [[X_2:%.*]] = load atomic i32, ptr null seq_cst, align 4294967296
1313
; CHECK-NEXT: ret void
1414
;
1515
%x.0 = load atomic i32, ptr null unordered, align 4
@@ -20,9 +20,9 @@ define void @load_null() {
2020

2121
define void @store_null() {
2222
; CHECK-LABEL: define void @store_null() {
23-
; CHECK-NEXT: store atomic i32 0, ptr null unordered, align 4
24-
; CHECK-NEXT: store atomic i32 0, ptr null monotonic, align 4
25-
; CHECK-NEXT: store atomic i32 0, ptr null seq_cst, align 4
23+
; CHECK-NEXT: store atomic i32 0, ptr null unordered, align 4294967296
24+
; CHECK-NEXT: store atomic i32 0, ptr null monotonic, align 4294967296
25+
; CHECK-NEXT: store atomic i32 0, ptr null seq_cst, align 4294967296
2626
; CHECK-NEXT: ret void
2727
;
2828
store atomic i32 0, ptr null unordered, align 4
@@ -38,9 +38,9 @@ define void @store_null() {
3838

3939
define void @load_nonnull() {
4040
; CHECK-LABEL: define void @load_nonnull() {
41-
; CHECK-NEXT: [[X_0:%.*]] = load atomic i32, ptr @c unordered, align 4
42-
; CHECK-NEXT: [[X_1:%.*]] = load atomic i32, ptr @c monotonic, align 4
43-
; CHECK-NEXT: [[X_2:%.*]] = load atomic i32, ptr @c seq_cst, align 4
41+
; CHECK-NEXT: [[X_0:%.*]] = load atomic i32, ptr @c unordered, align 8
42+
; CHECK-NEXT: [[X_1:%.*]] = load atomic i32, ptr @c monotonic, align 8
43+
; CHECK-NEXT: [[X_2:%.*]] = load atomic i32, ptr @c seq_cst, align 8
4444
; CHECK-NEXT: ret void
4545
;
4646
%x.0 = load atomic i32, ptr @c unordered, align 4
@@ -51,9 +51,9 @@ define void @load_nonnull() {
5151

5252
define void @store_nonnull() {
5353
; CHECK-LABEL: define void @store_nonnull() {
54-
; CHECK-NEXT: store atomic i32 0, ptr @c unordered, align 4
55-
; CHECK-NEXT: store atomic i32 0, ptr @c monotonic, align 4
56-
; CHECK-NEXT: store atomic i32 0, ptr @c seq_cst, align 4
54+
; CHECK-NEXT: store atomic i32 0, ptr @c unordered, align 8
55+
; CHECK-NEXT: store atomic i32 0, ptr @c monotonic, align 8
56+
; CHECK-NEXT: store atomic i32 0, ptr @c seq_cst, align 8
5757
; CHECK-NEXT: ret void
5858
;
5959
store atomic i32 0, ptr @c unordered, align 4
@@ -69,9 +69,9 @@ define void @store_nonnull() {
6969
define void @load_alloca() {
7070
; CHECK-LABEL: define void @load_alloca() {
7171
; CHECK-NEXT: [[ALLOCA:%.*]] = alloca i32, align 4
72-
; CHECK-NEXT: [[X_0:%.*]] = load atomic i32, ptr [[ALLOCA]] unordered, align 1
73-
; CHECK-NEXT: [[X_1:%.*]] = load atomic i32, ptr [[ALLOCA]] monotonic, align 1
74-
; CHECK-NEXT: [[X_2:%.*]] = load atomic i32, ptr [[ALLOCA]] seq_cst, align 1
72+
; CHECK-NEXT: [[X_0:%.*]] = load atomic i32, ptr [[ALLOCA]] unordered, align 4
73+
; CHECK-NEXT: [[X_1:%.*]] = load atomic i32, ptr [[ALLOCA]] monotonic, align 4
74+
; CHECK-NEXT: [[X_2:%.*]] = load atomic i32, ptr [[ALLOCA]] seq_cst, align 4
7575
; CHECK-NEXT: ret void
7676
;
7777
%alloca = alloca i32
@@ -84,9 +84,9 @@ define void @load_alloca() {
8484
define void @store_alloca() {
8585
; CHECK-LABEL: define void @store_alloca() {
8686
; CHECK-NEXT: [[ALLOCA:%.*]] = alloca i32, align 4
87-
; CHECK-NEXT: store atomic i32 0, ptr [[ALLOCA]] unordered, align 1
88-
; CHECK-NEXT: store atomic i32 0, ptr [[ALLOCA]] monotonic, align 1
89-
; CHECK-NEXT: store atomic i32 0, ptr [[ALLOCA]] seq_cst, align 1
87+
; CHECK-NEXT: store atomic i32 0, ptr [[ALLOCA]] unordered, align 4
88+
; CHECK-NEXT: store atomic i32 0, ptr [[ALLOCA]] monotonic, align 4
89+
; CHECK-NEXT: store atomic i32 0, ptr [[ALLOCA]] seq_cst, align 4
9090
; CHECK-NEXT: ret void
9191
;
9292
%alloca = alloca i32

‎llvm/test/Transforms/InferAlignment/attributes.ll

Lines changed: 7 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -1,11 +1,11 @@
11
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 2
2-
; RUN: opt < %s -passes=no-op-function -S | FileCheck %s
2+
; RUN: opt < %s -passes=infer-alignment -S | FileCheck %s
33

44
define void @attribute(ptr align 32 %a) {
55
; CHECK-LABEL: define void @attribute
66
; CHECK-SAME: (ptr align 32 [[A:%.*]]) {
7-
; CHECK-NEXT: [[LOAD:%.*]] = load i32, ptr [[A]], align 1
8-
; CHECK-NEXT: store i32 123, ptr [[A]], align 1
7+
; CHECK-NEXT: [[LOAD:%.*]] = load i32, ptr [[A]], align 32
8+
; CHECK-NEXT: store i32 123, ptr [[A]], align 32
99
; CHECK-NEXT: ret void
1010
;
1111
%load = load i32, ptr %a, align 1
@@ -17,8 +17,8 @@ define void @attribute_through_call(ptr align 32 %a) {
1717
; CHECK-LABEL: define void @attribute_through_call
1818
; CHECK-SAME: (ptr align 32 [[A:%.*]]) {
1919
; CHECK-NEXT: [[RES:%.*]] = call ptr @call(ptr [[A]])
20-
; CHECK-NEXT: [[LOAD:%.*]] = load i32, ptr [[RES]], align 1
21-
; CHECK-NEXT: store i32 123, ptr [[RES]], align 1
20+
; CHECK-NEXT: [[LOAD:%.*]] = load i32, ptr [[RES]], align 32
21+
; CHECK-NEXT: store i32 123, ptr [[RES]], align 32
2222
; CHECK-NEXT: ret void
2323
;
2424
%res = call ptr @call(ptr %a)
@@ -31,8 +31,8 @@ define void @attribute_return_value(ptr %a) {
3131
; CHECK-LABEL: define void @attribute_return_value
3232
; CHECK-SAME: (ptr [[A:%.*]]) {
3333
; CHECK-NEXT: [[RES:%.*]] = call align 32 ptr @call(ptr [[A]])
34-
; CHECK-NEXT: [[LOAD:%.*]] = load i32, ptr [[RES]], align 1
35-
; CHECK-NEXT: store i32 123, ptr [[RES]], align 1
34+
; CHECK-NEXT: [[LOAD:%.*]] = load i32, ptr [[RES]], align 32
35+
; CHECK-NEXT: store i32 123, ptr [[RES]], align 32
3636
; CHECK-NEXT: ret void
3737
;
3838
%res = call align 32 ptr @call(ptr %a)

‎llvm/test/Transforms/InferAlignment/gep-2d.ll

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,5 @@
11
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 2
2-
; RUN: opt < %s -passes=no-op-function -S | FileCheck %s
2+
; RUN: opt < %s -passes=infer-alignment -S | FileCheck %s
33

44
; A multi-dimensional array in a nested loop.inner doing vector stores that
55
; aren't yet aligned. InferAlignment can understand the addressing in the
@@ -21,8 +21,8 @@ define void @nested_loop() {
2121
; CHECK: loop.inner:
2222
; CHECK-NEXT: [[J:%.*]] = phi i64 [ 0, [[LOOP_OUTER]] ], [ [[J_NEXT:%.*]], [[LOOP_INNER_TAIL:%.*]] ]
2323
; CHECK-NEXT: [[GEP_1:%.*]] = getelementptr [1001 x [20000 x double]], ptr @Nice, i64 0, i64 [[I]], i64 [[J]]
24-
; CHECK-NEXT: store <2 x double> zeroinitializer, ptr [[GEP_1]], align 8
25-
; CHECK-NEXT: [[LOAD_1:%.*]] = load <2 x double>, ptr [[GEP_1]], align 8
24+
; CHECK-NEXT: store <2 x double> zeroinitializer, ptr [[GEP_1]], align 16
25+
; CHECK-NEXT: [[LOAD_1:%.*]] = load <2 x double>, ptr [[GEP_1]], align 16
2626
; CHECK-NEXT: [[GEP_2:%.*]] = getelementptr [1001 x [20001 x double]], ptr @Awkward, i64 0, i64 [[I]], i64 [[J]]
2727
; CHECK-NEXT: store <2 x double> zeroinitializer, ptr [[GEP_2]], align 8
2828
; CHECK-NEXT: [[LOAD_2:%.*]] = load <2 x double>, ptr [[GEP_2]], align 8

‎llvm/test/Transforms/InferAlignment/gep-array.ll

Lines changed: 9 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,5 @@
11
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 2
2-
; RUN: opt -passes=no-op-function -S < %s | FileCheck %s
2+
; RUN: opt -passes=infer-alignment -S < %s | FileCheck %s
33

44
; ------------------------------------------------------------------------------
55
; Array of pair
@@ -18,8 +18,8 @@ define void @simple_pair(i64 %idx) {
1818
; CHECK-LABEL: define void @simple_pair
1919
; CHECK-SAME: (i64 [[IDX:%.*]]) {
2020
; CHECK-NEXT: [[GEP:%.*]] = getelementptr inbounds [4 x %pair.simple], ptr @array.simple, i64 0, i64 [[IDX]], i32 1
21-
; CHECK-NEXT: [[RES:%.*]] = load i32, ptr [[GEP]], align 1
22-
; CHECK-NEXT: store i32 0, ptr [[GEP]], align 1
21+
; CHECK-NEXT: [[RES:%.*]] = load i32, ptr [[GEP]], align 8
22+
; CHECK-NEXT: store i32 0, ptr [[GEP]], align 8
2323
; CHECK-NEXT: ret void
2424
;
2525
%gep = getelementptr inbounds [4 x %pair.simple], ptr @array.simple, i64 0, i64 %idx, i32 1
@@ -39,11 +39,11 @@ define void @simple_pair(i64 %idx) {
3939

4040
define void @load_nested() {
4141
; CHECK-LABEL: define void @load_nested() {
42-
; CHECK-NEXT: [[X_0:%.*]] = load i32, ptr @array.array, align 4
42+
; CHECK-NEXT: [[X_0:%.*]] = load i32, ptr @array.array, align 16
4343
; CHECK-NEXT: [[X_1:%.*]] = load i32, ptr getelementptr inbounds ([3 x %pair.array], ptr @array.array, i64 0, i64 0, i32 0, i64 1), align 4
44-
; CHECK-NEXT: [[X_2:%.*]] = load i32, ptr getelementptr inbounds ([3 x %pair.array], ptr @array.array, i64 0, i64 0, i32 0, i64 2), align 4
44+
; CHECK-NEXT: [[X_2:%.*]] = load i32, ptr getelementptr inbounds ([3 x %pair.array], ptr @array.array, i64 0, i64 0, i32 0, i64 2), align 8
4545
; CHECK-NEXT: [[X_3:%.*]] = load i32, ptr getelementptr ([3 x %pair.array], ptr @array.array, i64 0, i64 0, i32 0, i64 3), align 4
46-
; CHECK-NEXT: [[X_4:%.*]] = load i32, ptr getelementptr ([3 x %pair.array], ptr @array.array, i64 0, i64 0, i32 0, i64 4), align 4
46+
; CHECK-NEXT: [[X_4:%.*]] = load i32, ptr getelementptr ([3 x %pair.array], ptr @array.array, i64 0, i64 0, i32 0, i64 4), align 16
4747
; CHECK-NEXT: ret void
4848
;
4949
%x.0 = load i32, ptr @array.array, align 4
@@ -56,11 +56,11 @@ define void @load_nested() {
5656

5757
define void @store_nested() {
5858
; CHECK-LABEL: define void @store_nested() {
59-
; CHECK-NEXT: store i32 1, ptr @array.array, align 4
59+
; CHECK-NEXT: store i32 1, ptr @array.array, align 16
6060
; CHECK-NEXT: store i32 1, ptr getelementptr inbounds ([3 x %pair.array], ptr @array.array, i64 0, i64 0, i32 0, i64 1), align 4
61-
; CHECK-NEXT: store i32 1, ptr getelementptr inbounds ([3 x %pair.array], ptr @array.array, i64 0, i64 0, i32 0, i64 2), align 4
61+
; CHECK-NEXT: store i32 1, ptr getelementptr inbounds ([3 x %pair.array], ptr @array.array, i64 0, i64 0, i32 0, i64 2), align 8
6262
; CHECK-NEXT: store i32 1, ptr getelementptr ([3 x %pair.array], ptr @array.array, i64 0, i64 0, i32 0, i64 3), align 4
63-
; CHECK-NEXT: store i32 1, ptr getelementptr ([3 x %pair.array], ptr @array.array, i64 0, i64 0, i32 0, i64 4), align 4
63+
; CHECK-NEXT: store i32 1, ptr getelementptr ([3 x %pair.array], ptr @array.array, i64 0, i64 0, i32 0, i64 4), align 16
6464
; CHECK-NEXT: ret void
6565
;
6666
store i32 1, ptr @array.array, align 4

‎llvm/test/Transforms/InferAlignment/irregular-size.ll

Lines changed: 10 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -1,12 +1,12 @@
11
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 2
2-
; RUN: opt < %s -passes=no-op-function -S | FileCheck %s
2+
; RUN: opt < %s -passes=infer-alignment -S | FileCheck %s
33

44
define void @non_pow2_size(i177 %X) {
55
; CHECK-LABEL: define void @non_pow2_size
66
; CHECK-SAME: (i177 [[X:%.*]]) {
7-
; CHECK-NEXT: [[A:%.*]] = alloca i177, align 1
8-
; CHECK-NEXT: [[L1:%.*]] = load i177, ptr [[A]], align 1
9-
; CHECK-NEXT: store i177 [[X]], ptr [[A]], align 1
7+
; CHECK-NEXT: [[A:%.*]] = alloca i177, align 8
8+
; CHECK-NEXT: [[L1:%.*]] = load i177, ptr [[A]], align 8
9+
; CHECK-NEXT: store i177 [[X]], ptr [[A]], align 8
1010
; CHECK-NEXT: ret void
1111
;
1212
%A = alloca i177, align 1
@@ -27,13 +27,13 @@ define void @load_vector_i4(i4 %X) {
2727
; CHECK-NEXT: [[PTR_2:%.*]] = getelementptr [16 x <2 x i4>], ptr @vector_i4, i64 0, i64 4
2828
; CHECK-NEXT: [[PTR_3:%.*]] = getelementptr [16 x <2 x i4>], ptr @vector_i4, i64 0, i64 8
2929
; CHECK-NEXT: [[RES_0:%.*]] = load i4, ptr [[PTR_0]], align 1
30-
; CHECK-NEXT: [[RES_1:%.*]] = load i4, ptr [[PTR_1]], align 1
31-
; CHECK-NEXT: [[RES_2:%.*]] = load i4, ptr [[PTR_2]], align 1
32-
; CHECK-NEXT: [[RES_3:%.*]] = load i4, ptr [[PTR_3]], align 1
30+
; CHECK-NEXT: [[RES_1:%.*]] = load i4, ptr [[PTR_1]], align 2
31+
; CHECK-NEXT: [[RES_2:%.*]] = load i4, ptr [[PTR_2]], align 4
32+
; CHECK-NEXT: [[RES_3:%.*]] = load i4, ptr [[PTR_3]], align 8
3333
; CHECK-NEXT: store i4 [[X]], ptr [[PTR_0]], align 1
34-
; CHECK-NEXT: store i4 [[X]], ptr [[PTR_1]], align 1
35-
; CHECK-NEXT: store i4 [[X]], ptr [[PTR_2]], align 1
36-
; CHECK-NEXT: store i4 [[X]], ptr [[PTR_3]], align 1
34+
; CHECK-NEXT: store i4 [[X]], ptr [[PTR_1]], align 2
35+
; CHECK-NEXT: store i4 [[X]], ptr [[PTR_2]], align 4
36+
; CHECK-NEXT: store i4 [[X]], ptr [[PTR_3]], align 8
3737
; CHECK-NEXT: ret void
3838
;
3939
%ptr.0 = getelementptr [16 x <2 x i4>], ptr @vector_i4, i64 0, i64 1

‎llvm/test/Transforms/InferAlignment/propagate-assume.ll

Lines changed: 19 additions & 19 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,5 @@
11
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 2
2-
; RUN: opt < %s -passes=no-op-function -S | FileCheck %s
2+
; RUN: opt < %s -passes=infer-alignment -S | FileCheck %s
33

44
; ------------------------------------------------------------------------------
55
; Simple test
@@ -12,8 +12,8 @@ define void @simple_forwardpropagate(ptr %a) {
1212
; CHECK-NEXT: [[MASKEDPTR:%.*]] = and i64 [[PTRINT]], 31
1313
; CHECK-NEXT: [[MASKCOND:%.*]] = icmp eq i64 [[MASKEDPTR]], 0
1414
; CHECK-NEXT: tail call void @llvm.assume(i1 [[MASKCOND]])
15-
; CHECK-NEXT: [[LOAD_A:%.*]] = load i32, ptr [[A]], align 4
16-
; CHECK-NEXT: store i32 345, ptr [[A]], align 4
15+
; CHECK-NEXT: [[LOAD_A:%.*]] = load i32, ptr [[A]], align 32
16+
; CHECK-NEXT: store i32 345, ptr [[A]], align 32
1717
; CHECK-NEXT: ret void
1818
;
1919
%ptrint = ptrtoint ptr %a to i64
@@ -30,8 +30,8 @@ define void @simple_forwardpropagate(ptr %a) {
3030
define void @simple_backpropagate(ptr %a) {
3131
; CHECK-LABEL: define void @simple_backpropagate
3232
; CHECK-SAME: (ptr [[A:%.*]]) {
33-
; CHECK-NEXT: [[LOAD_A:%.*]] = load i32, ptr [[A]], align 4
34-
; CHECK-NEXT: store i32 345, ptr [[A]], align 4
33+
; CHECK-NEXT: [[LOAD_A:%.*]] = load i32, ptr [[A]], align 32
34+
; CHECK-NEXT: store i32 345, ptr [[A]], align 32
3535
; CHECK-NEXT: [[PTRINT:%.*]] = ptrtoint ptr [[A]] to i64
3636
; CHECK-NEXT: [[MASKEDPTR:%.*]] = and i64 [[PTRINT]], 31
3737
; CHECK-NEXT: [[MASKCOND:%.*]] = icmp eq i64 [[MASKEDPTR]], 0
@@ -53,8 +53,8 @@ define void @simple_forwardpropagate_bundle(ptr %a) {
5353
; CHECK-LABEL: define void @simple_forwardpropagate_bundle
5454
; CHECK-SAME: (ptr [[A:%.*]]) {
5555
; CHECK-NEXT: call void @llvm.assume(i1 true) [ "align"(ptr [[A]], i32 32) ]
56-
; CHECK-NEXT: [[LOAD_A:%.*]] = load i32, ptr [[A]], align 4
57-
; CHECK-NEXT: store i32 345, ptr [[A]], align 4
56+
; CHECK-NEXT: [[LOAD_A:%.*]] = load i32, ptr [[A]], align 32
57+
; CHECK-NEXT: store i32 345, ptr [[A]], align 32
5858
; CHECK-NEXT: ret void
5959
;
6060
call void @llvm.assume(i1 true) ["align"(ptr %a, i32 32)]
@@ -66,8 +66,8 @@ define void @simple_forwardpropagate_bundle(ptr %a) {
6666
define void @simple_backpropagate_bundle(ptr %a) {
6767
; CHECK-LABEL: define void @simple_backpropagate_bundle
6868
; CHECK-SAME: (ptr [[A:%.*]]) {
69-
; CHECK-NEXT: [[LOAD_A:%.*]] = load i32, ptr [[A]], align 4
70-
; CHECK-NEXT: store i32 345, ptr [[A]], align 4
69+
; CHECK-NEXT: [[LOAD_A:%.*]] = load i32, ptr [[A]], align 32
70+
; CHECK-NEXT: store i32 345, ptr [[A]], align 32
7171
; CHECK-NEXT: call void @llvm.assume(i1 true) [ "align"(ptr [[A]], i32 32) ]
7272
; CHECK-NEXT: ret void
7373
;
@@ -97,10 +97,10 @@ define void @loop_forwardpropagate(ptr %a, ptr %b) {
9797
; CHECK: for.body:
9898
; CHECK-NEXT: [[I:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[I_NEXT:%.*]], [[FOR_BODY]] ]
9999
; CHECK-NEXT: [[GEP_B:%.*]] = getelementptr inbounds i32, ptr [[B]], i64 [[I]]
100-
; CHECK-NEXT: [[LOAD_B:%.*]] = load i32, ptr [[GEP_B]], align 4
100+
; CHECK-NEXT: [[LOAD_B:%.*]] = load i32, ptr [[GEP_B]], align 64
101101
; CHECK-NEXT: [[ADD:%.*]] = add nsw i32 [[LOAD_B]], 1
102102
; CHECK-NEXT: [[GEP_A:%.*]] = getelementptr inbounds i32, ptr [[A]], i64 [[I]]
103-
; CHECK-NEXT: store i32 [[ADD]], ptr [[GEP_A]], align 4
103+
; CHECK-NEXT: store i32 [[ADD]], ptr [[GEP_A]], align 64
104104
; CHECK-NEXT: [[I_NEXT]] = add nuw nsw i64 [[I]], 16
105105
; CHECK-NEXT: [[CMP:%.*]] = icmp slt i64 [[I_NEXT]], 1648
106106
; CHECK-NEXT: br i1 [[CMP]], label [[FOR_BODY]], label [[FOR_END:%.*]]
@@ -149,10 +149,10 @@ define void @loop_forwardpropagate_bundle(ptr %a, ptr %b) {
149149
; CHECK: for.body:
150150
; CHECK-NEXT: [[I:%.*]] = phi i64 [ 0, [[ENTRY:%.*]] ], [ [[I_NEXT:%.*]], [[FOR_BODY]] ]
151151
; CHECK-NEXT: [[GEP_B:%.*]] = getelementptr inbounds i32, ptr [[B]], i64 [[I]]
152-
; CHECK-NEXT: [[LOAD_B:%.*]] = load i32, ptr [[GEP_B]], align 4
152+
; CHECK-NEXT: [[LOAD_B:%.*]] = load i32, ptr [[GEP_B]], align 64
153153
; CHECK-NEXT: [[ADD:%.*]] = add nsw i32 [[LOAD_B]], 1
154154
; CHECK-NEXT: [[GEP_A:%.*]] = getelementptr inbounds i32, ptr [[A]], i64 [[I]]
155-
; CHECK-NEXT: store i32 [[ADD]], ptr [[GEP_A]], align 4
155+
; CHECK-NEXT: store i32 [[ADD]], ptr [[GEP_A]], align 64
156156
; CHECK-NEXT: [[I_NEXT]] = add nuw nsw i64 [[I]], 16
157157
; CHECK-NEXT: [[CMP:%.*]] = icmp slt i64 [[I_NEXT]], 1648
158158
; CHECK-NEXT: br i1 [[CMP]], label [[FOR_BODY]], label [[FOR_END:%.*]]
@@ -190,11 +190,11 @@ define void @complex_backpropagate(ptr %a, ptr %b, ptr %c) {
190190
; CHECK-LABEL: define void @complex_backpropagate
191191
; CHECK-SAME: (ptr [[A:%.*]], ptr [[B:%.*]], ptr [[C:%.*]]) {
192192
; CHECK-NEXT: [[ALLOCA:%.*]] = alloca i64, align 8
193-
; CHECK-NEXT: [[LOAD_A:%.*]] = load i32, ptr [[A]], align 4
193+
; CHECK-NEXT: [[LOAD_A:%.*]] = load i32, ptr [[A]], align 32
194194
; CHECK-NEXT: [[LOAD_B:%.*]] = load i32, ptr [[B]], align 4
195-
; CHECK-NEXT: store i32 [[LOAD_B]], ptr [[A]], align 4
195+
; CHECK-NEXT: store i32 [[LOAD_B]], ptr [[A]], align 32
196196
; CHECK-NEXT: [[OBJ_SIZE:%.*]] = call i64 @llvm.objectsize.i64.p0(ptr [[C]], i1 false, i1 false, i1 false)
197-
; CHECK-NEXT: store i64 [[OBJ_SIZE]], ptr [[ALLOCA]], align 4
197+
; CHECK-NEXT: store i64 [[OBJ_SIZE]], ptr [[ALLOCA]], align 8
198198
; CHECK-NEXT: [[PTRINT:%.*]] = ptrtoint ptr [[A]] to i64
199199
; CHECK-NEXT: [[MASKEDPTR:%.*]] = and i64 [[PTRINT]], 31
200200
; CHECK-NEXT: [[MASKCOND:%.*]] = icmp eq i64 [[MASKEDPTR]], 0
@@ -222,11 +222,11 @@ define void @complex_backpropagate_bundle(ptr %a, ptr %b, ptr %c) {
222222
; CHECK-LABEL: define void @complex_backpropagate_bundle
223223
; CHECK-SAME: (ptr [[A:%.*]], ptr [[B:%.*]], ptr [[C:%.*]]) {
224224
; CHECK-NEXT: [[ALLOCA:%.*]] = alloca i64, align 8
225-
; CHECK-NEXT: [[LOAD_A:%.*]] = load i32, ptr [[A]], align 4
225+
; CHECK-NEXT: [[LOAD_A:%.*]] = load i32, ptr [[A]], align 32
226226
; CHECK-NEXT: [[LOAD_B:%.*]] = load i32, ptr [[B]], align 4
227-
; CHECK-NEXT: store i32 [[LOAD_B]], ptr [[A]], align 4
227+
; CHECK-NEXT: store i32 [[LOAD_B]], ptr [[A]], align 32
228228
; CHECK-NEXT: [[OBJ_SIZE:%.*]] = call i64 @llvm.objectsize.i64.p0(ptr [[C]], i1 false, i1 false, i1 false)
229-
; CHECK-NEXT: store i64 [[OBJ_SIZE]], ptr [[ALLOCA]], align 4
229+
; CHECK-NEXT: store i64 [[OBJ_SIZE]], ptr [[ALLOCA]], align 8
230230
; CHECK-NEXT: tail call void @llvm.assume(i1 true) [ "align"(ptr [[A]], i32 32) ]
231231
; CHECK-NEXT: ret void
232232
;

‎llvm/test/Transforms/InferAlignment/ptrmask.ll

Lines changed: 9 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,5 @@
11
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 2
2-
; RUN: opt < %s -passes=no-op-function -S | FileCheck %s
2+
; RUN: opt < %s -passes=infer-alignment -S | FileCheck %s
33

44
; ------------------------------------------------------------------------------
55
; load instructions
@@ -11,9 +11,9 @@ define void @load(ptr align 1 %ptr) {
1111
; CHECK-NEXT: [[ALIGNED_0:%.*]] = call ptr @llvm.ptrmask.p0.i64(ptr [[PTR]], i64 -2)
1212
; CHECK-NEXT: [[ALIGNED_1:%.*]] = call ptr @llvm.ptrmask.p0.i64(ptr [[PTR]], i64 -4)
1313
; CHECK-NEXT: [[ALIGNED_2:%.*]] = call ptr @llvm.ptrmask.p0.i64(ptr [[PTR]], i64 -8)
14-
; CHECK-NEXT: [[LOAD_0:%.*]] = load <16 x i8>, ptr [[ALIGNED_0]], align 1
15-
; CHECK-NEXT: [[LOAD_1:%.*]] = load <16 x i8>, ptr [[ALIGNED_1]], align 1
16-
; CHECK-NEXT: [[LOAD_2:%.*]] = load <16 x i8>, ptr [[ALIGNED_2]], align 1
14+
; CHECK-NEXT: [[LOAD_0:%.*]] = load <16 x i8>, ptr [[ALIGNED_0]], align 2
15+
; CHECK-NEXT: [[LOAD_1:%.*]] = load <16 x i8>, ptr [[ALIGNED_1]], align 4
16+
; CHECK-NEXT: [[LOAD_2:%.*]] = load <16 x i8>, ptr [[ALIGNED_2]], align 8
1717
; CHECK-NEXT: ret void
1818
;
1919
%aligned.0 = call ptr @llvm.ptrmask.p0.i64(ptr %ptr, i64 -2)
@@ -37,9 +37,9 @@ define void @store(ptr align 1 %ptr) {
3737
; CHECK-NEXT: [[ALIGNED_0:%.*]] = call ptr @llvm.ptrmask.p0.i64(ptr [[PTR]], i64 -2)
3838
; CHECK-NEXT: [[ALIGNED_1:%.*]] = call ptr @llvm.ptrmask.p0.i64(ptr [[PTR]], i64 -4)
3939
; CHECK-NEXT: [[ALIGNED_2:%.*]] = call ptr @llvm.ptrmask.p0.i64(ptr [[PTR]], i64 -8)
40-
; CHECK-NEXT: store <16 x i8> zeroinitializer, ptr [[ALIGNED_0]], align 1
41-
; CHECK-NEXT: store <16 x i8> zeroinitializer, ptr [[ALIGNED_1]], align 1
42-
; CHECK-NEXT: store <16 x i8> zeroinitializer, ptr [[ALIGNED_2]], align 1
40+
; CHECK-NEXT: store <16 x i8> zeroinitializer, ptr [[ALIGNED_0]], align 2
41+
; CHECK-NEXT: store <16 x i8> zeroinitializer, ptr [[ALIGNED_1]], align 4
42+
; CHECK-NEXT: store <16 x i8> zeroinitializer, ptr [[ALIGNED_2]], align 8
4343
; CHECK-NEXT: ret void
4444
;
4545
%aligned.0 = call ptr @llvm.ptrmask.p0.i64(ptr %ptr, i64 -2)
@@ -62,8 +62,8 @@ define void @ptrmask_overaligned(ptr align 16 %ptr) {
6262
; CHECK-LABEL: define void @ptrmask_overaligned
6363
; CHECK-SAME: (ptr align 16 [[PTR:%.*]]) {
6464
; CHECK-NEXT: [[ALIGNED:%.*]] = call ptr @llvm.ptrmask.p0.i64(ptr [[PTR]], i64 -8)
65-
; CHECK-NEXT: [[LOAD:%.*]] = load <16 x i8>, ptr [[ALIGNED]], align 1
66-
; CHECK-NEXT: store <16 x i8> zeroinitializer, ptr [[ALIGNED]], align 1
65+
; CHECK-NEXT: [[LOAD:%.*]] = load <16 x i8>, ptr [[ALIGNED]], align 16
66+
; CHECK-NEXT: store <16 x i8> zeroinitializer, ptr [[ALIGNED]], align 16
6767
; CHECK-NEXT: ret void
6868
;
6969
%aligned = call ptr @llvm.ptrmask.p0.i64(ptr %ptr, i64 -8)

‎llvm/test/Transforms/InferAlignment/undef-and-null.ll

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -1,11 +1,11 @@
11
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 2
2-
; RUN: opt -passes=no-op-function -S < %s | FileCheck %s
2+
; RUN: opt -passes=infer-alignment -S < %s | FileCheck %s
33

44
define void @load_undef_null(ptr %P) {
55
; CHECK-LABEL: define void @load_undef_null
66
; CHECK-SAME: (ptr [[P:%.*]]) {
77
; CHECK-NEXT: [[RET_0:%.*]] = load i32, ptr undef, align 4
8-
; CHECK-NEXT: [[RET_1:%.*]] = load i32, ptr null, align 4
8+
; CHECK-NEXT: [[RET_1:%.*]] = load i32, ptr null, align 4294967296
99
; CHECK-NEXT: ret void
1010
;
1111
%ret.0 = load i32, ptr undef
@@ -17,7 +17,7 @@ define void @store_undef_null(ptr %P) {
1717
; CHECK-LABEL: define void @store_undef_null
1818
; CHECK-SAME: (ptr [[P:%.*]]) {
1919
; CHECK-NEXT: store i32 123, ptr undef, align 4
20-
; CHECK-NEXT: store i32 124, ptr null, align 4
20+
; CHECK-NEXT: store i32 124, ptr null, align 4294967296
2121
; CHECK-NEXT: ret void
2222
;
2323
store i32 123, ptr undef

‎llvm/test/Transforms/InferAlignment/vector.ll

Lines changed: 13 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,5 @@
11
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 2
2-
; RUN: opt < %s -passes=no-op-function -S | FileCheck %s
2+
; RUN: opt < %s -passes=infer-alignment -S | FileCheck %s
33

44
; InferAlignment should be able to prove vector alignment in the
55
; presence of a few mild address computation tricks.
@@ -12,8 +12,8 @@ define void @alloca(<2 x i64> %y) {
1212
; CHECK-LABEL: define void @alloca
1313
; CHECK-SAME: (<2 x i64> [[Y:%.*]]) {
1414
; CHECK-NEXT: [[ALLOCA:%.*]] = alloca <2 x i64>, align 16
15-
; CHECK-NEXT: [[LOAD:%.*]] = load <2 x i64>, ptr [[ALLOCA]], align 1
16-
; CHECK-NEXT: store <2 x i64> [[Y]], ptr [[ALLOCA]], align 1
15+
; CHECK-NEXT: [[LOAD:%.*]] = load <2 x i64>, ptr [[ALLOCA]], align 16
16+
; CHECK-NEXT: store <2 x i64> [[Y]], ptr [[ALLOCA]], align 16
1717
; CHECK-NEXT: ret void
1818
;
1919
%alloca = alloca <2 x i64>
@@ -31,8 +31,8 @@ define void @alloca(<2 x i64> %y) {
3131
define void @global(<2 x i64> %y) {
3232
; CHECK-LABEL: define void @global
3333
; CHECK-SAME: (<2 x i64> [[Y:%.*]]) {
34-
; CHECK-NEXT: [[LOAD:%.*]] = load <2 x i64>, ptr @x.vector, align 1
35-
; CHECK-NEXT: store <2 x i64> [[Y]], ptr @x.vector, align 1
34+
; CHECK-NEXT: [[LOAD:%.*]] = load <2 x i64>, ptr @x.vector, align 16
35+
; CHECK-NEXT: store <2 x i64> [[Y]], ptr @x.vector, align 16
3636
; CHECK-NEXT: ret void
3737
;
3838
%load = load <2 x i64>, ptr @x.vector, align 1
@@ -55,8 +55,8 @@ define void @vector_singular(i32 %i, <2 x i64> %y) {
5555
; CHECK-LABEL: define void @vector_singular
5656
; CHECK-SAME: (i32 [[I:%.*]], <2 x i64> [[Y:%.*]]) {
5757
; CHECK-NEXT: [[GEP:%.*]] = getelementptr <2 x i64>, ptr @vector, i32 [[I]]
58-
; CHECK-NEXT: [[LOAD:%.*]] = load <2 x i64>, ptr [[GEP]], align 1
59-
; CHECK-NEXT: store <2 x i64> [[Y]], ptr [[GEP]], align 1
58+
; CHECK-NEXT: [[LOAD:%.*]] = load <2 x i64>, ptr [[GEP]], align 16
59+
; CHECK-NEXT: store <2 x i64> [[Y]], ptr [[GEP]], align 16
6060
; CHECK-NEXT: ret void
6161
;
6262
%gep = getelementptr <2 x i64>, ptr @vector, i32 %i
@@ -73,8 +73,8 @@ define void @vector_array(i32 %i, i32 %j, <2 x i64> %y) {
7373
; CHECK-LABEL: define void @vector_array
7474
; CHECK-SAME: (i32 [[I:%.*]], i32 [[J:%.*]], <2 x i64> [[Y:%.*]]) {
7575
; CHECK-NEXT: [[GEP:%.*]] = getelementptr [13 x <2 x i64>], ptr @vector.arr, i32 [[I]], i32 [[J]]
76-
; CHECK-NEXT: [[LOAD:%.*]] = load <2 x i64>, ptr [[GEP]], align 1
77-
; CHECK-NEXT: store <2 x i64> [[Y]], ptr [[GEP]], align 1
76+
; CHECK-NEXT: [[LOAD:%.*]] = load <2 x i64>, ptr [[GEP]], align 16
77+
; CHECK-NEXT: store <2 x i64> [[Y]], ptr [[GEP]], align 16
7878
; CHECK-NEXT: ret void
7979
;
8080
%gep = getelementptr [13 x <2 x i64>], ptr @vector.arr, i32 %i, i32 %j
@@ -93,11 +93,11 @@ define void @vector_array(i32 %i, i32 %j, <2 x i64> %y) {
9393

9494
define void @nonvector_array() {
9595
; CHECK-LABEL: define void @nonvector_array() {
96-
; CHECK-NEXT: [[LOAD_0:%.*]] = load <16 x i8>, ptr @x.array, align 1
97-
; CHECK-NEXT: store <16 x i8> zeroinitializer, ptr @x.array, align 1
96+
; CHECK-NEXT: [[LOAD_0:%.*]] = load <16 x i8>, ptr @x.array, align 16
97+
; CHECK-NEXT: store <16 x i8> zeroinitializer, ptr @x.array, align 16
9898
; CHECK-NEXT: [[GEP:%.*]] = getelementptr [4 x i32], ptr @x.array, i16 0, i16 2
99-
; CHECK-NEXT: [[LOAD_1:%.*]] = load <16 x i8>, ptr [[GEP]], align 1
100-
; CHECK-NEXT: store <16 x i8> zeroinitializer, ptr [[GEP]], align 1
99+
; CHECK-NEXT: [[LOAD_1:%.*]] = load <16 x i8>, ptr [[GEP]], align 8
100+
; CHECK-NEXT: store <16 x i8> zeroinitializer, ptr [[GEP]], align 8
101101
; CHECK-NEXT: ret void
102102
;
103103
%load.0 = load <16 x i8>, ptr @x.array, align 1

‎llvm/test/Transforms/InferAlignment/volatile.ll

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -1,11 +1,11 @@
11
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 2
2-
; RUN: opt < %s -passes=no-op-function -S | FileCheck %s
2+
; RUN: opt < %s -passes=infer-alignment -S | FileCheck %s
33

44
define void @load_volatile() {
55
; CHECK-LABEL: define void @load_volatile() {
66
; CHECK-NEXT: [[A:%.*]] = alloca { i32 }, align 8
77
; CHECK-NEXT: [[B:%.*]] = alloca i32, align 4
8-
; CHECK-NEXT: [[LOAD_A:%.*]] = load volatile i32, ptr [[A]], align 4
8+
; CHECK-NEXT: [[LOAD_A:%.*]] = load volatile i32, ptr [[A]], align 8
99
; CHECK-NEXT: [[LOAD_B:%.*]] = load volatile i32, ptr [[B]], align 4
1010
; CHECK-NEXT: ret void
1111
;
@@ -20,7 +20,7 @@ define void @store_volatile() {
2020
; CHECK-LABEL: define void @store_volatile() {
2121
; CHECK-NEXT: [[A:%.*]] = alloca { i32 }, align 8
2222
; CHECK-NEXT: [[B:%.*]] = alloca i32, align 4
23-
; CHECK-NEXT: store volatile i32 123, ptr [[A]], align 4
23+
; CHECK-NEXT: store volatile i32 123, ptr [[A]], align 8
2424
; CHECK-NEXT: store volatile i32 123, ptr [[B]], align 4
2525
; CHECK-NEXT: ret void
2626
;

‎llvm/test/Transforms/InferAlignment/vscale.ll

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,5 @@
11
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --version 2
2-
; RUN: opt -passes=no-op-function -S < %s | FileCheck %s
2+
; RUN: opt -passes=infer-alignment -S < %s | FileCheck %s
33

44
; <4 x i32> -> 16 byte alignment
55
define void @alignment_sustain(ptr align 16 %ptr) {
@@ -23,8 +23,8 @@ define void @alignment_increase(ptr align 32 %ptr) {
2323
; CHECK-LABEL: define void @alignment_increase
2424
; CHECK-SAME: (ptr align 32 [[PTR:%.*]]) {
2525
; CHECK-NEXT: [[GEP:%.*]] = getelementptr <vscale x 8 x i32>, ptr [[PTR]], i32 3
26-
; CHECK-NEXT: [[LOAD:%.*]] = load <8 x i32>, ptr [[GEP]], align 16
27-
; CHECK-NEXT: store <8 x i32> zeroinitializer, ptr [[GEP]], align 16
26+
; CHECK-NEXT: [[LOAD:%.*]] = load <8 x i32>, ptr [[GEP]], align 32
27+
; CHECK-NEXT: store <8 x i32> zeroinitializer, ptr [[GEP]], align 32
2828
; CHECK-NEXT: ret void
2929
;
3030
%gep = getelementptr <vscale x 8 x i32>, ptr %ptr, i32 3

0 commit comments

Comments
 (0)
Please sign in to comment.