Added [BOX64] prefix for all the stdout logs (#2279)

* Added [BOX64] prefix for all the stdout logs

* Remove some hardcoded prefix

* review

25 files changed, 208 insertions, 193 deletions

diff --git a/src/core.c b/src/core.c
index 02c2dc50..08343c66 100644
--- a/src/core.c
+++ b/src/core.c
@@ -184,7 +184,7 @@ void openFTrace(const char* newtrace, int reopen)
     }
 }
 
-void printf_ftrace(const char* fmt, ...)
+void printf_ftrace(int prefix, const char* fmt, ...)
 {
     if(ftrace_name) {
         int fd = fileno(ftrace);
@@ -196,6 +196,9 @@ void printf_ftrace(const char* fmt, ...)
 
     va_list args;
     va_start(args, fmt);
+    if (prefix && ftrace == stdout) {
+        fprintf(ftrace, box64_is32bits ? "[BOX32] " : "[BOX64] ");
+    }
     vfprintf(ftrace, fmt, args);
 
     fflush(ftrace);
@@ -286,30 +289,30 @@ void GatherDynarecExtensions()
     #endif
     printf_log(LOG_INFO, "Dynarec for ARM64, with extension: ASIMD");
     if(arm64_aes)
-        printf_log(LOG_INFO, " AES");
+        printf_log_prefix(0, LOG_INFO, " AES");
     if(arm64_crc32)
-        printf_log(LOG_INFO, " CRC32");
+        printf_log_prefix(0, LOG_INFO, " CRC32");
     if(arm64_pmull)
-        printf_log(LOG_INFO, " PMULL");
+        printf_log_prefix(0, LOG_INFO, " PMULL");
     if(arm64_atomics)
-        printf_log(LOG_INFO, " ATOMICS");
+        printf_log_prefix(0, LOG_INFO, " ATOMICS");
     if(arm64_sha1)
-        printf_log(LOG_INFO, " SHA1");
+        printf_log_prefix(0, LOG_INFO, " SHA1");
     if(arm64_sha2)
-        printf_log(LOG_INFO, " SHA2");
+        printf_log_prefix(0, LOG_INFO, " SHA2");
     if(arm64_uscat)
-        printf_log(LOG_INFO, " USCAT");
+        printf_log_prefix(0, LOG_INFO, " USCAT");
     if(arm64_flagm)
-        printf_log(LOG_INFO, " FLAGM");
+        printf_log_prefix(0, LOG_INFO, " FLAGM");
     if(arm64_flagm2)
-        printf_log(LOG_INFO, " FLAGM2");
+        printf_log_prefix(0, LOG_INFO, " FLAGM2");
     if(arm64_frintts)
-        printf_log(LOG_INFO, " FRINT");
+        printf_log_prefix(0, LOG_INFO, " FRINT");
     if(arm64_afp)
-        printf_log(LOG_INFO, " AFP");
+        printf_log_prefix(0, LOG_INFO, " AFP");
     if(arm64_rndr)
-        printf_log(LOG_INFO, " RNDR");
-    printf_log(LOG_INFO, "\n");
+        printf_log_prefix(0, LOG_INFO, " RNDR");
+    printf_log_prefix(0, LOG_INFO, "\n");
 #elif defined(LA64)
     printf_log(LOG_INFO, "Dynarec for LoongArch ");
     char* p = getenv("BOX64_DYNAREC_LA64NOEXT");
@@ -317,7 +320,7 @@ void GatherDynarecExtensions()
         uint32_t cpucfg2 = 0, idx = 2;
         asm volatile("cpucfg %0, %1" : "=r"(cpucfg2) : "r"(idx));
         if (((cpucfg2 >> 6) & 0b11) == 3) {
-            printf_log(LOG_INFO, "with extension LSX LASX");
+            printf_log_prefix(0, LOG_INFO, "with extension LSX LASX");
         } else {
             printf_log(LOG_INFO, "\nMissing LSX and/or LASX extension support, disabling Dynarec\n");
             SET_BOX64ENV(dynarec, 0);
@@ -325,15 +328,15 @@ void GatherDynarecExtensions()
         }
 
         if (la64_lbt = ((cpucfg2 >> 18) & 0b1))
-            printf_log(LOG_INFO, " LBT_X86");
+            printf_log_prefix(0, LOG_INFO, " LBT_X86");
         if ((la64_lam_bh = (cpucfg2 >> 27) & 0b1))
-            printf_log(LOG_INFO, " LAM_BH");
+            printf_log_prefix(0, LOG_INFO, " LAM_BH");
         if ((la64_lamcas = (cpucfg2 >> 28) & 0b1))
-            printf_log(LOG_INFO, " LAMCAS");
+            printf_log_prefix(0, LOG_INFO, " LAMCAS");
         if ((la64_scq = (cpucfg2 >> 30) & 0b1))
-            printf_log(LOG_INFO, " SCQ");
+            printf_log_prefix(0, LOG_INFO, " SCQ");
     }
-    printf_log(LOG_INFO, "\n");
+    printf_log_prefix(0, LOG_INFO, "\n");
 #elif defined(RV64)
     void RV64_Detect_Function();
     // private env. variable for the developer ;)
@@ -366,24 +369,24 @@ void GatherDynarecExtensions()
     }
 
     printf_log(LOG_INFO, "Dynarec for rv64g");
-    if (rv64_vector && !rv64_xtheadvector) printf_log(LOG_INFO, "v");
-    if (rv64_zba) printf_log(LOG_INFO, "_zba");
-    if (rv64_zbb) printf_log(LOG_INFO, "_zbb");
-    if (rv64_zbc) printf_log(LOG_INFO, "_zbc");
-    if (rv64_zbs) printf_log(LOG_INFO, "_zbs");
-    if (rv64_vector && !rv64_xtheadvector) printf_log(LOG_INFO, "_zvl%d", rv64_vlen);
-    if (rv64_xtheadba) printf_log(LOG_INFO, "_xtheadba");
-    if (rv64_xtheadbb) printf_log(LOG_INFO, "_xtheadbb");
-    if (rv64_xtheadbs) printf_log(LOG_INFO, "_xtheadbs");
-    if (rv64_xtheadmempair) printf_log(LOG_INFO, "_xtheadmempair");
-    if (rv64_xtheadcondmov) printf_log(LOG_INFO, "_xtheadcondmov");
-    if (rv64_xtheadmemidx) printf_log(LOG_INFO, "_xtheadmemidx");
+    if (rv64_vector && !rv64_xtheadvector) printf_log_prefix(0, LOG_INFO, "v");
+    if (rv64_zba) printf_log_prefix(0, LOG_INFO, "_zba");
+    if (rv64_zbb) printf_log_prefix(0, LOG_INFO, "_zbb");
+    if (rv64_zbc) printf_log_prefix(0, LOG_INFO, "_zbc");
+    if (rv64_zbs) printf_log_prefix(0, LOG_INFO, "_zbs");
+    if (rv64_vector && !rv64_xtheadvector) printf_log_prefix(0, LOG_INFO, "_zvl%d", rv64_vlen);
+    if (rv64_xtheadba) printf_log_prefix(0, LOG_INFO, "_xtheadba");
+    if (rv64_xtheadbb) printf_log_prefix(0, LOG_INFO, "_xtheadbb");
+    if (rv64_xtheadbs) printf_log_prefix(0, LOG_INFO, "_xtheadbs");
+    if (rv64_xtheadmempair) printf_log_prefix(0, LOG_INFO, "_xtheadmempair");
+    if (rv64_xtheadcondmov) printf_log_prefix(0, LOG_INFO, "_xtheadcondmov");
+    if (rv64_xtheadmemidx) printf_log_prefix(0, LOG_INFO, "_xtheadmemidx");
     // Disable the display since these are only detected but never used.
-    // if(rv64_xtheadfmemidx) printf_log(LOG_INFO, " xtheadfmemidx");
-    // if(rv64_xtheadmac) printf_log(LOG_INFO, " xtheadmac");
-    // if(rv64_xtheadfmv) printf_log(LOG_INFO, " xtheadfmv");
-    if (rv64_xtheadvector) printf_log(LOG_INFO, "_xthvector");
-    printf_log(LOG_INFO, "\n");
+    // if(rv64_xtheadfmemidx) printf_log_prefix(0, LOG_INFO, " xtheadfmemidx");
+    // if(rv64_xtheadmac) printf_log_prefix(0, LOG_INFO, " xtheadmac");
+    // if(rv64_xtheadfmv) printf_log_prefix(0, LOG_INFO, " xtheadfmv");
+    if (rv64_xtheadvector) printf_log_prefix(0, LOG_INFO, "_xthvector");
+    printf_log_prefix(0, LOG_INFO, "\n");
 #else
 #error Unsupported architecture
 #endif
@@ -416,18 +419,18 @@ void computeRDTSC()
     printf_log(LOG_INFO, "Will use %s counter measured at ", box64_rdtsc?"software":"hardware");
     int ghz = freq>=1000000000LL;
     if(ghz) freq/=100000000LL; else freq/=100000;
-    if(ghz) printf_log(LOG_INFO, "%d.%d GHz", freq/10, freq%10);
-    if(!ghz && (freq>=1000)) printf_log(LOG_INFO, "%d MHz", freq/10);
-    if(!ghz && (freq<1000)) printf_log(LOG_INFO, "%d.%d MHz", freq/10, freq%10);
+    if (ghz) printf_log_prefix(0, LOG_INFO, "%d.%d GHz", freq / 10, freq % 10);
+    if (!ghz && (freq >= 1000)) printf_log_prefix(0, LOG_INFO, "%d MHz", freq / 10);
+    if (!ghz && (freq < 1000)) printf_log_prefix(0, LOG_INFO, "%d.%d MHz", freq / 10, freq % 10);
     if(box64_rdtsc_shift) {
-        printf_log(LOG_INFO, " emulating ");
+        printf_log_prefix(0, LOG_INFO, " emulating ");
         ghz = efreq>=1000000000LL;
         if(ghz) efreq/=100000000LL; else efreq/=100000;
-        if(ghz) printf_log(LOG_INFO, "%d.%d GHz", efreq/10, efreq%10);
-        if(!ghz && (efreq>=1000)) printf_log(LOG_INFO, "%d MHz", efreq/10);
-        if(!ghz && (efreq<1000)) printf_log(LOG_INFO, "%d.%d MHz", efreq/10, efreq%10);
+        if (ghz) printf_log_prefix(0, LOG_INFO, "%d.%d GHz", efreq / 10, efreq % 10);
+        if (!ghz && (efreq >= 1000)) printf_log_prefix(0, LOG_INFO, "%d MHz", efreq / 10);
+        if (!ghz && (efreq < 1000)) printf_log_prefix(0, LOG_INFO, "%d.%d MHz", efreq / 10, efreq % 10);
     }
-    printf_log(LOG_INFO, "\n");
+    printf_log_prefix(0, LOG_INFO, "\n");
 }
 
 static void displayMiscInfo()
@@ -478,7 +481,8 @@ void PrintCollection(path_collection_t* col, const char* env)
     if (LOG_INFO<=BOX64ENV(log)) {
         printf_log(LOG_INFO, "%s: ", env);
         for(int i=0; i<col->size; i++)
-            printf_log(LOG_INFO, "%s%s", col->paths[i], (i==col->size-1)?"\n":":");
+            printf_log_prefix(0, LOG_INFO, "%s%s", col->paths[i], (i==col->size-1)?"":":");
+        printf_log_prefix(0, LOG_INFO, "\n");
     }
 }
 
@@ -523,7 +527,7 @@ int GatherEnv(char*** dest, char** env, char* prog)
 void AddNewLibs(const char* list)
 {
     AppendList(&box64_addlibs, list, 0);
-    printf_log(LOG_INFO, "BOX64: Adding %s to the libs\n", list);
+    printf_log(LOG_INFO, "Adding %s to the libs\n", list);
 }
 
 void PrintHelp() {
@@ -559,8 +563,8 @@ static void addLibPaths(box64context_t* context)
         if (my_context->box64_emulated_libs.size && BOX64ENV(log)) {
             printf_log(LOG_INFO, "BOX64 will force the used of emulated libs for ");
             for (int i=0; i<context->box64_emulated_libs.size; ++i)
-                printf_log(LOG_INFO, "%s ", context->box64_emulated_libs.paths[i]);
-            printf_log(LOG_INFO, "\n");
+                printf_log_prefix(0, LOG_INFO, "%s ", context->box64_emulated_libs.paths[i]);
+            printf_log_prefix(0, LOG_INFO, "\n");
         }
     }
 
@@ -875,7 +879,7 @@ int initialize(int argc, const char **argv, char** env, x64emu_t** emulator, elf
         /*PrintBox64Version();
         PrintHelp();
         return 1;*/
-        printf("BOX64: Missing operand after 'box64'\n");
+        printf("[BOX64] Missing operand after 'box64'\n");
         printf("See 'box64 --help' for more information.\n");
         exit(0);
     }
@@ -929,7 +933,7 @@ int initialize(int argc, const char **argv, char** env, x64emu_t** emulator, elf
         prog = argv[++nextarg];
     }
     if(!prog || nextarg==argc) {
-        printf("BOX64: Nothing to run\n");
+        printf("[BOX64] Nothing to run\n");
         exit(0);
     }
     if (!BOX64ENV(nobanner)) PrintBox64Version();
@@ -946,7 +950,7 @@ int initialize(int argc, const char **argv, char** env, x64emu_t** emulator, elf
         #endif
         if(x64 || x86) {
             prog = argv[++nextarg];
-            printf_log(LOG_INFO, "BOX64: Wine preloader detected, loading \"%s\" directly\n", prog);
+            printf_log(LOG_INFO, "Wine preloader detected, loading \"%s\" directly\n", prog);
             wine_preloaded = 1;
             prog_ = strrchr(prog, '/');
             if(!prog_) prog_ = prog; else ++prog_;
@@ -955,7 +959,7 @@ int initialize(int argc, const char **argv, char** env, x64emu_t** emulator, elf
     #ifndef STATICBUILD
     // pre-check for pressure-vessel-wrap
     if(!strcmp(prog_, "pressure-vessel-wrap")) {
-        printf_log(LOG_INFO, "BOX64: pressure-vessel-wrap detected\n");
+        printf_log(LOG_INFO, "pressure-vessel-wrap detected\n");
         pressure_vessel(argc, argv, nextarg+1, prog);
     }
     #endif
@@ -967,7 +971,7 @@ int initialize(int argc, const char **argv, char** env, x64emu_t** emulator, elf
      || !strcmp(prog_, "wine64-development")
      || !strcmp(prog_, "wine")) {
         const char* prereserve = getenv("WINEPRELOADRESERVE");
-        printf_log(LOG_INFO, "BOX64: Wine64 detected, WINEPRELOADRESERVE=\"%s\"\n", prereserve?prereserve:"");
+        printf_log(LOG_INFO, "Wine64 detected, WINEPRELOADRESERVE=\"%s\"\n", prereserve?prereserve:"");
         if(wine_preloaded || 1) {
             wine_prereserve(prereserve);
         }
@@ -1007,10 +1011,10 @@ int initialize(int argc, const char **argv, char** env, x64emu_t** emulator, elf
                     wine_prog = argv[nextarg+1];
             }
         }
-        if(wine_prog) printf_log(LOG_INFO, "BOX64: Detected running wine with \"%s\"\n", wine_prog);
+        if(wine_prog) printf_log(LOG_INFO, "Detected running wine with \"%s\"\n", wine_prog);
     } else if(strstr(prog, "ld-musl-x86_64.so.1")) {
     // check if ld-musl-x86_64.so.1 is used
-        printf_log(LOG_INFO, "BOX64: ld-musl detected. Trying to workaround and use system ld-linux\n");
+        printf_log(LOG_INFO, "ld-musl detected. Trying to workaround and use system ld-linux\n");
         box64_musl = 1;
         // skip ld-musl and go through args unti "--" is found, handling "--library-path" to add some libs to BOX64_LD_LIBRARY
         ++nextarg;
@@ -1058,8 +1062,8 @@ int initialize(int argc, const char **argv, char** env, x64emu_t** emulator, elf
         if (ld_preload.size && BOX64ENV(log)) {
             printf_log(LOG_INFO, "BOX64 trying to Preload ");
             for (int i=0; i<ld_preload.size; ++i)
-                printf_log(LOG_INFO, "%s ", ld_preload.paths[i]);
-            printf_log(LOG_INFO, "\n");
+                printf_log_prefix(0, LOG_INFO, "%s ", ld_preload.paths[i]);
+            printf_log_prefix(0, LOG_INFO, "\n");
         }
     }
     if(getenv("LD_PRELOAD")) {
@@ -1076,8 +1080,8 @@ int initialize(int argc, const char **argv, char** env, x64emu_t** emulator, elf
         if (ld_preload.size && BOX64ENV(log)) {
             printf_log(LOG_INFO, "BOX64 trying to Preload ");
             for (int i=0; i<ld_preload.size; ++i)
-                printf_log(LOG_INFO, "%s ", ld_preload.paths[i]);
-            printf_log(LOG_INFO, "\n");
+                printf_log_prefix(0, LOG_INFO, "%s ", ld_preload.paths[i]);
+            printf_log_prefix(0, LOG_INFO, "\n");
         }
     }
     // print PATH and LD_LIB used
@@ -1253,7 +1257,7 @@ int initialize(int argc, const char **argv, char** env, x64emu_t** emulator, elf
     #ifdef BOX32
     box64_is32bits = FileIsX86ELF(my_context->fullpath);
     if(box64_is32bits) {
-        printf_log(LOG_INFO, "BOX64: Using Box32 to load 32bits elf\n");
+        printf_log(LOG_INFO, "Using Box32 to load 32bits elf\n");
         loadProtectionFromMap();
         reserveHighMem();
         init_pthread_helper_32();
@@ -1328,7 +1332,7 @@ int initialize(int argc, const char **argv, char** env, x64emu_t** emulator, elf
     if(ElfCheckIfUseTCMallocMinimal(elf_header)) {
         if(!box64_tcmalloc_minimal) {
             // need to reload with tcmalloc_minimal as a LD_PRELOAD!
-            printf_log(LOG_INFO, "BOX64: tcmalloc_minimal.so.4 used. Reloading box64 with the lib preladed\n");
+            printf_log(LOG_INFO, "tcmalloc_minimal.so.4 used. Reloading box64 with the lib preladed\n");
             // need to get a new envv variable. so first count it and check if LD_PRELOAD is there
             int preload=(getenv("LD_PRELOAD"))?1:0;
             int nenv = 0;
@@ -1368,7 +1372,7 @@ int initialize(int argc, const char **argv, char** env, x64emu_t** emulator, elf
             if(execve(newargv[0], newargv, newenv)<0)
                 printf_log(LOG_NONE, "Failed to relaunch. Error is %d/%s\n", errno, strerror(errno));
         } else {
-            printf_log(LOG_INFO, "BOX64: Using tcmalloc_minimal.so.4, and it's in the LD_PRELOAD command\n");
+            printf_log(LOG_INFO, "Using tcmalloc_minimal.so.4, and it's in the LD_PRELOAD command\n");
         }
     }
 #if defined(RPI) || defined(RK3399) || defined(RK3326)
diff --git a/src/custommem.c b/src/custommem.c
index cd2a743b..74203104 100644
--- a/src/custommem.c
+++ b/src/custommem.c
@@ -1045,11 +1045,11 @@ int isDBFromAddressRange(uintptr_t addr, size_t size)
     while (start_addr<end) {
         start_addr = getDBSize(start_addr, end-start_addr, &db);
         if(db) {
-            dynarec_log(LOG_DEBUG, "1\n");
+            dynarec_log_prefix(0, LOG_DEBUG, "1\n");
             return 1;
         }
     }
-    dynarec_log(LOG_DEBUG, "0\n");
+    dynarec_log_prefix(0, LOG_DEBUG, "0\n");
     return 0;
 }
 
@@ -1470,7 +1470,7 @@ int isprotectedDB(uintptr_t addr, size_t size)
         uint32_t prot;
         uintptr_t bend;
         if (!rb_get_end(memprot, addr, &prot, &bend) || !(prot&PROT_DYN)) {
-            dynarec_log(LOG_DEBUG, "0\n");
+            dynarec_log_prefix(0, LOG_DEBUG, "0\n");
             UNLOCK_PROT_READ();
             return 0;
         } else {
@@ -1478,7 +1478,7 @@ int isprotectedDB(uintptr_t addr, size_t size)
         }
     }
     UNLOCK_PROT_READ();
-    dynarec_log(LOG_DEBUG, "1\n");
+    dynarec_log_prefix(0, LOG_DEBUG, "1\n");
     return 1;
 }
 
@@ -1653,12 +1653,12 @@ void loadProtectionFromMap()
     if(!shown48bits) {
         shown48bits = 1;
         if(have48bits)
-            printf_log(LOG_INFO, "BOX64: Detected 48bits at least of address space\n");
+            printf_log(LOG_INFO, "Detected 48bits at least of address space\n");
         else
-            printf_log(LOG_INFO, "BOX64: Didn't detect 48bits of address space, considering it's 39bits\n");
+            printf_log(LOG_INFO, "Didn't detect 48bits of address space, considering it's 39bits\n");
     }
     if(!pbrk) {
-        printf_log(LOG_INFO, "BOX64: Warning, program break not found\n");
+        printf_log(LOG_INFO, "Warning, program break not found\n");
         if(cur_brk) pbrk = *cur_brk;    // approximate is better than nothing
     }
     fclose(f);
diff --git a/src/dynarec/arm64/dynarec_arm64_arch.c b/src/dynarec/arm64/dynarec_arm64_arch.c
index b2843dbd..a94d64cc 100644
--- a/src/dynarec/arm64/dynarec_arm64_arch.c
+++ b/src/dynarec/arm64/dynarec_arm64_arch.c
@@ -255,11 +255,11 @@ void adjust_arch(dynablock_t* db, x64emu_t* emu, ucontext_t* p, uintptr_t x64pc)
     int ninst = getX64AddressInst(db, x64pc);
     dynarec_log(LOG_INFO, "adjust_arch(...), db=%p, x64pc=%p, nints=%d", db, (void*)x64pc, ninst);
     if(ninst<0) {
-    dynarec_log(LOG_INFO, "\n");
+    dynarec_log_prefix(0, LOG_INFO, "\n");
         return;
     }
     if(ninst==0) {
-    dynarec_log(LOG_INFO, "\n");
+    dynarec_log_prefix(0, LOG_INFO, "\n");
         CHECK_FLAGS(emu);
         return;
     }
@@ -273,7 +273,7 @@ void adjust_arch(dynablock_t* db, x64emu_t* emu, ucontext_t* p, uintptr_t x64pc)
     while(i<ninst-1) {
         arch = next;
         i += 1+arch->seq;
-        dynarec_log(LOG_INFO, "[ seq=%d%s%s%s%s%s ] ", arch->seq, arch->flags?" Flags":"", arch->x87?" x87":"", arch->mmx?" MMX":"", arch->sse?" SSE":"", arch->ymm?" YMM":"");
+        dynarec_log_prefix(0, LOG_INFO, "[ seq=%d%s%s%s%s%s ] ", arch->seq, arch->flags?" Flags":"", arch->x87?" x87":"", arch->mmx?" MMX":"", arch->sse?" SSE":"", arch->ymm?" YMM":"");
         next = (arch_arch_t*)((uintptr_t)next + sizeof_arch(arch));
     }
     int sz = sizeof(arch_arch_t);
@@ -285,7 +285,7 @@ void adjust_arch(dynablock_t* db, x64emu_t* emu, ucontext_t* p, uintptr_t x64pc)
     SUPER()
     #undef GO
     if(flags) {
-        dynarec_log(LOG_INFO, " flags[%s-%s%s%s%s] ", flags->defered?"defered":"", flags->nf?"S":"", flags->vf?"O":"", flags->eq?"Z":"", flags->cf?(flags->inv_cf?"C(inv)":"C"):"");
+        dynarec_log_prefix(0, LOG_INFO, " flags[%s-%s%s%s%s] ", flags->defered?"defered":"", flags->nf?"S":"", flags->vf?"O":"", flags->eq?"Z":"", flags->cf?(flags->inv_cf?"C(inv)":"C"):"");
         if(flags->defered) {
             CHECK_FLAGS(emu);
             //return;
@@ -319,7 +319,7 @@ void adjust_arch(dynablock_t* db, x64emu_t* emu, ucontext_t* p, uintptr_t x64pc)
         }
     }
     if(sse) {
-        dynarec_log(LOG_INFO, " sse[%x (fpsimd=%p)] ", sse->sse, fpsimd);
+        dynarec_log_prefix(0, LOG_INFO, " sse[%x (fpsimd=%p)] ", sse->sse, fpsimd);
         for(int i=0; i<16; ++i)
             if(fpsimd && (sse->sse>>i)&1) {
                 int idx = 0;
@@ -332,7 +332,7 @@ void adjust_arch(dynablock_t* db, x64emu_t* emu, ucontext_t* p, uintptr_t x64pc)
             }
     }
     if(ymm) {
-        dynarec_log(LOG_INFO, " ymm[%x, pos=%x, 0=%x (fpsimd=%p)] ", ymm->ymm, ymm->ymm_pos, ymm->ymm0, fpsimd);
+        dynarec_log_prefix(0, LOG_INFO, " ymm[%x, pos=%x, 0=%x (fpsimd=%p)] ", ymm->ymm, ymm->ymm_pos, ymm->ymm0, fpsimd);
         for(int i=0; i<16; ++i) {
             if(fpsimd && (ymm->ymm>>i)&1) {
                 int idx = (ymm->ymm_pos>>(i*4))&0xf;
@@ -348,7 +348,7 @@ void adjust_arch(dynablock_t* db, x64emu_t* emu, ucontext_t* p, uintptr_t x64pc)
         }
     }
     if(mmx) {
-        dynarec_log(LOG_INFO, " mmx[%x (fpsimd=%p)] ", mmx->mmx, fpsimd);
+        dynarec_log_prefix(0, LOG_INFO, " mmx[%x (fpsimd=%p)] ", mmx->mmx, fpsimd);
         for(int i=0; i<8; ++i)
             if(fpsimd && (mmx->mmx>>i)&1) {
                 int idx = EMM0 + i;
@@ -356,7 +356,7 @@ void adjust_arch(dynablock_t* db, x64emu_t* emu, ucontext_t* p, uintptr_t x64pc)
             }
     }
     if(x87) {
-        dynarec_log(LOG_INFO, " x87[%x, pos=%x, type=%x (fpsimd=%p)] ", x87->x87, x87->x87_pos, x87->x87_type, fpsimd);
+        dynarec_log_prefix(0, LOG_INFO, " x87[%x, pos=%x, type=%x (fpsimd=%p)] ", x87->x87, x87->x87_pos, x87->x87_type, fpsimd);
         emu->top -= x87->delta;
         for(int i=0; i<8; ++i) {
             if(x87->x87&(1<<i)) {
@@ -376,7 +376,7 @@ void adjust_arch(dynablock_t* db, x64emu_t* emu, ucontext_t* p, uintptr_t x64pc)
             }
         }
     }
-    dynarec_log(LOG_INFO, "\n");
+    dynarec_log_prefix(0, LOG_INFO, "\n");
 }
 
 int arch_unaligned(dynablock_t* db, uintptr_t x64pc)
@@ -397,4 +397,4 @@ int arch_unaligned(dynablock_t* db, uintptr_t x64pc)
         next = (arch_arch_t*)((uintptr_t)next + sizeof_arch(arch));
     }
     return arch->unaligned;
-}
\ No newline at end of file
+}
diff --git a/src/dynarec/arm64/dynarec_arm64_functions.c b/src/dynarec/arm64/dynarec_arm64_functions.c
index 9d211a51..a83f9d3e 100644
--- a/src/dynarec/arm64/dynarec_arm64_functions.c
+++ b/src/dynarec/arm64/dynarec_arm64_functions.c
@@ -856,7 +856,7 @@ void inst_name_pass3(dynarec_native_t* dyn, int ninst, const char* name, rex_t r
 
 void print_opcode(dynarec_native_t* dyn, int ninst, uint32_t opcode)
 {
-    dynarec_log(LOG_NONE, "\t%08x\t%s\n", opcode, arm64_print(opcode, (uintptr_t)dyn->block));
+    dynarec_log_prefix(0, LOG_NONE, "\t%08x\t%s\n", opcode, arm64_print(opcode, (uintptr_t)dyn->block));
 }
 
 static void x87_reset(neoncache_t* n)
diff --git a/src/dynarec/arm64/dynarec_arm64_pass0.h b/src/dynarec/arm64/dynarec_arm64_pass0.h
index 3b049d79..9caa8faa 100644
--- a/src/dynarec/arm64/dynarec_arm64_pass0.h
+++ b/src/dynarec/arm64/dynarec_arm64_pass0.h
@@ -49,7 +49,7 @@
         PKip(10),PKip(11),PKip(12),     \
         PKip(13),PKip(14));             \
         printFunctionAddr(ip, " => ");  \
-        dynarec_log(LOG_NONE, "\n");    \
+        dynarec_log_prefix(0, LOG_NONE, "\n"); \
         }
 
 #define FEMIT(A)        dyn->insts[ninst].nat_flags_op = dyn->insts[ninst].x64.set_flags?NAT_FLAG_OP_TOUCH:NAT_FLAG_OP_UNUSABLE
diff --git a/src/dynarec/dynarec_native.c b/src/dynarec/dynarec_native.c
index b096b79f..d5453e7f 100644
--- a/src/dynarec/dynarec_native.c
+++ b/src/dynarec/dynarec_native.c
@@ -40,9 +40,9 @@ void printf_x64_instruction(zydis_dec_t* dec, instruction_x64_t* inst, const cha
         } else {
             dynarec_log(LOG_NONE, "%s%p: ", (BOX64ENV(dynarec_dump)>1)?"\e[01;33m":"", ip);
             for(int i=0; i<inst->size; ++i) {
-                dynarec_log(LOG_NONE, "%02X ", ip[i]);
+                dynarec_log_prefix(0, LOG_NONE, "%02X ", ip[i]);
             }
-            dynarec_log(LOG_NONE, " %s", name);
+            dynarec_log_prefix(0, LOG_NONE, " %s", name);
         }
         // print Call function name if possible
         if(ip[0]==0xE8 || ip[0]==0xE9) { // Call / Jmp
@@ -55,7 +55,7 @@ void printf_x64_instruction(zydis_dec_t* dec, instruction_x64_t* inst, const cha
             }
         }
         // end of line and colors
-        dynarec_log(LOG_NONE, "%s\n", (BOX64ENV(dynarec_dump)>1)?"\e[m":"");
+        dynarec_log_prefix(0, LOG_NONE, "%s\n", (BOX64ENV(dynarec_dump)>1)?"\e[m":"");
     }
 }
 
@@ -845,7 +845,7 @@ void* FillBlock64(dynablock_t* block, uintptr_t addr, int alternate, int is32bit
         return NULL;
     }
     if((oldnativesize!=helper.native_size) || (oldtable64size<helper.table64size)) {
-        printf_log(LOG_NONE, "BOX64: Warning, size difference in block between pass2 (%zu, %d) & pass3 (%zu, %d)!\n", oldnativesize+oldtable64size*8, oldsize, helper.native_size+helper.table64size*8, helper.size);
+        printf_log(LOG_NONE, "Warning, size difference in block between pass2 (%zu, %d) & pass3 (%zu, %d)!\n", oldnativesize+oldtable64size*8, oldsize, helper.native_size+helper.table64size*8, helper.size);
         uint8_t *dump = (uint8_t*)helper.start;
         printf_log(LOG_NONE, "Dump of %d x64 opcodes:\n", helper.size);
         for(int i=0; i<helper.size; ++i) {
@@ -866,7 +866,7 @@ void* FillBlock64(dynablock_t* block, uintptr_t addr, int alternate, int is32bit
     //dynaFree(helper.insts);
     helper.insts = NULL;
     if(insts_rsize/sizeof(instsize_t)<helper.insts_size) {
-        printf_log(LOG_NONE, "BOX64: Warning, insts_size difference in block between pass2 (%zu) and pass3 (%zu), allocated: %zu\n", oldinstsize, helper.insts_size, insts_rsize/sizeof(instsize_t));
+        printf_log(LOG_NONE, "Warning, insts_size difference in block between pass2 (%zu) and pass3 (%zu), allocated: %zu\n", oldinstsize, helper.insts_size, insts_rsize/sizeof(instsize_t));
     }
     if(!isprotectedDB(addr, end-addr)) {
         dynarec_log(LOG_DEBUG, "Warning, block unprotected while being processed %p:%ld, marking as need_test\n", block->x64_addr, block->x64_size);
diff --git a/src/dynarec/la64/dynarec_la64_functions.c b/src/dynarec/la64/dynarec_la64_functions.c
index 391eac80..44b01323 100644
--- a/src/dynarec/la64/dynarec_la64_functions.c
+++ b/src/dynarec/la64/dynarec_la64_functions.c
@@ -458,7 +458,7 @@ int la64_lock_cas_h_slow(void* addr, uint16_t ref, uint16_t val)
 
 void print_opcode(dynarec_native_t* dyn, int ninst, uint32_t opcode)
 {
-    dynarec_log(LOG_NONE, "\t%08x\t%s\n", opcode, la64_print(opcode, (uintptr_t)dyn->block));
+    dynarec_log_prefix(0, LOG_NONE, "\t%08x\t%s\n", opcode, la64_print(opcode, (uintptr_t)dyn->block));
 }
 
 static void sse_reset(lsxcache_t* lsx)
diff --git a/src/dynarec/la64/dynarec_la64_pass0.h b/src/dynarec/la64/dynarec_la64_pass0.h
index aa7ee34e..8c188226 100644
--- a/src/dynarec/la64/dynarec_la64_pass0.h
+++ b/src/dynarec/la64/dynarec_la64_pass0.h
@@ -64,5 +64,5 @@
             PKip(10), PKip(11), PKip(12),                                                                                                           \
             PKip(13), PKip(14));                                                                                                                    \
         printFunctionAddr(ip, " => ");                                                                                                              \
-        dynarec_log(LOG_NONE, "\n");                                                                                                                \
+        dynarec_log_prefix(0, LOG_NONE, "\n");                                                                                                                \
     }
diff --git a/src/dynarec/rv64/dynarec_rv64_functions.c b/src/dynarec/rv64/dynarec_rv64_functions.c
index 0b1943d6..05a9c855 100644
--- a/src/dynarec/rv64/dynarec_rv64_functions.c
+++ b/src/dynarec/rv64/dynarec_rv64_functions.c
@@ -779,7 +779,7 @@ void inst_name_pass3(dynarec_native_t* dyn, int ninst, const char* name, rex_t r
 
 void print_opcode(dynarec_native_t* dyn, int ninst, uint32_t opcode)
 {
-    dynarec_log(LOG_NONE, "\t%08x\t%s\n", opcode, rv64_print(opcode, (uintptr_t)dyn->block));
+    dynarec_log_prefix(0, LOG_NONE, "\t%08x\t%s\n", opcode, rv64_print(opcode, (uintptr_t)dyn->block));
 }
 
 void print_newinst(dynarec_native_t* dyn, int ninst)
diff --git a/src/dynarec/rv64/dynarec_rv64_pass0.h b/src/dynarec/rv64/dynarec_rv64_pass0.h
index 53630a89..badb5c70 100644
--- a/src/dynarec/rv64/dynarec_rv64_pass0.h
+++ b/src/dynarec/rv64/dynarec_rv64_pass0.h
@@ -83,7 +83,7 @@
             PKip(10), PKip(11), PKip(12),                                                                                                           \
             PKip(13), PKip(14));                                                                                                                    \
         printFunctionAddr(ip, " => ");                                                                                                              \
-        dynarec_log(LOG_NONE, "\n");                                                                                                                \
+        dynarec_log_prefix(0, LOG_NONE, "\n");                                                                                                                \
     }
 
 #define SET_ELEMENT_WIDTH(s1, sew, set)                    \
diff --git a/src/elfs/elfhash.c b/src/elfs/elfhash.c
index ebb81285..23431b0d 100644
--- a/src/elfs/elfhash.c
+++ b/src/elfs/elfhash.c
@@ -304,7 +304,7 @@ static void old_elf_hash_dump(elfheader_t* h)
     }
     printf_log(LOG_NONE,"Chains[%d] = ", nchains);
     for (uint32_t i = 0; i<nchains; ++i)
-        printf_log(LOG_NONE, "%d ", chains[i]);
+        printf_log_prefix(0, LOG_NONE, "%d ", chains[i]);
     printf_log(LOG_NONE, "\n------------\n");
 }
 
@@ -369,7 +369,7 @@ static void new_elf_hash_dump(elfheader_t* h)
     printf_log(LOG_NONE, "Buckets[%d] offset=%d = \n", nbuckets, symoffset);
     for(uint32_t i=0; i<nbuckets; ++i) {
         uint32_t symidx = buckets[i];
-        printf_log(LOG_NONE, "%d:", symidx);
+        printf_log_prefix(0, LOG_NONE, "%d:", symidx);
         while(symidx>=symoffset) {
             const char* name = h->DynStr + h->DynSym._64[symidx].st_name;
             const uint32_t hash = chains[symidx-symoffset];
@@ -377,7 +377,7 @@ static void new_elf_hash_dump(elfheader_t* h)
                 symidx=0;
             else
                 symidx++;
-            printf_log(LOG_NONE, " %s (%x) -> %d", name, hash, symidx);
+            printf_log_prefix(0, LOG_NONE, " %s (%x) -> %d", name, hash, symidx);
         }
         printf_log(LOG_NONE, "\n");
     }
diff --git a/src/elfs/elfhash32.c b/src/elfs/elfhash32.c
index 3773e59a..dcb231ae 100644
--- a/src/elfs/elfhash32.c
+++ b/src/elfs/elfhash32.c
@@ -112,7 +112,7 @@ static void old_elf_hash_dump(elfheader_t* h)
     }
     printf_log(LOG_NONE,"Chains[%d] = ", nchains);
     for (uint32_t i = 0; i<nchains; ++i)
-        printf_log(LOG_NONE, "%d ", chains[i]);
+        printf_log_prefix(0, LOG_NONE, "%d ", chains[i]);
     printf_log(LOG_NONE, "\n------------\n");
 }
 
diff --git a/src/elfs/elfload_dump.c b/src/elfs/elfload_dump.c
index fbd24eaa..f6fa50be 100644
--- a/src/elfs/elfload_dump.c
+++ b/src/elfs/elfload_dump.c
@@ -427,19 +427,19 @@ void DumpBinary(char* p, int sz)
         if (n>sz) n = sz;
         int fill = 16-sz;
         for (int j = 0; j<delta; ++j)
-            printf_dump(LOG_NEVER, "   ");
+            printf_dump_prefix(0, LOG_NEVER, "   ");
         for (int j = 0; j<n; ++j)
-            printf_dump(LOG_NEVER, "%02X ", d[j]);
+            printf_dump_prefix(0, LOG_NEVER, "%02X ", d[j]);
         for (int j = 0; j<fill; ++j)
-            printf_dump(LOG_NEVER, "   ");
-        printf_dump(LOG_NEVER, " | ");
+            printf_dump_prefix(0, LOG_NEVER, "   ");
+        printf_dump_prefix(0, LOG_NEVER, " | ");
         for (int j = 0; j<delta; ++j)
-            printf_dump(LOG_NEVER, " ");
+            printf_dump_prefix(0, LOG_NEVER, " ");
         for (int j = 0; j<n; ++j)
-            printf_dump(LOG_NEVER, "%c", (d[j]<32 || d[j]>127)?'.':d[j]);
+            printf_dump_prefix(0, LOG_NEVER, "%c", (d[j]<32 || d[j]>127)?'.':d[j]);
         for (int j = 0; j<fill; ++j)
-            printf_dump(LOG_NEVER, " ");
-        printf_dump(LOG_NEVER, "\n");
+            printf_dump_prefix(0, LOG_NEVER, " ");
+        printf_dump_prefix(0, LOG_NEVER, "\n");
         d+=n;
         sz-=n;
         delta=0;
diff --git a/src/elfs/elfloader.c b/src/elfs/elfloader.c
index 3a979ed5..11943c1a 100644
--- a/src/elfs/elfloader.c
+++ b/src/elfs/elfloader.c
@@ -1059,7 +1059,7 @@ int LoadNeededLibs(elfheader_t* h, lib_t *maplib, int local, int bindnow, int de
                 box_free(platform);
             }
             if(strchr(rpath, '$')) {
-                printf_log(LOG_INFO, "BOX64: Warning, RPATH with $ variable not supported yet (%s)\n", rpath);
+                printf_log(LOG_INFO, "Warning, RPATH with $ variable not supported yet (%s)\n", rpath);
             } else {
                 printf_log(LOG_DEBUG, "Prepending path \"%s\" to BOX64_LD_LIBRARY_PATH\n", rpath);
                 PrependList(&box64->box64_ld_lib, rpath, 1);
@@ -1574,32 +1574,32 @@ void ResetSpecialCaseMainElf(elfheader_t* h)
             if(strcmp(symname, "_IO_2_1_stderr_")==0 && ((void*)sym->st_value+h->delta)) {
                 memcpy((void*)sym->st_value+h->delta, stderr, sym->st_size);
                 my__IO_2_1_stderr_ = (void*)sym->st_value+h->delta;
-                printf_log(LOG_DEBUG, "BOX64: Set @_IO_2_1_stderr_ to %p\n", my__IO_2_1_stderr_);
+                printf_log(LOG_DEBUG, "Set @_IO_2_1_stderr_ to %p\n", my__IO_2_1_stderr_);
             } else
             if(strcmp(symname, "_IO_2_1_stdin_")==0 && ((void*)sym->st_value+h->delta)) {
                 memcpy((void*)sym->st_value+h->delta, stdin, sym->st_size);
                 my__IO_2_1_stdin_ = (void*)sym->st_value+h->delta;
-                printf_log(LOG_DEBUG, "BOX64: Set @_IO_2_1_stdin_ to %p\n", my__IO_2_1_stdin_);
+                printf_log(LOG_DEBUG, "Set @_IO_2_1_stdin_ to %p\n", my__IO_2_1_stdin_);
             } else
             if(strcmp(symname, "_IO_2_1_stdout_")==0 && ((void*)sym->st_value+h->delta)) {
                 memcpy((void*)sym->st_value+h->delta, stdout, sym->st_size);
                 my__IO_2_1_stdout_ = (void*)sym->st_value+h->delta;
-                printf_log(LOG_DEBUG, "BOX64: Set @_IO_2_1_stdout_ to %p\n", my__IO_2_1_stdout_);
+                printf_log(LOG_DEBUG, "Set @_IO_2_1_stdout_ to %p\n", my__IO_2_1_stdout_);
             } else
             if(strcmp(symname, "_IO_stderr_")==0 && ((void*)sym->st_value+h->delta)) {
                 memcpy((void*)sym->st_value+h->delta, stderr, sym->st_size);
                 my__IO_2_1_stderr_ = (void*)sym->st_value+h->delta;
-                printf_log(LOG_DEBUG, "BOX64: Set @_IO_stderr_ to %p\n", my__IO_2_1_stderr_);
+                printf_log(LOG_DEBUG, "Set @_IO_stderr_ to %p\n", my__IO_2_1_stderr_);
             } else
             if(strcmp(symname, "_IO_stdin_")==0 && ((void*)sym->st_value+h->delta)) {
                 memcpy((void*)sym->st_value+h->delta, stdin, sym->st_size);
                 my__IO_2_1_stdin_ = (void*)sym->st_value+h->delta;
-                printf_log(LOG_DEBUG, "BOX64: Set @_IO_stdin_ to %p\n", my__IO_2_1_stdin_);
+                printf_log(LOG_DEBUG, "Set @_IO_stdin_ to %p\n", my__IO_2_1_stdin_);
             } else
             if(strcmp(symname, "_IO_stdout_")==0 && ((void*)sym->st_value+h->delta)) {
                 memcpy((void*)sym->st_value+h->delta, stdout, sym->st_size);
                 my__IO_2_1_stdout_ = (void*)sym->st_value+h->delta;
-                printf_log(LOG_DEBUG, "BOX64: Set @_IO_stdout_ to %p\n", my__IO_2_1_stdout_);
+                printf_log(LOG_DEBUG, "Set @_IO_stdout_ to %p\n", my__IO_2_1_stdout_);
             }
         }
     }
diff --git a/src/emu/x64run_private.c b/src/emu/x64run_private.c
index a82fc6f5..f462361e 100644
--- a/src/emu/x64run_private.c
+++ b/src/emu/x64run_private.c
@@ -1146,7 +1146,7 @@ void UpdateFlags(x64emu_t *emu)
             break;
 
         case d_unknown:
-            printf_log(LOG_NONE, "Box64: %p trying to evaluate Unknown deferred Flags\n", (void*)R_RIP);
+            printf_log(LOG_NONE, "%p trying to evaluate Unknown deferred Flags\n", (void*)R_RIP);
             break;
     }
     RESET_FLAGS(emu);
@@ -1197,9 +1197,9 @@ int printFunctionAddr(uintptr_t nextaddr, const char* text)
     if(!sz) sz=0x100;   // arbitrary value...
     if(symbname && nextaddr>=start && (nextaddr<(start+sz) || !sz)) {
         if(nextaddr==start)
-            printf_log(LOG_NONE, " (%s%s:%s)", text, ElfName(FindElfAddress(my_context, nextaddr)), symbname);
+            printf_log_prefix(0, LOG_NONE, " (%s%s:%s)", text, ElfName(FindElfAddress(my_context, nextaddr)), symbname);
         else
-            printf_log(LOG_NONE, " (%s%s:%s + 0x%lx)", text, ElfName(FindElfAddress(my_context, nextaddr)), symbname, nextaddr - start);
+            printf_log_prefix(0, LOG_NONE, " (%s%s:%s + 0x%lx)", text, ElfName(FindElfAddress(my_context, nextaddr)), symbname, nextaddr - start);
         return 1;
     }
     return 0;
@@ -1224,7 +1224,7 @@ void PrintTrace(x64emu_t* emu, uintptr_t ip, int dynarec)
         if((my_context->trace_tid != tid) || (my_context->trace_dynarec!=dynarec)) {
             printf_log(LOG_NONE, "Thread %04d| (%s) ", tid, dynarec?"dyn":"int");
             printFunctionAddr(ip, "here: ");
-            printf_log(LOG_NONE, "\n");
+            printf_log_prefix(0, LOG_NONE, "\n");
             my_context->trace_tid = tid;
             my_context->trace_dynarec = dynarec;
         }
@@ -1259,29 +1259,29 @@ void PrintTrace(x64emu_t* emu, uintptr_t ip, int dynarec)
             }
             if(peek==0xC3 || peek==0xC2 || (peek==0xF3 && PK(1)==0xC3)) {
                 if(is32bits) {
-                    printf_log(LOG_NONE, " => %p", (void*)(uintptr_t)*(uint32_t*)(R_RSP));
+                    printf_log_prefix(0, LOG_NONE, " => %p", (void*)(uintptr_t)*(uint32_t*)(R_RSP));
                     printFunctionAddr(*(uint32_t*)(R_RSP), "=> ");
                 } else {
-                    printf_log(LOG_NONE, " => %p", *(void**)(R_RSP));
+                    printf_log_prefix(0, LOG_NONE, " => %p", *(void**)(R_RSP));
                     printFunctionAddr(*(uintptr_t*)(R_RSP), "=> ");
                 }
             } else if(peek==0x57 && rex.b) {
-                printf_log(LOG_NONE, " => STACK_TOP: %p", *(void**)(R_RSP));
+                printf_log_prefix(0, LOG_NONE, " => STACK_TOP: %p", *(void**)(R_RSP));
                 printFunctionAddr(ip, "here: ");
             } else if((peek==0x55 /*|| peek==0x53*/) && !is32bits) {
                 if(!printFunctionAddr(*(uintptr_t*)(R_RSP), " STACK_TOP: "))
-                    printf_log(LOG_NONE, " STACK_TOP: %p ", (void*)*(uintptr_t*)(R_RSP));
+                    printf_log_prefix(0, LOG_NONE, " STACK_TOP: %p ", (void*)*(uintptr_t*)(R_RSP));
             } else if((peek==0x55 || peek==0x56 || peek==0x53 || peek==0x57) && is32bits) {
                 if(!printFunctionAddr(*(uint32_t*)(R_RSP), " STACK_TOP: "))
-                    printf_log(LOG_NONE, " STACK_TOP: %p ", (void*)(uintptr_t)*(uint32_t*)(R_RSP));
+                    printf_log_prefix(0, LOG_NONE, " STACK_TOP: %p ", (void*)(uintptr_t)*(uint32_t*)(R_RSP));
             } else if(peek==0xF3 && PK(1)==0x0F && PK(2)==0x1E && PK(3)==0xFA && !is32bits) {
                 uintptr_t nextaddr = *(uintptr_t*)(R_RSP);
                 if(!printFunctionAddr(nextaddr, "=> "))
-                    printf_log(LOG_NONE, " => %p", (void*)nextaddr);
+                    printf_log_prefix(0, LOG_NONE, " => %p", (void*)nextaddr);
             } else if((peek==0x81 || peek==0x83) && PK(1)==0xEC && is32bits) {
                 uintptr_t nextaddr = *(ptr_t*)from_ptrv(R_ESP);
                 if(!printFunctionAddr(nextaddr, "STACK_TOP: "))
-                    printf_log(LOG_NONE, " STACK_TOP: %p", (void*)nextaddr);
+                    printf_log_prefix(0, LOG_NONE, " STACK_TOP: %p", (void*)nextaddr);
             } else if(peek==0xE8 || peek==0xE9) { // Call & Jmp
                 uintptr_t nextaddr = ip + 5 + PK32(1);
                 printFunctionAddr(nextaddr, "=> ");
@@ -1289,56 +1289,56 @@ void PrintTrace(x64emu_t* emu, uintptr_t ip, int dynarec)
                 if(PK(1)==0x25) {
                     uintptr_t nextaddr = is32bits?(*(uint32_t*)(uintptr_t)PK32(2)):(*(uintptr_t*)(ip + 6 + PK32(2)));
                     if(!printFunctionAddr(nextaddr, "=> "))
-                        printf_log(LOG_NONE, " => %p", (void*)nextaddr);
+                        printf_log_prefix(0, LOG_NONE, " => %p", (void*)nextaddr);
                 } else if(PK(1)==0x15) {
                     uintptr_t nextaddr = is32bits?(*(uint32_t*)(uintptr_t)PK32(2)):(*(uintptr_t*)(ip + 6 + PK32(2)));
                     if(!printFunctionAddr(nextaddr, "=> "))
-                        printf_log(LOG_NONE, " => %p", (void*)nextaddr);
+                        printf_log_prefix(0, LOG_NONE, " => %p", (void*)nextaddr);
                 } else if(PK(1)==0x60) {
                     uintptr_t nextaddr = *(uintptr_t*)(R_RAX+PK(2));
                     if(!printFunctionAddr(nextaddr, "=> "))
-                        printf_log(LOG_NONE, " => %p", (void*)nextaddr);
+                        printf_log_prefix(0, LOG_NONE, " => %p", (void*)nextaddr);
                 } else if(PK(1)==0xE0) {
                     uintptr_t nextaddr = R_RAX;
                     if(is32bits) nextaddr &= 0xffffffff;
                     if(!printFunctionAddr(nextaddr, "=> "))
-                        printf_log(LOG_NONE, " => %p", (void*)nextaddr);
+                        printf_log_prefix(0, LOG_NONE, " => %p", (void*)nextaddr);
                 } else if((PK(1)==0x14) && (PK(2)==0x25)) {
                     uintptr_t nextaddr = is32bits?(*(uint32_t*)(uintptr_t)PK32(3)):(*(uintptr_t*)(uintptr_t)PK32(3));
-                    printf_log(LOG_NONE, " => %p", (void*)nextaddr);
+                    printf_log_prefix(0, LOG_NONE, " => %p", (void*)nextaddr);
                     printFunctionAddr(nextaddr, "=> ");
                 } else if((PK(1)==0x14) && (PK(2)==0xC2) && rex.rex==0x41) {
                     uintptr_t nextaddr = *(uintptr_t*)(R_R10 + R_RAX*8);
-                    printf_log(LOG_NONE, " => %p", (void*)nextaddr);
+                    printf_log_prefix(0, LOG_NONE, " => %p", (void*)nextaddr);
                     printFunctionAddr(nextaddr, "=> ");
                 } else if(PK(1)==0xE1 && rex.rex==0x41) {
                     uintptr_t nextaddr = R_R9;
-                    printf_log(LOG_NONE, " => %p", (void*)nextaddr);
+                    printf_log_prefix(0, LOG_NONE, " => %p", (void*)nextaddr);
                     printFunctionAddr(nextaddr, "=> ");
                 } else if(is32bits && PK(1)==0xA3) {
                     uintptr_t nextaddr = *(ptr_t*)from_ptrv(R_EBX + PK32(2));
-                    printf_log(LOG_NONE, " => %p", (void*)nextaddr);
+                    printf_log_prefix(0, LOG_NONE, " => %p", (void*)nextaddr);
                     printFunctionAddr(nextaddr, "=> ");
                 } else if(PK(1)==0x92) {
                     uintptr_t nextaddr = is32bits?(*(ptr_t*)from_ptrv(R_EDX + PK32(2))):(*(uintptr_t*)(R_RDX + PK32(2)));
-                    printf_log(LOG_NONE, " => %p", (void*)nextaddr);
+                    printf_log_prefix(0, LOG_NONE, " => %p", (void*)nextaddr);
                     printFunctionAddr(nextaddr, "=> ");
                 } else if(PK(1)==0x50) {
                     uintptr_t nextaddr = is32bits?(*(ptr_t*)from_ptrv(R_EAX + PK(2))):(*(uintptr_t*)(R_RAX + PK(2)));
-                    printf_log(LOG_NONE, " => %p", (void*)nextaddr);
+                    printf_log_prefix(0, LOG_NONE, " => %p", (void*)nextaddr);
                     printFunctionAddr(nextaddr, "=> ");
                 } else if(PK(1)==0x52) {
                     uintptr_t nextaddr = is32bits?(*(ptr_t*)from_ptrv(R_EDX + PK(2))):(*(uintptr_t*)(R_RDX + PK(2)));
-                    printf_log(LOG_NONE, " => %p", (void*)nextaddr);
+                    printf_log_prefix(0, LOG_NONE, " => %p", (void*)nextaddr);
                     printFunctionAddr(nextaddr, "=> ");
                 } else if(is32bits && PK(1)==0x10) {
                     uintptr_t nextaddr = *(ptr_t*)from_ptrv(R_EAX);
-                    printf_log(LOG_NONE, " => %p", (void*)nextaddr);
+                    printf_log_prefix(0, LOG_NONE, " => %p", (void*)nextaddr);
                     printFunctionAddr(nextaddr, "=> ");
                 }
 
             }
-            printf_log(LOG_NONE, "\n");
+            printf_log_prefix(0, LOG_NONE, "\n");
         }
         mutex_unlock(&my_context->mutex_trace);
     }
diff --git a/src/emu/x64test.c b/src/emu/x64test.c
index b00fc060..974847ab 100644
--- a/src/emu/x64test.c
+++ b/src/emu/x64test.c
@@ -128,11 +128,11 @@ void x64test_check(x64emu_t* ref, uintptr_t ip)
             BANNER;
             printf_log(LOG_NONE, "MEM: @%p :", (void*)test->memaddr);
             for(int i=0; i<test->memsize; ++i)
-                printf_log(LOG_NONE, " %02x", ((uint8_t*)test->memaddr)[i]);
-            printf_log(LOG_NONE, " |");
+                printf_log_prefix(0, LOG_NONE, " %02x", ((uint8_t*)test->memaddr)[i]);
+            printf_log_prefix(0, LOG_NONE, " |");
             for(int i=0; i<test->memsize; ++i)
-                printf_log(LOG_NONE, " %02x", test->mem[i]);
-            printf_log(LOG_NONE, "\n");
+                printf_log_prefix(0, LOG_NONE, " %02x", test->mem[i]);
+            printf_log_prefix(0, LOG_NONE, "\n");
         }
     }
     if(banner)  // there was an error, re-sync!
diff --git a/src/emu/x86int3.c b/src/emu/x86int3.c
index 0eae5dd7..65b13902 100755
--- a/src/emu/x86int3.c
+++ b/src/emu/x86int3.c
@@ -470,9 +470,9 @@ void x86Int3(x64emu_t* emu, uintptr_t* addr)
                 } else {
                     mutex_lock(&emu->context->mutex_trace);
                     if(ret_fmt==1)
-                        printf_log(LOG_NONE, " return %d%s%s\n", S_EAX, buff2, buff3);
+                        printf_log_prefix(0, LOG_NONE, " return %d%s%s\n", S_EAX, buff2, buff3);
                     else
-                        printf_log(LOG_NONE, " return 0x%X%s%s\n", R_EAX, buff2, buff3);
+                        printf_log_prefix(0, LOG_NONE, " return 0x%X%s%s\n", R_EAX, buff2, buff3);
                     mutex_unlock(&emu->context->mutex_trace);
                 }
             } else
diff --git a/src/include/debug.h b/src/include/debug.h
index 36a2e14a..0510d7fe 100644
--- a/src/include/debug.h
+++ b/src/include/debug.h
@@ -67,24 +67,35 @@ extern int box64_tcmalloc_minimal;  // when using tcmalloc_minimal
 #define LOG_NEVER 3
 #define LOG_VERBOSE 3
 
-void printf_ftrace(const char* fmt, ...);
+void printf_ftrace(int prefix, const char* fmt, ...);
 
-#define printf_log(L, ...)                                        \
-    do {                                                          \
-        if ((L) <= BOX64ENV(log)) { printf_ftrace(__VA_ARGS__); } \
+#define printf_log_prefix(prefix, L, ...)                                 \
+    do {                                                                  \
+        if ((L) <= BOX64ENV(log)) { printf_ftrace(prefix, __VA_ARGS__); } \
     } while (0)
 
-#define printf_dump(L, ...)                                                           \
-    do {                                                                              \
-        if (BOX64ENV(dump) || ((L) <= BOX64ENV(log))) { printf_ftrace(__VA_ARGS__); } \
+#define printf_log(L, ...) printf_log_prefix(1, L, __VA_ARGS__)
+
+#define printf_dump_prefix(prefix, L, ...)                                                    \
+    do {                                                                                      \
+        if (BOX64ENV(dump) || ((L) <= BOX64ENV(log))) { printf_ftrace(prefix, __VA_ARGS__); } \
     } while (0)
 
-#define printf_dlsym(L, ...)                                                                 \
-    do {                                                                                     \
-        if (BOX64ENV(dlsym_error) || ((L) <= BOX64ENV(log))) { printf_ftrace(__VA_ARGS__); } \
+#define printf_dump(L, ...) printf_dump_prefix(1, L, __VA_ARGS__)
+
+#define printf_dlsym_prefix(prefix, L, ...)                                                          \
+    do {                                                                                             \
+        if (BOX64ENV(dlsym_error) || ((L) <= BOX64ENV(log))) { printf_ftrace(prefix, __VA_ARGS__); } \
+    } while (0)
+
+#define printf_dlsym(L, ...) printf_dlsym_prefix(1, L, __VA_ARGS__)
+
+#define dynarec_log_prefix(prefix, L, ...)                                        \
+    do {                                                                          \
+        if ((L) <= BOX64ENV(dynarec_log)) { printf_ftrace(prefix, __VA_ARGS__); } \
     } while (0)
 
-#define dynarec_log(L, ...) do {if((L)<=BOX64ENV(dynarec_log)) {printf_ftrace(__VA_ARGS__);}} while(0)
+#define dynarec_log(L, ...) dynarec_log_prefix(1, L, __VA_ARGS__)
 
 #define EXPORT __attribute__((visibility("default")))
 #ifdef BUILD_DYNAMIC
diff --git a/src/libtools/myalign.c b/src/libtools/myalign.c
index 3bd71237..9ef13cf5 100644
--- a/src/libtools/myalign.c
+++ b/src/libtools/myalign.c
@@ -1261,7 +1261,7 @@ void* align_xcb_connection(void* src)
         dest = add_xcb_connection(src);
     #else
     if(!dest) {
-        printf_log(LOG_NONE, "BOX64: Error, xcb_connect %p not found\n", src);
+        printf_log(LOG_NONE, "Error, xcb_connect %p not found\n", src);
         abort();
     }
     #endif
@@ -1339,7 +1339,7 @@ void* add_xcb_connection(void* src)
             unalign_xcb_connection(src, &x64_xcb_connects[i]);
             return &x64_xcb_connects[i];
         }
-    printf_log(LOG_NONE, "BOX64: Error, no more free xcb_connect slot for %p\n", src);
+    printf_log(LOG_NONE, "Error, no more free xcb_connect slot for %p\n", src);
     return src;
 }
 
@@ -1354,5 +1354,5 @@ void del_xcb_connection(void* src)
             memset(&x64_xcb_connects[i], 0, sizeof(x64_xcb_connection_t));
             return;
         }
-    printf_log(LOG_NONE, "BOX64: Error, xcb_connect %p not found for deletion\n", src);
+    printf_log(LOG_NONE, "Error, xcb_connect %p not found for deletion\n", src);
 }
diff --git a/src/libtools/myalignxcb32.c b/src/libtools/myalignxcb32.c
index 0d0fc6da..b9f58d0e 100644
--- a/src/libtools/myalignxcb32.c
+++ b/src/libtools/myalignxcb32.c
@@ -88,7 +88,7 @@ void* align_xcb_connection32(void* src)
         dest = add_xcb_connection32(src);
     #else
     if(!dest) {
-        printf_log(LOG_NONE, "BOX64: Error, xcb_connect %p not found\n", src);
+        printf_log(LOG_NONE, "Error, xcb_connect %p not found\n", src);
         abort();
     }
     #endif
@@ -190,7 +190,7 @@ void* add_xcb_connection32(void* src)
             unalign_xcb_connection32(src, &i386_xcb_connects[i]);
             return &i386_xcb_connects[i];
         }
-    printf_log(LOG_NONE, "BOX64: Error, no more free xcb_connect 32bits slot for %p\n", src);
+    printf_log(LOG_NONE, "Error, no more free xcb_connect 32bits slot for %p\n", src);
     return src;
 }
 
@@ -205,5 +205,5 @@ void del_xcb_connection32(void* src)
             memset(&i386_xcb_connects[i], 0, sizeof(my_xcb_connection_32_t));
             return;
         }
-    printf_log(LOG_NONE, "BOX64: Error, 32bits xcb_connect %p not found for deletion\n", src);
+    printf_log(LOG_NONE, "Error, 32bits xcb_connect %p not found for deletion\n", src);
 }
diff --git a/src/libtools/signals.c b/src/libtools/signals.c
index 819d89d7..85a66590 100644
--- a/src/libtools/signals.c
+++ b/src/libtools/signals.c
@@ -302,7 +302,7 @@ uint64_t RunFunctionHandler(x64emu_t* emu, int* exit, int dynarec, x64_ucontext_
         va_start (va, nargs);
         int sig = va_arg(va, int);
         va_end (va);
-        printf_log(LOG_NONE, "%04d|BOX64: Warning, calling Signal %d function handler %s\n", GetTID(), sig, fnc?"SIG_IGN":"SIG_DFL");
+        printf_log(LOG_NONE, "%04d|Warning, calling Signal %d function handler %s\n", GetTID(), sig, fnc?"SIG_IGN":"SIG_DFL");
         if(fnc==0) {
             printf_log(LOG_NONE, "Unhandled signal caught, aborting\n");
             abort();
@@ -1934,46 +1934,46 @@ dynarec_log(/*LOG_DEBUG*/LOG_INFO, "%04d|Repeated SIGSEGV with Access error on %
             if(db) {
                 shown_regs = 1;
                 for (int i=0; i<16; ++i) {
-                    if(!(i%4)) printf_log(log_minimum, "\n");
-                    printf_log(log_minimum, "%s:0x%016llx ", reg_name[i], p->uc_mcontext.regs[10+i]);
+                    if(!(i%4)) printf_log_prefix(0, log_minimum, "\n");
+                    printf_log_prefix(0, log_minimum, "%s:0x%016llx ", reg_name[i], p->uc_mcontext.regs[10+i]);
                 }
-                printf_log(log_minimum, "\n");
+                printf_log_prefix(0, log_minimum, "\n");
                 for (int i=0; i<6; ++i)
-                    printf_log(log_minimum, "%s:0x%04x ", seg_name[i], emu->segs[i]);
+                    printf_log_prefix(0, log_minimum, "%s:0x%04x ", seg_name[i], emu->segs[i]);
             }
             if(rsp!=addr && getProtection((uintptr_t)rsp-4*8) && getProtection((uintptr_t)rsp+4*8))
                 for (int i=-4; i<4; ++i) {
-                    printf_log(log_minimum, "%sRSP%c0x%02x:0x%016lx", (i%4)?" ":"\n", i<0?'-':'+', abs(i)*8, *(uintptr_t*)(rsp+i*8));
+                    printf_log_prefix(0, log_minimum, "%sRSP%c0x%02x:0x%016lx", (i%4)?" ":"\n", i<0?'-':'+', abs(i)*8, *(uintptr_t*)(rsp+i*8));
                 }
 #elif defined(RV64)
             if(db) {
                 shown_regs = 1;
                 for (int i=0; i<16; ++i) {
-                    if(!(i%4)) printf_log(log_minimum, "\n");
-                    printf_log(log_minimum, "%s:0x%016llx ", reg_name[i], p->uc_mcontext.__gregs[(((uint8_t[]) { 16, 13, 12, 24, 9, 8, 11, 10, 14, 15, 26, 27, 18, 19, 20, 21 })[i])]);
+                    if(!(i%4)) printf_log_prefix(0, log_minimum, "\n");
+                    printf_log_prefix(0, log_minimum, "%s:0x%016llx ", reg_name[i], p->uc_mcontext.__gregs[(((uint8_t[]) { 16, 13, 12, 24, 9, 8, 11, 10, 14, 15, 26, 27, 18, 19, 20, 21 })[i])]);
                 }
-                printf_log(log_minimum, "\n");
+                printf_log_prefix(0, log_minimum, "\n");
                 for (int i=0; i<6; ++i)
-                    printf_log(log_minimum, "%s:0x%04x ", seg_name[i], emu->segs[i]);
+                    printf_log_prefix(0, log_minimum, "%s:0x%04x ", seg_name[i], emu->segs[i]);
             }
             if(rsp!=addr && getProtection((uintptr_t)rsp-4*8) && getProtection((uintptr_t)rsp+4*8))
                 for (int i=-4; i<4; ++i) {
-                    printf_log(log_minimum, "%sRSP%c0x%02x:0x%016lx", (i%4)?" ":"\n", i<0?'-':'+', abs(i)*8, *(uintptr_t*)(rsp+i*8));
+                    printf_log_prefix(0, log_minimum, "%sRSP%c0x%02x:0x%016lx", (i%4)?" ":"\n", i<0?'-':'+', abs(i)*8, *(uintptr_t*)(rsp+i*8));
                 }
 #elif defined(LA64)
             if(db) {
                 shown_regs = 1;
                 for (int i=0; i<16; ++i) {
-                    if(!(i%4)) printf_log(log_minimum, "\n");
-                    printf_log(log_minimum, "%s:0x%016llx ", reg_name[i], p->uc_mcontext.__gregs[12+i]);
+                    if(!(i%4)) printf_log_prefix(0, log_minimum, "\n");
+                    printf_log_prefix(0, log_minimum, "%s:0x%016llx ", reg_name[i], p->uc_mcontext.__gregs[12+i]);
                 }
-                printf_log(log_minimum, "\n");
+                printf_log_prefix(0, log_minimum, "\n");
                 for (int i=0; i<6; ++i)
-                    printf_log(log_minimum, "%s:0x%04x ", seg_name[i], emu->segs[i]);
+                    printf_log_prefix(0, log_minimum, "%s:0x%04x ", seg_name[i], emu->segs[i]);
             }
             if(rsp!=addr && getProtection((uintptr_t)rsp-4*8) && getProtection((uintptr_t)rsp+4*8))
                 for (int i=-4; i<4; ++i) {
-                    printf_log(log_minimum, "%sRSP%c0x%02x:0x%016lx", (i%4)?" ":"\n", i<0?'-':'+', abs(i)*8, *(uintptr_t*)(rsp+i*8));
+                    printf_log_prefix(0, log_minimum, "%sRSP%c0x%02x:0x%016lx", (i%4)?" ":"\n", i<0?'-':'+', abs(i)*8, *(uintptr_t*)(rsp+i*8));
                 }
 #else
             #warning TODO
@@ -1983,19 +1983,19 @@ dynarec_log(/*LOG_DEBUG*/LOG_INFO, "%04d|Repeated SIGSEGV with Access error on %
 #endif
             if(!shown_regs) {
                 for (int i=0; i<16; ++i) {
-                    if(!(i%4)) printf_log(log_minimum, "\n");
-                    printf_log(log_minimum, "%s:0x%016llx ", reg_name[i], emu->regs[i].q[0]);
+                    if(!(i%4)) printf_log_prefix(0, log_minimum, "\n");
+                    printf_log_prefix(0, log_minimum, "%s:0x%016llx ", reg_name[i], emu->regs[i].q[0]);
                 }
-                printf_log(log_minimum, "\n");
+                printf_log_prefix(0, log_minimum, "\n");
                 for (int i=0; i<6; ++i)
-                    printf_log(log_minimum, "%s:0x%04x ", seg_name[i], emu->segs[i]);
+                    printf_log_prefix(0, log_minimum, "%s:0x%04x ", seg_name[i], emu->segs[i]);
             }
             if(sig==SIGILL) {
-                printf_log(log_minimum, " opcode=%02X %02X %02X %02X %02X %02X %02X %02X (%02X %02X %02X %02X %02X)\n", ((uint8_t*)pc)[0], ((uint8_t*)pc)[1], ((uint8_t*)pc)[2], ((uint8_t*)pc)[3], ((uint8_t*)pc)[4], ((uint8_t*)pc)[5], ((uint8_t*)pc)[6], ((uint8_t*)pc)[7], ((uint8_t*)x64pc)[0], ((uint8_t*)x64pc)[1], ((uint8_t*)x64pc)[2], ((uint8_t*)x64pc)[3], ((uint8_t*)x64pc)[4]);
+                printf_log_prefix(0, log_minimum, " opcode=%02X %02X %02X %02X %02X %02X %02X %02X (%02X %02X %02X %02X %02X)\n", ((uint8_t*)pc)[0], ((uint8_t*)pc)[1], ((uint8_t*)pc)[2], ((uint8_t*)pc)[3], ((uint8_t*)pc)[4], ((uint8_t*)pc)[5], ((uint8_t*)pc)[6], ((uint8_t*)pc)[7], ((uint8_t*)x64pc)[0], ((uint8_t*)x64pc)[1], ((uint8_t*)x64pc)[2], ((uint8_t*)x64pc)[3], ((uint8_t*)x64pc)[4]);
             } else if(sig==SIGBUS || (sig==SIGSEGV && (x64pc!=(uintptr_t)addr) && (pc!=addr))) {
-                printf_log(log_minimum, " %sopcode=%02X %02X %02X %02X %02X %02X %02X %02X (opcode=%08x)\n", (emu->segs[_CS]==0x23)?"x86":"x64", ((uint8_t*)x64pc)[0], ((uint8_t*)x64pc)[1], ((uint8_t*)x64pc)[2], ((uint8_t*)x64pc)[3], ((uint8_t*)x64pc)[4], ((uint8_t*)x64pc)[5], ((uint8_t*)x64pc)[6], ((uint8_t*)x64pc)[7], *(uint32_t*)pc);
+                printf_log_prefix(0, log_minimum, " %sopcode=%02X %02X %02X %02X %02X %02X %02X %02X (opcode=%08x)\n", (emu->segs[_CS]==0x23)?"x86":"x64", ((uint8_t*)x64pc)[0], ((uint8_t*)x64pc)[1], ((uint8_t*)x64pc)[2], ((uint8_t*)x64pc)[3], ((uint8_t*)x64pc)[4], ((uint8_t*)x64pc)[5], ((uint8_t*)x64pc)[6], ((uint8_t*)x64pc)[7], *(uint32_t*)pc);
             } else {
-                printf_log(log_minimum, "\n");
+                printf_log_prefix(0, log_minimum, "\n");
             }
         }
     }
diff --git a/src/tools/env.c b/src/tools/env.c
index 1e68d6ff..ae19c8ad 100644
--- a/src/tools/env.c
+++ b/src/tools/env.c
@@ -496,19 +496,19 @@ void PrintEnvVariables()
         printf_log(LOG_INFO, "BOX64ENV: Variables overridden via env and/or RC file:\n");
 #define INTEGER(NAME, name, default, min, max) \
     if (box64env.is_##name##_overridden)       \
-        printf_log(LOG_INFO, "\t%s=%d\n", #NAME, box64env.name);
+        printf_log_prefix(0, LOG_INFO, "\t%s=%d\n", #NAME, box64env.name);
 #define INTEGER64(NAME, name, default)   \
     if (box64env.is_##name##_overridden) \
-        printf_log(LOG_INFO, "\t%s=%lld\n", #NAME, box64env.name);
+        printf_log_prefix(0, LOG_INFO, "\t%s=%lld\n", #NAME, box64env.name);
 #define BOOLEAN(NAME, name, default)     \
     if (box64env.is_##name##_overridden) \
-        printf_log(LOG_INFO, "\t%s=%d\n", #NAME, box64env.name);
+        printf_log_prefix(0, LOG_INFO, "\t%s=%d\n", #NAME, box64env.name);
 #define ADDRESS(NAME, name)              \
     if (box64env.is_##name##_overridden) \
-        printf_log(LOG_INFO, "\t%s=%p\n", #NAME, (void*)box64env.name);
+        printf_log_prefix(0, LOG_INFO, "\t%s=%p\n", #NAME, (void*)box64env.name);
 #define STRING(NAME, name)               \
     if (box64env.is_##name##_overridden) \
-        printf_log(LOG_INFO, "\t%s=%s\n", #NAME, box64env.name);
+        printf_log_prefix(0, LOG_INFO, "\t%s=%s\n", #NAME, box64env.name);
     ENVSUPER()
 #undef INTEGER
 #undef INTEGER64
diff --git a/src/wrapped/wrappedgstreamer.c b/src/wrapped/wrappedgstreamer.c
index 9e5b8198..5c411f70 100644
--- a/src/wrapped/wrappedgstreamer.c
+++ b/src/wrapped/wrappedgstreamer.c
@@ -950,7 +950,7 @@ static void register_plugins_from_folder(x64emu_t* emu, const char* folder)
             }
             void* f_init = handle?(is_native?dlsym(handle, regfunc_name):my_dlsym(emu, handle, regfunc_name)):NULL;
             if(f_init) {
-                printf_log(LOG_DEBUG, "BOX64: Will registering %sgstplugin %s\n", is_native?"native ":"", filename);
+                printf_log(LOG_DEBUG, "Will registering %sgstplugin %s\n", is_native?"native ":"", filename);
                 if(is_native)
                     ((vFv_t)(f_init))();
                 else
@@ -962,7 +962,7 @@ static void register_plugins_from_folder(x64emu_t* emu, const char* folder)
                 my->plugins[my->plugin_cnt].is_native = is_native;
                 my->plugins[my->plugin_cnt++].handle = handle;
             } else {
-                printf_log(LOG_DEBUG, "BOX64: Failled to register %sgstplugin %s, name=%s, handle=%p\n", is_native?"native ":"", filename, name, handle);
+                printf_log(LOG_DEBUG, "Failled to register %sgstplugin %s, name=%s, handle=%p\n", is_native?"native ":"", filename, name, handle);
             }
             if(handle && !f_init) {
                 is_native?dlclose(handle):my_dlclose(emu, handle);
diff --git a/src/wrapped/wrappedlibc.c b/src/wrapped/wrappedlibc.c
index 2b4293cd..7afa134f 100644
--- a/src/wrapped/wrappedlibc.c
+++ b/src/wrapped/wrappedlibc.c
@@ -528,7 +528,7 @@ pid_t EXPORT my_fork(x64emu_t* emu)
     if(type == EMUTYPE_MAIN)
         thread_set_emu(emu);
     if(v<0) {
-        printf_log(LOG_NONE, "BOX64: Warning, fork errored... (%d)\n", v);
+        printf_log(LOG_NONE, "Warning, fork errored... (%d)\n", v);
         // error...
     } else if(v>0) {
         // execute atforks parent functions
@@ -3012,7 +3012,7 @@ EXPORT void* my_mmap64(x64emu_t* emu, void *addr, size_t length, int prot, int f
             ssize_t r = readlink(buf, filename, sizeof(filename)-1);
             if(r!=-1) filename[r]=0;
             if(r>0 && strlen(filename)>strlen("UnityPlayer.dll") && !strcasecmp(filename+strlen(filename)-strlen("UnityPlayer.dll"), "UnityPlayer.dll")) {
-                printf_log(LOG_INFO, "BOX64: Detected UnityPlayer.dll\n");
+                printf_log(LOG_INFO, "Detected UnityPlayer.dll\n");
                 #ifdef DYNAREC
                 if(!BOX64ENV(dynarec_strongmem)) SET_BOX64ENV(dynarec_strongmem, 1);
                 #endif
@@ -3776,16 +3776,16 @@ EXPORT void my__exit(x64emu_t* emu, int code) __attribute__((alias("my_exit")));
 EXPORT int my_prctl(x64emu_t* emu, int option, unsigned long arg2, unsigned long arg3, unsigned long arg4, unsigned long arg5)
 {
     if(option==PR_SET_NAME) {
-        printf_log(LOG_DEBUG, "BOX64: set process name to \"%s\"\n", (char*)arg2);
+        printf_log(LOG_DEBUG, "set process name to \"%s\"\n", (char*)arg2);
         ApplyEnvFileEntry((char*)arg2);
         size_t l = strlen((char*)arg2);
         if(l>4 && !strcasecmp((char*)arg2+l-4, ".exe")) {
-            printf_log(LOG_DEBUG, "BOX64: hacking orig command line to \"%s\"\n", (char*)arg2);
+            printf_log(LOG_DEBUG, "hacking orig command line to \"%s\"\n", (char*)arg2);
             strcpy(my_context->orig_argv[0], (char*)arg2);
         }
     }
     if(option==PR_SET_SECCOMP) {
-        printf_log(LOG_INFO, "BOX64: ignoring prctl(PR_SET_SECCOMP, ...)\n");
+        printf_log(LOG_INFO, "ignoring prctl(PR_SET_SECCOMP, ...)\n");
         return 0;
     }
     return prctl(option, arg2, arg3, arg4, arg5);
diff --git a/src/wrapped/wrappedwaylandclient.c b/src/wrapped/wrappedwaylandclient.c
index 737a2418..cc88f871 100644
--- a/src/wrapped/wrappedwaylandclient.c
+++ b/src/wrapped/wrappedwaylandclient.c
@@ -597,7 +597,7 @@ EXPORT int my_wl_proxy_add_listener(x64emu_t* emu, void* proxy, void** l, void*
     } else if(!strcmp(proxy_name, "zxdg_output_v1")) {
         l = find_zxdg_output_v1_listener_Fct(l);
     } else
-        printf_log(LOG_INFO, "BOX64: Error, Wayland-client, add_listener to %s unknown, will crash soon!\n", proxy_name);
+        printf_log(LOG_INFO, "Error, Wayland-client, add_listener to %s unknown, will crash soon!\n", proxy_name);
     return my->wl_proxy_add_listener(proxy, l, data);
 }