vm/utilities.hpp

   1 namespace factor
   2 {
   3
   4 inline static void memset_2(void *dst, u16 pattern, size_t size)
   5 {
   6 #ifdef __APPLE__
   7         cell cell_pattern = (pattern | (pattern << 16));
   8         memset_pattern4(dst,&cell_pattern,size);
   9 #else
  10         if(pattern == 0)
  11                 memset(dst,0,size);
  12         else
  13         {
  14                 u16 *start = (u16 *)dst;
  15                 u16 *end = (u16 *)((cell)dst + size);
  16                 while(start < end)
  17                 {
  18                         *start = pattern;
  19                         start++;
  20                 }
  21         }
  22 #endif
  23 }
  24
  25 inline static void memset_cell(void *dst, cell pattern, size_t size)
  26 {
  27 #ifdef __APPLE__
  28         #ifdef FACTOR_64
  29                 memset_pattern8(dst,&pattern,size);
  30         #else
  31                 memset_pattern4(dst,&pattern,size);
  32         #endif
  33 #else
  34         if(pattern == 0)
  35                 memset(dst,0,size);
  36         else
  37         {
  38                 cell *start = (cell *)dst;
  39                 cell *end = (cell *)((cell)dst + size);
  40                 while(start < end)
  41                 {
  42                         *start = pattern;
  43                         start++;
  44                 }
  45         }
  46 #endif
  47 }
  48
  49 void *fill_function_descriptor(void *ptr, void *code);
  50 void *function_descriptor_field(void *ptr, size_t idx);
  51
  52 vm_char *safe_strdup(const vm_char *str);
  53 cell read_cell_hex();
  54 VM_C_API void *factor_memcpy(void *dst, void *src, size_t len);
  55
  56 #if defined(WINDOWS)
  57
  58         #if defined(FACTOR_64)
  59
  60                 #define FACTOR_ATOMIC_CAS(ptr, old_val, new_val) \
  61                         (InterlockedCompareExchange64(ptr, new_val, old_val) == old_val)
  62
  63                 #define FACTOR_ATOMIC_ADD(ptr, val) \
  64                         InterlockedAdd64(ptr, val)
  65
  66                 #define FACTOR_ATOMIC_SUB(ptr, val) \
  67                         InterlockedSub64(ptr, val)
  68
  69         #else
  70
  71                 #define FACTOR_ATOMIC_CAS(ptr, old_val, new_val) \
  72                         (InterlockedCompareExchange(ptr, new_val, old_val) == old_val)
  73
  74                 #define FACTOR_ATOMIC_ADD(ptr, val) \
  75                         InterlockedAdd(ptr, val)
  76
  77                 #define FACTOR_ATOMIC_SUB(ptr, val) \
  78                         InterlockedSub(ptr, val)
  79
  80         #endif
  81
  82 #elif defined(__GNUC__) || defined(__clang__)
  83
  84         #define FACTOR_ATOMIC_CAS(ptr, old_val, new_val) \
  85                 __sync_bool_compare_and_swap(ptr, old_val, new_val)
  86
  87         #define FACTOR_ATOMIC_ADD(ptr, val) \
  88                 __sync_add_and_fetch(ptr, val)
  89
  90         #define FACTOR_ATOMIC_SUB(ptr, val) \
  91                 __sync_sub_and_fetch(ptr, val)
  92
  93 #else
  94         #error "Unsupported compiler"
  95 #endif
  96
  97 }