* inftarg.c (child_thread_alive): New function to see if a

[deliverable/binutils-gdb.git] / gdb / gdbtypes.c

diff --git a/gdb/gdbtypes.c b/gdb/gdbtypes.c
index 12caa7a124c6a211414724de48d8e1c58384f852..f5a8c3fb74f383df2da2d4ef3ab38bb208d90435 100644 (file)
--- a/gdb/gdbtypes.c
+++ b/gdb/gdbtypes.c
@@ -226,17 +226,6 @@ make_function_type (type, typeptr)
   register struct type *ntype;         /* New type */
   struct objfile *objfile;
 
-  ntype = TYPE_FUNCTION_TYPE (type);
-
-  if (ntype) 
-    if (typeptr == 0)          
-      return ntype;    /* Don't care about alloc, and have new type.  */
-    else if (*typeptr == 0)
-      {
-       *typeptr = ntype;       /* Tracking alloc, and we have new type.  */
-       return ntype;
-      }
-
   if (typeptr == 0 || *typeptr == 0)   /* We'll need to allocate one.  */
     {
       ntype = alloc_type (TYPE_OBJFILE (type));
@@ -252,14 +241,10 @@ make_function_type (type, typeptr)
     }
 
   TYPE_TARGET_TYPE (ntype) = type;
-  TYPE_FUNCTION_TYPE (type) = ntype;
 
   TYPE_LENGTH (ntype) = 1;
   TYPE_CODE (ntype) = TYPE_CODE_FUNC;
   
-  if (!TYPE_FUNCTION_TYPE (type))      /* Remember it, if don't have one.  */
-    TYPE_FUNCTION_TYPE (type) = ntype;
-
   return ntype;
 }
 
@@ -335,7 +320,10 @@ create_range_type (result_type, index_type, low_bound, high_bound)
     }
   TYPE_CODE (result_type) = TYPE_CODE_RANGE;
   TYPE_TARGET_TYPE (result_type) = index_type;
-  TYPE_LENGTH (result_type) = TYPE_LENGTH (index_type);
+  if (TYPE_FLAGS (index_type) & TYPE_FLAG_STUB)
+    TYPE_FLAGS (result_type) |= TYPE_FLAG_TARGET_STUB;
+  else
+    TYPE_LENGTH (result_type) = TYPE_LENGTH (index_type);
   TYPE_NFIELDS (result_type) = 2;
   TYPE_FIELDS (result_type) = (struct field *)
     TYPE_ALLOC (result_type, 2 * sizeof (struct field));
@@ -451,7 +439,9 @@ create_string_type (result_type, range_type)
      struct type *result_type;
      struct type *range_type;
 {
-  result_type = create_array_type (result_type, builtin_type_char, range_type);
+  result_type = create_array_type (result_type,
+                                  *current_language->string_char_type,
+                                  range_type);
   TYPE_CODE (result_type) = TYPE_CODE_STRING;
   return (result_type);
 }
@@ -466,24 +456,23 @@ create_set_type (result_type, domain_type)
     {
       result_type = alloc_type (TYPE_OBJFILE (domain_type));
     }
-  domain_type = force_to_range_type (domain_type);
   TYPE_CODE (result_type) = TYPE_CODE_SET;
   TYPE_NFIELDS (result_type) = 1;
   TYPE_FIELDS (result_type) = (struct field *)
     TYPE_ALLOC (result_type, 1 * sizeof (struct field));
   memset (TYPE_FIELDS (result_type), 0, sizeof (struct field));
+
+  if (! (TYPE_FLAGS (domain_type) & TYPE_FLAG_STUB))
+    {
+      domain_type = force_to_range_type (domain_type);
+      low_bound = TYPE_LOW_BOUND (domain_type);
+      high_bound = TYPE_HIGH_BOUND (domain_type);
+      bit_length = high_bound - low_bound + 1;
+      TYPE_LENGTH (result_type)
+       = ((bit_length + TARGET_CHAR_BIT - 1) / TARGET_CHAR_BIT)
+         * TARGET_CHAR_BIT;
+    }
   TYPE_FIELD_TYPE (result_type, 0) = domain_type;
-  low_bound = TYPE_LOW_BOUND (domain_type);
-  high_bound = TYPE_HIGH_BOUND (domain_type);
-  bit_length = high_bound - low_bound + 1;
-  if (bit_length <= TARGET_CHAR_BIT)
-    TYPE_LENGTH (result_type) = 1;
-  else if (bit_length <= TARGET_SHORT_BIT)
-    TYPE_LENGTH (result_type) = TARGET_SHORT_BIT / TARGET_CHAR_BIT;
-  else
-    TYPE_LENGTH (result_type)
-      = ((bit_length + TARGET_INT_BIT - 1) / TARGET_INT_BIT)
-       * TARGET_CHAR_BIT;
   return (result_type);
 }
 
@@ -904,11 +893,12 @@ check_stub_type (type)
       struct type *range_type;
 
       check_stub_type (TYPE_TARGET_TYPE (type));
-      if (!(TYPE_FLAGS (TYPE_TARGET_TYPE (type)) & TYPE_FLAG_STUB)
-         && TYPE_CODE (type) == TYPE_CODE_ARRAY
-         && TYPE_NFIELDS (type) == 1
-         && (TYPE_CODE (range_type = TYPE_FIELD_TYPE (type, 0))
-             == TYPE_CODE_RANGE))
+      if (TYPE_FLAGS (TYPE_TARGET_TYPE (type)) & TYPE_FLAG_STUB)
+       { }
+      else if (TYPE_CODE (type) == TYPE_CODE_ARRAY
+              && TYPE_NFIELDS (type) == 1
+              && (TYPE_CODE (range_type = TYPE_FIELD_TYPE (type, 0))
+                  == TYPE_CODE_RANGE))
        {
          /* Now recompute the length of the array type, based on its
             number of elements and the target type's length.  */
@@ -919,6 +909,11 @@ check_stub_type (type)
             * TYPE_LENGTH (TYPE_TARGET_TYPE (type)));
          TYPE_FLAGS (type) &= ~TYPE_FLAG_TARGET_STUB;
        }
+      else if (TYPE_CODE (type) == TYPE_CODE_RANGE)
+       {
+         TYPE_LENGTH (type) = TYPE_LENGTH (TYPE_TARGET_TYPE (type));
+         TYPE_FLAGS (type) &= ~TYPE_FLAG_TARGET_STUB;
+       }
     }
 }
 
@@ -979,6 +974,7 @@ check_stub_method (type, i, j)
   argtypes = (struct type **)
     TYPE_ALLOC (type, (argcount + 2) * sizeof (struct type *));
   p = argtypetext;
+  /* FIXME: This is wrong for static member functions.  */
   argtypes[0] = lookup_pointer_type (type);
   argcount = 1;
 
@@ -1145,6 +1141,34 @@ lookup_fundamental_type (objfile, typeid)
   return (*typep);
 }
 
+int
+can_dereference (t)
+     struct type *t;
+{
+  /* FIXME: Should we return true for references as well as pointers?  */
+  return
+    (t != NULL
+     && TYPE_CODE (t) == TYPE_CODE_PTR
+     && TYPE_CODE (TYPE_TARGET_TYPE (t)) != TYPE_CODE_VOID);
+}
+
+/* Chill varying string and arrays are represented as follows:
+
+   struct { int __var_length; ELEMENT_TYPE[MAX_SIZE] __var_data};
+
+   Return true if TYPE is such a Chill varying type. */
+
+int
+chill_varying_type (type)
+     struct type *type;
+{
+  if (TYPE_CODE (type) != TYPE_CODE_STRUCT
+      || TYPE_NFIELDS (type) != 2
+      || strcmp (TYPE_FIELD_NAME (type, 0), "__var_length") != 0)
+    return 0;
+  return 1;
+}
+
 #if MAINTENANCE_CMDS
 
 static void
@@ -1414,9 +1438,6 @@ recursive_dump_type (type, spaces)
   printfi_filtered (spaces, "reference_type ");
   gdb_print_address (TYPE_REFERENCE_TYPE (type), gdb_stdout);
   printf_filtered ("\n");
-  printfi_filtered (spaces, "function_type ");
-  gdb_print_address (TYPE_FUNCTION_TYPE (type), gdb_stdout);
-  printf_filtered ("\n");
   printfi_filtered (spaces, "flags 0x%x", TYPE_FLAGS (type));
   if (TYPE_FLAGS (type) & TYPE_FLAG_UNSIGNED)
     {
@@ -1555,13 +1576,15 @@ _initialize_gdbtypes ()
               0,
               "long double", (struct objfile *) NULL);
   builtin_type_complex =
-    init_type (TYPE_CODE_FLT, TARGET_COMPLEX_BIT / TARGET_CHAR_BIT,
+    init_type (TYPE_CODE_COMPLEX, 2 * TARGET_FLOAT_BIT / TARGET_CHAR_BIT,
               0,
               "complex", (struct objfile *) NULL);
+  TYPE_TARGET_TYPE (builtin_type_complex) = builtin_type_float;
   builtin_type_double_complex =
-    init_type (TYPE_CODE_FLT, TARGET_DOUBLE_COMPLEX_BIT / TARGET_CHAR_BIT,
+    init_type (TYPE_CODE_COMPLEX, 2 * TARGET_DOUBLE_BIT / TARGET_CHAR_BIT,
               0,
               "double complex", (struct objfile *) NULL);
+  TYPE_TARGET_TYPE (builtin_type_double_complex) = builtin_type_double;
   builtin_type_string =
     init_type (TYPE_CODE_STRING, TARGET_CHAR_BIT / TARGET_CHAR_BIT,
               0,