src/modules/tracepath/coregl_tracepath_gl.c

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