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