https://github.com/chaitanyav updated https://github.com/llvm/llvm-project/pull/169869
>From 9d2faf6196c580558a1fac3eeb463cda2cdc927b Mon Sep 17 00:00:00 2001 From: NagaChaitanya Vellanki <[email protected]> Date: Thu, 27 Nov 2025 19:18:31 -0800 Subject: [PATCH 1/2] [Clang] Make __builtin_assume_dereferenceable constexpr Enable constant evaluation of __builtin_assume_dereferenceable. During evaluation, we verify the pointer is valid and the requested bytes are dereferenceable. Resolves:#168335 --- clang/include/clang/Basic/Builtins.td | 2 +- clang/lib/AST/ByteCode/InterpBuiltin.cpp | 34 ++++++++++ clang/lib/AST/ExprConstant.cpp | 29 +++++++++ ...iltin-assume-dereferenceable-constexpr.cpp | 64 +++++++++++++++++++ 4 files changed, 128 insertions(+), 1 deletion(-) create mode 100644 clang/test/SemaCXX/builtin-assume-dereferenceable-constexpr.cpp diff --git a/clang/include/clang/Basic/Builtins.td b/clang/include/clang/Basic/Builtins.td index 6d6104a3ddb8d..226ad1cc03078 100644 --- a/clang/include/clang/Basic/Builtins.td +++ b/clang/include/clang/Basic/Builtins.td @@ -859,7 +859,7 @@ def BuiltinAssumeAligned : Builtin { def BuiltinAssumeDereferenceable : Builtin { let Spellings = ["__builtin_assume_dereferenceable"]; - let Attributes = [NoThrow, Const]; + let Attributes = [NoThrow, Const, Constexpr]; let Prototype = "void(void const*, size_t)"; } diff --git a/clang/lib/AST/ByteCode/InterpBuiltin.cpp b/clang/lib/AST/ByteCode/InterpBuiltin.cpp index d21f42d94d3a5..a29e7977b9d00 100644 --- a/clang/lib/AST/ByteCode/InterpBuiltin.cpp +++ b/clang/lib/AST/ByteCode/InterpBuiltin.cpp @@ -2215,6 +2215,37 @@ static unsigned computePointerOffset(const ASTContext &ASTCtx, return Result; } +/// __builtin_assume_dereferenceable(Ptr, Size) +static bool interp__builtin_assume_dereferenceable(InterpState &S, CodePtr OpPC, + const InterpFrame *Frame, + const CallExpr *Call) { + assert(Call->getNumArgs() == 2); + + APSInt ReqSize = popToAPSInt(S.Stk, *S.Ctx.classify(Call->getArg(1))); + if (ReqSize.getZExtValue() < 1) + return false; + + const Pointer &Ptr = S.Stk.pop<Pointer>(); + if (Ptr.isZero() || !Ptr.isLive() || !Ptr.isBlockPointer() || Ptr.isPastEnd()) + return false; + + const ASTContext &ASTCtx = S.getASTContext(); + const Descriptor *DeclDesc = Ptr.getDeclDesc(); + std::optional<unsigned> FullSize = computeFullDescSize(ASTCtx, DeclDesc); + if (!FullSize) + return false; + + unsigned ByteOffset = computePointerOffset(ASTCtx, Ptr); + if (ByteOffset > *FullSize) + return false; + + unsigned RemainingSpace = *FullSize - ByteOffset; + if (RemainingSpace < ReqSize.getZExtValue()) + return false; + + return true; +} + /// Does Ptr point to the last subobject? static bool pointsToLastObject(const Pointer &Ptr) { Pointer P = Ptr; @@ -3749,6 +3780,9 @@ bool InterpretBuiltin(InterpState &S, CodePtr OpPC, const CallExpr *Call, case Builtin::BI__assume: return interp__builtin_assume(S, OpPC, Frame, Call); + case Builtin::BI__builtin_assume_dereferenceable: + return interp__builtin_assume_dereferenceable(S, OpPC, Frame, Call); + case Builtin::BI__builtin_strcmp: case Builtin::BIstrcmp: case Builtin::BI__builtin_strncmp: diff --git a/clang/lib/AST/ExprConstant.cpp b/clang/lib/AST/ExprConstant.cpp index b986ee6ca4fa3..fe42afe5ddd78 100644 --- a/clang/lib/AST/ExprConstant.cpp +++ b/clang/lib/AST/ExprConstant.cpp @@ -19690,6 +19690,35 @@ class VoidExprEvaluator // The argument is not evaluated! return true; + case Builtin::BI__builtin_assume_dereferenceable: { + assert(E->getType()->isVoidType()); + assert(E->getNumArgs() == 2); + + APSInt ReqSizeVal; + if (!::EvaluateInteger(E->getArg(1), ReqSizeVal, Info)) + return false; + LValue Pointer; + if (!EvaluatePointer(E->getArg(0), Pointer, Info)) + return false; + if (Pointer.Designator.Invalid) + return false; + if (Pointer.isNullPointer()) + return false; + + uint64_t ReqSize = ReqSizeVal.getZExtValue(); + if (ReqSize < 1) + return false; + CharUnits EndOffset; + if (!determineEndOffset(Info, E->getExprLoc(), 0, Pointer, EndOffset)) + return false; + + uint64_t TotalSize = + (EndOffset - Pointer.getLValueOffset()).getQuantity(); + if (TotalSize < ReqSize) { + return false; + } + return true; + } case Builtin::BI__builtin_operator_delete: return HandleOperatorDeleteCall(Info, E); diff --git a/clang/test/SemaCXX/builtin-assume-dereferenceable-constexpr.cpp b/clang/test/SemaCXX/builtin-assume-dereferenceable-constexpr.cpp new file mode 100644 index 0000000000000..158eb78cbdabc --- /dev/null +++ b/clang/test/SemaCXX/builtin-assume-dereferenceable-constexpr.cpp @@ -0,0 +1,64 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -std=c++14 -triple x86_64-unknown-unknown %s +// RUN: %clang_cc1 -fsyntax-only -verify -std=c++14 -triple x86_64-unknown-unknown %s -fexperimental-new-constant-interpreter + +constexpr int arr[10] = {}; + +constexpr bool test_constexpr_valid() { + __builtin_assume_dereferenceable(arr, 40); + return true; +} +static_assert(test_constexpr_valid(), ""); + +constexpr bool test_constexpr_partial() { + __builtin_assume_dereferenceable(&arr[5], 20); + return true; +} +static_assert(test_constexpr_partial(), ""); + +constexpr bool test_constexpr_nullptr() { + __builtin_assume_dereferenceable(nullptr, 4); + return true; +} +static_assert(test_constexpr_nullptr(), ""); // expected-error {{not an integral constant expression}} + +constexpr bool test_constexpr_too_large() { + __builtin_assume_dereferenceable(arr, 100); + return true; +} +static_assert(test_constexpr_too_large(), ""); // expected-error {{not an integral constant expression}} + +constexpr int single_var = 42; +constexpr bool test_single_var() { + __builtin_assume_dereferenceable(&single_var, 4); + return true; +} +static_assert(test_single_var(), ""); + +constexpr bool test_exact_boundary() { + __builtin_assume_dereferenceable(&arr[9], 4); + return true; +} +static_assert(test_exact_boundary(), ""); + +constexpr bool test_one_over() { + __builtin_assume_dereferenceable(&arr[9], 5); + return true; +} +static_assert(test_one_over(), ""); // expected-error {{not an integral constant expression}} + +constexpr bool test_zero_size() { + __builtin_assume_dereferenceable(arr, 0); + return true; +} +static_assert(test_zero_size(), ""); // expected-error {{not an integral constant expression}} + +struct S { + int x; + int y; +}; +constexpr S s = {1, 2}; +constexpr bool test_struct_member() { + __builtin_assume_dereferenceable(&s.x, 4); + return true; +} +static_assert(test_struct_member(), ""); >From 410dfd189801c19dad6e1d9aa2e9986f09327cee Mon Sep 17 00:00:00 2001 From: NagaChaitanya Vellanki <[email protected]> Date: Fri, 28 Nov 2025 17:03:08 -0800 Subject: [PATCH 2/2] * Emit diagnostics when validation fails: null pointer, one-past-the-end, out-of-bounds access. * Enhance test suite to cover more scenarios * Return true when Size is zero. --- clang/lib/AST/ByteCode/InterpBuiltin.cpp | 25 ++++++-- clang/lib/AST/ExprConstant.cpp | 18 ++++-- ...iltin-assume-dereferenceable-constexpr.cpp | 64 +++++++++++++------ 3 files changed, 78 insertions(+), 29 deletions(-) diff --git a/clang/lib/AST/ByteCode/InterpBuiltin.cpp b/clang/lib/AST/ByteCode/InterpBuiltin.cpp index a29e7977b9d00..b23401d16928a 100644 --- a/clang/lib/AST/ByteCode/InterpBuiltin.cpp +++ b/clang/lib/AST/ByteCode/InterpBuiltin.cpp @@ -2222,12 +2222,22 @@ static bool interp__builtin_assume_dereferenceable(InterpState &S, CodePtr OpPC, assert(Call->getNumArgs() == 2); APSInt ReqSize = popToAPSInt(S.Stk, *S.Ctx.classify(Call->getArg(1))); - if (ReqSize.getZExtValue() < 1) - return false; - const Pointer &Ptr = S.Stk.pop<Pointer>(); - if (Ptr.isZero() || !Ptr.isLive() || !Ptr.isBlockPointer() || Ptr.isPastEnd()) + + if (ReqSize.isZero()) + return true; + if (Ptr.isZero()) { + S.FFDiag(S.Current->getSource(OpPC), diag::note_constexpr_access_null) + << AK_Read << S.Current->getRange(OpPC); return false; + } + if (!Ptr.isLive() || !Ptr.isBlockPointer()) + return false; + if (Ptr.isPastEnd()) { + S.FFDiag(S.Current->getSource(OpPC), diag::note_constexpr_access_past_end) + << AK_Read << S.Current->getRange(OpPC); + return false; + } const ASTContext &ASTCtx = S.getASTContext(); const Descriptor *DeclDesc = Ptr.getDeclDesc(); @@ -2239,9 +2249,12 @@ static bool interp__builtin_assume_dereferenceable(InterpState &S, CodePtr OpPC, if (ByteOffset > *FullSize) return false; - unsigned RemainingSpace = *FullSize - ByteOffset; - if (RemainingSpace < ReqSize.getZExtValue()) + unsigned AvailSize = *FullSize - ByteOffset; + if (AvailSize < ReqSize.getZExtValue()) { + S.FFDiag(S.Current->getSource(OpPC), diag::note_constexpr_access_past_end) + << AK_Read << S.Current->getRange(OpPC); return false; + } return true; } diff --git a/clang/lib/AST/ExprConstant.cpp b/clang/lib/AST/ExprConstant.cpp index fe42afe5ddd78..20b28598c4760 100644 --- a/clang/lib/AST/ExprConstant.cpp +++ b/clang/lib/AST/ExprConstant.cpp @@ -19697,24 +19697,32 @@ class VoidExprEvaluator APSInt ReqSizeVal; if (!::EvaluateInteger(E->getArg(1), ReqSizeVal, Info)) return false; + if (ReqSizeVal.isZero()) + return true; + LValue Pointer; if (!EvaluatePointer(E->getArg(0), Pointer, Info)) return false; if (Pointer.Designator.Invalid) return false; - if (Pointer.isNullPointer()) + if (Pointer.isNullPointer()) { + Info.FFDiag(E, diag::note_constexpr_access_null) << AK_Read; + return false; + } + if (Pointer.Designator.isOnePastTheEnd()) { + Info.FFDiag(E, diag::note_constexpr_access_past_end) << AK_Read; return false; + } uint64_t ReqSize = ReqSizeVal.getZExtValue(); - if (ReqSize < 1) - return false; CharUnits EndOffset; if (!determineEndOffset(Info, E->getExprLoc(), 0, Pointer, EndOffset)) return false; - uint64_t TotalSize = + uint64_t AvailSize = (EndOffset - Pointer.getLValueOffset()).getQuantity(); - if (TotalSize < ReqSize) { + if (AvailSize < ReqSize) { + Info.FFDiag(E, diag::note_constexpr_access_past_end) << AK_Read; return false; } return true; diff --git a/clang/test/SemaCXX/builtin-assume-dereferenceable-constexpr.cpp b/clang/test/SemaCXX/builtin-assume-dereferenceable-constexpr.cpp index 158eb78cbdabc..3819ae3b9c2f0 100644 --- a/clang/test/SemaCXX/builtin-assume-dereferenceable-constexpr.cpp +++ b/clang/test/SemaCXX/builtin-assume-dereferenceable-constexpr.cpp @@ -1,64 +1,92 @@ // RUN: %clang_cc1 -fsyntax-only -verify -std=c++14 -triple x86_64-unknown-unknown %s // RUN: %clang_cc1 -fsyntax-only -verify -std=c++14 -triple x86_64-unknown-unknown %s -fexperimental-new-constant-interpreter -constexpr int arr[10] = {}; - constexpr bool test_constexpr_valid() { + constexpr int arr[10] = {}; __builtin_assume_dereferenceable(arr, 40); return true; } static_assert(test_constexpr_valid(), ""); constexpr bool test_constexpr_partial() { + constexpr int arr[10] = {}; __builtin_assume_dereferenceable(&arr[5], 20); return true; } static_assert(test_constexpr_partial(), ""); -constexpr bool test_constexpr_nullptr() { - __builtin_assume_dereferenceable(nullptr, 4); +constexpr bool test_constexpr_nullptr() { // expected-error {{constexpr function never produces a constant expression}} + __builtin_assume_dereferenceable(nullptr, 4); // expected-note 2{{read of dereferenced null pointer is not allowed in a constant expression}} return true; } -static_assert(test_constexpr_nullptr(), ""); // expected-error {{not an integral constant expression}} +static_assert(test_constexpr_nullptr(), ""); // expected-error {{not an integral constant expression}} expected-note {{in call to}} -constexpr bool test_constexpr_too_large() { - __builtin_assume_dereferenceable(arr, 100); +constexpr bool test_constexpr_too_large() { // expected-error {{constexpr function never produces a constant expression}} + constexpr int arr[10] = {}; + __builtin_assume_dereferenceable(arr, 100); // expected-note 2{{read of dereferenced one-past-the-end pointer is not allowed in a constant expression}} return true; } -static_assert(test_constexpr_too_large(), ""); // expected-error {{not an integral constant expression}} +static_assert(test_constexpr_too_large(), ""); // expected-error {{not an integral constant expression}} expected-note {{in call to}} -constexpr int single_var = 42; constexpr bool test_single_var() { + constexpr int single_var = 42; __builtin_assume_dereferenceable(&single_var, 4); return true; } static_assert(test_single_var(), ""); constexpr bool test_exact_boundary() { + constexpr int arr[10] = {}; __builtin_assume_dereferenceable(&arr[9], 4); return true; } static_assert(test_exact_boundary(), ""); -constexpr bool test_one_over() { - __builtin_assume_dereferenceable(&arr[9], 5); +constexpr bool test_one_over() { // expected-error {{constexpr function never produces a constant expression}} + constexpr int arr[10] = {}; + __builtin_assume_dereferenceable(&arr[9], 5); // expected-note 2{{read of dereferenced one-past-the-end pointer is not allowed in a constant expression}} return true; } -static_assert(test_one_over(), ""); // expected-error {{not an integral constant expression}} +static_assert(test_one_over(), ""); // expected-error {{not an integral constant expression}} expected-note {{in call to}} constexpr bool test_zero_size() { + constexpr int arr[10] = {}; __builtin_assume_dereferenceable(arr, 0); return true; } -static_assert(test_zero_size(), ""); // expected-error {{not an integral constant expression}} +static_assert(test_zero_size(), ""); -struct S { - int x; - int y; -}; -constexpr S s = {1, 2}; constexpr bool test_struct_member() { + struct S { + int x; + int y; + }; + constexpr S s = {1, 2}; __builtin_assume_dereferenceable(&s.x, 4); return true; } static_assert(test_struct_member(), ""); + +constexpr bool test_range_valid() { + constexpr int range_data[5] = {1, 2, 3, 4, 5}; + __builtin_assume_dereferenceable(range_data, 5 * sizeof(int)); + return range_data[0] == 1; +} +static_assert(test_range_valid(), ""); + +constexpr bool test_range_invalid() { // expected-error {{constexpr function never produces a constant expression}} + constexpr int range_data[5] = {1, 2, 3, 4, 5}; + __builtin_assume_dereferenceable(range_data, 6 * sizeof(int)); // expected-note 2{{read of dereferenced one-past-the-end pointer is not allowed in a constant expression}} + return true; +} +static_assert(test_range_invalid(), ""); // expected-error {{not an integral constant expression}} expected-note {{in call to}} + +constexpr int arr1[10] = {}; +constexpr int valid = (__builtin_assume_dereferenceable(arr1, 40), 12); + +constexpr int invalid = (__builtin_assume_dereferenceable((int*)123, 4), 12); // expected-error {{constexpr variable 'invalid' must be initialized by a constant expression}} expected-note {{cast that performs the conversions of a reinterpret_cast is not allowed in a constant expression}} + +constexpr int arr2[5] = {1, 2, 3, 4, 5}; +constexpr int too_large = (__builtin_assume_dereferenceable(arr2, 6 * sizeof(int)), 12); // expected-error {{constexpr variable 'too_large' must be initialized by a constant expression}} expected-note {{read of dereferenced one-past-the-end pointer is not allowed in a constant expression}} + +constexpr int null = (__builtin_assume_dereferenceable(nullptr, 4), 12); // expected-error {{constexpr variable 'null' must be initialized by a constant expression}} expected-note {{read of dereferenced null pointer is not allowed in a constant expression}} _______________________________________________ cfe-commits mailing list [email protected] https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
