Fix integer division constant folding corner cases

src/compiler/translator/IntermNode.cpp

@@ -1204,14 +1204,42 @@ TConstantUnion *TIntermConstantUnion::foldBinary(TOperator op,
                     }
                     else
                     {
+                        int lhs     = leftArray[i].getIConst();
+                        int divisor = rightArray[i].getIConst();
                         if (op == EOpDiv)
                         {
-                            resultArray[i].setIConst(leftArray[i].getIConst() / rightArray[i].getIConst());
+                            // Check for the special case where the minimum representable number is
+                            // divided by -1. If left alone this leads to integer overflow in C++.
+                            // ESSL 3.00.6 section 4.1.3 Integers:
+                            // "However, for the case where the minimum representable value is
+                            // divided by -1, it is allowed to return either the minimum
+                            // representable value or the maximum representable value."
+                            if (lhs == -0x7fffffff - 1 && divisor == -1)
+                            {
+                                resultArray[i].setIConst(0x7fffffff);
+                            }
+                            else
+                            {
+                                resultArray[i].setIConst(lhs / divisor);
+                            }
                         }
                         else
                         {
                             ASSERT(op == EOpIMod);
-                            resultArray[i].setIConst(leftArray[i].getIConst() % rightArray[i].getIConst());
+                            if (lhs < 0 || divisor < 0)
+                            {
+                                // ESSL 3.00.6 section 5.9: Results of modulus are undefined when
+                                // either one of the operands is negative.
+                                diagnostics->warning(getLine(),
+                                                     "Negative modulus operator operand "
+                                                     "encountered during constant folding",
+                                                     "%", "");
+                                resultArray[i].setIConst(0);
+                            }
+                            else
+                            {
+                                resultArray[i].setIConst(lhs % divisor);
+                            }
                         }
                     }
                     break;

src/tests/compiler_tests/ConstantFolding_test.cpp

@@ -824,3 +824,22 @@ TEST_F(ConstantFoldingTest, FoldBitShiftRightDifferentSignedness)
     compile(shaderString);
     ASSERT_TRUE(constantFoundInAST(0x3u));
 }
+
+// Test that dividing the minimum signed integer by -1 works.
+// ESSL 3.00.6 section 4.1.3 Integers:
+// "However, for the case where the minimum representable value is divided by -1, it is allowed to
+// return either the minimum representable value or the maximum representable value."
+TEST_F(ConstantFoldingTest, FoldDivideMinimumIntegerByMinusOne)
+{
+    const std::string &shaderString =
+        "#version 300 es\n"
+        "precision mediump float;\n"
+        "out vec4 my_FragColor;\n"
+        "void main()\n"
+        "{\n"
+        "    int i = 0x80000000 / (-1);\n"
+        "    my_FragColor = vec4(i);\n"
+        "}\n";
+    compile(shaderString);
+    ASSERT_TRUE(constantFoundInAST(0x7fffffff) || constantFoundInAST(-0x7fffffff - 1));
+}