src/modules/tracepath/coregl_tracepath_gl.c

   1 #include "coregl_tracepath.h"
   2
   3 #include <stdlib.h>
   4
   5 struct _Glbuf_Data {
   6         int obj_idx;
   7         int width;
   8         int height;
   9         int bpp;
  10         char format[80];
  11
  12         struct _Glbuf_Data *next;
  13 };
  14
  15 static void
  16 __addhash_glbuf_object(Glbuf_Data **glbuf, Glbuf_Data *target)
  17 {
  18         Glbuf_Data *data = glbuf[target->obj_idx % MTD_GLBUF_HASH_ARRAY];
  19         if (data == NULL) {
  20                 glbuf[target->obj_idx % MTD_GLBUF_HASH_ARRAY] = target;
  21         } else {
  22                 while (data->next != NULL) {
  23                         AST(data->obj_idx != target->obj_idx);
  24                         data = data->next;
  25                 }
  26                 AST(data->obj_idx != target->obj_idx);
  27                 data->next = target;
  28         }
  29         goto finish;
  30
  31 finish:
  32         return;
  33 }
  34
  35 static void
  36 __removehash_glbuf_object(Glbuf_Data **glbuf, Glbuf_Data **target)
  37 {
  38         Glbuf_Data *data = glbuf[(*target)->obj_idx % MTD_GLBUF_HASH_ARRAY];
  39         Glbuf_Data *prev = NULL;
  40         while (data != NULL) {
  41                 if (data->obj_idx == (*target)->obj_idx) {
  42                         if (prev != NULL)
  43                                 prev->next = data->next;
  44                         else
  45                                 glbuf[(*target)->obj_idx % MTD_GLBUF_HASH_ARRAY] = data->next;
  46
  47                         free(*target);
  48                         *target = NULL;
  49                         break;
  50                 }
  51                 prev = data;
  52                 data = data->next;
  53         }
  54         goto finish;
  55
  56 finish:
  57         return;
  58 }
  59
  60 static Glbuf_Data *
  61 __findhash_glbuf_object(Glbuf_Data **glbuf, int obj_idx)
  62 {
  63         Glbuf_Data *data = glbuf[obj_idx % MTD_GLBUF_HASH_ARRAY];
  64         while (data != NULL) {
  65                 if (data->obj_idx == obj_idx)
  66                         break;
  67                 data = data->next;
  68         }
  69         goto finish;
  70
  71 finish:
  72         return data;
  73 }
  74
  75 void
  76 tracepath_glbuf_clear(Glbuf_Data **glbuf)
  77 {
  78         int i;
  79
  80         for (i = 0; i < MTD_GLBUF_HASH_ARRAY; i++) {
  81                 Glbuf_Data *data = glbuf[i];
  82
  83                 while (data) {
  84                         Glbuf_Data *delitm = data;
  85                         data = data->next;
  86                         free(delitm);
  87                         delitm = NULL;
  88                 }
  89         }
  90 }
  91
  92 static void
  93 _add_glbuf_object(Glbuf_Data **glbuf, int obj_idx, const char *obj_type,
  94                   int width, int height, int bpp, const char *format)
  95 {
  96         Glbuf_Data *data = __findhash_glbuf_object(glbuf, obj_idx);
  97         if (data == NULL) {
  98                 data = (Glbuf_Data *)calloc(1, sizeof(Glbuf_Data));
  99                 data->obj_idx = obj_idx;
 100                 __addhash_glbuf_object(glbuf, data);
 101         } else {
 102                 // Update
 103                 {
 104                         char ment[MAX_TRACE_NAME_LENGTH];
 105                         sprintf(ment, "%s(%4dx%4d %s)", obj_type, data->width, data->height,
 106                                 data->format);
 107                         _COREGL_TRACE_MEM_REMOVE(ment, data->width * data->height * data->bpp);
 108                 }
 109         }
 110
 111         data->width = width;
 112         data->height = height;
 113         data->bpp = bpp;
 114         sprintf(data->format, "%s", format);
 115
 116         {
 117                 char ment[MAX_TRACE_NAME_LENGTH];
 118                 sprintf(ment, "%s(%4dx%4d %s)", obj_type, data->width, data->height,
 119                         data->format);
 120                 _COREGL_TRACE_MEM_ADD(ment, data->width * data->height * data->bpp);
 121         }
 122         goto finish;
 123
 124 finish:
 125         return;
 126 }
 127
 128 static void
 129 _remove_glbuf_object(Glbuf_Data **glbuf, int obj_idx, const char *obj_type)
 130 {
 131         Glbuf_Data *data = __findhash_glbuf_object(glbuf, obj_idx);
 132         if (data == NULL) {
 133                 COREGL_WRN("\E[40;31;1mError deleting %s object %d. (is not created)\E[0m\n",
 134                            obj_type, obj_idx);
 135                 return;
 136         }
 137
 138         {
 139                 char ment[MAX_TRACE_NAME_LENGTH];
 140                 sprintf(ment, "%s(%4dx%4d %s)", obj_type, data->width, data->height,
 141                         data->format);
 142                 _COREGL_TRACE_MEM_REMOVE(ment, data->width * data->height * data->bpp);
 143         }
 144
 145         __removehash_glbuf_object(glbuf, &data);
 146         goto finish;
 147
 148 finish:
 149         return;
 150 }
 151
 152
 153 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
 154 void
 155 _surface_trace_set(int set, GLint fbname, GLenum attachment,
 156                    MY_MODULE_TSTATE *tstate)
 157 {
 158         int atttype = _COREGL_INT_INIT_VALUE;
 159         _orig_tracepath_glGetFramebufferAttachmentParameteriv(GL_FRAMEBUFFER,
 160                         attachment, GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE, &atttype);
 161         AST(atttype != _COREGL_INT_INIT_VALUE);
 162         int attname = _COREGL_INT_INIT_VALUE;
 163         _orig_tracepath_glGetFramebufferAttachmentParameteriv(GL_FRAMEBUFFER,
 164                         attachment, GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME, &attname);
 165         AST(attname != _COREGL_INT_INIT_VALUE);
 166         if (set == 1) {
 167                 switch (atttype) {
 168                 case GL_TEXTURE:
 169                         //COREGL_LOG("FBO DUMPING BEGIN = (TEX)0x%X\n", attname);
 170                 {
 171                         char name[256];
 172                         sprintf(name, "FBOTEX_0x%X", attname);
 173                         tracepath_surface_trace_add(name, tstate->ctx->dpy, tstate->ctx->handle,
 174                                                     tstate->surf_draw, fbname, attname, 0, -1, -1, -1, NULL);
 175                 }
 176                 break;
 177                 case GL_RENDERBUFFER:
 178                         //COREGL_LOG("FBO DUMPING BEGIN = (RB)0x%X\n", attname);
 179                 {
 180                         char name[256];
 181                         sprintf(name, "FBORB_0x%X", attname);
 182                         tracepath_surface_trace_add(name, tstate->ctx->dpy, tstate->ctx->handle,
 183                                                     tstate->surf_draw, fbname, 0, attname, -1, -1, -1, NULL);
 184                 }
 185                 break;
 186                 }
 187         } else {
 188                 switch (atttype) {
 189                 case GL_TEXTURE:
 190                         //COREGL_LOG("FBO DUMPING END = (TEX)0x%X\n", attname);
 191                 {
 192                         char name[256];
 193                         sprintf(name, "FBOTEX_0x%X", attname);
 194                         tracepath_surface_trace_add(name, tstate->ctx->dpy, tstate->ctx->handle,
 195                                                     tstate->surf_draw, 0, attname, 0, -1, -1, -1, NULL);
 196                 }
 197                 break;
 198                 case GL_RENDERBUFFER:
 199                         //COREGL_LOG("FBO DUMPING END = (RB)0x%X\n", attname);
 200                 {
 201                         char name[256];
 202                         sprintf(name, "FBORB_0x%X", attname);
 203                         tracepath_surface_trace_add(name, tstate->ctx->dpy, tstate->ctx->handle,
 204                                                     tstate->surf_draw, 0, 0, attname, -1, -1, -1, NULL);
 205                 }
 206                 break;
 207                 }
 208         }
 209 }
 210
 211 void
 212 tracepath_fbdump_update(GLint set)
 213 {
 214         if (trace_surface_flag == 1) {
 215                 GLint fbname = _COREGL_INT_INIT_VALUE;
 216                 _orig_tracepath_glGetIntegerv(GL_FRAMEBUFFER_BINDING, &fbname);
 217                 AST(fbname != _COREGL_INT_INIT_VALUE);
 218                 if (fbname != 0) {
 219                         MY_MODULE_TSTATE *tstate = NULL;
 220
 221                         GET_MY_TSTATE(tstate, get_current_thread_state());
 222                         AST(tstate != NULL);
 223                         if (tstate->ctx != NULL) {
 224                                 _surface_trace_set(set, fbname, GL_COLOR_ATTACHMENT0, tstate);
 225 //                              _surface_trace_set(set, fbname, GL_DEPTH_ATTACHMENT, tstate);
 226 //                              _surface_trace_set(set, fbname, GL_STENCIL_ATTACHMENT, tstate);
 227                         }
 228                 }
 229         }
 230 }
 231 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
 232
 233
 234
 235
 236
 237
 238 /* OpenGL ES 2.0 */
 239
 240 void
 241 tracepath_glActiveTexture(GLenum texture)
 242 {
 243         _COREGL_TRACEPATH_FUNC_BEGIN();
 244         _orig_tracepath_glActiveTexture(texture);
 245
 246         goto finish;
 247
 248 finish:
 249         _COREGL_TRACEPATH_FUNC_END();
 250 }
 251
 252 void
 253 tracepath_glAttachShader(GLuint program, GLuint shader)
 254 {
 255         _COREGL_TRACEPATH_FUNC_BEGIN();
 256         _orig_tracepath_glAttachShader(program, shader);
 257
 258         goto finish;
 259
 260 finish:
 261         _COREGL_TRACEPATH_FUNC_END();
 262 }
 263
 264 void
 265 tracepath_glBindAttribLocation(GLuint program, GLuint index, const char *name)
 266 {
 267         _COREGL_TRACEPATH_FUNC_BEGIN();
 268         _orig_tracepath_glBindAttribLocation(program, index, name);
 269
 270         goto finish;
 271
 272 finish:
 273         _COREGL_TRACEPATH_FUNC_END();
 274 }
 275
 276 void
 277 tracepath_glBindBuffer(GLenum target, GLuint buffer)
 278 {
 279         _COREGL_TRACEPATH_FUNC_BEGIN();
 280         _orig_tracepath_glBindBuffer(target, buffer);
 281
 282         goto finish;
 283
 284 finish:
 285         _COREGL_TRACEPATH_FUNC_END();
 286 }
 287
 288 void
 289 tracepath_glBindFramebuffer(GLenum target, GLuint framebuffer)
 290 {
 291         _COREGL_TRACEPATH_FUNC_BEGIN();
 292
 293 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
 294         if (unlikely(trace_surface_flag == 1)) {
 295                 GLint oldfb;
 296                 _orig_tracepath_glGetIntegerv(GL_FRAMEBUFFER_BINDING, &oldfb);
 297                 if (oldfb != 0) {
 298                         _COREGL_TRACE_SURFACE(0, 2, "GLBINDFBO");
 299                 }
 300
 301                 tracepath_fbdump_update(0);
 302         }
 303 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
 304
 305         _orig_tracepath_glBindFramebuffer(target, framebuffer);
 306
 307 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
 308         if (unlikely(trace_surface_flag == 1)) {
 309                 tracepath_fbdump_update(1);
 310         }
 311 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
 312
 313         goto finish;
 314
 315 finish:
 316         _COREGL_TRACEPATH_FUNC_END();
 317 }
 318
 319 void
 320 tracepath_glBindRenderbuffer(GLenum target, GLuint renderbuffer)
 321 {
 322         _COREGL_TRACEPATH_FUNC_BEGIN();
 323         _orig_tracepath_glBindRenderbuffer(target, renderbuffer);
 324
 325         goto finish;
 326
 327 finish:
 328         _COREGL_TRACEPATH_FUNC_END();
 329 }
 330
 331 void
 332 tracepath_glBindTexture(GLenum target, GLuint texture)
 333 {
 334         _COREGL_TRACEPATH_FUNC_BEGIN();
 335
 336         _COREGL_TRACE_SURFACE(0, 1, "GLBINDTEXTURE");
 337         _orig_tracepath_glBindTexture(target, texture);
 338
 339         goto finish;
 340
 341 finish:
 342         _COREGL_TRACEPATH_FUNC_END();
 343 }
 344
 345 void
 346 tracepath_glBlendColor(GLclampf red, GLclampf green, GLclampf blue,
 347                        GLclampf alpha)
 348 {
 349         _COREGL_TRACEPATH_FUNC_BEGIN();
 350         _orig_tracepath_glBlendColor(red, green, blue, alpha);
 351
 352         goto finish;
 353
 354 finish:
 355         _COREGL_TRACEPATH_FUNC_END();
 356 }
 357
 358 void
 359 tracepath_glBlendEquation(GLenum mode)
 360 {
 361         _COREGL_TRACEPATH_FUNC_BEGIN();
 362         _orig_tracepath_glBlendEquation(mode);
 363
 364         goto finish;
 365
 366 finish:
 367         _COREGL_TRACEPATH_FUNC_END();
 368 }
 369
 370 void
 371 tracepath_glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
 372 {
 373         _COREGL_TRACEPATH_FUNC_BEGIN();
 374         _orig_tracepath_glBlendEquationSeparate(modeRGB, modeAlpha);
 375
 376         goto finish;
 377
 378 finish:
 379         _COREGL_TRACEPATH_FUNC_END();
 380 }
 381
 382 void
 383 tracepath_glBlendFunc(GLenum sfactor, GLenum dfactor)
 384 {
 385         _COREGL_TRACEPATH_FUNC_BEGIN();
 386         _orig_tracepath_glBlendFunc(sfactor, dfactor);
 387
 388         goto finish;
 389
 390 finish:
 391         _COREGL_TRACEPATH_FUNC_END();
 392 }
 393
 394 void
 395 tracepath_glBlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha,
 396                               GLenum dstAlpha)
 397 {
 398         _COREGL_TRACEPATH_FUNC_BEGIN();
 399         _orig_tracepath_glBlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);
 400
 401         goto finish;
 402
 403 finish:
 404         _COREGL_TRACEPATH_FUNC_END();
 405 }
 406
 407 void
 408 tracepath_glBufferData(GLenum target, GLsizeiptr size, const void *data,
 409                        GLenum usage)
 410 {
 411         _COREGL_TRACEPATH_FUNC_BEGIN();
 412         _orig_tracepath_glBufferData(target, size, data, usage);
 413
 414         goto finish;
 415
 416 finish:
 417         _COREGL_TRACEPATH_FUNC_END();
 418 }
 419
 420 void
 421 tracepath_glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size,
 422                           const void *data)
 423 {
 424         _COREGL_TRACEPATH_FUNC_BEGIN();
 425         _orig_tracepath_glBufferSubData(target, offset, size, data);
 426
 427         goto finish;
 428
 429 finish:
 430         _COREGL_TRACEPATH_FUNC_END();
 431 }
 432
 433 GLenum
 434 tracepath_glCheckFramebufferStatus(GLenum target)
 435 {
 436         GLenum ret = GL_NONE;
 437
 438         _COREGL_TRACEPATH_FUNC_BEGIN();
 439         ret = _orig_tracepath_glCheckFramebufferStatus(target);
 440
 441         goto finish;
 442
 443 finish:
 444         _COREGL_TRACEPATH_FUNC_END();
 445         return ret;
 446 }
 447
 448 void
 449 tracepath_glClear(GLbitfield mask)
 450 {
 451         _COREGL_TRACEPATH_FUNC_BEGIN();
 452         _orig_tracepath_glClear(mask);
 453
 454         goto finish;
 455
 456 finish:
 457         _COREGL_TRACEPATH_FUNC_END();
 458 }
 459
 460 void
 461 tracepath_glClearColor(GLclampf red, GLclampf green, GLclampf blue,
 462                        GLclampf alpha)
 463 {
 464         _COREGL_TRACEPATH_FUNC_BEGIN();
 465         _orig_tracepath_glClearColor(red, green, blue, alpha);
 466
 467         goto finish;
 468
 469 finish:
 470         _COREGL_TRACEPATH_FUNC_END();
 471 }
 472
 473 void
 474 tracepath_glClearDepthf(GLclampf depth)
 475 {
 476         _COREGL_TRACEPATH_FUNC_BEGIN();
 477         _orig_tracepath_glClearDepthf(depth);
 478
 479         goto finish;
 480
 481 finish:
 482         _COREGL_TRACEPATH_FUNC_END();
 483 }
 484
 485 void
 486 tracepath_glClearStencil(GLint s)
 487 {
 488         _COREGL_TRACEPATH_FUNC_BEGIN();
 489         _orig_tracepath_glClearStencil(s);
 490
 491         goto finish;
 492
 493 finish:
 494         _COREGL_TRACEPATH_FUNC_END();
 495 }
 496
 497 void
 498 tracepath_glColorMask(GLboolean red, GLboolean green, GLboolean blue,
 499                       GLboolean alpha)
 500 {
 501         _COREGL_TRACEPATH_FUNC_BEGIN();
 502         _orig_tracepath_glColorMask(red, green, blue, alpha);
 503
 504         goto finish;
 505
 506 finish:
 507         _COREGL_TRACEPATH_FUNC_END();
 508 }
 509
 510 void
 511 tracepath_glCompileShader(GLuint shader)
 512 {
 513         _COREGL_TRACEPATH_FUNC_BEGIN();
 514         _orig_tracepath_glCompileShader(shader);
 515
 516         goto finish;
 517
 518 finish:
 519         _COREGL_TRACEPATH_FUNC_END();
 520 }
 521
 522 void
 523 tracepath_glCompressedTexImage2D(GLenum target, GLint level,
 524                                  GLenum internalformat, GLsizei width, GLsizei height, GLint border,
 525                                  GLsizei imageSize, const void *data)
 526 {
 527         _COREGL_TRACEPATH_FUNC_BEGIN();
 528         _orig_tracepath_glCompressedTexImage2D(target, level, internalformat, width,
 529                                                height, border, imageSize, data);
 530
 531         goto finish;
 532
 533 finish:
 534         _COREGL_TRACEPATH_FUNC_END();
 535 }
 536
 537 void
 538 tracepath_glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset,
 539                                     GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize,
 540                                     const void *data)
 541 {
 542         _COREGL_TRACEPATH_FUNC_BEGIN();
 543         _orig_tracepath_glCompressedTexSubImage2D(target, level, xoffset, yoffset,
 544                         width, height, format, imageSize, data);
 545
 546         goto finish;
 547
 548 finish:
 549         _COREGL_TRACEPATH_FUNC_END();
 550 }
 551
 552 void
 553 tracepath_glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat,
 554                            GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
 555 {
 556         _COREGL_TRACEPATH_FUNC_BEGIN();
 557         _orig_tracepath_glCopyTexImage2D(target, level, internalformat, x, y, width,
 558                                          height, border);
 559
 560         goto finish;
 561
 562 finish:
 563         _COREGL_TRACEPATH_FUNC_END();
 564 }
 565
 566 void
 567 tracepath_glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset,
 568                               GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
 569 {
 570         _COREGL_TRACEPATH_FUNC_BEGIN();
 571         _orig_tracepath_glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y,
 572                                             width, height);
 573
 574         goto finish;
 575
 576 finish:
 577         _COREGL_TRACEPATH_FUNC_END();
 578 }
 579
 580 GLuint
 581 tracepath_glCreateProgram(void)
 582 {
 583         GLuint ret = _COREGL_INT_INIT_VALUE;
 584
 585         _COREGL_TRACEPATH_FUNC_BEGIN();
 586         ret = _orig_tracepath_glCreateProgram();
 587
 588         goto finish;
 589
 590 finish:
 591         _COREGL_TRACEPATH_FUNC_END();
 592         return ret;
 593 }
 594
 595 GLuint
 596 tracepath_glCreateShader(GLenum type)
 597 {
 598         GLuint ret = _COREGL_INT_INIT_VALUE;
 599         _COREGL_TRACEPATH_FUNC_BEGIN();
 600         ret = _orig_tracepath_glCreateShader(type);
 601
 602         goto finish;
 603
 604 finish:
 605         _COREGL_TRACEPATH_FUNC_END();
 606         return ret;
 607 }
 608
 609 void
 610 tracepath_glCullFace(GLenum mode)
 611 {
 612         _COREGL_TRACEPATH_FUNC_BEGIN();
 613         _orig_tracepath_glCullFace(mode);
 614
 615         goto finish;
 616
 617 finish:
 618         _COREGL_TRACEPATH_FUNC_END();
 619 }
 620
 621 void
 622 tracepath_glDeleteBuffers(GLsizei n, const GLuint *buffers)
 623 {
 624         _COREGL_TRACEPATH_FUNC_BEGIN();
 625         _orig_tracepath_glDeleteBuffers(n, buffers);
 626
 627         goto finish;
 628
 629 finish:
 630         _COREGL_TRACEPATH_FUNC_END();
 631 }
 632
 633 void
 634 tracepath_glDeleteFramebuffers(GLsizei n, const GLuint *framebuffers)
 635 {
 636         _COREGL_TRACEPATH_FUNC_BEGIN();
 637
 638 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
 639         tracepath_fbdump_update(0);
 640 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
 641
 642         _orig_tracepath_glDeleteFramebuffers(n, framebuffers);
 643
 644 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
 645         tracepath_fbdump_update(1);
 646 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
 647
 648         goto finish;
 649
 650 finish:
 651         _COREGL_TRACEPATH_FUNC_END();
 652 }
 653
 654 void
 655 tracepath_glDeleteProgram(GLuint program)
 656 {
 657         _COREGL_TRACEPATH_FUNC_BEGIN();
 658         _orig_tracepath_glDeleteProgram(program);
 659
 660         goto finish;
 661
 662 finish:
 663         _COREGL_TRACEPATH_FUNC_END();
 664 }
 665
 666 void
 667 tracepath_glDeleteRenderbuffers(GLsizei n, const GLuint *renderbuffers)
 668 {
 669         _COREGL_TRACEPATH_FUNC_BEGIN();
 670
 671 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
 672         tracepath_fbdump_update(0);
 673 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
 674
 675         _orig_tracepath_glDeleteRenderbuffers(n, renderbuffers);
 676
 677 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
 678         tracepath_fbdump_update(1);
 679 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
 680
 681         goto finish;
 682
 683 finish:
 684         _COREGL_TRACEPATH_FUNC_END();
 685 #ifdef COREGL_TRACEPATH_TRACE_MEMUSE_INFO
 686         if (trace_mem_flag == 1) {
 687                 MY_MODULE_TSTATE *tstate = NULL;
 688
 689                 GET_MY_TSTATE(tstate, get_current_thread_state());
 690                 AST(tstate != NULL);
 691                 if (tstate->ctx != NULL) {
 692                         for (int i = 0; i < n; i++) {
 693                                 if (renderbuffers[i] == 0) continue;
 694                                 _remove_glbuf_object(tstate->ctx->sostate->glbuf_rb, renderbuffers[i],
 695                                                      "Renderbuffer");
 696                         }
 697                 }
 698         }
 699 #endif // COREGL_TRACEPATH_TRACE_MEMUSE_INFO
 700 }
 701
 702 void
 703 tracepath_glDeleteShader(GLuint shader)
 704 {
 705         _COREGL_TRACEPATH_FUNC_BEGIN();
 706         _orig_tracepath_glDeleteShader(shader);
 707
 708         goto finish;
 709
 710 finish:
 711         _COREGL_TRACEPATH_FUNC_END();
 712 }
 713
 714 void
 715 tracepath_glDeleteTextures(GLsizei n, const GLuint *textures)
 716 {
 717         _COREGL_TRACEPATH_FUNC_BEGIN();
 718
 719 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
 720         tracepath_fbdump_update(0);
 721 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
 722
 723         _orig_tracepath_glDeleteTextures(n, textures);
 724
 725 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
 726         tracepath_fbdump_update(1);
 727 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
 728
 729         goto finish;
 730
 731 finish:
 732         _COREGL_TRACEPATH_FUNC_END();
 733 #ifdef COREGL_TRACEPATH_TRACE_MEMUSE_INFO
 734         if (trace_mem_flag == 1) {
 735                 MY_MODULE_TSTATE *tstate = NULL;
 736
 737                 GET_MY_TSTATE(tstate, get_current_thread_state());
 738                 AST(tstate != NULL);
 739                 if (tstate->ctx != NULL) {
 740                         for (int i = 0; i < n; i++) {
 741                                 if (textures[i] == 0) continue;
 742                                 _remove_glbuf_object(tstate->ctx->sostate->glbuf_tex, textures[i], "Texture");
 743                         }
 744                 }
 745         }
 746 #endif // COREGL_TRACEPATH_TRACE_MEMUSE_INFO
 747 }
 748
 749 void
 750 tracepath_glDepthFunc(GLenum func)
 751 {
 752         _COREGL_TRACEPATH_FUNC_BEGIN();
 753         _orig_tracepath_glDepthFunc(func);
 754
 755         goto finish;
 756
 757 finish:
 758         _COREGL_TRACEPATH_FUNC_END();
 759 }
 760
 761 void
 762 tracepath_glDepthMask(GLboolean flag)
 763 {
 764         _COREGL_TRACEPATH_FUNC_BEGIN();
 765         _orig_tracepath_glDepthMask(flag);
 766
 767         goto finish;
 768
 769 finish:
 770         _COREGL_TRACEPATH_FUNC_END();
 771 }
 772
 773 void
 774 tracepath_glDepthRangef(GLclampf zNear, GLclampf zFar)
 775 {
 776         _COREGL_TRACEPATH_FUNC_BEGIN();
 777         _orig_tracepath_glDepthRangef(zNear, zFar);
 778
 779         goto finish;
 780
 781 finish:
 782         _COREGL_TRACEPATH_FUNC_END();
 783 }
 784
 785 void
 786 tracepath_glDetachShader(GLuint program, GLuint shader)
 787 {
 788         _COREGL_TRACEPATH_FUNC_BEGIN();
 789         _orig_tracepath_glDetachShader(program, shader);
 790
 791         goto finish;
 792
 793 finish:
 794         _COREGL_TRACEPATH_FUNC_END();
 795 }
 796
 797 void
 798 tracepath_glDisable(GLenum cap)
 799 {
 800         _COREGL_TRACEPATH_FUNC_BEGIN();
 801         _orig_tracepath_glDisable(cap);
 802
 803         goto finish;
 804
 805 finish:
 806         _COREGL_TRACEPATH_FUNC_END();
 807 }
 808
 809 void
 810 tracepath_glDisableVertexAttribArray(GLuint index)
 811 {
 812         _COREGL_TRACEPATH_FUNC_BEGIN();
 813         _orig_tracepath_glDisableVertexAttribArray(index);
 814
 815         goto finish;
 816
 817 finish:
 818         _COREGL_TRACEPATH_FUNC_END();
 819 }
 820
 821 void
 822 tracepath_glDrawArrays(GLenum mode, GLint first, GLsizei count)
 823 {
 824         _COREGL_TRACEPATH_FUNC_BEGIN();
 825         _orig_tracepath_glDrawArrays(mode, first, count);
 826
 827         goto finish;
 828
 829 finish:
 830         _COREGL_TRACEPATH_FUNC_END();
 831 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
 832         if (trace_surface_flag == 1) {
 833                 GLint fbname = _COREGL_INT_INIT_VALUE;
 834                 _orig_tracepath_glGetIntegerv(GL_FRAMEBUFFER_BINDING, &fbname);
 835                 AST(fbname != _COREGL_INT_INIT_VALUE);
 836                 if (fbname == 0) {
 837                         char name[256];
 838                         EGLint btype;
 839                         _orig_tracepath_eglQuerySurface(_orig_tracepath_eglGetCurrentDisplay(),
 840                                                         _orig_tracepath_eglGetCurrentSurface(EGL_DRAW), EGL_RENDER_BUFFER, &btype);
 841                         if (btype == EGL_SINGLE_BUFFER)
 842                                 sprintf(name, "EGLPIXMAP_%p", _orig_tracepath_eglGetCurrentSurface(EGL_DRAW));
 843                         else
 844                                 sprintf(name, "EGLWINDOW_%p", _orig_tracepath_eglGetCurrentSurface(EGL_DRAW));
 845                         tracepath_surface_trace_add(name, _orig_tracepath_eglGetCurrentDisplay(),
 846                                                     _orig_tracepath_eglGetCurrentContext(),
 847                                                     _orig_tracepath_eglGetCurrentSurface(EGL_DRAW), 0, 0, 0, 0, 0, 0, NULL);
 848                 }
 849         }
 850 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
 851 }
 852
 853 void
 854 tracepath_glDrawElements(GLenum mode, GLsizei count, GLenum type,
 855                          const void *indices)
 856 {
 857         _COREGL_TRACEPATH_FUNC_BEGIN();
 858         _orig_tracepath_glDrawElements(mode, count, type, indices);
 859
 860         goto finish;
 861
 862 finish:
 863         _COREGL_TRACEPATH_FUNC_END();
 864 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
 865         if (trace_surface_flag == 1) {
 866                 GLint fbname = _COREGL_INT_INIT_VALUE;
 867                 _orig_tracepath_glGetIntegerv(GL_FRAMEBUFFER_BINDING, &fbname);
 868                 AST(fbname != _COREGL_INT_INIT_VALUE);
 869                 if (fbname == 0) {
 870                         char name[256];
 871                         EGLint btype;
 872                         _orig_tracepath_eglQuerySurface(_orig_tracepath_eglGetCurrentDisplay(),
 873                                                         _orig_tracepath_eglGetCurrentSurface(EGL_DRAW), EGL_RENDER_BUFFER, &btype);
 874                         if (btype == EGL_SINGLE_BUFFER)
 875                                 sprintf(name, "EGLPIXMAP_%p", _orig_tracepath_eglGetCurrentSurface(EGL_DRAW));
 876                         else
 877                                 sprintf(name, "EGLWINDOW_%p", _orig_tracepath_eglGetCurrentSurface(EGL_DRAW));
 878                         tracepath_surface_trace_add(name, _orig_tracepath_eglGetCurrentDisplay(),
 879                                                     _orig_tracepath_eglGetCurrentContext(),
 880                                                     _orig_tracepath_eglGetCurrentSurface(EGL_DRAW), 0, 0, 0, 0, 0, 0, NULL);
 881                 }
 882         }
 883 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
 884 }
 885
 886 void
 887 tracepath_glEnable(GLenum cap)
 888 {
 889         _COREGL_TRACEPATH_FUNC_BEGIN();
 890         _orig_tracepath_glEnable(cap);
 891
 892         goto finish;
 893
 894 finish:
 895         _COREGL_TRACEPATH_FUNC_END();
 896 }
 897
 898 void
 899 tracepath_glEnableVertexAttribArray(GLuint index)
 900 {
 901         _COREGL_TRACEPATH_FUNC_BEGIN();
 902         _orig_tracepath_glEnableVertexAttribArray(index);
 903
 904         goto finish;
 905
 906 finish:
 907         _COREGL_TRACEPATH_FUNC_END();
 908 }
 909
 910 void
 911 tracepath_glFinish(void)
 912 {
 913         _COREGL_TRACEPATH_FUNC_BEGIN();
 914         _orig_tracepath_glFinish();
 915
 916         _COREGL_TRACE_SURFACE(0, 0, "GLFINISH");
 917
 918         goto finish;
 919
 920 finish:
 921         _COREGL_TRACEPATH_FUNC_END();
 922         _COREGL_TRACE_API_OUTPUT(0);
 923         _COREGL_TRACE_MEM_OUTPUT(0);
 924 }
 925
 926 void
 927 tracepath_glFlush(void)
 928 {
 929         _COREGL_TRACEPATH_FUNC_BEGIN();
 930         _orig_tracepath_glFlush();
 931
 932         _COREGL_TRACE_SURFACE(0, 0, "GLFLUSH");
 933
 934         goto finish;
 935
 936 finish:
 937         _COREGL_TRACEPATH_FUNC_END();
 938         _COREGL_TRACE_API_OUTPUT(0);
 939         _COREGL_TRACE_MEM_OUTPUT(0);
 940 }
 941
 942 void
 943 tracepath_glFramebufferRenderbuffer(GLenum target, GLenum attachment,
 944                                     GLenum renderbuffertarget, GLuint renderbuffer)
 945 {
 946         _COREGL_TRACEPATH_FUNC_BEGIN();
 947
 948 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
 949         tracepath_fbdump_update(0);
 950 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
 951
 952         _orig_tracepath_glFramebufferRenderbuffer(target, attachment,
 953                         renderbuffertarget, renderbuffer);
 954
 955 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
 956         tracepath_fbdump_update(1);
 957 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
 958
 959         goto finish;
 960
 961 finish:
 962         _COREGL_TRACEPATH_FUNC_END();
 963 }
 964
 965 void
 966 tracepath_glFramebufferTexture2D(GLenum target, GLenum attachment,
 967                                  GLenum textarget, GLuint texture, GLint level)
 968 {
 969         _COREGL_TRACEPATH_FUNC_BEGIN();
 970
 971 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
 972         tracepath_fbdump_update(0);
 973 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
 974
 975         _orig_tracepath_glFramebufferTexture2D(target, attachment, textarget, texture,
 976                                                level);
 977
 978 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
 979         tracepath_fbdump_update(1);
 980 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
 981
 982         goto finish;
 983
 984 finish:
 985         _COREGL_TRACEPATH_FUNC_END();
 986 }
 987
 988 void
 989 tracepath_glFrontFace(GLenum mode)
 990 {
 991         _COREGL_TRACEPATH_FUNC_BEGIN();
 992         _orig_tracepath_glFrontFace(mode);
 993
 994         goto finish;
 995
 996 finish:
 997         _COREGL_TRACEPATH_FUNC_END();
 998 }
 999
1000 void
1001 tracepath_glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params)
1002 {
1003         _COREGL_TRACEPATH_FUNC_BEGIN();
1004         _orig_tracepath_glGetVertexAttribfv(index, pname, params);
1005
1006
1007         goto finish;
1008
1009 finish:
1010         _COREGL_TRACEPATH_FUNC_END();
1011 }
1012
1013 void
1014 tracepath_glGetVertexAttribiv(GLuint index, GLenum pname, GLint *params)
1015 {
1016         _COREGL_TRACEPATH_FUNC_BEGIN();
1017         _orig_tracepath_glGetVertexAttribiv(index, pname, params);
1018
1019
1020         goto finish;
1021
1022 finish:
1023         _COREGL_TRACEPATH_FUNC_END();
1024 }
1025
1026 void
1027 tracepath_glGetVertexAttribPointerv(GLuint index, GLenum pname, void **pointer)
1028 {
1029         _COREGL_TRACEPATH_FUNC_BEGIN();
1030         _orig_tracepath_glGetVertexAttribPointerv(index, pname, pointer);
1031
1032
1033
1034         goto finish;
1035
1036 finish:
1037         _COREGL_TRACEPATH_FUNC_END();
1038 }
1039
1040 void
1041 tracepath_glHint(GLenum target, GLenum mode)
1042 {
1043         _COREGL_TRACEPATH_FUNC_BEGIN();
1044         _orig_tracepath_glHint(target, mode);
1045
1046         goto finish;
1047
1048 finish:
1049         _COREGL_TRACEPATH_FUNC_END();
1050 }
1051
1052 void
1053 tracepath_glGenBuffers(GLsizei n, GLuint *buffers)
1054 {
1055         _COREGL_TRACEPATH_FUNC_BEGIN();
1056         _orig_tracepath_glGenBuffers(n, buffers);
1057
1058         goto finish;
1059
1060 finish:
1061         _COREGL_TRACEPATH_FUNC_END();
1062 }
1063
1064 void
1065 tracepath_glGenerateMipmap(GLenum target)
1066 {
1067         _COREGL_TRACEPATH_FUNC_BEGIN();
1068         _orig_tracepath_glGenerateMipmap(target);
1069
1070         goto finish;
1071
1072 finish:
1073         _COREGL_TRACEPATH_FUNC_END();
1074 }
1075
1076 void
1077 tracepath_glGenFramebuffers(GLsizei n, GLuint *framebuffers)
1078 {
1079         _COREGL_TRACEPATH_FUNC_BEGIN();
1080         _orig_tracepath_glGenFramebuffers(n, framebuffers);
1081
1082         goto finish;
1083
1084 finish:
1085         _COREGL_TRACEPATH_FUNC_END();
1086 }
1087
1088 void
1089 tracepath_glGenRenderbuffers(GLsizei n, GLuint *renderbuffers)
1090 {
1091         _COREGL_TRACEPATH_FUNC_BEGIN();
1092         _orig_tracepath_glGenRenderbuffers(n, renderbuffers);
1093
1094         goto finish;
1095
1096 finish:
1097         _COREGL_TRACEPATH_FUNC_END();
1098 #ifdef COREGL_TRACEPATH_TRACE_MEMUSE_INFO
1099         if (trace_mem_flag == 1) {
1100                 MY_MODULE_TSTATE *tstate = NULL;
1101
1102                 GET_MY_TSTATE(tstate, get_current_thread_state());
1103                 AST(tstate != NULL);
1104                 if (tstate->ctx != NULL) {
1105                         for (int i = 0; i < n; i++) {
1106                                 if (renderbuffers[i] == 0) continue;
1107                                 _add_glbuf_object(tstate->ctx->sostate->glbuf_rb, renderbuffers[i],
1108                                                   "Renderbuffer", 0, 0, 0, "Unknown");
1109                         }
1110                 }
1111         }
1112 #endif // COREGL_TRACEPATH_TRACE_MEMUSE_INFO
1113 }
1114
1115 void
1116 tracepath_glGenTextures(GLsizei n, GLuint *textures)
1117 {
1118         _COREGL_TRACEPATH_FUNC_BEGIN();
1119         _orig_tracepath_glGenTextures(n, textures);
1120
1121         goto finish;
1122
1123 finish:
1124         _COREGL_TRACEPATH_FUNC_END();
1125 #ifdef COREGL_TRACEPATH_TRACE_MEMUSE_INFO
1126         if (trace_mem_flag == 1) {
1127                 MY_MODULE_TSTATE *tstate = NULL;
1128
1129                 GET_MY_TSTATE(tstate, get_current_thread_state());
1130                 AST(tstate != NULL);
1131                 if (tstate->ctx != NULL) {
1132                         for (int i = 0; i < n; i++) {
1133                                 if (textures[i] == 0) continue;
1134                                 _add_glbuf_object(tstate->ctx->sostate->glbuf_tex, textures[i], "Texture", 0, 0,
1135                                                   0, "Unknown");
1136                         }
1137                 }
1138         }
1139 #endif // COREGL_TRACEPATH_TRACE_MEMUSE_INFO
1140 }
1141
1142 void
1143 tracepath_glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufsize,
1144                             GLsizei *length, GLint *size, GLenum *type, char *name)
1145 {
1146         _COREGL_TRACEPATH_FUNC_BEGIN();
1147         _orig_tracepath_glGetActiveAttrib(program, index, bufsize, length, size, type,
1148                                           name);
1149
1150         goto finish;
1151
1152 finish:
1153         _COREGL_TRACEPATH_FUNC_END();
1154 }
1155
1156 void
1157 tracepath_glGetActiveUniform(GLuint program, GLuint index, GLsizei bufsize,
1158                              GLsizei *length, GLint *size, GLenum *type, char *name)
1159 {
1160         _COREGL_TRACEPATH_FUNC_BEGIN();
1161         _orig_tracepath_glGetActiveUniform(program, index, bufsize, length, size, type,
1162                                            name);
1163
1164         goto finish;
1165
1166 finish:
1167         _COREGL_TRACEPATH_FUNC_END();
1168 }
1169
1170 void
1171 tracepath_glGetAttachedShaders(GLuint program, GLsizei maxcount, GLsizei *count,
1172                                GLuint *shaders)
1173 {
1174         _COREGL_TRACEPATH_FUNC_BEGIN();
1175         _orig_tracepath_glGetAttachedShaders(program, maxcount, count, shaders);
1176
1177         goto finish;
1178
1179 finish:
1180         _COREGL_TRACEPATH_FUNC_END();
1181 }
1182
1183 int
1184 tracepath_glGetAttribLocation(GLuint program, const char *name)
1185 {
1186         int ret = _COREGL_INT_INIT_VALUE;
1187         _COREGL_TRACEPATH_FUNC_BEGIN();
1188         ret = _orig_tracepath_glGetAttribLocation(program, name);
1189
1190         goto finish;
1191
1192 finish:
1193         _COREGL_TRACEPATH_FUNC_END();
1194         return ret;
1195 }
1196
1197 void
1198 tracepath_glGetBooleanv(GLenum pname, GLboolean *params)
1199 {
1200         _COREGL_TRACEPATH_FUNC_BEGIN();
1201         _orig_tracepath_glGetBooleanv(pname, params);
1202
1203         goto finish;
1204
1205 finish:
1206         _COREGL_TRACEPATH_FUNC_END();
1207 }
1208
1209 void
1210 tracepath_glGetBufferParameteriv(GLenum target, GLenum pname, GLint *params)
1211 {
1212         _COREGL_TRACEPATH_FUNC_BEGIN();
1213         _orig_tracepath_glGetBufferParameteriv(target, pname, params);
1214
1215         goto finish;
1216
1217 finish:
1218         _COREGL_TRACEPATH_FUNC_END();
1219 }
1220
1221 GLenum
1222 tracepath_glGetError(void)
1223 {
1224         GLenum ret = GL_NONE;
1225
1226         _COREGL_TRACEPATH_FUNC_BEGIN();
1227         ret = _orig_tracepath_glGetError();
1228         goto finish;
1229
1230 finish:
1231         _COREGL_TRACEPATH_FUNC_END();
1232         return ret;
1233 }
1234
1235 void
1236 tracepath_glGetFloatv(GLenum pname, GLfloat *params)
1237 {
1238         _COREGL_TRACEPATH_FUNC_BEGIN();
1239         _orig_tracepath_glGetFloatv(pname, params);
1240
1241         goto finish;
1242
1243 finish:
1244         _COREGL_TRACEPATH_FUNC_END();
1245 }
1246
1247 void
1248 tracepath_glGetFramebufferAttachmentParameteriv(GLenum target,
1249                 GLenum attachment, GLenum pname, GLint *params)
1250 {
1251         _COREGL_TRACEPATH_FUNC_BEGIN();
1252         _orig_tracepath_glGetFramebufferAttachmentParameteriv(target, attachment, pname,
1253                         params);
1254
1255         goto finish;
1256
1257 finish:
1258         _COREGL_TRACEPATH_FUNC_END();
1259 }
1260
1261 void
1262 tracepath_glGetIntegerv(GLenum pname, GLint *params)
1263 {
1264         _COREGL_TRACEPATH_FUNC_BEGIN();
1265         _orig_tracepath_glGetIntegerv(pname, params);
1266
1267         goto finish;
1268
1269 finish:
1270         _COREGL_TRACEPATH_FUNC_END();
1271 }
1272
1273 void
1274 tracepath_glGetProgramiv(GLuint program, GLenum pname, GLint *params)
1275 {
1276         _COREGL_TRACEPATH_FUNC_BEGIN();
1277         _orig_tracepath_glGetProgramiv(program, pname, params);
1278
1279         goto finish;
1280
1281 finish:
1282         _COREGL_TRACEPATH_FUNC_END();
1283 }
1284
1285 void
1286 tracepath_glGetProgramInfoLog(GLuint program, GLsizei bufsize, GLsizei *length,
1287                               char *infolog)
1288 {
1289         _COREGL_TRACEPATH_FUNC_BEGIN();
1290         _orig_tracepath_glGetProgramInfoLog(program, bufsize, length, infolog);
1291
1292         goto finish;
1293
1294 finish:
1295         _COREGL_TRACEPATH_FUNC_END();
1296 }
1297
1298 void
1299 tracepath_glGetRenderbufferParameteriv(GLenum target, GLenum pname,
1300                                        GLint *params)
1301 {
1302         _COREGL_TRACEPATH_FUNC_BEGIN();
1303         _orig_tracepath_glGetRenderbufferParameteriv(target, pname, params);
1304
1305         goto finish;
1306
1307 finish:
1308         _COREGL_TRACEPATH_FUNC_END();
1309 }
1310
1311 void
1312 tracepath_glGetShaderiv(GLuint shader, GLenum pname, GLint *params)
1313 {
1314         _COREGL_TRACEPATH_FUNC_BEGIN();
1315         _orig_tracepath_glGetShaderiv(shader, pname, params);
1316
1317         goto finish;
1318
1319 finish:
1320         _COREGL_TRACEPATH_FUNC_END();
1321 }
1322
1323 void
1324 tracepath_glGetShaderInfoLog(GLuint shader, GLsizei bufsize, GLsizei *length,
1325                              char *infolog)
1326 {
1327         _COREGL_TRACEPATH_FUNC_BEGIN();
1328         _orig_tracepath_glGetShaderInfoLog(shader, bufsize, length, infolog);
1329
1330         goto finish;
1331
1332 finish:
1333         _COREGL_TRACEPATH_FUNC_END();
1334 }
1335
1336 void
1337 tracepath_glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype,
1338                                      GLint *range, GLint *precision)
1339 {
1340         _COREGL_TRACEPATH_FUNC_BEGIN();
1341         _orig_tracepath_glGetShaderPrecisionFormat(shadertype, precisiontype, range,
1342                         precision);
1343
1344         goto finish;
1345
1346 finish:
1347         _COREGL_TRACEPATH_FUNC_END();
1348 }
1349
1350 void
1351 tracepath_glGetShaderSource(GLuint shader, GLsizei bufsize, GLsizei *length,
1352                             char *source)
1353 {
1354         _COREGL_TRACEPATH_FUNC_BEGIN();
1355         _orig_tracepath_glGetShaderSource(shader, bufsize, length, source);
1356
1357         goto finish;
1358
1359 finish:
1360         _COREGL_TRACEPATH_FUNC_END();
1361 }
1362
1363 const GLubyte *
1364 tracepath_glGetString(GLenum name)
1365 {
1366         const GLubyte *ret = NULL;
1367
1368         _COREGL_TRACEPATH_FUNC_BEGIN();
1369         ret = _orig_tracepath_glGetString(name);
1370
1371         goto finish;
1372
1373 finish:
1374         _COREGL_TRACEPATH_FUNC_END();
1375         return ret;
1376 }
1377
1378 void
1379 tracepath_glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params)
1380 {
1381         _COREGL_TRACEPATH_FUNC_BEGIN();
1382         _orig_tracepath_glGetTexParameterfv(target, pname, params);
1383
1384         goto finish;
1385
1386 finish:
1387         _COREGL_TRACEPATH_FUNC_END();
1388 }
1389
1390 void
1391 tracepath_glGetTexParameteriv(GLenum target, GLenum pname, GLint *params)
1392 {
1393         _COREGL_TRACEPATH_FUNC_BEGIN();
1394         _orig_tracepath_glGetTexParameteriv(target, pname, params);
1395
1396         goto finish;
1397
1398 finish:
1399         _COREGL_TRACEPATH_FUNC_END();
1400 }
1401
1402 void
1403 tracepath_glGetUniformfv(GLuint program, GLint location, GLfloat *params)
1404 {
1405         _COREGL_TRACEPATH_FUNC_BEGIN();
1406         _orig_tracepath_glGetUniformfv(program, location, params);
1407
1408         goto finish;
1409
1410 finish:
1411         _COREGL_TRACEPATH_FUNC_END();
1412 }
1413
1414 void
1415 tracepath_glGetUniformiv(GLuint program, GLint location, GLint *params)
1416 {
1417         _COREGL_TRACEPATH_FUNC_BEGIN();
1418         _orig_tracepath_glGetUniformiv(program, location, params);
1419
1420         goto finish;
1421
1422 finish:
1423         _COREGL_TRACEPATH_FUNC_END();
1424 }
1425 int
1426 tracepath_glGetUniformLocation(GLuint program, const char *name)
1427 {
1428         int ret = _COREGL_INT_INIT_VALUE;
1429
1430         _COREGL_TRACEPATH_FUNC_BEGIN();
1431         ret = _orig_tracepath_glGetUniformLocation(program, name);
1432
1433         goto finish;
1434
1435 finish:
1436         _COREGL_TRACEPATH_FUNC_END();
1437         return ret;
1438 }
1439
1440 GLboolean
1441 tracepath_glIsBuffer(GLuint buffer)
1442 {
1443         GLboolean ret = GL_FALSE;
1444
1445         _COREGL_TRACEPATH_FUNC_BEGIN();
1446         ret = _orig_tracepath_glIsBuffer(buffer);
1447
1448         goto finish;
1449
1450 finish:
1451         _COREGL_TRACEPATH_FUNC_END();
1452         return ret;
1453 }
1454
1455 GLboolean
1456 tracepath_glIsEnabled(GLenum cap)
1457 {
1458         GLboolean ret = GL_FALSE;
1459
1460         _COREGL_TRACEPATH_FUNC_BEGIN();
1461         ret = _orig_tracepath_glIsEnabled(cap);
1462
1463         goto finish;
1464
1465 finish:
1466         _COREGL_TRACEPATH_FUNC_END();
1467         return ret;
1468 }
1469
1470 GLboolean
1471 tracepath_glIsFramebuffer(GLuint framebuffer)
1472 {
1473         GLboolean ret = GL_FALSE;
1474
1475         _COREGL_TRACEPATH_FUNC_BEGIN();
1476         ret = _orig_tracepath_glIsFramebuffer(framebuffer);
1477
1478         goto finish;
1479
1480 finish:
1481         _COREGL_TRACEPATH_FUNC_END();
1482         return ret;
1483 }
1484
1485 GLboolean
1486 tracepath_glIsProgram(GLuint program)
1487 {
1488         GLboolean ret;
1489         _COREGL_TRACEPATH_FUNC_BEGIN();
1490         ret = _orig_tracepath_glIsProgram(program);
1491
1492         goto finish;
1493
1494 finish:
1495         _COREGL_TRACEPATH_FUNC_END();
1496         return ret;
1497 }
1498
1499 GLboolean
1500 tracepath_glIsRenderbuffer(GLuint renderbuffer)
1501 {
1502         GLboolean ret;
1503         _COREGL_TRACEPATH_FUNC_BEGIN();
1504         ret = _orig_tracepath_glIsRenderbuffer(renderbuffer);
1505
1506         goto finish;
1507
1508 finish:
1509         _COREGL_TRACEPATH_FUNC_END();
1510         return ret;
1511 }
1512
1513 GLboolean
1514 tracepath_glIsShader(GLuint shader)
1515 {
1516         GLboolean ret;
1517         _COREGL_TRACEPATH_FUNC_BEGIN();
1518         ret = _orig_tracepath_glIsShader(shader);
1519
1520         goto finish;
1521
1522 finish:
1523         _COREGL_TRACEPATH_FUNC_END();
1524         return ret;
1525 }
1526
1527 GLboolean
1528 tracepath_glIsTexture(GLuint texture)
1529 {
1530         GLboolean ret;
1531         _COREGL_TRACEPATH_FUNC_BEGIN();
1532         ret = _orig_tracepath_glIsTexture(texture);
1533
1534         goto finish;
1535
1536 finish:
1537         _COREGL_TRACEPATH_FUNC_END();
1538         return ret;
1539 }
1540
1541 void
1542 tracepath_glLineWidth(GLfloat width)
1543 {
1544         _COREGL_TRACEPATH_FUNC_BEGIN();
1545         _orig_tracepath_glLineWidth(width);
1546
1547         goto finish;
1548
1549 finish:
1550         _COREGL_TRACEPATH_FUNC_END();
1551 }
1552
1553 void
1554 tracepath_glLinkProgram(GLuint program)
1555 {
1556         _COREGL_TRACEPATH_FUNC_BEGIN();
1557         _orig_tracepath_glLinkProgram(program);
1558
1559         goto finish;
1560
1561 finish:
1562         _COREGL_TRACEPATH_FUNC_END();
1563 }
1564
1565 void
1566 tracepath_glPixelStorei(GLenum pname, GLint param)
1567 {
1568         _COREGL_TRACEPATH_FUNC_BEGIN();
1569         _orig_tracepath_glPixelStorei(pname, param);
1570
1571         goto finish;
1572
1573 finish:
1574         _COREGL_TRACEPATH_FUNC_END();
1575 }
1576
1577 void
1578 tracepath_glPolygonOffset(GLfloat factor, GLfloat units)
1579 {
1580         _COREGL_TRACEPATH_FUNC_BEGIN();
1581         _orig_tracepath_glPolygonOffset(factor, units);
1582
1583         goto finish;
1584
1585 finish:
1586         _COREGL_TRACEPATH_FUNC_END();
1587 }
1588
1589 void
1590 tracepath_glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height,
1591                        GLenum format, GLenum type, void *pixels)
1592 {
1593         _COREGL_TRACEPATH_FUNC_BEGIN();
1594         _orig_tracepath_glReadPixels(x, y, width, height, format, type, pixels);
1595
1596         goto finish;
1597
1598 finish:
1599         _COREGL_TRACEPATH_FUNC_END();
1600 }
1601
1602 void
1603 tracepath_glReleaseShaderCompiler(void)
1604 {
1605         _COREGL_TRACEPATH_FUNC_BEGIN();
1606         _orig_tracepath_glReleaseShaderCompiler();
1607
1608         goto finish;
1609
1610 finish:
1611         _COREGL_TRACEPATH_FUNC_END();
1612 }
1613
1614 void
1615 tracepath_glRenderbufferStorage(GLenum target, GLenum internalformat,
1616                                 GLsizei width, GLsizei height)
1617 {
1618         _COREGL_TRACEPATH_FUNC_BEGIN();
1619
1620         _orig_tracepath_glRenderbufferStorage(target, internalformat, width, height);
1621
1622         goto finish;
1623
1624 finish:
1625         _COREGL_TRACEPATH_FUNC_END();
1626 #ifdef COREGL_TRACEPATH_TRACE_MEMUSE_INFO
1627         if (trace_mem_flag == 1) {
1628                 MY_MODULE_TSTATE *tstate = NULL;
1629
1630                 GET_MY_TSTATE(tstate, get_current_thread_state());
1631                 AST(tstate != NULL);
1632                 if (tstate->ctx != NULL) {
1633                         int objidx = _COREGL_INT_INIT_VALUE;
1634                         _orig_tracepath_glGetIntegerv(GL_RENDERBUFFER_BINDING, &objidx);
1635                         AST(objidx != _COREGL_INT_INIT_VALUE);
1636
1637                         // Detect byte per pixel
1638                         int bpp = 0;
1639                         char formatment[80];
1640                         switch (internalformat) {
1641                         case GL_ALPHA:
1642                                 sprintf(formatment, "ALPHA");
1643                                 bpp = 1;
1644                                 break;
1645                         case GL_LUMINANCE:
1646                                 sprintf(formatment, "LUMINANCE");
1647                                 bpp = 1;
1648                                 break;
1649                         case GL_LUMINANCE_ALPHA:
1650                                 sprintf(formatment, "LUMINANCE_ALPHA");
1651                                 bpp = 1;
1652                                 break;
1653                         case GL_RGB:
1654                                 sprintf(formatment, "RGB");
1655                                 bpp = 2;
1656                                 break;
1657                         case GL_RGBA:
1658                                 sprintf(formatment, "RGBA");
1659                                 bpp = 4;
1660                                 break;
1661                         case 0x80E1:
1662                                 sprintf(formatment, "BGRA_EXT");
1663                                 bpp = 4;
1664                                 break;
1665                         case 0x84F9:
1666                                 sprintf(formatment, "DEPTH_STENCIL_OES");
1667                                 bpp = 4;
1668                                 break;
1669                         case GL_DEPTH_COMPONENT :
1670                                 sprintf(formatment, "DEPTH_COMPONENT");
1671                                 bpp = 1;
1672                                 break;
1673                         case 0x81A5:
1674                                 sprintf(formatment, "DEPTH_COMPONENT16_ARB");
1675                                 bpp = 2;
1676                                 break;
1677                         case 0x81A6:
1678                                 sprintf(formatment, "DEPTH_COMPONENT24_ARB");
1679                                 bpp = 3;
1680                                 break;
1681                         case 0x81A7:
1682                                 sprintf(formatment, "DEPTH_COMPONENT32_ARB");
1683                                 bpp = 4;
1684                                 break;
1685                         case 0x8D46 :
1686                                 sprintf(formatment, "STENCIL_INDEX1_OES");
1687                                 bpp = 1;
1688                                 break;
1689                         case 0x8D47 :
1690                                 sprintf(formatment, "STENCIL_INDEX4_OES");
1691                                 bpp = 1;
1692                                 break;
1693                         case 0x8D48 :
1694                                 sprintf(formatment, "STENCIL_INDEX8_OES");
1695                                 bpp = 1;
1696                                 break;
1697                         default:
1698                                 sprintf(formatment, "0x%X", internalformat);
1699                                 bpp = 0;
1700                                 break;
1701                         }
1702
1703                         _add_glbuf_object(tstate->ctx->sostate->glbuf_rb, objidx, "Renderbuffer", width,
1704                                           height, bpp, formatment);
1705                 }
1706         }
1707 #endif // COREGL_TRACEPATH_TRACE_MEMUSE_INFO
1708 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
1709         if (trace_surface_flag == 1) {
1710                 MY_MODULE_TSTATE *tstate = NULL;
1711
1712                 GET_MY_TSTATE(tstate, get_current_thread_state());
1713                 AST(tstate != NULL);
1714                 if (tstate->ctx != NULL) {
1715                         int objidx = _COREGL_INT_INIT_VALUE;
1716                         _orig_tracepath_glGetIntegerv(GL_RENDERBUFFER_BINDING, &objidx);
1717                         AST(objidx != _COREGL_INT_INIT_VALUE);
1718
1719                         {
1720                                 int channel = 0;
1721                                 switch (internalformat) {
1722                                 case GL_ALPHA:
1723                                 case GL_LUMINANCE:
1724                                 case GL_DEPTH_COMPONENT :
1725                                 case 0x81A5:
1726                                 case 0x81A6:
1727                                 case 0x81A7:
1728                                 case 0x8D46 :
1729                                 case 0x8D47 :
1730                                 case 0x8D48 :
1731                                         channel = 1;
1732                                         break;
1733                                 case GL_LUMINANCE_ALPHA:
1734                                 case 0x84F9:
1735                                         channel = 2;
1736                                         break;
1737                                 case GL_RGB:
1738                                         channel = 3;
1739                                         break;
1740                                 case GL_RGBA:
1741                                 case 0x80E1:
1742                                         channel = 4;
1743                                         break;
1744                                 }
1745
1746                                 char name[256];
1747                                 sprintf(name, "FBORB_%d", objidx);
1748                                 tracepath_surface_trace_add(name, tstate->ctx->dpy, tstate->ctx->handle,
1749                                                             tstate->surf_draw, -1, 0, objidx, width, height, channel, NULL);
1750                         }
1751                 }
1752         }
1753 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
1754 }
1755
1756 void
1757 tracepath_glSampleCoverage(GLclampf value, GLboolean invert)
1758 {
1759         _COREGL_TRACEPATH_FUNC_BEGIN();
1760         _orig_tracepath_glSampleCoverage(value, invert);
1761
1762         goto finish;
1763
1764 finish:
1765         _COREGL_TRACEPATH_FUNC_END();
1766 }
1767
1768 void
1769 tracepath_glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
1770 {
1771         _COREGL_TRACEPATH_FUNC_BEGIN();
1772         _orig_tracepath_glScissor(x, y, width, height);
1773
1774         goto finish;
1775
1776 finish:
1777         _COREGL_TRACEPATH_FUNC_END();
1778 }
1779
1780 void
1781 tracepath_glShaderBinary(GLsizei n, const GLuint *shaders, GLenum binaryformat,
1782                          const void *binary, GLsizei length)
1783 {
1784         _COREGL_TRACEPATH_FUNC_BEGIN();
1785         _orig_tracepath_glShaderBinary(n, shaders, binaryformat, binary, length);
1786
1787         goto finish;
1788
1789 finish:
1790         _COREGL_TRACEPATH_FUNC_END();
1791 }
1792
1793 void
1794 tracepath_glShaderSource(GLuint shader, GLsizei count, const char **string,
1795                          const GLint *length)
1796 {
1797         _COREGL_TRACEPATH_FUNC_BEGIN();
1798         _orig_tracepath_glShaderSource(shader, count, string, length);
1799
1800         goto finish;
1801
1802 finish:
1803         _COREGL_TRACEPATH_FUNC_END();
1804 }
1805
1806 void
1807 tracepath_glStencilFunc(GLenum func, GLint ref, GLuint mask)
1808 {
1809         _COREGL_TRACEPATH_FUNC_BEGIN();
1810         _orig_tracepath_glStencilFunc(func, ref, mask);
1811
1812         goto finish;
1813
1814 finish:
1815         _COREGL_TRACEPATH_FUNC_END();
1816 }
1817
1818 void
1819 tracepath_glStencilFuncSeparate(GLenum face, GLenum func, GLint ref,
1820                                 GLuint mask)
1821 {
1822         _COREGL_TRACEPATH_FUNC_BEGIN();
1823         _orig_tracepath_glStencilFuncSeparate(face, func, ref, mask);
1824
1825         goto finish;
1826
1827 finish:
1828         _COREGL_TRACEPATH_FUNC_END();
1829 }
1830
1831 void
1832 tracepath_glStencilMask(GLuint mask)
1833 {
1834         _COREGL_TRACEPATH_FUNC_BEGIN();
1835         _orig_tracepath_glStencilMask(mask);
1836
1837         goto finish;
1838
1839 finish:
1840         _COREGL_TRACEPATH_FUNC_END();
1841 }
1842
1843 void
1844 tracepath_glStencilMaskSeparate(GLenum face, GLuint mask)
1845 {
1846         _COREGL_TRACEPATH_FUNC_BEGIN();
1847         _orig_tracepath_glStencilMaskSeparate(face, mask);
1848
1849         goto finish;
1850
1851 finish:
1852         _COREGL_TRACEPATH_FUNC_END();
1853 }
1854
1855 void
1856 tracepath_glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
1857 {
1858         _COREGL_TRACEPATH_FUNC_BEGIN();
1859         _orig_tracepath_glStencilOp(fail, zfail, zpass);
1860
1861         goto finish;
1862
1863 finish:
1864         _COREGL_TRACEPATH_FUNC_END();
1865 }
1866
1867 void
1868 tracepath_glStencilOpSeparate(GLenum face, GLenum fail, GLenum zfail,
1869                               GLenum zpass)
1870 {
1871         _COREGL_TRACEPATH_FUNC_BEGIN();
1872         _orig_tracepath_glStencilOpSeparate(face, fail, zfail, zpass);
1873
1874         goto finish;
1875
1876 finish:
1877         _COREGL_TRACEPATH_FUNC_END();
1878 }
1879
1880 void
1881 tracepath_glTexImage2D(GLenum target, GLint level, GLint internalformat,
1882                        GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type,
1883                        const void *pixels)
1884 {
1885         _COREGL_TRACEPATH_FUNC_BEGIN();
1886         _orig_tracepath_glTexImage2D(target, level, internalformat, width, height,
1887                                      border, format, type, pixels);
1888
1889         goto finish;
1890
1891 finish:
1892         _COREGL_TRACEPATH_FUNC_END();
1893 #ifdef COREGL_TRACEPATH_TRACE_MEMUSE_INFO
1894         if (trace_mem_flag == 1) {
1895                 MY_MODULE_TSTATE *tstate = NULL;
1896
1897                 GET_MY_TSTATE(tstate, get_current_thread_state());
1898                 AST(tstate != NULL);
1899                 if (tstate->ctx != NULL) {
1900                         int objidx = _COREGL_INT_INIT_VALUE;
1901                         _orig_tracepath_glGetIntegerv(GL_TEXTURE_BINDING_2D, &objidx);
1902                         AST(objidx != _COREGL_INT_INIT_VALUE);
1903
1904                         // Detect byte per pixel
1905                         int bpp = 0;
1906                         char formatment[80];
1907                         switch (internalformat) {
1908                         case GL_ALPHA:
1909                                 sprintf(formatment, "ALPHA");
1910                                 bpp = 1;
1911                                 break;
1912                         case GL_LUMINANCE:
1913                                 sprintf(formatment, "LUMINANCE");
1914                                 bpp = 1;
1915                                 break;
1916                         case GL_LUMINANCE_ALPHA:
1917                                 sprintf(formatment, "LUMINANCE_ALPHA");
1918                                 bpp = 1;
1919                                 break;
1920                         case GL_RGB:
1921                                 sprintf(formatment, "RGB");
1922                                 bpp = 2;
1923                                 break;
1924                         case GL_RGBA:
1925                                 sprintf(formatment, "RGBA");
1926                                 bpp = 4;
1927                                 break;
1928                         case 0x80E1:
1929                                 sprintf(formatment, "BGRA_EXT");
1930                                 bpp = 4;
1931                                 break;
1932                         case 0x84F9:
1933                                 sprintf(formatment, "DEPTH_STENCIL_OES");
1934                                 bpp = 4;
1935                                 break;
1936                         case GL_DEPTH_COMPONENT :
1937                                 sprintf(formatment, "DEPTH_COMPONENT");
1938                                 bpp = 1;
1939                                 break;
1940                         case 0x81A5:
1941                                 sprintf(formatment, "DEPTH_COMPONENT16_ARB");
1942                                 bpp = 2;
1943                                 break;
1944                         case 0x81A6:
1945                                 sprintf(formatment, "DEPTH_COMPONENT24_ARB");
1946                                 bpp = 3;
1947                                 break;
1948                         case 0x81A7:
1949                                 sprintf(formatment, "DEPTH_COMPONENT32_ARB");
1950                                 bpp = 4;
1951                                 break;
1952                         case 0x8D46 :
1953                                 sprintf(formatment, "STENCIL_INDEX1_OES");
1954                                 bpp = 1;
1955                                 break;
1956                         case 0x8D47 :
1957                                 sprintf(formatment, "STENCIL_INDEX4_OES");
1958                                 bpp = 1;
1959                                 break;
1960                         case 0x8D48 :
1961                                 sprintf(formatment, "STENCIL_INDEX8_OES");
1962                                 bpp = 1;
1963                                 break;
1964                         default:
1965                                 sprintf(formatment, "0x%X", internalformat);
1966                                 bpp = 0;
1967                                 break;
1968                         }
1969
1970                         _add_glbuf_object(tstate->ctx->sostate->glbuf_tex, objidx, "Texture", width,
1971                                           height, bpp, formatment);
1972                 }
1973         }
1974 #endif // COREGL_TRACEPATH_TRACE_MEMUSE_INFO
1975 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
1976         if (trace_surface_flag == 1) {
1977                 MY_MODULE_TSTATE *tstate = NULL;
1978
1979                 GET_MY_TSTATE(tstate, get_current_thread_state());
1980                 AST(tstate != NULL);
1981                 if (tstate->ctx != NULL) {
1982                         int objidx = _COREGL_INT_INIT_VALUE;
1983                         _orig_tracepath_glGetIntegerv(GL_TEXTURE_BINDING_2D, &objidx);
1984                         AST(objidx != _COREGL_INT_INIT_VALUE);
1985
1986                         {
1987                                 int channel = 0;
1988                                 switch (internalformat) {
1989                                 case GL_ALPHA:
1990                                 case GL_LUMINANCE:
1991                                 case GL_DEPTH_COMPONENT :
1992                                 case 0x81A5:
1993                                 case 0x81A6:
1994                                 case 0x81A7:
1995                                 case 0x8D46 :
1996                                 case 0x8D47 :
1997                                 case 0x8D48 :
1998                                         channel = 1;
1999                                         break;
2000                                 case GL_LUMINANCE_ALPHA:
2001                                 case 0x84F9:
2002                                         channel = 2;
2003                                         break;
2004                                 case GL_RGB:
2005                                         channel = 3;
2006                                         break;
2007                                 case GL_RGBA:
2008                                 case 0x80E1:
2009                                         channel = 4;
2010                                         break;
2011                                 }
2012
2013                                 char name[256];
2014                                 sprintf(name, "FBOTEX_0x%X", objidx);
2015                                 tracepath_surface_trace_add(name, tstate->ctx->dpy, tstate->ctx->handle,
2016                                                             tstate->surf_draw, -1, objidx, 0, width, height, channel, NULL);
2017                         }
2018                 }
2019         }
2020 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
2021 }
2022
2023 void
2024 tracepath_glTexParameterf(GLenum target, GLenum pname, GLfloat param)
2025 {
2026         _COREGL_TRACEPATH_FUNC_BEGIN();
2027         _orig_tracepath_glTexParameterf(target, pname, param);
2028
2029         goto finish;
2030
2031 finish:
2032         _COREGL_TRACEPATH_FUNC_END();
2033 }
2034
2035 void
2036 tracepath_glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params)
2037 {
2038         _COREGL_TRACEPATH_FUNC_BEGIN();
2039         _orig_tracepath_glTexParameterfv(target, pname, params);
2040
2041         goto finish;
2042
2043 finish:
2044         _COREGL_TRACEPATH_FUNC_END();
2045 }
2046
2047 void
2048 tracepath_glTexParameteri(GLenum target, GLenum pname, GLint param)
2049 {
2050         _COREGL_TRACEPATH_FUNC_BEGIN();
2051         _orig_tracepath_glTexParameteri(target, pname, param);
2052
2053         goto finish;
2054
2055 finish:
2056         _COREGL_TRACEPATH_FUNC_END();
2057 }
2058
2059 void
2060 tracepath_glTexParameteriv(GLenum target, GLenum pname, const GLint *params)
2061 {
2062         _COREGL_TRACEPATH_FUNC_BEGIN();
2063         _orig_tracepath_glTexParameteriv(target, pname, params);
2064
2065         goto finish;
2066
2067 finish:
2068         _COREGL_TRACEPATH_FUNC_END();
2069 }
2070
2071 void
2072 tracepath_glTexSubImage2D(GLenum target, GLint level, GLint xoffset,
2073                           GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type,
2074                           const void *pixels)
2075 {
2076         _COREGL_TRACEPATH_FUNC_BEGIN();
2077         _orig_tracepath_glTexSubImage2D(target, level, xoffset, yoffset, width, height,
2078                                         format, type, pixels);
2079
2080         goto finish;
2081
2082 finish:
2083         _COREGL_TRACEPATH_FUNC_END();
2084 }
2085
2086 void
2087 tracepath_glUniform1f(GLint location, GLfloat x)
2088 {
2089         _COREGL_TRACEPATH_FUNC_BEGIN();
2090         _orig_tracepath_glUniform1f(location, x);
2091
2092         goto finish;
2093
2094 finish:
2095         _COREGL_TRACEPATH_FUNC_END();
2096 }
2097
2098 void
2099 tracepath_glUniform1fv(GLint location, GLsizei count, const GLfloat *v)
2100 {
2101         _COREGL_TRACEPATH_FUNC_BEGIN();
2102         _orig_tracepath_glUniform1fv(location, count, v);
2103
2104         goto finish;
2105
2106 finish:
2107         _COREGL_TRACEPATH_FUNC_END();
2108 }
2109
2110 void
2111 tracepath_glUniform1i(GLint location, GLint x)
2112 {
2113         _COREGL_TRACEPATH_FUNC_BEGIN();
2114         _orig_tracepath_glUniform1i(location, x);
2115
2116         goto finish;
2117
2118 finish:
2119         _COREGL_TRACEPATH_FUNC_END();
2120 }
2121
2122 void
2123 tracepath_glUniform1iv(GLint location, GLsizei count, const GLint *v)
2124 {
2125         _COREGL_TRACEPATH_FUNC_BEGIN();
2126         _orig_tracepath_glUniform1iv(location, count, v);
2127
2128         goto finish;
2129
2130 finish:
2131         _COREGL_TRACEPATH_FUNC_END();
2132 }
2133
2134 void
2135 tracepath_glUniform2f(GLint location, GLfloat x, GLfloat y)
2136 {
2137         _COREGL_TRACEPATH_FUNC_BEGIN();
2138         _orig_tracepath_glUniform2f(location, x, y);
2139
2140         goto finish;
2141
2142 finish:
2143         _COREGL_TRACEPATH_FUNC_END();
2144 }
2145
2146 void
2147 tracepath_glUniform2fv(GLint location, GLsizei count, const GLfloat *v)
2148 {
2149         _COREGL_TRACEPATH_FUNC_BEGIN();
2150         _orig_tracepath_glUniform2fv(location, count, v);
2151
2152         goto finish;
2153
2154 finish:
2155         _COREGL_TRACEPATH_FUNC_END();
2156 }
2157
2158 void
2159 tracepath_glUniform2i(GLint location, GLint x, GLint y)
2160 {
2161         _COREGL_TRACEPATH_FUNC_BEGIN();
2162         _orig_tracepath_glUniform2i(location, x, y);
2163
2164         goto finish;
2165
2166 finish:
2167         _COREGL_TRACEPATH_FUNC_END();
2168 }
2169
2170 void
2171 tracepath_glUniform2iv(GLint location, GLsizei count, const GLint *v)
2172 {
2173         _COREGL_TRACEPATH_FUNC_BEGIN();
2174         _orig_tracepath_glUniform2iv(location, count, v);
2175
2176         goto finish;
2177
2178 finish:
2179         _COREGL_TRACEPATH_FUNC_END();
2180 }
2181
2182 void
2183 tracepath_glUniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z)
2184 {
2185         _COREGL_TRACEPATH_FUNC_BEGIN();
2186         _orig_tracepath_glUniform3f(location, x, y, z);
2187
2188         goto finish;
2189
2190 finish:
2191         _COREGL_TRACEPATH_FUNC_END();
2192 }
2193
2194 void
2195 tracepath_glUniform3fv(GLint location, GLsizei count, const GLfloat *v)
2196 {
2197         _COREGL_TRACEPATH_FUNC_BEGIN();
2198         _orig_tracepath_glUniform3fv(location, count, v);
2199
2200         goto finish;
2201
2202 finish:
2203         _COREGL_TRACEPATH_FUNC_END();
2204 }
2205
2206 void
2207 tracepath_glUniform3i(GLint location, GLint x, GLint y, GLint z)
2208 {
2209         _COREGL_TRACEPATH_FUNC_BEGIN();
2210         _orig_tracepath_glUniform3i(location, x, y, z);
2211
2212         goto finish;
2213
2214 finish:
2215         _COREGL_TRACEPATH_FUNC_END();
2216 }
2217
2218 void
2219 tracepath_glUniform3iv(GLint location, GLsizei count, const GLint *v)
2220 {
2221         _COREGL_TRACEPATH_FUNC_BEGIN();
2222         _orig_tracepath_glUniform3iv(location, count, v);
2223
2224         goto finish;
2225
2226 finish:
2227         _COREGL_TRACEPATH_FUNC_END();
2228 }
2229
2230 void
2231 tracepath_glUniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z,
2232                       GLfloat w)
2233 {
2234         _COREGL_TRACEPATH_FUNC_BEGIN();
2235         _orig_tracepath_glUniform4f(location, x, y, z, w);
2236
2237         goto finish;
2238
2239 finish:
2240         _COREGL_TRACEPATH_FUNC_END();
2241 }
2242
2243 void
2244 tracepath_glUniform4fv(GLint location, GLsizei count, const GLfloat *v)
2245 {
2246         _COREGL_TRACEPATH_FUNC_BEGIN();
2247         _orig_tracepath_glUniform4fv(location, count, v);
2248
2249         goto finish;
2250
2251 finish:
2252         _COREGL_TRACEPATH_FUNC_END();
2253 }
2254
2255 void
2256 tracepath_glUniform4i(GLint location, GLint x, GLint y, GLint z, GLint w)
2257 {
2258         _COREGL_TRACEPATH_FUNC_BEGIN();
2259         _orig_tracepath_glUniform4i(location, x, y, z, w);
2260
2261         goto finish;
2262
2263 finish:
2264         _COREGL_TRACEPATH_FUNC_END();
2265 }
2266
2267 void
2268 tracepath_glUniform4iv(GLint location, GLsizei count, const GLint *v)
2269 {
2270         _COREGL_TRACEPATH_FUNC_BEGIN();
2271         _orig_tracepath_glUniform4iv(location, count, v);
2272
2273         goto finish;
2274
2275 finish:
2276         _COREGL_TRACEPATH_FUNC_END();
2277 }
2278
2279 void
2280 tracepath_glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose,
2281                              const GLfloat *value)
2282 {
2283         _COREGL_TRACEPATH_FUNC_BEGIN();
2284         _orig_tracepath_glUniformMatrix2fv(location, count, transpose, value);
2285
2286         goto finish;
2287
2288 finish:
2289         _COREGL_TRACEPATH_FUNC_END();
2290 }
2291
2292 void
2293 tracepath_glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose,
2294                              const GLfloat *value)
2295 {
2296         _COREGL_TRACEPATH_FUNC_BEGIN();
2297         _orig_tracepath_glUniformMatrix3fv(location, count, transpose, value);
2298
2299         goto finish;
2300
2301 finish:
2302         _COREGL_TRACEPATH_FUNC_END();
2303 }
2304
2305 void
2306 tracepath_glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose,
2307                              const GLfloat *value)
2308 {
2309         _COREGL_TRACEPATH_FUNC_BEGIN();
2310         _orig_tracepath_glUniformMatrix4fv(location, count, transpose, value);
2311
2312         goto finish;
2313
2314 finish:
2315         _COREGL_TRACEPATH_FUNC_END();
2316 }
2317
2318 void
2319 tracepath_glUseProgram(GLuint program)
2320 {
2321         _COREGL_TRACEPATH_FUNC_BEGIN();
2322         _orig_tracepath_glUseProgram(program);
2323
2324         goto finish;
2325
2326 finish:
2327         _COREGL_TRACEPATH_FUNC_END();
2328 }
2329
2330 void
2331 tracepath_glValidateProgram(GLuint program)
2332 {
2333         _COREGL_TRACEPATH_FUNC_BEGIN();
2334         _orig_tracepath_glValidateProgram(program);
2335
2336         goto finish;
2337
2338 finish:
2339         _COREGL_TRACEPATH_FUNC_END();
2340 }
2341
2342 void
2343 tracepath_glVertexAttrib1f(GLuint index, GLfloat x)
2344 {
2345         _COREGL_TRACEPATH_FUNC_BEGIN();
2346         _orig_tracepath_glVertexAttrib1f(index, x);
2347
2348         goto finish;
2349
2350 finish:
2351         _COREGL_TRACEPATH_FUNC_END();
2352 }
2353
2354 void
2355 tracepath_glVertexAttrib1fv(GLuint index, const GLfloat *values)
2356 {
2357         _COREGL_TRACEPATH_FUNC_BEGIN();
2358         _orig_tracepath_glVertexAttrib1fv(index, values);
2359
2360         goto finish;
2361
2362 finish:
2363         _COREGL_TRACEPATH_FUNC_END();
2364 }
2365
2366 void
2367 tracepath_glVertexAttrib2f(GLuint index, GLfloat x, GLfloat y)
2368 {
2369         _COREGL_TRACEPATH_FUNC_BEGIN();
2370         _orig_tracepath_glVertexAttrib2f(index, x, y);
2371
2372         goto finish;
2373
2374 finish:
2375         _COREGL_TRACEPATH_FUNC_END();
2376 }
2377
2378 void
2379 tracepath_glVertexAttrib2fv(GLuint index, const GLfloat *values)
2380 {
2381         _COREGL_TRACEPATH_FUNC_BEGIN();
2382         _orig_tracepath_glVertexAttrib2fv(index, values);
2383
2384         goto finish;
2385
2386 finish:
2387         _COREGL_TRACEPATH_FUNC_END();
2388 }
2389
2390 void
2391 tracepath_glVertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z)
2392 {
2393         _COREGL_TRACEPATH_FUNC_BEGIN();
2394         _orig_tracepath_glVertexAttrib3f(index, x, y, z);
2395
2396         goto finish;
2397
2398 finish:
2399         _COREGL_TRACEPATH_FUNC_END();
2400 }
2401
2402 void
2403 tracepath_glVertexAttrib3fv(GLuint index, const GLfloat *values)
2404 {
2405         _COREGL_TRACEPATH_FUNC_BEGIN();
2406         _orig_tracepath_glVertexAttrib3fv(index, values);
2407
2408         goto finish;
2409
2410 finish:
2411         _COREGL_TRACEPATH_FUNC_END();
2412 }
2413
2414 void
2415 tracepath_glVertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z,
2416                            GLfloat w)
2417 {
2418         _COREGL_TRACEPATH_FUNC_BEGIN();
2419         _orig_tracepath_glVertexAttrib4f(index, x, y, z, w);
2420
2421         goto finish;
2422
2423 finish:
2424         _COREGL_TRACEPATH_FUNC_END();
2425 }
2426
2427 void
2428 tracepath_glVertexAttrib4fv(GLuint index, const GLfloat *values)
2429 {
2430         _COREGL_TRACEPATH_FUNC_BEGIN();
2431         _orig_tracepath_glVertexAttrib4fv(index, values);
2432
2433         goto finish;
2434
2435 finish:
2436         _COREGL_TRACEPATH_FUNC_END();
2437 }
2438
2439 void
2440 tracepath_glVertexAttribPointer(GLuint index, GLint size, GLenum type,
2441                                 GLboolean normalized, GLsizei stride, const void *pointer)
2442 {
2443         _COREGL_TRACEPATH_FUNC_BEGIN();
2444         _orig_tracepath_glVertexAttribPointer(index, size, type, normalized, stride,
2445                                               pointer);
2446
2447         goto finish;
2448
2449 finish:
2450         _COREGL_TRACEPATH_FUNC_END();
2451 }
2452
2453 void
2454 tracepath_glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
2455 {
2456         _COREGL_TRACEPATH_FUNC_BEGIN();
2457         _orig_tracepath_glViewport(x, y, width, height);
2458
2459         goto finish;
2460
2461 finish:
2462         _COREGL_TRACEPATH_FUNC_END();
2463 }
2464
2465
2466 /* OpenGL ES 3.0 */
2467 void
2468 tracepath_glReadBuffer(GLenum mode)
2469 {
2470         _COREGL_TRACEPATH_FUNC_BEGIN();
2471         _orig_tracepath_glReadBuffer(mode);
2472
2473         goto finish;
2474
2475 finish:
2476         _COREGL_TRACEPATH_FUNC_END();
2477 }
2478
2479 void
2480 tracepath_glDrawRangeElements(GLenum mode, GLuint start, GLuint end,
2481                               GLsizei count, GLenum type, const GLvoid *indices)
2482 {
2483         _COREGL_TRACEPATH_FUNC_BEGIN();
2484         _orig_tracepath_glDrawRangeElements(mode, start, end, count, type, indices);
2485
2486         goto finish;
2487
2488 finish:
2489         _COREGL_TRACEPATH_FUNC_END();
2490 }
2491
2492 void
2493 tracepath_glTexImage3D(GLenum target, GLint level, GLint GLinternalFormat,
2494                        GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format,
2495                        GLenum type, const GLvoid *pixels)
2496 {
2497         _COREGL_TRACEPATH_FUNC_BEGIN();
2498         _orig_tracepath_glTexImage3D(target, level, GLinternalFormat, width, height,
2499                                      depth, border, format, type, pixels);
2500
2501         goto finish;
2502
2503 finish:
2504         _COREGL_TRACEPATH_FUNC_END();
2505 }
2506
2507 void
2508 tracepath_glTexImage3DOES(GLenum target, GLint level, GLenum GLinternalFormat,
2509                           GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format,
2510                           GLenum type, const void *pixels)
2511 {
2512         _COREGL_TRACEPATH_FUNC_BEGIN();
2513         _orig_tracepath_glTexImage3DOES(target, level, GLinternalFormat, width, height,
2514                                         depth, border, format, type, pixels);
2515
2516         goto finish;
2517
2518 finish:
2519         _COREGL_TRACEPATH_FUNC_END();
2520 }
2521
2522 void
2523 tracepath_glTexSubImage3D(GLenum target, GLint level, GLint xoffset,
2524                           GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth,
2525                           GLenum format, GLenum type, const GLvoid *pixels)
2526 {
2527         _COREGL_TRACEPATH_FUNC_BEGIN();
2528         _orig_tracepath_glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width,
2529                                         height, depth, format, type, pixels);
2530
2531         goto finish;
2532
2533 finish:
2534         _COREGL_TRACEPATH_FUNC_END();
2535 }
2536
2537 void
2538 tracepath_glTexSubImage3DOES(GLenum target, GLint level, GLint xoffset,
2539                              GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth,
2540                              GLenum format, GLenum type, const GLvoid *pixels)
2541 {
2542         _COREGL_TRACEPATH_FUNC_BEGIN();
2543         _orig_tracepath_glTexSubImage3DOES(target, level, xoffset, yoffset, zoffset,
2544                                            width, height, depth, format, type, pixels);
2545
2546         goto finish;
2547
2548 finish:
2549         _COREGL_TRACEPATH_FUNC_END();
2550 }
2551
2552 void
2553 tracepath_glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset,
2554                               GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
2555 {
2556         _COREGL_TRACEPATH_FUNC_BEGIN();
2557         _orig_tracepath_glCopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x,
2558                                             y, width, height);
2559
2560         goto finish;
2561
2562 finish:
2563         _COREGL_TRACEPATH_FUNC_END();
2564 }
2565
2566 void
2567 tracepath_glCopyTexSubImage3DOES(GLenum target, GLint level, GLint xoffset,
2568                                  GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
2569 {
2570         _COREGL_TRACEPATH_FUNC_BEGIN();
2571         _orig_tracepath_glCopyTexSubImage3DOES(target, level, xoffset, yoffset, zoffset,
2572                                                x, y, width, height);
2573
2574         goto finish;
2575
2576 finish:
2577         _COREGL_TRACEPATH_FUNC_END();
2578 }
2579
2580 void
2581 tracepath_glCompressedTexImage3D(GLenum target, GLint level,
2582                                  GLenum GLinternalformat, GLsizei width, GLsizei height, GLsizei depth,
2583                                  GLint border, GLsizei imageSize, const GLvoid *data)
2584 {
2585         _COREGL_TRACEPATH_FUNC_BEGIN();
2586         _orig_tracepath_glCompressedTexImage3D(target, level, GLinternalformat, width,
2587                                                height, depth, border, imageSize, data);
2588
2589         goto finish;
2590
2591 finish:
2592         _COREGL_TRACEPATH_FUNC_END();
2593 }
2594
2595 void
2596 tracepath_glCompressedTexImage3DOES(GLenum target, GLint level,
2597                                     GLenum GLinternalformat, GLsizei width, GLsizei height, GLsizei depth,
2598                                     GLint border, GLsizei imageSize, const GLvoid *data)
2599 {
2600         _COREGL_TRACEPATH_FUNC_BEGIN();
2601         _orig_tracepath_glCompressedTexImage3DOES(target, level, GLinternalformat,
2602                         width, height, depth, border, imageSize, data);
2603
2604         goto finish;
2605
2606 finish:
2607         _COREGL_TRACEPATH_FUNC_END();
2608 }
2609
2610 void
2611 tracepath_glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset,
2612                                     GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth,
2613                                     GLenum format, GLsizei imageSize, const GLvoid *data)
2614 {
2615         _COREGL_TRACEPATH_FUNC_BEGIN();
2616         _orig_tracepath_glCompressedTexSubImage3D(target, level, xoffset, yoffset,
2617                         zoffset, width, height, depth, format, imageSize, data);
2618
2619         goto finish;
2620
2621 finish:
2622         _COREGL_TRACEPATH_FUNC_END();
2623 }
2624
2625 void
2626 tracepath_glCompressedTexSubImage3DOES(GLenum target, GLint level,
2627                                        GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height,
2628                                        GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data)
2629 {
2630         _COREGL_TRACEPATH_FUNC_BEGIN();
2631         _orig_tracepath_glCompressedTexSubImage3DOES(target, level, xoffset, yoffset,
2632                         zoffset, width, height, depth, format, imageSize, data);
2633
2634         goto finish;
2635
2636 finish:
2637         _COREGL_TRACEPATH_FUNC_END();
2638 }
2639
2640 void
2641 tracepath_glGenQueries(GLsizei n, GLuint *ids)
2642 {
2643         _COREGL_TRACEPATH_FUNC_BEGIN();
2644         _orig_tracepath_glGenQueries(n, ids);
2645
2646         goto finish;
2647
2648 finish:
2649         _COREGL_TRACEPATH_FUNC_END();
2650 }
2651
2652 void
2653 tracepath_glDeleteQueries(GLsizei n, const GLuint *ids)
2654 {
2655         _COREGL_TRACEPATH_FUNC_BEGIN();
2656         _orig_tracepath_glDeleteQueries(n, ids);
2657
2658         goto finish;
2659
2660 finish:
2661         _COREGL_TRACEPATH_FUNC_END();
2662 }
2663
2664 GLboolean
2665 tracepath_glIsQuery(GLuint id)
2666 {
2667         GLboolean ret = GL_FALSE;
2668
2669         _COREGL_TRACEPATH_FUNC_BEGIN();
2670         ret = _orig_tracepath_glIsQuery(id);
2671
2672         goto finish;
2673
2674 finish:
2675         _COREGL_TRACEPATH_FUNC_END();
2676         return ret;
2677 }
2678
2679 void
2680 tracepath_glBeginQuery(GLenum target, GLuint id)
2681 {
2682         _COREGL_TRACEPATH_FUNC_BEGIN();
2683         _orig_tracepath_glBeginQuery(target, id);
2684
2685         goto finish;
2686
2687 finish:
2688         _COREGL_TRACEPATH_FUNC_END();
2689 }
2690
2691 void
2692 tracepath_glEndQuery(GLenum target)
2693 {
2694         _COREGL_TRACEPATH_FUNC_BEGIN();
2695         _orig_tracepath_glEndQuery(target);
2696
2697         goto finish;
2698
2699 finish:
2700         _COREGL_TRACEPATH_FUNC_END();
2701 }
2702
2703 void
2704 tracepath_glGetQueryiv(GLenum target, GLenum pname, GLint *params)
2705 {
2706         _COREGL_TRACEPATH_FUNC_BEGIN();
2707         _orig_tracepath_glGetQueryiv(target, pname, params);
2708
2709         goto finish;
2710
2711 finish:
2712         _COREGL_TRACEPATH_FUNC_END();
2713 }
2714
2715 void
2716 tracepath_glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params)
2717 {
2718         _COREGL_TRACEPATH_FUNC_BEGIN();
2719         _orig_tracepath_glGetQueryObjectuiv(id, pname, params);
2720
2721         goto finish;
2722
2723 finish:
2724         _COREGL_TRACEPATH_FUNC_END();
2725 }
2726
2727 GLboolean
2728 tracepath_glUnmapBuffer(GLenum target)
2729 {
2730         GLboolean ret = GL_FALSE;
2731
2732         _COREGL_TRACEPATH_FUNC_BEGIN();
2733         ret = _orig_tracepath_glUnmapBuffer(target);
2734
2735         goto finish;
2736
2737 finish:
2738         _COREGL_TRACEPATH_FUNC_END();
2739         return ret;
2740 }
2741
2742 void
2743 tracepath_glGetBufferPointerv(GLenum target, GLenum pname, GLvoid **params)
2744 {
2745         _COREGL_TRACEPATH_FUNC_BEGIN();
2746         _orig_tracepath_glGetBufferPointerv(target, pname, params);
2747
2748         goto finish;
2749
2750 finish:
2751         _COREGL_TRACEPATH_FUNC_END();
2752 }
2753
2754 void
2755 tracepath_glDrawBuffers(GLsizei n, const GLenum *bufs)
2756 {
2757         _COREGL_TRACEPATH_FUNC_BEGIN();
2758         _orig_tracepath_glDrawBuffers(n, bufs);
2759
2760         goto finish;
2761
2762 finish:
2763         _COREGL_TRACEPATH_FUNC_END();
2764 }
2765
2766 void
2767 tracepath_glUniformMatrix2x3fv(GLint location, GLsizei count,
2768                                GLboolean transpose, const GLfloat *value)
2769 {
2770         _COREGL_TRACEPATH_FUNC_BEGIN();
2771         _orig_tracepath_glUniformMatrix2x3fv(location, count, transpose, value);
2772
2773         goto finish;
2774
2775 finish:
2776         _COREGL_TRACEPATH_FUNC_END();
2777 }
2778
2779 void
2780 tracepath_glUniformMatrix3x2fv(GLint location, GLsizei count,
2781                                GLboolean transpose, const GLfloat *value)
2782 {
2783         _COREGL_TRACEPATH_FUNC_BEGIN();
2784         _orig_tracepath_glUniformMatrix3x2fv(location, count, transpose, value);
2785
2786         goto finish;
2787
2788 finish:
2789         _COREGL_TRACEPATH_FUNC_END();
2790 }
2791
2792 void
2793 tracepath_glUniformMatrix2x4fv(GLint location, GLsizei count,
2794                                GLboolean transpose, const GLfloat *value)
2795 {
2796         _COREGL_TRACEPATH_FUNC_BEGIN();
2797         _orig_tracepath_glUniformMatrix2x4fv(location, count, transpose, value);
2798
2799         goto finish;
2800
2801 finish:
2802         _COREGL_TRACEPATH_FUNC_END();
2803 }
2804
2805 void
2806 tracepath_glUniformMatrix4x2fv(GLint location, GLsizei count,
2807                                GLboolean transpose, const GLfloat *value)
2808 {
2809         _COREGL_TRACEPATH_FUNC_BEGIN();
2810         _orig_tracepath_glUniformMatrix4x2fv(location, count, transpose, value);
2811
2812         goto finish;
2813
2814 finish:
2815         _COREGL_TRACEPATH_FUNC_END();
2816 }
2817
2818 void
2819 tracepath_glUniformMatrix3x4fv(GLint location, GLsizei count,
2820                                GLboolean transpose, const GLfloat *value)
2821 {
2822         _COREGL_TRACEPATH_FUNC_BEGIN();
2823         _orig_tracepath_glUniformMatrix3x4fv(location, count, transpose, value);
2824
2825         goto finish;
2826
2827 finish:
2828         _COREGL_TRACEPATH_FUNC_END();
2829 }
2830
2831 void
2832 tracepath_glUniformMatrix4x3fv(GLint location, GLsizei count,
2833                                GLboolean transpose, const GLfloat *value)
2834 {
2835         _COREGL_TRACEPATH_FUNC_BEGIN();
2836         _orig_tracepath_glUniformMatrix4x3fv(location, count, transpose, value);
2837
2838         goto finish;
2839
2840 finish:
2841         _COREGL_TRACEPATH_FUNC_END();
2842 }
2843
2844 void
2845 tracepath_glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,
2846                             GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask,
2847                             GLenum filter)
2848 {
2849         _COREGL_TRACEPATH_FUNC_BEGIN();
2850         _orig_tracepath_glBlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0,
2851                                           dstX1, dstY1, mask, filter);
2852
2853         goto finish;
2854
2855 finish:
2856         _COREGL_TRACEPATH_FUNC_END();
2857 }
2858
2859 void
2860 tracepath_glRenderbufferStorageMultisample(GLenum target, GLsizei samples,
2861                 GLenum internalformat, GLsizei width, GLsizei height)
2862 {
2863         _COREGL_TRACEPATH_FUNC_BEGIN();
2864         _orig_tracepath_glRenderbufferStorageMultisample(target, samples,
2865                         internalformat, width, height);
2866
2867         goto finish;
2868
2869 finish:
2870         _COREGL_TRACEPATH_FUNC_END();
2871 #ifdef COREGL_TRACEPATH_TRACE_MEMUSE_INFO
2872         if (trace_mem_flag == 1) {
2873                 MY_MODULE_TSTATE *tstate = NULL;
2874
2875                 GET_MY_TSTATE(tstate, get_current_thread_state());
2876                 AST(tstate != NULL);
2877                 if (tstate->ctx != NULL) {
2878                         int objidx = _COREGL_INT_INIT_VALUE;
2879                         _orig_tracepath_glGetIntegerv(GL_RENDERBUFFER_BINDING, &objidx);
2880                         AST(objidx != _COREGL_INT_INIT_VALUE);
2881
2882                         // Detect byte per pixel
2883                         int bpp = 0;
2884                         char formatment[80];
2885                         switch (internalformat) {
2886                         case GL_ALPHA:
2887                                 sprintf(formatment, "ALPHA");
2888                                 bpp = 1;
2889                                 break;
2890                         case GL_LUMINANCE:
2891                                 sprintf(formatment, "LUMINANCE");
2892                                 bpp = 1;
2893                                 break;
2894                         case GL_LUMINANCE_ALPHA:
2895                                 sprintf(formatment, "LUMINANCE_ALPHA");
2896                                 bpp = 1;
2897                                 break;
2898                         case GL_RGB:
2899                                 sprintf(formatment, "RGB");
2900                                 bpp = 2;
2901                                 break;
2902                         case GL_RGBA:
2903                                 sprintf(formatment, "RGBA");
2904                                 bpp = 4;
2905                                 break;
2906                         case 0x80E1:
2907                                 sprintf(formatment, "BGRA_EXT");
2908                                 bpp = 4;
2909                                 break;
2910                         case 0x84F9:
2911                                 sprintf(formatment, "DEPTH_STENCIL_OES");
2912                                 bpp = 4;
2913                                 break;
2914                         case GL_DEPTH_COMPONENT :
2915                                 sprintf(formatment, "DEPTH_COMPONENT");
2916                                 bpp = 1;
2917                                 break;
2918                         case 0x81A5:
2919                                 sprintf(formatment, "DEPTH_COMPONENT16_ARB");
2920                                 bpp = 2;
2921                                 break;
2922                         case 0x81A6:
2923                                 sprintf(formatment, "DEPTH_COMPONENT24_ARB");
2924                                 bpp = 3;
2925                                 break;
2926                         case 0x81A7:
2927                                 sprintf(formatment, "DEPTH_COMPONENT32_ARB");
2928                                 bpp = 4;
2929                                 break;
2930                         case 0x8D46 :
2931                                 sprintf(formatment, "STENCIL_INDEX1_OES");
2932                                 bpp = 1;
2933                                 break;
2934                         case 0x8D47 :
2935                                 sprintf(formatment, "STENCIL_INDEX4_OES");
2936                                 bpp = 1;
2937                                 break;
2938                         case 0x8D48 :
2939                                 sprintf(formatment, "STENCIL_INDEX8_OES");
2940                                 bpp = 1;
2941                                 break;
2942                         default:
2943                                 sprintf(formatment, "0x%X", internalformat);
2944                                 bpp = 0;
2945                                 break;
2946                         }
2947
2948                         _add_glbuf_object(tstate->ctx->sostate->glbuf_rb, objidx, "Renderbuffer", width,
2949                                           height, bpp, formatment);
2950                 }
2951         }
2952 #endif // COREGL_TRACEPATH_TRACE_MEMUSE_INFO
2953 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
2954         if (trace_surface_flag == 1) {
2955                 MY_MODULE_TSTATE *tstate = NULL;
2956
2957                 GET_MY_TSTATE(tstate, get_current_thread_state());
2958                 AST(tstate != NULL);
2959                 if (tstate->ctx != NULL) {
2960                         int objidx = _COREGL_INT_INIT_VALUE;
2961                         _orig_tracepath_glGetIntegerv(GL_RENDERBUFFER_BINDING, &objidx);
2962                         AST(objidx != _COREGL_INT_INIT_VALUE);
2963
2964                         {
2965                                 int channel = 0;
2966                                 switch (internalformat) {
2967                                 case GL_ALPHA:
2968                                 case GL_LUMINANCE:
2969                                 case GL_DEPTH_COMPONENT :
2970                                 case 0x81A5:
2971                                 case 0x81A6:
2972                                 case 0x81A7:
2973                                 case 0x8D46 :
2974                                 case 0x8D47 :
2975                                 case 0x8D48 :
2976                                         channel = 1;
2977                                         break;
2978                                 case GL_LUMINANCE_ALPHA:
2979                                 case 0x84F9:
2980                                         channel = 2;
2981                                         break;
2982                                 case GL_RGB:
2983                                         channel = 3;
2984                                         break;
2985                                 case GL_RGBA:
2986                                 case 0x80E1:
2987                                         channel = 4;
2988                                         break;
2989                                 }
2990
2991                                 char name[256];
2992                                 sprintf(name, "FBORB_0x%X", objidx);
2993                                 tracepath_surface_trace_add(name, tstate->ctx->dpy, tstate->ctx->handle,
2994                                                             tstate->surf_draw, -1, 0, objidx, width, height, channel, NULL);
2995                         }
2996                 }
2997         }
2998 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
2999 }
3000
3001 void
3002 tracepath_glRenderbufferStorageMultisampleEXT(GLenum target, GLsizei samples,
3003                 GLenum internalformat, GLsizei width, GLsizei height)
3004 {
3005         _COREGL_TRACEPATH_FUNC_BEGIN();
3006         _orig_tracepath_glRenderbufferStorageMultisampleEXT(target, samples,
3007                         internalformat, width, height);
3008
3009         goto finish;
3010
3011 finish:
3012         _COREGL_TRACEPATH_FUNC_END();
3013 #ifdef COREGL_TRACEPATH_TRACE_MEMUSE_INFO
3014         if (trace_mem_flag == 1) {
3015                 MY_MODULE_TSTATE *tstate = NULL;
3016
3017                 GET_MY_TSTATE(tstate, get_current_thread_state());
3018                 AST(tstate != NULL);
3019                 if (tstate->ctx != NULL) {
3020                         int objidx = _COREGL_INT_INIT_VALUE;
3021                         _orig_tracepath_glGetIntegerv(GL_RENDERBUFFER_BINDING, &objidx);
3022                         AST(objidx != _COREGL_INT_INIT_VALUE);
3023
3024                         // Detect byte per pixel
3025                         int bpp = 0;
3026                         char formatment[80];
3027                         switch (internalformat) {
3028                         case GL_ALPHA:
3029                                 sprintf(formatment, "ALPHA");
3030                                 bpp = 1;
3031                                 break;
3032                         case GL_LUMINANCE:
3033                                 sprintf(formatment, "LUMINANCE");
3034                                 bpp = 1;
3035                                 break;
3036                         case GL_LUMINANCE_ALPHA:
3037                                 sprintf(formatment, "LUMINANCE_ALPHA");
3038                                 bpp = 1;
3039                                 break;
3040                         case GL_RGB:
3041                                 sprintf(formatment, "RGB");
3042                                 bpp = 2;
3043                                 break;
3044                         case GL_RGBA:
3045                                 sprintf(formatment, "RGBA");
3046                                 bpp = 4;
3047                                 break;
3048                         case 0x80E1:
3049                                 sprintf(formatment, "BGRA_EXT");
3050                                 bpp = 4;
3051                                 break;
3052                         case 0x84F9:
3053                                 sprintf(formatment, "DEPTH_STENCIL_OES");
3054                                 bpp = 4;
3055                                 break;
3056                         case GL_DEPTH_COMPONENT :
3057                                 sprintf(formatment, "DEPTH_COMPONENT");
3058                                 bpp = 1;
3059                                 break;
3060                         case 0x81A5:
3061                                 sprintf(formatment, "DEPTH_COMPONENT16_ARB");
3062                                 bpp = 2;
3063                                 break;
3064                         case 0x81A6:
3065                                 sprintf(formatment, "DEPTH_COMPONENT24_ARB");
3066                                 bpp = 3;
3067                                 break;
3068                         case 0x81A7:
3069                                 sprintf(formatment, "DEPTH_COMPONENT32_ARB");
3070                                 bpp = 4;
3071                                 break;
3072                         case 0x8D46 :
3073                                 sprintf(formatment, "STENCIL_INDEX1_OES");
3074                                 bpp = 1;
3075                                 break;
3076                         case 0x8D47 :
3077                                 sprintf(formatment, "STENCIL_INDEX4_OES");
3078                                 bpp = 1;
3079                                 break;
3080                         case 0x8D48 :
3081                                 sprintf(formatment, "STENCIL_INDEX8_OES");
3082                                 bpp = 1;
3083                                 break;
3084                         default:
3085                                 sprintf(formatment, "0x%X", internalformat);
3086                                 bpp = 0;
3087                                 break;
3088                         }
3089
3090                         _add_glbuf_object(tstate->ctx->sostate->glbuf_rb, objidx, "Renderbuffer", width,
3091                                           height, bpp, formatment);
3092                 }
3093         }
3094 #endif // COREGL_TRACEPATH_TRACE_MEMUSE_INFO
3095 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
3096         if (trace_surface_flag == 1) {
3097                 MY_MODULE_TSTATE *tstate = NULL;
3098
3099                 GET_MY_TSTATE(tstate, get_current_thread_state());
3100                 AST(tstate != NULL);
3101                 if (tstate->ctx != NULL) {
3102                         int objidx = _COREGL_INT_INIT_VALUE;
3103                         _orig_tracepath_glGetIntegerv(GL_RENDERBUFFER_BINDING, &objidx);
3104                         AST(objidx != _COREGL_INT_INIT_VALUE);
3105
3106                         {
3107                                 int channel = 0;
3108                                 switch (internalformat) {
3109                                 case GL_ALPHA:
3110                                 case GL_LUMINANCE:
3111                                 case GL_DEPTH_COMPONENT :
3112                                 case 0x81A5:
3113                                 case 0x81A6:
3114                                 case 0x81A7:
3115                                 case 0x8D46 :
3116                                 case 0x8D47 :
3117                                 case 0x8D48 :
3118                                         channel = 1;
3119                                         break;
3120                                 case GL_LUMINANCE_ALPHA:
3121                                 case 0x84F9:
3122                                         channel = 2;
3123                                         break;
3124                                 case GL_RGB:
3125                                         channel = 3;
3126                                         break;
3127                                 case GL_RGBA:
3128                                 case 0x80E1:
3129                                         channel = 4;
3130                                         break;
3131                                 }
3132
3133                                 char name[256];
3134                                 sprintf(name, "FBORB_0x%X", objidx);
3135                                 tracepath_surface_trace_add(name, tstate->ctx->dpy, tstate->ctx->handle,
3136                                                             tstate->surf_draw, -1, 0, objidx, width, height, channel, NULL);
3137                         }
3138                 }
3139         }
3140 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
3141 }
3142
3143 void
3144 tracepath_glFramebufferTextureLayer(GLenum target, GLenum attachment,
3145                                     GLuint texture, GLint level, GLint layer)
3146 {
3147         _COREGL_TRACEPATH_FUNC_BEGIN();
3148
3149 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
3150         tracepath_fbdump_update(0);
3151 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
3152
3153         _orig_tracepath_glFramebufferTextureLayer(target, attachment, texture, level,
3154                         layer);
3155
3156 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
3157         tracepath_fbdump_update(1);
3158 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
3159
3160         goto finish;
3161
3162 finish:
3163         _COREGL_TRACEPATH_FUNC_END();
3164 }
3165
3166 GLvoid *
3167 tracepath_glMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length,
3168                            GLbitfield access)
3169 {
3170         GLvoid *ret = NULL;
3171
3172         _COREGL_TRACEPATH_FUNC_BEGIN();
3173         ret = _orig_tracepath_glMapBufferRange(target, offset, length, access);
3174
3175         goto finish;
3176
3177 finish:
3178         _COREGL_TRACEPATH_FUNC_END();
3179         return ret;
3180 }
3181
3182 void
3183 tracepath_glFlushMappedBufferRange(GLenum target, GLintptr offset,
3184                                    GLsizeiptr length)
3185 {
3186         _COREGL_TRACEPATH_FUNC_BEGIN();
3187         _orig_tracepath_glFlushMappedBufferRange(target, offset, length);
3188
3189         goto finish;
3190
3191 finish:
3192         _COREGL_TRACEPATH_FUNC_END();
3193 }
3194
3195 void
3196 tracepath_glBindVertexArray(GLuint array)
3197 {
3198         _COREGL_TRACEPATH_FUNC_BEGIN();
3199         _orig_tracepath_glBindVertexArray(array);
3200
3201         goto finish;
3202
3203 finish:
3204         _COREGL_TRACEPATH_FUNC_END();
3205 }
3206
3207 void
3208 tracepath_glDeleteVertexArrays(GLsizei n, const GLuint *arrays)
3209 {
3210         _COREGL_TRACEPATH_FUNC_BEGIN();
3211         _orig_tracepath_glDeleteVertexArrays(n, arrays);
3212
3213         goto finish;
3214
3215 finish:
3216         _COREGL_TRACEPATH_FUNC_END();
3217 }
3218
3219 void
3220 tracepath_glGenVertexArrays(GLsizei n, GLuint *arrays)
3221 {
3222         _COREGL_TRACEPATH_FUNC_BEGIN();
3223         _orig_tracepath_glGenVertexArrays(n, arrays);
3224
3225         goto finish;
3226
3227 finish:
3228         _COREGL_TRACEPATH_FUNC_END();
3229 }
3230
3231 GLboolean
3232 tracepath_glIsVertexArray(GLuint array)
3233 {
3234         GLboolean ret = GL_FALSE;
3235
3236         _COREGL_TRACEPATH_FUNC_BEGIN();
3237         ret = _orig_tracepath_glIsVertexArray(array);
3238
3239         goto finish;
3240
3241 finish:
3242         _COREGL_TRACEPATH_FUNC_END();
3243         return ret;
3244 }
3245
3246 void
3247 tracepath_glGetIntegeri_v(GLenum target, GLuint index, GLint *data)
3248 {
3249         _COREGL_TRACEPATH_FUNC_BEGIN();
3250         _orig_tracepath_glGetIntegeri_v(target, index, data);
3251
3252         goto finish;
3253
3254 finish:
3255         _COREGL_TRACEPATH_FUNC_END();
3256 }
3257
3258 void
3259 tracepath_glBeginTransformFeedback(GLenum primitiveMode)
3260 {
3261         _COREGL_TRACEPATH_FUNC_BEGIN();
3262         _orig_tracepath_glBeginTransformFeedback(primitiveMode);
3263
3264         goto finish;
3265
3266 finish:
3267         _COREGL_TRACEPATH_FUNC_END();
3268 }
3269
3270 void
3271 tracepath_glEndTransformFeedback()
3272 {
3273         _COREGL_TRACEPATH_FUNC_BEGIN();
3274         _orig_tracepath_glEndTransformFeedback();
3275
3276         goto finish;
3277
3278 finish:
3279         _COREGL_TRACEPATH_FUNC_END();
3280 }
3281
3282 void
3283 tracepath_glBindBufferRange(GLenum target, GLuint index, GLuint buffer,
3284                             GLintptr offset, GLsizeiptr size)
3285 {
3286         _COREGL_TRACEPATH_FUNC_BEGIN();
3287         _orig_tracepath_glBindBufferRange(target, index, buffer, offset, size);
3288
3289         goto finish;
3290
3291 finish:
3292         _COREGL_TRACEPATH_FUNC_END();
3293 }
3294
3295 void
3296 tracepath_glBindBufferBase(GLenum target, GLuint index, GLuint buffer)
3297 {
3298         _COREGL_TRACEPATH_FUNC_BEGIN();
3299         _orig_tracepath_glBindBufferBase(target, index, buffer);
3300
3301         goto finish;
3302
3303 finish:
3304         _COREGL_TRACEPATH_FUNC_END();
3305 }
3306
3307 void
3308 tracepath_glTransformFeedbackVaryings(GLuint program, GLsizei count,
3309                                       const GLchar *const *varyings, GLenum bufferMode)
3310 {
3311         _COREGL_TRACEPATH_FUNC_BEGIN();
3312         _orig_tracepath_glTransformFeedbackVaryings(program, count, varyings,
3313                         bufferMode);
3314
3315         goto finish;
3316
3317 finish:
3318         _COREGL_TRACEPATH_FUNC_END();
3319 }
3320
3321 void
3322 tracepath_glGetTransformFeedbackVarying(GLuint program, GLuint index,
3323                                         GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name)
3324 {
3325         _COREGL_TRACEPATH_FUNC_BEGIN();
3326         _orig_tracepath_glGetTransformFeedbackVarying(program, index, bufSize, length,
3327                         size, type, name);
3328
3329         goto finish;
3330
3331 finish:
3332         _COREGL_TRACEPATH_FUNC_END();
3333 }
3334
3335 void
3336 tracepath_glVertexAttribIPointer(GLuint index, GLint size, GLenum type,
3337                                  GLsizei stride, const GLvoid *pointer)
3338 {
3339         _COREGL_TRACEPATH_FUNC_BEGIN();
3340         _orig_tracepath_glVertexAttribIPointer(index, size, type, stride, pointer);
3341
3342         goto finish;
3343
3344 finish:
3345         _COREGL_TRACEPATH_FUNC_END();
3346 }
3347
3348 void
3349 tracepath_glGetVertexAttribIiv(GLuint index, GLenum pname, GLint *params)
3350 {
3351         _COREGL_TRACEPATH_FUNC_BEGIN();
3352         _orig_tracepath_glGetVertexAttribIiv(index, pname, params);
3353
3354         goto finish;
3355
3356 finish:
3357         _COREGL_TRACEPATH_FUNC_END();
3358 }
3359
3360 void
3361 tracepath_glGetVertexAttribIuiv(GLuint index, GLenum pname, GLuint *params)
3362 {
3363         _COREGL_TRACEPATH_FUNC_BEGIN();
3364         _orig_tracepath_glGetVertexAttribIuiv(index, pname, params);
3365
3366         goto finish;
3367
3368 finish:
3369         _COREGL_TRACEPATH_FUNC_END();
3370 }
3371
3372 void
3373 tracepath_glVertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w)
3374 {
3375         _COREGL_TRACEPATH_FUNC_BEGIN();
3376         _orig_tracepath_glVertexAttribI4i(index, x, y, z, w);
3377
3378         goto finish;
3379
3380 finish:
3381         _COREGL_TRACEPATH_FUNC_END();
3382 }
3383
3384 void
3385 tracepath_glVertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z,
3386                              GLuint w)
3387 {
3388         _COREGL_TRACEPATH_FUNC_BEGIN();
3389         _orig_tracepath_glVertexAttribI4ui(index, x, y, z, w);
3390
3391         goto finish;
3392
3393 finish:
3394         _COREGL_TRACEPATH_FUNC_END();
3395 }
3396
3397 void
3398 tracepath_glVertexAttribI4iv(GLuint index, const GLint *v)
3399 {
3400         _COREGL_TRACEPATH_FUNC_BEGIN();
3401         _orig_tracepath_glVertexAttribI4iv(index, v);
3402
3403         goto finish;
3404
3405 finish:
3406         _COREGL_TRACEPATH_FUNC_END();
3407 }
3408
3409 void
3410 tracepath_glVertexAttribI4uiv(GLuint index, const GLuint *v)
3411 {
3412         _COREGL_TRACEPATH_FUNC_BEGIN();
3413         _orig_tracepath_glVertexAttribI4uiv(index, v);
3414
3415         goto finish;
3416
3417 finish:
3418         _COREGL_TRACEPATH_FUNC_END();
3419 }
3420
3421 void
3422 tracepath_glGetUniformuiv(GLuint program, GLint location, GLuint *params)
3423 {
3424         _COREGL_TRACEPATH_FUNC_BEGIN();
3425         _orig_tracepath_glGetUniformuiv(program, location, params);
3426
3427         goto finish;
3428
3429 finish:
3430         _COREGL_TRACEPATH_FUNC_END();
3431 }
3432
3433 GLint
3434 tracepath_glGetFragDataLocation(GLuint program, const GLchar *name)
3435 {
3436         GLint ret = _COREGL_INT_INIT_VALUE;
3437
3438         _COREGL_TRACEPATH_FUNC_BEGIN();
3439         ret = _orig_tracepath_glGetFragDataLocation(program, name);
3440
3441         goto finish;
3442
3443 finish:
3444         _COREGL_TRACEPATH_FUNC_END();
3445         return ret;
3446 }
3447
3448 void
3449 tracepath_glUniform1ui(GLint location, GLuint v0)
3450 {
3451         _COREGL_TRACEPATH_FUNC_BEGIN();
3452         _orig_tracepath_glUniform1ui(location, v0);
3453
3454         goto finish;
3455
3456 finish:
3457         _COREGL_TRACEPATH_FUNC_END();
3458 }
3459
3460 void
3461 tracepath_glUniform2ui(GLint location, GLuint v0, GLuint v1)
3462 {
3463         _COREGL_TRACEPATH_FUNC_BEGIN();
3464         _orig_tracepath_glUniform2ui(location, v0, v1);
3465
3466         goto finish;
3467
3468 finish:
3469         _COREGL_TRACEPATH_FUNC_END();
3470 }
3471
3472 void
3473 tracepath_glUniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2)
3474 {
3475         _COREGL_TRACEPATH_FUNC_BEGIN();
3476         _orig_tracepath_glUniform3ui(location, v0, v1, v2);
3477
3478         goto finish;
3479
3480 finish:
3481         _COREGL_TRACEPATH_FUNC_END();
3482 }
3483
3484 void
3485 tracepath_glUniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2,
3486                        GLuint v3)
3487 {
3488         _COREGL_TRACEPATH_FUNC_BEGIN();
3489         _orig_tracepath_glUniform4ui(location, v0, v1, v2, v3);
3490
3491         goto finish;
3492
3493 finish:
3494         _COREGL_TRACEPATH_FUNC_END();
3495 }
3496
3497 void
3498 tracepath_glUniform1uiv(GLint location, GLsizei count, const GLuint *value)
3499 {
3500         _COREGL_TRACEPATH_FUNC_BEGIN();
3501         _orig_tracepath_glUniform1uiv(location, count, value);
3502
3503         goto finish;
3504
3505 finish:
3506         _COREGL_TRACEPATH_FUNC_END();
3507 }
3508
3509 void
3510 tracepath_glUniform2uiv(GLint location, GLsizei count, const GLuint *value)
3511 {
3512         _COREGL_TRACEPATH_FUNC_BEGIN();
3513         _orig_tracepath_glUniform2uiv(location, count, value);
3514
3515         goto finish;
3516
3517 finish:
3518         _COREGL_TRACEPATH_FUNC_END();
3519 }
3520
3521 void
3522 tracepath_glUniform3uiv(GLint location, GLsizei count, const GLuint *value)
3523 {
3524         _COREGL_TRACEPATH_FUNC_BEGIN();
3525         _orig_tracepath_glUniform3uiv(location, count, value);
3526
3527         goto finish;
3528
3529 finish:
3530         _COREGL_TRACEPATH_FUNC_END();
3531 }
3532
3533 void
3534 tracepath_glUniform4uiv(GLint location, GLsizei count, const GLuint *value)
3535 {
3536         _COREGL_TRACEPATH_FUNC_BEGIN();
3537         _orig_tracepath_glUniform4uiv(location, count, value);
3538
3539         goto finish;
3540
3541 finish:
3542         _COREGL_TRACEPATH_FUNC_END();
3543 }
3544
3545 void
3546 tracepath_glClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint *value)
3547 {
3548         _COREGL_TRACEPATH_FUNC_BEGIN();
3549         _orig_tracepath_glClearBufferiv(buffer, drawbuffer, value);
3550
3551         goto finish;
3552
3553 finish:
3554         _COREGL_TRACEPATH_FUNC_END();
3555 }
3556
3557 void
3558 tracepath_glClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint *value)
3559 {
3560         _COREGL_TRACEPATH_FUNC_BEGIN();
3561         _orig_tracepath_glClearBufferuiv(buffer, drawbuffer, value);
3562
3563         goto finish;
3564
3565 finish:
3566         _COREGL_TRACEPATH_FUNC_END();
3567 }
3568
3569 void
3570 tracepath_glClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat *value)
3571 {
3572         _COREGL_TRACEPATH_FUNC_BEGIN();
3573         _orig_tracepath_glClearBufferfv(buffer, drawbuffer, value);
3574
3575         goto finish;
3576
3577 finish:
3578         _COREGL_TRACEPATH_FUNC_END();
3579 }
3580
3581 void
3582 tracepath_glClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth,
3583                           GLint stencil)
3584 {
3585         _COREGL_TRACEPATH_FUNC_BEGIN();
3586         _orig_tracepath_glClearBufferfi(buffer, drawbuffer, depth, stencil);
3587
3588         goto finish;
3589
3590 finish:
3591         _COREGL_TRACEPATH_FUNC_END();
3592 }
3593
3594 const GLubyte *
3595 tracepath_glGetStringi(GLenum name, GLuint index)
3596 {
3597         const GLubyte *ret = NULL;
3598
3599         _COREGL_TRACEPATH_FUNC_BEGIN();
3600         ret = _orig_tracepath_glGetStringi(name, index);
3601
3602         goto finish;
3603
3604 finish:
3605         _COREGL_TRACEPATH_FUNC_END();
3606         return ret;
3607 }
3608
3609 void
3610 tracepath_glCopyBufferSubData(GLenum readTarget, GLenum writeTarget,
3611                               GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size)
3612 {
3613         _COREGL_TRACEPATH_FUNC_BEGIN();
3614         _orig_tracepath_glCopyBufferSubData(readTarget, writeTarget, readOffset,
3615                                             writeOffset, size);
3616
3617         goto finish;
3618
3619 finish:
3620         _COREGL_TRACEPATH_FUNC_END();
3621 }
3622
3623 void
3624 tracepath_glGetUniformIndices(GLuint program, GLsizei uniformCount,
3625                               const GLchar *const *uniformNames, GLuint *uniformIndices)
3626 {
3627         _COREGL_TRACEPATH_FUNC_BEGIN();
3628         _orig_tracepath_glGetUniformIndices(program, uniformCount, uniformNames,
3629                                             uniformIndices);
3630
3631         goto finish;
3632
3633 finish:
3634         _COREGL_TRACEPATH_FUNC_END();
3635 }
3636
3637 void
3638 tracepath_glGetActiveUniformsiv(GLuint program, GLsizei uniformCount,
3639                                 const GLuint *uniformIndices, GLenum pname, GLint *params)
3640 {
3641         _COREGL_TRACEPATH_FUNC_BEGIN();
3642         _orig_tracepath_glGetActiveUniformsiv(program, uniformCount, uniformIndices,
3643                                               pname, params);
3644
3645         goto finish;
3646
3647 finish:
3648         _COREGL_TRACEPATH_FUNC_END();
3649 }
3650
3651 GLuint
3652 tracepath_glGetUniformBlockIndex(GLuint program, const GLchar *uniformBlockName)
3653 {
3654         GLuint ret = _COREGL_INT_INIT_VALUE;
3655
3656         _COREGL_TRACEPATH_FUNC_BEGIN();
3657         ret = _orig_tracepath_glGetUniformBlockIndex(program, uniformBlockName);
3658
3659         goto finish;
3660
3661 finish:
3662         _COREGL_TRACEPATH_FUNC_END();
3663         return ret;
3664 }
3665
3666 void
3667 tracepath_glGetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex,
3668                                     GLenum pname, GLint *params)
3669 {
3670         _COREGL_TRACEPATH_FUNC_BEGIN();
3671         _orig_tracepath_glGetActiveUniformBlockiv(program, uniformBlockIndex, pname,
3672                         params);
3673
3674         goto finish;
3675
3676 finish:
3677         _COREGL_TRACEPATH_FUNC_END();
3678 }
3679
3680 void
3681 tracepath_glGetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex,
3682                                       GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName)
3683 {
3684         _COREGL_TRACEPATH_FUNC_BEGIN();
3685         _orig_tracepath_glGetActiveUniformBlockName(program, uniformBlockIndex, bufSize,
3686                         length, uniformBlockName);
3687
3688         goto finish;
3689
3690 finish:
3691         _COREGL_TRACEPATH_FUNC_END();
3692 }
3693
3694 void
3695 tracepath_glUniformBlockBinding(GLuint program, GLuint uniformBlockIndex,
3696                                 GLuint uniformBlockBinding)
3697 {
3698         _COREGL_TRACEPATH_FUNC_BEGIN();
3699         _orig_tracepath_glUniformBlockBinding(program, uniformBlockIndex,
3700                                               uniformBlockBinding);
3701
3702         goto finish;
3703
3704 finish:
3705         _COREGL_TRACEPATH_FUNC_END();
3706 }
3707
3708 void
3709 tracepath_glDrawArraysInstanced(GLenum mode, GLint first, GLsizei count,
3710                                 GLsizei instanceCount)
3711 {
3712         _COREGL_TRACEPATH_FUNC_BEGIN();
3713         _orig_tracepath_glDrawArraysInstanced(mode, first, count, instanceCount);
3714
3715         goto finish;
3716
3717 finish:
3718         _COREGL_TRACEPATH_FUNC_END();
3719 }
3720
3721 void
3722 tracepath_glDrawElementsInstanced(GLenum mode, GLsizei count, GLenum type,
3723                                   const GLvoid *indices, GLsizei instanceCount)
3724 {
3725         _COREGL_TRACEPATH_FUNC_BEGIN();
3726         _orig_tracepath_glDrawElementsInstanced(mode, count, type, indices,
3727                                                 instanceCount);
3728
3729         goto finish;
3730
3731 finish:
3732         _COREGL_TRACEPATH_FUNC_END();
3733 }
3734
3735 GLsync
3736 tracepath_glFenceSync(GLenum condition, GLbitfield flags)
3737 {
3738         GLsync ret = NULL;
3739
3740         _COREGL_TRACEPATH_FUNC_BEGIN();
3741         ret = _orig_tracepath_glFenceSync(condition, flags);
3742
3743         goto finish;
3744
3745 finish:
3746         _COREGL_TRACEPATH_FUNC_END();
3747         return ret;
3748 }
3749
3750 GLboolean
3751 tracepath_glIsSync(GLsync sync)
3752 {
3753         GLboolean ret = GL_FALSE;
3754
3755         _COREGL_TRACEPATH_FUNC_BEGIN();
3756         ret = _orig_tracepath_glIsSync(sync);
3757
3758         goto finish;
3759
3760 finish:
3761         _COREGL_TRACEPATH_FUNC_END();
3762         return ret;
3763 }
3764
3765 void
3766 tracepath_glDeleteSync(GLsync sync)
3767 {
3768         _COREGL_TRACEPATH_FUNC_BEGIN();
3769         _orig_tracepath_glDeleteSync(sync);
3770
3771         goto finish;
3772
3773 finish:
3774         _COREGL_TRACEPATH_FUNC_END();
3775 }
3776
3777 GLenum
3778 tracepath_glClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
3779 {
3780         GLenum ret = _COREGL_INT_INIT_VALUE;
3781
3782         _COREGL_TRACEPATH_FUNC_BEGIN();
3783         ret = _orig_tracepath_glClientWaitSync(sync, flags, timeout);
3784
3785         goto finish;
3786
3787 finish:
3788         _COREGL_TRACEPATH_FUNC_END();
3789         return ret;
3790 }
3791
3792 void
3793 tracepath_glWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
3794 {
3795         _COREGL_TRACEPATH_FUNC_BEGIN();
3796         _orig_tracepath_glWaitSync(sync, flags, timeout);
3797
3798         goto finish;
3799
3800 finish:
3801         _COREGL_TRACEPATH_FUNC_END();
3802 }
3803
3804 void
3805 tracepath_glGetInteger64v(GLenum pname, GLint64 *params)
3806 {
3807         _COREGL_TRACEPATH_FUNC_BEGIN();
3808         _orig_tracepath_glGetInteger64v(pname, params);
3809
3810         goto finish;
3811
3812 finish:
3813         _COREGL_TRACEPATH_FUNC_END();
3814 }
3815
3816 void
3817 tracepath_glGetSynciv(GLsync sync, GLenum pname, GLsizei bufSize,
3818                       GLsizei *length, GLint *values)
3819 {
3820         _COREGL_TRACEPATH_FUNC_BEGIN();
3821         _orig_tracepath_glGetSynciv(sync, pname, bufSize, length, values);
3822
3823         goto finish;
3824
3825 finish:
3826         _COREGL_TRACEPATH_FUNC_END();
3827 }
3828
3829 void
3830 tracepath_glGetInteger64i_v(GLenum target, GLuint index, GLint64 *data)
3831 {
3832         _COREGL_TRACEPATH_FUNC_BEGIN();
3833         _orig_tracepath_glGetInteger64i_v(target, index, data);
3834
3835         goto finish;
3836
3837 finish:
3838         _COREGL_TRACEPATH_FUNC_END();
3839 }
3840
3841 void
3842 tracepath_glGetBufferParameteri64v(GLenum target, GLenum pname, GLint64 *params)
3843 {
3844         _COREGL_TRACEPATH_FUNC_BEGIN();
3845         _orig_tracepath_glGetBufferParameteri64v(target, pname, params);
3846
3847         goto finish;
3848
3849 finish:
3850         _COREGL_TRACEPATH_FUNC_END();
3851 }
3852
3853 void
3854 tracepath_glGenSamplers(GLsizei n, GLuint *samplers)
3855 {
3856         _COREGL_TRACEPATH_FUNC_BEGIN();
3857         _orig_tracepath_glGenSamplers(n, samplers);
3858
3859         goto finish;
3860
3861 finish:
3862         _COREGL_TRACEPATH_FUNC_END();
3863 }
3864
3865 void
3866 tracepath_glDeleteSamplers(GLsizei n, const GLuint *samplers)
3867 {
3868         _COREGL_TRACEPATH_FUNC_BEGIN();
3869         _orig_tracepath_glDeleteSamplers(n, samplers);
3870
3871         goto finish;
3872
3873 finish:
3874         _COREGL_TRACEPATH_FUNC_END();
3875 }
3876
3877 GLboolean
3878 tracepath_glIsSampler(GLuint sampler)
3879 {
3880         GLboolean ret = GL_FALSE;
3881
3882         _COREGL_TRACEPATH_FUNC_BEGIN();
3883         ret = _orig_tracepath_glIsSampler(sampler);
3884
3885         goto finish;
3886
3887 finish:
3888         _COREGL_TRACEPATH_FUNC_END();
3889         return ret;
3890 }
3891
3892 void
3893 tracepath_glBindSampler(GLuint unit, GLuint sampler)
3894 {
3895         _COREGL_TRACEPATH_FUNC_BEGIN();
3896         _orig_tracepath_glBindSampler(unit, sampler);
3897
3898         goto finish;
3899
3900 finish:
3901         _COREGL_TRACEPATH_FUNC_END();
3902 }
3903
3904 void
3905 tracepath_glSamplerParameteri(GLuint sampler, GLenum pname, GLint param)
3906 {
3907         _COREGL_TRACEPATH_FUNC_BEGIN();
3908         _orig_tracepath_glSamplerParameteri(sampler, pname, param);
3909
3910         goto finish;
3911
3912 finish:
3913         _COREGL_TRACEPATH_FUNC_END();
3914 }
3915
3916 void
3917 tracepath_glSamplerParameteriv(GLuint sampler, GLenum pname, const GLint *param)
3918 {
3919         _COREGL_TRACEPATH_FUNC_BEGIN();
3920         _orig_tracepath_glSamplerParameteriv(sampler, pname, param);
3921
3922         goto finish;
3923
3924 finish:
3925         _COREGL_TRACEPATH_FUNC_END();
3926 }
3927
3928 void
3929 tracepath_glSamplerParameterf(GLuint sampler, GLenum pname, GLfloat param)
3930 {
3931         _COREGL_TRACEPATH_FUNC_BEGIN();
3932         _orig_tracepath_glSamplerParameterf(sampler, pname, param);
3933
3934         goto finish;
3935
3936 finish:
3937         _COREGL_TRACEPATH_FUNC_END();
3938 }
3939
3940 void
3941 tracepath_glSamplerParameterfv(GLuint sampler, GLenum pname,
3942                                const GLfloat *param)
3943 {
3944         _COREGL_TRACEPATH_FUNC_BEGIN();
3945         _orig_tracepath_glSamplerParameterfv(sampler, pname, param);
3946
3947         goto finish;
3948
3949 finish:
3950         _COREGL_TRACEPATH_FUNC_END();
3951 }
3952
3953 void
3954 tracepath_glGetSamplerParameteriv(GLuint sampler, GLenum pname, GLint *params)
3955 {
3956         _COREGL_TRACEPATH_FUNC_BEGIN();
3957         _orig_tracepath_glGetSamplerParameteriv(sampler, pname, params);
3958
3959         goto finish;
3960
3961 finish:
3962         _COREGL_TRACEPATH_FUNC_END();
3963 }
3964
3965 void
3966 tracepath_glGetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat *params)
3967 {
3968         _COREGL_TRACEPATH_FUNC_BEGIN();
3969         _orig_tracepath_glGetSamplerParameterfv(sampler, pname, params);
3970
3971         goto finish;
3972
3973 finish:
3974         _COREGL_TRACEPATH_FUNC_END();
3975 }
3976
3977 void
3978 tracepath_glVertexAttribDivisor(GLuint index, GLuint divisor)
3979 {
3980         _COREGL_TRACEPATH_FUNC_BEGIN();
3981         _orig_tracepath_glVertexAttribDivisor(index, divisor);
3982
3983         goto finish;
3984
3985 finish:
3986         _COREGL_TRACEPATH_FUNC_END();
3987 }
3988
3989 void
3990 tracepath_glBindTransformFeedback(GLenum target, GLuint id)
3991 {
3992         _COREGL_TRACEPATH_FUNC_BEGIN();
3993         _orig_tracepath_glBindTransformFeedback(target, id);
3994
3995         goto finish;
3996
3997 finish:
3998         _COREGL_TRACEPATH_FUNC_END();
3999 }
4000
4001 void
4002 tracepath_glDeleteTransformFeedbacks(GLsizei n, const GLuint *ids)
4003 {
4004         _COREGL_TRACEPATH_FUNC_BEGIN();
4005         _orig_tracepath_glDeleteTransformFeedbacks(n, ids);
4006
4007         goto finish;
4008
4009 finish:
4010         _COREGL_TRACEPATH_FUNC_END();
4011 }
4012
4013 void
4014 tracepath_glGenTransformFeedbacks(GLsizei n, GLuint *ids)
4015 {
4016         _COREGL_TRACEPATH_FUNC_BEGIN();
4017         _orig_tracepath_glGenTransformFeedbacks(n, ids);
4018
4019         goto finish;
4020
4021 finish:
4022         _COREGL_TRACEPATH_FUNC_END();
4023 }
4024
4025 GLboolean
4026 tracepath_glIsTransformFeedback(GLuint id)
4027 {
4028         GLboolean ret = GL_FALSE;
4029
4030         _COREGL_TRACEPATH_FUNC_BEGIN();
4031         ret = _orig_tracepath_glIsTransformFeedback(id);
4032
4033         goto finish;
4034
4035 finish:
4036         _COREGL_TRACEPATH_FUNC_END();
4037         return ret;
4038 }
4039
4040 void
4041 tracepath_glPauseTransformFeedback()
4042 {
4043         _COREGL_TRACEPATH_FUNC_BEGIN();
4044         _orig_tracepath_glPauseTransformFeedback();
4045
4046         goto finish;
4047
4048 finish:
4049         _COREGL_TRACEPATH_FUNC_END();
4050 }
4051
4052 void
4053 tracepath_glResumeTransformFeedback()
4054 {
4055         _COREGL_TRACEPATH_FUNC_BEGIN();
4056         _orig_tracepath_glResumeTransformFeedback();
4057
4058         goto finish;
4059
4060 finish:
4061         _COREGL_TRACEPATH_FUNC_END();
4062 }
4063
4064 void
4065 tracepath_glGetProgramBinary(GLuint program, GLsizei bufSize, GLsizei *length,
4066                              GLenum *binaryFormat, GLvoid *binary)
4067 {
4068         _COREGL_TRACEPATH_FUNC_BEGIN();
4069         _orig_tracepath_glGetProgramBinary(program, bufSize, length, binaryFormat,
4070                                            binary);
4071
4072         goto finish;
4073
4074 finish:
4075         _COREGL_TRACEPATH_FUNC_END();
4076 }
4077
4078 void
4079 tracepath_glGetProgramBinaryOES(GLuint program, GLsizei bufSize,
4080                                 GLsizei *length, GLenum *binaryFormat, GLvoid *binary)
4081 {
4082         _COREGL_TRACEPATH_FUNC_BEGIN();
4083         _orig_tracepath_glGetProgramBinaryOES(program, bufSize, length, binaryFormat,
4084                                               binary);
4085
4086         goto finish;
4087
4088 finish:
4089         _COREGL_TRACEPATH_FUNC_END();
4090 }
4091
4092 void
4093 tracepath_glProgramBinary(GLuint program, GLenum binaryFormat,
4094                           const GLvoid *binary, GLsizei length)
4095 {
4096         _COREGL_TRACEPATH_FUNC_BEGIN();
4097         _orig_tracepath_glProgramBinary(program, binaryFormat, binary, length);
4098
4099         goto finish;
4100
4101 finish:
4102         _COREGL_TRACEPATH_FUNC_END();
4103 }
4104
4105 void
4106 tracepath_glProgramBinaryOES(GLuint program, GLenum binaryFormat,
4107                              const GLvoid *binary, GLsizei length)
4108 {
4109         _COREGL_TRACEPATH_FUNC_BEGIN();
4110         _orig_tracepath_glProgramBinaryOES(program, binaryFormat, binary, length);
4111
4112         goto finish;
4113
4114 finish:
4115         _COREGL_TRACEPATH_FUNC_END();
4116 }
4117
4118 void
4119 tracepath_glProgramParameteri(GLuint program, GLenum pname, GLint value)
4120 {
4121         _COREGL_TRACEPATH_FUNC_BEGIN();
4122         _orig_tracepath_glProgramParameteri(program, pname, value);
4123
4124         goto finish;
4125
4126 finish:
4127         _COREGL_TRACEPATH_FUNC_END();
4128 }
4129
4130 void
4131 tracepath_glInvalidateFramebuffer(GLenum target, GLsizei numAttachments,
4132                                   const GLenum *attachments)
4133 {
4134         _COREGL_TRACEPATH_FUNC_BEGIN();
4135         _orig_tracepath_glInvalidateFramebuffer(target, numAttachments, attachments);
4136
4137         goto finish;
4138
4139 finish:
4140         _COREGL_TRACEPATH_FUNC_END();
4141 }
4142
4143 void
4144 tracepath_glDiscardFramebufferEXT(GLenum target, GLsizei numAttachments,
4145                                   const GLenum *attachments)
4146 {
4147         _COREGL_TRACEPATH_FUNC_BEGIN();
4148         _orig_tracepath_glDiscardFramebufferEXT(target, numAttachments, attachments);
4149
4150         goto finish;
4151
4152 finish:
4153         _COREGL_TRACEPATH_FUNC_END();
4154 }
4155
4156 void
4157 tracepath_glInvalidateSubFramebuffer(GLenum target, GLsizei numAttachments,
4158                                      const GLenum *attachments, GLint x, GLint y, GLsizei width, GLsizei height)
4159 {
4160         _COREGL_TRACEPATH_FUNC_BEGIN();
4161         _orig_tracepath_glInvalidateSubFramebuffer(target, numAttachments, attachments,
4162                         x, y, width, height);
4163
4164         goto finish;
4165
4166 finish:
4167         _COREGL_TRACEPATH_FUNC_END();
4168 }
4169
4170 void
4171 tracepath_glTexStorage2D(GLenum target, GLsizei levels, GLenum internalformat,
4172                          GLsizei width, GLsizei height)
4173 {
4174         _COREGL_TRACEPATH_FUNC_BEGIN();
4175         _orig_tracepath_glTexStorage2D(target, levels, internalformat, width, height);
4176
4177         goto finish;
4178
4179 finish:
4180         _COREGL_TRACEPATH_FUNC_END();
4181 }
4182
4183 void
4184 tracepath_glTexStorage3D(GLenum target, GLsizei levels, GLenum internalformat,
4185                          GLsizei width, GLsizei height, GLsizei depth)
4186 {
4187         _COREGL_TRACEPATH_FUNC_BEGIN();
4188         _orig_tracepath_glTexStorage3D(target, levels, internalformat, width, height,
4189                                        depth);
4190
4191         goto finish;
4192
4193 finish:
4194         _COREGL_TRACEPATH_FUNC_END();
4195 }
4196
4197 void
4198 tracepath_glGetInternalformativ(GLenum target, GLenum internalformat,
4199                                 GLenum pname, GLsizei bufSize, GLint *params)
4200 {
4201         _COREGL_TRACEPATH_FUNC_BEGIN();
4202         _orig_tracepath_glGetInternalformativ(target, internalformat, pname, bufSize,
4203                                               params);
4204
4205         goto finish;
4206
4207 finish:
4208         _COREGL_TRACEPATH_FUNC_END();
4209 }
4210
4211
4212 /* GLES Extensions */
4213 void
4214 tracepath_glEGLImageTargetTexture2DOES(GLenum target, GLeglImageOES image)
4215 {
4216         _COREGL_TRACEPATH_FUNC_BEGIN();
4217         _COREGL_TRACE_SURFACE(0, 1, "TEXTURE2DOES");
4218         _orig_tracepath_glEGLImageTargetTexture2DOES(target, image);
4219         goto finish;
4220
4221 finish:
4222         _COREGL_TRACEPATH_FUNC_END();
4223 #ifdef COREGL_TRACEPATH_TRACE_MEMUSE_INFO
4224         if (trace_mem_flag == 1) {
4225                 MY_MODULE_TSTATE *tstate = NULL;
4226
4227                 GET_MY_TSTATE(tstate, get_current_thread_state());
4228                 AST(tstate != NULL);
4229                 if (tstate->ctx != NULL) {
4230                         int objidx = _COREGL_INT_INIT_VALUE;
4231                         _orig_tracepath_glGetIntegerv(GL_TEXTURE_BINDING_2D, &objidx);
4232                         AST(objidx != _COREGL_INT_INIT_VALUE);
4233
4234                         _add_glbuf_object(tstate->ctx->sostate->glbuf_tex, objidx, "Texture", 0, 0, 0,
4235                                           "Unknown");
4236                 }
4237         }
4238 #endif // COREGL_TRACEPATH_TRACE_MEMUSE_INFO
4239 }
4240
4241 void
4242 tracepath_glEGLImageTargetRenderbufferStorageOES(GLenum target,
4243                 GLeglImageOES image)
4244 {
4245         _COREGL_TRACEPATH_FUNC_BEGIN();
4246         _orig_tracepath_glEGLImageTargetRenderbufferStorageOES(target, image);
4247         goto finish;
4248
4249 finish:
4250         _COREGL_TRACEPATH_FUNC_END();
4251 #ifdef COREGL_TRACEPATH_TRACE_MEMUSE_INFO
4252         if (trace_mem_flag == 1) {
4253                 MY_MODULE_TSTATE *tstate = NULL;
4254
4255                 GET_MY_TSTATE(tstate, get_current_thread_state());
4256                 AST(tstate != NULL);
4257                 if (tstate->ctx != NULL) {
4258                         int objidx = _COREGL_INT_INIT_VALUE;
4259                         _orig_tracepath_glGetIntegerv(GL_RENDERBUFFER_BINDING, &objidx);
4260                         AST(objidx != _COREGL_INT_INIT_VALUE);
4261
4262                         _add_glbuf_object(tstate->ctx->sostate->glbuf_rb, objidx, "Renderbuffer", 0, 0,
4263                                           0, "Unknown");
4264                 }
4265         }
4266 #endif // COREGL_TRACEPATH_TRACE_MEMUSE_INFO
4267 }
4268
4269 void
4270 tracepath_glUseProgramStagesEXT(GLuint pipeline, GLbitfield stages,
4271                                 GLuint program)
4272 {
4273         _COREGL_TRACEPATH_FUNC_BEGIN();
4274         _orig_tracepath_glUseProgramStagesEXT(pipeline, stages, program);
4275
4276         goto finish;
4277
4278 finish:
4279         _COREGL_TRACEPATH_FUNC_END();
4280 }
4281
4282 void
4283 tracepath_glActiveShaderProgramEXT(GLuint pipeline, GLuint program)
4284 {
4285         _COREGL_TRACEPATH_FUNC_BEGIN();
4286         _orig_tracepath_glActiveShaderProgramEXT(pipeline, program);
4287
4288         goto finish;
4289
4290 finish:
4291         _COREGL_TRACEPATH_FUNC_END();
4292 }
4293
4294 GLuint
4295 tracepath_glCreateShaderProgramvEXT(GLenum type, GLsizei count,
4296                                     const char **strings)
4297 {
4298         GLuint ret = _COREGL_INT_INIT_VALUE;
4299
4300         _COREGL_TRACEPATH_FUNC_BEGIN();
4301         ret = _orig_tracepath_glCreateShaderProgramvEXT(type, count, strings);
4302
4303         goto finish;
4304
4305 finish:
4306         _COREGL_TRACEPATH_FUNC_END();
4307         return ret;
4308 }
4309
4310 void
4311 tracepath_glBindProgramPipelineEXT(GLuint pipeline)
4312 {
4313         _COREGL_TRACEPATH_FUNC_BEGIN();
4314         _orig_tracepath_glBindProgramPipelineEXT(pipeline);
4315
4316         goto finish;
4317
4318 finish:
4319         _COREGL_TRACEPATH_FUNC_END();
4320 }
4321
4322 void
4323 tracepath_glDeleteProgramPipelinesEXT(GLsizei n, const GLuint *pipelines)
4324 {
4325         _COREGL_TRACEPATH_FUNC_BEGIN();
4326         _orig_tracepath_glDeleteProgramPipelinesEXT(n, pipelines);
4327
4328         goto finish;
4329
4330 finish:
4331         _COREGL_TRACEPATH_FUNC_END();
4332 }
4333
4334 void
4335 tracepath_glGenProgramPipelinesEXT(GLsizei n, GLuint *pipelines)
4336 {
4337         _COREGL_TRACEPATH_FUNC_BEGIN();
4338         _orig_tracepath_glGenProgramPipelinesEXT(n, pipelines);
4339
4340         goto finish;
4341
4342 finish:
4343         _COREGL_TRACEPATH_FUNC_END();
4344 }
4345
4346 GLboolean
4347 tracepath_glIsProgramPipelineEXT(GLuint pipeline)
4348 {
4349         GLboolean ret = _COREGL_INT_INIT_VALUE;
4350
4351         _COREGL_TRACEPATH_FUNC_BEGIN();
4352         ret = _orig_tracepath_glIsProgramPipelineEXT(pipeline);
4353
4354         goto finish;
4355
4356 finish:
4357         _COREGL_TRACEPATH_FUNC_END();
4358         return ret;
4359 }
4360
4361 void
4362 tracepath_glProgramParameteriEXT(GLuint program, GLenum pname, GLint value)
4363 {
4364         _COREGL_TRACEPATH_FUNC_BEGIN();
4365         _orig_tracepath_glProgramParameteriEXT(program, pname, value);
4366
4367         goto finish;
4368
4369 finish:
4370         _COREGL_TRACEPATH_FUNC_END();
4371 }
4372
4373 void
4374 tracepath_glGetProgramPipelineivEXT(GLuint pipeline, GLenum pname,
4375                                     GLint *params)
4376 {
4377         _COREGL_TRACEPATH_FUNC_BEGIN();
4378         _orig_tracepath_glGetProgramPipelineivEXT(pipeline, pname, params);
4379
4380         goto finish;
4381
4382 finish:
4383         _COREGL_TRACEPATH_FUNC_END();
4384 }
4385
4386 void
4387 tracepath_glProgramUniform1iEXT(GLuint program, GLint location, GLint x)
4388 {
4389         _COREGL_TRACEPATH_FUNC_BEGIN();
4390         _orig_tracepath_glProgramUniform1iEXT(program, location, x);
4391
4392         goto finish;
4393
4394 finish:
4395         _COREGL_TRACEPATH_FUNC_END();
4396 }
4397
4398 void
4399 tracepath_glProgramUniform2iEXT(GLuint program, GLint location, GLint x,
4400                                 GLint y)
4401 {
4402         _COREGL_TRACEPATH_FUNC_BEGIN();
4403         _orig_tracepath_glProgramUniform2iEXT(program, location, x, y);
4404
4405         goto finish;
4406
4407 finish:
4408         _COREGL_TRACEPATH_FUNC_END();
4409 }
4410
4411 void
4412 tracepath_glProgramUniform3iEXT(GLuint program, GLint location, GLint x,
4413                                 GLint y, GLint z)
4414 {
4415         _COREGL_TRACEPATH_FUNC_BEGIN();
4416         _orig_tracepath_glProgramUniform3iEXT(program, location, x, y, z);
4417
4418         goto finish;
4419
4420 finish:
4421         _COREGL_TRACEPATH_FUNC_END();
4422 }
4423
4424 void
4425 tracepath_glProgramUniform4iEXT(GLuint program, GLint location, GLint x,
4426                                 GLint y, GLint z, GLint w)
4427 {
4428         _COREGL_TRACEPATH_FUNC_BEGIN();
4429         _orig_tracepath_glProgramUniform4iEXT(program, location, x, y, z, w);
4430
4431         goto finish;
4432
4433 finish:
4434         _COREGL_TRACEPATH_FUNC_END();
4435 }
4436
4437 void
4438 tracepath_glProgramUniform1fEXT(GLuint program, GLint location, GLfloat x)
4439 {
4440         _COREGL_TRACEPATH_FUNC_BEGIN();
4441         _orig_tracepath_glProgramUniform1fEXT(program, location, x);
4442
4443         goto finish;
4444
4445 finish:
4446         _COREGL_TRACEPATH_FUNC_END();
4447 }
4448
4449 void
4450 tracepath_glProgramUniform2fEXT(GLuint program, GLint location, GLfloat x,
4451                                 GLfloat y)
4452 {
4453         _COREGL_TRACEPATH_FUNC_BEGIN();
4454         _orig_tracepath_glProgramUniform2fEXT(program, location, x, y);
4455
4456         goto finish;
4457
4458 finish:
4459         _COREGL_TRACEPATH_FUNC_END();
4460 }
4461
4462 void
4463 tracepath_glProgramUniform3fEXT(GLuint program, GLint location, GLfloat x,
4464                                 GLfloat y, GLfloat z)
4465 {
4466         _COREGL_TRACEPATH_FUNC_BEGIN();
4467         _orig_tracepath_glProgramUniform3fEXT(program, location, x, y, z);
4468
4469         goto finish;
4470
4471 finish:
4472         _COREGL_TRACEPATH_FUNC_END();
4473 }
4474
4475 void
4476 tracepath_glProgramUniform4fEXT(GLuint program, GLint location, GLfloat x,
4477                                 GLfloat y, GLfloat z, GLfloat w)
4478 {
4479         _COREGL_TRACEPATH_FUNC_BEGIN();
4480         _orig_tracepath_glProgramUniform4fEXT(program, location, x, y, z, w);
4481
4482         goto finish;
4483
4484 finish:
4485         _COREGL_TRACEPATH_FUNC_END();
4486 }
4487
4488 void
4489 tracepath_glProgramUniform1ivEXT(GLuint program, GLint location, GLsizei count,
4490                                  const GLint *value)
4491 {
4492         _COREGL_TRACEPATH_FUNC_BEGIN();
4493         _orig_tracepath_glProgramUniform1ivEXT(program, location, count, value);
4494
4495         goto finish;
4496
4497 finish:
4498         _COREGL_TRACEPATH_FUNC_END();
4499 }
4500
4501 void
4502 tracepath_glProgramUniform2ivEXT(GLuint program, GLint location, GLsizei count,
4503                                  const GLint *value)
4504 {
4505         _COREGL_TRACEPATH_FUNC_BEGIN();
4506         _orig_tracepath_glProgramUniform2ivEXT(program, location, count, value);
4507
4508         goto finish;
4509
4510 finish:
4511         _COREGL_TRACEPATH_FUNC_END();
4512 }
4513
4514 void
4515 tracepath_glProgramUniform3ivEXT(GLuint program, GLint location, GLsizei count,
4516                                  const GLint *value)
4517 {
4518         _COREGL_TRACEPATH_FUNC_BEGIN();
4519         _orig_tracepath_glProgramUniform3ivEXT(program, location, count, value);
4520
4521         goto finish;
4522
4523 finish:
4524         _COREGL_TRACEPATH_FUNC_END();
4525 }
4526
4527 void
4528 tracepath_glProgramUniform4ivEXT(GLuint program, GLint location, GLsizei count,
4529                                  const GLint *value)
4530 {
4531         _COREGL_TRACEPATH_FUNC_BEGIN();
4532         _orig_tracepath_glProgramUniform4ivEXT(program, location, count, value);
4533
4534         goto finish;
4535
4536 finish:
4537         _COREGL_TRACEPATH_FUNC_END();
4538 }
4539
4540 void
4541 tracepath_glProgramUniform1fvEXT(GLuint program, GLint location, GLsizei count,
4542                                  const GLfloat *value)
4543 {
4544         _COREGL_TRACEPATH_FUNC_BEGIN();
4545         _orig_tracepath_glProgramUniform1fvEXT(program, location, count, value);
4546
4547         goto finish;
4548
4549 finish:
4550         _COREGL_TRACEPATH_FUNC_END();
4551 }
4552
4553 void
4554 tracepath_glProgramUniform2fvEXT(GLuint program, GLint location, GLsizei count,
4555                                  const GLfloat *value)
4556 {
4557         _COREGL_TRACEPATH_FUNC_BEGIN();
4558         _orig_tracepath_glProgramUniform2fvEXT(program, location, count, value);
4559
4560         goto finish;
4561
4562 finish:
4563         _COREGL_TRACEPATH_FUNC_END();
4564 }
4565
4566 void
4567 tracepath_glProgramUniform3fvEXT(GLuint program, GLint location, GLsizei count,
4568                                  const GLfloat *value)
4569 {
4570         _COREGL_TRACEPATH_FUNC_BEGIN();
4571         _orig_tracepath_glProgramUniform3fvEXT(program, location, count, value);
4572
4573         goto finish;
4574
4575 finish:
4576         _COREGL_TRACEPATH_FUNC_END();
4577 }
4578
4579 void
4580 tracepath_glProgramUniform4fvEXT(GLuint program, GLint location, GLsizei count,
4581                                  const GLfloat *value)
4582 {
4583         _COREGL_TRACEPATH_FUNC_BEGIN();
4584         _orig_tracepath_glProgramUniform4fvEXT(program, location, count, value);
4585
4586         goto finish;
4587
4588 finish:
4589         _COREGL_TRACEPATH_FUNC_END();
4590 }
4591
4592 void
4593 tracepath_glProgramUniformMatrix2fvEXT(GLuint program, GLint location,
4594                                        GLsizei count, GLboolean transpose, const GLfloat *value)
4595 {
4596         _COREGL_TRACEPATH_FUNC_BEGIN();
4597         _orig_tracepath_glProgramUniformMatrix2fvEXT(program, location, count,
4598                         transpose, value);
4599
4600         goto finish;
4601
4602 finish:
4603         _COREGL_TRACEPATH_FUNC_END();
4604 }
4605
4606 void
4607 tracepath_glProgramUniformMatrix3fvEXT(GLuint program, GLint location,
4608                                        GLsizei count, GLboolean transpose, const GLfloat *value)
4609 {
4610         _COREGL_TRACEPATH_FUNC_BEGIN();
4611         _orig_tracepath_glProgramUniformMatrix3fvEXT(program, location, count,
4612                         transpose, value);
4613
4614         goto finish;
4615
4616 finish:
4617         _COREGL_TRACEPATH_FUNC_END();
4618 }
4619
4620 void
4621 tracepath_glProgramUniformMatrix4fvEXT(GLuint program, GLint location,
4622                                        GLsizei count, GLboolean transpose, const GLfloat *value)
4623 {
4624         _COREGL_TRACEPATH_FUNC_BEGIN();
4625         _orig_tracepath_glProgramUniformMatrix4fvEXT(program, location, count,
4626                         transpose, value);
4627
4628         goto finish;
4629
4630 finish:
4631         _COREGL_TRACEPATH_FUNC_END();
4632 }
4633
4634 void
4635 tracepath_glValidateProgramPipelineEXT(GLuint pipeline)
4636 {
4637         _COREGL_TRACEPATH_FUNC_BEGIN();
4638         _orig_tracepath_glValidateProgramPipelineEXT(pipeline);
4639
4640         goto finish;
4641
4642 finish:
4643         _COREGL_TRACEPATH_FUNC_END();
4644 }
4645
4646 void
4647 tracepath_glGetProgramPipelineInfoLogEXT(GLuint pipeline, GLsizei bufSize,
4648                 GLsizei *length, char *infoLog)
4649 {
4650         _COREGL_TRACEPATH_FUNC_BEGIN();
4651         _orig_tracepath_glGetProgramPipelineInfoLogEXT(pipeline, bufSize, length,
4652                         infoLog);
4653
4654         goto finish;
4655
4656 finish:
4657         _COREGL_TRACEPATH_FUNC_END();
4658 }
4659
4660
4661 void
4662 tracepath_glFramebufferTexture2DMultisampleEXT(GLenum target, GLenum attachment,
4663                 GLenum textarget, GLuint texture, GLint level, GLsizei samples)
4664 {
4665         _COREGL_TRACEPATH_FUNC_BEGIN();
4666
4667 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
4668         tracepath_fbdump_update(0);
4669 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
4670
4671         _orig_tracepath_glFramebufferTexture2DMultisampleEXT(target, attachment,
4672                         textarget, texture, level, samples);
4673
4674 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
4675         tracepath_fbdump_update(1);
4676 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
4677
4678         goto finish;
4679
4680 finish:
4681         _COREGL_TRACEPATH_FUNC_END();
4682 }
4683
4684 void
4685 tracepath_glFramebufferTexture3DOES(GLenum target, GLenum attachment,
4686                                     GLenum textarget, GLuint texture, GLint level, GLint zoffset)
4687 {
4688         _COREGL_TRACEPATH_FUNC_BEGIN();
4689         _orig_tracepath_glFramebufferTexture3DOES(target, attachment, textarget,
4690                         texture, level, zoffset);
4691
4692         goto finish;
4693
4694 finish:
4695         _COREGL_TRACEPATH_FUNC_END();
4696 }
4697 /*
4698 void
4699 tracepath_glBlitFramebufferANGLE(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)
4700 {
4701         _COREGL_TRACEPATH_FUNC_BEGIN();
4702         _orig_tracepath_glBlitFramebufferANGLE(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
4703
4704         goto finish;
4705
4706 finish:
4707         _COREGL_TRACEPATH_FUNC_END();
4708 }
4709
4710 void
4711 tracepath_glRenderbufferStorageMultisampleANGLE(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
4712 {
4713         _COREGL_TRACEPATH_FUNC_BEGIN();
4714
4715         _orig_tracepath_glRenderbufferStorageMultisampleANGLE(target, samples, internalformat, width, height);
4716
4717         goto finish;
4718
4719 finish:
4720         _COREGL_TRACEPATH_FUNC_END();
4721 #ifdef COREGL_TRACEPATH_TRACE_MEMUSE_INFO
4722         if (trace_mem_flag == 1)
4723         {
4724                 MY_MODULE_TSTATE *tstate = NULL;
4725
4726                 GET_MY_TSTATE(tstate, get_current_thread_state());
4727                 AST(tstate != NULL);
4728                 if (tstate->ctx != NULL)
4729                 {
4730                         int objidx = _COREGL_INT_INIT_VALUE;
4731                         _orig_tracepath_glGetIntegerv(GL_RENDERBUFFER_BINDING, &objidx);
4732                         AST(objidx != _COREGL_INT_INIT_VALUE);
4733
4734                         // Detect byte per pixel
4735                         int bpp = 0;
4736                         char formatment[80];
4737                         switch (internalformat)
4738                         {
4739                                 case GL_ALPHA: sprintf(formatment, "ALPHA"); bpp = 1; break;
4740                                 case GL_LUMINANCE: sprintf(formatment, "LUMINANCE"); bpp = 1; break;
4741                                 case GL_LUMINANCE_ALPHA: sprintf(formatment, "LUMINANCE_ALPHA"); bpp = 1; break;
4742                                 case GL_RGB: sprintf(formatment, "RGB"); bpp = 2; break;
4743                                 case GL_RGBA: sprintf(formatment, "RGBA"); bpp = 4; break;
4744                                 case 0x80E1: sprintf(formatment, "BGRA_EXT"); bpp = 4; break;
4745                                 case 0x84F9: sprintf(formatment, "DEPTH_STENCIL_OES"); bpp = 4; break;
4746                                 case GL_DEPTH_COMPONENT : sprintf(formatment, "DEPTH_COMPONENT"); bpp = 1; break;
4747                                 case 0x81A5: sprintf(formatment, "DEPTH_COMPONENT16_ARB"); bpp = 2; break;
4748                                 case 0x81A6: sprintf(formatment, "DEPTH_COMPONENT24_ARB"); bpp = 3; break;
4749                                 case 0x81A7: sprintf(formatment, "DEPTH_COMPONENT32_ARB"); bpp = 4; break;
4750                                 case 0x8D46 : sprintf(formatment, "STENCIL_INDEX1_OES"); bpp = 1; break;
4751                                 case 0x8D47 : sprintf(formatment, "STENCIL_INDEX4_OES"); bpp = 1; break;
4752                                 case 0x8D48 : sprintf(formatment, "STENCIL_INDEX8_OES"); bpp = 1; break;
4753                                 default: sprintf(formatment, "0x%X", internalformat); bpp = 0; break;
4754                         }
4755
4756                         _add_glbuf_object(tstate->ctx->sostate->glbuf_rb, objidx, "Renderbuffer", width, height, bpp, formatment);
4757                 }
4758         }
4759 #endif // COREGL_TRACEPATH_TRACE_MEMUSE_INFO
4760 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
4761         if (trace_surface_flag == 1)
4762         {
4763                 MY_MODULE_TSTATE *tstate = NULL;
4764
4765                 GET_MY_TSTATE(tstate, get_current_thread_state());
4766                 AST(tstate != NULL);
4767                 if (tstate->ctx != NULL)
4768                 {
4769                         int objidx = _COREGL_INT_INIT_VALUE;
4770                         _orig_tracepath_glGetIntegerv(GL_RENDERBUFFER_BINDING, &objidx);
4771                         AST(objidx != _COREGL_INT_INIT_VALUE);
4772
4773                         {
4774                                 int channel = 0;
4775                                 switch (internalformat)
4776                                 {
4777                                         case GL_ALPHA:
4778                                         case GL_LUMINANCE:
4779                                         case GL_DEPTH_COMPONENT :
4780                                         case 0x81A5:
4781                                         case 0x81A6:
4782                                         case 0x81A7:
4783                                         case 0x8D46 :
4784                                         case 0x8D47 :
4785                                         case 0x8D48 : channel = 1; break;
4786                                         case GL_LUMINANCE_ALPHA:
4787                                         case 0x84F9: channel = 2; break;
4788                                         case GL_RGB: channel = 3; break;
4789                                         case GL_RGBA:
4790                                         case 0x80E1: channel = 4; break;
4791                                 }
4792
4793                                 char name[256];
4794                                 sprintf(name, "FBORB_%d", objidx);
4795                                 tracepath_surface_trace_add(name, tstate->ctx->dpy, tstate->ctx->handle, tstate->surf_draw, -1, 0, objidx, width, height, channel, NULL);
4796                         }
4797                 }
4798         }
4799 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
4800 }
4801 */
4802
4803
4804 void
4805 tracepath_glGetBufferPointervOES(GLenum target, GLenum pname, GLvoid **params)
4806 {
4807         _COREGL_TRACEPATH_FUNC_BEGIN();
4808         _orig_tracepath_glGetBufferPointervOES(target, pname, params);
4809
4810         goto finish;
4811
4812 finish:
4813         _COREGL_TRACEPATH_FUNC_END();
4814 }
4815
4816
4817 void *
4818 tracepath_glMapBufferOES(GLenum target, GLenum access)
4819 {
4820         void *ret = NULL;
4821
4822         _COREGL_TRACEPATH_FUNC_BEGIN();
4823         ret = _orig_tracepath_glMapBufferOES(target, access);
4824
4825         goto finish;
4826
4827 finish:
4828         _COREGL_TRACEPATH_FUNC_END();
4829         return ret;
4830 }
4831
4832
4833 GLboolean
4834 tracepath_glUnmapBufferOES(GLenum target)
4835 {
4836         GLboolean ret = GL_FALSE;
4837
4838         _COREGL_TRACEPATH_FUNC_BEGIN();
4839         ret = _orig_tracepath_glUnmapBufferOES(target);
4840
4841         goto finish;
4842
4843 finish:
4844         _COREGL_TRACEPATH_FUNC_END();
4845         return ret;
4846 }
4847
4848 /* GLES3.1 API */
4849 void
4850 tracepath_glGetProgramPipelineInfoLog(GLuint pipeline, GLsizei bufSize,
4851                                       GLsizei *length, GLchar *infoLog)
4852 {
4853         _COREGL_TRACEPATH_FUNC_BEGIN();
4854         _orig_tracepath_glGetProgramPipelineInfoLog(pipeline, bufSize, length, infoLog);
4855
4856         goto finish;
4857
4858 finish:
4859         _COREGL_TRACEPATH_FUNC_END();
4860 }
4861
4862 GLuint
4863 tracepath_glCreateShaderProgramv(GLenum type,  GLsizei count,
4864                                  const GLchar *const *strings)
4865 {
4866         GLboolean ret = GL_FALSE;
4867         _COREGL_TRACEPATH_FUNC_BEGIN();
4868         ret = _orig_tracepath_glCreateShaderProgramv(type, count, strings);
4869
4870         goto finish;
4871
4872 finish:
4873         _COREGL_TRACEPATH_FUNC_END();
4874         return ret;
4875 }
4876
4877 void
4878 tracepath_glGenProgramPipelines( GLsizei n,  GLuint *pipelines)
4879 {
4880         _COREGL_TRACEPATH_FUNC_BEGIN();
4881         _orig_tracepath_glGenProgramPipelines(n, pipelines);
4882
4883         goto finish;
4884
4885 finish:
4886         _COREGL_TRACEPATH_FUNC_END();
4887 }
4888
4889 void
4890 tracepath_glBindProgramPipeline( GLuint pipeline)
4891 {
4892         _COREGL_TRACEPATH_FUNC_BEGIN();
4893         _orig_tracepath_glBindProgramPipeline(pipeline);
4894
4895         goto finish;
4896
4897 finish:
4898         _COREGL_TRACEPATH_FUNC_END();
4899 }
4900
4901 void
4902 tracepath_glGetProgramPipelineiv(GLuint pipeline, GLenum pname, GLint *params)
4903 {
4904         _COREGL_TRACEPATH_FUNC_BEGIN();
4905         _orig_tracepath_glGetProgramPipelineiv(pipeline, pname, params);
4906
4907         goto finish;
4908
4909 finish:
4910         _COREGL_TRACEPATH_FUNC_END();
4911 }
4912
4913 void
4914 tracepath_glDeleteProgramPipelines(GLsizei n, GLuint const *pipelines)
4915 {
4916         _COREGL_TRACEPATH_FUNC_BEGIN();
4917         _orig_tracepath_glDeleteProgramPipelines(n, pipelines);
4918
4919         goto finish;
4920
4921 finish:
4922         _COREGL_TRACEPATH_FUNC_END();
4923 }
4924
4925 GLboolean
4926 tracepath_glIsProgramPipeline( GLuint pipeline)
4927 {
4928         GLboolean ret = GL_FALSE;
4929
4930         _COREGL_TRACEPATH_FUNC_BEGIN();
4931         ret = _orig_tracepath_glIsProgramPipeline(pipeline);
4932
4933         goto finish;
4934
4935 finish:
4936         _COREGL_TRACEPATH_FUNC_END();
4937         return ret;
4938 }
4939
4940 void
4941 tracepath_glValidateProgramPipeline(GLuint pipeline)
4942 {
4943         _COREGL_TRACEPATH_FUNC_BEGIN();
4944         _orig_tracepath_glValidateProgramPipeline(pipeline);
4945
4946         goto finish;
4947
4948 finish:
4949         _COREGL_TRACEPATH_FUNC_END();
4950 }
4951
4952 void
4953 tracepath_glDispatchCompute(GLuint num_groups_x, GLuint num_groups_y,
4954                             GLuint num_groups_z)
4955 {
4956         _COREGL_TRACEPATH_FUNC_BEGIN();
4957         _orig_tracepath_glDispatchCompute(num_groups_x, num_groups_y, num_groups_z);
4958
4959         goto finish;
4960
4961 finish:
4962         _COREGL_TRACEPATH_FUNC_END();
4963 }
4964
4965 void
4966 tracepath_glDispatchComputeIndirect( GLintptr indirect)
4967 {
4968         _COREGL_TRACEPATH_FUNC_BEGIN();
4969         _orig_tracepath_glDispatchComputeIndirect(indirect);
4970
4971         goto finish;
4972
4973 finish:
4974         _COREGL_TRACEPATH_FUNC_END();
4975 }
4976
4977 void
4978 tracepath_glDrawArraysIndirect(GLenum mode, GLvoid const *indirect)
4979 {
4980         _COREGL_TRACEPATH_FUNC_BEGIN();
4981         _orig_tracepath_glDrawArraysIndirect(mode, indirect);
4982
4983         goto finish;
4984
4985 finish:
4986         _COREGL_TRACEPATH_FUNC_END();
4987 }
4988
4989 void
4990 tracepath_glDrawElementsIndirect(GLenum mode, GLenum type,
4991                                  GLvoid const *indirect)
4992 {
4993         _COREGL_TRACEPATH_FUNC_BEGIN();
4994         _orig_tracepath_glDrawElementsIndirect(mode, type, indirect);
4995
4996         goto finish;
4997
4998 finish:
4999         _COREGL_TRACEPATH_FUNC_END();
5000 }
5001
5002 void
5003 tracepath_glFramebufferParameteri(GLenum target, GLenum pname, GLint param)
5004 {
5005         _COREGL_TRACEPATH_FUNC_BEGIN();
5006         _orig_tracepath_glFramebufferParameteri(target, pname, param);
5007
5008         goto finish;
5009
5010 finish:
5011         _COREGL_TRACEPATH_FUNC_END();
5012 }
5013
5014 void
5015 tracepath_glGetFramebufferParameteriv( GLenum target,  GLenum pname,
5016                                        GLint *params)
5017 {
5018         _COREGL_TRACEPATH_FUNC_BEGIN();
5019         _orig_tracepath_glGetFramebufferParameteriv(target,  pname,  params);
5020
5021         goto finish;
5022
5023 finish:
5024         _COREGL_TRACEPATH_FUNC_END();
5025 }
5026
5027 void
5028 tracepath_glGetProgramInterfaceiv(GLuint program,  GLenum programInterface,
5029                                   GLenum pname,  GLint *params)
5030 {
5031         _COREGL_TRACEPATH_FUNC_BEGIN();
5032         _orig_tracepath_glGetProgramInterfaceiv(program, programInterface, pname,
5033                                                 params);
5034
5035         goto finish;
5036
5037 finish:
5038         _COREGL_TRACEPATH_FUNC_END();
5039 }
5040
5041 GLuint
5042 tracepath_glGetProgramResourceIndex( GLuint program,  GLenum programInterface,
5043                                      const char *name)
5044 {
5045         GLuint ret = GL_INVALID_INDEX;
5046         _COREGL_TRACEPATH_FUNC_BEGIN();
5047         ret =  _orig_tracepath_glGetProgramResourceIndex(program,  programInterface,
5048                         name);
5049
5050         goto finish;
5051
5052 finish:
5053         _COREGL_TRACEPATH_FUNC_END();
5054         return ret;
5055 }
5056
5057 void
5058 tracepath_glGetProgramResourceName(GLuint program, GLenum programInterface,
5059                                    GLuint index, GLsizei bufSize, GLsizei *length, GLchar *name)
5060 {
5061         _COREGL_TRACEPATH_FUNC_BEGIN();
5062
5063         _orig_tracepath_glGetProgramResourceName(program, programInterface, index,
5064                         bufSize, length, name);
5065
5066         goto finish;
5067
5068 finish:
5069         _COREGL_TRACEPATH_FUNC_END();
5070 }
5071
5072 void
5073 tracepath_glGetProgramResourceiv( GLuint program,  GLenum programInterface,
5074                                   GLuint index,  GLsizei propCount,  const GLenum *props,  GLsizei bufSize,
5075                                   GLsizei *length,  GLint *params)
5076 {
5077         _COREGL_TRACEPATH_FUNC_BEGIN();
5078
5079         _orig_tracepath_glGetProgramResourceiv(program,  programInterface,  index,
5080                                                propCount,  props,  bufSize,  length,  params);
5081
5082         goto finish;
5083
5084 finish:
5085         _COREGL_TRACEPATH_FUNC_END();
5086 }
5087
5088 GLint
5089 tracepath_glGetProgramResourceLocation(GLuint program, GLenum programInterface,
5090                                        GLchar const *name)
5091 {
5092         GLuint ret = -1;
5093         _COREGL_TRACEPATH_FUNC_BEGIN();
5094
5095         ret = _orig_tracepath_glGetProgramResourceLocation(program, programInterface,
5096                         name);
5097
5098         goto finish;
5099
5100 finish:
5101         _COREGL_TRACEPATH_FUNC_END();
5102         return ret;
5103 }
5104
5105 void
5106 tracepath_glUseProgramStages(GLuint pipeline, GLbitfield stages, GLuint program)
5107 {
5108         _COREGL_TRACEPATH_FUNC_BEGIN();
5109         _orig_tracepath_glUseProgramStages(pipeline, stages, program);
5110
5111         goto finish;
5112
5113 finish:
5114         _COREGL_TRACEPATH_FUNC_END();
5115 }
5116
5117 void
5118 tracepath_glActiveShaderProgram(GLuint pipeline, GLuint program)
5119 {
5120         _COREGL_TRACEPATH_FUNC_BEGIN();
5121         _orig_tracepath_glActiveShaderProgram(pipeline, program);
5122
5123         goto finish;
5124
5125 finish:
5126         _COREGL_TRACEPATH_FUNC_END();
5127 }
5128
5129 void
5130 tracepath_glProgramUniform1iv(GLuint program, GLint location, GLsizei count,
5131                               const GLint *value)
5132 {
5133         _COREGL_TRACEPATH_FUNC_BEGIN();
5134         _orig_tracepath_glProgramUniform1iv(program, location, count, value);
5135
5136         goto finish;
5137
5138 finish:
5139         _COREGL_TRACEPATH_FUNC_END();
5140 }
5141
5142 void
5143 tracepath_glProgramUniform2iv(GLuint program, GLint location, GLsizei count,
5144                               const GLint *value)
5145 {
5146         _COREGL_TRACEPATH_FUNC_BEGIN();
5147         _orig_tracepath_glProgramUniform2iv(program, location, count, value);
5148
5149         goto finish;
5150
5151 finish:
5152         _COREGL_TRACEPATH_FUNC_END();
5153 }
5154
5155 void
5156 tracepath_glProgramUniform3iv(GLuint program, GLint location, GLsizei count,
5157                               const GLint *value)
5158 {
5159         _COREGL_TRACEPATH_FUNC_BEGIN();
5160         _orig_tracepath_glProgramUniform3iv(program, location, count, value);
5161
5162         goto finish;
5163
5164 finish:
5165         _COREGL_TRACEPATH_FUNC_END();
5166 }
5167
5168 void
5169 tracepath_glProgramUniform4iv(GLuint program, GLint location, GLsizei count,
5170                               const GLint *value)
5171 {
5172         _COREGL_TRACEPATH_FUNC_BEGIN();
5173         _orig_tracepath_glProgramUniform4iv(program, location, count, value);
5174
5175         goto finish;
5176
5177 finish:
5178         _COREGL_TRACEPATH_FUNC_END();
5179 }
5180
5181 void
5182 tracepath_glProgramUniform1fv(GLuint program, GLint location, GLsizei count,
5183                               const GLfloat *value)
5184 {
5185         _COREGL_TRACEPATH_FUNC_BEGIN();
5186         _orig_tracepath_glProgramUniform1fv(program, location, count, value);
5187
5188         goto finish;
5189
5190 finish:
5191         _COREGL_TRACEPATH_FUNC_END();
5192 }
5193
5194 void
5195 tracepath_glProgramUniform2fv(GLuint program, GLint location, GLsizei count,
5196                               const GLfloat *value)
5197 {
5198         _COREGL_TRACEPATH_FUNC_BEGIN();
5199         _orig_tracepath_glProgramUniform2fv(program, location, count, value);
5200
5201         goto finish;
5202
5203 finish:
5204         _COREGL_TRACEPATH_FUNC_END();
5205 }
5206
5207 void
5208 tracepath_glProgramUniform3fv(GLuint program, GLint location, GLsizei count,
5209                               const GLfloat *value)
5210 {
5211         _COREGL_TRACEPATH_FUNC_BEGIN();
5212         _orig_tracepath_glProgramUniform3fv(program, location, count, value);
5213
5214         goto finish;
5215
5216 finish:
5217         _COREGL_TRACEPATH_FUNC_END();
5218 }
5219
5220 void
5221 tracepath_glProgramUniform4fv(GLuint program, GLint location, GLsizei count,
5222                               const GLfloat *value)
5223 {
5224         _COREGL_TRACEPATH_FUNC_BEGIN();
5225         _orig_tracepath_glProgramUniform4fv(program, location, count, value);
5226
5227         goto finish;
5228
5229 finish:
5230         _COREGL_TRACEPATH_FUNC_END();
5231 }
5232
5233 void
5234 tracepath_glProgramUniformMatrix2fv(GLuint program, GLint location,
5235                                     GLsizei count, GLboolean transpose, const GLfloat *value)
5236 {
5237         _COREGL_TRACEPATH_FUNC_BEGIN();
5238         _orig_tracepath_glProgramUniformMatrix2fv(program, location, count, transpose,
5239                         value);
5240
5241         goto finish;
5242
5243 finish:
5244         _COREGL_TRACEPATH_FUNC_END();
5245 }
5246
5247 void
5248 tracepath_glProgramUniformMatrix3fv(GLuint program, GLint location,
5249                                     GLsizei count, GLboolean transpose, const GLfloat *value)
5250 {
5251         _COREGL_TRACEPATH_FUNC_BEGIN();
5252         _orig_tracepath_glProgramUniformMatrix3fv(program, location, count, transpose,
5253                         value);
5254
5255         goto finish;
5256
5257 finish:
5258         _COREGL_TRACEPATH_FUNC_END();
5259 }
5260
5261 void
5262 tracepath_glProgramUniformMatrix4fv(GLuint program, GLint location,
5263                                     GLsizei count, GLboolean transpose, const GLfloat *value)
5264 {
5265         _COREGL_TRACEPATH_FUNC_BEGIN();
5266         _orig_tracepath_glProgramUniformMatrix4fv(program, location, count, transpose,
5267                         value);
5268
5269         goto finish;
5270
5271 finish:
5272         _COREGL_TRACEPATH_FUNC_END();
5273 }
5274
5275 void
5276 tracepath_glProgramUniform1i(GLuint program, GLint location, GLint x)
5277 {
5278         _COREGL_TRACEPATH_FUNC_BEGIN();
5279         _orig_tracepath_glProgramUniform1i(program, location, x);
5280
5281         goto finish;
5282
5283 finish:
5284         _COREGL_TRACEPATH_FUNC_END();
5285 }
5286
5287 void
5288 tracepath_glProgramUniform2i(GLuint program, GLint location, GLint x, GLint y)
5289 {
5290         _COREGL_TRACEPATH_FUNC_BEGIN();
5291         _orig_tracepath_glProgramUniform2i(program, location, x, y);
5292
5293         goto finish;
5294
5295 finish:
5296         _COREGL_TRACEPATH_FUNC_END();
5297 }
5298
5299 void
5300 tracepath_glProgramUniform3i(GLuint program, GLint location, GLint x, GLint y,
5301                              GLint z)
5302 {
5303         _COREGL_TRACEPATH_FUNC_BEGIN();
5304         _orig_tracepath_glProgramUniform3i(program, location, x, y, z);
5305
5306         goto finish;
5307
5308 finish:
5309         _COREGL_TRACEPATH_FUNC_END();
5310 }
5311
5312 void
5313 tracepath_glProgramUniform4i(GLuint program, GLint location, GLint x, GLint y,
5314                              GLint z, GLint w)
5315 {
5316         _COREGL_TRACEPATH_FUNC_BEGIN();
5317         _orig_tracepath_glProgramUniform4i(program, location, x, y, z, w);
5318
5319         goto finish;
5320
5321 finish:
5322         _COREGL_TRACEPATH_FUNC_END();
5323 }
5324
5325 void
5326 tracepath_glProgramUniform1f(GLuint program, GLint location, GLfloat x)
5327 {
5328         _COREGL_TRACEPATH_FUNC_BEGIN();
5329         _orig_tracepath_glProgramUniform1f(program, location, x);
5330
5331         goto finish;
5332
5333 finish:
5334         _COREGL_TRACEPATH_FUNC_END();
5335 }
5336
5337 void
5338 tracepath_glProgramUniform2f(GLuint program, GLint location, GLfloat x,
5339                              GLfloat y)
5340 {
5341         _COREGL_TRACEPATH_FUNC_BEGIN();
5342         _orig_tracepath_glProgramUniform2f(program, location, x, y);
5343
5344         goto finish;
5345
5346 finish:
5347         _COREGL_TRACEPATH_FUNC_END();
5348 }
5349
5350 void
5351 tracepath_glProgramUniform3f(GLuint program, GLint location, GLfloat x,
5352                              GLfloat y, GLfloat z)
5353 {
5354         _COREGL_TRACEPATH_FUNC_BEGIN();
5355         _orig_tracepath_glProgramUniform3f(program, location, x, y, z);
5356
5357         goto finish;
5358
5359 finish:
5360         _COREGL_TRACEPATH_FUNC_END();
5361 }
5362
5363 void
5364 tracepath_glProgramUniform4f(GLuint program, GLint location, GLfloat x,
5365                              GLfloat y, GLfloat z, GLfloat w)
5366 {
5367         _COREGL_TRACEPATH_FUNC_BEGIN();
5368         _orig_tracepath_glProgramUniform4f(program, location, x, y, z, w);
5369
5370         goto finish;
5371
5372 finish:
5373         _COREGL_TRACEPATH_FUNC_END();
5374 }
5375
5376 void
5377 tracepath_glProgramUniform1ui(GLuint program, GLint location, GLuint x)
5378 {
5379         _COREGL_TRACEPATH_FUNC_BEGIN();
5380         _orig_tracepath_glProgramUniform1ui(program, location, x);
5381
5382         goto finish;
5383
5384 finish:
5385         _COREGL_TRACEPATH_FUNC_END();
5386 }
5387
5388 void
5389 tracepath_glProgramUniform2ui(GLuint program, GLint location, GLuint x,
5390                               GLuint y)
5391 {
5392         _COREGL_TRACEPATH_FUNC_BEGIN();
5393         _orig_tracepath_glProgramUniform2ui(program, location, x, y);
5394
5395         goto finish;
5396
5397 finish:
5398         _COREGL_TRACEPATH_FUNC_END();
5399 }
5400
5401 void
5402 tracepath_glProgramUniform3ui(GLuint program, GLint location, GLuint x,
5403                               GLuint y, GLuint z)
5404 {
5405         _COREGL_TRACEPATH_FUNC_BEGIN();
5406         _orig_tracepath_glProgramUniform3ui(program, location, x, y, z);
5407
5408         goto finish;
5409
5410 finish:
5411         _COREGL_TRACEPATH_FUNC_END();
5412 }
5413
5414 void
5415 tracepath_glProgramUniform4ui(GLuint program, GLint location, GLuint x,
5416                               GLuint y, GLuint z, GLuint w)
5417 {
5418         _COREGL_TRACEPATH_FUNC_BEGIN();
5419         _orig_tracepath_glProgramUniform4ui(program, location, x, y, z, w);
5420
5421         goto finish;
5422
5423 finish:
5424         _COREGL_TRACEPATH_FUNC_END();
5425 }
5426
5427 void
5428 tracepath_glProgramUniform1uiv(GLuint program, GLint location, GLsizei count,
5429                                const GLuint *value)
5430 {
5431         _COREGL_TRACEPATH_FUNC_BEGIN();
5432         _orig_tracepath_glProgramUniform1uiv(program, location, count, value);
5433
5434         goto finish;
5435
5436 finish:
5437         _COREGL_TRACEPATH_FUNC_END();
5438 }
5439
5440 void
5441 tracepath_glProgramUniform2uiv(GLuint program, GLint location, GLsizei count,
5442                                const GLuint *value)
5443 {
5444         _COREGL_TRACEPATH_FUNC_BEGIN();
5445         _orig_tracepath_glProgramUniform2uiv(program, location, count, value);
5446
5447         goto finish;
5448
5449 finish:
5450         _COREGL_TRACEPATH_FUNC_END();
5451 }
5452
5453 void
5454 tracepath_glProgramUniform3uiv(GLuint program, GLint location, GLsizei count,
5455                                const GLuint *value)
5456 {
5457         _COREGL_TRACEPATH_FUNC_BEGIN();
5458         _orig_tracepath_glProgramUniform3uiv(program, location, count, value);
5459
5460         goto finish;
5461
5462 finish:
5463         _COREGL_TRACEPATH_FUNC_END();
5464 }
5465
5466 void
5467 tracepath_glProgramUniform4uiv(GLuint program, GLint location, GLsizei count,
5468                                const GLuint *value)
5469 {
5470         _COREGL_TRACEPATH_FUNC_BEGIN();
5471         _orig_tracepath_glProgramUniform4uiv(program, location, count, value);
5472
5473         goto finish;
5474
5475 finish:
5476         _COREGL_TRACEPATH_FUNC_END();
5477 }
5478
5479 void
5480 tracepath_glProgramUniformMatrix2x3fv(GLuint program, GLint location,
5481                                       GLsizei count, GLboolean transpose, const GLfloat *value)
5482 {
5483         _COREGL_TRACEPATH_FUNC_BEGIN();
5484         _orig_tracepath_glProgramUniformMatrix2x3fv(program, location, count, transpose,
5485                         value);
5486
5487         goto finish;
5488
5489 finish:
5490         _COREGL_TRACEPATH_FUNC_END();
5491 }
5492
5493 void
5494 tracepath_glProgramUniformMatrix3x2fv(GLuint program, GLint location,
5495                                       GLsizei count, GLboolean transpose, const GLfloat *value)
5496 {
5497         _COREGL_TRACEPATH_FUNC_BEGIN();
5498         _orig_tracepath_glProgramUniformMatrix3x2fv(program, location, count, transpose,
5499                         value);
5500
5501         goto finish;
5502
5503 finish:
5504         _COREGL_TRACEPATH_FUNC_END();
5505 }
5506
5507 void
5508 tracepath_glProgramUniformMatrix4x2fv(GLuint program, GLint location,
5509                                       GLsizei count, GLboolean transpose, const GLfloat *value)
5510 {
5511         _COREGL_TRACEPATH_FUNC_BEGIN();
5512         _orig_tracepath_glProgramUniformMatrix4x2fv(program, location, count, transpose,
5513                         value);
5514
5515         goto finish;
5516
5517 finish:
5518         _COREGL_TRACEPATH_FUNC_END();
5519 }
5520
5521 void
5522 tracepath_glProgramUniformMatrix2x4fv(GLuint program, GLint location,
5523                                       GLsizei count, GLboolean transpose, const GLfloat *value)
5524 {
5525         _COREGL_TRACEPATH_FUNC_BEGIN();
5526         _orig_tracepath_glProgramUniformMatrix2x4fv(program, location, count, transpose,
5527                         value);
5528
5529         goto finish;
5530
5531 finish:
5532         _COREGL_TRACEPATH_FUNC_END();
5533 }
5534
5535 void
5536 tracepath_glProgramUniformMatrix3x4fv(GLuint program, GLint location,
5537                                       GLsizei count, GLboolean transpose, const GLfloat *value)
5538 {
5539         _COREGL_TRACEPATH_FUNC_BEGIN();
5540         _orig_tracepath_glProgramUniformMatrix3x4fv(program, location, count, transpose,
5541                         value);
5542
5543         goto finish;
5544
5545 finish:
5546         _COREGL_TRACEPATH_FUNC_END();
5547 }
5548
5549 void
5550 tracepath_glProgramUniformMatrix4x3fv(GLuint program, GLint location,
5551                                       GLsizei count, GLboolean transpose, const GLfloat *value)
5552 {
5553         _COREGL_TRACEPATH_FUNC_BEGIN();
5554         _orig_tracepath_glProgramUniformMatrix4x3fv(program, location, count, transpose,
5555                         value);
5556
5557         goto finish;
5558
5559 finish:
5560         _COREGL_TRACEPATH_FUNC_END();
5561 }
5562
5563 void
5564 tracepath_glBindImageTexture(GLuint unit, GLuint texture, GLint level,
5565                              GLboolean layered, GLint layer, GLenum access, GLenum format)
5566 {
5567         _COREGL_TRACEPATH_FUNC_BEGIN();
5568
5569         _orig_tracepath_glBindImageTexture(unit, texture, level, layered, layer, access,
5570                                            format);
5571
5572         goto finish;
5573
5574 finish:
5575         _COREGL_TRACEPATH_FUNC_END();
5576 }
5577
5578 void
5579 tracepath_glGetBooleani_v (GLenum target, GLuint index, GLboolean *data)
5580 {
5581         _COREGL_TRACEPATH_FUNC_BEGIN();
5582         _orig_tracepath_glGetBooleani_v (target, index, data);
5583
5584         goto finish;
5585
5586 finish:
5587         _COREGL_TRACEPATH_FUNC_END();
5588 }
5589
5590 void
5591 tracepath_glMemoryBarrier (GLbitfield barriers)
5592 {
5593         _COREGL_TRACEPATH_FUNC_BEGIN();
5594         _orig_tracepath_glMemoryBarrier (barriers);
5595
5596         goto finish;
5597
5598 finish:
5599         _COREGL_TRACEPATH_FUNC_END();
5600 }
5601
5602 void tracepath_glMemoryBarrierByRegion (GLbitfield barriers)
5603 {
5604         _COREGL_TRACEPATH_FUNC_BEGIN();
5605         _orig_tracepath_glMemoryBarrierByRegion (barriers);
5606
5607         goto finish;
5608
5609 finish:
5610         _COREGL_TRACEPATH_FUNC_END();
5611 }
5612
5613 void
5614 tracepath_glTexStorage2DMultisample (GLenum target, GLsizei samples,
5615                                      GLenum internalformat, GLsizei width, GLsizei height,
5616                                      GLboolean fixedsamplelocations)
5617 {
5618         _COREGL_TRACEPATH_FUNC_BEGIN();
5619         _orig_tracepath_glTexStorage2DMultisample (target, samples, internalformat,
5620                         width, height, fixedsamplelocations);
5621
5622         goto finish;
5623
5624 finish:
5625         _COREGL_TRACEPATH_FUNC_END();
5626 }
5627
5628 void
5629 tracepath_glGetMultisamplefv (GLenum pname, GLuint index, GLfloat *val)
5630 {
5631         _COREGL_TRACEPATH_FUNC_BEGIN();
5632         _orig_tracepath_glGetMultisamplefv (pname, index, val);
5633
5634         goto finish;
5635
5636 finish:
5637         _COREGL_TRACEPATH_FUNC_END();
5638 }
5639
5640 void
5641 tracepath_glSampleMaski (GLuint maskNumber, GLbitfield mask)
5642 {
5643         _COREGL_TRACEPATH_FUNC_BEGIN();
5644         _orig_tracepath_glSampleMaski (maskNumber, mask);
5645
5646         goto finish;
5647
5648 finish:
5649         _COREGL_TRACEPATH_FUNC_END();
5650 }
5651
5652 void
5653 tracepath_glGetTexLevelParameteriv (GLenum target, GLint level, GLenum pname,
5654                                     GLint *params)
5655 {
5656         _COREGL_TRACEPATH_FUNC_BEGIN();
5657         _orig_tracepath_glGetTexLevelParameteriv (target, level, pname, params);
5658
5659         goto finish;
5660
5661 finish:
5662         _COREGL_TRACEPATH_FUNC_END();
5663 }
5664
5665 void
5666 tracepath_glGetTexLevelParameterfv (GLenum target, GLint level, GLenum pname,
5667                                     GLfloat *params)
5668 {
5669         _COREGL_TRACEPATH_FUNC_BEGIN();
5670         _orig_tracepath_glGetTexLevelParameterfv (target, level, pname, params);
5671
5672         goto finish;
5673
5674 finish:
5675         _COREGL_TRACEPATH_FUNC_END();
5676 }
5677
5678 void
5679 tracepath_glBindVertexBuffer (GLuint bindingindex, GLuint buffer,
5680                               GLintptr offset, GLsizei stride)
5681 {
5682         _COREGL_TRACEPATH_FUNC_BEGIN();
5683         _orig_tracepath_glBindVertexBuffer (bindingindex, buffer, offset, stride);
5684
5685         goto finish;
5686
5687 finish:
5688         _COREGL_TRACEPATH_FUNC_END();
5689 }
5690
5691
5692 void tracepath_glVertexAttribFormat (GLuint attribindex, GLint size,
5693                                      GLenum type, GLboolean normalized, GLuint relativeoffset)
5694 {
5695         _COREGL_TRACEPATH_FUNC_BEGIN();
5696         _orig_tracepath_glVertexAttribFormat (attribindex, size, type, normalized,
5697                                               relativeoffset);
5698
5699         goto finish;
5700
5701 finish:
5702         _COREGL_TRACEPATH_FUNC_END();
5703 }
5704
5705 void tracepath_glVertexAttribIFormat (GLuint attribindex, GLint size,
5706                                       GLenum type, GLuint relativeoffset)
5707 {
5708         _COREGL_TRACEPATH_FUNC_BEGIN();
5709         _orig_tracepath_glVertexAttribIFormat (attribindex, size, type, relativeoffset);
5710
5711         goto finish;
5712
5713 finish:
5714         _COREGL_TRACEPATH_FUNC_END();
5715 }
5716
5717 void tracepath_glVertexAttribBinding (GLuint attribindex, GLuint bindingindex)
5718 {
5719         _COREGL_TRACEPATH_FUNC_BEGIN();
5720         _orig_tracepath_glVertexAttribBinding (attribindex, bindingindex);
5721
5722         goto finish;
5723
5724 finish:
5725         _COREGL_TRACEPATH_FUNC_END();
5726 }
5727
5728 void tracepath_glVertexBindingDivisor (GLuint bindingindex, GLuint divisor)
5729 {
5730         _COREGL_TRACEPATH_FUNC_BEGIN();
5731         _orig_tracepath_glVertexBindingDivisor (bindingindex, divisor);
5732
5733         goto finish;
5734
5735 finish:
5736         _COREGL_TRACEPATH_FUNC_END();
5737 }
5738 void
5739 tracepath_glBindFramebufferOES(GLenum target, GLuint framebuffer)
5740 {
5741         _COREGL_TRACEPATH_FUNC_BEGIN();
5742
5743 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
5744         if (unlikely(trace_surface_flag == 1)) {
5745                 GLint oldfb;
5746                 _orig_tracepath_glGetIntegerv(GL_FRAMEBUFFER_BINDING, &oldfb);
5747                 if (oldfb != 0) {
5748                         _COREGL_TRACE_SURFACE(0, 2, "GLBINDFBO");
5749                 }
5750
5751                 tracepath_fbdump_update(0);
5752         }
5753 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
5754
5755         _orig_tracepath_glBindFramebufferOES(target, framebuffer);
5756
5757 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
5758         if (unlikely(trace_surface_flag == 1)) {
5759                 tracepath_fbdump_update(1);
5760         }
5761 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
5762
5763         goto finish;
5764
5765 finish:
5766         _COREGL_TRACEPATH_FUNC_END();
5767 }
5768
5769 void
5770 tracepath_glBindRenderbufferOES(GLenum target, GLuint renderbuffer)
5771 {
5772         _COREGL_TRACEPATH_FUNC_BEGIN();
5773         _orig_tracepath_glBindRenderbufferOES(target, renderbuffer);
5774
5775         goto finish;
5776
5777 finish:
5778         _COREGL_TRACEPATH_FUNC_END();
5779 }
5780
5781 void
5782 tracepath_glDeleteFramebuffersOES(GLsizei n, const GLuint *framebuffers)
5783 {
5784         _COREGL_TRACEPATH_FUNC_BEGIN();
5785
5786 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
5787         tracepath_fbdump_update(0);
5788 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
5789
5790         _orig_tracepath_glDeleteFramebuffersOES(n, framebuffers);
5791
5792 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
5793         tracepath_fbdump_update(1);
5794 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
5795
5796         goto finish;
5797
5798 finish:
5799         _COREGL_TRACEPATH_FUNC_END();
5800 }
5801
5802 void
5803 tracepath_glDeleteRenderbuffersOES(GLsizei n, const GLuint *renderbuffers)
5804 {
5805         _COREGL_TRACEPATH_FUNC_BEGIN();
5806
5807 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
5808         tracepath_fbdump_update(0);
5809 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
5810
5811         _orig_tracepath_glDeleteRenderbuffersOES(n, renderbuffers);
5812
5813 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
5814         tracepath_fbdump_update(1);
5815 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
5816
5817         goto finish;
5818
5819 finish:
5820         _COREGL_TRACEPATH_FUNC_END();
5821 #ifdef COREGL_TRACEPATH_TRACE_MEMUSE_INFO
5822         if (trace_mem_flag == 1) {
5823                 MY_MODULE_TSTATE *tstate = NULL;
5824
5825                 GET_MY_TSTATE(tstate, get_current_thread_state());
5826                 AST(tstate != NULL);
5827                 if (tstate->ctx != NULL) {
5828                         for (int i = 0; i < n; i++) {
5829                                 if (renderbuffers[i] == 0) continue;
5830                                 _remove_glbuf_object(tstate->ctx->sostate->glbuf_rb, renderbuffers[i],
5831                                                      "Renderbuffer");
5832                         }
5833                 }
5834         }
5835 #endif // COREGL_TRACEPATH_TRACE_MEMUSE_INFO
5836 }
5837
5838 void
5839 tracepath_glDepthRangefOES(GLclampf zNear, GLclampf zFar)
5840 {
5841         _COREGL_TRACEPATH_FUNC_BEGIN();
5842         _orig_tracepath_glDepthRangefOES(zNear, zFar);
5843
5844         goto finish;
5845
5846 finish:
5847         _COREGL_TRACEPATH_FUNC_END();
5848 }
5849
5850 void
5851 tracepath_glDepthRangexOES(GLclampx zNear, GLclampx zFar)
5852 {
5853         _COREGL_TRACEPATH_FUNC_BEGIN();
5854         _orig_tracepath_glDepthRangexOES(zNear, zFar);
5855
5856         goto finish;
5857
5858 finish:
5859         _COREGL_TRACEPATH_FUNC_END();
5860 }
5861
5862 void
5863 tracepath_glFramebufferRenderbufferOES(GLenum target, GLenum attachment,
5864                                        GLenum renderbuffertarget, GLuint renderbuffer)
5865 {
5866         _COREGL_TRACEPATH_FUNC_BEGIN();
5867
5868 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
5869         tracepath_fbdump_update(0);
5870 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
5871
5872         _orig_tracepath_glFramebufferRenderbufferOES(target, attachment,
5873                         renderbuffertarget, renderbuffer);
5874
5875 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
5876         tracepath_fbdump_update(1);
5877 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
5878
5879         goto finish;
5880
5881 finish:
5882         _COREGL_TRACEPATH_FUNC_END();
5883 }
5884
5885 void
5886 tracepath_glFramebufferTexture2DOES(GLenum target, GLenum attachment,
5887                                     GLenum textarget, GLuint texture, GLint level)
5888 {
5889         _COREGL_TRACEPATH_FUNC_BEGIN();
5890
5891 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
5892         tracepath_fbdump_update(0);
5893 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
5894
5895         _orig_tracepath_glFramebufferTexture2DOES(target, attachment, textarget,
5896                         texture, level);
5897
5898 #ifdef COREGL_TRACEPATH_TRACE_SURFACE_INFO
5899         tracepath_fbdump_update(1);
5900 #endif // COREGL_TRACEPATH_TRACE_SURFACE_INFO
5901
5902         goto finish;
5903
5904 finish:
5905         _COREGL_TRACEPATH_FUNC_END();
5906 }
5907
5908 void
5909 tracepath_glGenFramebuffersOES(GLsizei n, GLuint *framebuffers)
5910 {
5911         _COREGL_TRACEPATH_FUNC_BEGIN();
5912         _orig_tracepath_glGenFramebuffersOES(n, framebuffers);
5913
5914         goto finish;
5915
5916 finish:
5917         _COREGL_TRACEPATH_FUNC_END();
5918 }
5919
5920 void
5921 tracepath_glGenRenderbuffersOES(GLsizei n, GLuint *renderbuffers)
5922 {
5923         _COREGL_TRACEPATH_FUNC_BEGIN();
5924         _orig_tracepath_glGenRenderbuffersOES(n, renderbuffers);
5925
5926         goto finish;
5927
5928 finish:
5929         _COREGL_TRACEPATH_FUNC_END();
5930 #ifdef COREGL_TRACEPATH_TRACE_MEMUSE_INFO
5931         if (trace_mem_flag == 1) {
5932                 MY_MODULE_TSTATE *tstate = NULL;
5933
5934                 GET_MY_TSTATE(tstate, get_current_thread_state());
5935                 AST(tstate != NULL);
5936                 if (tstate->ctx != NULL) {
5937                         for (int i = 0; i < n; i++) {
5938                                 if (renderbuffers[i] == 0) continue;
5939                                 _add_glbuf_object(tstate->ctx->sostate->glbuf_rb, renderbuffers[i],
5940                                                   "Renderbuffer", 0, 0, 0, "Unknown");
5941                         }
5942                 }
5943         }
5944 #endif // COREGL_TRACEPATH_TRACE_MEMUSE_INFO
5945 }
5946
5947 void
5948 tracepath_glGetFramebufferAttachmentParameterivOES(GLenum target,
5949                 GLenum attachment, GLenum pname, GLint *params)
5950 {
5951         _COREGL_TRACEPATH_FUNC_BEGIN();
5952         _orig_tracepath_glGetFramebufferAttachmentParameterivOES(target, attachment,
5953                         pname, params);
5954
5955         goto finish;
5956
5957 finish:
5958         _COREGL_TRACEPATH_FUNC_END();
5959 }
5960
5961 void
5962 tracepath_glGetQueryObjecti64vEXT(GLuint id, GLenum pname, GLint64 *params)
5963 {
5964         _COREGL_TRACEPATH_FUNC_BEGIN();
5965         _orig_tracepath_glGetQueryObjecti64vEXT(id, pname, params);
5966
5967         goto finish;
5968
5969 finish:
5970         _COREGL_TRACEPATH_FUNC_END();
5971 }
5972
5973 void
5974 tracepath_glGetQueryObjectivEXT(GLuint id, GLenum pname, GLint *params)
5975 {
5976         _COREGL_TRACEPATH_FUNC_BEGIN();
5977         _orig_tracepath_glGetQueryObjectivEXT(id, pname, params);
5978
5979         goto finish;
5980
5981 finish:
5982         _COREGL_TRACEPATH_FUNC_END();
5983 }
5984
5985 void
5986 tracepath_glGetQueryObjectui64vEXT(GLuint id, GLenum pname, GLuint64 *params)
5987 {
5988         _COREGL_TRACEPATH_FUNC_BEGIN();
5989         _orig_tracepath_glGetQueryObjectui64vEXT(id, pname, params);
5990
5991         goto finish;
5992
5993 finish:
5994         _COREGL_TRACEPATH_FUNC_END();
5995 }
5996
5997 void
5998 tracepath_glGetQueryObjectuivEXT(GLuint id, GLenum pname, GLuint *params)
5999 {
6000         _COREGL_TRACEPATH_FUNC_BEGIN();
6001         _orig_tracepath_glGetQueryObjectuivEXT(id, pname, params);
6002
6003         goto finish;
6004
6005 finish:
6006         _COREGL_TRACEPATH_FUNC_END();
6007 }
6008
6009 void
6010 tracepath_glGetQueryivEXT(GLenum target, GLenum pname, GLint *params)
6011 {
6012         _COREGL_TRACEPATH_FUNC_BEGIN();
6013         _orig_tracepath_glGetQueryivEXT(target, pname, params);
6014
6015         goto finish;
6016
6017 finish:
6018         _COREGL_TRACEPATH_FUNC_END();
6019 }
6020
6021 void
6022 tracepath_glBeginQueryEXT(GLenum target, GLuint id)
6023 {
6024         _COREGL_TRACEPATH_FUNC_BEGIN();
6025         _orig_tracepath_glBeginQueryEXT(target, id);
6026
6027         goto finish;
6028
6029 finish:
6030         _COREGL_TRACEPATH_FUNC_END();
6031 }
6032
6033
6034 void
6035 tracepath_glDeleteQueriesEXT(GLsizei n, const GLuint *ids)
6036 {
6037         _COREGL_TRACEPATH_FUNC_BEGIN();
6038         _orig_tracepath_glDeleteQueriesEXT(n, ids);
6039
6040         goto finish;
6041
6042 finish:
6043         _COREGL_TRACEPATH_FUNC_END();
6044 }
6045
6046 void
6047 tracepath_glGenQueriesEXT(GLsizei n, GLuint *ids)
6048 {
6049         _COREGL_TRACEPATH_FUNC_BEGIN();
6050         _orig_tracepath_glGenQueriesEXT(n, ids);
6051
6052         goto finish;
6053
6054 finish:
6055         _COREGL_TRACEPATH_FUNC_END();
6056 }
6057
6058 GLboolean
6059 tracepath_glIsFramebufferOES(GLuint framebuffer)
6060 {
6061         GLboolean ret = GL_FALSE;
6062
6063         _COREGL_TRACEPATH_FUNC_BEGIN();
6064         ret = _orig_tracepath_glIsFramebufferOES(framebuffer);
6065
6066         goto finish;
6067
6068 finish:
6069         _COREGL_TRACEPATH_FUNC_END();
6070         return ret;
6071 }
6072
6073 GLboolean
6074 tracepath_glIsQueryEXT(GLuint id)
6075 {
6076         GLboolean ret = GL_FALSE;
6077
6078         _COREGL_TRACEPATH_FUNC_BEGIN();
6079         ret = _orig_tracepath_glIsQueryEXT(id);
6080
6081         goto finish;
6082
6083 finish:
6084         _COREGL_TRACEPATH_FUNC_END();
6085         return ret;
6086 }
6087
6088 GLboolean
6089 tracepath_glIsRenderbufferOES(GLuint renderbuffer)
6090 {
6091         GLboolean ret;
6092         _COREGL_TRACEPATH_FUNC_BEGIN();
6093         ret = _orig_tracepath_glIsRenderbufferOES(renderbuffer);
6094
6095         goto finish;
6096
6097 finish:
6098         _COREGL_TRACEPATH_FUNC_END();
6099         return ret;
6100 }
6101
6102 void
6103 tracepath_glEndQueryEXT(GLenum target)
6104 {
6105         _COREGL_TRACEPATH_FUNC_BEGIN();
6106         _orig_tracepath_glEndQueryEXT(target);
6107
6108         goto finish;
6109
6110 finish:
6111         _COREGL_TRACEPATH_FUNC_END();
6112 }
6113
6114 void
6115 tracepath_glAlphaFuncxOES(GLenum func, GLclampx ref)
6116 {
6117         _COREGL_TRACEPATH_FUNC_BEGIN();
6118         _orig_tracepath_glAlphaFuncxOES(func, ref);
6119         goto finish;
6120
6121 finish:
6122         _COREGL_TRACEPATH_FUNC_END();
6123 }
6124
6125 void tracepath_glBlendBarrierKHR()
6126 {
6127         _COREGL_TRACEPATH_FUNC_BEGIN();
6128         _orig_tracepath_glBlendBarrierKHR();
6129
6130         goto finish;
6131
6132 finish:
6133         _COREGL_TRACEPATH_FUNC_END();
6134 }
6135
6136 void tracepath_glBlendEquationOES(GLenum mode)
6137 {
6138         _COREGL_TRACEPATH_FUNC_BEGIN();
6139         _orig_tracepath_glBlendEquationOES(mode);
6140
6141         goto finish;
6142
6143 finish:
6144         _COREGL_TRACEPATH_FUNC_END();
6145 }
6146
6147 void tracepath_glBlendEquationSeparateOES(GLenum modeRGB, GLenum modeAlpha)
6148 {
6149         _COREGL_TRACEPATH_FUNC_BEGIN();
6150         _orig_tracepath_glBlendEquationSeparateOES(modeRGB, modeAlpha);
6151
6152         goto finish;
6153
6154 finish:
6155         _COREGL_TRACEPATH_FUNC_END();
6156 }
6157
6158 void tracepath_glBlendFuncSeparateOES(GLenum srcRGB, GLenum dstRGB,
6159                                       GLenum srcAlpha, GLenum dstAlpha)
6160 {
6161         _COREGL_TRACEPATH_FUNC_BEGIN();
6162         _orig_tracepath_glBlendFuncSeparateOES(srcRGB, dstRGB, srcAlpha, dstAlpha);
6163
6164         goto finish;
6165
6166 finish:
6167         _COREGL_TRACEPATH_FUNC_END();
6168 }
6169
6170 GLenum tracepath_glCheckFramebufferStatusOES(GLenum target)
6171 {
6172         GLenum ret = _COREGL_INT_INIT_VALUE;
6173
6174         _COREGL_TRACEPATH_FUNC_BEGIN();
6175         ret = _orig_tracepath_glCheckFramebufferStatusOES(target);
6176
6177         goto finish;
6178
6179 finish:
6180         _COREGL_TRACEPATH_FUNC_END();
6181         return ret;
6182 }
6183
6184
6185 void tracepath_glClearColorxOES(GLclampx red, GLclampx green, GLclampx blue,
6186                                 GLclampx alpha)
6187 {
6188         _COREGL_TRACEPATH_FUNC_BEGIN();
6189         _orig_tracepath_glClearColorxOES(red, green, blue, alpha);
6190
6191         goto finish;
6192
6193 finish:
6194         _COREGL_TRACEPATH_FUNC_END();
6195 }
6196
6197 void tracepath_glClearDepthfOES(GLclampf depth)
6198 {
6199         _COREGL_TRACEPATH_FUNC_BEGIN();
6200         _orig_tracepath_glClearDepthfOES(depth);
6201
6202         goto finish;
6203
6204 finish:
6205         _COREGL_TRACEPATH_FUNC_END();
6206 }
6207
6208 void tracepath_glClearDepthxOES(GLclampx depth)
6209 {
6210         _COREGL_TRACEPATH_FUNC_BEGIN();
6211         _orig_tracepath_glClearDepthxOES(depth);
6212
6213         goto finish;
6214
6215 finish:
6216         _COREGL_TRACEPATH_FUNC_END();
6217 }
6218
6219 void tracepath_glClipPlanefOES(GLenum plane, GLfloat const *equation)
6220 {
6221         _COREGL_TRACEPATH_FUNC_BEGIN();
6222         _orig_tracepath_glClipPlanefOES(plane, equation);
6223
6224         goto finish;
6225
6226 finish:
6227         _COREGL_TRACEPATH_FUNC_END();
6228 }
6229
6230
6231 void tracepath_glClipPlanexOES(GLenum plane, GLfixed const *equation)
6232 {
6233         _COREGL_TRACEPATH_FUNC_BEGIN();
6234         _orig_tracepath_glClipPlanexOES(plane, equation);
6235
6236         goto finish;
6237
6238 finish:
6239         _COREGL_TRACEPATH_FUNC_END();
6240 }
6241
6242 void tracepath_glColor4xOES(GLfixed red, GLfixed green, GLfixed blue,
6243                             GLfixed alpha)
6244 {
6245         _COREGL_TRACEPATH_FUNC_BEGIN();
6246         _orig_tracepath_glColor4xOES(red, green, blue, alpha);
6247
6248         goto finish;
6249
6250 finish:
6251         _COREGL_TRACEPATH_FUNC_END();
6252 }
6253
6254 void tracepath_glDebugMessageCallback(GLDEBUGPROCKHR callback,
6255                                       void const *userParam)
6256 {
6257         _COREGL_TRACEPATH_FUNC_BEGIN();
6258         _orig_tracepath_glDebugMessageCallback(callback, userParam);
6259
6260         goto finish;
6261
6262 finish:
6263         _COREGL_TRACEPATH_FUNC_END();
6264 }
6265
6266 void tracepath_glDebugMessageInsert(GLenum source, GLenum type, GLuint id,
6267                                     GLenum severity, GLsizei length, GLchar const *buf)
6268 {
6269         _COREGL_TRACEPATH_FUNC_BEGIN();
6270         _orig_tracepath_glDebugMessageInsert(source, type, id, severity, length, buf);
6271
6272         goto finish;
6273
6274 finish:
6275         _COREGL_TRACEPATH_FUNC_END();
6276 }
6277
6278 void tracepath_glDebugMessageControl(GLenum source, GLenum type,
6279                                      GLenum severity, GLsizei count, GLuint const *ids, GLboolean enabled)
6280 {
6281         _COREGL_TRACEPATH_FUNC_BEGIN();
6282         _orig_tracepath_glDebugMessageControl(source, type, severity, count, ids,
6283                                               enabled);
6284
6285         goto finish;
6286
6287 finish:
6288         _COREGL_TRACEPATH_FUNC_END();
6289 }
6290
6291 void tracepath_glFogxOES(GLenum pname, GLfixed param)
6292 {
6293         _COREGL_TRACEPATH_FUNC_BEGIN();
6294         _orig_tracepath_glFogxOES(pname, param);
6295
6296         goto finish;
6297
6298 finish:
6299         _COREGL_TRACEPATH_FUNC_END();
6300 }
6301
6302 void tracepath_glFogxvOES(GLenum pname, GLfixed const *params)
6303 {
6304         _COREGL_TRACEPATH_FUNC_BEGIN();
6305         _orig_tracepath_glFogxvOES(pname, params);
6306
6307         goto finish;
6308
6309 finish:
6310         _COREGL_TRACEPATH_FUNC_END();
6311 }
6312
6313 void tracepath_glFrustumxOES(GLfixed left, GLfixed right, GLfixed bottom,
6314                              GLfixed top, GLfixed zNear, GLfixed zFar)
6315 {
6316         _COREGL_TRACEPATH_FUNC_BEGIN();
6317         _orig_tracepath_glFrustumxOES(left, right, bottom, top, zNear, zFar);
6318
6319         goto finish;
6320
6321 finish:
6322         _COREGL_TRACEPATH_FUNC_END();
6323 }
6324
6325 void tracepath_glFrustumfOES(GLfloat left, GLfloat right, GLfloat bottom,
6326                              GLfloat top, GLfloat zNear, GLfloat zFar)
6327 {
6328         _COREGL_TRACEPATH_FUNC_BEGIN();
6329         _orig_tracepath_glFrustumfOES(left, right, bottom, top, zNear, zFar);
6330
6331         goto finish;
6332
6333 finish:
6334         _COREGL_TRACEPATH_FUNC_END();
6335 }
6336
6337 void tracepath_glGenerateMipmapOES(GLenum target)
6338 {
6339         _COREGL_TRACEPATH_FUNC_BEGIN();
6340         _orig_tracepath_glGenerateMipmapOES(target);
6341
6342         goto finish;
6343
6344 finish:
6345         _COREGL_TRACEPATH_FUNC_END();
6346 }
6347
6348 void tracepath_glGetClipPlanefOES(GLenum pname, GLfloat eqn[4])
6349 {
6350         _COREGL_TRACEPATH_FUNC_BEGIN();
6351         _orig_tracepath_glGetClipPlanefOES(pname, eqn);
6352
6353         goto finish;
6354
6355 finish:
6356         _COREGL_TRACEPATH_FUNC_END();
6357 }
6358
6359 void tracepath_glGetClipPlanexOES(GLenum pname, GLfixed eqn[4])
6360 {
6361         _COREGL_TRACEPATH_FUNC_BEGIN();
6362         _orig_tracepath_glGetClipPlanexOES(pname, eqn);
6363
6364         goto finish;
6365
6366 finish:
6367         _COREGL_TRACEPATH_FUNC_END();
6368 }
6369
6370 GLuint tracepath_glGetDebugMessageLog(GLuint count, GLsizei bufsize,
6371                                       GLenum *sources, GLenum *types, GLuint *ids, GLenum *severities,
6372                                       GLsizei *lengths, GLchar *messageLog)
6373 {
6374         GLuint ret = GL_INVALID_INDEX;
6375         _COREGL_TRACEPATH_FUNC_BEGIN();
6376         ret =  _orig_tracepath_glGetDebugMessageLog(count, bufsize, sources, types, ids,
6377                         severities, lengths, messageLog);
6378         goto finish;
6379
6380 finish:
6381         _COREGL_TRACEPATH_FUNC_END();
6382         return ret;
6383 }
6384
6385 void tracepath_glGetFixedvOES(GLenum pname, GLfixed *params)
6386 {
6387         _COREGL_TRACEPATH_FUNC_BEGIN();
6388         _orig_tracepath_glGetFixedvOES(pname, params);
6389
6390         goto finish;
6391
6392 finish:
6393         _COREGL_TRACEPATH_FUNC_END();
6394 }
6395
6396 void tracepath_glGetLightxvOES(GLenum light, GLenum pname, GLfixed *params)
6397 {
6398         _COREGL_TRACEPATH_FUNC_BEGIN();
6399         _orig_tracepath_glGetLightxvOES(light, pname, params);
6400
6401         goto finish;
6402
6403 finish:
6404         _COREGL_TRACEPATH_FUNC_END();
6405 }
6406
6407 void tracepath_glGetMaterialxvOES(GLenum face, GLenum pname, GLfixed *params)
6408 {
6409         _COREGL_TRACEPATH_FUNC_BEGIN();
6410         _orig_tracepath_glGetMaterialxvOES(face, pname, params);
6411
6412         goto finish;
6413
6414 finish:
6415         _COREGL_TRACEPATH_FUNC_END();
6416 }
6417
6418 void tracepath_glGetObjectLabel(GLenum identifier, GLuint name, GLsizei bufSize,
6419                                 GLsizei *length, GLchar *label)
6420 {
6421         _COREGL_TRACEPATH_FUNC_BEGIN();
6422         _orig_tracepath_glGetObjectLabel(identifier, name, bufSize, length, label);
6423
6424         goto finish;
6425
6426 finish:
6427         _COREGL_TRACEPATH_FUNC_END();
6428 }
6429
6430 void tracepath_glGetObjectPtrLabel(void const *ptr, GLsizei bufSize,
6431                                    GLsizei *length, GLchar *label)
6432 {
6433         _COREGL_TRACEPATH_FUNC_BEGIN();
6434         _orig_tracepath_glGetObjectPtrLabel(ptr, bufSize, length, label);
6435
6436         goto finish;
6437
6438 finish:
6439         _COREGL_TRACEPATH_FUNC_END();
6440 }
6441
6442 void tracepath_glGetPointervKHR(GLenum pname, GLvoid **params)
6443 {
6444         _COREGL_TRACEPATH_FUNC_BEGIN();
6445         _orig_tracepath_glGetPointervKHR(pname, params);
6446
6447         goto finish;
6448
6449 finish:
6450         _COREGL_TRACEPATH_FUNC_END();
6451 }
6452
6453 void tracepath_glGetRenderbufferParameterivOES(GLenum target, GLenum pname,
6454                 GLint *params)
6455 {
6456         _COREGL_TRACEPATH_FUNC_BEGIN();
6457         _orig_tracepath_glGetRenderbufferParameterivOES(target, pname, params);
6458
6459         goto finish;
6460
6461 finish:
6462         _COREGL_TRACEPATH_FUNC_END();
6463 }
6464
6465 void tracepath_glGetTexEnvxvOES(GLenum env, GLenum pname, GLfixed *params)
6466 {
6467         _COREGL_TRACEPATH_FUNC_BEGIN();
6468         _orig_tracepath_glGetTexEnvxvOES(env, pname, params);
6469
6470         goto finish;
6471
6472 finish:
6473         _COREGL_TRACEPATH_FUNC_END();
6474 }
6475
6476 void tracepath_glGetTexParameterxvOES(GLenum target, GLenum pname,
6477                                       GLfixed *params)
6478 {
6479         _COREGL_TRACEPATH_FUNC_BEGIN();
6480         _orig_tracepath_glGetTexParameterxvOES(target, pname, params);
6481
6482         goto finish;
6483
6484 finish:
6485         _COREGL_TRACEPATH_FUNC_END();
6486 }
6487
6488
6489 void
6490 tracepath_glLightModelxOES (GLenum pname, GLfixed param)
6491 {
6492         _COREGL_TRACEPATH_FUNC_BEGIN();
6493         _orig_tracepath_glLightModelxOES (pname, param);
6494
6495         goto finish;
6496
6497 finish:
6498         _COREGL_TRACEPATH_FUNC_END();
6499 }
6500
6501
6502 void
6503 tracepath_glLightModelxvOES (GLenum pname, const GLfixed *params)
6504 {
6505         _COREGL_TRACEPATH_FUNC_BEGIN();
6506         _orig_tracepath_glLightModelxvOES (pname, params);
6507
6508         goto finish;
6509
6510 finish:
6511         _COREGL_TRACEPATH_FUNC_END();
6512 }
6513
6514
6515 void
6516 tracepath_glLightxOES (GLenum light, GLenum pname, GLfixed param)
6517 {
6518         _COREGL_TRACEPATH_FUNC_BEGIN();
6519         _orig_tracepath_glLightxOES (light, pname, param);
6520
6521         goto finish;
6522
6523 finish:
6524         _COREGL_TRACEPATH_FUNC_END();
6525 }
6526
6527
6528 void
6529 tracepath_glLightxvOES (GLenum light, GLenum pname, const GLfixed *params)
6530 {
6531         _COREGL_TRACEPATH_FUNC_BEGIN();
6532         _orig_tracepath_glLightxvOES (light, pname, params);
6533
6534         goto finish;
6535
6536 finish:
6537         _COREGL_TRACEPATH_FUNC_END();
6538 }
6539
6540 void
6541 tracepath_glLineWidthxOES (GLfixed width)
6542 {
6543         _COREGL_TRACEPATH_FUNC_BEGIN();
6544         _orig_tracepath_glLineWidthxOES (width);
6545
6546         goto finish;
6547
6548 finish:
6549         _COREGL_TRACEPATH_FUNC_END();
6550 }
6551
6552 void
6553 tracepath_glLoadMatrixxOES (const GLfixed *m)
6554 {
6555         _COREGL_TRACEPATH_FUNC_BEGIN();
6556         _orig_tracepath_glLoadMatrixxOES (m);
6557         goto finish;
6558
6559 finish:
6560         _COREGL_TRACEPATH_FUNC_END();
6561 }
6562
6563 void
6564 tracepath_glMaterialxOES (GLenum face, GLenum pname, GLfixed param)
6565 {
6566         _COREGL_TRACEPATH_FUNC_BEGIN();
6567         _orig_tracepath_glMaterialxOES (face, pname, param);
6568
6569         goto finish;
6570
6571 finish:
6572         _COREGL_TRACEPATH_FUNC_END();
6573 }
6574
6575 void
6576 tracepath_glMaterialxvOES (GLenum face, GLenum pname, const GLfixed *params)
6577 {
6578         _COREGL_TRACEPATH_FUNC_BEGIN();
6579         _orig_tracepath_glMaterialxvOES (face, pname, params);
6580
6581         goto finish;
6582
6583 finish:
6584         _COREGL_TRACEPATH_FUNC_END();
6585 }
6586
6587 void
6588 tracepath_glMultMatrixxOES (const GLfixed *m)
6589 {
6590         _COREGL_TRACEPATH_FUNC_BEGIN();
6591         _orig_tracepath_glMultMatrixxOES (m);
6592
6593         goto finish;
6594
6595 finish:
6596         _COREGL_TRACEPATH_FUNC_END();
6597 }
6598
6599 void
6600 tracepath_glMultiTexCoord4bOES (GLenum target, GLbyte s, GLbyte t, GLbyte r,
6601                                 GLbyte q)
6602 {
6603         _COREGL_TRACEPATH_FUNC_BEGIN();
6604         _orig_tracepath_glMultiTexCoord4bOES (target, s, t, r, q);
6605
6606         goto finish;
6607
6608 finish:
6609         _COREGL_TRACEPATH_FUNC_END();
6610 }
6611
6612 void
6613 tracepath_glMultiTexCoord4xOES (GLenum target, GLfixed s, GLfixed t, GLfixed r,
6614                                 GLfixed q)
6615 {
6616         _COREGL_TRACEPATH_FUNC_BEGIN();
6617         _orig_tracepath_glMultiTexCoord4xOES (target, s, t, r, q);
6618
6619         goto finish;
6620
6621 finish:
6622         _COREGL_TRACEPATH_FUNC_END();
6623 }
6624
6625 void
6626 tracepath_glNormal3xOES (GLfixed nx, GLfixed ny, GLfixed nz)
6627 {
6628         _COREGL_TRACEPATH_FUNC_BEGIN();
6629         _orig_tracepath_glNormal3xOES (nx, ny, nz);
6630
6631         goto finish;
6632
6633 finish:
6634         _COREGL_TRACEPATH_FUNC_END();
6635 }
6636
6637 void
6638 tracepath_glObjectLabel (GLenum identifier, GLuint name, GLsizei length,
6639                          const GLchar *label)
6640 {
6641         _COREGL_TRACEPATH_FUNC_BEGIN();
6642         _orig_tracepath_glObjectLabel (identifier, name, length, label);
6643         goto finish;
6644
6645 finish:
6646         _COREGL_TRACEPATH_FUNC_END();
6647 }
6648
6649 void
6650 tracepath_glObjectPtrLabel (const void *ptr, GLsizei length,
6651                             const GLchar *label)
6652 {
6653         _COREGL_TRACEPATH_FUNC_BEGIN();
6654         _orig_tracepath_glObjectPtrLabel (ptr, length, label);
6655
6656         goto finish;
6657
6658 finish:
6659         _COREGL_TRACEPATH_FUNC_END();
6660 }
6661
6662 void
6663 tracepath_glOrthofOES (GLfloat left, GLfloat right, GLfloat bottom, GLfloat top,
6664                        GLfloat zNear, GLfloat zFar)
6665 {
6666         _COREGL_TRACEPATH_FUNC_BEGIN();
6667         _orig_tracepath_glOrthofOES (left, right, bottom, top, zNear, zFar);
6668
6669         goto finish;
6670
6671 finish:
6672         _COREGL_TRACEPATH_FUNC_END();
6673 }
6674
6675 void
6676 tracepath_glOrthoxOES (GLfixed left, GLfixed right, GLfixed bottom, GLfixed top,
6677                        GLfixed zNear, GLfixed zFar)
6678 {
6679         _COREGL_TRACEPATH_FUNC_BEGIN();
6680         _orig_tracepath_glOrthoxOES (left, right, bottom, top, zNear, zFar);
6681
6682         goto finish;
6683
6684 finish:
6685         _COREGL_TRACEPATH_FUNC_END();
6686 }
6687
6688 void
6689 tracepath_glPointParameterxOES (GLenum pname, GLfixed param)
6690 {
6691         _COREGL_TRACEPATH_FUNC_BEGIN();
6692         _orig_tracepath_glPointParameterxOES (pname, param);
6693
6694         goto finish;
6695
6696 finish:
6697         _COREGL_TRACEPATH_FUNC_END();
6698 }
6699
6700 void
6701 tracepath_glPointParameterxvOES (GLenum pname, const GLfixed *params)
6702 {
6703         _COREGL_TRACEPATH_FUNC_BEGIN();
6704         _orig_tracepath_glPointParameterxvOES (pname, params);
6705
6706         goto finish;
6707
6708 finish:
6709         _COREGL_TRACEPATH_FUNC_END();
6710 }
6711
6712 void
6713 tracepath_glPointSizexOES (GLfixed size)
6714 {
6715         _COREGL_TRACEPATH_FUNC_BEGIN();
6716         _orig_tracepath_glPointSizexOES (size);
6717
6718         goto finish;
6719
6720 finish:
6721         _COREGL_TRACEPATH_FUNC_END();
6722 }
6723
6724 void
6725 tracepath_glPolygonOffsetxOES (GLfixed factor, GLfixed units)
6726 {
6727         _COREGL_TRACEPATH_FUNC_BEGIN();
6728         _orig_tracepath_glPolygonOffsetxOES (factor, units);
6729
6730         goto finish;
6731
6732 finish:
6733         _COREGL_TRACEPATH_FUNC_END();
6734 }
6735
6736 void
6737 tracepath_glPopDebugGroup (void)
6738 {
6739         _COREGL_TRACEPATH_FUNC_BEGIN();
6740         _orig_tracepath_glPopDebugGroup ();
6741
6742         goto finish;
6743
6744 finish:
6745         _COREGL_TRACEPATH_FUNC_END();
6746 }
6747
6748 void
6749 tracepath_glPushDebugGroup (GLenum source, GLuint id, GLsizei length,
6750                             const GLchar *message)
6751 {
6752         _COREGL_TRACEPATH_FUNC_BEGIN();
6753         _orig_tracepath_glPushDebugGroup (source, id, length, message);
6754
6755         goto finish;
6756
6757 finish:
6758         _COREGL_TRACEPATH_FUNC_END();
6759 }
6760
6761 void
6762 tracepath_glQueryCounterEXT (GLuint id, GLenum target)
6763 {
6764         _COREGL_TRACEPATH_FUNC_BEGIN();
6765         _orig_tracepath_glQueryCounterEXT (id, target);
6766
6767         goto finish;
6768
6769 finish:
6770         _COREGL_TRACEPATH_FUNC_END();
6771 }
6772
6773 void
6774 tracepath_glRenderbufferStorageOES (GLenum target, GLenum internalformat,
6775                                     GLsizei width, GLsizei height)
6776 {
6777         _COREGL_TRACEPATH_FUNC_BEGIN();
6778         _orig_tracepath_glRenderbufferStorageOES (target, internalformat, width,
6779                         height);
6780
6781         goto finish;
6782
6783 finish:
6784         _COREGL_TRACEPATH_FUNC_END();
6785 }
6786
6787 void
6788 tracepath_glRotatexOES (GLfixed angle, GLfixed x, GLfixed y, GLfixed z)
6789 {
6790         _COREGL_TRACEPATH_FUNC_BEGIN();
6791         _orig_tracepath_glRotatexOES (angle, x, y, z);
6792
6793         goto finish;
6794
6795 finish:
6796         _COREGL_TRACEPATH_FUNC_END();
6797 }
6798
6799 void
6800 tracepath_glSampleCoveragexOES (GLclampx value, GLboolean invert)
6801 {
6802         _COREGL_TRACEPATH_FUNC_BEGIN();
6803         _orig_tracepath_glSampleCoveragexOES (value, invert);
6804
6805         goto finish;
6806
6807 finish:
6808         _COREGL_TRACEPATH_FUNC_END();
6809 }
6810
6811 void
6812 tracepath_glScalexOES (GLfixed x, GLfixed y, GLfixed z)
6813 {
6814         _COREGL_TRACEPATH_FUNC_BEGIN();
6815         _orig_tracepath_glScalexOES (x, y, z);
6816
6817         goto finish;
6818
6819 finish:
6820         _COREGL_TRACEPATH_FUNC_END();
6821 }
6822
6823 void
6824 tracepath_glTexEnvxOES (GLenum target, GLenum pname, GLfixed param)
6825 {
6826         _COREGL_TRACEPATH_FUNC_BEGIN();
6827         _orig_tracepath_glTexEnvxOES (target, pname, param);
6828
6829         goto finish;
6830
6831 finish:
6832         _COREGL_TRACEPATH_FUNC_END();
6833 }
6834
6835 void
6836 tracepath_glTexEnvxvOES (GLenum target, GLenum pname, const GLfixed *params)
6837 {
6838         _COREGL_TRACEPATH_FUNC_BEGIN();
6839         _orig_tracepath_glTexEnvxvOES (target, pname, params);
6840
6841         goto finish;
6842
6843 finish:
6844         _COREGL_TRACEPATH_FUNC_END();
6845 }
6846
6847 void
6848 tracepath_glTexParameterxOES (GLenum target, GLenum pname, GLfixed param)
6849 {
6850         _COREGL_TRACEPATH_FUNC_BEGIN();
6851         _orig_tracepath_glTexParameterxOES (target, pname, param);
6852
6853         goto finish;
6854
6855 finish:
6856         _COREGL_TRACEPATH_FUNC_END();
6857 }
6858
6859 void
6860 tracepath_glTexParameterxvOES (GLenum target, GLenum pname,
6861                                const GLfixed *params)
6862 {
6863         _COREGL_TRACEPATH_FUNC_BEGIN();
6864         _orig_tracepath_glTexParameterxvOES (target, pname, params);
6865
6866         goto finish;
6867
6868 finish:
6869         _COREGL_TRACEPATH_FUNC_END();
6870 }
6871
6872 void
6873 tracepath_glTexStorage2DEXT (GLenum target, GLsizei levels,
6874                              GLenum internalformat, GLsizei width, GLsizei height)
6875 {
6876         _COREGL_TRACEPATH_FUNC_BEGIN();
6877         _orig_tracepath_glTexStorage2DEXT (target, levels, internalformat, width,
6878                                            height);
6879
6880         goto finish;
6881
6882 finish:
6883         _COREGL_TRACEPATH_FUNC_END();
6884 }
6885
6886 void
6887 tracepath_glTexStorage3DEXT (GLenum target, GLsizei levels,
6888                              GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth)
6889 {
6890         _COREGL_TRACEPATH_FUNC_BEGIN();
6891         _orig_tracepath_glTexStorage3DEXT (target, levels, internalformat, width,
6892                                            height, depth);
6893
6894         goto finish;
6895
6896 finish:
6897         _COREGL_TRACEPATH_FUNC_END();
6898 }
6899
6900 void
6901 tracepath_glTexStorage3DMultisampleOES (GLenum target, GLsizei samples,
6902                                         GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth,
6903                                         GLboolean fixedsamplelocations)
6904 {
6905         _COREGL_TRACEPATH_FUNC_BEGIN();
6906         _orig_tracepath_glTexStorage3DMultisampleOES (target, samples, internalformat,
6907                         width, height, depth, fixedsamplelocations);
6908
6909         goto finish;
6910
6911 finish:
6912         _COREGL_TRACEPATH_FUNC_END();
6913 }
6914
6915 void
6916 tracepath_glTranslatexOES (GLfixed x, GLfixed y, GLfixed z)
6917 {
6918         _COREGL_TRACEPATH_FUNC_BEGIN();
6919         _orig_tracepath_glTranslatexOES (x, y, z);
6920
6921         goto finish;
6922
6923 finish:
6924         _COREGL_TRACEPATH_FUNC_END();
6925 }
6926
6927 void
6928 tracepath_glBindVertexArrayOES(GLuint array)
6929 {
6930         _COREGL_TRACEPATH_FUNC_BEGIN();
6931         _orig_tracepath_glBindVertexArrayOES(array);
6932
6933         goto finish;
6934
6935 finish:
6936         _COREGL_TRACEPATH_FUNC_END();
6937 }
6938
6939 void
6940 tracepath_glDeleteVertexArraysOES(GLsizei n, const GLuint *arrays)
6941 {
6942         _COREGL_TRACEPATH_FUNC_BEGIN();
6943         _orig_tracepath_glDeleteVertexArraysOES(n, arrays);
6944
6945         goto finish;
6946
6947 finish:
6948         _COREGL_TRACEPATH_FUNC_END();
6949 }
6950
6951 void
6952 tracepath_glGenVertexArraysOES(GLsizei n, GLuint *arrays)
6953 {
6954         _COREGL_TRACEPATH_FUNC_BEGIN();
6955         _orig_tracepath_glGenVertexArraysOES(n, arrays);
6956
6957         goto finish;
6958
6959 finish:
6960         _COREGL_TRACEPATH_FUNC_END();
6961 }
6962
6963 GLboolean
6964 tracepath_glIsVertexArrayOES(GLuint array)
6965 {
6966         GLboolean ret = GL_FALSE;
6967
6968         _COREGL_TRACEPATH_FUNC_BEGIN();
6969         ret = _orig_tracepath_glIsVertexArrayOES(array);
6970
6971         goto finish;
6972
6973 finish:
6974         _COREGL_TRACEPATH_FUNC_END();
6975         return ret;
6976 }
6977
6978 void tracepath_glDebugMessageCallbackKHR(GLDEBUGPROCKHR callback,
6979                 void const *userParam)
6980 {
6981         _COREGL_TRACEPATH_FUNC_BEGIN();
6982         _orig_tracepath_glDebugMessageCallbackKHR(callback, userParam);
6983
6984         goto finish;
6985
6986 finish:
6987         _COREGL_TRACEPATH_FUNC_END();
6988 }
6989
6990
6991 void tracepath_glDebugMessageControlKHR(GLenum source, GLenum type,
6992                                         GLenum severity, GLsizei count, GLuint const *ids, GLboolean enabled)
6993 {
6994         _COREGL_TRACEPATH_FUNC_BEGIN();
6995         _orig_tracepath_glDebugMessageControlKHR(source, type, severity, count, ids,
6996                         enabled);
6997
6998         goto finish;
6999
7000 finish:
7001         _COREGL_TRACEPATH_FUNC_END();
7002 }
7003
7004 void tracepath_glDebugMessageInsertKHR(GLenum source, GLenum type, GLuint id,
7005                                        GLenum severity, GLsizei length, GLchar const *buf)
7006 {
7007         _COREGL_TRACEPATH_FUNC_BEGIN();
7008         _orig_tracepath_glDebugMessageInsertKHR(source, type, id, severity, length,
7009                                                 buf);
7010
7011         goto finish;
7012
7013 finish:
7014         _COREGL_TRACEPATH_FUNC_END();
7015 }
7016
7017 GLuint tracepath_glGetDebugMessageLogKHR(GLuint count, GLsizei bufsize,
7018                 GLenum *sources, GLenum *types, GLuint *ids, GLenum *severities,
7019                 GLsizei *lengths, GLchar *messageLog)
7020 {
7021         GLuint ret = GL_INVALID_INDEX;
7022         _COREGL_TRACEPATH_FUNC_BEGIN();
7023         ret =  _orig_tracepath_glGetDebugMessageLogKHR(count, bufsize, sources, types,
7024                         ids, severities, lengths, messageLog);
7025         goto finish;
7026
7027 finish:
7028         _COREGL_TRACEPATH_FUNC_END();
7029         return ret;
7030 }
7031
7032 void tracepath_glGetObjectLabelKHR(GLenum identifier, GLuint name,
7033                                    GLsizei bufSize, GLsizei *length, GLchar *label)
7034 {
7035         _COREGL_TRACEPATH_FUNC_BEGIN();
7036         _orig_tracepath_glGetObjectLabelKHR(identifier, name, bufSize, length, label);
7037
7038         goto finish;
7039
7040 finish:
7041         _COREGL_TRACEPATH_FUNC_END();
7042 }
7043
7044 void tracepath_glGetObjectPtrLabelKHR(void const *ptr, GLsizei bufSize,
7045                                       GLsizei *length, GLchar *label)
7046 {
7047         _COREGL_TRACEPATH_FUNC_BEGIN();
7048         _orig_tracepath_glGetObjectPtrLabelKHR(ptr, bufSize, length, label);
7049
7050         goto finish;
7051
7052 finish:
7053         _COREGL_TRACEPATH_FUNC_END();
7054 }
7055
7056 void
7057 tracepath_glGetPointerv(GLenum pname, GLvoid **params)
7058 {
7059         _COREGL_TRACEPATH_FUNC_BEGIN();
7060         _orig_tracepath_glGetPointerv(pname, params);
7061
7062         goto finish;
7063
7064 finish:
7065         _COREGL_TRACEPATH_FUNC_END();
7066 }
7067
7068 void
7069 tracepath_glObjectLabelKHR (GLenum identifier, GLuint name, GLsizei length,
7070                             const GLchar *label)
7071 {
7072         _COREGL_TRACEPATH_FUNC_BEGIN();
7073         _orig_tracepath_glObjectLabelKHR (identifier, name, length, label);
7074         goto finish;
7075
7076 finish:
7077         _COREGL_TRACEPATH_FUNC_END();
7078 }
7079
7080 void
7081 tracepath_glObjectPtrLabelKHR (const void *ptr, GLsizei length,
7082                                const GLchar *label)
7083 {
7084         _COREGL_TRACEPATH_FUNC_BEGIN();
7085         _orig_tracepath_glObjectPtrLabelKHR (ptr, length, label);
7086
7087         goto finish;
7088
7089 finish:
7090         _COREGL_TRACEPATH_FUNC_END();
7091 }
7092
7093 void
7094 tracepath_glPopDebugGroupKHR (void)
7095 {
7096         _COREGL_TRACEPATH_FUNC_BEGIN();
7097         _orig_tracepath_glPopDebugGroupKHR ();
7098
7099         goto finish;
7100
7101 finish:
7102         _COREGL_TRACEPATH_FUNC_END();
7103 }
7104
7105 void
7106 tracepath_glPushDebugGroupKHR (GLenum source, GLuint id, GLsizei length,
7107                                const GLchar *message)
7108 {
7109         _COREGL_TRACEPATH_FUNC_BEGIN();
7110         _orig_tracepath_glPushDebugGroupKHR (source, id, length, message);
7111
7112         goto finish;
7113
7114 finish:
7115         _COREGL_TRACEPATH_FUNC_END();
7116 }
7117