Automatic date update in version.in
[external/binutils.git] / gdb / m2-valprint.c
1 /* Support for printing Modula 2 values for GDB, the GNU debugger.
2
3    Copyright (C) 1986-2018 Free Software Foundation, Inc.
4
5    This file is part of GDB.
6
7    This program is free software; you can redistribute it and/or modify
8    it under the terms of the GNU General Public License as published by
9    the Free Software Foundation; either version 3 of the License, or
10    (at your option) any later version.
11
12    This program is distributed in the hope that it will be useful,
13    but WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15    GNU General Public License for more details.
16
17    You should have received a copy of the GNU General Public License
18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
19
20 #include "defs.h"
21 #include "symtab.h"
22 #include "gdbtypes.h"
23 #include "expression.h"
24 #include "value.h"
25 #include "valprint.h"
26 #include "language.h"
27 #include "typeprint.h"
28 #include "c-lang.h"
29 #include "m2-lang.h"
30 #include "target.h"
31
32 static int print_unpacked_pointer (struct type *type,
33                                    CORE_ADDR address, CORE_ADDR addr,
34                                    const struct value_print_options *options,
35                                    struct ui_file *stream);
36 static void
37 m2_print_array_contents (struct type *type, const gdb_byte *valaddr,
38                          int embedded_offset, CORE_ADDR address,
39                          struct ui_file *stream, int recurse,
40                          struct value *val,
41                          const struct value_print_options *options,
42                          int len);
43
44
45 /* get_long_set_bounds - assigns the bounds of the long set to low and
46                          high.  */
47
48 int
49 get_long_set_bounds (struct type *type, LONGEST *low, LONGEST *high)
50 {
51   int len, i;
52
53   if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
54     {
55       len = TYPE_NFIELDS (type);
56       i = TYPE_N_BASECLASSES (type);
57       if (len == 0)
58         return 0;
59       *low = TYPE_LOW_BOUND (TYPE_INDEX_TYPE (TYPE_FIELD_TYPE (type, i)));
60       *high = TYPE_HIGH_BOUND (TYPE_INDEX_TYPE (TYPE_FIELD_TYPE (type,
61                                                                  len-1)));
62       return 1;
63     }
64   error (_("expecting long_set"));
65   return 0;
66 }
67
68 static void
69 m2_print_long_set (struct type *type, const gdb_byte *valaddr,
70                    int embedded_offset, CORE_ADDR address,
71                    struct ui_file *stream)
72 {
73   int empty_set        = 1;
74   int element_seen     = 0;
75   LONGEST previous_low = 0;
76   LONGEST previous_high= 0;
77   LONGEST i, low_bound, high_bound;
78   LONGEST field_low, field_high;
79   struct type *range;
80   int len, field;
81   struct type *target;
82   int bitval;
83
84   type = check_typedef (type);
85
86   fprintf_filtered (stream, "{");
87   len = TYPE_NFIELDS (type);
88   if (get_long_set_bounds (type, &low_bound, &high_bound))
89     {
90       field = TYPE_N_BASECLASSES (type);
91       range = TYPE_INDEX_TYPE (TYPE_FIELD_TYPE (type, field));
92     }
93   else
94     {
95       fprintf_filtered (stream, " %s }", _("<unknown bounds of set>"));
96       return;
97     }
98
99   target = TYPE_TARGET_TYPE (range);
100
101   if (get_discrete_bounds (range, &field_low, &field_high) >= 0)
102     {
103       for (i = low_bound; i <= high_bound; i++)
104         {
105           bitval = value_bit_index (TYPE_FIELD_TYPE (type, field),
106                                     (TYPE_FIELD_BITPOS (type, field) / 8) +
107                                     valaddr + embedded_offset, i);
108           if (bitval < 0)
109             error (_("bit test is out of range"));
110           else if (bitval > 0)
111             {
112               previous_high = i;
113               if (! element_seen)
114                 {
115                   if (! empty_set)
116                     fprintf_filtered (stream, ", ");
117                   print_type_scalar (target, i, stream);
118                   empty_set    = 0;
119                   element_seen = 1;
120                   previous_low = i;
121                 }
122             }
123           else
124             {
125               /* bit is not set */
126               if (element_seen)
127                 {
128                   if (previous_low+1 < previous_high)
129                     fprintf_filtered (stream, "..");
130                   if (previous_low+1 < previous_high)
131                     print_type_scalar (target, previous_high, stream);
132                   element_seen = 0;
133                 }
134             }
135           if (i == field_high)
136             {
137               field++;
138               if (field == len)
139                 break;
140               range = TYPE_INDEX_TYPE (TYPE_FIELD_TYPE (type, field));
141               if (get_discrete_bounds (range, &field_low, &field_high) < 0)
142                 break;
143               target = TYPE_TARGET_TYPE (range);
144             }
145         }
146       if (element_seen)
147         {
148           if (previous_low+1 < previous_high)
149             {
150               fprintf_filtered (stream, "..");
151               print_type_scalar (target, previous_high, stream);
152             }
153           element_seen = 0;
154         }
155       fprintf_filtered (stream, "}");
156     }
157 }
158
159 static void
160 m2_print_unbounded_array (struct type *type, const gdb_byte *valaddr,
161                           int embedded_offset, CORE_ADDR address,
162                           struct ui_file *stream, int recurse,
163                           const struct value_print_options *options)
164 {
165   CORE_ADDR addr;
166   LONGEST len;
167   struct value *val;
168
169   type = check_typedef (type);
170
171   addr = unpack_pointer (TYPE_FIELD_TYPE (type, 0),
172                          (TYPE_FIELD_BITPOS (type, 0) / 8) +
173                          valaddr + embedded_offset);
174
175   val = value_at_lazy (TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type, 0)),
176                        addr);
177   len = unpack_field_as_long (type, valaddr + embedded_offset, 1);
178
179   fprintf_filtered (stream, "{");  
180   m2_print_array_contents (value_type (val),
181                            value_contents_for_printing (val),
182                            value_embedded_offset (val), addr, stream,
183                            recurse, val, options, len);
184   fprintf_filtered (stream, ", HIGH = %d}", (int) len);
185 }
186
187 static int
188 print_unpacked_pointer (struct type *type,
189                         CORE_ADDR address, CORE_ADDR addr,
190                         const struct value_print_options *options,
191                         struct ui_file *stream)
192 {
193   struct gdbarch *gdbarch = get_type_arch (type);
194   struct type *elttype = check_typedef (TYPE_TARGET_TYPE (type));
195   int want_space = 0;
196
197   if (TYPE_CODE (elttype) == TYPE_CODE_FUNC)
198     {
199       /* Try to print what function it points to.  */
200       print_function_pointer_address (options, gdbarch, addr, stream);
201       /* Return value is irrelevant except for string pointers.  */
202       return 0;
203     }
204
205   if (options->addressprint && options->format != 's')
206     {
207       fputs_filtered (paddress (gdbarch, address), stream);
208       want_space = 1;
209     }
210
211   /* For a pointer to char or unsigned char, also print the string
212      pointed to, unless pointer is null.  */
213
214   if (TYPE_LENGTH (elttype) == 1
215       && TYPE_CODE (elttype) == TYPE_CODE_INT
216       && (options->format == 0 || options->format == 's')
217       && addr != 0)
218     {
219       if (want_space)
220         fputs_filtered (" ", stream);
221       return val_print_string (TYPE_TARGET_TYPE (type), NULL, addr, -1,
222                                stream, options);
223     }
224   
225   return 0;
226 }
227
228 static void
229 print_variable_at_address (struct type *type,
230                            const gdb_byte *valaddr,
231                            struct ui_file *stream,
232                            int recurse,
233                            const struct value_print_options *options)
234 {
235   struct gdbarch *gdbarch = get_type_arch (type);
236   CORE_ADDR addr = unpack_pointer (type, valaddr);
237   struct type *elttype = check_typedef (TYPE_TARGET_TYPE (type));
238
239   fprintf_filtered (stream, "[");
240   fputs_filtered (paddress (gdbarch, addr), stream);
241   fprintf_filtered (stream, "] : ");
242   
243   if (TYPE_CODE (elttype) != TYPE_CODE_UNDEF)
244     {
245       struct value *deref_val =
246         value_at (TYPE_TARGET_TYPE (type), unpack_pointer (type, valaddr));
247
248       common_val_print (deref_val, stream, recurse, options, current_language);
249     }
250   else
251     fputs_filtered ("???", stream);
252 }
253
254
255 /* m2_print_array_contents - prints out the contents of an
256                              array up to a max_print values.
257                              It prints arrays of char as a string
258                              and all other data types as comma
259                              separated values.  */
260
261 static void
262 m2_print_array_contents (struct type *type, const gdb_byte *valaddr,
263                          int embedded_offset, CORE_ADDR address,
264                          struct ui_file *stream, int recurse,
265                          struct value *val,
266                          const struct value_print_options *options,
267                          int len)
268 {
269   type = check_typedef (type);
270
271   if (TYPE_LENGTH (type) > 0)
272     {
273       if (options->prettyformat_arrays)
274         print_spaces_filtered (2 + 2 * recurse, stream);
275       /* For an array of chars, print with string syntax.  */
276       if (TYPE_LENGTH (type) == 1 &&
277           ((TYPE_CODE (type) == TYPE_CODE_INT)
278            || ((current_language->la_language == language_m2)
279                && (TYPE_CODE (type) == TYPE_CODE_CHAR)))
280           && (options->format == 0 || options->format == 's'))
281         val_print_string (type, NULL, address, len+1, stream, options);
282       else
283         {
284           fprintf_filtered (stream, "{");
285           val_print_array_elements (type, embedded_offset,
286                                     address, stream, recurse, val,
287                                     options, 0);
288           fprintf_filtered (stream, "}");
289         }
290     }
291 }
292
293 /* Decorations for Modula 2.  */
294
295 static const struct generic_val_print_decorations m2_decorations =
296 {
297   "",
298   " + ",
299   " * I",
300   "TRUE",
301   "FALSE",
302   "void",
303   "{",
304   "}"
305 };
306
307 /* See val_print for a description of the various parameters of this
308    function; they are identical.  */
309
310 void
311 m2_val_print (struct type *type, int embedded_offset,
312               CORE_ADDR address, struct ui_file *stream, int recurse,
313               struct value *original_value,
314               const struct value_print_options *options)
315 {
316   unsigned len;
317   struct type *elttype;
318   CORE_ADDR addr;
319   const gdb_byte *valaddr = value_contents_for_printing (original_value);
320
321   type = check_typedef (type);
322   switch (TYPE_CODE (type))
323     {
324     case TYPE_CODE_ARRAY:
325       if (TYPE_LENGTH (type) > 0 && TYPE_LENGTH (TYPE_TARGET_TYPE (type)) > 0)
326         {
327           elttype = check_typedef (TYPE_TARGET_TYPE (type));
328           len = TYPE_LENGTH (type) / TYPE_LENGTH (elttype);
329           if (options->prettyformat_arrays)
330             print_spaces_filtered (2 + 2 * recurse, stream);
331           /* For an array of chars, print with string syntax.  */
332           if (TYPE_LENGTH (elttype) == 1 &&
333               ((TYPE_CODE (elttype) == TYPE_CODE_INT)
334                || ((current_language->la_language == language_m2)
335                    && (TYPE_CODE (elttype) == TYPE_CODE_CHAR)))
336               && (options->format == 0 || options->format == 's'))
337             {
338               /* If requested, look for the first null char and only print
339                  elements up to it.  */
340               if (options->stop_print_at_null)
341                 {
342                   unsigned int temp_len;
343
344                   /* Look for a NULL char.  */
345                   for (temp_len = 0;
346                        (valaddr + embedded_offset)[temp_len]
347                          && temp_len < len && temp_len < options->print_max;
348                        temp_len++);
349                   len = temp_len;
350                 }
351
352               LA_PRINT_STRING (stream, TYPE_TARGET_TYPE (type),
353                                valaddr + embedded_offset, len, NULL,
354                                0, options);
355             }
356           else
357             {
358               fprintf_filtered (stream, "{");
359               val_print_array_elements (type, embedded_offset,
360                                         address, stream,
361                                         recurse, original_value,
362                                         options, 0);
363               fprintf_filtered (stream, "}");
364             }
365           break;
366         }
367       /* Array of unspecified length: treat like pointer to first elt.  */
368       print_unpacked_pointer (type, address, address, options, stream);
369       break;
370
371     case TYPE_CODE_PTR:
372       if (TYPE_CONST (type))
373         print_variable_at_address (type, valaddr + embedded_offset,
374                                    stream, recurse, options);
375       else if (options->format && options->format != 's')
376         val_print_scalar_formatted (type, embedded_offset,
377                                     original_value, options, 0, stream);
378       else
379         {
380           addr = unpack_pointer (type, valaddr + embedded_offset);
381           print_unpacked_pointer (type, addr, address, options, stream);
382         }
383       break;
384
385     case TYPE_CODE_UNION:
386       if (recurse && !options->unionprint)
387         {
388           fprintf_filtered (stream, "{...}");
389           break;
390         }
391       /* Fall through.  */
392     case TYPE_CODE_STRUCT:
393       if (m2_is_long_set (type))
394         m2_print_long_set (type, valaddr, embedded_offset, address,
395                            stream);
396       else if (m2_is_unbounded_array (type))
397         m2_print_unbounded_array (type, valaddr, embedded_offset,
398                                   address, stream, recurse, options);
399       else
400         cp_print_value_fields (type, type, embedded_offset,
401                                address, stream, recurse, original_value,
402                                options, NULL, 0);
403       break;
404
405     case TYPE_CODE_SET:
406       elttype = TYPE_INDEX_TYPE (type);
407       elttype = check_typedef (elttype);
408       if (TYPE_STUB (elttype))
409         {
410           fprintf_filtered (stream, _("<incomplete type>"));
411           gdb_flush (stream);
412           break;
413         }
414       else
415         {
416           struct type *range = elttype;
417           LONGEST low_bound, high_bound;
418           int i;
419           int need_comma = 0;
420
421           fputs_filtered ("{", stream);
422
423           i = get_discrete_bounds (range, &low_bound, &high_bound);
424         maybe_bad_bstring:
425           if (i < 0)
426             {
427               fputs_filtered (_("<error value>"), stream);
428               goto done;
429             }
430
431           for (i = low_bound; i <= high_bound; i++)
432             {
433               int element = value_bit_index (type, valaddr + embedded_offset,
434                                              i);
435
436               if (element < 0)
437                 {
438                   i = element;
439                   goto maybe_bad_bstring;
440                 }
441               if (element)
442                 {
443                   if (need_comma)
444                     fputs_filtered (", ", stream);
445                   print_type_scalar (range, i, stream);
446                   need_comma = 1;
447
448                   if (i + 1 <= high_bound
449                       && value_bit_index (type, valaddr + embedded_offset,
450                                           ++i))
451                     {
452                       int j = i;
453
454                       fputs_filtered ("..", stream);
455                       while (i + 1 <= high_bound
456                              && value_bit_index (type,
457                                                  valaddr + embedded_offset,
458                                                  ++i))
459                         j = i;
460                       print_type_scalar (range, j, stream);
461                     }
462                 }
463             }
464         done:
465           fputs_filtered ("}", stream);
466         }
467       break;
468
469     case TYPE_CODE_RANGE:
470       if (TYPE_LENGTH (type) == TYPE_LENGTH (TYPE_TARGET_TYPE (type)))
471         {
472           m2_val_print (TYPE_TARGET_TYPE (type), embedded_offset,
473                         address, stream, recurse, original_value, options);
474           break;
475         }
476       /* FIXME: create_static_range_type does not set the unsigned bit in a
477          range type (I think it probably should copy it from the target
478          type), so we won't print values which are too large to
479          fit in a signed integer correctly.  */
480       /* FIXME: Doesn't handle ranges of enums correctly.  (Can't just
481          print with the target type, though, because the size of our type
482          and the target type might differ).  */
483       /* FALLTHROUGH */
484
485     case TYPE_CODE_REF:
486     case TYPE_CODE_ENUM:
487     case TYPE_CODE_FUNC:
488     case TYPE_CODE_INT:
489     case TYPE_CODE_FLT:
490     case TYPE_CODE_METHOD:
491     case TYPE_CODE_VOID:
492     case TYPE_CODE_ERROR:
493     case TYPE_CODE_UNDEF:
494     case TYPE_CODE_BOOL:
495     case TYPE_CODE_CHAR:
496     default:
497       generic_val_print (type, embedded_offset, address,
498                          stream, recurse, original_value, options,
499                          &m2_decorations);
500       break;
501     }
502   gdb_flush (stream);
503 }