[clang] 6e93c4a - [DirectX] Specify element-aligned vectors (#180622)
via cfe-commits
cfe-commits at lists.llvm.org
Wed Mar 11 15:49:53 PDT 2026
Author: Justin Bogner
Date: 2026-03-11T15:49:48-07:00
New Revision: 6e93c4a19d3c9ada5cf29a9164a0a5f39cc7ff50
URL: https://github.com/llvm/llvm-project/commit/6e93c4a19d3c9ada5cf29a9164a0a5f39cc7ff50
DIFF: https://github.com/llvm/llvm-project/commit/6e93c4a19d3c9ada5cf29a9164a0a5f39cc7ff50.diff
LOG: [DirectX] Specify element-aligned vectors (#180622)
Use the new "ve" Data Layout specifier to indicate that vectors are
element-aligned for the target.
Part of #123968
Added:
Modified:
clang/test/CodeGenHLSL/ArrayAssignable.hlsl
clang/test/CodeGenHLSL/BoolVector.hlsl
clang/test/CodeGenHLSL/basic-target.c
clang/test/CodeGenHLSL/builtins/hlsl_resource_t.hlsl
clang/test/CodeGenHLSL/resources/CBufferMatrixSingleSubscriptSwizzle.hlsl
clang/test/CodeGenHLSL/resources/MatrixElement_cbuffer.hlsl
clang/test/CodeGenHLSL/resources/RasterizerOrderedStructuredBuffer-elementtype.hlsl
clang/test/CodeGenHLSL/resources/cbuffer_geps.hlsl
clang/test/CodeGenHLSL/semantics/semantic.array.hlsl
clang/test/CodeGenHLSL/semantics/semantic.array.output.hlsl
clang/test/CodeGenHLSL/semantics/semantic.explicit-location-output-struct.hlsl
clang/test/CodeGenHLSL/semantics/semantic.struct.hlsl
llvm/lib/TargetParser/TargetDataLayout.cpp
llvm/test/CodeGen/DirectX/CreateHandleFromBinding.ll
llvm/test/CodeGen/DirectX/MemIntrinsics/memcpy-pointee.ll
llvm/test/CodeGen/DirectX/MemIntrinsics/memcpy-struct.ll
llvm/test/CodeGen/DirectX/WaveActiveBallot.ll
Removed:
################################################################################
diff --git a/clang/test/CodeGenHLSL/ArrayAssignable.hlsl b/clang/test/CodeGenHLSL/ArrayAssignable.hlsl
index 310486018b53a..a2f01f5847410 100644
--- a/clang/test/CodeGenHLSL/ArrayAssignable.hlsl
+++ b/clang/test/CodeGenHLSL/ArrayAssignable.hlsl
@@ -159,11 +159,11 @@ void arr_assign8() {
// CHECK-LABEL: define hidden void {{.*}}arr_assign9
// CHECK: [[C:%.*]] = alloca [2 x <4 x i32>], align 16
// CHECK-NEXT: [[V0:%.*]] = getelementptr inbounds [2 x <4 x i32>], ptr [[C]], i32 0
-// CHECK-NEXT: [[L0:%.*]] = load <4 x i32>, ptr addrspace(2) @c2, align 16
-// CHECK-NEXT: store <4 x i32> [[L0]], ptr [[V0]], align 16
+// CHECK-NEXT: [[L0:%.*]] = load <4 x i32>, ptr addrspace(2) @c2, align 4
+// CHECK-NEXT: store <4 x i32> [[L0]], ptr [[V0]], align 4
// CHECK-NEXT: [[V1:%.*]] = getelementptr inbounds [2 x <4 x i32>], ptr [[C]], i32 0, i32 1
-// CHECK-NEXT: [[L1:%.*]] = load <4 x i32>, ptr addrspace(2) getelementptr inbounds nuw (i8, ptr addrspace(2) @c2, i32 16), align 16
-// CHECK-NEXT: store <4 x i32> [[L1]], ptr [[V1]], align 16
+// CHECK-NEXT: [[L1:%.*]] = load <4 x i32>, ptr addrspace(2) getelementptr inbounds nuw (i8, ptr addrspace(2) @c2, i32 16), align 4
+// CHECK-NEXT: store <4 x i32> [[L1]], ptr [[V1]], align 4
// CHECK-NEXT: ret void
void arr_assign9() {
int4 C[2];
diff --git a/clang/test/CodeGenHLSL/BoolVector.hlsl b/clang/test/CodeGenHLSL/BoolVector.hlsl
index 6be90e8f51ce2..246790dab176f 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 1
+// 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 {
diff --git a/clang/test/CodeGenHLSL/basic-target.c b/clang/test/CodeGenHLSL/basic-target.c
index b9482df5a0987..e64d344c2c5e0 100644
--- a/clang/test/CodeGenHLSL/basic-target.c
+++ b/clang/test/CodeGenHLSL/basic-target.c
@@ -6,5 +6,5 @@
// RUN: %clang -cc1 -triple dxil-pc-shadermodel6.0-domain -emit-llvm -o - %s | FileCheck %s
// RUN: %clang -cc1 -triple dxil-pc-shadermodel6.0-geometry -emit-llvm -o - %s | FileCheck %s
-// CHECK: target datalayout = "e-m:e-p:32:32-i1:32-i8:8-i16:16-i32:32-i64:64-f16:16-f32:32-f64:64-n8:16:32:64-v48:16:16-v96:32:32-v192:64:64"
+// CHECK: target datalayout = "e-m:e-ve-p:32:32-i1:32-i8:8-i16:16-i32:32-i64:64-f16:16-f32:32-f64:64-n8:16:32:64"
// CHECK: target triple = "dxilv1.0-pc-shadermodel6.0-{{[a-z]+}}"
diff --git a/clang/test/CodeGenHLSL/builtins/hlsl_resource_t.hlsl b/clang/test/CodeGenHLSL/builtins/hlsl_resource_t.hlsl
index 1efcccf5d3854..0eb36ce8fb7bb 100644
--- a/clang/test/CodeGenHLSL/builtins/hlsl_resource_t.hlsl
+++ b/clang/test/CodeGenHLSL/builtins/hlsl_resource_t.hlsl
@@ -9,7 +9,7 @@ struct CustomResource {
// CHECK: %struct.CustomResource = type { target("dx.TypedBuffer", float, 1, 0, 0) }
// 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> }>
+// CHECK: %struct.MyStruct = type { <4 x float>, <2 x i32> }
// CHECK: define hidden void @_Z2fa14CustomResource(ptr noundef byval(%struct.CustomResource) align 1 %a)
// CHECK: call void @_Z4foo114CustomResource(ptr noundef byval(%struct.CustomResource) align 1 %agg.tmp)
diff --git a/clang/test/CodeGenHLSL/resources/CBufferMatrixSingleSubscriptSwizzle.hlsl b/clang/test/CodeGenHLSL/resources/CBufferMatrixSingleSubscriptSwizzle.hlsl
index e3fda3ec40115..fe74e9845cbba 100644
--- a/clang/test/CodeGenHLSL/resources/CBufferMatrixSingleSubscriptSwizzle.hlsl
+++ b/clang/test/CodeGenHLSL/resources/CBufferMatrixSingleSubscriptSwizzle.hlsl
@@ -9,17 +9,17 @@ cbuffer CB {
// CHECK-LABEL: define hidden noundef nofpclass(nan inf) <2 x float> @_Z15get_row_swizzlev(
// CHECK-SAME: ) #[[ATTR2:[0-9]+]] {
// CHECK-NEXT: [[ENTRY:.*:]]
-// CHECK-NEXT: [[MATRIX_BUF_COPY:%.*]] = alloca [3 x <2 x float>], align 8
+// CHECK-NEXT: [[MATRIX_BUF_COPY:%.*]] = alloca [3 x <2 x float>], align 4
// CHECK-NEXT: [[CBUF_DEST:%.*]] = getelementptr inbounds [3 x <2 x float>], ptr [[MATRIX_BUF_COPY]], i32 0, i32 0
-// CHECK-NEXT: [[CBUF_LOAD:%.*]] = load <2 x float>, ptr addrspace(2) @Mat, align 8
-// CHECK-NEXT: store <2 x float> [[CBUF_LOAD]], ptr [[CBUF_DEST]], align 8
+// CHECK-NEXT: [[CBUF_LOAD:%.*]] = load <2 x float>, ptr addrspace(2) @Mat, align 4
+// CHECK-NEXT: store <2 x float> [[CBUF_LOAD]], ptr [[CBUF_DEST]], align 4
// CHECK-NEXT: [[CBUF_DEST1:%.*]] = getelementptr inbounds [3 x <2 x float>], ptr [[MATRIX_BUF_COPY]], i32 0, i32 1
-// CHECK-NEXT: [[CBUF_LOAD2:%.*]] = load <2 x float>, ptr addrspace(2) getelementptr inbounds nuw (i8, ptr addrspace(2) @Mat, i32 16), align 8
-// CHECK-NEXT: store <2 x float> [[CBUF_LOAD2]], ptr [[CBUF_DEST1]], align 8
+// CHECK-NEXT: [[CBUF_LOAD2:%.*]] = load <2 x float>, ptr addrspace(2) getelementptr inbounds nuw (i8, ptr addrspace(2) @Mat, i32 16), align 4
+// CHECK-NEXT: store <2 x float> [[CBUF_LOAD2]], ptr [[CBUF_DEST1]], align 4
// CHECK-NEXT: [[CBUF_DEST3:%.*]] = getelementptr inbounds [3 x <2 x float>], ptr [[MATRIX_BUF_COPY]], i32 0, i32 2
-// CHECK-NEXT: [[CBUF_LOAD4:%.*]] = load <2 x float>, ptr addrspace(2) getelementptr inbounds nuw (i8, ptr addrspace(2) @Mat, i32 32), align 8
-// CHECK-NEXT: store <2 x float> [[CBUF_LOAD4]], ptr [[CBUF_DEST3]], align 8
-// CHECK-NEXT: [[TMP0:%.*]] = load <6 x float>, ptr [[MATRIX_BUF_COPY]], align 8
+// CHECK-NEXT: [[CBUF_LOAD4:%.*]] = load <2 x float>, ptr addrspace(2) getelementptr inbounds nuw (i8, ptr addrspace(2) @Mat, i32 32), align 4
+// CHECK-NEXT: store <2 x float> [[CBUF_LOAD4]], ptr [[CBUF_DEST3]], align 4
+// CHECK-NEXT: [[TMP0:%.*]] = load <6 x float>, ptr [[MATRIX_BUF_COPY]], align 4
// CHECK-NEXT: [[TMP1:%.*]] = shufflevector <6 x float> [[TMP0]], <6 x float> poison, <2 x i32> <i32 4, i32 1>
// CHECK-NEXT: ret <2 x float> [[TMP1]]
//
diff --git a/clang/test/CodeGenHLSL/resources/MatrixElement_cbuffer.hlsl b/clang/test/CodeGenHLSL/resources/MatrixElement_cbuffer.hlsl
index e0ef9ce92fa81..0b4dc5b9c6485 100644
--- a/clang/test/CodeGenHLSL/resources/MatrixElement_cbuffer.hlsl
+++ b/clang/test/CodeGenHLSL/resources/MatrixElement_cbuffer.hlsl
@@ -25,17 +25,17 @@ cbuffer CB {
// COL-CHECK-NEXT: [[TMP1:%.*]] = extractelement <6 x float> [[TMP0]], i32 4
// COL-CHECK-NEXT: ret float [[TMP1]]
//
-// ROW-CHECK-NEXT: [[MATRIX_BUF_COPY:%.*]] = alloca [3 x <2 x float>], align 8
+// ROW-CHECK-NEXT: [[MATRIX_BUF_COPY:%.*]] = alloca [3 x <2 x float>], align 4
// ROW-CHECK-NEXT: [[CBUF_DEST:%.*]] = getelementptr inbounds [3 x <2 x float>], ptr [[MATRIX_BUF_COPY]], i32 0, i32 0
-// ROW-CHECK-NEXT: [[CBUF_LOAD:%.*]] = load <2 x float>, ptr addrspace(2) @Mat, align 8
-// ROW-CHECK-NEXT: store <2 x float> [[CBUF_LOAD]], ptr [[CBUF_DEST]], align 8
+// ROW-CHECK-NEXT: [[CBUF_LOAD:%.*]] = load <2 x float>, ptr addrspace(2) @Mat, align 4
+// ROW-CHECK-NEXT: store <2 x float> [[CBUF_LOAD]], ptr [[CBUF_DEST]], align 4
// ROW-CHECK-NEXT: [[CBUF_DEST1:%.*]] = getelementptr inbounds [3 x <2 x float>], ptr [[MATRIX_BUF_COPY]], i32 0, i32 1
-// ROW-CHECK-NEXT: [[CBUF_LOAD2:%.*]] = load <2 x float>, ptr addrspace(2) getelementptr inbounds nuw (i8, ptr addrspace(2) @Mat, i32 16), align 8
-// ROW-CHECK-NEXT: store <2 x float> [[CBUF_LOAD2]], ptr [[CBUF_DEST1]], align 8
+// ROW-CHECK-NEXT: [[CBUF_LOAD2:%.*]] = load <2 x float>, ptr addrspace(2) getelementptr inbounds nuw (i8, ptr addrspace(2) @Mat, i32 16), align 4
+// ROW-CHECK-NEXT: store <2 x float> [[CBUF_LOAD2]], ptr [[CBUF_DEST1]], align 4
// ROW-CHECK-NEXT: [[CBUF_DEST3:%.*]] = getelementptr inbounds [3 x <2 x float>], ptr [[MATRIX_BUF_COPY]], i32 0, i32 2
-// ROW-CHECK-NEXT: [[CBUF_LOAD4:%.*]] = load <2 x float>, ptr addrspace(2) getelementptr inbounds nuw (i8, ptr addrspace(2) @Mat, i32 32), align 8
-// ROW-CHECK-NEXT: store <2 x float> [[CBUF_LOAD4]], ptr [[CBUF_DEST3]], align 8
-// ROW-CHECK-NEXT: [[TMP0:%.*]] = load <6 x float>, ptr [[MATRIX_BUF_COPY]], align 8
+// ROW-CHECK-NEXT: [[CBUF_LOAD4:%.*]] = load <2 x float>, ptr addrspace(2) getelementptr inbounds nuw (i8, ptr addrspace(2) @Mat, i32 32), align 4
+// ROW-CHECK-NEXT: store <2 x float> [[CBUF_LOAD4]], ptr [[CBUF_DEST3]], align 4
+// ROW-CHECK-NEXT: [[TMP0:%.*]] = load <6 x float>, ptr [[MATRIX_BUF_COPY]], align 4
// ROW-CHECK-NEXT: [[TMP1:%.*]] = extractelement <6 x float> [[TMP0]], i32 3
// ROW-CHECK-NEXT: ret float [[TMP1]]
//
@@ -58,17 +58,17 @@ float getCBufferScalarElement() {
// COL-CHECK-NEXT: [[TMP1:%.*]] = shufflevector <6 x float> [[TMP0]], <6 x float> poison, <4 x i32> <i32 0, i32 3, i32 1, i32 4>
// COL-CHECK-NEXT: ret <4 x float> [[TMP1]]
//
-// ROW-CHECK-NEXT: [[MATRIX_BUF_COPY:%.*]] = alloca [3 x <2 x float>], align 8
+// ROW-CHECK-NEXT: [[MATRIX_BUF_COPY:%.*]] = alloca [3 x <2 x float>], align 4
// ROW-CHECK-NEXT: [[CBUF_DEST:%.*]] = getelementptr inbounds [3 x <2 x float>], ptr [[MATRIX_BUF_COPY]], i32 0, i32 0
-// ROW-CHECK-NEXT: [[CBUF_LOAD:%.*]] = load <2 x float>, ptr addrspace(2) @Mat, align 8
-// ROW-CHECK-NEXT: store <2 x float> [[CBUF_LOAD]], ptr [[CBUF_DEST]], align 8
+// ROW-CHECK-NEXT: [[CBUF_LOAD:%.*]] = load <2 x float>, ptr addrspace(2) @Mat, align 4
+// ROW-CHECK-NEXT: store <2 x float> [[CBUF_LOAD]], ptr [[CBUF_DEST]], align 4
// ROW-CHECK-NEXT: [[CBUF_DEST1:%.*]] = getelementptr inbounds [3 x <2 x float>], ptr [[MATRIX_BUF_COPY]], i32 0, i32 1
-// ROW-CHECK-NEXT: [[CBUF_LOAD2:%.*]] = load <2 x float>, ptr addrspace(2) getelementptr inbounds nuw (i8, ptr addrspace(2) @Mat, i32 16), align 8
-// ROW-CHECK-NEXT: store <2 x float> [[CBUF_LOAD2]], ptr [[CBUF_DEST1]], align 8
+// ROW-CHECK-NEXT: [[CBUF_LOAD2:%.*]] = load <2 x float>, ptr addrspace(2) getelementptr inbounds nuw (i8, ptr addrspace(2) @Mat, i32 16), align 4
+// ROW-CHECK-NEXT: store <2 x float> [[CBUF_LOAD2]], ptr [[CBUF_DEST1]], align 4
// ROW-CHECK-NEXT: [[CBUF_DEST3:%.*]] = getelementptr inbounds [3 x <2 x float>], ptr [[MATRIX_BUF_COPY]], i32 0, i32 2
-// ROW-CHECK-NEXT: [[CBUF_LOAD4:%.*]] = load <2 x float>, ptr addrspace(2) getelementptr inbounds nuw (i8, ptr addrspace(2) @Mat, i32 32), align 8
-// ROW-CHECK-NEXT: store <2 x float> [[CBUF_LOAD4]], ptr [[CBUF_DEST3]], align 8
-// ROW-CHECK-NEXT: [[TMP0:%.*]] = load <6 x float>, ptr [[MATRIX_BUF_COPY]], align 8
+// ROW-CHECK-NEXT: [[CBUF_LOAD4:%.*]] = load <2 x float>, ptr addrspace(2) getelementptr inbounds nuw (i8, ptr addrspace(2) @Mat, i32 32), align 4
+// ROW-CHECK-NEXT: store <2 x float> [[CBUF_LOAD4]], ptr [[CBUF_DEST3]], align 4
+// ROW-CHECK-NEXT: [[TMP0:%.*]] = load <6 x float>, ptr [[MATRIX_BUF_COPY]], align 4
// ROW-CHECK-NEXT: [[TMP1:%.*]] = shufflevector <6 x float> [[TMP0]], <6 x float> poison, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
// ROW-CHECK-NEXT: ret <4 x float> [[TMP1]]
//
diff --git a/clang/test/CodeGenHLSL/resources/RasterizerOrderedStructuredBuffer-elementtype.hlsl b/clang/test/CodeGenHLSL/resources/RasterizerOrderedStructuredBuffer-elementtype.hlsl
index 843f14474a23f..105c3e25c6d10 100644
--- a/clang/test/CodeGenHLSL/resources/RasterizerOrderedStructuredBuffer-elementtype.hlsl
+++ b/clang/test/CodeGenHLSL/resources/RasterizerOrderedStructuredBuffer-elementtype.hlsl
@@ -18,7 +18,7 @@ struct MyStruct {
// DXIL: %"class.hlsl::RasterizerOrderedStructuredBuffer.9" = type { target("dx.RawBuffer", <3 x i32>, 1, 1), target("dx.RawBuffer", <3 x i32>, 1, 1) }
// DXIL: %"class.hlsl::RasterizerOrderedStructuredBuffer.10" = type { target("dx.RawBuffer", <2 x half>, 1, 1), target("dx.RawBuffer", <2 x half>, 1, 1) }
// DXIL: %"class.hlsl::RasterizerOrderedStructuredBuffer.11" = type { target("dx.RawBuffer", <3 x float>, 1, 1), target("dx.RawBuffer", <3 x float>, 1, 1) }
-// DXIL: %struct.MyStruct = type <{ <4 x float>, <2 x i32> }>
+// DXIL: %struct.MyStruct = type { <4 x float>, <2 x i32> }
RasterizerOrderedStructuredBuffer<int16_t> BufI16;
RasterizerOrderedStructuredBuffer<uint16_t> BufU16;
diff --git a/clang/test/CodeGenHLSL/resources/cbuffer_geps.hlsl b/clang/test/CodeGenHLSL/resources/cbuffer_geps.hlsl
index 366aa108b5421..6fb0fed32d42d 100644
--- a/clang/test/CodeGenHLSL/resources/cbuffer_geps.hlsl
+++ b/clang/test/CodeGenHLSL/resources/cbuffer_geps.hlsl
@@ -69,13 +69,13 @@ cbuffer CBStructs {
// CHECK-LABEL: define hidden void @_Z9cbstructsv()
void cbstructs() {
- // CHECK: load <2 x float>, ptr addrspace(2) @s1, align 8
+ // CHECK: load <2 x float>, ptr addrspace(2) @s1, align 4
use(s1.a1);
// CHECK: load <3 x i16>, ptr addrspace(2) getelementptr inbounds nuw (i8, ptr addrspace(2) @s2, i32 8), align 2
use(s2.b1);
- // CHECK: load <2 x float>, ptr addrspace(2) getelementptr inbounds nuw (i8, ptr addrspace(2) @s3, i32 16), align 8
+ // CHECK: load <2 x float>, ptr addrspace(2) getelementptr inbounds nuw (i8, ptr addrspace(2) @s3, i32 16), align 4
use(s3.c2.a1);
- // CHECK: load <2 x float>, ptr addrspace(2) getelementptr inbounds nuw (i8, ptr addrspace(2) @s4, i32 32), align 8
+ // CHECK: load <2 x float>, ptr addrspace(2) getelementptr inbounds nuw (i8, ptr addrspace(2) @s4, i32 32), align 4
use(s4[2].a1);
// CHECK: load <3 x i16>, ptr addrspace(2) getelementptr inbounds nuw (i8, ptr addrspace(2) @s5, i32 376), align 2
use(s5.d1[3][5].b1);
@@ -108,9 +108,9 @@ void cbmix() {
use(m3.y);
// CHECK: load <2 x float>, ptr addrspace(2) getelementptr inbounds nuw (i8, ptr addrspace(2) @m4, i32 176), align 16
use(m4[2][3]);
- // CHECK: load <4 x i32>, ptr addrspace(2) getelementptr inbounds nuw (i8, ptr addrspace(2) @m5, i32 16), align 16
+ // CHECK: load <4 x i32>, ptr addrspace(2) getelementptr inbounds nuw (i8, ptr addrspace(2) @m5, i32 16), align 4
use(m5.d);
- // CHECK: load <4 x i32>, ptr addrspace(2) getelementptr inbounds nuw (i8, ptr addrspace(2) @m6, i32 240), align 16
+ // CHECK: load <4 x i32>, ptr addrspace(2) getelementptr inbounds nuw (i8, ptr addrspace(2) @m6, i32 240), align 4
use(m6.j[2].x[2]);
// CHECK: load <1 x double>, ptr addrspace(2) @m7, align 8
use(m7);
diff --git a/clang/test/CodeGenHLSL/semantics/semantic.array.hlsl b/clang/test/CodeGenHLSL/semantics/semantic.array.hlsl
index f57ac607db5bd..445a1f5a33f12 100644
--- a/clang/test/CodeGenHLSL/semantics/semantic.array.hlsl
+++ b/clang/test/CodeGenHLSL/semantics/semantic.array.hlsl
@@ -22,8 +22,8 @@ struct S0 {
// CHECK-SPIRV: %[[#A01:]] = load <4 x float>, ptr addrspace(7) @A2, align 16
// CHECK-SPIRV: %[[#TMP1:]] = insertvalue %struct.S0 %[[#TMP0]], <4 x float> %[[#A01]], 1
-// CHECK: %[[#ARG:]] = alloca %struct.S0, align 16
-// CHECK: store %struct.S0 %[[#TMP1]], ptr %[[#ARG]], align 16
+// CHECK: %[[#ARG:]] = alloca %struct.S0
+// CHECK: store %struct.S0 %[[#TMP1]], ptr %[[#ARG]]
// CHECK-DXIL: call void @{{.*}}main0{{.*}}(ptr %[[#ARG]])
// CHECK-SPIRV: call spir_func void @{{.*}}main0{{.*}}(ptr %[[#ARG]])
[shader("pixel")]
diff --git a/clang/test/CodeGenHLSL/semantics/semantic.array.output.hlsl b/clang/test/CodeGenHLSL/semantics/semantic.array.output.hlsl
index d75f4e0ca8338..7662b9ab881d9 100644
--- a/clang/test/CodeGenHLSL/semantics/semantic.array.output.hlsl
+++ b/clang/test/CodeGenHLSL/semantics/semantic.array.output.hlsl
@@ -10,13 +10,13 @@ struct S0 {
[shader("pixel")]
S0 main1(float4 input : A) : B {
-// CHECK: %[[#ARG:]] = alloca %struct.S0, align 16
+// CHECK: %[[#ARG:]] = alloca %struct.S0
// CHECK-SPIRV: %[[#INPUT:]] = load <4 x float>, ptr addrspace(7) @A0, align 16
// CHECK-DXIL: %A0 = call <4 x float> @llvm.dx.load.input.v4f32(i32 4, i32 0, i32 0, i8 0, i32 poison)
// CHECK-DXIL: call void @{{.*}}main1{{.*}}(ptr %[[#ARG]], <4 x float> %A0)
// CHECK-SPIRV: call spir_func void @{{.*}}main1{{.*}}(ptr %[[#ARG]], <4 x float> %[[#INPUT]])
- // CHECK: %[[#ST:]] = load %struct.S0, ptr %[[#ARG]], align 16
+ // CHECK: %[[#ST:]] = load %struct.S0, ptr %[[#ARG]]
// CHECK: %[[#TMP:]] = extractvalue %struct.S0 %[[#ST]], 0
// CHECK-SPIRV: store [2 x <4 x float>] %[[#TMP]], ptr addrspace(8) @B0, align 16
// CHECK-DXIL: call void @llvm.dx.store.output.a2v4f32(i32 4, i32 0, i32 0, i8 0, i32 poison, [2 x <4 x float>] %[[#TMP]])
diff --git a/clang/test/CodeGenHLSL/semantics/semantic.explicit-location-output-struct.hlsl b/clang/test/CodeGenHLSL/semantics/semantic.explicit-location-output-struct.hlsl
index c5d86637fb4ea..124badf756610 100644
--- a/clang/test/CodeGenHLSL/semantics/semantic.explicit-location-output-struct.hlsl
+++ b/clang/test/CodeGenHLSL/semantics/semantic.explicit-location-output-struct.hlsl
@@ -10,14 +10,14 @@ struct Output {
// CHECK: define void @main() {{.*}} {
Output main(float4 p : SV_Position) {
- // CHECK: %[[#OUT:]] = alloca %struct.Output, align 16
+ // CHECK: %[[#OUT:]] = alloca %struct.Output
// CHECK-SPIRV: %[[#IN:]] = load <4 x float>, ptr addrspace(7) @SV_Position, align 16
// CHECK-SPIRV: call spir_func void @_Z4mainDv4_f(ptr %[[#OUT]], <4 x float> %[[#IN]])
// CHECK-DXIL: call void @_Z4mainDv4_f(ptr %[[#OUT]], <4 x float> %SV_Position0)
- // CHECK: %[[#TMP:]] = load %struct.Output, ptr %[[#OUT]], align 16
+ // CHECK: %[[#TMP:]] = load %struct.Output, ptr %[[#OUT]]
// CHECK: %[[#FIELD:]] = extractvalue %struct.Output %[[#TMP]], 0
// CHECK-SPIRV: store <4 x float> %[[#FIELD]], ptr addrspace(8) @SV_Target0, align 16
diff --git a/clang/test/CodeGenHLSL/semantics/semantic.struct.hlsl b/clang/test/CodeGenHLSL/semantics/semantic.struct.hlsl
index 733cf3a1a7b9d..38a7559712a95 100644
--- a/clang/test/CodeGenHLSL/semantics/semantic.struct.hlsl
+++ b/clang/test/CodeGenHLSL/semantics/semantic.struct.hlsl
@@ -38,7 +38,7 @@ struct S1 {
// CHECK: %[[#ID_XY:]] = insertelement <2 x i32> %[[#ID_X_]], i32 %[[#ID_Y]], i64 1
// CHECK: %[[#S1AB:]] = insertvalue %struct.S1 %[[#S1A_]], <2 x i32> %[[#ID_XYZ:]], 1
// CHECK: %[[#ARG:]] = alloca %struct.S1, align 8
-// CHECK: store %struct.S1 %[[#S1AB]], ptr %[[#ARG]], align 8
+// CHECK: store %struct.S1 %[[#S1AB]], ptr %[[#ARG]]
// CHECK-DXIL: call void @{{.*}}main1{{.*}}(ptr %[[#ARG]])
// CHECK-SPIRV: call spir_func void @{{.*}}main1{{.*}}(ptr %[[#ARG]])
[shader("compute")]
@@ -69,7 +69,7 @@ struct S2 {
// CHECK: %[[#S2AB:]] = insertvalue %struct.S2 %[[#S2A_]], %struct.S2C %[[#S2V:]], 1
// CHECK: %[[#ARG:]] = alloca %struct.S2, align 8
-// CHECK: store %struct.S2 %[[#S2AB]], ptr %[[#ARG]], align 1
+// CHECK: store %struct.S2 %[[#S2AB]], ptr %[[#ARG]]
// CHECK-DXIL: call void @{{.*}}main2{{.*}}(ptr %[[#ARG]])
// CHECK-SPIRV: call spir_func void @{{.*}}main2{{.*}}(ptr %[[#ARG]])
[shader("compute")]
diff --git a/llvm/lib/TargetParser/TargetDataLayout.cpp b/llvm/lib/TargetParser/TargetDataLayout.cpp
index b985c1eec4244..91c41103a564c 100644
--- a/llvm/lib/TargetParser/TargetDataLayout.cpp
+++ b/llvm/lib/TargetParser/TargetDataLayout.cpp
@@ -563,11 +563,8 @@ std::string Triple::computeDataLayout(StringRef ABIName) const {
case Triple::csky:
return computeCSKYDataLayout(*this);
case Triple::dxil:
- // TODO: We need to align vectors on the element size generally, but for now
- // we hard code this for 3-element 32- and 64-bit vectors as a workaround.
- // See https://github.com/llvm/llvm-project/issues/123968
- return "e-m:e-p:32:32-i1:32-i8:8-i16:16-i32:32-i64:64-f16:16-"
- "f32:32-f64:64-n8:16:32:64-v48:16:16-v96:32:32-v192:64:64";
+ return "e-m:e-ve-p:32:32-i1:32-i8:8-i16:16-i32:32-i64:64-f16:16-"
+ "f32:32-f64:64-n8:16:32:64";
case Triple::hexagon:
return "e-m:e-p:32:32:32-a:0-n16:32-"
"i64:64:64-i32:32:32-i16:16:16-i1:8:8-f32:32:32-f64:64:64-"
diff --git a/llvm/test/CodeGen/DirectX/CreateHandleFromBinding.ll b/llvm/test/CodeGen/DirectX/CreateHandleFromBinding.ll
index 671fcef281314..78f6a9a8049f3 100644
--- a/llvm/test/CodeGen/DirectX/CreateHandleFromBinding.ll
+++ b/llvm/test/CodeGen/DirectX/CreateHandleFromBinding.ll
@@ -52,7 +52,7 @@ define void @test_bindings() {
@llvm.dx.resource.handlefrombinding.tdx.RawBuffer_sl_v4f32v4i32s_0_0t(
i32 4, i32 2, i32 1, i32 0, ptr null)
; CHECK: [[BUF3:%.*]] = call %dx.types.Handle @dx.op.createHandleFromBinding(i32 217, %dx.types.ResBind { i32 2, i32 2, i32 4, i8 0 }, i32 2, i1 false) #[[#ATTR]]
- ; CHECK: = call %dx.types.Handle @dx.op.annotateHandle(i32 216, %dx.types.Handle [[BUF3]], %dx.types.ResourceProperties { i32 1036, i32 32 }) #[[#ATTR]]
+ ; CHECK: = call %dx.types.Handle @dx.op.annotateHandle(i32 216, %dx.types.Handle [[BUF3]], %dx.types.ResourceProperties { i32 524, i32 32 }) #[[#ATTR]]
; ByteAddressBuffer Buf : register(t8, space1)
%byteaddr0 = call target("dx.RawBuffer", i8, 0, 0)
diff --git a/llvm/test/CodeGen/DirectX/MemIntrinsics/memcpy-pointee.ll b/llvm/test/CodeGen/DirectX/MemIntrinsics/memcpy-pointee.ll
index ae6793310fdb3..d24c1d6592c42 100644
--- a/llvm/test/CodeGen/DirectX/MemIntrinsics/memcpy-pointee.ll
+++ b/llvm/test/CodeGen/DirectX/MemIntrinsics/memcpy-pointee.ll
@@ -7,18 +7,18 @@ define void @test_structarray_alloca() "hlsl.export" {
; CHECK-LABEL: define void @test_structarray_alloca(
; CHECK-SAME: ) #[[ATTR0:[0-9]+]] {
; CHECK-NEXT: [[ENTRY:.*:]]
-; CHECK-NEXT: [[OUT:%.*]] = alloca [[STRUCT_S:%.*]], align 16
-; CHECK-NEXT: [[IN:%.*]] = alloca [[STRUCT_S]], align 16
+; CHECK-NEXT: [[OUT:%.*]] = alloca [[STRUCT_S:%.*]], align 8
+; CHECK-NEXT: [[IN:%.*]] = alloca [[STRUCT_S]], align 8
; CHECK-NEXT: [[OUT_I:%.*]] = getelementptr inbounds nuw i8, ptr [[OUT]], i32 16
; CHECK-NEXT: [[IN_I:%.*]] = getelementptr inbounds nuw i8, ptr [[IN]], i32 16
; CHECK-NEXT: [[TMP0:%.*]] = getelementptr inbounds i8, ptr [[IN_I]], i32 0
-; CHECK-NEXT: [[TMP1:%.*]] = load <4 x i32>, ptr [[TMP0]], align 16
+; CHECK-NEXT: [[TMP1:%.*]] = load <4 x i32>, ptr [[TMP0]], align 4
; CHECK-NEXT: [[TMP2:%.*]] = getelementptr inbounds i8, ptr [[OUT_I]], i32 0
-; CHECK-NEXT: store <4 x i32> [[TMP1]], ptr [[TMP2]], align 16
+; CHECK-NEXT: store <4 x i32> [[TMP1]], ptr [[TMP2]], align 4
; CHECK-NEXT: [[TMP3:%.*]] = getelementptr inbounds i8, ptr [[IN_I]], i32 16
-; CHECK-NEXT: [[TMP4:%.*]] = load <4 x i32>, ptr [[TMP3]], align 16
+; CHECK-NEXT: [[TMP4:%.*]] = load <4 x i32>, ptr [[TMP3]], align 4
; CHECK-NEXT: [[TMP5:%.*]] = getelementptr inbounds i8, ptr [[OUT_I]], i32 16
-; CHECK-NEXT: store <4 x i32> [[TMP4]], ptr [[TMP5]], align 16
+; CHECK-NEXT: store <4 x i32> [[TMP4]], ptr [[TMP5]], align 4
; CHECK-NEXT: ret void
;
entry:
@@ -34,18 +34,18 @@ define void @test_structarray_alloca_typed() "hlsl.export" {
; CHECK-LABEL: define void @test_structarray_alloca_typed(
; CHECK-SAME: ) #[[ATTR0]] {
; CHECK-NEXT: [[ENTRY:.*:]]
-; CHECK-NEXT: [[OUT:%.*]] = alloca [[STRUCT_S:%.*]], align 16
-; CHECK-NEXT: [[IN:%.*]] = alloca [[STRUCT_S]], align 16
+; CHECK-NEXT: [[OUT:%.*]] = alloca [[STRUCT_S:%.*]], align 8
+; CHECK-NEXT: [[IN:%.*]] = alloca [[STRUCT_S]], align 8
; CHECK-NEXT: [[OUT_I:%.*]] = getelementptr { <4 x i32>, [2 x <4 x i32>] }, ptr [[OUT]], i32 0, i32 1
; CHECK-NEXT: [[IN_I:%.*]] = getelementptr { <4 x i32>, [2 x <4 x i32>] }, ptr [[IN]], i32 0, i32 1
; CHECK-NEXT: [[GEP:%.*]] = getelementptr inbounds i8, ptr [[IN_I]], i32 0
-; CHECK-NEXT: [[TMP0:%.*]] = load <4 x i32>, ptr [[GEP]], align 16
+; CHECK-NEXT: [[TMP0:%.*]] = load <4 x i32>, ptr [[GEP]], align 4
; CHECK-NEXT: [[GEP1:%.*]] = getelementptr inbounds i8, ptr [[OUT_I]], i32 0
-; CHECK-NEXT: store <4 x i32> [[TMP0]], ptr [[GEP1]], align 16
+; CHECK-NEXT: store <4 x i32> [[TMP0]], ptr [[GEP1]], align 4
; CHECK-NEXT: [[GEP2:%.*]] = getelementptr inbounds i8, ptr [[IN_I]], i32 16
-; CHECK-NEXT: [[TMP1:%.*]] = load <4 x i32>, ptr [[GEP2]], align 16
+; CHECK-NEXT: [[TMP1:%.*]] = load <4 x i32>, ptr [[GEP2]], align 4
; CHECK-NEXT: [[GEP3:%.*]] = getelementptr inbounds i8, ptr [[OUT_I]], i32 16
-; CHECK-NEXT: store <4 x i32> [[TMP1]], ptr [[GEP3]], align 16
+; CHECK-NEXT: store <4 x i32> [[TMP1]], ptr [[GEP3]], align 4
; CHECK-NEXT: ret void
;
entry:
@@ -63,10 +63,10 @@ define void @test_structarray_groupshared() "hlsl.export" {
; CHECK-LABEL: define void @test_structarray_groupshared(
; CHECK-SAME: ) #[[ATTR0]] {
; CHECK-NEXT: [[ENTRY:.*:]]
-; CHECK-NEXT: [[TMP0:%.*]] = load <4 x i32>, ptr addrspace(3) getelementptr inbounds nuw (i8, ptr addrspace(3) @shared2, i32 16), align 16
-; CHECK-NEXT: store <4 x i32> [[TMP0]], ptr addrspace(3) getelementptr inbounds nuw (i8, ptr addrspace(3) @shared1, i32 16), align 16
-; CHECK-NEXT: [[TMP1:%.*]] = load <4 x i32>, ptr addrspace(3) getelementptr inbounds (i8, ptr addrspace(3) getelementptr inbounds nuw (i8, ptr addrspace(3) @shared2, i32 16), i32 16), align 16
-; CHECK-NEXT: store <4 x i32> [[TMP1]], ptr addrspace(3) getelementptr inbounds (i8, ptr addrspace(3) getelementptr inbounds nuw (i8, ptr addrspace(3) @shared1, i32 16), i32 16), align 16
+; CHECK-NEXT: [[TMP0:%.*]] = load <4 x i32>, ptr addrspace(3) getelementptr inbounds nuw (i8, ptr addrspace(3) @shared2, i32 16), align 4
+; CHECK-NEXT: store <4 x i32> [[TMP0]], ptr addrspace(3) getelementptr inbounds nuw (i8, ptr addrspace(3) @shared1, i32 16), align 4
+; CHECK-NEXT: [[TMP1:%.*]] = load <4 x i32>, ptr addrspace(3) getelementptr inbounds (i8, ptr addrspace(3) getelementptr inbounds nuw (i8, ptr addrspace(3) @shared2, i32 16), i32 16), align 4
+; CHECK-NEXT: store <4 x i32> [[TMP1]], ptr addrspace(3) getelementptr inbounds (i8, ptr addrspace(3) getelementptr inbounds nuw (i8, ptr addrspace(3) @shared1, i32 16), i32 16), align 4
; CHECK-NEXT: ret void
;
entry:
@@ -85,13 +85,13 @@ define void @test_structarray_in_buffer() "hlsl.export" {
; CHECK-NEXT: [[P_IN:%.*]] = tail call noundef nonnull align 1 dereferenceable(48) ptr @llvm.dx.resource.getpointer.p0.tdx.RawBuffer_s_struct.Ss_0_0t(target("dx.RawBuffer", [[STRUCT_S]], 0, 0) [[H_IN]], i32 0)
; CHECK-NEXT: [[IN_I:%.*]] = getelementptr inbounds nuw i8, ptr [[P_IN]], i32 16
; CHECK-NEXT: [[TMP0:%.*]] = getelementptr inbounds i8, ptr [[OUT_I]], i32 0
-; CHECK-NEXT: [[TMP1:%.*]] = load <4 x i32>, ptr [[TMP0]], align 16
+; CHECK-NEXT: [[TMP1:%.*]] = load <4 x i32>, ptr [[TMP0]], align 4
; CHECK-NEXT: [[TMP2:%.*]] = getelementptr inbounds i8, ptr [[IN_I]], i32 0
-; CHECK-NEXT: store <4 x i32> [[TMP1]], ptr [[TMP2]], align 16
+; CHECK-NEXT: store <4 x i32> [[TMP1]], ptr [[TMP2]], align 4
; CHECK-NEXT: [[TMP3:%.*]] = getelementptr inbounds i8, ptr [[OUT_I]], i32 16
-; CHECK-NEXT: [[TMP4:%.*]] = load <4 x i32>, ptr [[TMP3]], align 16
+; CHECK-NEXT: [[TMP4:%.*]] = load <4 x i32>, ptr [[TMP3]], align 4
; CHECK-NEXT: [[TMP5:%.*]] = getelementptr inbounds i8, ptr [[IN_I]], i32 16
-; CHECK-NEXT: store <4 x i32> [[TMP4]], ptr [[TMP5]], align 16
+; CHECK-NEXT: store <4 x i32> [[TMP4]], ptr [[TMP5]], align 4
; CHECK-NEXT: ret void
;
entry:
diff --git a/llvm/test/CodeGen/DirectX/MemIntrinsics/memcpy-struct.ll b/llvm/test/CodeGen/DirectX/MemIntrinsics/memcpy-struct.ll
index 060d08d99b550..1afac40091a61 100644
--- a/llvm/test/CodeGen/DirectX/MemIntrinsics/memcpy-struct.ll
+++ b/llvm/test/CodeGen/DirectX/MemIntrinsics/memcpy-struct.ll
@@ -7,20 +7,20 @@ define void @test_struct_alloca() "hlsl.export" {
; CHECK-LABEL: define void @test_struct_alloca(
; CHECK-SAME: ) #[[ATTR0:[0-9]+]] {
; CHECK-NEXT: [[ENTRY:.*:]]
-; CHECK-NEXT: [[OUT:%.*]] = alloca [[STRUCT_S:%.*]], align 16
-; CHECK-NEXT: [[IN:%.*]] = alloca [[STRUCT_S]], align 16
+; CHECK-NEXT: [[OUT:%.*]] = alloca [[STRUCT_S:%.*]], align 8
+; CHECK-NEXT: [[IN:%.*]] = alloca [[STRUCT_S]], align 8
; CHECK-NEXT: [[TMP0:%.*]] = getelementptr inbounds i8, ptr [[IN]], i32 0
-; CHECK-NEXT: [[TMP1:%.*]] = load <4 x i32>, ptr [[TMP0]], align 16
+; CHECK-NEXT: [[TMP1:%.*]] = load <4 x i32>, ptr [[TMP0]], align 4
; CHECK-NEXT: [[TMP2:%.*]] = getelementptr inbounds i8, ptr [[OUT]], i32 0
-; CHECK-NEXT: store <4 x i32> [[TMP1]], ptr [[TMP2]], align 16
+; CHECK-NEXT: store <4 x i32> [[TMP1]], ptr [[TMP2]], align 4
; CHECK-NEXT: [[TMP3:%.*]] = getelementptr inbounds i8, ptr [[IN]], i32 16
-; CHECK-NEXT: [[TMP4:%.*]] = load <4 x i32>, ptr [[TMP3]], align 16
+; CHECK-NEXT: [[TMP4:%.*]] = load <4 x i32>, ptr [[TMP3]], align 4
; CHECK-NEXT: [[TMP5:%.*]] = getelementptr inbounds i8, ptr [[OUT]], i32 16
-; CHECK-NEXT: store <4 x i32> [[TMP4]], ptr [[TMP5]], align 16
+; CHECK-NEXT: store <4 x i32> [[TMP4]], ptr [[TMP5]], align 4
; CHECK-NEXT: [[TMP6:%.*]] = getelementptr inbounds i8, ptr [[IN]], i32 32
-; CHECK-NEXT: [[TMP7:%.*]] = load <4 x i32>, ptr [[TMP6]], align 16
+; CHECK-NEXT: [[TMP7:%.*]] = load <4 x i32>, ptr [[TMP6]], align 4
; CHECK-NEXT: [[TMP8:%.*]] = getelementptr inbounds i8, ptr [[OUT]], i32 32
-; CHECK-NEXT: store <4 x i32> [[TMP7]], ptr [[TMP8]], align 16
+; CHECK-NEXT: store <4 x i32> [[TMP7]], ptr [[TMP8]], align 4
; CHECK-NEXT: ret void
;
entry:
diff --git a/llvm/test/CodeGen/DirectX/WaveActiveBallot.ll b/llvm/test/CodeGen/DirectX/WaveActiveBallot.ll
index f0440cb4e6183..94fb8eb68eb40 100644
--- a/llvm/test/CodeGen/DirectX/WaveActiveBallot.ll
+++ b/llvm/test/CodeGen/DirectX/WaveActiveBallot.ll
@@ -1,6 +1,5 @@
; RUN: opt -S -scalarizer -dxil-op-lower %s | FileCheck %s
-target datalayout = "e-m:e-p:32:32-i1:32-i8:8-i16:16-i32:32-i64:64-f16:16-f32:32-f64:64-n8:16:32:64-v48:16:16-v96:32:32-v192:64:64"
target triple = "dxilv1.3-pc-shadermodel6.3-compute"
; The definition of the custom type should be added
More information about the cfe-commits
mailing list