gdb/cp-valprint.c

   1 /* Support for printing C++ values for GDB, the GNU debugger.
   2
   3    Copyright (C) 1986-2021 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 "gdb_obstack.h"
  22 #include "symtab.h"
  23 #include "gdbtypes.h"
  24 #include "expression.h"
  25 #include "value.h"
  26 #include "command.h"
  27 #include "gdbcmd.h"
  28 #include "demangle.h"
  29 #include "annotate.h"
  30 #include "c-lang.h"
  31 #include "target.h"
  32 #include "cp-abi.h"
  33 #include "valprint.h"
  34 #include "cp-support.h"
  35 #include "language.h"
  36 #include "extension.h"
  37 #include "typeprint.h"
  38 #include "gdbsupport/byte-vector.h"
  39 #include "gdbarch.h"
  40 #include "cli/cli-style.h"
  41
  42 static struct obstack dont_print_vb_obstack;
  43 static struct obstack dont_print_statmem_obstack;
  44 static struct obstack dont_print_stat_array_obstack;
  45
  46 static void cp_print_static_field (struct type *, struct value *,
  47                                    struct ui_file *, int,
  48                                    const struct value_print_options *);
  49
  50 static void cp_print_value (struct value *, struct ui_file *,
  51                             int, const struct value_print_options *,
  52                             struct type **);
  53
  54
  55 /* GCC versions after 2.4.5 use this.  */
  56 const char vtbl_ptr_name[] = "__vtbl_ptr_type";
  57
  58 /* Return truth value for assertion that TYPE is of the type
  59    "pointer to virtual function".  */
  60
  61 int
  62 cp_is_vtbl_ptr_type (struct type *type)
  63 {
  64   const char *type_name = type->name ();
  65
  66   return (type_name != NULL && !strcmp (type_name, vtbl_ptr_name));
  67 }
  68
  69 /* Return truth value for the assertion that TYPE is of the type
  70    "pointer to virtual function table".  */
  71
  72 int
  73 cp_is_vtbl_member (struct type *type)
  74 {
  75   /* With older versions of g++, the vtbl field pointed to an array of
  76      structures.  Nowadays it points directly to the structure.  */
  77   if (type->code () == TYPE_CODE_PTR)
  78     {
  79       type = TYPE_TARGET_TYPE (type);
  80       if (type->code () == TYPE_CODE_ARRAY)
  81         {
  82           type = TYPE_TARGET_TYPE (type);
  83           if (type->code () == TYPE_CODE_STRUCT    /* if not using thunks */
  84               || type->code () == TYPE_CODE_PTR)   /* if using thunks */
  85             {
  86               /* Virtual functions tables are full of pointers
  87                  to virtual functions.  */
  88               return cp_is_vtbl_ptr_type (type);
  89             }
  90         }
  91       else if (type->code () == TYPE_CODE_STRUCT)  /* if not using thunks */
  92         {
  93           return cp_is_vtbl_ptr_type (type);
  94         }
  95       else if (type->code () == TYPE_CODE_PTR)     /* if using thunks */
  96         {
  97           /* The type name of the thunk pointer is NULL when using
  98              dwarf2.  We could test for a pointer to a function, but
  99              there is no type info for the virtual table either, so it
 100              wont help.  */
 101           return cp_is_vtbl_ptr_type (type);
 102         }
 103     }
 104   return 0;
 105 }
 106
 107 /* Mutually recursive subroutines of cp_print_value and c_val_print to
 108    print out a structure's fields: cp_print_value_fields and
 109    cp_print_value.
 110
 111    TYPE, VALADDR, ADDRESS, STREAM, RECURSE, and OPTIONS have the same
 112    meanings as in cp_print_value and c_val_print.
 113
 114    2nd argument REAL_TYPE is used to carry over the type of the
 115    derived class across the recursion to base classes.
 116
 117    DONT_PRINT is an array of baseclass types that we should not print,
 118    or zero if called from top level.  */
 119
 120 void
 121 cp_print_value_fields (struct value *val, struct ui_file *stream,
 122                        int recurse, const struct value_print_options *options,
 123                        struct type **dont_print_vb,
 124                        int dont_print_statmem)
 125 {
 126   int i, len, n_baseclasses;
 127   int fields_seen = 0;
 128   static int last_set_recurse = -1;
 129
 130   struct type *type = check_typedef (value_type (val));
 131
 132   if (recurse == 0)
 133     {
 134       /* Any object can be left on obstacks only during an unexpected
 135          error.  */
 136
 137       if (obstack_object_size (&dont_print_statmem_obstack) > 0)
 138         {
 139           obstack_free (&dont_print_statmem_obstack, NULL);
 140           obstack_begin (&dont_print_statmem_obstack,
 141                          32 * sizeof (CORE_ADDR));
 142         }
 143       if (obstack_object_size (&dont_print_stat_array_obstack) > 0)
 144         {
 145           obstack_free (&dont_print_stat_array_obstack, NULL);
 146           obstack_begin (&dont_print_stat_array_obstack,
 147                          32 * sizeof (struct type *));
 148         }
 149     }
 150
 151   fprintf_filtered (stream, "{");
 152   len = type->num_fields ();
 153   n_baseclasses = TYPE_N_BASECLASSES (type);
 154
 155   /* First, print out baseclasses such that we don't print
 156      duplicates of virtual baseclasses.  */
 157
 158   if (n_baseclasses > 0)
 159     cp_print_value (val, stream, recurse + 1, options, dont_print_vb);
 160
 161   /* Second, print out data fields */
 162
 163   /* If there are no data fields, skip this part */
 164   if (len == n_baseclasses || !len)
 165     fprintf_styled (stream, metadata_style.style (), "<No data fields>");
 166   else
 167     {
 168       size_t statmem_obstack_initial_size = 0;
 169       size_t stat_array_obstack_initial_size = 0;
 170       struct type *vptr_basetype = NULL;
 171       int vptr_fieldno;
 172
 173       if (dont_print_statmem == 0)
 174         {
 175           statmem_obstack_initial_size =
 176             obstack_object_size (&dont_print_statmem_obstack);
 177
 178           if (last_set_recurse != recurse)
 179             {
 180               stat_array_obstack_initial_size =
 181                 obstack_object_size (&dont_print_stat_array_obstack);
 182
 183               last_set_recurse = recurse;
 184             }
 185         }
 186
 187       vptr_fieldno = get_vptr_fieldno (type, &vptr_basetype);
 188       for (i = n_baseclasses; i < len; i++)
 189         {
 190           const gdb_byte *valaddr = value_contents_for_printing (val);
 191
 192           /* If requested, skip printing of static fields.  */
 193           if (!options->static_field_print
 194               && field_is_static (&type->field (i)))
 195             continue;
 196
 197           if (fields_seen)
 198             {
 199               fputs_filtered (",", stream);
 200               if (!options->prettyformat)
 201                 fputs_filtered (" ", stream);
 202             }
 203           else if (n_baseclasses > 0)
 204             {
 205               if (options->prettyformat)
 206                 {
 207                   fprintf_filtered (stream, "\n");
 208                   print_spaces_filtered (2 + 2 * recurse, stream);
 209                   fputs_filtered ("members of ", stream);
 210                   fputs_filtered (type->name (), stream);
 211                   fputs_filtered (":", stream);
 212                 }
 213             }
 214           fields_seen = 1;
 215
 216           if (options->prettyformat)
 217             {
 218               fprintf_filtered (stream, "\n");
 219               print_spaces_filtered (2 + 2 * recurse, stream);
 220             }
 221           else
 222             {
 223               wrap_here (n_spaces (2 + 2 * recurse));
 224             }
 225
 226           annotate_field_begin (type->field (i).type ());
 227
 228           if (field_is_static (&type->field (i)))
 229             {
 230               fputs_filtered ("static ", stream);
 231               fprintf_symbol_filtered (stream,
 232                                        TYPE_FIELD_NAME (type, i),
 233                                        current_language->la_language,
 234                                        DMGL_PARAMS | DMGL_ANSI);
 235             }
 236           else
 237             fputs_styled (TYPE_FIELD_NAME (type, i),
 238                           variable_name_style.style (), stream);
 239           annotate_field_name_end ();
 240
 241           /* We tweak various options in a few cases below.  */
 242           value_print_options options_copy = *options;
 243           value_print_options *opts = &options_copy;
 244
 245           /* Do not print leading '=' in case of anonymous
 246              unions.  */
 247           if (strcmp (TYPE_FIELD_NAME (type, i), ""))
 248             fputs_filtered (" = ", stream);
 249           else
 250             {
 251               /* If this is an anonymous field then we want to consider it
 252                  as though it is at its parent's depth when it comes to the
 253                  max print depth.  */
 254               if (opts->max_depth != -1 && opts->max_depth < INT_MAX)
 255                 ++opts->max_depth;
 256             }
 257           annotate_field_value ();
 258
 259           if (!field_is_static (&type->field (i))
 260               && TYPE_FIELD_PACKED (type, i))
 261             {
 262               struct value *v;
 263
 264               /* Bitfields require special handling, especially due to
 265                  byte order problems.  */
 266               if (TYPE_FIELD_IGNORE (type, i))
 267                 {
 268                   fputs_styled ("<optimized out or zero length>",
 269                                 metadata_style.style (), stream);
 270                 }
 271               else if (value_bits_synthetic_pointer (val,
 272                                                      TYPE_FIELD_BITPOS (type,
 273                                                                         i),
 274                                                      TYPE_FIELD_BITSIZE (type,
 275                                                                          i)))
 276                 {
 277                   fputs_styled (_("<synthetic pointer>"),
 278                                 metadata_style.style (), stream);
 279                 }
 280               else
 281                 {
 282                   opts->deref_ref = 0;
 283
 284                   v = value_field_bitfield (type, i, valaddr,
 285                                             value_embedded_offset (val), val);
 286
 287                   common_val_print (v, stream, recurse + 1,
 288                                     opts, current_language);
 289                 }
 290             }
 291           else
 292             {
 293               if (TYPE_FIELD_IGNORE (type, i))
 294                 {
 295                   fputs_styled ("<optimized out or zero length>",
 296                                 metadata_style.style (), stream);
 297                 }
 298               else if (field_is_static (&type->field (i)))
 299                 {
 300                   try
 301                     {
 302                       struct value *v = value_static_field (type, i);
 303
 304                       cp_print_static_field (type->field (i).type (),
 305                                              v, stream, recurse + 1,
 306                                              opts);
 307                     }
 308                   catch (const gdb_exception_error &ex)
 309                     {
 310                       fprintf_styled (stream, metadata_style.style (),
 311                                       _("<error reading variable: %s>"),
 312                                       ex.what ());
 313                     }
 314                 }
 315               else if (i == vptr_fieldno && type == vptr_basetype)
 316                 {
 317                   int i_offset = TYPE_FIELD_BITPOS (type, i) / 8;
 318                   struct type *i_type = type->field (i).type ();
 319
 320                   if (valprint_check_validity (stream, i_type, i_offset, val))
 321                     {
 322                       CORE_ADDR addr;
 323
 324                       i_offset += value_embedded_offset (val);
 325                       addr = extract_typed_address (valaddr + i_offset, i_type);
 326                       print_function_pointer_address (opts,
 327                                                       type->arch (),
 328                                                       addr, stream);
 329                     }
 330                 }
 331               else
 332                 {
 333                   struct value *v = value_primitive_field (val, 0, i, type);
 334                   opts->deref_ref = 0;
 335                   common_val_print (v, stream, recurse + 1, opts,
 336                                     current_language);
 337                 }
 338             }
 339           annotate_field_end ();
 340         }
 341
 342       if (dont_print_statmem == 0)
 343         {
 344           size_t obstack_final_size =
 345            obstack_object_size (&dont_print_statmem_obstack);
 346
 347           if (obstack_final_size > statmem_obstack_initial_size)
 348             {
 349               /* In effect, a pop of the printed-statics stack.  */
 350               size_t shrink_bytes
 351                 = statmem_obstack_initial_size - obstack_final_size;
 352               obstack_blank_fast (&dont_print_statmem_obstack, shrink_bytes);
 353             }
 354
 355           if (last_set_recurse != recurse)
 356             {
 357               obstack_final_size =
 358                 obstack_object_size (&dont_print_stat_array_obstack);
 359
 360               if (obstack_final_size > stat_array_obstack_initial_size)
 361                 {
 362                   void *free_to_ptr =
 363                     (char *) obstack_next_free (&dont_print_stat_array_obstack)
 364                     - (obstack_final_size
 365                        - stat_array_obstack_initial_size);
 366
 367                   obstack_free (&dont_print_stat_array_obstack,
 368                                 free_to_ptr);
 369                 }
 370               last_set_recurse = -1;
 371             }
 372         }
 373
 374       if (options->prettyformat)
 375         {
 376           fprintf_filtered (stream, "\n");
 377           print_spaces_filtered (2 * recurse, stream);
 378         }
 379     }                           /* if there are data fields */
 380
 381   fprintf_filtered (stream, "}");
 382 }
 383
 384 /* Special val_print routine to avoid printing multiple copies of
 385    virtual baseclasses.  */
 386
 387 static void
 388 cp_print_value (struct value *val, struct ui_file *stream,
 389                 int recurse, const struct value_print_options *options,
 390                 struct type **dont_print_vb)
 391 {
 392   struct type *type = check_typedef (value_type (val));
 393   CORE_ADDR address = value_address (val);
 394   struct type **last_dont_print
 395     = (struct type **) obstack_next_free (&dont_print_vb_obstack);
 396   struct obstack tmp_obstack = dont_print_vb_obstack;
 397   int i, n_baseclasses = TYPE_N_BASECLASSES (type);
 398   const gdb_byte *valaddr = value_contents_for_printing (val);
 399
 400   if (dont_print_vb == 0)
 401     {
 402       /* If we're at top level, carve out a completely fresh chunk of
 403          the obstack and use that until this particular invocation
 404          returns.  */
 405       /* Bump up the high-water mark.  Now alpha is omega.  */
 406       obstack_finish (&dont_print_vb_obstack);
 407     }
 408
 409   for (i = 0; i < n_baseclasses; i++)
 410     {
 411       LONGEST boffset = 0;
 412       int skip = 0;
 413       struct type *baseclass = check_typedef (TYPE_BASECLASS (type, i));
 414       const char *basename = baseclass->name ();
 415       struct value *base_val = NULL;
 416
 417       if (BASETYPE_VIA_VIRTUAL (type, i))
 418         {
 419           struct type **first_dont_print
 420             = (struct type **) obstack_base (&dont_print_vb_obstack);
 421
 422           int j = (struct type **)
 423             obstack_next_free (&dont_print_vb_obstack) - first_dont_print;
 424
 425           while (--j >= 0)
 426             if (baseclass == first_dont_print[j])
 427               goto flush_it;
 428
 429           obstack_ptr_grow (&dont_print_vb_obstack, baseclass);
 430         }
 431
 432       try
 433         {
 434           boffset = baseclass_offset (type, i, valaddr,
 435                                       value_embedded_offset (val),
 436                                       address, val);
 437         }
 438       catch (const gdb_exception_error &ex)
 439         {
 440           if (ex.error == NOT_AVAILABLE_ERROR)
 441             skip = -1;
 442           else
 443             skip = 1;
 444         }
 445
 446       if (skip == 0)
 447         {
 448           if (BASETYPE_VIA_VIRTUAL (type, i))
 449             {
 450               /* The virtual base class pointer might have been
 451                  clobbered by the user program. Make sure that it
 452                  still points to a valid memory location.  */
 453
 454               if (boffset < 0 || boffset >= TYPE_LENGTH (type))
 455                 {
 456                   gdb::byte_vector buf (TYPE_LENGTH (baseclass));
 457
 458                   if (target_read_memory (address + boffset, buf.data (),
 459                                           TYPE_LENGTH (baseclass)) != 0)
 460                     skip = 1;
 461                   base_val = value_from_contents_and_address (baseclass,
 462                                                               buf.data (),
 463                                                               address + boffset);
 464                   baseclass = value_type (base_val);
 465                   boffset = 0;
 466                 }
 467               else
 468                 {
 469                   base_val = val;
 470                 }
 471             }
 472           else
 473             {
 474               base_val = val;
 475             }
 476         }
 477
 478       /* Now do the printing.  */
 479       if (options->prettyformat)
 480         {
 481           fprintf_filtered (stream, "\n");
 482           print_spaces_filtered (2 * recurse, stream);
 483         }
 484       fputs_filtered ("<", stream);
 485       /* Not sure what the best notation is in the case where there is
 486          no baseclass name.  */
 487       fputs_filtered (basename ? basename : "", stream);
 488       fputs_filtered ("> = ", stream);
 489
 490       if (skip < 0)
 491         val_print_unavailable (stream);
 492       else if (skip > 0)
 493         val_print_invalid_address (stream);
 494       else
 495         {
 496           int result = 0;
 497
 498           if (!val_print_check_max_depth (stream, recurse, options,
 499                                           current_language))
 500             {
 501               struct value *baseclass_val = value_primitive_field (val, 0,
 502                                                                    i, type);
 503
 504               /* Attempt to run an extension language pretty-printer on the
 505                  baseclass if possible.  */
 506               if (!options->raw)
 507                 result
 508                   = apply_ext_lang_val_pretty_printer (baseclass_val, stream,
 509                                                        recurse, options,
 510                                                        current_language);
 511
 512               if (!result)
 513                 cp_print_value_fields (baseclass_val, stream, recurse, options,
 514                                        ((struct type **)
 515                                         obstack_base (&dont_print_vb_obstack)),
 516                                        0);
 517             }
 518         }
 519       fputs_filtered (", ", stream);
 520
 521     flush_it:
 522       ;
 523     }
 524
 525   if (dont_print_vb == 0)
 526     {
 527       /* Free the space used to deal with the printing
 528          of this type from top level.  */
 529       obstack_free (&dont_print_vb_obstack, last_dont_print);
 530       /* Reset watermark so that we can continue protecting
 531          ourselves from whatever we were protecting ourselves.  */
 532       dont_print_vb_obstack = tmp_obstack;
 533     }
 534 }
 535
 536 /* Print value of a static member.  To avoid infinite recursion when
 537    printing a class that contains a static instance of the class, we
 538    keep the addresses of all printed static member classes in an
 539    obstack and refuse to print them more than once.
 540
 541    VAL contains the value to print, TYPE, STREAM, RECURSE, and OPTIONS
 542    have the same meanings as in c_val_print.  */
 543
 544 static void
 545 cp_print_static_field (struct type *type,
 546                        struct value *val,
 547                        struct ui_file *stream,
 548                        int recurse,
 549                        const struct value_print_options *options)
 550 {
 551   struct value_print_options opts;
 552
 553   if (value_entirely_optimized_out (val))
 554     {
 555       val_print_optimized_out (val, stream);
 556       return;
 557     }
 558
 559   struct type *real_type = check_typedef (type);
 560   if (real_type->code () == TYPE_CODE_STRUCT)
 561     {
 562       CORE_ADDR *first_dont_print;
 563       CORE_ADDR addr = value_address (val);
 564       int i;
 565
 566       first_dont_print
 567         = (CORE_ADDR *) obstack_base (&dont_print_statmem_obstack);
 568       i = obstack_object_size (&dont_print_statmem_obstack)
 569         / sizeof (CORE_ADDR);
 570
 571       while (--i >= 0)
 572         {
 573           if (addr == first_dont_print[i])
 574             {
 575               fputs_styled (_("<same as static member of an already"
 576                               " seen type>"),
 577                             metadata_style.style (), stream);
 578               return;
 579             }
 580         }
 581
 582       obstack_grow (&dont_print_statmem_obstack, (char *) &addr,
 583                     sizeof (CORE_ADDR));
 584       cp_print_value_fields (val, stream, recurse, options, NULL, 1);
 585       return;
 586     }
 587
 588   if (real_type->code () == TYPE_CODE_ARRAY)
 589     {
 590       struct type **first_dont_print;
 591       int i;
 592       struct type *target_type = TYPE_TARGET_TYPE (type);
 593
 594       first_dont_print
 595         = (struct type **) obstack_base (&dont_print_stat_array_obstack);
 596       i = obstack_object_size (&dont_print_stat_array_obstack)
 597         / sizeof (struct type *);
 598
 599       while (--i >= 0)
 600         {
 601           if (target_type == first_dont_print[i])
 602             {
 603               fputs_styled (_("<same as static member of an already"
 604                               " seen type>"),
 605                             metadata_style.style (), stream);
 606               return;
 607             }
 608         }
 609
 610       obstack_grow (&dont_print_stat_array_obstack,
 611                     (char *) &target_type,
 612                     sizeof (struct type *));
 613     }
 614
 615   opts = *options;
 616   opts.deref_ref = 0;
 617   common_val_print (val, stream, recurse, &opts, current_language);
 618 }
 619
 620 /* Find the field in *SELF, or its non-virtual base classes, with
 621    bit offset OFFSET.  Set *SELF to the containing type and *FIELDNO
 622    to the containing field number.  If OFFSET is not exactly at the
 623    start of some field, set *SELF to NULL.  */
 624
 625 static void
 626 cp_find_class_member (struct type **self_p, int *fieldno,
 627                       LONGEST offset)
 628 {
 629   struct type *self;
 630   unsigned int i;
 631   unsigned len;
 632
 633   *self_p = check_typedef (*self_p);
 634   self = *self_p;
 635   len = self->num_fields ();
 636
 637   for (i = TYPE_N_BASECLASSES (self); i < len; i++)
 638     {
 639       LONGEST bitpos = TYPE_FIELD_BITPOS (self, i);
 640
 641       QUIT;
 642       if (offset == bitpos)
 643         {
 644           *fieldno = i;
 645           return;
 646         }
 647     }
 648
 649   for (i = 0; i < TYPE_N_BASECLASSES (self); i++)
 650     {
 651       LONGEST bitpos = TYPE_FIELD_BITPOS (self, i);
 652       LONGEST bitsize = 8 * TYPE_LENGTH (self->field (i).type ());
 653
 654       if (offset >= bitpos && offset < bitpos + bitsize)
 655         {
 656           *self_p = self->field (i).type ();
 657           cp_find_class_member (self_p, fieldno, offset - bitpos);
 658           return;
 659         }
 660     }
 661
 662   *self_p = NULL;
 663 }
 664
 665 void
 666 cp_print_class_member (const gdb_byte *valaddr, struct type *type,
 667                        struct ui_file *stream, const char *prefix)
 668 {
 669   enum bfd_endian byte_order = type_byte_order (type);
 670
 671   /* VAL is a byte offset into the structure type SELF_TYPE.
 672      Find the name of the field for that offset and
 673      print it.  */
 674   struct type *self_type = TYPE_SELF_TYPE (type);
 675   LONGEST val;
 676   int fieldno;
 677
 678   val = extract_signed_integer (valaddr,
 679                                 TYPE_LENGTH (type),
 680                                 byte_order);
 681
 682   /* Pointers to data members are usually byte offsets into an object.
 683      Because a data member can have offset zero, and a NULL pointer to
 684      member must be distinct from any valid non-NULL pointer to
 685      member, either the value is biased or the NULL value has a
 686      special representation; both are permitted by ISO C++.  HP aCC
 687      used a bias of 0x20000000; HP cfront used a bias of 1; g++ 3.x
 688      and other compilers which use the Itanium ABI use -1 as the NULL
 689      value.  GDB only supports that last form; to add support for
 690      another form, make this into a cp-abi hook.  */
 691
 692   if (val == -1)
 693     {
 694       fprintf_filtered (stream, "NULL");
 695       return;
 696     }
 697
 698   cp_find_class_member (&self_type, &fieldno, val << 3);
 699
 700   if (self_type != NULL)
 701     {
 702       const char *name;
 703
 704       fputs_filtered (prefix, stream);
 705       name = self_type->name ();
 706       if (name)
 707         fputs_filtered (name, stream);
 708       else
 709         c_type_print_base (self_type, stream, 0, 0, &type_print_raw_options);
 710       fprintf_filtered (stream, "::");
 711       fputs_styled (TYPE_FIELD_NAME (self_type, fieldno),
 712                     variable_name_style.style (), stream);
 713     }
 714   else
 715     fprintf_filtered (stream, "%ld", (long) val);
 716 }
 717
 718
 719 void _initialize_cp_valprint ();
 720 void
 721 _initialize_cp_valprint ()
 722 {
 723   obstack_begin (&dont_print_stat_array_obstack,
 724                  32 * sizeof (struct type *));
 725   obstack_begin (&dont_print_statmem_obstack,
 726                  32 * sizeof (CORE_ADDR));
 727   obstack_begin (&dont_print_vb_obstack,
 728                  32 * sizeof (struct type *));
 729 }