Add support for the weak variable attribute

Author: antoyo

gcc/jit/jit-playback.cc

@@ -590,6 +590,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;
   }
@@ -775,7 +777,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,
                  bool removed)
 {
@@ -831,7 +834,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;
 }
@@ -879,12 +894,14 @@ 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,
             bool removed)
 {
   tree inner =
-    global_new_decl (loc, kind, type, name, flags, attributes, readonly, removed);
+    global_new_decl (loc, kind, type, name, flags, string_attributes,
+        attributes, readonly, removed);
 
   return global_finalize_lvalue (inner, removed);
 }
@@ -1031,11 +1048,14 @@ 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,
                         bool removed)
 {
-  tree inner = global_new_decl (loc, kind, type, name, flags, attributes, readonly, removed);
+  tree inner = global_new_decl (loc, kind, type, name, flags,
+        string_attributes, attributes, readonly, removed);
 
   vec<constructor_elt, va_gc> *constructor_elements = NULL;
 

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,
               bool removed);
 
@@ -152,6 +153,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,
                           bool removed);
@@ -363,7 +366,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,
                    bool removed);
   lvalue *

gcc/jit/jit-recording.cc

@@ -4398,6 +4398,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
@@ -5453,6 +5459,7 @@ recording::global::replay_into (replayer *r)
 				 playback_string (m_name),
 				 m_flags,
 				 m_string_attributes,
+				 m_attributes,
 				 m_readonly,
                                  m_removed)
     : r->new_global (playback_location (r, m_loc),
@@ -5461,6 +5468,7 @@ recording::global::replay_into (replayer *r)
 		     playback_string (m_name),
 		     m_flags,
 		     m_string_attributes,
+		     m_attributes,
 		     m_readonly,
                      m_removed);
 
@@ -5530,6 +5538,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 ());
@@ -5602,6 +5611,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
@@ -5638,6 +5648,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_initializer)

gcc/jit/jit-recording.h

@@ -1429,7 +1429,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 *
@@ -1451,6 +1452,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);
 
   void set_readonly ()
   {
@@ -1478,6 +1480,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;
   bool m_removed = false;
 };

gcc/jit/libgccjit.cc

@@ -4407,6 +4407,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)
 {

gcc/jit/libgccjit.h

@@ -2176,6 +2176,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,
@@ -2187,6 +2188,11 @@ gcc_jit_lvalue_add_string_attribute (gcc_jit_lvalue *variable,
 				     enum gcc_jit_variable_attribute attribute,
 				     const char* value);
 
+/* 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);
 

gcc/jit/libgccjit.map

@@ -368,3 +368,7 @@ LIBGCCJIT_ABI_41 {
     gcc_jit_lvalue_remove;
     gcc_jit_rvalue_set_type;
 } LIBGCCJIT_ABI_40;
+
+LIBGCCJIT_ABI_42 {
+    gcc_jit_lvalue_add_attribute;
+} LIBGCCJIT_ABI_41;