ppcemu: Use ppc_off_reason setter.

Makes things slightly cleaner and helps debugging. Changes to
ppc_off_reason can be logged.

benchmark/bench1.cpp

@@ -29,8 +29,7 @@ along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 #if defined(PPC_BENCHMARKS)
 void ppc_exception_handler(Except_Type exception_type, uint32_t srr1_bits) {
-    power_on = false;
-    power_off_reason = po_benchmark_exception;
+    power_off(po_benchmark_exception);
 }
 #endif
 

core/hostevents_sdl.cpp

@@ -44,8 +44,7 @@ void EventManager::poll_events() {
 
         switch (event.type) {
         case SDL_QUIT:
-            power_on = false;
-            power_off_reason = po_quit;
+            power_off(po_quit);
             break;
 
         case SDL_WINDOWEVENT: {
@@ -138,8 +137,7 @@ void EventManager::poll_events() {
                 // Control-D: debugger
                 if (event.key.keysym.sym == SDLK_d && (event.key.keysym.mod & KMOD_ALL) == KMOD_LCTRL) {
                     if (event.type == SDL_KEYUP) {
-                        power_on = false;
-                        power_off_reason = po_enter_debugger;
+                        power_off(po_enter_debugger);
                     }
                     return;
                 }

cpu/ppc/ppcemu.h

@@ -366,6 +366,11 @@ enum Po_Cause : int {
 
 extern bool power_on;
 extern Po_Cause power_off_reason;
+void p_set_power_off_reason(const char* file, int line, Po_Cause new_reason);
+void p_power_off(const char* file, int line, Po_Cause new_reason);
+#define set_power_off_reason(r) p_set_power_off_reason(__FILE__, __LINE__, r)
+#define power_off(r) p_power_off(__FILE__, __LINE__, r)
+
 extern bool int_pin;
 extern bool dec_exception_pending;
 

cpu/ppc/ppcexec.cpp

@@ -73,6 +73,43 @@ bool is_deterministic = false;
 bool power_on = false;
 Po_Cause power_off_reason = po_enter_debugger;
 
+const char * get_po_name(Po_Cause reason) {
+#define onename(x) case x: return #x;
+    switch (reason) {
+    onename(po_none)
+    onename(po_starting_up)
+    onename(po_quit)
+    onename(po_quitting)
+    onename(po_shut_down)
+    onename(po_shutting_down)
+    onename(po_restart)
+    onename(po_restarting)
+    onename(po_disassemble_on)
+    onename(po_disassemble_off)
+    onename(po_enter_debugger)
+    onename(po_entered_debugger)
+    onename(po_signal_interrupt)
+    onename(po_benchmark_exception)
+    onename(po_endian_switch)
+    default: return "unknown";
+    }
+#undef onename
+}
+
+void p_set_power_off_reason(const char* file, int line, Po_Cause new_reason) {
+    if (new_reason != power_off_reason) {
+        power_off_reason = new_reason;
+#if 1
+        LOG_F(INFO, "power_off_reason changed to %s at \"%s\":%d", get_po_name(new_reason), file, line);
+#endif
+    }
+}
+
+void p_power_off(const char* file, int line, Po_Cause new_reason) {
+    power_on = false;
+    p_set_power_off_reason(file, line, new_reason);
+}
+
 SetPRS ppc_state;
 #ifdef LOG_INSTRUCTIONS
 uint32_t pcp;
@@ -224,8 +261,7 @@ void ppc_msr_did_change(uint32_t old_msr_val, uint32_t new_msr_val, bool set_nex
             ppc_next_instruction_address = ppc_state.pc + 4;
         }
 #else
-        power_on = false;
-        power_off_reason = po_endian_switch;
+        power_off(po_endian_switch);
 #endif
     }
 }
@@ -235,14 +271,12 @@ void ppc_change_endian(bool newLE) {
     if (ppc_state.is_LE != newLE) {
         LOG_F(INFO, "changed endian to %s", newLE ? "LE" : "BE");
         ppc_state.is_LE = newLE;
-        power_on = false;
-        power_off_reason = po_endian_switch;
+        power_off(po_endian_switch);
     }
 #else
     if (newLE) {
         LOG_F(ERROR, "unsupported endian %s", newLE ? "LE" : "BE");
-        power_on = false;
-        power_off_reason = po_enter_debugger;
+        power_off(po_enter_debugger);
     }
 #endif
 }

debugger/debugger.cpp

@@ -730,21 +730,21 @@ void DppcDebugger::enter_debugger() {
 
     while (1) {
         if (power_off_reason == po_shut_down) {
-            power_off_reason = po_shutting_down;
+            set_power_off_reason(po_shutting_down);
             break;
         }
         if (power_off_reason == po_restart) {
-            power_off_reason = po_restarting;
+            set_power_off_reason(po_restarting);
             break;
         }
         if (power_off_reason == po_quit) {
-            power_off_reason = po_quitting;
+            set_power_off_reason(po_quitting);
             break;
         }
         power_on = true;
 
         if (power_off_reason == po_starting_up) {
-            power_off_reason = po_none;
+            set_power_off_reason(po_none);
             cmd = "go";
         }
         else if (power_off_reason == po_disassemble_on) {
@@ -755,13 +755,13 @@ void DppcDebugger::enter_debugger() {
             ss >> cmd;
         }
         else if (power_off_reason == po_disassemble_off) {
-            power_off_reason = po_none;
+            set_power_off_reason(po_none);
             cmd = "go";
         }
         else
         {
             if (power_off_reason == po_enter_debugger) {
-                power_off_reason = po_entered_debugger;
+                set_power_off_reason(po_entered_debugger);
             }
             if (!did_message) {
                 cout << endl;
@@ -798,7 +798,7 @@ void DppcDebugger::enter_debugger() {
         }
 
         if (power_off_reason == po_signal_interrupt) {
-            power_off_reason = po_enter_debugger;
+            set_power_off_reason(po_enter_debugger);
             // ignore command if interrupt happens because the input line is probably incomplete.
             last_cmd = "";
             continue;
@@ -825,8 +825,7 @@ void DppcDebugger::enter_debugger() {
             break;
         } else if (cmd == "restart") {
             cmd = "";
-            power_on = false;
-            power_off_reason = po_restart;
+            power_off(po_restart);
         } else if (cmd == "profile") {
             cmd = "";
             ss >> sub_cmd;

devices/common/viacuda.cpp

@@ -814,13 +814,11 @@ void ViaCuda::pseudo_command() {
         break;
     case CUDA_RESTART_SYSTEM:
         LOG_F(INFO, "Cuda: system restart");
-        power_on = false;
-        power_off_reason = po_restart;
+        power_off(po_restart);
         break;
     case CUDA_POWER_DOWN:
         LOG_F(INFO, "Cuda: system shutdown");
-        power_on = false;
-        power_off_reason = po_shut_down;
+        power_off(po_shut_down);
         break;
     case CUDA_SET_POWER_UPTIME: {
         uint32_t alarm_time = READ_DWORD_BE_U(&this->in_buf[2]);

main.cpp

@@ -52,8 +52,7 @@ using namespace std;
 extern bool g_auto_grab_mouse;
 
 static void sigint_handler(int signum) {
-    power_on = false;
-    power_off_reason = po_signal_interrupt;
+    power_off(po_signal_interrupt);
 }
 
 static void sigabrt_handler(int signum) {
@@ -297,7 +296,7 @@ int main(int argc, char** argv) {
         // Make sure the reason for the failure is visible (it may have been
         // sent to the logfile only).
         cerr << message.preamble << message.indentation << message.prefix << message.message << endl;
-        power_off_reason = po_enter_debugger;
+        set_power_off_reason(po_enter_debugger);
         DppcDebugger::get_instance()->enter_debugger();
 
         // Ensure that NVRAM and other state is persisted before we terminate.
@@ -416,15 +415,15 @@ void run_machine(std::string machine_str, char* rom_data,
 
     switch (execution_mode) {
     case interpreter:
-        power_off_reason = po_starting_up;
+        set_power_off_reason(po_starting_up);
         DppcDebugger::get_instance()->enter_debugger();
         break;
     case threaded_int:
-        power_off_reason = po_starting_up;
+        set_power_off_reason(po_starting_up);
         DppcDebugger::get_instance()->enter_debugger();
         break;
     case debugger:
-        power_off_reason = po_enter_debugger;
+        set_power_off_reason(po_enter_debugger);
         DppcDebugger::get_instance()->enter_debugger();
         break;
     default: