WIP: Add support for function attributes

Author: antoyo

gcc/jit/jit-playback.cc

@@ -20,6 +20,7 @@ along with GCC; see the file COPYING3.  If not see
 
 #include "config.h"
 #define INCLUDE_MUTEX
+#include "libgccjit.h"
 #include "system.h"
 #include "coretypes.h"
 #include "target.h"
@@ -507,6 +508,20 @@ new_param (location *loc,
   return new param (this, inner);
 }
 
+const char* fn_attribute_to_string(gcc_jit_fn_attribute attr)
+{
+  switch (attr)
+  {
+    case GCC_JIT_FN_ATTRIBUTE_TARGET:
+      return "target";
+    case GCC_JIT_FN_ATTRIBUTE_USED:
+      return "used";
+    case GCC_JIT_FN_ATTRIBUTE_VISIBILITY:
+      return "visibility";
+  }
+  return NULL;
+}
+
 /* Construct a playback::function instance.  */
 
 playback::function *
@@ -517,7 +532,9 @@ new_function (location *loc,
 	      const char *name,
 	      const auto_vec<param *> *params,
 	      int is_variadic,
-	      enum built_in_function builtin_id)
+	      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)
 {
   int i;
   param *param;
@@ -602,6 +619,38 @@ new_function (location *loc,
 		   DECL_ATTRIBUTES (fndecl));
     }
 
+  for (auto attr: attributes)
+  {
+    tree ident = get_identifier (fn_attribute_to_string (attr));
+
+    /* See handle_used_attribute in gcc/c-family/c-attribs.cc.  */
+    if (attr == GCC_JIT_FN_ATTRIBUTE_USED)
+    {
+      TREE_USED (fndecl) = 1;
+      DECL_PRESERVE_P (fndecl) = 1;
+    }
+
+    DECL_ATTRIBUTES (fndecl) =
+      tree_cons (ident, NULL_TREE, DECL_ATTRIBUTES (fndecl));
+  }
+
+  for (auto attr: string_attributes)
+  {
+    gcc_jit_fn_attribute& name = std::get<0>(attr);
+    std::string& value = std::get<1>(attr);
+    tree attribute_value = build_tree_list (NULL_TREE, ::build_string (value.length () + 1, value.c_str ()));
+    tree ident = get_identifier (fn_attribute_to_string (name));
+
+    /* See handle_target_attribute in gcc/c-family/c-attribs.cc.  */
+    if (name == GCC_JIT_FN_ATTRIBUTE_TARGET)
+      /* We need to call valid_attribute_p so that the hook set-up some internal options.  */
+      if (!targetm.target_option.valid_attribute_p (fndecl, ident, attribute_value, 0))
+        continue;
+
+    DECL_ATTRIBUTES (fndecl) =
+      tree_cons (ident, attribute_value, DECL_ATTRIBUTES (fndecl));
+  }
+
   function *func = new function (this, fndecl, kind);
   m_functions.safe_push (func);
   return func;

gcc/jit/jit-playback.h

@@ -21,7 +21,9 @@ along with GCC; see the file COPYING3.  If not see
 #ifndef JIT_PLAYBACK_H
 #define JIT_PLAYBACK_H
 
+#include <string>
 #include <utility> // for std::pair
+#include <vector>
 
 #include "timevar.h"
 #include "varasm.h"
@@ -105,7 +107,9 @@ class context : public log_user
 		const char *name,
 		const auto_vec<param *> *params,
 		int is_variadic,
-		enum built_in_function builtin_id);
+		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);
 
   lvalue *
   new_global (location *loc,

gcc/jit/jit-recording.cc

@@ -4080,7 +4080,9 @@ recording::function::function (context *ctxt,
   m_builtin_id (builtin_id),
   m_locals (),
   m_blocks (),
-  m_fn_ptr_type (NULL)
+  m_fn_ptr_type (NULL),
+  m_attributes(),
+  m_string_attributes()
 {
   for (int i = 0; i< num_params; i++)
     {
@@ -4139,7 +4141,9 @@ recording::function::replay_into (replayer *r)
 				     m_name->c_str (),
 				     &params,
 				     m_is_variadic,
-				     m_builtin_id));
+				     m_builtin_id,
+				     m_attributes,
+				     m_string_attributes));
 }
 
 /* Create a recording::local instance and add it to
@@ -4382,6 +4386,18 @@ recording::function::get_address (recording::location *loc)
   return result;
 }
 
+void
+recording::function::add_attribute (gcc_jit_fn_attribute attribute)
+{
+  m_attributes.push_back (attribute);
+}
+
+void
+recording::function::add_string_attribute (gcc_jit_fn_attribute attribute, const char* value)
+{
+  m_string_attributes.push_back (std::make_pair (attribute, std::string (value)));
+}
+
 /* Implementation of recording::memento::make_debug_string for
    functions.  */
 

gcc/jit/jit-recording.h

@@ -23,6 +23,10 @@ along with GCC; see the file COPYING3.  If not see
 
 #include "jit-common.h"
 #include "jit-logging.h"
+#include "libgccjit.h"
+
+#include <string>
+#include <vector>
 
 class timer;
 
@@ -1326,6 +1330,9 @@ class function : public memento
 
   rvalue *get_address (location *loc);
 
+  void add_attribute (gcc_jit_fn_attribute attribute);
+  void add_string_attribute (gcc_jit_fn_attribute attribute, const char* value);
+
 private:
   string * make_debug_string () final override;
   void write_reproducer (reproducer &r) final override;
@@ -1341,6 +1348,8 @@ class function : public memento
   auto_vec<local *> m_locals;
   auto_vec<block *> m_blocks;
   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;
 };
 
 class block : public memento

gcc/jit/libgccjit.cc

@@ -4015,6 +4015,22 @@ gcc_jit_type_set_packed (gcc_jit_type *type)
   type->set_packed ();
 }
 
+void
+gcc_jit_function_add_attribute (gcc_jit_function *func, gcc_jit_fn_attribute attribute)
+{
+  RETURN_IF_FAIL (func, NULL, NULL, "NULL func");
+
+  func->add_attribute (attribute);
+}
+
+void
+gcc_jit_function_add_string_attribute (gcc_jit_function *func, gcc_jit_fn_attribute attribute, const char* value)
+{
+  RETURN_IF_FAIL (func, NULL, NULL, "NULL func");
+
+  func->add_string_attribute (attribute, value);
+}
+
 /* Public entrypoint.  See description in libgccjit.h.
 
    After error-checking, the real work is done by the

gcc/jit/libgccjit.h

@@ -2008,6 +2008,22 @@ gcc_jit_type_unqualified (gcc_jit_type *type);
 extern void
 gcc_jit_type_set_packed (gcc_jit_type *type);
 
+/* Function attributes.  */
+enum gcc_jit_fn_attribute
+{
+  GCC_JIT_FN_ATTRIBUTE_TARGET,
+  GCC_JIT_FN_ATTRIBUTE_USED,
+  GCC_JIT_FN_ATTRIBUTE_VISIBILITY,
+};
+
+/* 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);
+
 #ifdef __cplusplus
 }
 #endif /* __cplusplus */

gcc/jit/libgccjit.map

@@ -291,3 +291,9 @@ LIBGCCJIT_ABI_28 {
   global:
     gcc_jit_global_set_readonly;
 } LIBGCCJIT_ABI_27;
+
+LIBGCCJIT_ABI_29 {
+  global:
+    gcc_jit_function_add_attribute;
+    gcc_jit_function_add_string_attribute;
+} LIBGCCJIT_ABI_28;