Ticket #8877: debugger_x86-64.patch

src/apps/debugger/Jamfile

@@ -9 +9 @@
 
 SEARCH_SOURCE += [ FDirName $(SUBDIR) arch ] ;
 SEARCH_SOURCE += [ FDirName $(SUBDIR) arch x86 ] ;
+SEARCH_SOURCE += [ FDirName $(SUBDIR) arch x86_64 ] ;
 SEARCH_SOURCE += [ FDirName $(SUBDIR) debug_info ] ;
 SEARCH_SOURCE += [ FDirName $(SUBDIR) debugger_interface ] ;
 SEARCH_SOURCE += [ FDirName $(SUBDIR) elf ] ;
@@ -74 +75 @@
     ArchitectureX86.cpp
     CpuStateX86.cpp
 
+    # arch/x86_64
+    ArchitectureX86_64.cpp
+    CpuStateX86_64.cpp
+
     # debug_info
     BasicFunctionDebugInfo.cpp
     DebuggerImageDebugInfo.cpp

new file src/apps/debugger/arch/x86_64/ArchitectureX86_64.cpp

@@ +1 @@
+/*
+ * Copyright 2009-2012, Ingo Weinhold, ingo_weinhold@gmx.de.
+ * Copyright 2011-2012, Rene Gollent, rene@gollent.com.
+ * Distributed under the terms of the MIT License.
+ */
+
+
+#include "ArchitectureX86_64.h"
+
+#include <new>
+
+#include <String.h>
+
+#include <AutoDeleter.h>
+
+#include "CfaContext.h"
+#include "CpuStateX86_64.h"
+#include "DisassembledCode.h"
+#include "FunctionDebugInfo.h"
+#include "InstructionInfo.h"
+#include "NoOpStackFrameDebugInfo.h"
+#include "RegisterMap.h"
+#include "StackFrame.h"
+#include "Statement.h"
+#include "TeamMemory.h"
+#include "X86AssemblyLanguage.h"
+
+#include "disasm/DisassemblerX86.h"
+
+
+// source: http://www.x86-64.org/documentation/abi.pdf
+static const int32 kFromDwarfRegisters[] = {
+    X86_64_REGISTER_RAX,
+    X86_64_REGISTER_RDX,
+    X86_64_REGISTER_RCX,
+    X86_64_REGISTER_RBX,
+    X86_64_REGISTER_RSI,
+    X86_64_REGISTER_RDI,
+    X86_64_REGISTER_RBP,
+    X86_64_REGISTER_RSP,
+    X86_64_REGISTER_R8,
+    X86_64_REGISTER_R9,
+    X86_64_REGISTER_R10,
+    X86_64_REGISTER_R11,
+    X86_64_REGISTER_R12,
+    X86_64_REGISTER_R13,
+    X86_64_REGISTER_R14,
+    X86_64_REGISTER_R15,
+    -1, // RA
+    -1, -1, -1, -1, -1, -1, -1, -1, // xmm0-xmm7
+    -1, -1, -1, -1, -1, -1, -1, -1, // xmm8-xmm15
+    -1, -1, -1, -1, -1, -1, -1, -1, // st0-st7
+    -1, -1, -1, -1, -1, -1, -1, -1, // mm0-mm7
+    -1, // rflags
+    -1, // es
+    X86_64_REGISTER_CS,
+    -1, // ss
+    -1, // ds
+    X86_64_REGISTER_FS,
+    X86_64_REGISTER_GS,
+
+};
+static const int32 kFromDwarfRegisterCount = sizeof(kFromDwarfRegisters) / 4;
+
+
+// #pragma mark - ToDwarfRegisterMap
+
+
+struct ArchitectureX86_64::ToDwarfRegisterMap : RegisterMap {
+    ToDwarfRegisterMap()
+    {
+        // init the index array from the reverse map
+        memset(fIndices, -1, sizeof(fIndices));
+        for (int32 i = 0; i < kFromDwarfRegisterCount; i++) {
+            if (kFromDwarfRegisters[i] >= 0)
+                fIndices[kFromDwarfRegisters[i]] = i;
+        }
+    }
+
+    virtual int32 CountRegisters() const
+    {
+        return X86_64_REGISTER_COUNT;
+    }
+
+    virtual int32 MapRegisterIndex(int32 index) const
+    {
+        return index >= 0 && index < X86_64_REGISTER_COUNT ? fIndices[index] : -1;
+    }
+
+private:
+    int32   fIndices[X86_64_REGISTER_COUNT];
+};
+
+
+// #pragma mark - FromDwarfRegisterMap
+
+
+struct ArchitectureX86_64::FromDwarfRegisterMap : RegisterMap {
+    virtual int32 CountRegisters() const
+    {
+        return kFromDwarfRegisterCount;
+    }
+
+    virtual int32 MapRegisterIndex(int32 index) const
+    {
+        return index >= 0 && index < kFromDwarfRegisterCount
+            ? kFromDwarfRegisters[index] : -1;
+    }
+};
+
+
+// #pragma mark - ArchitectureX86_64
+
+
+ArchitectureX86_64::ArchitectureX86_64(TeamMemory* teamMemory)
+    :
+    Architecture(teamMemory, 4, false),
+    fAssemblyLanguage(NULL),
+    fToDwarfRegisterMap(NULL),
+    fFromDwarfRegisterMap(NULL)
+{
+}
+
+
+ArchitectureX86_64::~ArchitectureX86_64()
+{
+    if (fToDwarfRegisterMap != NULL)
+        fToDwarfRegisterMap->ReleaseReference();
+    if (fFromDwarfRegisterMap != NULL)
+        fFromDwarfRegisterMap->ReleaseReference();
+    if (fAssemblyLanguage != NULL)
+        fAssemblyLanguage->ReleaseReference();
+}
+
+
+status_t
+ArchitectureX86_64::Init()
+{
+    fAssemblyLanguage = new(std::nothrow) X86AssemblyLanguage;
+    if (fAssemblyLanguage == NULL)
+        return B_NO_MEMORY;
+
+    try {
+        _AddIntegerRegister(X86_64_REGISTER_RIP, "rip", B_UINT64_TYPE,
+            REGISTER_TYPE_INSTRUCTION_POINTER, false);
+        _AddIntegerRegister(X86_64_REGISTER_RSP, "rsp", B_UINT64_TYPE,
+            REGISTER_TYPE_STACK_POINTER, true);
+        _AddIntegerRegister(X86_64_REGISTER_RBP, "rbp", B_UINT64_TYPE,
+            REGISTER_TYPE_GENERAL_PURPOSE, true);
+
+        _AddIntegerRegister(X86_64_REGISTER_RAX, "rax", B_UINT64_TYPE,
+            REGISTER_TYPE_GENERAL_PURPOSE, false);
+        _AddIntegerRegister(X86_64_REGISTER_RBX, "rbx", B_UINT64_TYPE,
+            REGISTER_TYPE_GENERAL_PURPOSE, true);
+        _AddIntegerRegister(X86_64_REGISTER_RCX, "rcx", B_UINT64_TYPE,
+            REGISTER_TYPE_GENERAL_PURPOSE, false);
+        _AddIntegerRegister(X86_64_REGISTER_RDX, "rdx", B_UINT64_TYPE,
+            REGISTER_TYPE_GENERAL_PURPOSE, false);
+
+        _AddIntegerRegister(X86_64_REGISTER_RSI, "rsi", B_UINT64_TYPE,
+            REGISTER_TYPE_GENERAL_PURPOSE, true);
+        _AddIntegerRegister(X86_64_REGISTER_RDI, "rdi", B_UINT64_TYPE,
+            REGISTER_TYPE_GENERAL_PURPOSE, true);
+
+        _AddIntegerRegister(X86_64_REGISTER_R8, "r8", B_UINT64_TYPE,
+            REGISTER_TYPE_GENERAL_PURPOSE, true);
+        _AddIntegerRegister(X86_64_REGISTER_R9, "r9", B_UINT64_TYPE,
+            REGISTER_TYPE_GENERAL_PURPOSE, true);
+        _AddIntegerRegister(X86_64_REGISTER_R10, "r10", B_UINT64_TYPE,
+            REGISTER_TYPE_GENERAL_PURPOSE, true);
+        _AddIntegerRegister(X86_64_REGISTER_R11, "r11", B_UINT64_TYPE,
+            REGISTER_TYPE_GENERAL_PURPOSE, true);
+        _AddIntegerRegister(X86_64_REGISTER_R12, "r12", B_UINT64_TYPE,
+            REGISTER_TYPE_GENERAL_PURPOSE, true);
+        _AddIntegerRegister(X86_64_REGISTER_R13, "r13", B_UINT64_TYPE,
+            REGISTER_TYPE_GENERAL_PURPOSE, true);
+        _AddIntegerRegister(X86_64_REGISTER_R14, "r14", B_UINT64_TYPE,
+            REGISTER_TYPE_GENERAL_PURPOSE, true);
+        _AddIntegerRegister(X86_64_REGISTER_R15, "r15", B_UINT64_TYPE,
+            REGISTER_TYPE_GENERAL_PURPOSE, true);
+
+        _AddIntegerRegister(X86_64_REGISTER_CS, "cs", B_UINT16_TYPE,
+            REGISTER_TYPE_SPECIAL_PURPOSE, true);
+        _AddIntegerRegister(X86_64_REGISTER_FS, "fs", B_UINT16_TYPE,
+            REGISTER_TYPE_SPECIAL_PURPOSE, true);
+        _AddIntegerRegister(X86_64_REGISTER_GS, "gs", B_UINT16_TYPE,
+            REGISTER_TYPE_SPECIAL_PURPOSE, true);
+
+    } catch (std::bad_alloc) {
+        return B_NO_MEMORY;
+    }
+
+    fToDwarfRegisterMap = new(std::nothrow) ToDwarfRegisterMap;
+    fFromDwarfRegisterMap = new(std::nothrow) FromDwarfRegisterMap;
+
+    if (fToDwarfRegisterMap == NULL || fFromDwarfRegisterMap == NULL)
+        return B_NO_MEMORY;
+
+    return B_OK;
+}
+
+
+int32
+ArchitectureX86_64::StackGrowthDirection() const
+{
+    return STACK_GROWTH_DIRECTION_NEGATIVE;
+}
+
+
+int32
+ArchitectureX86_64::CountRegisters() const
+{
+    return fRegisters.Count();
+}
+
+
+const Register*
+ArchitectureX86_64::Registers() const
+{
+    return fRegisters.Elements();
+}
+
+
+status_t
+ArchitectureX86_64::InitRegisterRules(CfaContext& context) const
+{
+    status_t error = Architecture::InitRegisterRules(context);
+    if (error != B_OK)
+        return error;
+
+    // set up rule for RIP register
+    context.RegisterRule(fToDwarfRegisterMap->MapRegisterIndex(
+        X86_64_REGISTER_RIP))->SetToLocationOffset(-4);
+
+    return B_OK;
+}
+
+status_t
+ArchitectureX86_64::GetDwarfRegisterMaps(RegisterMap** _toDwarf,
+    RegisterMap** _fromDwarf) const
+{
+    if (_toDwarf != NULL) {
+        *_toDwarf = fToDwarfRegisterMap;
+        fToDwarfRegisterMap->AcquireReference();
+    }
+
+    if (_fromDwarf != NULL) {
+        *_fromDwarf = fFromDwarfRegisterMap;
+        fFromDwarfRegisterMap->AcquireReference();
+    }
+
+    return B_OK;
+}
+
+
+status_t
+ArchitectureX86_64::CreateCpuState(CpuState*& _state)
+{
+    CpuStateX86_64* state = new(std::nothrow) CpuStateX86_64;
+    if (state == NULL)
+        return B_NO_MEMORY;
+
+    _state = state;
+    return B_OK;
+}
+
+
+status_t
+ArchitectureX86_64::CreateCpuState(const void* cpuStateData, size_t size,
+    CpuState*& _state)
+{
+    if (size != sizeof(x86_debug_cpu_state))
+        return B_BAD_VALUE;
+
+    CpuStateX86_64* state = new(std::nothrow) CpuStateX86_64(
+        *(const x86_64_debug_cpu_state*)cpuStateData);
+    if (state == NULL)
+        return B_NO_MEMORY;
+
+    _state = state;
+    return B_OK;
+}
+
+
+status_t
+ArchitectureX86_64::CreateStackFrame(Image* image, FunctionDebugInfo* function,
+    CpuState* _cpuState, bool isTopFrame, StackFrame*& _frame,
+    CpuState*& _previousCpuState)
+{
+    CpuStateX86_64* cpuState = dynamic_cast<CpuStateX86_64*>(_cpuState);
+
+    uint64 framePointer = cpuState->IntRegisterValue(X86_64_REGISTER_RBP);
+    uint64 eip = cpuState->IntRegisterValue(X86_64_REGISTER_RIP);
+
+    bool readStandardFrame = true;
+    uint64 previousFramePointer = 0;
+    uint64 returnAddress = 0;
+
+    // check for syscall frames
+    stack_frame_type frameType;
+    bool hasPrologue = false;
+    if (isTopFrame && cpuState->InterruptVector() == 99) {
+        // The thread is performing a syscall. So this frame is not really the
+        // top-most frame and we need to adjust the eip.
+        frameType = STACK_FRAME_TYPE_SYSCALL;
+        eip -= 2;
+            // int 99, sysenter, and syscall all are 2 byte instructions
+
+        // The syscall stubs are frameless, the return address is on top of the
+        // stack.
+        uint64 rsp = cpuState->IntRegisterValue(X86_64_REGISTER_RSP);
+        uint64 address;
+        if (fTeamMemory->ReadMemory(rsp, &address, 8) == 8) {
+            returnAddress = address;
+            previousFramePointer = framePointer;
+            framePointer = 0;
+            readStandardFrame = false;
+        }
+    } else {
+        hasPrologue = _HasFunctionPrologue(function);
+        if (hasPrologue)
+            frameType = STACK_FRAME_TYPE_STANDARD;
+        else
+            frameType = STACK_FRAME_TYPE_FRAMELESS;
+        // TODO: Handling for frameless functions. It's not trivial to find the
+        // return address on the stack, though.
+
+        // If the function is not frameless and we're at the top frame we need
+        // to check whether the prologue has not been executed (completely) or
+        // we're already after the epilogue.
+        if (hasPrologue && isTopFrame) {
+            uint32 stack = 0;
+            if (eip < function->Address() + 3) {
+                // The prologue has not been executed yet, i.e. there's no
+                // stack frame yet. Get the return address from the stack.
+                stack = cpuState->IntRegisterValue(X86_64_REGISTER_RSP);
+                if (eip > function->Address()) {
+                    // The "push %ebp" has already been executed.
+                    stack += 8;
+                }
+            } else {
+                // Not in the function prologue, but maybe after the epilogue.
+                // The epilogue is a single "pop %ebp", so we check whether the
+                // current instruction is already a "ret".
+                uint8 code[1];
+                if (fTeamMemory->ReadMemory(eip, &code, 1) == 1
+                    && code[0] == 0xc3) {
+                    stack = cpuState->IntRegisterValue(X86_64_REGISTER_RSP);
+                }
+            }
+
+            if (stack != 0) {
+                uint64 address;
+                if (fTeamMemory->ReadMemory(stack, &address, 8) == 8) {
+                    returnAddress = address;
+                    previousFramePointer = framePointer;
+                    framePointer = 0;
+                    readStandardFrame = false;
+                    frameType = STACK_FRAME_TYPE_FRAMELESS;
+                }
+            }
+        }
+    }
+
+    // create the stack frame
+    StackFrameDebugInfo* stackFrameDebugInfo
+        = new(std::nothrow) NoOpStackFrameDebugInfo;
+    if (stackFrameDebugInfo == NULL)
+        return B_NO_MEMORY;
+    BReference<StackFrameDebugInfo> stackFrameDebugInfoReference(
+        stackFrameDebugInfo, true);
+
+    StackFrame* frame = new(std::nothrow) StackFrame(frameType, cpuState,
+        framePointer, eip, stackFrameDebugInfo);
+    if (frame == NULL)
+        return B_NO_MEMORY;
+    BReference<StackFrame> frameReference(frame, true);
+
+    status_t error = frame->Init();
+    if (error != B_OK)
+        return error;
+
+    // read the previous frame and return address, if this is a standard frame
+    if (readStandardFrame) {
+        uint64 frameData[2];
+        if (framePointer != 0
+            && fTeamMemory->ReadMemory(framePointer, frameData,
+                    sizeof(frameData))
+                == sizeof(frameData)) {
+            previousFramePointer = frameData[0];
+            returnAddress = frameData[1];
+        }
+    }
+
+    // create the CPU state, if we have any info
+    CpuStateX86_64* previousCpuState = NULL;
+    if (returnAddress != 0) {
+        // prepare the previous CPU state
+        previousCpuState = new(std::nothrow) CpuStateX86_64;
+        if (previousCpuState == NULL)
+            return B_NO_MEMORY;
+
+        previousCpuState->SetIntRegister(X86_64_REGISTER_RBP,
+            previousFramePointer);
+        previousCpuState->SetIntRegister(X86_64_REGISTER_RIP, returnAddress);
+        frame->SetPreviousCpuState(previousCpuState);
+    }
+
+    frame->SetReturnAddress(returnAddress);
+
+    _frame = frameReference.Detach();
+    _previousCpuState = previousCpuState;
+    return B_OK;
+}
+
+
+void
+ArchitectureX86_64::UpdateStackFrameCpuState(const StackFrame* frame,
+    Image* previousImage, FunctionDebugInfo* previousFunction,
+    CpuState* previousCpuState)
+{
+    // This is not a top frame, so we want to offset eip to the previous
+    // (calling) instruction.
+    CpuStateX86_64* cpuState = dynamic_cast<CpuStateX86_64*>(previousCpuState);
+
+    // get rip
+    uint64 rip = cpuState->IntRegisterValue(X86_64_REGISTER_RIP);
+    if (previousFunction == NULL || rip <= previousFunction->Address())
+        return;
+    target_addr_t functionAddress = previousFunction->Address();
+
+    // allocate a buffer for the function code to disassemble
+    size_t bufferSize = rip - functionAddress;
+    void* buffer = malloc(bufferSize);
+    if (buffer == NULL)
+        return;
+    MemoryDeleter bufferDeleter(buffer);
+
+    // read the code
+    ssize_t bytesRead = fTeamMemory->ReadMemory(functionAddress, buffer,
+        bufferSize);
+    if (bytesRead != (ssize_t)bufferSize)
+        return;
+
+    // disassemble to get the previous instruction
+    DisassemblerX86 disassembler;
+    target_addr_t instructionAddress;
+    target_size_t instructionSize;
+    if (disassembler.Init(functionAddress, buffer, bufferSize) == B_OK
+        && disassembler.GetPreviousInstruction(rip, instructionAddress,
+            instructionSize) == B_OK) {
+        rip -= instructionSize;
+        cpuState->SetIntRegister(X86_64_REGISTER_RIP, rip);
+    }
+}
+
+
+status_t
+ArchitectureX86_64::ReadValueFromMemory(target_addr_t address, uint32 valueType,
+    BVariant& _value) const
+{
+    uint8 buffer[64];
+    size_t size = BVariant::SizeOfType(valueType);
+    if (size == 0 || size > sizeof(buffer))
+        return B_BAD_VALUE;
+
+    ssize_t bytesRead = fTeamMemory->ReadMemory(address, buffer, size);
+    if (bytesRead < 0)
+        return bytesRead;
+    if ((size_t)bytesRead != size)
+        return B_ERROR;
+
+    // TODO: We need to swap endianess, if the host is big endian!
+
+    switch (valueType) {
+        case B_INT8_TYPE:
+            _value.SetTo(*(int8*)buffer);
+            return B_OK;
+        case B_UINT8_TYPE:
+            _value.SetTo(*(uint8*)buffer);
+            return B_OK;
+        case B_INT16_TYPE:
+            _value.SetTo(*(int16*)buffer);
+            return B_OK;
+        case B_UINT16_TYPE:
+            _value.SetTo(*(uint16*)buffer);
+            return B_OK;
+        case B_INT32_TYPE:
+            _value.SetTo(*(int32*)buffer);
+            return B_OK;
+        case B_UINT32_TYPE:
+            _value.SetTo(*(uint32*)buffer);
+            return B_OK;
+        case B_INT64_TYPE:
+            _value.SetTo(*(int64*)buffer);
+            return B_OK;
+        case B_UINT64_TYPE:
+            _value.SetTo(*(uint64*)buffer);
+            return B_OK;
+        case B_FLOAT_TYPE:
+            _value.SetTo(*(float*)buffer);
+                // TODO: float on the host might work differently!
+            return B_OK;
+        case B_DOUBLE_TYPE:
+            _value.SetTo(*(double*)buffer);
+                // TODO: double on the host might work differently!
+            return B_OK;
+        default:
+            return B_BAD_VALUE;
+    }
+}
+
+
+status_t
+ArchitectureX86_64::ReadValueFromMemory(target_addr_t addressSpace,
+    target_addr_t address, uint32 valueType, BVariant& _value) const
+{
+    // n/a on this architecture
+    return B_BAD_VALUE;
+}
+
+
+status_t
+ArchitectureX86_64::DisassembleCode(FunctionDebugInfo* function,
+    const void* buffer, size_t bufferSize, DisassembledCode*& _sourceCode)
+{
+    DisassembledCode* source = new(std::nothrow) DisassembledCode(
+        fAssemblyLanguage);
+    if (source == NULL)
+        return B_NO_MEMORY;
+    BReference<DisassembledCode> sourceReference(source, true);
+
+    // init disassembler
+    DisassemblerX86 disassembler;
+    status_t error = disassembler.Init(function->Address(), buffer, bufferSize);
+    if (error != B_OK)
+        return error;
+
+    // add a function name line
+    BString functionName(function->PrettyName());
+    if (!source->AddCommentLine((functionName << ':').String()))
+        return B_NO_MEMORY;
+
+    // disassemble the instructions
+    BString line;
+    target_addr_t instructionAddress;
+    target_size_t instructionSize;
+    bool breakpointAllowed;
+    while (disassembler.GetNextInstruction(line, instructionAddress,
+                instructionSize, breakpointAllowed) == B_OK) {
+// TODO: Respect breakpointAllowed!
+        if (!source->AddInstructionLine(line, instructionAddress,
+                instructionSize)) {
+            return B_NO_MEMORY;
+        }
+    }
+
+    _sourceCode = sourceReference.Detach();
+    return B_OK;
+}
+
+
+status_t
+ArchitectureX86_64::GetStatement(FunctionDebugInfo* function,
+    target_addr_t address, Statement*& _statement)
+{
+// TODO: This is not architecture dependent anymore!
+    // get the instruction info
+    InstructionInfo info;
+    status_t error = GetInstructionInfo(address, info);
+    if (error != B_OK)
+        return error;
+
+    // create a statement
+    ContiguousStatement* statement = new(std::nothrow) ContiguousStatement(
+        SourceLocation(-1), TargetAddressRange(info.Address(), info.Size()));
+    if (statement == NULL)
+        return B_NO_MEMORY;
+
+    _statement = statement;
+    return B_OK;
+}
+
+
+status_t
+ArchitectureX86_64::GetInstructionInfo(target_addr_t address,
+    InstructionInfo& _info)
+{
+    // read the code
+    uint8 buffer[16];
+        // TODO: What's the maximum instruction size?
+    ssize_t bytesRead = fTeamMemory->ReadMemory(address, buffer,
+        sizeof(buffer));
+    if (bytesRead < 0)
+        return bytesRead;
+
+    // init disassembler
+    DisassemblerX86 disassembler;
+    status_t error = disassembler.Init(address, buffer, bytesRead);
+    if (error != B_OK)
+        return error;
+
+    // disassemble the instruction
+    BString line;
+    target_addr_t instructionAddress;
+    target_size_t instructionSize;
+    bool breakpointAllowed;
+    error = disassembler.GetNextInstruction(line, instructionAddress,
+        instructionSize, breakpointAllowed);
+    if (error != B_OK)
+        return error;
+
+    // TODO: any changes needed for x86-64?
+    instruction_type instructionType = INSTRUCTION_TYPE_OTHER;
+    if (buffer[0] == 0xff && (buffer[1] & 0x34) == 0x10) {
+        // absolute call with r/m32
+        instructionType = INSTRUCTION_TYPE_SUBROUTINE_CALL;
+    } else if (buffer[0] == 0xe8 && instructionSize == 5) {
+        // relative call with rel32 -- don't categorize the call with 0 as
+        // subroutine call, since it is only used to get the address of the GOT
+        if (buffer[1] != 0 || buffer[2] != 0 || buffer[3] != 0
+            || buffer[4] != 0) {
+            instructionType = INSTRUCTION_TYPE_SUBROUTINE_CALL;
+        }
+    }
+
+    if (!_info.SetTo(instructionAddress, instructionSize, instructionType,
+            breakpointAllowed, line)) {
+        return B_NO_MEMORY;
+    }
+
+    return B_OK;
+}
+
+
+void
+ArchitectureX86_64::_AddRegister(int32 index, const char* name,
+    uint32 bitSize, uint32 valueType, register_type type, bool calleePreserved)
+{
+    if (!fRegisters.Add(Register(index, name, bitSize, valueType, type,
+            calleePreserved))) {
+        throw std::bad_alloc();
+    }
+}
+
+
+void
+ArchitectureX86_64::_AddIntegerRegister(int32 index, const char* name,
+    uint32 valueType, register_type type, bool calleePreserved)
+{
+    _AddRegister(index, name, 8 * BVariant::SizeOfType(valueType), valueType,
+        type, calleePreserved);
+}
+
+
+bool
+ArchitectureX86_64::_HasFunctionPrologue(FunctionDebugInfo* function) const
+{
+    // TODO: rework for x86-64
+    if (function == NULL)
+        return false;
+
+    // check whether the function has the typical prologue
+    if (function->Size() < 3)
+        return false;
+
+    uint8 buffer[3];
+    if (fTeamMemory->ReadMemory(function->Address(), buffer, 3) != 3)
+        return false;
+
+    return buffer[0] == 0x55 && buffer[1] == 0x89 && buffer[2] == 0xe5;
+}

new file src/apps/debugger/arch/x86_64/ArchitectureX86_64.h

@@ +1 @@
+/*
+ * Copyright 2009, Ingo Weinhold, ingo_weinhold@gmx.de.
+ * Copyright 2011-2012, Rene Gollent, rene@gollent.com.
+ * Distributed under the terms of the MIT License.
+ */
+#ifndef ARCHITECTURE_X86_64_H
+#define ARCHITECTURE_X86_64_H
+
+
+#include <Array.h>
+
+#include "Architecture.h"
+#include "Register.h"
+
+
+class SourceLanguage;
+
+
+class ArchitectureX86_64 : public Architecture {
+public:
+                                ArchitectureX86_64(TeamMemory* teamMemory);
+    virtual                     ~ArchitectureX86_64();
+
+    virtual status_t            Init();
+
+    virtual int32               StackGrowthDirection() const;
+
+    virtual int32               CountRegisters() const;
+    virtual const Register*     Registers() const;
+    virtual status_t            InitRegisterRules(CfaContext& context) const;
+
+    virtual status_t            GetDwarfRegisterMaps(RegisterMap** _toDwarf,
+                                    RegisterMap** _fromDwarf) const;
+
+    virtual status_t            CreateCpuState(CpuState*& _state);
+    virtual status_t            CreateCpuState(const void* cpuStateData,
+                                    size_t size, CpuState*& _state);
+    virtual status_t            CreateStackFrame(Image* image,
+                                    FunctionDebugInfo* function,
+                                    CpuState* cpuState, bool isTopFrame,
+                                    StackFrame*& _previousFrame,
+                                    CpuState*& _previousCpuState);
+    virtual void                UpdateStackFrameCpuState(
+                                    const StackFrame* frame,
+                                    Image* previousImage,
+                                    FunctionDebugInfo* previousFunction,
+                                    CpuState* previousCpuState);
+
+    virtual status_t            ReadValueFromMemory(target_addr_t address,
+                                    uint32 valueType, BVariant& _value) const;
+    virtual status_t            ReadValueFromMemory(target_addr_t addressSpace,
+                                    target_addr_t address, uint32 valueType,
+                                    BVariant& _value) const;
+
+    virtual status_t            DisassembleCode(FunctionDebugInfo* function,
+                                    const void* buffer, size_t bufferSize,
+                                    DisassembledCode*& _sourceCode);
+    virtual status_t            GetStatement(FunctionDebugInfo* function,
+                                    target_addr_t address,
+                                    Statement*& _statement);
+    virtual status_t            GetInstructionInfo(target_addr_t address,
+                                    InstructionInfo& _info);
+
+private:
+            struct ToDwarfRegisterMap;
+            struct FromDwarfRegisterMap;
+
+private:
+            void                _AddRegister(int32 index, const char* name,
+                                    uint32 bitSize, uint32 valueType,
+                                    register_type type, bool calleePreserved);
+            void                _AddIntegerRegister(int32 index,
+                                    const char* name, uint32 valueType,
+                                    register_type type, bool calleePreserved);
+
+            bool                _HasFunctionPrologue(
+                                    FunctionDebugInfo* function) const;
+
+private:
+            Array<Register>     fRegisters;
+            SourceLanguage*     fAssemblyLanguage;
+            ToDwarfRegisterMap* fToDwarfRegisterMap;
+            FromDwarfRegisterMap* fFromDwarfRegisterMap;
+};
+
+
+#endif  // ARCHITECTURE_X86_H

new file src/apps/debugger/arch/x86_64/CpuStateX86_64.cpp

@@ +1 @@
+/*
+ * Copyright 2009-2012, Ingo Weinhold, ingo_weinhold@gmx.de.
+ * Copyright 2011-2012, Rene Gollent, rene@gollent.com.
+ * Distributed under the terms of the MIT License.
+ */
+
+#include "CpuStateX86_64.h"
+
+#include "Register.h"
+
+
+CpuStateX86_64::CpuStateX86_64()
+    :
+    fSetRegisters(),
+    fInterruptVector(0)
+{
+}
+
+
+CpuStateX86_64::CpuStateX86_64(const x86_64_debug_cpu_state& state)
+    :
+    fSetRegisters(),
+    fInterruptVector(0)
+{
+    SetIntRegister(X86_64_REGISTER_RIP, state.rip);
+    SetIntRegister(X86_64_REGISTER_RSP, state.rsp);
+    SetIntRegister(X86_64_REGISTER_RBP, state.rbp);
+    SetIntRegister(X86_64_REGISTER_RAX, state.rax);
+    SetIntRegister(X86_64_REGISTER_RBX, state.rbx);
+    SetIntRegister(X86_64_REGISTER_RCX, state.rcx);
+    SetIntRegister(X86_64_REGISTER_RDX, state.rdx);
+    SetIntRegister(X86_64_REGISTER_RSI, state.rsi);
+    SetIntRegister(X86_64_REGISTER_RDI, state.rdi);
+    SetIntRegister(X86_64_REGISTER_R8, state.r8);
+    SetIntRegister(X86_64_REGISTER_R9, state.r9);
+    SetIntRegister(X86_64_REGISTER_R10, state.r10);
+    SetIntRegister(X86_64_REGISTER_R11, state.r11);
+    SetIntRegister(X86_64_REGISTER_R12, state.r12);
+    SetIntRegister(X86_64_REGISTER_R13, state.r13);
+    SetIntRegister(X86_64_REGISTER_R14, state.r14);
+    SetIntRegister(X86_64_REGISTER_R15, state.r15);
+    SetIntRegister(X86_64_REGISTER_CS, state.cs);
+    SetIntRegister(X86_64_REGISTER_FS, state.fs);
+    SetIntRegister(X86_64_REGISTER_GS, state.gs);
+
+    // TODO: fix
+//  fInterruptVector = state.vector;
+}
+
+
+CpuStateX86_64::~CpuStateX86_64()
+{
+}
+
+
+target_addr_t
+CpuStateX86_64::InstructionPointer() const
+{
+    return IsRegisterSet(X86_64_REGISTER_RIP)
+        ? IntRegisterValue(X86_64_REGISTER_RIP) : 0;
+}
+
+
+target_addr_t
+CpuStateX86_64::StackFramePointer() const
+{
+    return IsRegisterSet(X86_64_REGISTER_RBP)
+        ? IntRegisterValue(X86_64_REGISTER_RBP) : 0;
+}
+
+
+target_addr_t
+CpuStateX86_64::StackPointer() const
+{
+    return IsRegisterSet(X86_64_REGISTER_RSP)
+        ? IntRegisterValue(X86_64_REGISTER_RSP) : 0;
+}
+
+
+bool
+CpuStateX86_64::GetRegisterValue(const Register* reg, BVariant& _value) const
+{
+    int32 index = reg->Index();
+    if (!IsRegisterSet(index))
+        return false;
+
+    if (index >= X86_64_INT_REGISTER_END)
+        return false;
+
+    if (reg->BitSize() == 16)
+        _value.SetTo((uint16)fIntRegisters[index]);
+    else
+        _value.SetTo(fIntRegisters[index]);
+
+    return true;
+}
+
+
+bool
+CpuStateX86_64::SetRegisterValue(const Register* reg, const BVariant& value)
+{
+    int32 index = reg->Index();
+    if (index >= X86_64_INT_REGISTER_END)
+        return false;
+
+    fIntRegisters[index] = value.ToUInt64();
+    fSetRegisters[index] = 1;
+    return true;
+}
+
+
+bool
+CpuStateX86_64::IsRegisterSet(int32 index) const
+{
+    return index >= 0 && index < X86_64_REGISTER_COUNT && fSetRegisters[index];
+}
+
+
+uint32
+CpuStateX86_64::IntRegisterValue(int32 index) const
+{
+    if (!IsRegisterSet(index) || index >= X86_64_INT_REGISTER_END)
+        return 0;
+
+    return fIntRegisters[index];
+}
+
+
+void
+CpuStateX86_64::SetIntRegister(int32 index, uint64 value)
+{
+    if (index < 0 || index >= X86_64_INT_REGISTER_END)
+        return;
+
+    fIntRegisters[index] = value;
+    fSetRegisters[index] = 1;
+}
+
+
+void
+CpuStateX86_64::UnsetRegister(int32 index)
+{
+    if (index < 0 || index >= X86_64_REGISTER_COUNT)
+        return;
+
+    fSetRegisters[index] = 0;
+}

new file src/apps/debugger/arch/x86_64/CpuStateX86_64.h

@@ +1 @@
+/*
+ * Copyright 2009-2012, Ingo Weinhold, ingo_weinhold@gmx.de.
+ * Copyright 2011-2012, Rene Gollent, rene@gollent.com.
+ * Distributed under the terms of the MIT License.
+ */
+#ifndef CPU_STATE_X86_64_H
+#define CPU_STATE_X86_64_H
+
+#include <bitset>
+
+#include <debugger.h>
+
+#include "CpuState.h"
+
+
+enum {
+    X86_64_REGISTER_RIP = 0,
+    X86_64_REGISTER_RSP,
+    X86_64_REGISTER_RBP,
+
+    X86_64_REGISTER_RAX,
+    X86_64_REGISTER_RBX,
+    X86_64_REGISTER_RCX,
+    X86_64_REGISTER_RDX,
+
+    X86_64_REGISTER_RSI,
+    X86_64_REGISTER_RDI,
+
+    X86_64_REGISTER_R8,
+    X86_64_REGISTER_R9,
+    X86_64_REGISTER_R10,
+    X86_64_REGISTER_R11,
+    X86_64_REGISTER_R12,
+    X86_64_REGISTER_R13,
+    X86_64_REGISTER_R14,
+    X86_64_REGISTER_R15,
+
+    X86_64_REGISTER_CS,
+    X86_64_REGISTER_FS,
+    X86_64_REGISTER_GS,
+
+    X86_64_INT_REGISTER_END,
+    X86_64_REGISTER_COUNT
+};
+
+
+class CpuStateX86_64 : public CpuState {
+public:
+                                CpuStateX86_64();
+                                CpuStateX86_64(
+                                    const x86_64_debug_cpu_state& state);
+    virtual                     ~CpuStateX86_64();
+
+    virtual target_addr_t       InstructionPointer() const;
+    virtual target_addr_t       StackFramePointer() const;
+    virtual target_addr_t       StackPointer() const;
+    virtual bool                GetRegisterValue(const Register* reg,
+                                    BVariant& _value) const;
+    virtual bool                SetRegisterValue(const Register* reg,
+                                    const BVariant& value);
+
+            uint32              InterruptVector() const
+                                    { return fInterruptVector; }
+
+            bool                IsRegisterSet(int32 index) const;
+            uint32              IntRegisterValue(int32 index) const;
+            void                SetIntRegister(int32 index, uint64 value);
+            void                UnsetRegister(int32 index);
+
+private:
+    typedef std::bitset<X86_64_REGISTER_COUNT> RegisterBitSet;
+
+private:
+            uint32              fIntRegisters[X86_64_REGISTER_COUNT];
+            RegisterBitSet      fSetRegisters;
+            uint32              fInterruptVector;
+};
+
+
+#endif  // CPU_STATE_X86_64_H

src/apps/debugger/debugger_interface/DebuggerInterface.cpp

@@ -21 +21 @@
 
 #include "debug_utils.h"
 
+#ifdef ARCH_x86
 #include "ArchitectureX86.h"
+#elif defined(ARCH_x86_64)
+#include "ArchitectureX86_64.h"
+#endif
 #include "CpuState.h"
 #include "DebugEvent.h"
 #include "ImageInfo.h"
@@ -252 +256 @@
 DebuggerInterface::Init()
 {
     // create the architecture
-    // TODO: this probably needs to be rethought a bit,
-    // since especially when we eventually support remote debugging,
-    // the architecture will depend on the target machine, not the host
 #ifdef ARCH_x86
     fArchitecture = new(std::nothrow) ArchitectureX86(this);
+#elif defined(ARCH_x86_64)
+    fArchitecture = new(std::nothrow) ArchitectureX86_64(this);
 #else
     return B_UNSUPPORTED;
 #endif

src/apps/debugger/elf/ElfFile.cpp

@@ -19 +19 @@
 
 #include "Tracing.h"
 
+#ifdef B_HAIKU_64_BIT
+#include "elf64.h"
+#else
+#include "elf32.h"
+#endif
 
 // #pragma mark - ElfSection
 
@@ -147 +152 @@
     fFileSize = st.st_size;
 
     // read the elf header
-    fElfHeader = (Elf32_Ehdr*)malloc(sizeof(Elf32_Ehdr));
+    fElfHeader = (elf_ehdr*)malloc(sizeof(elf_ehdr));
     if (fElfHeader == NULL)
         return B_NO_MEMORY;
 
-    ssize_t bytesRead = pread(fFD, fElfHeader, sizeof(Elf32_Ehdr), 0);
-    if (bytesRead != (ssize_t)sizeof(Elf32_Ehdr))
+    ssize_t bytesRead = pread(fFD, fElfHeader, sizeof(elf_ehdr), 0);
+    if (bytesRead != (ssize_t)sizeof(elf_ehdr))
         return bytesRead < 0 ? errno : B_ERROR;
 
     // check the ELF header
-    if (!_CheckRange(0, sizeof(Elf32_Ehdr)) || !_CheckElfHeader()) {
+    if (!_CheckRange(0, sizeof(elf_ehdr)) || !_CheckElfHeader()) {
         WARNING("\"%s\": Not an ELF file\n", fileName);
         return B_BAD_DATA;
     }
@@ -183 +188 @@
         return bytesRead < 0 ? errno : B_ERROR;
 
     // check and get the section header string section
-    Elf32_Shdr* stringSectionHeader = (Elf32_Shdr*)(sectionHeaderTable
+    elf_shdr* stringSectionHeader = (elf_shdr*)(sectionHeaderTable
         + fElfHeader->e_shstrndx * sectionHeaderSize);
     if (!_CheckRange(stringSectionHeader->sh_offset,
             stringSectionHeader->sh_size)) {
@@ -207 +212 @@
 
     // read the other sections
     for (int i = 0; i < sectionCount; i++) {
-        Elf32_Shdr* sectionHeader = (Elf32_Shdr*)(sectionHeaderTable
+        elf_shdr* sectionHeader = (elf_shdr*)(sectionHeaderTable
             + i * sectionHeaderSize);
         // skip invalid sections and the section header string section
         const char* name = sectionStrings + sectionHeader->sh_name;
@@ -249 +254 @@
 
     // read the program headers and create ElfSegment objects
     for (int i = 0; i < segmentCount; i++) {
-        Elf32_Phdr* programHeader = (Elf32_Phdr*)(programHeaderTable
+        elf_phdr* programHeader = (elf_phdr*)(programHeaderTable
             + i * programHeaderSize);
         // skip program headers we aren't interested in or that are invalid
         if (programHeader->p_type != PT_LOAD || programHeader->p_filesz == 0
@@ -341 +346 @@
 ElfFile::_CheckElfHeader() const
 {
     return memcmp(fElfHeader->e_ident, ELF_MAGIC, 4) == 0
-        && fElfHeader->e_ident[4] == ELFCLASS32
+        && fElfHeader->e_ident[4] == ELF_CLASS
         && fElfHeader->e_shoff > 0
         && fElfHeader->e_shnum > 0
-        && fElfHeader->e_shentsize >= sizeof(struct Elf32_Shdr)
+        && fElfHeader->e_shentsize >= sizeof(elf_shdr)
         && fElfHeader->e_shstrndx != SHN_UNDEF
         && fElfHeader->e_shstrndx < fElfHeader->e_shnum
         && fElfHeader->e_phoff > 0
         && fElfHeader->e_phnum > 0
-        && fElfHeader->e_phentsize >= sizeof(struct Elf32_Phdr);
+        && fElfHeader->e_phentsize >= sizeof(elf_phdr);
 }

src/apps/debugger/elf/ElfFile.h

@@ -9 +9 @@
 
 #include <SupportDefs.h>
 
-#include <elf32.h>
+#include <elf_common.h>
 #include <util/DoublyLinkedList.h>
 
 #include "Types.h"
@@ -96 +96 @@
 private:
             off_t               fFileSize;
             int                 fFD;
-            Elf32_Ehdr*         fElfHeader;
+            elf_ehdr*           fElfHeader;
             SectionList         fSections;
             SegmentList         fSegments;
 };