kc3-lang/angle/src/compiler/translator/util.cpp

• Show log

  Commit

• Hash : f541f529
  Author :
  Date : 2015-10-13T12:21:01
  

  Fix parsing integers larger than 0x7FFFFFFF
  
  Parsing should accept all values between 0 and 0xFFFFFFFF as specified in
  ESSL 3.00 section 4.1.3.
  
  When a signed literal is parsed, it's interpreted as if it specifies the
  bit pattern of a two's complement integer. For example, parsing
  "0xFFFFFFFF" results in -1. Decimal literals behave the same way, so for
  example parsing "3000000000" results in -1294967296.
  
  This change affects parsing of literals in ESSL 1.00 as well. In ESSL
  3.00, an out-of-range integer literal now generates a compiler error.
  
  Unit tests are added based on examples in the ESSL 3.00 spec and one
  example in GLSL 4.5 spec that ESSL should match.
  
  BUG=541550
  TEST=angle_unittests
  
  Change-Id: I82f8ef5cfa2881019a3f80d77ff99707d61c000d
  Reviewed-on: https://chromium-review.googlesource.com/305420
  Reviewed-by: Zhenyao Mo <zmo@chromium.org>
  Tested-by: Olli Etuaho <oetuaho@nvidia.com>
  Reviewed-by: Corentin Wallez <cwallez@google.com>
  

Download

• src/compiler/translator/util.cpp

• //
  // Copyright (c) 2010 The ANGLE Project Authors. All rights reserved.
  // Use of this source code is governed by a BSD-style license that can be
  // found in the LICENSE file.
  //
  
  #include "compiler/translator/util.h"
  
  #include <limits>
  
  #include "compiler/preprocessor/numeric_lex.h"
  #include "compiler/translator/SymbolTable.h"
  #include "common/utilities.h"
  
  bool strtof_clamp(const std::string &str, float *value)
  {
      bool success = pp::numeric_lex_float(str, value);
      if (!success)
          *value = std::numeric_limits<float>::max();
      return success;
  }
  
  bool atoi_clamp(const char *str, unsigned int *value)
  {
      bool success = pp::numeric_lex_int(str, value);
      if (!success)
          *value = std::numeric_limits<unsigned int>::max();
      return success;
  }
  
  namespace sh
  {
  
  GLenum GLVariableType(const TType &type)
  {
      if (type.getBasicType() == EbtFloat)
      {
          if (type.isScalar())
          {
              return GL_FLOAT;
          }
          else if (type.isVector())
          {
              switch (type.getNominalSize())
              {
                case 2: return GL_FLOAT_VEC2;
                case 3: return GL_FLOAT_VEC3;
                case 4: return GL_FLOAT_VEC4;
                default: UNREACHABLE();
              }
          }
          else if (type.isMatrix())
          {
              switch (type.getCols())
              {
                case 2:
                  switch (type.getRows())
                  {
                    case 2: return GL_FLOAT_MAT2;
                    case 3: return GL_FLOAT_MAT2x3;
                    case 4: return GL_FLOAT_MAT2x4;
                    default: UNREACHABLE();
                  }
  
                case 3:
                  switch (type.getRows())
                  {
                    case 2: return GL_FLOAT_MAT3x2;
                    case 3: return GL_FLOAT_MAT3;
                    case 4: return GL_FLOAT_MAT3x4;
                    default: UNREACHABLE();
                  }
  
                case 4:
                  switch (type.getRows())
                  {
                    case 2: return GL_FLOAT_MAT4x2;
                    case 3: return GL_FLOAT_MAT4x3;
                    case 4: return GL_FLOAT_MAT4;
                    default: UNREACHABLE();
                  }
  
                default: UNREACHABLE();
              }
          }
          else UNREACHABLE();
      }
      else if (type.getBasicType() == EbtInt)
      {
          if (type.isScalar())
          {
              return GL_INT;
          }
          else if (type.isVector())
          {
              switch (type.getNominalSize())
              {
                case 2: return GL_INT_VEC2;
                case 3: return GL_INT_VEC3;
                case 4: return GL_INT_VEC4;
                default: UNREACHABLE();
              }
          }
          else UNREACHABLE();
      }
      else if (type.getBasicType() == EbtUInt)
      {
          if (type.isScalar())
          {
              return GL_UNSIGNED_INT;
          }
          else if (type.isVector())
          {
              switch (type.getNominalSize())
              {
                case 2: return GL_UNSIGNED_INT_VEC2;
                case 3: return GL_UNSIGNED_INT_VEC3;
                case 4: return GL_UNSIGNED_INT_VEC4;
                default: UNREACHABLE();
              }
          }
          else UNREACHABLE();
      }
      else if (type.getBasicType() == EbtBool)
      {
          if (type.isScalar())
          {
              return GL_BOOL;
          }
          else if (type.isVector())
          {
              switch (type.getNominalSize())
              {
                case 2: return GL_BOOL_VEC2;
                case 3: return GL_BOOL_VEC3;
                case 4: return GL_BOOL_VEC4;
                default: UNREACHABLE();
              }
          }
          else UNREACHABLE();
      }
  
      switch (type.getBasicType())
      {
        case EbtSampler2D:            return GL_SAMPLER_2D;
        case EbtSampler3D:            return GL_SAMPLER_3D;
        case EbtSamplerCube:          return GL_SAMPLER_CUBE;
        case EbtSamplerExternalOES:   return GL_SAMPLER_EXTERNAL_OES;
        case EbtSampler2DRect:        return GL_SAMPLER_2D_RECT_ARB;
        case EbtSampler2DArray:       return GL_SAMPLER_2D_ARRAY;
        case EbtISampler2D:           return GL_INT_SAMPLER_2D;
        case EbtISampler3D:           return GL_INT_SAMPLER_3D;
        case EbtISamplerCube:         return GL_INT_SAMPLER_CUBE;
        case EbtISampler2DArray:      return GL_INT_SAMPLER_2D_ARRAY;
        case EbtUSampler2D:           return GL_UNSIGNED_INT_SAMPLER_2D;
        case EbtUSampler3D:           return GL_UNSIGNED_INT_SAMPLER_3D;
        case EbtUSamplerCube:         return GL_UNSIGNED_INT_SAMPLER_CUBE;
        case EbtUSampler2DArray:      return GL_UNSIGNED_INT_SAMPLER_2D_ARRAY;
        case EbtSampler2DShadow:      return GL_SAMPLER_2D_SHADOW;
        case EbtSamplerCubeShadow:    return GL_SAMPLER_CUBE_SHADOW;
        case EbtSampler2DArrayShadow: return GL_SAMPLER_2D_ARRAY_SHADOW;
        default: UNREACHABLE();
      }
  
      return GL_NONE;
  }
  
  GLenum GLVariablePrecision(const TType &type)
  {
      if (type.getBasicType() == EbtFloat)
      {
          switch (type.getPrecision())
          {
            case EbpHigh:
              return GL_HIGH_FLOAT;
            case EbpMedium:
              return GL_MEDIUM_FLOAT;
            case EbpLow:
              return GL_LOW_FLOAT;
            case EbpUndefined:
            // Should be defined as the default precision by the parser
            default:
              UNREACHABLE();
          }
      }
      else if (type.getBasicType() == EbtInt || type.getBasicType() == EbtUInt)
      {
          switch (type.getPrecision())
          {
            case EbpHigh:
              return GL_HIGH_INT;
            case EbpMedium:
              return GL_MEDIUM_INT;
            case EbpLow:
              return GL_LOW_INT;
            case EbpUndefined:
            // Should be defined as the default precision by the parser
            default:
              UNREACHABLE();
          }
      }
  
      // Other types (boolean, sampler) don't have a precision
      return GL_NONE;
  }
  
  TString ArrayString(const TType &type)
  {
      if (!type.isArray())
      {
          return "";
      }
  
      return "[" + str(type.getArraySize()) + "]";
  }
  
  bool IsVaryingOut(TQualifier qualifier)
  {
      switch (qualifier)
      {
        case EvqVaryingOut:
        case EvqSmoothOut:
        case EvqFlatOut:
        case EvqCentroidOut:
        case EvqVertexOut:
          return true;
  
        default: break;
      }
  
      return false;
  }
  
  bool IsVaryingIn(TQualifier qualifier)
  {
      switch (qualifier)
      {
        case EvqVaryingIn:
        case EvqSmoothIn:
        case EvqFlatIn:
        case EvqCentroidIn:
        case EvqFragmentIn:
          return true;
  
        default: break;
      }
  
      return false;
  }
  
  bool IsVarying(TQualifier qualifier)
  {
      return IsVaryingIn(qualifier) || IsVaryingOut(qualifier);
  }
  
  InterpolationType GetInterpolationType(TQualifier qualifier)
  {
      switch (qualifier)
      {
        case EvqFlatIn:
        case EvqFlatOut:
          return INTERPOLATION_FLAT;
  
        case EvqSmoothIn:
        case EvqSmoothOut:
        case EvqVertexOut:
        case EvqFragmentIn:
        case EvqVaryingIn:
        case EvqVaryingOut:
          return INTERPOLATION_SMOOTH;
  
        case EvqCentroidIn:
        case EvqCentroidOut:
          return INTERPOLATION_CENTROID;
  
        default: UNREACHABLE();
          return INTERPOLATION_SMOOTH;
      }
  }
  
  GetVariableTraverser::GetVariableTraverser(const TSymbolTable &symbolTable)
      : mSymbolTable(symbolTable)
  {
  }
  
  template void GetVariableTraverser::setTypeSpecificInfo(
      const TType &type, const TString& name, InterfaceBlockField *variable);
  template void GetVariableTraverser::setTypeSpecificInfo(
      const TType &type, const TString& name, ShaderVariable *variable);
  template void GetVariableTraverser::setTypeSpecificInfo(
      const TType &type, const TString& name, Uniform *variable);
  
  template<>
  void GetVariableTraverser::setTypeSpecificInfo(
      const TType &type, const TString& name, Varying *variable)
  {
      ASSERT(variable);
      switch (type.getQualifier())
      {
        case EvqVaryingIn:
        case EvqVaryingOut:
        case EvqVertexOut:
        case EvqSmoothOut:
        case EvqFlatOut:
        case EvqCentroidOut:
          if (mSymbolTable.isVaryingInvariant(std::string(name.c_str())) || type.isInvariant())
          {
              variable->isInvariant = true;
          }
          break;
        default:
          break;
      }
  
      variable->interpolation = GetInterpolationType(type.getQualifier());
  }
  
  template <typename VarT>
  void GetVariableTraverser::traverse(const TType &type,
                                      const TString &name,
                                      std::vector<VarT> *output)
  {
      const TStructure *structure = type.getStruct();
  
      VarT variable;
      variable.name = name.c_str();
      variable.arraySize = static_cast<unsigned int>(type.getArraySize());
  
      if (!structure)
      {
          variable.type = GLVariableType(type);
          variable.precision = GLVariablePrecision(type);
      }
      else
      {
          // Note: this enum value is not exposed outside ANGLE
          variable.type = GL_STRUCT_ANGLEX;
          variable.structName = structure->name().c_str();
  
          const TFieldList &fields = structure->fields();
  
          for (size_t fieldIndex = 0; fieldIndex < fields.size(); fieldIndex++)
          {
              TField *field = fields[fieldIndex];
              traverse(*field->type(), field->name(), &variable.fields);
          }
      }
      setTypeSpecificInfo(type, name, &variable);
      visitVariable(&variable);
  
      ASSERT(output);
      output->push_back(variable);
  }
  
  template void GetVariableTraverser::traverse(const TType &, const TString &, std::vector<InterfaceBlockField> *);
  template void GetVariableTraverser::traverse(const TType &, const TString &, std::vector<ShaderVariable> *);
  template void GetVariableTraverser::traverse(const TType &, const TString &, std::vector<Uniform> *);
  template void GetVariableTraverser::traverse(const TType &, const TString &, std::vector<Varying> *);
  
  }
  

Download