]> git.cworth.org Git - apitrace/blob - trace_parser.cpp
Use markdown syntax.
[apitrace] / trace_parser.cpp
1 /**************************************************************************
2  *
3  * Copyright 2011 Jose Fonseca
4  * Copyright 2010 VMware, Inc.
5  * All Rights Reserved.
6  *
7  * Permission is hereby granted, free of charge, to any person obtaining a copy
8  * of this software and associated documentation files (the "Software"), to deal
9  * in the Software without restriction, including without limitation the rights
10  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
11  * copies of the Software, and to permit persons to whom the Software is
12  * furnished to do so, subject to the following conditions:
13  *
14  * The above copyright notice and this permission notice shall be included in
15  * all copies or substantial portions of the Software.
16  *
17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
20  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
22  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
23  * THE SOFTWARE.
24  *
25  **************************************************************************/
26
27
28 #include <assert.h>
29 #include <stdlib.h>
30
31 #include <zlib.h>
32
33 #include "trace_parser.hpp"
34
35
36 #define TRACE_VERBOSE 0
37
38
39 namespace Trace {
40
41
42 Parser::Parser() {
43     file = NULL;
44     next_call_no = 0;
45     version = 0;
46 }
47
48
49 Parser::~Parser() {
50     close();
51 }
52
53
54 bool Parser::open(const char *filename) {
55     file = gzopen(filename, "rb");
56     if (!file) {
57         return false;
58     }
59
60     version = read_uint();
61     if (version > TRACE_VERSION) {
62         std::cerr << "error: unsupported trace format version " << version << "\n";
63         return false;
64     }
65
66     return true;
67 }
68
69 template <typename Iter>
70 inline void
71 deleteAll(Iter begin, Iter end)
72 {
73     while (begin != end) {
74         delete *begin;
75         ++begin;
76     }
77 }
78
79 template <typename Container>
80 inline void
81 deleteAll(const Container &c)
82 {
83     deleteAll(c.begin(), c.end());
84 }
85
86 void Parser::close(void) {
87     if (file) {
88         gzclose(file);
89         file = NULL;
90     }
91
92     deleteAll(calls);
93     deleteAll(functions);
94     deleteAll(structs);
95     deleteAll(enums);
96     deleteAll(bitmasks);
97 }
98
99
100 Call *Parser::parse_call(void) {
101     do {
102         int c = read_byte();
103         switch(c) {
104         case Trace::EVENT_ENTER:
105             parse_enter();
106             break;
107         case Trace::EVENT_LEAVE:
108             return parse_leave();
109         default:
110             std::cerr << "error: unknown event " << c << "\n";
111             exit(1);
112         case -1:
113             for (CallList::iterator it = calls.begin(); it != calls.end(); ++it) {
114                 std::cerr << "warning: incomplete call " << (*it)->name() << "\n";
115                 std::cerr << **it << "\n";
116             }
117             return NULL;
118         }
119     } while(true);
120 }
121
122
123 /**
124  * Helper function to lookup an ID in a vector, resizing the vector if it doesn't fit.
125  */
126 template<class T>
127 T *lookup(std::vector<T *> &map, size_t index) {
128     if (index >= map.size()) {
129         map.resize(index + 1);
130         return NULL;
131     } else {
132         return map[index];
133     }
134 }
135
136
137 void Parser::parse_enter(void) {
138     size_t id = read_uint();
139
140     FunctionSig *sig = lookup(functions, id);
141     if (!sig) {
142         sig = new FunctionSig;
143         sig->id = id;
144         sig->name = read_string();
145         sig->num_args = read_uint();
146         const char **arg_names = new const char *[sig->num_args];
147         for (unsigned i = 0; i < sig->num_args; ++i) {
148             arg_names[i] = read_string();
149         }
150         sig->arg_names = arg_names;
151         functions[id] = sig;
152     }
153     assert(sig);
154
155     Call *call = new Call(sig);
156     call->no = next_call_no++;
157
158     if (parse_call_details(call)) {
159         calls.push_back(call);
160     } else {
161         delete call;
162     }
163 }
164
165
166 Call *Parser::parse_leave(void) {
167     unsigned call_no = read_uint();
168     Call *call = NULL;
169     for (CallList::iterator it = calls.begin(); it != calls.end(); ++it) {
170         if ((*it)->no == call_no) {
171             call = *it;
172             calls.erase(it);
173             break;
174         }
175     }
176     if (!call) {
177         return NULL;
178     }
179
180     if (parse_call_details(call)) {
181         return call;
182     } else {
183         delete call;
184         return NULL;
185     }
186 }
187
188
189 bool Parser::parse_call_details(Call *call) {
190     do {
191         int c = read_byte();
192         switch(c) {
193         case Trace::CALL_END:
194             return true;
195         case Trace::CALL_ARG:
196             parse_arg(call);
197             break;
198         case Trace::CALL_RET:
199             call->ret = parse_value();
200             break;
201         default:
202             std::cerr << "error: unknown call detail " << c << "\n";
203             exit(1);
204         case -1:
205             return false;
206         }
207     } while(true);
208 }
209
210
211 void Parser::parse_arg(Call *call) {
212     unsigned index = read_uint();
213     Value *value = parse_value();
214     if (index >= call->args.size()) {
215         call->args.resize(index + 1);
216     }
217     call->args[index] = value;
218 }
219
220
221 Value *Parser::parse_value(void) {
222     int c;
223     Value *value;
224     c = read_byte();
225     switch(c) {
226     case Trace::TYPE_NULL:
227         value = new Null;
228         break;
229     case Trace::TYPE_FALSE:
230         value = new Bool(false);
231         break;
232     case Trace::TYPE_TRUE:
233         value = new Bool(true);
234         break;
235     case Trace::TYPE_SINT:
236         value = parse_sint();
237         break;
238     case Trace::TYPE_UINT:
239         value = parse_uint();
240         break;
241     case Trace::TYPE_FLOAT:
242         value = parse_float();
243         break;
244     case Trace::TYPE_DOUBLE:
245         value = parse_double();
246         break;
247     case Trace::TYPE_STRING:
248         value = parse_string();
249         break;
250     case Trace::TYPE_ENUM:
251         value = parse_enum();
252         break;
253     case Trace::TYPE_BITMASK:
254         value = parse_bitmask();
255         break;
256     case Trace::TYPE_ARRAY:
257         value = parse_array();
258         break;
259     case Trace::TYPE_STRUCT:
260         value = parse_struct();
261         break;
262     case Trace::TYPE_BLOB:
263         value = parse_blob();
264         break;
265     case Trace::TYPE_OPAQUE:
266         value = parse_opaque();
267         break;
268     default:
269         std::cerr << "error: unknown type " << c << "\n";
270         exit(1);
271     case -1:
272         value = NULL;
273         break;
274     }
275 #if TRACE_VERBOSE
276     if (value) {
277         std::cerr << "\tVALUE " << value << "\n";
278     }
279 #endif
280     return value;
281 }
282
283
284 Value *Parser::parse_sint() {
285     return new SInt(-(signed long long)read_uint());
286 }
287
288
289 Value *Parser::parse_uint() {
290     return new UInt(read_uint());
291 }
292
293
294 Value *Parser::parse_float() {
295     float value;
296     gzread(file, &value, sizeof value);
297     return new Float(value);
298 }
299
300
301 Value *Parser::parse_double() {
302     double value;
303     gzread(file, &value, sizeof value);
304     return new Float(value);
305 }
306
307
308 Value *Parser::parse_string() {
309     return new String(read_string());
310 }
311
312
313 Value *Parser::parse_enum() {
314     size_t id = read_uint();
315     EnumSig *sig = lookup(enums, id);
316     if (!sig) {
317         sig = new EnumSig;
318         sig->id = id;
319         sig->name = read_string();
320         Value *value = parse_value();
321         sig->value = value->toSInt();
322         delete value;
323         enums[id] = sig;
324     }
325     assert(sig);
326     return new Enum(sig);
327 }
328
329
330 Value *Parser::parse_bitmask() {
331     size_t id = read_uint();
332     BitmaskSig *sig = lookup(bitmasks, id);
333     if (!sig) {
334         sig = new BitmaskSig;
335         sig->id = id;
336         sig->num_flags = read_uint();
337         BitmaskFlag *flags = new BitmaskFlag[sig->num_flags];
338         for (BitmaskFlag *it = flags; it != flags + sig->num_flags; ++it) {
339             it->name = read_string();
340             it->value = read_uint();
341             if (it->value == 0 && it != flags) {
342                 std::cerr << "warning: bitmask " << it->name << " is zero but is not first flag\n";
343             }
344         }
345         sig->flags = flags;
346         bitmasks[id] = sig;
347     }
348     assert(sig);
349
350     unsigned long long value = read_uint();
351
352     return new Bitmask(sig, value);
353 }
354
355
356 Value *Parser::parse_array(void) {
357     size_t len = read_uint();
358     Array *array = new Array(len);
359     for (size_t i = 0; i < len; ++i) {
360         array->values[i] = parse_value();
361     }
362     return array;
363 }
364
365
366 Value *Parser::parse_blob(void) {
367     size_t size = read_uint();
368     Blob *blob = new Blob(size);
369     if (size) {
370         gzread(file, blob->buf, (unsigned)size);
371     }
372     return blob;
373 }
374
375
376 Value *Parser::parse_struct() {
377     size_t id = read_uint();
378
379     StructSig *sig = lookup(structs, id);
380     if (!sig) {
381         sig = new StructSig;
382         sig->id = id;
383         sig->name = read_string();
384         sig->num_members = read_uint();
385         const char **member_names = new const char *[sig->num_members];
386         for (unsigned i = 0; i < sig->num_members; ++i) {
387             member_names[i] = read_string();
388         }
389         sig->member_names = member_names;
390         structs[id] = sig;
391     }
392     assert(sig);
393
394     Struct *value = new Struct(sig);
395
396     for (size_t i = 0; i < sig->num_members; ++i) {
397         value->members[i] = parse_value();
398     }
399
400     return value;
401 }
402
403
404 Value *Parser::parse_opaque() {
405     unsigned long long addr;
406     addr = read_uint();
407     return new Pointer(addr);
408 }
409
410
411 const char * Parser::read_string(void) {
412     size_t len = read_uint();
413     char * value = new char[len + 1];
414     if (len) {
415         gzread(file, value, (unsigned)len);
416     }
417     value[len] = 0;
418 #if TRACE_VERBOSE
419     std::cerr << "\tSTRING \"" << value << "\"\n";
420 #endif
421     return value;
422 }
423
424
425 unsigned long long Parser::read_uint(void) {
426     unsigned long long value = 0;
427     int c;
428     unsigned shift = 0;
429     do {
430         c = gzgetc(file);
431         if (c == -1) {
432             break;
433         }
434         value |= (unsigned long long)(c & 0x7f) << shift;
435         shift += 7;
436     } while(c & 0x80);
437 #if TRACE_VERBOSE
438     std::cerr << "\tUINT " << value << "\n";
439 #endif
440     return value;
441 }
442
443
444 inline int Parser::read_byte(void) {
445     int c = gzgetc(file);
446 #if TRACE_VERBOSE
447     if (c < 0)
448         std::cerr << "\tEOF" << "\n";
449     else
450         std::cerr << "\tBYTE 0x" << std::hex << c << std::dec << "\n";
451 #endif
452     return c;
453 }
454
455
456 } /* namespace Trace */