/* Support for printing Chill values for GDB, the GNU debugger.
- Copyright 1986, 1988, 1989, 1991, 1992, 1993, 1994
+ Copyright 1986, 1988, 1989, 1991-1994, 2000
Free Software Foundation, Inc.
-This file is part of GDB.
+ This file is part of GDB.
-This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
-(at your option) any later version.
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-GNU General Public License for more details.
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
-You should have received a copy of the GNU General Public License
-along with this program; if not, write to the Free Software
-Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330,
+ Boston, MA 02111-1307, USA. */
#include "defs.h"
#include "obstack.h"
#include "value.h"
#include "language.h"
#include "demangle.h"
-#include "c-lang.h" /* For c_val_print */
+#include "c-lang.h" /* For c_val_print */
#include "typeprint.h"
#include "ch-lang.h"
#include "annotate.h"
-static void
-chill_print_value_fields PARAMS ((struct type *, char *, GDB_FILE *, int, int,
- enum val_prettyprint, struct type **));
+static void chill_print_value_fields (struct type *, char *,
+ struct ui_file *, int, int,
+ enum val_prettyprint, struct type **);
+
+static void chill_print_type_scalar (struct type *, LONGEST,
+ struct ui_file *);
+static void chill_val_print_array_elements (struct type *, char *,
+ CORE_ADDR, struct ui_file *,
+ int, int, int,
+ enum val_prettyprint);
\f
+
/* Print integral scalar data VAL, of type TYPE, onto stdio stream STREAM.
Used to print data from type structures in a specified type. For example,
array bounds may be characters or booleans in some languages, and this
allows the ranges to be printed in their "natural" form rather than as
decimal integer values. */
-void
+static void
chill_print_type_scalar (type, val, stream)
struct type *type;
LONGEST val;
- GDB_FILE *stream;
+ struct ui_file *stream;
{
switch (TYPE_CODE (type))
{
struct type *type;
char *valaddr;
CORE_ADDR address;
- GDB_FILE *stream;
+ struct ui_file *stream;
int format;
int deref_ref;
int recurse;
unsigned int rep1;
/* Number of repetitions we have detected so far. */
unsigned int reps;
- LONGEST low_bound = TYPE_FIELD_BITPOS (range_type, 0);
-
+ LONGEST low_bound = TYPE_FIELD_BITPOS (range_type, 0);
+
elttype = check_typedef (TYPE_TARGET_TYPE (type));
eltlen = TYPE_LENGTH (elttype);
len = TYPE_LENGTH (type) / eltlen;
rep1 = i + 1;
reps = 1;
- while ((rep1 < len) &&
+ while ((rep1 < len) &&
!memcmp (valaddr + i * eltlen, valaddr + rep1 * eltlen, eltlen))
{
++reps;
chill_print_type_scalar (index_type, low_bound + i + reps - 1,
stream);
fputs_filtered ("): ", stream);
- val_print (elttype, valaddr + i * eltlen, 0, stream, format,
+ val_print (elttype, valaddr + i * eltlen, 0, 0, stream, format,
deref_ref, recurse + 1, pretty);
i = rep1 - 1;
else
{
fputs_filtered ("): ", stream);
- val_print (elttype, valaddr + i * eltlen, 0, stream, format,
+ val_print (elttype, valaddr + i * eltlen, 0, 0, stream, format,
deref_ref, recurse + 1, pretty);
annotate_elt ();
things_printed++;
}
}
-/* In certain cases it could happen, that an array type doesn't
- have a length (this have to do with seizing). The reason is
- shown in the following stabs:
-
- .stabs "m_x:Tt81=s36i:1,0,32;ar:82=ar80;0;1;83=xsm_struct:,32,256;;",128,0,25,0
-
- .stabs "m_struct:Tt83=s16f1:9,0,16;f2:85=*84,32,32;f3:84,64,64;;",128,0,10,0
-
- When processing t81, the array ar80 doesn't have a length, cause
- struct m_struct is specified extern at thse moment. Afterwards m_struct
- gets specified and updated, but not the surrounding type.
-
- So we walk through array's till we find a type with a length and
- calculate the array length.
-
- FIXME: Where may this happen too ?
- */
-
-static void
-calculate_array_length (type)
- struct type *type;
-{
- struct type *target_type;
- struct type *range_type;
- LONGEST lower_bound, upper_bound;
-
- if (TYPE_CODE (type) != TYPE_CODE_ARRAY)
- /* not an array, stop processing */
- return;
-
- target_type = TYPE_TARGET_TYPE (type);
- range_type = TYPE_FIELD_TYPE (type, 0);
- lower_bound = TYPE_FIELD_BITPOS (range_type, 0);
- upper_bound = TYPE_FIELD_BITPOS (range_type, 1);
-
- if (TYPE_LENGTH (target_type) == 0 &&
- TYPE_CODE (target_type) == TYPE_CODE_ARRAY)
- /* we've got another array */
- calculate_array_length (target_type);
-
- TYPE_LENGTH (type) = (upper_bound - lower_bound + 1) * TYPE_LENGTH (target_type);
-}
-
/* Print data of type TYPE located at VALADDR (within GDB), which came from
the inferior at address ADDRESS, onto stdio stream STREAM according to
FORMAT (a letter or 0 for natural format). The data at VALADDR is in
The PRETTY parameter controls prettyprinting. */
int
-chill_val_print (type, valaddr, address, stream, format, deref_ref, recurse,
- pretty)
+chill_val_print (type, valaddr, embedded_offset, address,
+ stream, format, deref_ref, recurse, pretty)
struct type *type;
char *valaddr;
+ int embedded_offset;
CORE_ADDR address;
- GDB_FILE *stream;
+ struct ui_file *stream;
int format;
int deref_ref;
int recurse;
switch (TYPE_CODE (type))
{
case TYPE_CODE_ARRAY:
- if (TYPE_LENGTH (type) == 0)
- /* see comment function calculate_array_length */
- calculate_array_length (type);
-
if (TYPE_LENGTH (type) > 0 && TYPE_LENGTH (TYPE_TARGET_TYPE (type)) > 0)
{
if (prettyprint_arrays)
}
fprintf_filtered (stream, "[");
chill_val_print_array_elements (type, valaddr, address, stream,
- format, deref_ref, recurse, pretty);
+ format, deref_ref, recurse, pretty);
fprintf_filtered (stream, "]");
}
else
case TYPE_CODE_UNDEF:
/* This happens (without TYPE_FLAG_STUB set) on systems which don't use
- dbx xrefs (NO_DBX_XREFS in gcc) if a file has a "struct foo *bar"
- and no complete type for struct foo in that file. */
+ dbx xrefs (NO_DBX_XREFS in gcc) if a file has a "struct foo *bar"
+ and no complete type for struct foo in that file. */
fprintf_filtered (stream, "<incomplete type>");
break;
fputs_filtered ("NULL", stream);
return 0;
}
-
+
if (TYPE_CODE (elttype) == TYPE_CODE_FUNC)
{
/* Try to print what function it points to. */
{
print_address_numeric (addr, 1, stream);
}
-
+
/* For a pointer to char or unsigned char, also print the string
- pointed to, unless pointer is null. */
+ pointed to, unless pointer is null. */
if (TYPE_LENGTH (elttype) == 1
&& TYPE_CODE (elttype) == TYPE_CODE_CHAR
&& (format == 0 || format == 's')
&& addr != 0
- && /* If print_max is UINT_MAX, the alloca below will fail.
- In that case don't try to print the string. */
+ && /* If print_max is UINT_MAX, the alloca below will fail.
+ In that case don't try to print the string. */
print_max < UINT_MAX)
- {
- i = val_print_string (addr, 0, stream);
- }
+ i = val_print_string (addr, -1, TYPE_LENGTH (elttype), stream);
+
/* Return number of characters printed, plus one for the
- terminating null if we have "reached the end". */
+ terminating null if we have "reached the end". */
return (i + (print_max && i != print_max));
break;
case TYPE_CODE_STRING:
i = TYPE_LENGTH (type);
- LA_PRINT_STRING (stream, valaddr, i, 0);
+ LA_PRINT_STRING (stream, valaddr, i, 1, 0);
/* Return number of characters printed, plus one for the terminating
- null if we have "reached the end". */
+ null if we have "reached the end". */
return (i + (print_max && i != print_max));
break;
{
if (need_comma)
fputs_filtered (", ", stream);
- chill_print_type_scalar (range, i, stream);
+ chill_print_type_scalar (range, (LONGEST) i, stream);
need_comma = 1;
/* Look for a continuous range of true elements. */
- if (i+1 <= high_bound && value_bit_index (type, valaddr, ++i))
+ if (i + 1 <= high_bound && value_bit_index (type, valaddr, ++i))
{
- int j = i; /* j is the upper bound so far of the range */
+ int j = i; /* j is the upper bound so far of the range */
fputs_filtered (":", stream);
- while (i+1 <= high_bound
+ while (i + 1 <= high_bound
&& value_bit_index (type, valaddr, ++i))
j = i;
- chill_print_type_scalar (range, j, stream);
+ chill_print_type_scalar (range, (LONGEST) j, stream);
}
}
}
struct type *inner = check_typedef (TYPE_FIELD_TYPE (type, 1));
long length = unpack_long (TYPE_FIELD_TYPE (type, 0), valaddr);
char *data_addr = valaddr + TYPE_FIELD_BITPOS (type, 1) / 8;
-
+
switch (TYPE_CODE (inner))
{
case TYPE_CODE_STRING:
- if (length > TYPE_LENGTH (type))
+ if (length > TYPE_LENGTH (type) - 2)
{
fprintf_filtered (stream,
- "<dynamic length %ld > static length %d>",
+ "<dynamic length %ld > static length %d> *invalid*",
length, TYPE_LENGTH (type));
+
+ /* Don't print the string; doing so might produce a
+ segfault. */
+ return length;
}
- LA_PRINT_STRING (stream, data_addr, length, 0);
+ LA_PRINT_STRING (stream, data_addr, length, 1, 0);
return length;
default:
break;
case TYPE_CODE_REF:
if (addressprint)
- {
+ {
fprintf_filtered (stream, "LOC(");
print_address_numeric
(extract_address (valaddr, TARGET_PTR_BIT / HOST_CHAR_BIT),
fprintf_filtered (stream, ")");
if (deref_ref)
fputs_filtered (": ", stream);
- }
+ }
/* De-reference the reference. */
if (deref_ref)
{
if (TYPE_CODE (TYPE_TARGET_TYPE (type)) != TYPE_CODE_UNDEF)
{
value_ptr deref_val =
- value_at
- (TYPE_TARGET_TYPE (type),
- unpack_pointer (lookup_pointer_type (builtin_type_void),
- valaddr));
+ value_at
+ (TYPE_TARGET_TYPE (type),
+ unpack_pointer (lookup_pointer_type (builtin_type_void),
+ valaddr),
+ NULL);
val_print (VALUE_TYPE (deref_val),
VALUE_CONTENTS (deref_val),
+ 0,
VALUE_ADDRESS (deref_val), stream, format,
deref_ref, recurse + 1, pretty);
}
break;
case TYPE_CODE_ENUM:
- c_val_print (type, valaddr, address, stream, format,
+ c_val_print (type, valaddr, 0, address, stream, format,
deref_ref, recurse, pretty);
break;
case TYPE_CODE_RANGE:
if (TYPE_TARGET_TYPE (type))
- chill_val_print (TYPE_TARGET_TYPE (type), valaddr, address, stream,
+ chill_val_print (TYPE_TARGET_TYPE (type), valaddr, 0, address, stream,
format, deref_ref, recurse, pretty);
break;
case TYPE_CODE_ERROR:
default:
/* Let's defer printing to the C printer, rather than
- print an error message. FIXME! */
- c_val_print (type, valaddr, address, stream, format,
+ print an error message. FIXME! */
+ c_val_print (type, valaddr, 0, address, stream, format,
deref_ref, recurse, pretty);
}
gdb_flush (stream);
dont_print)
struct type *type;
char *valaddr;
- GDB_FILE *stream;
+ struct ui_file *stream;
int format;
int recurse;
enum val_prettyprint pretty;
fprintf_filtered (stream, "\n");
print_spaces_filtered (2 + 2 * recurse, stream);
}
- else
+ else
{
wrap_here (n_spaces (2 + 2 * recurse));
}
value_ptr v;
/* Bitfields require special handling, especially due to byte
- order problems. */
+ order problems. */
v = value_from_longest (TYPE_FIELD_TYPE (type, i),
- unpack_field_as_long (type, valaddr, i));
+ unpack_field_as_long (type, valaddr, i));
- chill_val_print (TYPE_FIELD_TYPE (type, i), VALUE_CONTENTS (v), 0,
+ chill_val_print (TYPE_FIELD_TYPE (type, i), VALUE_CONTENTS (v), 0, 0,
stream, format, 0, recurse + 1, pretty);
}
else
{
- chill_val_print (TYPE_FIELD_TYPE (type, i),
- valaddr + TYPE_FIELD_BITPOS (type, i) / 8,
+ chill_val_print (TYPE_FIELD_TYPE (type, i),
+ valaddr + TYPE_FIELD_BITPOS (type, i) / 8, 0,
0, stream, format, 0, recurse + 1, pretty);
}
}
int
chill_value_print (val, stream, format, pretty)
value_ptr val;
- GDB_FILE *stream;
+ struct ui_file *stream;
int format;
enum val_prettyprint pretty;
{
struct type *type = VALUE_TYPE (val);
- struct type *real_type = check_typedef (type);
+ struct type *real_type = check_typedef (type);
/* If it is a pointer, indicate what it points to.
fprintf_filtered (stream, ")");
}
fprintf_filtered (stream, "(");
- i = val_print (type, valaddr, VALUE_ADDRESS (val),
+ i = val_print (type, valaddr, 0, VALUE_ADDRESS (val),
stream, format, 1, 0, pretty);
fprintf_filtered (stream, ")");
return i;
}
}
- return (val_print (type, VALUE_CONTENTS (val),
+ return (val_print (type, VALUE_CONTENTS (val), 0,
VALUE_ADDRESS (val), stream, format, 1, 0, pretty));
}
-
-
projects / deliverable / binutils-gdb.git / blobdiff