struct symbol * get_frame_function (struct frame_info *frame) { register struct block *bl = get_frame_block (frame); if (bl == 0) return 0; return block_function (bl); }
struct symbol * get_frame_function (struct frame_info *frame) { struct block *bl = get_frame_block (frame, 0); if (bl == 0) return 0; return block_linkage_function (bl); }
struct symbol * get_frame_function_inlined (struct frame_info * frame) { struct block *bl = get_frame_block (frame, 0); struct bfd_section *sect; if (bl == 0) return 0; sect = find_pc_mapped_section (bl->startaddr); return block_inlined_function (bl, sect); }
static int wrap_get_frame_block (char *opaque_arg) { struct gdb_wrapper_arguments **args = (struct gdb_wrapper_arguments **) opaque_arg; struct frame_info *fi; fi = (struct frame_info *) (*args)->args[0].ptr; (*args)->result.cstptr = get_frame_block (fi, NULL); return 1; }
struct symbol * get_frame_function (struct frame_info *frame) { struct block *bl = get_frame_block (frame, 0); if (bl == NULL) return NULL; while (BLOCK_FUNCTION (bl) == NULL && BLOCK_SUPERBLOCK (bl) != NULL) bl = BLOCK_SUPERBLOCK (bl); return BLOCK_FUNCTION (bl); }
/* Using the frame specified in BATON, find the location expression describing the frame base. Return a pointer to it in START and its length in LENGTH. */ static void dwarf_expr_frame_base (void *baton, gdb_byte **start, size_t * length) { /* FIXME: cagney/2003-03-26: This code should be using get_frame_base_address(), and then implement a dwarf2 specific this_base method. */ struct symbol *framefunc; struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton; /* Use block_linkage_function, which returns a real (not inlined) function, instead of get_frame_function, which may return an inlined function. */ framefunc = block_linkage_function (get_frame_block (debaton->frame, NULL)); /* If we found a frame-relative symbol then it was certainly within some function associated with a frame. If we can't find the frame, something has gone wrong. */ gdb_assert (framefunc != NULL); if (SYMBOL_LOCATION_BATON (framefunc) == NULL) *start = NULL; else if (SYMBOL_COMPUTED_OPS (framefunc) == &dwarf2_loclist_funcs) { struct dwarf2_loclist_baton *symbaton; struct frame_info *frame = debaton->frame; symbaton = SYMBOL_LOCATION_BATON (framefunc); *start = find_location_expression (symbaton, length, get_frame_address_in_block (frame)); } else { struct dwarf2_locexpr_baton *symbaton; symbaton = SYMBOL_LOCATION_BATON (framefunc); if (symbaton != NULL) { *length = symbaton->size; *start = symbaton->data; } else *start = NULL; } if (*start == NULL) error (_("Could not find the frame base for \"%s\"."), SYMBOL_NATURAL_NAME (framefunc)); }
struct frame_info * block_innermost_frame (const struct block *block) { struct frame_info *frame; if (block == NULL) return NULL; frame = get_selected_frame_if_set (); if (frame == NULL) frame = get_current_frame (); while (frame != NULL) { const struct block *frame_block = get_frame_block (frame, NULL); if (frame_block != NULL && contained_in (frame_block, block)) return frame; frame = get_prev_frame (frame); } return NULL; }
/* Using the frame specified in BATON, find the location expression describing the frame base. Return a pointer to it in START and its length in LENGTH. */ static void dwarf_expr_frame_base (void *baton, gdb_byte **start, size_t * length) { /* FIXME: cagney/2003-03-26: This code should be using get_frame_base_address(), and then implement a dwarf2 specific this_base method. */ struct symbol *framefunc; struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton; /* Use block_linkage_function, which returns a real (not inlined) function, instead of get_frame_function, which may return an inlined function. */ framefunc = block_linkage_function (get_frame_block (debaton->frame, NULL)); /* If we found a frame-relative symbol then it was certainly within some function associated with a frame. If we can't find the frame, something has gone wrong. */ gdb_assert (framefunc != NULL); dwarf_expr_frame_base_1 (framefunc, get_frame_address_in_block (debaton->frame), start, length); }
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); }
/* 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); }