Upgrade ANGLE to 2.1~99f075dade7c

This aligns with Chromium branch 2356.

This version brings more complete OpenGL ES 3 support as well as various
bug fixes and performance improvements.

The following changes were made to earlier patches:

-0000-General-fixes-for-ANGLE-2.1
  Removed. All changes are now handled elsewhere.
+0001-ANGLE-Improve-Windows-Phone-support
  Consolidated remaining parts from 0009/0010.
+0002-ANGLE-Fix-compilation-with-MinGW
  Remaining issues from patch 0016.
+0003-ANGLE-Fix-compilation-with-MSVC2010
  Remaining issues from patch 0015.
+0004-ANGLE-Dynamically-load-D3D-compiler-from-list
  Renamed from patch 0008.
+0005-ANGLE-Add-support-for-querying-platform-device
  Renamed from patch 0013.
-0004-Make-it-possible-to-link-ANGLE-statically-for-single
  Removed. Fixed by adding defines to project files.
-0008-ANGLE-Dynamically-load-D3D-compiler-from-a-list-or-t
  Renamed to patch 0005.
-0009-ANGLE-Support-WinRT
  Removed. Mostly fixed upstream; remaining parts in patch 0001.
-0010-ANGLE-Enable-D3D11-for-feature-level-9-cards
  Removed. Mostly fixed upstream; remaining parts in patch 0001.
-0012-ANGLE-fix-semantic-index-lookup
  Removed. Fixed upstream.
-0013-ANGLE-Add-support-for-querying-platform-device
  Renamed to patch 0005.
-0014-Let-ANGLE-use-multithreaded-devices-if-necessary
  Removed. No longer needed.
-0015-ANGLE-Fix-angle-d3d11-on-MSVC2010
  Moved remaining parts to patch 0003.
-0016-ANGLE-Fix-compilation-with-MinGW-D3D11
  Moved remaining parts to patch 0002.
-0017-ANGLE-Fix-compilation-with-D3D9
  Removed. Fixed upstream.
-0018-ANGLE-Fix-releasing-textures-after-we-kill-D3D11
  Removed. Fixed upstream.
-0019-ANGLE-Fix-handling-of-shader-source-with-fixed-lengt
  Removed. Fixed upstream.
-0020-ANGLE-Do-not-use-std-strlen
  Removed. Fixed upstream.
-0020-ANGLE-Fix-compilation-with-MSVC2013-Update4
  Removed. Fixed upstream.

[ChangeLog][Third-party libraries] ANGLE was updated to Chromium branch
2356 (2.1~99f075dade7c).

Change-Id: I32ccbfe95e10986bd94be7191dfd53445ea09158
Task-number: QTBUG-44815
Task-number: QTBUG-37660
Task-number: QTBUG-44694
Task-number: QTBUG-42443
Reviewed-by: Andrew Knight <qt@panimo.net>
Reviewed-by: Friedemann Kleint <Friedemann.Kleint@theqtcompany.com>

1 files changed, 195 insertions, 0 deletions

diff --git a/src/3rdparty/angle/src/compiler/translator/Operator.cpp b/src/3rdparty/angle/src/compiler/translator/Operator.cpp
new file mode 100644
index 0000000000..ae4512bd44
--- /dev/null
+++ b/src/3rdparty/angle/src/compiler/translator/Operator.cpp
@@ -0,0 +1,195 @@
+//
+// Copyright (c) 2002-2015 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/Operator.h"
+
+const char *GetOperatorString(TOperator op)
+{
+    switch (op)
+    {
+      // Note: ops from EOpNull to EOpPrototype can't be handled here.
+
+      case EOpNegative: return "-";
+      case EOpPositive: return "+";
+      case EOpLogicalNot: return "!";
+      case EOpVectorLogicalNot: return "not";
+      case EOpBitwiseNot: return "~";
+
+      case EOpPostIncrement: return "++";
+      case EOpPostDecrement: return "--";
+      case EOpPreIncrement: return "++";
+      case EOpPreDecrement: return "--";
+
+      case EOpAdd: return "+";
+      case EOpSub: return "-";
+      case EOpMul: return "*";
+      case EOpDiv: return "/";
+      case EOpIMod: return "%";
+      case EOpEqual: return "==";
+      case EOpNotEqual: return "!=";
+      case EOpVectorEqual: return "equal";
+      case EOpVectorNotEqual: return "notEqual";
+      case EOpLessThan: return "<";
+      case EOpGreaterThan: return ">";
+      case EOpLessThanEqual: return "<=";
+      case EOpGreaterThanEqual: return ">=";
+      case EOpComma: return ",";
+
+      // Fall-through.
+      case EOpVectorTimesScalar:
+      case EOpVectorTimesMatrix:
+      case EOpMatrixTimesVector:
+      case EOpMatrixTimesScalar: return "*";
+
+      case EOpLogicalOr: return "||";
+      case EOpLogicalXor: return "^^";
+      case EOpLogicalAnd: return "&&";
+
+      case EOpBitShiftLeft: return "<<";
+      case EOpBitShiftRight: return ">>";
+
+      case EOpBitwiseAnd: return "&";
+      case EOpBitwiseXor: return "^";
+      case EOpBitwiseOr: return "|";
+
+      // Fall-through.
+      case EOpIndexDirect:
+      case EOpIndexIndirect: return "[]";
+
+      case EOpIndexDirectStruct:
+      case EOpIndexDirectInterfaceBlock: return ".";
+
+      case EOpVectorSwizzle: return ".";
+
+      case EOpRadians: return "radians";
+      case EOpDegrees: return "degrees";
+      case EOpSin: return "sin";
+      case EOpCos: return "cos";
+      case EOpTan: return "tan";
+      case EOpAsin: return "asin";
+      case EOpAcos: return "acos";
+      case EOpAtan: return "atan";
+
+      case EOpSinh: return "sinh";
+      case EOpCosh: return "cosh";
+      case EOpTanh: return "tanh";
+      case EOpAsinh: return "asinh";
+      case EOpAcosh: return "acosh";
+      case EOpAtanh: return "atanh";
+
+      case EOpPow: return "pow";
+      case EOpExp: return "exp";
+      case EOpLog: return "log";
+      case EOpExp2: return "exp2";
+      case EOpLog2: return "log2";
+      case EOpSqrt: return "sqrt";
+      case EOpInverseSqrt: return "inversesqrt";
+
+      case EOpAbs: return "abs";
+      case EOpSign: return "sign";
+      case EOpFloor: return "floor";
+      case EOpTrunc: return "trunc";
+      case EOpRound: return "round";
+      case EOpRoundEven: return "roundEven";
+      case EOpCeil: return "ceil";
+      case EOpFract: return "fract";
+      case EOpMod: return "mod";
+      case EOpModf: return "modf";
+      case EOpMin: return "min";
+      case EOpMax: return "max";
+      case EOpClamp: return "clamp";
+      case EOpMix: return "mix";
+      case EOpStep: return "step";
+      case EOpSmoothStep: return "smoothstep";
+      case EOpIsNan: return "isnan";
+      case EOpIsInf: return "isinf";
+
+      case EOpFloatBitsToInt: return "floatBitsToInt";
+      case EOpFloatBitsToUint: return "floatBitsToUint";
+      case EOpIntBitsToFloat: return "intBitsToFloat";
+      case EOpUintBitsToFloat: return "uintBitsToFloat";
+
+      case EOpPackSnorm2x16: return "packSnorm2x16";
+      case EOpPackUnorm2x16: return "packUnorm2x16";
+      case EOpPackHalf2x16: return "packHalf2x16";
+      case EOpUnpackSnorm2x16: return "unpackSnorm2x16";
+      case EOpUnpackUnorm2x16: return "unpackUnorm2x16";
+      case EOpUnpackHalf2x16: return "unpackHalf2x16";
+
+      case EOpLength: return "length";
+      case EOpDistance: return "distance";
+      case EOpDot: return "dot";
+      case EOpCross: return "cross";
+      case EOpNormalize: return "normalize";
+      case EOpFaceForward: return "faceforward";
+      case EOpReflect: return "reflect";
+      case EOpRefract: return "refract";
+
+      case EOpDFdx: return "dFdx";
+      case EOpDFdy: return "dFdy";
+      case EOpFwidth: return "fwidth";
+
+      case EOpMatrixTimesMatrix: return "*";
+
+      case EOpOuterProduct: return "outerProduct";
+      case EOpTranspose: return "transpose";
+      case EOpDeterminant: return "determinant";
+      case EOpInverse: return "inverse";
+
+      case EOpAny: return "any";
+      case EOpAll: return "all";
+
+      case EOpKill: return "kill";
+      case EOpReturn: return "return";
+      case EOpBreak: return "break";
+      case EOpContinue: return "continue";
+
+      case EOpConstructInt: return "int";
+      case EOpConstructUInt: return "uint";
+      case EOpConstructBool: return "bool";
+      case EOpConstructFloat: return "float";
+      case EOpConstructVec2: return "vec2";
+      case EOpConstructVec3: return "vec3";
+      case EOpConstructVec4: return "vec4";
+      case EOpConstructBVec2: return "bvec2";
+      case EOpConstructBVec3: return "bvec3";
+      case EOpConstructBVec4: return "bvec4";
+      case EOpConstructIVec2: return "ivec2";
+      case EOpConstructIVec3: return "ivec3";
+      case EOpConstructIVec4: return "ivec4";
+      case EOpConstructUVec2: return "uvec2";
+      case EOpConstructUVec3: return "uvec3";
+      case EOpConstructUVec4: return "uvec4";
+      case EOpConstructMat2: return "mat2";
+      case EOpConstructMat3: return "mat3";
+      case EOpConstructMat4: return "mat4";
+      // Note: EOpConstructStruct can't be handled here
+
+      case EOpAssign: return "=";
+      case EOpInitialize: return "=";
+      case EOpAddAssign: return "+=";
+      case EOpSubAssign: return "-=";
+
+      // Fall-through.
+      case EOpMulAssign:
+      case EOpVectorTimesMatrixAssign:
+      case EOpVectorTimesScalarAssign:
+      case EOpMatrixTimesScalarAssign:
+      case EOpMatrixTimesMatrixAssign: return "*=";
+
+      case EOpDivAssign: return "/=";
+      case EOpIModAssign: return "%=";
+      case EOpBitShiftLeftAssign: return "<<=";
+      case EOpBitShiftRightAssign: return ">>=";
+      case EOpBitwiseAndAssign: return "&=";
+      case EOpBitwiseXorAssign: return "^=";
+      case EOpBitwiseOrAssign: return "|=";
+
+      default: break;
+    }
+    return "";
+}
+