Re: [PATCH bpf-next 2/6] libbpf: Add BTF_KIND_FLOAT support

[Yonghong Song <yhs@fb.com>]

On 2/15/21 5:12 PM, Ilya Leoshkevich wrote:
> The logic follows that of BTF_KIND_INT most of the time. Sanitization
> replaces BTF_KIND_FLOATs with equally-sized BTF_KIND_INTs on older
> kernels.
> 
> Signed-off-by: Ilya Leoshkevich <iii@linux.ibm.com>
> ---
>   tools/lib/bpf/btf.c             | 44 +++++++++++++++++++++++++++++++++
>   tools/lib/bpf/btf.h             |  8 ++++++
>   tools/lib/bpf/btf_dump.c        |  4 +++
>   tools/lib/bpf/libbpf.c          | 29 +++++++++++++++++++++-
>   tools/lib/bpf/libbpf.map        |  5 ++++
>   tools/lib/bpf/libbpf_internal.h |  2 ++
>   6 files changed, 91 insertions(+), 1 deletion(-)
> 
> diff --git a/tools/lib/bpf/btf.c b/tools/lib/bpf/btf.c
> index d9c10830d749..07a30e98c3de 100644
> --- a/tools/lib/bpf/btf.c
> +++ b/tools/lib/bpf/btf.c
> @@ -291,6 +291,7 @@ static int btf_type_size(const struct btf_type *t)
>   	case BTF_KIND_PTR:
>   	case BTF_KIND_TYPEDEF:
>   	case BTF_KIND_FUNC:
> +	case BTF_KIND_FLOAT:
>   		return base_size;
>   	case BTF_KIND_INT:
>   		return base_size + sizeof(__u32);
> @@ -338,6 +339,7 @@ static int btf_bswap_type_rest(struct btf_type *t)
>   	case BTF_KIND_PTR:
>   	case BTF_KIND_TYPEDEF:
>   	case BTF_KIND_FUNC:
> +	case BTF_KIND_FLOAT:
>   		return 0;
>   	case BTF_KIND_INT:
>   		*(__u32 *)(t + 1) = bswap_32(*(__u32 *)(t + 1));
> @@ -578,6 +580,7 @@ __s64 btf__resolve_size(const struct btf *btf, __u32 type_id)
>   		case BTF_KIND_UNION:
>   		case BTF_KIND_ENUM:
>   		case BTF_KIND_DATASEC:
> +		case BTF_KIND_FLOAT:
>   			size = t->size;
>   			goto done;
>   		case BTF_KIND_PTR:
> @@ -621,6 +624,7 @@ int btf__align_of(const struct btf *btf, __u32 id)
>   	switch (kind) {
>   	case BTF_KIND_INT:
>   	case BTF_KIND_ENUM:
> +	case BTF_KIND_FLOAT:
>   		return min(btf_ptr_sz(btf), (size_t)t->size);
>   	case BTF_KIND_PTR:
>   		return btf_ptr_sz(btf);
> @@ -2373,6 +2377,42 @@ int btf__add_datasec(struct btf *btf, const char *name, __u32 byte_sz)
>   	return btf_commit_type(btf, sz);
>   }
>   
> +/*
> + * Append new BTF_KIND_FLOAT type with:
> + *   - *name* - non-empty, non-NULL type name;
> + *   - *sz* - size of the type, in bytes;
> + * Returns:
> + *   - >0, type ID of newly added BTF type;
> + *   - <0, on error.
> + */
> +int btf__add_float(struct btf *btf, const char *name, size_t byte_sz)
> +{
> +	struct btf_type *t;
> +	int sz, name_off;
> +
> +	/* non-empty name */
> +	if (!name || !name[0])
> +		return -EINVAL;

Do we want to ensure byte_sz to be 2/4/8/16?
Currently, the int type supports 1/2/4/8/16.

In LLVM, the following are supported float types:

   case BuiltinType::Half:
   case BuiltinType::Float:
   case BuiltinType::LongDouble:
   case BuiltinType::Float16:
   case BuiltinType::BFloat16:
   case BuiltinType::Float128:
   case BuiltinType::Double:


> +
> +	if (btf_ensure_modifiable(btf))
> +		return -ENOMEM;
> +
> +	sz = sizeof(struct btf_type);
> +	t = btf_add_type_mem(btf, sz);
> +	if (!t)
> +		return -ENOMEM;
> +
> +	name_off = btf__add_str(btf, name);
> +	if (name_off < 0)
> +		return name_off;
> +
> +	t->name_off = name_off;
> +	t->info = btf_type_info(BTF_KIND_FLOAT, 0, 0);
> +	t->size = byte_sz;
> +
> +	return btf_commit_type(btf, sz);
> +}
> +
[...]