Ticket #6310: x86_64.kernel_void_functions.patch

src/system/kernel/platform/bios_x86_64/platform.cpp

@@ +1 @@
+/*
+    Just a dummy. No BIOS services are required in the kernel.
+*/

src/system/kernel/platform/bios_x86_64/Jamfile

@@ +1 @@
+SubDir HAIKU_TOP src system kernel platform bios_x86_64 ;
+
+SubDirCcFlags $(TARGET_KERNEL_PIC_CCFLAGS) ;
+SubDirC++Flags $(TARGET_KERNEL_PIC_CCFLAGS) ;
+
+KernelMergeObject kernel_platform_bios_x86_64.o :
+    platform.cpp
+;

src/system/kernel/device_manager/IOCache.cpp

@@ -242 +242 @@
         off_t lineOffset = (offset >> fLineSizeShift) << fLineSizeShift;
 
         // intersection of request and cache line
-        off_t cacheLineEnd = std::min(lineOffset + fLineSize, fDeviceCapacity);
+//      off_t cacheLineEnd = std::min(lineOffset + fLineSize, fDeviceCapacity);
+        off_t cacheLineEnd;
+        if((lineOffset + fLineSize) < fDeviceCapacity)
+            cacheLineEnd = (lineOffset + fLineSize);
+        else
+            cacheLineEnd = fDeviceCapacity;
+
         size_t requestLineLength
             = std::min(cacheLineEnd - offset, (off_t)length);
 

src/system/kernel/lib/arch/x86_64/arch_string.S

@@ +1 @@
+/*
+ * Copyright 2008, Ingo Weinhold, ingo_weinhold@gmx.de.
+ * Distributed under the terms of the MIT License.
+ *
+ * Copyright 2001, Travis Geiselbrecht. All rights reserved.
+ * Distributed under the terms of the NewOS License.
+*/
+
+#if !_BOOT_MODE
+#   include "asm_offsets.h"
+#endif
+
+#include <asm_defs.h>
+
+
+// We don't need the indirection in the boot loader.
+#if _BOOT_MODE
+#   define memcpy_generic   memcpy
+#   define memset_generic   memset
+#endif
+
+
+.align 4
+FUNCTION(memcpy_generic):
+//  pushl   %esi
+//  pushl   %edi
+//  movl    12(%esp),%edi   /* dest */
+//  movl    %edi,%eax   /* save dest ptr as return address */
+//  movl    16(%esp),%esi   /* source */
+//  movl    20(%esp),%ecx   /* count */
+
+    /* move by words */
+    // TODO: The addresses might not be aligned!
+//  cld
+//  shrl    $2,%ecx
+//  rep
+//  movsl
+
+    /* move any remaining data by bytes */
+//  movl    20(%esp),%ecx
+//  andl    $3,%ecx
+//  rep
+//  movsb
+
+//  popl    %edi
+//  popl    %esi
+    ret
+FUNCTION_END(memcpy_generic)
+SYMBOL(memcpy_generic_end):
+
+
+/* void *memset(void *dest, int value, size_t length); */
+.align 4
+FUNCTION(memset_generic):
+//  push    %ebp
+//  mov     %esp, %ebp
+
+    // %eax, %ecx, and %edx are scratch registers -- we only have to save %edi
+//  push    %edi
+
+    // get the parameters
+//  mov     16(%ebp), %ecx
+//  mov     12(%ebp), %eax
+//  mov     8(%ebp), %edi
+
+    // When touching less than 12 bytes, we just do it bytewise. We might be
+    // able to process one or two lwords lwordwise, but the additional overhead
+    // isn't worth it.
+//  cmp     $12, %ecx
+//  jl      2f
+
+    // buffer address lword-aligned?
+//  mov     %edi, %edx
+//  and     $0x3, %edx
+//  jz      1f
+
+    // the buffer is unaligned -- copy the first bytes bytewise
+//  mov     $4, %ecx
+//  sub     %edx, %ecx
+//  rep     stosb
+
+//  mov     16(%ebp), %ecx
+//  sub     $4, %ecx
+//  add     %edx, %ecx
+
+1:  // lwordwise
+    // prepare %eax -- the low byte must be copied to the other bytes
+//  mov     %al, %ah
+//  mov     %eax, %edx
+//  shl     $16, %eax
+//  mov     %dx, %ax
+
+    // get the unaligned remainder into %edx
+//  mov     %ecx, %edx
+//  and     $0x3, %edx
+
+    // write words
+//  shr     $2, %ecx
+//  rep     stosl
+
+//  mov     %edx, %ecx
+
+2:  // bytewise (remaining bytes)
+//  rep     stosb
+
+//  pop     %edi
+
+    // return value is the value passed in
+//  mov     8(%ebp), %eax
+
+//  mov     %ebp, %esp
+//  pop     %ebp
+    ret
+FUNCTION_END(memset_generic)
+SYMBOL(memset_generic_end):
+
+
+#if !_BOOT_MODE
+
+.align 4
+FUNCTION(memcpy):
+//  jmp     *(gOptimizedFunctions + X86_OPTIMIZED_FUNCTIONS_memcpy)
+FUNCTION_END(memcpy)
+
+FUNCTION(memset):
+//  jmp     *(gOptimizedFunctions + X86_OPTIMIZED_FUNCTIONS_memset)
+FUNCTION_END(memset)
+
+#endif  // !_BOOT_MODE

src/system/kernel/lib/arch/x86_64/Jamfile

@@ +1 @@
+SubDir HAIKU_TOP src system kernel lib arch x86_64 ;
+
+# find the generated asm_offsets.h
+SubDirHdrs [ FDirName $(TARGET_COMMON_DEBUG_OBJECT_DIR) system kernel arch
+    $(TARGET_ARCH) ] ;
+
+SEARCH_SOURCE += [ FDirName $(SUBDIR) $(DOTDOT) generic ] ;
+
+local librootSources = [ FDirName $(HAIKU_TOP) src system libroot ] ;
+local posixSources = [ FDirName $(librootSources) posix ] ;
+
+SEARCH_SOURCE += [ FDirName $(librootSources) os arch $(TARGET_ARCH) ] ;
+
+KernelMergeObject kernel_os_arch_$(TARGET_ARCH).o :
+    atomic.S
+    byteorder.S
+    system_time_asm.S
+    system_time.c
+
+    : $(TARGET_KERNEL_PIC_CCFLAGS)
+;
+
+SEARCH_SOURCE += [ FDirName $(posixSources) arch $(TARGET_ARCH) ] ;
+SEARCH_SOURCE += [ FDirName $(posixSources) string arch generic ] ;
+
+KernelMergeObject kernel_lib_posix_arch_$(TARGET_ARCH).o :
+    siglongjmp.S
+    sigsetjmp.S
+    kernel_longjmp_return.c
+    kernel_setjmp_save_sigs.c
+
+    arch_string.S
+
+    : $(TARGET_KERNEL_PIC_CCFLAGS)
+;
+
+# Explicitly tell the build system that arch_string.S includes the generated
+# asm_offsets.h.
+Includes [ FGristFiles arch_string.S ]
+    : <src!system!kernel!arch!x86_64>asm_offsets.h ;

src/system/kernel/arch/x86/arch_elf.cpp

@@ -179 +179 @@
     return B_ERROR;
 }
 
+
+
+/*  ELF64 support. only needed in bootmode. */
+#ifdef _BOOT_MODE
+status_t
+boot_arch_elf64_relocate_rel(struct preloaded_image *image, struct Elf64_Rel *rel, int relLength)
+{
+    addr_t S;
+    addr_t A;
+    addr_t P;
+    addr_t finalAddress;
+    addr_t *resolveAddress;
+    int i;
+
+    S = A = P = 0;
+
+    for (i = 0; i * (int)sizeof(struct Elf64_Rel) < relLength; i++) {
+        TRACE(("looking at rel type %s, offset 0x%lx\n",
+            kRelocations[ELF32_R_TYPE(rel[i].r_info)], rel[i].r_offset));
+
+        // calc S
+        switch (ELF64_R_TYPE(rel[i].r_info)) {
+            case R_X86_64_64:
+            case R_X86_64_PC32:
+            case R_X86_64_GLOB_DAT:
+            case R_X86_64_JMP_SLOT:
+            case R_X86_64_GOTOFF:
+            {
+                struct Elf64_Sym *symbol;
+                status_t status;
+
+                symbol = SYMBOL64(image, ELF64_R_SYM(rel[i].r_info));
+
+                status = boot_elf64_resolve_symbol(image, symbol, &S);
+
+                if (status < B_OK)
+                    return status;
+                TRACE(("S %p (%s)\n", (void *)S, SYMNAME(image, symbol)));
+            }
+        }
+        // calc A
+        switch (ELF64_R_TYPE(rel[i].r_info)) {
+            case R_X86_64_64:
+            case R_X86_64_PC32:
+            case R_X86_64_GOT32:
+            case R_X86_64_PLT32:
+            case R_X86_64_RELATIVE:
+            case R_X86_64_GOTOFF:
+                A = *(addr_t *)(image->text_region.delta + rel[i].r_offset);
+                TRACE(("A %p\n", (void *)A));
+                break;
+        }
+        // calc P
+        switch (ELF64_R_TYPE(rel[i].r_info)) {
+            case R_X86_64_PC32:
+            case R_X86_64_GOT32:
+            case R_X86_64_PLT32:
+                P = image->text_region.delta + rel[i].r_offset;
+                TRACE(("P %p\n", (void *)P));
+                break;
+        }
+
+        switch (ELF64_R_TYPE(rel[i].r_info)) {
+            case R_X86_64_NONE:
+                continue;
+            case R_X86_64_64:
+                finalAddress = S + A;
+                break;
+            case R_X86_64_PC32:
+                finalAddress = S + A - P;
+                break;
+            case R_X86_64_RELATIVE:
+                // B + A;
+                finalAddress = image->text_region.delta + A;
+                break;
+            case R_X86_64_JMP_SLOT:
+            case R_X86_64_GLOB_DAT:
+                finalAddress = S;
+                break;
+
+            default:
+                dprintf("arch_elf_relocate_rel: unhandled relocation type %d\n",
+                    ELF64_R_TYPE(rel[i].r_info));
+                return B_BAD_DATA;
+        }
+
+        resolveAddress = (addr_t *)(image->text_region.delta + rel[i].r_offset);
+        *resolveAddress = finalAddress;
+        TRACE(("-> offset %#lx = %#lx\n",
+            (image->text_region.delta + rel[i].r_offset), finalAddress));
+    }
+
+    return B_NO_ERROR;
+}
+
+status_t
+boot_arch_elf64_relocate_rela(struct preloaded_image *image,
+    struct Elf64_Rela *rel, int relLength)
+{
+    dprintf("arch_elf_relocate_rela: not supported on x86\n");
+    return B_ERROR;
+}
+#endif

src/system/kernel/arch/x86_64/arch_elf.cpp

@@ +1 @@
+/*
+ * Copyright 2009, Johannes Wischert, johanneswi@gmail.com.
+ * All rights reserved. Distributed under the terms of the MIT License.
+ *
+ * Copyright 2005, Ingo Weinhold <bonefish@cs.tu-berlin.de>.
+ * All rights reserved. Distributed under the terms of the MIT License.
+ *
+ * Copyright 2002, Travis Geiselbrecht. All rights reserved.
+ * Distributed under the terms of the NewOS License.
+ */
+
+#ifdef _BOOT_MODE
+#include <boot/arch.h>
+#endif
+
+#include <KernelExport.h>
+
+#include <elf_priv.h>
+#include <arch/elf.h>
+
+
+#define TRACE_ARCH_ELF
+#ifdef TRACE_ARCH_ELF
+#   define TRACE(x) dprintf x
+#   define CHATTY 1
+#else
+#   define TRACE(x) ;
+#   define CHATTY 0
+#endif
+
+#ifdef _BOOT_MODE
+status_t
+boot_arch_elf_relocate_rel(struct preloaded_image *image,
+    struct Elf32_Rel *rel, int rel_len)
+#else
+int
+arch_elf_relocate_rel(struct elf_image_info *image,
+    struct elf_image_info *resolve_image, struct Elf32_Rel *rel, int rel_len)
+#endif
+{
+    return B_NO_ERROR;
+}
+
+
+static inline void
+write_32(addr_t P, Elf32_Word value)
+{
+}
+
+
+static inline void
+write_16(addr_t P, Elf32_Word value)
+{
+}
+
+
+static inline bool
+write_16_check(addr_t P, Elf32_Word value)
+{
+    return true;
+}
+
+
+static inline bool
+write_8(addr_t P, Elf32_Word value)
+{
+    return true;
+}
+
+
+static inline bool
+write_8_check(addr_t P, Elf32_Word value)
+{
+    return true;
+}
+
+
+#ifdef _BOOT_MODE
+status_t
+boot_arch_elf_relocate_rela(struct preloaded_image *image,
+    struct Elf32_Rela *rel, int rel_len)
+#else
+int
+arch_elf_relocate_rela(struct elf_image_info *image,
+    struct elf_image_info *resolve_image, struct Elf32_Rela *rel, int rel_len)
+#endif
+{
+    return B_OK;
+}
+

src/system/kernel/arch/x86_64/arch_thread.cpp

@@ +1 @@
+/*
+ * Copyright 2003-2010, Haiku Inc. All rights reserved.
+ * Distributed under the terms of the MIT License.
+ *
+ * Authors:
+ *      Axel Dörfler <axeld@pinc-software.de>
+ *      Ingo Weinhold <bonefish@cs.tu-berlin.de>
+ *      François Revol <revol@free.fr>
+ *
+ * Copyright 2001, Travis Geiselbrecht. All rights reserved.
+ * Distributed under the terms of the NewOS License.
+ */
+
+#include <arch/thread.h>
+
+#include <string.h>
+
+#include <arch/user_debugger.h>
+#include <arch_cpu.h>
+#include <cpu.h>
+#include <debug.h>
+#include <kernel.h>
+#include <ksignal.h>
+#include <int.h>
+#include <team.h>
+#include <thread.h>
+#include <tls.h>
+#include <tracing.h>
+#include <vm/vm_types.h>
+#include <vm/VMAddressSpace.h>
+
+// static struct arch_thread sInitialState;
+
+struct thread *gCurrentThread;
+
+
+status_t
+arch_thread_init(struct kernel_args *args)
+{
+    // Initialize the static initial arch_thread state (sInitialState).
+    // Currently nothing to do, i.e. zero initialized is just fine.
+
+    return B_OK;
+}
+
+
+status_t
+arch_team_init_team_struct(struct team *team, bool kernel)
+{
+    // Nothing to do. The structure is empty.
+    return B_OK;
+}
+
+
+status_t
+arch_thread_init_thread_struct(struct thread *thread)
+{
+
+    return B_OK;
+}
+
+
+status_t
+arch_thread_init_kthread_stack(struct thread *t, int (*start_func)(void),
+    void (*entry_func)(void), void (*exit_func)(void))
+{
+/*  addr_t *kstack = (addr_t *)t->kernel_stack_base;
+    addr_t *kstackTop = (addr_t *)t->kernel_stack_base;
+
+    // clear the kernel stack
+#ifdef DEBUG_KERNEL_STACKS
+#   ifdef STACK_GROWS_DOWNWARDS
+    memset((void *)((addr_t)kstack + KERNEL_STACK_GUARD_PAGES * B_PAGE_SIZE), 0,
+        KERNEL_STACK_SIZE);
+#   else
+    memset(kstack, 0, KERNEL_STACK_SIZE);
+#   endif
+#else
+    memset(kstack, 0, KERNEL_STACK_SIZE);
+#endif
+
+    // space for frame pointer and return address, and stack frames must be
+    // 16 byte aligned
+    kstackTop -= 2;
+    kstackTop = (addr_t*)((addr_t)kstackTop & ~0xf);
+
+    // LR, CR, r2, r13-r31, f13-f31, as pushed by m68k_context_switch()
+    kstackTop -= 22 + 2 * 19;
+
+    // let LR point to m68k_kernel_thread_root()
+    kstackTop[0] = (addr_t)&m68k_kernel_thread_root;
+
+    // the arguments of m68k_kernel_thread_root() are the functions to call,
+    // provided in registers r13-r15
+    kstackTop[3] = (addr_t)entry_func;
+    kstackTop[4] = (addr_t)start_func;
+    kstackTop[5] = (addr_t)exit_func;
+
+    // save this stack position
+    t->arch_info.sp = (void *)kstackTop;
+*/
+    return B_OK;
+}
+
+
+status_t
+arch_thread_init_tls(struct thread *thread)
+{
+    // TODO: Implement!
+    return B_OK;
+}
+
+
+void
+arch_thread_context_switch(struct thread *from, struct thread *to)
+{
+/*  addr_t newPageDirectory;
+
+    newPageDirectory = (addr_t)m68k_next_page_directory(from, to);
+
+    if ((newPageDirectory % B_PAGE_SIZE) != 0)
+        panic("arch_thread_context_switch: bad pgdir 0x%lx\n", newPageDirectory);
+#warning M68K: export from arch_vm.c
+    m68k_set_pgdir(newPageDirectory);
+    m68k_context_switch(&from->arch_info.sp, to->arch_info.sp);*/
+}
+
+
+void
+arch_thread_dump_info(void *info)
+{
+}
+
+
+status_t
+arch_thread_enter_userspace(struct thread *thread, addr_t entry, void *arg1, void *arg2)
+{
+    panic("arch_thread_enter_uspace(): not yet implemented\n");
+    return B_ERROR;
+}
+
+
+bool
+arch_on_signal_stack(struct thread *thread)
+{
+    return false;
+}
+
+
+status_t
+arch_setup_signal_frame(struct thread *thread, struct sigaction *sa, int sig, int sigMask)
+{
+    return B_ERROR;
+}
+
+
+int64
+arch_restore_signal_frame(void)
+{
+    return 0;
+}
+
+
+void
+arch_check_syscall_restart(struct thread *thread)
+{
+}
+
+
+/** Saves everything needed to restore the frame in the child fork in the
+ *  arch_fork_arg structure to be passed to arch_restore_fork_frame().
+ *  Also makes sure to return the right value.
+ */
+
+void
+arch_store_fork_frame(struct arch_fork_arg *arg)
+{
+}
+
+
+/** Restores the frame from a forked team as specified by the provided
+ *  arch_fork_arg structure.
+ *  Needs to be called from within the child team, ie. instead of
+ *  arch_thread_enter_uspace() as thread "starter".
+ *  This function does not return to the caller, but will enter userland
+ *  in the child team at the same position where the parent team left of.
+ */
+
+void
+arch_restore_fork_frame(struct arch_fork_arg *arg)
+{
+}
+
+void
+arch_syscall_64_bit_return_value(void)
+{
+    struct thread* thread = thread_get_current_thread();
+    atomic_or(&thread->flags, THREAD_FLAGS_64_BIT_SYSCALL_RETURN);
+}

src/system/kernel/arch/x86_64/arch_debug_console.cpp

@@ +1 @@
+/*
+ * Copyright 2007, François Revol, revol@free.fr.
+ * Distributed under the terms of the MIT License.
+ *
+ * Copyright 2003-2006, Axel Dörfler, axeld@pinc-software.de.
+ * Distributed under the terms of the MIT License.
+ *
+ * Copyright 2001, Travis Geiselbrecht. All rights reserved.
+ * Distributed under the terms of the NewOS License.
+ */
+
+
+//#include <arch_platform.h>
+#include <arch/debug_console.h>
+#include <boot/kernel_args.h>
+#include <kernel.h>
+#include <vm/vm.h>
+#include <arch/arm/uart.h>
+#include <string.h>
+
+
+void
+arch_debug_remove_interrupt_handler(uint32 line)
+{
+}
+
+
+void
+arch_debug_install_interrupt_handlers(void)
+{
+}
+
+
+char
+arch_debug_blue_screen_getchar(void)
+{
+    return 0;
+//M68KPlatform::Default()->BlueScreenGetChar();
+}
+
+
+char
+arch_debug_serial_getchar(void)
+{
+    return 0;
+//M68KPlatform::Default()->SerialDebugGetChar();
+}
+
+
+void
+arch_debug_serial_putchar(const char c)
+{
+
+//  return 0;
+//M68KPlatform::Default()->SerialDebugPutChar(c);
+}
+
+
+void
+arch_debug_serial_puts(const char *s)
+{
+    while (*s != '\0') {
+        arch_debug_serial_putchar(*s);
+        s++;
+    }
+}
+
+
+void
+arch_debug_serial_early_boot_message(const char *string)
+{
+    // this function will only be called in fatal situations
+}
+
+
+status_t
+arch_debug_console_init(kernel_args *args)
+{
+
+    return 0;
+//M68KPlatform::Default()->InitSerialDebug(args);
+}
+
+
+status_t
+arch_debug_console_init_settings(kernel_args *args)
+{
+    return B_OK;
+}
+

src/system/kernel/arch/x86_64/asm_offsets.cpp

@@ +1 @@
+/*
+ * Copyright 2007-2009, Ingo Weinhold, ingo_weinhold@gmx.de.
+ * Distributed under the terms of the MIT License.
+ */
+
+// This file is used to get C structure offsets into assembly code.
+// The build system assembles the file and processes the output to create
+// a header file with macro definitions, that can be included from assembly
+// code.
+
+
+#include <computed_asm_macros.h>
+
+#include <arch_cpu.h>
+#include <cpu.h>
+#include <ksyscalls.h>
+#include <thread_types.h>
+
+
+#define DEFINE_MACRO(macro, value) DEFINE_COMPUTED_ASM_MACRO(macro, value)
+
+#define DEFINE_OFFSET_MACRO(prefix, structure, member) \
+    DEFINE_MACRO(prefix##_##member, offsetof(struct structure, member));
+
+#define DEFINE_SIZEOF_MACRO(prefix, structure) \
+    DEFINE_MACRO(prefix##_sizeof, sizeof(struct structure));
+
+
+void
+dummy()
+{
+    // struct cpu_ent
+    DEFINE_OFFSET_MACRO(CPU_ENT, cpu_ent, fault_handler);
+    DEFINE_OFFSET_MACRO(CPU_ENT, cpu_ent, fault_handler_stack_pointer);
+
+    // struct thread
+    DEFINE_OFFSET_MACRO(THREAD, thread, kernel_time);
+    DEFINE_OFFSET_MACRO(THREAD, thread, user_time);
+    DEFINE_OFFSET_MACRO(THREAD, thread, last_time);
+    DEFINE_OFFSET_MACRO(THREAD, thread, in_kernel);
+    DEFINE_OFFSET_MACRO(THREAD, thread, flags);
+    DEFINE_OFFSET_MACRO(THREAD, thread, kernel_stack_top);
+    DEFINE_OFFSET_MACRO(THREAD, thread, fault_handler);
+
+    // struct iframe
+    DEFINE_OFFSET_MACRO(IFRAME, iframe, cs);
+    DEFINE_OFFSET_MACRO(IFRAME, iframe, eax);
+    DEFINE_OFFSET_MACRO(IFRAME, iframe, edx);
+    DEFINE_OFFSET_MACRO(IFRAME, iframe, orig_eax);
+    DEFINE_OFFSET_MACRO(IFRAME, iframe, vector);
+    DEFINE_OFFSET_MACRO(IFRAME, iframe, eip);
+    DEFINE_OFFSET_MACRO(IFRAME, iframe, flags);
+    DEFINE_OFFSET_MACRO(IFRAME, iframe, user_esp);
+
+    // struct vm86_iframe
+    DEFINE_SIZEOF_MACRO(VM86_IFRAME, vm86_iframe);
+    DEFINE_OFFSET_MACRO(VM86_IFRAME, vm86_iframe, flags);
+
+    // struct syscall_info
+    DEFINE_SIZEOF_MACRO(SYSCALL_INFO, syscall_info);
+    DEFINE_OFFSET_MACRO(SYSCALL_INFO, syscall_info, function);
+    DEFINE_OFFSET_MACRO(SYSCALL_INFO, syscall_info, parameter_size);
+
+    // struct x86_optimized_functions
+    DEFINE_OFFSET_MACRO(X86_OPTIMIZED_FUNCTIONS, x86_optimized_functions,
+        memcpy);
+    DEFINE_OFFSET_MACRO(X86_OPTIMIZED_FUNCTIONS, x86_optimized_functions,
+        memset);
+}

src/system/kernel/arch/x86_64/arch_real_time_clock.cpp

@@ +1 @@
+/*
+ * Copyright 2007, François Revol, revol@free.fr.
+ * Copyright 2006, Ingo Weinhold <bonefish@cs.tu-berlin.de>. All rights reserved.
+ * Copyright 2005-2007, Axel Dörfler, axeld@pinc-software.de
+ * Copyright 2003, Jeff Ward, jeff@r2d2.stcloudstate.edu. All rights reserved.
+ *
+ * Distributed under the terms of the MIT License.
+ */
+
+#include <arch/real_time_clock.h>
+
+//#include <arch_platform.h>
+#include <real_time_clock.h>
+#include <real_time_data.h>
+#include <smp.h>
+/*
+typedef struct  {
+    uint8 second;
+    uint8 minute;
+    uint8 hour;
+    uint8 day;
+    uint8 month;
+    uint8 year;
+    uint8 century;
+} cmos_time;
+
+
+static uint32
+bcd_to_int(uint8 bcd)
+{
+    uint32 numl;
+    uint32 numh;
+
+    numl = bcd & 0x0f;
+    numh = (bcd & 0xf0) >> 4;
+
+    return numh * 10 + numl;
+}
+
+
+static uint8
+int_to_bcd(uint32 number)
+{
+    uint8 low;
+    uint8 high;
+
+    if (number > 99)
+        return 0;
+
+    high = number / 10;
+    low = number % 10;
+
+    return (high << 4) | low;
+}
+
+
+static int
+same_time(const cmos_time *time1, const cmos_time *time2)
+{
+    return time1->second == time2->second
+        && time1->minute == time2->minute
+        && time1->hour == time2->hour
+        && time1->day == time2->day
+        && time1->month == time2->month
+        && time1->year == time2->year
+        && time1->century == time2->century;
+}
+
+
+static uint8
+cmos_read(uint8 addr)
+{
+    return M68KPlatform::Default()->ReadRTCReg(addr);
+}
+
+
+static void
+cmos_write(uint8 addr, uint8 data)
+{
+    M68KPlatform::Default()->WriteRTCReg(addr, data);
+}
+
+
+static void
+set_24_hour_mode(void)
+{
+    uint8 status_b;
+
+    status_b = cmos_read(0x0b);
+    status_b |= 0x02;
+    cmos_write(0x0b, status_b);
+}
+
+
+static void
+read_cmos_clock(cmos_time *cmos)
+{
+    set_24_hour_mode();
+
+    cmos->century = cmos_read(0x32);
+    cmos->year = cmos_read(0x09);
+    cmos->month = cmos_read(0x08);
+    cmos->day = cmos_read(0x07);
+    cmos->hour = cmos_read(0x04);
+    cmos->minute = cmos_read(0x02);
+    cmos->second = cmos_read(0x00);
+}
+
+
+static void
+write_cmos_clock(cmos_time *cmos)
+{
+    set_24_hour_mode();
+
+    cmos_write(0x32, cmos->century);
+    cmos_write(0x09, cmos->year);
+    cmos_write(0x08, cmos->month);
+    cmos_write(0x07, cmos->day);
+    cmos_write(0x04, cmos->hour);
+    cmos_write(0x02, cmos->minute);
+    cmos_write(0x00, cmos->second);
+}
+
+
+static uint32
+cmos_to_secs(const cmos_time *cmos)
+{
+    struct tm t;
+    t.tm_year = bcd_to_int(cmos->century) * 100 + bcd_to_int(cmos->year)
+        - RTC_EPOCH_BASE_YEAR;
+    t.tm_mon = bcd_to_int(cmos->month) - 1;
+    t.tm_mday = bcd_to_int(cmos->day);
+    t.tm_hour = bcd_to_int(cmos->hour);
+    t.tm_min = bcd_to_int(cmos->minute);
+    t.tm_sec = bcd_to_int(cmos->second);
+
+    return rtc_tm_to_secs(&t);
+}
+
+
+static void
+secs_to_cmos(uint32 seconds, cmos_time *cmos)
+{
+    int wholeYear;
+
+    struct tm t;
+    rtc_secs_to_tm(seconds, &t);
+
+    wholeYear = t.tm_year + RTC_EPOCH_BASE_YEAR;
+
+    cmos->century = int_to_bcd(wholeYear / 100);
+    cmos->year = int_to_bcd(wholeYear % 100);
+    cmos->month = int_to_bcd(t.tm_mon + 1);
+    cmos->day = int_to_bcd(t.tm_mday);
+    cmos->hour = int_to_bcd(t.tm_hour);
+    cmos->minute = int_to_bcd(t.tm_min);
+    cmos->second = int_to_bcd(t.tm_sec);
+}
+
+
+//  #pragma mark -
+
+
+
+static spinlock sSetArchDataLock;
+*/
+status_t
+arch_rtc_init(kernel_args *args, struct real_time_data *data)
+{
+/*
+    // init the platform RTC service
+    status_t error = M68KPlatform::Default()->InitRTC(args, data);
+    if (error != B_OK)
+        return error;
+
+    // init the arch specific part of the real_time_data
+    data->arch_data.data[0].system_time_offset = 0;
+    // cvFactor = 2^32 * 1000000 / tbFreq
+    // => (tb * cvFactor) >> 32 = (tb * 2^32 * 1000000 / tbFreq) >> 32
+    //    = tb / tbFreq * 1000000 = time in us
+    data->arch_data.system_time_conversion_factor
+        = uint32((uint64(1) << 32) * 1000000
+            / args->arch_args.time_base_frequency);
+    data->arch_data.version = 0;
+
+    // init spinlock
+    sSetArchDataLock = 0;
+
+    // init system_time() conversion factor
+    __m68k_setup_system_time(&data->arch_data.system_time_conversion_factor);
+*/
+    return B_OK;
+}
+
+
+uint32
+arch_rtc_get_hw_time(void)
+{
+
+    return 0;
+//M68KPlatform::Default()->GetHardwareRTC();
+}
+
+
+void
+arch_rtc_set_hw_time(uint32 seconds)
+{
+
+//  M68KPlatform::Default()->SetHardwareRTC(seconds);
+}
+
+
+void
+arch_rtc_set_system_time_offset(struct real_time_data *data, bigtime_t offset)
+{
+/*
+    cpu_status state = disable_interrupts();
+    acquire_spinlock(&sSetArchDataLock);
+
+    int32 version = data->arch_data.version + 1;
+    data->arch_data.data[version % 2].system_time_offset = offset;
+    data->arch_data.version = version;
+
+    release_spinlock(&sSetArchDataLock);
+    restore_interrupts(state);
+*/
+
+}
+
+
+bigtime_t
+arch_rtc_get_system_time_offset(struct real_time_data *data)
+{
+/*
+    int32 version;
+    bigtime_t offset;
+    do {
+        version = data->arch_data.version;
+        offset = data->arch_data.data[version % 2].system_time_offset;
+    } while (version != data->arch_data.version);
+
+    return offset;
+*/
+return 0;
+}

src/system/kernel/arch/x86_64/arch_timer.cpp

@@ +1 @@
+/*
+ * Copyright 2007, Haiku Inc. All rights reserved.
+ * Distributed under the terms of the MIT License.
+ *
+ * Authors:
+ *      François Revol <revol@free.fr>
+ *
+ * Copyright 2001, Travis Geiselbrecht. All rights reserved.
+ * Distributed under the terms of the NewOS License.
+ */
+
+
+#include <boot/stage2.h>
+#include <kernel.h>
+#include <debug.h>
+
+#include <timer.h>
+#include <arch/timer.h>
+//#include <arch_platform.h>
+
+
+void 
+arch_timer_set_hardware_timer(bigtime_t timeout)
+{
+//  M68KPlatform::Default()->SetHardwareTimer(timeout);
+}
+
+
+void 
+arch_timer_clear_hardware_timer()
+{
+//  M68KPlatform::Default()->ClearHardwareTimer();
+}
+
+
+int 
+arch_init_timer(kernel_args *args)
+{
+
+    return 0;
+//M68KPlatform::Default()->InitTimer(args);
+}
+

src/system/kernel/arch/x86_64/arch_vm.cpp

@@ +1 @@
+/*
+ * Copyright 2007, François Revol, revol@free.fr.
+ * Distributed under the terms of the MIT License.
+ *
+ * Copyright 2003-2005, Axel Dörfler, axeld@pinc-software.de.
+ * Distributed under the terms of the MIT License.
+ *
+ * Copyright 2001, Travis Geiselbrecht. All rights reserved.
+ * Distributed under the terms of the NewOS License.
+ */
+
+#include <KernelExport.h>
+
+#include <kernel.h>
+#include <boot/kernel_args.h>
+
+#include <vm/vm.h>
+#include <vm/vm_types.h>
+#include <arch/vm.h>
+//#include <arch_mmu.h>
+
+
+//#define TRACE_ARCH_VM
+#ifdef TRACE_ARCH_VM
+#   define TRACE(x) dprintf x
+#else
+#   define TRACE(x) ;
+#endif
+
+//TODO: WRITEME
+
+status_t
+arch_vm_init(kernel_args *args)
+{
+    return B_OK;
+}
+
+
+status_t
+arch_vm_init2(kernel_args *args)
+{
+//  int bats[8];
+//  int i;
+
+    /**/
+//TODO: WRITEME
+
+    return B_OK;
+}
+
+
+status_t
+arch_vm_init_post_area(kernel_args *args)
+{
+    return B_OK;
+}
+
+
+status_t
+arch_vm_init_end(kernel_args *args)
+{
+
+//TODO: WRITEME
+    return B_OK;
+}
+
+
+status_t
+arch_vm_init_post_modules(kernel_args *args)
+{
+    return B_OK;
+}
+
+
+void
+arch_vm_aspace_swap(struct VMAddressSpace *from, struct VMAddressSpace *to)
+{
+//TODO: WRITEME
+//  m68k_set_pgdir(m68k_translation_map_get_pgdir(&to->TranslationMap()));
+}
+
+
+bool
+arch_vm_supports_protection(uint32 protection)
+{
+    return true;
+}
+
+
+void
+arch_vm_unset_memory_type(VMArea *area)
+{
+}
+
+
+status_t
+arch_vm_set_memory_type(VMArea *area, phys_addr_t physicalBase, uint32 type)
+{
+    if (type == 0)
+        return B_OK;
+
+    return B_ERROR;
+}

src/system/kernel/arch/x86_64/arch_user_debugger.cpp

@@ +1 @@
+/*
+ * Copyright 2007, François Revol, revol@free.fr.
+ * Distributed under the terms of the MIT License.
+ *
+ * Copyright 2005, Axel Dörfler, axeld@pinc-softare.de
+ * Distributed under the terms of the MIT License.
+ */
+
+
+#include <debugger.h>
+#include <int.h>
+#include <thread.h>
+#include <arch/user_debugger.h>
+
+const uint8 kX86SoftwareBreakpoint[1] = { 0xcc };
+
+void
+arch_clear_team_debug_info(struct arch_team_debug_info *info)
+{
+}
+
+
+void
+arch_destroy_team_debug_info(struct arch_team_debug_info *info)
+{
+    arch_clear_team_debug_info(info);
+}
+
+
+void
+arch_clear_thread_debug_info(struct arch_thread_debug_info *info)
+{
+}
+
+
+void
+arch_destroy_thread_debug_info(struct arch_thread_debug_info *info)
+{
+    arch_clear_thread_debug_info(info);
+}
+
+
+void
+arch_update_thread_single_step()
+{
+}
+
+
+void
+arch_set_debug_cpu_state(const debug_cpu_state *cpuState)
+{
+}
+
+
+void
+arch_get_debug_cpu_state(debug_cpu_state *cpuState)
+{
+}
+
+
+status_t
+arch_get_thread_debug_cpu_state(struct thread *thread,
+        debug_cpu_state *cpuState)
+{
+        return B_ERROR;
+}
+
+
+
+status_t
+arch_set_breakpoint(void *address)
+{
+    return B_ERROR;
+}
+
+
+status_t
+arch_clear_breakpoint(void *address)
+{
+    return B_ERROR;
+}
+
+
+status_t
+arch_set_watchpoint(void *address, uint32 type, int32 length)
+{
+    return B_ERROR;
+}
+
+
+status_t
+arch_clear_watchpoint(void *address)
+{
+    return B_ERROR;
+}
+
+bool
+arch_has_breakpoints(struct arch_team_debug_info *info)
+{
+    return false;
+}
+
+void
+x86_init_user_debug()
+{
+}

src/system/kernel/arch/x86_64/arch_platform.cpp

@@ +1 @@
+/*
+ * Copyright 2007, François Revol, revol@free.fr.
+ * Distributed under the terms of the MIT License.
+ *
+ * Copyright 2006, Ingo Weinhold <bonefish@cs.tu-berlin.de>.
+ * All rights reserved. Distributed under the terms of the MIT License.
+ */
+
+//#include <arch_platform.h>
+
+#include <new>
+
+#include <KernelExport.h>
+#include <arch/platform.h>
+#include <boot/kernel_args.h>
+//#include <platform/openfirmware/openfirmware.h>
+#include <real_time_clock.h>
+#include <util/kernel_cpp.h>
+
+/*
+static M68KPlatform *sM68KPlatform;
+
+
+// constructor
+M68KPlatform::M68KPlatform(platform_type platformType,
+    m68k_platform_type m68kPlatformType)
+    : fPlatformType(platformType),
+      fM68KPlatformType(m68kPlatformType)
+{
+}
+
+// destructor
+M68KPlatform::~M68KPlatform()
+{
+}
+
+// Default
+M68KPlatform *
+M68KPlatform::Default()
+{
+    return sM68KPlatform;
+}
+
+
+// # pragma mark -
+*/
+
+status_t
+arch_platform_init(struct kernel_args *kernelArgs)
+{
+
+    return B_OK;
+}
+
+
+status_t
+arch_platform_init_post_vm(struct kernel_args *kernelArgs)
+{
+    return B_OK;
+//sM68KPlatform->InitPostVM(kernelArgs);
+}
+
+
+status_t
+arch_platform_init_post_thread(struct kernel_args *kernelArgs)
+{
+    return B_OK;
+}

src/system/kernel/arch/x86_64/entry.S

@@ +1 @@
+;Temp entry to x86_64 code.
+;
+
+.code 32
+
+.external _start
+.global init_long_mode
+
+init_long_mode:
+
+ov eax, cr0 ; Read CR0.
+and eax,7FFFFFFFh; Set PE=0
+mov cr0, eax ; Write CR0.
+
+mov eax, cr4
+bts eax, 5
+mov cr4, eax
+
+mov ecx, 0c0000080h ; EFER MSR number. 
+rdmsr ; Read EFER.
+bts eax, 8 ; Set LME=1.
+wrmsr ; Write EFER.
+
+mov eax, cr0 ; Read CR0.
+or eax,80000000h ; Set PE=1.
+mov cr0, eax ; Write CR0.
+
+.code 64
+call _start
+
+ret
+
+end

src/system/kernel/arch/x86_64/arch_debug.cpp

@@ +1 @@
+/*
+ * Copyright 2003-2009, Haiku Inc. All rights reserved.
+ * Distributed under the terms of the MIT License.
+ *
+ * Authors:
+ *      Axel Dörfler <axeld@pinc-software.de>
+ *      Ingo Weinhold <bonefish@cs.tu-berlin.de>
+ *      François Revol <revol@free.fr>
+ */
+
+
+#include <arch/debug.h>
+
+#include <arch_cpu.h>
+#include <debug.h>
+#include <elf.h>
+#include <kernel.h>
+#include <kimage.h>
+#include <thread.h>
+
+
+struct stack_frame {
+    struct stack_frame  *previous;
+    addr_t              return_address;
+};
+
+#define NUM_PREVIOUS_LOCATIONS 32
+
+extern struct iframe_stack gBootFrameStack;
+/*
+
+static bool
+already_visited(uint32 *visited, int32 *_last, int32 *_num, uint32 framePointer)
+{
+    int32 last = *_last;
+    int32 num = *_num;
+    int32 i;
+
+    for (i = 0; i < num; i++) {
+        if (visited[(NUM_PREVIOUS_LOCATIONS + last - i)
+                % NUM_PREVIOUS_LOCATIONS] == framePointer) {
+            return true;
+        }
+    }
+
+    *_last = last = (last + 1) % NUM_PREVIOUS_LOCATIONS;
+    visited[last] = framePointer;
+
+    if (num < NUM_PREVIOUS_LOCATIONS)
+        *_num = num + 1;
+
+    return false;
+}
+
+
+static inline stack_frame *
+get_current_stack_frame()
+{
+    stack_frame *frame;
+    asm volatile("move.l %%fp,%0" : "=r"(frame));
+    return frame;
+}
+
+
+static status_t
+get_next_frame(addr_t framePointer, addr_t *next, addr_t *ip)
+{
+    struct thread *thread = thread_get_current_thread();
+    addr_t oldFaultHandler = thread->fault_handler;
+
+    // set fault handler, so that we can safely access user stacks
+    if (thread) {
+        if (m68k_set_fault_handler(&thread->fault_handler, (addr_t)&&error))
+            goto error;
+    }
+
+    *ip = ((struct stack_frame *)framePointer)->return_address;
+    *next = (addr_t)((struct stack_frame *)framePointer)->previous;
+
+    if (thread)
+        thread->fault_handler = oldFaultHandler;
+    return B_OK;
+
+error:
+    thread->fault_handler = oldFaultHandler;
+    return B_BAD_ADDRESS;
+}
+
+
+static void
+print_stack_frame(struct thread *thread, addr_t ip, addr_t framePointer,
+    addr_t nextFramePointer)
+{
+    addr_t diff = nextFramePointer - framePointer;
+
+    // kernel space/user space switch
+    if (diff & 0x80000000)
+        diff = 0;
+
+    // lookup symbol
+    const char *symbol, *image;
+    addr_t baseAddress;
+    bool exactMatch;
+    status_t status = elf_debug_lookup_symbol_address(ip, &baseAddress, &symbol,
+        &image, &exactMatch);
+    if (status != B_OK && !IS_KERNEL_ADDRESS(ip) && thread) {
+        // try to locate the image in the images loaded into user space
+        status = image_debug_lookup_user_symbol_address(thread->team, ip,
+            &baseAddress, &symbol, &image, &exactMatch);
+    }
+    if (status == B_OK) {
+        if (symbol != NULL) {
+            kprintf("%08lx (+%4ld) %08lx   <%s>:%s + 0x%04lx%s\n", framePointer,
+                diff, ip, image, symbol, ip - baseAddress,
+                (exactMatch ? "" : " (nearest)"));
+        } else {
+            kprintf("%08lx (+%4ld) %08lx   <%s@%p>:unknown + 0x%04lx\n",
+                framePointer, diff, ip, image, (void *)baseAddress,
+                ip - baseAddress);
+        }
+    } else
+        kprintf("%08lx (+%4ld) %08lx\n", framePointer, diff, ip);
+}
+
+
+static int
+stack_trace(int argc, char **argv)
+{
+    uint32 previousLocations[NUM_PREVIOUS_LOCATIONS];
+    struct iframe_stack *frameStack;
+    struct thread *thread;
+    addr_t framePointer;
+    int32 i, num = 0, last = 0;
+
+    if (argc < 2) {
+        thread = thread_get_current_thread();
+        framePointer = (addr_t)get_current_stack_frame();
+    } else {
+kprintf("Stack traces of other threads not supported yet!\n");
+return 0;
+    }
+
+    // We don't have a thread pointer early in the boot process
+    if (thread != NULL)
+        frameStack = &thread->arch_info.iframes;
+    else
+        frameStack = &gBootFrameStack;
+
+    for (i = 0; i < frameStack->index; i++) {
+        kprintf("iframe %p (end = %p)\n",
+            frameStack->frames[i], frameStack->frames[i] + 1);
+    }
+
+    if (thread != NULL) {
+        kprintf("stack trace for thread 0x%lx \"%s\"\n", thread->id,
+            thread->name);
+
+        kprintf("    kernel stack: %p to %p\n",
+            (void *)thread->kernel_stack_base,
+            (void *)(thread->kernel_stack_top));
+        if (thread->user_stack_base != 0) {
+            kprintf("      user stack: %p to %p\n",
+                (void *)thread->user_stack_base,
+                (void *)(thread->user_stack_base + thread->user_stack_size));
+        }
+    }
+
+    kprintf("frame            caller     <image>:function + offset\n");
+
+    for (;;) {
+        // see if the frame pointer matches the iframe
+        struct iframe *frame = NULL;
+        for (i = 0; i < frameStack->index; i++) {
+            if (framePointer == (addr_t)frameStack->frames[i]) {
+                // it's an iframe
+                frame = frameStack->frames[i];
+                break;
+            }
+        }
+
+        if (frame) {
+            kprintf("iframe at %p\n", frame);
+            kprintf("   d0 0x%08lx    d1 0x%08lx    d2 0x%08lx    d3 0x%08lx\n",
+                frame->d[0], frame->d[1], frame->d[2], frame->d[3]);
+            kprintf("   d4 0x%08lx    d5 0x%08lx    d6 0x%08lx    d7 0x%08lx\n",
+                frame->d[4], frame->d[5], frame->d[6], frame->d[7]);
+            kprintf("   a0 0x%08lx    a1 0x%08lx    a2 0x%08lx    a3 0x%08lx\n",
+                frame->a[0], frame->a[1], frame->a[2], frame->a[3]);
+            kprintf("   a4 0x%08lx    a5 0x%08lx    a6 0x%08lx    a7 0x%08lx (sp)\n",
+#warning M68K: a7 in iframe ??
+                frame->a[4], frame->a[5], frame->a[6], -1L);
+            kprintf("   pc 0x%08lx        sr 0x%04x\n",
+                frame->cpu.pc, frame->cpu.sr);
+#warning M68K: missing regs
+
+            print_stack_frame(thread, frame->cpu.pc, framePointer, frame->a[6]);
+            framePointer = frame->a[6];
+        } else {
+            addr_t ip, nextFramePointer;
+
+            if (get_next_frame(framePointer, &nextFramePointer, &ip) != B_OK) {
+                kprintf("%08lx -- read fault\n", framePointer);
+                break;
+            }
+
+            if (ip == 0 || framePointer == 0)
+                break;
+
+            print_stack_frame(thread, ip, framePointer, nextFramePointer);
+            framePointer = nextFramePointer;
+        }
+
+        if (already_visited(previousLocations, &last, &num, framePointer)) {
+            kprintf("circular stack frame: %p!\n", (void *)framePointer);
+            break;
+        }
+        if (framePointer == 0)
+            break;
+    }
+
+
+    return 0;
+}
+
+*/
+
+// #pragma mark -
+
+
+void
+arch_debug_save_registers(struct arch_debug_registers* registers)
+{
+}
+
+
+bool
+arch_debug_contains_call(struct thread *thread, const char *symbol,
+    addr_t start, addr_t end)
+{
+    return false;
+}
+
+
+void
+arch_debug_stack_trace(void)
+{
+}
+
+
+void *
+arch_debug_get_caller(void)
+{
+    // TODO: implement me
+    //return __builtin_frame_address(1);
+//  struct stack_frame *frame;
+    //frame = __builtin_frame_address(0);
+//  frame = get_current_stack_frame();
+//  return (void *)frame->previous->return_address;
+    return NULL;
+}
+
+
+int32
+arch_debug_get_stack_trace(addr_t* returnAddresses, int32 maxCount,
+    int32 skipIframes, int32 skipFrames, uint32 flags)
+{
+
+    return 0;
+}
+
+
+void*
+arch_debug_get_interrupt_pc(bool* _isSyscall)
+{
+    // TODO: Implement!
+    return NULL;
+}
+
+
+bool
+arch_is_debug_variable_defined(const char* variableName)
+{
+    // TODO: Implement!
+    return false;
+}
+
+
+status_t
+arch_set_debug_variable(const char* variableName, uint64 value)
+{
+    // TODO: Implement!
+    return B_ENTRY_NOT_FOUND;
+}
+
+
+status_t
+arch_get_debug_variable(const char* variableName, uint64* value)
+{
+    // TODO: Implement!
+    return B_ENTRY_NOT_FOUND;
+}
+
+
+status_t
+arch_debug_init(kernel_args *args)
+{
+//  add_debugger_command("where", &stack_trace, "Same as \"sc\"");
+//  add_debugger_command("bt", &stack_trace, "Same as \"sc\" (as in gdb)");
+//  add_debugger_command("sc", &stack_trace, "Stack crawl for current thread");
+
+    return B_NO_ERROR;
+}
+
+
+void
+arch_debug_call_with_fault_handler(cpu_ent* cpu, jmp_buf jumpBuffer,
+    void (*function)(void*), void* parameter)
+{
+    // TODO: Implement! Most likely in assembly.
+//  longjmp(jumpBuffer, 1);
+}
+
+
+void
+arch_debug_unset_current_thread(void)
+{
+    // TODO: Implement!
+}
+
+

src/system/kernel/arch/x86_64/arch_cpu.cpp

@@ +1 @@
+/*
+ * Copyright 2007, François Revol, revol@free.fr.
+ * Distributed under the terms of the MIT License.
+ *
+ * Copyright 2003-2005, Axel Dörfler, axeld@pinc-software.de.
+ * Distributed under the terms of the MIT License.
+ *
+ * Copyright 2001, Travis Geiselbrecht. All rights reserved.
+ * Distributed under the terms of the NewOS License.
+ */
+
+
+#include <KernelExport.h>
+
+//#include <arch_platform.h>
+#include <arch_thread.h>
+#include <arch/cpu.h>
+#include <boot/kernel_args.h>
+#include <commpage.h>
+#include <elf.h>
+
+
+int arch_cpu_type;
+int arch_fpu_type;
+int arch_mmu_type;
+int arch_platform;
+
+x86_optimized_functions gOptimizedFunctions = {
+};
+
+status_t 
+arch_cpu_preboot_init_percpu(kernel_args *args, int curr_cpu)
+{
+    // enable FPU
+    //ppc:set_msr(get_msr() | MSR_FP_AVAILABLE);
+
+    // The current thread must be NULL for all CPUs till we have threads.
+    // Some boot code relies on this.
+//  arch_thread_set_current_thread(NULL);
+
+    return B_OK;
+}
+
+
+status_t 
+arch_cpu_init_percpu(kernel_args *args, int curr_cpu)
+{
+    //detect_cpu(curr_cpu);
+
+    // we only support one anyway...
+    return 0;
+}
+
+
+status_t
+arch_cpu_init(kernel_args *args)
+{
+// TODO: FINISH
+
+    return B_OK;
+}
+
+
+status_t
+arch_cpu_init_post_vm(kernel_args *args)
+{
+    return B_OK;
+}
+
+status_t
+arch_cpu_init_post_modules(kernel_args *args)
+{
+    // add the functions to the commpage image
+//  image_id image = get_commpage_image();
+
+    return B_OK;
+}
+
+
+void 
+arch_cpu_sync_icache(void *address, size_t len)
+{
+
+//  cpu_ops.flush_icache((addr_t)address, len);
+}
+
+
+void
+arch_cpu_memory_read_barrier(void)
+{
+}
+
+
+void
+arch_cpu_memory_write_barrier(void)
+{
+}
+
+
+void 
+arch_cpu_invalidate_TLB_range(addr_t start, addr_t end)
+{
+/*  int32 num_pages = end / B_PAGE_SIZE - start / B_PAGE_SIZE;
+    cpu_ops.flush_insn_pipeline();
+    while (num_pages-- >= 0) {
+        cpu_ops.flush_atc_addr(start);
+        cpu_ops.flush_insn_pipeline();
+        start += B_PAGE_SIZE;
+    }
+    cpu_ops.flush_insn_pipeline();
+*/
+}
+
+
+void 
+arch_cpu_invalidate_TLB_list(addr_t pages[], int num_pages)
+{
+/*
+    int i;
+    
+    cpu_ops.flush_insn_pipeline();
+    for (i = 0; i < num_pages; i++) {
+        cpu_ops.flush_atc_addr(pages[i]);
+        cpu_ops.flush_insn_pipeline();
+    }
+    cpu_ops.flush_insn_pipeline();
+*/
+}
+
+
+void 
+arch_cpu_global_TLB_invalidate(void)
+{
+/*  cpu_ops.flush_insn_pipeline();
+    cpu_ops.flush_atc_all();
+    cpu_ops.flush_insn_pipeline();
+*/
+}
+
+
+void 
+arch_cpu_user_TLB_invalidate(void)
+{/*
+    cpu_ops.flush_insn_pipeline();
+    cpu_ops.flush_atc_user();
+    cpu_ops.flush_insn_pipeline();
+*/
+}
+
+
+status_t
+arch_cpu_user_memcpy(void *to, const void *from, size_t size,
+    addr_t *faultHandler)
+{
+/*
+    char *tmp = (char *)to;
+    char *s = (char *)from;
+    addr_t oldFaultHandler = *faultHandler;
+
+    if (m68k_set_fault_handler(faultHandler, (addr_t)&&error))
+        goto error;
+
+    while (size--)
+        *tmp++ = *s++;
+
+    *faultHandler = oldFaultHandler;
+    return 0;
+
+error:
+    *faultHandler = oldFaultHandler;*/
+    return B_BAD_ADDRESS;
+}
+
+
+/** \brief Copies at most (\a size - 1) characters from the string in \a from to
+ *  the string in \a to, NULL-terminating the result.
+ *
+ *  \param to Pointer to the destination C-string.
+ *  \param from Pointer to the source C-string.
+ *  \param size Size in bytes of the string buffer pointed to by \a to.
+ *  
+ *  \return strlen(\a from).
+ */
+
+ssize_t
+arch_cpu_user_strlcpy(char *to, const char *from, size_t size, addr_t *faultHandler)
+{
+/*
+    int from_length = 0;
+    addr_t oldFaultHandler = *faultHandler;
+
+    if (m68k_set_fault_handler(faultHandler, (addr_t)&&error))
+        goto error;
+
+    if (size > 0) {
+        to[--size] = '\0';
+        // copy 
+        for ( ; size; size--, from_length++, to++, from++) {
+            if ((*to = *from) == '\0')
+                break;
+        }
+    }
+    // count any leftover from chars
+    while (*from++ != '\0')
+        from_length++;
+
+    *faultHandler = oldFaultHandler;
+    return from_length;
+
+error:
+    *faultHandler = oldFaultHandler;*/
+    return B_BAD_ADDRESS;
+}
+
+
+status_t
+arch_cpu_user_memset(void *s, char c, size_t count, addr_t *faultHandler)
+{
+/*
+    char *xs = (char *)s;
+    addr_t oldFaultHandler = *faultHandler;
+
+    if (m68k_set_fault_handler(faultHandler, (addr_t)&&error))
+        goto error;
+
+    while (count--)
+        *xs++ = c;
+
+    *faultHandler = oldFaultHandler;
+    return 0;
+
+error:
+    *faultHandler = oldFaultHandler;*/
+
+    return B_BAD_ADDRESS;
+}
+
+
+status_t
+arch_cpu_shutdown(bool reboot)
+{
+//  M68KPlatform::Default()->ShutDown(reboot);
+    return B_ERROR;
+}
+
+
+void
+arch_cpu_idle(void)
+{
+//  if (cpu_ops.idle)
+//      cpu_ops.idle();
+//#warning M68K: use LPSTOP ?
+    //asm volatile ("lpstop");
+}
+

src/system/kernel/arch/x86_64/arch_commpage.cpp

@@ +1 @@
+/*
+ * Copyright 2009, Johannes Wischert, johanneswi@gmail.com.
+ * Distributed under the terms of the MIT License.
+ */
+
+
+#include <commpage.h>
+
+#include <string.h>
+
+#include <KernelExport.h>
+
+#include <cpu.h>
+#include <elf.h>
+#include <smp.h>
+
+
+status_t
+arch_commpage_init(void)
+{
+    /* no optimized memcpy or anything yet */
+    /* we don't use it for syscall yet either */
+    // add syscall to the commpage image
+//  image_id image = get_commpage_image();
+    return B_OK;
+}
+
+
+status_t
+arch_commpage_init_post_cpus(void)
+{
+        return B_OK;
+}
+

src/system/kernel/arch/x86_64/Jamfile

@@ +1 @@
+SubDir HAIKU_TOP src system kernel arch x86_64 ;
+
+SubDirHdrs $(SUBDIR) $(DOTDOT) generic ;
+UsePrivateKernelHeaders ;
+
+
+SEARCH_SOURCE += [ FDirName $(SUBDIR) $(DOTDOT) generic ] ;
+
+
+KernelMergeObject kernel_arch_x86_64.o :
+#   entry.S
+
+#   arch_atomic.c
+    arch_commpage.cpp
+    arch_cpu.cpp
+#   arch_cpu_asm.S
+    arch_debug_console.cpp
+    arch_debug.cpp
+    arch_elf.cpp
+#   arch_exceptions.S
+    arch_int.cpp
+    arch_platform.cpp
+    arch_real_time_clock.cpp
+    arch_smp.cpp
+    arch_system_info.cpp
+    arch_thread.cpp
+    arch_timer.cpp
+    arch_user_debugger.cpp
+    arch_vm.cpp
+    arch_vm_translation_map.cpp
+    generic_vm_physical_page_mapper.cpp
+    generic_vm_physical_page_ops.cpp
+
+    :
+    $(TARGET_KERNEL_PIC_CCFLAGS)
+    :
+
+;
+
+CreateAsmStructOffsetsHeader asm_offsets.h : asm_offsets.cpp ;
+

src/system/kernel/arch/x86_64/arch_int.cpp

@@ +1 @@
+/*
+ * Copyright 2003-2010, Haiku Inc. All rights reserved.
+ * Distributed under the terms of the MIT License.
+ *
+ * Authors:
+ *      Axel Dörfler <axeld@pinc-software.de>
+ *      Ingo Weinhold <bonefish@cs.tu-berlin.de>
+ *      François Revol <revol@free.fr>
+ *
+ * Copyright 2001, Travis Geiselbrecht. All rights reserved.
+ * Distributed under the terms of the NewOS License.
+ */
+
+
+#include <int.h>
+
+#include <arch/smp.h>
+#include <boot/kernel_args.h>
+#include <device_manager.h>
+#include <kscheduler.h>
+#include <interrupt_controller.h>
+#include <smp.h>
+#include <thread.h>
+#include <timer.h>
+#include <util/DoublyLinkedList.h>
+#include <util/kernel_cpp.h>
+#include <vm/vm.h>
+#include <vm/vm_priv.h>
+#include <vm/VMAddressSpace.h>
+#include <string.h>
+
+
+//#define TRACE_ARCH_INT
+#ifdef TRACE_ARCH_INT
+#   define TRACE(x) dprintf x
+#else
+#   define TRACE(x) ;
+#endif
+
+/*typedef void (*m68k_exception_handler)(void);
+#define M68K_EXCEPTION_VECTOR_COUNT 256
+#warning M68K: align on 4 ?
+//m68k_exception_handler gExceptionVectors[M68K_EXCEPTION_VECTOR_COUNT];
+m68k_exception_handler *gExceptionVectors;
+
+// defined in arch_exceptions.S
+extern "C" void __m68k_exception_noop(void);
+extern "C" void __m68k_exception_common(void);
+*/
+extern int __irqvec_start;
+extern int __irqvec_end;
+
+//extern"C" void m68k_exception_tail(void);
+
+// current fault handler
+addr_t gFaultHandler;
+
+// interrupt controller interface (initialized
+// in arch_int_init_post_device_manager())
+//static struct interrupt_controller_module_info *sPIC;
+//static void *sPICCookie;
+
+
+void
+arch_int_enable_io_interrupt(int irq)
+{
+    //if (!sPIC)
+    //  return;
+
+    // TODO: I have no idea, what IRQ type is appropriate.
+    //sPIC->enable_io_interrupt(sPICCookie, irq, IRQ_TYPE_LEVEL);
+//  M68KPlatform::Default()->EnableIOInterrupt(irq);
+}
+
+
+void
+arch_int_disable_io_interrupt(int irq)
+{
+
+    //if (!sPIC)
+    //  return;
+
+    //sPIC->disable_io_interrupt(sPICCookie, irq);
+//  M68KPlatform::Default()->DisableIOInterrupt(irq);
+}
+
+
+/* arch_int_*_interrupts() and friends are in arch_asm.S */
+
+/*
+static void
+print_iframe(struct iframe *frame)
+{
+    dprintf("r0-r3:   0x%08lx 0x%08lx 0x%08lx 0x%08lx\n", frame->r0, frame->r1, frame->r2, frame->r3);
+    dprintf("r4-r7:   0x%08lx 0x%08lx 0x%08lx 0x%08lx\n", frame->r4, frame->r5, frame->r6, frame->r7);
+    dprintf("r8-r11:  0x%08lx 0x%08lx 0x%08lx 0x%08lx\n", frame->r8, frame->r9, frame->r10, frame->r11);
+    dprintf("r12-r15: 0x%08lx 0x%08lx 0x%08lx 0x%08lx\n", frame->r12, frame->r13, frame->a6, frame->a7);
+    dprintf("      pc 0x%08lx         sr 0x%08lx\n", frame->pc, frame->sr);
+}
+*/
+
+status_t
+arch_int_init(kernel_args *args)
+{
+//  status_t err;
+//  addr_t vbr;
+//  int i;
+
+//  gExceptionVectors = (m68k_exception_handler *)args->arch_args.vir_vbr;
+
+    /* fill in the vector table */
+//  for (i = 0; i < M68K_EXCEPTION_VECTOR_COUNT; i++)
+//      gExceptionVectors[i] = &__m68k_exception_common;
+
+//  vbr = args->arch_args.phys_vbr;
+    /* point VBR to the new table */
+//  asm volatile  ("movec %0,%%vbr" : : "r"(vbr):);
+
+    return B_OK;
+}
+
+
+status_t
+arch_int_init_post_vm(kernel_args *args)
+{
+    return B_OK;
+}
+
+
+status_t
+arch_int_init_io(kernel_args* args)
+{
+    return B_OK;
+}
+
+
+status_t
+arch_int_init_post_device_manager(struct kernel_args *args)
+{
+    // no PIC found
+    panic("arch_int_init_post_device_manager(): Found no supported PIC!");
+
+    return B_ENTRY_NOT_FOUND;
+}
+
+

src/system/kernel/arch/x86_64/arch_vm_translation_map.cpp

@@ +1 @@
+/*
+ * Copyright 2007, François Revol, revol@free.fr.
+ * Distributed under the terms of the MIT License.
+ *
+ * Copyright 2003-2007, Axel Dörfler, axeld@pinc-software.de.
+ * Distributed under the terms of the MIT License.
+ *
+ * Copyright 2001, Travis Geiselbrecht. All rights reserved.
+ * Distributed under the terms of the NewOS License.
+ */
+
+#include <KernelExport.h>
+#include <kernel.h>
+#include <vm/vm.h>
+#include <vm/vm_priv.h>
+#include <vm/VMAddressSpace.h>
+#include <int.h>
+#include <boot/kernel_args.h>
+#include <arch/vm_translation_map.h>
+#include <arch/cpu.h>
+//#include <arch_mmu.h>
+#include <stdlib.h>
+
+#include "generic_vm_physical_page_mapper.h"
+
+
+void *
+m68k_translation_map_get_pgdir(VMTranslationMap *map)
+{
+    return NULL;
+//TODO: WRITEME
+//get_vm_ops()->m68k_translation_map_get_pgdir(map);
+}
+
+//  #pragma mark -
+//  VM API
+
+
+status_t
+arch_vm_translation_map_init(kernel_args *args,
+        VMPhysicalPageMapper** _physicalPageMapper)
+{
+    return NULL;
+//TODO: WRITEME
+
+//get_vm_ops()->arch_vm_translation_map_init_map(map, kernel);
+}
+
+status_t
+arch_vm_translation_map_create_map(bool kernel, VMTranslationMap** _map)
+{
+    return NULL;
+//TODO: WRITEME
+}
+
+status_t
+arch_vm_translation_map_init_kernel_map_post_sem(VMTranslationMap *map)
+{
+    return NULL;
+//TODO: WRITEME
+
+//get_vm_ops()->arch_vm_translation_map_init_kernel_map_post_sem(map);
+}
+
+
+status_t
+arch_vm_translation_map_init(kernel_args *args)
+{
+    return NULL;
+//TODO: WRITEME
+
+//get_vm_ops()->arch_vm_translation_map_init(args);
+}
+
+
+status_t
+arch_vm_translation_map_init_post_area(kernel_args *args)
+{
+    return NULL;
+//TODO: WRITEME
+
+//get_vm_ops()->arch_vm_translation_map_init_post_area(args);
+}
+
+
+status_t
+arch_vm_translation_map_init_post_sem(kernel_args *args)
+{
+    return NULL;
+//TODO: WRITEME
+
+//get_vm_ops()->arch_vm_translation_map_init_post_sem(args);
+}
+
+
+/** Directly maps a page without having knowledge of any kernel structures.
+ *  Used only during VM setup.
+ *  It currently ignores the "attributes" parameter and sets all pages
+ *  read/write.
+ */
+
+status_t
+arch_vm_translation_map_early_map(kernel_args *ka, addr_t virtualAddress,
+    phys_addr_t physicalAddress, uint8 attributes,
+    phys_addr_t (*get_free_page)(kernel_args *))
+{
+    return NULL;
+//TODO: WRITEME
+
+//get_vm_ops()->arch_vm_translation_map_early_map(ka, virtualAddress, physicalAddress,
+//      attributes, get_free_page);
+}
+
+
+// XXX currently assumes this translation map is active
+
+status_t
+arch_vm_translation_map_early_query(addr_t va, phys_addr_t *out_physical)
+{
+    return NULL;
+//TODO: WRITEME
+
+//get_vm_ops()->arch_vm_translation_map_early_query(va, out_physical);
+}
+
+
+bool
+arch_vm_translation_map_is_kernel_page_accessible(addr_t virtualAddress,
+        uint32 protection)
+{
+//TODO: WRITEME
+        return TRUE;
+//get_vm_ops()-arch_vm_translation_map_is_kernel_page_accessible(virtualAddress,
+  //              protection);
+}
+

src/system/kernel/arch/x86_64/arch_smp.cpp

@@ +1 @@
+/* 
+ * Copyright 2007, Haiku Inc. All rights reserved.
+ * Distributed under the terms of the MIT License.
+ *
+ * Authors:
+ *      François Revol <revol@free.fr>
+ *
+ * Copyright 2004, Axel Dörfler, axeld@pinc-software.de
+ * Distributed under the terms of the OpenBeOS License.
+ */
+
+
+#include <KernelExport.h>
+
+#include <boot/stage2.h>
+#include <arch/smp.h>
+#include <debug.h>
+
+
+status_t
+arch_smp_init(kernel_args *args)
+{
+    return B_OK;
+}
+
+
+status_t
+arch_smp_per_cpu_init(kernel_args *args, int32 cpu)
+{
+    return B_OK;
+}
+
+
+void
+arch_smp_send_ici(int32 target_cpu)
+{
+    panic("called arch_smp_send_ici!\n");
+}
+
+
+void
+arch_smp_send_broadcast_ici()
+{
+    panic("called arch_smp_send_broadcast_ici\n");
+}
+

src/system/kernel/arch/x86_64/arch_system_info.cpp

@@ +1 @@
+/*
+ * Copyright 2007, Haiku Inc. All rights reserved.
+ * Distributed under the terms of the MIT License.
+ *
+ * Authors:
+ *      François Revol <revol@free.fr>
+ *
+ * Copyright 2006, Ingo Weinhold <bonefish@cs.tu-berlin.de>.
+ * All rights reserved. Distributed under the terms of the MIT License.
+ */
+
+#include <OS.h>
+
+#include <arch_cpu.h>
+//#include <arch_platform.h>
+#include <arch/system_info.h>
+#include <boot/kernel_args.h>
+
+/*
+static uint64 sCPUClockFrequency;
+static uint64 sBusClockFrequency;
+static enum cpu_types sCPUType;
+static uint16 sCPURevision;
+*/
+status_t
+arch_get_system_info(system_info *info, size_t size)
+{
+    return B_OK;
+}
+
+
+status_t
+arch_system_info_init(struct kernel_args *args)
+{
+    return B_OK;
+}
+
+status_t
+_user_get_cpuid(cpuid_info *userInfo, uint32 eaxRegister, uint32 cpuNum)
+{
+    return B_OK;
+}

src/system/libroot/os/arch/x86_64/byteorder.S

@@ +1 @@
+/*
+ * Copyright 2003-2005, Axel Dörfler, axeld@pinc-software.de. All rights reserved.
+ * Distributed under the terms of the MIT License.
+ */
+
+#include <asm_defs.h>
+
+
+/* uint16 __swap_int16(uint16 value) */
+FUNCTION(__swap_int16):
+    movl    4(%esp), %eax
+    bswap   %eax
+    shr     $16, %eax
+    ret
+FUNCTION_END(__swap_int16)
+
+/* this one is much faster on a P4, courtesy of Marcus Overhagen,
+ * a good candidate for per processor optimizations: */
+/*
+FUNCTION(__swap_int16_p4):
+    movl    4(%esp), %eax
+    rolw    $8, %ax
+    ret
+*/
+
+/* uint32 __swap_int32(uint32 value) */
+FUNCTION(__swap_int32):
+    movl    4(%esp), %eax
+    bswap   %eax
+    ret
+FUNCTION_END(__swap_int32)
+
+/* uint64 __swap_int64(uint64 value) */
+FUNCTION(__swap_int64):
+    movl    4(%esp), %edx   /* the 32-bits registers are swapped here */
+    movl    8(%esp), %eax
+    bswap   %eax
+    bswap   %edx
+    ret
+FUNCTION_END(__swap_int64)
+
+/* float __swap_float(float value) */
+FUNCTION(__swap_float):
+    movl    4(%esp), %eax
+    bswap   %eax
+    movl    %eax, 4(%esp)
+    fld     4(%esp)
+    ret
+FUNCTION_END(__swap_float)
+
+/* double __swap_double(double value) */
+FUNCTION(__swap_double):
+    movl    4(%esp), %edx   /* the 32-bits registers are swapped here */
+    movl    8(%esp), %eax
+    bswap   %eax
+    bswap   %edx
+    movl    %eax, 4(%esp)
+    movl    %edx, 8(%esp)
+    fldl    4(%esp)
+    ret
+FUNCTION_END(__swap_double)

src/system/libroot/os/arch/x86_64/system_time.c

@@ +1 @@
+/*
+    Just a dummy to avoid a special case in the build system. system_time()
+    is implemented in system_time_asm.S.
+*/

src/system/libroot/os/arch/x86_64/system_time_asm.S

@@ +1 @@
+/*
+ * Copyright 2009, Ingo Weinhold, ingo_weinhold@gmx.de.
+ * Distributed under the terms of the MIT License.
+ *
+ * Copyright 2001, Travis Geiselbrecht. All rights reserved.
+ * Distributed under the terms of the NewOS License.
+ */
+
+#include <asm_defs.h>
+
+
+/* saves the conversion factor needed for system_time */
+.lcomm cv_factor                4
+.lcomm cv_factor_nsecs          4
+.lcomm cv_factor_nsecs_shift    1
+
+
+.text
+
+
+FUNCTION(__x86_setup_system_time):
+//  movl    4(%esp), %eax
+//  movl    %eax, cv_factor
+//  movl    8(%esp), %eax
+//  movl    %eax, cv_factor_nsecs
+//  movb    12(%esp), %al
+//  movb    %al, cv_factor_nsecs_shift
+    ret
+FUNCTION_END(__x86_setup_system_time)
+
+
+/* int64 system_time(); */
+FUNCTION(system_time):
+//  pushl   %ebx
+//  pushl   %ecx
+//  movl    cv_factor, %ebx
+
+    /* load 64-bit factor into %eax (low), %edx (high) */
+//  rdtsc       /* time in %edx,%eax */
+
+//  movl    %edx, %ecx  /* save high half */
+//  mull    %ebx        /* truncate %eax, but keep %edx */
+//  movl    %ecx, %eax
+//  movl    %edx, %ecx  /* save high half of low */
+//  mull    %ebx /*, %eax*/
+    /* now compute  [%edx, %eax] + [%ecx], propagating carry */
+//  subl    %ebx, %ebx  /* need zero to propagate carry */
+//  addl    %ecx, %eax
+//  adc     %ebx, %edx
+//  popl    %ecx
+//  popl    %ebx
+    ret
+FUNCTION_END(system_time)
+
+
+/* int64 system_time_nsecs(); */
+FUNCTION(system_time_nsecs):
+//  testb   $0, cv_factor_nsecs_shift
+//  jne     1f
+
+    /* same algorithm as system_time(), just with a different factor */
+
+//  pushl   %ebx
+//  pushl   %ecx
+//  movl    cv_factor_nsecs, %ebx
+
+    /* load 64-bit factor into %eax (low), %edx (high) */
+//  rdtsc       /* time in %edx,%eax */
+
+//  movl    %edx, %ecx  /* save high half */
+//  mull    %ebx        /* truncate %eax, but keep %edx */
+//  movl    %ecx, %eax
+//  movl    %edx, %ecx  /* save high half of low */
+//  mull    %ebx /*, %eax*/
+    /* now compute  [%edx, %eax] + [%ecx], propagating carry */
+//  subl    %ebx, %ebx  /* need zero to propagate carry */
+//  addl    %ecx, %eax
+//  adc     %ebx, %edx
+//  popl    %ecx
+//  popl    %ebx
+    ret
+
+1:
+    /* TSC frequency is less than 1 GHz -- we shift everything up 16 bit */
+
+//  pushl   %ebx
+//  pushl   %ecx
+//  pushl   %esi
+//  movl    cv_factor_nsecs, %ebx
+
+    /* load 64-bit factor into %eax (low), %edx (high) */
+//  rdtsc       /* time in %edx,%eax */
+
+    /* save high half */
+//  movl    %edx, %ecx
+
+    /* multiply low half by conversion factor */
+//  mull    %ebx
+
+    /* save result */
+//  movl    %eax, %esi  /* low half -> %esi */
+//  movl    %ecx, %eax
+//  movl    %edx, %ecx  /* high half -> %ecx */
+
+    /* multiply high half by conversion factor */
+//  mull    %ebx
+
+    /* now compute  [%edx, %eax] + [%ecx], propagating carry */
+//  xorl    %ebx, %ebx  /* need zero to propagate carry */
+//  addl    %ecx, %eax
+//  adc     %ebx, %edx
+
+    /* shift the result left 16 bit */
+//  shl     $16, %edx
+//  movl    %eax, %ebx
+//  shr     $16, %ebx
+//  orw     %bx, %dx
+//  shl     $16, %eax
+
+    /* add the high 16 bit of the low half of the low product */
+//  shr     $16, %esi
+//  orw     %si, %ax
+
+//  popl    %esi
+//  popl    %ecx
+//  popl    %ebx
+    ret
+FUNCTION_END(system_time_nsecs)

src/system/libroot/os/arch/x86_64/atomic.S

@@ +1 @@
+/*
+** Copyright 2003, Marcus Overhagen. All rights reserved.
+** Distributed under the terms of the OpenBeOS license.
+**
+** Copyright 2001, Travis Geiselbrecht. All rights reserved.
+** Distributed under the terms of the NewOS License.
+*/
+
+#include <asm_defs.h>
+
+
+.text
+
+/* int32    atomic_set(vint32 *value, int32 newValue) */
+FUNCTION(atomic_set):
+//  movl        4(%esp),%edx
+//  movl        8(%esp),%eax
+//  lock
+//  xchg        %eax,(%edx)
+    ret
+FUNCTION_END(atomic_set)
+
+/* int32    atomic_test_and_set(vint32 *value, int32 newValue, int32 testAgainst) */
+FUNCTION(atomic_test_and_set):
+//  movl        4(%esp),%edx
+//  movl        8(%esp),%ecx
+//  movl        12(%esp),%eax
+//  lock
+//  cmpxchgl    %ecx,(%edx)
+    ret
+FUNCTION_END(atomic_test_and_set)
+
+/* int32    atomic_add(vint32 *value, int32 addValue) */
+FUNCTION(atomic_add):
+//  movl        4(%esp),%edx
+//  movl        8(%esp),%eax
+//  lock
+//  xaddl       %eax,(%edx)
+    ret
+FUNCTION_END(atomic_add)
+
+/* int32    atomic_and(vint32 *value, int32 andValue) */
+FUNCTION(atomic_and):
+//  movl        4(%esp),%edx
+//_atomic_and1:
+//  movl        8(%esp),%ecx
+//  movl        (%edx),%eax
+//  andl        %eax,%ecx
+//  lock
+//  cmpxchgl    %ecx,(%edx)
+//  jnz         _atomic_and1
+    ret
+FUNCTION_END(atomic_and)
+
+/* int32    atomic_or(vint32 *value, int32 orValue) */
+FUNCTION(atomic_or):
+//  movl        4(%esp),%edx
+//_atomic_or1:
+//  movl        8(%esp),%ecx
+//  movl        (%edx),%eax
+//  orl         %eax,%ecx
+//  lock
+//  cmpxchgl    %ecx,(%edx)
+//  jnz         _atomic_or1
+    ret
+FUNCTION_END(atomic_or)
+
+/* int32    atomic_get(vint32 *value) */
+FUNCTION(atomic_get):
+//  movl        4(%esp), %edx
+//_atomic_get1:
+//  movl        (%edx), %eax
+//  movl        %eax, %ecx
+//  lock
+//  cmpxchgl    %ecx, (%edx)
+//  jnz         _atomic_get1
+    ret
+FUNCTION_END(atomic_get)
+
+/* int64    atomic_set64(vint64 *value, int64 newValue) */
+FUNCTION(atomic_set64):
+//  push        %esi
+//  push        %ebx
+//  movl        12(%esp), %esi  /* value */
+//  movl        16(%esp), %ebx  /* newValue low */
+//  movl        20(%esp), %ecx  /* newValue high */
+//_atomic_set64_1:
+//  movl        (%esi), %eax    /* testAgainst low */
+//  movl        4(%esi), %edx   /* testAgainst high */
+//  lock
+//  cmpxchg8b   (%esi)
+//  jnz         _atomic_set64_1
+//  pop         %ebx
+//  pop         %esi
+    ret
+FUNCTION_END(atomic_set64)
+
+/* int64    atomic_test_and_set64(vint64 *value, int64 newValue, int64 testAgainst) */
+FUNCTION(atomic_test_and_set64):
+//  push        %esi
+//  push        %ebx
+//  movl        12(%esp), %esi  /* value */
+//  movl        16(%esp), %ebx  /* newValue low */
+//  movl        20(%esp), %ecx  /* newValue high */
+//  movl        24(%esp), %eax  /* testAgainst low */
+//  movl        28(%esp), %edx  /* testAgainst high */
+//  lock
+//  cmpxchg8b   (%esi)
+//  pop         %ebx
+//  pop         %esi
+    ret
+FUNCTION_END(atomic_test_and_set64)
+
+/* int64    atomic_add64(vint64 *value, int64 addValue) */
+FUNCTION(atomic_add64):
+//  push        %esi
+//  push        %ebx
+//  movl        12(%esp), %esi
+//_atomic_add64_1:
+//  movl        (%esi), %eax
+//  movl        4(%esi), %edx
+//  movl        %eax, %ebx
+//  movl        %edx, %ecx
+//  addl        16(%esp), %ebx
+//  adcl        20(%esp), %ecx
+//  lock
+//  cmpxchg8b   (%esi)
+//  jnz         _atomic_add64_1
+//  pop         %ebx
+//  pop         %esi
+    ret
+FUNCTION_END(atomic_add64)
+
+/* int64    atomic_and64(vint64 *value, int64 andValue) */
+FUNCTION(atomic_and64):
+//  push        %esi
+//  push        %ebx
+//  movl        12(%esp), %esi
+//_atomic_and64_1:
+//  movl        (%esi), %eax
+//  movl        4(%esi), %edx
+//  movl        %eax, %ebx
+//  movl        %edx, %ecx
+//  andl        16(%esp), %ebx
+//  andl        20(%esp), %ecx
+//  lock
+//  cmpxchg8b   (%esi)
+//  jnz         _atomic_and64_1
+//  pop         %ebx
+//  pop         %esi
+    ret
+FUNCTION_END(atomic_and64)
+
+/* int64    atomic_or64(vint64 *value, int64 orValue) */
+FUNCTION(atomic_or64):
+//  push        %esi
+//  push        %ebx
+//  movl        12(%esp), %esi
+//_atomic_or64_1:
+//  movl        (%esi), %eax
+//  movl        4(%esi), %edx
+//  movl        %eax, %ebx
+//  movl        %edx, %ecx
+//  orl         16(%esp), %ebx
+//  orl         20(%esp), %ecx
+//  lock
+//  cmpxchg8b   (%esi)
+//  jnz         _atomic_or64_1
+//  pop         %ebx
+//  pop         %esi
+    ret
+FUNCTION_END(atomic_or64)
+
+/* int64    atomic_get64(vint64 *value) */
+FUNCTION(atomic_get64):
+//  push        %esi
+//  push        %ebx
+//  movl        12(%esp), %esi
+//_atomic_get64_1:
+//  movl        (%esi), %eax
+//  movl        4(%esi), %edx
+//  movl        %eax, %ebx
+//  movl        %edx, %ecx
+//  lock
+//  cmpxchg8b   (%esi)
+//  jnz         _atomic_get64_1
+//  pop         %ebx
+//  pop         %esi
+    ret
+FUNCTION_END(atomic_get64)

src/system/libroot/posix/stdlib/strtod.c

@@ -126 +126 @@
 #if defined(__i386__) || defined(__ia64__) || defined(__alpha__) || \
     defined(__sparc64__) || defined(__powerpc__) || defined(__POWERPC__) || \
     defined(__m68k__) || defined(__M68K__) || defined(__arm__) || \
-    defined(__ARM__) || defined(__mipsel__) || defined(__MIPSEL__)
+    defined(__ARM__) || defined(__mipsel__) || defined(__MIPSEL__) || \
+    defined(__X86_64__) || defined(__x86_64__)
 #   include <sys/types.h>
 #   if BYTE_ORDER == BIG_ENDIAN
 #       define IEEE_BIG_ENDIAN

src/system/libroot/posix/arch/x86_64/setjmp_internal.h

@@ +1 @@
+/*
+** Copyright 2004, Axel Dörfler, axeld@pinc-software.de. All rights reserved.
+** Distributed under the terms of the Haiku License.
+*/
+#ifndef SETJMP_INTERNAL_H
+#define SETJMP_INTERNAL_H
+
+/* These are the fields of the __jmp_regs structure */
+
+#define JMP_REGS_RBX    0
+#define JMP_REGS_RSI    4
+#define JMP_REGS_RDI    8
+#define JMP_REGS_RBP    12
+#define JMP_REGS_RSP    16
+#define JMP_REGS_PC 20
+
+#include <asm_defs.h>
+
+#endif  /* SETJMP_INTERNAL_H */

src/system/libroot/posix/arch/x86_64/sigsetjmp.S

@@ +1 @@
+/*
+ * Copyright 2008, Ingo Weinhold, ingo_weinhold@gmx.de.
+ * Copyright 2004-2005, Axel Dörfler, axeld@pinc-software.de. All rights reserved.
+ * Distributed under the terms of the MIT License.
+ */
+
+#include "setjmp_internal.h"
+
+
+/** This is a BeOS compatible __sigsetjmp() implementation; there,
+ *  setjmp() and sigsetjmp() are both macros to this function.
+ *
+ *  It first saves the register/stack environment of the running thread,
+ *  and then calls __setjmp_save_sigs() which will save the signal state
+ *  if it was asked to do this.
+ */
+
+/* int sigsetjmp(jmp_buf buffer, int saveMask) */
+FUNCTION(__sigsetjmp):
+FUNCTION(sigsetjmp):
+    // return address to %edx, stack pointer for return to %ecx (both are
+    // scratch registers)
+//  mov     0(%esp), %edx
+//  lea     4(%esp), %ecx
+
+    // buffer to %eax
+//  mov     4(%esp), %eax
+
+sigsetjmp_setjmp_entry:
+    // fill __jmp_buf structure with current registers
+//  mov     %ebx, JMP_REGS_EBX(%eax)
+//  mov     %esi, JMP_REGS_ESI(%eax)
+//  mov     %edi, JMP_REGS_EDI(%eax)
+//  mov     %ebp, JMP_REGS_EBP(%eax)
+
+    // save stack and return address (because that's where we intend to jump to)
+//  mov     %ecx, JMP_REGS_ESP(%eax)
+//  mov     %edx, JMP_REGS_PC(%eax)
+
+    jmp     __setjmp_save_sigs
+FUNCTION_END(sigsetjmp)
+
+
+/* int setjmp(jmp_buf buffer) */
+FUNCTION(setjmp):
+    // prepare %edx, %ecx, and %eax for sigsetjmp
+//  mov     0(%esp), %edx
+//  lea     4(%esp), %ecx
+//  mov     (%ecx), %eax
+
+    // let sigsetjmp do the real work
+//  pushl   $0                          // saveMask
+//  push    %eax                        // buffer
+//  call    sigsetjmp_setjmp_entry
+//  add     $8, %esp
+
+    ret
+FUNCTION_END(setjmp)
+
+
+#pragma weak _setjmp=setjmp

src/system/libroot/posix/arch/x86_64/siglongjmp.S

@@ +1 @@
+/*
+** Copyright 2004, Axel Dörfler, axeld@pinc-software.de. All rights reserved.
+** Distributed under the terms of the Haiku License.
+*/
+
+#include "setjmp_internal.h"
+
+
+/** This is a BeOS compatible siglongjmp() implementation;
+ *  longjmp() and _longjmp() are both calling this function.
+ */
+
+
+/* int __siglongjmp(jmp_buf buffer, int value) */
+FUNCTION(siglongjmp):
+FUNCTION(longjmp):
+FUNCTION(_longjmp):
+//  mov     4(%esp), %ecx
+//  mov     8(%esp), %eax
+
+    // restore registers
+//  mov     JMP_REGS_EBX(%ecx), %ebx
+//  mov     JMP_REGS_ESI(%ecx), %esi
+//  mov     JMP_REGS_EDI(%ecx), %edi
+//  mov     JMP_REGS_EBP(%ecx), %ebp
+//  mov     JMP_REGS_ESP(%ecx), %esp
+
+    // prepare the stack so that we will return to the setjmp() program location
+//  mov     JMP_REGS_PC(%ecx), %edx
+//  push    %edx                // return address
+
+    // let __setjmp_save_sigs deal with the signal mask and the return value
+//  push    %eax                // value
+//  push    %ecx                // buffer
+//  call    __longjmp_return
+//  add     $8, %esp
+//
+    ret
+FUNCTION_END(siglongjmp)
+
+
+#pragma weak longjmp=siglongjmp

src/system/glue/arch/x86_64/crti.S

@@ +1 @@
+/*
+ * Copyright 2005-2006, Axel Dörfler, axeld@pinc-software.de.
+ * Distributed under the terms of the MIT License.
+ */
+
+/** This file contains the first part of the ".init" and ".fini" sections in
+ *  the ELF executable.
+ *  The functions defined here will be called during initialization/termination
+ *  of the loaded executable/library. The ".init" and ".fini" sections are
+ *  stacked together like this:
+ *
+ *  crti.S      entry point
+ *              call to _init_before/_term_before
+ *  crtbegin.S  GCC specific: constructors/destructors are called, ...
+ *  crtend.S
+ *  crtn.S      call to _init_after/_term_after
+ *              exit
+ */
+
+#define FUNCTION(x) .global x; .type x,@function; x
+
+.section .init
+FUNCTION(_init):
+    pushl   %rbp
+    movl    %rsp, %rbp
+    pushl   8(%rbp)     // put image ID on the stack again
+    call    _init_before
+    // crtbegin.o stuff comes here
+
+.section .fini
+FUNCTION(_fini):
+    pushl   %rbp
+    movl    %rsp, %rbp
+    pushl   8(%rbp)
+    call    _term_before
+    // crtend.o stuff comes here

src/system/glue/arch/x86_64/crtn.S

@@ +1 @@
+/*
+ * Copyright 2005-2006, Axel Dörfler, axeld@pinc-software.de.
+ * Distributed under the terms of the MIT License.
+ */
+
+/** This file contains the final part of the ".init" and ".fini" sections in
+ *  the ELF executable. It is tightly connected to crti.S.
+ *  Have a look at crti.S to find a description of what happens here.
+ */
+
+.section .init
+    // the image ID is still on the stack
+    call    _init_after
+    movl    %rbp, %rsp
+    popl    %rbp
+    ret
+
+.section .fini
+    // the image ID is still on the stack
+    call    _term_after
+    movl    %rbp, %rsp
+    popl    %rbp
+    ret

src/system/glue/arch/x86_64/Jamfile

@@ +1 @@
+SubDir HAIKU_TOP src system glue arch x86_64 ;
+
+KernelObjects
+    crti.S
+    crtn.S
+    ;
+

src/tools/gensyscalls/arch/x86_64/arch_gensyscalls.h

@@ +1 @@
+#define SYSCALL_RETURN_TYPE_ALIGNMENT_TYPE  int
+#define SYSCALL_PARAMETER_ALIGNMENT_TYPE    int