added constant folding & branch elimination to skslc

src/sksl/SkSLIRGenerator.cpp

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
  
 #include "SkSLIRGenerator.h"
 
 #include "limits.h"
@@ skipping 228 matching lines @@
     if (!ifTrue) {
         return nullptr;
     }
     std::unique_ptr<Statement> ifFalse;
     if (s.fIfFalse) {
         ifFalse = this->convertStatement(*s.fIfFalse);
         if (!ifFalse) {
             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)));
 }
 
 std::unique_ptr<Statement> IRGenerator::convertFor(const ASTForStatement& f) {
     AutoLoopLevel level(this);
     AutoSymbolTable table(this);
     std::unique_ptr<Statement> initializer;
     if (f.fInitializer) {
         initializer = this->convertStatement(*f.fInitializer);
@@ skipping 528 matching lines @@
         }
         return false;
     }
     if (tryFlipped) {
         return determine_binary_type(context, op, right, left, outRightType, outLeftType, 
                                      outResultType, false);
     }
     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);
     if (!left) {
         return nullptr;
     }
     std::unique_ptr<Expression> right = this->convertExpression(*expression.fRight);
     if (!right) {
         return nullptr;
     }
     const Type* leftType;
     const Type* rightType;
     const Type* resultType;
     if (!determine_binary_type(fContext, expression.fOperator, left->fType, right->fType, &leftType,
                                &rightType, &resultType, !is_assignment(expression.fOperator))) {
         fErrors.error(expression.fPosition, "type mismatch: '" + 
                                             Token::OperatorName(expression.fOperator) + 
                                             "' cannot operate on '" + left->fType.fName + 
                                             "', '" + right->fType.fName + "'");
         return nullptr;
     }
     if (is_assignment(expression.fOperator)) {
         this->markWrittenTo(*left);
     }
     left = this->coerce(std::move(left), *leftType);
     right = this->coerce(std::move(right), *rightType);
     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(  
                                                            const ASTTernaryExpression& expression) {
     std::unique_ptr<Expression> test = this->coerce(this->convertExpression(*expression.fTest), 
                                                     *fContext.fBool_Type);
     if (!test) {
         return nullptr;
     }
     std::unique_ptr<Expression> ifTrue = this->convertExpression(*expression.fIfTrue);
@@ skipping 10 matching lines @@
     if (!determine_binary_type(fContext, Token::EQEQ, ifTrue->fType, ifFalse->fType, &trueType,
                                &falseType, &resultType, true)) {
         fErrors.error(expression.fPosition, "ternary operator result mismatch: '" + 
                                             ifTrue->fType.fName + "', '" + 
                                             ifFalse->fType.fName + "'");
         return nullptr;
     }
     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), 
                                                              std::move(ifFalse)));
 }
 
 std::unique_ptr<Expression> IRGenerator::call(Position position, 
                                               const FunctionDeclaration& function, 
                                               std::vector<std::unique_ptr<Expression>> arguments) {
     if (function.fParameters.size() != arguments.size()) {
@@ skipping 248 matching lines @@
             }
             this->markWrittenTo(*base);
             break;
         case Token::LOGICALNOT:
             if (base->fType != *fContext.fBool_Type) {
                 fErrors.error(expression.fPosition, 
                               "'" + Token::OperatorName(expression.fOperator) + 
                               "' 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) {
                 fErrors.error(expression.fPosition, 
                               "'" + Token::OperatorName(expression.fOperator) + 
                               "' cannot operate on '" + base->fType.description() + "'");
                 return nullptr;
             }
             break;
         default: 
@@ skipping 219 matching lines @@
         case Expression::kIndex_Kind:
             this->markWrittenTo(*((IndexExpression&) expr).fBase);
             break;
         default:
             fErrors.error(expr.fPosition, "cannot assign to '" + expr.description() + "'");
             break;
     }
 }
 
 }