gdb/typeprint.c

   1 /* Language independent support for printing types for GDB, the GNU debugger.
   2
   3    Copyright (C) 1986, 1988-1989, 1991-1995, 1998-2001, 2003, 2006-2012
   4    Free Software Foundation, Inc.
   5
   6    This file is part of GDB.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  20
  21 #include "defs.h"
  22 #include "gdb_obstack.h"
  23 #include "bfd.h"                /* Binary File Description */
  24 #include "symtab.h"
  25 #include "gdbtypes.h"
  26 #include "expression.h"
  27 #include "value.h"
  28 #include "gdbcore.h"
  29 #include "command.h"
  30 #include "gdbcmd.h"
  31 #include "target.h"
  32 #include "language.h"
  33 #include "cp-abi.h"
  34 #include "typeprint.h"
  35 #include "gdb_string.h"
  36 #include "exceptions.h"
  37 #include "valprint.h"
  38 #include <errno.h>
  39
  40 extern void _initialize_typeprint (void);
  41
  42 static void ptype_command (char *, int);
  43
  44 static void whatis_command (char *, int);
  45
  46 static void whatis_exp (char *, int);
  47
  48
  49 /* Print a description of a type in the format of a
  50    typedef for the current language.
  51    NEW is the new name for a type TYPE.  */
  52
  53 void
  54 typedef_print (struct type *type, struct symbol *new, struct ui_file *stream)
  55 {
  56   LA_PRINT_TYPEDEF (type, new, stream);
  57 }
  58
  59 /* The default way to print a typedef.  */
  60
  61 void
  62 default_print_typedef (struct type *type, struct symbol *new_symbol,
  63                        struct ui_file *stream)
  64 {
  65   error (_("Language not supported."));
  66 }
  67
  68 /* Print a description of a type TYPE in the form of a declaration of a
  69    variable named VARSTRING.  (VARSTRING is demangled if necessary.)
  70    Output goes to STREAM (via stdio).
  71    If SHOW is positive, we show the contents of the outermost level
  72    of structure even if there is a type name that could be used instead.
  73    If SHOW is negative, we never show the details of elements' types.  */
  74
  75 void
  76 type_print (struct type *type, const char *varstring, struct ui_file *stream,
  77             int show)
  78 {
  79   LA_PRINT_TYPE (type, varstring, stream, show, 0);
  80 }
  81
  82 /* Print TYPE to a string, returning it.  The caller is responsible for
  83    freeing the string.  */
  84
  85 char *
  86 type_to_string (struct type *type)
  87 {
  88   char *s = NULL;
  89   struct ui_file *stb;
  90   struct cleanup *old_chain;
  91   volatile struct gdb_exception except;
  92
  93   stb = mem_fileopen ();
  94   old_chain = make_cleanup_ui_file_delete (stb);
  95
  96   TRY_CATCH (except, RETURN_MASK_ALL)
  97     {
  98       type_print (type, "", stb, -1);
  99       s = ui_file_xstrdup (stb, NULL);
 100     }
 101   if (except.reason < 0)
 102     s = NULL;
 103
 104   do_cleanups (old_chain);
 105
 106   return s;
 107 }
 108
 109 /* Print type of EXP, or last thing in value history if EXP == NULL.
 110    show is passed to type_print.  */
 111
 112 static void
 113 whatis_exp (char *exp, int show)
 114 {
 115   struct expression *expr;
 116   struct value *val;
 117   struct cleanup *old_chain = NULL;
 118   struct type *real_type = NULL;
 119   struct type *type;
 120   int full = 0;
 121   int top = -1;
 122   int using_enc = 0;
 123   struct value_print_options opts;
 124
 125   if (exp)
 126     {
 127       expr = parse_expression (exp);
 128       old_chain = make_cleanup (free_current_contents, &expr);
 129       val = evaluate_type (expr);
 130     }
 131   else
 132     val = access_value_history (0);
 133
 134   type = value_type (val);
 135
 136   get_user_print_options (&opts);
 137   if (opts.objectprint)
 138     {
 139       if (((TYPE_CODE (type) == TYPE_CODE_PTR)
 140            || (TYPE_CODE (type) == TYPE_CODE_REF))
 141           && (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_CLASS))
 142         real_type = value_rtti_indirect_type (val, &full, &top, &using_enc);
 143       else if (TYPE_CODE (type) == TYPE_CODE_CLASS)
 144         real_type = value_rtti_type (val, &full, &top, &using_enc);
 145     }
 146
 147   printf_filtered ("type = ");
 148
 149   if (real_type)
 150     {
 151       printf_filtered ("/* real type = ");
 152       type_print (real_type, "", gdb_stdout, -1);
 153       if (! full)
 154         printf_filtered (" (incomplete object)");
 155       printf_filtered (" */\n");
 156     }
 157
 158   type_print (type, "", gdb_stdout, show);
 159   printf_filtered ("\n");
 160
 161   if (exp)
 162     do_cleanups (old_chain);
 163 }
 164
 165 static void
 166 whatis_command (char *exp, int from_tty)
 167 {
 168   /* Most of the time users do not want to see all the fields
 169      in a structure.  If they do they can use the "ptype" command.
 170      Hence the "-1" below.  */
 171   whatis_exp (exp, -1);
 172 }
 173
 174 /* TYPENAME is either the name of a type, or an expression.  */
 175
 176 static void
 177 ptype_command (char *typename, int from_tty)
 178 {
 179   whatis_exp (typename, 1);
 180 }
 181
 182 /* Print integral scalar data VAL, of type TYPE, onto stdio stream STREAM.
 183    Used to print data from type structures in a specified type.  For example,
 184    array bounds may be characters or booleans in some languages, and this
 185    allows the ranges to be printed in their "natural" form rather than as
 186    decimal integer values.
 187
 188    FIXME:  This is here simply because only the type printing routines
 189    currently use it, and it wasn't clear if it really belonged somewhere
 190    else (like printcmd.c).  There are a lot of other gdb routines that do
 191    something similar, but they are generally concerned with printing values
 192    that come from the inferior in target byte order and target size.  */
 193
 194 void
 195 print_type_scalar (struct type *type, LONGEST val, struct ui_file *stream)
 196 {
 197   unsigned int i;
 198   unsigned len;
 199
 200   CHECK_TYPEDEF (type);
 201
 202   switch (TYPE_CODE (type))
 203     {
 204
 205     case TYPE_CODE_ENUM:
 206       len = TYPE_NFIELDS (type);
 207       for (i = 0; i < len; i++)
 208         {
 209           if (TYPE_FIELD_ENUMVAL (type, i) == val)
 210             {
 211               break;
 212             }
 213         }
 214       if (i < len)
 215         {
 216           fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
 217         }
 218       else
 219         {
 220           print_longest (stream, 'd', 0, val);
 221         }
 222       break;
 223
 224     case TYPE_CODE_INT:
 225       print_longest (stream, TYPE_UNSIGNED (type) ? 'u' : 'd', 0, val);
 226       break;
 227
 228     case TYPE_CODE_CHAR:
 229       LA_PRINT_CHAR ((unsigned char) val, type, stream);
 230       break;
 231
 232     case TYPE_CODE_BOOL:
 233       fprintf_filtered (stream, val ? "TRUE" : "FALSE");
 234       break;
 235
 236     case TYPE_CODE_RANGE:
 237       print_type_scalar (TYPE_TARGET_TYPE (type), val, stream);
 238       return;
 239
 240     case TYPE_CODE_UNDEF:
 241     case TYPE_CODE_PTR:
 242     case TYPE_CODE_ARRAY:
 243     case TYPE_CODE_STRUCT:
 244     case TYPE_CODE_UNION:
 245     case TYPE_CODE_FUNC:
 246     case TYPE_CODE_FLT:
 247     case TYPE_CODE_VOID:
 248     case TYPE_CODE_SET:
 249     case TYPE_CODE_STRING:
 250     case TYPE_CODE_ERROR:
 251     case TYPE_CODE_MEMBERPTR:
 252     case TYPE_CODE_METHODPTR:
 253     case TYPE_CODE_METHOD:
 254     case TYPE_CODE_REF:
 255     case TYPE_CODE_NAMESPACE:
 256       error (_("internal error: unhandled type in print_type_scalar"));
 257       break;
 258
 259     default:
 260       error (_("Invalid type code in symbol table."));
 261     }
 262   gdb_flush (stream);
 263 }
 264
 265 /* Dump details of a type specified either directly or indirectly.
 266    Uses the same sort of type lookup mechanism as ptype_command()
 267    and whatis_command().  */
 268
 269 void
 270 maintenance_print_type (char *typename, int from_tty)
 271 {
 272   struct value *val;
 273   struct type *type;
 274   struct cleanup *old_chain;
 275   struct expression *expr;
 276
 277   if (typename != NULL)
 278     {
 279       expr = parse_expression (typename);
 280       old_chain = make_cleanup (free_current_contents, &expr);
 281       if (expr->elts[0].opcode == OP_TYPE)
 282         {
 283           /* The user expression names a type directly, just use that type.  */
 284           type = expr->elts[1].type;
 285         }
 286       else
 287         {
 288           /* The user expression may name a type indirectly by naming an
 289              object of that type.  Find that indirectly named type.  */
 290           val = evaluate_type (expr);
 291           type = value_type (val);
 292         }
 293       if (type != NULL)
 294         {
 295           recursive_dump_type (type, 0);
 296         }
 297       do_cleanups (old_chain);
 298     }
 299 }
 300 \f
 301
 302 void
 303 _initialize_typeprint (void)
 304 {
 305   add_com ("ptype", class_vars, ptype_command, _("\
 306 Print definition of type TYPE.\n\
 307 Argument may be a type name defined by typedef, or \"struct STRUCT-TAG\"\n\
 308 or \"class CLASS-NAME\" or \"union UNION-TAG\" or \"enum ENUM-TAG\".\n\
 309 The selected stack frame's lexical context is used to look up the name.\n\
 310 Contrary to \"whatis\", \"ptype\" always unrolls any typedefs."));
 311
 312   add_com ("whatis", class_vars, whatis_command,
 313            _("Print data type of expression EXP.\n\
 314 Only one level of typedefs is unrolled.  See also \"ptype\"."));
 315 }