Merge pull request #28 from GuillaumeGomez/non-null

Add support for multiple integers value for attribute and `NonNull`

Author: antoyo

gcc/jit/dummy-frontend.cc

@@ -539,6 +539,8 @@ const char* fn_attribute_to_string(gcc_jit_fn_attribute attr)
       return "const";
     case GCC_JIT_FN_ATTRIBUTE_WEAK:
       return "weak";
+    case GCC_JIT_FN_ATTRIBUTE_NONNULL:
+      return "nonnull";
   }
   return NULL;
 }
@@ -566,6 +568,7 @@ new_function (location *loc,
 	      enum built_in_function builtin_id,
 	      const std::vector<gcc_jit_fn_attribute> &attributes,
 	      const std::vector<std::pair<gcc_jit_fn_attribute, std::string>> &string_attributes,
+	      const std::vector<std::pair<gcc_jit_fn_attribute, std::vector<int>>> &int_array_attributes,
 	      int is_target_builtin)
 {
   int i;
@@ -601,6 +604,8 @@ new_function (location *loc,
   DECL_RESULT (fndecl) = resdecl;
   DECL_CONTEXT (resdecl) = fndecl;
 
+  tree fn_attributes = NULL_TREE;
+
   if (is_target_builtin)
   {
     tree *decl = target_builtins.get(name);
@@ -654,48 +659,24 @@ new_function (location *loc,
       DECL_DECLARED_INLINE_P (fndecl) = 1;
 
       /* Add attribute "always_inline": */
-      DECL_ATTRIBUTES (fndecl) =
+      fn_attributes =
 	tree_cons (get_identifier ("always_inline"),
 		   NULL,
-		   DECL_ATTRIBUTES (fndecl));
+		   fn_attributes);
     }
 
+  /* All attributes need to be declared in `dummy-frontend.cc` and more
+     specifically in `jit_attribute_table`. */
   for (auto attr: attributes)
   {
-    if (attr == GCC_JIT_FN_ATTRIBUTE_ALWAYS_INLINE)
-    {
+    if (attr == GCC_JIT_FN_ATTRIBUTE_INLINE)
       DECL_DECLARED_INLINE_P (fndecl) = 1;
-      DECL_DISREGARD_INLINE_LIMITS (fndecl) = 1;
-    }
-    else if (attr == GCC_JIT_FN_ATTRIBUTE_INLINE)
-      DECL_DECLARED_INLINE_P (fndecl) = 1;
-    else if (attr == GCC_JIT_FN_ATTRIBUTE_NOINLINE)
-      DECL_UNINLINABLE (fndecl) = 1;
-    /* See handle_used_attribute in gcc/c-family/c-attribs.cc.  */
-    else if (attr == GCC_JIT_FN_ATTRIBUTE_USED)
-    {
-      TREE_USED (fndecl) = 1;
-      DECL_PRESERVE_P (fndecl) = 1;
-    }
-    /* See handle_returns_twice_attribute in gcc/c-family/c-attribs.cc. */
-    else if (attr == GCC_JIT_FN_ATTRIBUTE_RETURNS_TWICE)
-      DECL_IS_RETURNS_TWICE (fndecl) = 1;
-    /* See handle_pure_attribute in gcc/c-family/c-attribs.cc. */
-    else if (attr == GCC_JIT_FN_ATTRIBUTE_PURE)
-      DECL_PURE_P (fndecl) = 1;
-    /* See handle_const_attribute in gcc/c-family/c-attribs.cc. */
-    else if (attr == GCC_JIT_FN_ATTRIBUTE_CONST)
-      TREE_READONLY (fndecl) = 1;
-    /* See handle_weak_attribute in gcc/c-family/c-attribs.cc.  */
-    else if (attr == GCC_JIT_FN_ATTRIBUTE_WEAK)
-      declare_weak (fndecl);
 
     const char* attribute = fn_attribute_to_string (attr);
     if (attribute)
     {
       tree ident = get_identifier (attribute);
-      DECL_ATTRIBUTES (fndecl) =
-	tree_cons (ident, NULL_TREE, DECL_ATTRIBUTES (fndecl));
+      fn_attributes = tree_cons (ident, NULL_TREE, fn_attributes);
     }
   }
 
@@ -713,20 +694,33 @@ new_function (location *loc,
       if (!ident || !targetm.target_option.valid_attribute_p (fndecl, ident, attribute_value, 0))
         continue;
 
-    /* See handle_alias_ifunc_attribute in gcc/c-family/c-attribs.cc.  */
-    if (name == GCC_JIT_FN_ATTRIBUTE_ALIAS)
+    if (ident)
+      fn_attributes = tree_cons (ident, attribute_value, fn_attributes);
+  }
+
+  for (auto attr: int_array_attributes)
+  {
+    gcc_jit_fn_attribute& name = std::get<0>(attr);
+    std::vector<int>& values = std::get<1>(attr);
+
+    const char* attribute = fn_attribute_to_string (name);
+    tree ident = attribute ? get_identifier (attribute) : NULL;
+
+    if (!ident)
+      continue;
+
+    tree tree_list = NULL_TREE;
+    tree *p_tree_list = &tree_list;
+    for (auto value : values)
     {
-      tree id = get_identifier (value.c_str ());
-      /* This counts as a use of the object pointed to.  */
-      TREE_USED (id) = 1;
-      DECL_INITIAL (fndecl) = error_mark_node;
+      tree int_value = build_int_cst (integer_type_node, value);
+      *p_tree_list = build_tree_list (NULL, int_value);
+      p_tree_list = &TREE_CHAIN (*p_tree_list);
     }
-
-    if (ident)
-      DECL_ATTRIBUTES (fndecl) =
-	tree_cons (ident, attribute_value, DECL_ATTRIBUTES (fndecl));
+    fn_attributes = tree_cons (ident, tree_list, fn_attributes);
   }
 
+  decl_attributes (&fndecl, fn_attributes, 0);
   function *func = new function (this, fndecl, kind);
   m_functions.safe_push (func);
   return func;
@@ -2396,7 +2390,7 @@ add_try_catch (location *loc,
   {
     catch_body = build2(CATCH_EXPR, void_type_node, NULL, catch_body);
     tree try_catch = build2 (TRY_CATCH_EXPR, void_type_node,
-            try_body, catch_body);
+	    try_body, catch_body);
     add_stmt (try_catch);
   }
 }
@@ -3794,7 +3788,7 @@ void
 playback::context::
 init_types ()
 {
-  /* See lto_init() in lto-lang.cc or void visit (TypeBasic *t) in D's types.cc 
+  /* See lto_init() in lto-lang.cc or void visit (TypeBasic *t) in D's types.cc
      for reference. If TYPE_NAME is not set, debug info will not contain types */
 #define NAME_TYPE(t,n) \
 if (t) \

gcc/jit/jit-playback.cc

@@ -37,6 +37,8 @@ namespace gcc {
 
 namespace jit {
 
+const char* fn_attribute_to_string(gcc_jit_fn_attribute attr);
+
 /**********************************************************************
  Playback.
  **********************************************************************/
@@ -114,6 +116,7 @@ class context : public log_user
 		enum built_in_function builtin_id,
 		const std::vector<gcc_jit_fn_attribute> &attributes,
 		const std::vector<std::pair<gcc_jit_fn_attribute, std::string>> &string_attributes,
+		const std::vector<std::pair<gcc_jit_fn_attribute, std::vector<int>>> &int_array_attributes,
 		int is_target_builtin);
 
   lvalue *

gcc/jit/jit-playback.h

@@ -4260,6 +4260,7 @@ recording::function::function (context *ctxt,
   m_fn_ptr_type (NULL),
   m_attributes(),
   m_string_attributes(),
+  m_int_array_attributes(),
   m_is_target_builtin (is_target_builtin)
 {
   for (int i = 0; i< num_params; i++)
@@ -4322,6 +4323,7 @@ recording::function::replay_into (replayer *r)
 				     m_builtin_id,
 				     m_attributes,
 				     m_string_attributes,
+				     m_int_array_attributes,
 				     m_is_target_builtin));
 }
 
@@ -4401,6 +4403,40 @@ recording::function::new_block (const char *name)
 void
 recording::function::write_to_dump (dump &d)
 {
+  for (auto attr: m_attributes)
+  {
+    const char* attribute = fn_attribute_to_string (attr);
+    if (attribute)
+      d.write("__attribute(%s)__\n", attribute);
+  }
+  for (auto attr: m_string_attributes)
+  {
+    gcc_jit_fn_attribute& name = std::get<0>(attr);
+    std::string& value = std::get<1>(attr);
+    const char* attribute = fn_attribute_to_string (name);
+
+    if (attribute)
+      d.write("__attribute(%s(\"%s\"))__\n", attribute, value.c_str());
+  }
+  for (auto attr: m_int_array_attributes)
+  {
+    gcc_jit_fn_attribute& name = std::get<0>(attr);
+    std::vector<int>& values = std::get<1>(attr);
+    const char* attribute = fn_attribute_to_string (name);
+    if (attribute)
+    {
+      d.write("__attribute(%s(", attribute);
+      for (int i = 0; i < values.size(); ++i)
+      {
+	if (i > 0)
+	  d.write(", %d", values[i]);
+	else
+	  d.write("%d", values[i]);
+      }
+      d.write("))__\n");
+    }
+  }
+
   switch (m_kind)
     {
     default: gcc_unreachable ();
@@ -4615,6 +4651,12 @@ recording::function::add_string_attribute (gcc_jit_fn_attribute attribute, const
   m_string_attributes.push_back (std::make_pair (attribute, std::string (value)));
 }
 
+void
+recording::function::add_integer_array_attribute (gcc_jit_fn_attribute attribute, const int* value, size_t length)
+{
+  m_int_array_attributes.push_back (std::make_pair (attribute, std::vector<int> (value, value + length)));
+}
+
 /* Implementation of recording::memento::make_debug_string for
    functions.  */
 

gcc/jit/jit-recording.cc

@@ -1483,6 +1483,7 @@ class function : public memento
 
   void add_attribute (gcc_jit_fn_attribute attribute);
   void add_string_attribute (gcc_jit_fn_attribute attribute, const char* value);
+  void add_integer_array_attribute (gcc_jit_fn_attribute attribute, const int* value, size_t length);
 
 private:
   string * make_debug_string () final override;
@@ -1501,6 +1502,7 @@ class function : public memento
   type *m_fn_ptr_type;
   std::vector<gcc_jit_fn_attribute> m_attributes;
   std::vector<std::pair<gcc_jit_fn_attribute, std::string>> m_string_attributes;
+  std::vector<std::pair<gcc_jit_fn_attribute, std::vector<int>>> m_int_array_attributes;
   int m_is_target_builtin;
 };
 

gcc/jit/jit-recording.h

@@ -4234,6 +4234,19 @@ gcc_jit_function_add_string_attribute (gcc_jit_function *func, gcc_jit_fn_attrib
   func->add_string_attribute (attribute, value);
 }
 
+/* This function adds an attribute with multiple integer values. For example
+   `nonnull(1, 2)`. The numbers in `values` are supposed to map how they
+   should be written in C code. So for `nonnull(1, 2)`, you should pass `1`
+   and `2` in `values` (and set `length` to `2`). */
+void
+gcc_jit_function_add_integer_array_attribute (gcc_jit_function *func, gcc_jit_fn_attribute attribute, const int* values, size_t length)
+{
+  RETURN_IF_FAIL (func, NULL, NULL, "NULL func");
+  RETURN_IF_FAIL (values, NULL, NULL, "NULL values");
+
+  func->add_integer_array_attribute (attribute, values, length);
+}
+
 void
 gcc_jit_lvalue_add_attribute (gcc_jit_lvalue *variable, gcc_jit_variable_attribute attribute, const char* value)
 {

gcc/jit/libgccjit.cc

@@ -2117,16 +2117,19 @@ enum gcc_jit_fn_attribute
   GCC_JIT_FN_ATTRIBUTE_PURE,
   GCC_JIT_FN_ATTRIBUTE_CONST,
   GCC_JIT_FN_ATTRIBUTE_WEAK,
+  GCC_JIT_FN_ATTRIBUTE_NONNULL,
 };
 
 /* Add an attribute to a function.  */
-// TODO: also support integer values.
 extern void
 gcc_jit_function_add_attribute (gcc_jit_function *func, enum gcc_jit_fn_attribute attribute);
 
 extern void
 gcc_jit_function_add_string_attribute (gcc_jit_function *func, enum gcc_jit_fn_attribute attribute, const char* value);
 
+extern void
+gcc_jit_function_add_integer_array_attribute (gcc_jit_function *func, enum gcc_jit_fn_attribute attribute, const int* value, size_t length);
+
 /* Variable attributes.  */
 enum gcc_jit_variable_attribute
 {

gcc/jit/libgccjit.h

@@ -335,4 +335,5 @@ LIBGCCJIT_ABI_34 {
 LIBGCCJIT_ABI_35 {
   global:
     gcc_jit_context_new_sizeof;
+    gcc_jit_function_add_integer_array_attribute;
 } LIBGCCJIT_ABI_34;

gcc/jit/libgccjit.map

@@ -0,0 +1,94 @@
+/* { dg-do compile { target x86_64-*-* } } */
+
+#include <stdlib.h>
+#include <stdio.h>
+
+#include "libgccjit.h"
+
+/* We don't want set_options() in harness.h to set -O2 to see that the nonnull
+   attribute affects the optimizations. */
+#define TEST_ESCHEWS_SET_OPTIONS
+static void set_options (gcc_jit_context *ctxt, const char *argv0)
+{
+  // Set "-O2".
+  gcc_jit_context_set_int_option(ctxt, GCC_JIT_INT_OPTION_OPTIMIZATION_LEVEL, 2);
+}
+
+#define TEST_COMPILING_TO_FILE
+#define OUTPUT_KIND      GCC_JIT_OUTPUT_KIND_ASSEMBLER
+#define OUTPUT_FILENAME  "output-of-test-nonnull.c.s"
+#include "harness.h"
+
+void
+create_code (gcc_jit_context *ctxt, void *user_data)
+{
+  /* Let's try to inject the equivalent of:
+
+__attribute__((nonnull(1)))
+int t(int *a) {
+  if (!a) {
+    return -1;
+  }
+  return *a;
+}
+  */
+  gcc_jit_type *int_type =
+    gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_INT);
+  gcc_jit_type *pint_type = gcc_jit_type_get_pointer(int_type);
+
+  gcc_jit_param *a =
+    gcc_jit_context_new_param (ctxt, NULL, pint_type, "a");
+
+  gcc_jit_function *func_t =
+    gcc_jit_context_new_function (ctxt, NULL,
+	  GCC_JIT_FUNCTION_EXPORTED,
+	  int_type,
+	  "t",
+	  1, &a,
+	  0);
+  /* Adding `nonnull(1)` attribute. */
+  int indexes[1] = {1};
+  gcc_jit_function_add_integer_array_attribute (
+    func_t,
+    GCC_JIT_FN_ATTRIBUTE_NONNULL,
+    indexes,
+    1
+  );
+
+  /* if (!a) {
+    return -1;
+  } */
+  gcc_jit_block *if_cond =
+    gcc_jit_function_new_block (func_t, "if_cond");
+  gcc_jit_block *if_body =
+    gcc_jit_function_new_block (func_t, "if_body");
+  gcc_jit_block *after_if =
+    gcc_jit_function_new_block (func_t, "after_if");
+
+  /* if (!a) */
+  gcc_jit_block_end_with_conditional (
+    if_cond, NULL,
+    gcc_jit_context_new_comparison (
+      ctxt, NULL,
+      GCC_JIT_COMPARISON_EQ,
+      gcc_jit_param_as_rvalue (a),
+      gcc_jit_context_null (ctxt, pint_type)),
+    if_body,
+    after_if);
+  /* return -1; */
+  gcc_jit_block_end_with_return (
+    if_body, NULL,
+    gcc_jit_context_new_rvalue_from_int (ctxt, int_type, -1));
+
+  /* return *a; */
+  gcc_jit_block_end_with_return (
+    after_if, NULL,
+    gcc_jit_lvalue_as_rvalue (
+      gcc_jit_rvalue_dereference (
+	gcc_jit_param_as_rvalue (a), NULL)));
+}
+
+/* { dg-final { jit-verify-output-file-was-created "" } } */
+/* Check that the "if block" was optimized away */
+/* { dg-final { jit-verify-assembler-output-not "testq" } } */
+/* { dg-final { jit-verify-assembler-output-not "-1" } } */