WIP: Add support for function attributes

Author: antoyo

gcc/jit/jit-playback.cc

@@ -19,6 +19,7 @@ along with GCC; see the file COPYING3.  If not see
 <http://www.gnu.org/licenses/>.  */
 
 #include "config.h"
+#include "libgccjit.h"
 #include "system.h"
 #include "coretypes.h"
 #include "target.h"
@@ -505,6 +506,16 @@ 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";
+  }
+  return NULL;
+}
+
 /* Construct a playback::function instance.  */
 
 playback::function *
@@ -516,7 +527,8 @@ new_function (location *loc,
 	      const auto_vec<param *> *params,
 	      int is_variadic,
 	      enum built_in_function builtin_id,
-	      int is_target_builtin)
+	      int is_target_builtin,
+	      const std::vector<std::pair<gcc_jit_fn_attribute, std::string>> &attributes)
 {
   int i;
   param *param;
@@ -609,6 +621,23 @@ new_function (location *loc,
 		   DECL_ATTRIBUTES (fndecl));
     }
 
+  for (auto attr: 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"
@@ -106,7 +108,8 @@ class context : public log_user
 		const auto_vec<param *> *params,
 		int is_variadic,
 		enum built_in_function builtin_id,
-		int is_target_builtin);
+		int is_target_builtin,
+		const std::vector<std::pair<gcc_jit_fn_attribute, std::string>> &attributes);
 
   lvalue *
   new_global (location *loc,

gcc/jit/jit-recording.cc

@@ -4176,7 +4176,8 @@ recording::function::function (context *ctxt,
   m_locals (),
   m_blocks (),
   m_fn_ptr_type (NULL),
-  m_is_target_builtin (is_target_builtin)
+  m_is_target_builtin (is_target_builtin),
+  m_attributes()
 {
   for (int i = 0; i< num_params; i++)
     {
@@ -4236,7 +4237,8 @@ recording::function::replay_into (replayer *r)
 				     &params,
 				     m_is_variadic,
 				     m_builtin_id,
-				     m_is_target_builtin));
+				     m_is_target_builtin,
+				     m_attributes));
 }
 
 /* Create a recording::local instance and add it to
@@ -4480,6 +4482,12 @@ recording::function::get_address (recording::location *loc)
   return result;
 }
 
+void
+recording::function::add_attribute (gcc_jit_fn_attribute attribute, const char* value)
+{
+  m_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,9 +23,11 @@ along with GCC; see the file COPYING3.  If not see
 
 #include "jit-common.h"
 #include "jit-logging.h"
+#include "libgccjit.h"
 
 #include <string>
 #include <unordered_map>
+#include <vector>
 
 class timer;
 
@@ -1419,6 +1421,8 @@ class function : public memento
 
   rvalue *get_address (location *loc);
 
+  void add_attribute (gcc_jit_fn_attribute attribute, const char* value);
+
 private:
   string * make_debug_string () FINAL OVERRIDE;
   void write_reproducer (reproducer &r) FINAL OVERRIDE;
@@ -1435,6 +1439,7 @@ class function : public memento
   auto_vec<block *> m_blocks;
   type *m_fn_ptr_type;
   int m_is_target_builtin;
+  std::vector<std::pair<gcc_jit_fn_attribute, std::string>> m_attributes;
 };
 
 class block : public memento

gcc/jit/libgccjit.cc

@@ -4082,6 +4082,14 @@ 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, const char* value)
+{
+  RETURN_IF_FAIL (func, NULL, NULL, "NULL func");
+
+  func->add_attribute (attribute, value);
+}
+
 /* Public entrypoint.  See description in libgccjit.h.
 
    After error-checking, the real work is done by the

gcc/jit/libgccjit.h

@@ -2037,6 +2037,17 @@ 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,
+};
+
+/* Add an attribute to a function.  */
+// TODO: also support integer values.
+extern void
+gcc_jit_function_add_attribute (gcc_jit_function *func, gcc_jit_fn_attribute attribute, const char* value);
+
 #ifdef __cplusplus
 }
 #endif /* __cplusplus */

gcc/jit/libgccjit.map

@@ -298,3 +298,8 @@ LIBGCCJIT_ABI_29 {
   global:
     gcc_jit_global_set_readonly;
 } LIBGCCJIT_ABI_28;
+
+LIBGCCJIT_ABI_30 {
+  global:
+    gcc_jit_function_add_attribute;
+} LIBGCCJIT_ABI_29;