/* 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; }
int inside_main_func (CORE_ADDR pc) { if (pc == 0) return 1; if (symfile_objfile == 0) return 0; /* If the addr range is not set up at symbol reading time, set it up now. This is for FRAME_CHAIN_VALID_ALTERNATE. I do this for coff, because it is unable to set it up and symbol reading time. */ if (symfile_objfile->ei.main_func_lowpc == INVALID_ENTRY_LOWPC && symfile_objfile->ei.main_func_highpc == INVALID_ENTRY_HIGHPC) { struct symbol *mainsym; mainsym = lookup_symbol (main_name (), NULL, VAR_NAMESPACE, NULL, NULL); if (mainsym && SYMBOL_CLASS (mainsym) == LOC_BLOCK) { symfile_objfile->ei.main_func_lowpc = BLOCK_START (SYMBOL_BLOCK_VALUE (mainsym)); symfile_objfile->ei.main_func_highpc = BLOCK_END (SYMBOL_BLOCK_VALUE (mainsym)); } } return (symfile_objfile->ei.main_func_lowpc <= pc && symfile_objfile->ei.main_func_highpc > pc); }
static PyObject * sympy_get_addr_class (PyObject *self, void *closure) { struct symbol *symbol = NULL; SYMPY_REQUIRE_VALID (self, symbol); return PyInt_FromLong (SYMBOL_CLASS (symbol)); }
static SCM gdbscm_symbol_addr_class (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_int (SYMBOL_CLASS (symbol)); }
static PyObject * sympy_is_function (PyObject *self, void *closure) { struct symbol *symbol = NULL; enum address_class theclass; SYMPY_REQUIRE_VALID (self, symbol); theclass = SYMBOL_CLASS (symbol); return PyBool_FromLong (theclass == LOC_BLOCK); }
static SCM gdbscm_symbol_function_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 (theclass == LOC_BLOCK); }
static PyObject * sympy_is_constant (PyObject *self, void *closure) { struct symbol *symbol = NULL; enum address_class theclass; SYMPY_REQUIRE_VALID (self, symbol); theclass = SYMBOL_CLASS (symbol); return PyBool_FromLong (theclass == LOC_CONST || theclass == LOC_CONST_BYTES); }
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 struct symbol * add_class_symbol (struct type *type, CORE_ADDR addr) { struct symbol *sym; sym = (struct symbol *) obstack_alloc (&dynamics_objfile->objfile_obstack, sizeof (struct symbol)); memset (sym, 0, sizeof (struct symbol)); SYMBOL_LANGUAGE (sym) = language_java; DEPRECATED_SYMBOL_NAME (sym) = TYPE_TAG_NAME (type); SYMBOL_CLASS (sym) = LOC_TYPEDEF; /* SYMBOL_VALUE (sym) = valu; */ SYMBOL_TYPE (sym) = type; SYMBOL_DOMAIN (sym) = STRUCT_DOMAIN; SYMBOL_VALUE_ADDRESS (sym) = addr; return sym; }
static struct symbol * add_class_symbol (struct type *type, CORE_ADDR addr) { struct symbol *sym; struct objfile *objfile = get_dynamics_objfile (get_type_arch (type)); sym = (struct symbol *) obstack_alloc (&objfile->objfile_obstack, sizeof (struct symbol)); memset (sym, 0, sizeof (struct symbol)); SYMBOL_SET_LANGUAGE (sym, language_java); SYMBOL_SET_LINKAGE_NAME (sym, TYPE_TAG_NAME (type)); SYMBOL_CLASS (sym) = LOC_TYPEDEF; /* SYMBOL_VALUE (sym) = valu; */ SYMBOL_TYPE (sym) = type; SYMBOL_DOMAIN (sym) = STRUCT_DOMAIN; SYMBOL_VALUE_ADDRESS (sym) = addr; return sym; }
static void nlm_symfile_read (struct objfile *objfile, int mainline) { bfd *abfd = objfile->obfd; struct cleanup *back_to; CORE_ADDR offset; struct symbol *mainsym; init_minimal_symbol_collection (); back_to = make_cleanup_discard_minimal_symbols (); /* FIXME, should take a section_offsets param, not just an offset. */ offset = ANOFFSET (objfile->section_offsets, 0); /* Process the NLM export records, which become the bfd's canonical symbol table. */ nlm_symtab_read (abfd, offset, objfile); /* Install any minimal symbols that have been collected as the current minimal symbols for this objfile. */ install_minimal_symbols (objfile); do_cleanups (back_to); stabsect_build_psymtabs (objfile, mainline, ".stab", ".stabstr", ".text"); mainsym = lookup_symbol (main_name (), NULL, VAR_DOMAIN, NULL, NULL); if (mainsym && SYMBOL_CLASS (mainsym) == LOC_BLOCK) { objfile->ei.main_func_lowpc = BLOCK_START (SYMBOL_BLOCK_VALUE (mainsym)); objfile->ei.main_func_highpc = BLOCK_END (SYMBOL_BLOCK_VALUE (mainsym)); } /* FIXME: We could locate and read the optional native debugging format here and add the symbols to the minimal symbol table. */ }
static void c_type_print_template_args (const struct type_print_options *flags, struct type *type, struct ui_file *stream) { int first = 1, i; if (flags->raw) return; for (i = 0; i < TYPE_N_TEMPLATE_ARGUMENTS (type); ++i) { struct symbol *sym = TYPE_TEMPLATE_ARGUMENT (type, i); if (SYMBOL_CLASS (sym) != LOC_TYPEDEF) continue; if (first) { wrap_here (" "); fprintf_filtered (stream, _("[with %s = "), SYMBOL_LINKAGE_NAME (sym)); first = 0; } else { fputs_filtered (", ", stream); wrap_here (" "); fprintf_filtered (stream, "%s = ", SYMBOL_LINKAGE_NAME (sym)); } c_print_type (SYMBOL_TYPE (sym), "", stream, -1, 0, flags); } if (!first) fputs_filtered (_("] "), stream); }
static void convert_one_symbol (struct compile_c_instance *context, struct symbol *sym, int is_global, int is_local) { gcc_type sym_type; const char *filename = symbol_symtab (sym)->filename; unsigned short line = SYMBOL_LINE (sym); error_symbol_once (context, sym); if (SYMBOL_CLASS (sym) == LOC_LABEL) sym_type = 0; else sym_type = convert_type (context, SYMBOL_TYPE (sym)); if (SYMBOL_DOMAIN (sym) == STRUCT_DOMAIN) { /* Binding a tag, so we don't need to build a decl. */ C_CTX (context)->c_ops->tagbind (C_CTX (context), SYMBOL_NATURAL_NAME (sym), sym_type, filename, line); } else { gcc_decl decl; enum gcc_c_symbol_kind kind; CORE_ADDR addr = 0; char *symbol_name = NULL; switch (SYMBOL_CLASS (sym)) { case LOC_TYPEDEF: kind = GCC_C_SYMBOL_TYPEDEF; break; case LOC_LABEL: kind = GCC_C_SYMBOL_LABEL; addr = SYMBOL_VALUE_ADDRESS (sym); break; case LOC_BLOCK: kind = GCC_C_SYMBOL_FUNCTION; addr = BLOCK_START (SYMBOL_BLOCK_VALUE (sym)); if (is_global && TYPE_GNU_IFUNC (SYMBOL_TYPE (sym))) addr = gnu_ifunc_resolve_addr (target_gdbarch (), addr); break; case LOC_CONST: if (TYPE_CODE (SYMBOL_TYPE (sym)) == TYPE_CODE_ENUM) { /* Already handled by convert_enum. */ return; } C_CTX (context)->c_ops->build_constant (C_CTX (context), sym_type, SYMBOL_NATURAL_NAME (sym), SYMBOL_VALUE (sym), filename, line); return; case LOC_CONST_BYTES: error (_("Unsupported LOC_CONST_BYTES for symbol \"%s\"."), SYMBOL_PRINT_NAME (sym)); case LOC_UNDEF: internal_error (__FILE__, __LINE__, _("LOC_UNDEF found for \"%s\"."), SYMBOL_PRINT_NAME (sym)); case LOC_COMMON_BLOCK: error (_("Fortran common block is unsupported for compilation " "evaluaton of symbol \"%s\"."), SYMBOL_PRINT_NAME (sym)); case LOC_OPTIMIZED_OUT: error (_("Symbol \"%s\" cannot be used for compilation evaluation " "as it is optimized out."), SYMBOL_PRINT_NAME (sym)); case LOC_COMPUTED: if (is_local) goto substitution; /* Probably TLS here. */ warning (_("Symbol \"%s\" is thread-local and currently can only " "be referenced from the current thread in " "compiled code."), SYMBOL_PRINT_NAME (sym)); /* FALLTHROUGH */ case LOC_UNRESOLVED: /* 'symbol_name' cannot be used here as that one is used only for local variables from compile_dwarf_expr_to_c. Global variables can be accessed by GCC only by their address, not by their name. */ { struct value *val; struct frame_info *frame = NULL; if (symbol_read_needs_frame (sym)) { frame = get_selected_frame (NULL); if (frame == NULL) error (_("Symbol \"%s\" cannot be used because " "there is no selected frame"), SYMBOL_PRINT_NAME (sym)); } val = read_var_value (sym, frame); if (VALUE_LVAL (val) != lval_memory) error (_("Symbol \"%s\" cannot be used for compilation " "evaluation as its address has not been found."), SYMBOL_PRINT_NAME (sym)); kind = GCC_C_SYMBOL_VARIABLE; addr = value_address (val); } break; case LOC_REGISTER: case LOC_ARG: case LOC_REF_ARG: case LOC_REGPARM_ADDR: case LOC_LOCAL: substitution: kind = GCC_C_SYMBOL_VARIABLE; symbol_name = symbol_substitution_name (sym); break; case LOC_STATIC: kind = GCC_C_SYMBOL_VARIABLE; addr = SYMBOL_VALUE_ADDRESS (sym); break; case LOC_FINAL_VALUE: default: gdb_assert_not_reached ("Unreachable case in convert_one_symbol."); } /* Don't emit local variable decls for a raw expression. */ if (context->base.scope != COMPILE_I_RAW_SCOPE || symbol_name == NULL) { decl = C_CTX (context)->c_ops->build_decl (C_CTX (context), SYMBOL_NATURAL_NAME (sym), kind, sym_type, symbol_name, addr, filename, line); C_CTX (context)->c_ops->bind (C_CTX (context), decl, is_global); } xfree (symbol_name); } }
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); }
int addr_inside_main_func (CORE_ADDR pc) { struct minimal_symbol *msymbol; if (symfile_objfile == 0) return 0; /* APPLE LOCAL begin don't recompute start/end of main */ /* If we've already found the start/end addrs of main, don't recompute them. This will probably be fixed in the FSF sources soon too, in which case this change can be dropped. jmolenda/2004-04-28 */ if (symfile_objfile->ei.main_func_lowpc != INVALID_ENTRY_LOWPC && symfile_objfile->ei.main_func_highpc != INVALID_ENTRY_LOWPC) return (symfile_objfile->ei.main_func_lowpc <= pc && symfile_objfile->ei.main_func_highpc > pc); /* APPLE LOCAL end don't recompute start/end of main */ /* APPLE LOCAL begin don't restrict lookup_minimal_symbol's object file */ /* Don't restrict lookup_minimal_symbol's object file to symfile_objfile -- this will fail for ZeroLink apps where symfile_objfile is just the ZL launcher stub. */ msymbol = lookup_minimal_symbol (main_name (), NULL, NULL); /* APPLE LOCAL end don't restrict lookup_minimal_symbol's object file */ /* If the address range hasn't been set up at symbol reading time, set it up now. */ if (msymbol != NULL && symfile_objfile->ei.main_func_lowpc == INVALID_ENTRY_LOWPC && symfile_objfile->ei.main_func_highpc == INVALID_ENTRY_HIGHPC) { /* brobecker/2003-10-10: We used to rely on lookup_symbol() to search the symbol associated to the "main" function. Unfortunately, lookup_symbol() uses the current-language la_lookup_symbol_nonlocal function to do the global symbol search. Depending on the language, this can introduce certain side-effects, because certain languages, for instance Ada, may find more than one match. Therefore we prefer to search the "main" function symbol using its address rather than its name. */ struct symbol *mainsym = find_pc_function (SYMBOL_VALUE_ADDRESS (msymbol)); if (mainsym && SYMBOL_CLASS (mainsym) == LOC_BLOCK) { /* APPLE LOCAL begin address ranges */ struct block *bl = SYMBOL_BLOCK_VALUE (mainsym); if (BLOCK_RANGES (bl)) { symfile_objfile->ei.main_func_lowpc = BLOCK_LOWEST_PC (bl); symfile_objfile->ei.main_func_highpc = BLOCK_HIGHEST_PC (bl); } else { symfile_objfile->ei.main_func_lowpc = BLOCK_START (SYMBOL_BLOCK_VALUE (mainsym)); symfile_objfile->ei.main_func_highpc = BLOCK_END (SYMBOL_BLOCK_VALUE (mainsym)); } /* APPLE LOCAL end address ranges */ } } /* Not in the normal symbol tables, see if "main" is in the partial symbol table. If it's not, then give up. */ if (msymbol != NULL && MSYMBOL_TYPE (msymbol) == mst_text) { CORE_ADDR maddr = SYMBOL_VALUE_ADDRESS (msymbol); asection *msect = SYMBOL_BFD_SECTION (msymbol); struct obj_section *osect = find_pc_sect_section (maddr, msect); if (osect != NULL) { int i; /* Step over other symbols at this same address, and symbols in other sections, to find the next symbol in this section with a different address. */ for (i = 1; SYMBOL_LINKAGE_NAME (msymbol + i) != NULL; i++) { if (SYMBOL_VALUE_ADDRESS (msymbol + i) != maddr && SYMBOL_BFD_SECTION (msymbol + i) == msect) break; } symfile_objfile->ei.main_func_lowpc = maddr; /* Use the lesser of the next minimal symbol in the same section, or the end of the section, as the end of the function. */ if (SYMBOL_LINKAGE_NAME (msymbol + i) != NULL && SYMBOL_VALUE_ADDRESS (msymbol + i) < osect->endaddr) symfile_objfile->ei.main_func_highpc = SYMBOL_VALUE_ADDRESS (msymbol + i); else /* We got the start address from the last msymbol in the objfile. So the end address is the end of the section. */ symfile_objfile->ei.main_func_highpc = osect->endaddr; } } return (symfile_objfile->ei.main_func_lowpc <= pc && symfile_objfile->ei.main_func_highpc > pc); }
int inside_main_func (CORE_ADDR pc) { struct minimal_symbol *msymbol; if (symfile_objfile == 0) return 0; msymbol = lookup_minimal_symbol (main_name (), NULL, symfile_objfile); /* If the address range hasn't been set up at symbol reading time, set it up now. */ if (msymbol != NULL && symfile_objfile->ei.main_func_lowpc == INVALID_ENTRY_LOWPC && symfile_objfile->ei.main_func_highpc == INVALID_ENTRY_HIGHPC) { /* brobecker/2003-10-10: We used to rely on lookup_symbol() to search the symbol associated to the "main" function. Unfortunately, lookup_symbol() uses the current-language la_lookup_symbol_nonlocal function to do the global symbol search. Depending on the language, this can introduce certain side-effects, because certain languages, for instance Ada, may find more than one match. Therefore we prefer to search the "main" function symbol using its address rather than its name. */ struct symbol *mainsym = find_pc_function (SYMBOL_VALUE_ADDRESS (msymbol)); if (mainsym && SYMBOL_CLASS (mainsym) == LOC_BLOCK) { symfile_objfile->ei.main_func_lowpc = BLOCK_START (SYMBOL_BLOCK_VALUE (mainsym)); symfile_objfile->ei.main_func_highpc = BLOCK_END (SYMBOL_BLOCK_VALUE (mainsym)); } } /* Not in the normal symbol tables, see if "main" is in the partial symbol table. If it's not, then give up. */ if (msymbol != NULL && MSYMBOL_TYPE (msymbol) == mst_text) { CORE_ADDR maddr = SYMBOL_VALUE_ADDRESS (msymbol); asection *msect = SYMBOL_BFD_SECTION (msymbol); struct obj_section *osect = find_pc_sect_section (maddr, msect); if (osect != NULL) { int i; /* Step over other symbols at this same address, and symbols in other sections, to find the next symbol in this section with a different address. */ for (i = 1; SYMBOL_LINKAGE_NAME (msymbol + i) != NULL; i++) { if (SYMBOL_VALUE_ADDRESS (msymbol + i) != maddr && SYMBOL_BFD_SECTION (msymbol + i) == msect) break; } symfile_objfile->ei.main_func_lowpc = maddr; /* Use the lesser of the next minimal symbol in the same section, or the end of the section, as the end of the function. */ if (SYMBOL_LINKAGE_NAME (msymbol + i) != NULL && SYMBOL_VALUE_ADDRESS (msymbol + i) < osect->endaddr) symfile_objfile->ei.main_func_highpc = SYMBOL_VALUE_ADDRESS (msymbol + i); else /* We got the start address from the last msymbol in the objfile. So the end address is the end of the section. */ symfile_objfile->ei.main_func_highpc = osect->endaddr; } } return (symfile_objfile->ei.main_func_lowpc <= pc && symfile_objfile->ei.main_func_highpc > pc); }
/* Print a list of the locals or the arguments for the currently selected frame. If the argument passed is 0, printonly the names of the variables, if an argument of 1 is passed, print the values as well. */ static void list_args_or_locals (int locals, int values, struct frame_info *fi) { struct block *block; struct symbol *sym; struct dict_iterator iter; int nsyms; struct cleanup *cleanup_list; static struct ui_stream *stb = NULL; struct type *type; stb = ui_out_stream_new (uiout); block = get_frame_block (fi, 0); cleanup_list = make_cleanup_ui_out_list_begin_end (uiout, locals ? "locals" : "args"); 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: /* register arg */ case LOC_REGPARM_ADDR: /* indirect register arg */ case LOC_LOCAL_ARG: /* stack arg */ case LOC_BASEREG_ARG: /* basereg arg */ case LOC_COMPUTED_ARG: /* arg with computed location */ if (!locals) print_me = 1; break; case LOC_LOCAL: /* stack local */ case LOC_BASEREG: /* basereg local */ case LOC_STATIC: /* static */ case LOC_REGISTER: /* register */ case LOC_COMPUTED: /* computed location */ if (locals) print_me = 1; break; } if (print_me) { struct cleanup *cleanup_tuple = NULL; struct symbol *sym2; if (values != PRINT_NO_VALUES) cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL); ui_out_field_string (uiout, "name", SYMBOL_PRINT_NAME (sym)); if (!locals) sym2 = lookup_symbol (SYMBOL_NATURAL_NAME (sym), block, VAR_DOMAIN, (int *) NULL, (struct symtab **) NULL); else sym2 = sym; switch (values) { case PRINT_SIMPLE_VALUES: type = check_typedef (sym2->type); type_print (sym2->type, "", stb->stream, -1); ui_out_field_stream (uiout, "type", stb); if (TYPE_CODE (type) != TYPE_CODE_ARRAY && TYPE_CODE (type) != TYPE_CODE_STRUCT && TYPE_CODE (type) != TYPE_CODE_UNION) { print_variable_value (sym2, fi, stb->stream); ui_out_field_stream (uiout, "value", stb); } do_cleanups (cleanup_tuple); break; case PRINT_ALL_VALUES: print_variable_value (sym2, fi, stb->stream); ui_out_field_stream (uiout, "value", stb); do_cleanups (cleanup_tuple); break; } } } if (BLOCK_FUNCTION (block)) break; else block = BLOCK_SUPERBLOCK (block); }