================
@@ -26996,18 +26996,38 @@ class, structure, array, or other object.
Arguments:
""""""""""
-The ``llvm.objectsize`` intrinsic takes four arguments. The first argument is a
-pointer to or into the ``object``. The second argument determines whether
-``llvm.objectsize`` returns 0 (if true) or -1 (if false) when the object size
is
-unknown. The third argument controls how ``llvm.objectsize`` acts when ``null``
-in address space 0 is used as its pointer argument. If it's ``false``,
-``llvm.objectsize`` reports 0 bytes available when given ``null``. Otherwise,
if
-the ``null`` is in a non-zero address space or if ``true`` is given for the
-third argument of ``llvm.objectsize``, we assume its size is unknown. The
fourth
-argument to ``llvm.objectsize`` determines if the value should be evaluated at
-runtime.
+The ``llvm.objectsize`` intrinsic takes six arguments:
+
+- The first argument is a pointer to or into the ``object``.
+- The second argument controls which value to return when the size is unknown:
+
+ - If it's ``false``, ``llvm.objectsize`` returns ``-1``.
+ - If it's ``true``, ``llvm.objectsize`` returns ``0``.
+
+- The third argument controls how ``llvm.objectsize`` acts when ``null`` in
+ address space 0 is used as its pointer argument:
+
+ - If it's ``false``, ``llvm.objectsize`` reports 0 bytes available when given
+ ``null``.
+ - If it's ``true``, or the ``null`` pointer is in a non-zero address space,
+ the size is assumed to be unknown.
+
+- The fourth argument to ``llvm.objectsize`` determines if the value should be
+ evaluated at runtime.
+- The fifth argument controls which size ``llvm.objectsize`` returns:
+
+ - If it's ``false``, ``llvm.objectsize`` returns the size of the closest
+ surrounding subobject.
+ - If it's ``true``, ``llvm.objectsize`` returns the size of the whole object.
+
+- If non-zero, the sixth and seventh arguments encode the size and offset
+ information, respectively, of the original subobject's layout and is used
+ when the fifth argument is ``false``.
+- The seventh argument encodes the offset information of the original
+ subobject's layout and is used when the fifth argument is ``false``.
----------------
zygoloid wrote:
You're passing the difference between the address of some arbitrary class
object and a field. The address of that class object is not the base address
that the LLVM intrinsic will calculate. So the offset you're passing in is not
meaningful. And there's no way it even *can* be meaningful. Consider something
like this:
```c++
struct A {
int n;
};
struct B {
int data[100];
A a;
};
int f(A *p) { return __builtin_dynamic_object_size(&p->n, 1); }
int g() {
A a;
return f(&a);
}
int h() {
B b;
return f(&b);
}
```
After inlining, the BDOS intrinsic in `g` will see a base pointer of `&a`, and
the intrinsic in `h` will see a base pointer of `&b`. The offset from the base
pointer to the `n` subobject is different in each case. So there's no way you
can compute a constant offset in Clang's lowering and pass it to the intrinsic.
What you *can* do is pass a pointer to `p->n` to the intrinsic as the start of
the subobject. That'll do the right thing regardless of what LLVM computes to
be the complete enclosing object.
https://github.com/llvm/llvm-project/pull/83204
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
