added initial GLSL support 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 164 matching lines @@
                 }
                 type = new Type(name, Type::kArray_Kind, *type, (int) count);
                 fSymbolTable->takeOwnership((Type*) type);
                 currentVarSizes.push_back(std::move(size));
             } else {
                 type = new Type(type->fName + "[]", Type::kArray_Kind, *type, -1);
                 fSymbolTable->takeOwnership((Type*) type);
                 currentVarSizes.push_back(nullptr);
             }
         }
-        sizes.push_back(std::move(currentVarSizes));
         auto var = std::unique_ptr<Variable>(new Variable(decl.fPosition, modifiers, decl.fNames[i], 
                                                           *type, storage));
         std::unique_ptr<Expression> value;
         if (decl.fValues[i]) {
             value = this->convertExpression(*decl.fValues[i]);
             if (!value) {
                 return nullptr;
             }
             value = this->coerce(std::move(value), *type);
         }
-        variables.push_back(var.get());
-        fSymbolTable->add(decl.fNames[i], std::move(var));
-        values.push_back(std::move(value));
+        if ("gl_FragCoord" == decl.fNames[i] && (*fSymbolTable)[decl.fNames[i]]) {
+            // already defined, just update the modifiers
+            Variable* old = (Variable*) (*fSymbolTable)[decl.fNames[i]];
+            old->fModifiers = var->fModifiers;
+        } else {
+            variables.push_back(var.get());
+            fSymbolTable->add(decl.fNames[i], std::move(var));
+            values.push_back(std::move(value));
+            sizes.push_back(std::move(currentVarSizes));
+        }
     }
     return std::unique_ptr<VarDeclaration>(new VarDeclaration(decl.fPosition, std::move(variables), 
                                                               std::move(sizes), std::move(values)));
 }
 
 std::unique_ptr<Statement> IRGenerator::convertIf(const ASTIfStatement& s) {
     std::unique_ptr<Expression> test = this->coerce(this->convertExpression(*s.fTest), 
                                                     *fContext.fBool_Type);
     if (!test) {
         return nullptr;
@@ skipping 358 matching lines @@
         case Symbol::kVariable_Kind: {
             const Variable* var = (const Variable*) result;
             this->markReadFrom(*var);
             return std::unique_ptr<VariableReference>(new VariableReference(identifier.fPosition,
                                                                             *var));
         }
         case Symbol::kField_Kind: {
             const Field* field = (const Field*) result;
             VariableReference* base = new VariableReference(identifier.fPosition, field->fOwner);
             return std::unique_ptr<Expression>(new FieldAccess(std::unique_ptr<Expression>(base),
-                                                               field->fFieldIndex));
+                                                               field->fFieldIndex,
+                                                               true));

[dogben, 2016/07/31 23:20:20]

nit: use enum, or "/*inAnonymousInterfaceBlock*/ true"

Same nit below.

[ethannicholas, 2016/08/02 16:13:18]

Done.

         }
         case Symbol::kType_Kind: {
             const Type* t = (const Type*) result;
             return std::unique_ptr<TypeReference>(new TypeReference(fContext, identifier.fPosition, 
                                                                     *t));
         }
         default:
             ABORT("unsupported symbol type %d\n", result->fKind);
     }
 
@@ skipping 56 matching lines @@
         case Token::LOGICALOREQ: // fall through
         case Token::LOGICALANDEQ: // fall through
         case Token::LOGICALXOREQ:
             *outLeftType = context.fBool_Type.get();
             *outRightType = context.fBool_Type.get();
             *outResultType = context.fBool_Type.get();
             return left.canCoerceTo(*context.fBool_Type) && 
                    right.canCoerceTo(*context.fBool_Type);
         case Token::STAR: // fall through
         case Token::STAREQ: 
-            // FIXME need to handle non-square matrices
             if (left.kind() == Type::kMatrix_Kind && right.kind() == Type::kVector_Kind) {
-                *outLeftType = &left;
-                *outRightType = &right;
-                *outResultType = &right;
-                return left.rows() == right.columns();
+                // determine final component type
+                if (determine_binary_type(context, Token::STAR, left.componentType(),
+                                          right.componentType(), outLeftType, outRightType,
+                                          outResultType, false)) {
+                    *outLeftType = &left;

[dogben, 2016/07/31 23:20:21]

Seems like you need *outLeftType = &(*outResultType)->toCompound(context,
left.columns(), left.rows()); and similarly for outRightType. I assume
SpvOpMatrixTimesVector doesn't work for dmat3 * vec3.

Same below.

[ethannicholas, 2016/08/02 16:13:18]

Completely reworked this.

+                    *outRightType = &right;
+                    *outResultType = &(*outResultType)->toCompound(context, left.rows(), 1);
+                    return left.rows() == right.columns();

[dogben, 2016/07/31 23:20:20]

Should be left.columns() == right.columns() because the vector is implicitly
transposed.

(Or maybe I'm confused, and it's implicitly transposed below, in which case you
would need left.columns() == right.columns() below.)

+                } else {
+                    return false;
+                }
             }  
             if (left.kind() == Type::kVector_Kind && right.kind() == Type::kMatrix_Kind) {
-                *outLeftType = &left;
-                *outRightType = &right;
-                *outResultType = &left;
-                return left.columns() == right.columns();
+                // determine final component type
+                if (determine_binary_type(context, Token::STAR, left.componentType(),
+                                          right.componentType(), outLeftType, outRightType,
+                                          outResultType, false)) {
+                    *outLeftType = &left;
+                    *outRightType = &right;
+                    *outResultType = &(*outResultType)->toCompound(context, right.columns(), 1);
+                    return left.columns() == right.rows();
+                } else {
+                    return false;
+                }
             }
             // fall through
         default:
             isLogical = false;
     }
     // FIXME: need to disallow illegal operations like vec3 > vec3. Also do not currently have
     // full support for numbers other than float.
     if (left == right) {
         *outLeftType = &left;
         *outRightType = &left;
@@ skipping 360 matching lines @@
     }
     return std::unique_ptr<Expression>(new IndexExpression(fContext, std::move(base), 
                                                            std::move(converted)));
 }
 
 std::unique_ptr<Expression> IRGenerator::convertField(std::unique_ptr<Expression> base,
                                                       const std::string& field) {
     auto fields = base->fType.fields();
     for (size_t i = 0; i < fields.size(); i++) {
         if (fields[i].fName == field) {
-            return std::unique_ptr<Expression>(new FieldAccess(std::move(base), (int) i));
+            return std::unique_ptr<Expression>(new FieldAccess(std::move(base), (int) i, false));
         }
     }
     fErrors.error(base->fPosition, "type '" + base->fType.description() + "' does not have a "
                                    "field named '" + field + "");
     return nullptr;
 }
 
 std::unique_ptr<Expression> IRGenerator::convertSwizzle(std::unique_ptr<Expression> base,
                                                         const std::string& fields) {
     if (base->fType.kind() != Type::kVector_Kind) {
@@ skipping 161 matching lines @@
         case Expression::kIndex_Kind:
             this->markWrittenTo(*((IndexExpression&) expr).fBase);
             break;
         default:
             fErrors.error(expr.fPosition, "cannot assign to '" + expr.description() + "'");
             break;
     }
 }
 
 }