rocket-tools/riscv-gnu-toolchain/qemu/roms/u-boot.git - Unnamed repository; edit this file 'description' to name the repository.

diff options

Diffstat (limited to 'arch')

-rw-r--r--

1 files changed, 7 insertions, 0 deletions

/* Implementation of the GDB variable objects API. Copyright (C) 1999-2020 Free Software Foundation, Inc. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see <http://www.gnu.org/licenses/>. */ #include "defs.h" #include "value.h" #include "expression.h" #include "frame.h" #include "language.h" #include "gdbcmd.h" #include "block.h" #include "valprint.h" #include "gdb_regex.h" #include "varobj.h" #include "gdbthread.h" #include "inferior.h" #include "varobj-iter.h" #include "parser-defs.h" #include "gdbarch.h" #if HAVE_PYTHON #include "python/python.h" #include "python/python-internal.h" #else typedef int PyObject; #endif /* See varobj.h. */ unsigned int varobjdebug = 0; static void show_varobjdebug (struct ui_file *file, int from_tty, struct cmd_list_element *c, const char *value) { fprintf_filtered (file, _("Varobj debugging is %s.\n"), value); } /* String representations of gdb's format codes. */ const char *varobj_format_string[] = { "natural", "binary", "decimal", "hexadecimal", "octal", "zero-hexadecimal" }; /* True if we want to allow Python-based pretty-printing. */ static bool pretty_printing = false; void varobj_enable_pretty_printing (void) { pretty_printing = true; } /* Data structures */ /* Every root variable has one of these structures saved in its varobj. */ struct varobj_root { /* The expression for this parent. */ expression_up exp; /* Block for which this expression is valid. */ const struct block *valid_block = NULL; /* The frame for this expression. This field is set iff valid_block is not NULL. */ struct frame_id frame = null_frame_id; /* The global thread ID that this varobj_root belongs to. This field is only valid if valid_block is not NULL. When not 0, indicates which thread 'frame' belongs to. When 0, indicates that the thread list was empty when the varobj_root was created. */ int thread_id = 0; /* If true, the -var-update always recomputes the value in the current thread and frame. Otherwise, variable object is always updated in the specific scope/thread/frame. */ bool floating = false; /* Flag that indicates validity: set to false when this varobj_root refers to symbols that do not exist anymore. */ bool is_valid = true; /* Language-related operations for this variable and its children. */ const struct lang_varobj_ops *lang_ops = NULL; /* The varobj for this root node. */ struct varobj *rootvar = NULL; /* Next root variable */ struct varobj_root *next = NULL; }; /* Dynamic part of varobj. */ struct varobj_dynamic { /* Whether the children of this varobj were requested. This field is used to decide if dynamic varobj should recompute their children. In the event that the frontend never asked for the children, we can avoid that. */ bool children_requested = false; /* The pretty-printer constructor. If NULL, then the default pretty-printer will be looked up. If None, then no pretty-printer will be installed. */ PyObject *constructor = NULL; /* The pretty-printer that has been constructed. If NULL, then a new printer object is needed, and one will be constructed. */ PyObject *pretty_printer = NULL; /* The iterator returned by the printer's 'children' method, or NULL if not available. */ struct varobj_iter *child_iter = NULL; /* We request one extra item from the iterator, so that we can report to the caller whether there are more items than we have already reported. However, we don't want to install this value when we read it, because that will mess up future updates. So, we stash it here instead. */ varobj_item *saved_item = NULL; }; /* A list of varobjs */ struct vlist { struct varobj *var; struct vlist *next; }; /* Private function prototypes */ /* Helper functions for the above subcommands. */ static int delete_variable (struct varobj *, bool); static void delete_variable_1 (int *, struct varobj *, bool, bool); static bool install_variable (struct varobj *); static void uninstall_variable (struct varobj *); static struct varobj *create_child (struct varobj *, int, std::string &); static struct varobj * create_child_with_value (struct varobj *parent, int index, struct varobj_item *item); /* Utility routines */ static enum varobj_display_formats variable_default_display (struct varobj *); static bool update_type_if_necessary (struct varobj *var, struct value *new_value); static bool install_new_value (struct varobj *var, struct value *value, bool initial); /* Language-specific routines. */ static int number_of_children (const struct varobj *); static std::string name_of_variable (const struct varobj *); static std::string name_of_child (struct varobj *, int); static struct value *value_of_root (struct varobj **var_handle, bool *); static struct value *value_of_child (const struct varobj *parent, int index); static std::string my_value_of_variable (struct varobj *var, enum varobj_display_formats format); static bool is_root_p (const struct varobj *var); static struct varobj *varobj_add_child (struct varobj *var, struct varobj_item *item); /* Private data */ /* Mappings of varobj_display_formats enums to gdb's format codes. */ static int format_code[] = { 0, 't', 'd', 'x', 'o', 'z' }; /* Header of the list of root variable objects. */ static struct varobj_root *rootlist; /* Prime number indicating the number of buckets in the hash table. */ /* A prime large enough to avoid too many collisions. */ #define VAROBJ_TABLE_SIZE 227 /* Pointer to the varobj hash table (built at run time). */ static struct vlist **varobj_table; /* API Implementation */ static bool is_root_p (const struct varobj *var) { return (var->root->rootvar == var); } #ifdef HAVE_PYTHON /* See python-internal.h. */ gdbpy_enter_varobj::gdbpy_enter_varobj (const struct varobj *var) : gdbpy_enter (var->root->exp->gdbarch, var->root->exp->language_defn) { } #endif /* Return the full FRAME which corresponds to the given CORE_ADDR or NULL if no FRAME on the chain corresponds to CORE_ADDR. */ static struct frame_info * find_frame_addr_in_frame_chain (CORE_ADDR frame_addr) { struct frame_info *frame = NULL; if (frame_addr == (CORE_ADDR) 0) return NULL; for (frame = get_current_frame (); frame != NULL; frame = get_prev_frame (frame)) { /* The CORE_ADDR we get as argument was parsed from a string GDB output as $fp. This output got truncated to gdbarch_addr_bit. Truncate the frame base address in the same manner before comparing it against our argument. */ CORE_ADDR frame_base = get_frame_base_address (frame); int addr_bit = gdbarch_addr_bit (get_frame_arch (frame)); if (addr_bit < (sizeof (CORE_ADDR) * HOST_CHAR_BIT)) frame_base &= ((CORE_ADDR) 1 << addr_bit) - 1; if (frame_base == frame_addr) return frame; } return NULL; } /* Creates a varobj (not its children). */ struct varobj * varobj_create (const char *objname, const char *expression, CORE_ADDR frame, enum varobj_type type) { /* Fill out a varobj structure for the (root) variable being constructed. */ std::unique_ptr<varobj> var (new varobj (new varobj_root)); if (expression != NULL) { struct frame_info *fi; struct frame_id old_id = null_frame_id; const struct block *block; const char *p; struct value *value = NULL; CORE_ADDR pc; /* Parse and evaluate the expression, filling in as much of the variable's data as possible. */ if (has_stack_frames ()) { /* Allow creator to specify context of variable. */ if ((type == USE_CURRENT_FRAME) || (type == USE_SELECTED_FRAME)) fi = get_selected_frame (NULL); else /* FIXME: cagney/2002-11-23: This code should be doing a lookup using the frame ID and not just the frame's ``address''. This, of course, means an interface change. However, with out that interface change ISAs, such as the ia64 with its two stacks, won't work. Similar goes for the case where there is a frameless function. */ fi = find_frame_addr_in_frame_chain (frame); } else fi = NULL; if (type == USE_SELECTED_FRAME) var->root->floating = true; pc = 0; block = NULL; if (fi != NULL) { block = get_frame_block (fi, 0); pc = get_frame_pc (fi); } p = expression; innermost_block_tracker tracker (INNERMOST_BLOCK_FOR_SYMBOLS | INNERMOST_BLOCK_FOR_REGISTERS); /* Wrap the call to parse expression, so we can return a sensible error. */ try { var->root->exp = parse_exp_1 (&p, pc, block, 0, &tracker); } catch (const gdb_exception_error &except) { return NULL; } /* Don't allow variables to be created for types. */ if (var->root->exp->elts[0].opcode == OP_TYPE || var->root->exp->elts[0].opcode == OP_TYPEOF || var->root->exp->elts[0].opcode == OP_DECLTYPE) { fprintf_unfiltered (gdb_stderr, "Attempt to use a type name" " as an expression.\n"); return NULL; } var->format = variable_default_display (var.get ()); var->root->valid_block = var->root->floating ? NULL : tracker.block (); var->name = expression; /* For a root var, the name and the expr are the same. */ var->path_expr = expression; /* When the frame is different from the current frame, we must select the appropriate frame before parsing the expression, otherwise the value will not be current. Since select_frame is so benign, just call it for all cases. */ if (var->root->valid_block) { /* User could specify explicit FRAME-ADDR which was not found but EXPRESSION is frame specific and we would not be able to evaluate it correctly next time. With VALID_BLOCK set we must also set FRAME and THREAD_ID. */ if (fi == NULL) error (_("Failed to find the specified frame")); var->root->frame = get_frame_id (fi); var->root->thread_id = inferior_thread ()->global_num; old_id = get_frame_id (get_selected_frame (NULL)); select_frame (fi); } /* We definitely need to catch errors here. If evaluate_expression succeeds we got the value we wanted. But if it fails, we still go on with a call to evaluate_type(). */ try { value = evaluate_expression (var->root->exp.get ()); } catch (const gdb_exception_error &except) { /* Error getting the value. Try to at least get the right type. */ struct value *type_only_value = evaluate_type (var->root->exp.get ()); var->type = value_type (type_only_value); } if (value != NULL) { int real_type_found = 0;


context:
space:
mode: