added constant folding & branch elimination to skslc

src/sksl/SkSLIRGenerator.cpp

Index: src/sksl/SkSLIRGenerator.cpp
diff --git a/src/sksl/SkSLIRGenerator.cpp b/src/sksl/SkSLIRGenerator.cpp
index ec64fa93487d065236e36470b7be193f050d1728..97d851d1f763404750c2a2e3f8b956c5ca7e1f3b 100644
--- a/src/sksl/SkSLIRGenerator.cpp
+++ b/src/sksl/SkSLIRGenerator.cpp
@@ -246,6 +246,17 @@ std::unique_ptr<Statement> IRGenerator::convertIf(const ASTIfStatement& s) {
             return nullptr;
         }
     }
+    if (test->fKind == Expression::kBoolLiteral_Kind) {
+        // static boolean value, fold down to a single branch
+        if (((BoolLiteral&) *test).fValue) {
+            return ifTrue;
+        } else if (s.fIfFalse) {
+            return ifFalse;
+        } else {
+            // False & no else clause. Not an error, so don't return null!
+            return std::unique_ptr<Statement>(new Block(s.fPosition, { }, fSymbolTable));
+        }
+    }
     return std::unique_ptr<Statement>(new IfStatement(s.fPosition, std::move(test), 
                                                       std::move(ifTrue), std::move(ifFalse)));
 }
@@ -794,6 +805,73 @@ static bool determine_binary_type(const Context& context,
     return false;
 }
 
+/**
+ * If both operands are compile-time constants and can be folded, returns an expression representing
+ * the folded value. Otherwise, returns null.
+ */
+std::unique_ptr<Expression> IRGenerator::constantFold(const Expression& left,
+                                                      Token::Kind op,
+                                                      const Expression& right) {
+    if (left.fKind == Expression::kBoolLiteral_Kind && 
+        right.fKind == Expression::kBoolLiteral_Kind) {
+        bool leftVal  = ((BoolLiteral&) left).fValue;
+        bool rightVal = ((BoolLiteral&) right).fValue;
+        bool result;
+        switch (op) {
+            case Token::LOGICALAND: result = leftVal && rightVal; break;
+            case Token::LOGICALOR:  result = leftVal || rightVal; break;
+            case Token::LOGICALXOR: result = leftVal ^  rightVal; break;
+            default: return nullptr;
+        }
+        return std::unique_ptr<Expression>(new BoolLiteral(fContext, left.fPosition, result));
+    }
+    #define RESULT(t, op) std::unique_ptr<Expression>(new t ## Literal(fContext, left.fPosition, \
+                                                                       leftVal op rightVal))
+    if (left.fKind == Expression::kIntLiteral_Kind && right.fKind == Expression::kIntLiteral_Kind) {
+        int64_t leftVal  = ((IntLiteral&) left).fValue;

[dogben, 2016/11/09 15:35:36]

Assuming integer overflow is well-defined in SkSL, this seems a bit dicey. SkSL
(and GLSL/SpirV) ints will be 32 bits (right?), but we are calculating the
result using int64_t. I could probably convince myself this is OK if we 
 - cast the result to int32_t or uint32_t, and
 - either 
   - ensure that anything that goes into IntLiteral is 32 bits, or
   - cast leftVal and rightVal to int32_t or uint32_t.

(The second part is probably not strictly necessary for all operators, but it
doesn't seem worthwhile to make special cases for those.)

Even if integer overflow produces undefined results, I would still expect SHR
and SHL to be well-defined.

[ethannicholas, 2016/11/09 16:36:21]

In GLSL ES, integer precision varies. It is allowed to be as low as 10 bits +
sign bit, and integer overflow is undefined. Furthermore, we do cast the result
to (u)int32 when generating code.

It's possible to detect the precision using GL functions and error appropriately
at compile time, but I don't have access to that from within SkSL yet. The plan
is for my next change to move all of the Skia GLSL caps into SkSL's hands, which
would allow me to perform that check. Given that this CL does not introduce new
problems (you can easily write undefined overflowing expressions in GLSL today),
I'll push as-is and revisit when I have the information I need to fix this.

I've added a comment to clarify this.

+        int64_t rightVal = ((IntLiteral&) right).fValue;
+        switch (op) {
+            case Token::PLUS:       return RESULT(Int,  +);
+            case Token::MINUS:      return RESULT(Int,  -);
+            case Token::STAR:       return RESULT(Int,  *);
+            case Token::SLASH:      return RESULT(Int,  /);
+            case Token::PERCENT:    return RESULT(Int,  %);
+            case Token::BITWISEAND: return RESULT(Int,  &);
+            case Token::BITWISEOR:  return RESULT(Int,  |);
+            case Token::BITWISEXOR: return RESULT(Int,  ^);
+            case Token::SHL:        return RESULT(Int,  <<);
+            case Token::SHR:        return RESULT(Int,  >>);
+            case Token::EQEQ:       return RESULT(Bool, ==);
+            case Token::NEQ:        return RESULT(Bool, !=);
+            case Token::GT:         return RESULT(Bool, >);
+            case Token::GTEQ:       return RESULT(Bool, >=);
+            case Token::LT:         return RESULT(Bool, <);
+            case Token::LTEQ:       return RESULT(Bool, <=);
+            default:                return nullptr;
+        }
+    }
+    if (left.fKind == Expression::kFloatLiteral_Kind && 
+        right.fKind == Expression::kFloatLiteral_Kind) {
+        double leftVal  = ((FloatLiteral&) left).fValue;

[dogben, 2016/11/09 15:35:36]

Same as above, except I don't feel that strongly about it, because if we're
relying on floating point precision to get the correct result, we are doing
something wrong.

[ethannicholas, 2016/11/09 16:36:21]

Floating point's range is allowed to be as small as -2 ... +2 (no, that is not a
typo) but could be much larger. For right now, I'll assume the author isn't
statically writing expressions that won't actually work, and as above look into
detecting this properly when I have access to all of the caps.

+        double rightVal = ((FloatLiteral&) right).fValue;
+        switch (op) {
+            case Token::PLUS:       return RESULT(Float, +);
+            case Token::MINUS:      return RESULT(Float, -);
+            case Token::STAR:       return RESULT(Float, *);
+            case Token::SLASH:      return RESULT(Float, /);
+            case Token::EQEQ:       return RESULT(Bool,  ==);
+            case Token::NEQ:        return RESULT(Bool,  !=);
+            case Token::GT:         return RESULT(Bool,  >);
+            case Token::GTEQ:       return RESULT(Bool,  >=);
+            case Token::LT:         return RESULT(Bool,  <);
+            case Token::LTEQ:       return RESULT(Bool,  <=);
+            default:                return nullptr;
+        }
+    }
+    #undef RESULT
+    return nullptr;
+}
+
 std::unique_ptr<Expression> IRGenerator::convertBinaryExpression(
                                                             const ASTBinaryExpression& expression) {
     std::unique_ptr<Expression> left = this->convertExpression(*expression.fLeft);
@@ -823,11 +901,16 @@ std::unique_ptr<Expression> IRGenerator::convertBinaryExpression(
     if (!left || !right) {
         return nullptr;
     }
-    return std::unique_ptr<Expression>(new BinaryExpression(expression.fPosition, 
-                                                            std::move(left), 
-                                                            expression.fOperator, 
-                                                            std::move(right), 
-                                                            *resultType));
+    std::unique_ptr<Expression> result = this->constantFold(*left.get(), expression.fOperator, 
+                                                            *right.get());
+    if (!result) {
+        result = std::unique_ptr<Expression>(new BinaryExpression(expression.fPosition,
+                                                                  std::move(left),
+                                                                  expression.fOperator,
+                                                                  std::move(right),
+                                                                  *resultType));
+    }
+    return result;
 }
 
 std::unique_ptr<Expression> IRGenerator::convertTernaryExpression(  
@@ -858,6 +941,14 @@ std::unique_ptr<Expression> IRGenerator::convertTernaryExpression(
     ASSERT(trueType == falseType);
     ifTrue = this->coerce(std::move(ifTrue), *trueType);
     ifFalse = this->coerce(std::move(ifFalse), *falseType);
+    if (test->fKind == Expression::kBoolLiteral_Kind) {
+        // static boolean test, just return one of the branches
+        if (((BoolLiteral&) *test).fValue) {
+            return ifTrue;
+        } else {
+            return ifFalse;
+        }
+    }
     return std::unique_ptr<Expression>(new TernaryExpression(expression.fPosition, 
                                                              std::move(test),
                                                              std::move(ifTrue), 
@@ -1126,6 +1217,10 @@ std::unique_ptr<Expression> IRGenerator::convertPrefixExpression(
                               "' cannot operate on '" + base->fType.description() + "'");
                 return nullptr;
             }
+            if (base->fKind == Expression::kBoolLiteral_Kind) {
+                return std::unique_ptr<Expression>(new BoolLiteral(fContext, base->fPosition,
+                                                                   !((BoolLiteral&) *base).fValue));
+            }
             break;
         case Token::BITWISENOT:
             if (base->fType != *fContext.fInt_Type) {