1 /*
   2  * Copyright (c) 1999, 2014, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 #ifndef SHARE_VM_RUNTIME_ATOMIC_HPP
  26 #define SHARE_VM_RUNTIME_ATOMIC_HPP
  27 
  28 #include "memory/allocation.hpp"
  29 #include "utilities/traits/selectBaseClass.hpp"
  30 
  31 class AtomicPlatform;
  32 
  33 class AtomicBase : AllStatic {
  34  protected:
  35   static jbyte cmpxchg_general(jbyte exchange_value, volatile jbyte* dest, jbyte compare_value);
  36  public:
  37   inline static jbyte cmpxchg(jbyte exchange_value, volatile jbyte* dest, jbyte compare_value) {
  38     return cmpxchg_general(exchange_value, dest, compare_value);
  39   }
  40 };
  41 
  42 // Linux
  43 #ifdef TARGET_OS_ARCH_linux_x86
  44 # include "atomic_linux_x86.hpp"
  45 #endif
  46 
  47 // Solaris
  48 #ifdef TARGET_OS_ARCH_solaris_x86
  49 # include "atomic_solaris_x86.hpp"
  50 #endif
  51 
  52 // Windows
  53 #ifdef TARGET_OS_ARCH_windows_x86
  54 # include "atomic_windows_x86.hpp"
  55 #endif
  56 
  57 // BSD
  58 #ifdef TARGET_OS_ARCH_bsd_x86
  59 # include "atomic_bsd_x86.hpp"
  60 #endif
  61 
  62 typedef SelectBaseClass<AtomicPlatform, AtomicBase>::type AtomicSuper;
  63 
  64 class Atomic : public AtomicSuper {
  65  public:
  66   // Atomic operations on jlong types are not available on all 32-bit
  67   // platforms. If atomic ops on jlongs are defined here they must only
  68   // be used from code that verifies they are available at runtime and
  69   // can provide an alternative action if not - see supports_cx8() for
  70   // a means to test availability.
  71 
  72   // The memory operations that are mentioned with each of the atomic
  73   // function families come from src/share/vm/runtime/orderAccess.hpp,
  74   // e.g., <fence> is described in that file and is implemented by the
  75   // OrderAccess::fence() function. See that file for the gory details
  76   // on the Memory Access Ordering Model.
  77 
  78   // All of the atomic operations that imply a read-modify-write action
  79   // guarantee a two-way memory barrier across that operation. Historically
  80   // these semantics reflect the strength of atomic operations that are
  81   // provided on SPARC/X86. We assume that strength is necessary unless
  82   // we can prove that a weaker form is sufficiently safe.
  83 
  84   // Atomically store to a location
  85   inline static void store    (jbyte    store_value, jbyte*    dest);
  86   inline static void store    (jshort   store_value, jshort*   dest);
  87   inline static void store    (jint     store_value, jint*     dest);
  88   // See comment above about using jlong atomics on 32-bit platforms
  89   inline static void store    (jlong    store_value, jlong*    dest);
  90   inline static void store_ptr(intptr_t store_value, intptr_t* dest);
  91   inline static void store_ptr(void*    store_value, void*     dest);
  92 
  93   inline static void store    (jbyte    store_value, volatile jbyte*    dest);
  94   inline static void store    (jshort   store_value, volatile jshort*   dest);
  95   inline static void store    (jint     store_value, volatile jint*     dest);
  96   // See comment above about using jlong atomics on 32-bit platforms
  97   inline static void store    (jlong    store_value, volatile jlong*    dest);
  98   inline static void store_ptr(intptr_t store_value, volatile intptr_t* dest);
  99   inline static void store_ptr(void*    store_value, volatile void*     dest);
 100 
 101   // See comment above about using jlong atomics on 32-bit platforms
 102   inline static jlong load(volatile jlong* src);
 103 
 104   // Atomically add to a location. Returns updated value. add*() provide:
 105   // <fence> add-value-to-dest <membar StoreLoad|StoreStore>
 106   inline static jint     add    (jint     add_value, volatile jint*     dest);
 107   inline static size_t   add    (size_t   add_value, volatile size_t*   dest);
 108   inline static intptr_t add_ptr(intptr_t add_value, volatile intptr_t* dest);
 109   inline static void*    add_ptr(intptr_t add_value, volatile void*     dest);
 110   // See comment above about using jlong atomics on 32-bit platforms
 111   static jlong           add    (jlong    add_value, volatile jlong*    dest);
 112 
 113   // Atomically increment location. inc*() provide:
 114   // <fence> increment-dest <membar StoreLoad|StoreStore>
 115   inline static void inc    (volatile jint*     dest);
 116   static void        inc    (volatile jshort*   dest);
 117   inline static void inc    (volatile size_t*   dest);
 118   inline static void inc_ptr(volatile intptr_t* dest);
 119   inline static void inc_ptr(volatile void*     dest);
 120 
 121   // Atomically decrement a location. dec*() provide:
 122   // <fence> decrement-dest <membar StoreLoad|StoreStore>
 123   inline static void dec    (volatile jint*     dest);
 124   static void        dec    (volatile jshort*   dest);
 125   inline static void dec    (volatile size_t*   dest);
 126   inline static void dec_ptr(volatile intptr_t* dest);
 127   inline static void dec_ptr(volatile void*     dest);
 128 
 129   // Performs atomic exchange of *dest with exchange_value. Returns old
 130   // prior value of *dest. xchg*() provide:
 131   // <fence> exchange-value-with-dest <membar StoreLoad|StoreStore>
 132   inline static jint     xchg    (jint         exchange_value, volatile jint*         dest);
 133   static unsigned int    xchg    (unsigned int exchange_value, volatile unsigned int* dest);
 134   inline static intptr_t xchg_ptr(intptr_t     exchange_value, volatile intptr_t*     dest);
 135   inline static void*    xchg_ptr(void*        exchange_value, volatile void*         dest);
 136 
 137   // Performs atomic compare of *dest and compare_value, and exchanges
 138   // *dest with exchange_value if the comparison succeeded. Returns prior
 139   // value of *dest. cmpxchg*() provide:
 140   // <fence> compare-and-exchange <membar StoreLoad|StoreStore>
 141   inline static jbyte    cmpxchg    (jbyte        exchange_value, volatile jbyte*        dest, jbyte        compare_value);
 142   inline static jint     cmpxchg    (jint         exchange_value, volatile jint*         dest, jint         compare_value);
 143   // See comment above about using jlong atomics on 32-bit platforms
 144   inline static jlong    cmpxchg    (jlong        exchange_value, volatile jlong*        dest, jlong        compare_value);
 145   static unsigned int    cmpxchg    (unsigned int exchange_value, volatile unsigned int* dest, unsigned int compare_value);
 146   inline static intptr_t cmpxchg_ptr(intptr_t     exchange_value, volatile intptr_t*     dest, intptr_t     compare_value);
 147   inline static void*    cmpxchg_ptr(void*        exchange_value, volatile void*         dest, void*        compare_value);
 148 };
 149 
 150 // To use Atomic::inc(jshort* dest) and Atomic::dec(jshort* dest), the address must be specially
 151 // aligned, such that (*dest) occupies the upper 16 bits of an aligned 32-bit word. The best way to
 152 // achieve is to place your short value next to another short value, which doesn't need atomic ops.
 153 //
 154 // Example
 155 //  ATOMIC_SHORT_PAIR(
 156 //    volatile short _refcount,  // needs atomic operation
 157 //    unsigned short _length     // number of UTF8 characters in the symbol (does not need atomic op)
 158 //  );
 159 
 160 #ifdef VM_LITTLE_ENDIAN
 161   #define ATOMIC_SHORT_PAIR(atomic_decl, non_atomic_decl)  \
 162     non_atomic_decl;                                       \
 163     atomic_decl
 164 #else
 165   #define ATOMIC_SHORT_PAIR(atomic_decl, non_atomic_decl)  \
 166     atomic_decl;                                           \
 167     non_atomic_decl
 168 #endif
 169 
 170 #endif // SHARE_VM_RUNTIME_ATOMIC_HPP