Change inferior thread list to be a thread map

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

diff --git a/gdb/c-lang.c b/gdb/c-lang.c
index aeffefad55e0011258a29e1f510f4950865441cb..1f40e885d99aac3e41227fd22e15f7ccb40d8ce2 100644 (file)
--- a/gdb/c-lang.c
+++ b/gdb/c-lang.c
@@ -35,6 +35,7 @@
 #include "gdb_obstack.h"
 #include <ctype.h>
 #include "gdbcore.h"
+#include "gdbarch.h"
 
 /* Given a C string type, STR_TYPE, return the corresponding target
    character set name.  */
@@ -244,7 +245,7 @@ c_get_string (struct value *value, gdb::unique_xmalloc_ptr<gdb_byte> *buffer,
   struct type *element_type = TYPE_TARGET_TYPE (type);
   int req_length = *length;
   enum bfd_endian byte_order
-    = gdbarch_byte_order (get_type_arch (type));
+    = type_byte_order (type);
 
   if (element_type == NULL)
     goto error;
@@ -279,10 +280,21 @@ c_get_string (struct value *value, gdb::unique_xmalloc_ptr<gdb_byte> *buffer,
   /* If the string lives in GDB's memory instead of the inferior's,
      then we just need to copy it to BUFFER.  Also, since such strings
      are arrays with known size, FETCHLIMIT will hold the size of the
-     array.  */
+     array.
+
+     An array is assumed to live in GDB's memory, so we take this path
+     here.
+
+     However, it's possible for the caller to request more array
+     elements than apparently exist -- this can happen when using the
+     C struct hack.  So, only do this if either no length was
+     specified, or the length is within the existing bounds.  This
+     avoids running off the end of the value's contents.  */
   if ((VALUE_LVAL (value) == not_lval
-       || VALUE_LVAL (value) == lval_internalvar)
-      && fetchlimit != UINT_MAX)
+       || VALUE_LVAL (value) == lval_internalvar
+       || TYPE_CODE (type) == TYPE_CODE_ARRAY)
+      && fetchlimit != UINT_MAX
+      && (*length < 0 || *length <= fetchlimit))
     {
       int i;
       const gdb_byte *contents = value_contents (value);
@@ -291,14 +303,14 @@ c_get_string (struct value *value, gdb::unique_xmalloc_ptr<gdb_byte> *buffer,
       if (*length >= 0)
        i  = *length;
       else
-       /* Otherwise, look for a null character.  */
-       for (i = 0; i < fetchlimit; i++)
+       /* Otherwise, look for a null character.  */
+       for (i = 0; i < fetchlimit; i++)
          if (extract_unsigned_integer (contents + i * width,
                                        width, byte_order) == 0)
-           break;
+           break;
   
       /* I is now either a user-defined length, the number of non-null
-        characters, or FETCHLIMIT.  */
+        characters, or FETCHLIMIT.  */
       *length = i * width;
       buffer->reset ((gdb_byte *) xmalloc (*length));
       memcpy (buffer->get (), contents, *length);
@@ -306,7 +318,19 @@ c_get_string (struct value *value, gdb::unique_xmalloc_ptr<gdb_byte> *buffer,
     }
   else
     {
-      CORE_ADDR addr = value_as_address (value);
+      /* value_as_address does not return an address for an array when
+        c_style_arrays is false, so we handle that specially
+        here.  */
+      CORE_ADDR addr;
+      if (TYPE_CODE (type) == TYPE_CODE_ARRAY)
+       {
+         if (VALUE_LVAL (value) != lval_memory)
+           error (_("Attempt to take address of value "
+                    "not located in memory."));
+         addr = value_address (value);
+       }
+      else
+       addr = value_as_address (value);
 
       /* Prior to the fix for PR 16196 read_string would ignore fetchlimit
         if length > 0.  The old "broken" behaviour is the behaviour we want:
@@ -587,16 +611,13 @@ evaluate_subexp_c (struct type *expect_type, struct expression *exp,
                                              exp->gdbarch);
            break;
          case C_WIDE_STRING:
-           type = lookup_typename (exp->language_defn, exp->gdbarch,
-                                   "wchar_t", NULL, 0);
+           type = lookup_typename (exp->language_defn, "wchar_t", NULL, 0);
            break;
          case C_STRING_16:
-           type = lookup_typename (exp->language_defn, exp->gdbarch,
-                                   "char16_t", NULL, 0);
+           type = lookup_typename (exp->language_defn, "char16_t", NULL, 0);
            break;
          case C_STRING_32:
-           type = lookup_typename (exp->language_defn, exp->gdbarch,
-                                   "char32_t", NULL, 0);
+           type = lookup_typename (exp->language_defn, "char32_t", NULL, 0);
            break;
          default:
            internal_error (__FILE__, __LINE__, _("unhandled c_string_type"));
@@ -902,7 +923,6 @@ extern const struct language_defn c_language_defn =
   c_language_arch_info,
   default_print_array_index,
   default_pass_by_reference,
-  c_get_string,
   c_watch_location_expression,
   NULL,                                /* la_get_symbol_name_matcher */
   iterate_over_symbols,
@@ -1048,7 +1068,6 @@ extern const struct language_defn cplus_language_defn =
   cplus_language_arch_info,
   default_print_array_index,
   cp_pass_by_reference,
-  c_get_string,
   c_watch_location_expression,
   cp_get_symbol_name_matcher,
   iterate_over_symbols,
@@ -1100,10 +1119,9 @@ extern const struct language_defn asm_language_defn =
   0,                           /* String lower bound */
   default_word_break_characters,
   default_collect_symbol_completion_matches,
-  c_language_arch_info,        /* FIXME: la_language_arch_info.  */
+  c_language_arch_info,                /* FIXME: la_language_arch_info.  */
   default_print_array_index,
   default_pass_by_reference,
-  c_get_string,
   c_watch_location_expression,
   NULL,                                /* la_get_symbol_name_matcher */
   iterate_over_symbols,
@@ -1158,7 +1176,6 @@ extern const struct language_defn minimal_language_defn =
   c_language_arch_info,
   default_print_array_index,
   default_pass_by_reference,
-  c_get_string,
   c_watch_location_expression,
   NULL,                                /* la_get_symbol_name_matcher */
   iterate_over_symbols,