/* MI prints only certain values according to the type of symbol and also what the user has specified. SYM is the symbol to check, and MI_PRINT_TYPES is an enum specifying what the user wants emitted for the MI command in question. */ static int mi_should_print (struct symbol *sym, enum mi_print_types type) { int print_me = 0; switch (SYMBOL_CLASS (sym)) { default: case LOC_UNDEF: /* catches errors */ case LOC_CONST: /* constant */ case LOC_TYPEDEF: /* local typedef */ case LOC_LABEL: /* local label */ case LOC_BLOCK: /* local function */ case LOC_CONST_BYTES: /* loc. byte seq. */ case LOC_UNRESOLVED: /* unresolved static */ case LOC_OPTIMIZED_OUT: /* optimized out */ print_me = 0; break; case LOC_ARG: /* argument */ case LOC_REF_ARG: /* reference arg */ case LOC_REGPARM_ADDR: /* indirect register arg */ case LOC_LOCAL: /* stack local */ case LOC_STATIC: /* static */ case LOC_REGISTER: /* register */ case LOC_COMPUTED: /* computed location */ if (type == MI_PRINT_LOCALS) print_me = ! SYMBOL_IS_ARGUMENT (sym); else print_me = SYMBOL_IS_ARGUMENT (sym); } return print_me; }
static PyObject * sympy_is_argument (PyObject *self, void *closure) { struct symbol *symbol = NULL; SYMPY_REQUIRE_VALID (self, symbol); return PyBool_FromLong (SYMBOL_IS_ARGUMENT (symbol)); }
static SCM gdbscm_symbol_argument_p (SCM self) { symbol_smob *s_smob = syscm_get_valid_symbol_smob_arg_unsafe (self, SCM_ARG1, FUNC_NAME); const struct symbol *symbol = s_smob->symbol; return scm_from_bool (SYMBOL_IS_ARGUMENT (symbol)); }
static SCM gdbscm_symbol_variable_p (SCM self) { symbol_smob *s_smob = syscm_get_valid_symbol_smob_arg_unsafe (self, SCM_ARG1, FUNC_NAME); const struct symbol *symbol = s_smob->symbol; enum address_class theclass; theclass = SYMBOL_CLASS (symbol); return scm_from_bool (!SYMBOL_IS_ARGUMENT (symbol) && (theclass == LOC_LOCAL || theclass == LOC_REGISTER || theclass == LOC_STATIC || theclass == LOC_COMPUTED || theclass == LOC_OPTIMIZED_OUT)); }
static PyObject * sympy_is_variable (PyObject *self, void *closure) { struct symbol *symbol = NULL; enum address_class theclass; SYMPY_REQUIRE_VALID (self, symbol); theclass = SYMBOL_CLASS (symbol); return PyBool_FromLong (!SYMBOL_IS_ARGUMENT (symbol) && (theclass == LOC_LOCAL || theclass == LOC_REGISTER || theclass == LOC_STATIC || theclass == LOC_COMPUTED || theclass == LOC_OPTIMIZED_OUT)); }
static void list_args_or_locals (enum what_to_list what, enum print_values values, struct frame_info *fi, int skip_unavailable) { const struct block *block; struct symbol *sym; struct block_iterator iter; struct cleanup *cleanup_list; struct type *type; char *name_of_result; struct ui_out *uiout = current_uiout; block = get_frame_block (fi, 0); switch (what) { case locals: name_of_result = "locals"; break; case arguments: name_of_result = "args"; break; case all: name_of_result = "variables"; break; default: internal_error (__FILE__, __LINE__, "unexpected what_to_list: %d", (int) what); } cleanup_list = make_cleanup_ui_out_list_begin_end (uiout, name_of_result); while (block != 0) { ALL_BLOCK_SYMBOLS (block, iter, sym) { int print_me = 0; switch (SYMBOL_CLASS (sym)) { default: case LOC_UNDEF: /* catches errors */ case LOC_CONST: /* constant */ case LOC_TYPEDEF: /* local typedef */ case LOC_LABEL: /* local label */ case LOC_BLOCK: /* local function */ case LOC_CONST_BYTES: /* loc. byte seq. */ case LOC_UNRESOLVED: /* unresolved static */ case LOC_OPTIMIZED_OUT: /* optimized out */ print_me = 0; break; case LOC_ARG: /* argument */ case LOC_REF_ARG: /* reference arg */ case LOC_REGPARM_ADDR: /* indirect register arg */ case LOC_LOCAL: /* stack local */ case LOC_STATIC: /* static */ case LOC_REGISTER: /* register */ case LOC_COMPUTED: /* computed location */ if (what == all) print_me = 1; else if (what == locals) print_me = !SYMBOL_IS_ARGUMENT (sym); else print_me = SYMBOL_IS_ARGUMENT (sym); break; } if (print_me) { struct symbol *sym2; struct frame_arg arg, entryarg; if (SYMBOL_IS_ARGUMENT (sym)) sym2 = lookup_symbol (SYMBOL_LINKAGE_NAME (sym), block, VAR_DOMAIN, NULL); else sym2 = sym; gdb_assert (sym2 != NULL); memset (&arg, 0, sizeof (arg)); arg.sym = sym2; arg.entry_kind = print_entry_values_no; memset (&entryarg, 0, sizeof (entryarg)); entryarg.sym = sym2; entryarg.entry_kind = print_entry_values_no; switch (values) { case PRINT_SIMPLE_VALUES: type = check_typedef (sym2->type); if (TYPE_CODE (type) != TYPE_CODE_ARRAY && TYPE_CODE (type) != TYPE_CODE_STRUCT && TYPE_CODE (type) != TYPE_CODE_UNION) { case PRINT_ALL_VALUES: if (SYMBOL_IS_ARGUMENT (sym)) read_frame_arg (sym2, fi, &arg, &entryarg); else read_frame_local (sym2, fi, &arg); } break; } if (arg.entry_kind != print_entry_values_only) list_arg_or_local (&arg, what, values, skip_unavailable); if (entryarg.entry_kind != print_entry_values_no) list_arg_or_local (&entryarg, what, values, skip_unavailable); xfree (arg.error); xfree (entryarg.error); } } if (BLOCK_FUNCTION (block)) break; else block = BLOCK_SUPERBLOCK (block); }
static void list_arg_or_local (const struct frame_arg *arg, enum what_to_list what, enum print_values values, int skip_unavailable) { struct cleanup *old_chain; struct ui_out *uiout = current_uiout; struct ui_file *stb; gdb_assert (!arg->val || !arg->error); gdb_assert ((values == PRINT_NO_VALUES && arg->val == NULL && arg->error == NULL) || values == PRINT_SIMPLE_VALUES || (values == PRINT_ALL_VALUES && (arg->val != NULL || arg->error != NULL))); gdb_assert (arg->entry_kind == print_entry_values_no || (arg->entry_kind == print_entry_values_only && (arg->val || arg->error))); if (skip_unavailable && arg->val != NULL && (value_entirely_unavailable (arg->val) /* A scalar object that does not have all bits available is also considered unavailable, because all bits contribute to its representation. */ || (val_print_scalar_type_p (value_type (arg->val)) && !value_bytes_available (arg->val, value_embedded_offset (arg->val), TYPE_LENGTH (value_type (arg->val)))))) return; stb = mem_fileopen (); old_chain = make_cleanup_ui_file_delete (stb); if (values != PRINT_NO_VALUES || what == all) make_cleanup_ui_out_tuple_begin_end (uiout, NULL); fputs_filtered (SYMBOL_PRINT_NAME (arg->sym), stb); if (arg->entry_kind == print_entry_values_only) fputs_filtered ("@entry", stb); ui_out_field_stream (uiout, "name", stb); if (what == all && SYMBOL_IS_ARGUMENT (arg->sym)) ui_out_field_int (uiout, "arg", 1); if (values == PRINT_SIMPLE_VALUES) { check_typedef (arg->sym->type); type_print (arg->sym->type, "", stb, -1); ui_out_field_stream (uiout, "type", stb); } if (arg->val || arg->error) { const char *error_message = NULL; if (arg->error) error_message = arg->error; else { TRY { struct value_print_options opts; get_no_prettyformat_print_options (&opts); opts.deref_ref = 1; common_val_print (arg->val, stb, 0, &opts, language_def (SYMBOL_LANGUAGE (arg->sym))); } CATCH (except, RETURN_MASK_ERROR) { error_message = except.message; } END_CATCH } if (error_message != NULL) fprintf_filtered (stb, _("<error reading variable: %s>"), error_message); ui_out_field_stream (uiout, "value", stb); } do_cleanups (old_chain); }
static void list_arg_or_local (const struct frame_arg *arg, enum what_to_list what, enum print_values values) { struct cleanup *old_chain; struct ui_out *uiout = current_uiout; struct ui_file *stb; stb = mem_fileopen (); old_chain = make_cleanup_ui_file_delete (stb); gdb_assert (!arg->val || !arg->error); gdb_assert ((values == PRINT_NO_VALUES && arg->val == NULL && arg->error == NULL) || values == PRINT_SIMPLE_VALUES || (values == PRINT_ALL_VALUES && (arg->val != NULL || arg->error != NULL))); gdb_assert (arg->entry_kind == print_entry_values_no || (arg->entry_kind == print_entry_values_only && (arg->val || arg->error))); if (values != PRINT_NO_VALUES || what == all) make_cleanup_ui_out_tuple_begin_end (uiout, NULL); fputs_filtered (SYMBOL_PRINT_NAME (arg->sym), stb); if (arg->entry_kind == print_entry_values_only) fputs_filtered ("@entry", stb); ui_out_field_stream (uiout, "name", stb); if (what == all && SYMBOL_IS_ARGUMENT (arg->sym)) ui_out_field_int (uiout, "arg", 1); if (values == PRINT_SIMPLE_VALUES) { check_typedef (arg->sym->type); type_print (arg->sym->type, "", stb, -1); ui_out_field_stream (uiout, "type", stb); } if (arg->val || arg->error) { volatile struct gdb_exception except; if (arg->error) except.message = arg->error; else { /* TRY_CATCH has two statements, wrap it in a block. */ TRY_CATCH (except, RETURN_MASK_ERROR) { struct value_print_options opts; get_raw_print_options (&opts); opts.deref_ref = 1; common_val_print (arg->val, stb, 0, &opts, language_def (SYMBOL_LANGUAGE (arg->sym))); } } if (except.message) fprintf_filtered (stb, _("<error reading variable: %s>"), except.message); ui_out_field_stream (uiout, "value", stb); } do_cleanups (old_chain); }