Capture/Replay: Capture entry point enum when possible.

scripts/code_generation_hashes/GL_EGL_entry_points.json

@@ -6,7 +6,7 @@
   "scripts/entry_point_packed_gl_enums.json":
     "e5282bdef690f0ec652fed0e0723d1e8",
   "scripts/generate_entry_points.py":
-    "9259c99a07d446b5a9b91989f8f02d37",
+    "72873c3806e749bf593bea823918e520",
   "scripts/gl.xml":
     "b470cb06b06cbbe7adb2c8129ec85708",
   "scripts/gl_angle_ext.xml":
@@ -64,27 +64,29 @@
   "src/libANGLE/Context_gles_ext_autogen.h":
     "d924200ebeb9fd0fae9effbc8489d3e1",
   "src/libANGLE/capture_gles_1_0_autogen.cpp":
-    "4eed3706b615e2778f6d7840af8b9a15",
+    "bc6dbb7355d76c9ffff0d424b5ca9036",
   "src/libANGLE/capture_gles_1_0_autogen.h":
     "06471d4526e8d0b824f5afc8bc8766fa",
   "src/libANGLE/capture_gles_2_0_autogen.cpp":
-    "0669611cd6c795864c5f2b36710aa223",
+    "a7ccc51733f4c608ae79e30195ebe70f",
   "src/libANGLE/capture_gles_2_0_autogen.h":
     "9876493671f3051054cb10524330c8b1",
   "src/libANGLE/capture_gles_3_0_autogen.cpp":
-    "42683a08ccbf8ef84727b40480a45421",
+    "1af4126b8eac91fd7401caa9bf4e9a7c",
   "src/libANGLE/capture_gles_3_0_autogen.h":
     "3b17c1843763678272281e1f2a59e254",
   "src/libANGLE/capture_gles_3_1_autogen.cpp":
-    "4d05155fff1c3e31a1580eb1ef022e6d",
+    "405717bc0d7a9c815fd81e119e69d219",
   "src/libANGLE/capture_gles_3_1_autogen.h":
     "7f3ff3ade9045bae39ed372e0350454c",
   "src/libANGLE/capture_gles_ext_autogen.cpp":
-    "90b5ef88fbd3c7be9b9b27485f165049",
+    "52f20a5a311c646510d31e6aa77b03cd",
   "src/libANGLE/capture_gles_ext_autogen.h":
     "2f2cfa1ee077c3b535138547db57e1af",
+  "src/libANGLE/entry_points_enum_autogen.cpp":
+    "b63b359a41a524c4ec3cb4e468bc2775",
   "src/libANGLE/entry_points_enum_autogen.h":
-    "b98241dd6ce96934cc1d6f8edc0725e1",
+    "909cf5a69dcfd6131a45fa26e6abff47",
   "src/libANGLE/frame_capture_utils_autogen.cpp":
     "ec6ca9dee86e07a0421721f2bab4fb0b",
   "src/libANGLE/frame_capture_utils_autogen.h":

scripts/generate_entry_points.py

@@ -93,10 +93,44 @@ enum class EntryPoint
 {{
 {entry_points_list}
 }};
+
+const char *GetEntryPointName(EntryPoint ep);
 }}  // namespace gl
 #endif  // LIBANGLE_ENTRY_POINTS_ENUM_AUTOGEN_H_
 """
 
+template_entry_points_name_case = """        case EntryPoint::{enum}:
+            return "gl{enum}";"""
+
+template_entry_points_enum_source = """// GENERATED FILE - DO NOT EDIT.
+// Generated by {script_name} using data from {data_source_name}.
+//
+// Copyright {year} 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.
+//
+// entry_points_enum_autogen.cpp:
+//   Helper methods for the {lib} entry points enumeration.
+
+#include "libANGLE/entry_points_enum_autogen.h"
+
+#include "common/debug.h"
+
+namespace gl
+{{
+const char *GetEntryPointName(EntryPoint ep)
+{{
+    switch (ep)
+    {{
+{entry_points_name_cases}
+        default:
+            UNREACHABLE();
+            return "error";
+    }}
+}}
+}}  // namespace gl
+"""
+
 template_lib_entry_point_source = """// GENERATED FILE - DO NOT EDIT.
 // Generated by {script_name} using data from {data_source_name}.
 //
@@ -289,7 +323,7 @@ CallCapture Capture{short_name}({params_with_type}, {return_value_type_original}
     InitParamValue(ParamType::T{return_value_type_custom}, returnValue, &returnValueCapture.value);
     paramBuffer.addReturnValue(std::move(returnValueCapture));
 
-    return CallCapture("gl{short_name}", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::{short_name}, std::move(paramBuffer));
 }}
 """
 
@@ -300,7 +334,7 @@ CallCapture Capture{short_name}({params_with_type})
 
     {parameter_captures}
 
-    return CallCapture("gl{short_name}", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::{short_name}, std::move(paramBuffer));
 }}
 """
 
@@ -1279,6 +1313,7 @@ def main():
             '../src/libANGLE/capture_gles_ext_autogen.h',
             '../src/libANGLE/frame_capture_utils_autogen.cpp',
             '../src/libANGLE/frame_capture_utils_autogen.h',
+            '../src/libANGLE/entry_points_enum_autogen.cpp',
             '../src/libANGLE/entry_points_enum_autogen.h',
             '../src/libANGLE/validationES1_autogen.h',
             '../src/libANGLE/validationES2_autogen.h',
@@ -1699,7 +1734,7 @@ def main():
     cmd_names.extend([cmd for cmd in gl_cmd_names if cmd not in cmd_names])
     sorted_cmd_names = sorted(cmd_names)
 
-    entry_points_enum = template_entry_points_enum_header.format(
+    entry_points_enum_header = template_entry_points_enum_header.format(
         script_name=os.path.basename(sys.argv[0]),
         data_source_name="gl.xml and gl_angle_ext.xml",
         year=date.today().year,
@@ -1708,7 +1743,22 @@ def main():
 
     entry_points_enum_header_path = path_to("libANGLE", "entry_points_enum_autogen.h")
     with open(entry_points_enum_header_path, "w") as out:
-        out.write(entry_points_enum)
+        out.write(entry_points_enum_header)
+        out.close()
+
+    entry_points_cases = [
+        template_entry_points_name_case.format(enum=cmd) for cmd in sorted_cmd_names
+    ]
+    entry_points_enum_source = template_entry_points_enum_source.format(
+        script_name=os.path.basename(sys.argv[0]),
+        data_source_name="gl.xml and gl_angle_ext.xml",
+        year=date.today().year,
+        lib="GL/GLES",
+        entry_points_name_cases="\n".join(entry_points_cases))
+
+    entry_points_enum_source_path = path_to("libANGLE", "entry_points_enum_autogen.cpp")
+    with open(entry_points_enum_source_path, "w") as out:
+        out.write(entry_points_enum_source)
         out.close()
 
     source_includes = """

src/libANGLE/FrameCapture.cpp

@@ -40,7 +40,7 @@ void WriteParamStaticVarName(const CallCapture &call,
                              int counter,
                              std::ostream &out)
 {
-    out << call.name << "_" << param.name << "_" << counter;
+    out << call.name() << "_" << param.name << "_" << counter;
 }
 
 template <typename T, typename CastT = T>
@@ -130,8 +130,14 @@ ParamCapture &ParamBuffer::getClientArrayPointerParameter()
     return mParamCaptures[mClientArrayDataParam];
 }
 
-CallCapture::CallCapture(const char *nameIn, ParamBuffer &&paramsIn)
-    : name(nameIn), params(std::move(paramsIn))
+CallCapture::CallCapture(gl::EntryPoint entryPointIn, ParamBuffer &&paramsIn)
+    : entryPoint(entryPointIn), params(std::move(paramsIn))
+{}
+
+CallCapture::CallCapture(const std::string &customFunctionNameIn, ParamBuffer &&paramsIn)
+    : entryPoint(gl::EntryPoint::Invalid),
+      customFunctionName(customFunctionNameIn),
+      params(std::move(paramsIn))
 {}
 
 CallCapture::~CallCapture() = default;
@@ -143,11 +149,23 @@ CallCapture::CallCapture(CallCapture &&other)
 
 CallCapture &CallCapture::operator=(CallCapture &&other)
 {
-    std::swap(name, other.name);
+    std::swap(entryPoint, other.entryPoint);
+    std::swap(customFunctionName, other.customFunctionName);
     std::swap(params, other.params);
     return *this;
 }
 
+const char *CallCapture::name() const
+{
+    if (entryPoint == gl::EntryPoint::Invalid)
+    {
+        ASSERT(!customFunctionName.empty());
+        return customFunctionName.c_str();
+    }
+
+    return gl::GetEntryPointName(entryPoint);
+}
+
 FrameCapture::FrameCapture() : mFrameIndex(0), mReadBufferSize(0)
 {
     reset();
@@ -157,7 +175,7 @@ FrameCapture::~FrameCapture() = default;
 
 void FrameCapture::captureCall(const gl::Context *context, CallCapture &&call)
 {
-    if (call.name == "glVertexAttribPointer")
+    if (call.entryPoint == gl::EntryPoint::VertexAttribPointer)
     {
         // Get array location
         GLuint index = call.params.getParam("index", ParamType::TGLuint, 0).value.GLuintVal;
@@ -171,7 +189,7 @@ void FrameCapture::captureCall(const gl::Context *context, CallCapture &&call)
             mClientVertexArrayMap[index] = -1;
         }
     }
-    else if (call.name == "glDrawArrays")
+    else if (call.entryPoint == gl::EntryPoint::DrawArrays)
     {
         if (context->getStateCache().hasAnyActiveClientAttrib())
         {
@@ -182,7 +200,7 @@ void FrameCapture::captureCall(const gl::Context *context, CallCapture &&call)
             captureClientArraySnapshot(context, firstVertex + drawCount, 1);
         }
     }
-    else if (call.name == "glDrawElements")
+    else if (call.entryPoint == gl::EntryPoint::DrawElements)
     {
         if (context->getStateCache().hasAnyActiveClientAttrib())
         {
@@ -378,9 +396,9 @@ void FrameCapture::saveCapturedFrameAsCpp()
     printf("Saved '%s'.\n", fname.c_str());
 }
 
-int FrameCapture::getAndIncrementCounter(const std::string &callName, const std::string &paramName)
+int FrameCapture::getAndIncrementCounter(gl::EntryPoint entryPoint, const std::string &paramName)
 {
-    auto counterKey = std::tie(callName, paramName);
+    auto counterKey = std::tie(entryPoint, paramName);
     return mDataCounters[counterKey]++;
 }
 
@@ -389,7 +407,7 @@ void FrameCapture::writeCallReplay(const CallCapture &call,
                                    std::ostream &header,
                                    std::vector<uint8_t> *binaryData)
 {
-    out << call.name << "(";
+    out << call.name() << "(";
 
     bool first = true;
     for (const ParamCapture &param : call.params.getParamCaptures())
@@ -421,7 +439,7 @@ void FrameCapture::writeCallReplay(const CallCapture &call,
             }
             else if (param.type == ParamType::TGLcharConstPointerPointer)
             {
-                int counter = getAndIncrementCounter(call.name, param.name);
+                int counter = getAndIncrementCounter(call.entryPoint, param.name);
 
                 header << "const char *";
                 WriteParamStaticVarName(call, param, counter, header);
@@ -438,7 +456,7 @@ void FrameCapture::writeCallReplay(const CallCapture &call,
             }
             else
             {
-                int counter = getAndIncrementCounter(call.name, param.name);
+                int counter = getAndIncrementCounter(call.entryPoint, param.name);
 
                 ASSERT(param.data.size() == 1);
                 const std::vector<uint8_t> &data = param.data[0];

src/libANGLE/FrameCapture.h

@@ -13,6 +13,7 @@
 #include "common/PackedEnums.h"
 #include "libANGLE/Context.h"
 #include "libANGLE/angletypes.h"
+#include "libANGLE/entry_points_utils.h"
 #include "libANGLE/frame_capture_utils_autogen.h"
 
 #include <tuple>
@@ -67,13 +68,17 @@ class ParamBuffer final : angle::NonCopyable
 
 struct CallCapture
 {
-    CallCapture(const char *nameIn, ParamBuffer &&paramsIn);
+    CallCapture(gl::EntryPoint entryPointIn, ParamBuffer &&paramsIn);
+    CallCapture(const std::string &customFunctionNameIn, ParamBuffer &&paramsIn);
     ~CallCapture();
 
     CallCapture(CallCapture &&other);
     CallCapture &operator=(CallCapture &&other);
 
-    std::string name;
+    const char *name() const;
+
+    gl::EntryPoint entryPoint;
+    std::string customFunctionName;
     ParamBuffer params;
 };
 
@@ -89,7 +94,7 @@ class FrameCapture final : angle::NonCopyable
 
   private:
     // <CallName, ParamName>
-    using Counter = std::tuple<std::string, std::string>;
+    using Counter = std::tuple<gl::EntryPoint, std::string>;
 
     void captureClientArraySnapshot(const gl::Context *context,
                                     size_t vertexCount,
@@ -100,7 +105,7 @@ class FrameCapture final : angle::NonCopyable
                          std::ostream &header,
                          std::vector<uint8_t> *binaryData);
     void reset();
-    int getAndIncrementCounter(const std::string &callName, const std::string &paramName);
+    int getAndIncrementCounter(gl::EntryPoint entryPoint, const std::string &paramName);
     bool anyClientArray() const;
     void saveCapturedFrameAsCpp();
 
@@ -113,8 +118,7 @@ class FrameCapture final : angle::NonCopyable
 };
 
 template <typename CaptureFuncT, typename... ArgsT>
-void CaptureCallToFrameCapture(const char *entryPointName,
-                               CaptureFuncT captureFunc,
+void CaptureCallToFrameCapture(CaptureFuncT captureFunc,
                                bool isCallValid,
                                gl::Context *context,
                                ArgsT... captureParams)

src/libANGLE/capture_gles_1_0_autogen.cpp

@@ -29,7 +29,7 @@ CallCapture CaptureAlphaFunc(const Context *context,
     paramBuffer.addValueParam("funcPacked", ParamType::TAlphaTestFunc, funcPacked);
     paramBuffer.addValueParam("ref", ParamType::TGLfloat, ref);
 
-    return CallCapture("glAlphaFunc", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::AlphaFunc, std::move(paramBuffer));
 }
 
 CallCapture CaptureAlphaFuncx(const Context *context,
@@ -42,7 +42,7 @@ CallCapture CaptureAlphaFuncx(const Context *context,
     paramBuffer.addValueParam("funcPacked", ParamType::TAlphaTestFunc, funcPacked);
     paramBuffer.addValueParam("ref", ParamType::TGLfixed, ref);
 
-    return CallCapture("glAlphaFuncx", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::AlphaFuncx, std::move(paramBuffer));
 }
 
 CallCapture CaptureClearColorx(const Context *context,
@@ -59,7 +59,7 @@ CallCapture CaptureClearColorx(const Context *context,
     paramBuffer.addValueParam("blue", ParamType::TGLfixed, blue);
     paramBuffer.addValueParam("alpha", ParamType::TGLfixed, alpha);
 
-    return CallCapture("glClearColorx", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::ClearColorx, std::move(paramBuffer));
 }
 
 CallCapture CaptureClearDepthx(const Context *context, bool isCallValid, GLfixed depth)
@@ -68,7 +68,7 @@ CallCapture CaptureClearDepthx(const Context *context, bool isCallValid, GLfixed
 
     paramBuffer.addValueParam("depth", ParamType::TGLfixed, depth);
 
-    return CallCapture("glClearDepthx", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::ClearDepthx, std::move(paramBuffer));
 }
 
 CallCapture CaptureClientActiveTexture(const Context *context, bool isCallValid, GLenum texture)
@@ -77,7 +77,7 @@ CallCapture CaptureClientActiveTexture(const Context *context, bool isCallValid,
 
     paramBuffer.addValueParam("texture", ParamType::TGLenum, texture);
 
-    return CallCapture("glClientActiveTexture", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::ClientActiveTexture, std::move(paramBuffer));
 }
 
 CallCapture CaptureClipPlanef(const Context *context,
@@ -94,7 +94,7 @@ CallCapture CaptureClipPlanef(const Context *context,
     CaptureClipPlanef_eqn(context, isCallValid, p, eqn, &eqnParam);
     paramBuffer.addParam(std::move(eqnParam));
 
-    return CallCapture("glClipPlanef", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::ClipPlanef, std::move(paramBuffer));
 }
 
 CallCapture CaptureClipPlanex(const Context *context,
@@ -111,7 +111,7 @@ CallCapture CaptureClipPlanex(const Context *context,
     CaptureClipPlanex_equation(context, isCallValid, plane, equation, &equationParam);
     paramBuffer.addParam(std::move(equationParam));
 
-    return CallCapture("glClipPlanex", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::ClipPlanex, std::move(paramBuffer));
 }
 
 CallCapture CaptureColor4f(const Context *context,
@@ -128,7 +128,7 @@ CallCapture CaptureColor4f(const Context *context,
     paramBuffer.addValueParam("blue", ParamType::TGLfloat, blue);
     paramBuffer.addValueParam("alpha", ParamType::TGLfloat, alpha);
 
-    return CallCapture("glColor4f", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::Color4f, std::move(paramBuffer));
 }
 
 CallCapture CaptureColor4ub(const Context *context,
@@ -145,7 +145,7 @@ CallCapture CaptureColor4ub(const Context *context,
     paramBuffer.addValueParam("blue", ParamType::TGLubyte, blue);
     paramBuffer.addValueParam("alpha", ParamType::TGLubyte, alpha);
 
-    return CallCapture("glColor4ub", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::Color4ub, std::move(paramBuffer));
 }
 
 CallCapture CaptureColor4x(const Context *context,
@@ -162,7 +162,7 @@ CallCapture CaptureColor4x(const Context *context,
     paramBuffer.addValueParam("blue", ParamType::TGLfixed, blue);
     paramBuffer.addValueParam("alpha", ParamType::TGLfixed, alpha);
 
-    return CallCapture("glColor4x", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::Color4x, std::move(paramBuffer));
 }
 
 CallCapture CaptureColorPointer(const Context *context,
@@ -184,7 +184,7 @@ CallCapture CaptureColorPointer(const Context *context,
                                 &pointerParam);
     paramBuffer.addParam(std::move(pointerParam));
 
-    return CallCapture("glColorPointer", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::ColorPointer, std::move(paramBuffer));
 }
 
 CallCapture CaptureDepthRangex(const Context *context, bool isCallValid, GLfixed n, GLfixed f)
@@ -194,7 +194,7 @@ CallCapture CaptureDepthRangex(const Context *context, bool isCallValid, GLfixed
     paramBuffer.addValueParam("n", ParamType::TGLfixed, n);
     paramBuffer.addValueParam("f", ParamType::TGLfixed, f);
 
-    return CallCapture("glDepthRangex", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::DepthRangex, std::move(paramBuffer));
 }
 
 CallCapture CaptureDisableClientState(const Context *context,
@@ -205,7 +205,7 @@ CallCapture CaptureDisableClientState(const Context *context,
 
     paramBuffer.addValueParam("arrayPacked", ParamType::TClientVertexArrayType, arrayPacked);
 
-    return CallCapture("glDisableClientState", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::DisableClientState, std::move(paramBuffer));
 }
 
 CallCapture CaptureEnableClientState(const Context *context,
@@ -216,7 +216,7 @@ CallCapture CaptureEnableClientState(const Context *context,
 
     paramBuffer.addValueParam("arrayPacked", ParamType::TClientVertexArrayType, arrayPacked);
 
-    return CallCapture("glEnableClientState", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::EnableClientState, std::move(paramBuffer));
 }
 
 CallCapture CaptureFogf(const Context *context, bool isCallValid, GLenum pname, GLfloat param)
@@ -226,7 +226,7 @@ CallCapture CaptureFogf(const Context *context, bool isCallValid, GLenum pname,
     paramBuffer.addValueParam("pname", ParamType::TGLenum, pname);
     paramBuffer.addValueParam("param", ParamType::TGLfloat, param);
 
-    return CallCapture("glFogf", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::Fogf, std::move(paramBuffer));
 }
 
 CallCapture CaptureFogfv(const Context *context,
@@ -243,7 +243,7 @@ CallCapture CaptureFogfv(const Context *context,
     CaptureFogfv_params(context, isCallValid, pname, params, &paramsParam);
     paramBuffer.addParam(std::move(paramsParam));
 
-    return CallCapture("glFogfv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::Fogfv, std::move(paramBuffer));
 }
 
 CallCapture CaptureFogx(const Context *context, bool isCallValid, GLenum pname, GLfixed param)
@@ -253,7 +253,7 @@ CallCapture CaptureFogx(const Context *context, bool isCallValid, GLenum pname,
     paramBuffer.addValueParam("pname", ParamType::TGLenum, pname);
     paramBuffer.addValueParam("param", ParamType::TGLfixed, param);
 
-    return CallCapture("glFogx", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::Fogx, std::move(paramBuffer));
 }
 
 CallCapture CaptureFogxv(const Context *context,
@@ -270,7 +270,7 @@ CallCapture CaptureFogxv(const Context *context,
     CaptureFogxv_param(context, isCallValid, pname, param, &paramParam);
     paramBuffer.addParam(std::move(paramParam));
 
-    return CallCapture("glFogxv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::Fogxv, std::move(paramBuffer));
 }
 
 CallCapture CaptureFrustumf(const Context *context,
@@ -291,7 +291,7 @@ CallCapture CaptureFrustumf(const Context *context,
     paramBuffer.addValueParam("n", ParamType::TGLfloat, n);
     paramBuffer.addValueParam("f", ParamType::TGLfloat, f);
 
-    return CallCapture("glFrustumf", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::Frustumf, std::move(paramBuffer));
 }
 
 CallCapture CaptureFrustumx(const Context *context,
@@ -312,7 +312,7 @@ CallCapture CaptureFrustumx(const Context *context,
     paramBuffer.addValueParam("n", ParamType::TGLfixed, n);
     paramBuffer.addValueParam("f", ParamType::TGLfixed, f);
 
-    return CallCapture("glFrustumx", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::Frustumx, std::move(paramBuffer));
 }
 
 CallCapture CaptureGetClipPlanef(const Context *context,
@@ -329,7 +329,7 @@ CallCapture CaptureGetClipPlanef(const Context *context,
     CaptureGetClipPlanef_equation(context, isCallValid, plane, equation, &equationParam);
     paramBuffer.addParam(std::move(equationParam));
 
-    return CallCapture("glGetClipPlanef", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::GetClipPlanef, std::move(paramBuffer));
 }
 
 CallCapture CaptureGetClipPlanex(const Context *context,
@@ -346,7 +346,7 @@ CallCapture CaptureGetClipPlanex(const Context *context,
     CaptureGetClipPlanex_equation(context, isCallValid, plane, equation, &equationParam);
     paramBuffer.addParam(std::move(equationParam));
 
-    return CallCapture("glGetClipPlanex", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::GetClipPlanex, std::move(paramBuffer));
 }
 
 CallCapture CaptureGetFixedv(const Context *context,
@@ -363,7 +363,7 @@ CallCapture CaptureGetFixedv(const Context *context,
     CaptureGetFixedv_params(context, isCallValid, pname, params, &paramsParam);
     paramBuffer.addParam(std::move(paramsParam));
 
-    return CallCapture("glGetFixedv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::GetFixedv, std::move(paramBuffer));
 }
 
 CallCapture CaptureGetLightfv(const Context *context,
@@ -382,7 +382,7 @@ CallCapture CaptureGetLightfv(const Context *context,
     CaptureGetLightfv_params(context, isCallValid, light, pnamePacked, params, &paramsParam);
     paramBuffer.addParam(std::move(paramsParam));
 
-    return CallCapture("glGetLightfv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::GetLightfv, std::move(paramBuffer));
 }
 
 CallCapture CaptureGetLightxv(const Context *context,
@@ -401,7 +401,7 @@ CallCapture CaptureGetLightxv(const Context *context,
     CaptureGetLightxv_params(context, isCallValid, light, pnamePacked, params, &paramsParam);
     paramBuffer.addParam(std::move(paramsParam));
 
-    return CallCapture("glGetLightxv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::GetLightxv, std::move(paramBuffer));
 }
 
 CallCapture CaptureGetMaterialfv(const Context *context,
@@ -420,7 +420,7 @@ CallCapture CaptureGetMaterialfv(const Context *context,
     CaptureGetMaterialfv_params(context, isCallValid, face, pnamePacked, params, &paramsParam);
     paramBuffer.addParam(std::move(paramsParam));
 
-    return CallCapture("glGetMaterialfv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::GetMaterialfv, std::move(paramBuffer));
 }
 
 CallCapture CaptureGetMaterialxv(const Context *context,
@@ -439,7 +439,7 @@ CallCapture CaptureGetMaterialxv(const Context *context,
     CaptureGetMaterialxv_params(context, isCallValid, face, pnamePacked, params, &paramsParam);
     paramBuffer.addParam(std::move(paramsParam));
 
-    return CallCapture("glGetMaterialxv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::GetMaterialxv, std::move(paramBuffer));
 }
 
 CallCapture CaptureGetPointerv(const Context *context,
@@ -456,7 +456,7 @@ CallCapture CaptureGetPointerv(const Context *context,
     CaptureGetPointerv_params(context, isCallValid, pname, params, &paramsParam);
     paramBuffer.addParam(std::move(paramsParam));
 
-    return CallCapture("glGetPointerv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::GetPointerv, std::move(paramBuffer));
 }
 
 CallCapture CaptureGetTexEnvfv(const Context *context,
@@ -476,7 +476,7 @@ CallCapture CaptureGetTexEnvfv(const Context *context,
                               &paramsParam);
     paramBuffer.addParam(std::move(paramsParam));
 
-    return CallCapture("glGetTexEnvfv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::GetTexEnvfv, std::move(paramBuffer));
 }
 
 CallCapture CaptureGetTexEnviv(const Context *context,
@@ -496,7 +496,7 @@ CallCapture CaptureGetTexEnviv(const Context *context,
                               &paramsParam);
     paramBuffer.addParam(std::move(paramsParam));
 
-    return CallCapture("glGetTexEnviv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::GetTexEnviv, std::move(paramBuffer));
 }
 
 CallCapture CaptureGetTexEnvxv(const Context *context,
@@ -516,7 +516,7 @@ CallCapture CaptureGetTexEnvxv(const Context *context,
                               &paramsParam);
     paramBuffer.addParam(std::move(paramsParam));
 
-    return CallCapture("glGetTexEnvxv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::GetTexEnvxv, std::move(paramBuffer));
 }
 
 CallCapture CaptureGetTexParameterxv(const Context *context,
@@ -536,7 +536,7 @@ CallCapture CaptureGetTexParameterxv(const Context *context,
                                     &paramsParam);
     paramBuffer.addParam(std::move(paramsParam));
 
-    return CallCapture("glGetTexParameterxv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::GetTexParameterxv, std::move(paramBuffer));
 }
 
 CallCapture CaptureLightModelf(const Context *context,
@@ -549,7 +549,7 @@ CallCapture CaptureLightModelf(const Context *context,
     paramBuffer.addValueParam("pname", ParamType::TGLenum, pname);
     paramBuffer.addValueParam("param", ParamType::TGLfloat, param);
 
-    return CallCapture("glLightModelf", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::LightModelf, std::move(paramBuffer));
 }
 
 CallCapture CaptureLightModelfv(const Context *context,
@@ -566,7 +566,7 @@ CallCapture CaptureLightModelfv(const Context *context,
     CaptureLightModelfv_params(context, isCallValid, pname, params, &paramsParam);
     paramBuffer.addParam(std::move(paramsParam));
 
-    return CallCapture("glLightModelfv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::LightModelfv, std::move(paramBuffer));
 }
 
 CallCapture CaptureLightModelx(const Context *context,
@@ -579,7 +579,7 @@ CallCapture CaptureLightModelx(const Context *context,
     paramBuffer.addValueParam("pname", ParamType::TGLenum, pname);
     paramBuffer.addValueParam("param", ParamType::TGLfixed, param);
 
-    return CallCapture("glLightModelx", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::LightModelx, std::move(paramBuffer));
 }
 
 CallCapture CaptureLightModelxv(const Context *context,
@@ -596,7 +596,7 @@ CallCapture CaptureLightModelxv(const Context *context,
     CaptureLightModelxv_param(context, isCallValid, pname, param, &paramParam);
     paramBuffer.addParam(std::move(paramParam));
 
-    return CallCapture("glLightModelxv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::LightModelxv, std::move(paramBuffer));
 }
 
 CallCapture CaptureLightf(const Context *context,
@@ -611,7 +611,7 @@ CallCapture CaptureLightf(const Context *context,
     paramBuffer.addValueParam("pnamePacked", ParamType::TLightParameter, pnamePacked);
     paramBuffer.addValueParam("param", ParamType::TGLfloat, param);
 
-    return CallCapture("glLightf", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::Lightf, std::move(paramBuffer));
 }
 
 CallCapture CaptureLightfv(const Context *context,
@@ -630,7 +630,7 @@ CallCapture CaptureLightfv(const Context *context,
     CaptureLightfv_params(context, isCallValid, light, pnamePacked, params, &paramsParam);
     paramBuffer.addParam(std::move(paramsParam));
 
-    return CallCapture("glLightfv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::Lightfv, std::move(paramBuffer));
 }
 
 CallCapture CaptureLightx(const Context *context,
@@ -645,7 +645,7 @@ CallCapture CaptureLightx(const Context *context,
     paramBuffer.addValueParam("pnamePacked", ParamType::TLightParameter, pnamePacked);
     paramBuffer.addValueParam("param", ParamType::TGLfixed, param);
 
-    return CallCapture("glLightx", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::Lightx, std::move(paramBuffer));
 }
 
 CallCapture CaptureLightxv(const Context *context,
@@ -664,7 +664,7 @@ CallCapture CaptureLightxv(const Context *context,
     CaptureLightxv_params(context, isCallValid, light, pnamePacked, params, &paramsParam);
     paramBuffer.addParam(std::move(paramsParam));
 
-    return CallCapture("glLightxv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::Lightxv, std::move(paramBuffer));
 }
 
 CallCapture CaptureLineWidthx(const Context *context, bool isCallValid, GLfixed width)
@@ -673,14 +673,14 @@ CallCapture CaptureLineWidthx(const Context *context, bool isCallValid, GLfixed
 
     paramBuffer.addValueParam("width", ParamType::TGLfixed, width);
 
-    return CallCapture("glLineWidthx", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::LineWidthx, std::move(paramBuffer));
 }
 
 CallCapture CaptureLoadIdentity(const Context *context, bool isCallValid)
 {
     ParamBuffer paramBuffer;
 
-    return CallCapture("glLoadIdentity", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::LoadIdentity, std::move(paramBuffer));
 }
 
 CallCapture CaptureLoadMatrixf(const Context *context, bool isCallValid, const GLfloat *m)
@@ -692,7 +692,7 @@ CallCapture CaptureLoadMatrixf(const Context *context, bool isCallValid, const G
     CaptureLoadMatrixf_m(context, isCallValid, m, &mParam);
     paramBuffer.addParam(std::move(mParam));
 
-    return CallCapture("glLoadMatrixf", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::LoadMatrixf, std::move(paramBuffer));
 }
 
 CallCapture CaptureLoadMatrixx(const Context *context, bool isCallValid, const GLfixed *m)
@@ -704,7 +704,7 @@ CallCapture CaptureLoadMatrixx(const Context *context, bool isCallValid, const G
     CaptureLoadMatrixx_m(context, isCallValid, m, &mParam);
     paramBuffer.addParam(std::move(mParam));
 
-    return CallCapture("glLoadMatrixx", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::LoadMatrixx, std::move(paramBuffer));
 }
 
 CallCapture CaptureLogicOp(const Context *context, bool isCallValid, LogicalOperation opcodePacked)
@@ -713,7 +713,7 @@ CallCapture CaptureLogicOp(const Context *context, bool isCallValid, LogicalOper
 
     paramBuffer.addValueParam("opcodePacked", ParamType::TLogicalOperation, opcodePacked);
 
-    return CallCapture("glLogicOp", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::LogicOp, std::move(paramBuffer));
 }
 
 CallCapture CaptureMaterialf(const Context *context,
@@ -728,7 +728,7 @@ CallCapture CaptureMaterialf(const Context *context,
     paramBuffer.addValueParam("pnamePacked", ParamType::TMaterialParameter, pnamePacked);
     paramBuffer.addValueParam("param", ParamType::TGLfloat, param);
 
-    return CallCapture("glMaterialf", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::Materialf, std::move(paramBuffer));
 }
 
 CallCapture CaptureMaterialfv(const Context *context,
@@ -747,7 +747,7 @@ CallCapture CaptureMaterialfv(const Context *context,
     CaptureMaterialfv_params(context, isCallValid, face, pnamePacked, params, &paramsParam);
     paramBuffer.addParam(std::move(paramsParam));
 
-    return CallCapture("glMaterialfv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::Materialfv, std::move(paramBuffer));
 }
 
 CallCapture CaptureMaterialx(const Context *context,
@@ -762,7 +762,7 @@ CallCapture CaptureMaterialx(const Context *context,
     paramBuffer.addValueParam("pnamePacked", ParamType::TMaterialParameter, pnamePacked);
     paramBuffer.addValueParam("param", ParamType::TGLfixed, param);
 
-    return CallCapture("glMaterialx", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::Materialx, std::move(paramBuffer));
 }
 
 CallCapture CaptureMaterialxv(const Context *context,
@@ -781,7 +781,7 @@ CallCapture CaptureMaterialxv(const Context *context,
     CaptureMaterialxv_param(context, isCallValid, face, pnamePacked, param, &paramParam);
     paramBuffer.addParam(std::move(paramParam));
 
-    return CallCapture("glMaterialxv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::Materialxv, std::move(paramBuffer));
 }
 
 CallCapture CaptureMatrixMode(const Context *context, bool isCallValid, MatrixType modePacked)
@@ -790,7 +790,7 @@ CallCapture CaptureMatrixMode(const Context *context, bool isCallValid, MatrixTy
 
     paramBuffer.addValueParam("modePacked", ParamType::TMatrixType, modePacked);
 
-    return CallCapture("glMatrixMode", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::MatrixMode, std::move(paramBuffer));
 }
 
 CallCapture CaptureMultMatrixf(const Context *context, bool isCallValid, const GLfloat *m)
@@ -802,7 +802,7 @@ CallCapture CaptureMultMatrixf(const Context *context, bool isCallValid, const G
     CaptureMultMatrixf_m(context, isCallValid, m, &mParam);
     paramBuffer.addParam(std::move(mParam));
 
-    return CallCapture("glMultMatrixf", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::MultMatrixf, std::move(paramBuffer));
 }
 
 CallCapture CaptureMultMatrixx(const Context *context, bool isCallValid, const GLfixed *m)
@@ -814,7 +814,7 @@ CallCapture CaptureMultMatrixx(const Context *context, bool isCallValid, const G
     CaptureMultMatrixx_m(context, isCallValid, m, &mParam);
     paramBuffer.addParam(std::move(mParam));
 
-    return CallCapture("glMultMatrixx", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::MultMatrixx, std::move(paramBuffer));
 }
 
 CallCapture CaptureMultiTexCoord4f(const Context *context,
@@ -833,7 +833,7 @@ CallCapture CaptureMultiTexCoord4f(const Context *context,
     paramBuffer.addValueParam("r", ParamType::TGLfloat, r);
     paramBuffer.addValueParam("q", ParamType::TGLfloat, q);
 
-    return CallCapture("glMultiTexCoord4f", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::MultiTexCoord4f, std::move(paramBuffer));
 }
 
 CallCapture CaptureMultiTexCoord4x(const Context *context,
@@ -852,7 +852,7 @@ CallCapture CaptureMultiTexCoord4x(const Context *context,
     paramBuffer.addValueParam("r", ParamType::TGLfixed, r);
     paramBuffer.addValueParam("q", ParamType::TGLfixed, q);
 
-    return CallCapture("glMultiTexCoord4x", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::MultiTexCoord4x, std::move(paramBuffer));
 }
 
 CallCapture CaptureNormal3f(const Context *context,
@@ -867,7 +867,7 @@ CallCapture CaptureNormal3f(const Context *context,
     paramBuffer.addValueParam("ny", ParamType::TGLfloat, ny);
     paramBuffer.addValueParam("nz", ParamType::TGLfloat, nz);
 
-    return CallCapture("glNormal3f", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::Normal3f, std::move(paramBuffer));
 }
 
 CallCapture CaptureNormal3x(const Context *context,
@@ -882,7 +882,7 @@ CallCapture CaptureNormal3x(const Context *context,
     paramBuffer.addValueParam("ny", ParamType::TGLfixed, ny);
     paramBuffer.addValueParam("nz", ParamType::TGLfixed, nz);
 
-    return CallCapture("glNormal3x", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::Normal3x, std::move(paramBuffer));
 }
 
 CallCapture CaptureNormalPointer(const Context *context,
@@ -901,7 +901,7 @@ CallCapture CaptureNormalPointer(const Context *context,
     CaptureNormalPointer_pointer(context, isCallValid, typePacked, stride, pointer, &pointerParam);
     paramBuffer.addParam(std::move(pointerParam));
 
-    return CallCapture("glNormalPointer", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::NormalPointer, std::move(paramBuffer));
 }
 
 CallCapture CaptureOrthof(const Context *context,
@@ -922,7 +922,7 @@ CallCapture CaptureOrthof(const Context *context,
     paramBuffer.addValueParam("n", ParamType::TGLfloat, n);
     paramBuffer.addValueParam("f", ParamType::TGLfloat, f);
 
-    return CallCapture("glOrthof", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::Orthof, std::move(paramBuffer));
 }
 
 CallCapture CaptureOrthox(const Context *context,
@@ -943,7 +943,7 @@ CallCapture CaptureOrthox(const Context *context,
     paramBuffer.addValueParam("n", ParamType::TGLfixed, n);
     paramBuffer.addValueParam("f", ParamType::TGLfixed, f);
 
-    return CallCapture("glOrthox", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::Orthox, std::move(paramBuffer));
 }
 
 CallCapture CapturePointParameterf(const Context *context,
@@ -956,7 +956,7 @@ CallCapture CapturePointParameterf(const Context *context,
     paramBuffer.addValueParam("pnamePacked", ParamType::TPointParameter, pnamePacked);
     paramBuffer.addValueParam("param", ParamType::TGLfloat, param);
 
-    return CallCapture("glPointParameterf", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::PointParameterf, std::move(paramBuffer));
 }
 
 CallCapture CapturePointParameterfv(const Context *context,
@@ -973,7 +973,7 @@ CallCapture CapturePointParameterfv(const Context *context,
     CapturePointParameterfv_params(context, isCallValid, pnamePacked, params, &paramsParam);
     paramBuffer.addParam(std::move(paramsParam));
 
-    return CallCapture("glPointParameterfv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::PointParameterfv, std::move(paramBuffer));
 }
 
 CallCapture CapturePointParameterx(const Context *context,
@@ -986,7 +986,7 @@ CallCapture CapturePointParameterx(const Context *context,
     paramBuffer.addValueParam("pnamePacked", ParamType::TPointParameter, pnamePacked);
     paramBuffer.addValueParam("param", ParamType::TGLfixed, param);
 
-    return CallCapture("glPointParameterx", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::PointParameterx, std::move(paramBuffer));
 }
 
 CallCapture CapturePointParameterxv(const Context *context,
@@ -1003,7 +1003,7 @@ CallCapture CapturePointParameterxv(const Context *context,
     CapturePointParameterxv_params(context, isCallValid, pnamePacked, params, &paramsParam);
     paramBuffer.addParam(std::move(paramsParam));
 
-    return CallCapture("glPointParameterxv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::PointParameterxv, std::move(paramBuffer));
 }
 
 CallCapture CapturePointSize(const Context *context, bool isCallValid, GLfloat size)
@@ -1012,7 +1012,7 @@ CallCapture CapturePointSize(const Context *context, bool isCallValid, GLfloat s
 
     paramBuffer.addValueParam("size", ParamType::TGLfloat, size);
 
-    return CallCapture("glPointSize", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::PointSize, std::move(paramBuffer));
 }
 
 CallCapture CapturePointSizex(const Context *context, bool isCallValid, GLfixed size)
@@ -1021,7 +1021,7 @@ CallCapture CapturePointSizex(const Context *context, bool isCallValid, GLfixed
 
     paramBuffer.addValueParam("size", ParamType::TGLfixed, size);
 
-    return CallCapture("glPointSizex", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::PointSizex, std::move(paramBuffer));
 }
 
 CallCapture CapturePolygonOffsetx(const Context *context,
@@ -1034,21 +1034,21 @@ CallCapture CapturePolygonOffsetx(const Context *context,
     paramBuffer.addValueParam("factor", ParamType::TGLfixed, factor);
     paramBuffer.addValueParam("units", ParamType::TGLfixed, units);
 
-    return CallCapture("glPolygonOffsetx", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::PolygonOffsetx, std::move(paramBuffer));
 }
 
 CallCapture CapturePopMatrix(const Context *context, bool isCallValid)
 {
     ParamBuffer paramBuffer;
 
-    return CallCapture("glPopMatrix", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::PopMatrix, std::move(paramBuffer));
 }
 
 CallCapture CapturePushMatrix(const Context *context, bool isCallValid)
 {
     ParamBuffer paramBuffer;
 
-    return CallCapture("glPushMatrix", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::PushMatrix, std::move(paramBuffer));
 }
 
 CallCapture CaptureRotatef(const Context *context,
@@ -1065,7 +1065,7 @@ CallCapture CaptureRotatef(const Context *context,
     paramBuffer.addValueParam("y", ParamType::TGLfloat, y);
     paramBuffer.addValueParam("z", ParamType::TGLfloat, z);
 
-    return CallCapture("glRotatef", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::Rotatef, std::move(paramBuffer));
 }
 
 CallCapture CaptureRotatex(const Context *context,
@@ -1082,7 +1082,7 @@ CallCapture CaptureRotatex(const Context *context,
     paramBuffer.addValueParam("y", ParamType::TGLfixed, y);
     paramBuffer.addValueParam("z", ParamType::TGLfixed, z);
 
-    return CallCapture("glRotatex", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::Rotatex, std::move(paramBuffer));
 }
 
 CallCapture CaptureSampleCoveragex(const Context *context,
@@ -1095,7 +1095,7 @@ CallCapture CaptureSampleCoveragex(const Context *context,
     paramBuffer.addValueParam("value", ParamType::TGLclampx, value);
     paramBuffer.addValueParam("invert", ParamType::TGLboolean, invert);
 
-    return CallCapture("glSampleCoveragex", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::SampleCoveragex, std::move(paramBuffer));
 }
 
 CallCapture CaptureScalef(const Context *context, bool isCallValid, GLfloat x, GLfloat y, GLfloat z)
@@ -1106,7 +1106,7 @@ CallCapture CaptureScalef(const Context *context, bool isCallValid, GLfloat x, G
     paramBuffer.addValueParam("y", ParamType::TGLfloat, y);
     paramBuffer.addValueParam("z", ParamType::TGLfloat, z);
 
-    return CallCapture("glScalef", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::Scalef, std::move(paramBuffer));
 }
 
 CallCapture CaptureScalex(const Context *context, bool isCallValid, GLfixed x, GLfixed y, GLfixed z)
@@ -1117,7 +1117,7 @@ CallCapture CaptureScalex(const Context *context, bool isCallValid, GLfixed x, G
     paramBuffer.addValueParam("y", ParamType::TGLfixed, y);
     paramBuffer.addValueParam("z", ParamType::TGLfixed, z);
 
-    return CallCapture("glScalex", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::Scalex, std::move(paramBuffer));
 }
 
 CallCapture CaptureShadeModel(const Context *context, bool isCallValid, ShadingModel modePacked)
@@ -1126,7 +1126,7 @@ CallCapture CaptureShadeModel(const Context *context, bool isCallValid, ShadingM
 
     paramBuffer.addValueParam("modePacked", ParamType::TShadingModel, modePacked);
 
-    return CallCapture("glShadeModel", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::ShadeModel, std::move(paramBuffer));
 }
 
 CallCapture CaptureTexCoordPointer(const Context *context,
@@ -1148,7 +1148,7 @@ CallCapture CaptureTexCoordPointer(const Context *context,
                                    &pointerParam);
     paramBuffer.addParam(std::move(pointerParam));
 
-    return CallCapture("glTexCoordPointer", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::TexCoordPointer, std::move(paramBuffer));
 }
 
 CallCapture CaptureTexEnvf(const Context *context,
@@ -1163,7 +1163,7 @@ CallCapture CaptureTexEnvf(const Context *context,
     paramBuffer.addValueParam("pnamePacked", ParamType::TTextureEnvParameter, pnamePacked);
     paramBuffer.addValueParam("param", ParamType::TGLfloat, param);
 
-    return CallCapture("glTexEnvf", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::TexEnvf, std::move(paramBuffer));
 }
 
 CallCapture CaptureTexEnvfv(const Context *context,
@@ -1182,7 +1182,7 @@ CallCapture CaptureTexEnvfv(const Context *context,
     CaptureTexEnvfv_params(context, isCallValid, targetPacked, pnamePacked, params, &paramsParam);
     paramBuffer.addParam(std::move(paramsParam));
 
-    return CallCapture("glTexEnvfv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::TexEnvfv, std::move(paramBuffer));
 }
 
 CallCapture CaptureTexEnvi(const Context *context,
@@ -1197,7 +1197,7 @@ CallCapture CaptureTexEnvi(const Context *context,
     paramBuffer.addValueParam("pnamePacked", ParamType::TTextureEnvParameter, pnamePacked);
     paramBuffer.addValueParam("param", ParamType::TGLint, param);
 
-    return CallCapture("glTexEnvi", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::TexEnvi, std::move(paramBuffer));
 }
 
 CallCapture CaptureTexEnviv(const Context *context,
@@ -1216,7 +1216,7 @@ CallCapture CaptureTexEnviv(const Context *context,
     CaptureTexEnviv_params(context, isCallValid, targetPacked, pnamePacked, params, &paramsParam);
     paramBuffer.addParam(std::move(paramsParam));
 
-    return CallCapture("glTexEnviv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::TexEnviv, std::move(paramBuffer));
 }
 
 CallCapture CaptureTexEnvx(const Context *context,
@@ -1231,7 +1231,7 @@ CallCapture CaptureTexEnvx(const Context *context,
     paramBuffer.addValueParam("pnamePacked", ParamType::TTextureEnvParameter, pnamePacked);
     paramBuffer.addValueParam("param", ParamType::TGLfixed, param);
 
-    return CallCapture("glTexEnvx", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::TexEnvx, std::move(paramBuffer));
 }
 
 CallCapture CaptureTexEnvxv(const Context *context,
@@ -1250,7 +1250,7 @@ CallCapture CaptureTexEnvxv(const Context *context,
     CaptureTexEnvxv_params(context, isCallValid, targetPacked, pnamePacked, params, &paramsParam);
     paramBuffer.addParam(std::move(paramsParam));
 
-    return CallCapture("glTexEnvxv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::TexEnvxv, std::move(paramBuffer));
 }
 
 CallCapture CaptureTexParameterx(const Context *context,
@@ -1265,7 +1265,7 @@ CallCapture CaptureTexParameterx(const Context *context,
     paramBuffer.addValueParam("pname", ParamType::TGLenum, pname);
     paramBuffer.addValueParam("param", ParamType::TGLfixed, param);
 
-    return CallCapture("glTexParameterx", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::TexParameterx, std::move(paramBuffer));
 }
 
 CallCapture CaptureTexParameterxv(const Context *context,
@@ -1284,7 +1284,7 @@ CallCapture CaptureTexParameterxv(const Context *context,
     CaptureTexParameterxv_params(context, isCallValid, targetPacked, pname, params, &paramsParam);
     paramBuffer.addParam(std::move(paramsParam));
 
-    return CallCapture("glTexParameterxv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::TexParameterxv, std::move(paramBuffer));
 }
 
 CallCapture CaptureTranslatef(const Context *context,
@@ -1299,7 +1299,7 @@ CallCapture CaptureTranslatef(const Context *context,
     paramBuffer.addValueParam("y", ParamType::TGLfloat, y);
     paramBuffer.addValueParam("z", ParamType::TGLfloat, z);
 
-    return CallCapture("glTranslatef", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::Translatef, std::move(paramBuffer));
 }
 
 CallCapture CaptureTranslatex(const Context *context,
@@ -1314,7 +1314,7 @@ CallCapture CaptureTranslatex(const Context *context,
     paramBuffer.addValueParam("y", ParamType::TGLfixed, y);
     paramBuffer.addValueParam("z", ParamType::TGLfixed, z);
 
-    return CallCapture("glTranslatex", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::Translatex, std::move(paramBuffer));
 }
 
 CallCapture CaptureVertexPointer(const Context *context,
@@ -1336,7 +1336,7 @@ CallCapture CaptureVertexPointer(const Context *context,
                                  &pointerParam);
     paramBuffer.addParam(std::move(pointerParam));
 
-    return CallCapture("glVertexPointer", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::VertexPointer, std::move(paramBuffer));
 }
 
 }  // namespace gl

src/libANGLE/capture_gles_2_0_autogen.cpp

@@ -25,7 +25,7 @@ CallCapture CaptureActiveTexture(const Context *context, bool isCallValid, GLenu
 
     paramBuffer.addValueParam("texture", ParamType::TGLenum, texture);
 
-    return CallCapture("glActiveTexture", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::ActiveTexture, std::move(paramBuffer));
 }
 
 CallCapture CaptureAttachShader(const Context *context,
@@ -38,7 +38,7 @@ CallCapture CaptureAttachShader(const Context *context,
     paramBuffer.addValueParam("program", ParamType::TGLuint, program);
     paramBuffer.addValueParam("shader", ParamType::TGLuint, shader);
 
-    return CallCapture("glAttachShader", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::AttachShader, std::move(paramBuffer));
 }
 
 CallCapture CaptureBindAttribLocation(const Context *context,
@@ -57,7 +57,7 @@ CallCapture CaptureBindAttribLocation(const Context *context,
     CaptureBindAttribLocation_name(context, isCallValid, program, index, name, &nameParam);
     paramBuffer.addParam(std::move(nameParam));
 
-    return CallCapture("glBindAttribLocation", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::BindAttribLocation, std::move(paramBuffer));
 }
 
 CallCapture CaptureBindBuffer(const Context *context,
@@ -70,7 +70,7 @@ CallCapture CaptureBindBuffer(const Context *context,
     paramBuffer.addValueParam("targetPacked", ParamType::TBufferBinding, targetPacked);
     paramBuffer.addValueParam("buffer", ParamType::TGLuint, buffer);
 
-    return CallCapture("glBindBuffer", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::BindBuffer, std::move(paramBuffer));
 }
 
 CallCapture CaptureBindFramebuffer(const Context *context,
@@ -83,7 +83,7 @@ CallCapture CaptureBindFramebuffer(const Context *context,
     paramBuffer.addValueParam("target", ParamType::TGLenum, target);
     paramBuffer.addValueParam("framebuffer", ParamType::TGLuint, framebuffer);
 
-    return CallCapture("glBindFramebuffer", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::BindFramebuffer, std::move(paramBuffer));
 }
 
 CallCapture CaptureBindRenderbuffer(const Context *context,
@@ -96,7 +96,7 @@ CallCapture CaptureBindRenderbuffer(const Context *context,
     paramBuffer.addValueParam("target", ParamType::TGLenum, target);
     paramBuffer.addValueParam("renderbuffer", ParamType::TGLuint, renderbuffer);
 
-    return CallCapture("glBindRenderbuffer", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::BindRenderbuffer, std::move(paramBuffer));
 }
 
 CallCapture CaptureBindTexture(const Context *context,
@@ -109,7 +109,7 @@ CallCapture CaptureBindTexture(const Context *context,
     paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
     paramBuffer.addValueParam("texture", ParamType::TGLuint, texture);
 
-    return CallCapture("glBindTexture", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::BindTexture, std::move(paramBuffer));
 }
 
 CallCapture CaptureBlendColor(const Context *context,
@@ -126,7 +126,7 @@ CallCapture CaptureBlendColor(const Context *context,
     paramBuffer.addValueParam("blue", ParamType::TGLfloat, blue);
     paramBuffer.addValueParam("alpha", ParamType::TGLfloat, alpha);
 
-    return CallCapture("glBlendColor", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::BlendColor, std::move(paramBuffer));
 }
 
 CallCapture CaptureBlendEquation(const Context *context, bool isCallValid, GLenum mode)
@@ -135,7 +135,7 @@ CallCapture CaptureBlendEquation(const Context *context, bool isCallValid, GLenu
 
     paramBuffer.addValueParam("mode", ParamType::TGLenum, mode);
 
-    return CallCapture("glBlendEquation", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::BlendEquation, std::move(paramBuffer));
 }
 
 CallCapture CaptureBlendEquationSeparate(const Context *context,
@@ -148,7 +148,7 @@ CallCapture CaptureBlendEquationSeparate(const Context *context,
     paramBuffer.addValueParam("modeRGB", ParamType::TGLenum, modeRGB);
     paramBuffer.addValueParam("modeAlpha", ParamType::TGLenum, modeAlpha);
 
-    return CallCapture("glBlendEquationSeparate", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::BlendEquationSeparate, std::move(paramBuffer));
 }
 
 CallCapture CaptureBlendFunc(const Context *context,
@@ -161,7 +161,7 @@ CallCapture CaptureBlendFunc(const Context *context,
     paramBuffer.addValueParam("sfactor", ParamType::TGLenum, sfactor);
     paramBuffer.addValueParam("dfactor", ParamType::TGLenum, dfactor);
 
-    return CallCapture("glBlendFunc", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::BlendFunc, std::move(paramBuffer));
 }
 
 CallCapture CaptureBlendFuncSeparate(const Context *context,
@@ -178,7 +178,7 @@ CallCapture CaptureBlendFuncSeparate(const Context *context,
     paramBuffer.addValueParam("sfactorAlpha", ParamType::TGLenum, sfactorAlpha);
     paramBuffer.addValueParam("dfactorAlpha", ParamType::TGLenum, dfactorAlpha);
 
-    return CallCapture("glBlendFuncSeparate", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::BlendFuncSeparate, std::move(paramBuffer));
 }
 
 CallCapture CaptureBufferData(const Context *context,
@@ -200,7 +200,7 @@ CallCapture CaptureBufferData(const Context *context,
 
     paramBuffer.addValueParam("usagePacked", ParamType::TBufferUsage, usagePacked);
 
-    return CallCapture("glBufferData", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::BufferData, std::move(paramBuffer));
 }
 
 CallCapture CaptureBufferSubData(const Context *context,
@@ -221,7 +221,7 @@ CallCapture CaptureBufferSubData(const Context *context,
     CaptureBufferSubData_data(context, isCallValid, targetPacked, offset, size, data, &dataParam);
     paramBuffer.addParam(std::move(dataParam));
 
-    return CallCapture("glBufferSubData", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::BufferSubData, std::move(paramBuffer));
 }
 
 CallCapture CaptureCheckFramebufferStatus(const Context *context,
@@ -237,7 +237,7 @@ CallCapture CaptureCheckFramebufferStatus(const Context *context,
     InitParamValue(ParamType::TGLenum, returnValue, &returnValueCapture.value);
     paramBuffer.addReturnValue(std::move(returnValueCapture));
 
-    return CallCapture("glCheckFramebufferStatus", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::CheckFramebufferStatus, std::move(paramBuffer));
 }
 
 CallCapture CaptureClear(const Context *context, bool isCallValid, GLbitfield mask)
@@ -246,7 +246,7 @@ CallCapture CaptureClear(const Context *context, bool isCallValid, GLbitfield ma
 
     paramBuffer.addValueParam("mask", ParamType::TGLbitfield, mask);
 
-    return CallCapture("glClear", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::Clear, std::move(paramBuffer));
 }
 
 CallCapture CaptureClearColor(const Context *context,
@@ -263,7 +263,7 @@ CallCapture CaptureClearColor(const Context *context,
     paramBuffer.addValueParam("blue", ParamType::TGLfloat, blue);
     paramBuffer.addValueParam("alpha", ParamType::TGLfloat, alpha);
 
-    return CallCapture("glClearColor", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::ClearColor, std::move(paramBuffer));
 }
 
 CallCapture CaptureClearDepthf(const Context *context, bool isCallValid, GLfloat d)
@@ -272,7 +272,7 @@ CallCapture CaptureClearDepthf(const Context *context, bool isCallValid, GLfloat
 
     paramBuffer.addValueParam("d", ParamType::TGLfloat, d);
 
-    return CallCapture("glClearDepthf", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::ClearDepthf, std::move(paramBuffer));
 }
 
 CallCapture CaptureClearStencil(const Context *context, bool isCallValid, GLint s)
@@ -281,7 +281,7 @@ CallCapture CaptureClearStencil(const Context *context, bool isCallValid, GLint
 
     paramBuffer.addValueParam("s", ParamType::TGLint, s);
 
-    return CallCapture("glClearStencil", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::ClearStencil, std::move(paramBuffer));
 }
 
 CallCapture CaptureColorMask(const Context *context,
@@ -298,7 +298,7 @@ CallCapture CaptureColorMask(const Context *context,
     paramBuffer.addValueParam("blue", ParamType::TGLboolean, blue);
     paramBuffer.addValueParam("alpha", ParamType::TGLboolean, alpha);
 
-    return CallCapture("glColorMask", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::ColorMask, std::move(paramBuffer));
 }
 
 CallCapture CaptureCompileShader(const Context *context, bool isCallValid, GLuint shader)
@@ -307,7 +307,7 @@ CallCapture CaptureCompileShader(const Context *context, bool isCallValid, GLuin
 
     paramBuffer.addValueParam("shader", ParamType::TGLuint, shader);
 
-    return CallCapture("glCompileShader", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::CompileShader, std::move(paramBuffer));
 }
 
 CallCapture CaptureCompressedTexImage2D(const Context *context,
@@ -337,7 +337,7 @@ CallCapture CaptureCompressedTexImage2D(const Context *context,
                                      width, height, border, imageSize, data, &dataParam);
     paramBuffer.addParam(std::move(dataParam));
 
-    return CallCapture("glCompressedTexImage2D", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::CompressedTexImage2D, std::move(paramBuffer));
 }
 
 CallCapture CaptureCompressedTexSubImage2D(const Context *context,
@@ -369,7 +369,7 @@ CallCapture CaptureCompressedTexSubImage2D(const Context *context,
                                         width, height, format, imageSize, data, &dataParam);
     paramBuffer.addParam(std::move(dataParam));
 
-    return CallCapture("glCompressedTexSubImage2D", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::CompressedTexSubImage2D, std::move(paramBuffer));
 }
 
 CallCapture CaptureCopyTexImage2D(const Context *context,
@@ -394,7 +394,7 @@ CallCapture CaptureCopyTexImage2D(const Context *context,
     paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
     paramBuffer.addValueParam("border", ParamType::TGLint, border);
 
-    return CallCapture("glCopyTexImage2D", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::CopyTexImage2D, std::move(paramBuffer));
 }
 
 CallCapture CaptureCopyTexSubImage2D(const Context *context,
@@ -419,7 +419,7 @@ CallCapture CaptureCopyTexSubImage2D(const Context *context,
     paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
     paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
 
-    return CallCapture("glCopyTexSubImage2D", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::CopyTexSubImage2D, std::move(paramBuffer));
 }
 
 CallCapture CaptureCreateProgram(const Context *context, bool isCallValid, GLuint returnValue)
@@ -430,7 +430,7 @@ CallCapture CaptureCreateProgram(const Context *context, bool isCallValid, GLuin
     InitParamValue(ParamType::TGLuint, returnValue, &returnValueCapture.value);
     paramBuffer.addReturnValue(std::move(returnValueCapture));
 
-    return CallCapture("glCreateProgram", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::CreateProgram, std::move(paramBuffer));
 }
 
 CallCapture CaptureCreateShader(const Context *context,
@@ -446,7 +446,7 @@ CallCapture CaptureCreateShader(const Context *context,
     InitParamValue(ParamType::TGLuint, returnValue, &returnValueCapture.value);
     paramBuffer.addReturnValue(std::move(returnValueCapture));
 
-    return CallCapture("glCreateShader", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::CreateShader, std::move(paramBuffer));
 }
 
 CallCapture CaptureCullFace(const Context *context, bool isCallValid, CullFaceMode modePacked)
@@ -455,7 +455,7 @@ CallCapture CaptureCullFace(const Context *context, bool isCallValid, CullFaceMo
 
     paramBuffer.addValueParam("modePacked", ParamType::TCullFaceMode, modePacked);
 
-    return CallCapture("glCullFace", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::CullFace, std::move(paramBuffer));
 }
 
 CallCapture CaptureDeleteBuffers(const Context *context,
@@ -472,7 +472,7 @@ CallCapture CaptureDeleteBuffers(const Context *context,
     CaptureDeleteBuffers_buffers(context, isCallValid, n, buffers, &buffersParam);
     paramBuffer.addParam(std::move(buffersParam));
 
-    return CallCapture("glDeleteBuffers", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::DeleteBuffers, std::move(paramBuffer));
 }
 
 CallCapture CaptureDeleteFramebuffers(const Context *context,
@@ -490,7 +490,7 @@ CallCapture CaptureDeleteFramebuffers(const Context *context,
                                            &framebuffersParam);
     paramBuffer.addParam(std::move(framebuffersParam));
 
-    return CallCapture("glDeleteFramebuffers", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::DeleteFramebuffers, std::move(paramBuffer));
 }
 
 CallCapture CaptureDeleteProgram(const Context *context, bool isCallValid, GLuint program)
@@ -499,7 +499,7 @@ CallCapture CaptureDeleteProgram(const Context *context, bool isCallValid, GLuin
 
     paramBuffer.addValueParam("program", ParamType::TGLuint, program);
 
-    return CallCapture("glDeleteProgram", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::DeleteProgram, std::move(paramBuffer));
 }
 
 CallCapture CaptureDeleteRenderbuffers(const Context *context,
@@ -517,7 +517,7 @@ CallCapture CaptureDeleteRenderbuffers(const Context *context,
                                              &renderbuffersParam);
     paramBuffer.addParam(std::move(renderbuffersParam));
 
-    return CallCapture("glDeleteRenderbuffers", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::DeleteRenderbuffers, std::move(paramBuffer));
 }
 
 CallCapture CaptureDeleteShader(const Context *context, bool isCallValid, GLuint shader)
@@ -526,7 +526,7 @@ CallCapture CaptureDeleteShader(const Context *context, bool isCallValid, GLuint
 
     paramBuffer.addValueParam("shader", ParamType::TGLuint, shader);
 
-    return CallCapture("glDeleteShader", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::DeleteShader, std::move(paramBuffer));
 }
 
 CallCapture CaptureDeleteTextures(const Context *context,
@@ -543,7 +543,7 @@ CallCapture CaptureDeleteTextures(const Context *context,
     CaptureDeleteTextures_textures(context, isCallValid, n, textures, &texturesParam);
     paramBuffer.addParam(std::move(texturesParam));
 
-    return CallCapture("glDeleteTextures", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::DeleteTextures, std::move(paramBuffer));
 }
 
 CallCapture CaptureDepthFunc(const Context *context, bool isCallValid, GLenum func)
@@ -552,7 +552,7 @@ CallCapture CaptureDepthFunc(const Context *context, bool isCallValid, GLenum fu
 
     paramBuffer.addValueParam("func", ParamType::TGLenum, func);
 
-    return CallCapture("glDepthFunc", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::DepthFunc, std::move(paramBuffer));
 }
 
 CallCapture CaptureDepthMask(const Context *context, bool isCallValid, GLboolean flag)
@@ -561,7 +561,7 @@ CallCapture CaptureDepthMask(const Context *context, bool isCallValid, GLboolean
 
     paramBuffer.addValueParam("flag", ParamType::TGLboolean, flag);
 
-    return CallCapture("glDepthMask", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::DepthMask, std::move(paramBuffer));
 }
 
 CallCapture CaptureDepthRangef(const Context *context, bool isCallValid, GLfloat n, GLfloat f)
@@ -571,7 +571,7 @@ CallCapture CaptureDepthRangef(const Context *context, bool isCallValid, GLfloat
     paramBuffer.addValueParam("n", ParamType::TGLfloat, n);
     paramBuffer.addValueParam("f", ParamType::TGLfloat, f);
 
-    return CallCapture("glDepthRangef", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::DepthRangef, std::move(paramBuffer));
 }
 
 CallCapture CaptureDetachShader(const Context *context,
@@ -584,7 +584,7 @@ CallCapture CaptureDetachShader(const Context *context,
     paramBuffer.addValueParam("program", ParamType::TGLuint, program);
     paramBuffer.addValueParam("shader", ParamType::TGLuint, shader);
 
-    return CallCapture("glDetachShader", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::DetachShader, std::move(paramBuffer));
 }
 
 CallCapture CaptureDisable(const Context *context, bool isCallValid, GLenum cap)
@@ -593,7 +593,7 @@ CallCapture CaptureDisable(const Context *context, bool isCallValid, GLenum cap)
 
     paramBuffer.addValueParam("cap", ParamType::TGLenum, cap);
 
-    return CallCapture("glDisable", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::Disable, std::move(paramBuffer));
 }
 
 CallCapture CaptureDisableVertexAttribArray(const Context *context, bool isCallValid, GLuint index)
@@ -602,7 +602,7 @@ CallCapture CaptureDisableVertexAttribArray(const Context *context, bool isCallV
 
     paramBuffer.addValueParam("index", ParamType::TGLuint, index);
 
-    return CallCapture("glDisableVertexAttribArray", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::DisableVertexAttribArray, std::move(paramBuffer));
 }
 
 CallCapture CaptureDrawArrays(const Context *context,
@@ -617,7 +617,7 @@ CallCapture CaptureDrawArrays(const Context *context,
     paramBuffer.addValueParam("first", ParamType::TGLint, first);
     paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
 
-    return CallCapture("glDrawArrays", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::DrawArrays, std::move(paramBuffer));
 }
 
 CallCapture CaptureDrawElements(const Context *context,
@@ -639,7 +639,7 @@ CallCapture CaptureDrawElements(const Context *context,
                                 &indicesParam);
     paramBuffer.addParam(std::move(indicesParam));
 
-    return CallCapture("glDrawElements", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::DrawElements, std::move(paramBuffer));
 }
 
 CallCapture CaptureEnable(const Context *context, bool isCallValid, GLenum cap)
@@ -648,7 +648,7 @@ CallCapture CaptureEnable(const Context *context, bool isCallValid, GLenum cap)
 
     paramBuffer.addValueParam("cap", ParamType::TGLenum, cap);
 
-    return CallCapture("glEnable", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::Enable, std::move(paramBuffer));
 }
 
 CallCapture CaptureEnableVertexAttribArray(const Context *context, bool isCallValid, GLuint index)
@@ -657,21 +657,21 @@ CallCapture CaptureEnableVertexAttribArray(const Context *context, bool isCallVa
 
     paramBuffer.addValueParam("index", ParamType::TGLuint, index);
 
-    return CallCapture("glEnableVertexAttribArray", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::EnableVertexAttribArray, std::move(paramBuffer));
 }
 
 CallCapture CaptureFinish(const Context *context, bool isCallValid)
 {
     ParamBuffer paramBuffer;
 
-    return CallCapture("glFinish", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::Finish, std::move(paramBuffer));
 }
 
 CallCapture CaptureFlush(const Context *context, bool isCallValid)
 {
     ParamBuffer paramBuffer;
 
-    return CallCapture("glFlush", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::Flush, std::move(paramBuffer));
 }
 
 CallCapture CaptureFramebufferRenderbuffer(const Context *context,
@@ -688,7 +688,7 @@ CallCapture CaptureFramebufferRenderbuffer(const Context *context,
     paramBuffer.addValueParam("renderbuffertarget", ParamType::TGLenum, renderbuffertarget);
     paramBuffer.addValueParam("renderbuffer", ParamType::TGLuint, renderbuffer);
 
-    return CallCapture("glFramebufferRenderbuffer", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::FramebufferRenderbuffer, std::move(paramBuffer));
 }
 
 CallCapture CaptureFramebufferTexture2D(const Context *context,
@@ -707,7 +707,7 @@ CallCapture CaptureFramebufferTexture2D(const Context *context,
     paramBuffer.addValueParam("texture", ParamType::TGLuint, texture);
     paramBuffer.addValueParam("level", ParamType::TGLint, level);
 
-    return CallCapture("glFramebufferTexture2D", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::FramebufferTexture2D, std::move(paramBuffer));
 }
 
 CallCapture CaptureFrontFace(const Context *context, bool isCallValid, GLenum mode)
@@ -716,7 +716,7 @@ CallCapture CaptureFrontFace(const Context *context, bool isCallValid, GLenum mo
 
     paramBuffer.addValueParam("mode", ParamType::TGLenum, mode);
 
-    return CallCapture("glFrontFace", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::FrontFace, std::move(paramBuffer));
 }
 
 CallCapture CaptureGenBuffers(const Context *context, bool isCallValid, GLsizei n, GLuint *buffers)
@@ -730,7 +730,7 @@ CallCapture CaptureGenBuffers(const Context *context, bool isCallValid, GLsizei
     CaptureGenBuffers_buffers(context, isCallValid, n, buffers, &buffersParam);
     paramBuffer.addParam(std::move(buffersParam));
 
-    return CallCapture("glGenBuffers", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::GenBuffers, std::move(paramBuffer));
 }
 
 CallCapture CaptureGenFramebuffers(const Context *context,
@@ -747,7 +747,7 @@ CallCapture CaptureGenFramebuffers(const Context *context,
     CaptureGenFramebuffers_framebuffers(context, isCallValid, n, framebuffers, &framebuffersParam);
     paramBuffer.addParam(std::move(framebuffersParam));
 
-    return CallCapture("glGenFramebuffers", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::GenFramebuffers, std::move(paramBuffer));
 }
 
 CallCapture CaptureGenRenderbuffers(const Context *context,
@@ -765,7 +765,7 @@ CallCapture CaptureGenRenderbuffers(const Context *context,
                                           &renderbuffersParam);
     paramBuffer.addParam(std::move(renderbuffersParam));
 
-    return CallCapture("glGenRenderbuffers", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::GenRenderbuffers, std::move(paramBuffer));
 }
 
 CallCapture CaptureGenTextures(const Context *context,
@@ -782,7 +782,7 @@ CallCapture CaptureGenTextures(const Context *context,
     CaptureGenTextures_textures(context, isCallValid, n, textures, &texturesParam);
     paramBuffer.addParam(std::move(texturesParam));
 
-    return CallCapture("glGenTextures", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::GenTextures, std::move(paramBuffer));
 }
 
 CallCapture CaptureGenerateMipmap(const Context *context,
@@ -793,7 +793,7 @@ CallCapture CaptureGenerateMipmap(const Context *context,
 
     paramBuffer.addValueParam("targetPacked", ParamType::TTextureType, targetPacked);
 
-    return CallCapture("glGenerateMipmap", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::GenerateMipmap, std::move(paramBuffer));
 }
 
 CallCapture CaptureGetActiveAttrib(const Context *context,
@@ -836,7 +836,7 @@ CallCapture CaptureGetActiveAttrib(const Context *context,
                                 name, &nameParam);
     paramBuffer.addParam(std::move(nameParam));
 
-    return CallCapture("glGetActiveAttrib", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::GetActiveAttrib, std::move(paramBuffer));
 }
 
 CallCapture CaptureGetActiveUniform(const Context *context,
@@ -879,7 +879,7 @@ CallCapture CaptureGetActiveUniform(const Context *context,
                                  name, &nameParam);
     paramBuffer.addParam(std::move(nameParam));
 
-    return CallCapture("glGetActiveUniform", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::GetActiveUniform, std::move(paramBuffer));
 }
 
 CallCapture CaptureGetAttachedShaders(const Context *context,
@@ -906,7 +906,7 @@ CallCapture CaptureGetAttachedShaders(const Context *context,
                                       &shadersParam);
     paramBuffer.addParam(std::move(shadersParam));
 
-    return CallCapture("glGetAttachedShaders", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::GetAttachedShaders, std::move(paramBuffer));
 }
 
 CallCapture CaptureGetAttribLocation(const Context *context,
@@ -928,7 +928,7 @@ CallCapture CaptureGetAttribLocation(const Context *context,
     InitParamValue(ParamType::TGLint, returnValue, &returnValueCapture.value);
     paramBuffer.addReturnValue(std::move(returnValueCapture));
 
-    return CallCapture("glGetAttribLocation", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::GetAttribLocation, std::move(paramBuffer));
 }
 
 CallCapture CaptureGetBooleanv(const Context *context,
@@ -945,7 +945,7 @@ CallCapture CaptureGetBooleanv(const Context *context,
     CaptureGetBooleanv_data(context, isCallValid, pname, data, &dataParam);
     paramBuffer.addParam(std::move(dataParam));
 
-    return CallCapture("glGetBooleanv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::GetBooleanv, std::move(paramBuffer));
 }
 
 CallCapture CaptureGetBufferParameteriv(const Context *context,
@@ -965,7 +965,7 @@ CallCapture CaptureGetBufferParameteriv(const Context *context,
                                        &paramsParam);
     paramBuffer.addParam(std::move(paramsParam));
 
-    return CallCapture("glGetBufferParameteriv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::GetBufferParameteriv, std::move(paramBuffer));
 }
 
 CallCapture CaptureGetError(const Context *context, bool isCallValid, GLenum returnValue)
@@ -976,7 +976,7 @@ CallCapture CaptureGetError(const Context *context, bool isCallValid, GLenum ret
     InitParamValue(ParamType::TGLenum, returnValue, &returnValueCapture.value);
     paramBuffer.addReturnValue(std::move(returnValueCapture));
 
-    return CallCapture("glGetError", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::GetError, std::move(paramBuffer));
 }
 
 CallCapture CaptureGetFloatv(const Context *context, bool isCallValid, GLenum pname, GLfloat *data)
@@ -990,7 +990,7 @@ CallCapture CaptureGetFloatv(const Context *context, bool isCallValid, GLenum pn
     CaptureGetFloatv_data(context, isCallValid, pname, data, &dataParam);
     paramBuffer.addParam(std::move(dataParam));
 
-    return CallCapture("glGetFloatv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::GetFloatv, std::move(paramBuffer));
 }
 
 CallCapture CaptureGetFramebufferAttachmentParameteriv(const Context *context,
@@ -1012,7 +1012,7 @@ CallCapture CaptureGetFramebufferAttachmentParameteriv(const Context *context,
                                                       pname, params, &paramsParam);
     paramBuffer.addParam(std::move(paramsParam));
 
-    return CallCapture("glGetFramebufferAttachmentParameteriv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::GetFramebufferAttachmentParameteriv, std::move(paramBuffer));
 }
 
 CallCapture CaptureGetIntegerv(const Context *context, bool isCallValid, GLenum pname, GLint *data)
@@ -1026,7 +1026,7 @@ CallCapture CaptureGetIntegerv(const Context *context, bool isCallValid, GLenum
     CaptureGetIntegerv_data(context, isCallValid, pname, data, &dataParam);
     paramBuffer.addParam(std::move(dataParam));
 
-    return CallCapture("glGetIntegerv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::GetIntegerv, std::move(paramBuffer));
 }
 
 CallCapture CaptureGetProgramInfoLog(const Context *context,
@@ -1053,7 +1053,7 @@ CallCapture CaptureGetProgramInfoLog(const Context *context,
                                      &infoLogParam);
     paramBuffer.addParam(std::move(infoLogParam));
 
-    return CallCapture("glGetProgramInfoLog", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::GetProgramInfoLog, std::move(paramBuffer));
 }
 
 CallCapture CaptureGetProgramiv(const Context *context,
@@ -1072,7 +1072,7 @@ CallCapture CaptureGetProgramiv(const Context *context,
     CaptureGetProgramiv_params(context, isCallValid, program, pname, params, &paramsParam);
     paramBuffer.addParam(std::move(paramsParam));
 
-    return CallCapture("glGetProgramiv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::GetProgramiv, std::move(paramBuffer));
 }
 
 CallCapture CaptureGetRenderbufferParameteriv(const Context *context,
@@ -1092,7 +1092,7 @@ CallCapture CaptureGetRenderbufferParameteriv(const Context *context,
                                              &paramsParam);
     paramBuffer.addParam(std::move(paramsParam));
 
-    return CallCapture("glGetRenderbufferParameteriv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::GetRenderbufferParameteriv, std::move(paramBuffer));
 }
 
 CallCapture CaptureGetShaderInfoLog(const Context *context,
@@ -1119,7 +1119,7 @@ CallCapture CaptureGetShaderInfoLog(const Context *context,
                                     &infoLogParam);
     paramBuffer.addParam(std::move(infoLogParam));
 
-    return CallCapture("glGetShaderInfoLog", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::GetShaderInfoLog, std::move(paramBuffer));
 }
 
 CallCapture CaptureGetShaderPrecisionFormat(const Context *context,
@@ -1146,7 +1146,7 @@ CallCapture CaptureGetShaderPrecisionFormat(const Context *context,
                                               range, precision, &precisionParam);
     paramBuffer.addParam(std::move(precisionParam));
 
-    return CallCapture("glGetShaderPrecisionFormat", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::GetShaderPrecisionFormat, std::move(paramBuffer));
 }
 
 CallCapture CaptureGetShaderSource(const Context *context,
@@ -1173,7 +1173,7 @@ CallCapture CaptureGetShaderSource(const Context *context,
                                   &sourceParam);
     paramBuffer.addParam(std::move(sourceParam));
 
-    return CallCapture("glGetShaderSource", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::GetShaderSource, std::move(paramBuffer));
 }
 
 CallCapture CaptureGetShaderiv(const Context *context,
@@ -1192,7 +1192,7 @@ CallCapture CaptureGetShaderiv(const Context *context,
     CaptureGetShaderiv_params(context, isCallValid, shader, pname, params, &paramsParam);
     paramBuffer.addParam(std::move(paramsParam));
 
-    return CallCapture("glGetShaderiv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::GetShaderiv, std::move(paramBuffer));
 }
 
 CallCapture CaptureGetString(const Context *context,
@@ -1208,7 +1208,7 @@ CallCapture CaptureGetString(const Context *context,
     InitParamValue(ParamType::TGLubyteConstPointer, returnValue, &returnValueCapture.value);
     paramBuffer.addReturnValue(std::move(returnValueCapture));
 
-    return CallCapture("glGetString", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::GetString, std::move(paramBuffer));
 }
 
 CallCapture CaptureGetTexParameterfv(const Context *context,
@@ -1228,7 +1228,7 @@ CallCapture CaptureGetTexParameterfv(const Context *context,
                                     &paramsParam);
     paramBuffer.addParam(std::move(paramsParam));
 
-    return CallCapture("glGetTexParameterfv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::GetTexParameterfv, std::move(paramBuffer));
 }
 
 CallCapture CaptureGetTexParameteriv(const Context *context,
@@ -1248,7 +1248,7 @@ CallCapture CaptureGetTexParameteriv(const Context *context,
                                     &paramsParam);
     paramBuffer.addParam(std::move(paramsParam));
 
-    return CallCapture("glGetTexParameteriv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::GetTexParameteriv, std::move(paramBuffer));
 }
 
 CallCapture CaptureGetUniformLocation(const Context *context,
@@ -1270,7 +1270,7 @@ CallCapture CaptureGetUniformLocation(const Context *context,
     InitParamValue(ParamType::TGLint, returnValue, &returnValueCapture.value);
     paramBuffer.addReturnValue(std::move(returnValueCapture));
 
-    return CallCapture("glGetUniformLocation", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::GetUniformLocation, std::move(paramBuffer));
 }
 
 CallCapture CaptureGetUniformfv(const Context *context,
@@ -1289,7 +1289,7 @@ CallCapture CaptureGetUniformfv(const Context *context,
     CaptureGetUniformfv_params(context, isCallValid, program, location, params, &paramsParam);
     paramBuffer.addParam(std::move(paramsParam));
 
-    return CallCapture("glGetUniformfv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::GetUniformfv, std::move(paramBuffer));
 }
 
 CallCapture CaptureGetUniformiv(const Context *context,
@@ -1308,7 +1308,7 @@ CallCapture CaptureGetUniformiv(const Context *context,
     CaptureGetUniformiv_params(context, isCallValid, program, location, params, &paramsParam);
     paramBuffer.addParam(std::move(paramsParam));
 
-    return CallCapture("glGetUniformiv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::GetUniformiv, std::move(paramBuffer));
 }
 
 CallCapture CaptureGetVertexAttribPointerv(const Context *context,
@@ -1328,7 +1328,7 @@ CallCapture CaptureGetVertexAttribPointerv(const Context *context,
                                            &pointerParam);
     paramBuffer.addParam(std::move(pointerParam));
 
-    return CallCapture("glGetVertexAttribPointerv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::GetVertexAttribPointerv, std::move(paramBuffer));
 }
 
 CallCapture CaptureGetVertexAttribfv(const Context *context,
@@ -1347,7 +1347,7 @@ CallCapture CaptureGetVertexAttribfv(const Context *context,
     CaptureGetVertexAttribfv_params(context, isCallValid, index, pname, params, &paramsParam);
     paramBuffer.addParam(std::move(paramsParam));
 
-    return CallCapture("glGetVertexAttribfv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::GetVertexAttribfv, std::move(paramBuffer));
 }
 
 CallCapture CaptureGetVertexAttribiv(const Context *context,
@@ -1366,7 +1366,7 @@ CallCapture CaptureGetVertexAttribiv(const Context *context,
     CaptureGetVertexAttribiv_params(context, isCallValid, index, pname, params, &paramsParam);
     paramBuffer.addParam(std::move(paramsParam));
 
-    return CallCapture("glGetVertexAttribiv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::GetVertexAttribiv, std::move(paramBuffer));
 }
 
 CallCapture CaptureHint(const Context *context, bool isCallValid, GLenum target, GLenum mode)
@@ -1376,7 +1376,7 @@ CallCapture CaptureHint(const Context *context, bool isCallValid, GLenum target,
     paramBuffer.addValueParam("target", ParamType::TGLenum, target);
     paramBuffer.addValueParam("mode", ParamType::TGLenum, mode);
 
-    return CallCapture("glHint", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::Hint, std::move(paramBuffer));
 }
 
 CallCapture CaptureIsBuffer(const Context *context,
@@ -1392,7 +1392,7 @@ CallCapture CaptureIsBuffer(const Context *context,
     InitParamValue(ParamType::TGLboolean, returnValue, &returnValueCapture.value);
     paramBuffer.addReturnValue(std::move(returnValueCapture));
 
-    return CallCapture("glIsBuffer", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::IsBuffer, std::move(paramBuffer));
 }
 
 CallCapture CaptureIsEnabled(const Context *context,
@@ -1408,7 +1408,7 @@ CallCapture CaptureIsEnabled(const Context *context,
     InitParamValue(ParamType::TGLboolean, returnValue, &returnValueCapture.value);
     paramBuffer.addReturnValue(std::move(returnValueCapture));
 
-    return CallCapture("glIsEnabled", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::IsEnabled, std::move(paramBuffer));
 }
 
 CallCapture CaptureIsFramebuffer(const Context *context,
@@ -1424,7 +1424,7 @@ CallCapture CaptureIsFramebuffer(const Context *context,
     InitParamValue(ParamType::TGLboolean, returnValue, &returnValueCapture.value);
     paramBuffer.addReturnValue(std::move(returnValueCapture));
 
-    return CallCapture("glIsFramebuffer", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::IsFramebuffer, std::move(paramBuffer));
 }
 
 CallCapture CaptureIsProgram(const Context *context,
@@ -1440,7 +1440,7 @@ CallCapture CaptureIsProgram(const Context *context,
     InitParamValue(ParamType::TGLboolean, returnValue, &returnValueCapture.value);
     paramBuffer.addReturnValue(std::move(returnValueCapture));
 
-    return CallCapture("glIsProgram", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::IsProgram, std::move(paramBuffer));
 }
 
 CallCapture CaptureIsRenderbuffer(const Context *context,
@@ -1456,7 +1456,7 @@ CallCapture CaptureIsRenderbuffer(const Context *context,
     InitParamValue(ParamType::TGLboolean, returnValue, &returnValueCapture.value);
     paramBuffer.addReturnValue(std::move(returnValueCapture));
 
-    return CallCapture("glIsRenderbuffer", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::IsRenderbuffer, std::move(paramBuffer));
 }
 
 CallCapture CaptureIsShader(const Context *context,
@@ -1472,7 +1472,7 @@ CallCapture CaptureIsShader(const Context *context,
     InitParamValue(ParamType::TGLboolean, returnValue, &returnValueCapture.value);
     paramBuffer.addReturnValue(std::move(returnValueCapture));
 
-    return CallCapture("glIsShader", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::IsShader, std::move(paramBuffer));
 }
 
 CallCapture CaptureIsTexture(const Context *context,
@@ -1488,7 +1488,7 @@ CallCapture CaptureIsTexture(const Context *context,
     InitParamValue(ParamType::TGLboolean, returnValue, &returnValueCapture.value);
     paramBuffer.addReturnValue(std::move(returnValueCapture));
 
-    return CallCapture("glIsTexture", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::IsTexture, std::move(paramBuffer));
 }
 
 CallCapture CaptureLineWidth(const Context *context, bool isCallValid, GLfloat width)
@@ -1497,7 +1497,7 @@ CallCapture CaptureLineWidth(const Context *context, bool isCallValid, GLfloat w
 
     paramBuffer.addValueParam("width", ParamType::TGLfloat, width);
 
-    return CallCapture("glLineWidth", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::LineWidth, std::move(paramBuffer));
 }
 
 CallCapture CaptureLinkProgram(const Context *context, bool isCallValid, GLuint program)
@@ -1506,7 +1506,7 @@ CallCapture CaptureLinkProgram(const Context *context, bool isCallValid, GLuint
 
     paramBuffer.addValueParam("program", ParamType::TGLuint, program);
 
-    return CallCapture("glLinkProgram", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::LinkProgram, std::move(paramBuffer));
 }
 
 CallCapture CapturePixelStorei(const Context *context, bool isCallValid, GLenum pname, GLint param)
@@ -1516,7 +1516,7 @@ CallCapture CapturePixelStorei(const Context *context, bool isCallValid, GLenum
     paramBuffer.addValueParam("pname", ParamType::TGLenum, pname);
     paramBuffer.addValueParam("param", ParamType::TGLint, param);
 
-    return CallCapture("glPixelStorei", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::PixelStorei, std::move(paramBuffer));
 }
 
 CallCapture CapturePolygonOffset(const Context *context,
@@ -1529,7 +1529,7 @@ CallCapture CapturePolygonOffset(const Context *context,
     paramBuffer.addValueParam("factor", ParamType::TGLfloat, factor);
     paramBuffer.addValueParam("units", ParamType::TGLfloat, units);
 
-    return CallCapture("glPolygonOffset", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::PolygonOffset, std::move(paramBuffer));
 }
 
 CallCapture CaptureReadPixels(const Context *context,
@@ -1557,14 +1557,14 @@ CallCapture CaptureReadPixels(const Context *context,
                              &pixelsParam);
     paramBuffer.addParam(std::move(pixelsParam));
 
-    return CallCapture("glReadPixels", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::ReadPixels, std::move(paramBuffer));
 }
 
 CallCapture CaptureReleaseShaderCompiler(const Context *context, bool isCallValid)
 {
     ParamBuffer paramBuffer;
 
-    return CallCapture("glReleaseShaderCompiler", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::ReleaseShaderCompiler, std::move(paramBuffer));
 }
 
 CallCapture CaptureRenderbufferStorage(const Context *context,
@@ -1581,7 +1581,7 @@ CallCapture CaptureRenderbufferStorage(const Context *context,
     paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
     paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
 
-    return CallCapture("glRenderbufferStorage", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::RenderbufferStorage, std::move(paramBuffer));
 }
 
 CallCapture CaptureSampleCoverage(const Context *context,
@@ -1594,7 +1594,7 @@ CallCapture CaptureSampleCoverage(const Context *context,
     paramBuffer.addValueParam("value", ParamType::TGLfloat, value);
     paramBuffer.addValueParam("invert", ParamType::TGLboolean, invert);
 
-    return CallCapture("glSampleCoverage", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::SampleCoverage, std::move(paramBuffer));
 }
 
 CallCapture CaptureScissor(const Context *context,
@@ -1611,7 +1611,7 @@ CallCapture CaptureScissor(const Context *context,
     paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
     paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
 
-    return CallCapture("glScissor", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::Scissor, std::move(paramBuffer));
 }
 
 CallCapture CaptureShaderBinary(const Context *context,
@@ -1642,7 +1642,7 @@ CallCapture CaptureShaderBinary(const Context *context,
 
     paramBuffer.addValueParam("length", ParamType::TGLsizei, length);
 
-    return CallCapture("glShaderBinary", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::ShaderBinary, std::move(paramBuffer));
 }
 
 CallCapture CaptureShaderSource(const Context *context,
@@ -1667,7 +1667,7 @@ CallCapture CaptureShaderSource(const Context *context,
     CaptureShaderSource_length(context, isCallValid, shader, count, string, length, &lengthParam);
     paramBuffer.addParam(std::move(lengthParam));
 
-    return CallCapture("glShaderSource", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::ShaderSource, std::move(paramBuffer));
 }
 
 CallCapture CaptureStencilFunc(const Context *context,
@@ -1682,7 +1682,7 @@ CallCapture CaptureStencilFunc(const Context *context,
     paramBuffer.addValueParam("ref", ParamType::TGLint, ref);
     paramBuffer.addValueParam("mask", ParamType::TGLuint, mask);
 
-    return CallCapture("glStencilFunc", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::StencilFunc, std::move(paramBuffer));
 }
 
 CallCapture CaptureStencilFuncSeparate(const Context *context,
@@ -1699,7 +1699,7 @@ CallCapture CaptureStencilFuncSeparate(const Context *context,
     paramBuffer.addValueParam("ref", ParamType::TGLint, ref);
     paramBuffer.addValueParam("mask", ParamType::TGLuint, mask);
 
-    return CallCapture("glStencilFuncSeparate", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::StencilFuncSeparate, std::move(paramBuffer));
 }
 
 CallCapture CaptureStencilMask(const Context *context, bool isCallValid, GLuint mask)
@@ -1708,7 +1708,7 @@ CallCapture CaptureStencilMask(const Context *context, bool isCallValid, GLuint
 
     paramBuffer.addValueParam("mask", ParamType::TGLuint, mask);
 
-    return CallCapture("glStencilMask", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::StencilMask, std::move(paramBuffer));
 }
 
 CallCapture CaptureStencilMaskSeparate(const Context *context,
@@ -1721,7 +1721,7 @@ CallCapture CaptureStencilMaskSeparate(const Context *context,
     paramBuffer.addValueParam("face", ParamType::TGLenum, face);
     paramBuffer.addValueParam("mask", ParamType::TGLuint, mask);
 
-    return CallCapture("glStencilMaskSeparate", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::StencilMaskSeparate, std::move(paramBuffer));
 }
 
 CallCapture CaptureStencilOp(const Context *context,
@@ -1736,7 +1736,7 @@ CallCapture CaptureStencilOp(const Context *context,
     paramBuffer.addValueParam("zfail", ParamType::TGLenum, zfail);
     paramBuffer.addValueParam("zpass", ParamType::TGLenum, zpass);
 
-    return CallCapture("glStencilOp", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::StencilOp, std::move(paramBuffer));
 }
 
 CallCapture CaptureStencilOpSeparate(const Context *context,
@@ -1753,7 +1753,7 @@ CallCapture CaptureStencilOpSeparate(const Context *context,
     paramBuffer.addValueParam("dpfail", ParamType::TGLenum, dpfail);
     paramBuffer.addValueParam("dppass", ParamType::TGLenum, dppass);
 
-    return CallCapture("glStencilOpSeparate", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::StencilOpSeparate, std::move(paramBuffer));
 }
 
 CallCapture CaptureTexImage2D(const Context *context,
@@ -1785,7 +1785,7 @@ CallCapture CaptureTexImage2D(const Context *context,
                              height, border, format, type, pixels, &pixelsParam);
     paramBuffer.addParam(std::move(pixelsParam));
 
-    return CallCapture("glTexImage2D", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::TexImage2D, std::move(paramBuffer));
 }
 
 CallCapture CaptureTexParameterf(const Context *context,
@@ -1800,7 +1800,7 @@ CallCapture CaptureTexParameterf(const Context *context,
     paramBuffer.addValueParam("pname", ParamType::TGLenum, pname);
     paramBuffer.addValueParam("param", ParamType::TGLfloat, param);
 
-    return CallCapture("glTexParameterf", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::TexParameterf, std::move(paramBuffer));
 }
 
 CallCapture CaptureTexParameterfv(const Context *context,
@@ -1819,7 +1819,7 @@ CallCapture CaptureTexParameterfv(const Context *context,
     CaptureTexParameterfv_params(context, isCallValid, targetPacked, pname, params, &paramsParam);
     paramBuffer.addParam(std::move(paramsParam));
 
-    return CallCapture("glTexParameterfv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::TexParameterfv, std::move(paramBuffer));
 }
 
 CallCapture CaptureTexParameteri(const Context *context,
@@ -1834,7 +1834,7 @@ CallCapture CaptureTexParameteri(const Context *context,
     paramBuffer.addValueParam("pname", ParamType::TGLenum, pname);
     paramBuffer.addValueParam("param", ParamType::TGLint, param);
 
-    return CallCapture("glTexParameteri", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::TexParameteri, std::move(paramBuffer));
 }
 
 CallCapture CaptureTexParameteriv(const Context *context,
@@ -1853,7 +1853,7 @@ CallCapture CaptureTexParameteriv(const Context *context,
     CaptureTexParameteriv_params(context, isCallValid, targetPacked, pname, params, &paramsParam);
     paramBuffer.addParam(std::move(paramsParam));
 
-    return CallCapture("glTexParameteriv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::TexParameteriv, std::move(paramBuffer));
 }
 
 CallCapture CaptureTexSubImage2D(const Context *context,
@@ -1885,7 +1885,7 @@ CallCapture CaptureTexSubImage2D(const Context *context,
                                 height, format, type, pixels, &pixelsParam);
     paramBuffer.addParam(std::move(pixelsParam));
 
-    return CallCapture("glTexSubImage2D", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::TexSubImage2D, std::move(paramBuffer));
 }
 
 CallCapture CaptureUniform1f(const Context *context, bool isCallValid, GLint location, GLfloat v0)
@@ -1895,7 +1895,7 @@ CallCapture CaptureUniform1f(const Context *context, bool isCallValid, GLint loc
     paramBuffer.addValueParam("location", ParamType::TGLint, location);
     paramBuffer.addValueParam("v0", ParamType::TGLfloat, v0);
 
-    return CallCapture("glUniform1f", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::Uniform1f, std::move(paramBuffer));
 }
 
 CallCapture CaptureUniform1fv(const Context *context,
@@ -1914,7 +1914,7 @@ CallCapture CaptureUniform1fv(const Context *context,
     CaptureUniform1fv_value(context, isCallValid, location, count, value, &valueParam);
     paramBuffer.addParam(std::move(valueParam));
 
-    return CallCapture("glUniform1fv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::Uniform1fv, std::move(paramBuffer));
 }
 
 CallCapture CaptureUniform1i(const Context *context, bool isCallValid, GLint location, GLint v0)
@@ -1924,7 +1924,7 @@ CallCapture CaptureUniform1i(const Context *context, bool isCallValid, GLint loc
     paramBuffer.addValueParam("location", ParamType::TGLint, location);
     paramBuffer.addValueParam("v0", ParamType::TGLint, v0);
 
-    return CallCapture("glUniform1i", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::Uniform1i, std::move(paramBuffer));
 }
 
 CallCapture CaptureUniform1iv(const Context *context,
@@ -1943,7 +1943,7 @@ CallCapture CaptureUniform1iv(const Context *context,
     CaptureUniform1iv_value(context, isCallValid, location, count, value, &valueParam);
     paramBuffer.addParam(std::move(valueParam));
 
-    return CallCapture("glUniform1iv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::Uniform1iv, std::move(paramBuffer));
 }
 
 CallCapture CaptureUniform2f(const Context *context,
@@ -1958,7 +1958,7 @@ CallCapture CaptureUniform2f(const Context *context,
     paramBuffer.addValueParam("v0", ParamType::TGLfloat, v0);
     paramBuffer.addValueParam("v1", ParamType::TGLfloat, v1);
 
-    return CallCapture("glUniform2f", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::Uniform2f, std::move(paramBuffer));
 }
 
 CallCapture CaptureUniform2fv(const Context *context,
@@ -1977,7 +1977,7 @@ CallCapture CaptureUniform2fv(const Context *context,
     CaptureUniform2fv_value(context, isCallValid, location, count, value, &valueParam);
     paramBuffer.addParam(std::move(valueParam));
 
-    return CallCapture("glUniform2fv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::Uniform2fv, std::move(paramBuffer));
 }
 
 CallCapture CaptureUniform2i(const Context *context,
@@ -1992,7 +1992,7 @@ CallCapture CaptureUniform2i(const Context *context,
     paramBuffer.addValueParam("v0", ParamType::TGLint, v0);
     paramBuffer.addValueParam("v1", ParamType::TGLint, v1);
 
-    return CallCapture("glUniform2i", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::Uniform2i, std::move(paramBuffer));
 }
 
 CallCapture CaptureUniform2iv(const Context *context,
@@ -2011,7 +2011,7 @@ CallCapture CaptureUniform2iv(const Context *context,
     CaptureUniform2iv_value(context, isCallValid, location, count, value, &valueParam);
     paramBuffer.addParam(std::move(valueParam));
 
-    return CallCapture("glUniform2iv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::Uniform2iv, std::move(paramBuffer));
 }
 
 CallCapture CaptureUniform3f(const Context *context,
@@ -2028,7 +2028,7 @@ CallCapture CaptureUniform3f(const Context *context,
     paramBuffer.addValueParam("v1", ParamType::TGLfloat, v1);
     paramBuffer.addValueParam("v2", ParamType::TGLfloat, v2);
 
-    return CallCapture("glUniform3f", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::Uniform3f, std::move(paramBuffer));
 }
 
 CallCapture CaptureUniform3fv(const Context *context,
@@ -2047,7 +2047,7 @@ CallCapture CaptureUniform3fv(const Context *context,
     CaptureUniform3fv_value(context, isCallValid, location, count, value, &valueParam);
     paramBuffer.addParam(std::move(valueParam));
 
-    return CallCapture("glUniform3fv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::Uniform3fv, std::move(paramBuffer));
 }
 
 CallCapture CaptureUniform3i(const Context *context,
@@ -2064,7 +2064,7 @@ CallCapture CaptureUniform3i(const Context *context,
     paramBuffer.addValueParam("v1", ParamType::TGLint, v1);
     paramBuffer.addValueParam("v2", ParamType::TGLint, v2);
 
-    return CallCapture("glUniform3i", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::Uniform3i, std::move(paramBuffer));
 }
 
 CallCapture CaptureUniform3iv(const Context *context,
@@ -2083,7 +2083,7 @@ CallCapture CaptureUniform3iv(const Context *context,
     CaptureUniform3iv_value(context, isCallValid, location, count, value, &valueParam);
     paramBuffer.addParam(std::move(valueParam));
 
-    return CallCapture("glUniform3iv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::Uniform3iv, std::move(paramBuffer));
 }
 
 CallCapture CaptureUniform4f(const Context *context,
@@ -2102,7 +2102,7 @@ CallCapture CaptureUniform4f(const Context *context,
     paramBuffer.addValueParam("v2", ParamType::TGLfloat, v2);
     paramBuffer.addValueParam("v3", ParamType::TGLfloat, v3);
 
-    return CallCapture("glUniform4f", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::Uniform4f, std::move(paramBuffer));
 }
 
 CallCapture CaptureUniform4fv(const Context *context,
@@ -2121,7 +2121,7 @@ CallCapture CaptureUniform4fv(const Context *context,
     CaptureUniform4fv_value(context, isCallValid, location, count, value, &valueParam);
     paramBuffer.addParam(std::move(valueParam));
 
-    return CallCapture("glUniform4fv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::Uniform4fv, std::move(paramBuffer));
 }
 
 CallCapture CaptureUniform4i(const Context *context,
@@ -2140,7 +2140,7 @@ CallCapture CaptureUniform4i(const Context *context,
     paramBuffer.addValueParam("v2", ParamType::TGLint, v2);
     paramBuffer.addValueParam("v3", ParamType::TGLint, v3);
 
-    return CallCapture("glUniform4i", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::Uniform4i, std::move(paramBuffer));
 }
 
 CallCapture CaptureUniform4iv(const Context *context,
@@ -2159,7 +2159,7 @@ CallCapture CaptureUniform4iv(const Context *context,
     CaptureUniform4iv_value(context, isCallValid, location, count, value, &valueParam);
     paramBuffer.addParam(std::move(valueParam));
 
-    return CallCapture("glUniform4iv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::Uniform4iv, std::move(paramBuffer));
 }
 
 CallCapture CaptureUniformMatrix2fv(const Context *context,
@@ -2181,7 +2181,7 @@ CallCapture CaptureUniformMatrix2fv(const Context *context,
                                   &valueParam);
     paramBuffer.addParam(std::move(valueParam));
 
-    return CallCapture("glUniformMatrix2fv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::UniformMatrix2fv, std::move(paramBuffer));
 }
 
 CallCapture CaptureUniformMatrix3fv(const Context *context,
@@ -2203,7 +2203,7 @@ CallCapture CaptureUniformMatrix3fv(const Context *context,
                                   &valueParam);
     paramBuffer.addParam(std::move(valueParam));
 
-    return CallCapture("glUniformMatrix3fv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::UniformMatrix3fv, std::move(paramBuffer));
 }
 
 CallCapture CaptureUniformMatrix4fv(const Context *context,
@@ -2225,7 +2225,7 @@ CallCapture CaptureUniformMatrix4fv(const Context *context,
                                   &valueParam);
     paramBuffer.addParam(std::move(valueParam));
 
-    return CallCapture("glUniformMatrix4fv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::UniformMatrix4fv, std::move(paramBuffer));
 }
 
 CallCapture CaptureUseProgram(const Context *context, bool isCallValid, GLuint program)
@@ -2234,7 +2234,7 @@ CallCapture CaptureUseProgram(const Context *context, bool isCallValid, GLuint p
 
     paramBuffer.addValueParam("program", ParamType::TGLuint, program);
 
-    return CallCapture("glUseProgram", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::UseProgram, std::move(paramBuffer));
 }
 
 CallCapture CaptureValidateProgram(const Context *context, bool isCallValid, GLuint program)
@@ -2243,7 +2243,7 @@ CallCapture CaptureValidateProgram(const Context *context, bool isCallValid, GLu
 
     paramBuffer.addValueParam("program", ParamType::TGLuint, program);
 
-    return CallCapture("glValidateProgram", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::ValidateProgram, std::move(paramBuffer));
 }
 
 CallCapture CaptureVertexAttrib1f(const Context *context, bool isCallValid, GLuint index, GLfloat x)
@@ -2253,7 +2253,7 @@ CallCapture CaptureVertexAttrib1f(const Context *context, bool isCallValid, GLui
     paramBuffer.addValueParam("index", ParamType::TGLuint, index);
     paramBuffer.addValueParam("x", ParamType::TGLfloat, x);
 
-    return CallCapture("glVertexAttrib1f", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::VertexAttrib1f, std::move(paramBuffer));
 }
 
 CallCapture CaptureVertexAttrib1fv(const Context *context,
@@ -2270,7 +2270,7 @@ CallCapture CaptureVertexAttrib1fv(const Context *context,
     CaptureVertexAttrib1fv_v(context, isCallValid, index, v, &vParam);
     paramBuffer.addParam(std::move(vParam));
 
-    return CallCapture("glVertexAttrib1fv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::VertexAttrib1fv, std::move(paramBuffer));
 }
 
 CallCapture CaptureVertexAttrib2f(const Context *context,
@@ -2285,7 +2285,7 @@ CallCapture CaptureVertexAttrib2f(const Context *context,
     paramBuffer.addValueParam("x", ParamType::TGLfloat, x);
     paramBuffer.addValueParam("y", ParamType::TGLfloat, y);
 
-    return CallCapture("glVertexAttrib2f", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::VertexAttrib2f, std::move(paramBuffer));
 }
 
 CallCapture CaptureVertexAttrib2fv(const Context *context,
@@ -2302,7 +2302,7 @@ CallCapture CaptureVertexAttrib2fv(const Context *context,
     CaptureVertexAttrib2fv_v(context, isCallValid, index, v, &vParam);
     paramBuffer.addParam(std::move(vParam));
 
-    return CallCapture("glVertexAttrib2fv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::VertexAttrib2fv, std::move(paramBuffer));
 }
 
 CallCapture CaptureVertexAttrib3f(const Context *context,
@@ -2319,7 +2319,7 @@ CallCapture CaptureVertexAttrib3f(const Context *context,
     paramBuffer.addValueParam("y", ParamType::TGLfloat, y);
     paramBuffer.addValueParam("z", ParamType::TGLfloat, z);
 
-    return CallCapture("glVertexAttrib3f", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::VertexAttrib3f, std::move(paramBuffer));
 }
 
 CallCapture CaptureVertexAttrib3fv(const Context *context,
@@ -2336,7 +2336,7 @@ CallCapture CaptureVertexAttrib3fv(const Context *context,
     CaptureVertexAttrib3fv_v(context, isCallValid, index, v, &vParam);
     paramBuffer.addParam(std::move(vParam));
 
-    return CallCapture("glVertexAttrib3fv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::VertexAttrib3fv, std::move(paramBuffer));
 }
 
 CallCapture CaptureVertexAttrib4f(const Context *context,
@@ -2355,7 +2355,7 @@ CallCapture CaptureVertexAttrib4f(const Context *context,
     paramBuffer.addValueParam("z", ParamType::TGLfloat, z);
     paramBuffer.addValueParam("w", ParamType::TGLfloat, w);
 
-    return CallCapture("glVertexAttrib4f", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::VertexAttrib4f, std::move(paramBuffer));
 }
 
 CallCapture CaptureVertexAttrib4fv(const Context *context,
@@ -2372,7 +2372,7 @@ CallCapture CaptureVertexAttrib4fv(const Context *context,
     CaptureVertexAttrib4fv_v(context, isCallValid, index, v, &vParam);
     paramBuffer.addParam(std::move(vParam));
 
-    return CallCapture("glVertexAttrib4fv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::VertexAttrib4fv, std::move(paramBuffer));
 }
 
 CallCapture CaptureVertexAttribPointer(const Context *context,
@@ -2398,7 +2398,7 @@ CallCapture CaptureVertexAttribPointer(const Context *context,
                                        stride, pointer, &pointerParam);
     paramBuffer.addParam(std::move(pointerParam));
 
-    return CallCapture("glVertexAttribPointer", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::VertexAttribPointer, std::move(paramBuffer));
 }
 
 CallCapture CaptureViewport(const Context *context,
@@ -2415,7 +2415,7 @@ CallCapture CaptureViewport(const Context *context,
     paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
     paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
 
-    return CallCapture("glViewport", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::Viewport, std::move(paramBuffer));
 }
 
 }  // namespace gl

src/libANGLE/capture_gles_3_0_autogen.cpp

@@ -29,7 +29,7 @@ CallCapture CaptureBeginQuery(const Context *context,
     paramBuffer.addValueParam("targetPacked", ParamType::TQueryType, targetPacked);
     paramBuffer.addValueParam("id", ParamType::TGLuint, id);
 
-    return CallCapture("glBeginQuery", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::BeginQuery, std::move(paramBuffer));
 }
 
 CallCapture CaptureBeginTransformFeedback(const Context *context,
@@ -41,7 +41,7 @@ CallCapture CaptureBeginTransformFeedback(const Context *context,
     paramBuffer.addValueParam("primitiveModePacked", ParamType::TPrimitiveMode,
                               primitiveModePacked);
 
-    return CallCapture("glBeginTransformFeedback", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::BeginTransformFeedback, std::move(paramBuffer));
 }
 
 CallCapture CaptureBindBufferBase(const Context *context,
@@ -56,7 +56,7 @@ CallCapture CaptureBindBufferBase(const Context *context,
     paramBuffer.addValueParam("index", ParamType::TGLuint, index);
     paramBuffer.addValueParam("buffer", ParamType::TGLuint, buffer);
 
-    return CallCapture("glBindBufferBase", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::BindBufferBase, std::move(paramBuffer));
 }
 
 CallCapture CaptureBindBufferRange(const Context *context,
@@ -75,7 +75,7 @@ CallCapture CaptureBindBufferRange(const Context *context,
     paramBuffer.addValueParam("offset", ParamType::TGLintptr, offset);
     paramBuffer.addValueParam("size", ParamType::TGLsizeiptr, size);
 
-    return CallCapture("glBindBufferRange", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::BindBufferRange, std::move(paramBuffer));
 }
 
 CallCapture CaptureBindSampler(const Context *context,
@@ -88,7 +88,7 @@ CallCapture CaptureBindSampler(const Context *context,
     paramBuffer.addValueParam("unit", ParamType::TGLuint, unit);
     paramBuffer.addValueParam("sampler", ParamType::TGLuint, sampler);
 
-    return CallCapture("glBindSampler", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::BindSampler, std::move(paramBuffer));
 }
 
 CallCapture CaptureBindTransformFeedback(const Context *context,
@@ -101,7 +101,7 @@ CallCapture CaptureBindTransformFeedback(const Context *context,
     paramBuffer.addValueParam("target", ParamType::TGLenum, target);
     paramBuffer.addValueParam("id", ParamType::TGLuint, id);
 
-    return CallCapture("glBindTransformFeedback", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::BindTransformFeedback, std::move(paramBuffer));
 }
 
 CallCapture CaptureBindVertexArray(const Context *context, bool isCallValid, GLuint array)
@@ -110,7 +110,7 @@ CallCapture CaptureBindVertexArray(const Context *context, bool isCallValid, GLu
 
     paramBuffer.addValueParam("array", ParamType::TGLuint, array);
 
-    return CallCapture("glBindVertexArray", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::BindVertexArray, std::move(paramBuffer));
 }
 
 CallCapture CaptureBlitFramebuffer(const Context *context,
@@ -139,7 +139,7 @@ CallCapture CaptureBlitFramebuffer(const Context *context,
     paramBuffer.addValueParam("mask", ParamType::TGLbitfield, mask);
     paramBuffer.addValueParam("filter", ParamType::TGLenum, filter);
 
-    return CallCapture("glBlitFramebuffer", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::BlitFramebuffer, std::move(paramBuffer));
 }
 
 CallCapture CaptureClearBufferfi(const Context *context,
@@ -156,7 +156,7 @@ CallCapture CaptureClearBufferfi(const Context *context,
     paramBuffer.addValueParam("depth", ParamType::TGLfloat, depth);
     paramBuffer.addValueParam("stencil", ParamType::TGLint, stencil);
 
-    return CallCapture("glClearBufferfi", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::ClearBufferfi, std::move(paramBuffer));
 }
 
 CallCapture CaptureClearBufferfv(const Context *context,
@@ -175,7 +175,7 @@ CallCapture CaptureClearBufferfv(const Context *context,
     CaptureClearBufferfv_value(context, isCallValid, buffer, drawbuffer, value, &valueParam);
     paramBuffer.addParam(std::move(valueParam));
 
-    return CallCapture("glClearBufferfv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::ClearBufferfv, std::move(paramBuffer));
 }
 
 CallCapture CaptureClearBufferiv(const Context *context,
@@ -194,7 +194,7 @@ CallCapture CaptureClearBufferiv(const Context *context,
     CaptureClearBufferiv_value(context, isCallValid, buffer, drawbuffer, value, &valueParam);
     paramBuffer.addParam(std::move(valueParam));
 
-    return CallCapture("glClearBufferiv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::ClearBufferiv, std::move(paramBuffer));
 }
 
 CallCapture CaptureClearBufferuiv(const Context *context,
@@ -213,7 +213,7 @@ CallCapture CaptureClearBufferuiv(const Context *context,
     CaptureClearBufferuiv_value(context, isCallValid, buffer, drawbuffer, value, &valueParam);
     paramBuffer.addParam(std::move(valueParam));
 
-    return CallCapture("glClearBufferuiv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::ClearBufferuiv, std::move(paramBuffer));
 }
 
 CallCapture CaptureClientWaitSync(const Context *context,
@@ -233,7 +233,7 @@ CallCapture CaptureClientWaitSync(const Context *context,
     InitParamValue(ParamType::TGLenum, returnValue, &returnValueCapture.value);
     paramBuffer.addReturnValue(std::move(returnValueCapture));
 
-    return CallCapture("glClientWaitSync", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::ClientWaitSync, std::move(paramBuffer));
 }
 
 CallCapture CaptureCompressedTexImage3D(const Context *context,
@@ -265,7 +265,7 @@ CallCapture CaptureCompressedTexImage3D(const Context *context,
                                      width, height, depth, border, imageSize, data, &dataParam);
     paramBuffer.addParam(std::move(dataParam));
 
-    return CallCapture("glCompressedTexImage3D", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::CompressedTexImage3D, std::move(paramBuffer));
 }
 
 CallCapture CaptureCompressedTexSubImage3D(const Context *context,
@@ -302,7 +302,7 @@ CallCapture CaptureCompressedTexSubImage3D(const Context *context,
                                         &dataParam);
     paramBuffer.addParam(std::move(dataParam));
 
-    return CallCapture("glCompressedTexSubImage3D", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::CompressedTexSubImage3D, std::move(paramBuffer));
 }
 
 CallCapture CaptureCopyBufferSubData(const Context *context,
@@ -321,7 +321,7 @@ CallCapture CaptureCopyBufferSubData(const Context *context,
     paramBuffer.addValueParam("writeOffset", ParamType::TGLintptr, writeOffset);
     paramBuffer.addValueParam("size", ParamType::TGLsizeiptr, size);
 
-    return CallCapture("glCopyBufferSubData", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::CopyBufferSubData, std::move(paramBuffer));
 }
 
 CallCapture CaptureCopyTexSubImage3D(const Context *context,
@@ -348,7 +348,7 @@ CallCapture CaptureCopyTexSubImage3D(const Context *context,
     paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
     paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
 
-    return CallCapture("glCopyTexSubImage3D", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::CopyTexSubImage3D, std::move(paramBuffer));
 }
 
 CallCapture CaptureDeleteQueries(const Context *context,
@@ -365,7 +365,7 @@ CallCapture CaptureDeleteQueries(const Context *context,
     CaptureDeleteQueries_ids(context, isCallValid, n, ids, &idsParam);
     paramBuffer.addParam(std::move(idsParam));
 
-    return CallCapture("glDeleteQueries", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::DeleteQueries, std::move(paramBuffer));
 }
 
 CallCapture CaptureDeleteSamplers(const Context *context,
@@ -382,7 +382,7 @@ CallCapture CaptureDeleteSamplers(const Context *context,
     CaptureDeleteSamplers_samplers(context, isCallValid, count, samplers, &samplersParam);
     paramBuffer.addParam(std::move(samplersParam));
 
-    return CallCapture("glDeleteSamplers", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::DeleteSamplers, std::move(paramBuffer));
 }
 
 CallCapture CaptureDeleteSync(const Context *context, bool isCallValid, GLsync sync)
@@ -391,7 +391,7 @@ CallCapture CaptureDeleteSync(const Context *context, bool isCallValid, GLsync s
 
     paramBuffer.addValueParam("sync", ParamType::TGLsync, sync);
 
-    return CallCapture("glDeleteSync", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::DeleteSync, std::move(paramBuffer));
 }
 
 CallCapture CaptureDeleteTransformFeedbacks(const Context *context,
@@ -408,7 +408,7 @@ CallCapture CaptureDeleteTransformFeedbacks(const Context *context,
     CaptureDeleteTransformFeedbacks_ids(context, isCallValid, n, ids, &idsParam);
     paramBuffer.addParam(std::move(idsParam));
 
-    return CallCapture("glDeleteTransformFeedbacks", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::DeleteTransformFeedbacks, std::move(paramBuffer));
 }
 
 CallCapture CaptureDeleteVertexArrays(const Context *context,
@@ -425,7 +425,7 @@ CallCapture CaptureDeleteVertexArrays(const Context *context,
     CaptureDeleteVertexArrays_arrays(context, isCallValid, n, arrays, &arraysParam);
     paramBuffer.addParam(std::move(arraysParam));
 
-    return CallCapture("glDeleteVertexArrays", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::DeleteVertexArrays, std::move(paramBuffer));
 }
 
 CallCapture CaptureDrawArraysInstanced(const Context *context,
@@ -442,7 +442,7 @@ CallCapture CaptureDrawArraysInstanced(const Context *context,
     paramBuffer.addValueParam("count", ParamType::TGLsizei, count);
     paramBuffer.addValueParam("instancecount", ParamType::TGLsizei, instancecount);
 
-    return CallCapture("glDrawArraysInstanced", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::DrawArraysInstanced, std::move(paramBuffer));
 }
 
 CallCapture CaptureDrawBuffers(const Context *context,
@@ -459,7 +459,7 @@ CallCapture CaptureDrawBuffers(const Context *context,
     CaptureDrawBuffers_bufs(context, isCallValid, n, bufs, &bufsParam);
     paramBuffer.addParam(std::move(bufsParam));
 
-    return CallCapture("glDrawBuffers", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::DrawBuffers, std::move(paramBuffer));
 }
 
 CallCapture CaptureDrawElementsInstanced(const Context *context,
@@ -484,7 +484,7 @@ CallCapture CaptureDrawElementsInstanced(const Context *context,
 
     paramBuffer.addValueParam("instancecount", ParamType::TGLsizei, instancecount);
 
-    return CallCapture("glDrawElementsInstanced", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::DrawElementsInstanced, std::move(paramBuffer));
 }
 
 CallCapture CaptureDrawRangeElements(const Context *context,
@@ -510,7 +510,7 @@ CallCapture CaptureDrawRangeElements(const Context *context,
                                      typePacked, indices, &indicesParam);
     paramBuffer.addParam(std::move(indicesParam));
 
-    return CallCapture("glDrawRangeElements", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::DrawRangeElements, std::move(paramBuffer));
 }
 
 CallCapture CaptureEndQuery(const Context *context, bool isCallValid, QueryType targetPacked)
@@ -519,14 +519,14 @@ CallCapture CaptureEndQuery(const Context *context, bool isCallValid, QueryType
 
     paramBuffer.addValueParam("targetPacked", ParamType::TQueryType, targetPacked);
 
-    return CallCapture("glEndQuery", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::EndQuery, std::move(paramBuffer));
 }
 
 CallCapture CaptureEndTransformFeedback(const Context *context, bool isCallValid)
 {
     ParamBuffer paramBuffer;
 
-    return CallCapture("glEndTransformFeedback", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::EndTransformFeedback, std::move(paramBuffer));
 }
 
 CallCapture CaptureFenceSync(const Context *context,
@@ -544,7 +544,7 @@ CallCapture CaptureFenceSync(const Context *context,
     InitParamValue(ParamType::TGLsync, returnValue, &returnValueCapture.value);
     paramBuffer.addReturnValue(std::move(returnValueCapture));
 
-    return CallCapture("glFenceSync", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::FenceSync, std::move(paramBuffer));
 }
 
 CallCapture CaptureFlushMappedBufferRange(const Context *context,
@@ -559,7 +559,7 @@ CallCapture CaptureFlushMappedBufferRange(const Context *context,
     paramBuffer.addValueParam("offset", ParamType::TGLintptr, offset);
     paramBuffer.addValueParam("length", ParamType::TGLsizeiptr, length);
 
-    return CallCapture("glFlushMappedBufferRange", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::FlushMappedBufferRange, std::move(paramBuffer));
 }
 
 CallCapture CaptureFramebufferTextureLayer(const Context *context,
@@ -578,7 +578,7 @@ CallCapture CaptureFramebufferTextureLayer(const Context *context,
     paramBuffer.addValueParam("level", ParamType::TGLint, level);
     paramBuffer.addValueParam("layer", ParamType::TGLint, layer);
 
-    return CallCapture("glFramebufferTextureLayer", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::FramebufferTextureLayer, std::move(paramBuffer));
 }
 
 CallCapture CaptureGenQueries(const Context *context, bool isCallValid, GLsizei n, GLuint *ids)
@@ -592,7 +592,7 @@ CallCapture CaptureGenQueries(const Context *context, bool isCallValid, GLsizei
     CaptureGenQueries_ids(context, isCallValid, n, ids, &idsParam);
     paramBuffer.addParam(std::move(idsParam));
 
-    return CallCapture("glGenQueries", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::GenQueries, std::move(paramBuffer));
 }
 
 CallCapture CaptureGenSamplers(const Context *context,
@@ -609,7 +609,7 @@ CallCapture CaptureGenSamplers(const Context *context,
     CaptureGenSamplers_samplers(context, isCallValid, count, samplers, &samplersParam);
     paramBuffer.addParam(std::move(samplersParam));
 
-    return CallCapture("glGenSamplers", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::GenSamplers, std::move(paramBuffer));
 }
 
 CallCapture CaptureGenTransformFeedbacks(const Context *context,
@@ -626,7 +626,7 @@ CallCapture CaptureGenTransformFeedbacks(const Context *context,
     CaptureGenTransformFeedbacks_ids(context, isCallValid, n, ids, &idsParam);
     paramBuffer.addParam(std::move(idsParam));
 
-    return CallCapture("glGenTransformFeedbacks", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::GenTransformFeedbacks, std::move(paramBuffer));
 }
 
 CallCapture CaptureGenVertexArrays(const Context *context,
@@ -643,7 +643,7 @@ CallCapture CaptureGenVertexArrays(const Context *context,
     CaptureGenVertexArrays_arrays(context, isCallValid, n, arrays, &arraysParam);
     paramBuffer.addParam(std::move(arraysParam));
 
-    return CallCapture("glGenVertexArrays", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::GenVertexArrays, std::move(paramBuffer));
 }
 
 CallCapture CaptureGetActiveUniformBlockName(const Context *context,
@@ -673,7 +673,7 @@ CallCapture CaptureGetActiveUniformBlockName(const Context *context,
                                                       uniformBlockName, &uniformBlockNameParam);
     paramBuffer.addParam(std::move(uniformBlockNameParam));
 
-    return CallCapture("glGetActiveUniformBlockName", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::GetActiveUniformBlockName, std::move(paramBuffer));
 }
 
 CallCapture CaptureGetActiveUniformBlockiv(const Context *context,
@@ -695,7 +695,7 @@ CallCapture CaptureGetActiveUniformBlockiv(const Context *context,
                                           params, &paramsParam);
     paramBuffer.addParam(std::move(paramsParam));
 
-    return CallCapture("glGetActiveUniformBlockiv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::GetActiveUniformBlockiv, std::move(paramBuffer));
 }
 
 CallCapture CaptureGetActiveUniformsiv(const Context *context,
@@ -725,7 +725,7 @@ CallCapture CaptureGetActiveUniformsiv(const Context *context,
                                       pname, params, &paramsParam);
     paramBuffer.addParam(std::move(paramsParam));
 
-    return CallCapture("glGetActiveUniformsiv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::GetActiveUniformsiv, std::move(paramBuffer));
 }
 
 CallCapture CaptureGetBufferParameteri64v(const Context *context,
@@ -745,7 +745,7 @@ CallCapture CaptureGetBufferParameteri64v(const Context *context,
                                          &paramsParam);
     paramBuffer.addParam(std::move(paramsParam));
 
-    return CallCapture("glGetBufferParameteri64v", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::GetBufferParameteri64v, std::move(paramBuffer));
 }
 
 CallCapture CaptureGetBufferPointerv(const Context *context,
@@ -765,7 +765,7 @@ CallCapture CaptureGetBufferPointerv(const Context *context,
                                     &paramsParam);
     paramBuffer.addParam(std::move(paramsParam));
 
-    return CallCapture("glGetBufferPointerv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::GetBufferPointerv, std::move(paramBuffer));
 }
 
 CallCapture CaptureGetFragDataLocation(const Context *context,
@@ -787,7 +787,7 @@ CallCapture CaptureGetFragDataLocation(const Context *context,
     InitParamValue(ParamType::TGLint, returnValue, &returnValueCapture.value);
     paramBuffer.addReturnValue(std::move(returnValueCapture));
 
-    return CallCapture("glGetFragDataLocation", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::GetFragDataLocation, std::move(paramBuffer));
 }
 
 CallCapture CaptureGetInteger64i_v(const Context *context,
@@ -806,7 +806,7 @@ CallCapture CaptureGetInteger64i_v(const Context *context,
     CaptureGetInteger64i_v_data(context, isCallValid, target, index, data, &dataParam);
     paramBuffer.addParam(std::move(dataParam));
 
-    return CallCapture("glGetInteger64i_v", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::GetInteger64i_v, std::move(paramBuffer));
 }
 
 CallCapture CaptureGetInteger64v(const Context *context,
@@ -823,7 +823,7 @@ CallCapture CaptureGetInteger64v(const Context *context,
     CaptureGetInteger64v_data(context, isCallValid, pname, data, &dataParam);
     paramBuffer.addParam(std::move(dataParam));
 
-    return CallCapture("glGetInteger64v", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::GetInteger64v, std::move(paramBuffer));
 }
 
 CallCapture CaptureGetIntegeri_v(const Context *context,
@@ -842,7 +842,7 @@ CallCapture CaptureGetIntegeri_v(const Context *context,
     CaptureGetIntegeri_v_data(context, isCallValid, target, index, data, &dataParam);
     paramBuffer.addParam(std::move(dataParam));
 
-    return CallCapture("glGetIntegeri_v", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::GetIntegeri_v, std::move(paramBuffer));
 }
 
 CallCapture CaptureGetInternalformativ(const Context *context,
@@ -866,7 +866,7 @@ CallCapture CaptureGetInternalformativ(const Context *context,
                                       params, &paramsParam);
     paramBuffer.addParam(std::move(paramsParam));
 
-    return CallCapture("glGetInternalformativ", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::GetInternalformativ, std::move(paramBuffer));
 }
 
 CallCapture CaptureGetProgramBinary(const Context *context,
@@ -900,7 +900,7 @@ CallCapture CaptureGetProgramBinary(const Context *context,
                                    binary, &binaryParam);
     paramBuffer.addParam(std::move(binaryParam));
 
-    return CallCapture("glGetProgramBinary", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::GetProgramBinary, std::move(paramBuffer));
 }
 
 CallCapture CaptureGetQueryObjectuiv(const Context *context,
@@ -919,7 +919,7 @@ CallCapture CaptureGetQueryObjectuiv(const Context *context,
     CaptureGetQueryObjectuiv_params(context, isCallValid, id, pname, params, &paramsParam);
     paramBuffer.addParam(std::move(paramsParam));
 
-    return CallCapture("glGetQueryObjectuiv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::GetQueryObjectuiv, std::move(paramBuffer));
 }
 
 CallCapture CaptureGetQueryiv(const Context *context,
@@ -938,7 +938,7 @@ CallCapture CaptureGetQueryiv(const Context *context,
     CaptureGetQueryiv_params(context, isCallValid, targetPacked, pname, params, &paramsParam);
     paramBuffer.addParam(std::move(paramsParam));
 
-    return CallCapture("glGetQueryiv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::GetQueryiv, std::move(paramBuffer));
 }
 
 CallCapture CaptureGetSamplerParameterfv(const Context *context,
@@ -957,7 +957,7 @@ CallCapture CaptureGetSamplerParameterfv(const Context *context,
     CaptureGetSamplerParameterfv_params(context, isCallValid, sampler, pname, params, &paramsParam);
     paramBuffer.addParam(std::move(paramsParam));
 
-    return CallCapture("glGetSamplerParameterfv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::GetSamplerParameterfv, std::move(paramBuffer));
 }
 
 CallCapture CaptureGetSamplerParameteriv(const Context *context,
@@ -976,7 +976,7 @@ CallCapture CaptureGetSamplerParameteriv(const Context *context,
     CaptureGetSamplerParameteriv_params(context, isCallValid, sampler, pname, params, &paramsParam);
     paramBuffer.addParam(std::move(paramsParam));
 
-    return CallCapture("glGetSamplerParameteriv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::GetSamplerParameteriv, std::move(paramBuffer));
 }
 
 CallCapture CaptureGetStringi(const Context *context,
@@ -994,7 +994,7 @@ CallCapture CaptureGetStringi(const Context *context,
     InitParamValue(ParamType::TGLubyteConstPointer, returnValue, &returnValueCapture.value);
     paramBuffer.addReturnValue(std::move(returnValueCapture));
 
-    return CallCapture("glGetStringi", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::GetStringi, std::move(paramBuffer));
 }
 
 CallCapture CaptureGetSynciv(const Context *context,
@@ -1023,7 +1023,7 @@ CallCapture CaptureGetSynciv(const Context *context,
                             &valuesParam);
     paramBuffer.addParam(std::move(valuesParam));
 
-    return CallCapture("glGetSynciv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::GetSynciv, std::move(paramBuffer));
 }
 
 CallCapture CaptureGetTransformFeedbackVarying(const Context *context,
@@ -1066,7 +1066,7 @@ CallCapture CaptureGetTransformFeedbackVarying(const Context *context,
                                             size, type, name, &nameParam);
     paramBuffer.addParam(std::move(nameParam));
 
-    return CallCapture("glGetTransformFeedbackVarying", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::GetTransformFeedbackVarying, std::move(paramBuffer));
 }
 
 CallCapture CaptureGetUniformBlockIndex(const Context *context,
@@ -1089,7 +1089,7 @@ CallCapture CaptureGetUniformBlockIndex(const Context *context,
     InitParamValue(ParamType::TGLuint, returnValue, &returnValueCapture.value);
     paramBuffer.addReturnValue(std::move(returnValueCapture));
 
-    return CallCapture("glGetUniformBlockIndex", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::GetUniformBlockIndex, std::move(paramBuffer));
 }
 
 CallCapture CaptureGetUniformIndices(const Context *context,
@@ -1116,7 +1116,7 @@ CallCapture CaptureGetUniformIndices(const Context *context,
                                             uniformNames, uniformIndices, &uniformIndicesParam);
     paramBuffer.addParam(std::move(uniformIndicesParam));
 
-    return CallCapture("glGetUniformIndices", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::GetUniformIndices, std::move(paramBuffer));
 }
 
 CallCapture CaptureGetUniformuiv(const Context *context,
@@ -1135,7 +1135,7 @@ CallCapture CaptureGetUniformuiv(const Context *context,
     CaptureGetUniformuiv_params(context, isCallValid, program, location, params, &paramsParam);
     paramBuffer.addParam(std::move(paramsParam));
 
-    return CallCapture("glGetUniformuiv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::GetUniformuiv, std::move(paramBuffer));
 }
 
 CallCapture CaptureGetVertexAttribIiv(const Context *context,
@@ -1154,7 +1154,7 @@ CallCapture CaptureGetVertexAttribIiv(const Context *context,
     CaptureGetVertexAttribIiv_params(context, isCallValid, index, pname, params, &paramsParam);
     paramBuffer.addParam(std::move(paramsParam));
 
-    return CallCapture("glGetVertexAttribIiv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::GetVertexAttribIiv, std::move(paramBuffer));
 }
 
 CallCapture CaptureGetVertexAttribIuiv(const Context *context,
@@ -1173,7 +1173,7 @@ CallCapture CaptureGetVertexAttribIuiv(const Context *context,
     CaptureGetVertexAttribIuiv_params(context, isCallValid, index, pname, params, &paramsParam);
     paramBuffer.addParam(std::move(paramsParam));
 
-    return CallCapture("glGetVertexAttribIuiv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::GetVertexAttribIuiv, std::move(paramBuffer));
 }
 
 CallCapture CaptureInvalidateFramebuffer(const Context *context,
@@ -1193,7 +1193,7 @@ CallCapture CaptureInvalidateFramebuffer(const Context *context,
                                              attachments, &attachmentsParam);
     paramBuffer.addParam(std::move(attachmentsParam));
 
-    return CallCapture("glInvalidateFramebuffer", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::InvalidateFramebuffer, std::move(paramBuffer));
 }
 
 CallCapture CaptureInvalidateSubFramebuffer(const Context *context,
@@ -1223,7 +1223,7 @@ CallCapture CaptureInvalidateSubFramebuffer(const Context *context,
     paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
     paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
 
-    return CallCapture("glInvalidateSubFramebuffer", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::InvalidateSubFramebuffer, std::move(paramBuffer));
 }
 
 CallCapture CaptureIsQuery(const Context *context,
@@ -1239,7 +1239,7 @@ CallCapture CaptureIsQuery(const Context *context,
     InitParamValue(ParamType::TGLboolean, returnValue, &returnValueCapture.value);
     paramBuffer.addReturnValue(std::move(returnValueCapture));
 
-    return CallCapture("glIsQuery", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::IsQuery, std::move(paramBuffer));
 }
 
 CallCapture CaptureIsSampler(const Context *context,
@@ -1255,7 +1255,7 @@ CallCapture CaptureIsSampler(const Context *context,
     InitParamValue(ParamType::TGLboolean, returnValue, &returnValueCapture.value);
     paramBuffer.addReturnValue(std::move(returnValueCapture));
 
-    return CallCapture("glIsSampler", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::IsSampler, std::move(paramBuffer));
 }
 
 CallCapture CaptureIsSync(const Context *context,
@@ -1271,7 +1271,7 @@ CallCapture CaptureIsSync(const Context *context,
     InitParamValue(ParamType::TGLboolean, returnValue, &returnValueCapture.value);
     paramBuffer.addReturnValue(std::move(returnValueCapture));
 
-    return CallCapture("glIsSync", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::IsSync, std::move(paramBuffer));
 }
 
 CallCapture CaptureIsTransformFeedback(const Context *context,
@@ -1287,7 +1287,7 @@ CallCapture CaptureIsTransformFeedback(const Context *context,
     InitParamValue(ParamType::TGLboolean, returnValue, &returnValueCapture.value);
     paramBuffer.addReturnValue(std::move(returnValueCapture));
 
-    return CallCapture("glIsTransformFeedback", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::IsTransformFeedback, std::move(paramBuffer));
 }
 
 CallCapture CaptureIsVertexArray(const Context *context,
@@ -1303,7 +1303,7 @@ CallCapture CaptureIsVertexArray(const Context *context,
     InitParamValue(ParamType::TGLboolean, returnValue, &returnValueCapture.value);
     paramBuffer.addReturnValue(std::move(returnValueCapture));
 
-    return CallCapture("glIsVertexArray", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::IsVertexArray, std::move(paramBuffer));
 }
 
 CallCapture CaptureMapBufferRange(const Context *context,
@@ -1325,14 +1325,14 @@ CallCapture CaptureMapBufferRange(const Context *context,
     InitParamValue(ParamType::TvoidPointer, returnValue, &returnValueCapture.value);
     paramBuffer.addReturnValue(std::move(returnValueCapture));
 
-    return CallCapture("glMapBufferRange", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::MapBufferRange, std::move(paramBuffer));
 }
 
 CallCapture CapturePauseTransformFeedback(const Context *context, bool isCallValid)
 {
     ParamBuffer paramBuffer;
 
-    return CallCapture("glPauseTransformFeedback", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::PauseTransformFeedback, std::move(paramBuffer));
 }
 
 CallCapture CaptureProgramBinary(const Context *context,
@@ -1355,7 +1355,7 @@ CallCapture CaptureProgramBinary(const Context *context,
 
     paramBuffer.addValueParam("length", ParamType::TGLsizei, length);
 
-    return CallCapture("glProgramBinary", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::ProgramBinary, std::move(paramBuffer));
 }
 
 CallCapture CaptureProgramParameteri(const Context *context,
@@ -1370,7 +1370,7 @@ CallCapture CaptureProgramParameteri(const Context *context,
     paramBuffer.addValueParam("pname", ParamType::TGLenum, pname);
     paramBuffer.addValueParam("value", ParamType::TGLint, value);
 
-    return CallCapture("glProgramParameteri", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::ProgramParameteri, std::move(paramBuffer));
 }
 
 CallCapture CaptureReadBuffer(const Context *context, bool isCallValid, GLenum src)
@@ -1379,7 +1379,7 @@ CallCapture CaptureReadBuffer(const Context *context, bool isCallValid, GLenum s
 
     paramBuffer.addValueParam("src", ParamType::TGLenum, src);
 
-    return CallCapture("glReadBuffer", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::ReadBuffer, std::move(paramBuffer));
 }
 
 CallCapture CaptureRenderbufferStorageMultisample(const Context *context,
@@ -1398,14 +1398,14 @@ CallCapture CaptureRenderbufferStorageMultisample(const Context *context,
     paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
     paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
 
-    return CallCapture("glRenderbufferStorageMultisample", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::RenderbufferStorageMultisample, std::move(paramBuffer));
 }
 
 CallCapture CaptureResumeTransformFeedback(const Context *context, bool isCallValid)
 {
     ParamBuffer paramBuffer;
 
-    return CallCapture("glResumeTransformFeedback", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::ResumeTransformFeedback, std::move(paramBuffer));
 }
 
 CallCapture CaptureSamplerParameterf(const Context *context,
@@ -1420,7 +1420,7 @@ CallCapture CaptureSamplerParameterf(const Context *context,
     paramBuffer.addValueParam("pname", ParamType::TGLenum, pname);
     paramBuffer.addValueParam("param", ParamType::TGLfloat, param);
 
-    return CallCapture("glSamplerParameterf", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::SamplerParameterf, std::move(paramBuffer));
 }
 
 CallCapture CaptureSamplerParameterfv(const Context *context,
@@ -1439,7 +1439,7 @@ CallCapture CaptureSamplerParameterfv(const Context *context,
     CaptureSamplerParameterfv_param(context, isCallValid, sampler, pname, param, &paramParam);
     paramBuffer.addParam(std::move(paramParam));
 
-    return CallCapture("glSamplerParameterfv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::SamplerParameterfv, std::move(paramBuffer));
 }
 
 CallCapture CaptureSamplerParameteri(const Context *context,
@@ -1454,7 +1454,7 @@ CallCapture CaptureSamplerParameteri(const Context *context,
     paramBuffer.addValueParam("pname", ParamType::TGLenum, pname);
     paramBuffer.addValueParam("param", ParamType::TGLint, param);
 
-    return CallCapture("glSamplerParameteri", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::SamplerParameteri, std::move(paramBuffer));
 }
 
 CallCapture CaptureSamplerParameteriv(const Context *context,
@@ -1473,7 +1473,7 @@ CallCapture CaptureSamplerParameteriv(const Context *context,
     CaptureSamplerParameteriv_param(context, isCallValid, sampler, pname, param, &paramParam);
     paramBuffer.addParam(std::move(paramParam));
 
-    return CallCapture("glSamplerParameteriv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::SamplerParameteriv, std::move(paramBuffer));
 }
 
 CallCapture CaptureTexImage3D(const Context *context,
@@ -1507,7 +1507,7 @@ CallCapture CaptureTexImage3D(const Context *context,
                              height, depth, border, format, type, pixels, &pixelsParam);
     paramBuffer.addParam(std::move(pixelsParam));
 
-    return CallCapture("glTexImage3D", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::TexImage3D, std::move(paramBuffer));
 }
 
 CallCapture CaptureTexStorage2D(const Context *context,
@@ -1526,7 +1526,7 @@ CallCapture CaptureTexStorage2D(const Context *context,
     paramBuffer.addValueParam("width", ParamType::TGLsizei, width);
     paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
 
-    return CallCapture("glTexStorage2D", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::TexStorage2D, std::move(paramBuffer));
 }
 
 CallCapture CaptureTexStorage3D(const Context *context,
@@ -1547,7 +1547,7 @@ CallCapture CaptureTexStorage3D(const Context *context,
     paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
     paramBuffer.addValueParam("depth", ParamType::TGLsizei, depth);
 
-    return CallCapture("glTexStorage3D", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::TexStorage3D, std::move(paramBuffer));
 }
 
 CallCapture CaptureTexSubImage3D(const Context *context,
@@ -1583,7 +1583,7 @@ CallCapture CaptureTexSubImage3D(const Context *context,
                                 zoffset, width, height, depth, format, type, pixels, &pixelsParam);
     paramBuffer.addParam(std::move(pixelsParam));
 
-    return CallCapture("glTexSubImage3D", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::TexSubImage3D, std::move(paramBuffer));
 }
 
 CallCapture CaptureTransformFeedbackVaryings(const Context *context,
@@ -1606,7 +1606,7 @@ CallCapture CaptureTransformFeedbackVaryings(const Context *context,
 
     paramBuffer.addValueParam("bufferMode", ParamType::TGLenum, bufferMode);
 
-    return CallCapture("glTransformFeedbackVaryings", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::TransformFeedbackVaryings, std::move(paramBuffer));
 }
 
 CallCapture CaptureUniform1ui(const Context *context, bool isCallValid, GLint location, GLuint v0)
@@ -1616,7 +1616,7 @@ CallCapture CaptureUniform1ui(const Context *context, bool isCallValid, GLint lo
     paramBuffer.addValueParam("location", ParamType::TGLint, location);
     paramBuffer.addValueParam("v0", ParamType::TGLuint, v0);
 
-    return CallCapture("glUniform1ui", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::Uniform1ui, std::move(paramBuffer));
 }
 
 CallCapture CaptureUniform1uiv(const Context *context,
@@ -1635,7 +1635,7 @@ CallCapture CaptureUniform1uiv(const Context *context,
     CaptureUniform1uiv_value(context, isCallValid, location, count, value, &valueParam);
     paramBuffer.addParam(std::move(valueParam));
 
-    return CallCapture("glUniform1uiv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::Uniform1uiv, std::move(paramBuffer));
 }
 
 CallCapture CaptureUniform2ui(const Context *context,
@@ -1650,7 +1650,7 @@ CallCapture CaptureUniform2ui(const Context *context,
     paramBuffer.addValueParam("v0", ParamType::TGLuint, v0);
     paramBuffer.addValueParam("v1", ParamType::TGLuint, v1);
 
-    return CallCapture("glUniform2ui", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::Uniform2ui, std::move(paramBuffer));
 }
 
 CallCapture CaptureUniform2uiv(const Context *context,
@@ -1669,7 +1669,7 @@ CallCapture CaptureUniform2uiv(const Context *context,
     CaptureUniform2uiv_value(context, isCallValid, location, count, value, &valueParam);
     paramBuffer.addParam(std::move(valueParam));
 
-    return CallCapture("glUniform2uiv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::Uniform2uiv, std::move(paramBuffer));
 }
 
 CallCapture CaptureUniform3ui(const Context *context,
@@ -1686,7 +1686,7 @@ CallCapture CaptureUniform3ui(const Context *context,
     paramBuffer.addValueParam("v1", ParamType::TGLuint, v1);
     paramBuffer.addValueParam("v2", ParamType::TGLuint, v2);
 
-    return CallCapture("glUniform3ui", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::Uniform3ui, std::move(paramBuffer));
 }
 
 CallCapture CaptureUniform3uiv(const Context *context,
@@ -1705,7 +1705,7 @@ CallCapture CaptureUniform3uiv(const Context *context,
     CaptureUniform3uiv_value(context, isCallValid, location, count, value, &valueParam);
     paramBuffer.addParam(std::move(valueParam));
 
-    return CallCapture("glUniform3uiv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::Uniform3uiv, std::move(paramBuffer));
 }
 
 CallCapture CaptureUniform4ui(const Context *context,
@@ -1724,7 +1724,7 @@ CallCapture CaptureUniform4ui(const Context *context,
     paramBuffer.addValueParam("v2", ParamType::TGLuint, v2);
     paramBuffer.addValueParam("v3", ParamType::TGLuint, v3);
 
-    return CallCapture("glUniform4ui", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::Uniform4ui, std::move(paramBuffer));
 }
 
 CallCapture CaptureUniform4uiv(const Context *context,
@@ -1743,7 +1743,7 @@ CallCapture CaptureUniform4uiv(const Context *context,
     CaptureUniform4uiv_value(context, isCallValid, location, count, value, &valueParam);
     paramBuffer.addParam(std::move(valueParam));
 
-    return CallCapture("glUniform4uiv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::Uniform4uiv, std::move(paramBuffer));
 }
 
 CallCapture CaptureUniformBlockBinding(const Context *context,
@@ -1758,7 +1758,7 @@ CallCapture CaptureUniformBlockBinding(const Context *context,
     paramBuffer.addValueParam("uniformBlockIndex", ParamType::TGLuint, uniformBlockIndex);
     paramBuffer.addValueParam("uniformBlockBinding", ParamType::TGLuint, uniformBlockBinding);
 
-    return CallCapture("glUniformBlockBinding", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::UniformBlockBinding, std::move(paramBuffer));
 }
 
 CallCapture CaptureUniformMatrix2x3fv(const Context *context,
@@ -1780,7 +1780,7 @@ CallCapture CaptureUniformMatrix2x3fv(const Context *context,
                                     &valueParam);
     paramBuffer.addParam(std::move(valueParam));
 
-    return CallCapture("glUniformMatrix2x3fv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::UniformMatrix2x3fv, std::move(paramBuffer));
 }
 
 CallCapture CaptureUniformMatrix2x4fv(const Context *context,
@@ -1802,7 +1802,7 @@ CallCapture CaptureUniformMatrix2x4fv(const Context *context,
                                     &valueParam);
     paramBuffer.addParam(std::move(valueParam));
 
-    return CallCapture("glUniformMatrix2x4fv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::UniformMatrix2x4fv, std::move(paramBuffer));
 }
 
 CallCapture CaptureUniformMatrix3x2fv(const Context *context,
@@ -1824,7 +1824,7 @@ CallCapture CaptureUniformMatrix3x2fv(const Context *context,
                                     &valueParam);
     paramBuffer.addParam(std::move(valueParam));
 
-    return CallCapture("glUniformMatrix3x2fv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::UniformMatrix3x2fv, std::move(paramBuffer));
 }
 
 CallCapture CaptureUniformMatrix3x4fv(const Context *context,
@@ -1846,7 +1846,7 @@ CallCapture CaptureUniformMatrix3x4fv(const Context *context,
                                     &valueParam);
     paramBuffer.addParam(std::move(valueParam));
 
-    return CallCapture("glUniformMatrix3x4fv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::UniformMatrix3x4fv, std::move(paramBuffer));
 }
 
 CallCapture CaptureUniformMatrix4x2fv(const Context *context,
@@ -1868,7 +1868,7 @@ CallCapture CaptureUniformMatrix4x2fv(const Context *context,
                                     &valueParam);
     paramBuffer.addParam(std::move(valueParam));
 
-    return CallCapture("glUniformMatrix4x2fv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::UniformMatrix4x2fv, std::move(paramBuffer));
 }
 
 CallCapture CaptureUniformMatrix4x3fv(const Context *context,
@@ -1890,7 +1890,7 @@ CallCapture CaptureUniformMatrix4x3fv(const Context *context,
                                     &valueParam);
     paramBuffer.addParam(std::move(valueParam));
 
-    return CallCapture("glUniformMatrix4x3fv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::UniformMatrix4x3fv, std::move(paramBuffer));
 }
 
 CallCapture CaptureUnmapBuffer(const Context *context,
@@ -1906,7 +1906,7 @@ CallCapture CaptureUnmapBuffer(const Context *context,
     InitParamValue(ParamType::TGLboolean, returnValue, &returnValueCapture.value);
     paramBuffer.addReturnValue(std::move(returnValueCapture));
 
-    return CallCapture("glUnmapBuffer", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::UnmapBuffer, std::move(paramBuffer));
 }
 
 CallCapture CaptureVertexAttribDivisor(const Context *context,
@@ -1919,7 +1919,7 @@ CallCapture CaptureVertexAttribDivisor(const Context *context,
     paramBuffer.addValueParam("index", ParamType::TGLuint, index);
     paramBuffer.addValueParam("divisor", ParamType::TGLuint, divisor);
 
-    return CallCapture("glVertexAttribDivisor", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::VertexAttribDivisor, std::move(paramBuffer));
 }
 
 CallCapture CaptureVertexAttribI4i(const Context *context,
@@ -1938,7 +1938,7 @@ CallCapture CaptureVertexAttribI4i(const Context *context,
     paramBuffer.addValueParam("z", ParamType::TGLint, z);
     paramBuffer.addValueParam("w", ParamType::TGLint, w);
 
-    return CallCapture("glVertexAttribI4i", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::VertexAttribI4i, std::move(paramBuffer));
 }
 
 CallCapture CaptureVertexAttribI4iv(const Context *context,
@@ -1955,7 +1955,7 @@ CallCapture CaptureVertexAttribI4iv(const Context *context,
     CaptureVertexAttribI4iv_v(context, isCallValid, index, v, &vParam);
     paramBuffer.addParam(std::move(vParam));
 
-    return CallCapture("glVertexAttribI4iv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::VertexAttribI4iv, std::move(paramBuffer));
 }
 
 CallCapture CaptureVertexAttribI4ui(const Context *context,
@@ -1974,7 +1974,7 @@ CallCapture CaptureVertexAttribI4ui(const Context *context,
     paramBuffer.addValueParam("z", ParamType::TGLuint, z);
     paramBuffer.addValueParam("w", ParamType::TGLuint, w);
 
-    return CallCapture("glVertexAttribI4ui", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::VertexAttribI4ui, std::move(paramBuffer));
 }
 
 CallCapture CaptureVertexAttribI4uiv(const Context *context,
@@ -1991,7 +1991,7 @@ CallCapture CaptureVertexAttribI4uiv(const Context *context,
     CaptureVertexAttribI4uiv_v(context, isCallValid, index, v, &vParam);
     paramBuffer.addParam(std::move(vParam));
 
-    return CallCapture("glVertexAttribI4uiv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::VertexAttribI4uiv, std::move(paramBuffer));
 }
 
 CallCapture CaptureVertexAttribIPointer(const Context *context,
@@ -2015,7 +2015,7 @@ CallCapture CaptureVertexAttribIPointer(const Context *context,
                                         pointer, &pointerParam);
     paramBuffer.addParam(std::move(pointerParam));
 
-    return CallCapture("glVertexAttribIPointer", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::VertexAttribIPointer, std::move(paramBuffer));
 }
 
 CallCapture CaptureWaitSync(const Context *context,
@@ -2030,7 +2030,7 @@ CallCapture CaptureWaitSync(const Context *context,
     paramBuffer.addValueParam("flags", ParamType::TGLbitfield, flags);
     paramBuffer.addValueParam("timeout", ParamType::TGLuint64, timeout);
 
-    return CallCapture("glWaitSync", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::WaitSync, std::move(paramBuffer));
 }
 
 }  // namespace gl

src/libANGLE/capture_gles_3_1_autogen.cpp

@@ -29,7 +29,7 @@ CallCapture CaptureActiveShaderProgram(const Context *context,
     paramBuffer.addValueParam("pipeline", ParamType::TGLuint, pipeline);
     paramBuffer.addValueParam("program", ParamType::TGLuint, program);
 
-    return CallCapture("glActiveShaderProgram", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::ActiveShaderProgram, std::move(paramBuffer));
 }
 
 CallCapture CaptureBindImageTexture(const Context *context,
@@ -52,7 +52,7 @@ CallCapture CaptureBindImageTexture(const Context *context,
     paramBuffer.addValueParam("access", ParamType::TGLenum, access);
     paramBuffer.addValueParam("format", ParamType::TGLenum, format);
 
-    return CallCapture("glBindImageTexture", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::BindImageTexture, std::move(paramBuffer));
 }
 
 CallCapture CaptureBindProgramPipeline(const Context *context, bool isCallValid, GLuint pipeline)
@@ -61,7 +61,7 @@ CallCapture CaptureBindProgramPipeline(const Context *context, bool isCallValid,
 
     paramBuffer.addValueParam("pipeline", ParamType::TGLuint, pipeline);
 
-    return CallCapture("glBindProgramPipeline", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::BindProgramPipeline, std::move(paramBuffer));
 }
 
 CallCapture CaptureBindVertexBuffer(const Context *context,
@@ -78,7 +78,7 @@ CallCapture CaptureBindVertexBuffer(const Context *context,
     paramBuffer.addValueParam("offset", ParamType::TGLintptr, offset);
     paramBuffer.addValueParam("stride", ParamType::TGLsizei, stride);
 
-    return CallCapture("glBindVertexBuffer", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::BindVertexBuffer, std::move(paramBuffer));
 }
 
 CallCapture CaptureCreateShaderProgramv(const Context *context,
@@ -103,7 +103,7 @@ CallCapture CaptureCreateShaderProgramv(const Context *context,
     InitParamValue(ParamType::TGLuint, returnValue, &returnValueCapture.value);
     paramBuffer.addReturnValue(std::move(returnValueCapture));
 
-    return CallCapture("glCreateShaderProgramv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::CreateShaderProgramv, std::move(paramBuffer));
 }
 
 CallCapture CaptureDeleteProgramPipelines(const Context *context,
@@ -120,7 +120,7 @@ CallCapture CaptureDeleteProgramPipelines(const Context *context,
     CaptureDeleteProgramPipelines_pipelines(context, isCallValid, n, pipelines, &pipelinesParam);
     paramBuffer.addParam(std::move(pipelinesParam));
 
-    return CallCapture("glDeleteProgramPipelines", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::DeleteProgramPipelines, std::move(paramBuffer));
 }
 
 CallCapture CaptureDispatchCompute(const Context *context,
@@ -135,7 +135,7 @@ CallCapture CaptureDispatchCompute(const Context *context,
     paramBuffer.addValueParam("num_groups_y", ParamType::TGLuint, num_groups_y);
     paramBuffer.addValueParam("num_groups_z", ParamType::TGLuint, num_groups_z);
 
-    return CallCapture("glDispatchCompute", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::DispatchCompute, std::move(paramBuffer));
 }
 
 CallCapture CaptureDispatchComputeIndirect(const Context *context,
@@ -146,7 +146,7 @@ CallCapture CaptureDispatchComputeIndirect(const Context *context,
 
     paramBuffer.addValueParam("indirect", ParamType::TGLintptr, indirect);
 
-    return CallCapture("glDispatchComputeIndirect", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::DispatchComputeIndirect, std::move(paramBuffer));
 }
 
 CallCapture CaptureDrawArraysIndirect(const Context *context,
@@ -163,7 +163,7 @@ CallCapture CaptureDrawArraysIndirect(const Context *context,
     CaptureDrawArraysIndirect_indirect(context, isCallValid, modePacked, indirect, &indirectParam);
     paramBuffer.addParam(std::move(indirectParam));
 
-    return CallCapture("glDrawArraysIndirect", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::DrawArraysIndirect, std::move(paramBuffer));
 }
 
 CallCapture CaptureDrawElementsIndirect(const Context *context,
@@ -183,7 +183,7 @@ CallCapture CaptureDrawElementsIndirect(const Context *context,
                                          &indirectParam);
     paramBuffer.addParam(std::move(indirectParam));
 
-    return CallCapture("glDrawElementsIndirect", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::DrawElementsIndirect, std::move(paramBuffer));
 }
 
 CallCapture CaptureFramebufferParameteri(const Context *context,
@@ -198,7 +198,7 @@ CallCapture CaptureFramebufferParameteri(const Context *context,
     paramBuffer.addValueParam("pname", ParamType::TGLenum, pname);
     paramBuffer.addValueParam("param", ParamType::TGLint, param);
 
-    return CallCapture("glFramebufferParameteri", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::FramebufferParameteri, std::move(paramBuffer));
 }
 
 CallCapture CaptureGenProgramPipelines(const Context *context,
@@ -215,7 +215,7 @@ CallCapture CaptureGenProgramPipelines(const Context *context,
     CaptureGenProgramPipelines_pipelines(context, isCallValid, n, pipelines, &pipelinesParam);
     paramBuffer.addParam(std::move(pipelinesParam));
 
-    return CallCapture("glGenProgramPipelines", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::GenProgramPipelines, std::move(paramBuffer));
 }
 
 CallCapture CaptureGetBooleani_v(const Context *context,
@@ -234,7 +234,7 @@ CallCapture CaptureGetBooleani_v(const Context *context,
     CaptureGetBooleani_v_data(context, isCallValid, target, index, data, &dataParam);
     paramBuffer.addParam(std::move(dataParam));
 
-    return CallCapture("glGetBooleani_v", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::GetBooleani_v, std::move(paramBuffer));
 }
 
 CallCapture CaptureGetFramebufferParameteriv(const Context *context,
@@ -254,7 +254,7 @@ CallCapture CaptureGetFramebufferParameteriv(const Context *context,
                                             &paramsParam);
     paramBuffer.addParam(std::move(paramsParam));
 
-    return CallCapture("glGetFramebufferParameteriv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::GetFramebufferParameteriv, std::move(paramBuffer));
 }
 
 CallCapture CaptureGetMultisamplefv(const Context *context,
@@ -273,7 +273,7 @@ CallCapture CaptureGetMultisamplefv(const Context *context,
     CaptureGetMultisamplefv_val(context, isCallValid, pname, index, val, &valParam);
     paramBuffer.addParam(std::move(valParam));
 
-    return CallCapture("glGetMultisamplefv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::GetMultisamplefv, std::move(paramBuffer));
 }
 
 CallCapture CaptureGetProgramInterfaceiv(const Context *context,
@@ -295,7 +295,7 @@ CallCapture CaptureGetProgramInterfaceiv(const Context *context,
                                         params, &paramsParam);
     paramBuffer.addParam(std::move(paramsParam));
 
-    return CallCapture("glGetProgramInterfaceiv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::GetProgramInterfaceiv, std::move(paramBuffer));
 }
 
 CallCapture CaptureGetProgramPipelineInfoLog(const Context *context,
@@ -322,7 +322,7 @@ CallCapture CaptureGetProgramPipelineInfoLog(const Context *context,
                                              infoLog, &infoLogParam);
     paramBuffer.addParam(std::move(infoLogParam));
 
-    return CallCapture("glGetProgramPipelineInfoLog", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::GetProgramPipelineInfoLog, std::move(paramBuffer));
 }
 
 CallCapture CaptureGetProgramPipelineiv(const Context *context,
@@ -341,7 +341,7 @@ CallCapture CaptureGetProgramPipelineiv(const Context *context,
     CaptureGetProgramPipelineiv_params(context, isCallValid, pipeline, pname, params, &paramsParam);
     paramBuffer.addParam(std::move(paramsParam));
 
-    return CallCapture("glGetProgramPipelineiv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::GetProgramPipelineiv, std::move(paramBuffer));
 }
 
 CallCapture CaptureGetProgramResourceIndex(const Context *context,
@@ -366,7 +366,7 @@ CallCapture CaptureGetProgramResourceIndex(const Context *context,
     InitParamValue(ParamType::TGLuint, returnValue, &returnValueCapture.value);
     paramBuffer.addReturnValue(std::move(returnValueCapture));
 
-    return CallCapture("glGetProgramResourceIndex", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::GetProgramResourceIndex, std::move(paramBuffer));
 }
 
 CallCapture CaptureGetProgramResourceLocation(const Context *context,
@@ -391,7 +391,7 @@ CallCapture CaptureGetProgramResourceLocation(const Context *context,
     InitParamValue(ParamType::TGLint, returnValue, &returnValueCapture.value);
     paramBuffer.addReturnValue(std::move(returnValueCapture));
 
-    return CallCapture("glGetProgramResourceLocation", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::GetProgramResourceLocation, std::move(paramBuffer));
 }
 
 CallCapture CaptureGetProgramResourceName(const Context *context,
@@ -422,7 +422,7 @@ CallCapture CaptureGetProgramResourceName(const Context *context,
                                        bufSize, length, name, &nameParam);
     paramBuffer.addParam(std::move(nameParam));
 
-    return CallCapture("glGetProgramResourceName", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::GetProgramResourceName, std::move(paramBuffer));
 }
 
 CallCapture CaptureGetProgramResourceiv(const Context *context,
@@ -463,7 +463,7 @@ CallCapture CaptureGetProgramResourceiv(const Context *context,
                                        propCount, props, bufSize, length, params, &paramsParam);
     paramBuffer.addParam(std::move(paramsParam));
 
-    return CallCapture("glGetProgramResourceiv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::GetProgramResourceiv, std::move(paramBuffer));
 }
 
 CallCapture CaptureGetTexLevelParameterfv(const Context *context,
@@ -485,7 +485,7 @@ CallCapture CaptureGetTexLevelParameterfv(const Context *context,
                                          &paramsParam);
     paramBuffer.addParam(std::move(paramsParam));
 
-    return CallCapture("glGetTexLevelParameterfv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::GetTexLevelParameterfv, std::move(paramBuffer));
 }
 
 CallCapture CaptureGetTexLevelParameteriv(const Context *context,
@@ -507,7 +507,7 @@ CallCapture CaptureGetTexLevelParameteriv(const Context *context,
                                          &paramsParam);
     paramBuffer.addParam(std::move(paramsParam));
 
-    return CallCapture("glGetTexLevelParameteriv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::GetTexLevelParameteriv, std::move(paramBuffer));
 }
 
 CallCapture CaptureIsProgramPipeline(const Context *context,
@@ -523,7 +523,7 @@ CallCapture CaptureIsProgramPipeline(const Context *context,
     InitParamValue(ParamType::TGLboolean, returnValue, &returnValueCapture.value);
     paramBuffer.addReturnValue(std::move(returnValueCapture));
 
-    return CallCapture("glIsProgramPipeline", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::IsProgramPipeline, std::move(paramBuffer));
 }
 
 CallCapture CaptureMemoryBarrier(const Context *context, bool isCallValid, GLbitfield barriers)
@@ -532,7 +532,7 @@ CallCapture CaptureMemoryBarrier(const Context *context, bool isCallValid, GLbit
 
     paramBuffer.addValueParam("barriers", ParamType::TGLbitfield, barriers);
 
-    return CallCapture("glMemoryBarrier", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::MemoryBarrier, std::move(paramBuffer));
 }
 
 CallCapture CaptureMemoryBarrierByRegion(const Context *context,
@@ -543,7 +543,7 @@ CallCapture CaptureMemoryBarrierByRegion(const Context *context,
 
     paramBuffer.addValueParam("barriers", ParamType::TGLbitfield, barriers);
 
-    return CallCapture("glMemoryBarrierByRegion", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::MemoryBarrierByRegion, std::move(paramBuffer));
 }
 
 CallCapture CaptureProgramUniform1f(const Context *context,
@@ -558,7 +558,7 @@ CallCapture CaptureProgramUniform1f(const Context *context,
     paramBuffer.addValueParam("location", ParamType::TGLint, location);
     paramBuffer.addValueParam("v0", ParamType::TGLfloat, v0);
 
-    return CallCapture("glProgramUniform1f", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::ProgramUniform1f, std::move(paramBuffer));
 }
 
 CallCapture CaptureProgramUniform1fv(const Context *context,
@@ -580,7 +580,7 @@ CallCapture CaptureProgramUniform1fv(const Context *context,
                                    &valueParam);
     paramBuffer.addParam(std::move(valueParam));
 
-    return CallCapture("glProgramUniform1fv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::ProgramUniform1fv, std::move(paramBuffer));
 }
 
 CallCapture CaptureProgramUniform1i(const Context *context,
@@ -595,7 +595,7 @@ CallCapture CaptureProgramUniform1i(const Context *context,
     paramBuffer.addValueParam("location", ParamType::TGLint, location);
     paramBuffer.addValueParam("v0", ParamType::TGLint, v0);
 
-    return CallCapture("glProgramUniform1i", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::ProgramUniform1i, std::move(paramBuffer));
 }
 
 CallCapture CaptureProgramUniform1iv(const Context *context,
@@ -617,7 +617,7 @@ CallCapture CaptureProgramUniform1iv(const Context *context,
                                    &valueParam);
     paramBuffer.addParam(std::move(valueParam));
 
-    return CallCapture("glProgramUniform1iv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::ProgramUniform1iv, std::move(paramBuffer));
 }
 
 CallCapture CaptureProgramUniform1ui(const Context *context,
@@ -632,7 +632,7 @@ CallCapture CaptureProgramUniform1ui(const Context *context,
     paramBuffer.addValueParam("location", ParamType::TGLint, location);
     paramBuffer.addValueParam("v0", ParamType::TGLuint, v0);
 
-    return CallCapture("glProgramUniform1ui", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::ProgramUniform1ui, std::move(paramBuffer));
 }
 
 CallCapture CaptureProgramUniform1uiv(const Context *context,
@@ -654,7 +654,7 @@ CallCapture CaptureProgramUniform1uiv(const Context *context,
                                     &valueParam);
     paramBuffer.addParam(std::move(valueParam));
 
-    return CallCapture("glProgramUniform1uiv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::ProgramUniform1uiv, std::move(paramBuffer));
 }
 
 CallCapture CaptureProgramUniform2f(const Context *context,
@@ -671,7 +671,7 @@ CallCapture CaptureProgramUniform2f(const Context *context,
     paramBuffer.addValueParam("v0", ParamType::TGLfloat, v0);
     paramBuffer.addValueParam("v1", ParamType::TGLfloat, v1);
 
-    return CallCapture("glProgramUniform2f", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::ProgramUniform2f, std::move(paramBuffer));
 }
 
 CallCapture CaptureProgramUniform2fv(const Context *context,
@@ -693,7 +693,7 @@ CallCapture CaptureProgramUniform2fv(const Context *context,
                                    &valueParam);
     paramBuffer.addParam(std::move(valueParam));
 
-    return CallCapture("glProgramUniform2fv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::ProgramUniform2fv, std::move(paramBuffer));
 }
 
 CallCapture CaptureProgramUniform2i(const Context *context,
@@ -710,7 +710,7 @@ CallCapture CaptureProgramUniform2i(const Context *context,
     paramBuffer.addValueParam("v0", ParamType::TGLint, v0);
     paramBuffer.addValueParam("v1", ParamType::TGLint, v1);
 
-    return CallCapture("glProgramUniform2i", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::ProgramUniform2i, std::move(paramBuffer));
 }
 
 CallCapture CaptureProgramUniform2iv(const Context *context,
@@ -732,7 +732,7 @@ CallCapture CaptureProgramUniform2iv(const Context *context,
                                    &valueParam);
     paramBuffer.addParam(std::move(valueParam));
 
-    return CallCapture("glProgramUniform2iv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::ProgramUniform2iv, std::move(paramBuffer));
 }
 
 CallCapture CaptureProgramUniform2ui(const Context *context,
@@ -749,7 +749,7 @@ CallCapture CaptureProgramUniform2ui(const Context *context,
     paramBuffer.addValueParam("v0", ParamType::TGLuint, v0);
     paramBuffer.addValueParam("v1", ParamType::TGLuint, v1);
 
-    return CallCapture("glProgramUniform2ui", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::ProgramUniform2ui, std::move(paramBuffer));
 }
 
 CallCapture CaptureProgramUniform2uiv(const Context *context,
@@ -771,7 +771,7 @@ CallCapture CaptureProgramUniform2uiv(const Context *context,
                                     &valueParam);
     paramBuffer.addParam(std::move(valueParam));
 
-    return CallCapture("glProgramUniform2uiv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::ProgramUniform2uiv, std::move(paramBuffer));
 }
 
 CallCapture CaptureProgramUniform3f(const Context *context,
@@ -790,7 +790,7 @@ CallCapture CaptureProgramUniform3f(const Context *context,
     paramBuffer.addValueParam("v1", ParamType::TGLfloat, v1);
     paramBuffer.addValueParam("v2", ParamType::TGLfloat, v2);
 
-    return CallCapture("glProgramUniform3f", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::ProgramUniform3f, std::move(paramBuffer));
 }
 
 CallCapture CaptureProgramUniform3fv(const Context *context,
@@ -812,7 +812,7 @@ CallCapture CaptureProgramUniform3fv(const Context *context,
                                    &valueParam);
     paramBuffer.addParam(std::move(valueParam));
 
-    return CallCapture("glProgramUniform3fv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::ProgramUniform3fv, std::move(paramBuffer));
 }
 
 CallCapture CaptureProgramUniform3i(const Context *context,
@@ -831,7 +831,7 @@ CallCapture CaptureProgramUniform3i(const Context *context,
     paramBuffer.addValueParam("v1", ParamType::TGLint, v1);
     paramBuffer.addValueParam("v2", ParamType::TGLint, v2);
 
-    return CallCapture("glProgramUniform3i", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::ProgramUniform3i, std::move(paramBuffer));
 }
 
 CallCapture CaptureProgramUniform3iv(const Context *context,
@@ -853,7 +853,7 @@ CallCapture CaptureProgramUniform3iv(const Context *context,
                                    &valueParam);
     paramBuffer.addParam(std::move(valueParam));
 
-    return CallCapture("glProgramUniform3iv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::ProgramUniform3iv, std::move(paramBuffer));
 }
 
 CallCapture CaptureProgramUniform3ui(const Context *context,
@@ -872,7 +872,7 @@ CallCapture CaptureProgramUniform3ui(const Context *context,
     paramBuffer.addValueParam("v1", ParamType::TGLuint, v1);
     paramBuffer.addValueParam("v2", ParamType::TGLuint, v2);
 
-    return CallCapture("glProgramUniform3ui", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::ProgramUniform3ui, std::move(paramBuffer));
 }
 
 CallCapture CaptureProgramUniform3uiv(const Context *context,
@@ -894,7 +894,7 @@ CallCapture CaptureProgramUniform3uiv(const Context *context,
                                     &valueParam);
     paramBuffer.addParam(std::move(valueParam));
 
-    return CallCapture("glProgramUniform3uiv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::ProgramUniform3uiv, std::move(paramBuffer));
 }
 
 CallCapture CaptureProgramUniform4f(const Context *context,
@@ -915,7 +915,7 @@ CallCapture CaptureProgramUniform4f(const Context *context,
     paramBuffer.addValueParam("v2", ParamType::TGLfloat, v2);
     paramBuffer.addValueParam("v3", ParamType::TGLfloat, v3);
 
-    return CallCapture("glProgramUniform4f", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::ProgramUniform4f, std::move(paramBuffer));
 }
 
 CallCapture CaptureProgramUniform4fv(const Context *context,
@@ -937,7 +937,7 @@ CallCapture CaptureProgramUniform4fv(const Context *context,
                                    &valueParam);
     paramBuffer.addParam(std::move(valueParam));
 
-    return CallCapture("glProgramUniform4fv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::ProgramUniform4fv, std::move(paramBuffer));
 }
 
 CallCapture CaptureProgramUniform4i(const Context *context,
@@ -958,7 +958,7 @@ CallCapture CaptureProgramUniform4i(const Context *context,
     paramBuffer.addValueParam("v2", ParamType::TGLint, v2);
     paramBuffer.addValueParam("v3", ParamType::TGLint, v3);
 
-    return CallCapture("glProgramUniform4i", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::ProgramUniform4i, std::move(paramBuffer));
 }
 
 CallCapture CaptureProgramUniform4iv(const Context *context,
@@ -980,7 +980,7 @@ CallCapture CaptureProgramUniform4iv(const Context *context,
                                    &valueParam);
     paramBuffer.addParam(std::move(valueParam));
 
-    return CallCapture("glProgramUniform4iv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::ProgramUniform4iv, std::move(paramBuffer));
 }
 
 CallCapture CaptureProgramUniform4ui(const Context *context,
@@ -1001,7 +1001,7 @@ CallCapture CaptureProgramUniform4ui(const Context *context,
     paramBuffer.addValueParam("v2", ParamType::TGLuint, v2);
     paramBuffer.addValueParam("v3", ParamType::TGLuint, v3);
 
-    return CallCapture("glProgramUniform4ui", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::ProgramUniform4ui, std::move(paramBuffer));
 }
 
 CallCapture CaptureProgramUniform4uiv(const Context *context,
@@ -1023,7 +1023,7 @@ CallCapture CaptureProgramUniform4uiv(const Context *context,
                                     &valueParam);
     paramBuffer.addParam(std::move(valueParam));
 
-    return CallCapture("glProgramUniform4uiv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::ProgramUniform4uiv, std::move(paramBuffer));
 }
 
 CallCapture CaptureProgramUniformMatrix2fv(const Context *context,
@@ -1047,7 +1047,7 @@ CallCapture CaptureProgramUniformMatrix2fv(const Context *context,
                                          value, &valueParam);
     paramBuffer.addParam(std::move(valueParam));
 
-    return CallCapture("glProgramUniformMatrix2fv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::ProgramUniformMatrix2fv, std::move(paramBuffer));
 }
 
 CallCapture CaptureProgramUniformMatrix2x3fv(const Context *context,
@@ -1071,7 +1071,7 @@ CallCapture CaptureProgramUniformMatrix2x3fv(const Context *context,
                                            transpose, value, &valueParam);
     paramBuffer.addParam(std::move(valueParam));
 
-    return CallCapture("glProgramUniformMatrix2x3fv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::ProgramUniformMatrix2x3fv, std::move(paramBuffer));
 }
 
 CallCapture CaptureProgramUniformMatrix2x4fv(const Context *context,
@@ -1095,7 +1095,7 @@ CallCapture CaptureProgramUniformMatrix2x4fv(const Context *context,
                                            transpose, value, &valueParam);
     paramBuffer.addParam(std::move(valueParam));
 
-    return CallCapture("glProgramUniformMatrix2x4fv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::ProgramUniformMatrix2x4fv, std::move(paramBuffer));
 }
 
 CallCapture CaptureProgramUniformMatrix3fv(const Context *context,
@@ -1119,7 +1119,7 @@ CallCapture CaptureProgramUniformMatrix3fv(const Context *context,
                                          value, &valueParam);
     paramBuffer.addParam(std::move(valueParam));
 
-    return CallCapture("glProgramUniformMatrix3fv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::ProgramUniformMatrix3fv, std::move(paramBuffer));
 }
 
 CallCapture CaptureProgramUniformMatrix3x2fv(const Context *context,
@@ -1143,7 +1143,7 @@ CallCapture CaptureProgramUniformMatrix3x2fv(const Context *context,
                                            transpose, value, &valueParam);
     paramBuffer.addParam(std::move(valueParam));
 
-    return CallCapture("glProgramUniformMatrix3x2fv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::ProgramUniformMatrix3x2fv, std::move(paramBuffer));
 }
 
 CallCapture CaptureProgramUniformMatrix3x4fv(const Context *context,
@@ -1167,7 +1167,7 @@ CallCapture CaptureProgramUniformMatrix3x4fv(const Context *context,
                                            transpose, value, &valueParam);
     paramBuffer.addParam(std::move(valueParam));
 
-    return CallCapture("glProgramUniformMatrix3x4fv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::ProgramUniformMatrix3x4fv, std::move(paramBuffer));
 }
 
 CallCapture CaptureProgramUniformMatrix4fv(const Context *context,
@@ -1191,7 +1191,7 @@ CallCapture CaptureProgramUniformMatrix4fv(const Context *context,
                                          value, &valueParam);
     paramBuffer.addParam(std::move(valueParam));
 
-    return CallCapture("glProgramUniformMatrix4fv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::ProgramUniformMatrix4fv, std::move(paramBuffer));
 }
 
 CallCapture CaptureProgramUniformMatrix4x2fv(const Context *context,
@@ -1215,7 +1215,7 @@ CallCapture CaptureProgramUniformMatrix4x2fv(const Context *context,
                                            transpose, value, &valueParam);
     paramBuffer.addParam(std::move(valueParam));
 
-    return CallCapture("glProgramUniformMatrix4x2fv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::ProgramUniformMatrix4x2fv, std::move(paramBuffer));
 }
 
 CallCapture CaptureProgramUniformMatrix4x3fv(const Context *context,
@@ -1239,7 +1239,7 @@ CallCapture CaptureProgramUniformMatrix4x3fv(const Context *context,
                                            transpose, value, &valueParam);
     paramBuffer.addParam(std::move(valueParam));
 
-    return CallCapture("glProgramUniformMatrix4x3fv", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::ProgramUniformMatrix4x3fv, std::move(paramBuffer));
 }
 
 CallCapture CaptureSampleMaski(const Context *context,
@@ -1252,7 +1252,7 @@ CallCapture CaptureSampleMaski(const Context *context,
     paramBuffer.addValueParam("maskNumber", ParamType::TGLuint, maskNumber);
     paramBuffer.addValueParam("mask", ParamType::TGLbitfield, mask);
 
-    return CallCapture("glSampleMaski", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::SampleMaski, std::move(paramBuffer));
 }
 
 CallCapture CaptureTexStorage2DMultisample(const Context *context,
@@ -1273,7 +1273,7 @@ CallCapture CaptureTexStorage2DMultisample(const Context *context,
     paramBuffer.addValueParam("height", ParamType::TGLsizei, height);
     paramBuffer.addValueParam("fixedsamplelocations", ParamType::TGLboolean, fixedsamplelocations);
 
-    return CallCapture("glTexStorage2DMultisample", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::TexStorage2DMultisample, std::move(paramBuffer));
 }
 
 CallCapture CaptureUseProgramStages(const Context *context,
@@ -1288,7 +1288,7 @@ CallCapture CaptureUseProgramStages(const Context *context,
     paramBuffer.addValueParam("stages", ParamType::TGLbitfield, stages);
     paramBuffer.addValueParam("program", ParamType::TGLuint, program);
 
-    return CallCapture("glUseProgramStages", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::UseProgramStages, std::move(paramBuffer));
 }
 
 CallCapture CaptureValidateProgramPipeline(const Context *context,
@@ -1299,7 +1299,7 @@ CallCapture CaptureValidateProgramPipeline(const Context *context,
 
     paramBuffer.addValueParam("pipeline", ParamType::TGLuint, pipeline);
 
-    return CallCapture("glValidateProgramPipeline", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::ValidateProgramPipeline, std::move(paramBuffer));
 }
 
 CallCapture CaptureVertexAttribBinding(const Context *context,
@@ -1312,7 +1312,7 @@ CallCapture CaptureVertexAttribBinding(const Context *context,
     paramBuffer.addValueParam("attribindex", ParamType::TGLuint, attribindex);
     paramBuffer.addValueParam("bindingindex", ParamType::TGLuint, bindingindex);
 
-    return CallCapture("glVertexAttribBinding", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::VertexAttribBinding, std::move(paramBuffer));
 }
 
 CallCapture CaptureVertexAttribFormat(const Context *context,
@@ -1331,7 +1331,7 @@ CallCapture CaptureVertexAttribFormat(const Context *context,
     paramBuffer.addValueParam("normalized", ParamType::TGLboolean, normalized);
     paramBuffer.addValueParam("relativeoffset", ParamType::TGLuint, relativeoffset);
 
-    return CallCapture("glVertexAttribFormat", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::VertexAttribFormat, std::move(paramBuffer));
 }
 
 CallCapture CaptureVertexAttribIFormat(const Context *context,
@@ -1348,7 +1348,7 @@ CallCapture CaptureVertexAttribIFormat(const Context *context,
     paramBuffer.addValueParam("typePacked", ParamType::TVertexAttribType, typePacked);
     paramBuffer.addValueParam("relativeoffset", ParamType::TGLuint, relativeoffset);
 
-    return CallCapture("glVertexAttribIFormat", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::VertexAttribIFormat, std::move(paramBuffer));
 }
 
 CallCapture CaptureVertexBindingDivisor(const Context *context,
@@ -1361,7 +1361,7 @@ CallCapture CaptureVertexBindingDivisor(const Context *context,
     paramBuffer.addValueParam("bindingindex", ParamType::TGLuint, bindingindex);
     paramBuffer.addValueParam("divisor", ParamType::TGLuint, divisor);
 
-    return CallCapture("glVertexBindingDivisor", std::move(paramBuffer));
+    return CallCapture(gl::EntryPoint::VertexBindingDivisor, std::move(paramBuffer));
 }
 
 }  // namespace gl

src/libANGLE/entry_points_enum_autogen.h

@@ -1362,5 +1362,7 @@ enum class EntryPoint
     WindowPos3s,
     WindowPos3sv
 };
+
+const char *GetEntryPointName(EntryPoint ep);
 }  // namespace gl
 #endif  // LIBANGLE_ENTRY_POINTS_ENUM_AUTOGEN_H_

src/libANGLE/entry_points_utils.h

@@ -83,8 +83,7 @@ constexpr ANGLE_INLINE ReturnType GetDefaultReturnValue()
 }
 
 #if ANGLE_CAPTURE_ENABLED
-#    define ANGLE_CAPTURE(Func, ...) \
-        CaptureCallToFrameCapture("gl" ANGLE_STRINGIFY(Func), Capture##Func, __VA_ARGS__)
+#    define ANGLE_CAPTURE(Func, ...) CaptureCallToFrameCapture(Capture##Func, __VA_ARGS__)
 #else
 #    define ANGLE_CAPTURE(...)
 #endif  // ANGLE_CAPTURE_ENABLED

src/libGLESv2.gni

@@ -294,6 +294,9 @@ libangle_sources = [
   "src/libANGLE/angletypes.cpp",
   "src/libANGLE/angletypes.h",
   "src/libANGLE/angletypes.inc",
+  "src/libANGLE/entry_points_enum_autogen.cpp",
+  "src/libANGLE/entry_points_enum_autogen.h",
+  "src/libANGLE/entry_points_utils.h",
   "src/libANGLE/es3_copy_conversion_table_autogen.cpp",
   "src/libANGLE/features.h",
   "src/libANGLE/format_map_autogen.cpp",
@@ -1010,8 +1013,6 @@ libangle_null_sources = [
 libgl_sources = [
   "src/common/angleutils.h",
   "src/common/debug.h",
-  "src/libANGLE/entry_points_enum_autogen.h",
-  "src/libANGLE/entry_points_utils.h",
   "src/libGLESv2/global_state.cpp",
   "src/libGLESv2/global_state.h",
   "src/libGL/entry_points_gl_1_0_autogen.cpp",