Revert "Add function to set the initial value of a global variable [PR96089]"

This reverts commit f2a6769.

Author: antoyo

gcc/jit/docs/topics/compatibility.rst

@@ -302,12 +302,3 @@ thread-local storage model of a variable:
 section of a variable:
 
   * :func:`gcc_jit_lvalue_set_link_section`
-
-.. _LIBGCCJIT_ABI_19:
-
-``LIBGCCJIT_ABI_19``
------------------------
-``LIBGCCJIT_ABI_19`` covers the addition of an API entrypoint to set the value
-of a global variable:
-
-  * :func:`gcc_jit_global_set_initializer_value`

gcc/jit/docs/topics/expressions.rst

@@ -643,20 +643,6 @@ Global variables
 
       #ifdef LIBGCCJIT_HAVE_gcc_jit_global_set_initializer
 
-.. function:: void
-              gcc_jit_global_set_initializer_value (gcc_jit_lvalue *global,\
-                                                    gcc_jit_rvalue *value)
-
-   Set an initializer for ``global`` using the specified value.
-   ``global`` must be the same type as ``value``.
-
-   This entrypoint was added in :ref:`LIBGCCJIT_ABI_19`; you can test for
-   its presence using
-
-   .. code-block:: c
-
-      #ifdef LIBGCCJIT_HAVE_gcc_jit_global_set_initializer_value
-
 Working with pointers, structs and unions
 -----------------------------------------
 

gcc/jit/jit-playback.c

@@ -702,24 +702,6 @@ new_global_initialized (location *loc,
   return global_finalize_lvalue (inner);
 }
 
-playback::lvalue *
-playback::context::
-new_global_with_value (location *loc,
-		       enum gcc_jit_global_kind kind,
-		       type *type,
-		       playback::rvalue *value,
-		       const char *name)
-{
-  tree inner = global_new_decl (loc, kind, type, name);
-
-  tree inner_type = type->as_tree ();
-  tree initial = value->as_tree ();
-  gcc_assert (TREE_CONSTANT (initial));
-  DECL_INITIAL (inner) = initial;
-
-  return global_finalize_lvalue (inner);
-}
-
 /* Implementation of the various
       gcc::jit::playback::context::new_rvalue_from_const <HOST_TYPE>
    methods.

gcc/jit/jit-playback.h

@@ -121,13 +121,6 @@ class context : public log_user
                           const void *initializer,
                           const char *name);
 
-  lvalue*
-  new_global_with_value (location *loc,
-			 enum gcc_jit_global_kind kind,
-			 type *type,
-			 rvalue *value,
-			 const char *name);
-
   template <typename HOST_TYPE>
   rvalue *
   new_rvalue_from_const (type *type,

gcc/jit/jit-recording.c

@@ -4687,14 +4687,6 @@ recording::global::replay_into (replayer *r)
 				 m_initializer,
 				 playback_string (m_name));
   }
-  else if (m_initializer_value)
-  {
-      global = r->new_global_with_value (playback_location (r, m_loc),
-				 m_kind,
-				 m_type->playback_type (),
-				 m_initializer_value->playback_rvalue (),
-				 playback_string (m_name));
-  }
   else
   {
       global = r->new_global (playback_location (r, m_loc),
@@ -4834,14 +4826,6 @@ recording::global::write_reproducer (reproducer &r)
     r.get_identifier_as_type (get_type ()),
     m_name->get_debug_string ());
 
-  if (m_initializer_value)
-  {
-    r.write ("  gcc_jit_global_set_initializer_value (%s, /* gcc_jit_lvalue *global */\n"
-      "    %s/* gcc_jit_rvalue *value */);\n",
-    id,
-    r.get_identifier_as_rvalue (m_initializer_value));
-  }
-
   if (m_link_section != NULL)
   {
     r.write ("  gcc_jit_lvalue_set_link_section (%s, /* gcc_jit_lvalue *lvalue */\n"

gcc/jit/jit-recording.h

@@ -1383,7 +1383,6 @@ class global : public lvalue
     m_name (name)
   {
     m_initializer = NULL;
-    m_initializer_value = NULL;
     m_initializer_num_bytes = 0;
   }
   ~global ()
@@ -1410,12 +1409,6 @@ class global : public lvalue
     m_initializer_num_bytes = num_bytes;
   }
 
-  void
-  set_initializer_value (rvalue* value)
-  {
-    m_initializer_value = value;
-  }
-
 private:
   string * make_debug_string () FINAL OVERRIDE { return m_name; }
   template <typename T>
@@ -1430,7 +1423,6 @@ class global : public lvalue
   enum gcc_jit_global_kind m_kind;
   string *m_name;
   void *m_initializer;
-  rvalue *m_initializer_value;
   size_t m_initializer_num_bytes;
 };
 

gcc/jit/libgccjit.c

@@ -277,17 +277,6 @@ struct gcc_jit_extended_asm : public gcc::jit::recording::extended_asm
       }								\
   JIT_END_STMT
 
-#define RETURN_IF_FAIL_PRINTF5(TEST_EXPR, CTXT, LOC, ERR_FMT, A0, A1, A2, A3, \
-			       A4) \
-  JIT_BEGIN_STMT							\
-    if (!(TEST_EXPR))							\
-      {								\
-	jit_error ((CTXT), (LOC), "%s: " ERR_FMT,			\
-		   __func__, (A0), (A1), (A2), (A3), (A4));		\
-	return;							\
-      }								\
-  JIT_END_STMT
-
 /* Check that BLOCK is non-NULL, and that it's OK to add statements to
    it.  This will fail if BLOCK has already been terminated by some
    kind of jump or a return.  */
@@ -1428,38 +1417,6 @@ gcc_jit_global_set_initializer (gcc_jit_lvalue *global,
   return global;
 }
 
-/* Public entrypoint.  See description in libgccjit.h.
-
-   After error-checking, the real work is done by the
-   gcc::jit::recording::global::set_initializer_value method, in
-   jit-recording.c.  */
-
-void
-gcc_jit_global_set_initializer_value (gcc_jit_lvalue *global,
-				gcc_jit_rvalue *value)
-{
-  RETURN_IF_FAIL (global, NULL, NULL, "NULL global");
-  RETURN_IF_FAIL (value, NULL, NULL, "NULL value");
-  RETURN_IF_FAIL_PRINTF1 (global->is_global (), NULL, NULL,
-			       "lvalue \"%s\" not a global",
-			       global->get_debug_string ());
-
-      RETURN_IF_FAIL_PRINTF5 (
-	compatible_types (global->get_type (),
-			  value->get_type ()),
-	NULL, NULL,
-	"mismatching types for global \"%s\":"
-	" assignment to global %s (type: %s) from %s (type: %s)",
-	global->get_debug_string (),
-	global->get_debug_string (),
-	global->get_type ()->get_debug_string (),
-	value->get_debug_string (),
-	value->get_type ()->get_debug_string ());
-
-  reinterpret_cast <gcc::jit::recording::global *> (global)
-    ->set_initializer_value (value);
-}
-
 /* Public entrypoint.  See description in libgccjit.h.
 
    After error-checking, this calls the trivial

gcc/jit/libgccjit.h

@@ -848,19 +848,6 @@ gcc_jit_global_set_initializer (gcc_jit_lvalue *global,
 				const void *blob,
 				size_t num_bytes);
 
-#define LIBGCCJIT_HAVE_gcc_jit_global_set_initializer_value
-
-/* Set an initial value for a global, which must be a constant.
-
-   This API entrypoint was added in LIBGCCJIT_ABI_19; you can test for its
-   presence using
-     #ifdef LIBGCCJIT_HAVE_gcc_jit_global_set_initializer_value
-*/
-
-extern void
-gcc_jit_global_set_initializer_value (gcc_jit_lvalue *global,
-				gcc_jit_rvalue *value);
-
 /* Upcasting.  */
 extern gcc_jit_object *
 gcc_jit_lvalue_as_object (gcc_jit_lvalue *lvalue);

gcc/jit/libgccjit.map

@@ -238,15 +238,10 @@ LIBGCCJIT_ABI_18 {
 } LIBGCCJIT_ABI_17;
 
 LIBGCCJIT_ABI_19 {
-  global:
-    gcc_jit_global_set_initializer_value;
+    gcc_jit_context_new_bitcast;
 } LIBGCCJIT_ABI_18;
 
 LIBGCCJIT_ABI_20 {
-    gcc_jit_context_new_bitcast;
-} LIBGCCJIT_ABI_19;
-
-LIBGCCJIT_ABI_21 {
   global:
     gcc_jit_lvalue_set_register_name;
-} LIBGCCJIT_ABI_20;
+} LIBGCCJIT_ABI_19;

gcc/testsuite/jit.dg/test-global-set-initializer.c

@@ -21,7 +21,6 @@ create_code (gcc_jit_context *ctxt, void *user_data)
      signed char bin_blob1[] = { 0xc, 0xa, 0xf, 0xf, 0xe };
      unsigned bin_blob2[] = { 0x3, 0x2, 0x1, 0x0, 0x1, 0x2, 0x3 };
      unsigned char bin_blob3[4096]...
-     unsigned int integer = 42;
   */
   gcc_jit_type *unsigned_char_type =
     gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_UNSIGNED_CHAR);
@@ -57,16 +56,6 @@ create_code (gcc_jit_context *ctxt, void *user_data)
 				      sizeof (test_blob3)),
       "bin_blob3");
   gcc_jit_global_set_initializer (glob, test_blob3, sizeof (test_blob3));
-
-  gcc_jit_rvalue *forty_two = gcc_jit_context_new_rvalue_from_int (
-      ctxt, unsigned_type, 42);
-
-  glob =
-    gcc_jit_context_new_global (
-      ctxt, NULL, GCC_JIT_GLOBAL_EXPORTED,
-      unsigned_type,
-      "integer");
-  gcc_jit_global_set_initializer_value (glob, forty_two);
 }
 
 void
@@ -86,8 +75,4 @@ verify_code (gcc_jit_context *ctxt, gcc_jit_result *result)
   CHECK_NON_NULL (glob);
   CHECK_VALUE (memcmp (test_blob3, glob, sizeof (test_blob3)), 0);
 
-  glob = gcc_jit_result_get_global (result, "integer");
-  CHECK_NON_NULL (glob);
-  int *value = glob;
-  CHECK_VALUE (*value, 42);
 }