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