diff --git a/clang/lib/Sema/SemaDecl.cpp b/clang/lib/Sema/SemaDecl.cpp index fe61b92e087d7..411ece25b4344 100644 --- a/clang/lib/Sema/SemaDecl.cpp +++ b/clang/lib/Sema/SemaDecl.cpp @@ -17567,6 +17567,8 @@ Sema::ActOnTag(Scope *S, unsigned TagSpec, TagUseKind TUK, SourceLocation KWLoc, // parsing of the struct). if (TUK == TagUseKind::Definition && (!SkipBody || !SkipBody->ShouldSkip)) { + if (LangOpts.HLSL) + RD->addAttr(PackedAttr::CreateImplicit(Context)); AddAlignmentAttributesForRecord(RD); AddMsStructLayoutForRecord(RD); } @@ -18257,6 +18259,8 @@ Sema::ActOnTag(Scope *S, unsigned TagSpec, TagUseKind TUK, SourceLocation KWLoc, // the #pragma tokens are effectively skipped over during the // parsing of the struct). if (TUK == TagUseKind::Definition && (!SkipBody || !SkipBody->ShouldSkip)) { + if (LangOpts.HLSL) + RD->addAttr(PackedAttr::CreateImplicit(Context)); AddAlignmentAttributesForRecord(RD); AddMsStructLayoutForRecord(RD); } diff --git a/clang/lib/Sema/SemaTemplate.cpp b/clang/lib/Sema/SemaTemplate.cpp index 894f072d84989..e5c3fc536a281 100644 --- a/clang/lib/Sema/SemaTemplate.cpp +++ b/clang/lib/Sema/SemaTemplate.cpp @@ -2116,6 +2116,8 @@ DeclResult Sema::CheckClassTemplate( // Add alignment attributes if necessary; these attributes are checked when // the ASTContext lays out the structure. if (TUK == TagUseKind::Definition && (!SkipBody || !SkipBody->ShouldSkip)) { + if (LangOpts.HLSL) + NewClass->addAttr(PackedAttr::CreateImplicit(Context)); AddAlignmentAttributesForRecord(NewClass); AddMsStructLayoutForRecord(NewClass); } @@ -8655,6 +8657,8 @@ DeclResult Sema::ActOnClassTemplateSpecialization( // Add alignment attributes if necessary; these attributes are checked when // the ASTContext lays out the structure. if (TUK == TagUseKind::Definition && (!SkipBody || !SkipBody->ShouldSkip)) { + if (LangOpts.HLSL) + Specialization->addAttr(PackedAttr::CreateImplicit(Context)); AddAlignmentAttributesForRecord(Specialization); AddMsStructLayoutForRecord(Specialization); } diff --git a/clang/test/AST/HLSL/PackedStruct.hlsl b/clang/test/AST/HLSL/PackedStruct.hlsl new file mode 100644 index 0000000000000..4bffd275c757b --- /dev/null +++ b/clang/test/AST/HLSL/PackedStruct.hlsl @@ -0,0 +1,13 @@ +// RUN: %clang_cc1 -triple dxil-pc-shadermodel6.3-library -ast-dump %s | FileCheck %s +// Structs are packed by default in HLSL + +#include + +// CHECK: CXXRecordDecl {{.*}} struct S definition +// CHECK: DefinitionData +// CHECK: PackedAttr {{.*}} Implicit +// CHECK-NEXT: CXXRecordDecl {{.*}} implicit struct S +struct S { + float2 f; + int i; +}; diff --git a/clang/test/CodeGenHLSL/ArrayAssignable.hlsl b/clang/test/CodeGenHLSL/ArrayAssignable.hlsl index 6374f91230546..c3204570d6ef3 100644 --- a/clang/test/CodeGenHLSL/ArrayAssignable.hlsl +++ b/clang/test/CodeGenHLSL/ArrayAssignable.hlsl @@ -10,7 +10,7 @@ struct S { // CHECK: @c1 = external addrspace(2) global [2 x float], align 4 // CHECK: @c2 = external addrspace(2) global [2 x <4 x i32>], align 16 // CHECK: @c3 = external addrspace(2) global [2 x [2 x i32]], align 4 -// CHECK: @c4 = external addrspace(2) global [1 x target("dx.Layout", %S, 8, 0, 4)], align 4 +// CHECK: @c4 = external addrspace(2) global [1 x target("dx.Layout", %S, 8, 0, 4)], align 1 cbuffer CBArrays : register(b0) { float c1[2]; @@ -169,8 +169,8 @@ void arr_assign10() { } // CHECK-LABEL: define void {{.*}}arr_assign11 -// CHECK: [[C:%.*]] = alloca [1 x %struct.S], align 4 -// CHECK: call void @llvm.memcpy.p0.p2.i32(ptr align 4 [[C]], ptr addrspace(2) align 4 @c4, i32 8, i1 false) +// CHECK: [[C:%.*]] = alloca [1 x %struct.S], align 1 +// CHECK: call void @llvm.memcpy.p0.p2.i32(ptr align 1 [[C]], ptr addrspace(2) align 1 @c4, i32 8, i1 false) // CHECK-NEXT: ret void void arr_assign11() { S s = {1, 2.0}; diff --git a/clang/test/CodeGenHLSL/ArrayTemporary.hlsl b/clang/test/CodeGenHLSL/ArrayTemporary.hlsl index 91a283554459d..29ea896045bb1 100644 --- a/clang/test/CodeGenHLSL/ArrayTemporary.hlsl +++ b/clang/test/CodeGenHLSL/ArrayTemporary.hlsl @@ -24,9 +24,9 @@ void fn2(Obj O[4]) { } // CHECK-LABEL: define void {{.*}}call2{{.*}} // CHECK: [[Arr:%.*]] = alloca [4 x %struct.Obj] // CHECK: [[Tmp:%.*]] = alloca [4 x %struct.Obj] -// CHECK: call void @llvm.memset.p0.i32(ptr align 4 [[Arr]], i8 0, i32 32, i1 false) -// CHECK: call void @llvm.memcpy.p0.p0.i32(ptr align 4 [[Tmp]], ptr align 4 [[Arr]], i32 32, i1 false) -// CHECK: call void {{.*}}fn2{{.*}}(ptr noundef byval([4 x %struct.Obj]) align 4 [[Tmp]]) +// CHECK: call void @llvm.memset.p0.i32(ptr align 1 [[Arr]], i8 0, i32 32, i1 false) +// CHECK: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[Tmp]], ptr align 1 [[Arr]], i32 32, i1 false) +// CHECK: call void {{.*}}fn2{{.*}}(ptr noundef byval([4 x %struct.Obj]) align 1 [[Tmp]]) void call2() { Obj Arr[4] = {{0, 0}, {0, 0}, {0, 0}, {0, 0}}; fn2(Arr); diff --git a/clang/test/CodeGenHLSL/BasicFeatures/AggregateSplatCast.hlsl b/clang/test/CodeGenHLSL/BasicFeatures/AggregateSplatCast.hlsl index 42b6abec1b3d8..512fcd435191a 100644 --- a/clang/test/CodeGenHLSL/BasicFeatures/AggregateSplatCast.hlsl +++ b/clang/test/CodeGenHLSL/BasicFeatures/AggregateSplatCast.hlsl @@ -55,7 +55,7 @@ struct S { // struct splats // CHECK-LABEL: define void {{.*}}call3 // CHECK: [[A:%.*]] = alloca <1 x i32>, align 4 -// CHECK: [[s:%.*]] = alloca %struct.S, align 4 +// CHECK: [[s:%.*]] = alloca %struct.S, align 1 // CHECK-NEXT: store <1 x i32> splat (i32 1), ptr [[A]], align 4 // CHECK-NEXT: [[L:%.*]] = load <1 x i32>, ptr [[A]], align 4 // CHECK-NEXT: [[VL:%.*]] = extractelement <1 x i32> [[L]], i32 0 @@ -72,7 +72,7 @@ export void call3() { // struct splat from vector of length 1 // CHECK-LABEL: define void {{.*}}call5 // CHECK: [[A:%.*]] = alloca <1 x i32>, align 4 -// CHECK-NEXT: [[s:%.*]] = alloca %struct.S, align 4 +// CHECK-NEXT: [[s:%.*]] = alloca %struct.S, align 1 // CHECK-NEXT: store <1 x i32> splat (i32 1), ptr [[A]], align 4 // CHECK-NEXT: [[L:%.*]] = load <1 x i32>, ptr [[A]], align 4 // CHECK-NEXT: [[VL:%.*]] = extractelement <1 x i32> [[L]], i32 0 diff --git a/clang/test/CodeGenHLSL/BasicFeatures/ArrayElementwiseCast.hlsl b/clang/test/CodeGenHLSL/BasicFeatures/ArrayElementwiseCast.hlsl index 18f82bff3b308..ac02ddf5765ed 100644 --- a/clang/test/CodeGenHLSL/BasicFeatures/ArrayElementwiseCast.hlsl +++ b/clang/test/CodeGenHLSL/BasicFeatures/ArrayElementwiseCast.hlsl @@ -125,12 +125,12 @@ struct S { // flatten and truncate from a struct // CHECK-LABEL: define void {{.*}}call7 -// CHECK: [[s:%.*]] = alloca %struct.S, align 4 +// CHECK: [[s:%.*]] = alloca %struct.S, align 1 // CHECK-NEXT: [[A:%.*]] = alloca [1 x i32], align 4 -// CHECK-NEXT: [[Tmp:%.*]] = alloca %struct.S, align 4 -// CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 4 [[s]], ptr align 4 {{.*}}, i32 8, i1 false) +// CHECK-NEXT: [[Tmp:%.*]] = alloca %struct.S, align 1 +// CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[s]], ptr align 1 {{.*}}, i32 8, i1 false) // CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 4 [[A]], ptr align 4 {{.*}}, i32 4, i1 false) -// CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 4 [[Tmp]], ptr align 4 [[s]], i32 8, i1 false) +// CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[Tmp]], ptr align 1 [[s]], i32 8, i1 false) // CHECK-NEXT: [[G1:%.*]] = getelementptr inbounds [1 x i32], ptr [[A]], i32 0, i32 0 // CHECK-NEXT: [[G2:%.*]] = getelementptr inbounds %struct.S, ptr [[Tmp]], i32 0, i32 0 // CHECK-NEXT: [[G3:%.*]] = getelementptr inbounds %struct.S, ptr [[Tmp]], i32 0, i32 1 @@ -141,4 +141,3 @@ export void call7() { int A[1] = {1}; A = (int[1])s; } - diff --git a/clang/test/CodeGenHLSL/BasicFeatures/InitLists.hlsl b/clang/test/CodeGenHLSL/BasicFeatures/InitLists.hlsl index a0590162c7087..d04583e4fc51a 100644 --- a/clang/test/CodeGenHLSL/BasicFeatures/InitLists.hlsl +++ b/clang/test/CodeGenHLSL/BasicFeatures/InitLists.hlsl @@ -47,9 +47,9 @@ struct SlicyBits { // Case 1: Extraneous braces get ignored in literal instantiation. // CHECK-LABEL: define void @_Z5case1v( -// CHECK-SAME: ptr dead_on_unwind noalias writable sret([[STRUCT_TWOFLOATS:%.*]]) align 4 [[AGG_RESULT:%.*]]) #[[ATTR0:[0-9]+]] { +// CHECK-SAME: ptr dead_on_unwind noalias writable sret([[STRUCT_TWOFLOATS:%.*]]) align 1 [[AGG_RESULT:%.*]]) #[[ATTR0:[0-9]+]] { // CHECK-NEXT: [[ENTRY:.*:]] -// CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 4 [[AGG_RESULT]], ptr align 4 @__const._Z5case1v.TF1, i32 8, i1 false) +// CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[AGG_RESULT]], ptr align 1 @__const._Z5case1v.TF1, i32 8, i1 false) // CHECK-NEXT: ret void // TwoFloats case1() { @@ -59,9 +59,9 @@ TwoFloats case1() { // Case 2: Valid C/C++ initializer is handled appropriately. // CHECK-LABEL: define void @_Z5case2v( -// CHECK-SAME: ptr dead_on_unwind noalias writable sret([[STRUCT_TWOFLOATS:%.*]]) align 4 [[AGG_RESULT:%.*]]) #[[ATTR0]] { +// CHECK-SAME: ptr dead_on_unwind noalias writable sret([[STRUCT_TWOFLOATS:%.*]]) align 1 [[AGG_RESULT:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] -// CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 4 [[AGG_RESULT]], ptr align 4 @__const._Z5case2v.TF2, i32 8, i1 false) +// CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[AGG_RESULT]], ptr align 1 @__const._Z5case2v.TF2, i32 8, i1 false) // CHECK-NEXT: ret void // TwoFloats case2() { @@ -71,16 +71,16 @@ TwoFloats case2() { // Case 3: Simple initialization with conversion of an argument. // CHECK-LABEL: define void @_Z5case3i( -// CHECK-SAME: ptr dead_on_unwind noalias writable sret([[STRUCT_TWOFLOATS:%.*]]) align 4 [[AGG_RESULT:%.*]], i32 noundef [[VAL:%.*]]) #[[ATTR0]] { +// CHECK-SAME: ptr dead_on_unwind noalias writable sret([[STRUCT_TWOFLOATS:%.*]]) align 1 [[AGG_RESULT:%.*]], i32 noundef [[VAL:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] // CHECK-NEXT: [[VAL_ADDR:%.*]] = alloca i32, align 4 // CHECK-NEXT: store i32 [[VAL]], ptr [[VAL_ADDR]], align 4 // CHECK-NEXT: [[X:%.*]] = getelementptr inbounds nuw [[STRUCT_TWOFLOATS]], ptr [[AGG_RESULT]], i32 0, i32 0 // CHECK-NEXT: [[TMP0:%.*]] = load i32, ptr [[VAL_ADDR]], align 4 // CHECK-NEXT: [[CONV:%.*]] = sitofp i32 [[TMP0]] to float -// CHECK-NEXT: store float [[CONV]], ptr [[X]], align 4 +// CHECK-NEXT: store float [[CONV]], ptr [[X]], align 1 // CHECK-NEXT: [[Y:%.*]] = getelementptr inbounds nuw [[STRUCT_TWOFLOATS]], ptr [[AGG_RESULT]], i32 0, i32 1 -// CHECK-NEXT: store float 2.000000e+00, ptr [[Y]], align 4 +// CHECK-NEXT: store float 2.000000e+00, ptr [[Y]], align 1 // CHECK-NEXT: ret void // TwoFloats case3(int Val) { @@ -91,7 +91,7 @@ TwoFloats case3(int Val) { // Case 4: Initialization from a scalarized vector into a structure with element // conversions. // CHECK-LABEL: define void @_Z5case4Dv2_i( -// CHECK-SAME: ptr dead_on_unwind noalias writable sret([[STRUCT_TWOFLOATS:%.*]]) align 4 [[AGG_RESULT:%.*]], <2 x i32> noundef [[TWOVALS:%.*]]) #[[ATTR0]] { +// CHECK-SAME: ptr dead_on_unwind noalias writable sret([[STRUCT_TWOFLOATS:%.*]]) align 1 [[AGG_RESULT:%.*]], <2 x i32> noundef [[TWOVALS:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] // CHECK-NEXT: [[TWOVALS_ADDR:%.*]] = alloca <2 x i32>, align 8 // CHECK-NEXT: store <2 x i32> [[TWOVALS]], ptr [[TWOVALS_ADDR]], align 8 @@ -99,12 +99,12 @@ TwoFloats case3(int Val) { // CHECK-NEXT: [[TMP0:%.*]] = load <2 x i32>, ptr [[TWOVALS_ADDR]], align 8 // CHECK-NEXT: [[VECEXT:%.*]] = extractelement <2 x i32> [[TMP0]], i64 0 // CHECK-NEXT: [[CONV:%.*]] = sitofp i32 [[VECEXT]] to float -// CHECK-NEXT: store float [[CONV]], ptr [[X]], align 4 +// CHECK-NEXT: store float [[CONV]], ptr [[X]], align 1 // CHECK-NEXT: [[Y:%.*]] = getelementptr inbounds nuw [[STRUCT_TWOFLOATS]], ptr [[AGG_RESULT]], i32 0, i32 1 // CHECK-NEXT: [[TMP1:%.*]] = load <2 x i32>, ptr [[TWOVALS_ADDR]], align 8 // CHECK-NEXT: [[VECEXT1:%.*]] = extractelement <2 x i32> [[TMP1]], i64 1 // CHECK-NEXT: [[CONV2:%.*]] = sitofp i32 [[VECEXT1]] to float -// CHECK-NEXT: store float [[CONV2]], ptr [[Y]], align 4 +// CHECK-NEXT: store float [[CONV2]], ptr [[Y]], align 1 // CHECK-NEXT: ret void // TwoFloats case4(int2 TwoVals) { @@ -114,18 +114,18 @@ TwoFloats case4(int2 TwoVals) { // Case 5: Initialization from a scalarized vector of matching type. // CHECK-LABEL: define void @_Z5case5Dv2_i( -// CHECK-SAME: ptr dead_on_unwind noalias writable sret([[STRUCT_TWOINTS:%.*]]) align 4 [[AGG_RESULT:%.*]], <2 x i32> noundef [[TWOVALS:%.*]]) #[[ATTR0]] { +// CHECK-SAME: ptr dead_on_unwind noalias writable sret([[STRUCT_TWOINTS:%.*]]) align 1 [[AGG_RESULT:%.*]], <2 x i32> noundef [[TWOVALS:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] // CHECK-NEXT: [[TWOVALS_ADDR:%.*]] = alloca <2 x i32>, align 8 // CHECK-NEXT: store <2 x i32> [[TWOVALS]], ptr [[TWOVALS_ADDR]], align 8 // CHECK-NEXT: [[Z:%.*]] = getelementptr inbounds nuw [[STRUCT_TWOINTS]], ptr [[AGG_RESULT]], i32 0, i32 0 // CHECK-NEXT: [[TMP0:%.*]] = load <2 x i32>, ptr [[TWOVALS_ADDR]], align 8 // CHECK-NEXT: [[VECEXT:%.*]] = extractelement <2 x i32> [[TMP0]], i64 0 -// CHECK-NEXT: store i32 [[VECEXT]], ptr [[Z]], align 4 +// CHECK-NEXT: store i32 [[VECEXT]], ptr [[Z]], align 1 // CHECK-NEXT: [[W:%.*]] = getelementptr inbounds nuw [[STRUCT_TWOINTS]], ptr [[AGG_RESULT]], i32 0, i32 1 // CHECK-NEXT: [[TMP1:%.*]] = load <2 x i32>, ptr [[TWOVALS_ADDR]], align 8 // CHECK-NEXT: [[VECEXT1:%.*]] = extractelement <2 x i32> [[TMP1]], i64 1 -// CHECK-NEXT: store i32 [[VECEXT1]], ptr [[W]], align 4 +// CHECK-NEXT: store i32 [[VECEXT1]], ptr [[W]], align 1 // CHECK-NEXT: ret void // TwoInts case5(int2 TwoVals) { @@ -136,18 +136,18 @@ TwoInts case5(int2 TwoVals) { // Case 6: Initialization from a scalarized structure of different type with // different element types. // CHECK-LABEL: define void @_Z5case69TwoFloats( -// CHECK-SAME: ptr dead_on_unwind noalias writable sret([[STRUCT_TWOINTS:%.*]]) align 4 [[AGG_RESULT:%.*]], ptr noundef byval([[STRUCT_TWOFLOATS:%.*]]) align 4 [[TF4:%.*]]) #[[ATTR0]] { +// CHECK-SAME: ptr dead_on_unwind noalias writable sret([[STRUCT_TWOINTS:%.*]]) align 1 [[AGG_RESULT:%.*]], ptr noundef byval([[STRUCT_TWOFLOATS:%.*]]) align 1 [[TF4:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] // CHECK-NEXT: [[Z:%.*]] = getelementptr inbounds nuw [[STRUCT_TWOINTS]], ptr [[AGG_RESULT]], i32 0, i32 0 // CHECK-NEXT: [[X:%.*]] = getelementptr inbounds nuw [[STRUCT_TWOFLOATS]], ptr [[TF4]], i32 0, i32 0 -// CHECK-NEXT: [[TMP0:%.*]] = load float, ptr [[X]], align 4 +// CHECK-NEXT: [[TMP0:%.*]] = load float, ptr [[X]], align 1 // CHECK-NEXT: [[CONV:%.*]] = fptosi float [[TMP0]] to i32 -// CHECK-NEXT: store i32 [[CONV]], ptr [[Z]], align 4 +// CHECK-NEXT: store i32 [[CONV]], ptr [[Z]], align 1 // CHECK-NEXT: [[W:%.*]] = getelementptr inbounds nuw [[STRUCT_TWOINTS]], ptr [[AGG_RESULT]], i32 0, i32 1 // CHECK-NEXT: [[Y:%.*]] = getelementptr inbounds nuw [[STRUCT_TWOFLOATS]], ptr [[TF4]], i32 0, i32 1 -// CHECK-NEXT: [[TMP1:%.*]] = load float, ptr [[Y]], align 4 +// CHECK-NEXT: [[TMP1:%.*]] = load float, ptr [[Y]], align 1 // CHECK-NEXT: [[CONV1:%.*]] = fptosi float [[TMP1]] to i32 -// CHECK-NEXT: store i32 [[CONV1]], ptr [[W]], align 4 +// CHECK-NEXT: store i32 [[CONV1]], ptr [[W]], align 1 // CHECK-NEXT: ret void // TwoInts case6(TwoFloats TF4) { @@ -158,59 +158,59 @@ TwoInts case6(TwoFloats TF4) { // Case 7: Initialization of a complex structure, with bogus braces and element // conversions from a collection of scalar values, and structures. // CHECK-LABEL: define void @_Z5case77TwoIntsS_i9TwoFloatsS0_S0_S0_( -// CHECK-SAME: ptr dead_on_unwind noalias writable sret([[STRUCT_DOGGO:%.*]]) align 16 [[AGG_RESULT:%.*]], ptr noundef byval([[STRUCT_TWOINTS:%.*]]) align 4 [[TI1:%.*]], ptr noundef byval([[STRUCT_TWOINTS]]) align 4 [[TI2:%.*]], i32 noundef [[VAL:%.*]], ptr noundef byval([[STRUCT_TWOFLOATS:%.*]]) align 4 [[TF1:%.*]], ptr noundef byval([[STRUCT_TWOFLOATS]]) align 4 [[TF2:%.*]], ptr noundef byval([[STRUCT_TWOFLOATS]]) align 4 [[TF3:%.*]], ptr noundef byval([[STRUCT_TWOFLOATS]]) align 4 [[TF4:%.*]]) #[[ATTR0]] { +// CHECK-SAME: ptr dead_on_unwind noalias writable sret([[STRUCT_DOGGO:%.*]]) align 1 [[AGG_RESULT:%.*]], ptr noundef byval([[STRUCT_TWOINTS:%.*]]) align 1 [[TI1:%.*]], ptr noundef byval([[STRUCT_TWOINTS]]) align 1 [[TI2:%.*]], i32 noundef [[VAL:%.*]], ptr noundef byval([[STRUCT_TWOFLOATS:%.*]]) align 1 [[TF1:%.*]], ptr noundef byval([[STRUCT_TWOFLOATS]]) align 1 [[TF2:%.*]], ptr noundef byval([[STRUCT_TWOFLOATS]]) align 1 [[TF3:%.*]], ptr noundef byval([[STRUCT_TWOFLOATS]]) align 1 [[TF4:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] // CHECK-NEXT: [[VAL_ADDR:%.*]] = alloca i32, align 4 // CHECK-NEXT: store i32 [[VAL]], ptr [[VAL_ADDR]], align 4 // CHECK-NEXT: [[LEGSTATE:%.*]] = getelementptr inbounds nuw [[STRUCT_DOGGO]], ptr [[AGG_RESULT]], i32 0, i32 0 // CHECK-NEXT: [[Z:%.*]] = getelementptr inbounds nuw [[STRUCT_TWOINTS]], ptr [[TI1]], i32 0, i32 0 -// CHECK-NEXT: [[TMP0:%.*]] = load i32, ptr [[Z]], align 4 +// CHECK-NEXT: [[TMP0:%.*]] = load i32, ptr [[Z]], align 1 // CHECK-NEXT: [[VECINIT:%.*]] = insertelement <4 x i32> poison, i32 [[TMP0]], i32 0 // CHECK-NEXT: [[W:%.*]] = getelementptr inbounds nuw [[STRUCT_TWOINTS]], ptr [[TI1]], i32 0, i32 1 -// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[W]], align 4 +// CHECK-NEXT: [[TMP1:%.*]] = load i32, ptr [[W]], align 1 // CHECK-NEXT: [[VECINIT1:%.*]] = insertelement <4 x i32> [[VECINIT]], i32 [[TMP1]], i32 1 // CHECK-NEXT: [[Z2:%.*]] = getelementptr inbounds nuw [[STRUCT_TWOINTS]], ptr [[TI2]], i32 0, i32 0 -// CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[Z2]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[Z2]], align 1 // CHECK-NEXT: [[VECINIT3:%.*]] = insertelement <4 x i32> [[VECINIT1]], i32 [[TMP2]], i32 2 // CHECK-NEXT: [[W4:%.*]] = getelementptr inbounds nuw [[STRUCT_TWOINTS]], ptr [[TI2]], i32 0, i32 1 -// CHECK-NEXT: [[TMP3:%.*]] = load i32, ptr [[W4]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load i32, ptr [[W4]], align 1 // CHECK-NEXT: [[VECINIT5:%.*]] = insertelement <4 x i32> [[VECINIT3]], i32 [[TMP3]], i32 3 -// CHECK-NEXT: store <4 x i32> [[VECINIT5]], ptr [[LEGSTATE]], align 16 +// CHECK-NEXT: store <4 x i32> [[VECINIT5]], ptr [[LEGSTATE]], align 1 // CHECK-NEXT: [[TAILSTATE:%.*]] = getelementptr inbounds nuw [[STRUCT_DOGGO]], ptr [[AGG_RESULT]], i32 0, i32 1 // CHECK-NEXT: [[TMP4:%.*]] = load i32, ptr [[VAL_ADDR]], align 4 -// CHECK-NEXT: store i32 [[TMP4]], ptr [[TAILSTATE]], align 16 +// CHECK-NEXT: store i32 [[TMP4]], ptr [[TAILSTATE]], align 1 // CHECK-NEXT: [[HAIRCOUNT:%.*]] = getelementptr inbounds nuw [[STRUCT_DOGGO]], ptr [[AGG_RESULT]], i32 0, i32 2 // CHECK-NEXT: [[TMP5:%.*]] = load i32, ptr [[VAL_ADDR]], align 4 // CHECK-NEXT: [[CONV:%.*]] = sitofp i32 [[TMP5]] to float -// CHECK-NEXT: store float [[CONV]], ptr [[HAIRCOUNT]], align 4 +// CHECK-NEXT: store float [[CONV]], ptr [[HAIRCOUNT]], align 1 // CHECK-NEXT: [[EARDIRECTION:%.*]] = getelementptr inbounds nuw [[STRUCT_DOGGO]], ptr [[AGG_RESULT]], i32 0, i32 3 // CHECK-NEXT: [[X:%.*]] = getelementptr inbounds nuw [[STRUCT_TWOFLOATS]], ptr [[TF1]], i32 0, i32 0 -// CHECK-NEXT: [[TMP6:%.*]] = load float, ptr [[X]], align 4 +// CHECK-NEXT: [[TMP6:%.*]] = load float, ptr [[X]], align 1 // CHECK-NEXT: [[VECINIT6:%.*]] = insertelement <4 x float> poison, float [[TMP6]], i32 0 // CHECK-NEXT: [[Y:%.*]] = getelementptr inbounds nuw [[STRUCT_TWOFLOATS]], ptr [[TF1]], i32 0, i32 1 -// CHECK-NEXT: [[TMP7:%.*]] = load float, ptr [[Y]], align 4 +// CHECK-NEXT: [[TMP7:%.*]] = load float, ptr [[Y]], align 1 // CHECK-NEXT: [[VECINIT7:%.*]] = insertelement <4 x float> [[VECINIT6]], float [[TMP7]], i32 1 // CHECK-NEXT: [[X8:%.*]] = getelementptr inbounds nuw [[STRUCT_TWOFLOATS]], ptr [[TF2]], i32 0, i32 0 -// CHECK-NEXT: [[TMP8:%.*]] = load float, ptr [[X8]], align 4 +// CHECK-NEXT: [[TMP8:%.*]] = load float, ptr [[X8]], align 1 // CHECK-NEXT: [[VECINIT9:%.*]] = insertelement <4 x float> [[VECINIT7]], float [[TMP8]], i32 2 // CHECK-NEXT: [[Y10:%.*]] = getelementptr inbounds nuw [[STRUCT_TWOFLOATS]], ptr [[TF2]], i32 0, i32 1 -// CHECK-NEXT: [[TMP9:%.*]] = load float, ptr [[Y10]], align 4 +// CHECK-NEXT: [[TMP9:%.*]] = load float, ptr [[Y10]], align 1 // CHECK-NEXT: [[VECINIT11:%.*]] = insertelement <4 x float> [[VECINIT9]], float [[TMP9]], i32 3 -// CHECK-NEXT: store <4 x float> [[VECINIT11]], ptr [[EARDIRECTION]], align 16 +// CHECK-NEXT: store <4 x float> [[VECINIT11]], ptr [[EARDIRECTION]], align 1 // CHECK-NEXT: [[ARRAYINIT_ELEMENT:%.*]] = getelementptr inbounds <4 x float>, ptr [[EARDIRECTION]], i32 1 // CHECK-NEXT: [[X12:%.*]] = getelementptr inbounds nuw [[STRUCT_TWOFLOATS]], ptr [[TF3]], i32 0, i32 0 -// CHECK-NEXT: [[TMP10:%.*]] = load float, ptr [[X12]], align 4 +// CHECK-NEXT: [[TMP10:%.*]] = load float, ptr [[X12]], align 1 // CHECK-NEXT: [[VECINIT13:%.*]] = insertelement <4 x float> poison, float [[TMP10]], i32 0 // CHECK-NEXT: [[Y14:%.*]] = getelementptr inbounds nuw [[STRUCT_TWOFLOATS]], ptr [[TF3]], i32 0, i32 1 -// CHECK-NEXT: [[TMP11:%.*]] = load float, ptr [[Y14]], align 4 +// CHECK-NEXT: [[TMP11:%.*]] = load float, ptr [[Y14]], align 1 // CHECK-NEXT: [[VECINIT15:%.*]] = insertelement <4 x float> [[VECINIT13]], float [[TMP11]], i32 1 // CHECK-NEXT: [[X16:%.*]] = getelementptr inbounds nuw [[STRUCT_TWOFLOATS]], ptr [[TF4]], i32 0, i32 0 -// CHECK-NEXT: [[TMP12:%.*]] = load float, ptr [[X16]], align 4 +// CHECK-NEXT: [[TMP12:%.*]] = load float, ptr [[X16]], align 1 // CHECK-NEXT: [[VECINIT17:%.*]] = insertelement <4 x float> [[VECINIT15]], float [[TMP12]], i32 2 // CHECK-NEXT: [[Y18:%.*]] = getelementptr inbounds nuw [[STRUCT_TWOFLOATS]], ptr [[TF4]], i32 0, i32 1 -// CHECK-NEXT: [[TMP13:%.*]] = load float, ptr [[Y18]], align 4 +// CHECK-NEXT: [[TMP13:%.*]] = load float, ptr [[Y18]], align 1 // CHECK-NEXT: [[VECINIT19:%.*]] = insertelement <4 x float> [[VECINIT17]], float [[TMP13]], i32 3 -// CHECK-NEXT: store <4 x float> [[VECINIT19]], ptr [[ARRAYINIT_ELEMENT]], align 16 +// CHECK-NEXT: store <4 x float> [[VECINIT19]], ptr [[ARRAYINIT_ELEMENT]], align 1 // CHECK-NEXT: ret void // Doggo case7(TwoInts TI1, TwoInts TI2, int Val, TwoFloats TF1, TwoFloats TF2, @@ -222,81 +222,81 @@ Doggo case7(TwoInts TI1, TwoInts TI2, int Val, TwoFloats TF1, TwoFloats TF2, // Case 8: Initialization of a structure from a different structure with // significantly different element types and grouping. // CHECK-LABEL: define void @_Z5case85Doggo( -// CHECK-SAME: ptr dead_on_unwind noalias writable sret([[STRUCT_ANIMALBITS:%.*]]) align 16 [[AGG_RESULT:%.*]], ptr noundef byval([[STRUCT_DOGGO:%.*]]) align 16 [[D1:%.*]]) #[[ATTR0]] { +// CHECK-SAME: ptr dead_on_unwind noalias writable sret([[STRUCT_ANIMALBITS:%.*]]) align 1 [[AGG_RESULT:%.*]], ptr noundef byval([[STRUCT_DOGGO:%.*]]) align 1 [[D1:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] // CHECK-NEXT: [[LEGS:%.*]] = getelementptr inbounds nuw [[STRUCT_ANIMALBITS]], ptr [[AGG_RESULT]], i32 0, i32 0 // CHECK-NEXT: [[LEGSTATE:%.*]] = getelementptr inbounds nuw [[STRUCT_DOGGO]], ptr [[D1]], i32 0, i32 0 -// CHECK-NEXT: [[TMP0:%.*]] = load <4 x i32>, ptr [[LEGSTATE]], align 16 +// CHECK-NEXT: [[TMP0:%.*]] = load <4 x i32>, ptr [[LEGSTATE]], align 1 // CHECK-NEXT: [[VECEXT:%.*]] = extractelement <4 x i32> [[TMP0]], i64 0 -// CHECK-NEXT: store i32 [[VECEXT]], ptr [[LEGS]], align 4 +// CHECK-NEXT: store i32 [[VECEXT]], ptr [[LEGS]], align 1 // CHECK-NEXT: [[ARRAYINIT_ELEMENT:%.*]] = getelementptr inbounds i32, ptr [[LEGS]], i32 1 // CHECK-NEXT: [[LEGSTATE1:%.*]] = getelementptr inbounds nuw [[STRUCT_DOGGO]], ptr [[D1]], i32 0, i32 0 -// CHECK-NEXT: [[TMP1:%.*]] = load <4 x i32>, ptr [[LEGSTATE1]], align 16 +// CHECK-NEXT: [[TMP1:%.*]] = load <4 x i32>, ptr [[LEGSTATE1]], align 1 // CHECK-NEXT: [[VECEXT2:%.*]] = extractelement <4 x i32> [[TMP1]], i64 1 -// CHECK-NEXT: store i32 [[VECEXT2]], ptr [[ARRAYINIT_ELEMENT]], align 4 +// CHECK-NEXT: store i32 [[VECEXT2]], ptr [[ARRAYINIT_ELEMENT]], align 1 // CHECK-NEXT: [[ARRAYINIT_ELEMENT3:%.*]] = getelementptr inbounds i32, ptr [[LEGS]], i32 2 // CHECK-NEXT: [[LEGSTATE4:%.*]] = getelementptr inbounds nuw [[STRUCT_DOGGO]], ptr [[D1]], i32 0, i32 0 -// CHECK-NEXT: [[TMP2:%.*]] = load <4 x i32>, ptr [[LEGSTATE4]], align 16 +// CHECK-NEXT: [[TMP2:%.*]] = load <4 x i32>, ptr [[LEGSTATE4]], align 1 // CHECK-NEXT: [[VECEXT5:%.*]] = extractelement <4 x i32> [[TMP2]], i64 2 -// CHECK-NEXT: store i32 [[VECEXT5]], ptr [[ARRAYINIT_ELEMENT3]], align 4 +// CHECK-NEXT: store i32 [[VECEXT5]], ptr [[ARRAYINIT_ELEMENT3]], align 1 // CHECK-NEXT: [[ARRAYINIT_ELEMENT6:%.*]] = getelementptr inbounds i32, ptr [[LEGS]], i32 3 // CHECK-NEXT: [[LEGSTATE7:%.*]] = getelementptr inbounds nuw [[STRUCT_DOGGO]], ptr [[D1]], i32 0, i32 0 -// CHECK-NEXT: [[TMP3:%.*]] = load <4 x i32>, ptr [[LEGSTATE7]], align 16 +// CHECK-NEXT: [[TMP3:%.*]] = load <4 x i32>, ptr [[LEGSTATE7]], align 1 // CHECK-NEXT: [[VECEXT8:%.*]] = extractelement <4 x i32> [[TMP3]], i64 3 -// CHECK-NEXT: store i32 [[VECEXT8]], ptr [[ARRAYINIT_ELEMENT6]], align 4 +// CHECK-NEXT: store i32 [[VECEXT8]], ptr [[ARRAYINIT_ELEMENT6]], align 1 // CHECK-NEXT: [[STATE:%.*]] = getelementptr inbounds nuw [[STRUCT_ANIMALBITS]], ptr [[AGG_RESULT]], i32 0, i32 1 // CHECK-NEXT: [[TAILSTATE:%.*]] = getelementptr inbounds nuw [[STRUCT_DOGGO]], ptr [[D1]], i32 0, i32 1 -// CHECK-NEXT: [[TMP4:%.*]] = load i32, ptr [[TAILSTATE]], align 16 -// CHECK-NEXT: store i32 [[TMP4]], ptr [[STATE]], align 16 +// CHECK-NEXT: [[TMP4:%.*]] = load i32, ptr [[TAILSTATE]], align 1 +// CHECK-NEXT: store i32 [[TMP4]], ptr [[STATE]], align 1 // CHECK-NEXT: [[COUNTER:%.*]] = getelementptr inbounds nuw [[STRUCT_ANIMALBITS]], ptr [[AGG_RESULT]], i32 0, i32 2 // CHECK-NEXT: [[HAIRCOUNT:%.*]] = getelementptr inbounds nuw [[STRUCT_DOGGO]], ptr [[D1]], i32 0, i32 2 -// CHECK-NEXT: [[TMP5:%.*]] = load float, ptr [[HAIRCOUNT]], align 4 +// CHECK-NEXT: [[TMP5:%.*]] = load float, ptr [[HAIRCOUNT]], align 1 // CHECK-NEXT: [[CONV:%.*]] = fptosi float [[TMP5]] to i64 -// CHECK-NEXT: store i64 [[CONV]], ptr [[COUNTER]], align 8 +// CHECK-NEXT: store i64 [[CONV]], ptr [[COUNTER]], align 1 // CHECK-NEXT: [[LEFTDIR:%.*]] = getelementptr inbounds nuw [[STRUCT_ANIMALBITS]], ptr [[AGG_RESULT]], i32 0, i32 3 // CHECK-NEXT: [[EARDIRECTION:%.*]] = getelementptr inbounds nuw [[STRUCT_DOGGO]], ptr [[D1]], i32 0, i32 3 // CHECK-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds nuw [2 x <4 x float>], ptr [[EARDIRECTION]], i32 0, i32 0 -// CHECK-NEXT: [[TMP6:%.*]] = load <4 x float>, ptr [[ARRAYIDX]], align 16 +// CHECK-NEXT: [[TMP6:%.*]] = load <4 x float>, ptr [[ARRAYIDX]], align 1 // CHECK-NEXT: [[VECEXT9:%.*]] = extractelement <4 x float> [[TMP6]], i64 0 // CHECK-NEXT: [[VECINIT:%.*]] = insertelement <4 x float> poison, float [[VECEXT9]], i32 0 // CHECK-NEXT: [[EARDIRECTION10:%.*]] = getelementptr inbounds nuw [[STRUCT_DOGGO]], ptr [[D1]], i32 0, i32 3 // CHECK-NEXT: [[ARRAYIDX11:%.*]] = getelementptr inbounds nuw [2 x <4 x float>], ptr [[EARDIRECTION10]], i32 0, i32 0 -// CHECK-NEXT: [[TMP7:%.*]] = load <4 x float>, ptr [[ARRAYIDX11]], align 16 +// CHECK-NEXT: [[TMP7:%.*]] = load <4 x float>, ptr [[ARRAYIDX11]], align 1 // CHECK-NEXT: [[VECEXT12:%.*]] = extractelement <4 x float> [[TMP7]], i64 1 // CHECK-NEXT: [[VECINIT13:%.*]] = insertelement <4 x float> [[VECINIT]], float [[VECEXT12]], i32 1 // CHECK-NEXT: [[EARDIRECTION14:%.*]] = getelementptr inbounds nuw [[STRUCT_DOGGO]], ptr [[D1]], i32 0, i32 3 // CHECK-NEXT: [[ARRAYIDX15:%.*]] = getelementptr inbounds nuw [2 x <4 x float>], ptr [[EARDIRECTION14]], i32 0, i32 0 -// CHECK-NEXT: [[TMP8:%.*]] = load <4 x float>, ptr [[ARRAYIDX15]], align 16 +// CHECK-NEXT: [[TMP8:%.*]] = load <4 x float>, ptr [[ARRAYIDX15]], align 1 // CHECK-NEXT: [[VECEXT16:%.*]] = extractelement <4 x float> [[TMP8]], i64 2 // CHECK-NEXT: [[VECINIT17:%.*]] = insertelement <4 x float> [[VECINIT13]], float [[VECEXT16]], i32 2 // CHECK-NEXT: [[EARDIRECTION18:%.*]] = getelementptr inbounds nuw [[STRUCT_DOGGO]], ptr [[D1]], i32 0, i32 3 // CHECK-NEXT: [[ARRAYIDX19:%.*]] = getelementptr inbounds nuw [2 x <4 x float>], ptr [[EARDIRECTION18]], i32 0, i32 0 -// CHECK-NEXT: [[TMP9:%.*]] = load <4 x float>, ptr [[ARRAYIDX19]], align 16 +// CHECK-NEXT: [[TMP9:%.*]] = load <4 x float>, ptr [[ARRAYIDX19]], align 1 // CHECK-NEXT: [[VECEXT20:%.*]] = extractelement <4 x float> [[TMP9]], i64 3 // CHECK-NEXT: [[VECINIT21:%.*]] = insertelement <4 x float> [[VECINIT17]], float [[VECEXT20]], i32 3 -// CHECK-NEXT: store <4 x float> [[VECINIT21]], ptr [[LEFTDIR]], align 16 +// CHECK-NEXT: store <4 x float> [[VECINIT21]], ptr [[LEFTDIR]], align 1 // CHECK-NEXT: [[RIGHTDIR:%.*]] = getelementptr inbounds nuw [[STRUCT_ANIMALBITS]], ptr [[AGG_RESULT]], i32 0, i32 4 // CHECK-NEXT: [[EARDIRECTION22:%.*]] = getelementptr inbounds nuw [[STRUCT_DOGGO]], ptr [[D1]], i32 0, i32 3 // CHECK-NEXT: [[ARRAYIDX23:%.*]] = getelementptr inbounds nuw [2 x <4 x float>], ptr [[EARDIRECTION22]], i32 0, i32 1 -// CHECK-NEXT: [[TMP10:%.*]] = load <4 x float>, ptr [[ARRAYIDX23]], align 16 +// CHECK-NEXT: [[TMP10:%.*]] = load <4 x float>, ptr [[ARRAYIDX23]], align 1 // CHECK-NEXT: [[VECEXT24:%.*]] = extractelement <4 x float> [[TMP10]], i64 0 // CHECK-NEXT: [[VECINIT25:%.*]] = insertelement <4 x float> poison, float [[VECEXT24]], i32 0 // CHECK-NEXT: [[EARDIRECTION26:%.*]] = getelementptr inbounds nuw [[STRUCT_DOGGO]], ptr [[D1]], i32 0, i32 3 // CHECK-NEXT: [[ARRAYIDX27:%.*]] = getelementptr inbounds nuw [2 x <4 x float>], ptr [[EARDIRECTION26]], i32 0, i32 1 -// CHECK-NEXT: [[TMP11:%.*]] = load <4 x float>, ptr [[ARRAYIDX27]], align 16 +// CHECK-NEXT: [[TMP11:%.*]] = load <4 x float>, ptr [[ARRAYIDX27]], align 1 // CHECK-NEXT: [[VECEXT28:%.*]] = extractelement <4 x float> [[TMP11]], i64 1 // CHECK-NEXT: [[VECINIT29:%.*]] = insertelement <4 x float> [[VECINIT25]], float [[VECEXT28]], i32 1 // CHECK-NEXT: [[EARDIRECTION30:%.*]] = getelementptr inbounds nuw [[STRUCT_DOGGO]], ptr [[D1]], i32 0, i32 3 // CHECK-NEXT: [[ARRAYIDX31:%.*]] = getelementptr inbounds nuw [2 x <4 x float>], ptr [[EARDIRECTION30]], i32 0, i32 1 -// CHECK-NEXT: [[TMP12:%.*]] = load <4 x float>, ptr [[ARRAYIDX31]], align 16 +// CHECK-NEXT: [[TMP12:%.*]] = load <4 x float>, ptr [[ARRAYIDX31]], align 1 // CHECK-NEXT: [[VECEXT32:%.*]] = extractelement <4 x float> [[TMP12]], i64 2 // CHECK-NEXT: [[VECINIT33:%.*]] = insertelement <4 x float> [[VECINIT29]], float [[VECEXT32]], i32 2 // CHECK-NEXT: [[EARDIRECTION34:%.*]] = getelementptr inbounds nuw [[STRUCT_DOGGO]], ptr [[D1]], i32 0, i32 3 // CHECK-NEXT: [[ARRAYIDX35:%.*]] = getelementptr inbounds nuw [2 x <4 x float>], ptr [[EARDIRECTION34]], i32 0, i32 1 -// CHECK-NEXT: [[TMP13:%.*]] = load <4 x float>, ptr [[ARRAYIDX35]], align 16 +// CHECK-NEXT: [[TMP13:%.*]] = load <4 x float>, ptr [[ARRAYIDX35]], align 1 // CHECK-NEXT: [[VECEXT36:%.*]] = extractelement <4 x float> [[TMP13]], i64 3 // CHECK-NEXT: [[VECINIT37:%.*]] = insertelement <4 x float> [[VECINIT33]], float [[VECEXT36]], i32 3 -// CHECK-NEXT: store <4 x float> [[VECINIT37]], ptr [[RIGHTDIR]], align 16 +// CHECK-NEXT: store <4 x float> [[VECINIT37]], ptr [[RIGHTDIR]], align 1 // CHECK-NEXT: ret void // AnimalBits case8(Doggo D1) { @@ -308,413 +308,413 @@ AnimalBits case8(Doggo D1) { // structures from different layouts, different component groupings, with no // top-level bracing separation. // CHECK-LABEL: define void @_Z5case95Doggo10AnimalBits( -// CHECK-SAME: ptr dead_on_unwind noalias writable sret([[STRUCT_ZOO:%.*]]) align 16 [[AGG_RESULT:%.*]], ptr noundef byval([[STRUCT_DOGGO:%.*]]) align 16 [[D1:%.*]], ptr noundef byval([[STRUCT_ANIMALBITS:%.*]]) align 16 [[A1:%.*]]) #[[ATTR0]] { +// CHECK-SAME: ptr dead_on_unwind noalias writable sret([[STRUCT_ZOO:%.*]]) align 1 [[AGG_RESULT:%.*]], ptr noundef byval([[STRUCT_DOGGO:%.*]]) align 1 [[D1:%.*]], ptr noundef byval([[STRUCT_ANIMALBITS:%.*]]) align 1 [[A1:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] // CHECK-NEXT: [[DOGS:%.*]] = getelementptr inbounds nuw [[STRUCT_ZOO]], ptr [[AGG_RESULT]], i32 0, i32 0 // CHECK-NEXT: [[LEGSTATE:%.*]] = getelementptr inbounds nuw [[STRUCT_DOGGO]], ptr [[DOGS]], i32 0, i32 0 // CHECK-NEXT: [[LEGSTATE1:%.*]] = getelementptr inbounds nuw [[STRUCT_DOGGO]], ptr [[D1]], i32 0, i32 0 -// CHECK-NEXT: [[TMP0:%.*]] = load <4 x i32>, ptr [[LEGSTATE1]], align 16 +// CHECK-NEXT: [[TMP0:%.*]] = load <4 x i32>, ptr [[LEGSTATE1]], align 1 // CHECK-NEXT: [[VECEXT:%.*]] = extractelement <4 x i32> [[TMP0]], i64 0 // CHECK-NEXT: [[VECINIT:%.*]] = insertelement <4 x i32> poison, i32 [[VECEXT]], i32 0 // CHECK-NEXT: [[LEGSTATE2:%.*]] = getelementptr inbounds nuw [[STRUCT_DOGGO]], ptr [[D1]], i32 0, i32 0 -// CHECK-NEXT: [[TMP1:%.*]] = load <4 x i32>, ptr [[LEGSTATE2]], align 16 +// CHECK-NEXT: [[TMP1:%.*]] = load <4 x i32>, ptr [[LEGSTATE2]], align 1 // CHECK-NEXT: [[VECEXT3:%.*]] = extractelement <4 x i32> [[TMP1]], i64 1 // CHECK-NEXT: [[VECINIT4:%.*]] = insertelement <4 x i32> [[VECINIT]], i32 [[VECEXT3]], i32 1 // CHECK-NEXT: [[LEGSTATE5:%.*]] = getelementptr inbounds nuw [[STRUCT_DOGGO]], ptr [[D1]], i32 0, i32 0 -// CHECK-NEXT: [[TMP2:%.*]] = load <4 x i32>, ptr [[LEGSTATE5]], align 16 +// CHECK-NEXT: [[TMP2:%.*]] = load <4 x i32>, ptr [[LEGSTATE5]], align 1 // CHECK-NEXT: [[VECEXT6:%.*]] = extractelement <4 x i32> [[TMP2]], i64 2 // CHECK-NEXT: [[VECINIT7:%.*]] = insertelement <4 x i32> [[VECINIT4]], i32 [[VECEXT6]], i32 2 // CHECK-NEXT: [[LEGSTATE8:%.*]] = getelementptr inbounds nuw [[STRUCT_DOGGO]], ptr [[D1]], i32 0, i32 0 -// CHECK-NEXT: [[TMP3:%.*]] = load <4 x i32>, ptr [[LEGSTATE8]], align 16 +// CHECK-NEXT: [[TMP3:%.*]] = load <4 x i32>, ptr [[LEGSTATE8]], align 1 // CHECK-NEXT: [[VECEXT9:%.*]] = extractelement <4 x i32> [[TMP3]], i64 3 // CHECK-NEXT: [[VECINIT10:%.*]] = insertelement <4 x i32> [[VECINIT7]], i32 [[VECEXT9]], i32 3 -// CHECK-NEXT: store <4 x i32> [[VECINIT10]], ptr [[LEGSTATE]], align 16 +// CHECK-NEXT: store <4 x i32> [[VECINIT10]], ptr [[LEGSTATE]], align 1 // CHECK-NEXT: [[TAILSTATE:%.*]] = getelementptr inbounds nuw [[STRUCT_DOGGO]], ptr [[DOGS]], i32 0, i32 1 // CHECK-NEXT: [[TAILSTATE11:%.*]] = getelementptr inbounds nuw [[STRUCT_DOGGO]], ptr [[D1]], i32 0, i32 1 -// CHECK-NEXT: [[TMP4:%.*]] = load i32, ptr [[TAILSTATE11]], align 16 -// CHECK-NEXT: store i32 [[TMP4]], ptr [[TAILSTATE]], align 16 +// CHECK-NEXT: [[TMP4:%.*]] = load i32, ptr [[TAILSTATE11]], align 1 +// CHECK-NEXT: store i32 [[TMP4]], ptr [[TAILSTATE]], align 1 // CHECK-NEXT: [[HAIRCOUNT:%.*]] = getelementptr inbounds nuw [[STRUCT_DOGGO]], ptr [[DOGS]], i32 0, i32 2 // CHECK-NEXT: [[HAIRCOUNT12:%.*]] = getelementptr inbounds nuw [[STRUCT_DOGGO]], ptr [[D1]], i32 0, i32 2 -// CHECK-NEXT: [[TMP5:%.*]] = load float, ptr [[HAIRCOUNT12]], align 4 -// CHECK-NEXT: store float [[TMP5]], ptr [[HAIRCOUNT]], align 4 +// CHECK-NEXT: [[TMP5:%.*]] = load float, ptr [[HAIRCOUNT12]], align 1 +// CHECK-NEXT: store float [[TMP5]], ptr [[HAIRCOUNT]], align 1 // CHECK-NEXT: [[EARDIRECTION:%.*]] = getelementptr inbounds nuw [[STRUCT_DOGGO]], ptr [[DOGS]], i32 0, i32 3 // CHECK-NEXT: [[EARDIRECTION13:%.*]] = getelementptr inbounds nuw [[STRUCT_DOGGO]], ptr [[D1]], i32 0, i32 3 // CHECK-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds nuw [2 x <4 x float>], ptr [[EARDIRECTION13]], i32 0, i32 0 -// CHECK-NEXT: [[TMP6:%.*]] = load <4 x float>, ptr [[ARRAYIDX]], align 16 +// CHECK-NEXT: [[TMP6:%.*]] = load <4 x float>, ptr [[ARRAYIDX]], align 1 // CHECK-NEXT: [[VECEXT14:%.*]] = extractelement <4 x float> [[TMP6]], i64 0 // CHECK-NEXT: [[VECINIT15:%.*]] = insertelement <4 x float> poison, float [[VECEXT14]], i32 0 // CHECK-NEXT: [[EARDIRECTION16:%.*]] = getelementptr inbounds nuw [[STRUCT_DOGGO]], ptr [[D1]], i32 0, i32 3 // CHECK-NEXT: [[ARRAYIDX17:%.*]] = getelementptr inbounds nuw [2 x <4 x float>], ptr [[EARDIRECTION16]], i32 0, i32 0 -// CHECK-NEXT: [[TMP7:%.*]] = load <4 x float>, ptr [[ARRAYIDX17]], align 16 +// CHECK-NEXT: [[TMP7:%.*]] = load <4 x float>, ptr [[ARRAYIDX17]], align 1 // CHECK-NEXT: [[VECEXT18:%.*]] = extractelement <4 x float> [[TMP7]], i64 1 // CHECK-NEXT: [[VECINIT19:%.*]] = insertelement <4 x float> [[VECINIT15]], float [[VECEXT18]], i32 1 // CHECK-NEXT: [[EARDIRECTION20:%.*]] = getelementptr inbounds nuw [[STRUCT_DOGGO]], ptr [[D1]], i32 0, i32 3 // CHECK-NEXT: [[ARRAYIDX21:%.*]] = getelementptr inbounds nuw [2 x <4 x float>], ptr [[EARDIRECTION20]], i32 0, i32 0 -// CHECK-NEXT: [[TMP8:%.*]] = load <4 x float>, ptr [[ARRAYIDX21]], align 16 +// CHECK-NEXT: [[TMP8:%.*]] = load <4 x float>, ptr [[ARRAYIDX21]], align 1 // CHECK-NEXT: [[VECEXT22:%.*]] = extractelement <4 x float> [[TMP8]], i64 2 // CHECK-NEXT: [[VECINIT23:%.*]] = insertelement <4 x float> [[VECINIT19]], float [[VECEXT22]], i32 2 // CHECK-NEXT: [[EARDIRECTION24:%.*]] = getelementptr inbounds nuw [[STRUCT_DOGGO]], ptr [[D1]], i32 0, i32 3 // CHECK-NEXT: [[ARRAYIDX25:%.*]] = getelementptr inbounds nuw [2 x <4 x float>], ptr [[EARDIRECTION24]], i32 0, i32 0 -// CHECK-NEXT: [[TMP9:%.*]] = load <4 x float>, ptr [[ARRAYIDX25]], align 16 +// CHECK-NEXT: [[TMP9:%.*]] = load <4 x float>, ptr [[ARRAYIDX25]], align 1 // CHECK-NEXT: [[VECEXT26:%.*]] = extractelement <4 x float> [[TMP9]], i64 3 // CHECK-NEXT: [[VECINIT27:%.*]] = insertelement <4 x float> [[VECINIT23]], float [[VECEXT26]], i32 3 -// CHECK-NEXT: store <4 x float> [[VECINIT27]], ptr [[EARDIRECTION]], align 16 +// CHECK-NEXT: store <4 x float> [[VECINIT27]], ptr [[EARDIRECTION]], align 1 // CHECK-NEXT: [[ARRAYINIT_ELEMENT:%.*]] = getelementptr inbounds <4 x float>, ptr [[EARDIRECTION]], i32 1 // CHECK-NEXT: [[EARDIRECTION28:%.*]] = getelementptr inbounds nuw [[STRUCT_DOGGO]], ptr [[D1]], i32 0, i32 3 // CHECK-NEXT: [[ARRAYIDX29:%.*]] = getelementptr inbounds nuw [2 x <4 x float>], ptr [[EARDIRECTION28]], i32 0, i32 1 -// CHECK-NEXT: [[TMP10:%.*]] = load <4 x float>, ptr [[ARRAYIDX29]], align 16 +// CHECK-NEXT: [[TMP10:%.*]] = load <4 x float>, ptr [[ARRAYIDX29]], align 1 // CHECK-NEXT: [[VECEXT30:%.*]] = extractelement <4 x float> [[TMP10]], i64 0 // CHECK-NEXT: [[VECINIT31:%.*]] = insertelement <4 x float> poison, float [[VECEXT30]], i32 0 // CHECK-NEXT: [[EARDIRECTION32:%.*]] = getelementptr inbounds nuw [[STRUCT_DOGGO]], ptr [[D1]], i32 0, i32 3 // CHECK-NEXT: [[ARRAYIDX33:%.*]] = getelementptr inbounds nuw [2 x <4 x float>], ptr [[EARDIRECTION32]], i32 0, i32 1 -// CHECK-NEXT: [[TMP11:%.*]] = load <4 x float>, ptr [[ARRAYIDX33]], align 16 +// CHECK-NEXT: [[TMP11:%.*]] = load <4 x float>, ptr [[ARRAYIDX33]], align 1 // CHECK-NEXT: [[VECEXT34:%.*]] = extractelement <4 x float> [[TMP11]], i64 1 // CHECK-NEXT: [[VECINIT35:%.*]] = insertelement <4 x float> [[VECINIT31]], float [[VECEXT34]], i32 1 // CHECK-NEXT: [[EARDIRECTION36:%.*]] = getelementptr inbounds nuw [[STRUCT_DOGGO]], ptr [[D1]], i32 0, i32 3 // CHECK-NEXT: [[ARRAYIDX37:%.*]] = getelementptr inbounds nuw [2 x <4 x float>], ptr [[EARDIRECTION36]], i32 0, i32 1 -// CHECK-NEXT: [[TMP12:%.*]] = load <4 x float>, ptr [[ARRAYIDX37]], align 16 +// CHECK-NEXT: [[TMP12:%.*]] = load <4 x float>, ptr [[ARRAYIDX37]], align 1 // CHECK-NEXT: [[VECEXT38:%.*]] = extractelement <4 x float> [[TMP12]], i64 2 // CHECK-NEXT: [[VECINIT39:%.*]] = insertelement <4 x float> [[VECINIT35]], float [[VECEXT38]], i32 2 // CHECK-NEXT: [[EARDIRECTION40:%.*]] = getelementptr inbounds nuw [[STRUCT_DOGGO]], ptr [[D1]], i32 0, i32 3 // CHECK-NEXT: [[ARRAYIDX41:%.*]] = getelementptr inbounds nuw [2 x <4 x float>], ptr [[EARDIRECTION40]], i32 0, i32 1 -// CHECK-NEXT: [[TMP13:%.*]] = load <4 x float>, ptr [[ARRAYIDX41]], align 16 +// CHECK-NEXT: [[TMP13:%.*]] = load <4 x float>, ptr [[ARRAYIDX41]], align 1 // CHECK-NEXT: [[VECEXT42:%.*]] = extractelement <4 x float> [[TMP13]], i64 3 // CHECK-NEXT: [[VECINIT43:%.*]] = insertelement <4 x float> [[VECINIT39]], float [[VECEXT42]], i32 3 -// CHECK-NEXT: store <4 x float> [[VECINIT43]], ptr [[ARRAYINIT_ELEMENT]], align 16 +// CHECK-NEXT: store <4 x float> [[VECINIT43]], ptr [[ARRAYINIT_ELEMENT]], align 1 // CHECK-NEXT: [[ARRAYINIT_ELEMENT44:%.*]] = getelementptr inbounds [[STRUCT_DOGGO]], ptr [[DOGS]], i32 1 // CHECK-NEXT: [[LEGSTATE45:%.*]] = getelementptr inbounds nuw [[STRUCT_DOGGO]], ptr [[ARRAYINIT_ELEMENT44]], i32 0, i32 0 // CHECK-NEXT: [[LEGS:%.*]] = getelementptr inbounds nuw [[STRUCT_ANIMALBITS]], ptr [[A1]], i32 0, i32 0 // CHECK-NEXT: [[ARRAYIDX46:%.*]] = getelementptr inbounds nuw [4 x i32], ptr [[LEGS]], i32 0, i32 0 -// CHECK-NEXT: [[TMP14:%.*]] = load i32, ptr [[ARRAYIDX46]], align 16 +// CHECK-NEXT: [[TMP14:%.*]] = load i32, ptr [[ARRAYIDX46]], align 1 // CHECK-NEXT: [[VECINIT47:%.*]] = insertelement <4 x i32> poison, i32 [[TMP14]], i32 0 // CHECK-NEXT: [[LEGS48:%.*]] = getelementptr inbounds nuw [[STRUCT_ANIMALBITS]], ptr [[A1]], i32 0, i32 0 // CHECK-NEXT: [[ARRAYIDX49:%.*]] = getelementptr inbounds nuw [4 x i32], ptr [[LEGS48]], i32 0, i32 1 -// CHECK-NEXT: [[TMP15:%.*]] = load i32, ptr [[ARRAYIDX49]], align 4 +// CHECK-NEXT: [[TMP15:%.*]] = load i32, ptr [[ARRAYIDX49]], align 1 // CHECK-NEXT: [[VECINIT50:%.*]] = insertelement <4 x i32> [[VECINIT47]], i32 [[TMP15]], i32 1 // CHECK-NEXT: [[LEGS51:%.*]] = getelementptr inbounds nuw [[STRUCT_ANIMALBITS]], ptr [[A1]], i32 0, i32 0 // CHECK-NEXT: [[ARRAYIDX52:%.*]] = getelementptr inbounds nuw [4 x i32], ptr [[LEGS51]], i32 0, i32 2 -// CHECK-NEXT: [[TMP16:%.*]] = load i32, ptr [[ARRAYIDX52]], align 8 +// CHECK-NEXT: [[TMP16:%.*]] = load i32, ptr [[ARRAYIDX52]], align 1 // CHECK-NEXT: [[VECINIT53:%.*]] = insertelement <4 x i32> [[VECINIT50]], i32 [[TMP16]], i32 2 // CHECK-NEXT: [[LEGS54:%.*]] = getelementptr inbounds nuw [[STRUCT_ANIMALBITS]], ptr [[A1]], i32 0, i32 0 // CHECK-NEXT: [[ARRAYIDX55:%.*]] = getelementptr inbounds nuw [4 x i32], ptr [[LEGS54]], i32 0, i32 3 -// CHECK-NEXT: [[TMP17:%.*]] = load i32, ptr [[ARRAYIDX55]], align 4 +// CHECK-NEXT: [[TMP17:%.*]] = load i32, ptr [[ARRAYIDX55]], align 1 // CHECK-NEXT: [[VECINIT56:%.*]] = insertelement <4 x i32> [[VECINIT53]], i32 [[TMP17]], i32 3 -// CHECK-NEXT: store <4 x i32> [[VECINIT56]], ptr [[LEGSTATE45]], align 16 +// CHECK-NEXT: store <4 x i32> [[VECINIT56]], ptr [[LEGSTATE45]], align 1 // CHECK-NEXT: [[TAILSTATE57:%.*]] = getelementptr inbounds nuw [[STRUCT_DOGGO]], ptr [[ARRAYINIT_ELEMENT44]], i32 0, i32 1 // CHECK-NEXT: [[STATE:%.*]] = getelementptr inbounds nuw [[STRUCT_ANIMALBITS]], ptr [[A1]], i32 0, i32 1 -// CHECK-NEXT: [[TMP18:%.*]] = load i32, ptr [[STATE]], align 16 -// CHECK-NEXT: store i32 [[TMP18]], ptr [[TAILSTATE57]], align 16 +// CHECK-NEXT: [[TMP18:%.*]] = load i32, ptr [[STATE]], align 1 +// CHECK-NEXT: store i32 [[TMP18]], ptr [[TAILSTATE57]], align 1 // CHECK-NEXT: [[HAIRCOUNT58:%.*]] = getelementptr inbounds nuw [[STRUCT_DOGGO]], ptr [[ARRAYINIT_ELEMENT44]], i32 0, i32 2 // CHECK-NEXT: [[COUNTER:%.*]] = getelementptr inbounds nuw [[STRUCT_ANIMALBITS]], ptr [[A1]], i32 0, i32 2 -// CHECK-NEXT: [[TMP19:%.*]] = load i64, ptr [[COUNTER]], align 8 +// CHECK-NEXT: [[TMP19:%.*]] = load i64, ptr [[COUNTER]], align 1 // CHECK-NEXT: [[CONV:%.*]] = sitofp i64 [[TMP19]] to float -// CHECK-NEXT: store float [[CONV]], ptr [[HAIRCOUNT58]], align 4 +// CHECK-NEXT: store float [[CONV]], ptr [[HAIRCOUNT58]], align 1 // CHECK-NEXT: [[EARDIRECTION59:%.*]] = getelementptr inbounds nuw [[STRUCT_DOGGO]], ptr [[ARRAYINIT_ELEMENT44]], i32 0, i32 3 // CHECK-NEXT: [[LEFTDIR:%.*]] = getelementptr inbounds nuw [[STRUCT_ANIMALBITS]], ptr [[A1]], i32 0, i32 3 -// CHECK-NEXT: [[TMP20:%.*]] = load <4 x float>, ptr [[LEFTDIR]], align 16 +// CHECK-NEXT: [[TMP20:%.*]] = load <4 x float>, ptr [[LEFTDIR]], align 1 // CHECK-NEXT: [[VECEXT60:%.*]] = extractelement <4 x float> [[TMP20]], i64 0 // CHECK-NEXT: [[VECINIT61:%.*]] = insertelement <4 x float> poison, float [[VECEXT60]], i32 0 // CHECK-NEXT: [[LEFTDIR62:%.*]] = getelementptr inbounds nuw [[STRUCT_ANIMALBITS]], ptr [[A1]], i32 0, i32 3 -// CHECK-NEXT: [[TMP21:%.*]] = load <4 x float>, ptr [[LEFTDIR62]], align 16 +// CHECK-NEXT: [[TMP21:%.*]] = load <4 x float>, ptr [[LEFTDIR62]], align 1 // CHECK-NEXT: [[VECEXT63:%.*]] = extractelement <4 x float> [[TMP21]], i64 1 // CHECK-NEXT: [[VECINIT64:%.*]] = insertelement <4 x float> [[VECINIT61]], float [[VECEXT63]], i32 1 // CHECK-NEXT: [[LEFTDIR65:%.*]] = getelementptr inbounds nuw [[STRUCT_ANIMALBITS]], ptr [[A1]], i32 0, i32 3 -// CHECK-NEXT: [[TMP22:%.*]] = load <4 x float>, ptr [[LEFTDIR65]], align 16 +// CHECK-NEXT: [[TMP22:%.*]] = load <4 x float>, ptr [[LEFTDIR65]], align 1 // CHECK-NEXT: [[VECEXT66:%.*]] = extractelement <4 x float> [[TMP22]], i64 2 // CHECK-NEXT: [[VECINIT67:%.*]] = insertelement <4 x float> [[VECINIT64]], float [[VECEXT66]], i32 2 // CHECK-NEXT: [[LEFTDIR68:%.*]] = getelementptr inbounds nuw [[STRUCT_ANIMALBITS]], ptr [[A1]], i32 0, i32 3 -// CHECK-NEXT: [[TMP23:%.*]] = load <4 x float>, ptr [[LEFTDIR68]], align 16 +// CHECK-NEXT: [[TMP23:%.*]] = load <4 x float>, ptr [[LEFTDIR68]], align 1 // CHECK-NEXT: [[VECEXT69:%.*]] = extractelement <4 x float> [[TMP23]], i64 3 // CHECK-NEXT: [[VECINIT70:%.*]] = insertelement <4 x float> [[VECINIT67]], float [[VECEXT69]], i32 3 -// CHECK-NEXT: store <4 x float> [[VECINIT70]], ptr [[EARDIRECTION59]], align 16 +// CHECK-NEXT: store <4 x float> [[VECINIT70]], ptr [[EARDIRECTION59]], align 1 // CHECK-NEXT: [[ARRAYINIT_ELEMENT71:%.*]] = getelementptr inbounds <4 x float>, ptr [[EARDIRECTION59]], i32 1 // CHECK-NEXT: [[RIGHTDIR:%.*]] = getelementptr inbounds nuw [[STRUCT_ANIMALBITS]], ptr [[A1]], i32 0, i32 4 -// CHECK-NEXT: [[TMP24:%.*]] = load <4 x float>, ptr [[RIGHTDIR]], align 16 +// CHECK-NEXT: [[TMP24:%.*]] = load <4 x float>, ptr [[RIGHTDIR]], align 1 // CHECK-NEXT: [[VECEXT72:%.*]] = extractelement <4 x float> [[TMP24]], i64 0 // CHECK-NEXT: [[VECINIT73:%.*]] = insertelement <4 x float> poison, float [[VECEXT72]], i32 0 // CHECK-NEXT: [[RIGHTDIR74:%.*]] = getelementptr inbounds nuw [[STRUCT_ANIMALBITS]], ptr [[A1]], i32 0, i32 4 -// CHECK-NEXT: [[TMP25:%.*]] = load <4 x float>, ptr [[RIGHTDIR74]], align 16 +// CHECK-NEXT: [[TMP25:%.*]] = load <4 x float>, ptr [[RIGHTDIR74]], align 1 // CHECK-NEXT: [[VECEXT75:%.*]] = extractelement <4 x float> [[TMP25]], i64 1 // CHECK-NEXT: [[VECINIT76:%.*]] = insertelement <4 x float> [[VECINIT73]], float [[VECEXT75]], i32 1 // CHECK-NEXT: [[RIGHTDIR77:%.*]] = getelementptr inbounds nuw [[STRUCT_ANIMALBITS]], ptr [[A1]], i32 0, i32 4 -// CHECK-NEXT: [[TMP26:%.*]] = load <4 x float>, ptr [[RIGHTDIR77]], align 16 +// CHECK-NEXT: [[TMP26:%.*]] = load <4 x float>, ptr [[RIGHTDIR77]], align 1 // CHECK-NEXT: [[VECEXT78:%.*]] = extractelement <4 x float> [[TMP26]], i64 2 // CHECK-NEXT: [[VECINIT79:%.*]] = insertelement <4 x float> [[VECINIT76]], float [[VECEXT78]], i32 2 // CHECK-NEXT: [[RIGHTDIR80:%.*]] = getelementptr inbounds nuw [[STRUCT_ANIMALBITS]], ptr [[A1]], i32 0, i32 4 -// CHECK-NEXT: [[TMP27:%.*]] = load <4 x float>, ptr [[RIGHTDIR80]], align 16 +// CHECK-NEXT: [[TMP27:%.*]] = load <4 x float>, ptr [[RIGHTDIR80]], align 1 // CHECK-NEXT: [[VECEXT81:%.*]] = extractelement <4 x float> [[TMP27]], i64 3 // CHECK-NEXT: [[VECINIT82:%.*]] = insertelement <4 x float> [[VECINIT79]], float [[VECEXT81]], i32 3 -// CHECK-NEXT: store <4 x float> [[VECINIT82]], ptr [[ARRAYINIT_ELEMENT71]], align 16 +// CHECK-NEXT: store <4 x float> [[VECINIT82]], ptr [[ARRAYINIT_ELEMENT71]], align 1 // CHECK-NEXT: [[CATS:%.*]] = getelementptr inbounds nuw [[STRUCT_ZOO]], ptr [[AGG_RESULT]], i32 0, i32 1 // CHECK-NEXT: [[LEGS83:%.*]] = getelementptr inbounds nuw [[STRUCT_KITTEH:%.*]], ptr [[CATS]], i32 0, i32 0 // CHECK-NEXT: [[LEGSTATE84:%.*]] = getelementptr inbounds nuw [[STRUCT_DOGGO]], ptr [[D1]], i32 0, i32 0 -// CHECK-NEXT: [[TMP28:%.*]] = load <4 x i32>, ptr [[LEGSTATE84]], align 16 +// CHECK-NEXT: [[TMP28:%.*]] = load <4 x i32>, ptr [[LEGSTATE84]], align 1 // CHECK-NEXT: [[VECEXT85:%.*]] = extractelement <4 x i32> [[TMP28]], i64 0 // CHECK-NEXT: [[VECINIT86:%.*]] = insertelement <4 x i32> poison, i32 [[VECEXT85]], i32 0 // CHECK-NEXT: [[LEGSTATE87:%.*]] = getelementptr inbounds nuw [[STRUCT_DOGGO]], ptr [[D1]], i32 0, i32 0 -// CHECK-NEXT: [[TMP29:%.*]] = load <4 x i32>, ptr [[LEGSTATE87]], align 16 +// CHECK-NEXT: [[TMP29:%.*]] = load <4 x i32>, ptr [[LEGSTATE87]], align 1 // CHECK-NEXT: [[VECEXT88:%.*]] = extractelement <4 x i32> [[TMP29]], i64 1 // CHECK-NEXT: [[VECINIT89:%.*]] = insertelement <4 x i32> [[VECINIT86]], i32 [[VECEXT88]], i32 1 // CHECK-NEXT: [[LEGSTATE90:%.*]] = getelementptr inbounds nuw [[STRUCT_DOGGO]], ptr [[D1]], i32 0, i32 0 -// CHECK-NEXT: [[TMP30:%.*]] = load <4 x i32>, ptr [[LEGSTATE90]], align 16 +// CHECK-NEXT: [[TMP30:%.*]] = load <4 x i32>, ptr [[LEGSTATE90]], align 1 // CHECK-NEXT: [[VECEXT91:%.*]] = extractelement <4 x i32> [[TMP30]], i64 2 // CHECK-NEXT: [[VECINIT92:%.*]] = insertelement <4 x i32> [[VECINIT89]], i32 [[VECEXT91]], i32 2 // CHECK-NEXT: [[LEGSTATE93:%.*]] = getelementptr inbounds nuw [[STRUCT_DOGGO]], ptr [[D1]], i32 0, i32 0 -// CHECK-NEXT: [[TMP31:%.*]] = load <4 x i32>, ptr [[LEGSTATE93]], align 16 +// CHECK-NEXT: [[TMP31:%.*]] = load <4 x i32>, ptr [[LEGSTATE93]], align 1 // CHECK-NEXT: [[VECEXT94:%.*]] = extractelement <4 x i32> [[TMP31]], i64 3 // CHECK-NEXT: [[VECINIT95:%.*]] = insertelement <4 x i32> [[VECINIT92]], i32 [[VECEXT94]], i32 3 -// CHECK-NEXT: store <4 x i32> [[VECINIT95]], ptr [[LEGS83]], align 16 +// CHECK-NEXT: store <4 x i32> [[VECINIT95]], ptr [[LEGS83]], align 1 // CHECK-NEXT: [[TAILSTATE96:%.*]] = getelementptr inbounds nuw [[STRUCT_KITTEH]], ptr [[CATS]], i32 0, i32 1 // CHECK-NEXT: [[TAILSTATE97:%.*]] = getelementptr inbounds nuw [[STRUCT_DOGGO]], ptr [[D1]], i32 0, i32 1 -// CHECK-NEXT: [[TMP32:%.*]] = load i32, ptr [[TAILSTATE97]], align 16 -// CHECK-NEXT: store i32 [[TMP32]], ptr [[TAILSTATE96]], align 16 +// CHECK-NEXT: [[TMP32:%.*]] = load i32, ptr [[TAILSTATE97]], align 1 +// CHECK-NEXT: store i32 [[TMP32]], ptr [[TAILSTATE96]], align 1 // CHECK-NEXT: [[HAIRCOUNT98:%.*]] = getelementptr inbounds nuw [[STRUCT_KITTEH]], ptr [[CATS]], i32 0, i32 2 // CHECK-NEXT: [[HAIRCOUNT99:%.*]] = getelementptr inbounds nuw [[STRUCT_DOGGO]], ptr [[D1]], i32 0, i32 2 -// CHECK-NEXT: [[TMP33:%.*]] = load float, ptr [[HAIRCOUNT99]], align 4 -// CHECK-NEXT: store float [[TMP33]], ptr [[HAIRCOUNT98]], align 4 +// CHECK-NEXT: [[TMP33:%.*]] = load float, ptr [[HAIRCOUNT99]], align 1 +// CHECK-NEXT: store float [[TMP33]], ptr [[HAIRCOUNT98]], align 1 // CHECK-NEXT: [[CLAWS:%.*]] = getelementptr inbounds nuw [[STRUCT_KITTEH]], ptr [[CATS]], i32 0, i32 3 // CHECK-NEXT: [[EARDIRECTION100:%.*]] = getelementptr inbounds nuw [[STRUCT_DOGGO]], ptr [[D1]], i32 0, i32 3 // CHECK-NEXT: [[ARRAYIDX101:%.*]] = getelementptr inbounds nuw [2 x <4 x float>], ptr [[EARDIRECTION100]], i32 0, i32 0 -// CHECK-NEXT: [[TMP34:%.*]] = load <4 x float>, ptr [[ARRAYIDX101]], align 16 +// CHECK-NEXT: [[TMP34:%.*]] = load <4 x float>, ptr [[ARRAYIDX101]], align 1 // CHECK-NEXT: [[VECEXT102:%.*]] = extractelement <4 x float> [[TMP34]], i64 0 // CHECK-NEXT: [[VECINIT103:%.*]] = insertelement <4 x float> poison, float [[VECEXT102]], i32 0 // CHECK-NEXT: [[EARDIRECTION104:%.*]] = getelementptr inbounds nuw [[STRUCT_DOGGO]], ptr [[D1]], i32 0, i32 3 // CHECK-NEXT: [[ARRAYIDX105:%.*]] = getelementptr inbounds nuw [2 x <4 x float>], ptr [[EARDIRECTION104]], i32 0, i32 0 -// CHECK-NEXT: [[TMP35:%.*]] = load <4 x float>, ptr [[ARRAYIDX105]], align 16 +// CHECK-NEXT: [[TMP35:%.*]] = load <4 x float>, ptr [[ARRAYIDX105]], align 1 // CHECK-NEXT: [[VECEXT106:%.*]] = extractelement <4 x float> [[TMP35]], i64 1 // CHECK-NEXT: [[VECINIT107:%.*]] = insertelement <4 x float> [[VECINIT103]], float [[VECEXT106]], i32 1 // CHECK-NEXT: [[EARDIRECTION108:%.*]] = getelementptr inbounds nuw [[STRUCT_DOGGO]], ptr [[D1]], i32 0, i32 3 // CHECK-NEXT: [[ARRAYIDX109:%.*]] = getelementptr inbounds nuw [2 x <4 x float>], ptr [[EARDIRECTION108]], i32 0, i32 0 -// CHECK-NEXT: [[TMP36:%.*]] = load <4 x float>, ptr [[ARRAYIDX109]], align 16 +// CHECK-NEXT: [[TMP36:%.*]] = load <4 x float>, ptr [[ARRAYIDX109]], align 1 // CHECK-NEXT: [[VECEXT110:%.*]] = extractelement <4 x float> [[TMP36]], i64 2 // CHECK-NEXT: [[VECINIT111:%.*]] = insertelement <4 x float> [[VECINIT107]], float [[VECEXT110]], i32 2 // CHECK-NEXT: [[EARDIRECTION112:%.*]] = getelementptr inbounds nuw [[STRUCT_DOGGO]], ptr [[D1]], i32 0, i32 3 // CHECK-NEXT: [[ARRAYIDX113:%.*]] = getelementptr inbounds nuw [2 x <4 x float>], ptr [[EARDIRECTION112]], i32 0, i32 0 -// CHECK-NEXT: [[TMP37:%.*]] = load <4 x float>, ptr [[ARRAYIDX113]], align 16 +// CHECK-NEXT: [[TMP37:%.*]] = load <4 x float>, ptr [[ARRAYIDX113]], align 1 // CHECK-NEXT: [[VECEXT114:%.*]] = extractelement <4 x float> [[TMP37]], i64 3 // CHECK-NEXT: [[VECINIT115:%.*]] = insertelement <4 x float> [[VECINIT111]], float [[VECEXT114]], i32 3 -// CHECK-NEXT: store <4 x float> [[VECINIT115]], ptr [[CLAWS]], align 16 +// CHECK-NEXT: store <4 x float> [[VECINIT115]], ptr [[CLAWS]], align 1 // CHECK-NEXT: [[ARRAYINIT_ELEMENT116:%.*]] = getelementptr inbounds <4 x float>, ptr [[CLAWS]], i32 1 // CHECK-NEXT: [[EARDIRECTION117:%.*]] = getelementptr inbounds nuw [[STRUCT_DOGGO]], ptr [[D1]], i32 0, i32 3 // CHECK-NEXT: [[ARRAYIDX118:%.*]] = getelementptr inbounds nuw [2 x <4 x float>], ptr [[EARDIRECTION117]], i32 0, i32 1 -// CHECK-NEXT: [[TMP38:%.*]] = load <4 x float>, ptr [[ARRAYIDX118]], align 16 +// CHECK-NEXT: [[TMP38:%.*]] = load <4 x float>, ptr [[ARRAYIDX118]], align 1 // CHECK-NEXT: [[VECEXT119:%.*]] = extractelement <4 x float> [[TMP38]], i64 0 // CHECK-NEXT: [[VECINIT120:%.*]] = insertelement <4 x float> poison, float [[VECEXT119]], i32 0 // CHECK-NEXT: [[EARDIRECTION121:%.*]] = getelementptr inbounds nuw [[STRUCT_DOGGO]], ptr [[D1]], i32 0, i32 3 // CHECK-NEXT: [[ARRAYIDX122:%.*]] = getelementptr inbounds nuw [2 x <4 x float>], ptr [[EARDIRECTION121]], i32 0, i32 1 -// CHECK-NEXT: [[TMP39:%.*]] = load <4 x float>, ptr [[ARRAYIDX122]], align 16 +// CHECK-NEXT: [[TMP39:%.*]] = load <4 x float>, ptr [[ARRAYIDX122]], align 1 // CHECK-NEXT: [[VECEXT123:%.*]] = extractelement <4 x float> [[TMP39]], i64 1 // CHECK-NEXT: [[VECINIT124:%.*]] = insertelement <4 x float> [[VECINIT120]], float [[VECEXT123]], i32 1 // CHECK-NEXT: [[EARDIRECTION125:%.*]] = getelementptr inbounds nuw [[STRUCT_DOGGO]], ptr [[D1]], i32 0, i32 3 // CHECK-NEXT: [[ARRAYIDX126:%.*]] = getelementptr inbounds nuw [2 x <4 x float>], ptr [[EARDIRECTION125]], i32 0, i32 1 -// CHECK-NEXT: [[TMP40:%.*]] = load <4 x float>, ptr [[ARRAYIDX126]], align 16 +// CHECK-NEXT: [[TMP40:%.*]] = load <4 x float>, ptr [[ARRAYIDX126]], align 1 // CHECK-NEXT: [[VECEXT127:%.*]] = extractelement <4 x float> [[TMP40]], i64 2 // CHECK-NEXT: [[VECINIT128:%.*]] = insertelement <4 x float> [[VECINIT124]], float [[VECEXT127]], i32 2 // CHECK-NEXT: [[EARDIRECTION129:%.*]] = getelementptr inbounds nuw [[STRUCT_DOGGO]], ptr [[D1]], i32 0, i32 3 // CHECK-NEXT: [[ARRAYIDX130:%.*]] = getelementptr inbounds nuw [2 x <4 x float>], ptr [[EARDIRECTION129]], i32 0, i32 1 -// CHECK-NEXT: [[TMP41:%.*]] = load <4 x float>, ptr [[ARRAYIDX130]], align 16 +// CHECK-NEXT: [[TMP41:%.*]] = load <4 x float>, ptr [[ARRAYIDX130]], align 1 // CHECK-NEXT: [[VECEXT131:%.*]] = extractelement <4 x float> [[TMP41]], i64 3 // CHECK-NEXT: [[VECINIT132:%.*]] = insertelement <4 x float> [[VECINIT128]], float [[VECEXT131]], i32 3 -// CHECK-NEXT: store <4 x float> [[VECINIT132]], ptr [[ARRAYINIT_ELEMENT116]], align 16 +// CHECK-NEXT: store <4 x float> [[VECINIT132]], ptr [[ARRAYINIT_ELEMENT116]], align 1 // CHECK-NEXT: [[ARRAYINIT_ELEMENT133:%.*]] = getelementptr inbounds [[STRUCT_KITTEH]], ptr [[CATS]], i32 1 // CHECK-NEXT: [[LEGS134:%.*]] = getelementptr inbounds nuw [[STRUCT_KITTEH]], ptr [[ARRAYINIT_ELEMENT133]], i32 0, i32 0 // CHECK-NEXT: [[LEGS135:%.*]] = getelementptr inbounds nuw [[STRUCT_ANIMALBITS]], ptr [[A1]], i32 0, i32 0 // CHECK-NEXT: [[ARRAYIDX136:%.*]] = getelementptr inbounds nuw [4 x i32], ptr [[LEGS135]], i32 0, i32 0 -// CHECK-NEXT: [[TMP42:%.*]] = load i32, ptr [[ARRAYIDX136]], align 16 +// CHECK-NEXT: [[TMP42:%.*]] = load i32, ptr [[ARRAYIDX136]], align 1 // CHECK-NEXT: [[VECINIT137:%.*]] = insertelement <4 x i32> poison, i32 [[TMP42]], i32 0 // CHECK-NEXT: [[LEGS138:%.*]] = getelementptr inbounds nuw [[STRUCT_ANIMALBITS]], ptr [[A1]], i32 0, i32 0 // CHECK-NEXT: [[ARRAYIDX139:%.*]] = getelementptr inbounds nuw [4 x i32], ptr [[LEGS138]], i32 0, i32 1 -// CHECK-NEXT: [[TMP43:%.*]] = load i32, ptr [[ARRAYIDX139]], align 4 +// CHECK-NEXT: [[TMP43:%.*]] = load i32, ptr [[ARRAYIDX139]], align 1 // CHECK-NEXT: [[VECINIT140:%.*]] = insertelement <4 x i32> [[VECINIT137]], i32 [[TMP43]], i32 1 // CHECK-NEXT: [[LEGS141:%.*]] = getelementptr inbounds nuw [[STRUCT_ANIMALBITS]], ptr [[A1]], i32 0, i32 0 // CHECK-NEXT: [[ARRAYIDX142:%.*]] = getelementptr inbounds nuw [4 x i32], ptr [[LEGS141]], i32 0, i32 2 -// CHECK-NEXT: [[TMP44:%.*]] = load i32, ptr [[ARRAYIDX142]], align 8 +// CHECK-NEXT: [[TMP44:%.*]] = load i32, ptr [[ARRAYIDX142]], align 1 // CHECK-NEXT: [[VECINIT143:%.*]] = insertelement <4 x i32> [[VECINIT140]], i32 [[TMP44]], i32 2 // CHECK-NEXT: [[LEGS144:%.*]] = getelementptr inbounds nuw [[STRUCT_ANIMALBITS]], ptr [[A1]], i32 0, i32 0 // CHECK-NEXT: [[ARRAYIDX145:%.*]] = getelementptr inbounds nuw [4 x i32], ptr [[LEGS144]], i32 0, i32 3 -// CHECK-NEXT: [[TMP45:%.*]] = load i32, ptr [[ARRAYIDX145]], align 4 +// CHECK-NEXT: [[TMP45:%.*]] = load i32, ptr [[ARRAYIDX145]], align 1 // CHECK-NEXT: [[VECINIT146:%.*]] = insertelement <4 x i32> [[VECINIT143]], i32 [[TMP45]], i32 3 -// CHECK-NEXT: store <4 x i32> [[VECINIT146]], ptr [[LEGS134]], align 16 +// CHECK-NEXT: store <4 x i32> [[VECINIT146]], ptr [[LEGS134]], align 1 // CHECK-NEXT: [[TAILSTATE147:%.*]] = getelementptr inbounds nuw [[STRUCT_KITTEH]], ptr [[ARRAYINIT_ELEMENT133]], i32 0, i32 1 // CHECK-NEXT: [[STATE148:%.*]] = getelementptr inbounds nuw [[STRUCT_ANIMALBITS]], ptr [[A1]], i32 0, i32 1 -// CHECK-NEXT: [[TMP46:%.*]] = load i32, ptr [[STATE148]], align 16 -// CHECK-NEXT: store i32 [[TMP46]], ptr [[TAILSTATE147]], align 16 +// CHECK-NEXT: [[TMP46:%.*]] = load i32, ptr [[STATE148]], align 1 +// CHECK-NEXT: store i32 [[TMP46]], ptr [[TAILSTATE147]], align 1 // CHECK-NEXT: [[HAIRCOUNT149:%.*]] = getelementptr inbounds nuw [[STRUCT_KITTEH]], ptr [[ARRAYINIT_ELEMENT133]], i32 0, i32 2 // CHECK-NEXT: [[COUNTER150:%.*]] = getelementptr inbounds nuw [[STRUCT_ANIMALBITS]], ptr [[A1]], i32 0, i32 2 -// CHECK-NEXT: [[TMP47:%.*]] = load i64, ptr [[COUNTER150]], align 8 +// CHECK-NEXT: [[TMP47:%.*]] = load i64, ptr [[COUNTER150]], align 1 // CHECK-NEXT: [[CONV151:%.*]] = sitofp i64 [[TMP47]] to float -// CHECK-NEXT: store float [[CONV151]], ptr [[HAIRCOUNT149]], align 4 +// CHECK-NEXT: store float [[CONV151]], ptr [[HAIRCOUNT149]], align 1 // CHECK-NEXT: [[CLAWS152:%.*]] = getelementptr inbounds nuw [[STRUCT_KITTEH]], ptr [[ARRAYINIT_ELEMENT133]], i32 0, i32 3 // CHECK-NEXT: [[LEFTDIR153:%.*]] = getelementptr inbounds nuw [[STRUCT_ANIMALBITS]], ptr [[A1]], i32 0, i32 3 -// CHECK-NEXT: [[TMP48:%.*]] = load <4 x float>, ptr [[LEFTDIR153]], align 16 +// CHECK-NEXT: [[TMP48:%.*]] = load <4 x float>, ptr [[LEFTDIR153]], align 1 // CHECK-NEXT: [[VECEXT154:%.*]] = extractelement <4 x float> [[TMP48]], i64 0 // CHECK-NEXT: [[VECINIT155:%.*]] = insertelement <4 x float> poison, float [[VECEXT154]], i32 0 // CHECK-NEXT: [[LEFTDIR156:%.*]] = getelementptr inbounds nuw [[STRUCT_ANIMALBITS]], ptr [[A1]], i32 0, i32 3 -// CHECK-NEXT: [[TMP49:%.*]] = load <4 x float>, ptr [[LEFTDIR156]], align 16 +// CHECK-NEXT: [[TMP49:%.*]] = load <4 x float>, ptr [[LEFTDIR156]], align 1 // CHECK-NEXT: [[VECEXT157:%.*]] = extractelement <4 x float> [[TMP49]], i64 1 // CHECK-NEXT: [[VECINIT158:%.*]] = insertelement <4 x float> [[VECINIT155]], float [[VECEXT157]], i32 1 // CHECK-NEXT: [[LEFTDIR159:%.*]] = getelementptr inbounds nuw [[STRUCT_ANIMALBITS]], ptr [[A1]], i32 0, i32 3 -// CHECK-NEXT: [[TMP50:%.*]] = load <4 x float>, ptr [[LEFTDIR159]], align 16 +// CHECK-NEXT: [[TMP50:%.*]] = load <4 x float>, ptr [[LEFTDIR159]], align 1 // CHECK-NEXT: [[VECEXT160:%.*]] = extractelement <4 x float> [[TMP50]], i64 2 // CHECK-NEXT: [[VECINIT161:%.*]] = insertelement <4 x float> [[VECINIT158]], float [[VECEXT160]], i32 2 // CHECK-NEXT: [[LEFTDIR162:%.*]] = getelementptr inbounds nuw [[STRUCT_ANIMALBITS]], ptr [[A1]], i32 0, i32 3 -// CHECK-NEXT: [[TMP51:%.*]] = load <4 x float>, ptr [[LEFTDIR162]], align 16 +// CHECK-NEXT: [[TMP51:%.*]] = load <4 x float>, ptr [[LEFTDIR162]], align 1 // CHECK-NEXT: [[VECEXT163:%.*]] = extractelement <4 x float> [[TMP51]], i64 3 // CHECK-NEXT: [[VECINIT164:%.*]] = insertelement <4 x float> [[VECINIT161]], float [[VECEXT163]], i32 3 -// CHECK-NEXT: store <4 x float> [[VECINIT164]], ptr [[CLAWS152]], align 16 +// CHECK-NEXT: store <4 x float> [[VECINIT164]], ptr [[CLAWS152]], align 1 // CHECK-NEXT: [[ARRAYINIT_ELEMENT165:%.*]] = getelementptr inbounds <4 x float>, ptr [[CLAWS152]], i32 1 // CHECK-NEXT: [[RIGHTDIR166:%.*]] = getelementptr inbounds nuw [[STRUCT_ANIMALBITS]], ptr [[A1]], i32 0, i32 4 -// CHECK-NEXT: [[TMP52:%.*]] = load <4 x float>, ptr [[RIGHTDIR166]], align 16 +// CHECK-NEXT: [[TMP52:%.*]] = load <4 x float>, ptr [[RIGHTDIR166]], align 1 // CHECK-NEXT: [[VECEXT167:%.*]] = extractelement <4 x float> [[TMP52]], i64 0 // CHECK-NEXT: [[VECINIT168:%.*]] = insertelement <4 x float> poison, float [[VECEXT167]], i32 0 // CHECK-NEXT: [[RIGHTDIR169:%.*]] = getelementptr inbounds nuw [[STRUCT_ANIMALBITS]], ptr [[A1]], i32 0, i32 4 -// CHECK-NEXT: [[TMP53:%.*]] = load <4 x float>, ptr [[RIGHTDIR169]], align 16 +// CHECK-NEXT: [[TMP53:%.*]] = load <4 x float>, ptr [[RIGHTDIR169]], align 1 // CHECK-NEXT: [[VECEXT170:%.*]] = extractelement <4 x float> [[TMP53]], i64 1 // CHECK-NEXT: [[VECINIT171:%.*]] = insertelement <4 x float> [[VECINIT168]], float [[VECEXT170]], i32 1 // CHECK-NEXT: [[RIGHTDIR172:%.*]] = getelementptr inbounds nuw [[STRUCT_ANIMALBITS]], ptr [[A1]], i32 0, i32 4 -// CHECK-NEXT: [[TMP54:%.*]] = load <4 x float>, ptr [[RIGHTDIR172]], align 16 +// CHECK-NEXT: [[TMP54:%.*]] = load <4 x float>, ptr [[RIGHTDIR172]], align 1 // CHECK-NEXT: [[VECEXT173:%.*]] = extractelement <4 x float> [[TMP54]], i64 2 // CHECK-NEXT: [[VECINIT174:%.*]] = insertelement <4 x float> [[VECINIT171]], float [[VECEXT173]], i32 2 // CHECK-NEXT: [[RIGHTDIR175:%.*]] = getelementptr inbounds nuw [[STRUCT_ANIMALBITS]], ptr [[A1]], i32 0, i32 4 -// CHECK-NEXT: [[TMP55:%.*]] = load <4 x float>, ptr [[RIGHTDIR175]], align 16 +// CHECK-NEXT: [[TMP55:%.*]] = load <4 x float>, ptr [[RIGHTDIR175]], align 1 // CHECK-NEXT: [[VECEXT176:%.*]] = extractelement <4 x float> [[TMP55]], i64 3 // CHECK-NEXT: [[VECINIT177:%.*]] = insertelement <4 x float> [[VECINIT174]], float [[VECEXT176]], i32 3 -// CHECK-NEXT: store <4 x float> [[VECINIT177]], ptr [[ARRAYINIT_ELEMENT165]], align 16 +// CHECK-NEXT: store <4 x float> [[VECINIT177]], ptr [[ARRAYINIT_ELEMENT165]], align 1 // CHECK-NEXT: [[ARRAYINIT_ELEMENT178:%.*]] = getelementptr inbounds [[STRUCT_KITTEH]], ptr [[CATS]], i32 2 // CHECK-NEXT: [[LEGS179:%.*]] = getelementptr inbounds nuw [[STRUCT_KITTEH]], ptr [[ARRAYINIT_ELEMENT178]], i32 0, i32 0 // CHECK-NEXT: [[LEGSTATE180:%.*]] = getelementptr inbounds nuw [[STRUCT_DOGGO]], ptr [[D1]], i32 0, i32 0 -// CHECK-NEXT: [[TMP56:%.*]] = load <4 x i32>, ptr [[LEGSTATE180]], align 16 +// CHECK-NEXT: [[TMP56:%.*]] = load <4 x i32>, ptr [[LEGSTATE180]], align 1 // CHECK-NEXT: [[VECEXT181:%.*]] = extractelement <4 x i32> [[TMP56]], i64 0 // CHECK-NEXT: [[VECINIT182:%.*]] = insertelement <4 x i32> poison, i32 [[VECEXT181]], i32 0 // CHECK-NEXT: [[LEGSTATE183:%.*]] = getelementptr inbounds nuw [[STRUCT_DOGGO]], ptr [[D1]], i32 0, i32 0 -// CHECK-NEXT: [[TMP57:%.*]] = load <4 x i32>, ptr [[LEGSTATE183]], align 16 +// CHECK-NEXT: [[TMP57:%.*]] = load <4 x i32>, ptr [[LEGSTATE183]], align 1 // CHECK-NEXT: [[VECEXT184:%.*]] = extractelement <4 x i32> [[TMP57]], i64 1 // CHECK-NEXT: [[VECINIT185:%.*]] = insertelement <4 x i32> [[VECINIT182]], i32 [[VECEXT184]], i32 1 // CHECK-NEXT: [[LEGSTATE186:%.*]] = getelementptr inbounds nuw [[STRUCT_DOGGO]], ptr [[D1]], i32 0, i32 0 -// CHECK-NEXT: [[TMP58:%.*]] = load <4 x i32>, ptr [[LEGSTATE186]], align 16 +// CHECK-NEXT: [[TMP58:%.*]] = load <4 x i32>, ptr [[LEGSTATE186]], align 1 // CHECK-NEXT: [[VECEXT187:%.*]] = extractelement <4 x i32> [[TMP58]], i64 2 // CHECK-NEXT: [[VECINIT188:%.*]] = insertelement <4 x i32> [[VECINIT185]], i32 [[VECEXT187]], i32 2 // CHECK-NEXT: [[LEGSTATE189:%.*]] = getelementptr inbounds nuw [[STRUCT_DOGGO]], ptr [[D1]], i32 0, i32 0 -// CHECK-NEXT: [[TMP59:%.*]] = load <4 x i32>, ptr [[LEGSTATE189]], align 16 +// CHECK-NEXT: [[TMP59:%.*]] = load <4 x i32>, ptr [[LEGSTATE189]], align 1 // CHECK-NEXT: [[VECEXT190:%.*]] = extractelement <4 x i32> [[TMP59]], i64 3 // CHECK-NEXT: [[VECINIT191:%.*]] = insertelement <4 x i32> [[VECINIT188]], i32 [[VECEXT190]], i32 3 -// CHECK-NEXT: store <4 x i32> [[VECINIT191]], ptr [[LEGS179]], align 16 +// CHECK-NEXT: store <4 x i32> [[VECINIT191]], ptr [[LEGS179]], align 1 // CHECK-NEXT: [[TAILSTATE192:%.*]] = getelementptr inbounds nuw [[STRUCT_KITTEH]], ptr [[ARRAYINIT_ELEMENT178]], i32 0, i32 1 // CHECK-NEXT: [[TAILSTATE193:%.*]] = getelementptr inbounds nuw [[STRUCT_DOGGO]], ptr [[D1]], i32 0, i32 1 -// CHECK-NEXT: [[TMP60:%.*]] = load i32, ptr [[TAILSTATE193]], align 16 -// CHECK-NEXT: store i32 [[TMP60]], ptr [[TAILSTATE192]], align 16 +// CHECK-NEXT: [[TMP60:%.*]] = load i32, ptr [[TAILSTATE193]], align 1 +// CHECK-NEXT: store i32 [[TMP60]], ptr [[TAILSTATE192]], align 1 // CHECK-NEXT: [[HAIRCOUNT194:%.*]] = getelementptr inbounds nuw [[STRUCT_KITTEH]], ptr [[ARRAYINIT_ELEMENT178]], i32 0, i32 2 // CHECK-NEXT: [[HAIRCOUNT195:%.*]] = getelementptr inbounds nuw [[STRUCT_DOGGO]], ptr [[D1]], i32 0, i32 2 -// CHECK-NEXT: [[TMP61:%.*]] = load float, ptr [[HAIRCOUNT195]], align 4 -// CHECK-NEXT: store float [[TMP61]], ptr [[HAIRCOUNT194]], align 4 +// CHECK-NEXT: [[TMP61:%.*]] = load float, ptr [[HAIRCOUNT195]], align 1 +// CHECK-NEXT: store float [[TMP61]], ptr [[HAIRCOUNT194]], align 1 // CHECK-NEXT: [[CLAWS196:%.*]] = getelementptr inbounds nuw [[STRUCT_KITTEH]], ptr [[ARRAYINIT_ELEMENT178]], i32 0, i32 3 // CHECK-NEXT: [[EARDIRECTION197:%.*]] = getelementptr inbounds nuw [[STRUCT_DOGGO]], ptr [[D1]], i32 0, i32 3 // CHECK-NEXT: [[ARRAYIDX198:%.*]] = getelementptr inbounds nuw [2 x <4 x float>], ptr [[EARDIRECTION197]], i32 0, i32 0 -// CHECK-NEXT: [[TMP62:%.*]] = load <4 x float>, ptr [[ARRAYIDX198]], align 16 +// CHECK-NEXT: [[TMP62:%.*]] = load <4 x float>, ptr [[ARRAYIDX198]], align 1 // CHECK-NEXT: [[VECEXT199:%.*]] = extractelement <4 x float> [[TMP62]], i64 0 // CHECK-NEXT: [[VECINIT200:%.*]] = insertelement <4 x float> poison, float [[VECEXT199]], i32 0 // CHECK-NEXT: [[EARDIRECTION201:%.*]] = getelementptr inbounds nuw [[STRUCT_DOGGO]], ptr [[D1]], i32 0, i32 3 // CHECK-NEXT: [[ARRAYIDX202:%.*]] = getelementptr inbounds nuw [2 x <4 x float>], ptr [[EARDIRECTION201]], i32 0, i32 0 -// CHECK-NEXT: [[TMP63:%.*]] = load <4 x float>, ptr [[ARRAYIDX202]], align 16 +// CHECK-NEXT: [[TMP63:%.*]] = load <4 x float>, ptr [[ARRAYIDX202]], align 1 // CHECK-NEXT: [[VECEXT203:%.*]] = extractelement <4 x float> [[TMP63]], i64 1 // CHECK-NEXT: [[VECINIT204:%.*]] = insertelement <4 x float> [[VECINIT200]], float [[VECEXT203]], i32 1 // CHECK-NEXT: [[EARDIRECTION205:%.*]] = getelementptr inbounds nuw [[STRUCT_DOGGO]], ptr [[D1]], i32 0, i32 3 // CHECK-NEXT: [[ARRAYIDX206:%.*]] = getelementptr inbounds nuw [2 x <4 x float>], ptr [[EARDIRECTION205]], i32 0, i32 0 -// CHECK-NEXT: [[TMP64:%.*]] = load <4 x float>, ptr [[ARRAYIDX206]], align 16 +// CHECK-NEXT: [[TMP64:%.*]] = load <4 x float>, ptr [[ARRAYIDX206]], align 1 // CHECK-NEXT: [[VECEXT207:%.*]] = extractelement <4 x float> [[TMP64]], i64 2 // CHECK-NEXT: [[VECINIT208:%.*]] = insertelement <4 x float> [[VECINIT204]], float [[VECEXT207]], i32 2 // CHECK-NEXT: [[EARDIRECTION209:%.*]] = getelementptr inbounds nuw [[STRUCT_DOGGO]], ptr [[D1]], i32 0, i32 3 // CHECK-NEXT: [[ARRAYIDX210:%.*]] = getelementptr inbounds nuw [2 x <4 x float>], ptr [[EARDIRECTION209]], i32 0, i32 0 -// CHECK-NEXT: [[TMP65:%.*]] = load <4 x float>, ptr [[ARRAYIDX210]], align 16 +// CHECK-NEXT: [[TMP65:%.*]] = load <4 x float>, ptr [[ARRAYIDX210]], align 1 // CHECK-NEXT: [[VECEXT211:%.*]] = extractelement <4 x float> [[TMP65]], i64 3 // CHECK-NEXT: [[VECINIT212:%.*]] = insertelement <4 x float> [[VECINIT208]], float [[VECEXT211]], i32 3 -// CHECK-NEXT: store <4 x float> [[VECINIT212]], ptr [[CLAWS196]], align 16 +// CHECK-NEXT: store <4 x float> [[VECINIT212]], ptr [[CLAWS196]], align 1 // CHECK-NEXT: [[ARRAYINIT_ELEMENT213:%.*]] = getelementptr inbounds <4 x float>, ptr [[CLAWS196]], i32 1 // CHECK-NEXT: [[EARDIRECTION214:%.*]] = getelementptr inbounds nuw [[STRUCT_DOGGO]], ptr [[D1]], i32 0, i32 3 // CHECK-NEXT: [[ARRAYIDX215:%.*]] = getelementptr inbounds nuw [2 x <4 x float>], ptr [[EARDIRECTION214]], i32 0, i32 1 -// CHECK-NEXT: [[TMP66:%.*]] = load <4 x float>, ptr [[ARRAYIDX215]], align 16 +// CHECK-NEXT: [[TMP66:%.*]] = load <4 x float>, ptr [[ARRAYIDX215]], align 1 // CHECK-NEXT: [[VECEXT216:%.*]] = extractelement <4 x float> [[TMP66]], i64 0 // CHECK-NEXT: [[VECINIT217:%.*]] = insertelement <4 x float> poison, float [[VECEXT216]], i32 0 // CHECK-NEXT: [[EARDIRECTION218:%.*]] = getelementptr inbounds nuw [[STRUCT_DOGGO]], ptr [[D1]], i32 0, i32 3 // CHECK-NEXT: [[ARRAYIDX219:%.*]] = getelementptr inbounds nuw [2 x <4 x float>], ptr [[EARDIRECTION218]], i32 0, i32 1 -// CHECK-NEXT: [[TMP67:%.*]] = load <4 x float>, ptr [[ARRAYIDX219]], align 16 +// CHECK-NEXT: [[TMP67:%.*]] = load <4 x float>, ptr [[ARRAYIDX219]], align 1 // CHECK-NEXT: [[VECEXT220:%.*]] = extractelement <4 x float> [[TMP67]], i64 1 // CHECK-NEXT: [[VECINIT221:%.*]] = insertelement <4 x float> [[VECINIT217]], float [[VECEXT220]], i32 1 // CHECK-NEXT: [[EARDIRECTION222:%.*]] = getelementptr inbounds nuw [[STRUCT_DOGGO]], ptr [[D1]], i32 0, i32 3 // CHECK-NEXT: [[ARRAYIDX223:%.*]] = getelementptr inbounds nuw [2 x <4 x float>], ptr [[EARDIRECTION222]], i32 0, i32 1 -// CHECK-NEXT: [[TMP68:%.*]] = load <4 x float>, ptr [[ARRAYIDX223]], align 16 +// CHECK-NEXT: [[TMP68:%.*]] = load <4 x float>, ptr [[ARRAYIDX223]], align 1 // CHECK-NEXT: [[VECEXT224:%.*]] = extractelement <4 x float> [[TMP68]], i64 2 // CHECK-NEXT: [[VECINIT225:%.*]] = insertelement <4 x float> [[VECINIT221]], float [[VECEXT224]], i32 2 // CHECK-NEXT: [[EARDIRECTION226:%.*]] = getelementptr inbounds nuw [[STRUCT_DOGGO]], ptr [[D1]], i32 0, i32 3 // CHECK-NEXT: [[ARRAYIDX227:%.*]] = getelementptr inbounds nuw [2 x <4 x float>], ptr [[EARDIRECTION226]], i32 0, i32 1 -// CHECK-NEXT: [[TMP69:%.*]] = load <4 x float>, ptr [[ARRAYIDX227]], align 16 +// CHECK-NEXT: [[TMP69:%.*]] = load <4 x float>, ptr [[ARRAYIDX227]], align 1 // CHECK-NEXT: [[VECEXT228:%.*]] = extractelement <4 x float> [[TMP69]], i64 3 // CHECK-NEXT: [[VECINIT229:%.*]] = insertelement <4 x float> [[VECINIT225]], float [[VECEXT228]], i32 3 -// CHECK-NEXT: store <4 x float> [[VECINIT229]], ptr [[ARRAYINIT_ELEMENT213]], align 16 +// CHECK-NEXT: store <4 x float> [[VECINIT229]], ptr [[ARRAYINIT_ELEMENT213]], align 1 // CHECK-NEXT: [[ARRAYINIT_ELEMENT230:%.*]] = getelementptr inbounds [[STRUCT_KITTEH]], ptr [[CATS]], i32 3 // CHECK-NEXT: [[LEGS231:%.*]] = getelementptr inbounds nuw [[STRUCT_KITTEH]], ptr [[ARRAYINIT_ELEMENT230]], i32 0, i32 0 // CHECK-NEXT: [[LEGS232:%.*]] = getelementptr inbounds nuw [[STRUCT_ANIMALBITS]], ptr [[A1]], i32 0, i32 0 // CHECK-NEXT: [[ARRAYIDX233:%.*]] = getelementptr inbounds nuw [4 x i32], ptr [[LEGS232]], i32 0, i32 0 -// CHECK-NEXT: [[TMP70:%.*]] = load i32, ptr [[ARRAYIDX233]], align 16 +// CHECK-NEXT: [[TMP70:%.*]] = load i32, ptr [[ARRAYIDX233]], align 1 // CHECK-NEXT: [[VECINIT234:%.*]] = insertelement <4 x i32> poison, i32 [[TMP70]], i32 0 // CHECK-NEXT: [[LEGS235:%.*]] = getelementptr inbounds nuw [[STRUCT_ANIMALBITS]], ptr [[A1]], i32 0, i32 0 // CHECK-NEXT: [[ARRAYIDX236:%.*]] = getelementptr inbounds nuw [4 x i32], ptr [[LEGS235]], i32 0, i32 1 -// CHECK-NEXT: [[TMP71:%.*]] = load i32, ptr [[ARRAYIDX236]], align 4 +// CHECK-NEXT: [[TMP71:%.*]] = load i32, ptr [[ARRAYIDX236]], align 1 // CHECK-NEXT: [[VECINIT237:%.*]] = insertelement <4 x i32> [[VECINIT234]], i32 [[TMP71]], i32 1 // CHECK-NEXT: [[LEGS238:%.*]] = getelementptr inbounds nuw [[STRUCT_ANIMALBITS]], ptr [[A1]], i32 0, i32 0 // CHECK-NEXT: [[ARRAYIDX239:%.*]] = getelementptr inbounds nuw [4 x i32], ptr [[LEGS238]], i32 0, i32 2 -// CHECK-NEXT: [[TMP72:%.*]] = load i32, ptr [[ARRAYIDX239]], align 8 +// CHECK-NEXT: [[TMP72:%.*]] = load i32, ptr [[ARRAYIDX239]], align 1 // CHECK-NEXT: [[VECINIT240:%.*]] = insertelement <4 x i32> [[VECINIT237]], i32 [[TMP72]], i32 2 // CHECK-NEXT: [[LEGS241:%.*]] = getelementptr inbounds nuw [[STRUCT_ANIMALBITS]], ptr [[A1]], i32 0, i32 0 // CHECK-NEXT: [[ARRAYIDX242:%.*]] = getelementptr inbounds nuw [4 x i32], ptr [[LEGS241]], i32 0, i32 3 -// CHECK-NEXT: [[TMP73:%.*]] = load i32, ptr [[ARRAYIDX242]], align 4 +// CHECK-NEXT: [[TMP73:%.*]] = load i32, ptr [[ARRAYIDX242]], align 1 // CHECK-NEXT: [[VECINIT243:%.*]] = insertelement <4 x i32> [[VECINIT240]], i32 [[TMP73]], i32 3 -// CHECK-NEXT: store <4 x i32> [[VECINIT243]], ptr [[LEGS231]], align 16 +// CHECK-NEXT: store <4 x i32> [[VECINIT243]], ptr [[LEGS231]], align 1 // CHECK-NEXT: [[TAILSTATE244:%.*]] = getelementptr inbounds nuw [[STRUCT_KITTEH]], ptr [[ARRAYINIT_ELEMENT230]], i32 0, i32 1 // CHECK-NEXT: [[STATE245:%.*]] = getelementptr inbounds nuw [[STRUCT_ANIMALBITS]], ptr [[A1]], i32 0, i32 1 -// CHECK-NEXT: [[TMP74:%.*]] = load i32, ptr [[STATE245]], align 16 -// CHECK-NEXT: store i32 [[TMP74]], ptr [[TAILSTATE244]], align 16 +// CHECK-NEXT: [[TMP74:%.*]] = load i32, ptr [[STATE245]], align 1 +// CHECK-NEXT: store i32 [[TMP74]], ptr [[TAILSTATE244]], align 1 // CHECK-NEXT: [[HAIRCOUNT246:%.*]] = getelementptr inbounds nuw [[STRUCT_KITTEH]], ptr [[ARRAYINIT_ELEMENT230]], i32 0, i32 2 // CHECK-NEXT: [[COUNTER247:%.*]] = getelementptr inbounds nuw [[STRUCT_ANIMALBITS]], ptr [[A1]], i32 0, i32 2 -// CHECK-NEXT: [[TMP75:%.*]] = load i64, ptr [[COUNTER247]], align 8 +// CHECK-NEXT: [[TMP75:%.*]] = load i64, ptr [[COUNTER247]], align 1 // CHECK-NEXT: [[CONV248:%.*]] = sitofp i64 [[TMP75]] to float -// CHECK-NEXT: store float [[CONV248]], ptr [[HAIRCOUNT246]], align 4 +// CHECK-NEXT: store float [[CONV248]], ptr [[HAIRCOUNT246]], align 1 // CHECK-NEXT: [[CLAWS249:%.*]] = getelementptr inbounds nuw [[STRUCT_KITTEH]], ptr [[ARRAYINIT_ELEMENT230]], i32 0, i32 3 // CHECK-NEXT: [[LEFTDIR250:%.*]] = getelementptr inbounds nuw [[STRUCT_ANIMALBITS]], ptr [[A1]], i32 0, i32 3 -// CHECK-NEXT: [[TMP76:%.*]] = load <4 x float>, ptr [[LEFTDIR250]], align 16 +// CHECK-NEXT: [[TMP76:%.*]] = load <4 x float>, ptr [[LEFTDIR250]], align 1 // CHECK-NEXT: [[VECEXT251:%.*]] = extractelement <4 x float> [[TMP76]], i64 0 // CHECK-NEXT: [[VECINIT252:%.*]] = insertelement <4 x float> poison, float [[VECEXT251]], i32 0 // CHECK-NEXT: [[LEFTDIR253:%.*]] = getelementptr inbounds nuw [[STRUCT_ANIMALBITS]], ptr [[A1]], i32 0, i32 3 -// CHECK-NEXT: [[TMP77:%.*]] = load <4 x float>, ptr [[LEFTDIR253]], align 16 +// CHECK-NEXT: [[TMP77:%.*]] = load <4 x float>, ptr [[LEFTDIR253]], align 1 // CHECK-NEXT: [[VECEXT254:%.*]] = extractelement <4 x float> [[TMP77]], i64 1 // CHECK-NEXT: [[VECINIT255:%.*]] = insertelement <4 x float> [[VECINIT252]], float [[VECEXT254]], i32 1 // CHECK-NEXT: [[LEFTDIR256:%.*]] = getelementptr inbounds nuw [[STRUCT_ANIMALBITS]], ptr [[A1]], i32 0, i32 3 -// CHECK-NEXT: [[TMP78:%.*]] = load <4 x float>, ptr [[LEFTDIR256]], align 16 +// CHECK-NEXT: [[TMP78:%.*]] = load <4 x float>, ptr [[LEFTDIR256]], align 1 // CHECK-NEXT: [[VECEXT257:%.*]] = extractelement <4 x float> [[TMP78]], i64 2 // CHECK-NEXT: [[VECINIT258:%.*]] = insertelement <4 x float> [[VECINIT255]], float [[VECEXT257]], i32 2 // CHECK-NEXT: [[LEFTDIR259:%.*]] = getelementptr inbounds nuw [[STRUCT_ANIMALBITS]], ptr [[A1]], i32 0, i32 3 -// CHECK-NEXT: [[TMP79:%.*]] = load <4 x float>, ptr [[LEFTDIR259]], align 16 +// CHECK-NEXT: [[TMP79:%.*]] = load <4 x float>, ptr [[LEFTDIR259]], align 1 // CHECK-NEXT: [[VECEXT260:%.*]] = extractelement <4 x float> [[TMP79]], i64 3 // CHECK-NEXT: [[VECINIT261:%.*]] = insertelement <4 x float> [[VECINIT258]], float [[VECEXT260]], i32 3 -// CHECK-NEXT: store <4 x float> [[VECINIT261]], ptr [[CLAWS249]], align 16 +// CHECK-NEXT: store <4 x float> [[VECINIT261]], ptr [[CLAWS249]], align 1 // CHECK-NEXT: [[ARRAYINIT_ELEMENT262:%.*]] = getelementptr inbounds <4 x float>, ptr [[CLAWS249]], i32 1 // CHECK-NEXT: [[RIGHTDIR263:%.*]] = getelementptr inbounds nuw [[STRUCT_ANIMALBITS]], ptr [[A1]], i32 0, i32 4 -// CHECK-NEXT: [[TMP80:%.*]] = load <4 x float>, ptr [[RIGHTDIR263]], align 16 +// CHECK-NEXT: [[TMP80:%.*]] = load <4 x float>, ptr [[RIGHTDIR263]], align 1 // CHECK-NEXT: [[VECEXT264:%.*]] = extractelement <4 x float> [[TMP80]], i64 0 // CHECK-NEXT: [[VECINIT265:%.*]] = insertelement <4 x float> poison, float [[VECEXT264]], i32 0 // CHECK-NEXT: [[RIGHTDIR266:%.*]] = getelementptr inbounds nuw [[STRUCT_ANIMALBITS]], ptr [[A1]], i32 0, i32 4 -// CHECK-NEXT: [[TMP81:%.*]] = load <4 x float>, ptr [[RIGHTDIR266]], align 16 +// CHECK-NEXT: [[TMP81:%.*]] = load <4 x float>, ptr [[RIGHTDIR266]], align 1 // CHECK-NEXT: [[VECEXT267:%.*]] = extractelement <4 x float> [[TMP81]], i64 1 // CHECK-NEXT: [[VECINIT268:%.*]] = insertelement <4 x float> [[VECINIT265]], float [[VECEXT267]], i32 1 // CHECK-NEXT: [[RIGHTDIR269:%.*]] = getelementptr inbounds nuw [[STRUCT_ANIMALBITS]], ptr [[A1]], i32 0, i32 4 -// CHECK-NEXT: [[TMP82:%.*]] = load <4 x float>, ptr [[RIGHTDIR269]], align 16 +// CHECK-NEXT: [[TMP82:%.*]] = load <4 x float>, ptr [[RIGHTDIR269]], align 1 // CHECK-NEXT: [[VECEXT270:%.*]] = extractelement <4 x float> [[TMP82]], i64 2 // CHECK-NEXT: [[VECINIT271:%.*]] = insertelement <4 x float> [[VECINIT268]], float [[VECEXT270]], i32 2 // CHECK-NEXT: [[RIGHTDIR272:%.*]] = getelementptr inbounds nuw [[STRUCT_ANIMALBITS]], ptr [[A1]], i32 0, i32 4 -// CHECK-NEXT: [[TMP83:%.*]] = load <4 x float>, ptr [[RIGHTDIR272]], align 16 +// CHECK-NEXT: [[TMP83:%.*]] = load <4 x float>, ptr [[RIGHTDIR272]], align 1 // CHECK-NEXT: [[VECEXT273:%.*]] = extractelement <4 x float> [[TMP83]], i64 3 // CHECK-NEXT: [[VECINIT274:%.*]] = insertelement <4 x float> [[VECINIT271]], float [[VECEXT273]], i32 3 -// CHECK-NEXT: store <4 x float> [[VECINIT274]], ptr [[ARRAYINIT_ELEMENT262]], align 16 +// CHECK-NEXT: store <4 x float> [[VECINIT274]], ptr [[ARRAYINIT_ELEMENT262]], align 1 // CHECK-NEXT: ret void // Zoo case9(Doggo D1, AnimalBits A1) { @@ -724,24 +724,24 @@ Zoo case9(Doggo D1, AnimalBits A1) { // Case 10: Initialize an object with a base class from two objects. // CHECK-LABEL: define void @_Z6case109TwoFloatsS_( -// CHECK-SAME: ptr dead_on_unwind noalias writable sret([[STRUCT_FOURFLOATS:%.*]]) align 4 [[AGG_RESULT:%.*]], ptr noundef byval([[STRUCT_TWOFLOATS:%.*]]) align 4 [[TF1:%.*]], ptr noundef byval([[STRUCT_TWOFLOATS]]) align 4 [[TF2:%.*]]) #[[ATTR0]] { +// CHECK-SAME: ptr dead_on_unwind noalias writable sret([[STRUCT_FOURFLOATS:%.*]]) align 1 [[AGG_RESULT:%.*]], ptr noundef byval([[STRUCT_TWOFLOATS:%.*]]) align 1 [[TF1:%.*]], ptr noundef byval([[STRUCT_TWOFLOATS]]) align 1 [[TF2:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] // CHECK-NEXT: [[X:%.*]] = getelementptr inbounds nuw [[STRUCT_TWOFLOATS]], ptr [[AGG_RESULT]], i32 0, i32 0 // CHECK-NEXT: [[X1:%.*]] = getelementptr inbounds nuw [[STRUCT_TWOFLOATS]], ptr [[TF1]], i32 0, i32 0 -// CHECK-NEXT: [[TMP0:%.*]] = load float, ptr [[X1]], align 4 -// CHECK-NEXT: store float [[TMP0]], ptr [[X]], align 4 +// CHECK-NEXT: [[TMP0:%.*]] = load float, ptr [[X1]], align 1 +// CHECK-NEXT: store float [[TMP0]], ptr [[X]], align 1 // CHECK-NEXT: [[Y:%.*]] = getelementptr inbounds nuw [[STRUCT_TWOFLOATS]], ptr [[AGG_RESULT]], i32 0, i32 1 // CHECK-NEXT: [[Y2:%.*]] = getelementptr inbounds nuw [[STRUCT_TWOFLOATS]], ptr [[TF1]], i32 0, i32 1 -// CHECK-NEXT: [[TMP1:%.*]] = load float, ptr [[Y2]], align 4 -// CHECK-NEXT: store float [[TMP1]], ptr [[Y]], align 4 +// CHECK-NEXT: [[TMP1:%.*]] = load float, ptr [[Y2]], align 1 +// CHECK-NEXT: store float [[TMP1]], ptr [[Y]], align 1 // CHECK-NEXT: [[Z:%.*]] = getelementptr inbounds nuw [[STRUCT_FOURFLOATS]], ptr [[AGG_RESULT]], i32 0, i32 1 // CHECK-NEXT: [[X3:%.*]] = getelementptr inbounds nuw [[STRUCT_TWOFLOATS]], ptr [[TF2]], i32 0, i32 0 -// CHECK-NEXT: [[TMP2:%.*]] = load float, ptr [[X3]], align 4 -// CHECK-NEXT: store float [[TMP2]], ptr [[Z]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load float, ptr [[X3]], align 1 +// CHECK-NEXT: store float [[TMP2]], ptr [[Z]], align 1 // CHECK-NEXT: [[W:%.*]] = getelementptr inbounds nuw [[STRUCT_FOURFLOATS]], ptr [[AGG_RESULT]], i32 0, i32 2 // CHECK-NEXT: [[Y4:%.*]] = getelementptr inbounds nuw [[STRUCT_TWOFLOATS]], ptr [[TF2]], i32 0, i32 1 -// CHECK-NEXT: [[TMP3:%.*]] = load float, ptr [[Y4]], align 4 -// CHECK-NEXT: store float [[TMP3]], ptr [[W]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load float, ptr [[Y4]], align 1 +// CHECK-NEXT: store float [[TMP3]], ptr [[W]], align 1 // CHECK-NEXT: ret void // FourFloats case10(TwoFloats TF1, TwoFloats TF2) { @@ -751,7 +751,7 @@ FourFloats case10(TwoFloats TF1, TwoFloats TF2) { // Case 11: Initialize an object with a base class from a vector splat. // CHECK-LABEL: define void @_Z6case11f( -// CHECK-SAME: ptr dead_on_unwind noalias writable sret([[STRUCT_FOURFLOATS:%.*]]) align 4 [[AGG_RESULT:%.*]], float noundef nofpclass(nan inf) [[F:%.*]]) #[[ATTR0]] { +// CHECK-SAME: ptr dead_on_unwind noalias writable sret([[STRUCT_FOURFLOATS:%.*]]) align 1 [[AGG_RESULT:%.*]], float noundef nofpclass(nan inf) [[F:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] // CHECK-NEXT: [[F_ADDR:%.*]] = alloca float, align 4 // CHECK-NEXT: [[REF_TMP:%.*]] = alloca <4 x float>, align 16 @@ -766,7 +766,7 @@ FourFloats case10(TwoFloats TF1, TwoFloats TF2) { // CHECK-NEXT: store <4 x float> [[TMP1]], ptr [[REF_TMP]], align 16 // CHECK-NEXT: [[TMP2:%.*]] = load <4 x float>, ptr [[REF_TMP]], align 16 // CHECK-NEXT: [[VECEXT:%.*]] = extractelement <4 x float> [[TMP2]], i64 0 -// CHECK-NEXT: store float [[VECEXT]], ptr [[X]], align 4 +// CHECK-NEXT: store float [[VECEXT]], ptr [[X]], align 1 // CHECK-NEXT: [[Y:%.*]] = getelementptr inbounds nuw [[STRUCT_TWOFLOATS]], ptr [[AGG_RESULT]], i32 0, i32 1 // CHECK-NEXT: [[TMP3:%.*]] = load float, ptr [[F_ADDR]], align 4 // CHECK-NEXT: [[CAST_SPLAT2:%.*]] = insertelement <1 x float> poison, float [[TMP3]], i64 0 @@ -774,7 +774,7 @@ FourFloats case10(TwoFloats TF1, TwoFloats TF2) { // CHECK-NEXT: store <4 x float> [[TMP4]], ptr [[REF_TMP1]], align 16 // CHECK-NEXT: [[TMP5:%.*]] = load <4 x float>, ptr [[REF_TMP1]], align 16 // CHECK-NEXT: [[VECEXT3:%.*]] = extractelement <4 x float> [[TMP5]], i64 1 -// CHECK-NEXT: store float [[VECEXT3]], ptr [[Y]], align 4 +// CHECK-NEXT: store float [[VECEXT3]], ptr [[Y]], align 1 // CHECK-NEXT: [[Z:%.*]] = getelementptr inbounds nuw [[STRUCT_FOURFLOATS]], ptr [[AGG_RESULT]], i32 0, i32 1 // CHECK-NEXT: [[TMP6:%.*]] = load float, ptr [[F_ADDR]], align 4 // CHECK-NEXT: [[CAST_SPLAT5:%.*]] = insertelement <1 x float> poison, float [[TMP6]], i64 0 @@ -782,7 +782,7 @@ FourFloats case10(TwoFloats TF1, TwoFloats TF2) { // CHECK-NEXT: store <4 x float> [[TMP7]], ptr [[REF_TMP4]], align 16 // CHECK-NEXT: [[TMP8:%.*]] = load <4 x float>, ptr [[REF_TMP4]], align 16 // CHECK-NEXT: [[VECEXT6:%.*]] = extractelement <4 x float> [[TMP8]], i64 2 -// CHECK-NEXT: store float [[VECEXT6]], ptr [[Z]], align 4 +// CHECK-NEXT: store float [[VECEXT6]], ptr [[Z]], align 1 // CHECK-NEXT: [[W:%.*]] = getelementptr inbounds nuw [[STRUCT_FOURFLOATS]], ptr [[AGG_RESULT]], i32 0, i32 2 // CHECK-NEXT: [[TMP9:%.*]] = load float, ptr [[F_ADDR]], align 4 // CHECK-NEXT: [[CAST_SPLAT8:%.*]] = insertelement <1 x float> poison, float [[TMP9]], i64 0 @@ -790,7 +790,7 @@ FourFloats case10(TwoFloats TF1, TwoFloats TF2) { // CHECK-NEXT: store <4 x float> [[TMP10]], ptr [[REF_TMP7]], align 16 // CHECK-NEXT: [[TMP11:%.*]] = load <4 x float>, ptr [[REF_TMP7]], align 16 // CHECK-NEXT: [[VECEXT9:%.*]] = extractelement <4 x float> [[TMP11]], i64 3 -// CHECK-NEXT: store float [[VECEXT9]], ptr [[W]], align 4 +// CHECK-NEXT: store float [[VECEXT9]], ptr [[W]], align 1 // CHECK-NEXT: ret void // FourFloats case11(float F) { @@ -800,27 +800,19 @@ FourFloats case11(float F) { // Case 12: Initialize bitfield from two integers. // CHECK-LABEL: define void @_Z6case12ii( -// CHECK-SAME: ptr dead_on_unwind noalias writable sret([[STRUCT_SLICYBITS:%.*]]) align 4 [[AGG_RESULT:%.*]], i32 noundef [[I:%.*]], i32 noundef [[J:%.*]]) #[[ATTR0]] { +// CHECK-SAME: ptr dead_on_unwind noalias writable sret([[STRUCT_SLICYBITS:%.*]]) align 1 [[AGG_RESULT:%.*]], i32 noundef [[I:%.*]], i32 noundef [[J:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] // CHECK-NEXT: [[I_ADDR:%.*]] = alloca i32, align 4 // CHECK-NEXT: [[J_ADDR:%.*]] = alloca i32, align 4 // CHECK-NEXT: store i32 [[I]], ptr [[I_ADDR]], align 4 // CHECK-NEXT: store i32 [[J]], ptr [[J_ADDR]], align 4 // CHECK-NEXT: [[TMP0:%.*]] = load i32, ptr [[I_ADDR]], align 4 -// CHECK-NEXT: [[TMP1:%.*]] = trunc i32 [[TMP0]] to i16 -// CHECK-NEXT: [[BF_LOAD:%.*]] = load i16, ptr [[AGG_RESULT]], align 4 -// CHECK-NEXT: [[BF_VALUE:%.*]] = and i16 [[TMP1]], 255 -// CHECK-NEXT: [[BF_CLEAR:%.*]] = and i16 [[BF_LOAD]], -256 -// CHECK-NEXT: [[BF_SET:%.*]] = or i16 [[BF_CLEAR]], [[BF_VALUE]] -// CHECK-NEXT: store i16 [[BF_SET]], ptr [[AGG_RESULT]], align 4 +// CHECK-NEXT: [[TMP1:%.*]] = trunc i32 [[TMP0]] to i8 +// CHECK-NEXT: store i8 [[TMP1]], ptr [[AGG_RESULT]], align 1 +// CHECK-NEXT: [[W:%.*]] = getelementptr inbounds nuw [[STRUCT_SLICYBITS]], ptr [[AGG_RESULT]], i32 0, i32 1 // CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[J_ADDR]], align 4 -// CHECK-NEXT: [[TMP3:%.*]] = trunc i32 [[TMP2]] to i16 -// CHECK-NEXT: [[BF_LOAD1:%.*]] = load i16, ptr [[AGG_RESULT]], align 4 -// CHECK-NEXT: [[BF_VALUE2:%.*]] = and i16 [[TMP3]], 255 -// CHECK-NEXT: [[BF_SHL:%.*]] = shl i16 [[BF_VALUE2]], 8 -// CHECK-NEXT: [[BF_CLEAR3:%.*]] = and i16 [[BF_LOAD1]], 255 -// CHECK-NEXT: [[BF_SET4:%.*]] = or i16 [[BF_CLEAR3]], [[BF_SHL]] -// CHECK-NEXT: store i16 [[BF_SET4]], ptr [[AGG_RESULT]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = trunc i32 [[TMP2]] to i8 +// CHECK-NEXT: store i8 [[TMP3]], ptr [[W]], align 1 // CHECK-NEXT: ret void // SlicyBits case12(int I, int J) { @@ -830,25 +822,17 @@ SlicyBits case12(int I, int J) { // Case 13: Initialize bitfield from a struct of two ints. // CHECK-LABEL: define void @_Z6case137TwoInts( -// CHECK-SAME: ptr dead_on_unwind noalias writable sret([[STRUCT_SLICYBITS:%.*]]) align 4 [[AGG_RESULT:%.*]], ptr noundef byval([[STRUCT_TWOINTS:%.*]]) align 4 [[TI:%.*]]) #[[ATTR0]] { +// CHECK-SAME: ptr dead_on_unwind noalias writable sret([[STRUCT_SLICYBITS:%.*]]) align 1 [[AGG_RESULT:%.*]], ptr noundef byval([[STRUCT_TWOINTS:%.*]]) align 1 [[TI:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] // CHECK-NEXT: [[Z:%.*]] = getelementptr inbounds nuw [[STRUCT_TWOINTS]], ptr [[TI]], i32 0, i32 0 -// CHECK-NEXT: [[TMP0:%.*]] = load i32, ptr [[Z]], align 4 -// CHECK-NEXT: [[TMP1:%.*]] = trunc i32 [[TMP0]] to i16 -// CHECK-NEXT: [[BF_LOAD:%.*]] = load i16, ptr [[AGG_RESULT]], align 4 -// CHECK-NEXT: [[BF_VALUE:%.*]] = and i16 [[TMP1]], 255 -// CHECK-NEXT: [[BF_CLEAR:%.*]] = and i16 [[BF_LOAD]], -256 -// CHECK-NEXT: [[BF_SET:%.*]] = or i16 [[BF_CLEAR]], [[BF_VALUE]] -// CHECK-NEXT: store i16 [[BF_SET]], ptr [[AGG_RESULT]], align 4 -// CHECK-NEXT: [[W:%.*]] = getelementptr inbounds nuw [[STRUCT_TWOINTS]], ptr [[TI]], i32 0, i32 1 -// CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[W]], align 4 -// CHECK-NEXT: [[TMP3:%.*]] = trunc i32 [[TMP2]] to i16 -// CHECK-NEXT: [[BF_LOAD1:%.*]] = load i16, ptr [[AGG_RESULT]], align 4 -// CHECK-NEXT: [[BF_VALUE2:%.*]] = and i16 [[TMP3]], 255 -// CHECK-NEXT: [[BF_SHL:%.*]] = shl i16 [[BF_VALUE2]], 8 -// CHECK-NEXT: [[BF_CLEAR3:%.*]] = and i16 [[BF_LOAD1]], 255 -// CHECK-NEXT: [[BF_SET4:%.*]] = or i16 [[BF_CLEAR3]], [[BF_SHL]] -// CHECK-NEXT: store i16 [[BF_SET4]], ptr [[AGG_RESULT]], align 4 +// CHECK-NEXT: [[TMP0:%.*]] = load i32, ptr [[Z]], align 1 +// CHECK-NEXT: [[TMP1:%.*]] = trunc i32 [[TMP0]] to i8 +// CHECK-NEXT: store i8 [[TMP1]], ptr [[AGG_RESULT]], align 1 +// CHECK-NEXT: [[W:%.*]] = getelementptr inbounds nuw [[STRUCT_SLICYBITS]], ptr [[AGG_RESULT]], i32 0, i32 1 +// CHECK-NEXT: [[W1:%.*]] = getelementptr inbounds nuw [[STRUCT_TWOINTS]], ptr [[TI]], i32 0, i32 1 +// CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[W1]], align 1 +// CHECK-NEXT: [[TMP3:%.*]] = trunc i32 [[TMP2]] to i8 +// CHECK-NEXT: store i8 [[TMP3]], ptr [[W]], align 1 // CHECK-NEXT: ret void // SlicyBits case13(TwoInts TI) { @@ -858,19 +842,17 @@ SlicyBits case13(TwoInts TI) { // Case 14: Initialize struct of ints from struct with bitfields. // CHECK-LABEL: define void @_Z6case149SlicyBits( -// CHECK-SAME: ptr dead_on_unwind noalias writable sret([[STRUCT_TWOINTS:%.*]]) align 4 [[AGG_RESULT:%.*]], ptr noundef byval([[STRUCT_SLICYBITS:%.*]]) align 4 [[SB:%.*]]) #[[ATTR0]] { +// CHECK-SAME: ptr dead_on_unwind noalias writable sret([[STRUCT_TWOINTS:%.*]]) align 1 [[AGG_RESULT:%.*]], ptr noundef byval([[STRUCT_SLICYBITS:%.*]]) align 1 [[SB:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] // CHECK-NEXT: [[Z:%.*]] = getelementptr inbounds nuw [[STRUCT_TWOINTS]], ptr [[AGG_RESULT]], i32 0, i32 0 -// CHECK-NEXT: [[BF_LOAD:%.*]] = load i16, ptr [[SB]], align 4 -// CHECK-NEXT: [[BF_SHL:%.*]] = shl i16 [[BF_LOAD]], 8 -// CHECK-NEXT: [[BF_ASHR:%.*]] = ashr i16 [[BF_SHL]], 8 -// CHECK-NEXT: [[BF_CAST:%.*]] = sext i16 [[BF_ASHR]] to i32 -// CHECK-NEXT: store i32 [[BF_CAST]], ptr [[Z]], align 4 +// CHECK-NEXT: [[BF_LOAD:%.*]] = load i8, ptr [[SB]], align 1 +// CHECK-NEXT: [[BF_CAST:%.*]] = sext i8 [[BF_LOAD]] to i32 +// CHECK-NEXT: store i32 [[BF_CAST]], ptr [[Z]], align 1 // CHECK-NEXT: [[W:%.*]] = getelementptr inbounds nuw [[STRUCT_TWOINTS]], ptr [[AGG_RESULT]], i32 0, i32 1 -// CHECK-NEXT: [[BF_LOAD1:%.*]] = load i16, ptr [[SB]], align 4 -// CHECK-NEXT: [[BF_ASHR2:%.*]] = ashr i16 [[BF_LOAD1]], 8 -// CHECK-NEXT: [[BF_CAST3:%.*]] = sext i16 [[BF_ASHR2]] to i32 -// CHECK-NEXT: store i32 [[BF_CAST3]], ptr [[W]], align 4 +// CHECK-NEXT: [[W1:%.*]] = getelementptr inbounds nuw [[STRUCT_SLICYBITS]], ptr [[SB]], i32 0, i32 1 +// CHECK-NEXT: [[BF_LOAD2:%.*]] = load i8, ptr [[W1]], align 1 +// CHECK-NEXT: [[BF_CAST3:%.*]] = sext i8 [[BF_LOAD2]] to i32 +// CHECK-NEXT: store i32 [[BF_CAST3]], ptr [[W]], align 1 // CHECK-NEXT: ret void // TwoInts case14(SlicyBits SB) { @@ -880,21 +862,19 @@ TwoInts case14(SlicyBits SB) { // Case 15: Initialize struct of floats from struct with bitfields. // CHECK-LABEL: define void @_Z6case159SlicyBits( -// CHECK-SAME: ptr dead_on_unwind noalias writable sret([[STRUCT_TWOFLOATS:%.*]]) align 4 [[AGG_RESULT:%.*]], ptr noundef byval([[STRUCT_SLICYBITS:%.*]]) align 4 [[SB:%.*]]) #[[ATTR0]] { +// CHECK-SAME: ptr dead_on_unwind noalias writable sret([[STRUCT_TWOFLOATS:%.*]]) align 1 [[AGG_RESULT:%.*]], ptr noundef byval([[STRUCT_SLICYBITS:%.*]]) align 1 [[SB:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] // CHECK-NEXT: [[X:%.*]] = getelementptr inbounds nuw [[STRUCT_TWOFLOATS]], ptr [[AGG_RESULT]], i32 0, i32 0 -// CHECK-NEXT: [[BF_LOAD:%.*]] = load i16, ptr [[SB]], align 4 -// CHECK-NEXT: [[BF_SHL:%.*]] = shl i16 [[BF_LOAD]], 8 -// CHECK-NEXT: [[BF_ASHR:%.*]] = ashr i16 [[BF_SHL]], 8 -// CHECK-NEXT: [[BF_CAST:%.*]] = sext i16 [[BF_ASHR]] to i32 +// CHECK-NEXT: [[BF_LOAD:%.*]] = load i8, ptr [[SB]], align 1 +// CHECK-NEXT: [[BF_CAST:%.*]] = sext i8 [[BF_LOAD]] to i32 // CHECK-NEXT: [[CONV:%.*]] = sitofp i32 [[BF_CAST]] to float -// CHECK-NEXT: store float [[CONV]], ptr [[X]], align 4 +// CHECK-NEXT: store float [[CONV]], ptr [[X]], align 1 // CHECK-NEXT: [[Y:%.*]] = getelementptr inbounds nuw [[STRUCT_TWOFLOATS]], ptr [[AGG_RESULT]], i32 0, i32 1 -// CHECK-NEXT: [[BF_LOAD1:%.*]] = load i16, ptr [[SB]], align 4 -// CHECK-NEXT: [[BF_ASHR2:%.*]] = ashr i16 [[BF_LOAD1]], 8 -// CHECK-NEXT: [[BF_CAST3:%.*]] = sext i16 [[BF_ASHR2]] to i32 -// CHECK-NEXT: [[CONV4:%.*]] = sitofp i32 [[BF_CAST3]] to float -// CHECK-NEXT: store float [[CONV4]], ptr [[Y]], align 4 +// CHECK-NEXT: [[W:%.*]] = getelementptr inbounds nuw [[STRUCT_SLICYBITS]], ptr [[SB]], i32 0, i32 1 +// CHECK-NEXT: [[BF_LOAD1:%.*]] = load i8, ptr [[W]], align 1 +// CHECK-NEXT: [[BF_CAST2:%.*]] = sext i8 [[BF_LOAD1]] to i32 +// CHECK-NEXT: [[CONV3:%.*]] = sitofp i32 [[BF_CAST2]] to float +// CHECK-NEXT: store float [[CONV3]], ptr [[Y]], align 1 // CHECK-NEXT: ret void // TwoFloats case15(SlicyBits SB) { @@ -905,19 +885,19 @@ TwoFloats case15(SlicyBits SB) { // Case 16: Side-effecting initialization list arguments. The important thing // here is that case16 only has _one_ call to makeTwo. // CHECK-LABEL: define void @_Z7makeTwoRf( -// CHECK-SAME: ptr dead_on_unwind noalias writable sret([[STRUCT_TWOFLOATS:%.*]]) align 4 [[AGG_RESULT:%.*]], ptr noalias noundef nonnull align 4 dereferenceable(4) [[X:%.*]]) #[[ATTR0]] { +// CHECK-SAME: ptr dead_on_unwind noalias writable sret([[STRUCT_TWOFLOATS:%.*]]) align 1 [[AGG_RESULT:%.*]], ptr noalias noundef nonnull align 4 dereferenceable(4) [[X:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] // CHECK-NEXT: [[X_ADDR:%.*]] = alloca ptr, align 4 // CHECK-NEXT: store ptr [[X]], ptr [[X_ADDR]], align 4 // CHECK-NEXT: [[X1:%.*]] = getelementptr inbounds nuw [[STRUCT_TWOFLOATS]], ptr [[AGG_RESULT]], i32 0, i32 0 // CHECK-NEXT: [[TMP0:%.*]] = load ptr, ptr [[X_ADDR]], align 4 // CHECK-NEXT: [[TMP1:%.*]] = load float, ptr [[TMP0]], align 4 -// CHECK-NEXT: store float [[TMP1]], ptr [[X1]], align 4 +// CHECK-NEXT: store float [[TMP1]], ptr [[X1]], align 1 // CHECK-NEXT: [[Y:%.*]] = getelementptr inbounds nuw [[STRUCT_TWOFLOATS]], ptr [[AGG_RESULT]], i32 0, i32 1 // CHECK-NEXT: [[TMP2:%.*]] = load ptr, ptr [[X_ADDR]], align 4 // CHECK-NEXT: [[TMP3:%.*]] = load float, ptr [[TMP2]], align 4 // CHECK-NEXT: [[MUL:%.*]] = fmul reassoc nnan ninf nsz arcp afn float [[TMP3]], 1.500000e+00 -// CHECK-NEXT: store float [[MUL]], ptr [[Y]], align 4 +// CHECK-NEXT: store float [[MUL]], ptr [[Y]], align 1 // CHECK-NEXT: [[TMP4:%.*]] = load ptr, ptr [[X_ADDR]], align 4 // CHECK-NEXT: [[TMP5:%.*]] = load float, ptr [[TMP4]], align 4 // CHECK-NEXT: [[MUL2:%.*]] = fmul reassoc nnan ninf nsz arcp afn float [[TMP5]], 2.000000e+00 @@ -931,29 +911,29 @@ TwoFloats makeTwo(inout float X) { } // CHECK-LABEL: define void @_Z6case16v( -// CHECK-SAME: ptr dead_on_unwind noalias writable sret([[STRUCT_FOURFLOATS:%.*]]) align 4 [[AGG_RESULT:%.*]]) #[[ATTR0]] { +// CHECK-SAME: ptr dead_on_unwind noalias writable sret([[STRUCT_FOURFLOATS:%.*]]) align 1 [[AGG_RESULT:%.*]]) #[[ATTR0]] { // CHECK-NEXT: [[ENTRY:.*:]] // CHECK-NEXT: [[X:%.*]] = alloca float, align 4 -// CHECK-NEXT: [[REF_TMP:%.*]] = alloca [[STRUCT_TWOFLOATS:%.*]], align 4 +// CHECK-NEXT: [[REF_TMP:%.*]] = alloca [[STRUCT_TWOFLOATS:%.*]], align 1 // CHECK-NEXT: [[TMP:%.*]] = alloca float, align 4 // CHECK-NEXT: store float 0.000000e+00, ptr [[X]], align 4 // CHECK-NEXT: [[TMP0:%.*]] = load float, ptr [[X]], align 4 // CHECK-NEXT: store float [[TMP0]], ptr [[TMP]], align 4 -// CHECK-NEXT: call void @_Z7makeTwoRf(ptr dead_on_unwind writable sret([[STRUCT_TWOFLOATS]]) align 4 [[REF_TMP]], ptr noalias noundef nonnull align 4 dereferenceable(4) [[TMP]]) #[[ATTR2:[0-9]+]] +// CHECK-NEXT: call void @_Z7makeTwoRf(ptr dead_on_unwind writable sret([[STRUCT_TWOFLOATS]]) align 1 [[REF_TMP]], ptr noalias noundef nonnull align 4 dereferenceable(4) [[TMP]]) #[[ATTR2:[0-9]+]] // CHECK-NEXT: [[TMP1:%.*]] = load float, ptr [[TMP]], align 4 // CHECK-NEXT: store float [[TMP1]], ptr [[X]], align 4 // CHECK-NEXT: [[X1:%.*]] = getelementptr inbounds nuw [[STRUCT_TWOFLOATS]], ptr [[AGG_RESULT]], i32 0, i32 0 -// CHECK-NEXT: store float 0.000000e+00, ptr [[X1]], align 4 +// CHECK-NEXT: store float 0.000000e+00, ptr [[X1]], align 1 // CHECK-NEXT: [[Y:%.*]] = getelementptr inbounds nuw [[STRUCT_TWOFLOATS]], ptr [[AGG_RESULT]], i32 0, i32 1 // CHECK-NEXT: [[X2:%.*]] = getelementptr inbounds nuw [[STRUCT_TWOFLOATS]], ptr [[REF_TMP]], i32 0, i32 0 -// CHECK-NEXT: [[TMP2:%.*]] = load float, ptr [[X2]], align 4 -// CHECK-NEXT: store float [[TMP2]], ptr [[Y]], align 4 +// CHECK-NEXT: [[TMP2:%.*]] = load float, ptr [[X2]], align 1 +// CHECK-NEXT: store float [[TMP2]], ptr [[Y]], align 1 // CHECK-NEXT: [[Z:%.*]] = getelementptr inbounds nuw [[STRUCT_FOURFLOATS]], ptr [[AGG_RESULT]], i32 0, i32 1 // CHECK-NEXT: [[Y3:%.*]] = getelementptr inbounds nuw [[STRUCT_TWOFLOATS]], ptr [[REF_TMP]], i32 0, i32 1 -// CHECK-NEXT: [[TMP3:%.*]] = load float, ptr [[Y3]], align 4 -// CHECK-NEXT: store float [[TMP3]], ptr [[Z]], align 4 +// CHECK-NEXT: [[TMP3:%.*]] = load float, ptr [[Y3]], align 1 +// CHECK-NEXT: store float [[TMP3]], ptr [[Z]], align 1 // CHECK-NEXT: [[W:%.*]] = getelementptr inbounds nuw [[STRUCT_FOURFLOATS]], ptr [[AGG_RESULT]], i32 0, i32 2 -// CHECK-NEXT: store float 3.000000e+00, ptr [[W]], align 4 +// CHECK-NEXT: store float 3.000000e+00, ptr [[W]], align 1 // CHECK-NEXT: ret void // FourFloats case16() { diff --git a/clang/test/CodeGenHLSL/BasicFeatures/OutputArguments.hlsl b/clang/test/CodeGenHLSL/BasicFeatures/OutputArguments.hlsl index 289bbb959e8a4..1f45a7f9b46d3 100644 --- a/clang/test/CodeGenHLSL/BasicFeatures/OutputArguments.hlsl +++ b/clang/test/CodeGenHLSL/BasicFeatures/OutputArguments.hlsl @@ -144,7 +144,7 @@ struct S { float Y; }; -// CHECK: define void {{.*}}init{{.*}}(ptr noalias noundef nonnull align 4 dereferenceable(8) {{%.*}}) +// CHECK: define void {{.*}}init{{.*}}(ptr noalias noundef nonnull align 1 dereferenceable(8) {{%.*}}) void init(out S s) { s.X = 3; s.Y = 4; @@ -154,8 +154,8 @@ void init(out S s) { // CHECK: [[S:%.*]] = alloca %struct.S // CHECK: [[Tmp:%.*]] = alloca %struct.S -// CHECK: call void {{.*}}init{{.*}}(ptr noalias noundef nonnull align 4 dereferenceable(8) [[Tmp]]) -// CHECK: call void @llvm.memcpy.p0.p0.i32(ptr align 4 [[S]], ptr align 4 [[Tmp]], i32 8, i1 false) +// CHECK: call void {{.*}}init{{.*}}(ptr noalias noundef nonnull align 1 dereferenceable(8) [[Tmp]]) +// CHECK: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[S]], ptr align 1 [[Tmp]], i32 8, i1 false) // OPT: ret i32 7 export int case6() { @@ -170,7 +170,7 @@ struct R { float Y; }; -// CHECK: define void {{.*}}init{{.*}}(ptr noalias noundef nonnull align 4 dereferenceable(8) {{%.*}}) +// CHECK: define void {{.*}}init{{.*}}(ptr noalias noundef nonnull align 1 dereferenceable(8) {{%.*}}) void init(inout R s) { s.X = 3; s.Y = 4; @@ -180,9 +180,9 @@ void init(inout R s) { // CHECK: [[S:%.*]] = alloca %struct.R // CHECK: [[Tmp:%.*]] = alloca %struct.R -// CHECK: call void @llvm.memcpy.p0.p0.i32(ptr align 4 [[Tmp]], ptr align 4 [[S]], i32 8, i1 false) -// CHECK: call void {{.*}}init{{.*}}(ptr noalias noundef nonnull align 4 dereferenceable(8) [[Tmp]]) -// CHECK: call void @llvm.memcpy.p0.p0.i32(ptr align 4 [[S]], ptr align 4 [[Tmp]], i32 8, i1 false) +// CHECK: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[Tmp]], ptr align 1 [[S]], i32 8, i1 false) +// CHECK: call void {{.*}}init{{.*}}(ptr noalias noundef nonnull align 1 dereferenceable(8) [[Tmp]]) +// CHECK: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[S]], ptr align 1 [[Tmp]], i32 8, i1 false) // OPT: ret i32 7 export int case7() { @@ -289,19 +289,13 @@ void setFour(inout int I) { // CHECK: [[B:%.*]] = alloca %struct.B // CHECK: [[Tmp:%.*]] = alloca i32 -// CHECK: [[BFLoad:%.*]] = load i16, ptr [[B]] -// CHECK: [[BFshl:%.*]] = shl i16 [[BFLoad]], 8 -// CHECK: [[BFashr:%.*]] = ashr i16 [[BFshl]], 8 -// CHECK: [[BFcast:%.*]] = sext i16 [[BFashr]] to i32 +// CHECK: [[BFLoad:%.*]] = load i8, ptr [[B]] +// CHECK: [[BFcast:%.*]] = sext i8 [[BFLoad]] to i32 // CHECK: store i32 [[BFcast]], ptr [[Tmp]] // CHECK: call void {{.*}}setFour{{.*}}(ptr noalias noundef nonnull align 4 dereferenceable(4) [[Tmp]]) // CHECK: [[RetVal:%.*]] = load i32, ptr [[Tmp]] -// CHECK: [[TruncVal:%.*]] = trunc i32 [[RetVal]] to i16 -// CHECK: [[BFLoad:%.*]] = load i16, ptr [[B]] -// CHECK: [[BFValue:%.*]] = and i16 [[TruncVal]], 255 -// CHECK: [[ZerodField:%.*]] = and i16 [[BFLoad]], -256 -// CHECK: [[BFSet:%.*]] = or i16 [[ZerodField]], [[BFValue]] -// CHECK: store i16 [[BFSet]], ptr [[B]] +// CHECK: [[TruncVal:%.*]] = trunc i32 [[RetVal]] to i8 +// CHECK: store i8 [[TruncVal]], ptr [[B]] // OPT: ret i32 8 export int case11() { diff --git a/clang/test/CodeGenHLSL/BasicFeatures/StructElementwiseCast.hlsl b/clang/test/CodeGenHLSL/BasicFeatures/StructElementwiseCast.hlsl index 26fde37c901dd..81b9f5b28cc7e 100644 --- a/clang/test/CodeGenHLSL/BasicFeatures/StructElementwiseCast.hlsl +++ b/clang/test/CodeGenHLSL/BasicFeatures/StructElementwiseCast.hlsl @@ -7,11 +7,11 @@ struct S { // struct truncation to a scalar // CHECK-LABEL: define void {{.*}}call0 -// CHECK: [[s:%.*]] = alloca %struct.S, align 4 +// CHECK: [[s:%.*]] = alloca %struct.S, align 1 // CHECK-NEXT: [[A:%.*]] = alloca i32, align 4 -// CHECK-NEXT: [[Tmp:%.*]] = alloca %struct.S, align 4 -// CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 4 [[s]], ptr align 4 {{.*}}, i32 8, i1 false) -// CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 4 [[Tmp]], ptr align 4 [[s]], i32 8, i1 false) +// CHECK-NEXT: [[Tmp:%.*]] = alloca %struct.S, align 1 +// CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[s]], ptr align 1 {{.*}}, i32 8, i1 false) +// CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[Tmp]], ptr align 1 [[s]], i32 8, i1 false) // CHECK-NEXT: [[G1:%.*]] = getelementptr inbounds %struct.S, ptr [[Tmp]], i32 0, i32 0 // CHECK-NEXT: [[G2:%.*]] = getelementptr inbounds %struct.S, ptr [[Tmp]], i32 0, i32 1 // CHECK-NEXT: [[L:%.*]] = load i32, ptr [[G1]], align 4 @@ -24,7 +24,7 @@ export void call0() { // struct from vector // CHECK-LABEL: define void {{.*}}call1 // CHECK: [[A:%.*]] = alloca <2 x i32>, align 8 -// CHECK-NEXT: [[s:%.*]] = alloca %struct.S, align 4 +// CHECK-NEXT: [[s:%.*]] = alloca %struct.S, align 1 // CHECK-NEXT: store <2 x i32> , ptr [[A]], align 8 // CHECK-NEXT: [[L:%.*]] = load <2 x i32>, ptr [[A]], align 8 // CHECK-NEXT: [[G1:%.*]] = getelementptr inbounds %struct.S, ptr [[s]], i32 0, i32 0 @@ -43,7 +43,7 @@ export void call1() { // struct from array // CHECK-LABEL: define void {{.*}}call2 // CHECK: [[A:%.*]] = alloca [2 x i32], align 4 -// CHECK-NEXT: [[s:%.*]] = alloca %struct.S, align 4 +// CHECK-NEXT: [[s:%.*]] = alloca %struct.S, align 1 // CHECK-NEXT: [[Tmp:%.*]] = alloca [2 x i32], align 4 // CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 4 [[A]], ptr align 4 {{.*}}, i32 8, i1 false) // CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 4 [[Tmp]], ptr align 4 [[A]], i32 8, i1 false) @@ -72,11 +72,11 @@ struct R { // struct from nested struct? // CHECK-LABEL: define void {{.*}}call6 -// CHECK: [[r:%.*]] = alloca %struct.R, align 4 -// CHECK-NEXT: [[s:%.*]] = alloca %struct.S, align 4 -// CHECK-NEXT: [[Tmp:%.*]] = alloca %struct.R, align 4 -// CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 4 [[r]], ptr align 4 {{.*}}, i32 8, i1 false) -// CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 4 [[Tmp]], ptr align 4 [[r]], i32 8, i1 false) +// CHECK: [[r:%.*]] = alloca %struct.R, align 1 +// CHECK-NEXT: [[s:%.*]] = alloca %struct.S, align 1 +// CHECK-NEXT: [[Tmp:%.*]] = alloca %struct.R, align 1 +// CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[r]], ptr align 1 {{.*}}, i32 8, i1 false) +// CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[Tmp]], ptr align 1 [[r]], i32 8, i1 false) // CHECK-NEXT: [[G1:%.*]] = getelementptr inbounds %struct.S, ptr [[s]], i32 0, i32 0 // CHECK-NEXT: [[G2:%.*]] = getelementptr inbounds %struct.S, ptr [[s]], i32 0, i32 1 // CHECK-NEXT: [[G3:%.*]] = getelementptr inbounds %struct.R, ptr [[Tmp]], i32 0, i32 0 @@ -93,7 +93,7 @@ export void call6() { // nested struct from array? // CHECK-LABEL: define void {{.*}}call7 // CHECK: [[A:%.*]] = alloca [2 x i32], align 4 -// CHECK-NEXT: [[r:%.*]] = alloca %struct.R, align 4 +// CHECK-NEXT: [[r:%.*]] = alloca %struct.R, align 1 // CHECK-NEXT: [[Tmp:%.*]] = alloca [2 x i32], align 4 // CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 4 [[A]], ptr align 4 {{.*}}, i32 8, i1 false) // CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 4 [[Tmp]], ptr align 4 [[A]], i32 8, i1 false) @@ -119,11 +119,11 @@ struct T { // struct truncation // CHECK-LABEL: define void {{.*}}call8 -// CHECK: [[t:%.*]] = alloca %struct.T, align 4 -// CHECK-NEXT: [[s:%.*]] = alloca %struct.S, align 4 -// CHECK-NEXT: [[Tmp:%.*]] = alloca %struct.T, align 4 -// CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 4 [[t]], ptr align 4 {{.*}}, i32 12, i1 false) -// CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 4 [[Tmp]], ptr align 4 [[t]], i32 12, i1 false) +// CHECK: [[t:%.*]] = alloca %struct.T, align 1 +// CHECK-NEXT: [[s:%.*]] = alloca %struct.S, align 1 +// CHECK-NEXT: [[Tmp:%.*]] = alloca %struct.T, align 1 +// CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[t]], ptr align 1 {{.*}}, i32 12, i1 false) +// CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[Tmp]], ptr align 1 [[t]], i32 12, i1 false) // CHECK-NEXT: [[G1:%.*]] = getelementptr inbounds %struct.S, ptr [[s]], i32 0, i32 0 // CHECK-NEXT: [[G2:%.*]] = getelementptr inbounds %struct.S, ptr [[s]], i32 0, i32 1 // CHECK-NEXT: [[G3:%.*]] = getelementptr inbounds %struct.T, ptr [[Tmp]], i32 0, i32 0 diff --git a/clang/test/CodeGenHLSL/BasicFeatures/VectorElementwiseCast.hlsl b/clang/test/CodeGenHLSL/BasicFeatures/VectorElementwiseCast.hlsl index f579dfb377de5..253b38a7ca072 100644 --- a/clang/test/CodeGenHLSL/BasicFeatures/VectorElementwiseCast.hlsl +++ b/clang/test/CodeGenHLSL/BasicFeatures/VectorElementwiseCast.hlsl @@ -28,12 +28,12 @@ struct S { // vector flat cast from struct // CHECK-LABEL: define void {{.*}}call3 -// CHECK: [[s:%.*]] = alloca %struct.S, align 4 +// CHECK: [[s:%.*]] = alloca %struct.S, align 1 // CHECK-NEXT: [[A:%.*]] = alloca <2 x i32>, align 8 -// CHECK-NEXT: [[Tmp:%.*]] = alloca %struct.S, align 4 +// CHECK-NEXT: [[Tmp:%.*]] = alloca %struct.S, align 1 // CHECK-NEXT: [[Tmp2:%.*]] = alloca <2 x i32>, align 8 -// CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 4 [[s]], ptr align 4 {{.*}}, i32 8, i1 false) -// CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 4 [[Tmp]], ptr align 4 [[s]], i32 8, i1 false) +// CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[s]], ptr align 1 {{.*}}, i32 8, i1 false) +// CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[Tmp]], ptr align 1 [[s]], i32 8, i1 false) // CHECK-NEXT: [[G1:%.*]] = getelementptr inbounds %struct.S, ptr [[Tmp]], i32 0, i32 0 // CHECK-NEXT: [[G2:%.*]] = getelementptr inbounds %struct.S, ptr [[Tmp]], i32 0, i32 1 // CHECK-NEXT: [[B:%.*]] = load <2 x i32>, ptr [[Tmp2]], align 8 @@ -66,11 +66,11 @@ export void call4() { // truncate struct to scalar // CHECK-LABEL: define void {{.*}}call5 -// CHECK: [[s:%.*]] = alloca %struct.S, align 4 +// CHECK: [[s:%.*]] = alloca %struct.S, align 1 // CHECK-NEXT: [[A:%.*]] = alloca i32, align 4 -// CHECK-NEXT: [[Tmp:%.*]] = alloca %struct.S, align 4 -// CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 4 [[s]], ptr align 4 {{.*}}, i32 8, i1 false) -// CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 4 [[Tmp]], ptr align 4 [[s]], i32 8, i1 false) +// CHECK-NEXT: [[Tmp:%.*]] = alloca %struct.S, align 1 +// CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[s]], ptr align 1 {{.*}}, i32 8, i1 false) +// CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[Tmp]], ptr align 1 [[s]], i32 8, i1 false) // CHECK-NEXT: [[G1:%.*]] = getelementptr inbounds %struct.S, ptr [[Tmp]], i32 0, i32 0 // CHECK-NEXT: [[G2:%.*]] = getelementptr inbounds %struct.S, ptr [[Tmp]], i32 0, i32 1 // CHECK-NEXT: [[L:%.*]] = load i32, ptr [[G1]], align 4 diff --git a/clang/test/CodeGenHLSL/BoolVector.hlsl b/clang/test/CodeGenHLSL/BoolVector.hlsl index 5e889d50be98d..35d8b9dac801d 100644 --- a/clang/test/CodeGenHLSL/BoolVector.hlsl +++ b/clang/test/CodeGenHLSL/BoolVector.hlsl @@ -1,7 +1,7 @@ // RUN: %clang_cc1 -finclude-default-header -triple dxil-pc-shadermodel6.3-library -emit-llvm -disable-llvm-passes -o - %s | FileCheck %s -// CHECK: %struct.S = type { <2 x i32>, float } -// CHECK: [[ConstS:@.*]] = private unnamed_addr constant %struct.S { <2 x i32> splat (i32 1), float 1.000000e+00 }, align 8 +// CHECK: %struct.S = type <{ <2 x i32>, float }> +// CHECK: [[ConstS:@.*]] = private unnamed_addr constant %struct.S <{ <2 x i32> splat (i32 1), float 1.000000e+00 }>, align 1 // CHECK: [[ConstArr:.*]] = private unnamed_addr constant [2 x <2 x i32>] [<2 x i32> splat (i32 1), <2 x i32> zeroinitializer], align 8 struct S { @@ -41,10 +41,10 @@ bool2 fn2(bool V) { } // CHECK-LABEL: define noundef i1 {{.*}}fn3{{.*}} -// CHECK: [[s:%.*]] = alloca %struct.S, align 8 -// CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 8 [[s]], ptr align 8 [[ConstS]], i32 16, i1 false) +// CHECK: [[s:%.*]] = alloca %struct.S, align 1 +// CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[s]], ptr align 1 [[ConstS]], i32 12, i1 false) // CHECK-NEXT: [[BV:%.*]] = getelementptr inbounds nuw %struct.S, ptr [[s]], i32 0, i32 0 -// CHECK-NEXT: [[LBV:%.*]] = load <2 x i32>, ptr [[BV]], align 8 +// CHECK-NEXT: [[LBV:%.*]] = load <2 x i32>, ptr [[BV]], align 1 // CHECK-NEXT: [[LV:%.*]] = trunc <2 x i32> [[LBV]] to <2 x i1> // CHECK-NEXT: [[VX:%.*]] = extractelement <2 x i1> [[LV]], i32 0 // CHECK-NEXT: ret i1 [[VX]] @@ -80,16 +80,16 @@ void fn5() { // CHECK-LABEL: define void {{.*}}fn6{{.*}} // CHECK: [[V:%.*]] = alloca i32, align 4 -// CHECK-NEXT: [[S:%.*]] = alloca %struct.S, align 8 +// CHECK-NEXT: [[S:%.*]] = alloca %struct.S, align 1 // CHECK-NEXT: store i32 0, ptr [[V]], align 4 -// CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 8 [[S]], ptr align 8 {{.*}}, i32 16, i1 false) +// CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[S]], ptr align 1 {{.*}}, i32 12, i1 false) // CHECK-NEXT: [[Y:%.*]] = load i32, ptr [[V]], align 4 // CHECK-NEXT: [[LV:%.*]] = trunc i32 [[Y]] to i1 // CHECK-NEXT: [[BV:%.*]] = getelementptr inbounds nuw %struct.S, ptr [[S]], i32 0, i32 0 -// CHECK-NEXT: [[X:%.*]] = load <2 x i32>, ptr [[BV]], align 8 +// CHECK-NEXT: [[X:%.*]] = load <2 x i32>, ptr [[BV]], align 1 // CHECK-NEXT: [[Z:%.*]] = zext i1 [[LV]] to i32 // CHECK-NEXT: [[VI:%.*]] = insertelement <2 x i32> [[X]], i32 [[Z]], i32 1 -// CHECK-NEXT: store <2 x i32> [[VI]], ptr [[BV]], align 8 +// CHECK-NEXT: store <2 x i32> [[VI]], ptr [[BV]], align 1 // CHECK-NEXT: ret void void fn6() { bool V = false; diff --git a/clang/test/CodeGenHLSL/builtins/AppendStructuredBuffer-elementtype.hlsl b/clang/test/CodeGenHLSL/builtins/AppendStructuredBuffer-elementtype.hlsl index eea148c46f3a0..31932ef98c740 100644 --- a/clang/test/CodeGenHLSL/builtins/AppendStructuredBuffer-elementtype.hlsl +++ b/clang/test/CodeGenHLSL/builtins/AppendStructuredBuffer-elementtype.hlsl @@ -19,7 +19,7 @@ struct MyStruct { // DXIL: %"class.hlsl::AppendStructuredBuffer.10" = type { target("dx.RawBuffer", <2 x half>, 1, 0) // DXIL: %"class.hlsl::AppendStructuredBuffer.11" = type { target("dx.RawBuffer", <3 x float>, 1, 0) // DXIL: %"class.hlsl::AppendStructuredBuffer.12" = type { target("dx.RawBuffer", %struct.MyStruct, 1, 0) -// DXIL: %struct.MyStruct = type { <4 x float>, <2 x i32>, [8 x i8] } +// DXIL: %struct.MyStruct = type <{ <4 x float>, <2 x i32> }> // DXIL: %"class.hlsl::AppendStructuredBuffer.13" = type { target("dx.RawBuffer", i32, 1, 0) // DXIL: %"class.hlsl::AppendStructuredBuffer.14" = type { target("dx.RawBuffer", <4 x i32>, 1, 0) diff --git a/clang/test/CodeGenHLSL/builtins/ConsumeStructuredBuffer-elementtype.hlsl b/clang/test/CodeGenHLSL/builtins/ConsumeStructuredBuffer-elementtype.hlsl index c303d48f7bd87..63de87e10f404 100644 --- a/clang/test/CodeGenHLSL/builtins/ConsumeStructuredBuffer-elementtype.hlsl +++ b/clang/test/CodeGenHLSL/builtins/ConsumeStructuredBuffer-elementtype.hlsl @@ -19,7 +19,7 @@ struct MyStruct { // DXIL: %"class.hlsl::ConsumeStructuredBuffer.10" = type { target("dx.RawBuffer", <2 x half>, 1, 0) // DXIL: %"class.hlsl::ConsumeStructuredBuffer.11" = type { target("dx.RawBuffer", <3 x float>, 1, 0) // DXIL: %"class.hlsl::ConsumeStructuredBuffer.12" = type { target("dx.RawBuffer", %struct.MyStruct, 1, 0) -// DXIL: %struct.MyStruct = type { <4 x float>, <2 x i32>, [8 x i8] } +// DXIL: %struct.MyStruct = type <{ <4 x float>, <2 x i32> }> // DXIL: %"class.hlsl::ConsumeStructuredBuffer.13" = type { target("dx.RawBuffer", i32, 1, 0) // DXIL: %"class.hlsl::ConsumeStructuredBuffer.14" = type { target("dx.RawBuffer", <4 x i32>, 1, 0) diff --git a/clang/test/CodeGenHLSL/builtins/RasterizerOrderedStructuredBuffer-elementtype.hlsl b/clang/test/CodeGenHLSL/builtins/RasterizerOrderedStructuredBuffer-elementtype.hlsl index e50d97b119058..dfa6a6d838266 100644 --- a/clang/test/CodeGenHLSL/builtins/RasterizerOrderedStructuredBuffer-elementtype.hlsl +++ b/clang/test/CodeGenHLSL/builtins/RasterizerOrderedStructuredBuffer-elementtype.hlsl @@ -18,7 +18,7 @@ struct MyStruct { // DXIL: %"class.hlsl::RasterizerOrderedStructuredBuffer.9" = type { target("dx.RawBuffer", <3 x i32>, 1, 1) } // DXIL: %"class.hlsl::RasterizerOrderedStructuredBuffer.10" = type { target("dx.RawBuffer", <2 x half>, 1, 1) } // DXIL: %"class.hlsl::RasterizerOrderedStructuredBuffer.11" = type { target("dx.RawBuffer", <3 x float>, 1, 1) } -// DXIL: %struct.MyStruct = type { <4 x float>, <2 x i32>, [8 x i8] } +// DXIL: %struct.MyStruct = type <{ <4 x float>, <2 x i32> }> RasterizerOrderedStructuredBuffer BufI16; RasterizerOrderedStructuredBuffer BufU16; diff --git a/clang/test/CodeGenHLSL/builtins/StructuredBuffers-subscripts.hlsl b/clang/test/CodeGenHLSL/builtins/StructuredBuffers-subscripts.hlsl index 4e716a85456a6..1e70483ae63da 100644 --- a/clang/test/CodeGenHLSL/builtins/StructuredBuffers-subscripts.hlsl +++ b/clang/test/CodeGenHLSL/builtins/StructuredBuffers-subscripts.hlsl @@ -37,15 +37,15 @@ void main(unsigned GI : SV_GroupIndex) { // For SPIR-V, the addrspacecast comes from `S::operator=` member function, which expects // parameters in address space 0. This is why hlsl_device is a sub address // space of the default address space. - // SPV: %[[INPTR:.*]] = call noundef align 4 dereferenceable(4) ptr addrspace(11) @llvm.spv.resource.getpointer.p11.tspirv.VulkanBuffer_a0s_struct.Ss_12_1t(target("spirv.VulkanBuffer", [0 x %struct.S], 12, 1) %{{.*}}, i32 %{{.*}}) + // SPV: %[[INPTR:.*]] = call noundef align 1 dereferenceable(4) ptr addrspace(11) @llvm.spv.resource.getpointer.p11.tspirv.VulkanBuffer_a0s_struct.Ss_12_1t(target("spirv.VulkanBuffer", [0 x %struct.S], 12, 1) %{{.*}}, i32 %{{.*}}) // SPV: %[[INCAST:.*]] = addrspacecast ptr addrspace(11) %[[INPTR]] to ptr - // SPV: %[[OUTPTR:.*]] = call noundef align 4 dereferenceable(4) ptr addrspace(11) @llvm.spv.resource.getpointer.p11.tspirv.VulkanBuffer_a0s_struct.Ss_12_1t(target("spirv.VulkanBuffer", [0 x %struct.S], 12, 1) %{{.*}}, i32 %{{.*}}) + // SPV: %[[OUTPTR:.*]] = call noundef align 1 dereferenceable(4) ptr addrspace(11) @llvm.spv.resource.getpointer.p11.tspirv.VulkanBuffer_a0s_struct.Ss_12_1t(target("spirv.VulkanBuffer", [0 x %struct.S], 12, 1) %{{.*}}, i32 %{{.*}}) // SPV: %[[OUTCAST:.*]] = addrspacecast ptr addrspace(11) %[[OUTPTR]] to ptr - // SPV: call void @llvm.memcpy.p0.p0.i64(ptr align 4 %[[OUTCAST]], ptr align 4 %[[INCAST]], i64 4, i1 false) + // SPV: call void @llvm.memcpy.p0.p0.i64(ptr align 1 %[[OUTCAST]], ptr align 1 %[[INCAST]], i64 4, i1 false) // For DXIL, hlsl_device and the default address space map to the same target address space. No need for an address space cast. - // DXIL: %[[INPTR:.*]] = call noundef nonnull align 4 dereferenceable(4) ptr @llvm.dx.resource.getpointer.p0.tdx.RawBuffer_s_struct.Ss_1_0t(target("dx.RawBuffer", %struct.S, 1, 0) %{{.*}}, i32 %{{.*}}) - // DXIL: %[[OUTPTR:.*]] = call noundef nonnull align 4 dereferenceable(4) ptr @llvm.dx.resource.getpointer.p0.tdx.RawBuffer_s_struct.Ss_1_0t(target("dx.RawBuffer", %struct.S, 1, 0) %{{.*}}, i32 %{{.*}}) - // DXIL: call void @llvm.memcpy.p0.p0.i32(ptr align 4 %[[OUTPTR]], ptr align 4 %[[INPTR]], i32 4, i1 false) + // DXIL: %[[INPTR:.*]] = call noundef nonnull align 1 dereferenceable(4) ptr @llvm.dx.resource.getpointer.p0.tdx.RawBuffer_s_struct.Ss_1_0t(target("dx.RawBuffer", %struct.S, 1, 0) %{{.*}}, i32 %{{.*}}) + // DXIL: %[[OUTPTR:.*]] = call noundef nonnull align 1 dereferenceable(4) ptr @llvm.dx.resource.getpointer.p0.tdx.RawBuffer_s_struct.Ss_1_0t(target("dx.RawBuffer", %struct.S, 1, 0) %{{.*}}, i32 %{{.*}}) + // DXIL: call void @llvm.memcpy.p0.p0.i32(ptr align 1 %[[OUTPTR]], ptr align 1 %[[INPTR]], i32 4, i1 false) RWSB3[0] = RWSB3[1]; } diff --git a/clang/test/CodeGenHLSL/builtins/hlsl_resource_t.hlsl b/clang/test/CodeGenHLSL/builtins/hlsl_resource_t.hlsl index fda034ce7f203..6d2ae6535ecb3 100644 --- a/clang/test/CodeGenHLSL/builtins/hlsl_resource_t.hlsl +++ b/clang/test/CodeGenHLSL/builtins/hlsl_resource_t.hlsl @@ -4,7 +4,7 @@ using handle_float_t = __hlsl_resource_t [[hlsl::resource_class(UAV)]] [[hlsl::c // CHECK: %"class.hlsl::RWBuffer" = type { target("dx.TypedBuffer", <4 x float>, 1, 0, 0) // CHECK: %"class.hlsl::StructuredBuffer" = type { target("dx.RawBuffer", %struct.MyStruct, 0, 0) -// CHECK: %struct.MyStruct = type { <4 x float>, <2 x i32>, [8 x i8] } +// CHECK: %struct.MyStruct = type <{ <4 x float>, <2 x i32> }> // CHECK: define void @_Z2faU9_Res_u_CTfu17__hlsl_resource_t(target("dx.TypedBuffer", float, 1, 0, 0) %a) // CHECK: call void @_Z4foo1U9_Res_u_CTfu17__hlsl_resource_t(target("dx.TypedBuffer", float, 1, 0, 0) %0) diff --git a/clang/test/CodeGenHLSL/cbuffer.hlsl b/clang/test/CodeGenHLSL/cbuffer.hlsl index e13999a9982e2..a588b17120d0e 100644 --- a/clang/test/CodeGenHLSL/cbuffer.hlsl +++ b/clang/test/CodeGenHLSL/cbuffer.hlsl @@ -133,11 +133,11 @@ struct D { // CHECK: @CBStructs.cb = global target("dx.CBuffer", target("dx.Layout", %__cblayout_CBStructs, // CHECK-SAME: 246, 0, 16, 32, 64, 144, 238, 240)) -// CHECK: @a = external addrspace(2) global target("dx.Layout", %A, 8, 0), align 8 -// CHECK: @b = external addrspace(2) global target("dx.Layout", %B, 14, 0, 8), align 8 -// CHECK: @c = external addrspace(2) global target("dx.Layout", %C, 24, 0, 16), align 8 -// CHECK: @array_of_A = external addrspace(2) global [5 x target("dx.Layout", %A, 8, 0)], align 8 -// CHECK: @d = external addrspace(2) global target("dx.Layout", %__cblayout_D, 94, 0), align 8 +// CHECK: @a = external addrspace(2) global target("dx.Layout", %A, 8, 0), align 1 +// CHECK: @b = external addrspace(2) global target("dx.Layout", %B, 14, 0, 8), align 1 +// CHECK: @c = external addrspace(2) global target("dx.Layout", %C, 24, 0, 16), align 1 +// CHECK: @array_of_A = external addrspace(2) global [5 x target("dx.Layout", %A, 8, 0)], align 1 +// CHECK: @d = external addrspace(2) global target("dx.Layout", %__cblayout_D, 94, 0), align 1 // CHECK: @e = external addrspace(2) global half, align 2 // CHECK: @f = external addrspace(2) global <3 x i16>, align 8 @@ -173,10 +173,10 @@ cbuffer CBClasses { // CHECK: @CBClasses.cb = global target("dx.CBuffer", target("dx.Layout", %__cblayout_CBClasses, // CHECK-SAME: 260, 0, 16, 32, 112)) -// CHECK: @k = external addrspace(2) global target("dx.Layout", %K, 4, 0), align 4 -// CHECK: @l = external addrspace(2) global target("dx.Layout", %L, 8, 0, 4), align 4 -// CHECK: @m = external addrspace(2) global target("dx.Layout", %M, 68, 0), align 4 -// CHECK: @ka = external addrspace(2) global [10 x target("dx.Layout", %K, 4, 0)], align 4 +// CHECK: @k = external addrspace(2) global target("dx.Layout", %K, 4, 0), align 1 +// CHECK: @l = external addrspace(2) global target("dx.Layout", %L, 8, 0, 4), align 1 +// CHECK: @m = external addrspace(2) global target("dx.Layout", %M, 68, 0), align 1 +// CHECK: @ka = external addrspace(2) global [10 x target("dx.Layout", %K, 4, 0)], align 1 struct Test { float a, b; @@ -184,13 +184,13 @@ struct Test { // CHECK: @CBMix.cb = global target("dx.CBuffer", target("dx.Layout", %__cblayout_CBMix, // CHECK-SAME: 170, 0, 24, 32, 120, 128, 136, 144, 152, 160, 168)) -// CHECK: @test = external addrspace(2) global [2 x target("dx.Layout", %Test, 8, 0, 4)], align 4 +// CHECK: @test = external addrspace(2) global [2 x target("dx.Layout", %Test, 8, 0, 4)], align 1 // CHECK: @f1 = external addrspace(2) global float, align 4 // CHECK: @f2 = external addrspace(2) global [3 x [2 x <2 x float>]], align 8 // CHECK: @f3 = external addrspace(2) global float, align 4 -// CHECK: @f4 = external addrspace(2) global target("dx.Layout", %anon, 4, 0), align 4 +// CHECK: @f4 = external addrspace(2) global target("dx.Layout", %anon, 4, 0), align 1 // CHECK: @f5 = external addrspace(2) global double, align 8 -// CHECK: @f6 = external addrspace(2) global target("dx.Layout", %anon.0, 8, 0), align 8 +// CHECK: @f6 = external addrspace(2) global target("dx.Layout", %anon.0, 8, 0), align 1 // CHECK: @f7 = external addrspace(2) global float, align 4 // CHECK: @f8 = external addrspace(2) global <1 x double>, align 8 // CHECK: @f9 = external addrspace(2) global i16, align 2 diff --git a/clang/test/CodeGenHLSL/cbuffer_and_namespaces.hlsl b/clang/test/CodeGenHLSL/cbuffer_and_namespaces.hlsl index 188c9831044e6..4d7094f559975 100644 --- a/clang/test/CodeGenHLSL/cbuffer_and_namespaces.hlsl +++ b/clang/test/CodeGenHLSL/cbuffer_and_namespaces.hlsl @@ -15,7 +15,7 @@ // CHECK: @C.cb = global target("dx.CBuffer", target("dx.Layout", %"n0::n2::__cblayout_C", 20, 0, 16)) // CHECK: @_ZN2n02n21aE = external addrspace(2) global float, align 4 -// CHECK: external addrspace(2) global target("dx.Layout", %"n0::Foo", 4, 0), align 4 +// CHECK: external addrspace(2) global target("dx.Layout", %"n0::Foo", 4, 0), align 1 namespace n0 { struct Foo { diff --git a/clang/test/CodeGenHLSL/default_cbuffer_with_layout.hlsl b/clang/test/CodeGenHLSL/default_cbuffer_with_layout.hlsl index 7e69e1c040935..9736a56fdc20b 100644 --- a/clang/test/CodeGenHLSL/default_cbuffer_with_layout.hlsl +++ b/clang/test/CodeGenHLSL/default_cbuffer_with_layout.hlsl @@ -11,7 +11,7 @@ // CHECK-DAG: @a = external addrspace(2) global i32, align 4 // CHECK-DAG: @c = external addrspace(2) global [4 x double], align 8 // CHECK-DAG: @e = external addrspace(2) global <4 x float>, align 16 -// CHECK-DAG: @s = external addrspace(2) global target("dx.Layout", %S, 8, 0), align 8 +// CHECK-DAG: @s = external addrspace(2) global target("dx.Layout", %S, 8, 0), align 1 struct S { float2 v; diff --git a/clang/test/CodeGenHLSL/implicit-norecurse-attrib.hlsl b/clang/test/CodeGenHLSL/implicit-norecurse-attrib.hlsl index ab5001a0496de..daa16cc0d42cf 100644 --- a/clang/test/CodeGenHLSL/implicit-norecurse-attrib.hlsl +++ b/clang/test/CodeGenHLSL/implicit-norecurse-attrib.hlsl @@ -12,7 +12,7 @@ struct Node { }; // CHECK: Function Attrs:{{.*}}norecurse -// CHECK: define noundef i32 @_Z4FindA100_4Nodej(ptr noundef byval([100 x %struct.Node]) align 4 %SortedTree, i32 noundef %key) [[IntAttr:\#[0-9]+]] +// CHECK: define noundef i32 @_Z4FindA100_4Nodej(ptr noundef byval([100 x %struct.Node]) align 1 %SortedTree, i32 noundef %key) [[IntAttr:\#[0-9]+]] // CHECK: ret i32 // Find and return value corresponding to key in the SortedTree uint Find(Node SortedTree[MAX], uint key) { @@ -31,7 +31,7 @@ uint Find(Node SortedTree[MAX], uint key) { } // CHECK: Function Attrs:{{.*}}norecurse -// CHECK: define noundef i1 @_Z8InitTreeA100_4NodeN4hlsl8RWBufferIDv4_jEEj(ptr noundef byval([100 x %struct.Node]) align 4 %tree, ptr noundef byval(%"class.hlsl::RWBuffer") align 4 %encodedTree, i32 noundef %maxDepth) [[ExtAttr:\#[0-9]+]] +// CHECK: define noundef i1 @_Z8InitTreeA100_4NodeN4hlsl8RWBufferIDv4_jEEj(ptr noundef byval([100 x %struct.Node]) align 1 %tree, ptr noundef byval(%"class.hlsl::RWBuffer") align 4 %encodedTree, i32 noundef %maxDepth) [[ExtAttr:\#[0-9]+]] // CHECK: ret i1 // Initialize tree with given buffer // Imagine the inout works diff --git a/clang/test/CodeGenHLSL/sret_output.hlsl b/clang/test/CodeGenHLSL/sret_output.hlsl index c324790ba016d..eefc9dabab517 100644 --- a/clang/test/CodeGenHLSL/sret_output.hlsl +++ b/clang/test/CodeGenHLSL/sret_output.hlsl @@ -9,7 +9,7 @@ struct S { // Make sure sret parameter is generated. -// CHECK:define internal void @_Z7ps_mainv(ptr dead_on_unwind noalias writable sret(%struct.S) align 4 %agg.result) +// CHECK:define internal void @_Z7ps_mainv(ptr dead_on_unwind noalias writable sret(%struct.S) align 1 %agg.result) // FIXME: change it to real value instead of poison value once semantic is add to a. // Make sure the function with sret is called. // CHECK:call void @_Z7ps_mainv(ptr poison) diff --git a/clang/test/CodeGenHLSL/this-assignment-overload.hlsl b/clang/test/CodeGenHLSL/this-assignment-overload.hlsl index 5a3bdc3d4d38e..a87eb0b38f603 100644 --- a/clang/test/CodeGenHLSL/this-assignment-overload.hlsl +++ b/clang/test/CodeGenHLSL/this-assignment-overload.hlsl @@ -25,31 +25,31 @@ void main() { } // This test makes a probably safe assumption that HLSL 202x includes operator overloading for assignment operators. -// CHECK: define linkonce_odr noundef i32 @_ZN4Pair8getFirstEv(ptr noundef nonnull align 4 dereferenceable(8) %this) #0 align 2 { +// CHECK: define linkonce_odr noundef i32 @_ZN4Pair8getFirstEv(ptr noundef nonnull align 1 dereferenceable(8) %this) #0 align 2 { // CHECK-NEXT:entry: // CHECK-NEXT:%this.addr = alloca ptr, align 4 -// CHECK-NEXT:%Another = alloca %struct.Pair, align 4 -// CHECK-NEXT:%agg.tmp = alloca %struct.Pair, align 4 +// CHECK-NEXT:%Another = alloca %struct.Pair, align 1 +// CHECK-NEXT:%agg.tmp = alloca %struct.Pair, align 1 // CHECK-NEXT:store ptr %this, ptr %this.addr, align 4 // CHECK-NEXT:%this1 = load ptr, ptr %this.addr, align 4 // CHECK-NEXT:%First = getelementptr inbounds nuw %struct.Pair, ptr %Another, i32 0, i32 0 -// CHECK-NEXT:store i32 5, ptr %First, align 4 +// CHECK-NEXT:store i32 5, ptr %First, align 1 // CHECK-NEXT:%Second = getelementptr inbounds nuw %struct.Pair, ptr %Another, i32 0, i32 1 -// CHECK-NEXT:store i32 10, ptr %Second, align 4 -// CHECK-NEXT:call void @llvm.memcpy.p0.p0.i32(ptr align 4 %agg.tmp, ptr align 4 %Another, i32 8, i1 false) -// CHECK-NEXT:call void @_ZN4PairaSES_(ptr noundef nonnull align 4 dereferenceable(8) %this1, ptr noundef byval(%struct.Pair) align 4 %agg.tmp) +// CHECK-NEXT:store i32 10, ptr %Second, align 1 +// CHECK-NEXT:call void @llvm.memcpy.p0.p0.i32(ptr align 1 %agg.tmp, ptr align 1 %Another, i32 8, i1 false) +// CHECK-NEXT:call void @_ZN4PairaSES_(ptr noundef nonnull align 1 dereferenceable(8) %this1, ptr noundef byval(%struct.Pair) align 1 %agg.tmp) // CHECK-NEXT:%First2 = getelementptr inbounds nuw %struct.Pair, ptr %this1, i32 0, i32 0 -// CHECK-NEXT:%0 = load i32, ptr %First2, align 4 +// CHECK-NEXT:%0 = load i32, ptr %First2, align 1 // CHECK-NEXT:ret i32 %0 -// CHECK: define linkonce_odr noundef i32 @_ZN4Pair9getSecondEv(ptr noundef nonnull align 4 dereferenceable(8) %this) #0 align 2 { +// CHECK: define linkonce_odr noundef i32 @_ZN4Pair9getSecondEv(ptr noundef nonnull align 1 dereferenceable(8) %this) #0 align 2 { // CHECK-NEXT:entry: // CHECK-NEXT:%this.addr = alloca ptr, align 4 -// CHECK-NEXT:%agg.tmp = alloca %struct.Pair, align 4 +// CHECK-NEXT:%agg.tmp = alloca %struct.Pair, align 1 // CHECK-NEXT:store ptr %this, ptr %this.addr, align 4 // CHECK-NEXT:%this1 = load ptr, ptr %this.addr, align 4 -// CHECK-NEXT:call void @llvm.memset.p0.i32(ptr align 4 %agg.tmp, i8 0, i32 8, i1 false) -// CHECK-NEXT:call void @_ZN4PairaSES_(ptr noundef nonnull align 4 dereferenceable(8) %this1, ptr noundef byval(%struct.Pair) align 4 %agg.tmp) +// CHECK-NEXT:call void @llvm.memset.p0.i32(ptr align 1 %agg.tmp, i8 0, i32 8, i1 false) +// CHECK-NEXT:call void @_ZN4PairaSES_(ptr noundef nonnull align 1 dereferenceable(8) %this1, ptr noundef byval(%struct.Pair) align 1 %agg.tmp) // CHECK-NEXT:%Second = getelementptr inbounds nuw %struct.Pair, ptr %this1, i32 0, i32 1 -// CHECK-NEXT:%0 = load i32, ptr %Second, align 4 +// CHECK-NEXT:%0 = load i32, ptr %Second, align 1 // CHECK-NEXT:ret i32 %0 diff --git a/clang/test/CodeGenHLSL/this-assignment.hlsl b/clang/test/CodeGenHLSL/this-assignment.hlsl index 72bd2f8e70af8..efccc96499242 100644 --- a/clang/test/CodeGenHLSL/this-assignment.hlsl +++ b/clang/test/CodeGenHLSL/this-assignment.hlsl @@ -36,21 +36,21 @@ void main() { // CHECK-LABEL: define {{.*}}getFirst // CHECK-NEXT:entry: // CHECK-NEXT:%this.addr = alloca ptr, align 4 -// CHECK-NEXT:%Another = alloca %struct.Pair, align 4 +// CHECK-NEXT:%Another = alloca %struct.Pair, align 1 // CHECK-NEXT:store ptr %this, ptr %this.addr, align 4 // CHECK-NEXT:%this1 = load ptr, ptr %this.addr, align 4 -// CHECK-NEXT:call void @llvm.memcpy.p0.p0.i32(ptr align 4 %Another, ptr align 4 @__const._ZN4Pair8getFirstEv.Another, i32 8, i1 false) -// CHECK-NEXT:call void @llvm.memcpy.p0.p0.i32(ptr align 4 %this1, ptr align 4 %Another, i32 8, i1 false) +// CHECK-NEXT:call void @llvm.memcpy.p0.p0.i32(ptr align 1 %Another, ptr align 1 @__const._ZN4Pair8getFirstEv.Another, i32 8, i1 false) +// CHECK-NEXT:call void @llvm.memcpy.p0.p0.i32(ptr align 1 %this1, ptr align 1 %Another, i32 8, i1 false) // CHECK-NEXT:%First = getelementptr inbounds nuw %struct.Pair, ptr %this1, i32 0, i32 0 // CHECK-LABEL: define {{.*}}getSecond // CHECK-NEXT:entry: // CHECK-NEXT:%this.addr = alloca ptr, align 4 -// CHECK-NEXT:%ref.tmp = alloca %struct.Pair, align 4 +// CHECK-NEXT:%ref.tmp = alloca %struct.Pair, align 1 // CHECK-NEXT:store ptr %this, ptr %this.addr, align 4 // CHECK-NEXT:%this1 = load ptr, ptr %this.addr, align 4 -// CHECK-NEXT:call void @llvm.memset.p0.i32(ptr align 4 %ref.tmp, i8 0, i32 8, i1 false) -// CHECK-NEXT:call void @llvm.memcpy.p0.p0.i32(ptr align 4 %this1, ptr align 4 %ref.tmp, i32 8, i1 false) +// CHECK-NEXT:call void @llvm.memset.p0.i32(ptr align 1 %ref.tmp, i8 0, i32 8, i1 false) +// CHECK-NEXT:call void @llvm.memcpy.p0.p0.i32(ptr align 1 %this1, ptr align 1 %ref.tmp, i32 8, i1 false) // CHECK-NEXT:%Second = getelementptr inbounds nuw %struct.Pair, ptr %this1, i32 0, i32 1 // CHECK-LABEL: define {{.*}}DoSilly @@ -58,9 +58,9 @@ void main() { // CHECK-NEXT: [[ThisPtrAddr:%.*]] = alloca ptr // CHECK-NEXT: store ptr {{.*}}, ptr [[ThisPtrAddr]] // CHECK-NEXT: [[ThisPtr:%.*]] = load ptr, ptr [[ThisPtrAddr]] -// CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 4 [[ThisPtr]], ptr align 4 [[Obj:%.*]], i32 8, i1 false) +// CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 [[ThisPtr]], ptr align 1 [[Obj:%.*]], i32 8, i1 false) // CHECK-NEXT: [[FirstAddr:%.*]] = getelementptr inbounds nuw %struct.Pair, ptr [[ThisPtr]], i32 0, i32 0 // CHECK-NEXT: [[First:%.*]] = load i32, ptr [[FirstAddr]] // CHECK-NEXT: [[FirstPlusTwo:%.*]] = add nsw i32 [[First]], 2 // CHECK-NEXT: store i32 [[FirstPlusTwo]], ptr [[FirstAddr]] -// CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 4 {{.*}}, ptr align 4 [[Obj]], i32 8, i1 false) +// CHECK-NEXT: call void @llvm.memcpy.p0.p0.i32(ptr align 1 {{.*}}, ptr align 1 [[Obj]], i32 8, i1 false) diff --git a/clang/test/CodeGenHLSL/this-reference.hlsl b/clang/test/CodeGenHLSL/this-reference.hlsl index 71a33f4a271a2..edf1abf6bd81a 100644 --- a/clang/test/CodeGenHLSL/this-reference.hlsl +++ b/clang/test/CodeGenHLSL/this-reference.hlsl @@ -21,10 +21,10 @@ void main() { } // This tests reference like `this` in HLSL - // CHECK: %call = call noundef i32 @_ZN4Pair8getFirstEv(ptr noundef nonnull align 4 dereferenceable(8) %Vals) + // CHECK: %call = call noundef i32 @_ZN4Pair8getFirstEv(ptr noundef nonnull align 1 dereferenceable(8) %Vals) // CHECK-NEXT: %First = getelementptr inbounds nuw %struct.Pair, ptr %Vals, i32 0, i32 0 - // CHECK-NEXT: store i32 %call, ptr %First, align 4 - // CHECK-NEXT: %call1 = call reassoc nnan ninf nsz arcp afn noundef nofpclass(nan inf) float @_ZN4Pair9getSecondEv(ptr noundef nonnull align 4 dereferenceable(8) %Vals) + // CHECK-NEXT: store i32 %call, ptr %First, align 1 + // CHECK-NEXT: %call1 = call reassoc nnan ninf nsz arcp afn noundef nofpclass(nan inf) float @_ZN4Pair9getSecondEv(ptr noundef nonnull align 1 dereferenceable(8) %Vals) // CHECK-NEXT: %Second = getelementptr inbounds nuw %struct.Pair, ptr %Vals, i32 0, i32 1 // CHECK: [[Pair:![0-9]+]] = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "Pair"