Fix for DAGCombiner infinite loop in AMDGPU OCLtst

[alex-t]

Summary

Some SelectionDAG methods use raw bits to create the ID for CSE map.
We need to exclude isDivergent bit from that raw representation to avoid creating new node each time we want to change it's properties.

For example this bug was caused by creating new node in DAGCombiner when it attempted to change node alignment.
It happened because we do not use divergence bit creating the hash for the node to put it in the CSE map. Same time for MemSDNode raw bits were used to create CSE map ID.
Thus we cannot identify the existing node in the map because it was added w/o counting the divergence bit but was looking for counting this bit.
So we either should add the divergence bit to ID any time we creating the node or exclude it from the raw bits representation.
The latter seems easier.

[rampitec]

I guess that is impossible to have two nodes which only differ by this bit. LGTM.

llvm/trunk/include/llvm/CodeGen/SelectionDAGNodes.h

public:
   unsigned getAlignment() const {
     return MMO->getAlignment();
   }
 
   /// Return the SubclassData value, without HasDebugValue. This contains an
   /// encoding of the volatile flag, as well as bits used by subclasses. This
   /// function should only be used to compute a FoldingSetNodeID value.
   /// The HasDebugValue bit is masked out because CSE map needs to match
-  /// nodes with debug info with nodes without debug info.
+  /// nodes with debug info with nodes without debug info. Same is about
+  /// isDivergent bit.
   unsigned getRawSubclassData() const {
     uint16_t Data;
     union {
       char RawSDNodeBits[sizeof(uint16_t)];
       SDNodeBitfields SDNodeBits;
     };
     memcpy(&RawSDNodeBits, &this->RawSDNodeBits, sizeof(this->RawSDNodeBits));
     SDNodeBits.HasDebugValue = 0;
+    SDNodeBits.IsDivergent = false;
     memcpy(&Data, &RawSDNodeBits, sizeof(RawSDNodeBits));
     return Data;
   }
 
   bool isVolatile() const { return MemSDNodeBits.IsVolatile; }
   bool isNonTemporal() const { return MemSDNodeBits.IsNonTemporal; }
   bool isDereferenceable() const { return MemSDNodeBits.IsDereferenceable; }
   bool isInvariant() const { return MemSDNodeBits.IsInvariant; }