LCOV - code coverage report
Current view: top level - include/llvm/Support - AtomicOrdering.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 9 9 100.0 %
Date: 2017-09-14 15:23:50 Functions: 0 0 -
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===-- llvm/Support/AtomicOrdering.h ---Atomic Ordering---------*- C++ -*-===//
       2             : //
       3             : //                     The LLVM Compiler Infrastructure
       4             : //
       5             : // This file is distributed under the University of Illinois Open Source
       6             : // License. See LICENSE.TXT for details.
       7             : //
       8             : //===----------------------------------------------------------------------===//
       9             : ///
      10             : /// \file
      11             : /// \brief Atomic ordering constants.
      12             : ///
      13             : /// These values are used by LLVM to represent atomic ordering for C++11's
      14             : /// memory model and more, as detailed in docs/Atomics.rst.
      15             : ///
      16             : //===----------------------------------------------------------------------===//
      17             : 
      18             : #ifndef LLVM_SUPPORT_ATOMICORDERING_H
      19             : #define LLVM_SUPPORT_ATOMICORDERING_H
      20             : 
      21             : #include <cstddef>
      22             : 
      23             : namespace llvm {
      24             : 
      25             : /// Atomic ordering for C11 / C++11's memody models.
      26             : ///
      27             : /// These values cannot change because they are shared with standard library
      28             : /// implementations as well as with other compilers.
      29             : enum class AtomicOrderingCABI {
      30             :   relaxed = 0,
      31             :   consume = 1,
      32             :   acquire = 2,
      33             :   release = 3,
      34             :   acq_rel = 4,
      35             :   seq_cst = 5,
      36             : };
      37             : 
      38             : bool operator<(AtomicOrderingCABI, AtomicOrderingCABI) = delete;
      39             : bool operator>(AtomicOrderingCABI, AtomicOrderingCABI) = delete;
      40             : bool operator<=(AtomicOrderingCABI, AtomicOrderingCABI) = delete;
      41             : bool operator>=(AtomicOrderingCABI, AtomicOrderingCABI) = delete;
      42             : 
      43             : // Validate an integral value which isn't known to fit within the enum's range
      44             : // is a valid AtomicOrderingCABI.
      45             : template <typename Int> static inline bool isValidAtomicOrderingCABI(Int I) {
      46        1221 :   return (Int)AtomicOrderingCABI::relaxed <= I &&
      47             :          I <= (Int)AtomicOrderingCABI::seq_cst;
      48             : }
      49             : 
      50             : /// Atomic ordering for LLVM's memory model.
      51             : ///
      52             : /// C++ defines ordering as a lattice. LLVM supplements this with NotAtomic and
      53             : /// Unordered, which are both below the C++ orders.
      54             : ///
      55             : /// not_atomic-->unordered-->relaxed-->release--------------->acq_rel-->seq_cst
      56             : ///                                   \-->consume-->acquire--/
      57             : enum class AtomicOrdering {
      58             :   NotAtomic = 0,
      59             :   Unordered = 1,
      60             :   Monotonic = 2, // Equivalent to C++'s relaxed.
      61             :   // Consume = 3,  // Not specified yet.
      62             :   Acquire = 4,
      63             :   Release = 5,
      64             :   AcquireRelease = 6,
      65             :   SequentiallyConsistent = 7
      66             : };
      67             : 
      68             : bool operator<(AtomicOrdering, AtomicOrdering) = delete;
      69             : bool operator>(AtomicOrdering, AtomicOrdering) = delete;
      70             : bool operator<=(AtomicOrdering, AtomicOrdering) = delete;
      71             : bool operator>=(AtomicOrdering, AtomicOrdering) = delete;
      72             : 
      73             : // Validate an integral value which isn't known to fit within the enum's range
      74             : // is a valid AtomicOrdering.
      75             : template <typename Int> static inline bool isValidAtomicOrdering(Int I) {
      76             :   return static_cast<Int>(AtomicOrdering::NotAtomic) <= I &&
      77             :          I <= static_cast<Int>(AtomicOrdering::SequentiallyConsistent);
      78             : }
      79             : 
      80             : /// String used by LLVM IR to represent atomic ordering.
      81             : static inline const char *toIRString(AtomicOrdering ao) {
      82             :   static const char *names[8] = {"not_atomic", "unordered", "monotonic",
      83             :                                  "consume",    "acquire",   "release",
      84             :                                  "acq_rel",    "seq_cst"};
      85        3843 :   return names[static_cast<size_t>(ao)];
      86             : }
      87             : 
      88             : /// Returns true if ao is stronger than other as defined by the AtomicOrdering
      89             : /// lattice, which is based on C++'s definition.
      90             : static inline bool isStrongerThan(AtomicOrdering ao, AtomicOrdering other) {
      91             :   static const bool lookup[8][8] = {
      92             :       //               NA     UN     RX     CO     AC     RE     AR     SC
      93             :       /* NotAtomic */ {false, false, false, false, false, false, false, false},
      94             :       /* Unordered */ { true, false, false, false, false, false, false, false},
      95             :       /* relaxed   */ { true,  true, false, false, false, false, false, false},
      96             :       /* consume   */ { true,  true,  true, false, false, false, false, false},
      97             :       /* acquire   */ { true,  true,  true,  true, false, false, false, false},
      98             :       /* release   */ { true,  true,  true, false, false, false, false, false},
      99             :       /* acq_rel   */ { true,  true,  true,  true,  true,  true, false, false},
     100             :       /* seq_cst   */ { true,  true,  true,  true,  true,  true,  true, false},
     101             :   };
     102     9062573 :   return lookup[static_cast<size_t>(ao)][static_cast<size_t>(other)];
     103             : }
     104             : 
     105             : static inline bool isAtLeastOrStrongerThan(AtomicOrdering ao,
     106             :                                            AtomicOrdering other) {
     107             :   static const bool lookup[8][8] = {
     108             :       //               NA     UN     RX     CO     AC     RE     AR     SC
     109             :       /* NotAtomic */ { true, false, false, false, false, false, false, false},
     110             :       /* Unordered */ { true,  true, false, false, false, false, false, false},
     111             :       /* relaxed   */ { true,  true,  true, false, false, false, false, false},
     112             :       /* consume   */ { true,  true,  true,  true, false, false, false, false},
     113             :       /* acquire   */ { true,  true,  true,  true,  true, false, false, false},
     114             :       /* release   */ { true,  true,  true, false, false,  true, false, false},
     115             :       /* acq_rel   */ { true,  true,  true,  true,  true,  true,  true, false},
     116             :       /* seq_cst   */ { true,  true,  true,  true,  true,  true,  true,  true},
     117             :   };
     118        5961 :   return lookup[static_cast<size_t>(ao)][static_cast<size_t>(other)];
     119             : }
     120             : 
     121             : static inline bool isStrongerThanUnordered(AtomicOrdering ao) {
     122          88 :   return isStrongerThan(ao, AtomicOrdering::Unordered);
     123             : }
     124             : 
     125             : static inline bool isStrongerThanMonotonic(AtomicOrdering ao) {
     126      388531 :   return isStrongerThan(ao, AtomicOrdering::Monotonic);
     127             : }
     128             : 
     129             : static inline bool isAcquireOrStronger(AtomicOrdering ao) {
     130        1897 :   return isAtLeastOrStrongerThan(ao, AtomicOrdering::Acquire);
     131             : }
     132             : 
     133             : static inline bool isReleaseOrStronger(AtomicOrdering ao) {
     134        2338 :   return isAtLeastOrStrongerThan(ao, AtomicOrdering::Release);
     135             : }
     136             : 
     137             : static inline AtomicOrderingCABI toCABI(AtomicOrdering ao) {
     138             :   static const AtomicOrderingCABI lookup[8] = {
     139             :       /* NotAtomic */ AtomicOrderingCABI::relaxed,
     140             :       /* Unordered */ AtomicOrderingCABI::relaxed,
     141             :       /* relaxed   */ AtomicOrderingCABI::relaxed,
     142             :       /* consume   */ AtomicOrderingCABI::consume,
     143             :       /* acquire   */ AtomicOrderingCABI::acquire,
     144             :       /* release   */ AtomicOrderingCABI::release,
     145             :       /* acq_rel   */ AtomicOrderingCABI::acq_rel,
     146             :       /* seq_cst   */ AtomicOrderingCABI::seq_cst,
     147             :   };
     148         203 :   return lookup[static_cast<size_t>(ao)];
     149             : }
     150             : 
     151             : } // end namespace llvm
     152             : 
     153             : #endif // LLVM_SUPPORT_ATOMICORDERING_H

Generated by: LCOV version 1.13