Everywhere: Prefix hexadecimal numbers with 0x

Depending on the values it might be difficult to figure out whether a
value is decimal or hexadecimal. So let's make this more obvious. Also
this allows copying and pasting those numbers into GNOME calculator and
probably also other apps which auto-detect the base.

Kernel/Arch/x86/common/Interrupts.cpp

@@ -192,21 +192,21 @@ static void dump(const RegisterState& regs)
 
  dbgln("Exception code: {:04x} (isr: {:04x})", regs.exception_code, regs.isr_number);
 #if ARCH(I386)
- dbgln(" pc={:04x}:{:08x} eflags={:08x}", (u16)regs.cs, regs.eip, regs.eflags);
- dbgln(" stack={:04x}:{:08x}", ss, esp);
- dbgln(" ds={:04x} es={:04x} fs={:04x} gs={:04x}", (u16)regs.ds, (u16)regs.es, (u16)regs.fs, (u16)regs.gs);
- dbgln(" eax={:08x} ebx={:08x} ecx={:08x} edx={:08x}", regs.eax, regs.ebx, regs.ecx, regs.edx);
- dbgln(" ebp={:08x} esp={:08x} esi={:08x} edi={:08x}", regs.ebp, regs.esp, regs.esi, regs.edi);
- dbgln(" cr0={:08x} cr2={:08x} cr3={:08x} cr4={:08x}", read_cr0(), read_cr2(), read_cr3(), read_cr4());
+ dbgln(" pc={:#04x}:{:p} eflags={:p}", (u16)regs.cs, regs.eip, regs.eflags);
+ dbgln(" stack={:#04x}:{:p}", ss, esp);
+ dbgln(" ds={:#04x} es={:#04x} fs={:#04x} gs={:#04x}", (u16)regs.ds, (u16)regs.es, (u16)regs.fs, (u16)regs.gs);
+ dbgln(" eax={:p} ebx={:p} ecx={:p} edx={:p}", regs.eax, regs.ebx, regs.ecx, regs.edx);
+ dbgln(" ebp={:p} esp={:p} esi={:p} edi={:p}", regs.ebp, regs.esp, regs.esi, regs.edi);
+ dbgln(" cr0={:p} cr2={:p} cr3={:p} cr4={:p}", read_cr0(), read_cr2(), read_cr3(), read_cr4());
 #else
- dbgln(" pc={:04x}:{:16x} rflags={:16x}", (u16)regs.cs, regs.rip, regs.rflags);
- dbgln(" stack={:16x}", rsp);
+ dbgln(" pc={:#04x}:{:p} rflags={:p}", (u16)regs.cs, regs.rip, regs.rflags);
+ dbgln(" stack={:p}", rsp);
  // FIXME: Add fs_base and gs_base here
- dbgln(" rax={:16x} rbx={:16x} rcx={:16x} rdx={:16x}", regs.rax, regs.rbx, regs.rcx, regs.rdx);
- dbgln(" rbp={:16x} rsp={:16x} rsi={:16x} rdi={:16x}", regs.rbp, regs.rsp, regs.rsi, regs.rdi);
- dbgln(" r8={:16x} r9={:16x} r10={:16x} r11={:16x}", regs.r8, regs.r9, regs.r10, regs.r11);
- dbgln(" r12={:16x} r13={:16x} r14={:16x} r15={:16x}", regs.r12, regs.r13, regs.r14, regs.r15);
- dbgln(" cr0={:16x} cr2={:16x} cr3={:16x} cr4={:16x}", read_cr0(), read_cr2(), read_cr3(), read_cr4());
+ dbgln(" rax={:p} rbx={:p} rcx={:p} rdx={:p}", regs.rax, regs.rbx, regs.rcx, regs.rdx);
+ dbgln(" rbp={:p} rsp={:p} rsi={:p} rdi={:p}", regs.rbp, regs.rsp, regs.rsi, regs.rdi);
+ dbgln(" r8={:p} r9={:p} r10={:p} r11={:p}", regs.r8, regs.r9, regs.r10, regs.r11);
+ dbgln(" r12={:p} r13={:p} r14={:p} r15={:p}", regs.r12, regs.r13, regs.r14, regs.r15);
+ dbgln(" cr0={:p} cr2={:p} cr3={:p} cr4={:p}", read_cr0(), read_cr2(), read_cr3(), read_cr4());
 #endif
 }
 

Kernel/Bus/USB/USBPipe.cpp

@@ -65,7 +65,7 @@ KResultOr<size_t> Pipe::control_transfer(u8 request_type, u8 request, u16 value,
 
  transfer->set_setup_packet(usb_request);
 
- dbgln_if(USB_DEBUG, "Pipe: Transfer allocated @ {:08x}", transfer->buffer_physical());
+ dbgln_if(USB_DEBUG, "Pipe: Transfer allocated @ {}", transfer->buffer_physical());
  auto transfer_len_or_error = UHCIController::the().submit_control_transfer(*transfer);
 
  if (transfer_len_or_error.is_error())

Kernel/Scheduler.cpp

@@ -295,12 +295,7 @@ bool Scheduler::context_switch(Thread* thread)
  from_thread->set_state(Thread::Runnable);
 
 #ifdef LOG_EVERY_CONTEXT_SWITCH
- const auto msg =
-# if ARCH(I386)
- "Scheduler[{}]: {} -> {} [prio={}] {:04x}:{:08x}";
-# else
- "Scheduler[{}]: {} -> {} [prio={}] {:04x}:{:16x}";
-# endif
+ const auto msg = "Scheduler[{}]: {} -> {} [prio={}] {:#04x}:{:p}";
 
  dbgln(msg,
  Processor::id(), from_thread->tid().value(),

Kernel/Syscall.cpp

@@ -109,7 +109,7 @@ KResultOr<FlatPtr> handle(RegisterState& regs, FlatPtr function, FlatPtr arg1, F
  current_thread->did_syscall();
 
  if (function >= Function::__Count) {
- dbgln("Unknown syscall {} requested ({:08x}, {:08x}, {:08x})", function, arg1, arg2, arg3);
+ dbgln("Unknown syscall {} requested ({:p}, {:p}, {:p})", function, arg1, arg2, arg3);
  return ENOSYS;
  }
 

Kernel/Syscalls/fork.cpp

@@ -64,7 +64,7 @@ KResultOr<FlatPtr> Process::sys$fork(RegisterState& regs)
  child_regs.gs = regs.gs;
  child_regs.ss = regs.userspace_ss;
 
- dbgln_if(FORK_DEBUG, "fork: child will begin executing at {:04x}:{:08x} with stack {:04x}:{:08x}, kstack {:04x}:{:08x}",
+ dbgln_if(FORK_DEBUG, "fork: child will begin executing at {:#04x}:{:p} with stack {:#04x}:{:p}, kstack {:#04x}:{:p}",
  child_regs.cs, child_regs.eip, child_regs.ss, child_regs.esp, child_regs.ss0, child_regs.esp0);
 #else
  auto& child_regs = child_first_thread->m_regs;
@@ -88,7 +88,7 @@ KResultOr<FlatPtr> Process::sys$fork(RegisterState& regs)
  child_regs.rip = regs.rip;
  child_regs.cs = regs.cs;
 
- dbgln_if(FORK_DEBUG, "fork: child will begin executing at {:04x}:{:16x} with stack {:08x}, kstack {:08x}",
+ dbgln_if(FORK_DEBUG, "fork: child will begin executing at {:#04x}:{:p} with stack {:p}, kstack {:p}",
  child_regs.cs, child_regs.rip, child_regs.rsp, child_regs.rsp0);
 #endif
 

Kernel/Thread.cpp

@@ -1030,11 +1030,7 @@ DispatchSignalResult Thread::dispatch_signal(u8 signal)
  auto signal_trampoline_addr = process.signal_trampoline().get();
  regs.set_ip_reg(signal_trampoline_addr);
 
-#if ARCH(I386)
- dbgln_if(SIGNAL_DEBUG, "Thread in state '{}' has been primed with signal handler {:04x}:{:08x} to deliver {}", state_string(), m_regs.cs, m_regs.ip(), signal);
-#else
- dbgln_if(SIGNAL_DEBUG, "Thread in state '{}' has been primed with signal handler {:04x}:{:16x} to deliver {}", state_string(), m_regs.cs, m_regs.ip(), signal);
-#endif
+ dbgln_if(SIGNAL_DEBUG, "Thread in state '{}' has been primed with signal handler {:#04x}:{:p} to deliver {}", state_string(), m_regs.cs, m_regs.ip(), signal);
 
  return DispatchSignalResult::Continue;
 }

Kernel/VM/MemoryManager.cpp

@@ -1121,10 +1121,10 @@ void MemoryManager::unregister_region(Region& region)
 void MemoryManager::dump_kernel_regions()
 {
  dbgln("Kernel regions:");
- dbgln("BEGIN END  SIZE  ACCESS  NAME");
+ dbgln("BEGIN  END  SIZE ACCESS NAME");
  ScopedSpinLock lock(s_mm_lock);
  for (auto& region : m_kernel_regions) {
- dbgln("{:08x} -- {:08x} {:08x} {:c}{:c}{:c}{:c}{:c}{:c} {}",
+ dbgln("{:p} -- {:p} {:p} {:c}{:c}{:c}{:c}{:c}{:c} {}",
  region.vaddr().get(),
  region.vaddr().offset(region.size() - 1).get(),
  region.size(),

Kernel/VM/Range.h

@@ -63,6 +63,6 @@ template<>
 struct AK::Formatter<Kernel::Range> : Formatter<FormatString> {
  void format(FormatBuilder& builder, Kernel::Range value)
  {
- return Formatter<FormatString>::format(builder, "{} - {} (size 0x{:08x})", value.base().as_ptr(), value.base().offset(value.size() - 1).as_ptr(), value.size());
+ return Formatter<FormatString>::format(builder, "{} - {} (size {:p})", value.base().as_ptr(), value.base().offset(value.size() - 1).as_ptr(), value.size());
  }
 };

Kernel/VM/Space.cpp

@@ -316,13 +316,13 @@ KResultOr<Vector<Region*, 2>> Space::try_split_region_around_range(const Region&
 void Space::dump_regions()
 {
  dbgln("Process regions:");
- dbgln("BEGIN END  SIZE  ACCESS  NAME");
+ dbgln("BEGIN  END  SIZE ACCESS NAME");
 
  ScopedSpinLock lock(m_lock);
 
  for (auto& sorted_region : m_regions) {
  auto& region = *sorted_region;
- dbgln("{:08x} -- {:08x} {:08x} {:c}{:c}{:c}{:c}{:c}{:c} {}", region.vaddr().get(), region.vaddr().offset(region.size() - 1).get(), region.size(),
+ dbgln("{:p} -- {:p} {:p} {:c}{:c}{:c}{:c}{:c}{:c} {}", region.vaddr().get(), region.vaddr().offset(region.size() - 1).get(), region.size(),
  region.is_readable() ? 'R' : ' ',
  region.is_writable() ? 'W' : ' ',
  region.is_executable() ? 'X' : ' ',

Userland/Applications/CrashReporter/main.cpp

@@ -86,21 +86,15 @@ static TitleAndText build_cpu_registers(const ELF::Core::ThreadInfo& thread_info
  StringBuilder builder;
 
 #if ARCH(I386)
- builder.appendff("eax={:08x} ebx={:08x} ecx={:08x} edx={:08x}", regs.eax, regs.ebx, regs.ecx, regs.edx);
- builder.append('\n');
- builder.appendff("ebp={:08x} esp={:08x} esi={:08x} edi={:08x}", regs.ebp, regs.esp, regs.esi, regs.edi);
- builder.append('\n');
- builder.appendff("eip={:08x} eflags={:08x}", regs.eip, regs.eflags);
+ builder.appendff("eax={:p} ebx={:p} ecx={:p} edx={:p}\n", regs.eax, regs.ebx, regs.ecx, regs.edx);
+ builder.appendff("ebp={:p} esp={:p} esi={:p} edi={:p}\n", regs.ebp, regs.esp, regs.esi, regs.edi);
+ builder.appendff("eip={:p} eflags={:p}", regs.eip, regs.eflags);
 #else
- builder.appendff("rax={:16x} rbx={:16x} rcx={:16x} rdx={:16x}", regs.rax, regs.rbx, regs.rcx, regs.rdx);
- builder.append('\n');
- builder.appendff("rbp={:16x} rsp={:16x} rsi={:16x} rdi={:16x}", regs.rbp, regs.rsp, regs.rsi, regs.rdi);
- builder.append('\n');
- builder.appendff(" r8={:16x} r9={:16x} r10={:16x} r11={:16x}", regs.r8, regs.r9, regs.r10, regs.r11);
- builder.append('\n');
- builder.appendff("r12={:16x} r13={:16x} r14={:16x} r15={:16x}", regs.r12, regs.r13, regs.r14, regs.r15);
- builder.append('\n');
- builder.appendff("rip={:16x} rflags={:16x}", regs.rip, regs.rflags);
+ builder.appendff("rax={:p} rbx={:p} rcx={:p} rdx={:p}\n", regs.rax, regs.rbx, regs.rcx, regs.rdx);
+ builder.appendff("rbp={:p} rsp={:p} rsi={:p} rdi={:p}\n", regs.rbp, regs.rsp, regs.rsi, regs.rdi);
+ builder.appendff(" r8={:p} r9={:p} r10={:p} r11={:p}\n", regs.r8, regs.r9, regs.r10, regs.r11);
+ builder.appendff("r12={:p} r13={:p} r14={:p} r15={:p}\n", regs.r12, regs.r13, regs.r14, regs.r15);
+ builder.appendff("rip={:p} rflags={:p}", regs.rip, regs.rflags);
 #endif
 
  return {

Userland/Applications/Debugger/main.cpp

@@ -39,13 +39,13 @@ static void handle_sigint(int)
 static void handle_print_registers(const PtraceRegisters& regs)
 {
 #if ARCH(I386)
- outln("eax={:08x} ebx={:08x} ecx={:08x} edx={:08x}", regs.eax, regs.ebx, regs.ecx, regs.edx);
- outln("esp={:08x} ebp={:08x} esi={:08x} edi={:08x}", regs.esp, regs.ebp, regs.esi, regs.edi);
- outln("eip={:08x} eflags={:08x}", regs.eip, regs.eflags);
+ outln("eax={:p} ebx={:p} ecx={:p} edx={:p}", regs.eax, regs.ebx, regs.ecx, regs.edx);
+ outln("esp={:p} ebp={:p} esi={:p} edi={:p}", regs.esp, regs.ebp, regs.esi, regs.edi);
+ outln("eip={:p} eflags={:p}", regs.eip, regs.eflags);
 #else
- outln("rax={:016x} rbx={:016x} rcx={:016x} rdx={:016x}", regs.rax, regs.rbx, regs.rcx, regs.rdx);
- outln("rsp={:016x} rbp={:016x} rsi={:016x} rdi={:016x}", regs.rsp, regs.rbp, regs.rsi, regs.rdi);
- outln("rip={:016x} rflags={:08x}", regs.rip, regs.rflags);
+ outln("rax={:p} rbx={:p} rcx={:p} rdx={:p}", regs.rax, regs.rbx, regs.rcx, regs.rdx);
+ outln("rsp={:p} rbp={:p} rsi={:p} rdi={:p}", regs.rsp, regs.rbp, regs.rsi, regs.rdi);
+ outln("rip={:p} rflags={:p}", regs.rip, regs.rflags);
 #endif
 }
 

Userland/DevTools/HackStudio/Debugger/RegistersModel.cpp

@@ -87,7 +87,7 @@ GUI::Variant RegistersModel::data(const GUI::ModelIndex& index, GUI::ModelRole r
  if (index.column() == Column::Register)
  return reg.name;
  if (index.column() == Column::Value)
- return String::formatted("{:08x}", reg.value);
+ return String::formatted("{:p}", reg.value);
  return {};
  }
  return {};

Userland/DevTools/UserspaceEmulator/SoftCPU.cpp

@@ -79,9 +79,9 @@ SoftCPU::SoftCPU(Emulator& emulator)
 
 void SoftCPU::dump() const
 {
- outln(" eax={:08x} ebx={:08x} ecx={:08x} edx={:08x} ebp={:08x} esp={:08x} esi={:08x} edi={:08x} o={:d} s={:d} z={:d} a={:d} p={:d} c={:d}",
+ outln(" eax={:p} ebx={:p} ecx={:p} edx={:p} ebp={:p} esp={:p} esi={:p} edi={:p} o={:d} s={:d} z={:d} a={:d} p={:d} c={:d}",
  eax(), ebx(), ecx(), edx(), ebp(), esp(), esi(), edi(), of(), sf(), zf(), af(), pf(), cf());
- outln("#eax={:08x} #ebx={:08x} #ecx={:08x} #edx={:08x} #ebp={:08x} #esp={:08x} #esi={:08x} #edi={:08x} #f={}",
+ outln("#eax={:p} #ebx={:p} #ecx={:p} #edx={:p} #ebp={:p} #esp={:p} #esi={:p} #edi={:p} #f={}",
  eax().shadow(), ebx().shadow(), ecx().shadow(), edx().shadow(), ebp().shadow(), esp().shadow(), esi().shadow(), edi().shadow(), m_flags_tainted);
  fflush(stdout);
 }
@@ -106,88 +106,88 @@ ValueWithShadow<u8> SoftCPU::read_memory8(X86::LogicalAddress address)
 {
  VERIFY(address.selector() == 0x1b || address.selector() == 0x23 || address.selector() == 0x2b);
  auto value = m_emulator.mmu().read8(address);
- outln_if(MEMORY_DEBUG, "\033[36;1mread_memory8: @{:04x}:{:08x} -> {:02x} ({:02x})\033[0m", address.selector(), address.offset(), value, value.shadow());
+ outln_if(MEMORY_DEBUG, "\033[36;1mread_memory8: @{:#04x}:{:p} -> {:#02x} ({:#02x})\033[0m", address.selector(), address.offset(), value, value.shadow());
  return value;
 }
 
 ValueWithShadow<u16> SoftCPU::read_memory16(X86::LogicalAddress address)
 {
  VERIFY(address.selector() == 0x1b || address.selector() == 0x23 || address.selector() == 0x2b);
  auto value = m_emulator.mmu().read16(address);
- outln_if(MEMORY_DEBUG, "\033[36;1mread_memory16: @{:04x}:{:08x} -> {:04x} ({:04x})\033[0m", address.selector(), address.offset(), value, value.shadow());
+ outln_if(MEMORY_DEBUG, "\033[36;1mread_memory16: @{:#04x}:{:p} -> {:#04x} ({:#04x})\033[0m", address.selector(), address.offset(), value, value.shadow());
  return value;
 }
 
 ValueWithShadow<u32> SoftCPU::read_memory32(X86::LogicalAddress address)
 {
  VERIFY(address.selector() == 0x1b || address.selector() == 0x23 || address.selector() == 0x2b);
  auto value = m_emulator.mmu().read32(address);
- outln_if(MEMORY_DEBUG, "\033[36;1mread_memory32: @{:04x}:{:08x} -> {:08x} ({:08x})\033[0m", address.selector(), address.offset(), value, value.shadow());
+ outln_if(MEMORY_DEBUG, "\033[36;1mread_memory32: @{:#04x}:{:p} -> {:#08x} ({:#08x})\033[0m", address.selector(), address.offset(), value, value.shadow());
  return value;
 }
 
 ValueWithShadow<u64> SoftCPU::read_memory64(X86::LogicalAddress address)
 {
  VERIFY(address.selector() == 0x1b || address.selector() == 0x23 || address.selector() == 0x2b);
  auto value = m_emulator.mmu().read64(address);
- outln_if(MEMORY_DEBUG, "\033[36;1mread_memory64: @{:04x}:{:08x} -> {:016x} ({:016x})\033[0m", address.selector(), address.offset(), value, value.shadow());
+ outln_if(MEMORY_DEBUG, "\033[36;1mread_memory64: @{:#04x}:{:p} -> {:#016x} ({:#016x})\033[0m", address.selector(), address.offset(), value, value.shadow());
  return value;
 }
 
 ValueWithShadow<u128> SoftCPU::read_memory128(X86::LogicalAddress address)
 {
  VERIFY(address.selector() == 0x1b || address.selector() == 0x23 || address.selector() == 0x2b);
  auto value = m_emulator.mmu().read128(address);
- outln_if(MEMORY_DEBUG, "\033[36;1mread_memory128: @{:04x}:{:08x} -> {:032x} ({:032x})\033[0m", address.selector(), address.offset(), value, value.shadow());
+ outln_if(MEMORY_DEBUG, "\033[36;1mread_memory128: @{:#04x}:{:p} -> {:#032x} ({:#032x})\033[0m", address.selector(), address.offset(), value, value.shadow());
  return value;
 }
 ValueWithShadow<u256> SoftCPU::read_memory256(X86::LogicalAddress address)
 {
  VERIFY(address.selector() == 0x1b || address.selector() == 0x23 || address.selector() == 0x2b);
  auto value = m_emulator.mmu().read256(address);
- outln_if(MEMORY_DEBUG, "\033[36;1mread_memory256: @{:04x}:{:08x} -> {:064x} ({:064x})\033[0m", address.selector(), address.offset(), value, value.shadow());
+ outln_if(MEMORY_DEBUG, "\033[36;1mread_memory256: @{:#04x}:{:p} -> {:#064x} ({:#064x})\033[0m", address.selector(), address.offset(), value, value.shadow());
  return value;
 }
 
 void SoftCPU::write_memory8(X86::LogicalAddress address, ValueWithShadow<u8> value)
 {
  VERIFY(address.selector() == 0x23 || address.selector() == 0x2b);
- outln_if(MEMORY_DEBUG, "\033[36;1mwrite_memory8: @{:04x}:{:08x} <- {:02x} ({:02x})\033[0m", address.selector(), address.offset(), value, value.shadow());
+ outln_if(MEMORY_DEBUG, "\033[36;1mwrite_memory8: @{:#04x}:{:p} <- {:#02x} ({:#02x})\033[0m", address.selector(), address.offset(), value, value.shadow());
  m_emulator.mmu().write8(address, value);
 }
 
 void SoftCPU::write_memory16(X86::LogicalAddress address, ValueWithShadow<u16> value)
 {
  VERIFY(address.selector() == 0x23 || address.selector() == 0x2b);
- outln_if(MEMORY_DEBUG, "\033[36;1mwrite_memory16: @{:04x}:{:08x} <- {:04x} ({:04x})\033[0m", address.selector(), address.offset(), value, value.shadow());
+ outln_if(MEMORY_DEBUG, "\033[36;1mwrite_memory16: @{:#04x}:{:p} <- {:#04x} ({:#04x})\033[0m", address.selector(), address.offset(), value, value.shadow());
  m_emulator.mmu().write16(address, value);
 }
 
 void SoftCPU::write_memory32(X86::LogicalAddress address, ValueWithShadow<u32> value)
 {
  VERIFY(address.selector() == 0x23 || address.selector() == 0x2b);
- outln_if(MEMORY_DEBUG, "\033[36;1mwrite_memory32: @{:04x}:{:08x} <- {:08x} ({:08x})\033[0m", address.selector(), address.offset(), value, value.shadow());
+ outln_if(MEMORY_DEBUG, "\033[36;1mwrite_memory32: @{:#04x}:{:p} <- {:#08x} ({:#08x})\033[0m", address.selector(), address.offset(), value, value.shadow());
  m_emulator.mmu().write32(address, value);
 }
 
 void SoftCPU::write_memory64(X86::LogicalAddress address, ValueWithShadow<u64> value)
 {
  VERIFY(address.selector() == 0x23 || address.selector() == 0x2b);
- outln_if(MEMORY_DEBUG, "\033[36;1mwrite_memory64: @{:04x}:{:08x} <- {:016x} ({:016x})\033[0m", address.selector(), address.offset(), value, value.shadow());
+ outln_if(MEMORY_DEBUG, "\033[36;1mwrite_memory64: @{:#04x}:{:p} <- {:#016x} ({:#016x})\033[0m", address.selector(), address.offset(), value, value.shadow());
  m_emulator.mmu().write64(address, value);
 }
 
 void SoftCPU::write_memory128(X86::LogicalAddress address, ValueWithShadow<u128> value)
 {
  VERIFY(address.selector() == 0x23 || address.selector() == 0x2b);
- outln_if(MEMORY_DEBUG, "\033[36;1mwrite_memory128: @{:04x}:{:08x} <- {:032x} ({:032x})\033[0m", address.selector(), address.offset(), value, value.shadow());
+ outln_if(MEMORY_DEBUG, "\033[36;1mwrite_memory128: @{:#04x}:{:p} <- {:#032x} ({:#032x})\033[0m", address.selector(), address.offset(), value, value.shadow());
  m_emulator.mmu().write128(address, value);
 }
 
 void SoftCPU::write_memory256(X86::LogicalAddress address, ValueWithShadow<u256> value)
 {
  VERIFY(address.selector() == 0x23 || address.selector() == 0x2b);
- outln_if(MEMORY_DEBUG, "\033[36;1mwrite_memory256: @{:04x}:{:08x} <- {:064x} ({:064x})\033[0m", address.selector(), address.offset(), value, value.shadow());
+ outln_if(MEMORY_DEBUG, "\033[36;1mwrite_memory256: @{:#04x}:{:p} <- {:#064x} ({:#064x})\033[0m", address.selector(), address.offset(), value, value.shadow());
  m_emulator.mmu().write256(address, value);
 }
 
@@ -1327,7 +1327,7 @@ void SoftCPU::CPUID(const X86::Instruction&)
  return;
  }
 
- dbgln("Unhandled CPUID with eax={:08x}", eax().value());
+ dbgln("Unhandled CPUID with eax={:p}", eax().value());
 }
 
 void SoftCPU::CWD(const X86::Instruction&)

Userland/Utilities/pmap.cpp

@@ -44,9 +44,9 @@ int main(int argc, char** argv)
  outln("{}:", pid);
 
  if (extended) {
- outln("Address Size Resident Dirty Access VMObject Type Purgeable CoW Pages Name");
+ outln("Address  Size Resident Dirty Access VMObject Type Purgeable CoW Pages Name");
  } else {
- outln("Address Size Access Name");
+ outln("Address  Size Access Name");
  }
 
  auto file_contents = file->read_all();
@@ -74,11 +74,7 @@ int main(int argc, char** argv)
  (map.get("shared").to_bool() ? "s" : "-"),
  (map.get("syscall").to_bool() ? "c" : "-"));
 
-#if ARCH(I386)
- out("{:08x} ", address);
-#else
- out("{:16x} ", address);
-#endif
+ out("{:p} ", address);
  out("{:>10} ", size);
  if (extended) {
  auto resident = map.get("amount_resident").to_string();