contrib/libcxxrt/guard.cc

   1 /*
   2  * Copyright 2010-2012 PathScale, Inc. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions are met:
   6  *
   7  * 1. Redistributions of source code must retain the above copyright notice,
   8  *    this list of conditions and the following disclaimer.
   9  *
  10  * 2. Redistributions in binary form must reproduce the above copyright notice,
  11  *    this list of conditions and the following disclaimer in the documentation
  12  *    and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS
  15  * IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
  16  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  17  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
  18  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  19  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  20  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  21  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  22  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  23  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  24  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  25  */
  26
  27 /**
  28  * guard.cc: Functions for thread-safe static initialisation.
  29  *
  30  * Static values in C++ can be initialised lazily their first use.  This file
  31  * contains functions that are used to ensure that two threads attempting to
  32  * initialize the same static do not call the constructor twice.  This is
  33  * important because constructors can have side effects, so calling the
  34  * constructor twice may be very bad.
  35  *
  36  * Statics that require initialisation are protected by a 64-bit value.  Any
  37  * platform that can do 32-bit atomic test and set operations can use this
  38  * value as a low-overhead lock.  Because statics (in most sane code) are
  39  * accessed far more times than they are initialised, this lock implementation
  40  * is heavily optimised towards the case where the static has already been
  41  * initialised.
  42  */
  43 #include <stdint.h>
  44 #include <stdlib.h>
  45 #include <stdio.h>
  46 #include <pthread.h>
  47 #include <assert.h>
  48 #include "atomic.h"
  49
  50 // Older GCC doesn't define __LITTLE_ENDIAN__
  51 #ifndef __LITTLE_ENDIAN__
  52         // If __BYTE_ORDER__ is defined, use that instead
  53 #       ifdef __BYTE_ORDER__
  54 #               if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
  55 #                       define __LITTLE_ENDIAN__
  56 #               endif
  57         // x86 and ARM are the most common little-endian CPUs, so let's have a
  58         // special case for them (ARM is already special cased).  Assume everything
  59         // else is big endian.
  60 #       elif defined(__x86_64) || defined(__i386)
  61 #               define __LITTLE_ENDIAN__
  62 #       endif
  63 #endif
  64
  65
  66 /*
  67  * The least significant bit of the guard variable indicates that the object
  68  * has been initialised, the most significant bit is used for a spinlock.
  69  */
  70 #ifdef __arm__
  71 // ARM ABI - 32-bit guards.
  72 typedef uint32_t guard_t;
  73 static const uint32_t LOCKED = ((guard_t)1) << 31;
  74 static const uint32_t INITIALISED = 1;
  75 #else
  76 typedef uint64_t guard_t;
  77 #       if defined(__LITTLE_ENDIAN__)
  78 static const guard_t LOCKED = ((guard_t)1) << 63;
  79 static const guard_t INITIALISED = 1;
  80 #       else
  81 static const guard_t LOCKED = 1;
  82 static const guard_t INITIALISED = ((guard_t)1) << 56;
  83 #       endif
  84 #endif
  85
  86 /**
  87  * Acquires a lock on a guard, returning 0 if the object has already been
  88  * initialised, and 1 if it has not.  If the object is already constructed then
  89  * this function just needs to read a byte from memory and return.
  90  */
  91 extern "C" int __cxa_guard_acquire(volatile guard_t *guard_object)
  92 {
  93         // Not an atomic read, doesn't establish a happens-before relationship, but
  94         // if one is already established and we end up seeing an initialised state
  95         // then it's a fast path, otherwise we'll do something more expensive than
  96         // this test anyway...
  97         if ((INITIALISED == *guard_object)) { return 0; }
  98         // Spin trying to do the initialisation
  99         while (1)
 100         {
 101                 // Loop trying to move the value of the guard from 0 (not
 102                 // locked, not initialised) to the locked-uninitialised
 103                 // position.
 104                 switch (__sync_val_compare_and_swap(guard_object, 0, LOCKED))
 105                 {
 106                         // If the old value was 0, we succeeded, so continue
 107                         // initialising
 108                         case 0:
 109                                 return 1;
 110                         // If this was already initialised, return and let the caller skip
 111                         // initialising it again.
 112                         case INITIALISED:
 113                                 return 0;
 114                         // If it is locked by another thread, relinquish the CPU and try
 115                         // again later.
 116                         case LOCKED:
 117                         case LOCKED | INITIALISED:
 118                                 sched_yield();
 119                                 break;
 120                         // If it is some other value, then something has gone badly wrong.
 121                         // Give up.
 122                         default:
 123                                 fprintf(stderr, "Invalid state detected attempting to lock static initialiser.\n");
 124                                 abort();
 125                 }
 126         }
 127         //__builtin_unreachable();
 128         return 0;
 129 }
 130
 131 /**
 132  * Releases the lock without marking the object as initialised.  This function
 133  * is called if initialising a static causes an exception to be thrown.
 134  */
 135 extern "C" void __cxa_guard_abort(volatile guard_t *guard_object)
 136 {
 137         __attribute__((unused))
 138         bool reset = __sync_bool_compare_and_swap(guard_object, LOCKED, 0);
 139         assert(reset);
 140 }
 141 /**
 142  * Releases the guard and marks the object as initialised.  This function is
 143  * called after successful initialisation of a static.
 144  */
 145 extern "C" void __cxa_guard_release(volatile guard_t *guard_object)
 146 {
 147         __attribute__((unused))
 148         bool reset = __sync_bool_compare_and_swap(guard_object, LOCKED, INITIALISED);
 149         assert(reset);
 150 }
 151
 152