file = NULL;
next_call_no = 0;
version = 0;
+ api = API_UNKNOWN;
glGetErrorSig = NULL;
}
std::cerr << "error: unsupported trace format version " << version << "\n";
return false;
}
+ api = API_UNKNOWN;
return true;
}
for (EnumMap::iterator it = enums.begin(); it != enums.end(); ++it) {
EnumSigState *sig = *it;
if (sig) {
- delete [] sig->name;
+ for (unsigned value = 0; value < sig->num_values; ++value) {
+ delete [] sig->values[value].name;
+ }
+ delete [] sig->values;
delete sig;
}
}
sig->offset = file->currentOffset();
functions[id] = sig;
+ /**
+ * Try to autodetect the API.
+ *
+ * XXX: Ideally we would allow to mix multiple APIs in a single trace,
+ * but as it stands today, retrace is done separately for each API.
+ */
+ if (api == API_UNKNOWN) {
+ const char *n = sig->name;
+ if ((n[0] == 'g' && n[1] == 'l' && n[2] == 'X') || // glX*
+ (n[0] == 'w' && n[1] == 'g' && n[2] == 'l' && n[3] >= 'A' && n[3] <= 'Z') || // wgl[A-Z]*
+ (n[0] == 'C' && n[1] == 'G' && n[2] == 'L')) { // CGL*
+ api = trace::API_GL;
+ } else if (n[0] == 'e' && n[1] == 'g' && n[2] == 'l' && n[3] >= 'A' && n[3] <= 'Z') { // egl[A-Z]*
+ api = trace::API_EGL;
+ } else if (n[0] == 'D' &&
+ ((n[1] == 'i' && n[2] == 'r' && n[3] == 'e' && n[4] == 'c' && n[5] == 't') || // Direct*
+ (n[1] == '3' && n[2] == 'D'))) { // D3D*
+ api = trace::API_DX;
+ } else {
+ /* TODO */
+ }
+ }
+
/**
* Note down the signature of special functions for future reference.
*
}
-EnumSig *Parser::parse_enum_sig() {
+/*
+ * Old enum signatures would cover a single name/value only:
+ *
+ * enum_sig = id name value
+ * | id
+ */
+EnumSig *Parser::parse_old_enum_sig() {
size_t id = read_uint();
EnumSigState *sig = lookup(enums, id);
/* parse the signature */
sig = new EnumSigState;
sig->id = id;
- sig->name = read_string();
- Value *value = parse_value();
- sig->value = value->toSInt();
- delete value;
+ sig->num_values = 1;
+ EnumValue *values = new EnumValue[sig->num_values];
+ values->name = read_string();
+ values->value = read_sint();
+ sig->values = values;
sig->offset = file->currentOffset();
enums[id] = sig;
} else if (file->currentOffset() < sig->offset) {
}
+EnumSig *Parser::parse_enum_sig() {
+ size_t id = read_uint();
+
+ EnumSigState *sig = lookup(enums, id);
+
+ if (!sig) {
+ /* parse the signature */
+ sig = new EnumSigState;
+ sig->id = id;
+ sig->num_values = read_uint();
+ EnumValue *values = new EnumValue[sig->num_values];
+ for (EnumValue *it = values; it != values + sig->num_values; ++it) {
+ it->name = read_string();
+ it->value = read_sint();
+ }
+ sig->values = values;
+ sig->offset = file->currentOffset();
+ enums[id] = sig;
+ } else if (file->currentOffset() < sig->offset) {
+ /* skip over the signature */
+ int num_values = read_uint();
+ for (int i = 0; i < num_values; ++i) {
+ skip_string(); /*name */
+ skip_sint(); /* value */
+ }
+ }
+
+ assert(sig);
+ return sig;
+}
+
+
BitmaskSig *Parser::parse_bitmask_sig() {
size_t id = read_uint();
void Parser::parse_enter(Mode mode) {
+ unsigned thread_id;
+
+ if (version >= 4) {
+ thread_id = read_uint();
+ } else {
+ thread_id = 0;
+ }
+
FunctionSigFlags *sig = parse_function_sig();
- Call *call = new Call(sig, sig->flags);
+ Call *call = new Call(sig, sig->flags, thread_id);
call->no = next_call_no++;
if (index >= call->args.size()) {
call->args.resize(index + 1);
}
- call->args[index] = value;
+ call->args[index].value = value;
}
}
case trace::TYPE_OPAQUE:
value = parse_opaque();
break;
+ case trace::TYPE_REPR:
+ value = parse_repr();
+ break;
default:
std::cerr << "error: unknown type " << c << "\n";
exit(1);
case trace::TYPE_OPAQUE:
scan_opaque();
break;
+ case trace::TYPE_REPR:
+ scan_repr();
+ break;
default:
std::cerr << "error: unknown type " << c << "\n";
exit(1);
Value *Parser::parse_enum() {
- EnumSig *sig = parse_enum_sig();
- return new Enum(sig);
+ EnumSig *sig;
+ signed long long value;
+ if (version >= 3) {
+ sig = parse_enum_sig();
+ value = read_sint();
+ } else {
+ sig = parse_old_enum_sig();
+ assert(sig->num_values == 1);
+ value = sig->values->value;
+ }
+ return new Enum(sig, value);
}
void Parser::scan_enum() {
- parse_enum_sig();
+ if (version >= 3) {
+ parse_enum_sig();
+ skip_sint();
+ } else {
+ parse_old_enum_sig();
+ }
}
size_t size = read_uint();
Blob *blob = new Blob(size);
if (size) {
- file->read(blob->buf, (unsigned)size);
+ file->read(blob->buf, size);
}
return blob;
}
}
+Value *Parser::parse_repr() {
+ Value *humanValue = parse_value();
+ Value *machineValue = parse_value();
+ return new Repr(humanValue, machineValue);
+}
+
+
+void Parser::scan_repr() {
+ scan_value();
+ scan_value();
+}
+
+
const char * Parser::read_string(void) {
size_t len = read_uint();
char * value = new char[len + 1];
if (len) {
- file->read(value, (unsigned)len);
+ file->read(value, len);
}
value[len] = 0;
#if TRACE_VERBOSE
}
+/*
+ * For the time being, a signed int is encoded as any other value, but we here parse
+ * it without the extra baggage of the Value class.
+ */
+signed long long
+Parser::read_sint(void) {
+ int c;
+ c = read_byte();
+ switch (c) {
+ case trace::TYPE_SINT:
+ return -(signed long long)read_uint();
+ case trace::TYPE_UINT:
+ return read_uint();
+ default:
+ std::cerr << "error: unexpected type " << c << "\n";
+ exit(1);
+ case -1:
+ return 0;
+ }
+}
+
+void
+Parser::skip_sint(void) {
+ skip_byte();
+ skip_uint();
+}
+
unsigned long long Parser::read_uint(void) {
unsigned long long value = 0;
int c;
projects / apitrace / blobdiff