inline u64 AtomicExchangeU64(u64 volatile *Value, u64 New)
{
    u64 Result = __sync_lock_test_and_set(Value, New);
    return(Result);
}
inline u64 AtomicAddU64(u64 volatile *Value, u64 Addend)
{
    u64 Result = __sync_fetch_and_add(Value, Addend);
    return(Result);
}
inline u32 GetThreadID(void)
{
    u32 ThreadID;
#if defined(__APPLE__)
    asm("mov %%gs:0x00,%0" : "=r"(ThreadID));
#elif defined(__i386__)
    asm("mov %%gs:0x08,%0" : "=r"(ThreadID));
#elif defined(__x86_64__)
    asm("mov %%fs:0x10,%0" : "=r" (ThreadID));
#else
#error Unsupported architecture
#endif
    return ThreadID;
}

#define TIMED_FUNCTION(...) TIMED_BLOCK_((char *)__FUNCTION__, __LINE__, ## __VA_ARG

#if COMPILER_MSVC
#define snprintf _snprintf
#endif

handmade_platform.h:561:137: error: expected primary-expression before ‘)’ token
 Block_##Number(__COUNTER__, __FILE__, __LINE__, BlockName, ## __VA_ARGS__)

-#define TIMED_BLOCK__(BlockName, Number, ...) timed_block TimedBlock_##Numb\
er(__COUNTER__, __FILE__, __LINE__, BlockName, ## __VA_ARGS__)
+#define TIMED_BLOCK__(BlockName, Number, ...) timed_block TimedBlock_##Numb\
er(__COUNTER__, __FILE__, __LINE__, BlockName) //, ## __VA_ARGS__)

	.align 16
	.globl __syscall_entry
__syscall_entry:
        // Calling convention on HBOS is that %rax contains
        // the system call number when you enter a system call and
        // contains errno when you exit. This is a fast path to make sure
        // that the number makes sense. Note that this doesn't change
        // the values in any registers or use any stack.
	cmpq $SYSCALL_COUNT,%rax
	jb __syscall_ok
	movq $ENOTSUP,%rax
	sysretq
__syscall_ok:
        // Swap the user-space thread-local storage with the kernel's
        // per-cpu state for this CPU.
	swapgs

        // %gs:0 now points to the kernel's per-CPU state.
        // We can now freely use this without interfering with
        // anything that other CPUs are doing.

        // Swap stacks...
	movq %rsp,%gs:CPUSTATE_SAVED_STACK
	movq %gs:CPUSTATE_SYSCALL_STACK,%rsp

        // Now we are on a known good stack, so we
        // have a place to save a register so we can do
        // some computation.
	push %rax
	movq %gs:CPUSTATE_CUR_THREAD,%rax

        // %rax now points to the kernel's thread control block.

        // Remember that we entered the kernel via a syscall as
        // opposed to, say, an interrupt. Eventually we will probably
        // want to return control to the thread, so we have to make
        // sure we exit in the opposite way that we entered.
	movb $THREADRET_SYSCALL,THREAD_THREADRET(%rax)

        // Now that we have the TCB, save registers into it...
	movq %r11,REGOFF_RFLAGS(%rax)
	lea THREAD_CPUREGS(%rax),%rax
	movq %rbx,REGOFF_RBX(%rax)
	movq %rcx,REGOFF_RCX(%rax)
	movq %rdx,REGOFF_RDX(%rax)
	movq %rsi,REGOFF_RSI(%rax)
	movq %rdi,REGOFF_RDI(%rax)
	movq %rbp,REGOFF_RBP(%rax)
	movq %r8,REGOFF_R8(%rax)
	movq %r9,REGOFF_R9(%rax)
	movq %r10,REGOFF_R10(%rax)
	movq %r11,REGOFF_R11(%rax)
	movq %r12,REGOFF_R12(%rax)
	movq %r13,REGOFF_R13(%rax)
	movq %r14,REGOFF_R14(%rax)
	movq %r15,REGOFF_R15(%rax)

	// We temporarily stored the user-space stack
        // pointer in CPUSTATE_SAVED_STACK...
	movq %gs:CPUSTATE_SAVED_STACK,%rcx
	movq %rcx,REGOFF_RSP(%rax)

        // ...and we temporarily stored %rax on the stack.
	pop %rcx
	movq %rcx,REGOFF_RAX(%rax)

        // All registers are now saved, and we're on a known
        // good kernel-space stack. We can now call into C
        // code and everything will work.
	mov %rcx,%rax
	movq %r10,%rcx
	call *syscall_table(,%rax,8)