Merge pull request #9282 from lioncash/core-log5

Core: Convert logging over to fmt pt.5

Source/Core/Core/PowerPC/BreakPoints.cpp

@@ -265,10 +265,9 @@ bool TMemCheck::Action(Common::DebugInterface* debug_interface, u32 value, u32 a
   {
     if (log_on_hit)
     {
-      NOTICE_LOG(MEMMAP, "MBP %08x (%s) %s%zu %0*x at %08x (%s)", pc,
-                 debug_interface->GetDescription(pc).c_str(), write ? "Write" : "Read", size * 8,
-                 static_cast<int>(size * 2), value, addr,
-                 debug_interface->GetDescription(addr).c_str());
+      NOTICE_LOG_FMT(MEMMAP, "MBP {:08x} ({}) {}{} {:x} at {:08x} ({})", pc,
+                     debug_interface->GetDescription(pc), write ? "Write" : "Read", size * 8, value,
+                     addr, debug_interface->GetDescription(addr));
     }
     if (break_on_hit)
       return true;

Source/Core/Core/PowerPC/CachedInterpreter/CachedInterpreter.cpp

@@ -101,7 +101,7 @@ void CachedInterpreter::ExecuteOneBlock()
       break;
 
     default:
-      ERROR_LOG(POWERPC, "Unknown CachedInterpreter Instruction: %d", static_cast<int>(code->type));
+      ERROR_LOG_FMT(POWERPC, "Unknown CachedInterpreter Instruction: {}", code->type);
       break;
     }
   }
@@ -220,7 +220,7 @@ void CachedInterpreter::Jit(u32 address)
     NPC = nextPC;
     PowerPC::ppcState.Exceptions |= EXCEPTION_ISI;
     PowerPC::CheckExceptions();
-    WARN_LOG(POWERPC, "ISI exception at 0x%08x", nextPC);
+    WARN_LOG_FMT(POWERPC, "ISI exception at {:#010x}", nextPC);
     return;
   }
 

Source/Core/Core/PowerPC/GDBStub.cpp

@@ -57,6 +57,11 @@ static gdb_bp_t bp_r[GDB_MAX_BP];
 static gdb_bp_t bp_w[GDB_MAX_BP];
 static gdb_bp_t bp_a[GDB_MAX_BP];
 
+static const char* CommandBufferAsString()
+{
+  return reinterpret_cast<const char*>(cmd_bfr);
+}
+
 // private helpers
 static u8 hex2char(u8 hex)
 {
@@ -67,7 +72,7 @@ static u8 hex2char(u8 hex)
   else if (hex >= 'A' && hex <= 'F')
     return hex - 'A' + 0xa;
 
-  ERROR_LOG(GDB_STUB, "Invalid nibble: %c (%02x)", hex, hex);
+  ERROR_LOG_FMT(GDB_STUB, "Invalid nibble: {} ({:02x})", static_cast<char>(hex), hex);
   return 0;
 }
 
@@ -82,11 +87,9 @@ static u8 nibble2hex(u8 n)
 
 static void mem2hex(u8* dst, u8* src, u32 len)
 {
-  u8 tmp;
-
   while (len-- > 0)
   {
-    tmp = *src++;
+    const u8 tmp = *src++;
     *dst++ = nibble2hex(tmp >> 4);
     *dst++ = nibble2hex(tmp);
   }
@@ -103,13 +106,12 @@ static void hex2mem(u8* dst, u8* src, u32 len)
 
 static u8 gdb_read_byte()
 {
-  ssize_t res;
   u8 c = '+';
 
-  res = recv(sock, &c, 1, MSG_WAITALL);
+  const ssize_t res = recv(sock, &c, 1, MSG_WAITALL);
   if (res != 1)
   {
-    ERROR_LOG(GDB_STUB, "recv failed : %ld", res);
+    ERROR_LOG_FMT(GDB_STUB, "recv failed : {}", res);
     gdb_deinit();
   }
 
@@ -190,7 +192,7 @@ static void gdb_bp_remove(u32 type, u32 addr, u32 len)
     p = gdb_bp_find(type, addr, len);
     if (p != nullptr)
     {
-      DEBUG_LOG(GDB_STUB, "gdb: removed a breakpoint: %08x bytes at %08x", len, addr);
+      DEBUG_LOG_FMT(GDB_STUB, "gdb: removed a breakpoint: {:08x} bytes at {:08x}", len, addr);
       p->active = 0;
       memset(p, 0, sizeof(gdb_bp_t));
     }
@@ -218,32 +220,27 @@ static int gdb_bp_check(u32 addr, u32 type)
 static void gdb_nak()
 {
   const char nak = GDB_STUB_NAK;
-  ssize_t res;
+  const ssize_t res = send(sock, &nak, 1, 0);
 
-  res = send(sock, &nak, 1, 0);
   if (res != 1)
-    ERROR_LOG(GDB_STUB, "send failed");
+    ERROR_LOG_FMT(GDB_STUB, "send failed");
 }
 
 static void gdb_ack()
 {
   const char ack = GDB_STUB_ACK;
-  ssize_t res;
+  const ssize_t res = send(sock, &ack, 1, 0);
 
-  res = send(sock, &ack, 1, 0);
   if (res != 1)
-    ERROR_LOG(GDB_STUB, "send failed");
+    ERROR_LOG_FMT(GDB_STUB, "send failed");
 }
 
 static void gdb_read_command()
 {
-  u8 c;
-  u8 chk_read, chk_calc;
-
   cmd_len = 0;
   memset(cmd_bfr, 0, sizeof cmd_bfr);
 
-  c = gdb_read_byte();
+  const u8 c = gdb_read_byte();
   if (c == '+')
   {
     // ignore ack
@@ -257,7 +254,7 @@ static void gdb_read_command()
   }
   else if (c != GDB_STUB_START)
   {
-    DEBUG_LOG(GDB_STUB, "gdb: read invalid byte %02x", c);
+    DEBUG_LOG_FMT(GDB_STUB, "gdb: read invalid byte {:02x}", c);
     return;
   }
 
@@ -266,29 +263,30 @@ static void gdb_read_command()
     cmd_bfr[cmd_len++] = c;
     if (cmd_len == sizeof cmd_bfr)
     {
-      ERROR_LOG(GDB_STUB, "gdb: cmd_bfr overflow");
+      ERROR_LOG_FMT(GDB_STUB, "gdb: cmd_bfr overflow");
       gdb_nak();
       return;
     }
   }
 
-  chk_read = hex2char(gdb_read_byte()) << 4;
+  u8 chk_read = hex2char(gdb_read_byte()) << 4;
   chk_read |= hex2char(gdb_read_byte());
 
-  chk_calc = gdb_calc_chksum();
+  const u8 chk_calc = gdb_calc_chksum();
 
   if (chk_calc != chk_read)
   {
-    ERROR_LOG(GDB_STUB,
-              "gdb: invalid checksum: calculated %02x and read %02x for $%s# (length: %d)",
-              chk_calc, chk_read, cmd_bfr, cmd_len);
+    ERROR_LOG_FMT(GDB_STUB,
+                  "gdb: invalid checksum: calculated {:02x} and read {:02x} for ${}# (length: {})",
+                  chk_calc, chk_read, CommandBufferAsString(), cmd_len);
     cmd_len = 0;
 
     gdb_nak();
     return;
   }
 
-  DEBUG_LOG(GDB_STUB, "gdb: read command %c with a length of %d: %s", cmd_bfr[0], cmd_len, cmd_bfr);
+  DEBUG_LOG_FMT(GDB_STUB, "gdb: read command {} with a length of {}: {}",
+                static_cast<char>(cmd_bfr[0]), cmd_len, CommandBufferAsString());
   gdb_ack();
 }
 
@@ -305,7 +303,7 @@ static int gdb_data_available()
 
   if (select(sock + 1, fds, nullptr, nullptr, &t) < 0)
   {
-    ERROR_LOG(GDB_STUB, "select failed");
+    ERROR_LOG_FMT(GDB_STUB, "select failed");
     return 0;
   }
 
@@ -316,40 +314,35 @@ static int gdb_data_available()
 
 static void gdb_reply(const char* reply)
 {
-  u8 chk;
-  u32 left;
-  u8* ptr;
-  int n;
-
   if (!gdb_active())
     return;
 
   memset(cmd_bfr, 0, sizeof cmd_bfr);
 
   cmd_len = strlen(reply);
   if (cmd_len + 4 > sizeof cmd_bfr)
-    ERROR_LOG(GDB_STUB, "cmd_bfr overflow in gdb_reply");
+    ERROR_LOG_FMT(GDB_STUB, "cmd_bfr overflow in gdb_reply");
 
   memcpy(cmd_bfr + 1, reply, cmd_len);
 
   cmd_len++;
-  chk = gdb_calc_chksum();
+  const u8 chk = gdb_calc_chksum();
   cmd_len--;
   cmd_bfr[0] = GDB_STUB_START;
   cmd_bfr[cmd_len + 1] = GDB_STUB_END;
   cmd_bfr[cmd_len + 2] = nibble2hex(chk >> 4);
   cmd_bfr[cmd_len + 3] = nibble2hex(chk);
 
-  DEBUG_LOG(GDB_STUB, "gdb: reply (len: %d): %s", cmd_len, cmd_bfr);
+  DEBUG_LOG_FMT(GDB_STUB, "gdb: reply (len: {}): {}", cmd_len, CommandBufferAsString());
 
-  ptr = cmd_bfr;
-  left = cmd_len + 4;
+  u8* ptr = cmd_bfr;
+  u32 left = cmd_len + 4;
   while (left > 0)
   {
-    n = send(sock, ptr, left, 0);
+    const int n = send(sock, ptr, left, 0);
     if (n < 0)
     {
-      ERROR_LOG(GDB_STUB, "gdb: send failed");
+      ERROR_LOG_FMT(GDB_STUB, "gdb: send failed");
       return gdb_deinit();
     }
     left -= n;
@@ -359,7 +352,7 @@ static void gdb_reply(const char* reply)
 
 static void gdb_handle_query()
 {
-  DEBUG_LOG(GDB_STUB, "gdb: query '%s'", cmd_bfr + 1);
+  DEBUG_LOG_FMT(GDB_STUB, "gdb: query '{}'", CommandBufferAsString() + 1);
 
   if (!strcmp((const char*)(cmd_bfr + 1), "TStatus"))
   {
@@ -574,7 +567,7 @@ static void gdb_read_mem()
   len = 0;
   while (i < cmd_len)
     len = (len << 4) | hex2char(cmd_bfr[i++]);
-  DEBUG_LOG(GDB_STUB, "gdb: read memory: %08x bytes from %08x", len, addr);
+  DEBUG_LOG_FMT(GDB_STUB, "gdb: read memory: {:08x} bytes from {:08x}", len, addr);
 
   if (len * 2 > sizeof reply)
     gdb_reply("E01");
@@ -600,7 +593,7 @@ static void gdb_write_mem()
   len = 0;
   while (cmd_bfr[i] != ':')
     len = (len << 4) | hex2char(cmd_bfr[i++]);
-  DEBUG_LOG(GDB_STUB, "gdb: write memory: %08x bytes to %08x", len, addr);
+  DEBUG_LOG_FMT(GDB_STUB, "gdb: write memory: {:08x} bytes to {:08x}", len, addr);
 
   u8* dst = Memory::GetPointer(addr);
   if (!dst)
@@ -637,7 +630,8 @@ bool gdb_add_bp(u32 type, u32 addr, u32 len)
   bp->addr = addr;
   bp->len = len;
 
-  DEBUG_LOG(GDB_STUB, "gdb: added %d breakpoint: %08x bytes at %08x", type, bp->len, bp->addr);
+  DEBUG_LOG_FMT(GDB_STUB, "gdb: added {} breakpoint: {:08x} bytes at {:08x}", type, bp->len,
+                bp->addr);
   return true;
 }
 
@@ -825,7 +819,6 @@ void gdb_init(u32 port)
 static void gdb_init_generic(int domain, const sockaddr* server_addr, socklen_t server_addrlen,
                              sockaddr* client_addr, socklen_t* client_addrlen)
 {
-  int on;
 #ifdef _WIN32
   WSAStartup(MAKEWORD(2, 2), &InitData);
 #endif
@@ -837,24 +830,24 @@ static void gdb_init_generic(int domain, const sockaddr* server_addr, socklen_t
 
   tmpsock = socket(domain, SOCK_STREAM, 0);
   if (tmpsock == -1)
-    ERROR_LOG(GDB_STUB, "Failed to create gdb socket");
+    ERROR_LOG_FMT(GDB_STUB, "Failed to create gdb socket");
 
-  on = 1;
+  int on = 1;
   if (setsockopt(tmpsock, SOL_SOCKET, SO_REUSEADDR, &on, sizeof on) < 0)
-    ERROR_LOG(GDB_STUB, "Failed to setsockopt");
+    ERROR_LOG_FMT(GDB_STUB, "Failed to setsockopt");
 
   if (bind(tmpsock, server_addr, server_addrlen) < 0)
-    ERROR_LOG(GDB_STUB, "Failed to bind gdb socket");
+    ERROR_LOG_FMT(GDB_STUB, "Failed to bind gdb socket");
 
   if (listen(tmpsock, 1) < 0)
-    ERROR_LOG(GDB_STUB, "Failed to listen to gdb socket");
+    ERROR_LOG_FMT(GDB_STUB, "Failed to listen to gdb socket");
 
-  INFO_LOG(GDB_STUB, "Waiting for gdb to connect...");
+  INFO_LOG_FMT(GDB_STUB, "Waiting for gdb to connect...");
 
   sock = accept(tmpsock, client_addr, client_addrlen);
   if (sock < 0)
-    ERROR_LOG(GDB_STUB, "Failed to accept gdb client");
-  INFO_LOG(GDB_STUB, "Client connected.");
+    ERROR_LOG_FMT(GDB_STUB, "Failed to accept gdb client");
+  INFO_LOG_FMT(GDB_STUB, "Client connected.");
 
   close(tmpsock);
   tmpsock = -1;
@@ -908,7 +901,7 @@ int gdb_bp_x(u32 addr)
   {
     step_break = 0;
 
-    DEBUG_LOG(GDB_STUB, "Step was successful.");
+    DEBUG_LOG_FMT(GDB_STUB, "Step was successful.");
     return 1;
   }
 

Source/Core/Core/PowerPC/Interpreter/Interpreter.cpp

@@ -132,11 +132,11 @@ static void Trace(UGeckoInstruction& inst)
   }
 
   const std::string ppc_inst = Common::GekkoDisassembler::Disassemble(inst.hex, PC);
-  DEBUG_LOG(POWERPC,
-            "INTER PC: %08x SRR0: %08x SRR1: %08x CRval: %016" PRIx64 " FPSCR: %08x MSR: %08x LR: "
-            "%08x %s %08x %s",
-            PC, SRR0, SRR1, PowerPC::ppcState.cr.fields[0], FPSCR.Hex, MSR.Hex,
-            PowerPC::ppcState.spr[8], regs.c_str(), inst.hex, ppc_inst.c_str());
+  DEBUG_LOG_FMT(POWERPC,
+                "INTER PC: {:08x} SRR0: {:08x} SRR1: {:08x} CRval: {:016x} "
+                "FPSCR: {:08x} MSR: {:08x} LR: {:08x} {} {:08x} {}",
+                PC, SRR0, SRR1, PowerPC::ppcState.cr.fields[0], FPSCR.Hex, MSR.Hex,
+                PowerPC::ppcState.spr[8], regs, inst.hex, ppc_inst);
 }
 
 bool Interpreter::HandleFunctionHooking(u32 address)
@@ -285,25 +285,25 @@ void Interpreter::Run()
           if (PowerPC::breakpoints.IsAddressBreakPoint(PC))
           {
 #ifdef SHOW_HISTORY
-            NOTICE_LOG(POWERPC, "----------------------------");
-            NOTICE_LOG(POWERPC, "Blocks:");
-            for (int j = 0; j < PCBlockVec.size(); j++)
-              NOTICE_LOG(POWERPC, "PC: 0x%08x", PCBlockVec.at(j));
-            NOTICE_LOG(POWERPC, "----------------------------");
-            NOTICE_LOG(POWERPC, "Steps:");
-            for (int j = 0; j < PCVec.size(); j++)
+            NOTICE_LOG_FMT(POWERPC, "----------------------------");
+            NOTICE_LOG_FMT(POWERPC, "Blocks:");
+            for (const int entry : PCBlockVec)
+              NOTICE_LOG_FMT(POWERPC, "PC: {:#010x}", entry);
+            NOTICE_LOG_FMT(POWERPC, "----------------------------");
+            NOTICE_LOG_FMT(POWERPC, "Steps:");
+            for (size_t j = 0; j < PCVec.size(); j++)
             {
               // Write space
               if (j > 0)
               {
-                if (PCVec.at(j) != PCVec.at(j - 1) + 4)
-                  NOTICE_LOG(POWERPC, "");
+                if (PCVec[j] != PCVec[(j - 1) + 4]
+                  NOTICE_LOG_FMT(POWERPC, "");
               }
 
-              NOTICE_LOG(POWERPC, "PC: 0x%08x", PCVec.at(j));
+              NOTICE_LOG_FMT(POWERPC, "PC: {:#010x}", PCVec[j]);
             }
 #endif
-            INFO_LOG(POWERPC, "Hit Breakpoint - %08x", PC);
+            INFO_LOG_FMT(POWERPC, "Hit Breakpoint - {:08x}", PC);
             CPU::Break();
             if (PowerPC::breakpoints.IsTempBreakPoint(PC))
               PowerPC::breakpoints.Remove(PC);
@@ -338,15 +338,16 @@ void Interpreter::unknown_instruction(UGeckoInstruction inst)
 {
   const u32 opcode = PowerPC::HostRead_U32(last_pc);
   const std::string disasm = Common::GekkoDisassembler::Disassemble(opcode, last_pc);
-  NOTICE_LOG(POWERPC, "Last PC = %08x : %s", last_pc, disasm.c_str());
+  NOTICE_LOG_FMT(POWERPC, "Last PC = {:08x} : {}", last_pc, disasm);
   Dolphin_Debugger::PrintCallstack();
-  NOTICE_LOG(POWERPC,
-             "\nIntCPU: Unknown instruction %08x at PC = %08x  last_PC = %08x  LR = %08x\n",
-             inst.hex, PC, last_pc, LR);
+  NOTICE_LOG_FMT(
+      POWERPC,
+      "\nIntCPU: Unknown instruction {:08x} at PC = {:08x}  last_PC = {:08x}  LR = {:08x}\n",
+      inst.hex, PC, last_pc, LR);
   for (int i = 0; i < 32; i += 4)
   {
-    NOTICE_LOG(POWERPC, "r%d: 0x%08x r%d: 0x%08x r%d:0x%08x r%d: 0x%08x", i, rGPR[i], i + 1,
-               rGPR[i + 1], i + 2, rGPR[i + 2], i + 3, rGPR[i + 3]);
+    NOTICE_LOG_FMT(POWERPC, "r{}: {:#010x} r{}: {:#010x} r{}: {:#010x} r{}: {:#010x}", i, rGPR[i],
+                   i + 1, rGPR[i + 1], i + 2, rGPR[i + 2], i + 3, rGPR[i + 3]);
   }
   ASSERT_MSG(POWERPC, 0,
              "\nIntCPU: Unknown instruction %08x at PC = %08x  last_PC = %08x  LR = %08x\n",