gdb/m2-valprint.c - gdb

Global variables defined

Functions defined

Source code

  1. /* Support for printing Modula 2 values for GDB, the GNU debugger.

  3.    Copyright (C) 1986-2015 Free Software Foundation, Inc.

  5.    This file is part of GDB.

  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.

  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.

  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/>.  */

  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"

  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.                          const struct value *val,
  41.                          const struct value_print_options *options,
  42.                          int len);


  45. /* get_long_set_bounds - assigns the bounds of the long set to low and
  46.                          high.  */

  48. int
  49. ‌get_long_set_bounds (struct type *type, LONGEST *low, LONGEST *high)
  50. {
  51.   int len, i;

  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. }

  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;

  84.   CHECK_TYPEDEF (type);

  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.     }

  99.   target = TYPE_TARGET_TYPE (range);

  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. }

  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.   struct type *content_type;
  166.   CORE_ADDR addr;
  167.   LONGEST len;
  168.   struct value *val;

  170.   CHECK_TYPEDEF (type);
  171.   content_type = TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type, 0));

  173.   addr = unpack_pointer (TYPE_FIELD_TYPE (type, 0),
  174.                          (TYPE_FIELD_BITPOS (type, 0) / 8) +
  175.                          valaddr + embedded_offset);

  177.   val = value_at_lazy (TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type, 0)),
  178.                        addr);
  179.   len = unpack_field_as_long (type, valaddr + embedded_offset, 1);

  181.   fprintf_filtered (stream, "{");
  182.   m2_print_array_contents (value_type (val),
  183.                            value_contents_for_printing (val),
  184.                            value_embedded_offset (val), addr, stream,
  185.                            recurse, val, options, len);
  186.   fprintf_filtered (stream, ", HIGH = %d}", (int) len);
  187. }

  189. static int
  190. ‌print_unpacked_pointer (struct type *type,
  191.                         CORE_ADDR address, CORE_ADDR addr,
  192.                         const struct value_print_options *options,
  193.                         struct ui_file *stream)
  194. {
  195.   struct gdbarch *gdbarch = get_type_arch (type);
  196.   struct type *elttype = check_typedef (TYPE_TARGET_TYPE (type));
  197.   int want_space = 0;

  199.   if (TYPE_CODE (elttype) == TYPE_CODE_FUNC)
  200.     {
  201.       /* Try to print what function it points to.  */
  202.       print_function_pointer_address (options, gdbarch, addr, stream);
  203.       /* Return value is irrelevant except for string pointers.  */
  204.       return 0;
  205.     }

  207.   if (options->addressprint && options->format != 's')
  208.     {
  209.       fputs_filtered (paddress (gdbarch, address), stream);
  210.       want_space = 1;
  211.     }

  213.   /* For a pointer to char or unsigned char, also print the string
  214.      pointed to, unless pointer is null.  */

  216.   if (TYPE_LENGTH (elttype) == 1
  217.       && TYPE_CODE (elttype) == TYPE_CODE_INT
  218.       && (options->format == 0 || options->format == 's')
  219.       && addr != 0)
  220.     {
  221.       if (want_space)
  222.         fputs_filtered (" ", stream);
  223.       return val_print_string (TYPE_TARGET_TYPE (type), NULL, addr, -1,
  224.                                stream, options);
  225.     }

  227.   return 0;
  228. }

  230. static void
  231. ‌print_variable_at_address (struct type *type,
  232.                            const gdb_byte *valaddr,
  233.                            struct ui_file *stream,
  234.                            int recurse,
  235.                            const struct value_print_options *options)
  236. {
  237.   struct gdbarch *gdbarch = get_type_arch (type);
  238.   CORE_ADDR addr = unpack_pointer (type, valaddr);
  239.   struct type *elttype = check_typedef (TYPE_TARGET_TYPE (type));

  241.   fprintf_filtered (stream, "[");
  242.   fputs_filtered (paddress (gdbarch, addr), stream);
  243.   fprintf_filtered (stream, "] : ");

  245.   if (TYPE_CODE (elttype) != TYPE_CODE_UNDEF)
  246.     {
  247.       struct value *deref_val =
  248.         value_at (TYPE_TARGET_TYPE (type), unpack_pointer (type, valaddr));

  250.       common_val_print (deref_val, stream, recurse, options, current_language);
  251.     }
  252.   else
  253.     fputs_filtered ("???", stream);
  254. }


  257. /* m2_print_array_contents - prints out the contents of an
  258.                              array up to a max_print values.
  259.                              It prints arrays of char as a string
  260.                              and all other data types as comma
  261.                              separated values.  */

  263. static void
  264. ‌m2_print_array_contents (struct type *type, const gdb_byte *valaddr,
  265.                          int embedded_offset, CORE_ADDR address,
  266.                          struct ui_file *stream, int recurse,
  267.                          const struct value *val,
  268.                          const struct value_print_options *options,
  269.                          int len)
  270. {
  271.   CHECK_TYPEDEF (type);

  273.   if (TYPE_LENGTH (type) > 0)
  274.     {
  275.       if (options->prettyformat_arrays)
  276.         print_spaces_filtered (2 + 2 * recurse, stream);
  277.       /* For an array of chars, print with string syntax.  */
  278.       if (TYPE_LENGTH (type) == 1 &&
  279.           ((TYPE_CODE (type) == TYPE_CODE_INT)
  280.            || ((current_language->la_language == language_m2)
  281.                && (TYPE_CODE (type) == TYPE_CODE_CHAR)))
  282.           && (options->format == 0 || options->format == 's'))
  283.         val_print_string (type, NULL, address, len+1, stream, options);
  284.       else
  285.         {
  286.           fprintf_filtered (stream, "{");
  287.           val_print_array_elements (type, valaddr, embedded_offset,
  288.                                     address, stream, recurse, val,
  289.                                     options, 0);
  290.           fprintf_filtered (stream, "}");
  291.         }
  292.     }
  293. }

  295. /* Decorations for Modula 2.  */

  297. ‌static const struct generic_val_print_decorations m2_decorations =
  298. {
  299.   "",
  300.   " + ",
  301.   " * I",
  302.   "TRUE",
  303.   "FALSE",
  304.   "void"
  305. };

  307. /* See val_print for a description of the various parameters of this
  308.    function; they are identical.  */

  310. void
  311. ‌m2_val_print (struct type *type, const gdb_byte *valaddr, int embedded_offset,
  312.               CORE_ADDR address, struct ui_file *stream, int recurse,
  313.               const struct value *original_value,
  314.               const struct value_print_options *options)
  315. {
  316.   struct gdbarch *gdbarch = get_type_arch (type);
  317.   unsigned int i = 0;        /* Number of characters printed.  */
  318.   unsigned len;
  319.   struct type *elttype;
  320.   CORE_ADDR addr;

  322.   CHECK_TYPEDEF (type);
  323.   switch (TYPE_CODE (type))
  324.     {
  325.     case TYPE_CODE_ARRAY:
  326.       if (TYPE_LENGTH (type) > 0 && TYPE_LENGTH (TYPE_TARGET_TYPE (type)) > 0)
  327.         {
  328.           elttype = check_typedef (TYPE_TARGET_TYPE (type));
  329.           len = TYPE_LENGTH (type) / TYPE_LENGTH (elttype);
  330.           if (options->prettyformat_arrays)
  331.             print_spaces_filtered (2 + 2 * recurse, stream);
  332.           /* For an array of chars, print with string syntax.  */
  333.           if (TYPE_LENGTH (elttype) == 1 &&
  334.               ((TYPE_CODE (elttype) == TYPE_CODE_INT)
  335.                || ((current_language->la_language == language_m2)
  336.                    && (TYPE_CODE (elttype) == TYPE_CODE_CHAR)))
  337.               && (options->format == 0 || options->format == 's'))
  338.             {
  339.               /* If requested, look for the first null char and only print
  340.                  elements up to it.  */
  341.               if (options->stop_print_at_null)
  342.                 {
  343.                   unsigned int temp_len;

  345.                   /* Look for a NULL char.  */
  346.                   for (temp_len = 0;
  347.                        (valaddr + embedded_offset)[temp_len]
  348.                          && temp_len < len && temp_len < options->print_max;
  349.                        temp_len++);
  350.                   len = temp_len;
  351.                 }

  353.               LA_PRINT_STRING (stream, TYPE_TARGET_TYPE (type),
  354.                                valaddr + embedded_offset, len, NULL,
  355.                                0, options);
  356.               i = len;
  357.             }
  358.           else
  359.             {
  360.               fprintf_filtered (stream, "{");
  361.               val_print_array_elements (type, valaddr, embedded_offset,
  362.                                         address, stream,
  363.                                         recurse, original_value,
  364.                                         options, 0);
  365.               fprintf_filtered (stream, "}");
  366.             }
  367.           break;
  368.         }
  369.       /* Array of unspecified length: treat like pointer to first elt.  */
  370.       print_unpacked_pointer (type, address, address, options, stream);
  371.       break;

  373.     case TYPE_CODE_PTR:
  374.       if (TYPE_CONST (type))
  375.         print_variable_at_address (type, valaddr + embedded_offset,
  376.                                    stream, recurse, options);
  377.       else if (options->format && options->format != 's')
  378.         val_print_scalar_formatted (type, valaddr, embedded_offset,
  379.                                     original_value, options, 0, stream);
  380.       else
  381.         {
  382.           addr = unpack_pointer (type, valaddr + embedded_offset);
  383.           print_unpacked_pointer (type, addr, address, options, stream);
  384.         }
  385.       break;

  387.     case TYPE_CODE_UNION:
  388.       if (recurse && !options->unionprint)
  389.         {
  390.           fprintf_filtered (stream, "{...}");
  391.           break;
  392.         }
  393.       /* Fall through.  */
  394.     case TYPE_CODE_STRUCT:
  395.       if (m2_is_long_set (type))
  396.         m2_print_long_set (type, valaddr, embedded_offset, address,
  397.                            stream);
  398.       else if (m2_is_unbounded_array (type))
  399.         m2_print_unbounded_array (type, valaddr, embedded_offset,
  400.                                   address, stream, recurse, options);
  401.       else
  402.         cp_print_value_fields (type, type, valaddr, embedded_offset,
  403.                                address, stream, recurse, original_value,
  404.                                options, NULL, 0);
  405.       break;

  407.     case TYPE_CODE_SET:
  408.       elttype = TYPE_INDEX_TYPE (type);
  409.       CHECK_TYPEDEF (elttype);
  410.       if (TYPE_STUB (elttype))
  411.         {
  412.           fprintf_filtered (stream, _("<incomplete type>"));
  413.           gdb_flush (stream);
  414.           break;
  415.         }
  416.       else
  417.         {
  418.           struct type *range = elttype;
  419.           LONGEST low_bound, high_bound;
  420.           int i;
  421.           int need_comma = 0;

  423.           fputs_filtered ("{", stream);

  425.           i = get_discrete_bounds (range, &low_bound, &high_bound);
  426.         maybe_bad_bstring:
  427.           if (i < 0)
  428.             {
  429.               fputs_filtered (_("<error value>"), stream);
  430.               goto done;
  431.             }

  433.           for (i = low_bound; i <= high_bound; i++)
  434.             {
  435.               int element = value_bit_index (type, valaddr + embedded_offset,
  436.                                              i);

  438.               if (element < 0)
  439.                 {
  440.                   i = element;
  441.                   goto maybe_bad_bstring;
  442.                 }
  443.               if (element)
  444.                 {
  445.                   if (need_comma)
  446.                     fputs_filtered (", ", stream);
  447.                   print_type_scalar (range, i, stream);
  448.                   need_comma = 1;

  450.                   if (i + 1 <= high_bound
  451.                       && value_bit_index (type, valaddr + embedded_offset,
  452.                                           ++i))
  453.                     {
  454.                       int j = i;

  456.                       fputs_filtered ("..", stream);
  457.                       while (i + 1 <= high_bound
  458.                              && value_bit_index (type,
  459.                                                  valaddr + embedded_offset,
  460.                                                  ++i))
  461.                         j = i;
  462.                       print_type_scalar (range, j, stream);
  463.                     }
  464.                 }
  465.             }
  466.         done:
  467.           fputs_filtered ("}", stream);
  468.         }
  469.       break;

  471.     case TYPE_CODE_RANGE:
  472.       if (TYPE_LENGTH (type) == TYPE_LENGTH (TYPE_TARGET_TYPE (type)))
  473.         {
  474.           m2_val_print (TYPE_TARGET_TYPE (type), valaddr, embedded_offset,
  475.                         address, stream, recurse, original_value, options);
  476.           break;
  477.         }
  478.       /* FIXME: create_static_range_type does not set the unsigned bit in a
  479.          range type (I think it probably should copy it from the target
  480.          type), so we won't print values which are too large to
  481.          fit in a signed integer correctly.  */
  482.       /* FIXME: Doesn't handle ranges of enums correctly.  (Can't just
  483.          print with the target type, though, because the size of our type
  484.          and the target type might differ).  */
  485.       /* FALLTHROUGH */

  487.     case TYPE_CODE_REF:
  488.     case TYPE_CODE_ENUM:
  489.     case TYPE_CODE_FUNC:
  490.     case TYPE_CODE_INT:
  491.     case TYPE_CODE_FLT:
  492.     case TYPE_CODE_METHOD:
  493.     case TYPE_CODE_VOID:
  494.     case TYPE_CODE_ERROR:
  495.     case TYPE_CODE_UNDEF:
  496.     case TYPE_CODE_BOOL:
  497.     case TYPE_CODE_CHAR:
  498.     default:
  499.       generic_val_print (type, valaddr, embedded_offset, address,
  500.                          stream, recurse, original_value, options,
  501.                          &m2_decorations);
  502.       break;
  503.     }
  504.   gdb_flush (stream);
  505. }