x86.c

Go to the documentation of this file.

// Do not compile anything here if we're not on an x86 machine!

#include <stdlib.h>
#include <stdio.h>
#include <stdbool.h>
#include <arch/atomic.h>
#include <mm/dymelor.h>

inline bool iCAS(volatile uint32_t *ptr, uint32_t oldVal, uint32_t newVal)
{
    unsigned long res = 0;

    __asm__ __volatile__("lock cmpxchgl %1, %2;"    // ZF = 1 if succeeded
                 "lahf;"            // to get the correct result even if oldVal == 0
                 "bt $14, %%ax;"        // is ZF set? (ZF is the 6'th bit in %ah, so it's the 14'th in ax)
                 "adc %0, %0"       // get the result
                 :"=r"(res)
                 :"r"(newVal), "m"(*ptr), "a"(oldVal), "0"(res)
                 :"memory");

    return (bool)res;
}

inline int atomic_test_and_set(int *b)
{
    int result = 0;

    __asm__ __volatile__("lock bts $0, %1;\n\t"
                 "adc %0, %0"
                 :"=r"(result)
                 :"m"(*b), "0"(result)
                 :"memory");

    return !result;
}

inline void atomic_inc(atomic_t * v)
{
    __asm__ __volatile__("lock incl %0"
                 :"=m"(v->count)
                 :"m"(v->count));
}

inline void atomic_dec(atomic_t * v)
{
    __asm__ __volatile__("lock decl %0"
                 :"=m"(v->count)
                 :"m"(v->count));
}

inline int atomic_inc_and_test(atomic_t * v)
{
    unsigned char c = 0;

    __asm__ __volatile__("lock incl %0\n\t"
                 "sete %1"
                 :"=m"(v->count), "=qm"(c)
                 :"m"(v->count)
                 :"memory");
    return c != 0;
}

inline void spin_lock(spinlock_t * s)
{
    __asm__ __volatile__("1:\n\t" "movl $1,%%eax\n\t"
                 "lock xchgl %%eax, %0\n\t"
                 "testl %%eax, %%eax\n\t"
                 "jnz 1b"
                 :  /* no output */
                 :"m"(s->lock)
                 :"eax", "memory");
}

inline bool spin_trylock(spinlock_t * s)
{
    return atomic_test_and_set((int *)&s->lock);
}

inline void spin_unlock(spinlock_t * s)
{
    __asm__ __volatile__("mov $0, %%eax\n\t"
                 "lock xchgl %%eax, %0"
                 : /* no output */
                 :"m"(s->lock)
                 :"eax", "memory");
}