Test with indirect returns

Author: antoyo

gcc/calls.cc

@@ -61,6 +61,7 @@ along with GCC; see the file COPYING3.  If not see
 #include "value-query.h"
 #include "tree-pretty-print.h"
 #include "tree-eh.h"
+#include "print-tree.h"
 
 /* Like PREFERRED_STACK_BOUNDARY but in units of bytes, not bits.  */
 #define STACK_BYTES (PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT)
@@ -1338,6 +1339,8 @@ initialize_argument_information (int num_actuals ATTRIBUTE_UNUSED,
   CUMULATIVE_ARGS *args_so_far_pnt = get_cumulative_args (args_so_far);
   location_t loc = EXPR_LOCATION (exp);
 
+  //debug_tree (exp);
+
   /* Count arg position in order args appear.  */
   int argpos;
 
@@ -2897,6 +2900,13 @@ expand_call (tree exp, rtx target, int ignore)
 	  structure_value_addr = XEXP (target, 0);
 	else
 	  {
+	    fprintf (stderr, "HERE: %d %p, %d, %d\n", CALL_EXPR_RETURN_SLOT_OPT (exp),
+                    target, MEM_P (target),
+	       (TREE_ADDRESSABLE (rettype)
+		|| !(MEM_ALIGN (target) < TYPE_ALIGN (rettype)
+		     && targetm.slow_unaligned_access (TYPE_MODE (rettype),
+						       MEM_ALIGN (target)))));
+            debug_rtx (target);
 	    /* For variable-sized objects, we must be called with a target
 	       specified.  If we were to allocate space on the stack here,
 	       we would have no way of knowing when to free it.  */

gcc/function.cc

@@ -85,6 +85,7 @@ along with GCC; see the file COPYING3.  If not see
 #include "value-range.h"
 #include "gimple-range.h"
 #include "insn-attr.h"
+#include "print-tree.h"
 
 /* So we can assign to cfun in this file.  */
 #undef cfun
@@ -987,6 +988,9 @@ assign_temp (tree type_or_decl, int memory_required,
 
   /* Allocating temporaries of TREE_ADDRESSABLE type must be done in the front
      end.  See also create_tmp_var for the gimplification-time check.  */
+  //fprintf (stderr, "1\n");
+  /*debug_tree (type_or_decl);
+  debug_tree (type);*/
   gcc_assert (!TREE_ADDRESSABLE (type) && COMPLETE_TYPE_P (type));
 
   if (mode == BLKmode || memory_required)

gcc/jit/jit-playback.cc

@@ -467,7 +467,19 @@ new_compound_type (location *loc,
 
   if (is_packed)
     TYPE_PACKED (t) = 1;
-  if (is_addressable) TREE_ADDRESSABLE(t) = 1;
+
+  //gcc_assert (!is_addressable);
+  if (is_addressable)
+  {
+      TREE_ADDRESSABLE(t) = 1;
+      /*if (TREE_CODE (t) == COMPOUND_LITERAL_EXPR)
+      {
+        fprintf (stderr, "Is compound literal\n");
+        TREE_ADDRESSABLE (COMPOUND_LITERAL_EXPR_DECL (t)) = 1;
+      }
+      else
+          fprintf (stderr, "Is NOT compound literal\n");*/
+  }
   if (loc)
     set_tree_location (t, loc);
 
@@ -653,24 +665,32 @@ new_function (location *loc,
 	      const std::vector<std::pair<gcc_jit_fn_attribute,
 					  std::vector<int>>>
 					  &int_array_attributes,
-	      bool is_target_builtin)
+	      bool is_target_builtin,
+	      bool is_indirect_return)
 {
   int i;
   param *param;
 
   //can return_type be NULL?
   gcc_assert (name);
 
+  tree func_return_type = return_type->as_tree ();
+  if (is_indirect_return)
+  {
+    func_return_type = build_variant_type_copy (func_return_type);
+    TREE_ADDRESSABLE (func_return_type) = 1;
+  }
+
   tree *arg_types = (tree *)xcalloc(params->length (), sizeof(tree*));
   FOR_EACH_VEC_ELT (*params, i, param)
     arg_types[i] = TREE_TYPE (param->as_tree ());
 
   tree fn_type;
   if (is_variadic)
-    fn_type = build_varargs_function_type_array (return_type->as_tree (),
+    fn_type = build_varargs_function_type_array (func_return_type,
 						 params->length (), arg_types);
   else
-    fn_type = build_function_type_array (return_type->as_tree (),
+    fn_type = build_function_type_array (func_return_type,
 					 params->length (), arg_types);
   free (arg_types);
 
@@ -682,7 +702,7 @@ new_function (location *loc,
     set_tree_location (fndecl, loc);
 
   tree resdecl = build_decl (UNKNOWN_LOCATION, RESULT_DECL,
-			     NULL_TREE, return_type->as_tree ());
+			     NULL_TREE, func_return_type);
   DECL_ARTIFICIAL (resdecl) = 1;
   DECL_IGNORED_P (resdecl) = 1;
   DECL_RESULT (fndecl) = resdecl;
@@ -1593,7 +1613,17 @@ build_call (location *loc,
   vec<tree, va_gc> *tree_args;
   vec_alloc (tree_args, args->length ());
   for (unsigned i = 0; i < args->length (); i++)
+  {
+    if (TREE_ADDRESSABLE (TREE_TYPE ((*args)[i]->as_tree ())))
+    {
+      fprintf (stderr, "Function:\n");
+      debug_tree (fn_ptr);
+      fprintf (stderr, "Argument:\n");
+      debug_tree ((*args)[i]->as_tree ());
+      abort ();
+    }
     tree_args->quick_push ((*args)[i]->as_tree ());
+  }
 
   if (loc)
     set_tree_location (fn_ptr, loc);
@@ -1604,6 +1634,11 @@ build_call (location *loc,
 
   tree call = build_call_vec (return_type,
 			      fn_ptr, tree_args);
+  if (TREE_ADDRESSABLE (return_type))
+  {
+    CALL_EXPR_RETURN_SLOT_OPT (call) = true;
+    //fprintf (stderr, "Setting return slot opt\n");
+  }
 
   if (require_tail_call)
     CALL_EXPR_MUST_TAIL_CALL (call) = 1;
@@ -2052,6 +2087,18 @@ get_aligned (size_t alignment_in_bytes) const
   return new type (t_new_type);
 }
 
+/* Construct a playback::type instance (wrapping a tree)
+   with TREE_ADDRESSABLE set.  */
+
+playback::type *
+playback::type::
+get_addressable () const
+{
+  tree t_new_type = build_variant_type_copy (m_inner);
+  TREE_ADDRESSABLE (t_new_type) = 1;
+  return new type (t_new_type);
+}
+
 /* Construct a playback::type instance (wrapping a tree)
    for the given vector type.  */
 
@@ -2120,6 +2167,8 @@ dereference (location *loc)
 {
   tree ptr = as_tree ();
   tree datum = get_context ()->new_dereference (ptr, loc);
+  /*fprintf (stderr, "ptr: %p\n", ptr);
+  fprintf (stderr, "deref: %p\n", datum);*/
   return new lvalue (get_context (), datum);
 }
 
@@ -2294,12 +2343,13 @@ new_local (location *loc,
 			   type->as_tree ());
   else
   {
-    inner = build_decl (UNKNOWN_LOCATION, VAR_DECL,
+    inner = create_tmp_var (type->as_tree (), "JITTMP");
+    /*inner = build_decl (UNKNOWN_LOCATION, VAR_DECL,
 			create_tmp_var_name ("JITTMP"),
 			type->as_tree ());
     DECL_ARTIFICIAL (inner) = 1;
     DECL_IGNORED_P (inner) = 1;
-    DECL_NAMELESS (inner) = 1;
+    DECL_NAMELESS (inner) = 1;*/
   }
   DECL_CONTEXT (inner) = this->m_inner_fndecl;
 

gcc/jit/jit-playback.h

@@ -27,6 +27,7 @@ along with GCC; see the file COPYING3.  If not see
 
 #include "timevar.h"
 #include "varasm.h"
+#include "print-tree.h"
 
 #include "jit-recording.h"
 #include "jit-target.h"
@@ -132,7 +133,8 @@ class context : public log_user
 		const std::vector<std::pair<gcc_jit_fn_attribute,
 					    std::vector<int>>>
 					    &int_array_attributes,
-		bool is_target_builtin);
+		bool is_target_builtin,
+		bool is_indirect_return);
 
   lvalue *
   new_global (location *loc,
@@ -542,6 +544,7 @@ class type : public wrapper
   }
 
   type *get_aligned (size_t alignment_in_bytes) const;
+  type *get_addressable () const;
   type *get_vector (size_t num_units) const;
 
 private:

gcc/jit/jit-recording.cc

@@ -1409,6 +1409,16 @@ recording::context::new_call (recording::location *loc,
 			      int numargs , recording::rvalue **args)
 {
   recording::rvalue *result = new call (this, loc, func, numargs, args);
+  /*for (int i = 0 ; i < numargs ; i++)
+  {
+    type* type = args[i]->get_type ();
+    if (args[i]->is_addressable () || type->is_addressable ())
+    {
+      fprintf (stderr, "Function: %s\n", func->get_name ()->c_str ());
+      fprintf (stderr, "Argument: %s\n", args[i]->get_debug_string ());
+      abort ();
+    }
+  }*/
   record (result);
   return result;
 }
@@ -2596,6 +2606,15 @@ recording::type::get_aligned (size_t alignment_in_bytes)
   return result;
 }
 
+recording::type *
+recording::type::get_addressable ()
+{
+  recording::type *result
+    = new memento_of_get_addressable (this);
+  m_ctxt->record_type (result);
+  return result;
+}
+
 void
 recording::type::set_packed ()
 {
@@ -3427,6 +3446,43 @@ recording::memento_of_get_aligned::write_reproducer (reproducer &r)
 	   m_alignment_in_bytes);
 }
 
+/* The implementation of class gcc::jit::recording::memento_of_get_addressable.  */
+
+/* Implementation of pure virtual hook recording::memento::replay_into
+   for recording::memento_of_get_addressable.  */
+
+void
+recording::memento_of_get_addressable::replay_into (replayer *)
+{
+  set_playback_obj
+    (m_other_type->playback_type ()->get_addressable ());
+}
+
+/* Implementation of recording::memento::make_debug_string for
+   results of get_addressable.  */
+
+recording::string *
+recording::memento_of_get_addressable::make_debug_string ()
+{
+  return string::from_printf (m_ctxt,
+			      "%s adressable",
+			      m_other_type->get_debug_string ());
+}
+
+/* Implementation of recording::memento::write_reproducer for addressable
+   types. */
+
+void
+recording::memento_of_get_addressable::write_reproducer (reproducer &r)
+{
+  const char *id = r.make_identifier (this, "type");
+  r.write ("  gcc_jit_type *%s =\n"
+	   "    gcc_jit_type_get_addressable (%s);\n",
+	   id,
+	   r.get_identifier_as_type (m_other_type));
+}
+
+
 /* The implementation of class gcc::jit::recording::vector_type.  */
 
 /* Implementation of pure virtual hook recording::memento::replay_into
@@ -4164,6 +4220,10 @@ recording::rvalue::dereference_field (recording::location *loc,
 recording::lvalue *
 recording::rvalue::dereference (recording::location *loc)
 {
+  if (this->get_type ()->dereference ()->is_addressable ())
+  {
+    abort();
+  }
   recording::lvalue *result =
     new dereference_rvalue (m_ctxt, loc, this);
   m_ctxt->record (result);
@@ -4515,7 +4575,8 @@ recording::function::function (context *ctxt,
   m_attributes (),
   m_string_attributes (),
   m_int_array_attributes (),
-  m_is_target_builtin (is_target_builtin)
+  m_is_target_builtin (is_target_builtin),
+  m_indirect_return (false)
 {
   for (int i = 0; i< num_params; i++)
     {
@@ -4578,7 +4639,8 @@ recording::function::replay_into (replayer *r)
 				     m_attributes,
 				     m_string_attributes,
 				     m_int_array_attributes,
-				     m_is_target_builtin));
+				     m_is_target_builtin,
+				     m_indirect_return));
 }
 
 /* Implementation of recording::memento::make_debug_string for
@@ -7628,7 +7690,7 @@ recording::statement::write_to_dump (dump &d)
    for recording::memento_of_set_personality_function.  */
 
 void
-recording::memento_of_set_personality_function::replay_into (replayer *r)
+recording::memento_of_set_personality_function::replay_into (replayer * ARG_UNUSED (r))
 {
   m_function->playback_function ()->set_personality_function (m_personality_function->playback_function ());
 }