dbghelp: No longer use wine_dbgstr_longlong.

dlls/dbghelp/coff.c

@@ -297,9 +297,8 @@ DECLSPEC_HIDDEN BOOL coff_process_info(const struct msc_debug_info* msc_dbg)
             DWORD base = msc_dbg->sectp[coff_sym->SectionNumber - 1].VirtualAddress;
             nampnt = coff_get_name(coff_sym, coff_strtab);
 
-            TRACE("%d: %s %s\n",
-                  i, wine_dbgstr_longlong(msc_dbg->module->module.BaseOfImage + base + coff_sym->Value),
-                  nampnt);
+            TRACE("%d: %I64x %s\n",
+                  i, msc_dbg->module->module.BaseOfImage + base + coff_sym->Value, nampnt);
             TRACE("\tAdding global symbol %s (sect=%s)\n",
                   nampnt, msc_dbg->sectp[coff_sym->SectionNumber - 1].Name);
 
@@ -344,9 +343,8 @@ DECLSPEC_HIDDEN BOOL coff_process_info(const struct msc_debug_info* msc_dbg)
              */
             nampnt = coff_get_name(coff_sym, coff_strtab);
 
-            TRACE("%d: %s %s\n",
-                  i, wine_dbgstr_longlong(msc_dbg->module->module.BaseOfImage + base + coff_sym->Value),
-                  nampnt);
+            TRACE("%d: %I64x %s\n",
+                  i, msc_dbg->module->module.BaseOfImage + base + coff_sym->Value, nampnt);
             TRACE("\tAdding global data symbol %s\n", nampnt);
 
             /*

dlls/dbghelp/cpu_arm.c

@@ -91,13 +91,13 @@ static BOOL arm_stack_walk(struct cpu_stack_walk *csw, STACKFRAME64 *frame,
     /* sanity check */
     if (curr_mode >= stm_done) return FALSE;
 
-    TRACE("Enter: PC=%s Frame=%s Return=%s Stack=%s Mode=%s Count=%s\n",
+    TRACE("Enter: PC=%s Frame=%s Return=%s Stack=%s Mode=%s Count=%I64u\n",
           wine_dbgstr_addr(&frame->AddrPC),
           wine_dbgstr_addr(&frame->AddrFrame),
           wine_dbgstr_addr(&frame->AddrReturn),
           wine_dbgstr_addr(&frame->AddrStack),
           curr_mode == stm_start ? "start" : "ARM",
-          wine_dbgstr_longlong(curr_count));
+          curr_count);
 
     if (curr_mode == stm_start)
     {
@@ -131,13 +131,13 @@ static BOOL arm_stack_walk(struct cpu_stack_walk *csw, STACKFRAME64 *frame,
     frame->Virtual = TRUE;
     inc_curr_count();
 
-    TRACE("Leave: PC=%s Frame=%s Return=%s Stack=%s Mode=%s Count=%s FuncTable=%p\n",
+    TRACE("Leave: PC=%s Frame=%s Return=%s Stack=%s Mode=%s Count=%I64u FuncTable=%p\n",
           wine_dbgstr_addr(&frame->AddrPC),
           wine_dbgstr_addr(&frame->AddrFrame),
           wine_dbgstr_addr(&frame->AddrReturn),
           wine_dbgstr_addr(&frame->AddrStack),
           curr_mode == stm_start ? "start" : "ARM",
-          wine_dbgstr_longlong(curr_count),
+          curr_count,
           frame->FuncTableEntry);
 
     return TRUE;

dlls/dbghelp/cpu_arm64.c

@@ -93,13 +93,13 @@ static BOOL arm64_stack_walk(struct cpu_stack_walk *csw, STACKFRAME64 *frame,
     /* sanity check */
     if (curr_mode >= stm_done) return FALSE;
 
-    TRACE("Enter: PC=%s Frame=%s Return=%s Stack=%s Mode=%s Count=%s\n",
+    TRACE("Enter: PC=%s Frame=%s Return=%s Stack=%s Mode=%s Count=%I64u\n",
           wine_dbgstr_addr(&frame->AddrPC),
           wine_dbgstr_addr(&frame->AddrFrame),
           wine_dbgstr_addr(&frame->AddrReturn),
           wine_dbgstr_addr(&frame->AddrStack),
           curr_mode == stm_start ? "start" : "ARM64",
-          wine_dbgstr_longlong(curr_count));
+          curr_count);
 
     if (curr_mode == stm_start)
     {
@@ -133,13 +133,13 @@ static BOOL arm64_stack_walk(struct cpu_stack_walk *csw, STACKFRAME64 *frame,
     frame->Virtual = TRUE;
     inc_curr_count();
 
-    TRACE("Leave: PC=%s Frame=%s Return=%s Stack=%s Mode=%s Count=%s FuncTable=%p\n",
+    TRACE("Leave: PC=%s Frame=%s Return=%s Stack=%s Mode=%s Count=%I64u FuncTable=%p\n",
           wine_dbgstr_addr(&frame->AddrPC),
           wine_dbgstr_addr(&frame->AddrFrame),
           wine_dbgstr_addr(&frame->AddrReturn),
           wine_dbgstr_addr(&frame->AddrStack),
           curr_mode == stm_start ? "start" : "ARM64",
-          wine_dbgstr_longlong(curr_count),
+          curr_count,
           frame->FuncTableEntry);
 
     return TRUE;

dlls/dbghelp/cpu_i386.c

@@ -163,13 +163,13 @@ static BOOL i386_stack_walk(struct cpu_stack_walk *csw, STACKFRAME64 *frame,
     /* sanity check */
     if (curr_mode >= stm_done) return FALSE;
 
-    TRACE("Enter: PC=%s Frame=%s Return=%s Stack=%s Mode=%s Count=%s cSwitch=%p nSwitch=%p\n",
+    TRACE("Enter: PC=%s Frame=%s Return=%s Stack=%s Mode=%s Count=%I64u cSwitch=%p nSwitch=%p\n",
           wine_dbgstr_addr(&frame->AddrPC),
           wine_dbgstr_addr(&frame->AddrFrame),
           wine_dbgstr_addr(&frame->AddrReturn),
           wine_dbgstr_addr(&frame->AddrStack),
           curr_mode == stm_start ? "start" : (curr_mode == stm_16bit ? "16bit" : "32bit"),
-          wine_dbgstr_longlong(curr_count),
+          curr_count,
           (void*)(DWORD_PTR)curr_switch, (void*)(DWORD_PTR)next_switch);
 
     /* if we're at first call (which doesn't actually unwind, it just computes ReturnPC,
@@ -403,8 +403,8 @@ static BOOL i386_stack_walk(struct cpu_stack_walk *csw, STACKFRAME64 *frame,
                 frame->AddrStack.Offset = context->x86.Esp;
                 frame->AddrFrame.Offset = context->x86.Ebp;
                 if (frame->AddrReturn.Offset != context->x86.Eip)
-                    FIXME("new PC=%s different from Eip=%lx\n",
-                          wine_dbgstr_longlong(frame->AddrReturn.Offset), context->x86.Eip);
+                    FIXME("new PC=%I64x different from Eip=%lx\n",
+                          frame->AddrReturn.Offset, context->x86.Eip);
                 frame->AddrPC.Offset = context->x86.Eip;
             }
         }
@@ -493,13 +493,13 @@ static BOOL i386_stack_walk(struct cpu_stack_walk *csw, STACKFRAME64 *frame,
         frame->FuncTableEntry = NULL;
 
     inc_curr_count();
-    TRACE("Leave: PC=%s Frame=%s Return=%s Stack=%s Mode=%s Count=%s cSwitch=%p nSwitch=%p FuncTable=%p\n",
+    TRACE("Leave: PC=%s Frame=%s Return=%s Stack=%s Mode=%s Count=%I64u cSwitch=%p nSwitch=%p FuncTable=%p\n",
           wine_dbgstr_addr(&frame->AddrPC),
           wine_dbgstr_addr(&frame->AddrFrame),
           wine_dbgstr_addr(&frame->AddrReturn),
           wine_dbgstr_addr(&frame->AddrStack),
           curr_mode == stm_start ? "start" : (curr_mode == stm_16bit ? "16bit" : "32bit"),
-          wine_dbgstr_longlong(curr_count),
+          curr_count,
           (void*)(DWORD_PTR)curr_switch, (void*)(DWORD_PTR)next_switch, frame->FuncTableEntry);
 
     return TRUE;

dlls/dbghelp/cpu_x86_64.c

@@ -471,7 +471,7 @@ static BOOL default_unwind(struct cpu_stack_walk* csw, CONTEXT* context)
 {
     if (!sw_read_mem(csw, context->Rsp, &context->Rip, sizeof(DWORD64)))
     {
-        WARN("Cannot read new frame offset %s\n", wine_dbgstr_longlong(context->Rsp));
+        WARN("Cannot read new frame offset %I64x\n", context->Rsp);
         return FALSE;
     }
     context->Rsp += sizeof(DWORD64);
@@ -649,13 +649,13 @@ static BOOL x86_64_stack_walk(struct cpu_stack_walk *csw, STACKFRAME64 *frame,
     if (curr_mode >= stm_done) return FALSE;
     assert(!csw->is32);
 
-    TRACE("Enter: PC=%s Frame=%s Return=%s Stack=%s Mode=%s Count=%s\n",
+    TRACE("Enter: PC=%s Frame=%s Return=%s Stack=%s Mode=%s Count=%I64u\n",
           wine_dbgstr_addr(&frame->AddrPC),
           wine_dbgstr_addr(&frame->AddrFrame),
           wine_dbgstr_addr(&frame->AddrReturn),
           wine_dbgstr_addr(&frame->AddrStack),
           curr_mode == stm_start ? "start" : "64bit",
-          wine_dbgstr_longlong(curr_count));
+          curr_count);
 
     if (curr_mode == stm_start)
     {
@@ -705,13 +705,13 @@ static BOOL x86_64_stack_walk(struct cpu_stack_walk *csw, STACKFRAME64 *frame,
     frame->Virtual = TRUE;
     curr_count++;
 
-    TRACE("Leave: PC=%s Frame=%s Return=%s Stack=%s Mode=%s Count=%s FuncTable=%p\n",
+    TRACE("Leave: PC=%s Frame=%s Return=%s Stack=%s Mode=%s Count=%I64u FuncTable=%p\n",
           wine_dbgstr_addr(&frame->AddrPC),
           wine_dbgstr_addr(&frame->AddrFrame),
           wine_dbgstr_addr(&frame->AddrReturn),
           wine_dbgstr_addr(&frame->AddrStack),
           curr_mode == stm_start ? "start" : "64bit",
-          wine_dbgstr_longlong(curr_count),
+          curr_count,
           frame->FuncTableEntry);
 
     return TRUE;

dlls/dbghelp/dbghelp.c

@@ -104,7 +104,7 @@ BOOL validate_addr64(DWORD64 addr)
 {
     if (sizeof(void*) == sizeof(int) && (addr >> 32))
     {
-        FIXME("Unsupported address %s\n", wine_dbgstr_longlong(addr));
+        FIXME("Unsupported address %I64x\n", addr);
         SetLastError(ERROR_INVALID_PARAMETER);
         return FALSE;
     }
@@ -135,7 +135,7 @@ const char* wine_dbgstr_addr(const ADDRESS64* addr)
     switch (addr->Mode)
     {
     case AddrModeFlat:
-        return wine_dbg_sprintf("flat<%s>", wine_dbgstr_longlong(addr->Offset));
+        return wine_dbg_sprintf("flat<%I64x>", addr->Offset);
     case AddrMode1616:
         return wine_dbg_sprintf("1616<%04x:%04lx>", addr->Segment, (DWORD)addr->Offset);
     case AddrMode1632:
@@ -858,24 +858,22 @@ BOOL WINAPI SymRegisterCallback(HANDLE hProcess,
 /***********************************************************************
  *		SymRegisterCallback64 (DBGHELP.@)
  */
-BOOL WINAPI SymRegisterCallback64(HANDLE hProcess, 
+BOOL WINAPI SymRegisterCallback64(HANDLE hProcess,
                                   PSYMBOL_REGISTERED_CALLBACK64 CallbackFunction,
                                   ULONG64 UserContext)
 {
-    TRACE("(%p, %p, %s)\n", 
-          hProcess, CallbackFunction, wine_dbgstr_longlong(UserContext));
+    TRACE("(%p, %p, %I64x)\n", hProcess, CallbackFunction, UserContext);
     return sym_register_cb(hProcess, CallbackFunction, NULL, UserContext, FALSE);
 }
 
 /***********************************************************************
  *		SymRegisterCallbackW64 (DBGHELP.@)
  */
-BOOL WINAPI SymRegisterCallbackW64(HANDLE hProcess, 
+BOOL WINAPI SymRegisterCallbackW64(HANDLE hProcess,
                                    PSYMBOL_REGISTERED_CALLBACK64 CallbackFunction,
                                    ULONG64 UserContext)
 {
-    TRACE("(%p, %p, %s)\n", 
-          hProcess, CallbackFunction, wine_dbgstr_longlong(UserContext));
+    TRACE("(%p, %p, %I64x)\n", hProcess, CallbackFunction, UserContext);
     return sym_register_cb(hProcess, CallbackFunction, NULL, UserContext, TRUE);
 }
 

dlls/dbghelp/dwarf.c

@@ -588,7 +588,7 @@ static BOOL dwarf2_fill_attr(const dwarf2_parse_context_t* ctx,
 
     case DW_FORM_data8:
         attr->u.lluvalue = dwarf2_get_u8(data);
-        TRACE("data8<%s>\n", wine_dbgstr_longlong(attr->u.uvalue));
+        TRACE("data8<%Ix>\n", attr->u.uvalue);
         break;
 
     case DW_FORM_ref1:
@@ -671,7 +671,7 @@ static BOOL dwarf2_fill_attr(const dwarf2_parse_context_t* ctx,
 
     case DW_FORM_sec_offset:
         attr->u.lluvalue = dwarf2_get_addr(data, ctx->head.offset_size);
-        TRACE("sec_offset<%s>\n", wine_dbgstr_longlong(attr->u.lluvalue));
+        TRACE("sec_offset<%I64x>\n", attr->u.lluvalue);
         break;
 
     case DW_FORM_GNU_ref_alt:
@@ -3685,7 +3685,7 @@ static ULONG_PTR eval_expression(const struct module* module, struct cpu_stack_w
             tmp = 0;
             if (!sw_read_mem(csw, stack[sp], &tmp, module->format_info[DFI_DWARF]->u.dwarf2_info->word_size))
             {
-                ERR("Couldn't read memory at %s\n", wine_dbgstr_longlong(stack[sp]));
+                ERR("Couldn't read memory at %I64x\n", stack[sp]);
                 tmp = 0;
             }
             stack[sp] = tmp;
@@ -3735,7 +3735,7 @@ static ULONG_PTR eval_expression(const struct module* module, struct cpu_stack_w
             sz = dwarf2_parse_byte(&ctx);
             if (!sw_read_mem(csw, stack[sp], &tmp, sz))
             {
-                ERR("Couldn't read memory at %s\n", wine_dbgstr_longlong(stack[sp]));
+                ERR("Couldn't read memory at %I64x\n", stack[sp]);
                 tmp = 0;
             }
             /* do integral promotion */
@@ -3769,7 +3769,7 @@ static void apply_frame_state(const struct module* module, struct cpu_stack_walk
         *cfa = eval_expression(module, csw, (const unsigned char*)state->cfa_offset, context);
         if (!sw_read_mem(csw, *cfa, cfa, csw->cpu->word_size))
         {
-            WARN("Couldn't read memory at %s\n", wine_dbgstr_longlong(*cfa));
+            WARN("Couldn't read memory at %I64x\n", *cfa);
             return;
         }
         break;

dlls/dbghelp/elf_module.c

@@ -860,10 +860,10 @@ static void elf_finish_stabs_info(struct module* module, const struct hash_table
             {
                 if (((struct symt_function*)sym)->address != elf_info->elf_addr &&
                     ((struct symt_function*)sym)->address != elf_info->elf_addr + symp->st_value)
-                    FIXME("Changing address for %p/%s!%s from %08Ix to %s\n",
+                    FIXME("Changing address for %p/%s!%s from %08Ix to %I64x\n",
                           sym, debugstr_w(module->modulename), sym->hash_elt.name,
                           ((struct symt_function*)sym)->address,
-                          wine_dbgstr_longlong(elf_info->elf_addr + symp->st_value));
+                          elf_info->elf_addr + symp->st_value);
                 if (((struct symt_function*)sym)->size && ((struct symt_function*)sym)->size != symp->st_size)
                     FIXME("Changing size for %p/%s!%s from %08Ix to %08x\n",
                           sym, debugstr_w(module->modulename), sym->hash_elt.name,
@@ -889,10 +889,10 @@ static void elf_finish_stabs_info(struct module* module, const struct hash_table
                 {
                     if (((struct symt_data*)sym)->u.var.offset != elf_info->elf_addr &&
                         ((struct symt_data*)sym)->u.var.offset != elf_info->elf_addr + symp->st_value)
-                        FIXME("Changing address for %p/%s!%s from %08Ix to %s\n",
+                        FIXME("Changing address for %p/%s!%s from %08Ix to %I64x\n",
                               sym, debugstr_w(module->modulename), sym->hash_elt.name,
                               ((struct symt_function*)sym)->address,
-                              wine_dbgstr_longlong(elf_info->elf_addr + symp->st_value));
+                              elf_info->elf_addr + symp->st_value);
                     ((struct symt_data*)sym)->u.var.offset = elf_info->elf_addr + symp->st_value;
                     ((struct symt_data*)sym)->kind = elf_is_local_symbol(symp->st_info) ?
                         DataIsFileStatic : DataIsGlobal;

dlls/dbghelp/macho_module.c

@@ -1154,11 +1154,11 @@ static void macho_finish_stabs(struct module* module, struct hash_table* ht_symt
                 symt_get_info(module, &sym->symt, TI_GET_LENGTH,   &size);
                 symt_get_info(module, &sym->symt, TI_GET_DATAKIND, &kind);
                 if (size && kind == (ste->is_global ? DataIsGlobal : DataIsFileStatic))
-                    FIXME("Duplicate in %s: %s<%08Ix> %s<%s-%s>\n",
+                    FIXME("Duplicate in %s: %s<%08Ix> %s<%I64x-%I64x>\n",
                           debugstr_w(module->modulename),
                           ste->ht_elt.name, ste->addr,
                           sym->hash_elt.name,
-                          wine_dbgstr_longlong(addr), wine_dbgstr_longlong(size));
+                          addr, size);
             }
         }
     }
@@ -1622,7 +1622,7 @@ static BOOL macho_enum_modules_internal(const struct process* pcs,
     }
     if (!image_infos.infos64.infoArray)
         goto done;
-    TRACE("Process has %u image infos at %s\n", image_infos.infos64.infoArrayCount, wine_dbgstr_longlong(image_infos.infos64.infoArray));
+    TRACE("Process has %u image infos at %I64x\n", image_infos.infos64.infoArrayCount, image_infos.infos64.infoArray);
 
     if (pcs->is_64bit)
         len = sizeof(info_array->info64);

dlls/dbghelp/module.c

@@ -186,10 +186,8 @@ struct module* module_new(struct process* pcs, const WCHAR* name,
     module->next = pcs->lmodules;
     pcs->lmodules = module;
 
-    TRACE("=> %s %s-%s %s\n",
-          get_module_type(type, virtual),
-	  wine_dbgstr_longlong(mod_addr), wine_dbgstr_longlong(mod_addr + size),
-          debugstr_w(name));
+    TRACE("=> %s %I64x-%I64x %s\n",
+          get_module_type(type, virtual), mod_addr, mod_addr + size, debugstr_w(name));
 
     pool_init(&module->pool, 65536);
 
@@ -858,9 +856,9 @@ DWORD64 WINAPI  SymLoadModuleEx(HANDLE hProcess, HANDLE hFile, PCSTR ImageName,
     unsigned    len;
     DWORD64     ret;
 
-    TRACE("(%p %p %s %s %s %08lx %p %08lx)\n",
+    TRACE("(%p %p %s %s %I64x %08lx %p %08lx)\n",
           hProcess, hFile, debugstr_a(ImageName), debugstr_a(ModuleName),
-          wine_dbgstr_longlong(BaseOfDll), DllSize, Data, Flags);
+          BaseOfDll, DllSize, Data, Flags);
 
     if (ImageName)
     {
@@ -895,9 +893,9 @@ DWORD64 WINAPI  SymLoadModuleExW(HANDLE hProcess, HANDLE hFile, PCWSTR wImageNam
     struct module*      module = NULL;
     struct module*      altmodule;
 
-    TRACE("(%p %p %s %s %s %08lx %p %08lx)\n",
+    TRACE("(%p %p %s %s %I64x %08lx %p %08lx)\n",
           hProcess, hFile, debugstr_w(wImageName), debugstr_w(wModuleName),
-          wine_dbgstr_longlong(BaseOfDll), SizeOfDll, Data, Flags);
+          BaseOfDll, SizeOfDll, Data, Flags);
 
     if (Data)
         FIXME("Unsupported load data parameter %p for %s\n",
@@ -1402,7 +1400,7 @@ BOOL  WINAPI SymGetModuleInfoW64(HANDLE hProcess, DWORD64 dwAddr,
     struct module*      module;
     IMAGEHLP_MODULEW64  miw64;
 
-    TRACE("%p %s %p\n", hProcess, wine_dbgstr_longlong(dwAddr), ModuleInfo);
+    TRACE("%p %I64x %p\n", hProcess, dwAddr, ModuleInfo);
 
     if (!pcs) return FALSE;
     if (ModuleInfo->SizeOfStruct > sizeof(*ModuleInfo)) return FALSE;

dlls/dbghelp/pe_module.c

@@ -407,11 +407,11 @@ static BOOL pe_locate_with_coff_symbol_table(struct module* module)
                     sym->u.var.kind == loc_absolute &&
                     !strcmp(sym->hash_elt.name, name))
                 {
-                    TRACE("Changing absolute address for %d.%s: %Ix -> %s\n",
+                    TRACE("Changing absolute address for %d.%s: %Ix -> %I64x\n",
                           isym->SectionNumber, name, sym->u.var.offset,
-                          wine_dbgstr_longlong(module->module.BaseOfImage +
-                                               fmap->u.pe.sect[isym->SectionNumber - 1].shdr.VirtualAddress +
-                                               isym->Value));
+                          module->module.BaseOfImage +
+                          fmap->u.pe.sect[isym->SectionNumber - 1].shdr.VirtualAddress +
+                          isym->Value);
                     sym->u.var.offset = module->module.BaseOfImage +
                         fmap->u.pe.sect[isym->SectionNumber - 1].shdr.VirtualAddress + isym->Value;
                     break;

dlls/dbghelp/source.c

@@ -293,8 +293,8 @@ BOOL WINAPI SymEnumSourceLines(HANDLE hProcess, ULONG64 base, PCSTR obj,
                                PSYM_ENUMLINES_CALLBACK EnumLinesCallback,
                                PVOID UserContext)
 {
-    FIXME("%p %s %s %s %lu %lu %p %p: stub!\n",
-          hProcess, wine_dbgstr_longlong(base), debugstr_a(obj), debugstr_a(file),
+    FIXME("%p %I64x %s %s %lu %lu %p %p: stub!\n",
+          hProcess, base, debugstr_a(obj), debugstr_a(file),
           line, flags, EnumLinesCallback, UserContext);
     SetLastError(ERROR_NOT_SUPPORTED);
     return FALSE;
@@ -309,8 +309,8 @@ BOOL WINAPI SymEnumSourceLinesW(HANDLE hProcess, ULONG64 base, PCWSTR obj,
                                 PSYM_ENUMLINES_CALLBACKW EnumLinesCallback,
                                 PVOID UserContext)
 {
-    FIXME("%p %s %s %s %lu %lu %p %p: stub!\n",
-          hProcess, wine_dbgstr_longlong(base), debugstr_w(obj), debugstr_w(file),
+    FIXME("%p %I64x %s %s %lu %lu %p %p: stub!\n",
+          hProcess, base, debugstr_w(obj), debugstr_w(file),
           line, flags, EnumLinesCallback, UserContext);
     SetLastError(ERROR_NOT_SUPPORTED);
     return FALSE;
@@ -323,8 +323,8 @@ BOOL WINAPI SymEnumSourceLinesW(HANDLE hProcess, ULONG64 base, PCWSTR obj,
 BOOL WINAPI SymGetSourceFileToken(HANDLE hProcess, ULONG64 base,
                                   PCSTR src, PVOID* token, DWORD* size)
 {
-    FIXME("%p %s %s %p %p: stub!\n",
-          hProcess, wine_dbgstr_longlong(base), debugstr_a(src), token, size);
+    FIXME("%p %I64x %s %p %p: stub!\n",
+          hProcess, base, debugstr_a(src), token, size);
     SetLastError(ERROR_NOT_SUPPORTED);
     return FALSE;
 }
@@ -336,8 +336,8 @@ BOOL WINAPI SymGetSourceFileToken(HANDLE hProcess, ULONG64 base,
 BOOL WINAPI SymGetSourceFileTokenW(HANDLE hProcess, ULONG64 base,
                                    PCWSTR src, PVOID* token, DWORD* size)
 {
-    FIXME("%p %s %s %p %p: stub!\n",
-          hProcess, wine_dbgstr_longlong(base), debugstr_w(src), token, size);
+    FIXME("%p %I64x %s %p %p: stub!\n",
+          hProcess, base, debugstr_w(src), token, size);
     SetLastError(ERROR_NOT_SUPPORTED);
     return FALSE;
 }

dlls/dbghelp/stack.c

@@ -55,8 +55,8 @@ static DWORD64 WINAPI addr_to_linear(HANDLE hProcess, HANDLE hThread, ADDRESS64*
         FIXME("Unsupported (yet) mode (%x)\n", addr->Mode);
         return 0;
     }
-    FIXME("Failed to linearize address %04x:%s (mode %x)\n",
-          addr->Segment, wine_dbgstr_longlong(addr->Offset), addr->Mode);
+    FIXME("Failed to linearize address %04x:%I64x (mode %x)\n",
+          addr->Segment, addr->Offset, addr->Mode);
     return 0;
 }
 
@@ -362,7 +362,7 @@ BOOL WINAPI SymRegisterFunctionEntryCallback64(HANDLE hProc,
                                                PSYMBOL_FUNCENTRY_CALLBACK64 cb,
                                                ULONG64 user)
 {
-    FIXME("(%p %p %s): stub!\n", hProc, cb, wine_dbgstr_longlong(user));
+    FIXME("(%p %p %I64x): stub!\n", hProc, cb, user);
     SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
     return FALSE;
 }

dlls/dbghelp/symbol.c

@@ -303,9 +303,8 @@ struct symt_data* symt_new_global_variable(struct module* module,
         if (type && size && symt_get_info(module, type, TI_GET_LENGTH, &tsz))
         {
             if (tsz != size)
-                FIXME("Size mismatch for %s.%s between type (%s) and src (%Iu)\n",
-                      debugstr_w(module->modulename), name,
-                      wine_dbgstr_longlong(tsz), size);
+                FIXME("Size mismatch for %s.%s between type (%I64u) and src (%Iu)\n",
+                      debugstr_w(module->modulename), name, tsz, size);
         }
         symt_add_module_ht(module, (struct symt_ht*)sym);
         p = vector_add(compiland ? &compiland->vchildren : &module->top->vchildren, &module->pool);
@@ -887,9 +886,8 @@ static void symt_fill_sym_info(struct module_pair* pair,
     else
         symbol_setname(sym_info, name);
 
-    TRACE_(dbghelp_symt)("%p => %s %lu %s\n",
-                         sym, sym_info->Name, sym_info->Size,
-                         wine_dbgstr_longlong(sym_info->Address));
+    TRACE_(dbghelp_symt)("%p => %s %lu %I64x\n",
+                         sym, sym_info->Name, sym_info->Size, sym_info->Address);
 }
 
 struct sym_enum
@@ -1414,9 +1412,8 @@ BOOL WINAPI SymEnumSymbols(HANDLE hProcess, ULONG64 BaseOfDll, PCSTR Mask,
     BOOL                ret;
     PWSTR               maskW = NULL;
 
-    TRACE("(%p %s %s %p %p)\n",
-          hProcess, wine_dbgstr_longlong(BaseOfDll), debugstr_a(Mask),
-          EnumSymbolsCallback, UserContext);
+    TRACE("(%p %I64x %s %p %p)\n",
+          hProcess, BaseOfDll, debugstr_a(Mask), EnumSymbolsCallback, UserContext);
 
     if (Mask)
     {
@@ -2489,10 +2486,9 @@ BOOL WINAPI SymSearch(HANDLE hProcess, ULONG64 BaseOfDll, DWORD Index,
     LPWSTR      maskW = NULL;
     BOOLEAN     ret;
 
-    TRACE("(%p %s %lu %lu %s %s %p %p %lx)\n",
-          hProcess, wine_dbgstr_longlong(BaseOfDll), Index, SymTag, Mask,
-          wine_dbgstr_longlong(Address), EnumSymbolsCallback,
-          UserContext, Options);
+    TRACE("(%p %I64x %lu %lu %s %I64x %p %p %lx)\n",
+          hProcess, BaseOfDll, Index, SymTag, Mask,
+          Address, EnumSymbolsCallback, UserContext, Options);
 
     if (Mask)
     {
@@ -2518,10 +2514,9 @@ BOOL WINAPI SymSearchW(HANDLE hProcess, ULONG64 BaseOfDll, DWORD Index,
 {
     struct sym_enumW    sew;
 
-    TRACE("(%p %s %lu %lu %s %s %p %p %lx)\n",
-          hProcess, wine_dbgstr_longlong(BaseOfDll), Index, SymTag, debugstr_w(Mask),
-          wine_dbgstr_longlong(Address), EnumSymbolsCallback,
-          UserContext, Options);
+    TRACE("(%p %I64x %lu %lu %s %I64x %p %p %lx)\n",
+          hProcess, BaseOfDll, Index, SymTag, debugstr_w(Mask),
+          Address, EnumSymbolsCallback, UserContext, Options);
 
     sew.ctx = UserContext;
     sew.cb = EnumSymbolsCallback;
@@ -2540,7 +2535,7 @@ BOOL WINAPI SymAddSymbol(HANDLE hProcess, ULONG64 BaseOfDll, PCSTR name,
 {
     struct module_pair  pair;
 
-    TRACE("(%p %s %s %lu)\n", hProcess, wine_dbgstr_a(name), wine_dbgstr_longlong(addr), size);
+    TRACE("(%p %s %I64x %lu)\n", hProcess, wine_dbgstr_a(name), addr, size);
 
     if (!module_init_pair(&pair, hProcess, BaseOfDll)) return FALSE;
 
@@ -2556,7 +2551,7 @@ BOOL WINAPI SymAddSymbolW(HANDLE hProcess, ULONG64 BaseOfDll, PCWSTR nameW,
 {
     char       name[MAX_SYM_NAME];
 
-    TRACE("(%p %s %s %lu)\n", hProcess, wine_dbgstr_w(nameW), wine_dbgstr_longlong(addr), size);
+    TRACE("(%p %s %I64x %lu)\n", hProcess, wine_dbgstr_w(nameW), addr, size);
 
     WideCharToMultiByte(CP_ACP, 0, nameW, -1, name, ARRAY_SIZE(name), NULL, NULL);
 
@@ -2663,8 +2658,8 @@ BOOL WINAPI SymGetLineFromNameW64(HANDLE hProcess, PCWSTR ModuleName, PCWSTR Fil
  */
 BOOL WINAPI SymFromIndex(HANDLE hProcess, ULONG64 BaseOfDll, DWORD index, PSYMBOL_INFO symbol)
 {
-    FIXME("hProcess = %p, BaseOfDll = %s, index = %ld, symbol = %p\n",
-          hProcess, wine_dbgstr_longlong(BaseOfDll), index, symbol);
+    FIXME("hProcess = %p, BaseOfDll = %I64x, index = %ld, symbol = %p\n",
+          hProcess, BaseOfDll, index, symbol);
 
     return FALSE;
 }
@@ -2675,8 +2670,8 @@ BOOL WINAPI SymFromIndex(HANDLE hProcess, ULONG64 BaseOfDll, DWORD index, PSYMBO
  */
 BOOL WINAPI SymFromIndexW(HANDLE hProcess, ULONG64 BaseOfDll, DWORD index, PSYMBOL_INFOW symbol)
 {
-    FIXME("hProcess = %p, BaseOfDll = %s, index = %ld, symbol = %p\n",
-          hProcess, wine_dbgstr_longlong(BaseOfDll), index, symbol);
+    FIXME("hProcess = %p, BaseOfDll = %I64x, index = %ld, symbol = %p\n",
+          hProcess, BaseOfDll, index, symbol);
 
     return FALSE;
 }

dlls/dbghelp/type.c

@@ -479,9 +479,7 @@ BOOL WINAPI SymEnumTypes(HANDLE hProcess, ULONG64 BaseOfDll,
     DWORD64             size;
     unsigned int        i;
 
-    TRACE("(%p %s %p %p)\n",
-          hProcess, wine_dbgstr_longlong(BaseOfDll), EnumSymbolsCallback,
-          UserContext);
+    TRACE("(%p %I64x %p %p)\n", hProcess, BaseOfDll, EnumSymbolsCallback, UserContext);
 
     if (!module_init_pair(&pair, hProcess, BaseOfDll)) return FALSE;