Add some more casts (1/2)

[thirdparty/binutils-gdb.git] / gdb / compile / compile-object-run.c

diff --git a/gdb/compile/compile-object-run.c b/gdb/compile/compile-object-run.c
index 422693b6167dfd59be973cb059021f0f636ebf4d..e5d2b64322f2c97fa7021a242729930a8207242a 100644 (file)
--- a/gdb/compile/compile-object-run.c
+++ b/gdb/compile/compile-object-run.c
@@ -24,6 +24,9 @@
 #include "objfiles.h"
 #include "compile-internal.h"
 #include "dummy-frame.h"
+#include "block.h"
+#include "valprint.h"
+#include "compile.h"
 
 /* Helper for do_module_cleanup.  */
 
@@ -36,6 +39,17 @@ struct do_module_cleanup
   /* .c file OBJFILE was built from.  It needs to be xfree-d.  */
   char *source_file;
 
+  /* Copy from struct compile_module.  */
+  enum compile_i_scope_types scope;
+  void *scope_data;
+
+  /* Copy from struct compile_module.  */
+  struct type *out_value_type;
+  CORE_ADDR out_value_addr;
+
+  /* Copy from struct compile_module.  */
+  struct munmap_list *munmap_list_head;
+
   /* objfile_name of our objfile.  */
   char objfile_name_string[1];
 };
@@ -47,11 +61,27 @@ static dummy_frame_dtor_ftype do_module_cleanup;
 static void
 do_module_cleanup (void *arg, int registers_valid)
 {
-  struct do_module_cleanup *data = arg;
+  struct do_module_cleanup *data = (struct do_module_cleanup *) arg;
   struct objfile *objfile;
 
   if (data->executedp != NULL)
-    *data->executedp = 1;
+    {
+      *data->executedp = 1;
+
+      /* This code cannot be in compile_object_run as OUT_VALUE_TYPE
+        no longer exists there.  */
+      if (data->scope == COMPILE_I_PRINT_ADDRESS_SCOPE
+         || data->scope == COMPILE_I_PRINT_VALUE_SCOPE)
+       {
+         struct value *addr_value;
+         struct type *ptr_type = lookup_pointer_type (data->out_value_type);
+
+         addr_value = value_from_pointer (ptr_type, data->out_value_addr);
+
+         /* SCOPE_DATA would be stale unlesse EXECUTEDP != NULL.  */
+         compile_print_value (value_ind (addr_value), data->scope_data);
+       }
+    }
 
   ALL_OBJFILES (objfile)
     if ((objfile->flags & OBJF_USERLOADED) == 0
@@ -69,6 +99,8 @@ do_module_cleanup (void *arg, int registers_valid)
   unlink (data->source_file);
   xfree (data->source_file);
 
+  munmap_list_free (data->munmap_list_head);
+
   /* Delete the .o file.  */
   unlink (data->objfile_name_string);
   xfree (data);
@@ -89,36 +121,59 @@ compile_object_run (struct compile_module *module)
   struct do_module_cleanup *data;
   const char *objfile_name_s = objfile_name (module->objfile);
   int dtor_found, executed = 0;
-  CORE_ADDR func_addr = module->func_addr;
+  struct symbol *func_sym = module->func_sym;
   CORE_ADDR regs_addr = module->regs_addr;
+  struct objfile *objfile = module->objfile;
 
-  data = xmalloc (sizeof (*data) + strlen (objfile_name_s));
+  data = (struct do_module_cleanup *) xmalloc (sizeof (*data)
+                                              + strlen (objfile_name_s));
   data->executedp = &executed;
   data->source_file = xstrdup (module->source_file);
   strcpy (data->objfile_name_string, objfile_name_s);
+  data->scope = module->scope;
+  data->scope_data = module->scope_data;
+  data->out_value_type = module->out_value_type;
+  data->out_value_addr = module->out_value_addr;
+  data->munmap_list_head = module->munmap_list_head;
 
   xfree (module->source_file);
   xfree (module);
+  module = NULL;
 
   TRY
     {
-      func_val = value_from_pointer
-                (builtin_type (target_gdbarch ())->builtin_func_ptr,
-                 func_addr);
-
-      if (regs_addr == 0)
-       call_function_by_hand_dummy (func_val, 0, NULL,
-                                    do_module_cleanup, data);
-      else
+      struct type *func_type = SYMBOL_TYPE (func_sym);
+      htab_t copied_types;
+      int current_arg = 0;
+      struct value **vargs;
+
+      /* OBJFILE may disappear while FUNC_TYPE still will be in use.  */
+      copied_types = create_copied_types_hash (objfile);
+      func_type = copy_type_recursive (objfile, func_type, copied_types);
+      htab_delete (copied_types);
+
+      gdb_assert (TYPE_CODE (func_type) == TYPE_CODE_FUNC);
+      func_val = value_from_pointer (lookup_pointer_type (func_type),
+                                  BLOCK_START (SYMBOL_BLOCK_VALUE (func_sym)));
+
+      vargs = XALLOCAVEC (struct value *, TYPE_NFIELDS (func_type));
+      if (TYPE_NFIELDS (func_type) >= 1)
        {
-         struct value *arg_val;
-
-         arg_val = value_from_pointer
-                   (builtin_type (target_gdbarch ())->builtin_func_ptr,
-                    regs_addr);
-         call_function_by_hand_dummy (func_val, 1, &arg_val,
-                                      do_module_cleanup, data);
+         gdb_assert (regs_addr != 0);
+         vargs[current_arg] = value_from_pointer
+                         (TYPE_FIELD_TYPE (func_type, current_arg), regs_addr);
+         ++current_arg;
+       }
+      if (TYPE_NFIELDS (func_type) >= 2)
+       {
+         gdb_assert (data->out_value_addr != 0);
+         vargs[current_arg] = value_from_pointer
+              (TYPE_FIELD_TYPE (func_type, current_arg), data->out_value_addr);
+         ++current_arg;
        }
+      gdb_assert (current_arg == TYPE_NFIELDS (func_type));
+      call_function_by_hand_dummy (func_val, TYPE_NFIELDS (func_type), vargs,
+                                  do_module_cleanup, data);
     }
   CATCH (ex, RETURN_MASK_ERROR)
     {