Bitset: remove some GCC<6.2 workarounds related to bitwise operators

GCC<6.2 has been unsupported since April 2022 (commit 4c72deb).

X86TargetParser.cpp has another workaround that the other 2 nearly identical places don't have. Remove them as well.

Reviewed By: arsenm, craig.topper

Differential Revision: https://reviews.llvm.org/D158687

Author: MaskRay

llvm/include/llvm/ADT/Bitset.h

@@ -56,23 +56,17 @@ class Bitset {
   }
 
   constexpr Bitset &set(unsigned I) {
-    // GCC <6.2 crashes if this is written in a single statement.
-    BitWord NewBits = Bits[I / BITWORD_SIZE] | (BitWord(1) << (I % BITWORD_SIZE));
-    Bits[I / BITWORD_SIZE] = NewBits;
+    Bits[I / BITWORD_SIZE] |= BitWord(1) << (I % BITWORD_SIZE);
     return *this;
   }
 
   constexpr Bitset &reset(unsigned I) {
-    // GCC <6.2 crashes if this is written in a single statement.
-    BitWord NewBits = Bits[I / BITWORD_SIZE] & ~(BitWord(1) << (I % BITWORD_SIZE));
-    Bits[I / BITWORD_SIZE] = NewBits;
+    Bits[I / BITWORD_SIZE] &= ~(BitWord(1) << (I % BITWORD_SIZE));
     return *this;
   }
 
   constexpr Bitset &flip(unsigned I) {
-    // GCC <6.2 crashes if this is written in a single statement.
-    BitWord NewBits = Bits[I / BITWORD_SIZE] ^ (BitWord(1) << (I % BITWORD_SIZE));
-    Bits[I / BITWORD_SIZE] = NewBits;
+    Bits[I / BITWORD_SIZE] ^= BitWord(1) << (I % BITWORD_SIZE);
     return *this;
   }
 
@@ -109,9 +103,8 @@ class Bitset {
   }
 
   constexpr Bitset &operator&=(const Bitset &RHS) {
-    for (unsigned I = 0, E = Bits.size(); I != E; ++I) {
+    for (unsigned I = 0, E = Bits.size(); I != E; ++I)
       Bits[I] &= RHS.Bits[I];
-    }
     return *this;
   }
   constexpr Bitset operator&(const Bitset &RHS) const {

llvm/include/llvm/TargetParser/SubtargetFeature.h

@@ -60,23 +60,17 @@ class FeatureBitset {
   }
 
   constexpr FeatureBitset &set(unsigned I) {
-    // GCC <6.2 crashes if this is written in a single statement.
-    uint64_t NewBits = Bits[I / 64] | (uint64_t(1) << (I % 64));
-    Bits[I / 64] = NewBits;
+    Bits[I / 64] |= uint64_t(1) << (I % 64);
     return *this;
   }
 
   constexpr FeatureBitset &reset(unsigned I) {
-    // GCC <6.2 crashes if this is written in a single statement.
-    uint64_t NewBits = Bits[I / 64] & ~(uint64_t(1) << (I % 64));
-    Bits[I / 64] = NewBits;
+    Bits[I / 64] &= ~(uint64_t(1) << (I % 64));
     return *this;
   }
 
   constexpr FeatureBitset &flip(unsigned I) {
-    // GCC <6.2 crashes if this is written in a single statement.
-    uint64_t NewBits = Bits[I / 64] ^ (uint64_t(1) << (I % 64));
-    Bits[I / 64] = NewBits;
+    Bits[I / 64] ^= uint64_t(1) << (I % 64);
     return *this;
   }
 
@@ -113,9 +107,8 @@ class FeatureBitset {
   }
 
   constexpr FeatureBitset &operator&=(const FeatureBitset &RHS) {
-    for (unsigned I = 0, E = Bits.size(); I != E; ++I) {
+    for (unsigned I = 0, E = Bits.size(); I != E; ++I)
       Bits[I] &= RHS.Bits[I];
-    }
     return *this;
   }
   constexpr FeatureBitset operator&(const FeatureBitset &RHS) const {

llvm/lib/TargetParser/X86TargetParser.cpp

@@ -42,9 +42,7 @@ class FeatureBitset {
   }
 
   constexpr FeatureBitset &set(unsigned I) {
-    // GCC <6.2 crashes if this is written in a single statement.
-    uint32_t NewBits = Bits[I / 32] | (uint32_t(1) << (I % 32));
-    Bits[I / 32] = NewBits;
+    Bits[I / 32] |= uint32_t(1) << (I % 32);
     return *this;
   }
 
@@ -54,36 +52,26 @@ class FeatureBitset {
   }
 
   constexpr FeatureBitset &operator&=(const FeatureBitset &RHS) {
-    for (unsigned I = 0, E = std::size(Bits); I != E; ++I) {
-      // GCC <6.2 crashes if this is written in a single statement.
-      uint32_t NewBits = Bits[I] & RHS.Bits[I];
-      Bits[I] = NewBits;
-    }
+    for (unsigned I = 0, E = std::size(Bits); I != E; ++I)
+      Bits[I] &= RHS.Bits[I];
     return *this;
   }
 
   constexpr FeatureBitset &operator|=(const FeatureBitset &RHS) {
-    for (unsigned I = 0, E = std::size(Bits); I != E; ++I) {
-      // GCC <6.2 crashes if this is written in a single statement.
-      uint32_t NewBits = Bits[I] | RHS.Bits[I];
-      Bits[I] = NewBits;
-    }
+    for (unsigned I = 0, E = std::size(Bits); I != E; ++I)
+      Bits[I] |= RHS.Bits[I];
     return *this;
   }
 
-  // gcc 5.3 miscompiles this if we try to write this using operator&=.
   constexpr FeatureBitset operator&(const FeatureBitset &RHS) const {
-    FeatureBitset Result;
-    for (unsigned I = 0, E = std::size(Bits); I != E; ++I)
-      Result.Bits[I] = Bits[I] & RHS.Bits[I];
+    FeatureBitset Result = *this;
+    Result &= RHS;
     return Result;
   }
 
-  // gcc 5.3 miscompiles this if we try to write this using operator&=.
   constexpr FeatureBitset operator|(const FeatureBitset &RHS) const {
-    FeatureBitset Result;
-    for (unsigned I = 0, E = std::size(Bits); I != E; ++I)
-      Result.Bits[I] = Bits[I] | RHS.Bits[I];
+    FeatureBitset Result = *this;
+    Result |= RHS;
     return Result;
   }