Author: Florian Hahn Date: 2025-02-14T12:44:20+01:00 New Revision: 50d10b5c1c26c12570d3d31ef24b1a880fd23e26
URL: https://github.com/llvm/llvm-project/commit/50d10b5c1c26c12570d3d31ef24b1a880fd23e26 DIFF: https://github.com/llvm/llvm-project/commit/50d10b5c1c26c12570d3d31ef24b1a880fd23e26.diff LOG: [Clang] Add __builtin_assume_dereferenceable to encode deref assumption. (#121789) This patch adds a new __builtin_assume_dereferenceable to encode dereferenceability of a pointer using llvm.assume with an operand bundle. For now the builtin only accepts constant sizes, I am planning to drop this restriction in a follow-up change. This can be used to better optimize cases where a pointer is known to be dereferenceable, e.g. unconditionally loading from p2 when vectorizing the loop. int *get_ptr(); void foo(int* src, int x) { int *p2 = get_ptr(); __builtin_assume_aligned(p2, 4); __builtin_assume_dereferenceable(p2, 4000); for (unsigned I = 0; I != 1000; ++I) { int x = src[I]; if (x == 0) x = p2[I]; src[I] = x; } } PR: https://github.com/llvm/llvm-project/pull/121789 Added: clang/test/CodeGen/builtin-assume-dereferenceable.c clang/test/SemaCXX/builtin-assume-dereferenceable.cpp Modified: clang/docs/LanguageExtensions.rst clang/include/clang/Basic/Builtins.td clang/lib/CodeGen/CGBuiltin.cpp llvm/include/llvm/IR/IRBuilder.h llvm/lib/IR/IRBuilder.cpp Removed: ################################################################################ diff --git a/clang/docs/LanguageExtensions.rst b/clang/docs/LanguageExtensions.rst index 973cf8f9d091c..2a956ad5b2909 100644 --- a/clang/docs/LanguageExtensions.rst +++ b/clang/docs/LanguageExtensions.rst @@ -2866,6 +2866,47 @@ etc.). Query for this feature with ``__has_builtin(__builtin_assume_separate_storage)``. +``__builtin_assume_dereferenceable`` +------------------------------------- + +``__builtin_assume_dereferenceable`` is used to provide the optimizer with the +knowledge that the pointer argument P is dereferenceable up to at least the +specified number of bytes. + +**Syntax**: + +.. code-block:: c++ + + __builtin_assume_dereferenceable(const void *, size_t) + +**Example of Use**: + +.. code-block:: c++ + + int foo(int *x, int y) { + __builtin_assume_dereferenceable(x, sizeof(int)); + int z = 0; + if (y == 1) { + // The optimizer may execute the load of x unconditionally due to + // __builtin_assume_dereferenceable guaranteeing sizeof(int) bytes can + // be loaded speculatively without trapping. + z = *x; + } + return z; + } + +**Description**: + +The arguments to this function provide a start pointer ``P`` and a size ``S``. +``S`` must be at least 1 and a constant. The optimizer may assume that ``S`` +bytes are dereferenceable starting at ``P``. Note that this does not necessarily +imply that ``P`` is non-null as ``nullptr`` can be dereferenced in some cases. +The assumption also does not imply that ``P`` is not dereferenceable past ``S`` +bytes. + + +Query for this feature with ``__has_builtin(__builtin_assume_dereferenceable)``. + ``__builtin_offsetof`` ---------------------- diff --git a/clang/include/clang/Basic/Builtins.td b/clang/include/clang/Basic/Builtins.td index 29939242596ba..0e5df338dd2e5 100644 --- a/clang/include/clang/Basic/Builtins.td +++ b/clang/include/clang/Basic/Builtins.td @@ -839,6 +839,12 @@ def BuiltinAssumeAligned : Builtin { let Prototype = "void*(void const*, size_t, ...)"; } +def BuiltinAssumeDereferenceable : Builtin { + let Spellings = ["__builtin_assume_dereferenceable"]; + let Attributes = [NoThrow, Const]; + let Prototype = "void(void const*, _Constant size_t)"; +} + def BuiltinFree : Builtin { let Spellings = ["__builtin_free"]; let Attributes = [FunctionWithBuiltinPrefix, NoThrow]; diff --git a/clang/lib/CodeGen/CGBuiltin.cpp b/clang/lib/CodeGen/CGBuiltin.cpp index 1f1983620fdee..d57f491a20c8e 100644 --- a/clang/lib/CodeGen/CGBuiltin.cpp +++ b/clang/lib/CodeGen/CGBuiltin.cpp @@ -3839,6 +3839,17 @@ RValue CodeGenFunction::EmitBuiltinExpr(const GlobalDecl GD, unsigned BuiltinID, AlignmentCI, OffsetValue); return RValue::get(PtrValue); } + case Builtin::BI__builtin_assume_dereferenceable: { + const Expr *Ptr = E->getArg(0); + const Expr *Size = E->getArg(1); + Value *PtrValue = EmitScalarExpr(Ptr); + Value *SizeValue = EmitScalarExpr(Size); + if (SizeValue->getType() != IntPtrTy) + SizeValue = + Builder.CreateIntCast(SizeValue, IntPtrTy, false, "casted.size"); + Builder.CreateDereferenceableAssumption(PtrValue, SizeValue); + return RValue::get(nullptr); + } case Builtin::BI__assume: case Builtin::BI__builtin_assume: { if (E->getArg(0)->HasSideEffects(getContext())) diff --git a/clang/test/CodeGen/builtin-assume-dereferenceable.c b/clang/test/CodeGen/builtin-assume-dereferenceable.c new file mode 100644 index 0000000000000..cadffd4a84c26 --- /dev/null +++ b/clang/test/CodeGen/builtin-assume-dereferenceable.c @@ -0,0 +1,34 @@ +// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py +// RUN: %clang_cc1 -triple x86_64-unknown-unknown -emit-llvm -o - %s | FileCheck %s + +// CHECK-LABEL: @test1( +// CHECK-NEXT: entry: +// CHECK-NEXT: [[A_ADDR:%.*]] = alloca ptr, align 8 +// CHECK-NEXT: store ptr [[A:%.*]], ptr [[A_ADDR]], align 8 +// CHECK-NEXT: [[TMP0:%.*]] = load ptr, ptr [[A_ADDR]], align 8 +// CHECK-NEXT: call void @llvm.assume(i1 true) [ "dereferenceable"(ptr [[TMP0]], i64 10) ] +// CHECK-NEXT: [[TMP1:%.*]] = load ptr, ptr [[A_ADDR]], align 8 +// CHECK-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, ptr [[TMP1]], i64 0 +// CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[ARRAYIDX]], align 4 +// CHECK-NEXT: ret i32 [[TMP2]] +// +int test1(int *a) { + __builtin_assume_dereferenceable(a, 10); + return a[0]; +} + +// CHECK-LABEL: @test2( +// CHECK-NEXT: entry: +// CHECK-NEXT: [[A_ADDR:%.*]] = alloca ptr, align 8 +// CHECK-NEXT: store ptr [[A:%.*]], ptr [[A_ADDR]], align 8 +// CHECK-NEXT: [[TMP0:%.*]] = load ptr, ptr [[A_ADDR]], align 8 +// CHECK-NEXT: call void @llvm.assume(i1 true) [ "dereferenceable"(ptr [[TMP0]], i64 32) ] +// CHECK-NEXT: [[TMP1:%.*]] = load ptr, ptr [[A_ADDR]], align 8 +// CHECK-NEXT: [[ARRAYIDX:%.*]] = getelementptr inbounds i32, ptr [[TMP1]], i64 0 +// CHECK-NEXT: [[TMP2:%.*]] = load i32, ptr [[ARRAYIDX]], align 4 +// CHECK-NEXT: ret i32 [[TMP2]] +// +int test2(int *a) { + __builtin_assume_dereferenceable(a, 32ull); + return a[0]; +} diff --git a/clang/test/SemaCXX/builtin-assume-dereferenceable.cpp b/clang/test/SemaCXX/builtin-assume-dereferenceable.cpp new file mode 100644 index 0000000000000..b79b7c059567e --- /dev/null +++ b/clang/test/SemaCXX/builtin-assume-dereferenceable.cpp @@ -0,0 +1,55 @@ +// RUN: %clang_cc1 -DSIZE_T_64 -fsyntax-only -verify -std=c++11 -triple x86_64-linux-gnu %s +// RUN: %clang_cc1 -DSIZE_T_64 -fsyntax-only -verify -std=c++11 -triple x86_64-linux-gnu %s -fexperimental-new-constant-interpreter + + +int test1(int *a) { + __builtin_assume_dereferenceable(a, 32); + return a[0]; +} + +int test2(int *a) { + __builtin_assume_dereferenceable(a, 32ull); + return a[0]; +} + +int test3(int *a) { + __builtin_assume_dereferenceable(a, 32u); + return a[0]; +} + +int test4(int *a, unsigned size) { + a = __builtin_assume_dereferenceable(a, size); // expected-error {{argument to '__builtin_assume_dereferenceable' must be a constant integer}} + return a[0]; +} + +int test5(int *a, unsigned long long size) { + a = __builtin_assume_dereferenceable(a, size); // expected-error {{argument to '__builtin_assume_dereferenceable' must be a constant integer}} + return a[0]; +} + +int test6(float a) { + __builtin_assume_dereferenceable(a, 2); // expected-error {{cannot initialize a parameter of type 'const void *' with an lvalue of type 'float'}} + return 0;; +} + +int test7(int *a) { + __builtin_assume_dereferenceable(a, 32, 1); // expected-error {{too many arguments to function call, expected 2, have 3}} + return a[0]; +} + +int test8(int *a) { + __builtin_assume_dereferenceable(a); // expected-error {{too few arguments to function call, expected 2, have 1}} + return a[0]; +} + +int test9(int *a) { + a[0] = __builtin_assume_dereferenceable(a, 32); // expected-error {{assigning to 'int' from incompatible type 'void'}} + return a[0]; +} + +constexpr int *p = 0; +constexpr void *l = __builtin_assume_dereferenceable(p, 4); // expected-error {{cannot initialize a variable of type 'void *const' with an rvalue of type 'void'}} + +void *foo() { + return l; +} diff --git a/llvm/include/llvm/IR/IRBuilder.h b/llvm/include/llvm/IR/IRBuilder.h index 1692f7dfb7fa7..933dbb306d1fc 100644 --- a/llvm/include/llvm/IR/IRBuilder.h +++ b/llvm/include/llvm/IR/IRBuilder.h @@ -2684,6 +2684,10 @@ class IRBuilderBase { CallInst *CreateAlignmentAssumption(const DataLayout &DL, Value *PtrValue, Value *Alignment, Value *OffsetValue = nullptr); + + /// Create an assume intrinsic call that represents an dereferencable + /// assumption on the provided pointer. + CallInst *CreateDereferenceableAssumption(Value *PtrValue, Value *SizeValue); }; /// This provides a uniform API for creating instructions and inserting diff --git a/llvm/lib/IR/IRBuilder.cpp b/llvm/lib/IR/IRBuilder.cpp index d46ae206890e8..134459265cecb 100644 --- a/llvm/lib/IR/IRBuilder.cpp +++ b/llvm/lib/IR/IRBuilder.cpp @@ -1284,6 +1284,16 @@ CallInst *IRBuilderBase::CreateAlignmentAssumption(const DataLayout &DL, return CreateAlignmentAssumptionHelper(DL, PtrValue, Alignment, OffsetValue); } +CallInst *IRBuilderBase::CreateDereferenceableAssumption(Value *PtrValue, + Value *SizeValue) { + assert(isa<PointerType>(PtrValue->getType()) && + "trying to create an deferenceable assumption on a non-pointer?"); + SmallVector<Value *, 4> Vals({PtrValue, SizeValue}); + OperandBundleDefT<Value *> DereferenceableOpB("dereferenceable", Vals); + return CreateAssumption(ConstantInt::getTrue(getContext()), + {DereferenceableOpB}); +} + IRBuilderDefaultInserter::~IRBuilderDefaultInserter() = default; IRBuilderCallbackInserter::~IRBuilderCallbackInserter() = default; IRBuilderFolder::~IRBuilderFolder() = default; _______________________________________________ cfe-commits mailing list cfe-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
