Further work on the function emulation.

src/common/version.h

 #define MAJOR_VERSION 0
 #define MINOR_VERSION 0
 #define BUILD_VERSION 0
-#define BUILD_REVISION 753
+#define BUILD_REVISION 754
 
 #define STRINGIFY(x) #x
 #define MACRO_STRINGIFY(x) STRINGIFY(x)

src/compiler/BuiltInFunctionEmulator.h

@@ -13,23 +13,6 @@
 #include "compiler/intermediate.h"
 
 //
-// Built-in function groups.  We only list the ones that might need to be
-// emulated in certain os/drivers, assuming they are no more than 32.
-//
-enum TBuiltInFunctionGroup {
-    TFunctionGroupAbs            = 1 << 0,  // NVIDIA Win/Mac
-    TFunctionGroupAtan           = 1 << 1,  // NVIDIA Win/Mac
-    TFunctionGroupCos            = 1 << 2,  // ATI Mac
-    TFunctionGroupMod            = 1 << 3,  // NVIDIA Win/Mac
-    TFunctionGroupSign           = 1 << 4,  // NVIDIA Win/Mac
-    TFunctionGroupAll            = TFunctionGroupAbs |
-                                   TFunctionGroupAtan |
-                                   TFunctionGroupCos |
-                                   TFunctionGroupMod |
-                                   TFunctionGroupSign
-};
-
-//
 // This class decides which built-in functions need to be replaced with the
 // emulated ones.
 // It's only a workaround for OpenGL driver bugs, and isn't needed in general.
@@ -37,13 +20,6 @@ enum TBuiltInFunctionGroup {
 class BuiltInFunctionEmulator {
 public:
     BuiltInFunctionEmulator(ShShaderType shaderType);
-
-    // functionGroupMask is a bitmap of TBuiltInFunctionGroup.
-    // We only emulate functions that are marked by this mask and are actually
-    // called in a given shader.
-    // By default the value is TFunctionGroupAll.
-    void SetFunctionGroupMask(unsigned int functionGroupMask);
-
     // Records that a function is called by the shader and might needs to be
     // emulated.  If the function's group is not in mFunctionGroupFilter, this
     // becomes an no-op.
@@ -59,6 +35,8 @@ public:
 
     void MarkBuiltInFunctionsForEmulation(TIntermNode* root);
 
+    void Cleanup();
+
     // "name(" becomes "webgl_name_emu(".
     static TString GetEmulatedFunctionName(const TString& name);
 
@@ -67,16 +45,7 @@ private:
     // Built-in functions.
     //
     enum TBuiltInFunction {
-        TFunctionAbs1 = 0,  // float abs(float);
-        TFunctionAbs2,  // vec2 abs(vec2);
-        TFunctionAbs3,  // vec3 abs(vec3);
-        TFunctionAbs4,  // vec4 abs(vec4);
-
-        TFunctionAtan1,  // float atan(float);
-        TFunctionAtan2,  // vec2 atan(vec2);
-        TFunctionAtan3,  // vec3 atan(vec3);
-        TFunctionAtan4,  // vec4 atan(vec4);
-        TFunctionAtan1_1,  // float atan(float, float);
+        TFunctionAtan1_1 = 0,  // float atan(float, float);
         TFunctionAtan2_2,  // vec2 atan(vec2, vec2);
         TFunctionAtan3_3,  // vec3 atan(vec3, vec2);
         TFunctionAtan4_4,  // vec4 atan(vec4, vec2);
@@ -86,15 +55,36 @@ private:
         TFunctionCos3,  // vec3 cos(vec3);
         TFunctionCos4,  // vec4 cos(vec4);
 
+        TFunctionDistance1_1,  // float distance(float, float);
+        TFunctionDistance2_2,  // vec2 distance(vec2, vec2);
+        TFunctionDistance3_3,  // vec3 distance(vec3, vec3);
+        TFunctionDistance4_4,  // vec4 distance(vec4, vec4);
+
+        TFunctionDot1_1,  // float dot(float, float);
+        TFunctionDot2_2,  // vec2 dot(vec2, vec2);
+        TFunctionDot3_3,  // vec3 dot(vec3, vec3);
+        TFunctionDot4_4,  // vec4 dot(vec4, vec4);
+
+        TFunctionLength1,  // float length(float);
+        TFunctionLength2,  // float length(vec2);
+        TFunctionLength3,  // float length(vec3);
+        TFunctionLength4,  // float length(vec4);
+
         TFunctionMod1_1,  // float mod(float, float);
         TFunctionMod2_2,  // vec2 mod(vec2, vec2);
         TFunctionMod3_3,  // vec3 mod(vec3, vec3);
         TFunctionMod4_4,  // vec4 mod(vec4, vec4);
 
-        TFunctionSign1,  // float sign(float);
-        TFunctionSign2,  // vec2 sign(vec2);
-        TFunctionSign3,  // vec3 sign(vec3);
-        TFunctionSign4,  // vec4 sign(vec4);
+        TFunctionNormalize1,  // float normalize(float);
+        TFunctionNormalize2,  // vec2 normalize(vec2);
+        TFunctionNormalize3,  // vec3 normalize(vec3);
+        TFunctionNormalize4,  // vec4 normalize(vec4);
+
+        TFunctionReflect1_1,  // float reflect(float, float);
+        TFunctionReflect2_2,  // vec2 reflect(vec2, vec2);
+        TFunctionReflect3_3,  // vec3 reflect(vec3, vec3);
+        TFunctionReflect4_4,  // vec4 reflect(vec4, vec4);
+
         TFunctionUnknown
     };
 
@@ -105,9 +95,9 @@ private:
     bool SetFunctionCalled(TBuiltInFunction function);
 
     TVector<TBuiltInFunction> mFunctions;
-    unsigned int mFunctionGroupMask;  // a bitmap of TBuiltInFunctionGroup.
 
     const bool* mFunctionMask;  // a boolean flag for each function.
+    const char** mFunctionSource;
 };
 
 #endif  // COMPILIER_BUILT_IN_FUNCTION_EMULATOR_H_

src/compiler/Compiler.cpp

@@ -209,6 +209,8 @@ void TCompiler::clearResults()
 
     attribs.clear();
     uniforms.clear();
+
+    builtInFunctionEmulator.Cleanup();
 }
 
 bool TCompiler::detectRecursion(TIntermNode* root)