mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2025-06-23 01:24:30 +00:00
Add printing the LC_THREAD load commands with llvm-objdump’s -private-headers.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@224792 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Kevin Enderby
@ -3773,6 +3773,354 @@ static void PrintRoutinesCommand64(MachO::routines_command_64 r) {
|
||||
outs() << " reserved6 " << r.reserved6 << "\n";
|
||||
}
|
||||
|
||||
static void Print_x86_thread_state64_t(MachO::x86_thread_state64_t &cpu64) {
|
||||
outs() << " rax " << format("0x%016" PRIx64, cpu64.rax);
|
||||
outs() << " rbx " << format("0x%016" PRIx64, cpu64.rbx);
|
||||
outs() << " rcx " << format("0x%016" PRIx64, cpu64.rcx) << "\n";
|
||||
outs() << " rdx " << format("0x%016" PRIx64, cpu64.rdx);
|
||||
outs() << " rdi " << format("0x%016" PRIx64, cpu64.rdi);
|
||||
outs() << " rsi " << format("0x%016" PRIx64, cpu64.rsi) << "\n";
|
||||
outs() << " rbp " << format("0x%016" PRIx64, cpu64.rbp);
|
||||
outs() << " rsp " << format("0x%016" PRIx64, cpu64.rsp);
|
||||
outs() << " r8 " << format("0x%016" PRIx64, cpu64.r8) << "\n";
|
||||
outs() << " r9 " << format("0x%016" PRIx64, cpu64.r9);
|
||||
outs() << " r10 " << format("0x%016" PRIx64, cpu64.r10);
|
||||
outs() << " r11 " << format("0x%016" PRIx64, cpu64.r11) << "\n";
|
||||
outs() << " r12 " << format("0x%016" PRIx64, cpu64.r12);
|
||||
outs() << " r13 " << format("0x%016" PRIx64, cpu64.r13);
|
||||
outs() << " r14 " << format("0x%016" PRIx64, cpu64.r14) << "\n";
|
||||
outs() << " r15 " << format("0x%016" PRIx64, cpu64.r15);
|
||||
outs() << " rip " << format("0x%016" PRIx64, cpu64.rip) << "\n";
|
||||
outs() << "rflags " << format("0x%016" PRIx64, cpu64.rflags);
|
||||
outs() << " cs " << format("0x%016" PRIx64, cpu64.cs);
|
||||
outs() << " fs " << format("0x%016" PRIx64, cpu64.fs) << "\n";
|
||||
outs() << " gs " << format("0x%016" PRIx64, cpu64.gs) << "\n";
|
||||
}
|
||||
|
||||
static void Print_mmst_reg(MachO::mmst_reg &r) {
|
||||
uint32_t f;
|
||||
outs() << "\t mmst_reg ";
|
||||
for (f = 0; f < 10; f++)
|
||||
outs() << format("%02" PRIx32, (r.mmst_reg[f] & 0xff)) << " ";
|
||||
outs() << "\n";
|
||||
outs() << "\t mmst_rsrv ";
|
||||
for (f = 0; f < 6; f++)
|
||||
outs() << format("%02" PRIx32, (r.mmst_rsrv[f] & 0xff)) << " ";
|
||||
outs() << "\n";
|
||||
}
|
||||
|
||||
static void Print_xmm_reg(MachO::xmm_reg &r) {
|
||||
uint32_t f;
|
||||
outs() << "\t xmm_reg ";
|
||||
for (f = 0; f < 16; f++)
|
||||
outs() << format("%02" PRIx32, (r.xmm_reg[f] & 0xff)) << " ";
|
||||
outs() << "\n";
|
||||
}
|
||||
|
||||
static void Print_x86_float_state_t(MachO::x86_float_state64_t &fpu) {
|
||||
outs() << "\t fpu_reserved[0] " << fpu.fpu_reserved[0];
|
||||
outs() << " fpu_reserved[1] " << fpu.fpu_reserved[1] << "\n";
|
||||
outs() << "\t control: invalid " << fpu.fpu_fcw.invalid;
|
||||
outs() << " denorm " << fpu.fpu_fcw.denorm;
|
||||
outs() << " zdiv " << fpu.fpu_fcw.zdiv;
|
||||
outs() << " ovrfl " << fpu.fpu_fcw.ovrfl;
|
||||
outs() << " undfl " << fpu.fpu_fcw.undfl;
|
||||
outs() << " precis " << fpu.fpu_fcw.precis << "\n";
|
||||
outs() << "\t\t pc ";
|
||||
if (fpu.fpu_fcw.pc == MachO::x86_FP_PREC_24B)
|
||||
outs() << "FP_PREC_24B ";
|
||||
else if (fpu.fpu_fcw.pc == MachO::x86_FP_PREC_53B)
|
||||
outs() << "FP_PREC_53B ";
|
||||
else if (fpu.fpu_fcw.pc == MachO::x86_FP_PREC_64B)
|
||||
outs() << "FP_PREC_64B ";
|
||||
else
|
||||
outs() << fpu.fpu_fcw.pc << " ";
|
||||
outs() << "rc ";
|
||||
if (fpu.fpu_fcw.rc == MachO::x86_FP_RND_NEAR)
|
||||
outs() << "FP_RND_NEAR ";
|
||||
else if (fpu.fpu_fcw.rc == MachO::x86_FP_RND_DOWN)
|
||||
outs() << "FP_RND_DOWN ";
|
||||
else if (fpu.fpu_fcw.rc == MachO::x86_FP_RND_UP)
|
||||
outs() << "FP_RND_UP ";
|
||||
else if (fpu.fpu_fcw.rc == MachO::x86_FP_CHOP)
|
||||
outs() << "FP_CHOP ";
|
||||
outs() << "\n";
|
||||
outs() << "\t status: invalid " << fpu.fpu_fsw.invalid;
|
||||
outs() << " denorm " << fpu.fpu_fsw.denorm;
|
||||
outs() << " zdiv " << fpu.fpu_fsw.zdiv;
|
||||
outs() << " ovrfl " << fpu.fpu_fsw.ovrfl;
|
||||
outs() << " undfl " << fpu.fpu_fsw.undfl;
|
||||
outs() << " precis " << fpu.fpu_fsw.precis;
|
||||
outs() << " stkflt " << fpu.fpu_fsw.stkflt << "\n";
|
||||
outs() << "\t errsumm " << fpu.fpu_fsw.errsumm;
|
||||
outs() << " c0 " << fpu.fpu_fsw.c0;
|
||||
outs() << " c1 " << fpu.fpu_fsw.c1;
|
||||
outs() << " c2 " << fpu.fpu_fsw.c2;
|
||||
outs() << " tos " << fpu.fpu_fsw.tos;
|
||||
outs() << " c3 " << fpu.fpu_fsw.c3;
|
||||
outs() << " busy " << fpu.fpu_fsw.busy << "\n";
|
||||
outs() << "\t fpu_ftw " << format("0x%02" PRIx32, fpu.fpu_ftw);
|
||||
outs() << " fpu_rsrv1 " << format("0x%02" PRIx32, fpu.fpu_rsrv1);
|
||||
outs() << " fpu_fop " << format("0x%04" PRIx32, fpu.fpu_fop);
|
||||
outs() << " fpu_ip " << format("0x%08" PRIx32, fpu.fpu_ip) << "\n";
|
||||
outs() << "\t fpu_cs " << format("0x%04" PRIx32, fpu.fpu_cs);
|
||||
outs() << " fpu_rsrv2 " << format("0x%04" PRIx32, fpu.fpu_rsrv2);
|
||||
outs() << " fpu_dp " << format("0x%08" PRIx32, fpu.fpu_dp);
|
||||
outs() << " fpu_ds " << format("0x%04" PRIx32, fpu.fpu_ds) << "\n";
|
||||
outs() << "\t fpu_rsrv3 " << format("0x%04" PRIx32, fpu.fpu_rsrv3);
|
||||
outs() << " fpu_mxcsr " << format("0x%08" PRIx32, fpu.fpu_mxcsr);
|
||||
outs() << " fpu_mxcsrmask " << format("0x%08" PRIx32, fpu.fpu_mxcsrmask);
|
||||
outs() << "\n";
|
||||
outs() << "\t fpu_stmm0:\n";
|
||||
Print_mmst_reg(fpu.fpu_stmm0);
|
||||
outs() << "\t fpu_stmm1:\n";
|
||||
Print_mmst_reg(fpu.fpu_stmm1);
|
||||
outs() << "\t fpu_stmm2:\n";
|
||||
Print_mmst_reg(fpu.fpu_stmm2);
|
||||
outs() << "\t fpu_stmm3:\n";
|
||||
Print_mmst_reg(fpu.fpu_stmm3);
|
||||
outs() << "\t fpu_stmm4:\n";
|
||||
Print_mmst_reg(fpu.fpu_stmm4);
|
||||
outs() << "\t fpu_stmm5:\n";
|
||||
Print_mmst_reg(fpu.fpu_stmm5);
|
||||
outs() << "\t fpu_stmm6:\n";
|
||||
Print_mmst_reg(fpu.fpu_stmm6);
|
||||
outs() << "\t fpu_stmm7:\n";
|
||||
Print_mmst_reg(fpu.fpu_stmm7);
|
||||
outs() << "\t fpu_xmm0:\n";
|
||||
Print_xmm_reg(fpu.fpu_xmm0);
|
||||
outs() << "\t fpu_xmm1:\n";
|
||||
Print_xmm_reg(fpu.fpu_xmm1);
|
||||
outs() << "\t fpu_xmm2:\n";
|
||||
Print_xmm_reg(fpu.fpu_xmm2);
|
||||
outs() << "\t fpu_xmm3:\n";
|
||||
Print_xmm_reg(fpu.fpu_xmm3);
|
||||
outs() << "\t fpu_xmm4:\n";
|
||||
Print_xmm_reg(fpu.fpu_xmm4);
|
||||
outs() << "\t fpu_xmm5:\n";
|
||||
Print_xmm_reg(fpu.fpu_xmm5);
|
||||
outs() << "\t fpu_xmm6:\n";
|
||||
Print_xmm_reg(fpu.fpu_xmm6);
|
||||
outs() << "\t fpu_xmm7:\n";
|
||||
Print_xmm_reg(fpu.fpu_xmm7);
|
||||
outs() << "\t fpu_xmm8:\n";
|
||||
Print_xmm_reg(fpu.fpu_xmm8);
|
||||
outs() << "\t fpu_xmm9:\n";
|
||||
Print_xmm_reg(fpu.fpu_xmm9);
|
||||
outs() << "\t fpu_xmm10:\n";
|
||||
Print_xmm_reg(fpu.fpu_xmm10);
|
||||
outs() << "\t fpu_xmm11:\n";
|
||||
Print_xmm_reg(fpu.fpu_xmm11);
|
||||
outs() << "\t fpu_xmm12:\n";
|
||||
Print_xmm_reg(fpu.fpu_xmm12);
|
||||
outs() << "\t fpu_xmm13:\n";
|
||||
Print_xmm_reg(fpu.fpu_xmm13);
|
||||
outs() << "\t fpu_xmm14:\n";
|
||||
Print_xmm_reg(fpu.fpu_xmm14);
|
||||
outs() << "\t fpu_xmm15:\n";
|
||||
Print_xmm_reg(fpu.fpu_xmm15);
|
||||
outs() << "\t fpu_rsrv4:\n";
|
||||
for (uint32_t f = 0; f < 6; f++) {
|
||||
outs() << "\t ";
|
||||
for (uint32_t g = 0; g < 16; g++)
|
||||
outs() << format("%02" PRIx32, fpu.fpu_rsrv4[f*g]) << " ";
|
||||
outs() << "\n";
|
||||
}
|
||||
outs() << "\t fpu_reserved1 " << format("0x%08" PRIx32, fpu.fpu_reserved1);
|
||||
outs() << "\n";
|
||||
}
|
||||
|
||||
static void Print_x86_exception_state_t(MachO::x86_exception_state64_t &exc64) {
|
||||
outs() << "\t trapno " << format("0x%08" PRIx32, exc64.trapno);
|
||||
outs() << " err " << format("0x%08" PRIx32, exc64.err);
|
||||
outs() << " faultvaddr " << format("0x%016" PRIx64, exc64.faultvaddr) << "\n";
|
||||
}
|
||||
|
||||
static void PrintThreadCommand(MachO::thread_command t, const char *Ptr,
|
||||
bool isLittleEndian, uint32_t cputype) {
|
||||
if (t.cmd == MachO::LC_THREAD)
|
||||
outs() << " cmd LC_THREAD\n";
|
||||
else if (t.cmd == MachO::LC_UNIXTHREAD)
|
||||
outs() << " cmd LC_UNIXTHREAD\n";
|
||||
else
|
||||
outs() << " cmd " << t.cmd << " (unknown)\n";
|
||||
outs() << " cmdsize " << t.cmdsize;
|
||||
if (t.cmdsize < sizeof(struct MachO::thread_command) + 2 * sizeof(uint32_t))
|
||||
outs() << " Incorrect size\n";
|
||||
else
|
||||
outs() << "\n";
|
||||
|
||||
const char *begin = Ptr + sizeof(struct MachO::thread_command);
|
||||
const char *end = Ptr + t.cmdsize;
|
||||
uint32_t flavor, count, left;
|
||||
if (cputype == MachO::CPU_TYPE_X86_64) {
|
||||
while (begin < end) {
|
||||
if (end - begin > (ptrdiff_t)sizeof(uint32_t)) {
|
||||
memcpy((char *)&flavor, begin, sizeof(uint32_t));
|
||||
begin += sizeof(uint32_t);
|
||||
} else{
|
||||
flavor = 0;
|
||||
begin = end;
|
||||
}
|
||||
if (isLittleEndian != sys::IsLittleEndianHost)
|
||||
sys::swapByteOrder(flavor);
|
||||
if (end - begin > (ptrdiff_t)sizeof(uint32_t)) {
|
||||
memcpy((char *)&count, begin, sizeof(uint32_t));
|
||||
begin += sizeof(uint32_t);
|
||||
} else{
|
||||
count = 0;
|
||||
begin = end;
|
||||
}
|
||||
if (isLittleEndian != sys::IsLittleEndianHost)
|
||||
sys::swapByteOrder(count);
|
||||
if (flavor == MachO::x86_THREAD_STATE64) {
|
||||
outs() << " flavor x86_THREAD_STATE64\n";
|
||||
if (count == MachO::x86_THREAD_STATE64_COUNT)
|
||||
outs() << " count x86_THREAD_STATE64_COUNT\n";
|
||||
else
|
||||
outs() << " count " << count
|
||||
<< " (not x86_THREAD_STATE64_COUNT)\n";
|
||||
MachO::x86_thread_state64_t cpu64;
|
||||
left = end - begin;
|
||||
if (left >= sizeof(MachO::x86_thread_state64_t)) {
|
||||
memcpy(&cpu64, begin, sizeof(MachO::x86_thread_state64_t));
|
||||
begin += sizeof(MachO::x86_thread_state64_t);
|
||||
} else {
|
||||
memset(&cpu64, '\0', sizeof(MachO::x86_thread_state64_t));
|
||||
memcpy(&cpu64, begin, left);
|
||||
begin += left;
|
||||
}
|
||||
if (isLittleEndian != sys::IsLittleEndianHost)
|
||||
swapStruct(cpu64);
|
||||
Print_x86_thread_state64_t(cpu64);
|
||||
} else if (flavor == MachO::x86_THREAD_STATE) {
|
||||
outs() << " flavor x86_THREAD_STATE\n";
|
||||
if (count == MachO::x86_THREAD_STATE_COUNT)
|
||||
outs() << " count x86_THREAD_STATE_COUNT\n";
|
||||
else
|
||||
outs() << " count " << count
|
||||
<< " (not x86_THREAD_STATE_COUNT)\n";
|
||||
struct MachO::x86_thread_state_t ts;
|
||||
left = end - begin;
|
||||
if (left >= sizeof(MachO::x86_thread_state_t)) {
|
||||
memcpy(&ts, begin, sizeof(MachO::x86_thread_state_t));
|
||||
begin += sizeof(MachO::x86_thread_state_t);
|
||||
} else {
|
||||
memset(&ts, '\0', sizeof(MachO::x86_thread_state_t));
|
||||
memcpy(&ts, begin, left);
|
||||
begin += left;
|
||||
}
|
||||
if (isLittleEndian != sys::IsLittleEndianHost)
|
||||
swapStruct(ts);
|
||||
if (ts.tsh.flavor == MachO::x86_THREAD_STATE64) {
|
||||
outs() << "\t tsh.flavor x86_THREAD_STATE64 ";
|
||||
if (ts.tsh.count == MachO::x86_THREAD_STATE64_COUNT)
|
||||
outs() << "tsh.count x86_THREAD_STATE64_COUNT\n";
|
||||
else
|
||||
outs() << "tsh.count " << ts.tsh.count
|
||||
<< " (not x86_THREAD_STATE64_COUNT\n";
|
||||
Print_x86_thread_state64_t(ts.uts.ts64);
|
||||
} else {
|
||||
outs() << "\t tsh.flavor " << ts.tsh.flavor
|
||||
<< " tsh.count " << ts.tsh.count << "\n";
|
||||
}
|
||||
} else if (flavor == MachO::x86_FLOAT_STATE) {
|
||||
outs() << " flavor x86_FLOAT_STATE\n";
|
||||
if (count == MachO::x86_FLOAT_STATE_COUNT)
|
||||
outs() << " count x86_FLOAT_STATE_COUNT\n";
|
||||
else
|
||||
outs() << " count " << count
|
||||
<< " (not x86_FLOAT_STATE_COUNT)\n";
|
||||
struct MachO::x86_float_state_t fs;
|
||||
left = end - begin;
|
||||
if (left >= sizeof(MachO::x86_float_state_t)) {
|
||||
memcpy(&fs, begin, sizeof(MachO::x86_float_state_t));
|
||||
begin += sizeof(MachO::x86_float_state_t);
|
||||
} else {
|
||||
memset(&fs, '\0', sizeof(MachO::x86_float_state_t));
|
||||
memcpy(&fs, begin, left);
|
||||
begin += left;
|
||||
}
|
||||
if (isLittleEndian != sys::IsLittleEndianHost)
|
||||
swapStruct(fs);
|
||||
if (fs.fsh.flavor == MachO::x86_FLOAT_STATE64) {
|
||||
outs() << "\t fsh.flavor x86_FLOAT_STATE64 ";
|
||||
if (fs.fsh.count == MachO::x86_FLOAT_STATE64_COUNT)
|
||||
outs() << "fsh.count x86_FLOAT_STATE64_COUNT\n";
|
||||
else
|
||||
outs() << "fsh.count " << fs.fsh.count
|
||||
<< " (not x86_FLOAT_STATE64_COUNT\n";
|
||||
Print_x86_float_state_t(fs.ufs.fs64);
|
||||
} else {
|
||||
outs() << "\t fsh.flavor " << fs.fsh.flavor
|
||||
<< " fsh.count " << fs.fsh.count << "\n";
|
||||
}
|
||||
} else if (flavor == MachO::x86_EXCEPTION_STATE) {
|
||||
outs() << " flavor x86_EXCEPTION_STATE\n";
|
||||
if (count == MachO::x86_EXCEPTION_STATE_COUNT)
|
||||
outs() << " count x86_EXCEPTION_STATE_COUNT\n";
|
||||
else
|
||||
outs() << " count " << count
|
||||
<< " (not x86_EXCEPTION_STATE_COUNT)\n";
|
||||
struct MachO::x86_exception_state_t es;
|
||||
left = end - begin;
|
||||
if (left >= sizeof(MachO::x86_exception_state_t)) {
|
||||
memcpy(&es, begin, sizeof(MachO::x86_exception_state_t));
|
||||
begin += sizeof(MachO::x86_exception_state_t);
|
||||
} else {
|
||||
memset(&es, '\0', sizeof(MachO::x86_exception_state_t));
|
||||
memcpy(&es, begin, left);
|
||||
begin += left;
|
||||
}
|
||||
if (isLittleEndian != sys::IsLittleEndianHost)
|
||||
swapStruct(es);
|
||||
if (es.esh.flavor == MachO::x86_EXCEPTION_STATE64) {
|
||||
outs() << "\t esh.flavor x86_EXCEPTION_STATE64\n";
|
||||
if (es.esh.count == MachO::x86_EXCEPTION_STATE64_COUNT)
|
||||
outs() << "\t esh.count x86_EXCEPTION_STATE64_COUNT\n";
|
||||
else
|
||||
outs() << "\t esh.count " << es.esh.count
|
||||
<< " (not x86_EXCEPTION_STATE64_COUNT\n";
|
||||
Print_x86_exception_state_t(es.ues.es64);
|
||||
} else {
|
||||
outs() << "\t esh.flavor " << es.esh.flavor
|
||||
<< " esh.count " << es.esh.count << "\n";
|
||||
}
|
||||
} else {
|
||||
outs() << " flavor " << flavor << " (unknown)\n";
|
||||
outs() << " count " << count << "\n";
|
||||
outs() << " state (unknown)\n";
|
||||
begin += count * sizeof(uint32_t);
|
||||
}
|
||||
}
|
||||
} else {
|
||||
while (begin < end) {
|
||||
if (end - begin > (ptrdiff_t)sizeof(uint32_t)) {
|
||||
memcpy((char *)&flavor, begin, sizeof(uint32_t));
|
||||
begin += sizeof(uint32_t);
|
||||
} else{
|
||||
flavor = 0;
|
||||
begin = end;
|
||||
}
|
||||
if (isLittleEndian != sys::IsLittleEndianHost)
|
||||
sys::swapByteOrder(flavor);
|
||||
if (end - begin > (ptrdiff_t)sizeof(uint32_t)) {
|
||||
memcpy((char *)&count, begin, sizeof(uint32_t));
|
||||
begin += sizeof(uint32_t);
|
||||
} else{
|
||||
count = 0;
|
||||
begin = end;
|
||||
}
|
||||
if (isLittleEndian != sys::IsLittleEndianHost)
|
||||
sys::swapByteOrder(count);
|
||||
outs() << " flavor " << flavor << "\n";
|
||||
outs() << " count " << count << "\n";
|
||||
outs() << " state (Unknown cputype/cpusubtype)\n";
|
||||
begin += count * sizeof(uint32_t);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void PrintDylibCommand(MachO::dylib_command dl, const char *Ptr) {
|
||||
if (dl.cmd == MachO::LC_ID_DYLIB)
|
||||
outs() << " cmd LC_ID_DYLIB\n";
|
||||
@ -3947,6 +4295,10 @@ static void PrintLoadCommands(const MachOObjectFile *Obj, uint32_t ncmds,
|
||||
} else if (Command.C.cmd == MachO::LC_ROUTINES_64) {
|
||||
MachO::routines_command_64 Rc = Obj->getRoutinesCommand64(Command);
|
||||
PrintRoutinesCommand64(Rc);
|
||||
} else if (Command.C.cmd == MachO::LC_THREAD ||
|
||||
Command.C.cmd == MachO::LC_UNIXTHREAD) {
|
||||
MachO::thread_command Tc = Obj->getThreadCommand(Command);
|
||||
PrintThreadCommand(Tc, Command.Ptr, Obj->isLittleEndian(), cputype);
|
||||
} else if (Command.C.cmd == MachO::LC_LOAD_DYLIB ||
|
||||
Command.C.cmd == MachO::LC_ID_DYLIB ||
|
||||
Command.C.cmd == MachO::LC_LOAD_WEAK_DYLIB ||
|
||||
|
||||
Reference in New Issue
Block a user