translator: Refactor Constant Union shift ops.

src/common/debug.h

@@ -154,8 +154,7 @@ bool DebugAnnotationsActive();
 // A macro for code which is not expected to be reached under valid assumptions
 #if !defined(NDEBUG)
 #define UNREACHABLE() \
-    ERR("\t! Unreachable reached: %s(%d)\n", __FUNCTION__, __LINE__), \
-    assert(false)
+    ERR("\t! Unreachable reached: %s(%d)\n", __FUNCTION__, __LINE__), assert(false)
 #else
     #define UNREACHABLE() ERR("\t! Unreachable reached: %s(%d)\n", __FUNCTION__, __LINE__)
 #endif

src/compiler/translator/ConstantUnion.cpp

@@ -369,17 +369,21 @@ TConstantUnion TConstantUnion::operator%(const TConstantUnion &constant) const
     return returnValue;
 }
 
-TConstantUnion TConstantUnion::operator>>(const TConstantUnion &constant) const
+// static
+TConstantUnion TConstantUnion::rshift(const TConstantUnion &lhs,
+                                      const TConstantUnion &rhs,
+                                      TDiagnostics *diag,
+                                      const TSourceLoc &line)
 {
     TConstantUnion returnValue;
-    ASSERT(type == constant.type);
-    switch (type)
+    ASSERT((lhs.type == rhs.type) && (lhs.type == EbtInt || lhs.type == EbtUInt));
+    switch (lhs.type)
     {
         case EbtInt:
-            returnValue.setIConst(iConst >> constant.iConst);
+            returnValue.setIConst(lhs.iConst >> rhs.iConst);
             break;
         case EbtUInt:
-            returnValue.setUConst(uConst >> constant.uConst);
+            returnValue.setUConst(lhs.uConst >> rhs.uConst);
             break;
         default:
             UNREACHABLE();
@@ -388,20 +392,24 @@ TConstantUnion TConstantUnion::operator>>(const TConstantUnion &constant) const
     return returnValue;
 }
 
-TConstantUnion TConstantUnion::operator<<(const TConstantUnion &constant) const
+// static
+TConstantUnion TConstantUnion::lshift(const TConstantUnion &lhs,
+                                      const TConstantUnion &rhs,
+                                      TDiagnostics *diag,
+                                      const TSourceLoc &line)
 {
     TConstantUnion returnValue;
     // The signedness of the second parameter might be different, but we
     // don't care, since the result is undefined if the second parameter is
     // negative, and aliasing should not be a problem with unions.
-    ASSERT(constant.type == EbtInt || constant.type == EbtUInt);
-    switch (type)
+    ASSERT((lhs.type == rhs.type) && (lhs.type == EbtInt || lhs.type == EbtUInt));
+    switch (lhs.type)
     {
         case EbtInt:
-            returnValue.setIConst(iConst << constant.iConst);
+            returnValue.setIConst(lhs.iConst << rhs.iConst);
             break;
         case EbtUInt:
-            returnValue.setUConst(uConst << constant.uConst);
+            returnValue.setUConst(lhs.uConst << rhs.uConst);
             break;
         default:
             UNREACHABLE();

src/compiler/translator/ConstantUnion.h

@@ -57,8 +57,14 @@ class TConstantUnion
                               TDiagnostics *diag,
                               const TSourceLoc &line);
     TConstantUnion operator%(const TConstantUnion &constant) const;
-    TConstantUnion operator>>(const TConstantUnion &constant) const;
-    TConstantUnion operator<<(const TConstantUnion &constant) const;
+    static TConstantUnion rshift(const TConstantUnion &lhs,
+                                 const TConstantUnion &rhs,
+                                 TDiagnostics *diag,
+                                 const TSourceLoc &line);
+    static TConstantUnion lshift(const TConstantUnion &lhs,
+                                 const TConstantUnion &rhs,
+                                 TDiagnostics *diag,
+                                 const TSourceLoc &line);
     TConstantUnion operator&(const TConstantUnion &constant) const;
     TConstantUnion operator|(const TConstantUnion &constant) const;
     TConstantUnion operator^(const TConstantUnion &constant) const;

src/compiler/translator/IntermNode.cpp

@@ -1340,12 +1340,12 @@ TConstantUnion *TIntermConstantUnion::foldBinary(TOperator op,
       case EOpBitShiftLeft:
         resultArray = new TConstantUnion[objectSize];
         for (size_t i = 0; i < objectSize; i++)
-            resultArray[i] = leftArray[i] << rightArray[i];
+            resultArray[i] = TConstantUnion::lshift(leftArray[i], rightArray[i], diagnostics, line);
         break;
       case EOpBitShiftRight:
         resultArray = new TConstantUnion[objectSize];
         for (size_t i = 0; i < objectSize; i++)
-            resultArray[i] = leftArray[i] >> rightArray[i];
+            resultArray[i] = TConstantUnion::rshift(leftArray[i], rightArray[i], diagnostics, line);
         break;
 
       case EOpLessThan: