/*--------------------------------------------------------------------------------------* | | | gdb_testing.i | | | | Separate place to "bread board", test, and expirement with gdb | | | | Ira L. Ruben | | Copyright Apple Computer, Inc. 2000-2006 | | | *--------------------------------------------------------------------------------------* This file is just for "fooling around". It is included as part of gdb.c and uses its #include setup. As such it can talk directly to gdb since the includes and -I's for gdb.c allow using its frameworks. */ /*--------------------------------------------------------------------------------------*/ static char *(*saved_cmd_line_input_hook)(char *, int, char *) = NULL; static void (*saved_window_hook)(FILE *, char *) = NULL; extern void (*window_hook) PARAMS ((FILE *, char *)); /*--------------------------------------------------------------------------------------*/ static char rawline[1024]; static int cp = 0; static void (*saved_rl_getc_function)(); static int first_testx = 1; static int my_getc(FILE *stream) { int i, c = ((int (*)(FILE*))saved_rl_getc_function)(stream); rawline[cp++] = c; //fprintf(stderr, "%.2x\n", c); if (c == '\n' || c == '\r') { rawline[cp] = 0; fprintf(stderr, "\n"); for (i = 0; i < cp; ++i) fprintf(stderr, "%.2x ", rawline[i] & 0xFF); fprintf(stderr, " ==> "); for (i = 0; i < cp; ++i) { c = rawline[i] & 0xFF; fprintf(stderr, "%c", (c < ' ') ? '¥' : c); } fprintf(stderr, "\n"); cp = 0; } return (c); } void gdb_testx(char *arg, int from_tty) { if (first_testx) { first_testx = 0; saved_rl_getc_function = rl_getc_function; rl_getc_function = (void (*)())my_getc; } cp = 0; } /*--------------------------------------------------------------------------------------*/ void gdb_testy(char *arg, int from_tty) { } /*--------------------------------------------------------------------------------------*/ static Gdb_Cmd_Class myClass = Gdb_Private; void a_cmd(char *arg, int from_tty) { gdb_printf("a_cmd(%s)\n", a_cmd ? a_cmd : "<null>"); } void gdb_testa(char *arg, int from_tty) { struct cmd_list_element *c; char alias[1024]; if (arg && *arg) { gdb_define_cmd(arg, a_cmd, myClass, "cmd help."); if (strlen(arg) > 1) { strcpy(alias, arg); alias[0]= 'X'; gdb_define_cmd_alias(arg, alias); } } } /*--------------------------------------------------------------------------------------*/ //#include "ui-file.h" void gdb_testw(char *addr) { struct objfile *objfile; struct obj_section *p; #if 0 if (addr && *addr) { p = find_pc_section((CORE_ADDR)gdb_get_address(addr)); if (p) gdb_printf("%s is %s\n", bfd_get_filename(p->objfile->obfd), bfd_section_name(unused, p->the_bfd_section)); } #else ALL_OBJFILES(objfile) { #if 1 print_section_info_objfile(objfile); gdb_printf("-------------------------------\n"); #elif 0 ui_out_field_string(uiout, "filename", bfd_get_filename(objfile->obfd)); ui_out_text (uiout, "\n"); gdb_printf("-------------------------------\n"); #elif 0 print_section_info_objfile(objfile); for (p = objfile->sections; p < objfile->sections_end; p++) { if (find_pc_sect_section((CORE_ADDR)addr, p)) { gdb_printf("%s\n", bfd_get_filename(objfile->obfd)); break; } } #endif } #endif } /*--------------------------------------------------------------------------------------*/ void gdb_testz(char *arg, int from_tty) { #if 0 int regnum; //int numregs = ARCH_NUM_REGS; char virtual_buffer[MAX_REGISTER_VIRTUAL_SIZE]; char raw_buffer[MAX_REGISTER_RAW_SIZE]; if (!arg || !*arg) return; regnum = frame_map_name_to_regnum (arg, 2); if (regnum < 0) gdb_error("undefined"); if (REGISTER_NAME(regnum) == NULL || *(REGISTER_NAME(regnum)) == '\0') gdb_error("undefined for machine"); if (frame_register_read(selected_frame, regnum, raw_buffer)) gdb_error("value not available"); if (REGISTER_CONVERTIBLE(regnum)) { REGISTER_CONVERT_TO_VIRTUAL(regnum, REGISTER_VIRTUAL_TYPE(regnum), raw_buffer, virtual_buffer); } else memcpy(virtual_buffer, raw_buffer, REGISTER_VIRTUAL_SIZE(regnum)); #endif } /*--------------------------------------------------------------------------------------*/ #if 0 #include <time.h> #include <locale.h> #include "breakpoint.h" #include "ui-file.h" #define ALL_BREAKPOINTS(B) for (B = breakpoint_chain; B; B = B->next) extern struct breakpoint *breakpoint_chain; static void write_one_breakpoint (struct breakpoint *b, FILE *stream) { register struct command_line *l; switch (b->type) { case bp_watchpoint: fprintf_unfiltered (stream, "watch %s", b->exp_string); break; case bp_hardware_watchpoint: fprintf_unfiltered (stream, "watch %s", b->exp_string); break; case bp_read_watchpoint: fprintf_unfiltered (stream, "rwatch %s", b->exp_string); break; case bp_access_watchpoint: fprintf_unfiltered (stream, "awatch %s", b->exp_string); break; case bp_catch_load: case bp_catch_unload: fprintf_unfiltered (stream, "%scatch %sload", b->disposition == del ? "t" : "", b->type == bp_catch_unload ? "un" : ""); if (b->dll_pathname != NULL) fputs_unfiltered (b->dll_pathname, stream); break; case bp_catch_fork: fprintf_unfiltered (stream, "%scatch fork", b->disposition == del ? "t" : ""); break; case bp_catch_vfork: fprintf_unfiltered (stream, "%scatch vfork", b->disposition == del ? "t" : ""); break; case bp_catch_exec: fprintf_unfiltered (stream, "%scatch exec", b->disposition == del ? "t" : ""); break; case bp_catch_catch: fprintf_unfiltered (stream, "%scatch catch", b->disposition == del ? "t" : ""); break; case bp_catch_throw: fprintf_unfiltered (stream, "%scatch throw", b->disposition == del ? "t" : ""); break; case bp_breakpoint: case bp_hardware_breakpoint: if (b->enable == shlib_disabled) fputs_unfiltered ("future-", stream); fprintf_unfiltered (stream, "%s%sbreak", b->disposition == del ? "t" : "", (b->type == bp_hardware_breakpoint) ? "h" : ""); if (b->addr_string) { int len = strlen(b->addr_string) - 1; if (b->addr_string[len] == ' ') b->addr_string[len] = 0; else len = 0; fprintf_unfiltered (stream, " %s", b->addr_string); if (len) b->addr_string[len] = ' '; } else if (b->source_file) fprintf_unfiltered (stream, " %s:%d", b->source_file, b->line_number); else fprintf_unfiltered(stream, " %s", local_hex_string_custom((unsigned long) b->address, "08l")); break; } if (b->thread != -1) fprintf_unfiltered (stream, " thread %d", b->thread); if (b->cond_string) fprintf_unfiltered (stream, " if %s", b->cond_string); fputc_unfiltered ('\n', stream); if ((l = b->commands)) { fputs_unfiltered ("commands\n", stream); while (l) { print_command_line (l, 1, stream); l = l->next; } fputs_unfiltered ("end\n", stream); } if (b->ignore_count) fprintf_unfiltered (stream, "ignore $bpnum %d\n", b->ignore_count); if (b->enable == disabled) fputs_unfiltered ("disable $bpnum\n", stream); } void save_breakpoints_commandX (char *arg, int from_tty) { char *pathname, buf[256], *p; register struct breakpoint *b; int found_a_breakpoint = 0, current_radix, skip, prev_radix; long n; FILE *fp; struct ui_file *stream; time_t t; extern char *tilde_expand (char *); if (!arg || !*arg) error ("Argument required (file name in which to save breakpoints"); ALL_BREAKPOINTS (b) { /* Filter out non-user breakpoints. */ if ( b->type != bp_breakpoint && b->type != bp_catch_load && b->type != bp_catch_unload && b->type != bp_catch_fork && b->type != bp_catch_vfork && b->type != bp_catch_exec && b->type != bp_catch_catch && b->type != bp_catch_throw && b->type != bp_hardware_breakpoint && b->type != bp_watchpoint && b->type != bp_read_watchpoint && b->type != bp_access_watchpoint && b->type != bp_hardware_watchpoint) continue; if (!found_a_breakpoint++) { if ((fp = fopen ((pathname = tilde_expand (arg)), "w")) == NULL) error ("Unable to open file '%s' for saving breakpoints (%s)", arg, strerror (errno)); stream = stdio_fileopen (fp); if (time (&t) != -1) { char *l= setlocale (LC_ALL, NULL); if (l) { char *orig_locale = strcpy(xmalloc(strlen(l)+1), l); (void)setlocale(LC_ALL, ""); if (strftime (buf, sizeof(buf), "%a %b %e %H:%M:%S %Z %Y", localtime (&t))) fprintf_unfiltered (stream, "# Saved breakpoints file created on %s\n\n", buf); setlocale(LC_ALL, orig_locale); } } current_radix = -1; } skip = (b->commands || b->ignore_count || b->enable == disabled); if (skip) fputc_unfiltered ('\n', stream); if (b->input_radix != current_radix) { if (!skip && current_radix != -1) fputc_unfiltered ('\n', stream); // ------- determine initial radix here ------- prev_radix = (current_radix == -1) ? input_radix : current_radix; if (prev_radix > 36) { ui_file_delete (stream); fclose (fp); remove (pathname); xfree (pathname); error ("Current radix (%d) for breakpoint #%d to large to support for saving.", prev_radix, b->number); } n = b->input_radix; p = buf + 255; *p-- = '\0'; do { *p-- = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"[n % prev_radix]; n /= prev_radix; } while (n); fprintf_unfiltered (stream, "set input-radix %s\n", ++p); current_radix = b->input_radix; } write_one_breakpoint (b, stream); if (skip && b->next) fputc_unfiltered ('\n', stream); } if (!found_a_breakpoint) printf_filtered ("No breakpoints or watchpoints to save.\n"); else { // ------- restore original input radix here ------- //fprintf_unfiltered (stream, "\nset input-radix %d\n", ???????); ui_file_delete (stream); fclose (fp); xfree (pathname); if (from_tty) printf_filtered ("Breakpoints saved to file '%s'.\n", arg); } } #endif /*--------------------------------------------------------------------------------------*/ char *gdb_teste(GDB_ADDRESS addr) { int unmapped = 0; int offset = 0; int line = 0; char *filename = NULL; char *name = NULL; asection *section = NULL; struct minimal_symbol *msymbol; struct obj_section *addr_section; struct bfd_section *the_bfd_section; struct objfile *objfile; bfd *abfd; // references are bfd/bdd-in2.h, objfiles.h static char result[2048]; #if 0 if (!build_address_symbolic(addr, 0, &name, &offset, &filename, &line, &unmapped)) return (name); #endif msymbol = lookup_solib_trampoline_symbol_by_pc(addr); *result = '\0'; if (msymbol) strcpy(result, SYMBOL_LINKAGE_NAME(msymbol)); #if 0 msymbol = lookup_minimal_symbol_by_pc_section(addr, section); if (msymbol) if (*result) strcat(result, " "); sprintf(result + strlen(result), "(%s)", SYMBOL_BFD_SECTION(msymbol)->name); #endif // LC_SEGMENT.segname.sectname // LC_SEGMENT.__TEXT.__cstring // LC_SEGMENT.__DATA.__cfstring // LC_SEGMENT.__OBJC.__cstring_object addr_section = find_pc_section(addr); if (addr_section) { objfile = addr_section->objfile; abfd = addr_section->objfile->obfd; the_bfd_section = addr_section->the_bfd_section; if (the_bfd_section) { if (*result) strcat(result, " "); sprintf(result + strlen(result), "(%s)", the_bfd_section->name); } if (bfd_get_section_by_name(abfd, "LC_SEGMENT.__DATA.__basicstring")) { if (*result) strcat(result, " "); sprintf(result + strlen(result), "(RealBasic)"); } if (bfd_get_section_by_name(abfd, "LC_SEGMENT.__OBJC")) { if (*result) strcat(result, " "); sprintf(result + strlen(result), "(objc)"); } } if (!*result) *result = '\0'; return (result); } /*--------------------------------------------------------------------------------------*/