Add support for the weak variable attribute

antoyo · antoyo · commit 4b9b1786acf6 · 2024-11-21T11:03:00.000-05:00
diff --git a/gcc/jit/jit-playback.cc b/gcc/jit/jit-playback.cc
@@ -595,6 +595,8 @@ const char* variable_attribute_to_string (gcc_jit_variable_attribute attr)
   {
     case GCC_JIT_VARIABLE_ATTRIBUTE_VISIBILITY:
       return "visibility";
+    case GCC_JIT_VARIABLE_ATTRIBUTE_WEAK:
+      return "weak";
     case GCC_JIT_VARIABLE_ATTRIBUTE_MAX:
       return NULL;
   }
@@ -780,7 +782,8 @@ global_new_decl (location *loc,
 		 const char *name,
 		 enum global_var_flags flags,
 		 const std::vector<std::pair<gcc_jit_variable_attribute,
-					     std::string>> &attributes,
+					     std::string>> &string_attributes,
+		 const std::vector<gcc_jit_variable_attribute> &attributes,
 		 bool readonly)
 {
   gcc_assert (type);
@@ -826,7 +829,19 @@ global_new_decl (location *loc,
   if (loc)
     set_tree_location (inner, loc);
 
-  set_variable_string_attribute (attributes, inner);
+  set_variable_string_attribute (string_attributes, inner);
+
+  tree var_attributes = NULL_TREE;
+  for (auto attr: attributes)
+  {
+    const char* attribute = variable_attribute_to_string (attr);
+    if (attribute)
+    {
+      tree ident = get_identifier (attribute);
+      var_attributes = tree_cons (ident, NULL_TREE, var_attributes);
+    }
+  }
+  decl_attributes (&inner, var_attributes, 0);
 
   return inner;
 }
@@ -873,11 +888,13 @@ new_global (location *loc,
 	    const char *name,
 	    enum global_var_flags flags,
 	    const std::vector<std::pair<gcc_jit_variable_attribute,
-					std::string>> &attributes,
+					std::string>> &string_attributes,
+	    const std::vector<gcc_jit_variable_attribute> &attributes,
 	    bool readonly)
 {
   tree inner =
-    global_new_decl (loc, kind, type, name, flags, attributes, readonly);
+    global_new_decl (loc, kind, type, name, flags, string_attributes,
+        attributes, readonly);
 
   return global_finalize_lvalue (inner);
 }
@@ -1024,10 +1041,13 @@ new_global_initialized (location *loc,
 			const char *name,
 			enum global_var_flags flags,
 			const std::vector<std::pair<gcc_jit_variable_attribute,
-						    std::string>> &attributes,
+						    std::string>> &string_attributes,
+			const std::vector<gcc_jit_variable_attribute>
+					  &attributes,
 			bool readonly)
 {
-  tree inner = global_new_decl (loc, kind, type, name, flags, attributes, readonly);
+  tree inner = global_new_decl (loc, kind, type, name, flags,
+        string_attributes, attributes, readonly);
 
   vec<constructor_elt, va_gc> *constructor_elements = NULL;
 
diff --git a/gcc/jit/jit-playback.h b/gcc/jit/jit-playback.h
@@ -136,7 +136,8 @@ class context : public log_user
 	      const char *name,
 	      enum global_var_flags flags,
 	      const std::vector<std::pair<gcc_jit_variable_attribute,
-					  std::string>> &attributes,
+					  std::string>> &string_attributes,
+	      const std::vector<gcc_jit_variable_attribute> &attributes,
 	      bool readonly);
 
   lvalue *
@@ -151,6 +152,8 @@ class context : public log_user
 			  const std::vector<std::pair<
 					    gcc_jit_variable_attribute,
 					    std::string>>
+					    &string_attributes,
+			  const std::vector<gcc_jit_variable_attribute>
 					    &attributes,
 			  bool readonly);
 
@@ -360,7 +363,8 @@ class context : public log_user
 		   const char *name,
 		   enum global_var_flags flags,
 		   const std::vector<std::pair<gcc_jit_variable_attribute,
-					       std::string>> &attributes,
+					       std::string>> &string_attributes,
+		   const std::vector<gcc_jit_variable_attribute> &attributes,
 		   bool readonly);
   lvalue *
   global_finalize_lvalue (tree inner);
diff --git a/gcc/jit/jit-recording.cc b/gcc/jit/jit-recording.cc
@@ -4406,6 +4406,12 @@ void recording::lvalue::add_string_attribute (
   m_string_attributes.push_back (std::make_pair (attribute, std::string (value)));
 }
 
+void recording::lvalue::add_attribute (
+	gcc_jit_variable_attribute attribute)
+{
+  m_attributes.push_back (attribute);
+}
+
 /* The implementation of class gcc::jit::recording::param.  */
 
 /* Implementation of pure virtual hook recording::memento::replay_into
@@ -5461,13 +5467,15 @@ recording::global::replay_into (replayer *r)
 				 playback_string (m_name),
 				 m_flags,
 				 m_string_attributes,
+				 m_attributes,
 				 m_readonly)
     : r->new_global (playback_location (r, m_loc),
 		     m_kind,
 		     m_type->playback_type (),
 		     playback_string (m_name),
 		     m_flags,
 		     m_string_attributes,
+		     m_attributes,
 		     m_readonly);
 
   if (m_tls_model != GCC_JIT_TLS_MODEL_NONE)
@@ -5536,6 +5544,7 @@ recording::global::write_to_dump (dump &d)
     if (attribute)
       d.write ("__attribute(%s(\"%s\"))__\n", attribute, value.c_str());
   }
+  // TODO: handle m_attributes.
   d.write ("%s %s",
 	   m_type->get_debug_string (),
 	   get_debug_string ());
@@ -5608,6 +5617,7 @@ static const char * const tls_model_enum_strings[] = {
 
 static const char * const gcc_jit_variable_attribute_enum_strings[] = {
   "GCC_JIT_VARIABLE_ATTRIBUTE_VISIBILITY",
+  "GCC_JIT_VARIABLE_ATTRIBUTE_WEAK",
 };
 
 void
@@ -5644,6 +5654,7 @@ recording::global::write_reproducer (reproducer &r)
 	    id,
 	    gcc_jit_variable_attribute_enum_strings[std::get<0>(attribute)],
 	    std::get<1>(attribute).c_str());
+  // TODO: handle m_attributes.
 
   if (m_readonly)
     r.write ("  gcc_jit_global_set_readonly (%s /* gcc_jit_lvalue *lvalue */);\n",
diff --git a/gcc/jit/jit-recording.h b/gcc/jit/jit-recording.h
@@ -1446,7 +1446,8 @@ class lvalue : public rvalue
     m_reg_name (NULL),
     m_tls_model (GCC_JIT_TLS_MODEL_NONE),
     m_alignment (0),
-    m_string_attributes ()
+    m_string_attributes (),
+    m_attributes ()
   {}
 
   playback::lvalue *
@@ -1468,6 +1469,7 @@ class lvalue : public rvalue
   const char *access_as_rvalue (reproducer &r) override;
 
   void add_string_attribute (gcc_jit_variable_attribute attribute, const char* value);
+  void add_attribute (gcc_jit_variable_attribute attribute);
 
   bool get_readonly () const
   {
@@ -1495,6 +1497,7 @@ class lvalue : public rvalue
   unsigned m_alignment;
   std::vector<std::pair<gcc_jit_variable_attribute,
 	      std::string>> m_string_attributes;
+  std::vector<gcc_jit_variable_attribute> m_attributes;
   bool m_readonly = false;
 };
 
diff --git a/gcc/jit/libgccjit.cc b/gcc/jit/libgccjit.cc
@@ -4406,6 +4406,23 @@ gcc_jit_lvalue_add_string_attribute (gcc_jit_lvalue *variable,
   variable->add_string_attribute (attribute, value);
 }
 
+void
+gcc_jit_lvalue_add_attribute (gcc_jit_lvalue *variable,
+			      gcc_jit_variable_attribute attribute)
+{
+  RETURN_IF_FAIL (variable, NULL, NULL, "NULL variable");
+  RETURN_IF_FAIL (variable->is_global () || variable->is_local (),
+		  NULL,
+		  NULL,
+		  "variable should be a variable");
+  RETURN_IF_FAIL ((attribute >= 0 && attribute < GCC_JIT_VARIABLE_ATTRIBUTE_MAX),
+		  NULL,
+		  NULL,
+		  "attribute should be a `gcc_jit_variable_attribute` enum value");
+
+  variable->add_attribute (attribute);
+}
+
 void
 gcc_jit_type_set_packed (gcc_jit_type *type)
 {
diff --git a/gcc/jit/libgccjit.h b/gcc/jit/libgccjit.h
@@ -2194,6 +2194,7 @@ gcc_jit_function_add_integer_array_attribute (
 enum gcc_jit_variable_attribute
 {
   GCC_JIT_VARIABLE_ATTRIBUTE_VISIBILITY,
+  GCC_JIT_VARIABLE_ATTRIBUTE_WEAK,
 
   /* Maximum value of this enum, should always be last. */
   GCC_JIT_VARIABLE_ATTRIBUTE_MAX,
@@ -2211,6 +2212,11 @@ gcc_jit_context_set_output_ident (gcc_jit_context *ctxt,
 
 #define LIBGCCJIT_HAVE_gcc_jit_context_set_output_ident
 
+/* Add an attribute to a variable.  */
+extern void
+gcc_jit_lvalue_add_attribute (gcc_jit_lvalue *variable,
+			      enum gcc_jit_variable_attribute attribute);
+
 extern gcc_jit_target_info *
 gcc_jit_context_get_target_info (gcc_jit_context *ctxt);
 
diff --git a/gcc/jit/libgccjit.map b/gcc/jit/libgccjit.map
@@ -368,3 +368,8 @@ LIBGCCJIT_ABI_41 {
   global:
     gcc_jit_rvalue_set_type;
 } LIBGCCJIT_ABI_40;
+
+LIBGCCJIT_ABI_42 {
+  global:
+    gcc_jit_lvalue_add_attribute;
+} LIBGCCJIT_ABI_41;
