gdb/cp-valprint.c

   1 /* Support for printing C++ values for GDB, the GNU debugger.
   2
   3    Copyright (C) 1986-2023 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 "gdbsupport/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 #include "gdbsupport/selftest.h"
  42 #include "selftest-arch.h"
  43
  44 static struct obstack dont_print_vb_obstack;
  45 static struct obstack dont_print_statmem_obstack;
  46 static struct obstack dont_print_stat_array_obstack;
  47
  48 static void cp_print_static_field (struct type *, struct value *,
  49                                    struct ui_file *, int,
  50                                    const struct value_print_options *);
  51
  52 static void cp_print_value (struct value *, struct ui_file *,
  53                             int, const struct value_print_options *,
  54                             struct type **);
  55
  56
  57 /* GCC versions after 2.4.5 use this.  */
  58 const char vtbl_ptr_name[] = "__vtbl_ptr_type";
  59
  60 /* Return truth value for assertion that TYPE is of the type
  61    "pointer to virtual function".  */
  62
  63 int
  64 cp_is_vtbl_ptr_type (struct type *type)
  65 {
  66   const char *type_name = type->name ();
  67
  68   return (type_name != NULL && !strcmp (type_name, vtbl_ptr_name));
  69 }
  70
  71 /* Return truth value for the assertion that TYPE is of the type
  72    "pointer to virtual function table".  */
  73
  74 int
  75 cp_is_vtbl_member (struct type *type)
  76 {
  77   /* With older versions of g++, the vtbl field pointed to an array of
  78      structures.  Nowadays it points directly to the structure.  */
  79   if (type->code () == TYPE_CODE_PTR)
  80     {
  81       type = type->target_type ();
  82       if (type->code () == TYPE_CODE_ARRAY)
  83         {
  84           type = type->target_type ();
  85           if (type->code () == TYPE_CODE_STRUCT    /* if not using thunks */
  86               || type->code () == TYPE_CODE_PTR)   /* if using thunks */
  87             {
  88               /* Virtual functions tables are full of pointers
  89                  to virtual functions.  */
  90               return cp_is_vtbl_ptr_type (type);
  91             }
  92         }
  93       else if (type->code () == TYPE_CODE_STRUCT)  /* if not using thunks */
  94         {
  95           return cp_is_vtbl_ptr_type (type);
  96         }
  97       else if (type->code () == TYPE_CODE_PTR)     /* if using thunks */
  98         {
  99           /* The type name of the thunk pointer is NULL when using
 100              dwarf2.  We could test for a pointer to a function, but
 101              there is no type info for the virtual table either, so it
 102              wont help.  */
 103           return cp_is_vtbl_ptr_type (type);
 104         }
 105     }
 106   return 0;
 107 }
 108
 109 /* Mutually recursive subroutines of cp_print_value and c_val_print to
 110    print out a structure's fields: cp_print_value_fields and
 111    cp_print_value.
 112
 113    TYPE, VALADDR, ADDRESS, STREAM, RECURSE, and OPTIONS have the same
 114    meanings as in cp_print_value and c_val_print.
 115
 116    2nd argument REAL_TYPE is used to carry over the type of the
 117    derived class across the recursion to base classes.
 118
 119    DONT_PRINT is an array of baseclass types that we should not print,
 120    or zero if called from top level.  */
 121
 122 void
 123 cp_print_value_fields (struct value *val, struct ui_file *stream,
 124                        int recurse, const struct value_print_options *options,
 125                        struct type **dont_print_vb,
 126                        int dont_print_statmem)
 127 {
 128   int i, len, n_baseclasses;
 129   int fields_seen = 0;
 130   static int last_set_recurse = -1;
 131
 132   struct type *type = check_typedef (value_type (val));
 133
 134   if (recurse == 0)
 135     {
 136       /* Any object can be left on obstacks only during an unexpected
 137          error.  */
 138
 139       if (obstack_object_size (&dont_print_statmem_obstack) > 0)
 140         {
 141           obstack_free (&dont_print_statmem_obstack, NULL);
 142           obstack_begin (&dont_print_statmem_obstack,
 143                          32 * sizeof (CORE_ADDR));
 144         }
 145       if (obstack_object_size (&dont_print_stat_array_obstack) > 0)
 146         {
 147           obstack_free (&dont_print_stat_array_obstack, NULL);
 148           obstack_begin (&dont_print_stat_array_obstack,
 149                          32 * sizeof (struct type *));
 150         }
 151     }
 152
 153   gdb_printf (stream, "{");
 154   len = type->num_fields ();
 155   n_baseclasses = TYPE_N_BASECLASSES (type);
 156
 157   /* First, print out baseclasses such that we don't print
 158      duplicates of virtual baseclasses.  */
 159
 160   if (n_baseclasses > 0)
 161     cp_print_value (val, stream, recurse + 1, options, dont_print_vb);
 162
 163   /* Second, print out data fields */
 164
 165   /* If there are no data fields, skip this part */
 166   if (len == n_baseclasses || !len)
 167     fprintf_styled (stream, metadata_style.style (), "<No data fields>");
 168   else
 169     {
 170       size_t statmem_obstack_initial_size = 0;
 171       size_t stat_array_obstack_initial_size = 0;
 172       struct type *vptr_basetype = NULL;
 173       int vptr_fieldno;
 174
 175       if (dont_print_statmem == 0)
 176         {
 177           statmem_obstack_initial_size =
 178             obstack_object_size (&dont_print_statmem_obstack);
 179
 180           if (last_set_recurse != recurse)
 181             {
 182               stat_array_obstack_initial_size =
 183                 obstack_object_size (&dont_print_stat_array_obstack);
 184
 185               last_set_recurse = recurse;
 186             }
 187         }
 188
 189       vptr_fieldno = get_vptr_fieldno (type, &vptr_basetype);
 190       for (i = n_baseclasses; i < len; i++)
 191         {
 192           const gdb_byte *valaddr = value_contents_for_printing (val).data ();
 193
 194           /* If requested, skip printing of static fields.  */
 195           if (!options->static_field_print
 196               && field_is_static (&type->field (i)))
 197             continue;
 198
 199           if (fields_seen)
 200             {
 201               gdb_puts (",", stream);
 202               if (!options->prettyformat)
 203                 gdb_puts (" ", stream);
 204             }
 205           else if (n_baseclasses > 0)
 206             {
 207               if (options->prettyformat)
 208                 {
 209                   gdb_printf (stream, "\n");
 210                   print_spaces (2 + 2 * recurse, stream);
 211                   gdb_puts ("members of ", stream);
 212                   gdb_puts (type->name (), stream);
 213                   gdb_puts (":", stream);
 214                 }
 215             }
 216           fields_seen = 1;
 217
 218           if (options->prettyformat)
 219             {
 220               gdb_printf (stream, "\n");
 221               print_spaces (2 + 2 * recurse, stream);
 222             }
 223           else
 224             {
 225               stream->wrap_here (2 + 2 * recurse);
 226             }
 227
 228           annotate_field_begin (type->field (i).type ());
 229
 230           if (field_is_static (&type->field (i)))
 231             {
 232               gdb_puts ("static ", stream);
 233               fprintf_symbol (stream,
 234                               type->field (i).name (),
 235                               current_language->la_language,
 236                               DMGL_PARAMS | DMGL_ANSI);
 237             }
 238           else
 239             fputs_styled (type->field (i).name (),
 240                           variable_name_style.style (), stream);
 241           annotate_field_name_end ();
 242
 243           /* We tweak various options in a few cases below.  */
 244           value_print_options options_copy = *options;
 245           value_print_options *opts = &options_copy;
 246
 247           /* Do not print leading '=' in case of anonymous
 248              unions.  */
 249           if (strcmp (type->field (i).name (), ""))
 250             gdb_puts (" = ", stream);
 251           else
 252             {
 253               /* If this is an anonymous field then we want to consider it
 254                  as though it is at its parent's depth when it comes to the
 255                  max print depth.  */
 256               if (opts->max_depth != -1 && opts->max_depth < INT_MAX)
 257                 ++opts->max_depth;
 258             }
 259           annotate_field_value ();
 260
 261           if (!field_is_static (&type->field (i))
 262               && TYPE_FIELD_PACKED (type, i))
 263             {
 264               struct value *v;
 265
 266               /* Bitfields require special handling, especially due to
 267                  byte order problems.  */
 268               if (TYPE_FIELD_IGNORE (type, i))
 269                 {
 270                   fputs_styled ("<optimized out or zero length>",
 271                                 metadata_style.style (), stream);
 272                 }
 273               else if (value_bits_synthetic_pointer
 274                          (val, type->field (i).loc_bitpos (),
 275                           TYPE_FIELD_BITSIZE (type, 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 (i).loc_bitpos () / 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           gdb_printf (stream, "\n");
 377           print_spaces (2 * recurse, stream);
 378         }
 379     }                           /* if there are data fields */
 380
 381   gdb_printf (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).data ();
 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 ())
 455                 {
 456                   gdb::byte_vector buf (baseclass->length ());
 457
 458                   if (target_read_memory (address + boffset, buf.data (),
 459                                           baseclass->length ()) != 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           gdb_printf (stream, "\n");
 482           print_spaces (2 * recurse, stream);
 483         }
 484       gdb_puts ("<", stream);
 485       /* Not sure what the best notation is in the case where there is
 486          no baseclass name.  */
 487       gdb_puts (basename ? basename : "", stream);
 488       gdb_puts ("> = ", 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       gdb_puts (", ", 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 ();
 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       field &f = self->field (i);
 640       if (field_is_static (&f))
 641         continue;
 642       LONGEST bitpos = f.loc_bitpos ();
 643
 644       QUIT;
 645       if (offset == bitpos)
 646         {
 647           *fieldno = i;
 648           return;
 649         }
 650     }
 651
 652   for (i = 0; i < TYPE_N_BASECLASSES (self); i++)
 653     {
 654       LONGEST bitpos = self->field (i).loc_bitpos ();
 655       LONGEST bitsize = 8 * self->field (i).type ()->length ();
 656
 657       if (offset >= bitpos && offset < bitpos + bitsize)
 658         {
 659           *self_p = self->field (i).type ();
 660           cp_find_class_member (self_p, fieldno, offset - bitpos);
 661           return;
 662         }
 663     }
 664
 665   *self_p = NULL;
 666 }
 667
 668 void
 669 cp_print_class_member (const gdb_byte *valaddr, struct type *type,
 670                        struct ui_file *stream, const char *prefix)
 671 {
 672   enum bfd_endian byte_order = type_byte_order (type);
 673
 674   /* VAL is a byte offset into the structure type SELF_TYPE.
 675      Find the name of the field for that offset and
 676      print it.  */
 677   struct type *self_type = TYPE_SELF_TYPE (type);
 678   LONGEST val;
 679   int fieldno;
 680
 681   val = extract_signed_integer (valaddr,
 682                                 type->length (),
 683                                 byte_order);
 684
 685   /* Pointers to data members are usually byte offsets into an object.
 686      Because a data member can have offset zero, and a NULL pointer to
 687      member must be distinct from any valid non-NULL pointer to
 688      member, either the value is biased or the NULL value has a
 689      special representation; both are permitted by ISO C++.  HP aCC
 690      used a bias of 0x20000000; HP cfront used a bias of 1; g++ 3.x
 691      and other compilers which use the Itanium ABI use -1 as the NULL
 692      value.  GDB only supports that last form; to add support for
 693      another form, make this into a cp-abi hook.  */
 694
 695   if (val == -1)
 696     {
 697       gdb_printf (stream, "NULL");
 698       return;
 699     }
 700
 701   cp_find_class_member (&self_type, &fieldno, val << 3);
 702
 703   if (self_type != NULL)
 704     {
 705       const char *name;
 706
 707       gdb_puts (prefix, stream);
 708       name = self_type->name ();
 709       if (name)
 710         gdb_puts (name, stream);
 711       else
 712         c_type_print_base (self_type, stream, 0, 0, &type_print_raw_options);
 713       gdb_printf (stream, "::");
 714       fputs_styled (self_type->field (fieldno).name (),
 715                     variable_name_style.style (), stream);
 716     }
 717   else
 718     gdb_printf (stream, "%ld", (long) val);
 719 }
 720
 721 #if GDB_SELF_TEST
 722
 723 /* Test printing of TYPE_CODE_STRUCT values.  */
 724
 725 static void
 726 test_print_fields (gdbarch *arch)
 727 {
 728   struct field *f;
 729   type *uint8_type = builtin_type (arch)->builtin_uint8;
 730   type *bool_type = builtin_type (arch)->builtin_bool;
 731   type *the_struct = arch_composite_type (arch, NULL, TYPE_CODE_STRUCT);
 732   the_struct->set_length (4);
 733
 734   /* Value:  1110 1001
 735      Fields: C-BB B-A- */
 736   if (gdbarch_byte_order (arch) == BFD_ENDIAN_LITTLE)
 737     {
 738       f = append_composite_type_field_raw (the_struct, "A", bool_type);
 739       f->set_loc_bitpos (1);
 740       FIELD_BITSIZE (*f) = 1;
 741       f = append_composite_type_field_raw (the_struct, "B", uint8_type);
 742       f->set_loc_bitpos (3);
 743       FIELD_BITSIZE (*f) = 3;
 744       f = append_composite_type_field_raw (the_struct, "C", bool_type);
 745       f->set_loc_bitpos (7);
 746       FIELD_BITSIZE (*f) = 1;
 747     }
 748   /* According to the logic commented in "make_gdb_type_struct ()" of
 749    * target-descriptions.c, bit positions are numbered differently for
 750    * little and big endians.  */
 751   else
 752     {
 753       f = append_composite_type_field_raw (the_struct, "A", bool_type);
 754       f->set_loc_bitpos (30);
 755       FIELD_BITSIZE (*f) = 1;
 756       f = append_composite_type_field_raw (the_struct, "B", uint8_type);
 757       f->set_loc_bitpos (26);
 758       FIELD_BITSIZE (*f) = 3;
 759       f = append_composite_type_field_raw (the_struct, "C", bool_type);
 760       f->set_loc_bitpos (24);
 761       FIELD_BITSIZE (*f) = 1;
 762     }
 763
 764   value *val = allocate_value (the_struct);
 765   gdb_byte *contents = value_contents_writeable (val).data ();
 766   store_unsigned_integer (contents, value_enclosing_type (val)->length (),
 767                           gdbarch_byte_order (arch), 0xe9);
 768
 769   string_file out;
 770   struct value_print_options opts;
 771   get_no_prettyformat_print_options (&opts);
 772   cp_print_value_fields(val, &out, 0, &opts, NULL, 0);
 773   SELF_CHECK (out.string () == "{A = false, B = 5, C = true}");
 774
 775   out.clear();
 776   opts.format = 'x';
 777   cp_print_value_fields(val, &out, 0, &opts, NULL, 0);
 778   SELF_CHECK (out.string () == "{A = 0x0, B = 0x5, C = 0x1}");
 779 }
 780
 781 #endif
 782
 783
 784 void _initialize_cp_valprint ();
 785 void
 786 _initialize_cp_valprint ()
 787 {
 788 #if GDB_SELF_TEST
 789   selftests::register_test_foreach_arch ("print-fields", test_print_fields);
 790 #endif
 791
 792   obstack_begin (&dont_print_stat_array_obstack,
 793                  32 * sizeof (struct type *));
 794   obstack_begin (&dont_print_statmem_obstack,
 795                  32 * sizeof (CORE_ADDR));
 796   obstack_begin (&dont_print_vb_obstack,
 797                  32 * sizeof (struct type *));
 798 }