trim: Never trim any glBindTexture calls.

[apitrace] / cli / cli_trim.cpp

diff --git a/cli/cli_trim.cpp b/cli/cli_trim.cpp
index 45934e0b166840b29653d0460177ad8f292cf75b..f7bc92bacaee63d9fb7fea32e3e8a4bb1e03f54b 100644 (file)
--- a/cli/cli_trim.cpp
+++ b/cli/cli_trim.cpp
@@ -173,6 +173,7 @@ class TraceAnalyzer {
     bool transformFeedbackActive;
     bool framebufferObjectActive;
     bool insideBeginEnd;
+    GLuint insideNewEndList;
     GLuint activeProgram;
     GLenum activeTextureUnit;
 
@@ -345,6 +346,12 @@ class TraceAnalyzer {
             }
             return;
         }
+
+        if (strcmp(name, "glNewList") == 0) {
+            GLuint list = call->arg(0).toUInt();
+
+            insideNewEndList = list;
+        }
     }
 
     void stateTrackPostCall(trace::Call *call) {
@@ -371,12 +378,41 @@ class TraceAnalyzer {
             resources.erase("framebuffer");
             return;
         }
+
+        if (strcmp(name, "glEndList") == 0) {
+            insideNewEndList = 0;
+        }
     }
 
     void recordSideEffects(trace::Call *call) {
 
         const char *name = call->name();
 
+        /* Handle display lists before any other processing. */
+
+        /* FIXME: If we encode the list of commands that are executed
+         * immediately (as opposed to those that are compiled into a
+         * display list) then we could generate a "display-list-X"
+         * resource just as we do for "texture-X" resources and only
+         * emit it in the trace if a glCallList(X) is emitted. For
+         * now, simply punt and include anything within glNewList and
+         * glEndList in the trim output. This guarantees that display
+         * lists will work, but does not trim out unused display
+         * lists. */
+        if (insideNewEndList != 0) {
+            provide("state", call->no);
+
+            /* Also, any texture bound inside a display list is
+             * conservatively considered required. */
+            if (strcmp(name, "glBindTexture") == 0) {
+                GLuint texture = call->arg(1).toUInt();
+
+                linkf("state", "texture-", texture);
+            }
+
+            return;
+        }
+
         /* If call is flagged as no side effects, then we are done here. */
         if (call->flags & trace::CALL_FLAG_NO_SIDE_EFFECTS) {
             return;
@@ -420,6 +456,20 @@ class TraceAnalyzer {
             unlinkAll(ss_target.str());
             link(ss_target.str(), ss_texture.str());
 
+            /* FIXME: This really shouldn't be necessary. The effect
+             * this provide() has is that all glBindTexture calls will
+             * be preserved in the output trace (never trimmed). Carl
+             * has a trace ("btr") where a glBindTexture call should
+             * not be necessary at all, (it's immediately followed
+             * with a glBindTexture to a different texture and no
+             * intervening texture-related calls), yet this 'provide'
+             * makes the difference between a trim_stress test failing
+             * and passing.
+             *
+             * More investigation is necessary, but for now, be
+             * conservative and don't trim. */
+            provide("state", call->no);
+
             return;
         }
 
@@ -718,6 +768,7 @@ public:
     TraceAnalyzer(): transformFeedbackActive(false),
                      framebufferObjectActive(false),
                      insideBeginEnd(false),
+                     insideNewEndList(0),
                      activeTextureUnit(GL_TEXTURE0)
     {}