Home | History | Annotate | Download | only in compiler 
      1 //
      2 // Copyright (c) 2002-2012 The ANGLE Project Authors. All rights reserved.
      3 // Use of this source code is governed by a BSD-style license that can be
      4 // found in the LICENSE file.
      5 //
      6 
      7 #include "compiler/VersionGLSL.h"
      8 
      9 static const int GLSL_VERSION_110 = 110;
     10 static const int GLSL_VERSION_120 = 120;
     11 
     12 // We need to scan for the following:
     13 // 1. "invariant" keyword: This can occur in both - vertex and fragment shaders
     14 //    but only at the global scope.
     15 // 2. "gl_PointCoord" built-in variable: This can only occur in fragment shader
     16 //    but inside any scope.
     17 // 3. Call to a matrix constructor with another matrix as argument.
     18 //    (These constructors were reserved in GLSL version 1.10.)
     19 // 4. Arrays as "out" function parameters.
     20 //    GLSL spec section 6.1.1: "When calling a function, expressions that do
     21 //    not evaluate to l-values cannot be passed to parameters declared as
     22 //    out or inout."
     23 //    GLSL 1.1 section 5.8: "Other binary or unary expressions,
     24 //    non-dereferenced arrays, function names, swizzles with repeated fields,
     25 //    and constants cannot be l-values."
     26 //    GLSL 1.2 relaxed the restriction on arrays, section 5.8: "Variables that
     27 //    are built-in types, entire structures or arrays... are all l-values."
     28 //
     29 // TODO(alokp): The following two cases of invariant decalaration get lost
     30 // during parsing - they do not get carried over to the intermediate tree.
     31 // Handle these cases:
     32 // 1. When a pragma is used to force all output variables to be invariant:
     33 //    - #pragma STDGL invariant(all)
     34 // 2. When a previously decalared or built-in variable is marked invariant:
     35 //    - invariant gl_Position;
     36 //    - varying vec3 color; invariant color;
     37 //
     38 TVersionGLSL::TVersionGLSL(ShShaderType type)
     39     : mShaderType(type),
     40       mVersion(GLSL_VERSION_110)
     41 {
     42 }
     43 
     44 void TVersionGLSL::visitSymbol(TIntermSymbol* node)
     45 {
     46     if (node->getSymbol() == "gl_PointCoord")
     47         updateVersion(GLSL_VERSION_120);
     48 }
     49 
     50 void TVersionGLSL::visitConstantUnion(TIntermConstantUnion*)
     51 {
     52 }
     53 
     54 bool TVersionGLSL::visitBinary(Visit, TIntermBinary*)
     55 {
     56     return true;
     57 }
     58 
     59 bool TVersionGLSL::visitUnary(Visit, TIntermUnary*)
     60 {
     61     return true;
     62 }
     63 
     64 bool TVersionGLSL::visitSelection(Visit, TIntermSelection*)
     65 {
     66     return true;
     67 }
     68 
     69 bool TVersionGLSL::visitAggregate(Visit, TIntermAggregate* node)
     70 {
     71     bool visitChildren = true;
     72 
     73     switch (node->getOp()) {
     74       case EOpSequence:
     75         // We need to visit sequence children to get to global or inner scope.
     76         visitChildren = true;
     77         break;
     78       case EOpDeclaration: {
     79         const TIntermSequence& sequence = node->getSequence();
     80         TQualifier qualifier = sequence.front()->getAsTyped()->getQualifier();
     81         if ((qualifier == EvqInvariantVaryingIn) ||
     82             (qualifier == EvqInvariantVaryingOut)) {
     83             updateVersion(GLSL_VERSION_120);
     84         }
     85         break;
     86       }
     87       case EOpParameters: {
     88         const TIntermSequence& params = node->getSequence();
     89         for (TIntermSequence::const_iterator iter = params.begin();
     90              iter != params.end(); ++iter)
     91         {
     92             const TIntermTyped* param = (*iter)->getAsTyped();
     93             if (param->isArray())
     94             {
     95                 TQualifier qualifier = param->getQualifier();
     96                 if ((qualifier == EvqOut) || (qualifier ==  EvqInOut))
     97                 {
     98                     updateVersion(GLSL_VERSION_120);
     99                     break;
    100                 }
    101             }
    102         }
    103         // Fully processed. No need to visit children.
    104         visitChildren = false;
    105         break;
    106       }
    107       case EOpConstructMat2:
    108       case EOpConstructMat3:
    109       case EOpConstructMat4: {
    110         const TIntermSequence& sequence = node->getSequence();
    111         if (sequence.size() == 1) {
    112           TIntermTyped* typed = sequence.front()->getAsTyped();
    113           if (typed && typed->isMatrix()) {
    114             updateVersion(GLSL_VERSION_120);
    115           }
    116         }
    117         break;
    118       }
    119 
    120       default: break;
    121     }
    122 
    123     return visitChildren;
    124 }
    125 
    126 bool TVersionGLSL::visitLoop(Visit, TIntermLoop*)
    127 {
    128     return true;
    129 }
    130 
    131 bool TVersionGLSL::visitBranch(Visit, TIntermBranch*)
    132 {
    133     return true;
    134 }
    135 
    136 void TVersionGLSL::updateVersion(int version)
    137 {
    138     mVersion = std::max(version, mVersion);
    139 }
    140 
    141