Convert REG_STRUCT_HAS_ADDR to multi-arch. Use REG_STRUCT_HAS_ADDR_P

in conversion.

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index 9378b887fdfc6b20fc22203ebf77db0ffe2cfb00..928bab3aa456490f0f32d92c85016f12ce2cb09b 100644 (file)
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,3 +1,18 @@
+Fri Apr 21 15:23:13 2000  Andrew Cagney  <cagney@b1.cygnus.com>
+
+       * stabsread.c (REG_STRUCT_HAS_ADDR): Delete default.
+       (define_symbol): Check REG_STRUCT_HAS_ADDR_P before using
+       REG_STRUCT_HAS_ADDR.
+       (define_symbol): Ditto.
+
+       * valops.c (hand_function_call): Replace #ifdef
+       REG_STRUCT_HAS_ADDR with if REG_STRUCT_HAS_ADDR_P.  Re-indent
+       affected code.
+
+       * gdbarch.sh (REG_STRUCT_HAS_ADDR): Add along with the predicate
+       function REG_STRUCT_HAS_ADDR_P.
+       * gdbarch.h, gdbarch.c: Re-generate.
+       
 2000-04-21  Elena Zannoni  <ezannoni@kwikemart.cygnus.com>
 
        * gdb-stabs.h (SECT_OFF_MAX): Increase to 40.

diff --git a/gdb/gdbarch.c b/gdb/gdbarch.c
index 06eccad729aeca3707c288f8c97a2214d08bec92..b14cee8c13e0441076ec1dfba65ccbd083c23cfc 100644 (file)
--- a/gdb/gdbarch.c
+++ b/gdb/gdbarch.c
@@ -214,6 +214,7 @@ struct gdbarch
   gdbarch_saved_pc_after_call_ftype *saved_pc_after_call;
   gdbarch_frame_num_args_ftype *frame_num_args;
   gdbarch_stack_align_ftype *stack_align;
+  gdbarch_reg_struct_has_addr_ftype *reg_struct_has_addr;
 };
 
 
@@ -319,6 +320,7 @@ struct gdbarch startup_gdbarch = {
   0,
   0,
   0,
+  0,
   /* startup_gdbarch() */
 };
 struct gdbarch *current_gdbarch = &startup_gdbarch;
@@ -623,6 +625,7 @@ verify_gdbarch (struct gdbarch *gdbarch)
       && (gdbarch->frame_num_args == 0))
     internal_error ("gdbarch: verify_gdbarch: frame_num_args invalid");
   /* Skip verify of stack_align, has predicate */
+  /* Skip verify of reg_struct_has_addr, has predicate */
 }
 
 
@@ -962,6 +965,10 @@ gdbarch_dump (void)
                       "gdbarch_update: STACK_ALIGN = 0x%08lx\n",
                       (long) current_gdbarch->stack_align
                       /*STACK_ALIGN ()*/);
+  fprintf_unfiltered (gdb_stdlog,
+                      "gdbarch_update: REG_STRUCT_HAS_ADDR = 0x%08lx\n",
+                      (long) current_gdbarch->reg_struct_has_addr
+                      /*REG_STRUCT_HAS_ADDR ()*/);
 }
 
 struct gdbarch_tdep *
@@ -2517,6 +2524,29 @@ set_gdbarch_stack_align (struct gdbarch *gdbarch,
   gdbarch->stack_align = stack_align;
 }
 
+int
+gdbarch_reg_struct_has_addr_p (struct gdbarch *gdbarch)
+{
+  return gdbarch->reg_struct_has_addr != 0;
+}
+
+int
+gdbarch_reg_struct_has_addr (struct gdbarch *gdbarch, int gcc_p, struct type *type)
+{
+  if (gdbarch->reg_struct_has_addr == 0)
+    internal_error ("gdbarch: gdbarch_reg_struct_has_addr invalid");
+  if (gdbarch_debug >= 2)
+    fprintf_unfiltered (gdb_stdlog, "gdbarch_reg_struct_has_addr called\n");
+  return gdbarch->reg_struct_has_addr (gcc_p, type);
+}
+
+void
+set_gdbarch_reg_struct_has_addr (struct gdbarch *gdbarch,
+                                 gdbarch_reg_struct_has_addr_ftype reg_struct_has_addr)
+{
+  gdbarch->reg_struct_has_addr = reg_struct_has_addr;
+}
+
 
 /* Keep a registrary of per-architecture data-pointers required by GDB
    modules. */

diff --git a/gdb/gdbarch.h b/gdb/gdbarch.h
index 06d74393128f3696cd02b9c927b3ccd0d1684ef2..6ed085682d3277e6ac945d276699903d0a29c28a 100644 (file)
--- a/gdb/gdbarch.h
+++ b/gdb/gdbarch.h
@@ -815,6 +815,23 @@ extern void set_gdbarch_stack_align (struct gdbarch *gdbarch, gdbarch_stack_alig
 #define STACK_ALIGN(sp) (gdbarch_stack_align (current_gdbarch, sp))
 #endif
 
+#if defined (REG_STRUCT_HAS_ADDR)
+/* Legacy for systems yet to multi-arch REG_STRUCT_HAS_ADDR */
+#define REG_STRUCT_HAS_ADDR_P() (1)
+#endif
+
+extern int gdbarch_reg_struct_has_addr_p (struct gdbarch *gdbarch);
+#if (GDB_MULTI_ARCH > 1) || !defined (REG_STRUCT_HAS_ADDR_P)
+#define REG_STRUCT_HAS_ADDR_P() (gdbarch_reg_struct_has_addr_p (current_gdbarch))
+#endif
+
+typedef int (gdbarch_reg_struct_has_addr_ftype) (int gcc_p, struct type *type);
+extern int gdbarch_reg_struct_has_addr (struct gdbarch *gdbarch, int gcc_p, struct type *type);
+extern void set_gdbarch_reg_struct_has_addr (struct gdbarch *gdbarch, gdbarch_reg_struct_has_addr_ftype *reg_struct_has_addr);
+#if (GDB_MULTI_ARCH > 1) || !defined (REG_STRUCT_HAS_ADDR)
+#define REG_STRUCT_HAS_ADDR(gcc_p, type) (gdbarch_reg_struct_has_addr (current_gdbarch, gcc_p, type))
+#endif
+
 extern struct gdbarch_tdep *gdbarch_tdep (struct gdbarch *gdbarch);
 
 

diff --git a/gdb/gdbarch.sh b/gdb/gdbarch.sh
index c2689d0f0d4195967a9cec2e801b2d198e7a8078..c743e15a39c4d959a32d6f7f15329ea21ef5a323 100755 (executable)
--- a/gdb/gdbarch.sh
+++ b/gdb/gdbarch.sh
@@ -322,6 +322,7 @@ f:2:SAVED_PC_AFTER_CALL:CORE_ADDR:saved_pc_after_call:struct frame_info *frame:f
 f:2:FRAME_NUM_ARGS:int:frame_num_args:struct frame_info *frame:frame::0:0
 #
 F:2:STACK_ALIGN:CORE_ADDR:stack_align:CORE_ADDR sp:sp::0:0
+F:2:REG_STRUCT_HAS_ADDR:int:reg_struct_has_addr:int gcc_p, struct type *type:gcc_p, type::0:0
 EOF
   grep -v '^#'
 }

diff --git a/gdb/stabsread.c b/gdb/stabsread.c
index 48eef6236c07fb52365e9a19b3ae5bd66cac8c6d..7adf078e8258da857c7901c46f6781f368273e47 100644 (file)
--- a/gdb/stabsread.c
+++ b/gdb/stabsread.c
@@ -559,10 +559,6 @@ read_type_number (pp, typenums)
 }
 \f
 
-#if !defined (REG_STRUCT_HAS_ADDR)
-#define REG_STRUCT_HAS_ADDR(gcc_p,type) 0
-#endif
-
 #define VISIBILITY_PRIVATE     '0'     /* Stabs character for private field */
 #define VISIBILITY_PROTECTED   '1'     /* Stabs character for protected fld */
 #define VISIBILITY_PUBLIC      '2'     /* Stabs character for public field */
@@ -1899,6 +1895,7 @@ define_symbol (valu, string, desc, type, objfile)
          if (local_symbols
              && local_symbols->nsyms > 0
 #ifndef USE_REGISTER_NOT_ARG
+             && REG_STRUCT_HAS_ADDR_P ()
              && REG_STRUCT_HAS_ADDR (processing_gcc_compilation,
                                      SYMBOL_TYPE (sym))
              && (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_STRUCT
@@ -2156,8 +2153,9 @@ define_symbol (valu, string, desc, type, objfile)
   /* When passing structures to a function, some systems sometimes pass
      the address in a register, not the structure itself. */
 
-  if (REG_STRUCT_HAS_ADDR (processing_gcc_compilation, SYMBOL_TYPE (sym))
-    && (SYMBOL_CLASS (sym) == LOC_REGPARM || SYMBOL_CLASS (sym) == LOC_ARG))
+  if (REG_STRUCT_HAS_ADDR_P ()
+      && REG_STRUCT_HAS_ADDR (processing_gcc_compilation, SYMBOL_TYPE (sym))
+      && (SYMBOL_CLASS (sym) == LOC_REGPARM || SYMBOL_CLASS (sym) == LOC_ARG))
     {
       struct type *symbol_type = check_typedef (SYMBOL_TYPE (sym));
 

diff --git a/gdb/valops.c b/gdb/valops.c
index 36846c7ebdbcf8a59bb443886a9749af527ed317..0632ede82087a8b9f48fde99175e0388eb1835ac 100644 (file)
--- a/gdb/valops.c
+++ b/gdb/valops.c
@@ -1510,72 +1510,72 @@ You must use a pointer to function type variable. Command ignored.", arg_name);
                  }
     }
 
-#if defined (REG_STRUCT_HAS_ADDR)
-  {
-    /* This is a machine like the sparc, where we may need to pass a pointer
-       to the structure, not the structure itself.  */
-    for (i = nargs - 1; i >= 0; i--)
-      {
-       struct type *arg_type = check_typedef (VALUE_TYPE (args[i]));
-       if ((TYPE_CODE (arg_type) == TYPE_CODE_STRUCT
-            || TYPE_CODE (arg_type) == TYPE_CODE_UNION
-            || TYPE_CODE (arg_type) == TYPE_CODE_ARRAY
-            || TYPE_CODE (arg_type) == TYPE_CODE_STRING
-            || TYPE_CODE (arg_type) == TYPE_CODE_BITSTRING
-            || TYPE_CODE (arg_type) == TYPE_CODE_SET
-            || (TYPE_CODE (arg_type) == TYPE_CODE_FLT
-                && TYPE_LENGTH (arg_type) > 8)
-           )
-           && REG_STRUCT_HAS_ADDR (using_gcc, arg_type))
-         {
-           CORE_ADDR addr;
-           int len;            /*  = TYPE_LENGTH (arg_type); */
-           int aligned_len;
-           arg_type = check_typedef (VALUE_ENCLOSING_TYPE (args[i]));
-           len = TYPE_LENGTH (arg_type);
-
-           if (STACK_ALIGN_P ())
-             /* MVS 11/22/96: I think at least some of this
-                stack_align code is really broken.  Better to let
-                PUSH_ARGUMENTS adjust the stack in a target-defined
-                manner.  */
-             aligned_len = STACK_ALIGN (len);
-           else
-             aligned_len = len;
-           if (INNER_THAN (1, 2))
-             {
-               /* stack grows downward */
-               sp -= aligned_len;
-             }
-           else
-             {
-               /* The stack grows up, so the address of the thing we push
-                  is the stack pointer before we push it.  */
-               addr = sp;
-             }
-           /* Push the structure.  */
-           write_memory (sp, VALUE_CONTENTS_ALL (args[i]), len);
-           if (INNER_THAN (1, 2))
-             {
-               /* The stack grows down, so the address of the thing we push
-                  is the stack pointer after we push it.  */
-               addr = sp;
-             }
-           else
-             {
-               /* stack grows upward */
-               sp += aligned_len;
-             }
-           /* The value we're going to pass is the address of the thing
-              we just pushed.  */
-           /*args[i] = value_from_longest (lookup_pointer_type (value_type),
-              (LONGEST) addr); */
-           args[i] = value_from_pointer (lookup_pointer_type (arg_type),
-                                         addr);
-         }
-      }
-  }
-#endif /* REG_STRUCT_HAS_ADDR.  */
+  if (REG_STRUCT_HAS_ADDR_P ())
+    {
+      /* This is a machine like the sparc, where we may need to pass a
+        pointer to the structure, not the structure itself.  */
+      for (i = nargs - 1; i >= 0; i--)
+       {
+         struct type *arg_type = check_typedef (VALUE_TYPE (args[i]));
+         if ((TYPE_CODE (arg_type) == TYPE_CODE_STRUCT
+              || TYPE_CODE (arg_type) == TYPE_CODE_UNION
+              || TYPE_CODE (arg_type) == TYPE_CODE_ARRAY
+              || TYPE_CODE (arg_type) == TYPE_CODE_STRING
+              || TYPE_CODE (arg_type) == TYPE_CODE_BITSTRING
+              || TYPE_CODE (arg_type) == TYPE_CODE_SET
+              || (TYPE_CODE (arg_type) == TYPE_CODE_FLT
+                  && TYPE_LENGTH (arg_type) > 8)
+              )
+             && REG_STRUCT_HAS_ADDR (using_gcc, arg_type))
+           {
+             CORE_ADDR addr;
+             int len;          /*  = TYPE_LENGTH (arg_type); */
+             int aligned_len;
+             arg_type = check_typedef (VALUE_ENCLOSING_TYPE (args[i]));
+             len = TYPE_LENGTH (arg_type);
+
+             if (STACK_ALIGN_P ())
+               /* MVS 11/22/96: I think at least some of this
+                  stack_align code is really broken.  Better to let
+                  PUSH_ARGUMENTS adjust the stack in a target-defined
+                  manner.  */
+               aligned_len = STACK_ALIGN (len);
+             else
+               aligned_len = len;
+             if (INNER_THAN (1, 2))
+               {
+                 /* stack grows downward */
+                 sp -= aligned_len;
+               }
+             else
+               {
+                 /* The stack grows up, so the address of the thing
+                    we push is the stack pointer before we push it.  */
+                 addr = sp;
+               }
+             /* Push the structure.  */
+             write_memory (sp, VALUE_CONTENTS_ALL (args[i]), len);
+             if (INNER_THAN (1, 2))
+               {
+                 /* The stack grows down, so the address of the thing
+                    we push is the stack pointer after we push it.  */
+                 addr = sp;
+               }
+             else
+               {
+                 /* stack grows upward */
+                 sp += aligned_len;
+               }
+             /* The value we're going to pass is the address of the
+                thing we just pushed.  */
+             /*args[i] = value_from_longest (lookup_pointer_type (value_type),
+               (LONGEST) addr); */
+             args[i] = value_from_pointer (lookup_pointer_type (arg_type),
+                                           addr);
+           }
+       }
+    }
+
 
   /* Reserve space for the return structure to be written on the
      stack, if necessary */