LCOV - app.info - gfx/angle/src/compiler/VariableInfo.cpp

LCOV - code coverage report
| Current view: | directory - gfx/angle/src/compiler - VariableInfo.cpp (source / functions) |  | Found | Hit | Coverage |
| Test: | app.info | Lines: | 111 | 0 | 0.0 %
| Date: | 2012-07-07 | Functions: | 14 | 0 | 0.0 %

           1                 : //
           2                 : // Copyright (c) 2002-2010 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/VariableInfo.h"
           8                 :
           9               0 : static TString arrayBrackets(int index)
          10                 : {
          11               0 :     TStringStream stream;
          12               0 :     stream << "[" << index << "]";
          13               0 :     return stream.str();
          14                 : }
          15                 :
          16                 : // Returns the data type for an attribute or uniform.
          17               0 : static ShDataType getVariableDataType(const TType& type)
          18                 : {
          19               0 :     switch (type.getBasicType()) {
          20                 :       case EbtFloat:
          21               0 :           if (type.isMatrix()) {
          22               0 :               switch (type.getNominalSize()) {
          23               0 :                 case 2: return SH_FLOAT_MAT2;
          24               0 :                 case 3: return SH_FLOAT_MAT3;
          25               0 :                 case 4: return SH_FLOAT_MAT4;
          26               0 :                 default: UNREACHABLE();
          27                 :               }
          28               0 :           } else if (type.isVector()) {
          29               0 :               switch (type.getNominalSize()) {
          30               0 :                 case 2: return SH_FLOAT_VEC2;
          31               0 :                 case 3: return SH_FLOAT_VEC3;
          32               0 :                 case 4: return SH_FLOAT_VEC4;
          33               0 :                 default: UNREACHABLE();
          34                 :               }
          35                 :           } else {
          36               0 :               return SH_FLOAT;
          37                 :           }
          38                 :       case EbtInt:
          39               0 :           if (type.isMatrix()) {
          40               0 :               UNREACHABLE();
          41               0 :           } else if (type.isVector()) {
          42               0 :               switch (type.getNominalSize()) {
          43               0 :                 case 2: return SH_INT_VEC2;
          44               0 :                 case 3: return SH_INT_VEC3;
          45               0 :                 case 4: return SH_INT_VEC4;
          46               0 :                 default: UNREACHABLE();
          47                 :               }
          48                 :           } else {
          49               0 :               return SH_INT;
          50                 :           }
          51                 :       case EbtBool:
          52               0 :           if (type.isMatrix()) {
          53               0 :               UNREACHABLE();
          54               0 :           } else if (type.isVector()) {
          55               0 :               switch (type.getNominalSize()) {
          56               0 :                 case 2: return SH_BOOL_VEC2;
          57               0 :                 case 3: return SH_BOOL_VEC3;
          58               0 :                 case 4: return SH_BOOL_VEC4;
          59               0 :                 default: UNREACHABLE();
          60                 :               }
          61                 :           } else {
          62               0 :               return SH_BOOL;
          63                 :           }
          64               0 :       case EbtSampler2D: return SH_SAMPLER_2D;
          65               0 :       case EbtSamplerCube: return SH_SAMPLER_CUBE;
          66               0 :       case EbtSamplerExternalOES: return SH_SAMPLER_EXTERNAL_OES;
          67               0 :       case EbtSampler2DRect: return SH_SAMPLER_2D_RECT_ARB;
          68               0 :       default: UNREACHABLE();
          69                 :     }
          70                 :     return SH_NONE;
          71                 : }
          72                 :
          73                 : static void getBuiltInVariableInfo(const TType& type,
          74                 :                                    const TString& name,
          75                 :                                    const TString& mappedName,
          76                 :                                    TVariableInfoList& infoList);
          77                 : static void getUserDefinedVariableInfo(const TType& type,
          78                 :                                        const TString& name,
          79                 :                                        const TString& mappedName,
          80                 :                                        TVariableInfoList& infoList);
          81                 :
          82                 : // Returns info for an attribute or uniform.
          83               0 : static void getVariableInfo(const TType& type,
          84                 :                             const TString& name,
          85                 :                             const TString& mappedName,
          86                 :                             TVariableInfoList& infoList)
          87                 : {
          88               0 :     if (type.getBasicType() == EbtStruct) {
          89               0 :         if (type.isArray()) {
          90               0 :             for (int i = 0; i < type.getArraySize(); ++i) {
          91               0 :                 TString lname = name + arrayBrackets(i);
          92               0 :                 TString lmappedName = mappedName + arrayBrackets(i);
          93               0 :                 getUserDefinedVariableInfo(type, lname, lmappedName, infoList);
          94                 :             }
          95                 :         } else {
          96               0 :             getUserDefinedVariableInfo(type, name, mappedName, infoList);
          97                 :         }
          98                 :     } else {
          99               0 :         getBuiltInVariableInfo(type, name, mappedName, infoList);
         100                 :     }
         101               0 : }
         102                 :
         103               0 : void getBuiltInVariableInfo(const TType& type,
         104                 :                             const TString& name,
         105                 :                             const TString& mappedName,
         106                 :                             TVariableInfoList& infoList)
         107                 : {
         108               0 :     ASSERT(type.getBasicType() != EbtStruct);
         109                 :
         110               0 :     TVariableInfo varInfo;
         111               0 :     if (type.isArray()) {
         112               0 :         varInfo.name = (name + "[0]").c_str();
         113               0 :         varInfo.mappedName = (mappedName + "[0]").c_str();
         114               0 :         varInfo.size = type.getArraySize();
         115                 :     } else {
         116               0 :         varInfo.name = name.c_str();
         117               0 :         varInfo.mappedName = mappedName.c_str();
         118               0 :         varInfo.size = 1;
         119                 :     }
         120               0 :     varInfo.type = getVariableDataType(type);
         121               0 :     infoList.push_back(varInfo);
         122               0 : }
         123                 :
         124               0 : void getUserDefinedVariableInfo(const TType& type,
         125                 :                                 const TString& name,
         126                 :                                 const TString& mappedName,
         127                 :                                 TVariableInfoList& infoList)
         128                 : {
         129               0 :     ASSERT(type.getBasicType() == EbtStruct);
         130                 :
         131               0 :     const TTypeList* structure = type.getStruct();
         132               0 :     for (size_t i = 0; i < structure->size(); ++i) {
         133               0 :         const TType* fieldType = (*structure)[i].type;
         134                 :         getVariableInfo(*fieldType,
         135               0 :                         name + "." + fieldType->getFieldName(),
         136               0 :                         mappedName + "." + fieldType->getFieldName(),
         137               0 :                         infoList);
         138                 :     }
         139               0 : }
         140                 :
         141               0 : CollectAttribsUniforms::CollectAttribsUniforms(TVariableInfoList& attribs,
         142                 :                                                TVariableInfoList& uniforms)
         143                 :     : mAttribs(attribs),
         144               0 :       mUniforms(uniforms)
         145                 : {
         146               0 : }
         147                 :
         148                 : // We are only interested in attribute and uniform variable declaration.
         149               0 : void CollectAttribsUniforms::visitSymbol(TIntermSymbol*)
         150                 : {
         151               0 : }
         152                 :
         153               0 : void CollectAttribsUniforms::visitConstantUnion(TIntermConstantUnion*)
         154                 : {
         155               0 : }
         156                 :
         157               0 : bool CollectAttribsUniforms::visitBinary(Visit, TIntermBinary*)
         158                 : {
         159               0 :     return false;
         160                 : }
         161                 :
         162               0 : bool CollectAttribsUniforms::visitUnary(Visit, TIntermUnary*)
         163                 : {
         164               0 :     return false;
         165                 : }
         166                 :
         167               0 : bool CollectAttribsUniforms::visitSelection(Visit, TIntermSelection*)
         168                 : {
         169               0 :     return false;
         170                 : }
         171                 :
         172               0 : bool CollectAttribsUniforms::visitAggregate(Visit, TIntermAggregate* node)
         173                 : {
         174               0 :     bool visitChildren = false;
         175                 :
         176               0 :     switch (node->getOp())
         177                 :     {
         178                 :     case EOpSequence:
         179                 :         // We need to visit sequence children to get to variable declarations.
         180               0 :         visitChildren = true;
         181               0 :         break;
         182                 :     case EOpDeclaration: {
         183               0 :         const TIntermSequence& sequence = node->getSequence();
         184               0 :         TQualifier qualifier = sequence.front()->getAsTyped()->getQualifier();
         185               0 :         if (qualifier == EvqAttribute || qualifier == EvqUniform)
         186                 :         {
         187                 :             TVariableInfoList& infoList = qualifier == EvqAttribute ?
         188               0 :                 mAttribs : mUniforms;
         189               0 :             for (TIntermSequence::const_iterator i = sequence.begin();
         190               0 :                  i != sequence.end(); ++i)
         191                 :             {
         192               0 :                 const TIntermSymbol* variable = (*i)->getAsSymbolNode();
         193                 :                 // The only case in which the sequence will not contain a
         194                 :                 // TIntermSymbol node is initialization. It will contain a
         195                 :                 // TInterBinary node in that case. Since attributes and unifroms
         196                 :                 // cannot be initialized in a shader, we must have only
         197                 :                 // TIntermSymbol nodes in the sequence.
         198               0 :                 ASSERT(variable != NULL);
         199               0 :                 getVariableInfo(variable->getType(),
         200               0 :                                 variable->getOriginalSymbol(),
         201               0 :                                 variable->getSymbol(),
         202               0 :                                 infoList);
         203                 :             }
         204                 :         }
         205               0 :         break;
         206                 :     }
         207               0 :     default: break;
         208                 :     }
         209                 :
         210               0 :     return visitChildren;
         211                 : }
         212                 :
         213               0 : bool CollectAttribsUniforms::visitLoop(Visit, TIntermLoop*)
         214                 : {
         215               0 :     return false;
         216                 : }
         217                 :
         218               0 : bool CollectAttribsUniforms::visitBranch(Visit, TIntermBranch*)
         219                 : {
         220               0 :     return false;
         221                 : }
         222                 :

Generated by: LCOV version 1.7