OCL12AdapterPass

include/llvm/Bitcode/LLVMBitCodes.h

@@ -370,9 +370,15 @@ enum AtomicOrderingCodes {
 };
 
 /// Encoded SynchronizationScope values.
-enum AtomicSynchScopeCodes {
+enum AtomicSynchScopeCodes : unsigned {
+  /// Encoded value for SingleThread synchronization scope.
   SYNCHSCOPE_SINGLETHREAD = 0,
-  SYNCHSCOPE_CROSSTHREAD = 1
+
+  /// Encoded value for CrossThread synchronization scope.
+  SYNCHSCOPE_CROSSTHREAD = 1,
+
+  /// First encoded value for target specific synchronization scope.
+  SYNCHSCOPE_FIRSTTARGETSPECIFIC = 2
 };
 
 /// Markers and flags for call instruction.

include/llvm/CodeGen/SelectionDAGNodes.h

@@ -431,7 +431,6 @@ class SDNode : public FoldingSetNode, public ilist_node<SDNode> {
     uint16_t IsVolatile : 1;
     uint16_t IsNonTemporal : 1;
     uint16_t IsInvariant : 1;
-    uint16_t SynchScope : 1; // enum SynchronizationScope
     uint16_t Ordering : 4;   // enum AtomicOrdering
   };
   enum { NumMemSDNodeBits = NumSDNodeBits + 8 };
@@ -1075,6 +1074,11 @@ class MemSDNode : public SDNode {
   /// Memory reference information.
   MachineMemOperand *MMO;
 
+  /// The synchronization scope of this atomic operation. Not quite enough room
+  /// in SubclassData for everything, so synchronization scope gets its own
+  /// field.
+  SynchronizationScope SynchScope;
+
 public:
   MemSDNode(unsigned Opc, unsigned Order, const DebugLoc &dl, SDVTList VTs,
             EVT MemoryVT, MachineMemOperand *MMO);
@@ -1107,11 +1111,14 @@ class MemSDNode : public SDNode {
   bool isNonTemporal() const { return MemSDNodeBits.IsNonTemporal; }
   bool isInvariant() const { return MemSDNodeBits.IsInvariant; }
 
+  /// Returns the ordering of this atomic operation.
   AtomicOrdering getOrdering() const {
     return static_cast<AtomicOrdering>(MemSDNodeBits.Ordering);
   }
+
+  /// Returns the synchronization scope of this atomic operation.
   SynchronizationScope getSynchScope() const {
-    return static_cast<SynchronizationScope>(MemSDNodeBits.SynchScope);
+    return SynchScope;
   }
 
   // Returns the offset from the location of the access.
@@ -1185,18 +1192,18 @@ class MemSDNode : public SDNode {
 
 /// This is an SDNode representing atomic operations.
 class AtomicSDNode : public MemSDNode {
-  /// For cmpxchg instructions, the ordering requirements when a store does not
-  /// occur.
+  /// For cmpxchg operations, the ordering requirements when a store does not
+  /// occur. Not quite enough room in SubclassData for everything, so failure
+  /// gets its own field.
   AtomicOrdering FailureOrdering;
 
   void InitAtomic(AtomicOrdering SuccessOrdering,
                   AtomicOrdering FailureOrdering,
                   SynchronizationScope SynchScope) {
     MemSDNodeBits.Ordering = static_cast<uint16_t>(SuccessOrdering);
     assert(getOrdering() == SuccessOrdering && "Value truncated");
-    MemSDNodeBits.SynchScope = static_cast<uint16_t>(SynchScope);
-    assert(getSynchScope() == SynchScope && "Value truncated");
     this->FailureOrdering = FailureOrdering;
+    this->SynchScope = SynchScope;
   }
 
 public:
@@ -1211,12 +1218,14 @@ class AtomicSDNode : public MemSDNode {
   const SDValue &getBasePtr() const { return getOperand(1); }
   const SDValue &getVal() const { return getOperand(2); }
 
+  /// For cmpxchg operations, returns the ordering requirements when store
+  /// occurs.
   AtomicOrdering getSuccessOrdering() const {
     return getOrdering();
   }
 
-  // Not quite enough room in SubclassData for everything, so failure gets its
-  // own field.
+  /// For cmpxchg operations, returns the ordering requirements when store does
+  /// not occur.
   AtomicOrdering getFailureOrdering() const {
     return FailureOrdering;
   }