Turned on SkSL->GLSL compiler

src/sksl/SkSLGLSLCodeGenerator.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 "SkSLGLSLCodeGenerator.h"
 
 #include "string.h"
 
 #include "GLSL.std.450.h"
 
 #include "ir/SkSLExpressionStatement.h"
 #include "ir/SkSLExtension.h"
 #include "ir/SkSLIndexExpression.h"
+#include "ir/SkSLModifiersDeclaration.h"
 #include "ir/SkSLVariableReference.h"
 
+#define SK_FRAGCOLOR_BUILTIN 10001
+
 namespace SkSL {
 
 void GLSLCodeGenerator::write(const char* s) {
     if (s[0] == 0) {
         return;
     }
     if (fAtLineStart) {
         for (int i = 0; i < fIndentation; i++) {
             *fOut << "    ";
         }
@@ skipping 30 matching lines @@
             if (*search == type) {
                 // already written
                 this->write(type.name());
                 return;
             }
         }
         fWrittenStructs.push_back(&type);
         this->writeLine("struct " + type.name() + " {");
         fIndentation++;
         for (const auto& f : type.fields()) {
-            this->writeModifiers(f.fModifiers);
+            this->writeModifiers(f.fModifiers, false);
             // sizes (which must be static in structs) are part of the type name here
             this->writeType(*f.fType);
             this->writeLine(" " + f.fName + ";");
         }
         fIndentation--;
         this->writeLine("}");
     } else {
         this->write(type.name());
     }
 }
@@ skipping 37 matching lines @@
             this->writeTernaryExpression((TernaryExpression&) expr, parentPrecedence);
             break;
         case Expression::kIndex_Kind:
             this->writeIndexExpression((IndexExpression&) expr);
             break;
         default:
             ABORT("unsupported expression: %s", expr.description().c_str());
     }
 }
 
+static bool is_abs(Expression& expr) {
+    if (expr.fKind != Expression::kFunctionCall_Kind) {
+        return false;
+    }
+    return ((FunctionCall&) expr).fFunction.fName == "abs";
+}
+
+// turns min(abs(x), y) into (abs(x) > (tmpVar = y) ? tmpVar : abs(x)) to avoid a Tegra3 compiler 
+// bug.
+void GLSLCodeGenerator::writeMinAbsHack(Expression& absExpr, Expression& otherExpr) {
+    ASSERT(!fCaps.fCanUseMinAndAbsTogether);
+    std::string varName = "minAbsHackVar" + to_string(fVarCount++);
+    this->fFunctionHeader += "    " + otherExpr.fType.name() + " " + varName + ";\n";
+    this->write("(");
+    this->writeExpression(absExpr, kTopLevel_Precedence);
+    this->write(" > (" + varName + " = ");
+    this->writeExpression(otherExpr, kRelational_Precedence);

[dogben, 2016/09/30 15:00:51]

nit: kAssignment_Precedence

[ethannicholas, 2016/10/06 13:16:47]

Done.

+    this->write(") ? " + varName + " : ");
+    this->writeExpression(absExpr, kTernary_Precedence);

[dogben, 2016/09/30 15:00:51]

Why make a temp var for otherExpr but not absExpr?

[ethannicholas, 2016/10/06 13:16:47]

Fixed.

+    this->write(")");
+}
+
 void GLSLCodeGenerator::writeFunctionCall(const FunctionCall& c) {
+    if (!fCaps.fCanUseMinAndAbsTogether && c.fFunction.fName == "min") {
+        ASSERT(c.fArguments.size() == 2);
+        if (is_abs(*c.fArguments[0])) {
+            this->writeMinAbsHack(*c.fArguments[0], *c.fArguments[1]);
+            return;
+        }
+        if (is_abs(*c.fArguments[1])) {
+            this->writeMinAbsHack(*c.fArguments[1], *c.fArguments[0]);

[dogben, 2016/09/30 15:00:51]

Is argument evaluation order undefined? E.g. "min(abs(x++), x++)"

[ethannicholas, 2016/10/06 13:16:47]

GLSL specifies left to right, but I haven't decided whether SkSL is going to
stick to that rule (and clearly it isn't 100% doing so at the moment). I'll at
least add a comment noting that this breaks the GLSL assumption in this case.

+            return;
+        }
+    }
     this->write(c.fFunction.fName + "(");
     const char* separator = "";
     for (const auto& arg : c.fArguments) {
         this->write(separator);
         separator = ", ";
         this->writeExpression(*arg, kSequence_Precedence);
     }
     this->write(")");
 }
 
 void GLSLCodeGenerator::writeConstructor(const Constructor& c) {
     this->write(c.fType.name() + "(");
     const char* separator = "";
     for (const auto& arg : c.fArguments) {
         this->write(separator);
         separator = ", ";
         this->writeExpression(*arg, kSequence_Precedence);
     }
     this->write(")");
 }
 
 void GLSLCodeGenerator::writeVariableReference(const VariableReference& ref) {
-    this->write(ref.fVariable.fName);
+    if (ref.fVariable.fModifiers.fLayout.fBuiltin == SK_FRAGCOLOR_BUILTIN) {
+        if (fCaps.fMustDeclareFragmentShaderOutput) {
+            this->write("sk_FragColor");
+        } else {
+            this->write("gl_FragColor");
+        }
+    } else {
+        this->write(ref.fVariable.fName);
+    }
 }
 
 void GLSLCodeGenerator::writeIndexExpression(const IndexExpression& expr) {
     this->writeExpression(*expr.fBase, kPostfix_Precedence);
     this->write("[");
     this->writeExpression(*expr.fIndex, kTopLevel_Precedence);
     this->write("]");
 }
 
 void GLSLCodeGenerator::writeFieldAccess(const FieldAccess& f) {
@@ skipping 102 matching lines @@
     if (kPostfix_Precedence >= parentPrecedence) {
         this->write(")");
     }
 }
 
 void GLSLCodeGenerator::writeBoolLiteral(const BoolLiteral& b) {
     this->write(b.fValue ? "true" : "false");
 }
 
 void GLSLCodeGenerator::writeIntLiteral(const IntLiteral& i) {
-    this->write(to_string(i.fValue));
+    if (i.fType == *fContext.fUInt_Type) {
+        this->write(to_string(i.fValue & 0xffffffff) + "u");
+    } else {
+        this->write(to_string(i.fValue));
+    }
 }
 
 void GLSLCodeGenerator::writeFloatLiteral(const FloatLiteral& f) {
     this->write(to_string(f.fValue));
 }
 
 void GLSLCodeGenerator::writeFunction(const FunctionDefinition& f) {
     this->writeType(f.fDeclaration.fReturnType);
     this->write(" " + f.fDeclaration.fName + "(");
     const char* separator = "";
     for (const auto& param : f.fDeclaration.fParameters) {
         this->write(separator);
         separator = ", ";
-        this->writeModifiers(param->fModifiers);
-        this->writeType(param->fType);
+        this->writeModifiers(param->fModifiers, false);
+        std::vector<int> sizes;
+        const Type* type = &param->fType;
+        while (type->kind() == Type::kArray_Kind) {
+            sizes.push_back(type->columns());
+            type = &type->componentType();
+        }
+        this->writeType(*type);
         this->write(" " + param->fName);
+        for (int s : sizes) {
+            if (s <= 0) {
+                this->write("[]");
+            } else {
+                this->write("[" + to_string(s) + "]");
+            }
+        }
     }
-    this->write(") ");
-    this->writeBlock(*f.fBody);
-    this->writeLine();
+    this->writeLine(") {");
+
+    fFunctionHeader = "";
+    std::ostream* oldOut = fOut;
+    std::stringstream buffer;
+    fOut = &buffer;
+    fIndentation++;
+    for (const auto& s : f.fBody->fStatements) {
+        this->writeStatement(*s);
+        this->writeLine();
+    }
+    fIndentation--;
+    this->writeLine("}");
+
+    fOut = oldOut;
+    this->write(fFunctionHeader);
+    this->write(buffer.str());
 }
 
-void GLSLCodeGenerator::writeModifiers(const Modifiers& modifiers) {
-    this->write(modifiers.description());
+void GLSLCodeGenerator::writeModifiers(const Modifiers& modifiers, 
+                                       bool globalContext) {
+    if (modifiers.fFlags & Modifiers::kNoPerspective_Flag) {
+        this->write("noperspective ");
+    }
+    if (modifiers.fFlags & Modifiers::kFlat_Flag) {
+        this->write("flat ");
+    }
+    std::string layout = modifiers.fLayout.description();
+    if (layout.length()) {
+        this->write(layout + " ");
+    }
+    if ((modifiers.fFlags & Modifiers::kIn_Flag) && 
+        (modifiers.fFlags & Modifiers::kOut_Flag)) {
+        this->write("inout ");
+    } else if (modifiers.fFlags & Modifiers::kIn_Flag) {
+        if (globalContext && fCaps.fVersion < 130) {
+            this->write(fProgramKind == Program::kVertex_Kind ? "attribute "
+                                                              : "varying ");
+        } else {
+            this->write("in ");
+        }
+    } else if (modifiers.fFlags & Modifiers::kOut_Flag) {
+        if (globalContext && fCaps.fVersion < 130) {
+            this->write("varying ");
+        } else {
+            this->write("out ");
+        }
+    }
+    if (modifiers.fFlags & Modifiers::kUniform_Flag) {
+        this->write("uniform ");
+    }
+    if (modifiers.fFlags & Modifiers::kConst_Flag) {
+        this->write("const ");
+    }
+    if (fCaps.fUsesPrecisionModifiers) {
+        if (modifiers.fFlags & Modifiers::kLowp_Flag) {
+            this->write("lowp ");
+        }
+        if (modifiers.fFlags & Modifiers::kMediump_Flag) {
+            this->write("mediump ");
+        }
+        if (modifiers.fFlags & Modifiers::kHighp_Flag) {
+            this->write("highp ");
+        }
+    }
 }
 
 void GLSLCodeGenerator::writeInterfaceBlock(const InterfaceBlock& intf) {
     if (intf.fVariable.fName == "gl_PerVertex") {
         return;
     }
-    this->writeModifiers(intf.fVariable.fModifiers);
+    this->writeModifiers(intf.fVariable.fModifiers, true);
     this->writeLine(intf.fVariable.fType.name() + " {");
     fIndentation++;
     for (const auto& f : intf.fVariable.fType.fields()) {
-        this->writeModifiers(f.fModifiers);
+        this->writeModifiers(f.fModifiers, false);
         this->writeType(*f.fType);
         this->writeLine(" " + f.fName + ";");
     }
     fIndentation--;
     this->writeLine("};");
 }
 
-void GLSLCodeGenerator::writeVarDeclarations(const VarDeclarations& decl) {
+void GLSLCodeGenerator::writeVarDeclarations(const VarDeclarations& decl, bool global) {
     ASSERT(decl.fVars.size() > 0);
-    this->writeModifiers(decl.fVars[0].fVar->fModifiers);
+    this->writeModifiers(decl.fVars[0].fVar->fModifiers, global);
     this->writeType(decl.fBaseType);
     std::string separator = " ";
     for (const auto& var : decl.fVars) {
         ASSERT(var.fVar->fModifiers == decl.fVars[0].fVar->fModifiers);
         this->write(separator);
         separator = ", ";
         this->write(var.fVar->fName);
         for (const auto& size : var.fSizes) {
             this->write("[");
-            this->writeExpression(*size, kTopLevel_Precedence);
+            if (size) {
+                this->writeExpression(*size, kTopLevel_Precedence);
+            }
             this->write("]");
         }
         if (var.fValue) {
             this->write(" = ");
             this->writeExpression(*var.fValue, kTopLevel_Precedence);
         }
     }
     this->write(";");
 }
 
 void GLSLCodeGenerator::writeStatement(const Statement& s) {
     switch (s.fKind) {
         case Statement::kBlock_Kind:
             this->writeBlock((Block&) s);
             break;
         case Statement::kExpression_Kind:
             this->writeExpression(*((ExpressionStatement&) s).fExpression, kTopLevel_Precedence);
             this->write(";");
             break;
         case Statement::kReturn_Kind: 
             this->writeReturnStatement((ReturnStatement&) s);
             break;
         case Statement::kVarDeclarations_Kind:
-            this->writeVarDeclarations(*((VarDeclarationsStatement&) s).fDeclaration);
+            this->writeVarDeclarations(*((VarDeclarationsStatement&) s).fDeclaration, false);
             break;
         case Statement::kIf_Kind:
             this->writeIfStatement((IfStatement&) s);
             break;
         case Statement::kFor_Kind:
             this->writeForStatement((ForStatement&) s);
             break;
         case Statement::kWhile_Kind:
             this->writeWhileStatement((WhileStatement&) s);
             break;
@@ skipping 74 matching lines @@
     if (r.fExpression) {
         this->write(" ");
         this->writeExpression(*r.fExpression, kTopLevel_Precedence);
     }
     this->write(";");
 }
 
 void GLSLCodeGenerator::generateCode(const Program& program, std::ostream& out) {
     ASSERT(fOut == nullptr);
     fOut = &out;
+    fProgramKind = program.fKind;
     this->write("#version " + to_string(fCaps.fVersion));
-    if (fCaps.fStandard == GLCaps::kGLES_Standard) {
+    if (fCaps.fStandard == GLCaps::kGLES_Standard && fCaps.fVersion >= 300) {
         this->write(" es");
+    } else if (fCaps.fIsCoreProfile) {
+        this->write(" core");
     }
     this->writeLine();
     for (const auto& e : program.fElements) {
+        if (e->fKind == ProgramElement::kExtension_Kind) {
+            this->writeExtension((Extension&) *e);
+        }
+    }
+    if (fCaps.fStandard == GLCaps::kGLES_Standard) {
+        this->write("precision ");
+        switch (program.fDefaultPrecision) {
+            case Modifiers::kLowp_Flag:
+                this->write("lowp");
+                break;
+            case Modifiers::kMediump_Flag:
+                this->write("mediump");
+                break;
+            case Modifiers::kHighp_Flag:
+                this->write("highp");
+                break;
+            default:
+                ASSERT(false);
+                this->write("<error>");
+        }
+        this->writeLine(" float;");
+    }
+    for (const auto& e : program.fElements) {
         switch (e->fKind) {
             case ProgramElement::kExtension_Kind:
-                this->writeExtension((Extension&) *e);
                 break;
             case ProgramElement::kVar_Kind: {
                 VarDeclarations& decl = (VarDeclarations&) *e;
-                if (decl.fVars.size() > 0 && 
-                    decl.fVars[0].fVar->fModifiers.fLayout.fBuiltin == -1) {
-                    this->writeVarDeclarations(decl);
-                    this->writeLine();
+                if (decl.fVars.size() > 0) {
+                    int builtin = decl.fVars[0].fVar->fModifiers.fLayout.fBuiltin;
+                    if (builtin == -1) {
+                        // normal var
+                        this->writeVarDeclarations(decl, true);
+                        this->writeLine();
+                    } else if (builtin == SK_FRAGCOLOR_BUILTIN &&
+                               fCaps.fMustDeclareFragmentShaderOutput) {
+                        this->write("out ");

[dogben, 2016/09/30 15:00:51]

Does this ever need to be "varying "?

[ethannicholas, 2016/10/06 13:16:47]

I don't think so -- versions new enough to require you to specify the output
also use out instead of varying.

+                        if (fCaps.fUsesPrecisionModifiers) {
+                            this->write("mediump ");
+                        }
+                        this->writeLine("vec4 sk_FragColor;");
+                    }
                 }
                 break;
             }
             case ProgramElement::kInterfaceBlock_Kind:
                 this->writeInterfaceBlock((InterfaceBlock&) *e);
                 break;
             case ProgramElement::kFunction_Kind:
                 this->writeFunction((FunctionDefinition&) *e);
                 break;
+            case ProgramElement::kModifiers_Kind:
+                this->writeModifiers(((ModifiersDeclaration&) *e).fModifiers, true);
+                this->writeLine(";");
+                break;
             default:
                 printf("%s\n", e->description().c_str());
                 ABORT("unsupported program element");
         }
     }
     fOut = nullptr;
 }
 
 }