WIP: Add support for variable attributes

antoyo · antoyo · commit e7f055bf1cf7 · 2022-08-28T20:03:03.000-04:00
diff --git a/gcc/jit/jit-playback.cc b/gcc/jit/jit-playback.cc
@@ -522,6 +522,16 @@ const char* fn_attribute_to_string(gcc_jit_fn_attribute attr)
   return NULL;
 }
 
+const char* variable_attribute_to_string(gcc_jit_variable_attribute attr)
+{
+  switch (attr)
+  {
+    case GCC_JIT_VARIABLE_ATTRIBUTE_VISIBILITY:
+      return "visibility";
+  }
+  return NULL;
+}
+
 /* Construct a playback::function instance.  */
 
 playback::function *
@@ -674,7 +684,8 @@ global_new_decl (location *loc,
 		 type *type,
 		 const char *name,
 		 enum global_var_flags flags,
-		 bool readonly)
+		 bool readonly,
+		 const std::vector<std::pair<gcc_jit_variable_attribute, std::string>> &attributes)
 {
   gcc_assert (type);
   gcc_assert (name);
@@ -719,9 +730,27 @@ global_new_decl (location *loc,
   if (loc)
     set_tree_location (inner, loc);
 
+  set_variable_attribute (attributes, inner);
+
   return inner;
 }
 
+void
+playback::
+set_variable_attribute(const std::vector<std::pair<gcc_jit_variable_attribute, std::string>> &attributes, tree decl)
+{
+  for (auto attr: attributes)
+  {
+    gcc_jit_variable_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 (variable_attribute_to_string (name));
+
+    DECL_ATTRIBUTES (decl) =
+      tree_cons (ident, attribute_value, DECL_ATTRIBUTES (decl));
+  }
+}
+
 /* In use by new_global and new_global_initialized.  */
 
 playback::lvalue *
@@ -742,10 +771,11 @@ new_global (location *loc,
 	    type *type,
 	    const char *name,
 	    enum global_var_flags flags,
-	    bool readonly)
+	    bool readonly,
+	    const std::vector<std::pair<gcc_jit_variable_attribute, std::string>> &attributes)
 {
   tree inner =
-    global_new_decl (loc, kind, type, name, flags, readonly);
+    global_new_decl (loc, kind, type, name, flags, readonly, attributes);
 
   return global_finalize_lvalue (inner);
 }
@@ -891,9 +921,10 @@ new_global_initialized (location *loc,
 			const void *initializer,
 			const char *name,
 			enum global_var_flags flags,
-			bool readonly)
+			bool readonly,
+			const std::vector<std::pair<gcc_jit_variable_attribute, std::string>> &attributes)
 {
-  tree inner = global_new_decl (loc, kind, type, name, flags, readonly);
+  tree inner = global_new_decl (loc, kind, type, name, flags, readonly, attributes);
 
   vec<constructor_elt, va_gc> *constructor_elements = NULL;
 
@@ -2072,7 +2103,8 @@ playback::lvalue *
 playback::function::
 new_local (location *loc,
 	   type *type,
-	   const char *name)
+	   const char *name,
+	   const std::vector<std::pair<gcc_jit_variable_attribute, std::string>> &attributes)
 {
   gcc_assert (type);
   gcc_assert (name);
@@ -2085,6 +2117,8 @@ new_local (location *loc,
   DECL_CHAIN (inner) = BIND_EXPR_VARS (m_inner_bind_expr);
   BIND_EXPR_VARS (m_inner_bind_expr) = inner;
 
+  set_variable_attribute (attributes, inner);
+
   if (loc)
     set_tree_location (inner, loc);
   return new lvalue (m_ctxt, inner);
diff --git a/gcc/jit/jit-playback.h b/gcc/jit/jit-playback.h
@@ -43,6 +43,9 @@ namespace jit {
 
 namespace playback {
 
+void
+set_variable_attribute(const std::vector<std::pair<gcc_jit_variable_attribute, std::string>> &attributes, tree decl);
+
 /* playback::context is an abstract base class.
 
    The two concrete subclasses are:
@@ -118,7 +121,8 @@ class context : public log_user
 	      type *type,
 	      const char *name,
 	      enum global_var_flags flags,
-	      bool readonly);
+	      bool readonly,
+	      const std::vector<std::pair<gcc_jit_variable_attribute, std::string>> &attributes);
 
   lvalue *
   new_global_initialized (location *loc,
@@ -129,7 +133,8 @@ class context : public log_user
                           const void *initializer,
 			  const char *name,
 			  enum global_var_flags flags,
-			  bool readonly);
+			  bool readonly,
+			  const std::vector<std::pair<gcc_jit_variable_attribute, std::string>> &attributes);
 
   rvalue *
   new_ctor (location *log,
@@ -332,7 +337,8 @@ class context : public log_user
                    type *type,
 		   const char *name,
 		   enum global_var_flags flags,
-		   bool readonly);
+		   bool readonly,
+		   const std::vector<std::pair<gcc_jit_variable_attribute, std::string>> &attributes);
   lvalue *
   global_finalize_lvalue (tree inner);
 
@@ -520,7 +526,8 @@ class function : public wrapper
   lvalue *
   new_local (location *loc,
 	     type *type,
-	     const char *name);
+	     const char *name,
+	     const std::vector<std::pair<gcc_jit_variable_attribute, std::string>> &attributes);
 
   block*
   new_block (const char *name);
diff --git a/gcc/jit/jit-recording.cc b/gcc/jit/jit-recording.cc
@@ -4095,6 +4095,11 @@ void recording::lvalue::set_alignment (unsigned bytes)
   m_alignment = bytes;
 }
 
+void recording::lvalue::add_attribute (gcc_jit_variable_attribute attribute, const char* value)
+{
+  m_attributes.push_back (std::make_pair (attribute, std::string (value)));
+}
+
 /* The implementation of class gcc::jit::recording::param.  */
 
 /* Implementation of pure virtual hook recording::memento::replay_into
@@ -4969,13 +4974,15 @@ recording::global::replay_into (replayer *r)
 				 m_initializer,
 				 playback_string (m_name),
 				 m_flags,
-				 m_readonly)
+				 m_readonly,
+				 m_attributes)
     : r->new_global (playback_location (r, m_loc),
 		     m_kind,
 		     m_type->playback_type (),
 		     playback_string (m_name),
 		     m_flags,
-		     m_readonly);
+		     m_readonly,
+		     m_attributes);
 
   if (m_tls_model != GCC_JIT_TLS_MODEL_NONE)
     global->set_tls_model (recording::tls_models[m_tls_model]);
@@ -6916,7 +6923,8 @@ recording::local::replay_into (replayer *r)
   playback::lvalue *obj = m_func->playback_function ()
       ->new_local (playback_location (r, m_loc),
 		   m_type->playback_type (),
-		   playback_string (m_name));
+		   playback_string (m_name),
+		   m_attributes);
 
   if (m_reg_name != NULL)
     obj->set_register_name (m_reg_name->c_str ());
diff --git a/gcc/jit/jit-recording.h b/gcc/jit/jit-recording.h
@@ -1303,7 +1303,8 @@ class lvalue : public rvalue
     m_link_section (NULL),
     m_reg_name (NULL),
     m_tls_model (GCC_JIT_TLS_MODEL_NONE),
-    m_alignment (0)
+    m_alignment (0),
+    m_attributes ()
   {}
 
   playback::lvalue *
@@ -1329,6 +1330,8 @@ class lvalue : public rvalue
     m_readonly = true;
   }
 
+  void add_attribute (gcc_jit_variable_attribute attribute, const char* value);
+
   virtual const char *access_as_lvalue (reproducer &r);
   virtual bool is_global () const { return false; }
   void set_tls_model (enum gcc_jit_tls_model model);
@@ -1343,6 +1346,7 @@ class lvalue : public rvalue
   enum gcc_jit_tls_model m_tls_model;
   unsigned m_alignment;
   bool m_readonly = false;
+  std::vector<std::pair<gcc_jit_variable_attribute, std::string>> m_attributes;
 };
 
 class param : public lvalue
diff --git a/gcc/jit/libgccjit.cc b/gcc/jit/libgccjit.cc
@@ -4111,6 +4111,14 @@ gcc_jit_function_add_string_attribute (gcc_jit_function *func, gcc_jit_fn_attrib
   func->add_string_attribute (attribute, value);
 }
 
+void
+gcc_jit_lvalue_add_attribute (gcc_jit_lvalue *variable, gcc_jit_variable_attribute attribute, const char* value)
+{
+  RETURN_IF_FAIL (variable, NULL, NULL, "NULL variable");
+
+  variable->add_attribute (attribute, value);
+}
+
 /* Public entrypoint.  See description in libgccjit.h.
 
    After error-checking, the real work is done by the
diff --git a/gcc/jit/libgccjit.h b/gcc/jit/libgccjit.h
@@ -2061,6 +2061,17 @@ gcc_jit_function_add_attribute (gcc_jit_function *func, gcc_jit_fn_attribute att
 extern void
 gcc_jit_function_add_string_attribute (gcc_jit_function *func, gcc_jit_fn_attribute attribute, const char* value);
 
+/* Variable attributes.  */
+enum gcc_jit_variable_attribute
+{
+  GCC_JIT_VARIABLE_ATTRIBUTE_VISIBILITY,
+};
+
+/* Add an attribute to a variable.  */
+// TODO: also support integer values.
+extern void
+gcc_jit_lvalue_add_attribute (gcc_jit_lvalue *variable, gcc_jit_variable_attribute attribute, const char* value);
+
 #ifdef __cplusplus
 }
 #endif /* __cplusplus */
diff --git a/gcc/jit/libgccjit.map b/gcc/jit/libgccjit.map
@@ -305,3 +305,8 @@ LIBGCCJIT_ABI_30 {
     gcc_jit_function_add_attribute;
     gcc_jit_function_add_string_attribute;
 } LIBGCCJIT_ABI_29;
+
+LIBGCCJIT_ABI_31 {
+  global:
+    gcc_jit_lvalue_add_attribute;
+} LIBGCCJIT_ABI_30;
