[PATCH 66/73] builtin: Add support for Linux kernel compiler builtins

[Bart Van Assche <bvanassche@acm.org>]

Add support for compiler builtins used across the Linux kernel:
- Support __builtin_dynamic_object_size(ptr, type) via object_size_op.
- Support __builtin_thread_pointer() returning void * and
  __builtin_alloca_uninitialized(size) returning void *.
- Validate that __builtin_counted_by_ref() receives one argument and fold
  it to (void *)0 for flexible array members.

Add validation tests in validation/builtins-kernel.c and
validation/builtin-counted-by-ref-err.c.

Signed-off-by: Bart Van Assche <bvanassche@acm.org>
---
 builtin.c                               | 22 +++++++++++++
 validation/builtin-counted-by-ref-err.c | 20 ++++++++++++
 validation/builtins-kernel.c            | 42 +++++++++++++++++++++++++
 3 files changed, 84 insertions(+)
 create mode 100644 validation/builtin-counted-by-ref-err.c
 create mode 100644 validation/builtins-kernel.c

diff --git a/builtin.c b/builtin.c
index ba3326970391..e8ea7721b771 100644
--- a/builtin.c
+++ b/builtin.c
@@ -733,6 +733,24 @@ static struct symbol_op va_start_op = {
 	.evaluate = evaluate_va_start,
 };
 
+static int args_counted_by_ref(struct expression *expr)
+{
+	return eval_args(expr, 1);
+}
+
+static int expand_counted_by_ref(struct expression *expr, int cost)
+{
+	expr->type = EXPR_VALUE;
+	expr->value = 0;
+	expr->taint = 0;
+	return 0;
+}
+
+static struct symbol_op counted_by_ref_op = {
+	.args = args_counted_by_ref,
+	.expand = expand_counted_by_ref,
+};
+
 static int evaluate_strlen(struct expression *expr)
 {
 	struct expression *arg = first_expression(expr->args);
@@ -852,6 +870,7 @@ static const struct builtin_fn builtins_common[] = {
 	{ "__builtin_add_overflow", &bool_ctype, 1, .op = &overflow_op },
 	{ "__builtin_add_overflow_p", &bool_ctype, 1, .op = &overflow_p_op },
 	{ "__builtin_alloca", &ptr_ctype, 0, { size_t_ctype }},
+	{ "__builtin_alloca_uninitialized", &ptr_ctype, 0, { size_t_ctype }},
 	{ "__builtin_bcmp", &int_ctype , 0, { &const_ptr_ctype, &const_ptr_ctype, size_t_ctype }},
 	{ "__builtin_bcopy", &void_ctype, 0, { &const_ptr_ctype, &ptr_ctype, size_t_ctype }},
 	{ "__builtin_bswap16", &ushort_ctype, 0, { &ushort_ctype }, .op = &bswap_op },
@@ -859,6 +878,7 @@ static const struct builtin_fn builtins_common[] = {
 	{ "__builtin_bswap64", &ullong_ctype, 0, { &ullong_ctype }, .op = &bswap_op },
 	{ "__builtin_bzero", &void_ctype, 0, { &ptr_ctype, size_t_ctype }},
 	{ "__builtin_calloc", &ptr_ctype, 0, { size_t_ctype, size_t_ctype }},
+	{ "__builtin_counted_by_ref", &ptr_ctype, 1, .op = &counted_by_ref_op },
 	{ "__builtin_clrsb", &int_ctype, 0, { &int_ctype }, .op = &clrsb_op },
 	{ "__builtin_clrsbl", &int_ctype, 0, { &long_ctype }, .op = &clrsb_op },
 	{ "__builtin_clrsbll", &int_ctype, 0, { &llong_ctype }, .op = &clrsb_op },
@@ -868,6 +888,7 @@ static const struct builtin_fn builtins_common[] = {
 	{ "__builtin_ctz", &int_ctype, 0, { &int_ctype }, .op = &ctz_op },
 	{ "__builtin_ctzl", &int_ctype, 0, { &long_ctype }, .op = &ctz_op },
 	{ "__builtin_ctzll", &int_ctype, 0, { &llong_ctype }, .op = &ctz_op },
+	{ "__builtin_dynamic_object_size", size_t_ctype, 0, { &const_ptr_ctype, &int_ctype }, .op = &object_size_op},
 	{ "__builtin_exit", &void_ctype, 0, { &int_ctype }},
 	{ "__builtin_extract_return_addr", &ptr_ctype, 0, { &ptr_ctype }},
 	{ "__builtin_fabs", &double_ctype, 0, { &double_ctype }},
@@ -961,6 +982,7 @@ static const struct builtin_fn builtins_common[] = {
 	{ "__builtin_strstr", &string_ctype, 0, { &const_string_ctype, &const_string_ctype }},
 	{ "__builtin_sub_overflow", &bool_ctype, 1, .op = &overflow_op },
 	{ "__builtin_sub_overflow_p", &bool_ctype, 1, .op = &overflow_p_op },
+	{ "__builtin_thread_pointer", &ptr_ctype, 0 },
 	{ "__builtin_trap", &void_ctype, 0 },
 	{ "__builtin_uadd_overflow", &bool_ctype, 0, { &uint_ctype, &uint_ctype, &uint_ptr_ctype }},
 	{ "__builtin_uaddl_overflow", &bool_ctype, 0, { &ulong_ctype, &ulong_ctype, &ulong_ptr_ctype }},
diff --git a/validation/builtin-counted-by-ref-err.c b/validation/builtin-counted-by-ref-err.c
new file mode 100644
index 000000000000..242e1a3f441c
--- /dev/null
+++ b/validation/builtin-counted-by-ref-err.c
@@ -0,0 +1,20 @@
+struct fam {
+	int count;
+	char arr[];
+};
+
+static void test_cbr_args(struct fam *f)
+{
+	(void)__builtin_counted_by_ref();
+	(void)__builtin_counted_by_ref(f->arr, 1);
+}
+
+/*
+ * check-name: builtin-counted-by-ref-err
+ * check-command: sparse $file
+ *
+ * check-error-start
+builtin-counted-by-ref-err.c:8:39: error: not enough arguments for __builtin_counted_by_ref
+builtin-counted-by-ref-err.c:9:39: error: too many arguments for __builtin_counted_by_ref
+ * check-error-end
+ */
diff --git a/validation/builtins-kernel.c b/validation/builtins-kernel.c
new file mode 100644
index 000000000000..05c13f4c1eae
--- /dev/null
+++ b/validation/builtins-kernel.c
@@ -0,0 +1,42 @@
+#if !__has_builtin(__builtin_dynamic_object_size)
+#error "missing __builtin_dynamic_object_size"
+#endif
+
+#if !__has_builtin(__builtin_thread_pointer)
+#error "missing __builtin_thread_pointer"
+#endif
+
+#if !__has_builtin(__builtin_alloca_uninitialized)
+#error "missing __builtin_alloca_uninitialized"
+#endif
+
+#if !__has_builtin(__builtin_counted_by_ref)
+#error "missing __builtin_counted_by_ref"
+#endif
+
+struct fam {
+	int count;
+	char arr[];
+};
+
+static void test_builtins(struct fam *f)
+{
+	char buf[10];
+	void *tp = __builtin_thread_pointer();
+	void *al = __builtin_alloca_uninitialized(32);
+	void *cbr = __builtin_counted_by_ref(f->arr);
+	int is_null = (__builtin_counted_by_ref(f->arr) == (void *)0);
+	unsigned long sz0 = __builtin_dynamic_object_size(buf, 0);
+	unsigned long sz1 = __builtin_dynamic_object_size(buf, 1);
+
+	(void)tp;
+	(void)al;
+	(void)cbr;
+	(void)is_null;
+	(void)sz0;
+	(void)sz1;
+}
+
+/*
+ * check-name: builtins-kernel
+ */