Mercurial > repos > blastem

comparison debug.c @ 2500:d44fe974fb85

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Get blastem compiling with new 68K core
author Michael Pavone <pavone@retrodev.com>
date Tue, 30 Apr 2024 22:32:08 -0700
parents d74d3998482c
children 927083238a39
comparison
equal deleted inserted replaced
2499:d74d3998482c 2500:d44fe974fb85
1628 static debug_val m68k_sr_get(debug_var *var) 1628 static debug_val m68k_sr_get(debug_var *var)
1629 { 1629 {
1630 m68k_context *context = var->ptr; 1630 m68k_context *context = var->ptr;
1631 debug_val ret; 1631 debug_val ret;
1632 ret.v.u32 = context->status << 8; 1632 ret.v.u32 = context->status << 8;
1633 #ifdef NEW_CORE
1634 //TODO: implement me
1635 #else
1633 for (int flag = 0; flag < 5; flag++) 1636 for (int flag = 0; flag < 5; flag++)
1634 { 1637 {
1635 ret.v.u32 |= context->flags[flag] << (4-flag); 1638 ret.v.u32 |= context->flags[flag] << (4-flag);
1636 } 1639 }
1640 #endif
1637 ret.type = DBG_VAL_U32; 1641 ret.type = DBG_VAL_U32;
1638 return ret; 1642 return ret;
1639 } 1643 }
1640 1644
1641 static void m68k_sr_set(debug_var *var, debug_val val) 1645 static void m68k_sr_set(debug_var *var, debug_val val)
1645 if (!debug_cast_int(val, &ival)) { 1649 if (!debug_cast_int(val, &ival)) {
1646 fprintf(stderr, "M68K register sr can only be set to an integer\n"); 1650 fprintf(stderr, "M68K register sr can only be set to an integer\n");
1647 return; 1651 return;
1648 } 1652 }
1649 context->status = ival >> 8; 1653 context->status = ival >> 8;
1654 #ifdef NEW_CORE
1655 //TODO: implement me
1656 #else
1650 for (int flag = 0; flag < 5; flag++) { 1657 for (int flag = 0; flag < 5; flag++) {
1651 context->flags[flag] = (ival & (1 << (4 - flag))) != 0; 1658 context->flags[flag] = (ival & (1 << (4 - flag))) != 0;
1652 } 1659 }
1660 #endif
1653 } 1661 }
1654 1662
1655 static debug_val m68k_cycle_get(debug_var *var) 1663 static debug_val m68k_cycle_get(debug_var *var)
1656 { 1664 {
1657 m68k_context *context = var->ptr; 1665 m68k_context *context = var->ptr;
3740 } 3748 }
3741 3749
3742 static uint8_t cmd_backtrace_m68k(debug_root *root, parsed_command *cmd) 3750 static uint8_t cmd_backtrace_m68k(debug_root *root, parsed_command *cmd)
3743 { 3751 {
3744 m68k_context *context = root->cpu_context; 3752 m68k_context *context = root->cpu_context;
3753 #ifdef NEW_CORE
3754 //TODO: implement me
3755 #else
3745 uint32_t stack = context->aregs[7]; 3756 uint32_t stack = context->aregs[7];
3746 uint8_t non_adr_count = 0; 3757 uint8_t non_adr_count = 0;
3747 do { 3758 do {
3748 uint32_t bt_address = m68k_instruction_fetch(stack, context); 3759 uint32_t bt_address = m68k_instruction_fetch(stack, context);
3749 bt_address = get_instruction_start(context->opts, bt_address - 2); 3760 bt_address = get_instruction_start(context->opts, bt_address - 2);
3760 stack += 2; 3771 stack += 2;
3761 non_adr_count++; 3772 non_adr_count++;
3762 } 3773 }
3763 //TODO: Make sure we don't wander into an invalid memory region 3774 //TODO: Make sure we don't wander into an invalid memory region
3764 } while (stack && non_adr_count < 6); 3775 } while (stack && non_adr_count < 6);
3776 #endif
3765 return 1; 3777 return 1;
3766 } 3778 }
3767 3779
3768 static uint8_t cmd_disassemble_m68k(debug_root *root, parsed_command *cmd) 3780 static uint8_t cmd_disassemble_m68k(debug_root *root, parsed_command *cmd)
3769 { 3781 {
3773 if (!debug_cast_int(cmd->args[0].value, &address)) { 3785 if (!debug_cast_int(cmd->args[0].value, &address)) {
3774 fprintf(stderr, "Argument to disassemble must be an integer if provided\n"); 3786 fprintf(stderr, "Argument to disassemble must be an integer if provided\n");
3775 return 1; 3787 return 1;
3776 } 3788 }
3777 } 3789 }
3790 #ifndef NEW_CORE
3778 char disasm_buf[1024]; 3791 char disasm_buf[1024];
3779 m68kinst inst; 3792 m68kinst inst;
3780 do { 3793 do {
3781 label_def *def = find_label(root->disasm, address); 3794 label_def *def = find_label(root->disasm, address);
3782 if (def) { 3795 if (def) {
3788 3801
3789 address = m68k_decode(m68k_instruction_fetch, context, &inst, address); 3802 address = m68k_decode(m68k_instruction_fetch, context, &inst, address);
3790 m68k_disasm_labels(&inst, disasm_buf, root->disasm); 3803 m68k_disasm_labels(&inst, disasm_buf, root->disasm);
3791 printf("\t%s\n", disasm_buf); 3804 printf("\t%s\n", disasm_buf);
3792 } while(!m68k_is_terminal(&inst)); 3805 } while(!m68k_is_terminal(&inst));
3806 #endif
3793 return 1; 3807 return 1;
3794 } 3808 }
3795 3809
3796 static uint8_t cmd_vdp_sprites(debug_root *root, parsed_command *cmd) 3810 static uint8_t cmd_vdp_sprites(debug_root *root, parsed_command *cmd)
3797 { 3811 {
4370 }; 4384 };
4371 4385
4372 #define NUM_SCD_SUB (sizeof(scd_main_commands)/sizeof(*scd_main_commands)) 4386 #define NUM_SCD_SUB (sizeof(scd_main_commands)/sizeof(*scd_main_commands))
4373 4387
4374 #ifndef NO_Z80 4388 #ifndef NO_Z80
4389 #ifndef NEW_CORE
4375 4390
4376 static uint8_t cmd_delete_z80(debug_root *root, parsed_command *cmd) 4391 static uint8_t cmd_delete_z80(debug_root *root, parsed_command *cmd)
4377 { 4392 {
4378 uint32_t index; 4393 uint32_t index;
4379 if (!debug_cast_int(cmd->args[0].value, &index)) { 4394 if (!debug_cast_int(cmd->args[0].value, &index)) {
4589 address += after - pc; 4604 address += after - pc;
4590 printf("\t%s\n", disasm_buf); 4605 printf("\t%s\n", disasm_buf);
4591 } while(!z80_is_terminal(&inst)); 4606 } while(!z80_is_terminal(&inst));
4592 return 1; 4607 return 1;
4593 } 4608 }
4609 #endif //NEW_CORE
4594 4610
4595 static uint8_t cmd_gen_m68k(debug_root *root, parsed_command *cmd) 4611 static uint8_t cmd_gen_m68k(debug_root *root, parsed_command *cmd)
4596 { 4612 {
4597 char *param = cmd->raw; 4613 char *param = cmd->raw;
4598 while (param && *param && isblank(*param)) 4614 while (param && *param && isblank(*param))
4635 vdp_print_reg_explain(sms->vdp); 4651 vdp_print_reg_explain(sms->vdp);
4636 return 1; 4652 return 1;
4637 } 4653 }
4638 4654
4639 command_def z80_commands[] = { 4655 command_def z80_commands[] = {
4656 #ifndef NEW_CORE
4640 { 4657 {
4641 .names = (const char *[]){ 4658 .names = (const char *[]){
4642 "breakpoint", "b", NULL 4659 "breakpoint", "b", NULL
4643 }, 4660 },
4644 .usage = "breakpoint ADDRESSS", 4661 .usage = "breakpoint ADDRESSS",
4725 .desc = "Disassemble code starting at ADDRESS if provided or the current address if not", 4742 .desc = "Disassemble code starting at ADDRESS if provided or the current address if not",
4726 .impl = cmd_disassemble_z80, 4743 .impl = cmd_disassemble_z80,
4727 .min_args = 0, 4744 .min_args = 0,
4728 .max_args = 1 4745 .max_args = 1
4729 } 4746 }
4747 #endif //NEW_CORE
4730 }; 4748 };
4731 4749
4732 #define NUM_Z80 (sizeof(z80_commands)/sizeof(*z80_commands)) 4750 #define NUM_Z80 (sizeof(z80_commands)/sizeof(*z80_commands))
4733 4751
4734 command_def gen_z80_commands[] = { 4752 command_def gen_z80_commands[] = {
4872 } 4890 }
4873 return root; 4891 return root;
4874 } 4892 }
4875 4893
4876 #ifndef NO_Z80 4894 #ifndef NO_Z80
4895 #ifdef NEW_CORE
4896 #define Z80_OPTS opts
4897 #else
4898 #define Z80_OPTS options
4899 #endif
4877 4900
4878 static uint8_t read_z80(debug_root *root, uint32_t *out, char size) 4901 static uint8_t read_z80(debug_root *root, uint32_t *out, char size)
4879 { 4902 {
4880 z80_context *context = root->cpu_context; 4903 z80_context *context = root->cpu_context;
4881 uint32_t address = *out; 4904 uint32_t address = *out;
4882 *out = read_byte(address, (void **)context->mem_pointers, &context->options->gen, context); 4905 *out = read_byte(address, (void **)context->mem_pointers, &context->Z80_OPTS->gen, context);
4883 if (size == 'w') { 4906 if (size == 'w') {
4884 *out |= read_byte(address + 1, (void **)context->mem_pointers, &context->options->gen, context) << 8; 4907 *out |= read_byte(address + 1, (void **)context->mem_pointers, &context->Z80_OPTS->gen, context) << 8;
4885 } 4908 }
4886 return 1; 4909 return 1;
4887 } 4910 }
4888 4911
4889 static uint8_t write_z80(debug_root *root, uint32_t address, uint32_t value, char size) 4912 static uint8_t write_z80(debug_root *root, uint32_t address, uint32_t value, char size)
4890 { 4913 {
4891 z80_context *context = root->cpu_context; 4914 z80_context *context = root->cpu_context;
4892 write_byte(address, value, (void **)context->mem_pointers, &context->options->gen, context); 4915 write_byte(address, value, (void **)context->mem_pointers, &context->Z80_OPTS->gen, context);
4893 if (size == 'w') { 4916 if (size == 'w') {
4894 write_byte(address + 1, value >> 8, (void **)context->mem_pointers, &context->options->gen, context); 4917 write_byte(address + 1, value >> 8, (void **)context->mem_pointers, &context->Z80_OPTS->gen, context);
4895 } 4918 }
4896 return 1; 4919 return 1;
4897 } 4920 }
4898 4921
4922 #ifndef NEW_CORE
4899 static debug_val z80_reg8_get(debug_var *var) 4923 static debug_val z80_reg8_get(debug_var *var)
4900 { 4924 {
4901 z80_context *context = var->ptr; 4925 z80_context *context = var->ptr;
4902 return debug_int(context->regs[var->val.v.u32]); 4926 return debug_int(context->regs[var->val.v.u32]);
4903 } 4927 }
5210 var->ptr = root->cpu_context; 5234 var->ptr = root->cpu_context;
5211 var->get = z80_pc_get; 5235 var->get = z80_pc_get;
5212 root->variables = tern_insert_ptr(root->variables, "pc", var); 5236 root->variables = tern_insert_ptr(root->variables, "pc", var);
5213 root->variables = tern_insert_ptr(root->variables, "PC", var); 5237 root->variables = tern_insert_ptr(root->variables, "PC", var);
5214 } 5238 }
5239 #endif //NEW_CORE
5215 5240
5216 static uint32_t z80_chunk_end(debug_root *root, uint32_t start_address) 5241 static uint32_t z80_chunk_end(debug_root *root, uint32_t start_address)
5217 { 5242 {
5218 z80_context *z80 = root->cpu_context; 5243 z80_context *z80 = root->cpu_context;
5219 memmap_chunk const *chunk = find_map_chunk(start_address, &z80->options->gen, 0, NULL); 5244 memmap_chunk const *chunk = find_map_chunk(start_address, &z80->Z80_OPTS->gen, 0, NULL);
5220 if (!chunk) { 5245 if (!chunk) {
5221 return start_address; 5246 return start_address;
5222 } 5247 }
5223 if (chunk->mask == z80->options->gen.address_mask) { 5248 if (chunk->mask == z80->Z80_OPTS->gen.address_mask) {
5224 return chunk->end; 5249 return chunk->end;
5225 } 5250 }
5226 return (start_address & ~chunk->mask) + chunk->mask + 1; 5251 return (start_address & ~chunk->mask) + chunk->mask + 1;
5227 } 5252 }
5228 5253
5230 { 5255 {
5231 debug_root *root = find_root(context); 5256 debug_root *root = find_root(context);
5232 if (root && !root->commands) { 5257 if (root && !root->commands) {
5233 add_commands(root, common_commands, NUM_COMMON); 5258 add_commands(root, common_commands, NUM_COMMON);
5234 add_commands(root, z80_commands, NUM_Z80); 5259 add_commands(root, z80_commands, NUM_Z80);
5260 #ifndef NEW_CORE
5235 z80_names(root); 5261 z80_names(root);
5262 #endif
5236 genesis_context *gen; 5263 genesis_context *gen;
5237 sms_context *sms; 5264 sms_context *sms;
5238 coleco_context *coleco; 5265 coleco_context *coleco;
5239 debug_var *var; 5266 debug_var *var;
5240 //TODO: populate names 5267 //TODO: populate names
5313 return context; 5340 return context;
5314 } 5341 }
5315 } else { 5342 } else {
5316 zremove_breakpoint(context, address); 5343 zremove_breakpoint(context, address);
5317 } 5344 }
5345 #ifndef NEW_CORE
5318 if (context->wp_hit) { 5346 if (context->wp_hit) {
5319 context->wp_hit = 0; 5347 context->wp_hit = 0;
5320 this_bp = find_breakpoint(&root->breakpoints, context->wp_hit_address, BP_TYPE_CPU_WATCH); 5348 this_bp = find_breakpoint(&root->breakpoints, context->wp_hit_address, BP_TYPE_CPU_WATCH);
5321 if (*this_bp) { 5349 if (*this_bp) {
5322 if ((*this_bp)->condition) { 5350 if ((*this_bp)->condition) {
5346 fflush(stdout); 5374 fflush(stdout);
5347 return context; 5375 return context;
5348 } 5376 }
5349 } 5377 }
5350 } 5378 }
5379 #endif
5351 uint8_t * pc = get_native_pointer(address, (void **)context->mem_pointers, &context->Z80_OPTS->gen); 5380 uint8_t * pc = get_native_pointer(address, (void **)context->mem_pointers, &context->Z80_OPTS->gen);
5352 if (!pc) { 5381 if (!pc) {
5353 fatal_error("Failed to get native pointer on entering Z80 debugger at address %X\n", address); 5382 fatal_error("Failed to get native pointer on entering Z80 debugger at address %X\n", address);
5354 } 5383 }
5355 uint8_t * after_pc = z80_decode(pc, &inst); 5384 uint8_t * after_pc = z80_decode(pc, &inst);
5380 char input_buf[1024]; 5409 char input_buf[1024];
5381 m68kinst inst; 5410 m68kinst inst;
5382 5411
5383 init_terminal(); 5412 init_terminal();
5384 5413
5414 #ifndef NEW_CORE
5385 context->opts->sync_components(context, 0); 5415 context->opts->sync_components(context, 0);
5416 #endif
5386 debug_root *root = find_m68k_root(context); 5417 debug_root *root = find_m68k_root(context);
5387 if (!root) { 5418 if (!root) {
5388 return; 5419 return;
5389 } 5420 }
5390 //probably not necessary, but let's play it safe 5421 //probably not necessary, but let's play it safe
5467 } 5498 }
5468 if (context->system == current_system) { 5499 if (context->system == current_system) {
5469 genesis_context *gen = context->system; 5500 genesis_context *gen = context->system;
5470 vdp_force_update_framebuffer(gen->vdp); 5501 vdp_force_update_framebuffer(gen->vdp);
5471 } 5502 }
5503 #ifndef NEW_CORE
5472 uint32_t after = m68k_decode(m68k_instruction_fetch, context, &inst, address); 5504 uint32_t after = m68k_decode(m68k_instruction_fetch, context, &inst, address);
5473 root->after = after; 5505 root->after = after;
5474 root->inst = &inst; 5506 root->inst = &inst;
5507 #endif
5475 for (disp_def * cur = root->displays; cur; cur = cur->next) { 5508 for (disp_def * cur = root->displays; cur; cur = cur->next) {
5476 char format_str[8]; 5509 char format_str[8];
5477 make_format_str(format_str, cur->format); 5510 make_format_str(format_str, cur->format);
5478 for (int i = 0; i < cur->num_args; i++) 5511 for (int i = 0; i < cur->num_args; i++)
5479 { 5512 {