1 files changed, 10 insertions, 11 deletions

diff --git a/include/llvm/Support/AtomicOrdering.h b/include/llvm/Support/AtomicOrdering.h
index 001804248b85c..e93b755aa63b8 100644
--- a/include/llvm/Support/AtomicOrdering.h
+++ b/include/llvm/Support/AtomicOrdering.h
@@ -42,7 +42,7 @@ bool operator>=(AtomicOrderingCABI, AtomicOrderingCABI) = delete;
 
 // Validate an integral value which isn't known to fit within the enum's range
 // is a valid AtomicOrderingCABI.
-template <typename Int> static inline bool isValidAtomicOrderingCABI(Int I) {
+template <typename Int> inline bool isValidAtomicOrderingCABI(Int I) {
   return (Int)AtomicOrderingCABI::relaxed <= I &&
          I <= (Int)AtomicOrderingCABI::seq_cst;
 }
@@ -72,13 +72,13 @@ bool operator>=(AtomicOrdering, AtomicOrdering) = delete;
 
 // Validate an integral value which isn't known to fit within the enum's range
 // is a valid AtomicOrdering.
-template <typename Int> static inline bool isValidAtomicOrdering(Int I) {
+template <typename Int> inline bool isValidAtomicOrdering(Int I) {
   return static_cast<Int>(AtomicOrdering::NotAtomic) <= I &&
          I <= static_cast<Int>(AtomicOrdering::SequentiallyConsistent);
 }
 
 /// String used by LLVM IR to represent atomic ordering.
-static inline const char *toIRString(AtomicOrdering ao) {
+inline const char *toIRString(AtomicOrdering ao) {
   static const char *names[8] = {"not_atomic", "unordered", "monotonic",
                                  "consume",    "acquire",   "release",
                                  "acq_rel",    "seq_cst"};
@@ -87,7 +87,7 @@ static inline const char *toIRString(AtomicOrdering ao) {
 
 /// Returns true if ao is stronger than other as defined by the AtomicOrdering
 /// lattice, which is based on C++'s definition.
-static inline bool isStrongerThan(AtomicOrdering ao, AtomicOrdering other) {
+inline bool isStrongerThan(AtomicOrdering ao, AtomicOrdering other) {
   static const bool lookup[8][8] = {
       //               NA     UN     RX     CO     AC     RE     AR     SC
       /* NotAtomic */ {false, false, false, false, false, false, false, false},
@@ -102,8 +102,7 @@ static inline bool isStrongerThan(AtomicOrdering ao, AtomicOrdering other) {
   return lookup[static_cast<size_t>(ao)][static_cast<size_t>(other)];
 }
 
-static inline bool isAtLeastOrStrongerThan(AtomicOrdering ao,
-                                           AtomicOrdering other) {
+inline bool isAtLeastOrStrongerThan(AtomicOrdering ao, AtomicOrdering other) {
   static const bool lookup[8][8] = {
       //               NA     UN     RX     CO     AC     RE     AR     SC
       /* NotAtomic */ { true, false, false, false, false, false, false, false},
@@ -118,23 +117,23 @@ static inline bool isAtLeastOrStrongerThan(AtomicOrdering ao,
   return lookup[static_cast<size_t>(ao)][static_cast<size_t>(other)];
 }
 
-static inline bool isStrongerThanUnordered(AtomicOrdering ao) {
+inline bool isStrongerThanUnordered(AtomicOrdering ao) {
   return isStrongerThan(ao, AtomicOrdering::Unordered);
 }
 
-static inline bool isStrongerThanMonotonic(AtomicOrdering ao) {
+inline bool isStrongerThanMonotonic(AtomicOrdering ao) {
   return isStrongerThan(ao, AtomicOrdering::Monotonic);
 }
 
-static inline bool isAcquireOrStronger(AtomicOrdering ao) {
+inline bool isAcquireOrStronger(AtomicOrdering ao) {
   return isAtLeastOrStrongerThan(ao, AtomicOrdering::Acquire);
 }
 
-static inline bool isReleaseOrStronger(AtomicOrdering ao) {
+inline bool isReleaseOrStronger(AtomicOrdering ao) {
   return isAtLeastOrStrongerThan(ao, AtomicOrdering::Release);
 }
 
-static inline AtomicOrderingCABI toCABI(AtomicOrdering ao) {
+inline AtomicOrderingCABI toCABI(AtomicOrdering ao) {
   static const AtomicOrderingCABI lookup[8] = {
       /* NotAtomic */ AtomicOrderingCABI::relaxed,
       /* Unordered */ AtomicOrderingCABI::relaxed,