2006-05-13 Gaius Mulley <gaius@glam.ac.uk>
[external/binutils.git] / gdb / m2-valprint.c
1 /* Support for printing Modula 2 values for GDB, the GNU debugger.
2
3    Copyright (C) 1986, 1988, 1989, 1991, 1992, 1996, 1998,
4                  2000, 2005, 2006
5    Free Software Foundation, Inc.
6
7    This file is part of GDB.
8
9    This program is free software; you can redistribute it and/or modify
10    it under the terms of the GNU General Public License as published by
11    the Free Software Foundation; either version 2 of the License, or
12    (at your option) any later version.
13
14    This program is distributed in the hope that it will be useful,
15    but WITHOUT ANY WARRANTY; without even the implied warranty of
16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17    GNU General Public License for more details.
18
19    You should have received a copy of the GNU General Public License
20    along with this program; if not, write to the Free Software
21    Foundation, Inc., 51 Franklin Street, Fifth Floor,
22    Boston, MA 02110-1301, USA.  */
23
24 #include "defs.h"
25 #include "symtab.h"
26 #include "gdbtypes.h"
27 #include "expression.h"
28 #include "value.h"
29 #include "valprint.h"
30 #include "language.h"
31 #include "typeprint.h"
32 #include "c-lang.h"
33 #include "m2-lang.h"
34 #include "target.h"
35
36 int print_unpacked_pointer (struct type *type,
37                             CORE_ADDR address, CORE_ADDR addr,
38                             int format, struct ui_file *stream);
39
40
41 /* Print function pointer with inferior address ADDRESS onto stdio
42    stream STREAM.  */
43
44 static void
45 print_function_pointer_address (CORE_ADDR address, struct ui_file *stream)
46 {
47   CORE_ADDR func_addr = gdbarch_convert_from_func_ptr_addr (current_gdbarch,
48                                                             address,
49                                                             &current_target);
50
51   /* If the function pointer is represented by a description, print the
52      address of the description.  */
53   if (addressprint && func_addr != address)
54     {
55       fputs_filtered ("@", stream);
56       fputs_filtered (paddress (address), stream);
57       fputs_filtered (": ", stream);
58     }
59   print_address_demangle (func_addr, stream, demangle);
60 }
61
62 /*
63  *  get_long_set_bounds - assigns the bounds of the long set to low and high.
64  */
65
66 int
67 get_long_set_bounds (struct type *type, LONGEST *low, LONGEST *high)
68 {
69   int len, i;
70
71   if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
72     {
73       len = TYPE_NFIELDS (type);
74       i = TYPE_N_BASECLASSES (type);
75       if (len == 0)
76         return 0;
77       *low = TYPE_LOW_BOUND (TYPE_INDEX_TYPE (TYPE_FIELD_TYPE (type, i)));
78       *high = TYPE_HIGH_BOUND (TYPE_INDEX_TYPE (TYPE_FIELD_TYPE (type,
79                                                                  len-1)));
80       return 1;
81     }
82   error (_("expecting long_set"));
83   return 0;
84 }
85
86 static void
87 m2_print_long_set (struct type *type, const gdb_byte *valaddr,
88                    int embedded_offset, CORE_ADDR address,
89                    struct ui_file *stream, int format,
90                    enum val_prettyprint pretty)
91 {
92   int empty_set        = 1;
93   int element_seen     = 0;
94   LONGEST previous_low = 0;
95   LONGEST previous_high= 0;
96   LONGEST i, low_bound, high_bound;
97   LONGEST field_low, field_high;
98   struct type *range;
99   int len, field;
100   struct type *target;
101   int bitval;
102
103   CHECK_TYPEDEF (type);
104
105   fprintf_filtered (stream, "{");
106   len = TYPE_NFIELDS (type);
107   if (get_long_set_bounds (type, &low_bound, &high_bound))
108     {
109       field = TYPE_N_BASECLASSES (type);
110       range = TYPE_INDEX_TYPE (TYPE_FIELD_TYPE (type, field));
111     }
112   else
113     {
114       fprintf_filtered (stream, " %s }", _("<unknown bounds of set>"));
115       return;
116     }
117
118   target = TYPE_TARGET_TYPE (range);
119   if (target == NULL)
120     target = builtin_type_int;
121
122   if (get_discrete_bounds (range, &field_low, &field_high) >= 0)
123     {
124       for (i = low_bound; i <= high_bound; i++)
125         {
126           bitval = value_bit_index (TYPE_FIELD_TYPE (type, field),
127                                     (TYPE_FIELD_BITPOS (type, field) / 8) +
128                                     valaddr + embedded_offset, i);
129           if (bitval < 0)
130             error (_("bit test is out of range"));
131           else if (bitval > 0)
132             {
133               previous_high = i;
134               if (! element_seen)
135                 {
136                   if (! empty_set)
137                     fprintf_filtered (stream, ", ");
138                   print_type_scalar (target, i, stream);
139                   empty_set    = 0;
140                   element_seen = 1;
141                   previous_low = i;
142                 }
143             }
144           else
145             {
146               /* bit is not set */
147               if (element_seen)
148                 {
149                   if (previous_low+1 < previous_high)
150                     fprintf_filtered (stream, "..");
151                   if (previous_low+1 < previous_high)
152                     print_type_scalar (target, previous_high, stream);
153                   element_seen = 0;
154                 }
155             }
156           if (i == field_high)
157             {
158               field++;
159               if (field == len)
160                 break;
161               range = TYPE_INDEX_TYPE (TYPE_FIELD_TYPE (type, field));
162               if (get_discrete_bounds (range, &field_low, &field_high) < 0)
163                 break;
164               target = TYPE_TARGET_TYPE (range);
165               if (target == NULL)
166                 target = builtin_type_int;
167             }
168         }
169       if (element_seen)
170         {
171           if (previous_low+1 < previous_high)
172             {
173               fprintf_filtered (stream, "..");
174               print_type_scalar (target, previous_high, stream);
175             }
176           element_seen = 0;
177         }
178       fprintf_filtered (stream, "}");
179     }
180 }
181
182 int
183 print_unpacked_pointer (struct type *type,
184                         CORE_ADDR address, CORE_ADDR addr,
185                         int format, struct ui_file *stream)
186 {
187   struct type *elttype = check_typedef (TYPE_TARGET_TYPE (type));
188
189   if (TYPE_CODE (elttype) == TYPE_CODE_FUNC)
190     {
191       /* Try to print what function it points to.  */
192       print_function_pointer_address (addr, stream);
193       /* Return value is irrelevant except for string pointers.  */
194       return 0;
195     }
196
197   if (addressprint && format != 's')
198     fputs_filtered (paddress (address), stream);
199
200   /* For a pointer to char or unsigned char, also print the string
201      pointed to, unless pointer is null.  */
202
203   if (TYPE_LENGTH (elttype) == 1
204       && TYPE_CODE (elttype) == TYPE_CODE_INT
205       && (format == 0 || format == 's')
206       && addr != 0)
207       return val_print_string (addr, -1, TYPE_LENGTH (elttype), stream);
208   
209   return 0;
210 }
211
212 static void
213 print_variable_at_address (struct type *type, const gdb_byte *valaddr,
214                            struct ui_file *stream, int format,
215                            int deref_ref, int recurse,
216                            enum val_prettyprint pretty)
217 {
218   CORE_ADDR addr = unpack_pointer (type, valaddr);
219   struct type *elttype = check_typedef (TYPE_TARGET_TYPE (type));
220
221   fprintf_filtered (stream, "[");
222   fputs_filtered (paddress (addr), stream);
223   fprintf_filtered (stream, "] : ");
224   
225   if (TYPE_CODE (elttype) != TYPE_CODE_UNDEF)
226     {
227       struct value *deref_val =
228         value_at
229         (TYPE_TARGET_TYPE (type),
230          unpack_pointer (lookup_pointer_type (builtin_type_void),
231                          valaddr));
232       common_val_print (deref_val, stream, format, deref_ref,
233                         recurse, pretty);
234     }
235   else
236     fputs_filtered ("???", stream);
237 }
238
239 /* Print data of type TYPE located at VALADDR (within GDB), which came from
240    the inferior at address ADDRESS, onto stdio stream STREAM according to
241    FORMAT (a letter or 0 for natural format).  The data at VALADDR is in
242    target byte order.
243
244    If the data are a string pointer, returns the number of string characters
245    printed.
246
247    If DEREF_REF is nonzero, then dereference references, otherwise just print
248    them like pointers.
249
250    The PRETTY parameter controls prettyprinting.  */
251
252 int
253 m2_val_print (struct type *type, const gdb_byte *valaddr, int embedded_offset,
254               CORE_ADDR address, struct ui_file *stream, int format,
255               int deref_ref, int recurse, enum val_prettyprint pretty)
256 {
257   unsigned int i = 0;   /* Number of characters printed */
258   unsigned len;
259   struct type *elttype;
260   unsigned eltlen;
261   int length_pos, length_size, string_pos;
262   int char_size;
263   LONGEST val;
264   CORE_ADDR addr;
265
266   CHECK_TYPEDEF (type);
267   switch (TYPE_CODE (type))
268     {
269     case TYPE_CODE_ARRAY:
270       if (TYPE_LENGTH (type) > 0 && TYPE_LENGTH (TYPE_TARGET_TYPE (type)) > 0)
271         {
272           elttype = check_typedef (TYPE_TARGET_TYPE (type));
273           eltlen = TYPE_LENGTH (elttype);
274           len = TYPE_LENGTH (type) / eltlen;
275           if (prettyprint_arrays)
276             print_spaces_filtered (2 + 2 * recurse, stream);
277           /* For an array of chars, print with string syntax.  */
278           if (eltlen == 1 &&
279               ((TYPE_CODE (elttype) == TYPE_CODE_INT)
280                || ((current_language->la_language == language_m2)
281                    && (TYPE_CODE (elttype) == TYPE_CODE_CHAR)))
282               && (format == 0 || format == 's'))
283             {
284               /* If requested, look for the first null char and only print
285                  elements up to it.  */
286               if (stop_print_at_null)
287                 {
288                   unsigned int temp_len;
289
290                   /* Look for a NULL char. */
291                   for (temp_len = 0;
292                        (valaddr + embedded_offset)[temp_len]
293                          && temp_len < len && temp_len < print_max;
294                        temp_len++);
295                   len = temp_len;
296                 }
297
298               LA_PRINT_STRING (stream, valaddr + embedded_offset, len, 1, 0);
299               i = len;
300             }
301           else
302             {
303               fprintf_filtered (stream, "{");
304               val_print_array_elements (type, valaddr + embedded_offset,
305                                         address, stream, format, deref_ref,
306                                         recurse, pretty, 0);
307               fprintf_filtered (stream, "}");
308             }
309           break;
310         }
311       /* Array of unspecified length: treat like pointer to first elt.  */
312       print_unpacked_pointer (type, address, address, format, stream);
313       break;
314
315     case TYPE_CODE_PTR:
316       if (TYPE_CONST (type))
317         print_variable_at_address (type, valaddr + embedded_offset,
318                                    stream, format, deref_ref, recurse,
319                                    pretty);
320       else if (format && format != 's')
321         print_scalar_formatted (valaddr + embedded_offset, type, format,
322                                 0, stream);
323       else
324         {
325           addr = unpack_pointer (type, valaddr + embedded_offset);
326           print_unpacked_pointer (type, addr, address, format, stream);
327         }
328       break;
329
330     case TYPE_CODE_MEMBER:
331       error (_("not implemented: member type in m2_val_print"));
332       break;
333
334     case TYPE_CODE_REF:
335       elttype = check_typedef (TYPE_TARGET_TYPE (type));
336       if (addressprint)
337         {
338           CORE_ADDR addr
339             = extract_typed_address (valaddr + embedded_offset, type);
340           fprintf_filtered (stream, "@");
341           fputs_filtered (paddress (addr), stream);
342           if (deref_ref)
343             fputs_filtered (": ", stream);
344         }
345       /* De-reference the reference.  */
346       if (deref_ref)
347         {
348           if (TYPE_CODE (elttype) != TYPE_CODE_UNDEF)
349             {
350               struct value *deref_val =
351                 value_at
352                 (TYPE_TARGET_TYPE (type),
353                  unpack_pointer (lookup_pointer_type (builtin_type_void),
354                                  valaddr + embedded_offset));
355               common_val_print (deref_val, stream, format, deref_ref,
356                                 recurse, pretty);
357             }
358           else
359             fputs_filtered ("???", stream);
360         }
361       break;
362
363     case TYPE_CODE_UNION:
364       if (recurse && !unionprint)
365         {
366           fprintf_filtered (stream, "{...}");
367           break;
368         }
369       /* Fall through.  */
370     case TYPE_CODE_STRUCT:
371       if (m2_is_long_set (type))
372         m2_print_long_set (type, valaddr, embedded_offset, address,
373                            stream, format, pretty);
374       else
375         cp_print_value_fields (type, type, valaddr, embedded_offset,
376                                address, stream, format,
377                                recurse, pretty, NULL, 0);
378       break;
379
380     case TYPE_CODE_ENUM:
381       if (format)
382         {
383           print_scalar_formatted (valaddr + embedded_offset, type,
384                                   format, 0, stream);
385           break;
386         }
387       len = TYPE_NFIELDS (type);
388       val = unpack_long (type, valaddr + embedded_offset);
389       for (i = 0; i < len; i++)
390         {
391           QUIT;
392           if (val == TYPE_FIELD_BITPOS (type, i))
393             {
394               break;
395             }
396         }
397       if (i < len)
398         {
399           fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
400         }
401       else
402         {
403           print_longest (stream, 'd', 0, val);
404         }
405       break;
406
407     case TYPE_CODE_FUNC:
408       if (format)
409         {
410           print_scalar_formatted (valaddr + embedded_offset, type,
411                                   format, 0, stream);
412           break;
413         }
414       /* FIXME, we should consider, at least for ANSI C language, eliminating
415          the distinction made between FUNCs and POINTERs to FUNCs.  */
416       fprintf_filtered (stream, "{");
417       type_print (type, "", stream, -1);
418       fprintf_filtered (stream, "} ");
419       /* Try to print what function it points to, and its address.  */
420       print_address_demangle (address, stream, demangle);
421       break;
422
423     case TYPE_CODE_BOOL:
424       format = format ? format : output_format;
425       if (format)
426         print_scalar_formatted (valaddr + embedded_offset, type,
427                                 format, 0, stream);
428       else
429         {
430           val = unpack_long (type, valaddr + embedded_offset);
431           if (val == 0)
432             fputs_filtered ("FALSE", stream);
433           else if (val == 1)
434             fputs_filtered ("TRUE", stream);
435           else
436             fprintf_filtered (stream, "%ld)", (long int) val);
437         }
438       break;
439
440     case TYPE_CODE_RANGE:
441       if (TYPE_LENGTH (type) == TYPE_LENGTH (TYPE_TARGET_TYPE (type)))
442         {
443           m2_val_print (TYPE_TARGET_TYPE (type), valaddr, embedded_offset,
444                         address, stream, format, deref_ref, recurse, pretty);
445           break;
446         }
447       /* FIXME: create_range_type does not set the unsigned bit in a
448          range type (I think it probably should copy it from the target
449          type), so we won't print values which are too large to
450          fit in a signed integer correctly.  */
451       /* FIXME: Doesn't handle ranges of enums correctly.  (Can't just
452          print with the target type, though, because the size of our type
453          and the target type might differ).  */
454       /* FALLTHROUGH */
455
456     case TYPE_CODE_INT:
457       format = format ? format : output_format;
458       if (format)
459         print_scalar_formatted (valaddr + embedded_offset, type, format,
460                                 0, stream);
461       else
462         val_print_type_code_int (type, valaddr + embedded_offset, stream);
463       break;
464
465     case TYPE_CODE_CHAR:
466       format = format ? format : output_format;
467       if (format)
468         print_scalar_formatted (valaddr + embedded_offset, type,
469                                 format, 0, stream);
470       else
471         {
472           val = unpack_long (type, valaddr + embedded_offset);
473           if (TYPE_UNSIGNED (type))
474             fprintf_filtered (stream, "%u", (unsigned int) val);
475           else
476             fprintf_filtered (stream, "%d", (int) val);
477           fputs_filtered (" ", stream);
478           LA_PRINT_CHAR ((unsigned char) val, stream);
479         }
480       break;
481
482     case TYPE_CODE_FLT:
483       if (format)
484         print_scalar_formatted (valaddr + embedded_offset, type,
485                                 format, 0, stream);
486       else
487         print_floating (valaddr + embedded_offset, type, stream);
488       break;
489
490     case TYPE_CODE_METHOD:
491       break;
492
493     case TYPE_CODE_BITSTRING:
494     case TYPE_CODE_SET:
495       elttype = TYPE_INDEX_TYPE (type);
496       CHECK_TYPEDEF (elttype);
497       if (TYPE_STUB (elttype))
498         {
499           fprintf_filtered (stream, _("<incomplete type>"));
500           gdb_flush (stream);
501           break;
502         }
503       else
504         {
505           struct type *range = elttype;
506           LONGEST low_bound, high_bound;
507           int i;
508           int is_bitstring = TYPE_CODE (type) == TYPE_CODE_BITSTRING;
509           int need_comma = 0;
510
511           if (is_bitstring)
512             fputs_filtered ("B'", stream);
513           else
514             fputs_filtered ("{", stream);
515
516           i = get_discrete_bounds (range, &low_bound, &high_bound);
517         maybe_bad_bstring:
518           if (i < 0)
519             {
520               fputs_filtered (_("<error value>"), stream);
521               goto done;
522             }
523
524           for (i = low_bound; i <= high_bound; i++)
525             {
526               int element = value_bit_index (type, valaddr + embedded_offset,
527                                              i);
528               if (element < 0)
529                 {
530                   i = element;
531                   goto maybe_bad_bstring;
532                 }
533               if (is_bitstring)
534                 fprintf_filtered (stream, "%d", element);
535               else if (element)
536                 {
537                   if (need_comma)
538                     fputs_filtered (", ", stream);
539                   print_type_scalar (range, i, stream);
540                   need_comma = 1;
541
542                   if (i + 1 <= high_bound
543                       && value_bit_index (type, valaddr + embedded_offset,
544                                           ++i))
545                     {
546                       int j = i;
547                       fputs_filtered ("..", stream);
548                       while (i + 1 <= high_bound
549                              && value_bit_index (type,
550                                                  valaddr + embedded_offset,
551                                                  ++i))
552                         j = i;
553                       print_type_scalar (range, j, stream);
554                     }
555                 }
556             }
557         done:
558           if (is_bitstring)
559             fputs_filtered ("'", stream);
560           else
561             fputs_filtered ("}", stream);
562         }
563       break;
564
565     case TYPE_CODE_VOID:
566       fprintf_filtered (stream, "void");
567       break;
568
569     case TYPE_CODE_ERROR:
570       fprintf_filtered (stream, _("<error type>"));
571       break;
572
573     case TYPE_CODE_UNDEF:
574       /* This happens (without TYPE_FLAG_STUB set) on systems which don't use
575          dbx xrefs (NO_DBX_XREFS in gcc) if a file has a "struct foo *bar"
576          and no complete type for struct foo in that file.  */
577       fprintf_filtered (stream, _("<incomplete type>"));
578       break;
579
580     default:
581       error (_("Invalid m2 type code %d in symbol table."), TYPE_CODE (type));
582     }
583   gdb_flush (stream);
584   return (0);
585 }