================
@@ -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``.
----------------
bwendling wrote:
> I think the information you're passing in here isn't quite what we'd want. If
> I'm reading the code correctly, the offset you're passing in is the field
> offset relative to the immediately-enclosing record type, which doesn't give
> us any information about either where the pointer is within the subobject, or
> where the subobject is within the complete object, so this doesn't seem like
> it can be enough information to produce a correct result.
That's the information which leads to the correct calculation. If you have a
pointer like this:
```c
struct S {
int a;
char c[234];
int b;
};
void foo(struct S *ptr) {
size_t x = __builtin_dynamic_object_size(ptr->a[22], 1);
/* ... */
}
```
the value of `x` should be `0`. See https://godbolt.org/z/4xaY4191o for a list
of examples that show this behavior (at least in GCC). Notice that this applies
for the sub-object type only. If the __bdos value is `0`, then your behavior is
the correct behavior.
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
