[Lldb-commits] x86_32 linux support
Stephen Wilson
wilsons at start.ca
Sat Feb 26 13:58:00 PST 2011
Marco, Greg,
On Sat, Feb 26, 2011 at 03:09:45PM +0100, Marco Minutoli wrote:
> Here is the patch with the changes you have requested.
Nice. This looks good.
Greg, mind if I commit this one? There is one trivial tweak needed to
avoid a compile time warning.
> Sorry for the duplicated header here It was late night(or maybe early
> in the morning :D) when I sent the patch to the ML. Next time I'll be
> more careful.
No worries! We still have a bit of work to do to support i386 on linux
but this is a significant step forward. Thanks so much!
> Best regards,
> Marco
>
> On Sat, Feb 26, 2011 at 1:25 AM, Stephen Wilson <wilsons at start.ca> wrote:
> > On Fri, Feb 25, 2011 at 02:52:51AM +0100, Marco Minutoli wrote:
> >> Hi everybody,
> >>
> >> as suggested by Stephen I had a look at the user_32.h Linux header and
> >> I fixed the UserArea structure.
> >>
> >> In the attachment the revised patch. As ever comments and suggestions
> >> are welcome :).
> >
> > This looks good. Only two small issues: the patch for
> > RegisterContextLinux_i386.h contains the old and new versions of your
> > patch (the latter is protected behind an #ifndef). Also, I think we
> > need the following patch for LinuxThread.cpp: Use a register context
> > according to the host instead of the process target so we can debug and
> > test lldb using 32-bit binaries on 64-bit systems.
> >
> > I have not been able to test your patch much yet -- another issue has
> > crept into the linux builds that I need to track down first... but with
> > those changes I think the patches can go in.
> >
> >
> >
> > Thanks again!
> >
> >
> > diff --git a/source/Plugins/Process/Linux/LinuxThread.cpp b/source/Plugins/Process/Linux/LinuxThread.cpp
> > index 397d31b..15bc9e3 100644
> > --- a/source/Plugins/Process/Linux/LinuxThread.cpp
> > +++ b/source/Plugins/Process/Linux/LinuxThread.cpp
> > @@ -12,6 +12,7 @@
> >
> > // C++ Includes
> > // Other libraries and framework includes
> > +#include "lldb/Host/Host.h"
> > #include "lldb/Target/Process.h"
> > #include "lldb/Target/StopInfo.h"
> > #include "lldb/Target/Target.h"
> > @@ -19,6 +20,7 @@
> > #include "LinuxThread.h"
> > #include "ProcessLinux.h"
> > #include "ProcessMonitor.h"
> > +#include "RegisterContextLinux_i386.h"
> > #include "RegisterContextLinux_x86_64.h"
> > #include "UnwindLLDB.h"
> >
> > @@ -59,11 +61,9 @@ LinuxThread::GetInfo()
> > lldb::RegisterContextSP
> > LinuxThread::GetRegisterContext()
> > {
> > - ProcessLinux &process = static_cast<ProcessLinux&>(GetProcess());
> > -
> > if (!m_reg_context_sp)
> > {
> > - ArchSpec arch = process.GetTarget().GetArchitecture();
> > + ArchSpec arch = Host::GetArchitecture();
> >
> > switch (arch.GetCore())
> > {
> > @@ -71,6 +71,12 @@ LinuxThread::GetRegisterContext()
> > assert(false && "CPU type not supported!");
> > break;
> >
> > + case ArchSpec::eCore_x86_32_i386:
> > + case ArchSpec::eCore_x86_32_i486:
> > + case ArchSpec::eCore_x86_32_i486sx:
> > + m_reg_context_sp.reset(new RegisterContextLinux_i386(*this, 0));
> > + break;
> > +
> > case ArchSpec::eCore_x86_64_x86_64:
> > m_reg_context_sp.reset(new RegisterContextLinux_x86_64(*this, 0));
> > break;
> >
>
>
>
> --
> Marco Minutoli
>
> "If A is success in life, then A equals x plus y plus z. Work is x;
> y is play; and z is keeping your mouth shut." --A. Einstein
> diff --git a/source/Plugins/Process/Linux/LinuxThread.cpp b/source/Plugins/Process/Linux/LinuxThread.cpp
> index 397d31b..8f3a273 100644
> --- a/source/Plugins/Process/Linux/LinuxThread.cpp
> +++ b/source/Plugins/Process/Linux/LinuxThread.cpp
> @@ -12,6 +12,7 @@
>
> // C++ Includes
> // Other libraries and framework includes
> +#include "lldb/Host/Host.h"
> #include "lldb/Target/Process.h"
> #include "lldb/Target/StopInfo.h"
> #include "lldb/Target/Target.h"
> @@ -19,6 +20,7 @@
> #include "LinuxThread.h"
> #include "ProcessLinux.h"
> #include "ProcessMonitor.h"
> +#include "RegisterContextLinux_i386.h"
> #include "RegisterContextLinux_x86_64.h"
> #include "UnwindLLDB.h"
>
> @@ -63,7 +65,7 @@ LinuxThread::GetRegisterContext()
>
> if (!m_reg_context_sp)
> {
> - ArchSpec arch = process.GetTarget().GetArchitecture();
> + ArchSpec arch = Host::GetArchitecture();
>
> switch (arch.GetCore())
> {
> @@ -71,6 +73,12 @@ LinuxThread::GetRegisterContext()
> assert(false && "CPU type not supported!");
> break;
>
> + case ArchSpec::eCore_x86_32_i386:
> + case ArchSpec::eCore_x86_32_i486:
> + case ArchSpec::eCore_x86_32_i486sx:
> + m_reg_context_sp.reset(new RegisterContextLinux_i386(*this, 0));
> + break;
> +
> case ArchSpec::eCore_x86_64_x86_64:
> m_reg_context_sp.reset(new RegisterContextLinux_x86_64(*this, 0));
> break;
> diff --git a/source/Plugins/Process/Linux/RegisterContextLinux_i386.cpp b/source/Plugins/Process/Linux/RegisterContextLinux_i386.cpp
> new file mode 100644
> index 0000000..b7451d2
> --- /dev/null
> +++ b/source/Plugins/Process/Linux/RegisterContextLinux_i386.cpp
> @@ -0,0 +1,633 @@
> +//===-- RegisterContextLinux_i386.cpp ----------------------------*- C++ -*-===//
> +//
> +// The LLVM Compiler Infrastructure
> +//
> +// This file is distributed under the University of Illinois Open Source
> +// License. See LICENSE.TXT for details.
> +//
> +//===----------------------------------------------------------------------===//
> +
> +#include "lldb/Core/DataExtractor.h"
> +#include "lldb/Target/Thread.h"
> +#include "lldb/Host/Endian.h"
> +
> +#include "ProcessLinux.h"
> +#include "ProcessMonitor.h"
> +#include "RegisterContextLinux_i386.h"
> +
> +using namespace lldb_private;
> +using namespace lldb;
> +
> +enum
> +{
> + k_first_gpr,
> + gpr_eax = k_first_gpr,
> + gpr_ebx,
> + gpr_ecx,
> + gpr_edx,
> + gpr_edi,
> + gpr_esi,
> + gpr_ebp,
> + gpr_esp,
> + gpr_ss,
> + gpr_eflags,
> + gpr_orig_ax,
> + gpr_eip,
> + gpr_cs,
> + gpr_ds,
> + gpr_es,
> + gpr_fs,
> + gpr_gs,
> + k_last_gpr = gpr_gs,
> +
> + k_first_fpr,
> + fpu_fcw = k_first_fpr,
> + fpu_fsw,
> + fpu_ftw,
> + fpu_fop,
> + fpu_ip,
> + fpu_cs,
> + fpu_foo,
> + fpu_fos,
> + fpu_mxcsr,
> + fpu_stmm0,
> + fpu_stmm1,
> + fpu_stmm2,
> + fpu_stmm3,
> + fpu_stmm4,
> + fpu_stmm5,
> + fpu_stmm6,
> + fpu_stmm7,
> + fpu_xmm0,
> + fpu_xmm1,
> + fpu_xmm2,
> + fpu_xmm3,
> + fpu_xmm4,
> + fpu_xmm5,
> + fpu_xmm6,
> + fpu_xmm7,
> + k_last_fpr = fpu_xmm7,
> +
> + k_num_registers,
> + k_num_gpr_registers = k_last_gpr - k_first_gpr + 1,
> + k_num_fpu_registers = k_last_fpr - k_first_fpr + 1
> +};
> +
> +// Number of register sets provided by this context.
> +enum
> +{
> + k_num_register_sets = 2
> +};
> +
> +enum
> +{
> + gcc_eax = 0,
> + gcc_ecx,
> + gcc_edx,
> + gcc_ebx,
> + gcc_ebp,
> + gcc_esp,
> + gcc_esi,
> + gcc_edi,
> + gcc_eip,
> + gcc_eflags
> +};
> +
> +enum
> +{
> + dwarf_eax = 0,
> + dwarf_ecx,
> + dwarf_edx,
> + dwarf_ebx,
> + dwarf_esp,
> + dwarf_ebp,
> + dwarf_esi,
> + dwarf_edi,
> + dwarf_eip,
> + dwarf_eflags,
> + dwarf_stmm0 = 11,
> + dwarf_stmm1,
> + dwarf_stmm2,
> + dwarf_stmm3,
> + dwarf_stmm4,
> + dwarf_stmm5,
> + dwarf_stmm6,
> + dwarf_stmm7,
> + dwarf_xmm0 = 21,
> + dwarf_xmm1,
> + dwarf_xmm2,
> + dwarf_xmm3,
> + dwarf_xmm4,
> + dwarf_xmm5,
> + dwarf_xmm6,
> + dwarf_xmm7
> +};
> +
> +enum
> +{
> + gdb_eax = 0,
> + gdb_ecx = 1,
> + gdb_edx = 2,
> + gdb_ebx = 3,
> + gdb_esp = 4,
> + gdb_ebp = 5,
> + gdb_esi = 6,
> + gdb_edi = 7,
> + gdb_eip = 8,
> + gdb_eflags = 9,
> + gdb_cs = 10,
> + gdb_ss = 11,
> + gdb_ds = 12,
> + gdb_es = 13,
> + gdb_fs = 14,
> + gdb_gs = 15,
> + gdb_stmm0 = 16,
> + gdb_stmm1 = 17,
> + gdb_stmm2 = 18,
> + gdb_stmm3 = 19,
> + gdb_stmm4 = 20,
> + gdb_stmm5 = 21,
> + gdb_stmm6 = 22,
> + gdb_stmm7 = 23,
> + gdb_fcw = 24,
> + gdb_fsw = 25,
> + gdb_ftw = 26,
> + gdb_fpu_cs = 27,
> + gdb_ip = 28,
> + gdb_fpu_ds = 29,
> + gdb_dp = 30,
> + gdb_fop = 31,
> + gdb_xmm0 = 32,
> + gdb_xmm1 = 33,
> + gdb_xmm2 = 34,
> + gdb_xmm3 = 35,
> + gdb_xmm4 = 36,
> + gdb_xmm5 = 37,
> + gdb_xmm6 = 38,
> + gdb_xmm7 = 39,
> + gdb_mxcsr = 40,
> + gdb_mm0 = 41,
> + gdb_mm1 = 42,
> + gdb_mm2 = 43,
> + gdb_mm3 = 44,
> + gdb_mm4 = 45,
> + gdb_mm5 = 46,
> + gdb_mm6 = 47,
> + gdb_mm7 = 48
> +};
> +
> +static const
> +uint32_t g_gpr_regnums[k_num_gpr_registers] =
> +{
> + gpr_eax,
> + gpr_ebx,
> + gpr_ecx,
> + gpr_edx,
> + gpr_edi,
> + gpr_esi,
> + gpr_ebp,
> + gpr_esp,
> + gpr_ss,
> + gpr_eflags,
> + gpr_orig_ax,
> + gpr_eip,
> + gpr_cs,
> + gpr_ds,
> + gpr_es,
> + gpr_fs,
> + gpr_gs,
> +};
> +
> +static const uint32_t
> +g_fpu_regnums[k_num_fpu_registers] =
> +{
> + fpu_fcw,
> + fpu_fsw,
> + fpu_ftw,
> + fpu_fop,
> + fpu_ip,
> + fpu_cs,
> + fpu_foo,
> + fpu_fos,
> + fpu_mxcsr,
> + fpu_stmm0,
> + fpu_stmm1,
> + fpu_stmm2,
> + fpu_stmm3,
> + fpu_stmm4,
> + fpu_stmm5,
> + fpu_stmm6,
> + fpu_stmm7,
> + fpu_xmm0,
> + fpu_xmm1,
> + fpu_xmm2,
> + fpu_xmm3,
> + fpu_xmm4,
> + fpu_xmm5,
> + fpu_xmm6,
> + fpu_xmm7,
> +};
> +
> +static const RegisterSet
> +g_reg_sets[k_num_register_sets] =
> +{
> + { "General Purpose Registers", "gpr", k_num_gpr_registers, g_gpr_regnums },
> + { "Floating Point Registers", "fpu", k_num_fpu_registers, g_fpu_regnums }
> +};
> +
> +// Computes the offset of the given GPR in the user data area.
> +#define GPR_OFFSET(regname) \
> + (offsetof(RegisterContextLinux_i386::UserArea, regs) + \
> + offsetof(RegisterContextLinux_i386::GPR, regname))
> +
> +// Computes the offset of the given FPR in the user data area.
> +#define FPR_OFFSET(regname) \
> + (offsetof(RegisterContextLinux_i386::UserArea, i387) + \
> + offsetof(RegisterContextLinux_i386::FPU, regname))
> +
> +// Number of bytes needed to represent a GPR.
> +#define GPR_SIZE(reg) sizeof(((RegisterContextLinux_i386::GPR*)NULL)->reg)
> +
> +// Number of bytes needed to represent a FPR.
> +#define FPR_SIZE(reg) sizeof(((RegisterContextLinux_i386::FPU*)NULL)->reg)
> +
> +// Number of bytes needed to represent the i'th FP register.
> +#define FP_SIZE sizeof(((RegisterContextLinux_i386::MMSReg*)NULL)->bytes)
> +
> +// Number of bytes needed to represent an XMM register.
> +#define XMM_SIZE sizeof(RegisterContextLinux_i386::XMMReg)
> +
> +#define DEFINE_GPR(reg, alt, kind1, kind2, kind3, kind4) \
> + { #reg, alt, GPR_SIZE(reg), GPR_OFFSET(reg), eEncodingUint, \
> + eFormatHex, { kind1, kind2, kind3, kind4, gpr_##reg } }
> +
> +#define DEFINE_FPR(reg, kind1, kind2, kind3, kind4) \
> + { #reg, NULL, FPR_SIZE(reg), FPR_OFFSET(reg), eEncodingUint, \
> + eFormatHex, { kind1, kind2, kind3, kind4, fpu_##reg } }
> +
> +#define DEFINE_FP(reg, i) \
> + { #reg#i, NULL, FP_SIZE, FPR_OFFSET(reg[i]), eEncodingVector, \
> + eFormatVectorOfUInt8, \
> + { dwarf_##reg##i, dwarf_##reg##i, \
> + LLDB_INVALID_REGNUM, gdb_##reg##i, fpu_##reg##i } }
> +
> +#define DEFINE_XMM(reg, i) \
> + { #reg#i, NULL, XMM_SIZE, FPR_OFFSET(reg[i]), eEncodingVector, \
> + eFormatVectorOfUInt8, \
> + { dwarf_##reg##i, dwarf_##reg##i, \
> + LLDB_INVALID_REGNUM, gdb_##reg##i, fpu_##reg##i } }
> +
> +static RegisterInfo
> +g_register_infos[k_num_registers] =
> +{
> + // General purpose registers.
> + DEFINE_GPR(eax, NULL, gcc_eax, dwarf_eax, LLDB_INVALID_REGNUM, gdb_eax),
> + DEFINE_GPR(ebx, NULL, gcc_ebx, dwarf_ebx, LLDB_INVALID_REGNUM, gdb_ebx),
> + DEFINE_GPR(ecx, NULL, gcc_ecx, dwarf_ecx, LLDB_INVALID_REGNUM, gdb_ecx),
> + DEFINE_GPR(edx, NULL, gcc_edx, dwarf_edx, LLDB_INVALID_REGNUM, gdb_edx),
> + DEFINE_GPR(edi, NULL, gcc_edi, dwarf_edi, LLDB_INVALID_REGNUM, gdb_edi),
> + DEFINE_GPR(esi, NULL, gcc_esi, dwarf_esi, LLDB_INVALID_REGNUM, gdb_esi),
> + DEFINE_GPR(ebp, "fp", gcc_ebp, dwarf_ebp, LLDB_INVALID_REGNUM, gdb_ebp),
> + DEFINE_GPR(esp, "sp", gcc_esp, dwarf_esp, LLDB_INVALID_REGNUM, gdb_esp),
> + DEFINE_GPR(ss, NULL, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, gdb_ss),
> + DEFINE_GPR(eflags, "flags", gcc_eflags, dwarf_eflags, LLDB_INVALID_REGNUM, gdb_eflags),
> + DEFINE_GPR(eip, "pc", gcc_eip, dwarf_eip, LLDB_INVALID_REGNUM, gdb_eip),
> + DEFINE_GPR(cs, NULL, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, gdb_cs),
> + DEFINE_GPR(ds, NULL, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, gdb_ds),
> + DEFINE_GPR(es, NULL, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, gdb_es),
> + DEFINE_GPR(fs, NULL, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, gdb_fs),
> + DEFINE_GPR(gs, NULL, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, gdb_gs),
> +
> + // Floating point registers.
> + DEFINE_FPR(fcw, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, gdb_fcw),
> + DEFINE_FPR(fsw, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, gdb_fsw),
> + DEFINE_FPR(ftw, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, gdb_ftw),
> + DEFINE_FPR(fop, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, gdb_fop),
> + DEFINE_FPR(ip, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, gdb_ip),
> + DEFINE_FPR(cs, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, gdb_fpu_cs),
> + DEFINE_FPR(foo, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, gdb_dp),
> + DEFINE_FPR(fos, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, gdb_fpu_ds),
> + DEFINE_FPR(mxcsr, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, LLDB_INVALID_REGNUM, gdb_mxcsr),
> +
> + DEFINE_FP(stmm, 0),
> + DEFINE_FP(stmm, 1),
> + DEFINE_FP(stmm, 2),
> + DEFINE_FP(stmm, 3),
> + DEFINE_FP(stmm, 4),
> + DEFINE_FP(stmm, 5),
> + DEFINE_FP(stmm, 6),
> + DEFINE_FP(stmm, 7),
> +
> + // XMM registers
> + DEFINE_XMM(xmm, 0),
> + DEFINE_XMM(xmm, 1),
> + DEFINE_XMM(xmm, 2),
> + DEFINE_XMM(xmm, 3),
> + DEFINE_XMM(xmm, 4),
> + DEFINE_XMM(xmm, 5),
> + DEFINE_XMM(xmm, 6),
> + DEFINE_XMM(xmm, 7),
> +
> +};
> +
> +static unsigned GetRegOffset(unsigned reg)
> +{
> + assert(reg < k_num_registers && "Invalid register number.");
> + return g_register_infos[reg].byte_offset;
> +}
> +
> +static unsigned GetRegSize(unsigned reg)
> +{
> + assert(reg < k_num_registers && "Invalid register number.");
> + return g_register_infos[reg].byte_size;
> +}
> +
> +static bool IsGPR(unsigned reg)
> +{
> + return reg <= k_last_gpr; // GPR's come first.
> +}
> +
> +static bool IsFPR(unsigned reg)
> +{
> + return (k_first_fpr <= reg && reg <= k_last_fpr);
> +}
> +
> +
> +RegisterContextLinux_i386::RegisterContextLinux_i386(Thread &thread,
> + uint32_t concrete_frame_idx)
> + : RegisterContextLinux(thread, concrete_frame_idx)
> +{
> +}
> +
> +RegisterContextLinux_i386::~RegisterContextLinux_i386()
> +{
> +}
> +
> +ProcessMonitor &
> +RegisterContextLinux_i386::GetMonitor()
> +{
> + ProcessLinux *process = static_cast<ProcessLinux*>(CalculateProcess());
> + return process->GetMonitor();
> +}
> +
> +void
> +RegisterContextLinux_i386::Invalidate()
> +{
> +}
> +
> +void
> +RegisterContextLinux_i386::InvalidateAllRegisters()
> +{
> +}
> +
> +size_t
> +RegisterContextLinux_i386::GetRegisterCount()
> +{
> + return k_num_registers;
> +}
> +
> +const RegisterInfo *
> +RegisterContextLinux_i386::GetRegisterInfoAtIndex(uint32_t reg)
> +{
> + if (reg < k_num_registers)
> + return &g_register_infos[reg];
> + else
> + return NULL;
> +}
> +
> +size_t
> +RegisterContextLinux_i386::GetRegisterSetCount()
> +{
> + return k_num_register_sets;
> +}
> +
> +const RegisterSet *
> +RegisterContextLinux_i386::GetRegisterSet(uint32_t set)
> +{
> + if (set < k_num_register_sets)
> + return &g_reg_sets[set];
> + else
> + return NULL;
> +}
> +
> +bool
> +RegisterContextLinux_i386::ReadRegisterValue(uint32_t reg,
> + Scalar &value)
> +{
> + ProcessMonitor &monitor = GetMonitor();
> + return monitor.ReadRegisterValue(GetRegOffset(reg), value);
> +}
> +
> +bool
> +RegisterContextLinux_i386::ReadRegisterBytes(uint32_t reg,
> + DataExtractor &data)
> +{
> + uint8_t *buf = reinterpret_cast<uint8_t*>(&user);
> + bool status;
> +
> + if (IsGPR(reg))
> + status = ReadGPR();
> + else if (IsFPR(reg))
> + status = ReadFPR();
> + else
> + {
> + assert(false && "invalid register number");
> + status = false;
> + }
> +
> + if (status)
> + data.SetData(buf + GetRegOffset(reg), GetRegSize(reg), lldb::endian::InlHostByteOrder());
> +
> + return status;
> +}
> +
> +bool
> +RegisterContextLinux_i386::ReadAllRegisterValues(DataBufferSP &data_sp)
> +{
> + return false;
> +}
> +
> +bool
> +RegisterContextLinux_i386::WriteRegisterValue(uint32_t reg,
> + const Scalar &value)
> +{
> + ProcessMonitor &monitor = GetMonitor();
> + return monitor.WriteRegisterValue(GetRegOffset(reg), value);
> +}
> +
> +bool
> +RegisterContextLinux_i386::WriteRegisterBytes(uint32_t reg,
> + DataExtractor &data,
> + uint32_t data_offset)
> +{
> + return false;
> +}
> +
> +bool
> +RegisterContextLinux_i386::WriteAllRegisterValues(const DataBufferSP &data)
> +{
> + return false;
> +}
> +
> +bool
> +RegisterContextLinux_i386::UpdateAfterBreakpoint()
> +{
> + // PC points one byte past the int3 responsible for the breakpoint.
> + lldb::addr_t pc;
> +
> + if ((pc = GetPC()) == LLDB_INVALID_ADDRESS)
> + return false;
> +
> + SetPC(pc - 1);
> + return true;
> +}
> +
> +uint32_t
> +RegisterContextLinux_i386::ConvertRegisterKindToRegisterNumber(uint32_t kind,
> + uint32_t num)
> +{
> + if (kind == eRegisterKindGeneric)
> + {
> + switch (num)
> + {
> + case LLDB_REGNUM_GENERIC_PC: return gpr_eip;
> + case LLDB_REGNUM_GENERIC_SP: return gpr_esp;
> + case LLDB_REGNUM_GENERIC_FP: return gpr_ebp;
> + case LLDB_REGNUM_GENERIC_FLAGS: return gpr_eflags;
> + case LLDB_REGNUM_GENERIC_RA:
> + default:
> + return LLDB_INVALID_REGNUM;
> + }
> + }
> +
> + if (kind == eRegisterKindGCC || kind == eRegisterKindDWARF)
> + {
> + switch (num)
> + {
> + case dwarf_eax: return gpr_eax;
> + case dwarf_edx: return gpr_edx;
> + case dwarf_ecx: return gpr_ecx;
> + case dwarf_ebx: return gpr_ebx;
> + case dwarf_esi: return gpr_esi;
> + case dwarf_edi: return gpr_edi;
> + case dwarf_ebp: return gpr_ebp;
> + case dwarf_esp: return gpr_esp;
> + case dwarf_eip: return gpr_eip;
> + case dwarf_xmm0: return fpu_xmm0;
> + case dwarf_xmm1: return fpu_xmm1;
> + case dwarf_xmm2: return fpu_xmm2;
> + case dwarf_xmm3: return fpu_xmm3;
> + case dwarf_xmm4: return fpu_xmm4;
> + case dwarf_xmm5: return fpu_xmm5;
> + case dwarf_xmm6: return fpu_xmm6;
> + case dwarf_xmm7: return fpu_xmm7;
> + case dwarf_stmm0: return fpu_stmm0;
> + case dwarf_stmm1: return fpu_stmm1;
> + case dwarf_stmm2: return fpu_stmm2;
> + case dwarf_stmm3: return fpu_stmm3;
> + case dwarf_stmm4: return fpu_stmm4;
> + case dwarf_stmm5: return fpu_stmm5;
> + case dwarf_stmm6: return fpu_stmm6;
> + case dwarf_stmm7: return fpu_stmm7;
> + default:
> + return LLDB_INVALID_REGNUM;
> + }
> + }
> +
> + if (kind == eRegisterKindGDB)
> + {
> + switch (num)
> + {
> + case gdb_eax : return gpr_eax;
> + case gdb_ebx : return gpr_ebx;
> + case gdb_ecx : return gpr_ecx;
> + case gdb_edx : return gpr_edx;
> + case gdb_esi : return gpr_esi;
> + case gdb_edi : return gpr_edi;
> + case gdb_ebp : return gpr_ebp;
> + case gdb_esp : return gpr_esp;
> + case gdb_eip : return gpr_eip;
> + case gdb_eflags : return gpr_eflags;
> + case gdb_cs : return gpr_cs;
> + case gdb_ss : return gpr_ss;
> + case gdb_ds : return gpr_ds;
> + case gdb_es : return gpr_es;
> + case gdb_fs : return gpr_fs;
> + case gdb_gs : return gpr_gs;
> + case gdb_stmm0 : return fpu_stmm0;
> + case gdb_stmm1 : return fpu_stmm1;
> + case gdb_stmm2 : return fpu_stmm2;
> + case gdb_stmm3 : return fpu_stmm3;
> + case gdb_stmm4 : return fpu_stmm4;
> + case gdb_stmm5 : return fpu_stmm5;
> + case gdb_stmm6 : return fpu_stmm6;
> + case gdb_stmm7 : return fpu_stmm7;
> + case gdb_fcw : return fpu_fcw;
> + case gdb_fsw : return fpu_fsw;
> + case gdb_ftw : return fpu_ftw;
> + case gdb_fpu_cs : return fpu_cs;
> + case gdb_ip : return fpu_ip;
> + case gdb_fpu_ds : return fpu_fos;
> + case gdb_dp : return fpu_foo;
> + case gdb_fop : return fpu_fop;
> + case gdb_xmm0 : return fpu_xmm0;
> + case gdb_xmm1 : return fpu_xmm1;
> + case gdb_xmm2 : return fpu_xmm2;
> + case gdb_xmm3 : return fpu_xmm3;
> + case gdb_xmm4 : return fpu_xmm4;
> + case gdb_xmm5 : return fpu_xmm5;
> + case gdb_xmm6 : return fpu_xmm6;
> + case gdb_xmm7 : return fpu_xmm7;
> + case gdb_mxcsr : return fpu_mxcsr;
> + default:
> + return LLDB_INVALID_REGNUM;
> + }
> + }
> + else if (kind == eRegisterKindLLDB)
> + {
> + return num;
> + }
> +
> + return LLDB_INVALID_REGNUM;
> +}
> +
> +bool
> +RegisterContextLinux_i386::HardwareSingleStep(bool enable)
> +{
> + enum { TRACE_BIT = 0x100 };
> + uint64_t eflags;
> +
> + if ((eflags = ReadRegisterAsUnsigned(gpr_eflags, -1UL)) == -1UL)
> + return false;
> +
> + if (enable)
> + {
> + if (eflags & TRACE_BIT)
> + return true;
> +
> + eflags |= TRACE_BIT;
> + }
> + else
> + {
> + if (!(eflags & TRACE_BIT))
> + return false;
> +
> + eflags &= ~TRACE_BIT;
> + }
> +
> + return WriteRegisterFromUnsigned(gpr_eflags, eflags);
> +}
> +
> +bool
> +RegisterContextLinux_i386::ReadGPR()
> +{
> + ProcessMonitor &monitor = GetMonitor();
> + return monitor.ReadGPR(&user.regs);
> +}
> +
> +bool
> +RegisterContextLinux_i386::ReadFPR()
> +{
> + ProcessMonitor &monitor = GetMonitor();
> + return monitor.ReadFPR(&user.i387);
> +}
> diff --git a/source/Plugins/Process/Linux/RegisterContextLinux_i386.h b/source/Plugins/Process/Linux/RegisterContextLinux_i386.h
> new file mode 100644
> index 0000000..30b3d70
> --- /dev/null
> +++ b/source/Plugins/Process/Linux/RegisterContextLinux_i386.h
> @@ -0,0 +1,148 @@
> +//===-- RegisterContextLinux_i386.h ------------------------------*- C++ -*-===//
> +//
> +// The LLVM Compiler Infrastructure
> +//
> +// This file is distributed under the University of Illinois Open Source
> +// License. See LICENSE.TXT for details.
> +//
> +//===----------------------------------------------------------------------===//
> +
> +#ifndef liblldb_RegisterContextLinux_i386_h_
> +#define liblldb_RegisterContextLinux_i386_h_
> +
> +// C Includes
> +// C++ Includes
> +// Other libraries and framework includes
> +// Project includes
> +#include "RegisterContextLinux.h"
> +
> +class RegisterContextLinux_i386 : public RegisterContextLinux
> +{
> +public:
> + RegisterContextLinux_i386(lldb_private::Thread &thread,
> + uint32_t concreate_frame_idx);
> +
> + ~RegisterContextLinux_i386();
> +
> + void
> + Invalidate();
> +
> + void
> + InvalidateAllRegisters();
> +
> + size_t
> + GetRegisterCount();
> +
> + const lldb::RegisterInfo *
> + GetRegisterInfoAtIndex(uint32_t reg);
> +
> + size_t
> + GetRegisterSetCount();
> +
> + const lldb::RegisterSet *
> + GetRegisterSet(uint32_t set);
> +
> + bool
> + ReadRegisterValue(uint32_t reg, lldb_private::Scalar &value);
> +
> + bool
> + ReadRegisterBytes(uint32_t reg, lldb_private::DataExtractor &data);
> +
> + bool
> + ReadAllRegisterValues(lldb::DataBufferSP &data_sp);
> +
> + bool
> + WriteRegisterValue(uint32_t reg, const lldb_private::Scalar &value);
> +
> + bool
> + WriteRegisterBytes(uint32_t reg, lldb_private::DataExtractor &data,
> + uint32_t data_offset = 0);
> +
> + bool
> + WriteAllRegisterValues(const lldb::DataBufferSP &data_sp);
> +
> + uint32_t
> + ConvertRegisterKindToRegisterNumber(uint32_t kind, uint32_t num);
> +
> + bool
> + HardwareSingleStep(bool enable);
> +
> + bool
> + UpdateAfterBreakpoint();
> +
> + struct GPR
> + {
> + uint32_t ebx;
> + uint32_t ecx;
> + uint32_t edx;
> + uint32_t esi;
> + uint32_t edi;
> + uint32_t ebp;
> + uint32_t eax;
> + uint32_t ds;
> + uint32_t es;
> + uint32_t fs;
> + uint32_t gs;
> + uint32_t orig_ax;
> + uint32_t eip;
> + uint32_t cs;
> + uint32_t eflags;
> + uint32_t esp;
> + uint32_t ss;
> + };
> +
> + struct MMSReg
> + {
> + uint8_t bytes[8];
> + };
> +
> + struct XMMReg
> + {
> + uint8_t bytes[16];
> + };
> +
> + struct FPU
> + {
> + uint16_t fcw;
> + uint16_t fsw;
> + uint16_t ftw;
> + uint16_t fop;
> + uint32_t ip;
> + uint32_t cs;
> + uint32_t foo;
> + uint32_t fos;
> + uint32_t mxcsr;
> + uint32_t reserved;
> + MMSReg stmm[8];
> + XMMReg xmm[8];
> + uint32_t pad[56];
> + };
> +
> + struct UserArea
> + {
> + GPR regs; // General purpose registers.
> + int32_t fpvalid; // True if FPU is being used.
> + FPU i387; // FPU registers.
> + uint32_t tsize; // Text segment size.
> + uint32_t dsize; // Data segment size.
> + uint32_t ssize; // Stack segment size.
> + uint32_t start_code; // VM address of text.
> + uint32_t start_stack; // VM address of stack bottom (top in rsp).
> + int32_t signal; // Signal causing core dump.
> + int32_t reserved; // Unused.
> + uint32_t ar0; // Location of GPR's.
> + FPU* fpstate; // Location of FPR's.
> + uint32_t magic; // Identifier for core dumps.
> + char u_comm[32]; // Command causing core dump.
> + uint32_t u_debugreg[8]; // Debug registers (DR0 - DR7).
> + };
> +private:
> + UserArea user;
> +
> + ProcessMonitor &GetMonitor();
> +
> + bool ReadGPR();
> + bool ReadFPR();
> +};
> +
> +#endif // #ifndef liblldb_RegisterContextLinux_i386_h_
--
steve
More information about the lldb-commits
mailing list