[clang] 0b79f71 - [clang][OpenMP] Fix crash on `linear(uval)` with a reference parameter (#237754)
via cfe-commits
cfe-commits at lists.llvm.org
Wed Nov 4 05:08:00 PST 2026
Author: Akash Manna
Date: 2026-11-04T13:07:54Z
New Revision: 0b79f71295fd68e7bbb4771f55edcc75b8de0b58
URL: https://github.com/llvm/llvm-project/commit/0b79f71295fd68e7bbb4771f55edcc75b8de0b58
DIFF: https://github.com/llvm/llvm-project/commit/0b79f71295fd68e7bbb4771f55edcc75b8de0b58.diff
LOG: [clang][OpenMP] Fix crash on `linear(uval)` with a reference parameter (#237754)
Fixes #108166
`linear(uval(x))` crashed when `x` is a reference parameter. For `uval`,
Sema read the initial value from the reference's initializer instead of
the reference, and a parameter has none, so a null `Expr` reached
`DefaultLvalueConversion`. Even with an initializer this was wrong: a
defaulted `int &x = g` made the loop update `g`, and in a `parallel`
region or a lambda it could name an uncaptured variable.
Drop the shortcut in `ActOnOpenMPLinearClause` and
`FinishOpenMPLinearClause`, so a `uval` item is read from and written
back through the reference, like `val`. That is what the spec says for
loop constructs, where `uval` only adds the requirement that the item be
a reference, which is still checked.
AI Assisted!
Added:
clang/test/OpenMP/simd_linear_uval_codegen.cpp
Modified:
clang/docs/ReleaseNotes.md
clang/lib/Sema/SemaOpenMP.cpp
clang/test/OpenMP/for_linear_codegen.cpp
clang/test/OpenMP/simd_codegen.cpp
clang/test/OpenMP/simd_linear_messages.cpp
Removed:
################################################################################
diff --git a/clang/docs/ReleaseNotes.md b/clang/docs/ReleaseNotes.md
index 409d2459b0580..e72d30e5ebbd2 100644
--- a/clang/docs/ReleaseNotes.md
+++ b/clang/docs/ReleaseNotes.md
@@ -1544,6 +1544,8 @@ The `alpha.cplusplus.UseAfterLifetimeEnd` checker was renamed to `alpha.core.Use
`_BitInt` type wider than any standard integer type. (#GH140074)
- Fixed a crash when a non-static data member appears in a `lastprivate` clause
inside a member function template of a non-template class. (#GH144302)
+- Fixed a crash when a `linear` clause with the `uval` modifier names a
+ reference without an initializer, such as a reference parameter. (#GH108166)
- Loop-transforming constructs such as `tile` and `unroll` are now allowed
inside a `simd` region for OpenMP 6.0 or later, which classifies them as
simdizable.
diff --git a/clang/lib/Sema/SemaOpenMP.cpp b/clang/lib/Sema/SemaOpenMP.cpp
index d524a3dd183e5..6da0f1870b899 100644
--- a/clang/lib/Sema/SemaOpenMP.cpp
+++ b/clang/lib/Sema/SemaOpenMP.cpp
@@ -23191,7 +23191,6 @@ OMPClause *SemaOpenMP::ActOnOpenMPLinearClause(
DeclRefExpr *PrivateRef = buildDeclRefExpr(SemaRef, Private, Type, ELoc);
// Build var to save initial value.
VarDecl *Init = buildVarDecl(SemaRef, ELoc, Type, ".linear.start");
- Expr *InitExpr;
DeclRefExpr *Ref = nullptr;
bool IsBindingDecl = isa<BindingDecl>(D);
if (!VD && !IsBindingDecl && !SemaRef.CurContext->isDependentContext()) {
@@ -23212,10 +23211,10 @@ OMPClause *SemaOpenMP::ActOnOpenMPLinearClause(
}
}
}
- if (LinKind == OMPC_LINEAR_uval)
- InitExpr = VD ? VD->getInit() : SimpleRefExpr;
- else
- InitExpr = (VD || IsBindingDecl) ? SimpleRefExpr : Ref;
+ // Read the initial value through the list item itself for every modifier;
+ // a 'uval' item is a reference whose referenced value is linear, exactly as
+ // for 'val', and need not have an initializer (e.g. a reference parameter).
+ Expr *InitExpr = Ref ? Ref : SimpleRefExpr;
SemaRef.AddInitializerToDecl(
Init, SemaRef.DefaultLvalueConversion(InitExpr).get(),
/*DirectInit=*/false);
@@ -23293,7 +23292,6 @@ static bool FinishOpenMPLinearClause(OMPLinearClause &Clause, DeclRefExpr *IV,
bool HasErrors = false;
auto CurInit = Clause.inits().begin();
auto CurPrivate = Clause.privates().begin();
- OpenMPLinearClauseKind LinKind = Clause.getModifier();
for (Expr *RefExpr : Clause.varlist()) {
SourceLocation ELoc;
SourceRange ERange;
@@ -23321,13 +23319,12 @@ static bool FinishOpenMPLinearClause(OMPLinearClause &Clause, DeclRefExpr *IV,
}
Expr *InitExpr = *CurInit;
- // Build privatized reference to the current linear var.
+ // Build privatized reference to the current linear var. The final value is
+ // written back through the variable itself, also for 'uval' references.
auto *DE = cast<DeclRefExpr>(SimpleRefExpr);
Expr *CapturedRef;
if (isa<BindingDecl>(DE->getDecl())) {
CapturedRef = SimpleRefExpr;
- } else if (LinKind == OMPC_LINEAR_uval) {
- CapturedRef = cast<VarDecl>(DE->getDecl())->getInit();
} else {
CapturedRef =
buildDeclRefExpr(SemaRef, cast<VarDecl>(DE->getDecl()),
diff --git a/clang/test/OpenMP/for_linear_codegen.cpp b/clang/test/OpenMP/for_linear_codegen.cpp
index 88c218ac8af80..a4244b63da2b9 100644
--- a/clang/test/OpenMP/for_linear_codegen.cpp
+++ b/clang/test/OpenMP/for_linear_codegen.cpp
@@ -1754,8 +1754,7 @@ int main() {
// CHECK4-NEXT: [[TMP37:%.*]] = load ptr, ptr [[_TMP3]], align 8, !nonnull [[META2]], !align [[META3]]
// CHECK4-NEXT: store ptr [[TMP37]], ptr [[_TMP21]], align 8
// CHECK4-NEXT: [[TMP38:%.*]] = load i32, ptr [[C10]], align 4
-// CHECK4-NEXT: [[C22:%.*]] = getelementptr inbounds nuw [[STRUCT_SS:%.*]], ptr [[TMP0]], i32 0, i32 2
-// CHECK4-NEXT: [[TMP39:%.*]] = load ptr, ptr [[C22]], align 8, !nonnull [[META2]], !align [[META3]]
+// CHECK4-NEXT: [[TMP39:%.*]] = load ptr, ptr [[_TMP21]], align 8, !nonnull [[META2]], !align [[META3]]
// CHECK4-NEXT: store i32 [[TMP38]], ptr [[TMP39]], align 4
// CHECK4-NEXT: br label [[DOTOMP_LINEAR_PU_DONE]]
// CHECK4: .omp.linear.pu.done:
diff --git a/clang/test/OpenMP/simd_codegen.cpp b/clang/test/OpenMP/simd_codegen.cpp
index ee8d709ba47fe..2af0b7ae3ec47 100644
--- a/clang/test/OpenMP/simd_codegen.cpp
+++ b/clang/test/OpenMP/simd_codegen.cpp
@@ -714,8 +714,11 @@ void linear(float *a) {
// CHECK-NEXT: store i64 [[LIN0_2]], ptr [[K_REF]]
//
#pragma omp simd linear(uval(k) : 3)
+// CHECK: [[UVAL_REF:%.+]] = load ptr, ptr [[K_ADDR]],
+// CHECK: store ptr [[UVAL_REF]], ptr [[K_ADDR_REF:%.+]],
// CHECK: store i32 0, ptr [[OMP_IV:%[^,]+]]
-// CHECK: [[K0LOAD:%.+]] = load i64, ptr [[VAL_ADDR]]
+// CHECK: [[K_REF:%.+]] = load ptr, ptr [[K_ADDR_REF]],
+// CHECK: [[K0LOAD:%.+]] = load i64, ptr [[K_REF]]
// CHECK-NEXT: store i64 [[K0LOAD]], ptr [[LIN0:%[^,]+]]
// CHECK: [[IV:%.+]] = load i32, ptr [[OMP_IV]]{{.*}}!llvm.access.group
@@ -747,8 +750,11 @@ void linear(float *a) {
// CHECK: [[SIMPLE_LOOP_END]]:
//
// Update linear vars after loop, as the loop was operating on a private version.
+// CHECK: [[K_REF:%.+]] = load ptr, ptr [[K_ADDR_REF]],
+// CHECK: store ptr [[K_REF]], ptr [[K_PRIV_REF:%.+]],
// CHECK: [[LIN0_2:%.+]] = load i64, ptr [[K_PRIVATIZED]]
-// CHECK-NEXT: store i64 [[LIN0_2]], ptr [[VAL_ADDR]]
+// CHECK-NEXT: [[K_REF:%.+]] = load ptr, ptr [[K_PRIV_REF]],
+// CHECK-NEXT: store i64 [[LIN0_2]], ptr [[K_REF]]
//
}
diff --git a/clang/test/OpenMP/simd_linear_messages.cpp b/clang/test/OpenMP/simd_linear_messages.cpp
index 3ce4de697de0c..b605165114840 100644
--- a/clang/test/OpenMP/simd_linear_messages.cpp
+++ b/clang/test/OpenMP/simd_linear_messages.cpp
@@ -202,6 +202,69 @@ void linear_modifiers(int argc) {
for (int k = 0; k < argc; ++k) ++k;
}
+extern int &ext_ref;
+
+template <class T> void linear_dependent_reference(T &x, int &y) {
+#ifdef OMP52
+ #pragma omp simd linear(x: uval, step(y + 1))
+#else
+ #pragma omp simd linear(uval(x): y + 1)
+#endif
+ for (int k = 0; k < 10; ++k) x += y + 1;
+}
+
+template <class T> void linear_dependent_step(int &x, T y) {
+#ifdef OMP52
+ #pragma omp simd linear(x: uval, step(y + 1))
+#else
+ #pragma omp simd linear(uval(x): y + 1)
+#endif
+ for (int k = 0; k < 10; ++k) x += y + 1;
+}
+
+void linear_reference_params(int &x, int &y, int s) {
+ int ls = s + 1;
+ #pragma omp simd linear(uval(x)) // omp52-error {{old syntax 'linear-modifier(list)' on 'linear' clause was deprecated, use new syntax 'linear(list: [linear-modifier,] step(step-size))'}}
+ for (int k = 0; k < 10; ++k) ++x;
+ #pragma omp simd linear(ref(x)) // omp52-error {{old syntax 'linear-modifier(list)' on 'linear' clause was deprecated, use new syntax 'linear(list: [linear-modifier,] step(step-size))'}}
+ for (int k = 0; k < 10; ++k) ++x;
+ #pragma omp simd linear(uval(ext_ref)) // omp52-error {{old syntax 'linear-modifier(list)' on 'linear' clause was deprecated, use new syntax 'linear(list: [linear-modifier,] step(step-size))'}}
+ for (int k = 0; k < 10; ++k) ++ext_ref;
+ #pragma omp simd linear(uval(x): 2) // omp52-error {{old syntax 'linear-modifier(list)' on 'linear' clause was deprecated, use new syntax 'linear(list: [linear-modifier,] step(step-size))'}} omp52-error {{step simple modifier is exclusive and cannot be use with 'val', 'uval' or 'ref' modifier}}
+ for (int k = 0; k < 10; ++k) x += 2;
+ #pragma omp simd linear(uval(x): y + 1) // omp52-error {{old syntax 'linear-modifier(list)' on 'linear' clause was deprecated, use new syntax 'linear(list: [linear-modifier,] step(step-size))'}} omp52-error {{step simple modifier is exclusive and cannot be use with 'val', 'uval' or 'ref' modifier}}
+ for (int k = 0; k < 10; ++k) x += y + 1;
+ #pragma omp simd linear(uval(x): ls) // omp52-error {{old syntax 'linear-modifier(list)' on 'linear' clause was deprecated, use new syntax 'linear(list: [linear-modifier,] step(step-size))'}} omp52-error {{step simple modifier is exclusive and cannot be use with 'val', 'uval' or 'ref' modifier}}
+ for (int k = 0; k < 10; ++k) x += ls;
+ #pragma omp simd linear(ref(x): y + 1) // omp52-error {{old syntax 'linear-modifier(list)' on 'linear' clause was deprecated, use new syntax 'linear(list: [linear-modifier,] step(step-size))'}} omp52-error {{step simple modifier is exclusive and cannot be use with 'val', 'uval' or 'ref' modifier}}
+ for (int k = 0; k < 10; ++k) x += y + 1;
+ #pragma omp simd linear(val(x): y + 1) // omp52-error {{old syntax 'linear-modifier(list)' on 'linear' clause was deprecated, use new syntax 'linear(list: [linear-modifier,] step(step-size))'}} omp52-error {{step simple modifier is exclusive and cannot be use with 'val', 'uval' or 'ref' modifier}}
+ for (int k = 0; k < 10; ++k) x += y + 1;
+ #pragma omp simd linear(x: y + 1)
+ for (int k = 0; k < 10; ++k) x += y + 1;
+#ifdef OMP52
+ #pragma omp simd linear(x: uval, step(y + 1))
+ for (int k = 0; k < 10; ++k) x += y + 1;
+ #pragma omp simd linear(x: ref, step(y + 1))
+ for (int k = 0; k < 10; ++k) x += y + 1;
+ #pragma omp simd linear(ext_ref: uval, step(ls))
+ for (int k = 0; k < 10; ++k) ext_ref += ls;
+#endif
+ #pragma omp simd linear(uval(s): y + 1) // expected-error {{variable of non-reference type 'int' can be used only with 'val' modifier, but used with 'uval'}} omp52-error {{old syntax 'linear-modifier(list)' on 'linear' clause was deprecated, use new syntax 'linear(list: [linear-modifier,] step(step-size))'}} omp52-error {{step simple modifier is exclusive and cannot be use with 'val', 'uval' or 'ref' modifier}}
+ for (int k = 0; k < 10; ++k) s += y + 1;
+ #pragma omp simd linear(uval(x): 1.5) // expected-error {{expression must have integral or unscoped enumeration type, not 'double'}} omp52-error {{old syntax 'linear-modifier(list)' on 'linear' clause was deprecated, use new syntax 'linear(list: [linear-modifier,] step(step-size))'}} omp52-error {{step simple modifier is exclusive and cannot be use with 'val', 'uval' or 'ref' modifier}}
+ for (int k = 0; k < 10; ++k) ++x;
+ #pragma omp simd linear(uval(x): zzz) // expected-error {{use of undeclared identifier 'zzz'}} omp52-error {{old syntax 'linear-modifier(list)' on 'linear' clause was deprecated, use new syntax 'linear(list: [linear-modifier,] step(step-size))'}}
+ for (int k = 0; k < 10; ++k) ++x;
+ // expected-error at +3 3 {{use of undeclared identifier 'i'}}
+ // expected-error at +2 {{initialization clause of OpenMP for loop is not in canonical form ('var = init' or 'T var = init')}}
+ #pragma omp simd linear(uval(x): y + 1) // omp52-error {{old syntax 'linear-modifier(list)' on 'linear' clause was deprecated, use new syntax 'linear(list: [linear-modifier,] step(step-size))'}} omp52-error {{step simple modifier is exclusive and cannot be use with 'val', 'uval' or 'ref' modifier}}
+ for (i = 0; i < 10; i++)
+ x += y + 1;
+ linear_dependent_reference(x, y);
+ linear_dependent_step(x, s);
+}
+
int f;
int main(int argc, char **argv) {
double darr[100];
diff --git a/clang/test/OpenMP/simd_linear_uval_codegen.cpp b/clang/test/OpenMP/simd_linear_uval_codegen.cpp
new file mode 100644
index 0000000000000..a9e883eec6791
--- /dev/null
+++ b/clang/test/OpenMP/simd_linear_uval_codegen.cpp
@@ -0,0 +1,70 @@
+// RUN: %clang_cc1 -verify -fopenmp -x c++ -triple x86_64-unknown-linux-gnu -emit-llvm %s -o - | FileCheck %s
+// RUN: %clang_cc1 -verify -fopenmp-simd -x c++ -triple x86_64-unknown-linux-gnu -emit-llvm %s -o - | FileCheck %s --check-prefix=SIMD-ONLY
+// expected-no-diagnostics
+
+// SIMD-ONLY-NOT: {{__kmpc|__tgt}}
+
+// A 'uval' item is read and written back through the reference itself, not
+// through its initializer (absent for a parameter, uncaptured in a region).
+
+// CHECK-LABEL: define {{.*}}void @{{.*}}ref_param
+// CHECK-SAME: (ptr noundef nonnull align 4 dereferenceable(4) [[X:%.+]], ptr noundef nonnull align 4 dereferenceable(4) [[Y:%.+]])
+void ref_param(int &x, int &y) {
+// CHECK: store ptr [[X]], ptr [[X_ADDR:%[^,]+]],
+// CHECK: [[X_REF:%.+]] = load ptr, ptr [[X_ADDR]],
+// CHECK-NEXT: store ptr [[X_REF]], ptr [[X_TMP:%[^,]+]],
+// CHECK: store i32 0, ptr [[OMP_IV:%[^,]+]],
+// CHECK-NEXT: [[X_REF1:%.+]] = load ptr, ptr [[X_TMP]],
+// CHECK-NEXT: [[X_START:%.+]] = load i32, ptr [[X_REF1]],
+// CHECK-NEXT: store i32 [[X_START]], ptr [[LINEAR_START:%[^,]+]],
+// CHECK-NEXT: [[Y_REF:%.+]] = load ptr, ptr
+// CHECK-NEXT: [[Y_VAL:%.+]] = load i32, ptr [[Y_REF]],
+// CHECK-NEXT: [[STEP:%.+]] = add nsw i32 [[Y_VAL]], 1
+// CHECK-NEXT: store i32 [[STEP]], ptr [[LINEAR_STEP:%[^,]+]],
+#pragma omp simd linear(uval(x) : y + 1)
+ for (int i = 0; i < 10; ++i)
+ x += y + 1;
+// CHECK: [[START:%.+]] = load i32, ptr [[LINEAR_START]],
+// CHECK-NEXT: [[IV:%.+]] = load i32, ptr [[OMP_IV]],
+// CHECK-NEXT: [[STEP_VAL:%.+]] = load i32, ptr [[LINEAR_STEP]],
+// CHECK-NEXT: [[MUL:%.+]] = mul nsw i32 [[IV]], [[STEP_VAL]]
+// CHECK-NEXT: [[ADD:%.+]] = add nsw i32 [[START]], [[MUL]]
+// CHECK-NEXT: store i32 [[ADD]], ptr [[X_PRIV:%[^,]+]],
+// CHECK: omp.inner.for.end:
+// CHECK: [[X_REF2:%.+]] = load ptr, ptr [[X_TMP]],
+// CHECK-NEXT: store ptr [[X_REF2]], ptr [[X_TMP1:%[^,]+]],
+// CHECK-NEXT: [[X_FINAL:%.+]] = load i32, ptr [[X_PRIV]],
+// CHECK-NEXT: [[X_REF3:%.+]] = load ptr, ptr [[X_TMP1]],
+// CHECK-NEXT: store i32 [[X_FINAL]], ptr [[X_REF3]],
+// CHECK-NEXT: ret void
+}
+
+// CHECK-LABEL: define {{.*}}void @{{.*}}local_ref{{.*}}()
+void local_ref() {
+ int a = 0;
+ int &r = a;
+// CHECK: [[R_PTR:%.+]] = load ptr, ptr %r,
+// CHECK-NEXT: call void {{.*}}@__kmpc_fork_call({{.*}}, ptr @[[OUTLINED:.+]], ptr [[R_PTR]])
+#pragma omp parallel for simd linear(uval(r))
+ for (int i = 0; i < 10; ++i)
+ r += 1;
+}
+
+// CHECK: define internal void @[[OUTLINED]](ptr noalias noundef %{{.+}}, ptr noalias noundef %{{.+}}, ptr noundef nonnull align 4 dereferenceable(4) [[R:%.+]])
+// CHECK: store ptr [[R]], ptr [[R_ADDR:%[^,]+]],
+// CHECK-NEXT: [[R_REF:%.+]] = load ptr, ptr [[R_ADDR]],
+// CHECK-NEXT: store ptr [[R_REF]], ptr [[R_TMP:%[^,]+]],
+// CHECK-NEXT: [[R_REF1:%.+]] = load ptr, ptr [[R_TMP]],
+// CHECK-NEXT: [[R_START:%.+]] = load i32, ptr [[R_REF1]],
+// CHECK-NEXT: store i32 [[R_START]], ptr [[LINEAR_START:%[^,]+]],
+// CHECK: [[START:%.+]] = load i32, ptr [[LINEAR_START]],
+// CHECK-NEXT: [[IV:%.+]] = load i32, ptr
+// CHECK-NEXT: [[MUL:%.+]] = mul nsw i32 [[IV]], 1
+// CHECK-NEXT: [[ADD:%.+]] = add nsw i32 [[START]], [[MUL]]
+// CHECK-NEXT: store i32 [[ADD]], ptr [[R_PRIV:%[^,]+]],
+// CHECK: .omp.linear.pu:
+// CHECK-NEXT: [[R_REF2:%.+]] = load ptr, ptr [[R_TMP]],
+// CHECK-NEXT: store ptr [[R_REF2]], ptr [[R_TMP1:%[^,]+]],
+// CHECK-NEXT: [[R_FINAL:%.+]] = load i32, ptr [[R_PRIV]],
+// CHECK-NEXT: [[R_REF3:%.+]] = load ptr, ptr [[R_TMP1]],
+// CHECK-NEXT: store i32 [[R_FINAL]], ptr [[R_REF3]],
More information about the cfe-commits
mailing list