1 /* Implementation of the GDB variable objects API. 2 3 Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 4 2009, 2010, 2011 Free Software Foundation, Inc. 5 6 This program is free software; you can redistribute it and/or modify 7 it under the terms of the GNU General Public License as published by 8 the Free Software Foundation; either version 3 of the License, or 9 (at your option) any later version. 10 11 This program is distributed in the hope that it will be useful, 12 but WITHOUT ANY WARRANTY; without even the implied warranty of 13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 GNU General Public License for more details. 15 16 You should have received a copy of the GNU General Public License 17 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 18 19 #include "defs.h" 20 #include "exceptions.h" 21 #include "value.h" 22 #include "expression.h" 23 #include "frame.h" 24 #include "language.h" 25 #include "wrapper.h" 26 #include "gdbcmd.h" 27 #include "block.h" 28 #include "valprint.h" 29 30 #include "gdb_assert.h" 31 #include "gdb_string.h" 32 #include "gdb_regex.h" 33 34 #include "varobj.h" 35 #include "vec.h" 36 #include "gdbthread.h" 37 #include "inferior.h" 38 39 #if HAVE_PYTHON 40 #include "python/python.h" 41 #include "python/python-internal.h" 42 #else 43 typedef int PyObject; 44 #endif 45 46 /* Non-zero if we want to see trace of varobj level stuff. */ 47 48 int varobjdebug = 0; 49 static void 50 show_varobjdebug (struct ui_file *file, int from_tty, 51 struct cmd_list_element *c, const char *value) 52 { 53 fprintf_filtered (file, _("Varobj debugging is %s.\n"), value); 54 } 55 56 /* String representations of gdb's format codes. */ 57 char *varobj_format_string[] = 58 { "natural", "binary", "decimal", "hexadecimal", "octal" }; 59 60 /* String representations of gdb's known languages. */ 61 char *varobj_language_string[] = { "unknown", "C", "C++", "Java" }; 62 63 /* True if we want to allow Python-based pretty-printing. */ 64 static int pretty_printing = 0; 65 66 void 67 varobj_enable_pretty_printing (void) 68 { 69 pretty_printing = 1; 70 } 71 72 /* Data structures */ 73 74 /* Every root variable has one of these structures saved in its 75 varobj. Members which must be free'd are noted. */ 76 struct varobj_root 77 { 78 79 /* Alloc'd expression for this parent. */ 80 struct expression *exp; 81 82 /* Block for which this expression is valid. */ 83 struct block *valid_block; 84 85 /* The frame for this expression. This field is set iff valid_block is 86 not NULL. */ 87 struct frame_id frame; 88 89 /* The thread ID that this varobj_root belong to. This field 90 is only valid if valid_block is not NULL. 91 When not 0, indicates which thread 'frame' belongs to. 92 When 0, indicates that the thread list was empty when the varobj_root 93 was created. */ 94 int thread_id; 95 96 /* If 1, the -var-update always recomputes the value in the 97 current thread and frame. Otherwise, variable object is 98 always updated in the specific scope/thread/frame. */ 99 int floating; 100 101 /* Flag that indicates validity: set to 0 when this varobj_root refers 102 to symbols that do not exist anymore. */ 103 int is_valid; 104 105 /* Language info for this variable and its children. */ 106 struct language_specific *lang; 107 108 /* The varobj for this root node. */ 109 struct varobj *rootvar; 110 111 /* Next root variable */ 112 struct varobj_root *next; 113 }; 114 115 /* Every variable in the system has a structure of this type defined 116 for it. This structure holds all information necessary to manipulate 117 a particular object variable. Members which must be freed are noted. */ 118 struct varobj 119 { 120 121 /* Alloc'd name of the variable for this object. If this variable is a 122 child, then this name will be the child's source name. 123 (bar, not foo.bar). */ 124 /* NOTE: This is the "expression". */ 125 char *name; 126 127 /* Alloc'd expression for this child. Can be used to create a 128 root variable corresponding to this child. */ 129 char *path_expr; 130 131 /* The alloc'd name for this variable's object. This is here for 132 convenience when constructing this object's children. */ 133 char *obj_name; 134 135 /* Index of this variable in its parent or -1. */ 136 int index; 137 138 /* The type of this variable. This can be NULL 139 for artifial variable objects -- currently, the "accessibility" 140 variable objects in C++. */ 141 struct type *type; 142 143 /* The value of this expression or subexpression. A NULL value 144 indicates there was an error getting this value. 145 Invariant: if varobj_value_is_changeable_p (this) is non-zero, 146 the value is either NULL, or not lazy. */ 147 struct value *value; 148 149 /* The number of (immediate) children this variable has. */ 150 int num_children; 151 152 /* If this object is a child, this points to its immediate parent. */ 153 struct varobj *parent; 154 155 /* Children of this object. */ 156 VEC (varobj_p) *children; 157 158 /* Whether the children of this varobj were requested. This field is 159 used to decide if dynamic varobj should recompute their children. 160 In the event that the frontend never asked for the children, we 161 can avoid that. */ 162 int children_requested; 163 164 /* Description of the root variable. Points to root variable for 165 children. */ 166 struct varobj_root *root; 167 168 /* The format of the output for this object. */ 169 enum varobj_display_formats format; 170 171 /* Was this variable updated via a varobj_set_value operation. */ 172 int updated; 173 174 /* Last print value. */ 175 char *print_value; 176 177 /* Is this variable frozen. Frozen variables are never implicitly 178 updated by -var-update * 179 or -var-update <direct-or-indirect-parent>. */ 180 int frozen; 181 182 /* Is the value of this variable intentionally not fetched? It is 183 not fetched if either the variable is frozen, or any parents is 184 frozen. */ 185 int not_fetched; 186 187 /* Sub-range of children which the MI consumer has requested. If 188 FROM < 0 or TO < 0, means that all children have been 189 requested. */ 190 int from; 191 int to; 192 193 /* The pretty-printer constructor. If NULL, then the default 194 pretty-printer will be looked up. If None, then no 195 pretty-printer will be installed. */ 196 PyObject *constructor; 197 198 /* The pretty-printer that has been constructed. If NULL, then a 199 new printer object is needed, and one will be constructed. */ 200 PyObject *pretty_printer; 201 202 /* The iterator returned by the printer's 'children' method, or NULL 203 if not available. */ 204 PyObject *child_iter; 205 206 /* We request one extra item from the iterator, so that we can 207 report to the caller whether there are more items than we have 208 already reported. However, we don't want to install this value 209 when we read it, because that will mess up future updates. So, 210 we stash it here instead. */ 211 PyObject *saved_item; 212 }; 213 214 struct cpstack 215 { 216 char *name; 217 struct cpstack *next; 218 }; 219 220 /* A list of varobjs */ 221 222 struct vlist 223 { 224 struct varobj *var; 225 struct vlist *next; 226 }; 227 228 /* Private function prototypes */ 229 230 /* Helper functions for the above subcommands. */ 231 232 static int delete_variable (struct cpstack **, struct varobj *, int); 233 234 static void delete_variable_1 (struct cpstack **, int *, 235 struct varobj *, int, int); 236 237 static int install_variable (struct varobj *); 238 239 static void uninstall_variable (struct varobj *); 240 241 static struct varobj *create_child (struct varobj *, int, char *); 242 243 static struct varobj * 244 create_child_with_value (struct varobj *parent, int index, const char *name, 245 struct value *value); 246 247 /* Utility routines */ 248 249 static struct varobj *new_variable (void); 250 251 static struct varobj *new_root_variable (void); 252 253 static void free_variable (struct varobj *var); 254 255 static struct cleanup *make_cleanup_free_variable (struct varobj *var); 256 257 static struct type *get_type (struct varobj *var); 258 259 static struct type *get_value_type (struct varobj *var); 260 261 static struct type *get_target_type (struct type *); 262 263 static enum varobj_display_formats variable_default_display (struct varobj *); 264 265 static void cppush (struct cpstack **pstack, char *name); 266 267 static char *cppop (struct cpstack **pstack); 268 269 static int install_new_value (struct varobj *var, struct value *value, 270 int initial); 271 272 /* Language-specific routines. */ 273 274 static enum varobj_languages variable_language (struct varobj *var); 275 276 static int number_of_children (struct varobj *); 277 278 static char *name_of_variable (struct varobj *); 279 280 static char *name_of_child (struct varobj *, int); 281 282 static struct value *value_of_root (struct varobj **var_handle, int *); 283 284 static struct value *value_of_child (struct varobj *parent, int index); 285 286 static char *my_value_of_variable (struct varobj *var, 287 enum varobj_display_formats format); 288 289 static char *value_get_print_value (struct value *value, 290 enum varobj_display_formats format, 291 struct varobj *var); 292 293 static int varobj_value_is_changeable_p (struct varobj *var); 294 295 static int is_root_p (struct varobj *var); 296 297 #if HAVE_PYTHON 298 299 static struct varobj *varobj_add_child (struct varobj *var, 300 const char *name, 301 struct value *value); 302 303 #endif /* HAVE_PYTHON */ 304 305 /* C implementation */ 306 307 static int c_number_of_children (struct varobj *var); 308 309 static char *c_name_of_variable (struct varobj *parent); 310 311 static char *c_name_of_child (struct varobj *parent, int index); 312 313 static char *c_path_expr_of_child (struct varobj *child); 314 315 static struct value *c_value_of_root (struct varobj **var_handle); 316 317 static struct value *c_value_of_child (struct varobj *parent, int index); 318 319 static struct type *c_type_of_child (struct varobj *parent, int index); 320 321 static char *c_value_of_variable (struct varobj *var, 322 enum varobj_display_formats format); 323 324 /* C++ implementation */ 325 326 static int cplus_number_of_children (struct varobj *var); 327 328 static void cplus_class_num_children (struct type *type, int children[3]); 329 330 static char *cplus_name_of_variable (struct varobj *parent); 331 332 static char *cplus_name_of_child (struct varobj *parent, int index); 333 334 static char *cplus_path_expr_of_child (struct varobj *child); 335 336 static struct value *cplus_value_of_root (struct varobj **var_handle); 337 338 static struct value *cplus_value_of_child (struct varobj *parent, int index); 339 340 static struct type *cplus_type_of_child (struct varobj *parent, int index); 341 342 static char *cplus_value_of_variable (struct varobj *var, 343 enum varobj_display_formats format); 344 345 /* Java implementation */ 346 347 static int java_number_of_children (struct varobj *var); 348 349 static char *java_name_of_variable (struct varobj *parent); 350 351 static char *java_name_of_child (struct varobj *parent, int index); 352 353 static char *java_path_expr_of_child (struct varobj *child); 354 355 static struct value *java_value_of_root (struct varobj **var_handle); 356 357 static struct value *java_value_of_child (struct varobj *parent, int index); 358 359 static struct type *java_type_of_child (struct varobj *parent, int index); 360 361 static char *java_value_of_variable (struct varobj *var, 362 enum varobj_display_formats format); 363 364 /* The language specific vector */ 365 366 struct language_specific 367 { 368 369 /* The language of this variable. */ 370 enum varobj_languages language; 371 372 /* The number of children of PARENT. */ 373 int (*number_of_children) (struct varobj * parent); 374 375 /* The name (expression) of a root varobj. */ 376 char *(*name_of_variable) (struct varobj * parent); 377 378 /* The name of the INDEX'th child of PARENT. */ 379 char *(*name_of_child) (struct varobj * parent, int index); 380 381 /* Returns the rooted expression of CHILD, which is a variable 382 obtain that has some parent. */ 383 char *(*path_expr_of_child) (struct varobj * child); 384 385 /* The ``struct value *'' of the root variable ROOT. */ 386 struct value *(*value_of_root) (struct varobj ** root_handle); 387 388 /* The ``struct value *'' of the INDEX'th child of PARENT. */ 389 struct value *(*value_of_child) (struct varobj * parent, int index); 390 391 /* The type of the INDEX'th child of PARENT. */ 392 struct type *(*type_of_child) (struct varobj * parent, int index); 393 394 /* The current value of VAR. */ 395 char *(*value_of_variable) (struct varobj * var, 396 enum varobj_display_formats format); 397 }; 398 399 /* Array of known source language routines. */ 400 static struct language_specific languages[vlang_end] = { 401 /* Unknown (try treating as C). */ 402 { 403 vlang_unknown, 404 c_number_of_children, 405 c_name_of_variable, 406 c_name_of_child, 407 c_path_expr_of_child, 408 c_value_of_root, 409 c_value_of_child, 410 c_type_of_child, 411 c_value_of_variable} 412 , 413 /* C */ 414 { 415 vlang_c, 416 c_number_of_children, 417 c_name_of_variable, 418 c_name_of_child, 419 c_path_expr_of_child, 420 c_value_of_root, 421 c_value_of_child, 422 c_type_of_child, 423 c_value_of_variable} 424 , 425 /* C++ */ 426 { 427 vlang_cplus, 428 cplus_number_of_children, 429 cplus_name_of_variable, 430 cplus_name_of_child, 431 cplus_path_expr_of_child, 432 cplus_value_of_root, 433 cplus_value_of_child, 434 cplus_type_of_child, 435 cplus_value_of_variable} 436 , 437 /* Java */ 438 { 439 vlang_java, 440 java_number_of_children, 441 java_name_of_variable, 442 java_name_of_child, 443 java_path_expr_of_child, 444 java_value_of_root, 445 java_value_of_child, 446 java_type_of_child, 447 java_value_of_variable} 448 }; 449 450 /* A little convenience enum for dealing with C++/Java. */ 451 enum vsections 452 { 453 v_public = 0, v_private, v_protected 454 }; 455 456 /* Private data */ 457 458 /* Mappings of varobj_display_formats enums to gdb's format codes. */ 459 static int format_code[] = { 0, 't', 'd', 'x', 'o' }; 460 461 /* Header of the list of root variable objects. */ 462 static struct varobj_root *rootlist; 463 464 /* Prime number indicating the number of buckets in the hash table. */ 465 /* A prime large enough to avoid too many colisions. */ 466 #define VAROBJ_TABLE_SIZE 227 467 468 /* Pointer to the varobj hash table (built at run time). */ 469 static struct vlist **varobj_table; 470 471 /* Is the variable X one of our "fake" children? */ 472 #define CPLUS_FAKE_CHILD(x) \ 473 ((x) != NULL && (x)->type == NULL && (x)->value == NULL) 474 475 476 /* API Implementation */ 477 static int 478 is_root_p (struct varobj *var) 479 { 480 return (var->root->rootvar == var); 481 } 482 483 #ifdef HAVE_PYTHON 484 /* Helper function to install a Python environment suitable for 485 use during operations on VAR. */ 486 struct cleanup * 487 varobj_ensure_python_env (struct varobj *var) 488 { 489 return ensure_python_env (var->root->exp->gdbarch, 490 var->root->exp->language_defn); 491 } 492 #endif 493 494 /* Creates a varobj (not its children). */ 495 496 /* Return the full FRAME which corresponds to the given CORE_ADDR 497 or NULL if no FRAME on the chain corresponds to CORE_ADDR. */ 498 499 static struct frame_info * 500 find_frame_addr_in_frame_chain (CORE_ADDR frame_addr) 501 { 502 struct frame_info *frame = NULL; 503 504 if (frame_addr == (CORE_ADDR) 0) 505 return NULL; 506 507 for (frame = get_current_frame (); 508 frame != NULL; 509 frame = get_prev_frame (frame)) 510 { 511 /* The CORE_ADDR we get as argument was parsed from a string GDB 512 output as $fp. This output got truncated to gdbarch_addr_bit. 513 Truncate the frame base address in the same manner before 514 comparing it against our argument. */ 515 CORE_ADDR frame_base = get_frame_base_address (frame); 516 int addr_bit = gdbarch_addr_bit (get_frame_arch (frame)); 517 518 if (addr_bit < (sizeof (CORE_ADDR) * HOST_CHAR_BIT)) 519 frame_base &= ((CORE_ADDR) 1 << addr_bit) - 1; 520 521 if (frame_base == frame_addr) 522 return frame; 523 } 524 525 return NULL; 526 } 527 528 struct varobj * 529 varobj_create (char *objname, 530 char *expression, CORE_ADDR frame, enum varobj_type type) 531 { 532 struct varobj *var; 533 struct cleanup *old_chain; 534 535 /* Fill out a varobj structure for the (root) variable being constructed. */ 536 var = new_root_variable (); 537 old_chain = make_cleanup_free_variable (var); 538 539 if (expression != NULL) 540 { 541 struct frame_info *fi; 542 struct frame_id old_id = null_frame_id; 543 struct block *block; 544 char *p; 545 enum varobj_languages lang; 546 struct value *value = NULL; 547 548 /* Parse and evaluate the expression, filling in as much of the 549 variable's data as possible. */ 550 551 if (has_stack_frames ()) 552 { 553 /* Allow creator to specify context of variable. */ 554 if ((type == USE_CURRENT_FRAME) || (type == USE_SELECTED_FRAME)) 555 fi = get_selected_frame (NULL); 556 else 557 /* FIXME: cagney/2002-11-23: This code should be doing a 558 lookup using the frame ID and not just the frame's 559 ``address''. This, of course, means an interface 560 change. However, with out that interface change ISAs, 561 such as the ia64 with its two stacks, won't work. 562 Similar goes for the case where there is a frameless 563 function. */ 564 fi = find_frame_addr_in_frame_chain (frame); 565 } 566 else 567 fi = NULL; 568 569 /* frame = -2 means always use selected frame. */ 570 if (type == USE_SELECTED_FRAME) 571 var->root->floating = 1; 572 573 block = NULL; 574 if (fi != NULL) 575 block = get_frame_block (fi, 0); 576 577 p = expression; 578 innermost_block = NULL; 579 /* Wrap the call to parse expression, so we can 580 return a sensible error. */ 581 if (!gdb_parse_exp_1 (&p, block, 0, &var->root->exp)) 582 { 583 return NULL; 584 } 585 586 /* Don't allow variables to be created for types. */ 587 if (var->root->exp->elts[0].opcode == OP_TYPE) 588 { 589 do_cleanups (old_chain); 590 fprintf_unfiltered (gdb_stderr, "Attempt to use a type name" 591 " as an expression.\n"); 592 return NULL; 593 } 594 595 var->format = variable_default_display (var); 596 var->root->valid_block = innermost_block; 597 var->name = xstrdup (expression); 598 /* For a root var, the name and the expr are the same. */ 599 var->path_expr = xstrdup (expression); 600 601 /* When the frame is different from the current frame, 602 we must select the appropriate frame before parsing 603 the expression, otherwise the value will not be current. 604 Since select_frame is so benign, just call it for all cases. */ 605 if (innermost_block) 606 { 607 /* User could specify explicit FRAME-ADDR which was not found but 608 EXPRESSION is frame specific and we would not be able to evaluate 609 it correctly next time. With VALID_BLOCK set we must also set 610 FRAME and THREAD_ID. */ 611 if (fi == NULL) 612 error (_("Failed to find the specified frame")); 613 614 var->root->frame = get_frame_id (fi); 615 var->root->thread_id = pid_to_thread_id (inferior_ptid); 616 old_id = get_frame_id (get_selected_frame (NULL)); 617 select_frame (fi); 618 } 619 620 /* We definitely need to catch errors here. 621 If evaluate_expression succeeds we got the value we wanted. 622 But if it fails, we still go on with a call to evaluate_type(). */ 623 if (!gdb_evaluate_expression (var->root->exp, &value)) 624 { 625 /* Error getting the value. Try to at least get the 626 right type. */ 627 struct value *type_only_value = evaluate_type (var->root->exp); 628 629 var->type = value_type (type_only_value); 630 } 631 else 632 var->type = value_type (value); 633 634 install_new_value (var, value, 1 /* Initial assignment */); 635 636 /* Set language info */ 637 lang = variable_language (var); 638 var->root->lang = &languages[lang]; 639 640 /* Set ourselves as our root. */ 641 var->root->rootvar = var; 642 643 /* Reset the selected frame. */ 644 if (frame_id_p (old_id)) 645 select_frame (frame_find_by_id (old_id)); 646 } 647 648 /* If the variable object name is null, that means this 649 is a temporary variable, so don't install it. */ 650 651 if ((var != NULL) && (objname != NULL)) 652 { 653 var->obj_name = xstrdup (objname); 654 655 /* If a varobj name is duplicated, the install will fail so 656 we must cleanup. */ 657 if (!install_variable (var)) 658 { 659 do_cleanups (old_chain); 660 return NULL; 661 } 662 } 663 664 discard_cleanups (old_chain); 665 return var; 666 } 667 668 /* Generates an unique name that can be used for a varobj. */ 669 670 char * 671 varobj_gen_name (void) 672 { 673 static int id = 0; 674 char *obj_name; 675 676 /* Generate a name for this object. */ 677 id++; 678 obj_name = xstrprintf ("var%d", id); 679 680 return obj_name; 681 } 682 683 /* Given an OBJNAME, returns the pointer to the corresponding varobj. Call 684 error if OBJNAME cannot be found. */ 685 686 struct varobj * 687 varobj_get_handle (char *objname) 688 { 689 struct vlist *cv; 690 const char *chp; 691 unsigned int index = 0; 692 unsigned int i = 1; 693 694 for (chp = objname; *chp; chp++) 695 { 696 index = (index + (i++ * (unsigned int) *chp)) % VAROBJ_TABLE_SIZE; 697 } 698 699 cv = *(varobj_table + index); 700 while ((cv != NULL) && (strcmp (cv->var->obj_name, objname) != 0)) 701 cv = cv->next; 702 703 if (cv == NULL) 704 error (_("Variable object not found")); 705 706 return cv->var; 707 } 708 709 /* Given the handle, return the name of the object. */ 710 711 char * 712 varobj_get_objname (struct varobj *var) 713 { 714 return var->obj_name; 715 } 716 717 /* Given the handle, return the expression represented by the object. */ 718 719 char * 720 varobj_get_expression (struct varobj *var) 721 { 722 return name_of_variable (var); 723 } 724 725 /* Deletes a varobj and all its children if only_children == 0, 726 otherwise deletes only the children; returns a malloc'ed list of 727 all the (malloc'ed) names of the variables that have been deleted 728 (NULL terminated). */ 729 730 int 731 varobj_delete (struct varobj *var, char ***dellist, int only_children) 732 { 733 int delcount; 734 int mycount; 735 struct cpstack *result = NULL; 736 char **cp; 737 738 /* Initialize a stack for temporary results. */ 739 cppush (&result, NULL); 740 741 if (only_children) 742 /* Delete only the variable children. */ 743 delcount = delete_variable (&result, var, 1 /* only the children */ ); 744 else 745 /* Delete the variable and all its children. */ 746 delcount = delete_variable (&result, var, 0 /* parent+children */ ); 747 748 /* We may have been asked to return a list of what has been deleted. */ 749 if (dellist != NULL) 750 { 751 *dellist = xmalloc ((delcount + 1) * sizeof (char *)); 752 753 cp = *dellist; 754 mycount = delcount; 755 *cp = cppop (&result); 756 while ((*cp != NULL) && (mycount > 0)) 757 { 758 mycount--; 759 cp++; 760 *cp = cppop (&result); 761 } 762 763 if (mycount || (*cp != NULL)) 764 warning (_("varobj_delete: assertion failed - mycount(=%d) <> 0"), 765 mycount); 766 } 767 768 return delcount; 769 } 770 771 #if HAVE_PYTHON 772 773 /* Convenience function for varobj_set_visualizer. Instantiate a 774 pretty-printer for a given value. */ 775 static PyObject * 776 instantiate_pretty_printer (PyObject *constructor, struct value *value) 777 { 778 PyObject *val_obj = NULL; 779 PyObject *printer; 780 781 val_obj = value_to_value_object (value); 782 if (! val_obj) 783 return NULL; 784 785 printer = PyObject_CallFunctionObjArgs (constructor, val_obj, NULL); 786 Py_DECREF (val_obj); 787 return printer; 788 } 789 790 #endif 791 792 /* Set/Get variable object display format. */ 793 794 enum varobj_display_formats 795 varobj_set_display_format (struct varobj *var, 796 enum varobj_display_formats format) 797 { 798 switch (format) 799 { 800 case FORMAT_NATURAL: 801 case FORMAT_BINARY: 802 case FORMAT_DECIMAL: 803 case FORMAT_HEXADECIMAL: 804 case FORMAT_OCTAL: 805 var->format = format; 806 break; 807 808 default: 809 var->format = variable_default_display (var); 810 } 811 812 if (varobj_value_is_changeable_p (var) 813 && var->value && !value_lazy (var->value)) 814 { 815 xfree (var->print_value); 816 var->print_value = value_get_print_value (var->value, var->format, var); 817 } 818 819 return var->format; 820 } 821 822 enum varobj_display_formats 823 varobj_get_display_format (struct varobj *var) 824 { 825 return var->format; 826 } 827 828 char * 829 varobj_get_display_hint (struct varobj *var) 830 { 831 char *result = NULL; 832 833 #if HAVE_PYTHON 834 struct cleanup *back_to = varobj_ensure_python_env (var); 835 836 if (var->pretty_printer) 837 result = gdbpy_get_display_hint (var->pretty_printer); 838 839 do_cleanups (back_to); 840 #endif 841 842 return result; 843 } 844 845 /* Return true if the varobj has items after TO, false otherwise. */ 846 847 int 848 varobj_has_more (struct varobj *var, int to) 849 { 850 if (VEC_length (varobj_p, var->children) > to) 851 return 1; 852 return ((to == -1 || VEC_length (varobj_p, var->children) == to) 853 && var->saved_item != NULL); 854 } 855 856 /* If the variable object is bound to a specific thread, that 857 is its evaluation can always be done in context of a frame 858 inside that thread, returns GDB id of the thread -- which 859 is always positive. Otherwise, returns -1. */ 860 int 861 varobj_get_thread_id (struct varobj *var) 862 { 863 if (var->root->valid_block && var->root->thread_id > 0) 864 return var->root->thread_id; 865 else 866 return -1; 867 } 868 869 void 870 varobj_set_frozen (struct varobj *var, int frozen) 871 { 872 /* When a variable is unfrozen, we don't fetch its value. 873 The 'not_fetched' flag remains set, so next -var-update 874 won't complain. 875 876 We don't fetch the value, because for structures the client 877 should do -var-update anyway. It would be bad to have different 878 client-size logic for structure and other types. */ 879 var->frozen = frozen; 880 } 881 882 int 883 varobj_get_frozen (struct varobj *var) 884 { 885 return var->frozen; 886 } 887 888 /* A helper function that restricts a range to what is actually 889 available in a VEC. This follows the usual rules for the meaning 890 of FROM and TO -- if either is negative, the entire range is 891 used. */ 892 893 static void 894 restrict_range (VEC (varobj_p) *children, int *from, int *to) 895 { 896 if (*from < 0 || *to < 0) 897 { 898 *from = 0; 899 *to = VEC_length (varobj_p, children); 900 } 901 else 902 { 903 if (*from > VEC_length (varobj_p, children)) 904 *from = VEC_length (varobj_p, children); 905 if (*to > VEC_length (varobj_p, children)) 906 *to = VEC_length (varobj_p, children); 907 if (*from > *to) 908 *from = *to; 909 } 910 } 911 912 #if HAVE_PYTHON 913 914 /* A helper for update_dynamic_varobj_children that installs a new 915 child when needed. */ 916 917 static void 918 install_dynamic_child (struct varobj *var, 919 VEC (varobj_p) **changed, 920 VEC (varobj_p) **new, 921 VEC (varobj_p) **unchanged, 922 int *cchanged, 923 int index, 924 const char *name, 925 struct value *value) 926 { 927 if (VEC_length (varobj_p, var->children) < index + 1) 928 { 929 /* There's no child yet. */ 930 struct varobj *child = varobj_add_child (var, name, value); 931 932 if (new) 933 { 934 VEC_safe_push (varobj_p, *new, child); 935 *cchanged = 1; 936 } 937 } 938 else 939 { 940 varobj_p existing = VEC_index (varobj_p, var->children, index); 941 942 if (install_new_value (existing, value, 0)) 943 { 944 if (changed) 945 VEC_safe_push (varobj_p, *changed, existing); 946 } 947 else if (unchanged) 948 VEC_safe_push (varobj_p, *unchanged, existing); 949 } 950 } 951 952 static int 953 dynamic_varobj_has_child_method (struct varobj *var) 954 { 955 struct cleanup *back_to; 956 PyObject *printer = var->pretty_printer; 957 int result; 958 959 back_to = varobj_ensure_python_env (var); 960 result = PyObject_HasAttr (printer, gdbpy_children_cst); 961 do_cleanups (back_to); 962 return result; 963 } 964 965 #endif 966 967 static int 968 update_dynamic_varobj_children (struct varobj *var, 969 VEC (varobj_p) **changed, 970 VEC (varobj_p) **new, 971 VEC (varobj_p) **unchanged, 972 int *cchanged, 973 int update_children, 974 int from, 975 int to) 976 { 977 #if HAVE_PYTHON 978 struct cleanup *back_to; 979 PyObject *children; 980 int i; 981 PyObject *printer = var->pretty_printer; 982 983 back_to = varobj_ensure_python_env (var); 984 985 *cchanged = 0; 986 if (!PyObject_HasAttr (printer, gdbpy_children_cst)) 987 { 988 do_cleanups (back_to); 989 return 0; 990 } 991 992 if (update_children || !var->child_iter) 993 { 994 children = PyObject_CallMethodObjArgs (printer, gdbpy_children_cst, 995 NULL); 996 997 if (!children) 998 { 999 gdbpy_print_stack (); 1000 error (_("Null value returned for children")); 1001 } 1002 1003 make_cleanup_py_decref (children); 1004 1005 if (!PyIter_Check (children)) 1006 error (_("Returned value is not iterable")); 1007 1008 Py_XDECREF (var->child_iter); 1009 var->child_iter = PyObject_GetIter (children); 1010 if (!var->child_iter) 1011 { 1012 gdbpy_print_stack (); 1013 error (_("Could not get children iterator")); 1014 } 1015 1016 Py_XDECREF (var->saved_item); 1017 var->saved_item = NULL; 1018 1019 i = 0; 1020 } 1021 else 1022 i = VEC_length (varobj_p, var->children); 1023 1024 /* We ask for one extra child, so that MI can report whether there 1025 are more children. */ 1026 for (; to < 0 || i < to + 1; ++i) 1027 { 1028 PyObject *item; 1029 int force_done = 0; 1030 1031 /* See if there was a leftover from last time. */ 1032 if (var->saved_item) 1033 { 1034 item = var->saved_item; 1035 var->saved_item = NULL; 1036 } 1037 else 1038 item = PyIter_Next (var->child_iter); 1039 1040 if (!item) 1041 { 1042 /* Normal end of iteration. */ 1043 if (!PyErr_Occurred ()) 1044 break; 1045 1046 /* If we got a memory error, just use the text as the 1047 item. */ 1048 if (PyErr_ExceptionMatches (gdbpy_gdb_memory_error)) 1049 { 1050 PyObject *type, *value, *trace; 1051 char *name_str, *value_str; 1052 1053 PyErr_Fetch (&type, &value, &trace); 1054 value_str = gdbpy_exception_to_string (type, value); 1055 Py_XDECREF (type); 1056 Py_XDECREF (value); 1057 Py_XDECREF (trace); 1058 if (!value_str) 1059 { 1060 gdbpy_print_stack (); 1061 break; 1062 } 1063 1064 name_str = xstrprintf ("<error at %d>", i); 1065 item = Py_BuildValue ("(ss)", name_str, value_str); 1066 xfree (name_str); 1067 xfree (value_str); 1068 if (!item) 1069 { 1070 gdbpy_print_stack (); 1071 break; 1072 } 1073 1074 force_done = 1; 1075 } 1076 else 1077 { 1078 /* Any other kind of error. */ 1079 gdbpy_print_stack (); 1080 break; 1081 } 1082 } 1083 1084 /* We don't want to push the extra child on any report list. */ 1085 if (to < 0 || i < to) 1086 { 1087 PyObject *py_v; 1088 char *name; 1089 struct value *v; 1090 struct cleanup *inner; 1091 int can_mention = from < 0 || i >= from; 1092 1093 inner = make_cleanup_py_decref (item); 1094 1095 if (!PyArg_ParseTuple (item, "sO", &name, &py_v)) 1096 { 1097 gdbpy_print_stack (); 1098 error (_("Invalid item from the child list")); 1099 } 1100 1101 v = convert_value_from_python (py_v); 1102 if (v == NULL) 1103 gdbpy_print_stack (); 1104 install_dynamic_child (var, can_mention ? changed : NULL, 1105 can_mention ? new : NULL, 1106 can_mention ? unchanged : NULL, 1107 can_mention ? cchanged : NULL, i, name, v); 1108 do_cleanups (inner); 1109 } 1110 else 1111 { 1112 Py_XDECREF (var->saved_item); 1113 var->saved_item = item; 1114 1115 /* We want to truncate the child list just before this 1116 element. */ 1117 break; 1118 } 1119 1120 if (force_done) 1121 break; 1122 } 1123 1124 if (i < VEC_length (varobj_p, var->children)) 1125 { 1126 int j; 1127 1128 *cchanged = 1; 1129 for (j = i; j < VEC_length (varobj_p, var->children); ++j) 1130 varobj_delete (VEC_index (varobj_p, var->children, j), NULL, 0); 1131 VEC_truncate (varobj_p, var->children, i); 1132 } 1133 1134 /* If there are fewer children than requested, note that the list of 1135 children changed. */ 1136 if (to >= 0 && VEC_length (varobj_p, var->children) < to) 1137 *cchanged = 1; 1138 1139 var->num_children = VEC_length (varobj_p, var->children); 1140 1141 do_cleanups (back_to); 1142 1143 return 1; 1144 #else 1145 gdb_assert (0 && "should never be called if Python is not enabled"); 1146 #endif 1147 } 1148 1149 int 1150 varobj_get_num_children (struct varobj *var) 1151 { 1152 if (var->num_children == -1) 1153 { 1154 if (var->pretty_printer) 1155 { 1156 int dummy; 1157 1158 /* If we have a dynamic varobj, don't report -1 children. 1159 So, try to fetch some children first. */ 1160 update_dynamic_varobj_children (var, NULL, NULL, NULL, &dummy, 1161 0, 0, 0); 1162 } 1163 else 1164 var->num_children = number_of_children (var); 1165 } 1166 1167 return var->num_children >= 0 ? var->num_children : 0; 1168 } 1169 1170 /* Creates a list of the immediate children of a variable object; 1171 the return code is the number of such children or -1 on error. */ 1172 1173 VEC (varobj_p)* 1174 varobj_list_children (struct varobj *var, int *from, int *to) 1175 { 1176 char *name; 1177 int i, children_changed; 1178 1179 var->children_requested = 1; 1180 1181 if (var->pretty_printer) 1182 { 1183 /* This, in theory, can result in the number of children changing without 1184 frontend noticing. But well, calling -var-list-children on the same 1185 varobj twice is not something a sane frontend would do. */ 1186 update_dynamic_varobj_children (var, NULL, NULL, NULL, &children_changed, 1187 0, 0, *to); 1188 restrict_range (var->children, from, to); 1189 return var->children; 1190 } 1191 1192 if (var->num_children == -1) 1193 var->num_children = number_of_children (var); 1194 1195 /* If that failed, give up. */ 1196 if (var->num_children == -1) 1197 return var->children; 1198 1199 /* If we're called when the list of children is not yet initialized, 1200 allocate enough elements in it. */ 1201 while (VEC_length (varobj_p, var->children) < var->num_children) 1202 VEC_safe_push (varobj_p, var->children, NULL); 1203 1204 for (i = 0; i < var->num_children; i++) 1205 { 1206 varobj_p existing = VEC_index (varobj_p, var->children, i); 1207 1208 if (existing == NULL) 1209 { 1210 /* Either it's the first call to varobj_list_children for 1211 this variable object, and the child was never created, 1212 or it was explicitly deleted by the client. */ 1213 name = name_of_child (var, i); 1214 existing = create_child (var, i, name); 1215 VEC_replace (varobj_p, var->children, i, existing); 1216 } 1217 } 1218 1219 restrict_range (var->children, from, to); 1220 return var->children; 1221 } 1222 1223 #if HAVE_PYTHON 1224 1225 static struct varobj * 1226 varobj_add_child (struct varobj *var, const char *name, struct value *value) 1227 { 1228 varobj_p v = create_child_with_value (var, 1229 VEC_length (varobj_p, var->children), 1230 name, value); 1231 1232 VEC_safe_push (varobj_p, var->children, v); 1233 return v; 1234 } 1235 1236 #endif /* HAVE_PYTHON */ 1237 1238 /* Obtain the type of an object Variable as a string similar to the one gdb 1239 prints on the console. */ 1240 1241 char * 1242 varobj_get_type (struct varobj *var) 1243 { 1244 /* For the "fake" variables, do not return a type. (It's type is 1245 NULL, too.) 1246 Do not return a type for invalid variables as well. */ 1247 if (CPLUS_FAKE_CHILD (var) || !var->root->is_valid) 1248 return NULL; 1249 1250 return type_to_string (var->type); 1251 } 1252 1253 /* Obtain the type of an object variable. */ 1254 1255 struct type * 1256 varobj_get_gdb_type (struct varobj *var) 1257 { 1258 return var->type; 1259 } 1260 1261 /* Return a pointer to the full rooted expression of varobj VAR. 1262 If it has not been computed yet, compute it. */ 1263 char * 1264 varobj_get_path_expr (struct varobj *var) 1265 { 1266 if (var->path_expr != NULL) 1267 return var->path_expr; 1268 else 1269 { 1270 /* For root varobjs, we initialize path_expr 1271 when creating varobj, so here it should be 1272 child varobj. */ 1273 gdb_assert (!is_root_p (var)); 1274 return (*var->root->lang->path_expr_of_child) (var); 1275 } 1276 } 1277 1278 enum varobj_languages 1279 varobj_get_language (struct varobj *var) 1280 { 1281 return variable_language (var); 1282 } 1283 1284 int 1285 varobj_get_attributes (struct varobj *var) 1286 { 1287 int attributes = 0; 1288 1289 if (varobj_editable_p (var)) 1290 /* FIXME: define masks for attributes. */ 1291 attributes |= 0x00000001; /* Editable */ 1292 1293 return attributes; 1294 } 1295 1296 int 1297 varobj_pretty_printed_p (struct varobj *var) 1298 { 1299 return var->pretty_printer != NULL; 1300 } 1301 1302 char * 1303 varobj_get_formatted_value (struct varobj *var, 1304 enum varobj_display_formats format) 1305 { 1306 return my_value_of_variable (var, format); 1307 } 1308 1309 char * 1310 varobj_get_value (struct varobj *var) 1311 { 1312 return my_value_of_variable (var, var->format); 1313 } 1314 1315 /* Set the value of an object variable (if it is editable) to the 1316 value of the given expression. */ 1317 /* Note: Invokes functions that can call error(). */ 1318 1319 int 1320 varobj_set_value (struct varobj *var, char *expression) 1321 { 1322 struct value *val; 1323 1324 /* The argument "expression" contains the variable's new value. 1325 We need to first construct a legal expression for this -- ugh! */ 1326 /* Does this cover all the bases? */ 1327 struct expression *exp; 1328 struct value *value; 1329 int saved_input_radix = input_radix; 1330 char *s = expression; 1331 1332 gdb_assert (varobj_editable_p (var)); 1333 1334 input_radix = 10; /* ALWAYS reset to decimal temporarily. */ 1335 exp = parse_exp_1 (&s, 0, 0); 1336 if (!gdb_evaluate_expression (exp, &value)) 1337 { 1338 /* We cannot proceed without a valid expression. */ 1339 xfree (exp); 1340 return 0; 1341 } 1342 1343 /* All types that are editable must also be changeable. */ 1344 gdb_assert (varobj_value_is_changeable_p (var)); 1345 1346 /* The value of a changeable variable object must not be lazy. */ 1347 gdb_assert (!value_lazy (var->value)); 1348 1349 /* Need to coerce the input. We want to check if the 1350 value of the variable object will be different 1351 after assignment, and the first thing value_assign 1352 does is coerce the input. 1353 For example, if we are assigning an array to a pointer variable we 1354 should compare the pointer with the array's address, not with the 1355 array's content. */ 1356 value = coerce_array (value); 1357 1358 /* The new value may be lazy. gdb_value_assign, or 1359 rather value_contents, will take care of this. 1360 If fetching of the new value will fail, gdb_value_assign 1361 with catch the exception. */ 1362 if (!gdb_value_assign (var->value, value, &val)) 1363 return 0; 1364 1365 /* If the value has changed, record it, so that next -var-update can 1366 report this change. If a variable had a value of '1', we've set it 1367 to '333' and then set again to '1', when -var-update will report this 1368 variable as changed -- because the first assignment has set the 1369 'updated' flag. There's no need to optimize that, because return value 1370 of -var-update should be considered an approximation. */ 1371 var->updated = install_new_value (var, val, 0 /* Compare values. */); 1372 input_radix = saved_input_radix; 1373 return 1; 1374 } 1375 1376 #if HAVE_PYTHON 1377 1378 /* A helper function to install a constructor function and visualizer 1379 in a varobj. */ 1380 1381 static void 1382 install_visualizer (struct varobj *var, PyObject *constructor, 1383 PyObject *visualizer) 1384 { 1385 Py_XDECREF (var->constructor); 1386 var->constructor = constructor; 1387 1388 Py_XDECREF (var->pretty_printer); 1389 var->pretty_printer = visualizer; 1390 1391 Py_XDECREF (var->child_iter); 1392 var->child_iter = NULL; 1393 } 1394 1395 /* Install the default visualizer for VAR. */ 1396 1397 static void 1398 install_default_visualizer (struct varobj *var) 1399 { 1400 /* Do not install a visualizer on a CPLUS_FAKE_CHILD. */ 1401 if (CPLUS_FAKE_CHILD (var)) 1402 return; 1403 1404 if (pretty_printing) 1405 { 1406 PyObject *pretty_printer = NULL; 1407 1408 if (var->value) 1409 { 1410 pretty_printer = gdbpy_get_varobj_pretty_printer (var->value); 1411 if (! pretty_printer) 1412 { 1413 gdbpy_print_stack (); 1414 error (_("Cannot instantiate printer for default visualizer")); 1415 } 1416 } 1417 1418 if (pretty_printer == Py_None) 1419 { 1420 Py_DECREF (pretty_printer); 1421 pretty_printer = NULL; 1422 } 1423 1424 install_visualizer (var, NULL, pretty_printer); 1425 } 1426 } 1427 1428 /* Instantiate and install a visualizer for VAR using CONSTRUCTOR to 1429 make a new object. */ 1430 1431 static void 1432 construct_visualizer (struct varobj *var, PyObject *constructor) 1433 { 1434 PyObject *pretty_printer; 1435 1436 /* Do not install a visualizer on a CPLUS_FAKE_CHILD. */ 1437 if (CPLUS_FAKE_CHILD (var)) 1438 return; 1439 1440 Py_INCREF (constructor); 1441 if (constructor == Py_None) 1442 pretty_printer = NULL; 1443 else 1444 { 1445 pretty_printer = instantiate_pretty_printer (constructor, var->value); 1446 if (! pretty_printer) 1447 { 1448 gdbpy_print_stack (); 1449 Py_DECREF (constructor); 1450 constructor = Py_None; 1451 Py_INCREF (constructor); 1452 } 1453 1454 if (pretty_printer == Py_None) 1455 { 1456 Py_DECREF (pretty_printer); 1457 pretty_printer = NULL; 1458 } 1459 } 1460 1461 install_visualizer (var, constructor, pretty_printer); 1462 } 1463 1464 #endif /* HAVE_PYTHON */ 1465 1466 /* A helper function for install_new_value. This creates and installs 1467 a visualizer for VAR, if appropriate. */ 1468 1469 static void 1470 install_new_value_visualizer (struct varobj *var) 1471 { 1472 #if HAVE_PYTHON 1473 /* If the constructor is None, then we want the raw value. If VAR 1474 does not have a value, just skip this. */ 1475 if (var->constructor != Py_None && var->value) 1476 { 1477 struct cleanup *cleanup; 1478 1479 cleanup = varobj_ensure_python_env (var); 1480 1481 if (!var->constructor) 1482 install_default_visualizer (var); 1483 else 1484 construct_visualizer (var, var->constructor); 1485 1486 do_cleanups (cleanup); 1487 } 1488 #else 1489 /* Do nothing. */ 1490 #endif 1491 } 1492 1493 /* Assign a new value to a variable object. If INITIAL is non-zero, 1494 this is the first assignement after the variable object was just 1495 created, or changed type. In that case, just assign the value 1496 and return 0. 1497 Otherwise, assign the new value, and return 1 if the value is 1498 different from the current one, 0 otherwise. The comparison is 1499 done on textual representation of value. Therefore, some types 1500 need not be compared. E.g. for structures the reported value is 1501 always "{...}", so no comparison is necessary here. If the old 1502 value was NULL and new one is not, or vice versa, we always return 1. 1503 1504 The VALUE parameter should not be released -- the function will 1505 take care of releasing it when needed. */ 1506 static int 1507 install_new_value (struct varobj *var, struct value *value, int initial) 1508 { 1509 int changeable; 1510 int need_to_fetch; 1511 int changed = 0; 1512 int intentionally_not_fetched = 0; 1513 char *print_value = NULL; 1514 1515 /* We need to know the varobj's type to decide if the value should 1516 be fetched or not. C++ fake children (public/protected/private) 1517 don't have a type. */ 1518 gdb_assert (var->type || CPLUS_FAKE_CHILD (var)); 1519 changeable = varobj_value_is_changeable_p (var); 1520 1521 /* If the type has custom visualizer, we consider it to be always 1522 changeable. FIXME: need to make sure this behaviour will not 1523 mess up read-sensitive values. */ 1524 if (var->pretty_printer) 1525 changeable = 1; 1526 1527 need_to_fetch = changeable; 1528 1529 /* We are not interested in the address of references, and given 1530 that in C++ a reference is not rebindable, it cannot 1531 meaningfully change. So, get hold of the real value. */ 1532 if (value) 1533 value = coerce_ref (value); 1534 1535 if (var->type && TYPE_CODE (var->type) == TYPE_CODE_UNION) 1536 /* For unions, we need to fetch the value implicitly because 1537 of implementation of union member fetch. When gdb 1538 creates a value for a field and the value of the enclosing 1539 structure is not lazy, it immediately copies the necessary 1540 bytes from the enclosing values. If the enclosing value is 1541 lazy, the call to value_fetch_lazy on the field will read 1542 the data from memory. For unions, that means we'll read the 1543 same memory more than once, which is not desirable. So 1544 fetch now. */ 1545 need_to_fetch = 1; 1546 1547 /* The new value might be lazy. If the type is changeable, 1548 that is we'll be comparing values of this type, fetch the 1549 value now. Otherwise, on the next update the old value 1550 will be lazy, which means we've lost that old value. */ 1551 if (need_to_fetch && value && value_lazy (value)) 1552 { 1553 struct varobj *parent = var->parent; 1554 int frozen = var->frozen; 1555 1556 for (; !frozen && parent; parent = parent->parent) 1557 frozen |= parent->frozen; 1558 1559 if (frozen && initial) 1560 { 1561 /* For variables that are frozen, or are children of frozen 1562 variables, we don't do fetch on initial assignment. 1563 For non-initial assignemnt we do the fetch, since it means we're 1564 explicitly asked to compare the new value with the old one. */ 1565 intentionally_not_fetched = 1; 1566 } 1567 else if (!gdb_value_fetch_lazy (value)) 1568 { 1569 /* Set the value to NULL, so that for the next -var-update, 1570 we don't try to compare the new value with this value, 1571 that we couldn't even read. */ 1572 value = NULL; 1573 } 1574 } 1575 1576 1577 /* Below, we'll be comparing string rendering of old and new 1578 values. Don't get string rendering if the value is 1579 lazy -- if it is, the code above has decided that the value 1580 should not be fetched. */ 1581 if (value && !value_lazy (value) && !var->pretty_printer) 1582 print_value = value_get_print_value (value, var->format, var); 1583 1584 /* If the type is changeable, compare the old and the new values. 1585 If this is the initial assignment, we don't have any old value 1586 to compare with. */ 1587 if (!initial && changeable) 1588 { 1589 /* If the value of the varobj was changed by -var-set-value, 1590 then the value in the varobj and in the target is the same. 1591 However, that value is different from the value that the 1592 varobj had after the previous -var-update. So need to the 1593 varobj as changed. */ 1594 if (var->updated) 1595 { 1596 changed = 1; 1597 } 1598 else if (! var->pretty_printer) 1599 { 1600 /* Try to compare the values. That requires that both 1601 values are non-lazy. */ 1602 if (var->not_fetched && value_lazy (var->value)) 1603 { 1604 /* This is a frozen varobj and the value was never read. 1605 Presumably, UI shows some "never read" indicator. 1606 Now that we've fetched the real value, we need to report 1607 this varobj as changed so that UI can show the real 1608 value. */ 1609 changed = 1; 1610 } 1611 else if (var->value == NULL && value == NULL) 1612 /* Equal. */ 1613 ; 1614 else if (var->value == NULL || value == NULL) 1615 { 1616 changed = 1; 1617 } 1618 else 1619 { 1620 gdb_assert (!value_lazy (var->value)); 1621 gdb_assert (!value_lazy (value)); 1622 1623 gdb_assert (var->print_value != NULL && print_value != NULL); 1624 if (strcmp (var->print_value, print_value) != 0) 1625 changed = 1; 1626 } 1627 } 1628 } 1629 1630 if (!initial && !changeable) 1631 { 1632 /* For values that are not changeable, we don't compare the values. 1633 However, we want to notice if a value was not NULL and now is NULL, 1634 or vise versa, so that we report when top-level varobjs come in scope 1635 and leave the scope. */ 1636 changed = (var->value != NULL) != (value != NULL); 1637 } 1638 1639 /* We must always keep the new value, since children depend on it. */ 1640 if (var->value != NULL && var->value != value) 1641 value_free (var->value); 1642 var->value = value; 1643 if (value != NULL) 1644 value_incref (value); 1645 if (value && value_lazy (value) && intentionally_not_fetched) 1646 var->not_fetched = 1; 1647 else 1648 var->not_fetched = 0; 1649 var->updated = 0; 1650 1651 install_new_value_visualizer (var); 1652 1653 /* If we installed a pretty-printer, re-compare the printed version 1654 to see if the variable changed. */ 1655 if (var->pretty_printer) 1656 { 1657 xfree (print_value); 1658 print_value = value_get_print_value (var->value, var->format, var); 1659 if ((var->print_value == NULL && print_value != NULL) 1660 || (var->print_value != NULL && print_value == NULL) 1661 || (var->print_value != NULL && print_value != NULL 1662 && strcmp (var->print_value, print_value) != 0)) 1663 changed = 1; 1664 } 1665 if (var->print_value) 1666 xfree (var->print_value); 1667 var->print_value = print_value; 1668 1669 gdb_assert (!var->value || value_type (var->value)); 1670 1671 return changed; 1672 } 1673 1674 /* Return the requested range for a varobj. VAR is the varobj. FROM 1675 and TO are out parameters; *FROM and *TO will be set to the 1676 selected sub-range of VAR. If no range was selected using 1677 -var-set-update-range, then both will be -1. */ 1678 void 1679 varobj_get_child_range (struct varobj *var, int *from, int *to) 1680 { 1681 *from = var->from; 1682 *to = var->to; 1683 } 1684 1685 /* Set the selected sub-range of children of VAR to start at index 1686 FROM and end at index TO. If either FROM or TO is less than zero, 1687 this is interpreted as a request for all children. */ 1688 void 1689 varobj_set_child_range (struct varobj *var, int from, int to) 1690 { 1691 var->from = from; 1692 var->to = to; 1693 } 1694 1695 void 1696 varobj_set_visualizer (struct varobj *var, const char *visualizer) 1697 { 1698 #if HAVE_PYTHON 1699 PyObject *mainmod, *globals, *constructor; 1700 struct cleanup *back_to; 1701 1702 back_to = varobj_ensure_python_env (var); 1703 1704 mainmod = PyImport_AddModule ("__main__"); 1705 globals = PyModule_GetDict (mainmod); 1706 Py_INCREF (globals); 1707 make_cleanup_py_decref (globals); 1708 1709 constructor = PyRun_String (visualizer, Py_eval_input, globals, globals); 1710 1711 if (! constructor) 1712 { 1713 gdbpy_print_stack (); 1714 error (_("Could not evaluate visualizer expression: %s"), visualizer); 1715 } 1716 1717 construct_visualizer (var, constructor); 1718 Py_XDECREF (constructor); 1719 1720 /* If there are any children now, wipe them. */ 1721 varobj_delete (var, NULL, 1 /* children only */); 1722 var->num_children = -1; 1723 1724 do_cleanups (back_to); 1725 #else 1726 error (_("Python support required")); 1727 #endif 1728 } 1729 1730 /* Update the values for a variable and its children. This is a 1731 two-pronged attack. First, re-parse the value for the root's 1732 expression to see if it's changed. Then go all the way 1733 through its children, reconstructing them and noting if they've 1734 changed. 1735 1736 The EXPLICIT parameter specifies if this call is result 1737 of MI request to update this specific variable, or 1738 result of implicit -var-update *. For implicit request, we don't 1739 update frozen variables. 1740 1741 NOTE: This function may delete the caller's varobj. If it 1742 returns TYPE_CHANGED, then it has done this and VARP will be modified 1743 to point to the new varobj. */ 1744 1745 VEC(varobj_update_result) *varobj_update (struct varobj **varp, int explicit) 1746 { 1747 int changed = 0; 1748 int type_changed = 0; 1749 int i; 1750 struct value *new; 1751 VEC (varobj_update_result) *stack = NULL; 1752 VEC (varobj_update_result) *result = NULL; 1753 1754 /* Frozen means frozen -- we don't check for any change in 1755 this varobj, including its going out of scope, or 1756 changing type. One use case for frozen varobjs is 1757 retaining previously evaluated expressions, and we don't 1758 want them to be reevaluated at all. */ 1759 if (!explicit && (*varp)->frozen) 1760 return result; 1761 1762 if (!(*varp)->root->is_valid) 1763 { 1764 varobj_update_result r = {0}; 1765 1766 r.varobj = *varp; 1767 r.status = VAROBJ_INVALID; 1768 VEC_safe_push (varobj_update_result, result, &r); 1769 return result; 1770 } 1771 1772 if ((*varp)->root->rootvar == *varp) 1773 { 1774 varobj_update_result r = {0}; 1775 1776 r.varobj = *varp; 1777 r.status = VAROBJ_IN_SCOPE; 1778 1779 /* Update the root variable. value_of_root can return NULL 1780 if the variable is no longer around, i.e. we stepped out of 1781 the frame in which a local existed. We are letting the 1782 value_of_root variable dispose of the varobj if the type 1783 has changed. */ 1784 new = value_of_root (varp, &type_changed); 1785 r.varobj = *varp; 1786 1787 r.type_changed = type_changed; 1788 if (install_new_value ((*varp), new, type_changed)) 1789 r.changed = 1; 1790 1791 if (new == NULL) 1792 r.status = VAROBJ_NOT_IN_SCOPE; 1793 r.value_installed = 1; 1794 1795 if (r.status == VAROBJ_NOT_IN_SCOPE) 1796 { 1797 if (r.type_changed || r.changed) 1798 VEC_safe_push (varobj_update_result, result, &r); 1799 return result; 1800 } 1801 1802 VEC_safe_push (varobj_update_result, stack, &r); 1803 } 1804 else 1805 { 1806 varobj_update_result r = {0}; 1807 1808 r.varobj = *varp; 1809 VEC_safe_push (varobj_update_result, stack, &r); 1810 } 1811 1812 /* Walk through the children, reconstructing them all. */ 1813 while (!VEC_empty (varobj_update_result, stack)) 1814 { 1815 varobj_update_result r = *(VEC_last (varobj_update_result, stack)); 1816 struct varobj *v = r.varobj; 1817 1818 VEC_pop (varobj_update_result, stack); 1819 1820 /* Update this variable, unless it's a root, which is already 1821 updated. */ 1822 if (!r.value_installed) 1823 { 1824 new = value_of_child (v->parent, v->index); 1825 if (install_new_value (v, new, 0 /* type not changed */)) 1826 { 1827 r.changed = 1; 1828 v->updated = 0; 1829 } 1830 } 1831 1832 /* We probably should not get children of a varobj that has a 1833 pretty-printer, but for which -var-list-children was never 1834 invoked. */ 1835 if (v->pretty_printer) 1836 { 1837 VEC (varobj_p) *changed = 0, *new = 0, *unchanged = 0; 1838 int i, children_changed = 0; 1839 1840 if (v->frozen) 1841 continue; 1842 1843 if (!v->children_requested) 1844 { 1845 int dummy; 1846 1847 /* If we initially did not have potential children, but 1848 now we do, consider the varobj as changed. 1849 Otherwise, if children were never requested, consider 1850 it as unchanged -- presumably, such varobj is not yet 1851 expanded in the UI, so we need not bother getting 1852 it. */ 1853 if (!varobj_has_more (v, 0)) 1854 { 1855 update_dynamic_varobj_children (v, NULL, NULL, NULL, 1856 &dummy, 0, 0, 0); 1857 if (varobj_has_more (v, 0)) 1858 r.changed = 1; 1859 } 1860 1861 if (r.changed) 1862 VEC_safe_push (varobj_update_result, result, &r); 1863 1864 continue; 1865 } 1866 1867 /* If update_dynamic_varobj_children returns 0, then we have 1868 a non-conforming pretty-printer, so we skip it. */ 1869 if (update_dynamic_varobj_children (v, &changed, &new, &unchanged, 1870 &children_changed, 1, 1871 v->from, v->to)) 1872 { 1873 if (children_changed || new) 1874 { 1875 r.children_changed = 1; 1876 r.new = new; 1877 } 1878 /* Push in reverse order so that the first child is 1879 popped from the work stack first, and so will be 1880 added to result first. This does not affect 1881 correctness, just "nicer". */ 1882 for (i = VEC_length (varobj_p, changed) - 1; i >= 0; --i) 1883 { 1884 varobj_p tmp = VEC_index (varobj_p, changed, i); 1885 varobj_update_result r = {0}; 1886 1887 r.varobj = tmp; 1888 r.changed = 1; 1889 r.value_installed = 1; 1890 VEC_safe_push (varobj_update_result, stack, &r); 1891 } 1892 for (i = VEC_length (varobj_p, unchanged) - 1; i >= 0; --i) 1893 { 1894 varobj_p tmp = VEC_index (varobj_p, unchanged, i); 1895 1896 if (!tmp->frozen) 1897 { 1898 varobj_update_result r = {0}; 1899 1900 r.varobj = tmp; 1901 r.value_installed = 1; 1902 VEC_safe_push (varobj_update_result, stack, &r); 1903 } 1904 } 1905 if (r.changed || r.children_changed) 1906 VEC_safe_push (varobj_update_result, result, &r); 1907 1908 /* Free CHANGED and UNCHANGED, but not NEW, because NEW 1909 has been put into the result vector. */ 1910 VEC_free (varobj_p, changed); 1911 VEC_free (varobj_p, unchanged); 1912 1913 continue; 1914 } 1915 } 1916 1917 /* Push any children. Use reverse order so that the first 1918 child is popped from the work stack first, and so 1919 will be added to result first. This does not 1920 affect correctness, just "nicer". */ 1921 for (i = VEC_length (varobj_p, v->children)-1; i >= 0; --i) 1922 { 1923 varobj_p c = VEC_index (varobj_p, v->children, i); 1924 1925 /* Child may be NULL if explicitly deleted by -var-delete. */ 1926 if (c != NULL && !c->frozen) 1927 { 1928 varobj_update_result r = {0}; 1929 1930 r.varobj = c; 1931 VEC_safe_push (varobj_update_result, stack, &r); 1932 } 1933 } 1934 1935 if (r.changed || r.type_changed) 1936 VEC_safe_push (varobj_update_result, result, &r); 1937 } 1938 1939 VEC_free (varobj_update_result, stack); 1940 1941 return result; 1942 } 1943 1944 1945 /* Helper functions */ 1946 1947 /* 1948 * Variable object construction/destruction 1949 */ 1950 1951 static int 1952 delete_variable (struct cpstack **resultp, struct varobj *var, 1953 int only_children_p) 1954 { 1955 int delcount = 0; 1956 1957 delete_variable_1 (resultp, &delcount, var, 1958 only_children_p, 1 /* remove_from_parent_p */ ); 1959 1960 return delcount; 1961 } 1962 1963 /* Delete the variable object VAR and its children. */ 1964 /* IMPORTANT NOTE: If we delete a variable which is a child 1965 and the parent is not removed we dump core. It must be always 1966 initially called with remove_from_parent_p set. */ 1967 static void 1968 delete_variable_1 (struct cpstack **resultp, int *delcountp, 1969 struct varobj *var, int only_children_p, 1970 int remove_from_parent_p) 1971 { 1972 int i; 1973 1974 /* Delete any children of this variable, too. */ 1975 for (i = 0; i < VEC_length (varobj_p, var->children); ++i) 1976 { 1977 varobj_p child = VEC_index (varobj_p, var->children, i); 1978 1979 if (!child) 1980 continue; 1981 if (!remove_from_parent_p) 1982 child->parent = NULL; 1983 delete_variable_1 (resultp, delcountp, child, 0, only_children_p); 1984 } 1985 VEC_free (varobj_p, var->children); 1986 1987 /* if we were called to delete only the children we are done here. */ 1988 if (only_children_p) 1989 return; 1990 1991 /* Otherwise, add it to the list of deleted ones and proceed to do so. */ 1992 /* If the name is null, this is a temporary variable, that has not 1993 yet been installed, don't report it, it belongs to the caller... */ 1994 if (var->obj_name != NULL) 1995 { 1996 cppush (resultp, xstrdup (var->obj_name)); 1997 *delcountp = *delcountp + 1; 1998 } 1999 2000 /* If this variable has a parent, remove it from its parent's list. */ 2001 /* OPTIMIZATION: if the parent of this variable is also being deleted, 2002 (as indicated by remove_from_parent_p) we don't bother doing an 2003 expensive list search to find the element to remove when we are 2004 discarding the list afterwards. */ 2005 if ((remove_from_parent_p) && (var->parent != NULL)) 2006 { 2007 VEC_replace (varobj_p, var->parent->children, var->index, NULL); 2008 } 2009 2010 if (var->obj_name != NULL) 2011 uninstall_variable (var); 2012 2013 /* Free memory associated with this variable. */ 2014 free_variable (var); 2015 } 2016 2017 /* Install the given variable VAR with the object name VAR->OBJ_NAME. */ 2018 static int 2019 install_variable (struct varobj *var) 2020 { 2021 struct vlist *cv; 2022 struct vlist *newvl; 2023 const char *chp; 2024 unsigned int index = 0; 2025 unsigned int i = 1; 2026 2027 for (chp = var->obj_name; *chp; chp++) 2028 { 2029 index = (index + (i++ * (unsigned int) *chp)) % VAROBJ_TABLE_SIZE; 2030 } 2031 2032 cv = *(varobj_table + index); 2033 while ((cv != NULL) && (strcmp (cv->var->obj_name, var->obj_name) != 0)) 2034 cv = cv->next; 2035 2036 if (cv != NULL) 2037 error (_("Duplicate variable object name")); 2038 2039 /* Add varobj to hash table. */ 2040 newvl = xmalloc (sizeof (struct vlist)); 2041 newvl->next = *(varobj_table + index); 2042 newvl->var = var; 2043 *(varobj_table + index) = newvl; 2044 2045 /* If root, add varobj to root list. */ 2046 if (is_root_p (var)) 2047 { 2048 /* Add to list of root variables. */ 2049 if (rootlist == NULL) 2050 var->root->next = NULL; 2051 else 2052 var->root->next = rootlist; 2053 rootlist = var->root; 2054 } 2055 2056 return 1; /* OK */ 2057 } 2058 2059 /* Unistall the object VAR. */ 2060 static void 2061 uninstall_variable (struct varobj *var) 2062 { 2063 struct vlist *cv; 2064 struct vlist *prev; 2065 struct varobj_root *cr; 2066 struct varobj_root *prer; 2067 const char *chp; 2068 unsigned int index = 0; 2069 unsigned int i = 1; 2070 2071 /* Remove varobj from hash table. */ 2072 for (chp = var->obj_name; *chp; chp++) 2073 { 2074 index = (index + (i++ * (unsigned int) *chp)) % VAROBJ_TABLE_SIZE; 2075 } 2076 2077 cv = *(varobj_table + index); 2078 prev = NULL; 2079 while ((cv != NULL) && (strcmp (cv->var->obj_name, var->obj_name) != 0)) 2080 { 2081 prev = cv; 2082 cv = cv->next; 2083 } 2084 2085 if (varobjdebug) 2086 fprintf_unfiltered (gdb_stdlog, "Deleting %s\n", var->obj_name); 2087 2088 if (cv == NULL) 2089 { 2090 warning 2091 ("Assertion failed: Could not find variable object \"%s\" to delete", 2092 var->obj_name); 2093 return; 2094 } 2095 2096 if (prev == NULL) 2097 *(varobj_table + index) = cv->next; 2098 else 2099 prev->next = cv->next; 2100 2101 xfree (cv); 2102 2103 /* If root, remove varobj from root list. */ 2104 if (is_root_p (var)) 2105 { 2106 /* Remove from list of root variables. */ 2107 if (rootlist == var->root) 2108 rootlist = var->root->next; 2109 else 2110 { 2111 prer = NULL; 2112 cr = rootlist; 2113 while ((cr != NULL) && (cr->rootvar != var)) 2114 { 2115 prer = cr; 2116 cr = cr->next; 2117 } 2118 if (cr == NULL) 2119 { 2120 warning (_("Assertion failed: Could not find " 2121 "varobj \"%s\" in root list"), 2122 var->obj_name); 2123 return; 2124 } 2125 if (prer == NULL) 2126 rootlist = NULL; 2127 else 2128 prer->next = cr->next; 2129 } 2130 } 2131 2132 } 2133 2134 /* Create and install a child of the parent of the given name. */ 2135 static struct varobj * 2136 create_child (struct varobj *parent, int index, char *name) 2137 { 2138 return create_child_with_value (parent, index, name, 2139 value_of_child (parent, index)); 2140 } 2141 2142 static struct varobj * 2143 create_child_with_value (struct varobj *parent, int index, const char *name, 2144 struct value *value) 2145 { 2146 struct varobj *child; 2147 char *childs_name; 2148 2149 child = new_variable (); 2150 2151 /* Name is allocated by name_of_child. */ 2152 /* FIXME: xstrdup should not be here. */ 2153 child->name = xstrdup (name); 2154 child->index = index; 2155 child->parent = parent; 2156 child->root = parent->root; 2157 childs_name = xstrprintf ("%s.%s", parent->obj_name, name); 2158 child->obj_name = childs_name; 2159 install_variable (child); 2160 2161 /* Compute the type of the child. Must do this before 2162 calling install_new_value. */ 2163 if (value != NULL) 2164 /* If the child had no evaluation errors, var->value 2165 will be non-NULL and contain a valid type. */ 2166 child->type = value_type (value); 2167 else 2168 /* Otherwise, we must compute the type. */ 2169 child->type = (*child->root->lang->type_of_child) (child->parent, 2170 child->index); 2171 install_new_value (child, value, 1); 2172 2173 return child; 2174 } 2175 2176 2177 /* 2178 * Miscellaneous utility functions. 2179 */ 2180 2181 /* Allocate memory and initialize a new variable. */ 2182 static struct varobj * 2183 new_variable (void) 2184 { 2185 struct varobj *var; 2186 2187 var = (struct varobj *) xmalloc (sizeof (struct varobj)); 2188 var->name = NULL; 2189 var->path_expr = NULL; 2190 var->obj_name = NULL; 2191 var->index = -1; 2192 var->type = NULL; 2193 var->value = NULL; 2194 var->num_children = -1; 2195 var->parent = NULL; 2196 var->children = NULL; 2197 var->format = 0; 2198 var->root = NULL; 2199 var->updated = 0; 2200 var->print_value = NULL; 2201 var->frozen = 0; 2202 var->not_fetched = 0; 2203 var->children_requested = 0; 2204 var->from = -1; 2205 var->to = -1; 2206 var->constructor = 0; 2207 var->pretty_printer = 0; 2208 var->child_iter = 0; 2209 var->saved_item = 0; 2210 2211 return var; 2212 } 2213 2214 /* Allocate memory and initialize a new root variable. */ 2215 static struct varobj * 2216 new_root_variable (void) 2217 { 2218 struct varobj *var = new_variable (); 2219 2220 var->root = (struct varobj_root *) xmalloc (sizeof (struct varobj_root)); 2221 var->root->lang = NULL; 2222 var->root->exp = NULL; 2223 var->root->valid_block = NULL; 2224 var->root->frame = null_frame_id; 2225 var->root->floating = 0; 2226 var->root->rootvar = NULL; 2227 var->root->is_valid = 1; 2228 2229 return var; 2230 } 2231 2232 /* Free any allocated memory associated with VAR. */ 2233 static void 2234 free_variable (struct varobj *var) 2235 { 2236 #if HAVE_PYTHON 2237 if (var->pretty_printer) 2238 { 2239 struct cleanup *cleanup = varobj_ensure_python_env (var); 2240 Py_XDECREF (var->constructor); 2241 Py_XDECREF (var->pretty_printer); 2242 Py_XDECREF (var->child_iter); 2243 Py_XDECREF (var->saved_item); 2244 do_cleanups (cleanup); 2245 } 2246 #endif 2247 2248 value_free (var->value); 2249 2250 /* Free the expression if this is a root variable. */ 2251 if (is_root_p (var)) 2252 { 2253 xfree (var->root->exp); 2254 xfree (var->root); 2255 } 2256 2257 xfree (var->name); 2258 xfree (var->obj_name); 2259 xfree (var->print_value); 2260 xfree (var->path_expr); 2261 xfree (var); 2262 } 2263 2264 static void 2265 do_free_variable_cleanup (void *var) 2266 { 2267 free_variable (var); 2268 } 2269 2270 static struct cleanup * 2271 make_cleanup_free_variable (struct varobj *var) 2272 { 2273 return make_cleanup (do_free_variable_cleanup, var); 2274 } 2275 2276 /* This returns the type of the variable. It also skips past typedefs 2277 to return the real type of the variable. 2278 2279 NOTE: TYPE_TARGET_TYPE should NOT be used anywhere in this file 2280 except within get_target_type and get_type. */ 2281 static struct type * 2282 get_type (struct varobj *var) 2283 { 2284 struct type *type; 2285 2286 type = var->type; 2287 if (type != NULL) 2288 type = check_typedef (type); 2289 2290 return type; 2291 } 2292 2293 /* Return the type of the value that's stored in VAR, 2294 or that would have being stored there if the 2295 value were accessible. 2296 2297 This differs from VAR->type in that VAR->type is always 2298 the true type of the expession in the source language. 2299 The return value of this function is the type we're 2300 actually storing in varobj, and using for displaying 2301 the values and for comparing previous and new values. 2302 2303 For example, top-level references are always stripped. */ 2304 static struct type * 2305 get_value_type (struct varobj *var) 2306 { 2307 struct type *type; 2308 2309 if (var->value) 2310 type = value_type (var->value); 2311 else 2312 type = var->type; 2313 2314 type = check_typedef (type); 2315 2316 if (TYPE_CODE (type) == TYPE_CODE_REF) 2317 type = get_target_type (type); 2318 2319 type = check_typedef (type); 2320 2321 return type; 2322 } 2323 2324 /* This returns the target type (or NULL) of TYPE, also skipping 2325 past typedefs, just like get_type (). 2326 2327 NOTE: TYPE_TARGET_TYPE should NOT be used anywhere in this file 2328 except within get_target_type and get_type. */ 2329 static struct type * 2330 get_target_type (struct type *type) 2331 { 2332 if (type != NULL) 2333 { 2334 type = TYPE_TARGET_TYPE (type); 2335 if (type != NULL) 2336 type = check_typedef (type); 2337 } 2338 2339 return type; 2340 } 2341 2342 /* What is the default display for this variable? We assume that 2343 everything is "natural". Any exceptions? */ 2344 static enum varobj_display_formats 2345 variable_default_display (struct varobj *var) 2346 { 2347 return FORMAT_NATURAL; 2348 } 2349 2350 /* FIXME: The following should be generic for any pointer. */ 2351 static void 2352 cppush (struct cpstack **pstack, char *name) 2353 { 2354 struct cpstack *s; 2355 2356 s = (struct cpstack *) xmalloc (sizeof (struct cpstack)); 2357 s->name = name; 2358 s->next = *pstack; 2359 *pstack = s; 2360 } 2361 2362 /* FIXME: The following should be generic for any pointer. */ 2363 static char * 2364 cppop (struct cpstack **pstack) 2365 { 2366 struct cpstack *s; 2367 char *v; 2368 2369 if ((*pstack)->name == NULL && (*pstack)->next == NULL) 2370 return NULL; 2371 2372 s = *pstack; 2373 v = s->name; 2374 *pstack = (*pstack)->next; 2375 xfree (s); 2376 2377 return v; 2378 } 2379 2380 /* 2381 * Language-dependencies 2382 */ 2383 2384 /* Common entry points */ 2385 2386 /* Get the language of variable VAR. */ 2387 static enum varobj_languages 2388 variable_language (struct varobj *var) 2389 { 2390 enum varobj_languages lang; 2391 2392 switch (var->root->exp->language_defn->la_language) 2393 { 2394 default: 2395 case language_c: 2396 lang = vlang_c; 2397 break; 2398 case language_cplus: 2399 lang = vlang_cplus; 2400 break; 2401 case language_java: 2402 lang = vlang_java; 2403 break; 2404 } 2405 2406 return lang; 2407 } 2408 2409 /* Return the number of children for a given variable. 2410 The result of this function is defined by the language 2411 implementation. The number of children returned by this function 2412 is the number of children that the user will see in the variable 2413 display. */ 2414 static int 2415 number_of_children (struct varobj *var) 2416 { 2417 return (*var->root->lang->number_of_children) (var); 2418 } 2419 2420 /* What is the expression for the root varobj VAR? Returns a malloc'd 2421 string. */ 2422 static char * 2423 name_of_variable (struct varobj *var) 2424 { 2425 return (*var->root->lang->name_of_variable) (var); 2426 } 2427 2428 /* What is the name of the INDEX'th child of VAR? Returns a malloc'd 2429 string. */ 2430 static char * 2431 name_of_child (struct varobj *var, int index) 2432 { 2433 return (*var->root->lang->name_of_child) (var, index); 2434 } 2435 2436 /* What is the ``struct value *'' of the root variable VAR? 2437 For floating variable object, evaluation can get us a value 2438 of different type from what is stored in varobj already. In 2439 that case: 2440 - *type_changed will be set to 1 2441 - old varobj will be freed, and new one will be 2442 created, with the same name. 2443 - *var_handle will be set to the new varobj 2444 Otherwise, *type_changed will be set to 0. */ 2445 static struct value * 2446 value_of_root (struct varobj **var_handle, int *type_changed) 2447 { 2448 struct varobj *var; 2449 2450 if (var_handle == NULL) 2451 return NULL; 2452 2453 var = *var_handle; 2454 2455 /* This should really be an exception, since this should 2456 only get called with a root variable. */ 2457 2458 if (!is_root_p (var)) 2459 return NULL; 2460 2461 if (var->root->floating) 2462 { 2463 struct varobj *tmp_var; 2464 char *old_type, *new_type; 2465 2466 tmp_var = varobj_create (NULL, var->name, (CORE_ADDR) 0, 2467 USE_SELECTED_FRAME); 2468 if (tmp_var == NULL) 2469 { 2470 return NULL; 2471 } 2472 old_type = varobj_get_type (var); 2473 new_type = varobj_get_type (tmp_var); 2474 if (strcmp (old_type, new_type) == 0) 2475 { 2476 /* The expression presently stored inside var->root->exp 2477 remembers the locations of local variables relatively to 2478 the frame where the expression was created (in DWARF location 2479 button, for example). Naturally, those locations are not 2480 correct in other frames, so update the expression. */ 2481 2482 struct expression *tmp_exp = var->root->exp; 2483 2484 var->root->exp = tmp_var->root->exp; 2485 tmp_var->root->exp = tmp_exp; 2486 2487 varobj_delete (tmp_var, NULL, 0); 2488 *type_changed = 0; 2489 } 2490 else 2491 { 2492 tmp_var->obj_name = xstrdup (var->obj_name); 2493 tmp_var->from = var->from; 2494 tmp_var->to = var->to; 2495 varobj_delete (var, NULL, 0); 2496 2497 install_variable (tmp_var); 2498 *var_handle = tmp_var; 2499 var = *var_handle; 2500 *type_changed = 1; 2501 } 2502 xfree (old_type); 2503 xfree (new_type); 2504 } 2505 else 2506 { 2507 *type_changed = 0; 2508 } 2509 2510 return (*var->root->lang->value_of_root) (var_handle); 2511 } 2512 2513 /* What is the ``struct value *'' for the INDEX'th child of PARENT? */ 2514 static struct value * 2515 value_of_child (struct varobj *parent, int index) 2516 { 2517 struct value *value; 2518 2519 value = (*parent->root->lang->value_of_child) (parent, index); 2520 2521 return value; 2522 } 2523 2524 /* GDB already has a command called "value_of_variable". Sigh. */ 2525 static char * 2526 my_value_of_variable (struct varobj *var, enum varobj_display_formats format) 2527 { 2528 if (var->root->is_valid) 2529 { 2530 if (var->pretty_printer) 2531 return value_get_print_value (var->value, var->format, var); 2532 return (*var->root->lang->value_of_variable) (var, format); 2533 } 2534 else 2535 return NULL; 2536 } 2537 2538 static char * 2539 value_get_print_value (struct value *value, enum varobj_display_formats format, 2540 struct varobj *var) 2541 { 2542 struct ui_file *stb; 2543 struct cleanup *old_chain; 2544 gdb_byte *thevalue = NULL; 2545 struct value_print_options opts; 2546 struct type *type = NULL; 2547 long len = 0; 2548 char *encoding = NULL; 2549 struct gdbarch *gdbarch = NULL; 2550 /* Initialize it just to avoid a GCC false warning. */ 2551 CORE_ADDR str_addr = 0; 2552 int string_print = 0; 2553 2554 if (value == NULL) 2555 return NULL; 2556 2557 stb = mem_fileopen (); 2558 old_chain = make_cleanup_ui_file_delete (stb); 2559 2560 gdbarch = get_type_arch (value_type (value)); 2561 #if HAVE_PYTHON 2562 { 2563 PyObject *value_formatter = var->pretty_printer; 2564 2565 varobj_ensure_python_env (var); 2566 2567 if (value_formatter) 2568 { 2569 /* First check to see if we have any children at all. If so, 2570 we simply return {...}. */ 2571 if (dynamic_varobj_has_child_method (var)) 2572 { 2573 do_cleanups (old_chain); 2574 return xstrdup ("{...}"); 2575 } 2576 2577 if (PyObject_HasAttr (value_formatter, gdbpy_to_string_cst)) 2578 { 2579 char *hint; 2580 struct value *replacement; 2581 PyObject *output = NULL; 2582 2583 hint = gdbpy_get_display_hint (value_formatter); 2584 if (hint) 2585 { 2586 if (!strcmp (hint, "string")) 2587 string_print = 1; 2588 xfree (hint); 2589 } 2590 2591 output = apply_varobj_pretty_printer (value_formatter, 2592 &replacement, 2593 stb); 2594 if (output) 2595 { 2596 make_cleanup_py_decref (output); 2597 2598 if (gdbpy_is_lazy_string (output)) 2599 { 2600 gdbpy_extract_lazy_string (output, &str_addr, &type, 2601 &len, &encoding); 2602 make_cleanup (free_current_contents, &encoding); 2603 string_print = 1; 2604 } 2605 else 2606 { 2607 PyObject *py_str 2608 = python_string_to_target_python_string (output); 2609 2610 if (py_str) 2611 { 2612 char *s = PyString_AsString (py_str); 2613 2614 len = PyString_Size (py_str); 2615 thevalue = xmemdup (s, len + 1, len + 1); 2616 type = builtin_type (gdbarch)->builtin_char; 2617 Py_DECREF (py_str); 2618 2619 if (!string_print) 2620 { 2621 do_cleanups (old_chain); 2622 return thevalue; 2623 } 2624 2625 make_cleanup (xfree, thevalue); 2626 } 2627 else 2628 gdbpy_print_stack (); 2629 } 2630 } 2631 if (replacement) 2632 value = replacement; 2633 } 2634 } 2635 } 2636 #endif 2637 2638 get_formatted_print_options (&opts, format_code[(int) format]); 2639 opts.deref_ref = 0; 2640 opts.raw = 1; 2641 if (thevalue) 2642 LA_PRINT_STRING (stb, type, thevalue, len, encoding, 0, &opts); 2643 else if (string_print) 2644 val_print_string (type, encoding, str_addr, len, stb, &opts); 2645 else 2646 common_val_print (value, stb, 0, &opts, current_language); 2647 thevalue = ui_file_xstrdup (stb, NULL); 2648 2649 do_cleanups (old_chain); 2650 return thevalue; 2651 } 2652 2653 int 2654 varobj_editable_p (struct varobj *var) 2655 { 2656 struct type *type; 2657 2658 if (!(var->root->is_valid && var->value && VALUE_LVAL (var->value))) 2659 return 0; 2660 2661 type = get_value_type (var); 2662 2663 switch (TYPE_CODE (type)) 2664 { 2665 case TYPE_CODE_STRUCT: 2666 case TYPE_CODE_UNION: 2667 case TYPE_CODE_ARRAY: 2668 case TYPE_CODE_FUNC: 2669 case TYPE_CODE_METHOD: 2670 return 0; 2671 break; 2672 2673 default: 2674 return 1; 2675 break; 2676 } 2677 } 2678 2679 /* Return non-zero if changes in value of VAR 2680 must be detected and reported by -var-update. 2681 Return zero is -var-update should never report 2682 changes of such values. This makes sense for structures 2683 (since the changes in children values will be reported separately), 2684 or for artifical objects (like 'public' pseudo-field in C++). 2685 2686 Return value of 0 means that gdb need not call value_fetch_lazy 2687 for the value of this variable object. */ 2688 static int 2689 varobj_value_is_changeable_p (struct varobj *var) 2690 { 2691 int r; 2692 struct type *type; 2693 2694 if (CPLUS_FAKE_CHILD (var)) 2695 return 0; 2696 2697 type = get_value_type (var); 2698 2699 switch (TYPE_CODE (type)) 2700 { 2701 case TYPE_CODE_STRUCT: 2702 case TYPE_CODE_UNION: 2703 case TYPE_CODE_ARRAY: 2704 r = 0; 2705 break; 2706 2707 default: 2708 r = 1; 2709 } 2710 2711 return r; 2712 } 2713 2714 /* Return 1 if that varobj is floating, that is is always evaluated in the 2715 selected frame, and not bound to thread/frame. Such variable objects 2716 are created using '@' as frame specifier to -var-create. */ 2717 int 2718 varobj_floating_p (struct varobj *var) 2719 { 2720 return var->root->floating; 2721 } 2722 2723 /* Given the value and the type of a variable object, 2724 adjust the value and type to those necessary 2725 for getting children of the variable object. 2726 This includes dereferencing top-level references 2727 to all types and dereferencing pointers to 2728 structures. 2729 2730 Both TYPE and *TYPE should be non-null. VALUE 2731 can be null if we want to only translate type. 2732 *VALUE can be null as well -- if the parent 2733 value is not known. 2734 2735 If WAS_PTR is not NULL, set *WAS_PTR to 0 or 1 2736 depending on whether pointer was dereferenced 2737 in this function. */ 2738 static void 2739 adjust_value_for_child_access (struct value **value, 2740 struct type **type, 2741 int *was_ptr) 2742 { 2743 gdb_assert (type && *type); 2744 2745 if (was_ptr) 2746 *was_ptr = 0; 2747 2748 *type = check_typedef (*type); 2749 2750 /* The type of value stored in varobj, that is passed 2751 to us, is already supposed to be 2752 reference-stripped. */ 2753 2754 gdb_assert (TYPE_CODE (*type) != TYPE_CODE_REF); 2755 2756 /* Pointers to structures are treated just like 2757 structures when accessing children. Don't 2758 dererences pointers to other types. */ 2759 if (TYPE_CODE (*type) == TYPE_CODE_PTR) 2760 { 2761 struct type *target_type = get_target_type (*type); 2762 if (TYPE_CODE (target_type) == TYPE_CODE_STRUCT 2763 || TYPE_CODE (target_type) == TYPE_CODE_UNION) 2764 { 2765 if (value && *value) 2766 { 2767 int success = gdb_value_ind (*value, value); 2768 2769 if (!success) 2770 *value = NULL; 2771 } 2772 *type = target_type; 2773 if (was_ptr) 2774 *was_ptr = 1; 2775 } 2776 } 2777 2778 /* The 'get_target_type' function calls check_typedef on 2779 result, so we can immediately check type code. No 2780 need to call check_typedef here. */ 2781 } 2782 2783 /* C */ 2784 static int 2785 c_number_of_children (struct varobj *var) 2786 { 2787 struct type *type = get_value_type (var); 2788 int children = 0; 2789 struct type *target; 2790 2791 adjust_value_for_child_access (NULL, &type, NULL); 2792 target = get_target_type (type); 2793 2794 switch (TYPE_CODE (type)) 2795 { 2796 case TYPE_CODE_ARRAY: 2797 if (TYPE_LENGTH (type) > 0 && TYPE_LENGTH (target) > 0 2798 && !TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (type)) 2799 children = TYPE_LENGTH (type) / TYPE_LENGTH (target); 2800 else 2801 /* If we don't know how many elements there are, don't display 2802 any. */ 2803 children = 0; 2804 break; 2805 2806 case TYPE_CODE_STRUCT: 2807 case TYPE_CODE_UNION: 2808 children = TYPE_NFIELDS (type); 2809 break; 2810 2811 case TYPE_CODE_PTR: 2812 /* The type here is a pointer to non-struct. Typically, pointers 2813 have one child, except for function ptrs, which have no children, 2814 and except for void*, as we don't know what to show. 2815 2816 We can show char* so we allow it to be dereferenced. If you decide 2817 to test for it, please mind that a little magic is necessary to 2818 properly identify it: char* has TYPE_CODE == TYPE_CODE_INT and 2819 TYPE_NAME == "char". */ 2820 if (TYPE_CODE (target) == TYPE_CODE_FUNC 2821 || TYPE_CODE (target) == TYPE_CODE_VOID) 2822 children = 0; 2823 else 2824 children = 1; 2825 break; 2826 2827 default: 2828 /* Other types have no children. */ 2829 break; 2830 } 2831 2832 return children; 2833 } 2834 2835 static char * 2836 c_name_of_variable (struct varobj *parent) 2837 { 2838 return xstrdup (parent->name); 2839 } 2840 2841 /* Return the value of element TYPE_INDEX of a structure 2842 value VALUE. VALUE's type should be a structure, 2843 or union, or a typedef to struct/union. 2844 2845 Returns NULL if getting the value fails. Never throws. */ 2846 static struct value * 2847 value_struct_element_index (struct value *value, int type_index) 2848 { 2849 struct value *result = NULL; 2850 volatile struct gdb_exception e; 2851 struct type *type = value_type (value); 2852 2853 type = check_typedef (type); 2854 2855 gdb_assert (TYPE_CODE (type) == TYPE_CODE_STRUCT 2856 || TYPE_CODE (type) == TYPE_CODE_UNION); 2857 2858 TRY_CATCH (e, RETURN_MASK_ERROR) 2859 { 2860 if (field_is_static (&TYPE_FIELD (type, type_index))) 2861 result = value_static_field (type, type_index); 2862 else 2863 result = value_primitive_field (value, 0, type_index, type); 2864 } 2865 if (e.reason < 0) 2866 { 2867 return NULL; 2868 } 2869 else 2870 { 2871 return result; 2872 } 2873 } 2874 2875 /* Obtain the information about child INDEX of the variable 2876 object PARENT. 2877 If CNAME is not null, sets *CNAME to the name of the child relative 2878 to the parent. 2879 If CVALUE is not null, sets *CVALUE to the value of the child. 2880 If CTYPE is not null, sets *CTYPE to the type of the child. 2881 2882 If any of CNAME, CVALUE, or CTYPE is not null, but the corresponding 2883 information cannot be determined, set *CNAME, *CVALUE, or *CTYPE 2884 to NULL. */ 2885 static void 2886 c_describe_child (struct varobj *parent, int index, 2887 char **cname, struct value **cvalue, struct type **ctype, 2888 char **cfull_expression) 2889 { 2890 struct value *value = parent->value; 2891 struct type *type = get_value_type (parent); 2892 char *parent_expression = NULL; 2893 int was_ptr; 2894 2895 if (cname) 2896 *cname = NULL; 2897 if (cvalue) 2898 *cvalue = NULL; 2899 if (ctype) 2900 *ctype = NULL; 2901 if (cfull_expression) 2902 { 2903 *cfull_expression = NULL; 2904 parent_expression = varobj_get_path_expr (parent); 2905 } 2906 adjust_value_for_child_access (&value, &type, &was_ptr); 2907 2908 switch (TYPE_CODE (type)) 2909 { 2910 case TYPE_CODE_ARRAY: 2911 if (cname) 2912 *cname 2913 = xstrdup (int_string (index 2914 + TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type)), 2915 10, 1, 0, 0)); 2916 2917 if (cvalue && value) 2918 { 2919 int real_index = index + TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type)); 2920 2921 gdb_value_subscript (value, real_index, cvalue); 2922 } 2923 2924 if (ctype) 2925 *ctype = get_target_type (type); 2926 2927 if (cfull_expression) 2928 *cfull_expression = 2929 xstrprintf ("(%s)[%s]", parent_expression, 2930 int_string (index 2931 + TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type)), 2932 10, 1, 0, 0)); 2933 2934 2935 break; 2936 2937 case TYPE_CODE_STRUCT: 2938 case TYPE_CODE_UNION: 2939 if (cname) 2940 *cname = xstrdup (TYPE_FIELD_NAME (type, index)); 2941 2942 if (cvalue && value) 2943 { 2944 /* For C, varobj index is the same as type index. */ 2945 *cvalue = value_struct_element_index (value, index); 2946 } 2947 2948 if (ctype) 2949 *ctype = TYPE_FIELD_TYPE (type, index); 2950 2951 if (cfull_expression) 2952 { 2953 char *join = was_ptr ? "->" : "."; 2954 2955 *cfull_expression = xstrprintf ("(%s)%s%s", parent_expression, join, 2956 TYPE_FIELD_NAME (type, index)); 2957 } 2958 2959 break; 2960 2961 case TYPE_CODE_PTR: 2962 if (cname) 2963 *cname = xstrprintf ("*%s", parent->name); 2964 2965 if (cvalue && value) 2966 { 2967 int success = gdb_value_ind (value, cvalue); 2968 2969 if (!success) 2970 *cvalue = NULL; 2971 } 2972 2973 /* Don't use get_target_type because it calls 2974 check_typedef and here, we want to show the true 2975 declared type of the variable. */ 2976 if (ctype) 2977 *ctype = TYPE_TARGET_TYPE (type); 2978 2979 if (cfull_expression) 2980 *cfull_expression = xstrprintf ("*(%s)", parent_expression); 2981 2982 break; 2983 2984 default: 2985 /* This should not happen. */ 2986 if (cname) 2987 *cname = xstrdup ("???"); 2988 if (cfull_expression) 2989 *cfull_expression = xstrdup ("???"); 2990 /* Don't set value and type, we don't know then. */ 2991 } 2992 } 2993 2994 static char * 2995 c_name_of_child (struct varobj *parent, int index) 2996 { 2997 char *name; 2998 2999 c_describe_child (parent, index, &name, NULL, NULL, NULL); 3000 return name; 3001 } 3002 3003 static char * 3004 c_path_expr_of_child (struct varobj *child) 3005 { 3006 c_describe_child (child->parent, child->index, NULL, NULL, NULL, 3007 &child->path_expr); 3008 return child->path_expr; 3009 } 3010 3011 /* If frame associated with VAR can be found, switch 3012 to it and return 1. Otherwise, return 0. */ 3013 static int 3014 check_scope (struct varobj *var) 3015 { 3016 struct frame_info *fi; 3017 int scope; 3018 3019 fi = frame_find_by_id (var->root->frame); 3020 scope = fi != NULL; 3021 3022 if (fi) 3023 { 3024 CORE_ADDR pc = get_frame_pc (fi); 3025 3026 if (pc < BLOCK_START (var->root->valid_block) || 3027 pc >= BLOCK_END (var->root->valid_block)) 3028 scope = 0; 3029 else 3030 select_frame (fi); 3031 } 3032 return scope; 3033 } 3034 3035 static struct value * 3036 c_value_of_root (struct varobj **var_handle) 3037 { 3038 struct value *new_val = NULL; 3039 struct varobj *var = *var_handle; 3040 int within_scope = 0; 3041 struct cleanup *back_to; 3042 3043 /* Only root variables can be updated... */ 3044 if (!is_root_p (var)) 3045 /* Not a root var. */ 3046 return NULL; 3047 3048 back_to = make_cleanup_restore_current_thread (); 3049 3050 /* Determine whether the variable is still around. */ 3051 if (var->root->valid_block == NULL || var->root->floating) 3052 within_scope = 1; 3053 else if (var->root->thread_id == 0) 3054 { 3055 /* The program was single-threaded when the variable object was 3056 created. Technically, it's possible that the program became 3057 multi-threaded since then, but we don't support such 3058 scenario yet. */ 3059 within_scope = check_scope (var); 3060 } 3061 else 3062 { 3063 ptid_t ptid = thread_id_to_pid (var->root->thread_id); 3064 if (in_thread_list (ptid)) 3065 { 3066 switch_to_thread (ptid); 3067 within_scope = check_scope (var); 3068 } 3069 } 3070 3071 if (within_scope) 3072 { 3073 /* We need to catch errors here, because if evaluate 3074 expression fails we want to just return NULL. */ 3075 gdb_evaluate_expression (var->root->exp, &new_val); 3076 return new_val; 3077 } 3078 3079 do_cleanups (back_to); 3080 3081 return NULL; 3082 } 3083 3084 static struct value * 3085 c_value_of_child (struct varobj *parent, int index) 3086 { 3087 struct value *value = NULL; 3088 3089 c_describe_child (parent, index, NULL, &value, NULL, NULL); 3090 return value; 3091 } 3092 3093 static struct type * 3094 c_type_of_child (struct varobj *parent, int index) 3095 { 3096 struct type *type = NULL; 3097 3098 c_describe_child (parent, index, NULL, NULL, &type, NULL); 3099 return type; 3100 } 3101 3102 static char * 3103 c_value_of_variable (struct varobj *var, enum varobj_display_formats format) 3104 { 3105 /* BOGUS: if val_print sees a struct/class, or a reference to one, 3106 it will print out its children instead of "{...}". So we need to 3107 catch that case explicitly. */ 3108 struct type *type = get_type (var); 3109 3110 /* If we have a custom formatter, return whatever string it has 3111 produced. */ 3112 if (var->pretty_printer && var->print_value) 3113 return xstrdup (var->print_value); 3114 3115 /* Strip top-level references. */ 3116 while (TYPE_CODE (type) == TYPE_CODE_REF) 3117 type = check_typedef (TYPE_TARGET_TYPE (type)); 3118 3119 switch (TYPE_CODE (type)) 3120 { 3121 case TYPE_CODE_STRUCT: 3122 case TYPE_CODE_UNION: 3123 return xstrdup ("{...}"); 3124 /* break; */ 3125 3126 case TYPE_CODE_ARRAY: 3127 { 3128 char *number; 3129 3130 number = xstrprintf ("[%d]", var->num_children); 3131 return (number); 3132 } 3133 /* break; */ 3134 3135 default: 3136 { 3137 if (var->value == NULL) 3138 { 3139 /* This can happen if we attempt to get the value of a struct 3140 member when the parent is an invalid pointer. This is an 3141 error condition, so we should tell the caller. */ 3142 return NULL; 3143 } 3144 else 3145 { 3146 if (var->not_fetched && value_lazy (var->value)) 3147 /* Frozen variable and no value yet. We don't 3148 implicitly fetch the value. MI response will 3149 use empty string for the value, which is OK. */ 3150 return NULL; 3151 3152 gdb_assert (varobj_value_is_changeable_p (var)); 3153 gdb_assert (!value_lazy (var->value)); 3154 3155 /* If the specified format is the current one, 3156 we can reuse print_value. */ 3157 if (format == var->format) 3158 return xstrdup (var->print_value); 3159 else 3160 return value_get_print_value (var->value, format, var); 3161 } 3162 } 3163 } 3164 } 3165 3166 3167 /* C++ */ 3168 3169 static int 3170 cplus_number_of_children (struct varobj *var) 3171 { 3172 struct type *type; 3173 int children, dont_know; 3174 3175 dont_know = 1; 3176 children = 0; 3177 3178 if (!CPLUS_FAKE_CHILD (var)) 3179 { 3180 type = get_value_type (var); 3181 adjust_value_for_child_access (NULL, &type, NULL); 3182 3183 if (((TYPE_CODE (type)) == TYPE_CODE_STRUCT) || 3184 ((TYPE_CODE (type)) == TYPE_CODE_UNION)) 3185 { 3186 int kids[3]; 3187 3188 cplus_class_num_children (type, kids); 3189 if (kids[v_public] != 0) 3190 children++; 3191 if (kids[v_private] != 0) 3192 children++; 3193 if (kids[v_protected] != 0) 3194 children++; 3195 3196 /* Add any baseclasses. */ 3197 children += TYPE_N_BASECLASSES (type); 3198 dont_know = 0; 3199 3200 /* FIXME: save children in var. */ 3201 } 3202 } 3203 else 3204 { 3205 int kids[3]; 3206 3207 type = get_value_type (var->parent); 3208 adjust_value_for_child_access (NULL, &type, NULL); 3209 3210 cplus_class_num_children (type, kids); 3211 if (strcmp (var->name, "public") == 0) 3212 children = kids[v_public]; 3213 else if (strcmp (var->name, "private") == 0) 3214 children = kids[v_private]; 3215 else 3216 children = kids[v_protected]; 3217 dont_know = 0; 3218 } 3219 3220 if (dont_know) 3221 children = c_number_of_children (var); 3222 3223 return children; 3224 } 3225 3226 /* Compute # of public, private, and protected variables in this class. 3227 That means we need to descend into all baseclasses and find out 3228 how many are there, too. */ 3229 static void 3230 cplus_class_num_children (struct type *type, int children[3]) 3231 { 3232 int i, vptr_fieldno; 3233 struct type *basetype = NULL; 3234 3235 children[v_public] = 0; 3236 children[v_private] = 0; 3237 children[v_protected] = 0; 3238 3239 vptr_fieldno = get_vptr_fieldno (type, &basetype); 3240 for (i = TYPE_N_BASECLASSES (type); i < TYPE_NFIELDS (type); i++) 3241 { 3242 /* If we have a virtual table pointer, omit it. Even if virtual 3243 table pointers are not specifically marked in the debug info, 3244 they should be artificial. */ 3245 if ((type == basetype && i == vptr_fieldno) 3246 || TYPE_FIELD_ARTIFICIAL (type, i)) 3247 continue; 3248 3249 if (TYPE_FIELD_PROTECTED (type, i)) 3250 children[v_protected]++; 3251 else if (TYPE_FIELD_PRIVATE (type, i)) 3252 children[v_private]++; 3253 else 3254 children[v_public]++; 3255 } 3256 } 3257 3258 static char * 3259 cplus_name_of_variable (struct varobj *parent) 3260 { 3261 return c_name_of_variable (parent); 3262 } 3263 3264 enum accessibility { private_field, protected_field, public_field }; 3265 3266 /* Check if field INDEX of TYPE has the specified accessibility. 3267 Return 0 if so and 1 otherwise. */ 3268 static int 3269 match_accessibility (struct type *type, int index, enum accessibility acc) 3270 { 3271 if (acc == private_field && TYPE_FIELD_PRIVATE (type, index)) 3272 return 1; 3273 else if (acc == protected_field && TYPE_FIELD_PROTECTED (type, index)) 3274 return 1; 3275 else if (acc == public_field && !TYPE_FIELD_PRIVATE (type, index) 3276 && !TYPE_FIELD_PROTECTED (type, index)) 3277 return 1; 3278 else 3279 return 0; 3280 } 3281 3282 static void 3283 cplus_describe_child (struct varobj *parent, int index, 3284 char **cname, struct value **cvalue, struct type **ctype, 3285 char **cfull_expression) 3286 { 3287 struct value *value; 3288 struct type *type; 3289 int was_ptr; 3290 char *parent_expression = NULL; 3291 3292 if (cname) 3293 *cname = NULL; 3294 if (cvalue) 3295 *cvalue = NULL; 3296 if (ctype) 3297 *ctype = NULL; 3298 if (cfull_expression) 3299 *cfull_expression = NULL; 3300 3301 if (CPLUS_FAKE_CHILD (parent)) 3302 { 3303 value = parent->parent->value; 3304 type = get_value_type (parent->parent); 3305 if (cfull_expression) 3306 parent_expression = varobj_get_path_expr (parent->parent); 3307 } 3308 else 3309 { 3310 value = parent->value; 3311 type = get_value_type (parent); 3312 if (cfull_expression) 3313 parent_expression = varobj_get_path_expr (parent); 3314 } 3315 3316 adjust_value_for_child_access (&value, &type, &was_ptr); 3317 3318 if (TYPE_CODE (type) == TYPE_CODE_STRUCT 3319 || TYPE_CODE (type) == TYPE_CODE_UNION) 3320 { 3321 char *join = was_ptr ? "->" : "."; 3322 3323 if (CPLUS_FAKE_CHILD (parent)) 3324 { 3325 /* The fields of the class type are ordered as they 3326 appear in the class. We are given an index for a 3327 particular access control type ("public","protected", 3328 or "private"). We must skip over fields that don't 3329 have the access control we are looking for to properly 3330 find the indexed field. */ 3331 int type_index = TYPE_N_BASECLASSES (type); 3332 enum accessibility acc = public_field; 3333 int vptr_fieldno; 3334 struct type *basetype = NULL; 3335 3336 vptr_fieldno = get_vptr_fieldno (type, &basetype); 3337 if (strcmp (parent->name, "private") == 0) 3338 acc = private_field; 3339 else if (strcmp (parent->name, "protected") == 0) 3340 acc = protected_field; 3341 3342 while (index >= 0) 3343 { 3344 if ((type == basetype && type_index == vptr_fieldno) 3345 || TYPE_FIELD_ARTIFICIAL (type, type_index)) 3346 ; /* ignore vptr */ 3347 else if (match_accessibility (type, type_index, acc)) 3348 --index; 3349 ++type_index; 3350 } 3351 --type_index; 3352 3353 if (cname) 3354 *cname = xstrdup (TYPE_FIELD_NAME (type, type_index)); 3355 3356 if (cvalue && value) 3357 *cvalue = value_struct_element_index (value, type_index); 3358 3359 if (ctype) 3360 *ctype = TYPE_FIELD_TYPE (type, type_index); 3361 3362 if (cfull_expression) 3363 *cfull_expression 3364 = xstrprintf ("((%s)%s%s)", parent_expression, 3365 join, 3366 TYPE_FIELD_NAME (type, type_index)); 3367 } 3368 else if (index < TYPE_N_BASECLASSES (type)) 3369 { 3370 /* This is a baseclass. */ 3371 if (cname) 3372 *cname = xstrdup (TYPE_FIELD_NAME (type, index)); 3373 3374 if (cvalue && value) 3375 *cvalue = value_cast (TYPE_FIELD_TYPE (type, index), value); 3376 3377 if (ctype) 3378 { 3379 *ctype = TYPE_FIELD_TYPE (type, index); 3380 } 3381 3382 if (cfull_expression) 3383 { 3384 char *ptr = was_ptr ? "*" : ""; 3385 3386 /* Cast the parent to the base' type. Note that in gdb, 3387 expression like 3388 (Base1)d 3389 will create an lvalue, for all appearences, so we don't 3390 need to use more fancy: 3391 *(Base1*)(&d) 3392 construct. */ 3393 *cfull_expression = xstrprintf ("(%s(%s%s) %s)", 3394 ptr, 3395 TYPE_FIELD_NAME (type, index), 3396 ptr, 3397 parent_expression); 3398 } 3399 } 3400 else 3401 { 3402 char *access = NULL; 3403 int children[3]; 3404 3405 cplus_class_num_children (type, children); 3406 3407 /* Everything beyond the baseclasses can 3408 only be "public", "private", or "protected" 3409 3410 The special "fake" children are always output by varobj in 3411 this order. So if INDEX == 2, it MUST be "protected". */ 3412 index -= TYPE_N_BASECLASSES (type); 3413 switch (index) 3414 { 3415 case 0: 3416 if (children[v_public] > 0) 3417 access = "public"; 3418 else if (children[v_private] > 0) 3419 access = "private"; 3420 else 3421 access = "protected"; 3422 break; 3423 case 1: 3424 if (children[v_public] > 0) 3425 { 3426 if (children[v_private] > 0) 3427 access = "private"; 3428 else 3429 access = "protected"; 3430 } 3431 else if (children[v_private] > 0) 3432 access = "protected"; 3433 break; 3434 case 2: 3435 /* Must be protected. */ 3436 access = "protected"; 3437 break; 3438 default: 3439 /* error! */ 3440 break; 3441 } 3442 3443 gdb_assert (access); 3444 if (cname) 3445 *cname = xstrdup (access); 3446 3447 /* Value and type and full expression are null here. */ 3448 } 3449 } 3450 else 3451 { 3452 c_describe_child (parent, index, cname, cvalue, ctype, cfull_expression); 3453 } 3454 } 3455 3456 static char * 3457 cplus_name_of_child (struct varobj *parent, int index) 3458 { 3459 char *name = NULL; 3460 3461 cplus_describe_child (parent, index, &name, NULL, NULL, NULL); 3462 return name; 3463 } 3464 3465 static char * 3466 cplus_path_expr_of_child (struct varobj *child) 3467 { 3468 cplus_describe_child (child->parent, child->index, NULL, NULL, NULL, 3469 &child->path_expr); 3470 return child->path_expr; 3471 } 3472 3473 static struct value * 3474 cplus_value_of_root (struct varobj **var_handle) 3475 { 3476 return c_value_of_root (var_handle); 3477 } 3478 3479 static struct value * 3480 cplus_value_of_child (struct varobj *parent, int index) 3481 { 3482 struct value *value = NULL; 3483 3484 cplus_describe_child (parent, index, NULL, &value, NULL, NULL); 3485 return value; 3486 } 3487 3488 static struct type * 3489 cplus_type_of_child (struct varobj *parent, int index) 3490 { 3491 struct type *type = NULL; 3492 3493 cplus_describe_child (parent, index, NULL, NULL, &type, NULL); 3494 return type; 3495 } 3496 3497 static char * 3498 cplus_value_of_variable (struct varobj *var, 3499 enum varobj_display_formats format) 3500 { 3501 3502 /* If we have one of our special types, don't print out 3503 any value. */ 3504 if (CPLUS_FAKE_CHILD (var)) 3505 return xstrdup (""); 3506 3507 return c_value_of_variable (var, format); 3508 } 3509 3510 /* Java */ 3511 3512 static int 3513 java_number_of_children (struct varobj *var) 3514 { 3515 return cplus_number_of_children (var); 3516 } 3517 3518 static char * 3519 java_name_of_variable (struct varobj *parent) 3520 { 3521 char *p, *name; 3522 3523 name = cplus_name_of_variable (parent); 3524 /* If the name has "-" in it, it is because we 3525 needed to escape periods in the name... */ 3526 p = name; 3527 3528 while (*p != '\000') 3529 { 3530 if (*p == '-') 3531 *p = '.'; 3532 p++; 3533 } 3534 3535 return name; 3536 } 3537 3538 static char * 3539 java_name_of_child (struct varobj *parent, int index) 3540 { 3541 char *name, *p; 3542 3543 name = cplus_name_of_child (parent, index); 3544 /* Escape any periods in the name... */ 3545 p = name; 3546 3547 while (*p != '\000') 3548 { 3549 if (*p == '.') 3550 *p = '-'; 3551 p++; 3552 } 3553 3554 return name; 3555 } 3556 3557 static char * 3558 java_path_expr_of_child (struct varobj *child) 3559 { 3560 return NULL; 3561 } 3562 3563 static struct value * 3564 java_value_of_root (struct varobj **var_handle) 3565 { 3566 return cplus_value_of_root (var_handle); 3567 } 3568 3569 static struct value * 3570 java_value_of_child (struct varobj *parent, int index) 3571 { 3572 return cplus_value_of_child (parent, index); 3573 } 3574 3575 static struct type * 3576 java_type_of_child (struct varobj *parent, int index) 3577 { 3578 return cplus_type_of_child (parent, index); 3579 } 3580 3581 static char * 3582 java_value_of_variable (struct varobj *var, enum varobj_display_formats format) 3583 { 3584 return cplus_value_of_variable (var, format); 3585 } 3586 3587 /* Iterate all the existing _root_ VAROBJs and call the FUNC callback for them 3588 with an arbitrary caller supplied DATA pointer. */ 3589 3590 void 3591 all_root_varobjs (void (*func) (struct varobj *var, void *data), void *data) 3592 { 3593 struct varobj_root *var_root, *var_root_next; 3594 3595 /* Iterate "safely" - handle if the callee deletes its passed VAROBJ. */ 3596 3597 for (var_root = rootlist; var_root != NULL; var_root = var_root_next) 3598 { 3599 var_root_next = var_root->next; 3600 3601 (*func) (var_root->rootvar, data); 3602 } 3603 } 3604 3605 extern void _initialize_varobj (void); 3606 void 3607 _initialize_varobj (void) 3608 { 3609 int sizeof_table = sizeof (struct vlist *) * VAROBJ_TABLE_SIZE; 3610 3611 varobj_table = xmalloc (sizeof_table); 3612 memset (varobj_table, 0, sizeof_table); 3613 3614 add_setshow_zinteger_cmd ("debugvarobj", class_maintenance, 3615 &varobjdebug, 3616 _("Set varobj debugging."), 3617 _("Show varobj debugging."), 3618 _("When non-zero, varobj debugging is enabled."), 3619 NULL, show_varobjdebug, 3620 &setlist, &showlist); 3621 } 3622 3623 /* Invalidate varobj VAR if it is tied to locals and re-create it if it is 3624 defined on globals. It is a helper for varobj_invalidate. */ 3625 3626 static void 3627 varobj_invalidate_iter (struct varobj *var, void *unused) 3628 { 3629 /* Floating varobjs are reparsed on each stop, so we don't care if the 3630 presently parsed expression refers to something that's gone. */ 3631 if (var->root->floating) 3632 return; 3633 3634 /* global var must be re-evaluated. */ 3635 if (var->root->valid_block == NULL) 3636 { 3637 struct varobj *tmp_var; 3638 3639 /* Try to create a varobj with same expression. If we succeed 3640 replace the old varobj, otherwise invalidate it. */ 3641 tmp_var = varobj_create (NULL, var->name, (CORE_ADDR) 0, 3642 USE_CURRENT_FRAME); 3643 if (tmp_var != NULL) 3644 { 3645 tmp_var->obj_name = xstrdup (var->obj_name); 3646 varobj_delete (var, NULL, 0); 3647 install_variable (tmp_var); 3648 } 3649 else 3650 var->root->is_valid = 0; 3651 } 3652 else /* locals must be invalidated. */ 3653 var->root->is_valid = 0; 3654 } 3655 3656 /* Invalidate the varobjs that are tied to locals and re-create the ones that 3657 are defined on globals. 3658 Invalidated varobjs will be always printed in_scope="invalid". */ 3659 3660 void 3661 varobj_invalidate (void) 3662 { 3663 all_root_varobjs (varobj_invalidate_iter, NULL); 3664 } 3665