retrace: Implement glxCopySubBufferMESA

[apitrace] / common / trace_parser.cpp

diff --git a/common/trace_parser.cpp b/common/trace_parser.cpp
index f3aea7e7cf482f26f69e74432691bcefbb75ab1c..a9cdd0fbc0586465be407522a0148146e05f283a 100644 (file)
--- a/common/trace_parser.cpp
+++ b/common/trace_parser.cpp
@@ -30,6 +30,7 @@
 #include <string.h>
 
 #include "trace_file.hpp"
+#include "trace_dump.hpp"
 #include "trace_parser.hpp"
 
 
@@ -64,6 +65,8 @@ bool Parser::open(const char *filename) {
     version = read_uint();
     if (version > TRACE_VERSION) {
         std::cerr << "error: unsupported trace format version " << version << "\n";
+        delete file;
+        file = NULL;
         return false;
     }
     api = API_UNKNOWN;
@@ -176,12 +179,21 @@ Call *Parser::parse_call(Mode mode) {
         int c = read_byte();
         switch (c) {
         case trace::EVENT_ENTER:
+#if TRACE_VERBOSE
+            std::cerr << "\tENTER\n";
+#endif
             parse_enter(mode);
             break;
         case trace::EVENT_LEAVE:
+#if TRACE_VERBOSE
+            std::cerr << "\tLEAVE\n";
+#endif
             call = parse_leave(mode);
-            adjust_call_flags(call);
-            return call;
+            if (call) {
+                adjust_call_flags(call);
+                return call;
+            }
+            break;
         default:
             std::cerr << "error: unknown event " << c << "\n";
             exit(1);
@@ -231,7 +243,7 @@ Parser::parse_function_sig(void) {
         }
         sig->arg_names = arg_names;
         sig->flags = lookupCallFlags(sig->name);
-        sig->offset = file->currentOffset();
+        sig->fileOffset = file->currentOffset();
         functions[id] = sig;
 
         /**
@@ -269,7 +281,7 @@ Parser::parse_function_sig(void) {
             glGetErrorSig = sig;
         }
 
-    } else if (file->currentOffset() < sig->offset) {
+    } else if (file->currentOffset() < sig->fileOffset) {
         /* skip over the signature */
         skip_string(); /* name */
         unsigned num_args = read_uint();
@@ -299,9 +311,9 @@ StructSig *Parser::parse_struct_sig() {
             member_names[i] = read_string();
         }
         sig->member_names = member_names;
-        sig->offset = file->currentOffset();
+        sig->fileOffset = file->currentOffset();
         structs[id] = sig;
-    } else if (file->currentOffset() < sig->offset) {
+    } else if (file->currentOffset() < sig->fileOffset) {
         /* skip over the signature */
         skip_string(); /* name */
         unsigned num_members = read_uint();
@@ -335,9 +347,9 @@ EnumSig *Parser::parse_old_enum_sig() {
         values->name = read_string();
         values->value = read_sint();
         sig->values = values;
-        sig->offset = file->currentOffset();
+        sig->fileOffset = file->currentOffset();
         enums[id] = sig;
-    } else if (file->currentOffset() < sig->offset) {
+    } else if (file->currentOffset() < sig->fileOffset) {
         /* skip over the signature */
         skip_string(); /*name*/
         scan_value();
@@ -364,9 +376,9 @@ EnumSig *Parser::parse_enum_sig() {
             it->value = read_sint();
         }
         sig->values = values;
-        sig->offset = file->currentOffset();
+        sig->fileOffset = file->currentOffset();
         enums[id] = sig;
-    } else if (file->currentOffset() < sig->offset) {
+    } else if (file->currentOffset() < sig->fileOffset) {
         /* skip over the signature */
         int num_values = read_uint();
         for (int i = 0; i < num_values; ++i) {
@@ -399,9 +411,9 @@ BitmaskSig *Parser::parse_bitmask_sig() {
             }
         }
         sig->flags = flags;
-        sig->offset = file->currentOffset();
+        sig->fileOffset = file->currentOffset();
         bitmasks[id] = sig;
-    } else if (file->currentOffset() < sig->offset) {
+    } else if (file->currentOffset() < sig->fileOffset) {
         /* skip over the signature */
         int num_flags = read_uint();
         for (int i = 0; i < num_flags; ++i) {
@@ -449,6 +461,14 @@ Call *Parser::parse_leave(Mode mode) {
         }
     }
     if (!call) {
+        /* This might happen on random access, when an asynchronous call is stranded
+         * between two frames.  We won't return this call, but we still need to skip 
+         * over its data.
+         */
+        const FunctionSig sig = {0, NULL, 0, NULL};
+        call = new Call(&sig, 0, 0);
+        parse_call_details(call, SCAN);
+        delete call;
         return NULL;
     }
 
@@ -466,13 +486,28 @@ bool Parser::parse_call_details(Call *call, Mode mode) {
         int c = read_byte();
         switch (c) {
         case trace::CALL_END:
+#if TRACE_VERBOSE
+            std::cerr << "\tCALL_END\n";
+#endif
             return true;
         case trace::CALL_ARG:
+#if TRACE_VERBOSE
+            std::cerr << "\tCALL_ARG\n";
+#endif
             parse_arg(call, mode);
             break;
         case trace::CALL_RET:
+#if TRACE_VERBOSE
+            std::cerr << "\tCALL_RET\n";
+#endif
             call->ret = parse_value(mode);
             break;
+        case trace::CALL_BACKTRACE:
+#if TRACE_VERBOSE
+            std::cerr << "\tCALL_BACKTRACE\n";
+#endif
+            parse_call_backtrace(call, mode);
+            break;
         default:
             std::cerr << "error: ("<<call->name()<< ") unknown call detail "
                       << c << "\n";
@@ -483,6 +518,83 @@ bool Parser::parse_call_details(Call *call, Mode mode) {
     } while(true);
 }
 
+bool Parser::parse_call_backtrace(Call *call, Mode mode) {
+    unsigned num_frames = read_uint();
+    Backtrace* backtrace = new Backtrace(num_frames);
+    for (unsigned i = 0; i < num_frames; ++i) {
+        (*backtrace)[i] = parse_backtrace_frame(mode);
+    }
+    call->backtrace = backtrace;
+    return true;
+}
+
+StackFrame * Parser::parse_backtrace_frame(Mode mode) {
+    size_t id = read_uint();
+
+    StackFrameState *frame = lookup(frames, id);
+
+    if (!frame) {
+        frame = new StackFrameState;
+        int c = read_byte();
+        while (c != trace::BACKTRACE_END &&
+               c != -1) {
+            switch (c) {
+            case trace::BACKTRACE_MODULE:
+                frame->module = read_string();
+                break;
+            case trace::BACKTRACE_FUNCTION:
+                frame->function = read_string();
+                break;
+            case trace::BACKTRACE_FILENAME:
+                frame->filename = read_string();
+                break;
+            case trace::BACKTRACE_LINENUMBER:
+                frame->linenumber = read_uint();
+                break;
+            case trace::BACKTRACE_OFFSET:
+                frame->offset = read_uint();
+                break;
+            default:
+                std::cerr << "error: unknown backtrace detail "
+                          << c << "\n";
+                exit(1);
+            }
+            c = read_byte();
+        }
+
+        frame->fileOffset = file->currentOffset();
+        frames[id] = frame;
+    } else if (file->currentOffset() < frame->fileOffset) {
+        int c = read_byte();
+        while (c != trace::BACKTRACE_END &&
+               c != -1) {
+            switch (c) {
+            case trace::BACKTRACE_MODULE:
+                scan_string();
+                break;
+            case trace::BACKTRACE_FUNCTION:
+                scan_string();
+                break;
+            case trace::BACKTRACE_FILENAME:
+                scan_string();
+                break;
+            case trace::BACKTRACE_LINENUMBER:
+                scan_uint();
+                break;
+            case trace::BACKTRACE_OFFSET:
+                scan_uint();
+                break;
+            default:
+                std::cerr << "error: unknown backtrace detail "
+                          << c << "\n";
+                exit(1);
+            }
+            c = read_byte();
+        }
+    }
+
+    return frame;
+}
 
 /**
  * Make adjustments to this particular call flags.
@@ -570,7 +682,9 @@ Value *Parser::parse_value(void) {
     }
 #if TRACE_VERBOSE
     if (value) {
-        std::cerr << "\tVALUE " << value << "\n";
+        std::cerr << "\tVALUE ";
+        trace::dump(value, std::cerr);
+        std::cerr << "\n";
     }
 #endif
     return value;