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