void _initialize_amd64nbsd_nat (void) { amd64_native_gregset32_reg_offset = amd64nbsd32_r_reg_offset; amd64_native_gregset32_num_regs = ARRAY_SIZE (amd64nbsd32_r_reg_offset); amd64_native_gregset64_reg_offset = amd64nbsd_r_reg_offset; /* We've got nothing to add to the common *BSD/amd64 target. */ add_target (amd64bsd_target ()); }
void _initialize_alpha_nat (void) { struct target_ops *t; t = procfs_target (); add_target (t); deprecated_add_core_fns (&alpha_osf_core_fns); }
void gbuffer::add_depth(const tstring& name, DXGI_SURFACE_DESC desc) { desc.Format = DXGI_FORMAT_R32_TYPELESS; desc.SampleDesc.Count = 1; desc.SampleDesc.Quality = 0; assert(device_); add_target(name, desc); }
// return from hopper to rendezvous in reverse direction void return_from_hopper() { byte h; if (active_hopper == HOPPER1) h = 0; else if (active_hopper == HOPPER2) h = 2; else if (active_hopper == HOPPER3) h = 3; else if (active_hopper == HOPPER4) h = 4; Hopper& hopper = hoppers[h]; if (hopper.waypoint == 0) { SERIAL_PRINT("No waypoints:"); SERIAL_PRINTLN(active_hopper); return; } add_target(RENDEZVOUS_X, RENDEZVOUS_Y, 0, TARGET_PUT); // skip the last target for (byte w = hoppers[h].waypoint - 1; w > 0; --w) { add_target(hopper_waypoints[h][w].x, hopper_waypoints[h][w].y); } }
void _initialize_mipsnbsd_nat (void) { struct target_ops *t; t = inf_ptrace_target (); t->to_fetch_registers = mipsnbsd_fetch_inferior_registers; t->to_store_registers = mipsnbsd_store_inferior_registers; add_target (t); }
void _initialize_thread_db (void) { if (fbsdcoreops_suppress_target) return; init_fbsd_thread_ops (); init_fbsd_core_ops (); if (thread_db_load ()) { add_target (&fbsd_thread_ops); /* "thread tsd" command */ add_cmd ("tsd", class_run, fbsd_thread_tsd_cmd, "Show the thread-specific data keys and destructors " "for the process.\n", &thread_cmd_list); add_cmd ("signal", class_run, fbsd_thread_signal_cmd, "Show the thread signal info.\n", &thread_cmd_list); memcpy (&orig_core_ops, &core_ops, sizeof (struct target_ops)); memcpy (&core_ops, &fbsd_core_ops, sizeof (struct target_ops)); add_target (&core_ops); /* Add ourselves to objfile event chain. */ target_new_objfile_chain = target_new_objfile_hook; target_new_objfile_hook = fbsd_thread_new_objfile; child_suppress_run = 1; } else { fprintf_unfiltered (gdb_stderr, "[GDB will not be able to debug user-mode threads: %s]\n", dlerror()); /* allow the user to debug non-threaded core files */ add_target (&core_ops); } }
void SuperLogger::set_log_target(ILogTarget* log_target) { if (m_log_target) { remove_target(m_log_target); delete m_log_target; } m_log_target = log_target; add_target(m_log_target); }
void merger::add(const model& m) { require_not_has_merged(); if (m.is_target()) add_target(m); BOOST_LOG_SEV(lg, debug) << "adding model: " << m.name().qualified(); BOOST_LOG_SEV(lg, debug) << "contents: " << m; models_.insert(std::make_pair(m.name(), m)); }
void _initialize_shnbsd_nat (void) { struct target_ops *t; t = inf_ptrace_target (); t->to_fetch_registers = shnbsd_fetch_inferior_registers; t->to_store_registers = shnbsd_store_inferior_registers; t->to_pid_to_exec_file = nbsd_pid_to_exec_file; add_target (t); }
void _initialize_sparc_sol2_nat (void) { struct target_ops *t; t = procfs_target (); #ifdef NEW_PROC_API /* Solaris 6 and above can do HW watchpoints. */ procfs_use_watchpoints (t); #endif add_target (t); }
void _initialize_record_btrace (void) { add_cmd ("btrace", class_obscure, cmd_record_btrace_start, _("Start branch trace recording."), &record_cmdlist); add_alias_cmd ("b", "btrace", class_obscure, 1, &record_cmdlist); init_record_btrace_ops (); add_target (&record_btrace_ops); }
void _initialize_nbsd_thread (void) { init_nbsd_thread_ops (); init_nbsd_proc_callbacks (); add_target (&nbsd_thread_ops); /* Hook into new_objfile notification. */ observer_attach_new_objfile (nbsd_thread_new_objfile); }
void _initialize_i386fbsd_nat (void) { struct target_ops *t; /* Add some extra features to the common *BSD/i386 target. */ t = i386bsd_target (); #ifdef HAVE_PT_GETDBREGS i386_use_watchpoints (t); i386_dr_low.set_control = i386bsd_dr_set_control; i386_dr_low.set_addr = i386bsd_dr_set_addr; i386_dr_low.get_addr = i386bsd_dr_get_addr; i386_dr_low.get_status = i386bsd_dr_get_status; i386_dr_low.get_control = i386bsd_dr_get_control; i386_set_debug_register_length (4); #endif /* HAVE_PT_GETDBREGS */ t->to_resume = i386fbsd_resume; t->to_pid_to_exec_file = fbsd_pid_to_exec_file; t->to_find_memory_regions = fbsd_find_memory_regions; t->to_make_corefile_notes = fbsd_make_corefile_notes; add_target (t); /* Support debugging kernel virtual memory images. */ bsd_kvm_add_target (i386fbsd_supply_pcb); /* FreeBSD provides a kern.ps_strings sysctl that we can use to locate the sigtramp. That way we can still recognize a sigtramp if its location is changed in a new kernel. Of course this is still based on the assumption that the sigtramp is placed directly under the location where the program arguments and environment can be found. */ #ifdef KERN_PS_STRINGS { int mib[2]; u_long ps_strings; size_t len; mib[0] = CTL_KERN; mib[1] = KERN_PS_STRINGS; len = sizeof (ps_strings); if (sysctl (mib, 2, &ps_strings, &len, NULL, 0) == 0) { i386fbsd_sigtramp_start_addr = ps_strings - 128; i386fbsd_sigtramp_end_addr = ps_strings; } } #endif }
void _initialize_hppabsd_nat (void) { struct target_ops *t; /* Add in local overrides. */ t = inf_ptrace_target (); t->to_fetch_registers = hppabsd_fetch_registers; t->to_store_registers = hppabsd_store_registers; add_target (t); }
void _initialize_irix5_nat (void) { struct target_ops *t; t = procfs_target (); procfs_use_watchpoints (t); add_target (t); deprecated_add_core_fns (&irix5_core_fns); }
void _initialize_sparcnbsd_nat (void) { sparc_gregmap = &sparc32nbsd_gregmap; sparc_fpregmap = &sparc32_bsd_fpregmap; /* We've got nothing to add to the generic SPARC target. */ add_target (sparc_target ()); /* Support debugging kernel virtual memory images. */ bsd_kvm_add_target (sparc32nbsd_supply_pcb); }
void _initialize_linux_kernel() { add_target (&lk_ops); #if 0 add_show_from_set ( add_set_cmd ("kerneldebug", no_class, var_boolean, (char *)&lkdebug, "Set debugging of linux kernel debugger.\n", &setlist), &showlist); #endif }
/* Initialize the SPU multi-architecture support target. */ static void init_spu_ops (void) { spu_ops.to_shortname = "spu"; spu_ops.to_longname = "SPU multi-architecture support."; spu_ops.to_doc = "SPU multi-architecture support."; spu_ops.to_mourn_inferior = spu_mourn_inferior; spu_ops.to_fetch_registers = spu_fetch_registers; spu_ops.to_store_registers = spu_store_registers; spu_ops.to_xfer_partial = spu_xfer_partial; spu_ops.to_search_memory = spu_search_memory; spu_ops.to_region_ok_for_hw_watchpoint = spu_region_ok_for_hw_watchpoint; spu_ops.to_thread_architecture = spu_thread_architecture; spu_ops.to_stratum = arch_stratum; spu_ops.to_magic = OPS_MAGIC; } extern void _initialize_spu_multiarch(void); /* -Wmissing-prototypes */ void _initialize_spu_multiarch(void) { /* Install ourselves on the target stack. */ init_spu_ops (); add_target (&spu_ops); /* Install observers to watch for SPU objects. */ observer_attach_inferior_created (spu_multiarch_inferior_created); observer_attach_solib_loaded (spu_multiarch_solib_loaded); observer_attach_solib_unloaded (spu_multiarch_solib_unloaded); }
void _initialize_sh3_rom (void) { init_sh3_cmds (); init_monitor_ops (&sh3_ops); sh3_ops.to_shortname = "sh3"; sh3_ops.to_longname = "Renesas SH-3 rom monitor"; sh3_ops.to_doc = /* We can download through the parallel port too. */ "Debug on a Renesas eval board running the SH-3E rom monitor.\n" "Specify the serial device it is connected to.\n" "If you want to use the parallel port to download to it, specify that\n" "as an additional second argument."; sh3_ops.to_open = sh3_open; sh3_ops.to_close = sh3_close; add_target (&sh3_ops); /* Setup the SH3e, which has float registers. */ init_monitor_ops (&sh3e_ops); sh3e_ops.to_shortname = "sh3e"; sh3e_ops.to_longname = "Renesas SH-3E rom monitor"; sh3e_ops.to_doc = /* We can download through the parallel port too. */ "Debug on a Renesas eval board running the SH-3E rom monitor.\n" "Specify the serial device it is connected to.\n" "If you want to use the parallel port to download to it, specify that\n" "as an additional second argument."; sh3e_ops.to_open = sh3e_open; sh3e_ops.to_close = sh3_close; add_target (&sh3e_ops); }
void SuperLogger::enable_message_coloring() { LogMessage::FormattingFlags flags[LogMessage::NumMessageCategories]; save_formatting_flags(*m_log_target, flags); remove_target(m_log_target); delete m_log_target; m_log_target = create_console_log_target(stderr); add_target(m_log_target); restore_formatting_flags(*m_log_target, flags); }
void _initialize_remote_sim (void) { init_gdbsim_ops (); add_target (&gdbsim_ops); add_com ("sim", class_obscure, simulator_command, _("Send a command to the simulator.")); /* Yes, 42000 is arbitrary. The only sense out of it, is that it isn't 0. */ remote_sim_ptid = ptid_build (42000, 0, 42000); }
void _initialize_m68kbsd_nat (void) { struct target_ops *t; t = inf_ptrace_target (); t->to_fetch_registers = m68kbsd_fetch_inferior_registers; t->to_store_registers = m68kbsd_store_inferior_registers; add_target (t); /* Support debugging kernel virtual memory images. */ bsd_kvm_add_target (m68kbsd_supply_pcb); }
/* * add to the dependecy and selection lists */ static void add_depend(struct makenode *node, const char *dst) { struct makenode *dep; dep = add_target(dst); loop = 0; if (check_loop(dep, node)) return; dep->select = new_list(node, dep->select); dep->num_sels++; node->depend = new_list(dep, node->depend); node->num_deps++; }
void _initialize_arm_netbsd_nat (void) { struct target_ops *t; t = inf_ptrace_target (); t->to_fetch_registers = armnbsd_fetch_registers; t->to_store_registers = armnbsd_store_registers; add_target (t); deprecated_add_core_fns (&arm_netbsd_core_fns); deprecated_add_core_fns (&arm_netbsd_elfcore_fns); }
void _initialize_amd64obsd_nat (void) { amd64_native_gregset32_reg_offset = amd64obsd32_r_reg_offset; amd64_native_gregset32_num_regs = ARRAY_SIZE (amd64obsd32_r_reg_offset); amd64_native_gregset64_reg_offset = amd64obsd_r_reg_offset; /* We've got nothing to add to the common *BSD/amd64 target. */ add_target (amd64bsd_target ()); /* Support debugging kernel virtual memory images. */ bsd_kvm_add_target (amd64obsd_supply_pcb); }
void _initialize_i386gnu_nat (void) { struct target_ops *t; /* Fill in the generic GNU/Hurd methods. */ t = gnu_target (); t->to_fetch_registers = gnu_fetch_registers; t->to_store_registers = gnu_store_registers; /* Register the target. */ add_target (t); }
void _initialize_dbug_rom (void) { init_dbug_cmds (); init_monitor_ops (&dbug_ops); dbug_ops.to_shortname = "dbug"; dbug_ops.to_longname = "dBUG monitor"; dbug_ops.to_doc = "Debug via the dBUG monitor.\n\ Specify the serial device it is connected to (e.g. /dev/ttya)."; dbug_ops.to_open = dbug_open; add_target (&dbug_ops); }
void _initialize_ppcnbsd_nat (void) { struct target_ops *t; /* Support debugging kernel virtual memory images. */ bsd_kvm_add_target (ppcnbsd_supply_pcb); /* Add in local overrides. */ t = inf_ptrace_target (); t->to_fetch_registers = ppcnbsd_fetch_inferior_registers; t->to_store_registers = ppcnbsd_store_inferior_registers; add_target (t); }
void _initialize_w89k (void) { init_w89k_cmds (); init_monitor_ops (&w89k_ops); w89k_ops.to_shortname = "w89k"; w89k_ops.to_longname = "WinBond's debug monitor for the W89k Eval board"; w89k_ops.to_doc = "Debug on a WinBond W89K eval board.\n\ Specify the serial device it is connected to (e.g. /dev/ttya)."; w89k_ops.to_open = w89k_open; add_target (&w89k_ops); }
void _initialize_record_btrace (void) { add_cmd ("btrace", class_obscure, cmd_record_btrace_start, _("Start branch trace recording."), &record_cmdlist); add_alias_cmd ("b", "btrace", class_obscure, 1, &record_cmdlist); init_record_btrace_ops (); add_target (&record_btrace_ops); bfcache = htab_create_alloc (50, bfcache_hash, bfcache_eq, NULL, xcalloc, xfree); }