RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-05-31 05:58:11 +00:00
Code Issues Activity Actions

LibX86+disasm: Use an output format closer to objdump

Browse source 
This mainly does two things,
1. Removes spaces after commas
2. Elides "0x" and leading zeros in most contexts

Remaining differences are:
1. objdump always has memory size annotations
   We lack these and probably have some annotations wrong
2. Boolean check names
   We use jump-zero, while objdump uses jump-equal for example
3. We sometimes add "00 00" symbols, which objdump elides
4. We always demangle (This is a good thing)
5. We always resolve relocations (This is a good thing)
6. We seem to detect some symbols differently/incorrectly
This commit is contained in:
Hendiadyoin1 2022-04-07 14:53:19 +02:00 • committed by Andreas Kling
parent 5ee85aaa5d
commit f602bbf135
2 changed files with 128 additions and 130 deletions
Download patch file Download diff file Expand all files Collapse all files

256
Userland/Libraries/LibX86/Instruction.cpp
View file

@ -1490,7 +1490,7 @@ String MemoryOrRegisterReference::to_string_a32() const
break; break;
case 5: case 5:
if (mod() == 0) if (mod() == 0)
base = String::formatted("{:#08x}", m_displacement32); base = String::formatted("{:x}", m_displacement32);
else else
base = "ebp"; base = "ebp";
break; break;
@ -1513,18 +1513,18 @@ String MemoryOrRegisterReference::to_string_a32() const
static String relative_address(u32 origin, bool x32, i8 imm) static String relative_address(u32 origin, bool x32, i8 imm)
{ {
if (x32) if (x32)
return String::formatted("{:#08x}", origin + imm); return String::formatted("{:x}", origin + imm);
u16 w = origin & 0xffff; u16 w = origin & 0xffff;
return String::formatted("{:#04x}", w + imm); return String::formatted("{:x}", w + imm);
} }
static String relative_address(u32 origin, bool x32, i32 imm) static String relative_address(u32 origin, bool x32, i32 imm)
{ {
if (x32) if (x32)
return String::formatted("{:#08x}", origin + imm); return String::formatted("{:x}", origin + imm);
u16 w = origin & 0xffff; u16 w = origin & 0xffff;
i16 si = imm; i16 si = imm;
return String::formatted("{:#04x}", w + si); return String::formatted("{:x}", w + si);
} }
String Instruction::to_string(u32 origin, SymbolProvider const* symbol_provider, bool x32) const String Instruction::to_string(u32 origin, SymbolProvider const* symbol_provider, bool x32) const
@ -1556,10 +1556,8 @@ void Instruction::to_string_internal(StringBuilder& builder, u32 origin, SymbolP
String mnemonic = String(m_descriptor->mnemonic).to_lowercase(); String mnemonic = String(m_descriptor->mnemonic).to_lowercase();
auto append_mnemonic = [&] { builder.append(mnemonic); }; auto append_mnemonic = [&] { builder.append(mnemonic); };
auto append_mnemonic_space = [&] {
builder.append(mnemonic); auto append_mnemonic_space = [&] { builder.appendff("{: <6} ", mnemonic); };
builder.append(' ');
};
auto formatted_address = [&](FlatPtr origin, bool x32, auto offset) { auto formatted_address = [&](FlatPtr origin, bool x32, auto offset) {
builder.append(relative_address(origin, x32, offset)); builder.append(relative_address(origin, x32, offset));
@ -1569,7 +1567,7 @@ void Instruction::to_string_internal(StringBuilder& builder, u32 origin, SymbolP
builder.append(" <"); builder.append(" <");
builder.append(symbol); builder.append(symbol);
if (symbol_offset) if (symbol_offset)
builder.appendff("+{}", symbol_offset); builder.appendff("+{:#x}", symbol_offset);
builder.append('>'); builder.append('>');
} }
}; };
@ -1586,13 +1584,13 @@ void Instruction::to_string_internal(StringBuilder& builder, u32 origin, SymbolP
auto append_fpu_rm32 = [&] { builder.append(m_modrm.to_string_fpu32(*this)); }; auto append_fpu_rm32 = [&] { builder.append(m_modrm.to_string_fpu32(*this)); };
auto append_fpu_rm64 = [&] { builder.append(m_modrm.to_string_fpu64(*this)); }; auto append_fpu_rm64 = [&] { builder.append(m_modrm.to_string_fpu64(*this)); };
auto append_fpu_rm80 = [&] { builder.append(m_modrm.to_string_fpu80(*this)); }; auto append_fpu_rm80 = [&] { builder.append(m_modrm.to_string_fpu80(*this)); };
auto append_imm8 = [&] { builder.appendff("{:#02x}", imm8()); }; auto append_imm8 = [&] { builder.appendff("{:#x}", imm8()); };
auto append_imm8_2 = [&] { builder.appendff("{:#02x}", imm8_2()); }; auto append_imm8_2 = [&] { builder.appendff("{:#x}", imm8_2()); };
auto append_imm16 = [&] { builder.appendff("{:#04x}", imm16()); }; auto append_imm16 = [&] { builder.appendff("{:#x}", imm16()); };
auto append_imm16_1 = [&] { builder.appendff("{:#04x}", imm16_1()); }; auto append_imm16_1 = [&] { builder.appendff("{:#x}", imm16_1()); };
auto append_imm16_2 = [&] { builder.appendff("{:#04x}", imm16_2()); }; auto append_imm16_2 = [&] { builder.appendff("{:#x}", imm16_2()); };
auto append_imm32 = [&] { builder.appendff("{:#08x}", imm32()); }; auto append_imm32 = [&] { builder.appendff("{:#x}", imm32()); };
auto append_imm32_2 = [&] { builder.appendff("{:#08x}", imm32_2()); }; auto append_imm32_2 = [&] { builder.appendff("{:#x}", imm32_2()); };
auto append_reg8 = [&] { builder.append(reg8_name()); }; auto append_reg8 = [&] { builder.append(reg8_name()); };
auto append_reg16 = [&] { builder.append(reg16_name()); }; auto append_reg16 = [&] { builder.append(reg16_name()); };
auto append_reg32 = [&] { builder.append(reg32_name()); }; auto append_reg32 = [&] { builder.append(reg32_name()); };
@ -1643,40 +1641,40 @@ void Instruction::to_string_internal(StringBuilder& builder, u32 origin, SymbolP
case OP_RM8_imm8: case OP_RM8_imm8:
append_mnemonic_space(); append_mnemonic_space();
append_rm8(); append_rm8();
append(", "); append(",");
append_imm8(); append_imm8();
break; break;
case OP_RM16_imm8: case OP_RM16_imm8:
append_mnemonic_space(); append_mnemonic_space();
append_rm16(); append_rm16();
append(", "); append(",");
append_imm8(); append_imm8();
break; break;
case OP_RM32_imm8: case OP_RM32_imm8:
append_mnemonic_space(); append_mnemonic_space();
append_rm32(); append_rm32();
append(", "); append(",");
append_imm8(); append_imm8();
break; break;
case OP_reg16_RM16_imm8: case OP_reg16_RM16_imm8:
append_mnemonic_space(); append_mnemonic_space();
append_reg16(); append_reg16();
append(", "); append(",");
append_rm16(); append_rm16();
append(", "); append(",");
append_imm8(); append_imm8();
break; break;
case OP_reg32_RM32_imm8: case OP_reg32_RM32_imm8:
append_mnemonic_space(); append_mnemonic_space();
append_reg32(); append_reg32();
append(", "); append(",");
append_rm32(); append_rm32();
append(", "); append(",");
append_imm8(); append_imm8();
break; break;
case OP_AL_imm8: case OP_AL_imm8:
append_mnemonic_space(); append_mnemonic_space();
append("al, "); append("al,");
append_imm8(); append_imm8();
break; break;
case OP_imm8: case OP_imm8:
@ -1686,37 +1684,37 @@ void Instruction::to_string_internal(StringBuilder& builder, u32 origin, SymbolP
case OP_reg8_imm8: case OP_reg8_imm8:
append_mnemonic_space(); append_mnemonic_space();
append_reg8(); append_reg8();
append(", "); append(",");
append_imm8(); append_imm8();
break; break;
case OP_AX_imm8: case OP_AX_imm8:
append_mnemonic_space(); append_mnemonic_space();
append("ax, "); append("ax,");
append_imm8(); append_imm8();
break; break;
case OP_EAX_imm8: case OP_EAX_imm8:
append_mnemonic_space(); append_mnemonic_space();
append("eax, "); append("eax,");
append_imm8(); append_imm8();
break; break;
case OP_imm8_AL: case OP_imm8_AL:
append_mnemonic_space(); append_mnemonic_space();
append_imm8(); append_imm8();
append(", al"); append(",al");
break; break;
case OP_imm8_AX: case OP_imm8_AX:
append_mnemonic_space(); append_mnemonic_space();
append_imm8(); append_imm8();
append(", ax"); append(",ax");
break; break;
case OP_imm8_EAX: case OP_imm8_EAX:
append_mnemonic_space(); append_mnemonic_space();
append_imm8(); append_imm8();
append(", eax"); append(",eax");
break; break;
case OP_AX_imm16: case OP_AX_imm16:
append_mnemonic_space(); append_mnemonic_space();
append("ax, "); append("ax,");
append_imm16(); append_imm16();
break; break;
case OP_imm16: case OP_imm16:
@ -1726,23 +1724,23 @@ void Instruction::to_string_internal(StringBuilder& builder, u32 origin, SymbolP
case OP_reg16_imm16: case OP_reg16_imm16:
append_mnemonic_space(); append_mnemonic_space();
append_reg16(); append_reg16();
append(", "); append(",");
append_imm16(); append_imm16();
break; break;
case OP_reg16_RM16_imm16: case OP_reg16_RM16_imm16:
append_mnemonic_space(); append_mnemonic_space();
append_reg16(); append_reg16();
append(", "); append(",");
append_rm16(); append_rm16();
append(", "); append(",");
append_imm16(); append_imm16();
break; break;
case OP_reg32_RM32_imm32: case OP_reg32_RM32_imm32:
append_mnemonic_space(); append_mnemonic_space();
append_reg32(); append_reg32();
append(", "); append(",");
append_rm32(); append_rm32();
append(", "); append(",");
append_imm32(); append_imm32();
break; break;
case OP_imm32: case OP_imm32:
@ -1751,7 +1749,7 @@ void Instruction::to_string_internal(StringBuilder& builder, u32 origin, SymbolP
break; break;
case OP_EAX_imm32: case OP_EAX_imm32:
append_mnemonic_space(); append_mnemonic_space();
append("eax, "); append("eax,");
append_imm32(); append_imm32();
break; break;
case OP_CS: case OP_CS:
@ -1779,7 +1777,7 @@ void Instruction::to_string_internal(StringBuilder& builder, u32 origin, SymbolP
append("gs"); append("gs");
break; break;
case OP: case OP:
append_mnemonic_space(); append_mnemonic();
break; break;
case OP_reg32: case OP_reg32:
append_mnemonic_space(); append_mnemonic_space();
@ -1788,37 +1786,37 @@ void Instruction::to_string_internal(StringBuilder& builder, u32 origin, SymbolP
case OP_imm16_imm8: case OP_imm16_imm8:
append_mnemonic_space(); append_mnemonic_space();
append_imm16_1(); append_imm16_1();
append(", "); append(",");
append_imm8_2(); append_imm8_2();
break; break;
case OP_moff8_AL: case OP_moff8_AL:
append_mnemonic_space(); append_mnemonic_space();
append_moff(); append_moff();
append(", al"); append(",al");
break; break;
case OP_moff16_AX: case OP_moff16_AX:
append_mnemonic_space(); append_mnemonic_space();
append_moff(); append_moff();
append(", ax"); append(",ax");
break; break;
case OP_moff32_EAX: case OP_moff32_EAX:
append_mnemonic_space(); append_mnemonic_space();
append_moff(); append_moff();
append(", eax"); append(",eax");
break; break;
case OP_AL_moff8: case OP_AL_moff8:
append_mnemonic_space(); append_mnemonic_space();
append("al, "); append("al,");
append_moff(); append_moff();
break; break;
case OP_AX_moff16: case OP_AX_moff16:
append_mnemonic_space(); append_mnemonic_space();
append("ax, "); append("ax,");
append_moff(); append_moff();
break; break;
case OP_EAX_moff32: case OP_EAX_moff32:
append_mnemonic_space(); append_mnemonic_space();
append("eax, "); append("eax,");
append_moff(); append_moff();
break; break;
case OP_imm16_imm16: case OP_imm16_imm16:
@ -1836,38 +1834,38 @@ void Instruction::to_string_internal(StringBuilder& builder, u32 origin, SymbolP
case OP_reg32_imm32: case OP_reg32_imm32:
append_mnemonic_space(); append_mnemonic_space();
append_reg32(); append_reg32();
append(", "); append(",");
append_imm32(); append_imm32();
break; break;
case OP_RM8_1: case OP_RM8_1:
append_mnemonic_space(); append_mnemonic_space();
append_rm8(); append_rm8();
append(", 0x01"); append(",0x01");
break; break;
case OP_RM16_1: case OP_RM16_1:
append_mnemonic_space(); append_mnemonic_space();
append_rm16(); append_rm16();
append(", 0x01"); append(",0x01");
break; break;
case OP_RM32_1: case OP_RM32_1:
append_mnemonic_space(); append_mnemonic_space();
append_rm32(); append_rm32();
append(", 0x01"); append(",0x01");
break; break;
case OP_RM8_CL: case OP_RM8_CL:
append_mnemonic_space(); append_mnemonic_space();
append_rm8(); append_rm8();
append(", cl"); append(",cl");
break; break;
case OP_RM16_CL: case OP_RM16_CL:
append_mnemonic_space(); append_mnemonic_space();
append_rm16(); append_rm16();
append(", cl"); append(",cl");
break; break;
case OP_RM32_CL: case OP_RM32_CL:
append_mnemonic_space(); append_mnemonic_space();
append_rm32(); append_rm32();
append(", cl"); append(",cl");
break; break;
case OP_reg16: case OP_reg16:
append_mnemonic_space(); append_mnemonic_space();
@ -1875,12 +1873,12 @@ void Instruction::to_string_internal(StringBuilder& builder, u32 origin, SymbolP
break; break;
case OP_AX_reg16: case OP_AX_reg16:
append_mnemonic_space(); append_mnemonic_space();
append("ax, "); append("ax,");
append_reg16(); append_reg16();
break; break;
case OP_EAX_reg32: case OP_EAX_reg32:
append_mnemonic_space(); append_mnemonic_space();
append("eax, "); append("eax,");
append_reg32(); append_reg32();
break; break;
case OP_3: case OP_3:
@ -1889,32 +1887,32 @@ void Instruction::to_string_internal(StringBuilder& builder, u32 origin, SymbolP
break; break;
case OP_AL_DX: case OP_AL_DX:
append_mnemonic_space(); append_mnemonic_space();
append("al, dx"); append("al,dx");
break; break;
case OP_AX_DX: case OP_AX_DX:
append_mnemonic_space(); append_mnemonic_space();
append("ax, dx"); append("ax,dx");
break; break;
case OP_EAX_DX: case OP_EAX_DX:
append_mnemonic_space(); append_mnemonic_space();
append("eax, dx"); append("eax,dx");
break; break;
case OP_DX_AL: case OP_DX_AL:
append_mnemonic_space(); append_mnemonic_space();
append("dx, al"); append("dx,al");
break; break;
case OP_DX_AX: case OP_DX_AX:
append_mnemonic_space(); append_mnemonic_space();
append("dx, ax"); append("dx,ax");
break; break;
case OP_DX_EAX: case OP_DX_EAX:
append_mnemonic_space(); append_mnemonic_space();
append("dx, eax"); append("dx,eax");
break; break;
case OP_reg8_CL: case OP_reg8_CL:
append_mnemonic_space(); append_mnemonic_space();
append_reg8(); append_reg8();
append(", cl"); append(",cl");
break; break;
case OP_RM8: case OP_RM8:
append_mnemonic_space(); append_mnemonic_space();
@ -1962,103 +1960,103 @@ void Instruction::to_string_internal(StringBuilder& builder, u32 origin, SymbolP
case OP_RM8_reg8: case OP_RM8_reg8:
append_mnemonic_space(); append_mnemonic_space();
append_rm8(); append_rm8();
append(", "); append(",");
append_reg8(); append_reg8();
break; break;
case OP_RM16_reg16: case OP_RM16_reg16:
append_mnemonic_space(); append_mnemonic_space();
append_rm16(); append_rm16();
append(", "); append(",");
append_reg16(); append_reg16();
break; break;
case OP_RM32_reg32: case OP_RM32_reg32:
append_mnemonic_space(); append_mnemonic_space();
append_rm32(); append_rm32();
append(", "); append(",");
append_reg32(); append_reg32();
break; break;
case OP_reg8_RM8: case OP_reg8_RM8:
append_mnemonic_space(); append_mnemonic_space();
append_reg8(); append_reg8();
append(", "); append(",");
append_rm8(); append_rm8();
break; break;
case OP_reg16_RM16: case OP_reg16_RM16:
append_mnemonic_space(); append_mnemonic_space();
append_reg16(); append_reg16();
append(", "); append(",");
append_rm16(); append_rm16();
break; break;
case OP_reg32_RM32: case OP_reg32_RM32:
append_mnemonic_space(); append_mnemonic_space();
append_reg32(); append_reg32();
append(", "); append(",");
append_rm32(); append_rm32();
break; break;
case OP_reg32_RM16: case OP_reg32_RM16:
append_mnemonic_space(); append_mnemonic_space();
append_reg32(); append_reg32();
append(", "); append(",");
append_rm16(); append_rm16();
break; break;
case OP_reg16_RM8: case OP_reg16_RM8:
append_mnemonic_space(); append_mnemonic_space();
append_reg16(); append_reg16();
append(", "); append(",");
append_rm8(); append_rm8();
break; break;
case OP_reg32_RM8: case OP_reg32_RM8:
append_mnemonic_space(); append_mnemonic_space();
append_reg32(); append_reg32();
append(", "); append(",");
append_rm8(); append_rm8();
break; break;
case OP_RM16_imm16: case OP_RM16_imm16:
append_mnemonic_space(); append_mnemonic_space();
append_rm16(); append_rm16();
append(", "); append(",");
append_imm16(); append_imm16();
break; break;
case OP_RM32_imm32: case OP_RM32_imm32:
append_mnemonic_space(); append_mnemonic_space();
append_rm32(); append_rm32();
append(", "); append(",");
append_imm32(); append_imm32();
break; break;
case OP_RM16_seg: case OP_RM16_seg:
append_mnemonic_space(); append_mnemonic_space();
append_rm16(); append_rm16();
append(", "); append(",");
append_seg(); append_seg();
break; break;
case OP_RM32_seg: case OP_RM32_seg:
append_mnemonic_space(); append_mnemonic_space();
append_rm32(); append_rm32();
append(", "); append(",");
append_seg(); append_seg();
break; break;
case OP_seg_RM16: case OP_seg_RM16:
append_mnemonic_space(); append_mnemonic_space();
append_seg(); append_seg();
append(", "); append(",");
append_rm16(); append_rm16();
break; break;
case OP_seg_RM32: case OP_seg_RM32:
append_mnemonic_space(); append_mnemonic_space();
append_seg(); append_seg();
append(", "); append(",");
append_rm32(); append_rm32();
break; break;
case OP_reg16_mem16: case OP_reg16_mem16:
append_mnemonic_space(); append_mnemonic_space();
append_reg16(); append_reg16();
append(", "); append(",");
append_rm16(); append_rm16();
break; break;
case OP_reg32_mem32: case OP_reg32_mem32:
append_mnemonic_space(); append_mnemonic_space();
append_reg32(); append_reg32();
append(", "); append(",");
append_rm32(); append_rm32();
break; break;
case OP_FAR_mem16: case OP_FAR_mem16:
@ -2074,25 +2072,25 @@ void Instruction::to_string_internal(StringBuilder& builder, u32 origin, SymbolP
case OP_reg32_CR: case OP_reg32_CR:
append_mnemonic_space(); append_mnemonic_space();
builder.append(register_name(static_cast<RegisterIndex32>(modrm().rm()))); builder.append(register_name(static_cast<RegisterIndex32>(modrm().rm())));
append(", "); append(",");
append_creg(); append_creg();
break; break;
case OP_CR_reg32: case OP_CR_reg32:
append_mnemonic_space(); append_mnemonic_space();
append_creg(); append_creg();
append(", "); append(",");
builder.append(register_name(static_cast<RegisterIndex32>(modrm().rm()))); builder.append(register_name(static_cast<RegisterIndex32>(modrm().rm())));
break; break;
case OP_reg32_DR: case OP_reg32_DR:
append_mnemonic_space(); append_mnemonic_space();
builder.append(register_name(static_cast<RegisterIndex32>(modrm().rm()))); builder.append(register_name(static_cast<RegisterIndex32>(modrm().rm())));
append(", "); append(",");
append_dreg(); append_dreg();
break; break;
case OP_DR_reg32: case OP_DR_reg32:
append_mnemonic_space(); append_mnemonic_space();
append_dreg(); append_dreg();
append(", "); append(",");
builder.append(register_name(static_cast<RegisterIndex32>(modrm().rm()))); builder.append(register_name(static_cast<RegisterIndex32>(modrm().rm())));
break; break;
case OP_short_imm8: case OP_short_imm8:
@ -2116,32 +2114,32 @@ void Instruction::to_string_internal(StringBuilder& builder, u32 origin, SymbolP
case OP_RM16_reg16_imm8: case OP_RM16_reg16_imm8:
append_mnemonic_space(); append_mnemonic_space();
append_rm16(); append_rm16();
append(", "); append(",");
append_reg16(); append_reg16();
append(", "); append(",");
append_imm8(); append_imm8();
break; break;
case OP_RM32_reg32_imm8: case OP_RM32_reg32_imm8:
append_mnemonic_space(); append_mnemonic_space();
append_rm32(); append_rm32();
append(", "); append(",");
append_reg32(); append_reg32();
append(", "); append(",");
append_imm8(); append_imm8();
break; break;
case OP_RM16_reg16_CL: case OP_RM16_reg16_CL:
append_mnemonic_space(); append_mnemonic_space();
append_rm16(); append_rm16();
append(", "); append(",");
append_reg16(); append_reg16();
append(", cl"); append(", cl");
break; break;
case OP_RM32_reg32_CL: case OP_RM32_reg32_CL:
append_mnemonic_space(); append_mnemonic_space();
append_rm32(); append_rm32();
append(", "); append(",");
append_reg32(); append_reg32();
append(", cl"); append(",cl");
break; break;
case OP_reg: case OP_reg:
append_mnemonic_space(); append_mnemonic_space();
@ -2157,66 +2155,66 @@ void Instruction::to_string_internal(StringBuilder& builder, u32 origin, SymbolP
case OP_mm1_imm8: case OP_mm1_imm8:
append_mnemonic_space(); append_mnemonic_space();
append_mm_or_xmm(); append_mm_or_xmm();
append(", "); append(",");
append_imm8(); append_imm8();
break; break;
case OP_mm1_mm2m32: case OP_mm1_mm2m32:
append_mnemonic_space(); append_mnemonic_space();
append_mm_or_xmm(); append_mm_or_xmm();
append(", "); append(",");
append_mm_or_xmm_or_mem(); append_mm_or_xmm_or_mem();
break; break;
case OP_mm1_rm32: case OP_mm1_rm32:
append_mnemonic_space(); append_mnemonic_space();
append_mm_or_xmm(); append_mm_or_xmm();
append(", "); append(",");
append_rm32(); append_rm32();
break; break;
case OP_rm32_mm2: case OP_rm32_mm2:
append_mnemonic_space(); append_mnemonic_space();
append_rm32(); append_rm32();
append(", "); append(",");
append_mm_or_xmm(); append_mm_or_xmm();
break; break;
case OP_mm1_mm2m64: case OP_mm1_mm2m64:
append_mnemonic_space(); append_mnemonic_space();
append_mm_or_xmm(); append_mm_or_xmm();
append(", "); append(",");
append_mm_or_xmm_or_mem(); append_mm_or_xmm_or_mem();
break; break;
case OP_mm1m64_mm2: case OP_mm1m64_mm2:
append_mnemonic_space(); append_mnemonic_space();
append_mm_or_xmm_or_mem(); append_mm_or_xmm_or_mem();
append(", "); append(",");
append_mm_or_xmm(); append_mm_or_xmm();
break; break;
case OP_mm1_mm2m64_imm8: case OP_mm1_mm2m64_imm8:
append_mnemonic_space(); append_mnemonic_space();
append_mm_or_xmm(); append_mm_or_xmm();
append(", "); append(",");
append_mm_or_xmm_or_mem(); append_mm_or_xmm_or_mem();
append(", "); append(",");
append_imm8(); append_imm8();
break; break;
case OP_reg_mm1: case OP_reg_mm1:
append_mnemonic_space(); append_mnemonic_space();
append_rm32(); append_rm32();
append(", "); append(",");
append_mm_or_xmm(); append_mm_or_xmm();
break; break;
case OP_reg_mm1_imm8: case OP_reg_mm1_imm8:
append_mnemonic_space(); append_mnemonic_space();
append_reg32(); append_reg32();
append(", "); append(",");
append_mm_or_xmm_or_mem(); append_mm_or_xmm_or_mem();
append(", "); append(",");
append_imm8(); append_imm8();
break; break;
case OP_mm1_r32m16_imm8: case OP_mm1_r32m16_imm8:
append_mnemonic_space(); append_mnemonic_space();
append_mm_or_xmm(); append_mm_or_xmm();
append_rm32(); // FIXME: r32m16 append_rm32(); // FIXME: r32m16
append(", "); append(",");
append_imm8(); append_imm8();
break; break;
case __SSE: case __SSE:
@ -2224,150 +2222,150 @@ void Instruction::to_string_internal(StringBuilder& builder, u32 origin, SymbolP
case OP_xmm_mm: case OP_xmm_mm:
append_mnemonic_space(); append_mnemonic_space();
append_xmm(); append_xmm();
append(", "); append(",");
append_mmrm32(); // FIXME: No Memmory append_mmrm32(); // FIXME: No Memmory
break; break;
case OP_mm1_xmm2m128: case OP_mm1_xmm2m128:
case OP_mm_xmm: case OP_mm_xmm:
append_mnemonic_space(); append_mnemonic_space();
append_mm(); append_mm();
append(", "); append(",");
append_xmmrm32(); // FIXME: No Memmory append_xmmrm32(); // FIXME: No Memmory
break; break;
case OP_xmm1_imm8: case OP_xmm1_imm8:
append_mnemonic_space(); append_mnemonic_space();
append_xmm(); append_xmm();
append(", "); append(",");
append_imm8(); append_imm8();
break; break;
case OP_xmm1_xmm2m32: case OP_xmm1_xmm2m32:
append_mnemonic_space(); append_mnemonic_space();
append_xmm(); append_xmm();
append(", "); append(",");
append_xmmrm32(); append_xmmrm32();
break; break;
case OP_xmm1_xmm2m64: case OP_xmm1_xmm2m64:
append_mnemonic_space(); append_mnemonic_space();
append_xmm(); append_xmm();
append(", "); append(",");
append_xmmrm64(); append_xmmrm64();
break; break;
case OP_xmm1_xmm2m128: case OP_xmm1_xmm2m128:
append_mnemonic_space(); append_mnemonic_space();
append_xmm(); append_xmm();
append(", "); append(",");
append_xmmrm128(); append_xmmrm128();
break; break;
case OP_xmm1_xmm2m32_imm8: case OP_xmm1_xmm2m32_imm8:
append_mnemonic_space(); append_mnemonic_space();
append_xmm(); append_xmm();
append(", "); append(",");
append_xmmrm32(); append_xmmrm32();
append(", "); append(",");
append_imm8(); append_imm8();
break; break;
case OP_xmm1_xmm2m128_imm8: case OP_xmm1_xmm2m128_imm8:
append_mnemonic_space(); append_mnemonic_space();
append_xmm(); append_xmm();
append(", "); append(",");
append_xmmrm32(); append_xmmrm32();
append(", "); append(",");
append_imm8(); append_imm8();
break; break;
case OP_xmm1m32_xmm2: case OP_xmm1m32_xmm2:
append_mnemonic_space(); append_mnemonic_space();
append_xmmrm32(); append_xmmrm32();
append(", "); append(",");
append_xmm(); append_xmm();
break; break;
case OP_xmm1m64_xmm2: case OP_xmm1m64_xmm2:
append_mnemonic_space(); append_mnemonic_space();
append_xmmrm64(); append_xmmrm64();
append(", "); append(",");
append_xmm(); append_xmm();
break; break;
case OP_xmm1m128_xmm2: case OP_xmm1m128_xmm2:
append_mnemonic_space(); append_mnemonic_space();
append_xmmrm128(); append_xmmrm128();
append(", "); append(",");
append_xmm(); append_xmm();
break; break;
case OP_reg_xmm1: case OP_reg_xmm1:
case OP_r32_xmm2m64: case OP_r32_xmm2m64:
append_mnemonic_space(); append_mnemonic_space();
append_reg32(); append_reg32();
append(", "); append(",");
append_xmmrm128(); // second entry in the rm byte append_xmmrm128(); // second entry in the rm byte
break; break;
case OP_rm32_xmm2: case OP_rm32_xmm2:
append_mnemonic_space(); append_mnemonic_space();
append_rm32(); append_rm32();
append(", "); append(",");
append_xmm(); append_xmm();
break; break;
case OP_reg_xmm1_imm8: case OP_reg_xmm1_imm8:
append_mnemonic_space(); append_mnemonic_space();
append_reg32(); append_reg32();
append(", "); append(",");
append_xmmrm128(); // second entry in the rm byte append_xmmrm128(); // second entry in the rm byte
append(", "); append(",");
append_imm8(); append_imm8();
break; break;
case OP_xmm1_rm32: case OP_xmm1_rm32:
append_mnemonic_space(); append_mnemonic_space();
append_xmm(); append_xmm();
append(", "); append(",");
append_rm32(); // second entry in the rm byte append_rm32(); // second entry in the rm byte
break; break;
case OP_xmm1_m64: case OP_xmm1_m64:
append_mnemonic_space(); append_mnemonic_space();
append_xmm(); append_xmm();
append(", "); append(",");
append_rm64(); // second entry in the rm byte append_rm64(); // second entry in the rm byte
break; break;
case OP_m64_xmm2: case OP_m64_xmm2:
append_mnemonic_space(); append_mnemonic_space();
append_rm64(); // second entry in the rm byte append_rm64(); // second entry in the rm byte
append(", "); append(",");
append_xmm(); append_xmm();
break; break;
case OP_rm8_xmm2m32: case OP_rm8_xmm2m32:
append_mnemonic_space(); append_mnemonic_space();
append_rm8(); append_rm8();
append(", "); append(",");
append_xmmrm32(); append_xmmrm32();
break; break;
case OP_xmm1_mm2m64: case OP_xmm1_mm2m64:
append_mnemonic_space(); append_mnemonic_space();
append_xmm(); append_xmm();
append(", "); append(",");
append_mmrm64(); append_mmrm64();
break; break;
case OP_mm1m64_xmm2: case OP_mm1m64_xmm2:
append_mnemonic_space(); append_mnemonic_space();
append_mmrm64(); append_mmrm64();
append(", "); append(",");
append_xmm(); append_xmm();
break; break;
case OP_mm1_xmm2m64: case OP_mm1_xmm2m64:
append_mnemonic_space(); append_mnemonic_space();
append_mm(); append_mm();
append(", "); append(",");
append_xmmrm64(); append_xmmrm64();
break; break;
case OP_r32_xmm2m32: case OP_r32_xmm2m32:
append_mnemonic_space(); append_mnemonic_space();
append_reg32(); append_reg32();
append(", "); append(",");
append_xmmrm32(); append_xmmrm32();
break; break;
case OP_xmm1_r32m16_imm8: case OP_xmm1_r32m16_imm8:
append_mnemonic_space(); append_mnemonic_space();
append_xmm(); append_xmm();
append(", "); append(",");
append_rm32(); // FIXME: r32m16 append_rm32(); // FIXME: r32m16
append(", "); append(",");
append_imm8(); append_imm8();
break; break;
case InstructionPrefix: case InstructionPrefix:

2
Userland/Utilities/disasm.cpp
View file

@ -124,7 +124,7 @@ ErrorOr<int> serenity_main(Main::Arguments args)
outln(); outln();
++current_symbol; ++current_symbol;
current_instruction_is_in_symbol = true; current_instruction_is_in_symbol = true;
outln("{} ({:p}-{:p}):", current_symbol->name, current_symbol->address(), current_symbol->address_end()); outln("{:08x} <{}>:", current_symbol->address(), current_symbol->name);
} }
is_first_symbol = false; is_first_symbol = false;