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