Add interrupt test

Author: AsaiYusuke

README.md

@@ -33,6 +33,9 @@ All tests passed.
   | Check write value history |                    | :heavy_check_mark: |                    |
 - Evaluate processor information
   - Cycle count
+- Simulate interrupt at any memory addresses
+  - NMI
+  - IRQ
 - Assertion operator
   - *"eq"* (Equal to)
   - *"ne"* (Not equal to)
@@ -134,8 +137,10 @@ ca65 V2.18 - Ubuntu 2.19-1
 - [Check value of stack](https://github.com/AsaiYusuke/6502_test_executor/blob/master/example/test/ok/stack.value.check.test.json)
 - [rts to caller](https://github.com/AsaiYusuke/6502_test_executor/blob/master/example/test/ok/stack.rts.check.test.json)
 
-### Processor information
-- [Cycle count](https://github.com/AsaiYusuke/6502_test_executor/blob/master/example/test/ok/error.timeout.test.json)
+### Processor conditions
+- [Cycle count information](https://github.com/AsaiYusuke/6502_test_executor/blob/master/example/test/ok/error.timeout.test.json)
+- [Interrupt hooks](https://github.com/AsaiYusuke/6502_test_executor/blob/master/example/test/ok/interrupt.test.json)
+
 ### Error handling
 - [Write to readonly memory](https://github.com/AsaiYusuke/6502_test_executor/blob/master/example/test/fail/error.readonly.test.json)
 - [Access to out of segment](https://github.com/AsaiYusuke/6502_test_executor/blob/master/example/test/fail/error.out_of_segment.test.json)

example/test/ok/interrupt.test.json

@@ -0,0 +1,53 @@
+{
+    "$schema": "../../../schema/testcase.schema.json",
+    "target": {
+        "start": {
+            "label": "control"
+        }
+    },
+    "cases": {
+        "NMI interrupt": {
+            "setup": {
+                "memory": [
+                    {
+                        "label": "vector_addr",
+                        "value": 0
+                    },
+                    {
+                        "label": "APU_PAD1",
+                        "sequence": [
+                            0,
+                            1,
+                            1,
+                            0
+                        ]
+                    }
+                ],
+                "interrupt": [
+                    {
+                        "type": "NMI",
+                        "hook": {
+                            "label": "save_id"
+                        }
+                    }
+                ]
+            },
+            "expected": {
+                "memory": [
+                    {
+                        "label": "vector_addr",
+                        "value": {
+                            "eq": 4
+                        }
+                    },
+                    {
+                        "label": "nmi_lock",
+                        "readCount": {
+                            "gt": 0
+                        }
+                    }
+                ]
+            }
+        }
+    }
+}

include/condition/condition.h

@@ -6,6 +6,7 @@
 #include "condition/condition_register_pc.h"
 #include "condition/condition_memory.h"
 #include "condition/condition_stack.h"
+#include "condition/condition_interrupt.h"
 #include "condition/condition_timeout.h"
 #include "nlohmann/json.hpp"
 
@@ -22,6 +23,7 @@ class condition
     vector<condition_memory> memory_defs;
     condition_register_pc *register_pc_def;
     condition_stack *stack_def;
+    vector<condition_interrupt> interrupt_defs;
     condition_timeout *timeout_def;
 
 protected:
@@ -31,6 +33,7 @@ class condition
     vector<condition_register_status_flag> get_status_flag_defs();
     vector<condition_memory> get_memory_defs();
     condition_stack *get_stack_def();
+    vector<condition_interrupt> get_interrupt_defs();
     condition_timeout *get_timeout_def();
 
 public:

include/condition/condition_interrupt.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include "enum/interrupt_type.h"
+#include "emulation/emulation_devices.h"
+#include "nlohmann/json.hpp"
+
+using namespace std;
+
+using json = nlohmann::json;
+
+class condition_interrupt
+{
+private:
+    interrupt_type type;
+    uint8_t hook_address;
+
+public:
+    condition_interrupt(emulation_devices *_device, json condition);
+    interrupt_type get_type();
+    uint8_t get_hook_address();
+};

include/emulation/cpu_device.h

@@ -6,7 +6,7 @@
 #include "nlohmann/json.hpp"
 #include "args_parser.h"
 #include "enum/register_type.h"
-#include "enum/runtime_error_type.h"
+#include "enum/interrupt_type.h"
 #include "runtime_error_result.h"
 
 #define TEST_RETURN_ADDRESS 0xFFFF
@@ -32,6 +32,7 @@ class cpu_device
     vector<pair<inst_type, uint16_t>> call_stack;
     uint16_t currentPC;
     uint16_t endPC;
+    map<uint8_t, interrupt_type> interrupt_defs;
 
 public:
     cpu_device(emulation_devices *_device, args_parser *args, json config);
@@ -43,6 +44,7 @@ class cpu_device
     uint8_t get_register(register_type type);
     void set_register(register_type type, uint8_t value);
     vector<uint8_t> get_stack();
+    void add_interrupt_hook(interrupt_type type, uint8_t address);
 
     void print();
     vector<uint16_t> get_call_stack();

include/enum/interrupt_type.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#include <map>
+#include <string>
+
+using namespace std;
+
+enum class interrupt_type
+{
+    // NMI
+    NMI,
+    // IRQ
+    IRQ
+};
+
+static map<string, interrupt_type> interrupt_name_type_map = {
+    {"NMI", interrupt_type::NMI},
+    {"IRQ", interrupt_type::IRQ}};

schema/testcase.schema.json

@@ -65,6 +65,32 @@
                                 "stack": {
                                     "title": "Stack",
                                     "$ref": "#/definitions/setup/stack"
+                                },
+                                "interrupt": {
+                                    "title": "Interrupt",
+                                    "type": "array",
+                                    "minItems": 1,
+                                    "items": {
+                                        "type": "object",
+                                        "required": [
+                                            "type",
+                                            "hook"
+                                        ],
+                                        "additionalProperties": false,
+                                        "properties": {
+                                            "type": {
+                                                "type": "string",
+                                                "enum": [
+                                                    "NMI",
+                                                    "IRQ"
+                                                ]
+                                            },
+                                            "hook": {
+                                                "title": "Hook address",
+                                                "$ref": "#/definitions/address"
+                                            }
+                                        }
+                                    }
                                 }
                             }
                         },
@@ -340,7 +366,7 @@
                     "type": "object",
                     "allOf": [
                         {
-                        "$ref": "#/definitions/address"
+                            "$ref": "#/definitions/address"
                         }
                     ],
                     "additionalProperties": false,

src/condition/condition.cpp

@@ -40,6 +40,13 @@ condition::condition(emulation_devices *_device, json condition_json)
 
     stack_def = new condition_stack(device, condition_json["stack"]);
 
+    if (condition_json["interrupt"].is_array())
+        for (auto &interrupt_def : condition_json["interrupt"])
+            interrupt_defs.push_back(
+                condition_interrupt(
+                    device,
+                    interrupt_def));
+
     timeout_def = new condition_timeout(device, condition_json["timeout"]);
 }
 
@@ -73,6 +80,11 @@ condition_stack *condition::get_stack_def()
     return stack_def;
 }
 
+vector<condition_interrupt> condition::get_interrupt_defs()
+{
+    return interrupt_defs;
+}
+
 condition_timeout *condition::get_timeout_def()
 {
     return timeout_def;

src/condition/condition_interrupt.cpp

@@ -0,0 +1,18 @@
+#include "condition/condition_interrupt.h"
+#include "util/value_convert.h"
+
+condition_interrupt::condition_interrupt(emulation_devices *device, json condition)
+{
+    type = interrupt_name_type_map[condition["type"]];
+    hook_address = value_convert::get_address(device, condition["hook"]);
+}
+
+interrupt_type condition_interrupt::get_type()
+{
+    return type;
+}
+
+uint8_t condition_interrupt::get_hook_address()
+{
+    return hook_address;
+}

src/emulation/cpu_device.cpp

@@ -46,6 +46,7 @@ void cpu_device::execute()
     {
         bool isCallInstr = false;
         bool isReternInstr = false;
+        bool isReterned = false;
 
         currentPC = cpu->GetPC();
 
@@ -60,6 +61,7 @@ void cpu_device::execute()
             {
                 call_stack.pop_back();
                 call_stack.pop_back();
+                isReterned = true;
             }
             else
             {
@@ -76,6 +78,21 @@ void cpu_device::execute()
         if (isReternInstr)
             call_stack.push_back(make_pair(inst_type::retern, cpu->GetPC()));
 
+        if (interrupt_defs.count(cpu->GetPC()) > 0 && !isReterned)
+        {
+            call_stack.push_back(make_pair(inst_type::call, cpu->GetPC()));
+            switch(interrupt_defs[cpu->GetPC()])
+            {
+                case interrupt_type::NMI:
+                    cpu->NMI();
+                    break;
+                case interrupt_type::IRQ:
+                    cpu->IRQ();
+                    break;
+            }
+            call_stack.push_back(make_pair(inst_type::call, cpu->GetPC()));
+        }
+
     } while (cpu->GetPC() != TEST_RETURN_ADDRESS && cpu->GetPC() != endPC && cycle_count <= get_max_cycle_count());
 
     if (cycle_count > get_max_cycle_count())
@@ -128,6 +145,11 @@ vector<uint8_t> cpu_device::get_stack()
     return result_stack;
 }
 
+void cpu_device::add_interrupt_hook(interrupt_type type, uint8_t address)
+{
+    interrupt_defs[address] = type;
+}
+
 void cpu_device::print()
 {
     printf("Register result:\n");