enum mi_cmd_result mi_cmd_file_list_exec_source_file (char *command, char **argv, int argc) { struct symtab_and_line st; int optind = 0; char *optarg; if (!mi_valid_noargs ("mi_cmd_file_list_exec_source_file", argc, argv)) error (_("mi_cmd_file_list_exec_source_file: Usage: No args")); /* Set the default file and line, also get them */ set_default_source_symtab_and_line (); st = get_current_source_symtab_and_line (); /* We should always get a symtab. Apparently, filename does not need to be tested for NULL. The documentation in symtab.h suggests it will always be correct */ if (!st.symtab) error (_("mi_cmd_file_list_exec_source_file: No symtab")); /* Extract the fullname if it is not known yet */ symtab_to_fullname (st.symtab); /* Print to the user the line, filename and fullname */ ui_out_field_int (uiout, "line", st.line); ui_out_field_string (uiout, "file", st.symtab->filename); /* We may not be able to open the file (not available). */ if (st.symtab->fullname) ui_out_field_string (uiout, "fullname", st.symtab->fullname); ui_out_field_int (uiout, "macro-info", st.symtab->macro_table ? 1 : 0); return MI_CMD_DONE; }
void mi_cmd_file_list_exec_source_file (char *command, char **argv, int argc) { struct symtab_and_line st; struct ui_out *uiout = current_uiout; if (!mi_valid_noargs ("-file-list-exec-source-file", argc, argv)) error (_("-file-list-exec-source-file: Usage: No args")); /* Set the default file and line, also get them. */ set_default_source_symtab_and_line (); st = get_current_source_symtab_and_line (); /* We should always get a symtab. Apparently, filename does not need to be tested for NULL. The documentation in symtab.h suggests it will always be correct. */ if (!st.symtab) error (_("-file-list-exec-source-file: No symtab")); /* Print to the user the line, filename and fullname. */ ui_out_field_int (uiout, "line", st.line); ui_out_field_string (uiout, "file", symtab_to_filename_for_display (st.symtab)); ui_out_field_string (uiout, "fullname", symtab_to_fullname (st.symtab)); ui_out_field_int (uiout, "macro-info", COMPUNIT_MACRO_TABLE (SYMTAB_COMPUNIT (st.symtab)) != NULL); }
static void btrace_call_history_src_line (struct ui_out *uiout, const struct btrace_function *bfun) { struct symbol *sym; int begin, end; sym = bfun->sym; if (sym == NULL) return; ui_out_field_string (uiout, "file", symtab_to_filename_for_display (sym->symtab)); begin = bfun->lbegin; end = bfun->lend; if (end < begin) return; ui_out_text (uiout, ":"); ui_out_field_int (uiout, "min line", begin); if (end == begin) return; ui_out_text (uiout, ","); ui_out_field_int (uiout, "max line", end); }
static void mi_on_normal_stop (struct bpstats *bs, int print_frame) { /* Since this can be called when CLI command is executing, using cli interpreter, be sure to use MI uiout for output, not the current one. */ struct ui_out *mi_uiout = interp_ui_out (top_level_interpreter ()); if (print_frame) { int core; if (current_uiout != mi_uiout) { /* The normal_stop function has printed frame information into CLI uiout, or some other non-MI uiout. There's no way we can extract proper fields from random uiout object, so we print the frame again. In practice, this can only happen when running a CLI command in MI. */ struct ui_out *saved_uiout = current_uiout; struct target_waitstatus last; ptid_t last_ptid; current_uiout = mi_uiout; get_last_target_status (&last_ptid, &last); bpstat_print (bs, last.kind); print_stack_frame (get_selected_frame (NULL), 0, SRC_AND_LOC, 1); current_uiout = saved_uiout; } ui_out_field_int (mi_uiout, "thread-id", pid_to_thread_id (inferior_ptid)); if (non_stop) { struct cleanup *back_to = make_cleanup_ui_out_list_begin_end (mi_uiout, "stopped-threads"); ui_out_field_int (mi_uiout, NULL, pid_to_thread_id (inferior_ptid)); do_cleanups (back_to); } else ui_out_field_string (mi_uiout, "stopped-threads", "all"); core = target_core_of_thread (inferior_ptid); if (core != -1) ui_out_field_int (mi_uiout, "core", core); } fputs_unfiltered ("*stopped", raw_stdout); mi_out_put (mi_uiout, raw_stdout); mi_out_rewind (mi_uiout); mi_print_timing_maybe (); fputs_unfiltered ("\n", raw_stdout); gdb_flush (raw_stdout); }
enum mi_cmd_result mi_cmd_var_list_children (char *command, char **argv, int argc) { struct varobj *var; struct varobj **childlist; struct varobj **cc; struct cleanup *cleanup_children; int numchild; char *type; enum print_values print_values; if (argc != 1 && argc != 2) error (_("mi_cmd_var_list_children: Usage: [PRINT_VALUES] NAME")); /* Get varobj handle, if a valid var obj name was specified */ if (argc == 1) var = varobj_get_handle (argv[0]); else var = varobj_get_handle (argv[1]); if (var == NULL) error (_("Variable object not found")); numchild = varobj_list_children (var, &childlist); ui_out_field_int (uiout, "numchild", numchild); if (argc == 2) print_values = mi_parse_values_option (argv[0]); else print_values = PRINT_NO_VALUES; if (numchild <= 0) return MI_CMD_DONE; if (mi_version (uiout) == 1) cleanup_children = make_cleanup_ui_out_tuple_begin_end (uiout, "children"); else cleanup_children = make_cleanup_ui_out_list_begin_end (uiout, "children"); cc = childlist; while (*cc != NULL) { struct cleanup *cleanup_child; cleanup_child = make_cleanup_ui_out_tuple_begin_end (uiout, "child"); ui_out_field_string (uiout, "name", varobj_get_objname (*cc)); ui_out_field_string (uiout, "exp", varobj_get_expression (*cc)); ui_out_field_int (uiout, "numchild", varobj_get_num_children (*cc)); if (mi_print_value_p (varobj_get_gdb_type (*cc), print_values)) ui_out_field_string (uiout, "value", varobj_get_value (*cc)); type = varobj_get_type (*cc); /* C++ pseudo-variables (public, private, protected) do not have a type */ if (type) ui_out_field_string (uiout, "type", type); do_cleanups (cleanup_child); cc++; } do_cleanups (cleanup_children); xfree (childlist); return MI_CMD_DONE; }
static void print_varobj (struct varobj *var, enum print_values print_values, int print_expression) { struct ui_out *uiout = current_uiout; char *type; int thread_id; char *display_hint; ui_out_field_string (uiout, "name", varobj_get_objname (var)); if (print_expression) { char *exp = varobj_get_expression (var); ui_out_field_string (uiout, "exp", exp); xfree (exp); } ui_out_field_int (uiout, "numchild", varobj_get_num_children (var)); if (mi_print_value_p (var, print_values)) { char *val = varobj_get_value (var); ui_out_field_string (uiout, "value", val); xfree (val); } type = varobj_get_type (var); if (type != NULL) { ui_out_field_string (uiout, "type", type); xfree (type); } thread_id = varobj_get_thread_id (var); if (thread_id > 0) ui_out_field_int (uiout, "thread-id", thread_id); if (varobj_get_frozen (var)) ui_out_field_int (uiout, "frozen", 1); display_hint = varobj_get_display_hint (var); if (display_hint) { ui_out_field_string (uiout, "displayhint", display_hint); xfree (display_hint); } if (varobj_is_dynamic_p (var)) ui_out_field_int (uiout, "dynamic", 1); }
static int varobj_update_one (struct varobj *var, enum print_values print_values) { struct varobj **changelist; struct varobj **cc; struct cleanup *cleanup = NULL; int nc; nc = varobj_update (&var, &changelist); /* nc == 0 means that nothing has changed. nc == -1 means that an error occured in updating the variable. nc == -2 means the variable has changed type. */ if (nc == 0) return 1; else if (nc == -1) { if (mi_version (uiout) > 1) cleanup = make_cleanup_ui_out_tuple_begin_end (uiout, NULL); ui_out_field_string (uiout, "name", varobj_get_objname(var)); ui_out_field_string (uiout, "in_scope", "false"); if (mi_version (uiout) > 1) do_cleanups (cleanup); return -1; } else if (nc == -2) { if (mi_version (uiout) > 1) cleanup = make_cleanup_ui_out_tuple_begin_end (uiout, NULL); ui_out_field_string (uiout, "name", varobj_get_objname (var)); ui_out_field_string (uiout, "in_scope", "true"); ui_out_field_string (uiout, "new_type", varobj_get_type(var)); ui_out_field_int (uiout, "new_num_children", varobj_get_num_children(var)); if (mi_version (uiout) > 1) do_cleanups (cleanup); } else { cc = changelist; while (*cc != NULL) { if (mi_version (uiout) > 1) cleanup = make_cleanup_ui_out_tuple_begin_end (uiout, NULL); ui_out_field_string (uiout, "name", varobj_get_objname (*cc)); if (mi_print_value_p (varobj_get_gdb_type (*cc), print_values)) ui_out_field_string (uiout, "value", varobj_get_value (*cc)); ui_out_field_string (uiout, "in_scope", "true"); ui_out_field_string (uiout, "type_changed", "false"); if (mi_version (uiout) > 1) do_cleanups (cleanup); cc++; } xfree (changelist); return 1; } return 1; }
static void mi_solib_loaded (struct so_list *solib) { struct mi_interp *mi = top_level_interpreter_data (); struct ui_out *uiout = interp_ui_out (top_level_interpreter ()); target_terminal_ours (); fprintf_unfiltered (mi->event_channel, "library-loaded"); ui_out_redirect (uiout, mi->event_channel); ui_out_field_string (uiout, "id", solib->so_original_name); ui_out_field_string (uiout, "target-name", solib->so_original_name); ui_out_field_string (uiout, "host-name", solib->so_name); ui_out_field_int (uiout, "symbols-loaded", solib->symbols_loaded); if (!gdbarch_has_global_solist (target_gdbarch ())) { ui_out_field_fmt (uiout, "thread-group", "i%d", current_inferior ()->num); } ui_out_redirect (uiout, NULL); gdb_flush (mi->event_channel); }
void macosx_print_extra_stop_info(int code, CORE_ADDR address) { ui_out_text(uiout, "Reason: "); switch (code) { case KERN_PROTECTION_FAILURE: ui_out_field_string(uiout, "access-reason", "KERN_PROTECTION_FAILURE"); break; case KERN_INVALID_ADDRESS: ui_out_field_string(uiout, "access-reason", "KERN_INVALID_ADDRESS"); break; #if defined(TARGET_ARM) case 0x101: ui_out_field_string(uiout, "access-reason", "EXC_ARM_DA_ALIGN"); break; case 0x102: ui_out_field_string(uiout, "access-reason", "EXC_ARM_DA_DEBUG"); break; #endif /* TARGET_ARM */ default: ui_out_field_int(uiout, "access-reason", code); } ui_out_text(uiout, " at address: "); ui_out_field_core_addr(uiout, "address", address); ui_out_text(uiout, "\n"); }
enum mi_cmd_result mi_cmd_stack_info_depth (char *command, char **argv, int argc) { int frame_high; int i; struct frame_info *fi; if (!target_has_stack) error ("mi_cmd_stack_info_depth: No stack."); if (argc > 1) error ("mi_cmd_stack_info_depth: Usage: [MAX_DEPTH]"); if (argc == 1) frame_high = atoi (argv[0]); else /* Called with no arguments, it means we want the real depth of the stack. */ frame_high = -1; for (i = 0, fi = get_current_frame (); fi && (i < frame_high || frame_high == -1); i++, fi = get_prev_frame (fi)) QUIT; ui_out_field_int (uiout, "depth", i); return MI_CMD_DONE; }
void mi_cmd_var_create (char *command, char **argv, int argc) { struct ui_out *uiout = current_uiout; CORE_ADDR frameaddr = 0; struct varobj *var; char *name; char *frame; char *expr; struct cleanup *old_cleanups; enum varobj_type var_type; if (argc != 3) error (_("-var-create: Usage: NAME FRAME EXPRESSION.")); name = xstrdup (argv[0]); /* Add cleanup for name. Must be free_current_contents as name can be reallocated. */ old_cleanups = make_cleanup (free_current_contents, &name); frame = xstrdup (argv[1]); make_cleanup (xfree, frame); expr = xstrdup (argv[2]); make_cleanup (xfree, expr); if (strcmp (name, "-") == 0) { xfree (name); name = varobj_gen_name (); } else if (!isalpha (*name)) error (_("-var-create: name of object must begin with a letter")); if (strcmp (frame, "*") == 0) var_type = USE_CURRENT_FRAME; else if (strcmp (frame, "@") == 0) var_type = USE_SELECTED_FRAME; else { var_type = USE_SPECIFIED_FRAME; frameaddr = string_to_core_addr (frame); } if (varobjdebug) fprintf_unfiltered (gdb_stdlog, "Name=\"%s\", Frame=\"%s\" (%s), Expression=\"%s\"\n", name, frame, hex_string (frameaddr), expr); var = varobj_create (name, expr, frameaddr, var_type); if (var == NULL) error (_("-var-create: unable to create variable object")); print_varobj (var, PRINT_ALL_VALUES, 0 /* don't print expression */); ui_out_field_int (uiout, "has_more", varobj_has_more (var, 0)); do_cleanups (old_cleanups); }
static int dump_insns(struct ui_out *uiout, struct disassemble_info * di, CORE_ADDR low, CORE_ADDR high, int how_many, struct ui_stream *stb) { int num_displayed = 0; CORE_ADDR pc; /* parts of the symbolic representation of the address */ int unmapped; int offset; int line; struct cleanup *ui_out_chain; for (pc = low; pc < high;) { char *filename = NULL; char *name = NULL; QUIT; if (how_many >= 0) { if (num_displayed >= how_many) break; else num_displayed++; } ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, NULL); ui_out_field_core_addr (uiout, "address", pc); if (!build_address_symbolic (pc, 0, &name, &offset, &filename, &line, &unmapped)) { /* We don't care now about line, filename and unmapped. But we might in the future. */ ui_out_text (uiout, " <"); ui_out_field_string (uiout, "func-name", name); ui_out_text (uiout, "+"); ui_out_field_int (uiout, "offset", offset); ui_out_text (uiout, ">:\t"); } else ui_out_text (uiout, ":\t"); if (filename != NULL) xfree (filename); if (name != NULL) xfree (name); ui_file_rewind (stb->stream); pc += TARGET_PRINT_INSN (pc, di); ui_out_field_stream (uiout, "inst", stb); ui_file_rewind (stb->stream); do_cleanups (ui_out_chain); ui_out_text (uiout, "\n"); } return num_displayed; }
/* Print a list of the arguments for the current frame. With argument of 0, print only the names, with argument of 1 print also the values. */ enum mi_cmd_result mi_cmd_stack_list_args (char *command, char **argv, int argc) { int frame_low; int frame_high; int i; struct frame_info *fi; struct cleanup *cleanup_stack_args; if (argc < 1 || argc > 3 || argc == 2) error ("mi_cmd_stack_list_args: Usage: PRINT_VALUES [FRAME_LOW FRAME_HIGH]"); if (argc == 3) { frame_low = atoi (argv[1]); frame_high = atoi (argv[2]); } else { /* Called with no arguments, it means we want args for the whole backtrace. */ frame_low = -1; frame_high = -1; } /* Let's position fi on the frame at which to start the display. Could be the innermost frame if the whole stack needs displaying, or if frame_low is 0. */ for (i = 0, fi = get_current_frame (); fi && i < frame_low; i++, fi = get_prev_frame (fi)); if (fi == NULL) error ("mi_cmd_stack_list_args: Not enough frames in stack."); cleanup_stack_args = make_cleanup_ui_out_list_begin_end (uiout, "stack-args"); /* Now let's print the frames up to frame_high, or until there are frames in the stack. */ for (; fi && (i <= frame_high || frame_high == -1); i++, fi = get_prev_frame (fi)) { struct cleanup *cleanup_frame; QUIT; cleanup_frame = make_cleanup_ui_out_tuple_begin_end (uiout, "frame"); ui_out_field_int (uiout, "level", i); list_args_or_locals (0, atoi (argv[0]), fi); do_cleanups (cleanup_frame); } do_cleanups (cleanup_stack_args); if (i < frame_high) error ("mi_cmd_stack_list_args: Not enough frames in stack."); return MI_CMD_DONE; }
enum mi_cmd_result mi_cmd_var_delete (char *command, char **argv, int argc) { char *name; char *expr; struct varobj *var; int numdel; int children_only_p = 0; struct cleanup *old_cleanups; if (argc < 1 || argc > 2) error ("mi_cmd_var_delete: Usage: [-c] EXPRESSION."); name = xstrdup (argv[0]); /* Add cleanup for name. Must be free_current_contents as name can be reallocated */ old_cleanups = make_cleanup (free_current_contents, &name); /* If we have one single argument it cannot be '-c' or any string starting with '-'. */ if (argc == 1) { if (strcmp (name, "-c") == 0) error ("mi_cmd_var_delete: Missing required argument after '-c': variable object name"); if (*name == '-') error ("mi_cmd_var_delete: Illegal variable object name"); } /* If we have 2 arguments they must be '-c' followed by a string which would be the variable name. */ if (argc == 2) { expr = xstrdup (argv[1]); if (strcmp (name, "-c") != 0) error ("mi_cmd_var_delete: Invalid option."); children_only_p = 1; xfree (name); name = xstrdup (expr); xfree (expr); } /* If we didn't error out, now NAME contains the name of the variable. */ var = varobj_get_handle (name); if (var == NULL) error ("mi_cmd_var_delete: Variable object not found."); numdel = varobj_delete (var, NULL, children_only_p); ui_out_field_int (uiout, "ndeleted", numdel); do_cleanups (old_cleanups); return MI_CMD_DONE; }
void mi_cmd_var_info_num_children (char *command, char **argv, int argc) { struct ui_out *uiout = current_uiout; struct varobj *var; if (argc != 1) error (_("-var-info-num-children: Usage: NAME.")); /* Get varobj handle, if a valid var obj name was specified. */ var = varobj_get_handle (argv[0]); ui_out_field_int (uiout, "numchild", varobj_get_num_children (var)); }
static void btrace_func_history_src_line (struct ui_out *uiout, struct btrace_func *bfun) { struct symbol *sym; sym = bfun->sym; if (sym == NULL) return; ui_out_field_string (uiout, "file", symtab_to_filename_for_display (sym->symtab)); if (bfun->lend == 0) return; ui_out_text (uiout, ":"); ui_out_field_int (uiout, "min line", bfun->lbegin); if (bfun->lend == bfun->lbegin) return; ui_out_text (uiout, "-"); ui_out_field_int (uiout, "max line", bfun->lend); }
enum mi_cmd_result mi_cmd_var_info_num_children (char *command, char **argv, int argc) { struct varobj *var; if (argc != 1) error ("mi_cmd_var_info_num_children: Usage: NAME."); /* Get varobj handle, if a valid var obj name was specified */ var = varobj_get_handle (argv[0]); if (var == NULL) error ("mi_cmd_var_info_num_children: Variable object not found"); ui_out_field_int (uiout, "numchild", varobj_get_num_children (var)); return MI_CMD_DONE; }
void mi_cmd_symbol_list_lines (char *command, char **argv, int argc) { struct gdbarch *gdbarch; char *filename; struct symtab *s; int i; struct cleanup *cleanup_stack, *cleanup_tuple; struct ui_out *uiout = current_uiout; if (argc != 1) error (_("-symbol-list-lines: Usage: SOURCE_FILENAME")); filename = argv[0]; s = lookup_symtab (filename); if (s == NULL) error (_("-symbol-list-lines: Unknown source file name.")); /* Now, dump the associated line table. The pc addresses are already sorted by increasing values in the symbol table, so no need to perform any other sorting. */ gdbarch = get_objfile_arch (s->objfile); cleanup_stack = make_cleanup_ui_out_list_begin_end (uiout, "lines"); if (LINETABLE (s) != NULL && LINETABLE (s)->nitems > 0) for (i = 0; i < LINETABLE (s)->nitems; i++) { cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL); ui_out_field_core_addr (uiout, "pc", gdbarch, LINETABLE (s)->item[i].pc); ui_out_field_int (uiout, "line", LINETABLE (s)->item[i].line); do_cleanups (cleanup_tuple); } do_cleanups (cleanup_stack); }
void mi_cmd_stack_info_depth (char *command, char **argv, int argc) { int frame_high; int i; struct frame_info *fi; if (argc > 1) error (_("-stack-info-depth: Usage: [MAX_DEPTH]")); if (argc == 1) frame_high = atoi (argv[0]); else /* Called with no arguments, it means we want the real depth of the stack. */ frame_high = -1; for (i = 0, fi = get_current_frame (); fi && (i < frame_high || frame_high == -1); i++, fi = get_prev_frame (fi)) QUIT; ui_out_field_int (current_uiout, "depth", i); }
static int dump_insns (struct gdbarch *gdbarch, struct ui_out *uiout, struct disassemble_info * di, CORE_ADDR low, CORE_ADDR high, int how_many, int flags, struct ui_stream *stb) { int num_displayed = 0; CORE_ADDR pc; /* parts of the symbolic representation of the address */ int unmapped; int offset; int line; struct cleanup *ui_out_chain; for (pc = low; pc < high;) { char *filename = NULL; char *name = NULL; QUIT; if (how_many >= 0) { if (num_displayed >= how_many) break; else num_displayed++; } ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, NULL); ui_out_field_core_addr (uiout, "address", gdbarch, pc); if (!build_address_symbolic (pc, 0, &name, &offset, &filename, &line, &unmapped)) { /* We don't care now about line, filename and unmapped. But we might in the future. */ ui_out_text (uiout, " <"); ui_out_field_string (uiout, "func-name", name); ui_out_text (uiout, "+"); ui_out_field_int (uiout, "offset", offset); ui_out_text (uiout, ">:\t"); } else ui_out_text (uiout, ":\t"); if (filename != NULL) xfree (filename); if (name != NULL) xfree (name); ui_file_rewind (stb->stream); if (flags & DISASSEMBLY_RAW_INSN) { CORE_ADDR old_pc = pc; bfd_byte data; int status; pc += gdbarch_print_insn (gdbarch, pc, di); for (;old_pc < pc; old_pc++) { status = (*di->read_memory_func) (old_pc, &data, 1, di); if (status != 0) (*di->memory_error_func) (status, old_pc, di); ui_out_message (uiout, 0, " %02x", (unsigned)data); } ui_out_text (uiout, "\t"); } else pc += gdbarch_print_insn (gdbarch, pc, di); ui_out_field_stream (uiout, "inst", stb); ui_file_rewind (stb->stream); do_cleanups (ui_out_chain); ui_out_text (uiout, "\n"); } return num_displayed; }
void mi_load_progress (const char *section_name, unsigned long sent_so_far, unsigned long total_section, unsigned long total_sent, unsigned long grand_total) { struct timeval time_now, delta, update_threshold; static struct timeval last_update; static char *previous_sect_name = NULL; int new_section; struct ui_out *saved_uiout; /* This function is called through deprecated_show_load_progress which means uiout may not be correct. Fix it for the duration of this function. */ saved_uiout = uiout; if (current_interp_named_p (INTERP_MI)) uiout = mi_out_new (2); else if (current_interp_named_p (INTERP_MI1)) uiout = mi_out_new (1); else return; update_threshold.tv_sec = 0; update_threshold.tv_usec = 500000; gettimeofday (&time_now, NULL); delta.tv_usec = time_now.tv_usec - last_update.tv_usec; delta.tv_sec = time_now.tv_sec - last_update.tv_sec; if (delta.tv_usec < 0) { delta.tv_sec -= 1; delta.tv_usec += 1000000; } new_section = (previous_sect_name ? strcmp (previous_sect_name, section_name) : 1); if (new_section) { struct cleanup *cleanup_tuple; xfree (previous_sect_name); previous_sect_name = xstrdup (section_name); if (last_async_command) fputs_unfiltered (last_async_command, raw_stdout); fputs_unfiltered ("+download", raw_stdout); cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL); ui_out_field_string (uiout, "section", section_name); ui_out_field_int (uiout, "section-size", total_section); ui_out_field_int (uiout, "total-size", grand_total); do_cleanups (cleanup_tuple); mi_out_put (uiout, raw_stdout); fputs_unfiltered ("\n", raw_stdout); gdb_flush (raw_stdout); } if (delta.tv_sec >= update_threshold.tv_sec && delta.tv_usec >= update_threshold.tv_usec) { struct cleanup *cleanup_tuple; last_update.tv_sec = time_now.tv_sec; last_update.tv_usec = time_now.tv_usec; if (last_async_command) fputs_unfiltered (last_async_command, raw_stdout); fputs_unfiltered ("+download", raw_stdout); cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL); ui_out_field_string (uiout, "section", section_name); ui_out_field_int (uiout, "section-sent", sent_so_far); ui_out_field_int (uiout, "section-size", total_section); ui_out_field_int (uiout, "total-sent", total_sent); ui_out_field_int (uiout, "total-size", grand_total); do_cleanups (cleanup_tuple); mi_out_put (uiout, raw_stdout); fputs_unfiltered ("\n", raw_stdout); gdb_flush (raw_stdout); } xfree (uiout); uiout = saved_uiout; }
enum mi_cmd_result mi_cmd_data_list_changed_registers (char *command, char **argv, int argc) { int regnum, numregs, changed; int i; struct cleanup *cleanup; /* Note that the test for a valid register must include checking the REGISTER_NAME because NUM_REGS may be allocated for the union of the register sets within a family of related processors. In this case, some entries of REGISTER_NAME will change depending upon the particular processor being debugged. */ numregs = NUM_REGS + NUM_PSEUDO_REGS; cleanup = make_cleanup_ui_out_list_begin_end (uiout, "changed-registers"); if (argc == 0) /* No args, just do all the regs */ { for (regnum = 0; regnum < numregs; regnum++) { if (REGISTER_NAME (regnum) == NULL || *(REGISTER_NAME (regnum)) == '\0') continue; changed = register_changed_p (regnum); if (changed < 0) { do_cleanups (cleanup); mi_error_message = xstrprintf ("mi_cmd_data_list_changed_registers: Unable to read register contents."); return MI_CMD_ERROR; } else if (changed) ui_out_field_int (uiout, NULL, regnum); } } /* Else, list of register #s, just do listed regs */ for (i = 0; i < argc; i++) { regnum = atoi (argv[i]); if (regnum >= 0 && regnum < numregs && REGISTER_NAME (regnum) != NULL && *REGISTER_NAME (regnum) != '\000') { changed = register_changed_p (regnum); if (changed < 0) { do_cleanups (cleanup); mi_error_message = xstrprintf ("mi_cmd_data_list_register_change: Unable to read register contents."); return MI_CMD_ERROR; } else if (changed) ui_out_field_int (uiout, NULL, regnum); } else { do_cleanups (cleanup); mi_error_message = xstrprintf ("bad register number"); return MI_CMD_ERROR; } } do_cleanups (cleanup); return MI_CMD_DONE; }
/* Return a list of register number and value pairs. The valid arguments expected are: a letter indicating the format in which to display the registers contents. This can be one of: x (hexadecimal), d (decimal), N (natural), t (binary), o (octal), r (raw). After the format argumetn there can be a sequence of numbers, indicating which registers to fetch the content of. If the format is the only argument, a list of all the registers with their values is returned. */ enum mi_cmd_result mi_cmd_data_list_register_values (char *command, char **argv, int argc) { int regnum, numregs, format, result; int i; struct cleanup *list_cleanup, *tuple_cleanup; /* Note that the test for a valid register must include checking the REGISTER_NAME because NUM_REGS may be allocated for the union of the register sets within a family of related processors. In this case, some entries of REGISTER_NAME will change depending upon the particular processor being debugged. */ numregs = NUM_REGS + NUM_PSEUDO_REGS; if (argc == 0) { mi_error_message = xstrprintf ("mi_cmd_data_list_register_values: Usage: -data-list-register-values <format> [<regnum1>...<regnumN>]"); return MI_CMD_ERROR; } format = (int) argv[0][0]; list_cleanup = make_cleanup_ui_out_list_begin_end (uiout, "register-values"); if (argc == 1) /* No args, beside the format: do all the regs */ { for (regnum = 0; regnum < numregs; regnum++) { if (REGISTER_NAME (regnum) == NULL || *(REGISTER_NAME (regnum)) == '\0') continue; tuple_cleanup = make_cleanup_ui_out_tuple_begin_end (uiout, NULL); ui_out_field_int (uiout, "number", regnum); result = get_register (regnum, format); if (result == -1) { do_cleanups (list_cleanup); return MI_CMD_ERROR; } do_cleanups (tuple_cleanup); } } /* Else, list of register #s, just do listed regs */ for (i = 1; i < argc; i++) { regnum = atoi (argv[i]); if (regnum >= 0 && regnum < numregs && REGISTER_NAME (regnum) != NULL && *REGISTER_NAME (regnum) != '\000') { tuple_cleanup = make_cleanup_ui_out_tuple_begin_end (uiout, NULL); ui_out_field_int (uiout, "number", regnum); result = get_register (regnum, format); if (result == -1) { do_cleanups (list_cleanup); return MI_CMD_ERROR; } do_cleanups (tuple_cleanup); } else { do_cleanups (list_cleanup); mi_error_message = xstrprintf ("bad register number"); return MI_CMD_ERROR; } } do_cleanups (list_cleanup); return MI_CMD_DONE; }
static void mi_on_normal_stop (struct bpstats *bs, int print_frame) { /* Since this can be called when CLI command is executing, using cli interpreter, be sure to use MI uiout for output, not the current one. */ struct ui_out *mi_uiout = interp_ui_out (top_level_interpreter ()); if (print_frame) { int core; if (current_uiout != mi_uiout) { /* The normal_stop function has printed frame information into CLI uiout, or some other non-MI uiout. There's no way we can extract proper fields from random uiout object, so we print the frame again. In practice, this can only happen when running a CLI command in MI. */ struct ui_out *saved_uiout = current_uiout; struct target_waitstatus last; ptid_t last_ptid; current_uiout = mi_uiout; get_last_target_status (&last_ptid, &last); print_stop_event (&last); current_uiout = saved_uiout; } /* Otherwise, frame information has already been printed by normal_stop. */ else { /* Breakpoint hits should always be mirrored to the console. Deciding what to mirror to the console wrt to breakpoints and random stops gets messy real fast. E.g., say "s" trips on a breakpoint. We'd clearly want to mirror the event to the console in this case. But what about more complicated cases like "s&; thread n; s&", and one of those steps spawning a new thread, and that thread hitting a breakpoint? It's impossible in general to track whether the thread had any relation to the commands that had been executed. So we just simplify and always mirror breakpoints and random events to the console. Also, CLI execution commands (-interpreter-exec console "next", for example) in async mode have the opposite issue as described in the "then" branch above -- normal_stop has already printed frame information to MI uiout, but nothing has printed the same information to the CLI channel. We should print the source line to the console when stepping or other similar commands, iff the step was started by a console command (but not if it was started with -exec-step or similar). */ struct thread_info *tp = inferior_thread (); if ((!tp->control.stop_step && !tp->control.proceed_to_finish) || (tp->control.command_interp != NULL && tp->control.command_interp != top_level_interpreter ())) { struct mi_interp *mi = top_level_interpreter_data (); struct target_waitstatus last; ptid_t last_ptid; struct cleanup *old_chain; /* Set the current uiout to CLI uiout temporarily. */ old_chain = make_cleanup (restore_current_uiout_cleanup, current_uiout); current_uiout = mi->cli_uiout; get_last_target_status (&last_ptid, &last); print_stop_event (&last); do_cleanups (old_chain); } } ui_out_field_int (mi_uiout, "thread-id", pid_to_thread_id (inferior_ptid)); if (non_stop) { struct cleanup *back_to = make_cleanup_ui_out_list_begin_end (mi_uiout, "stopped-threads"); ui_out_field_int (mi_uiout, NULL, pid_to_thread_id (inferior_ptid)); do_cleanups (back_to); } else ui_out_field_string (mi_uiout, "stopped-threads", "all"); core = target_core_of_thread (inferior_ptid); if (core != -1) ui_out_field_int (mi_uiout, "core", core); } fputs_unfiltered ("*stopped", raw_stdout); mi_out_put (mi_uiout, raw_stdout); mi_out_rewind (mi_uiout); mi_print_timing_maybe (); fputs_unfiltered ("\n", raw_stdout); gdb_flush (raw_stdout); }
enum mi_cmd_result mi_cmd_data_read_memory (char *command, char **argv, int argc) { struct cleanup *cleanups = make_cleanup (null_cleanup, NULL); CORE_ADDR addr; long total_bytes; long nr_cols; long nr_rows; char word_format; struct type *word_type; long word_size; char word_asize; char aschar; gdb_byte *mbuf; int nr_bytes; long offset = 0; int optind = 0; char *optarg; enum opt { OFFSET_OPT }; static struct mi_opt opts[] = { {"o", OFFSET_OPT, 1}, 0 }; while (1) { int opt = mi_getopt ("mi_cmd_data_read_memory", argc, argv, opts, &optind, &optarg); if (opt < 0) break; switch ((enum opt) opt) { case OFFSET_OPT: offset = atol (optarg); break; } } argv += optind; argc -= optind; if (argc < 5 || argc > 6) { mi_error_message = xstrprintf ("mi_cmd_data_read_memory: Usage: ADDR WORD-FORMAT WORD-SIZE NR-ROWS NR-COLS [ASCHAR]."); return MI_CMD_ERROR; } /* Extract all the arguments. */ /* Start address of the memory dump. */ addr = parse_and_eval_address (argv[0]) + offset; /* The format character to use when displaying a memory word. See the ``x'' command. */ word_format = argv[1][0]; /* The size of the memory word. */ word_size = atol (argv[2]); switch (word_size) { case 1: word_type = builtin_type_int8; word_asize = 'b'; break; case 2: word_type = builtin_type_int16; word_asize = 'h'; break; case 4: word_type = builtin_type_int32; word_asize = 'w'; break; case 8: word_type = builtin_type_int64; word_asize = 'g'; break; default: word_type = builtin_type_int8; word_asize = 'b'; } /* The number of rows */ nr_rows = atol (argv[3]); if (nr_rows <= 0) { mi_error_message = xstrprintf ("mi_cmd_data_read_memory: invalid number of rows."); return MI_CMD_ERROR; } /* number of bytes per row. */ nr_cols = atol (argv[4]); if (nr_cols <= 0) { mi_error_message = xstrprintf ("mi_cmd_data_read_memory: invalid number of columns."); return MI_CMD_ERROR; } /* The un-printable character when printing ascii. */ if (argc == 6) aschar = *argv[5]; else aschar = 0; /* create a buffer and read it in. */ total_bytes = word_size * nr_rows * nr_cols; mbuf = xcalloc (total_bytes, 1); make_cleanup (xfree, mbuf); nr_bytes = target_read (¤t_target, TARGET_OBJECT_MEMORY, NULL, mbuf, addr, total_bytes); if (nr_bytes <= 0) { do_cleanups (cleanups); mi_error_message = xstrdup ("Unable to read memory."); return MI_CMD_ERROR; } /* output the header information. */ ui_out_field_core_addr (uiout, "addr", addr); ui_out_field_int (uiout, "nr-bytes", nr_bytes); ui_out_field_int (uiout, "total-bytes", total_bytes); ui_out_field_core_addr (uiout, "next-row", addr + word_size * nr_cols); ui_out_field_core_addr (uiout, "prev-row", addr - word_size * nr_cols); ui_out_field_core_addr (uiout, "next-page", addr + total_bytes); ui_out_field_core_addr (uiout, "prev-page", addr - total_bytes); /* Build the result as a two dimentional table. */ { struct ui_stream *stream = ui_out_stream_new (uiout); struct cleanup *cleanup_list_memory; int row; int row_byte; cleanup_list_memory = make_cleanup_ui_out_list_begin_end (uiout, "memory"); for (row = 0, row_byte = 0; row < nr_rows; row++, row_byte += nr_cols * word_size) { int col; int col_byte; struct cleanup *cleanup_tuple; struct cleanup *cleanup_list_data; cleanup_tuple = make_cleanup_ui_out_tuple_begin_end (uiout, NULL); ui_out_field_core_addr (uiout, "addr", addr + row_byte); /* ui_out_field_core_addr_symbolic (uiout, "saddr", addr + row_byte); */ cleanup_list_data = make_cleanup_ui_out_list_begin_end (uiout, "data"); for (col = 0, col_byte = row_byte; col < nr_cols; col++, col_byte += word_size) { if (col_byte + word_size > nr_bytes) { ui_out_field_string (uiout, NULL, "N/A"); } else { ui_file_rewind (stream->stream); print_scalar_formatted (mbuf + col_byte, word_type, word_format, word_asize, stream->stream); ui_out_field_stream (uiout, NULL, stream); } } do_cleanups (cleanup_list_data); if (aschar) { int byte; ui_file_rewind (stream->stream); for (byte = row_byte; byte < row_byte + word_size * nr_cols; byte++) { if (byte >= nr_bytes) { fputc_unfiltered ('X', stream->stream); } else if (mbuf[byte] < 32 || mbuf[byte] > 126) { fputc_unfiltered (aschar, stream->stream); } else fputc_unfiltered (mbuf[byte], stream->stream); } ui_out_field_stream (uiout, "ascii", stream); } do_cleanups (cleanup_tuple); } ui_out_stream_delete (stream); do_cleanups (cleanup_list_memory); } do_cleanups (cleanups); return MI_CMD_DONE; }
/* * First, disassemble all instructions of the function and store them in buffer * Second, follow and calculate register values at each instruction * Finally, display all disassembled instruction with annotation of object context */ int decode_insns(struct decode_control_block* decode_cb) { unsigned int insn_index, i; int num_insns = 0; struct gdbarch *gdbarch = decode_cb->gdbarch; struct ui_out *uiout = decode_cb->uiout; // Disassemble the whole function even if user chooses // only a subset of it num_insns += dump_insns(decode_cb); // copy known function parameters init_reg_table(decode_cb->param_regs); init_stack_vars(); g_reg_table.cur_regs[RIP]->has_value = 1; // Annotate the context of each instruction for (insn_index = 0; insn_index < g_num_insns; insn_index++) { int cur_insn = 0; struct ca_dis_insn* insn = &g_insns_buffer[insn_index]; // update program counter for RIP-relative instruction // RIP points to the address of the next instruction before executing current one if (insn_index + 1 < g_num_insns) set_reg_value_at_pc(RIP, (insn+1)->pc, insn->pc); // user may set some register values deliberately if (decode_cb->user_regs) { if (insn->pc == decode_cb->low || (insn_index + 1 < g_num_insns && g_insns_buffer[insn_index + 1].pc > decode_cb->low) ) { if (insn->pc == decode_cb->func_start) set_reg_table_at_pc(decode_cb->user_regs, 0); else set_reg_table_at_pc(decode_cb->user_regs, insn->pc); } } // analyze and update register context affected by this instruction if (decode_cb->innermost_frame) { if (insn->pc == decode_cb->current) cur_insn = 1; } else if (insn_index + 1 < g_num_insns && g_insns_buffer[insn_index + 1].pc == decode_cb->current) cur_insn = 1; process_one_insn(insn, cur_insn); if (cur_insn) { // return the register context back to caller for (i = 0; i < TOTAL_REGS; i++) { struct ca_reg_value* reg = g_reg_table.cur_regs[i]; if (reg->has_value) { // only pass on values, symbol may be out of context in another function struct ca_reg_value* dst = &decode_cb->param_regs[i]; memcpy(dst, reg, sizeof(struct ca_reg_value)); dst->sym_name = NULL; } } } } if (decode_cb->verbose) validate_reg_table(); // display disassembled insns for (insn_index = 0; insn_index < g_num_insns; insn_index++) { struct ca_dis_insn* insn = &g_insns_buffer[insn_index]; // parts of the symbolic representation of the address int unmapped; int offset; int line; char *filename = NULL; char *name = NULL; if (insn->pc >= decode_cb->high) break; else if (insn->pc >= decode_cb->low) { // instruction address + offset ui_out_text(uiout, pc_prefix(insn->pc)); ui_out_field_core_addr(uiout, "address", gdbarch, insn->pc); if (!build_address_symbolic(gdbarch, insn->pc, 0, &name, &offset, &filename, &line, &unmapped)) { ui_out_text(uiout, " <"); //if (decode_cb->verbose) // ui_out_field_string(uiout, "func-name", name); ui_out_text(uiout, "+"); ui_out_field_int(uiout, "offset", offset); ui_out_text(uiout, ">:\t"); } else ui_out_message(uiout, 0, "<+%ld>:\t", insn->pc - decode_cb->func_start); // disassembled instruction with annotation print_one_insn(insn, uiout); if (filename != NULL) free(filename); if (name != NULL) free(name); } } reset_reg_table(); reset_stack_vars(); return num_insns; }
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); }
void mi_cmd_stack_list_args (char *command, char **argv, int argc) { int frame_low; int frame_high; int i; struct frame_info *fi; struct cleanup *cleanup_stack_args; enum print_values print_values; struct ui_out *uiout = current_uiout; int raw_arg = 0; int oind = 0; int skip_unavailable = 0; enum ext_lang_bt_status result = EXT_LANG_BT_ERROR; enum opt { NO_FRAME_FILTERS, SKIP_UNAVAILABLE, }; static const struct mi_opt opts[] = { {"-no-frame-filters", NO_FRAME_FILTERS, 0}, {"-skip-unavailable", SKIP_UNAVAILABLE, 0}, { 0, 0, 0 } }; while (1) { char *oarg; int opt = mi_getopt_allow_unknown ("-stack-list-args", argc, argv, opts, &oind, &oarg); if (opt < 0) break; switch ((enum opt) opt) { case NO_FRAME_FILTERS: raw_arg = oind; break; case SKIP_UNAVAILABLE: skip_unavailable = 1; break; } } if (argc - oind != 1 && argc - oind != 3) error (_("-stack-list-arguments: Usage: " \ "[--no-frame-filters] [--skip-unavailable] " "PRINT_VALUES [FRAME_LOW FRAME_HIGH]")); if (argc - oind == 3) { frame_low = atoi (argv[1 + oind]); frame_high = atoi (argv[2 + oind]); } else { /* Called with no arguments, it means we want args for the whole backtrace. */ frame_low = -1; frame_high = -1; } print_values = mi_parse_print_values (argv[oind]); /* Let's position fi on the frame at which to start the display. Could be the innermost frame if the whole stack needs displaying, or if frame_low is 0. */ for (i = 0, fi = get_current_frame (); fi && i < frame_low; i++, fi = get_prev_frame (fi)); if (fi == NULL) error (_("-stack-list-arguments: Not enough frames in stack.")); cleanup_stack_args = make_cleanup_ui_out_list_begin_end (uiout, "stack-args"); if (! raw_arg && frame_filters) { int flags = PRINT_LEVEL | PRINT_ARGS; int py_frame_low = frame_low; /* We cannot pass -1 to frame_low, as that would signify a relative backtrace from the tail of the stack. So, in the case of frame_low == -1, assign and increment it. */ if (py_frame_low == -1) py_frame_low++; result = mi_apply_ext_lang_frame_filter (get_current_frame (), flags, print_values, current_uiout, py_frame_low, frame_high); } /* Run the inbuilt backtrace if there are no filters registered, or if "--no-frame-filters" has been specified from the command. */ if (! frame_filters || raw_arg || result == EXT_LANG_BT_NO_FILTERS) { /* Now let's print the frames up to frame_high, or until there are frames in the stack. */ for (; fi && (i <= frame_high || frame_high == -1); i++, fi = get_prev_frame (fi)) { struct cleanup *cleanup_frame; QUIT; cleanup_frame = make_cleanup_ui_out_tuple_begin_end (uiout, "frame"); ui_out_field_int (uiout, "level", i); list_args_or_locals (arguments, print_values, fi, skip_unavailable); do_cleanups (cleanup_frame); } } do_cleanups (cleanup_stack_args); }
static int dump_insns (struct gdbarch *gdbarch, struct ui_out *uiout, struct disassemble_info * di, CORE_ADDR low, CORE_ADDR high, int how_many, int flags, struct ui_stream *stb) { int num_displayed = 0; CORE_ADDR pc; /* parts of the symbolic representation of the address */ int unmapped; int offset; int line; struct cleanup *ui_out_chain; for (pc = low; pc < high;) { char *filename = NULL; char *name = NULL; QUIT; if (how_many >= 0) { if (num_displayed >= how_many) break; else num_displayed++; } ui_out_chain = make_cleanup_ui_out_tuple_begin_end (uiout, NULL); ui_out_text (uiout, pc_prefix (pc)); ui_out_field_core_addr (uiout, "address", gdbarch, pc); if (!build_address_symbolic (gdbarch, pc, 0, &name, &offset, &filename, &line, &unmapped)) { /* We don't care now about line, filename and unmapped. But we might in the future. */ ui_out_text (uiout, " <"); if ((flags & DISASSEMBLY_OMIT_FNAME) == 0) ui_out_field_string (uiout, "func-name", name); ui_out_text (uiout, "+"); ui_out_field_int (uiout, "offset", offset); ui_out_text (uiout, ">:\t"); } else ui_out_text (uiout, ":\t"); if (filename != NULL) xfree (filename); if (name != NULL) xfree (name); ui_file_rewind (stb->stream); if (flags & DISASSEMBLY_RAW_INSN) { CORE_ADDR old_pc = pc; bfd_byte data; int status; const char *spacer = ""; /* Build the opcodes using a temporary stream so we can write them out in a single go for the MI. */ struct ui_stream *opcode_stream = ui_out_stream_new (uiout); struct cleanup *cleanups = make_cleanup_ui_out_stream_delete (opcode_stream); pc += gdbarch_print_insn (gdbarch, pc, di); for (;old_pc < pc; old_pc++) { status = (*di->read_memory_func) (old_pc, &data, 1, di); if (status != 0) (*di->memory_error_func) (status, old_pc, di); fprintf_filtered (opcode_stream->stream, "%s%02x", spacer, (unsigned) data); spacer = " "; } ui_out_field_stream (uiout, "opcodes", opcode_stream); ui_out_text (uiout, "\t"); do_cleanups (cleanups); } else pc += gdbarch_print_insn (gdbarch, pc, di); ui_out_field_stream (uiout, "inst", stb); ui_file_rewind (stb->stream); do_cleanups (ui_out_chain); ui_out_text (uiout, "\n"); } return num_displayed; }
enum mi_cmd_result mi_cmd_var_create (char *command, char **argv, int argc) { CORE_ADDR frameaddr = 0; struct varobj *var; char *name; char *frame; char *expr; char *type; struct cleanup *old_cleanups; enum varobj_type var_type; if (argc != 3) { /* mi_error_message = xstrprintf ("mi_cmd_var_create: Usage: ...."); return MI_CMD_ERROR; */ error ("mi_cmd_var_create: Usage: NAME FRAME EXPRESSION."); } name = xstrdup (argv[0]); /* Add cleanup for name. Must be free_current_contents as name can be reallocated */ old_cleanups = make_cleanup (free_current_contents, &name); frame = xstrdup (argv[1]); old_cleanups = make_cleanup (xfree, frame); expr = xstrdup (argv[2]); if (strcmp (name, "-") == 0) { xfree (name); name = varobj_gen_name (); } else if (!isalpha (*name)) error ("mi_cmd_var_create: name of object must begin with a letter"); if (strcmp (frame, "*") == 0) var_type = USE_CURRENT_FRAME; else if (strcmp (frame, "@") == 0) var_type = USE_SELECTED_FRAME; else { var_type = USE_SPECIFIED_FRAME; frameaddr = string_to_core_addr (frame); } if (varobjdebug) fprintf_unfiltered (gdb_stdlog, "Name=\"%s\", Frame=\"%s\" (0x%s), Expression=\"%s\"\n", name, frame, paddr (frameaddr), expr); var = varobj_create (name, expr, frameaddr, var_type); if (var == NULL) error ("mi_cmd_var_create: unable to create variable object"); ui_out_field_string (uiout, "name", name); ui_out_field_int (uiout, "numchild", varobj_get_num_children (var)); type = varobj_get_type (var); if (type == NULL) ui_out_field_string (uiout, "type", ""); else { ui_out_field_string (uiout, "type", type); xfree (type); } do_cleanups (old_cleanups); return MI_CMD_DONE; }