]> git.cworth.org Git - apitrace/blob - common/trace_parser.cpp
Attempt to retrace incomplete calls.
[apitrace] / common / 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 "trace_file.hpp"
32 #include "trace_snappyfile.hpp"
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     assert(!file);
56     if (File::isZLibCompressed(filename)) {
57         file = new ZLibFile;
58     } else {
59         file = new SnappyFile;
60     }
61
62     if (!file->open(filename, File::Read)) {
63         return false;
64     }
65
66     version = read_uint();
67     if (version > TRACE_VERSION) {
68         std::cerr << "error: unsupported trace format version " << version << "\n";
69         return false;
70     }
71
72     return true;
73 }
74
75 template <typename Iter>
76 inline void
77 deleteAll(Iter begin, Iter end)
78 {
79     while (begin != end) {
80         delete *begin;
81         ++begin;
82     }
83 }
84
85 template <typename Container>
86 inline void
87 deleteAll(Container &c)
88 {
89     deleteAll(c.begin(), c.end());
90     c.clear();
91 }
92
93 void Parser::close(void) {
94     if (file) {
95         file->close();
96         delete file;
97         file = NULL;
98     }
99
100     deleteAll(calls);
101
102     // Delete all signature data.  Signatures are mere structures which don't
103     // own their own memory, so we need to destroy all data we created here.
104
105     for (FunctionMap::iterator it = functions.begin(); it != functions.end(); ++it) {
106         FunctionSigState *sig = *it;
107         if (sig) {
108             delete [] sig->name;
109             for (unsigned arg = 0; arg < sig->num_args; ++arg) {
110                 delete [] sig->arg_names[arg];
111             }
112             delete [] sig->arg_names;
113             delete sig;
114         }
115     }
116     functions.clear();
117
118     for (StructMap::iterator it = structs.begin(); it != structs.end(); ++it) {
119         StructSigState *sig = *it;
120         if (sig) {
121             delete [] sig->name;
122             for (unsigned member = 0; member < sig->num_members; ++member) {
123                 delete [] sig->member_names[member];
124             }
125             delete [] sig->member_names;
126             delete sig;
127         }
128     }
129     structs.clear();
130
131     for (EnumMap::iterator it = enums.begin(); it != enums.end(); ++it) {
132         EnumSigState *sig = *it;
133         if (sig) {
134             delete [] sig->name;
135             delete sig;
136         }
137     }
138     enums.clear();
139     
140     for (BitmaskMap::iterator it = bitmasks.begin(); it != bitmasks.end(); ++it) {
141         BitmaskSigState *sig = *it;
142         if (sig) {
143             for (unsigned flag = 0; flag < sig->num_flags; ++flag) {
144                 delete [] sig->flags[flag].name;
145             }
146             delete [] sig->flags;
147             delete sig;
148         }
149     }
150     bitmasks.clear();
151 }
152
153
154 void Parser::getBookmark(ParseBookmark &bookmark) {
155     bookmark.offset = file->currentOffset();
156     bookmark.next_call_no = next_call_no;
157 }
158
159
160 void Parser::setBookmark(const ParseBookmark &bookmark) {
161     file->setCurrentOffset(bookmark.offset);
162     next_call_no = bookmark.next_call_no;
163     
164     // Simply ignore all pending calls
165     deleteAll(calls);
166 }
167
168
169 Call *Parser::parse_call(Mode mode) {
170     do {
171         int c = read_byte();
172         switch(c) {
173         case Trace::EVENT_ENTER:
174             parse_enter(mode);
175             break;
176         case Trace::EVENT_LEAVE:
177             return parse_leave(mode);
178         default:
179             std::cerr << "error: unknown event " << c << "\n";
180             exit(1);
181         case -1:
182             if (!calls.empty()) {
183                 Call *call = calls.front();
184                 std::cerr << call->no << ": warning: incomplete call " << call->name() << "\n";
185                 calls.pop_front();
186                 return call;
187             }
188             return NULL;
189         }
190     } while(true);
191 }
192
193
194 /**
195  * Helper function to lookup an ID in a vector, resizing the vector if it doesn't fit.
196  */
197 template<class T>
198 T *lookup(std::vector<T *> &map, size_t index) {
199     if (index >= map.size()) {
200         map.resize(index + 1);
201         return NULL;
202     } else {
203         return map[index];
204     }
205 }
206
207
208 FunctionSig *Parser::parse_function_sig(void) {
209     size_t id = read_uint();
210
211     FunctionSigState *sig = lookup(functions, id);
212
213     if (!sig) {
214         /* parse the signature */
215         sig = new FunctionSigState;
216         sig->id = id;
217         sig->name = read_string();
218         sig->num_args = read_uint();
219         const char **arg_names = new const char *[sig->num_args];
220         for (unsigned i = 0; i < sig->num_args; ++i) {
221             arg_names[i] = read_string();
222         }
223         sig->arg_names = arg_names;
224         sig->offset = file->currentOffset();
225         functions[id] = sig;
226     } else if (file->currentOffset() < sig->offset) {
227         /* skip over the signature */
228         skip_string(); /* name */
229         int num_args = read_uint();
230         for (unsigned i = 0; i < num_args; ++i) {
231              skip_string(); /*arg_name*/
232         }
233     }
234
235     assert(sig);
236     return sig;
237 }
238
239
240 StructSig *Parser::parse_struct_sig() {
241     size_t id = read_uint();
242
243     StructSigState *sig = lookup(structs, id);
244
245     if (!sig) {
246         /* parse the signature */
247         sig = new StructSigState;
248         sig->id = id;
249         sig->name = read_string();
250         sig->num_members = read_uint();
251         const char **member_names = new const char *[sig->num_members];
252         for (unsigned i = 0; i < sig->num_members; ++i) {
253             member_names[i] = read_string();
254         }
255         sig->member_names = member_names;
256         sig->offset = file->currentOffset();
257         structs[id] = sig;
258     } else if (file->currentOffset() < sig->offset) {
259         /* skip over the signature */
260         skip_string(); /* name */
261         unsigned num_members = read_uint();
262         for (unsigned i = 0; i < num_members; ++i) {
263             skip_string(); /* member_name */
264         }
265     }
266
267     assert(sig);
268     return sig;
269 }
270
271
272 EnumSig *Parser::parse_enum_sig() {
273     size_t id = read_uint();
274
275     EnumSigState *sig = lookup(enums, id);
276
277     if (!sig) {
278         /* parse the signature */
279         sig = new EnumSigState;
280         sig->id = id;
281         sig->name = read_string();
282         Value *value = parse_value();
283         sig->value = value->toSInt();
284         delete value;
285         sig->offset = file->currentOffset();
286         enums[id] = sig;
287     } else if (file->currentOffset() < sig->offset) {
288         /* skip over the signature */
289         skip_string(); /*name*/
290         scan_value();
291     }
292
293     assert(sig);
294     return sig;
295 }
296
297
298 BitmaskSig *Parser::parse_bitmask_sig() {
299     size_t id = read_uint();
300
301     BitmaskSigState *sig = lookup(bitmasks, id);
302
303     if (!sig) {
304         /* parse the signature */
305         sig = new BitmaskSigState;
306         sig->id = id;
307         sig->num_flags = read_uint();
308         BitmaskFlag *flags = new BitmaskFlag[sig->num_flags];
309         for (BitmaskFlag *it = flags; it != flags + sig->num_flags; ++it) {
310             it->name = read_string();
311             it->value = read_uint();
312             if (it->value == 0 && it != flags) {
313                 std::cerr << "warning: bitmask " << it->name << " is zero but is not first flag\n";
314             }
315         }
316         sig->flags = flags;
317         sig->offset = file->currentOffset();
318         bitmasks[id] = sig;
319     } else if (file->currentOffset() < sig->offset) {
320         /* skip over the signature */
321         int num_flags = read_uint();
322         for (int i = 0; i < num_flags; ++i) {
323             skip_string(); /*name */
324             skip_uint(); /* value */
325         }
326     }
327
328     assert(sig);
329     return sig;
330 }
331
332
333 void Parser::parse_enter(Mode mode) {
334     FunctionSig *sig = parse_function_sig();
335
336     Call *call = new Call(sig);
337
338     call->no = next_call_no++;
339
340     if (parse_call_details(call, mode)) {
341         calls.push_back(call);
342     } else {
343         delete call;
344     }
345 }
346
347
348 Call *Parser::parse_leave(Mode mode) {
349     unsigned call_no = read_uint();
350     Call *call = NULL;
351     for (CallList::iterator it = calls.begin(); it != calls.end(); ++it) {
352         if ((*it)->no == call_no) {
353             call = *it;
354             calls.erase(it);
355             break;
356         }
357     }
358     if (!call) {
359         return NULL;
360     }
361
362     if (parse_call_details(call, mode)) {
363         return call;
364     } else {
365         delete call;
366         return NULL;
367     }
368 }
369
370
371 bool Parser::parse_call_details(Call *call, Mode mode) {
372     do {
373         int c = read_byte();
374         switch(c) {
375         case Trace::CALL_END:
376             return true;
377         case Trace::CALL_ARG:
378             parse_arg(call, mode);
379             break;
380         case Trace::CALL_RET:
381             call->ret = parse_value(mode);
382             break;
383         default:
384             std::cerr << "error: ("<<call->name()<< ") unknown call detail "
385                       << c << "\n";
386             exit(1);
387         case -1:
388             return false;
389         }
390     } while(true);
391 }
392
393
394 void Parser::parse_arg(Call *call, Mode mode) {
395     unsigned index = read_uint();
396     Value *value = parse_value(mode);
397     if (value) {
398         if (index >= call->args.size()) {
399             call->args.resize(index + 1);
400         }
401         call->args[index] = value;
402     }
403 }
404
405
406 Value *Parser::parse_value(void) {
407     int c;
408     Value *value;
409     c = read_byte();
410     switch(c) {
411     case Trace::TYPE_NULL:
412         value = new Null;
413         break;
414     case Trace::TYPE_FALSE:
415         value = new Bool(false);
416         break;
417     case Trace::TYPE_TRUE:
418         value = new Bool(true);
419         break;
420     case Trace::TYPE_SINT:
421         value = parse_sint();
422         break;
423     case Trace::TYPE_UINT:
424         value = parse_uint();
425         break;
426     case Trace::TYPE_FLOAT:
427         value = parse_float();
428         break;
429     case Trace::TYPE_DOUBLE:
430         value = parse_double();
431         break;
432     case Trace::TYPE_STRING:
433         value = parse_string();
434         break;
435     case Trace::TYPE_ENUM:
436         value = parse_enum();
437         break;
438     case Trace::TYPE_BITMASK:
439         value = parse_bitmask();
440         break;
441     case Trace::TYPE_ARRAY:
442         value = parse_array();
443         break;
444     case Trace::TYPE_STRUCT:
445         value = parse_struct();
446         break;
447     case Trace::TYPE_BLOB:
448         value = parse_blob();
449         break;
450     case Trace::TYPE_OPAQUE:
451         value = parse_opaque();
452         break;
453     default:
454         std::cerr << "error: unknown type " << c << "\n";
455         exit(1);
456     case -1:
457         value = NULL;
458         break;
459     }
460 #if TRACE_VERBOSE
461     if (value) {
462         std::cerr << "\tVALUE " << value << "\n";
463     }
464 #endif
465     return value;
466 }
467
468
469 void Parser::scan_value(void) {
470     int c = read_byte();
471     switch(c) {
472     case Trace::TYPE_NULL:
473     case Trace::TYPE_FALSE:
474     case Trace::TYPE_TRUE:
475         break;
476     case Trace::TYPE_SINT:
477         scan_sint();
478         break;
479     case Trace::TYPE_UINT:
480         scan_uint();
481         break;
482     case Trace::TYPE_FLOAT:
483         scan_float();
484         break;
485     case Trace::TYPE_DOUBLE:
486         scan_double();
487         break;
488     case Trace::TYPE_STRING:
489         scan_string();
490         break;
491     case Trace::TYPE_ENUM:
492         scan_enum();
493         break;
494     case Trace::TYPE_BITMASK:
495         scan_bitmask();
496         break;
497     case Trace::TYPE_ARRAY:
498         scan_array();
499         break;
500     case Trace::TYPE_STRUCT:
501         scan_struct();
502         break;
503     case Trace::TYPE_BLOB:
504         scan_blob();
505         break;
506     case Trace::TYPE_OPAQUE:
507         scan_opaque();
508         break;
509     default:
510         std::cerr << "error: unknown type " << c << "\n";
511         exit(1);
512     case -1:
513         break;
514     }
515 }
516
517
518 Value *Parser::parse_sint() {
519     return new SInt(-(signed long long)read_uint());
520 }
521
522
523 void Parser::scan_sint() {
524     skip_uint();
525 }
526
527
528 Value *Parser::parse_uint() {
529     return new UInt(read_uint());
530 }
531
532
533 void Parser::scan_uint() {
534     skip_uint();
535 }
536
537
538 Value *Parser::parse_float() {
539     float value;
540     file->read(&value, sizeof value);
541     return new Float(value);
542 }
543
544
545 void Parser::scan_float() {
546     file->skip(sizeof(float));
547 }
548
549
550 Value *Parser::parse_double() {
551     double value;
552     file->read(&value, sizeof value);
553     return new Float(value);
554 }
555
556
557 void Parser::scan_double() {
558     file->skip(sizeof(double));
559 }
560
561
562 Value *Parser::parse_string() {
563     return new String(read_string());
564 }
565
566
567 void Parser::scan_string() {
568     skip_string();
569 }
570
571
572 Value *Parser::parse_enum() {
573     EnumSig *sig = parse_enum_sig();
574     return new Enum(sig);
575 }
576
577
578 void Parser::scan_enum() {
579     parse_enum_sig();
580 }
581
582
583 Value *Parser::parse_bitmask() {
584     BitmaskSig *sig = parse_bitmask_sig();
585
586     unsigned long long value = read_uint();
587
588     return new Bitmask(sig, value);
589 }
590
591
592 void Parser::scan_bitmask() {
593     parse_bitmask_sig();
594     skip_uint(); /* value */
595 }
596
597
598 Value *Parser::parse_array(void) {
599     size_t len = read_uint();
600     Array *array = new Array(len);
601     for (size_t i = 0; i < len; ++i) {
602         array->values[i] = parse_value();
603     }
604     return array;
605 }
606
607
608 void Parser::scan_array(void) {
609     size_t len = read_uint();
610     for (size_t i = 0; i < len; ++i) {
611         scan_value();
612     }
613 }
614
615
616 Value *Parser::parse_blob(void) {
617     size_t size = read_uint();
618     Blob *blob = new Blob(size);
619     if (size) {
620         file->read(blob->buf, (unsigned)size);
621     }
622     return blob;
623 }
624
625
626 void Parser::scan_blob(void) {
627     size_t size = read_uint();
628     if (size) {
629         file->skip(size);
630     }
631 }
632
633
634 Value *Parser::parse_struct() {
635     StructSig *sig = parse_struct_sig();
636     Struct *value = new Struct(sig);
637
638     for (size_t i = 0; i < sig->num_members; ++i) {
639         value->members[i] = parse_value();
640     }
641
642     return value;
643 }
644
645
646 void Parser::scan_struct() {
647     StructSig *sig = parse_struct_sig();
648     for (size_t i = 0; i < sig->num_members; ++i) {
649         scan_value();
650     }
651 }
652
653
654 Value *Parser::parse_opaque() {
655     unsigned long long addr;
656     addr = read_uint();
657     return new Pointer(addr);
658 }
659
660
661 void Parser::scan_opaque() {
662     skip_uint();
663 }
664
665
666 const char * Parser::read_string(void) {
667     size_t len = read_uint();
668     char * value = new char[len + 1];
669     if (len) {
670         file->read(value, (unsigned)len);
671     }
672     value[len] = 0;
673 #if TRACE_VERBOSE
674     std::cerr << "\tSTRING \"" << value << "\"\n";
675 #endif
676     return value;
677 }
678
679
680 void Parser::skip_string(void) {
681     size_t len = read_uint();
682     file->skip(len);
683 }
684
685
686 unsigned long long Parser::read_uint(void) {
687     unsigned long long value = 0;
688     int c;
689     unsigned shift = 0;
690     do {
691         c = file->getc();
692         if (c == -1) {
693             break;
694         }
695         value |= (unsigned long long)(c & 0x7f) << shift;
696         shift += 7;
697     } while(c & 0x80);
698 #if TRACE_VERBOSE
699     std::cerr << "\tUINT " << value << "\n";
700 #endif
701     return value;
702 }
703
704
705 void Parser::skip_uint(void) {
706     int c;
707     do {
708         c = file->getc();
709         if (c == -1) {
710             break;
711         }
712     } while(c & 0x80);
713 }
714
715
716 inline int Parser::read_byte(void) {
717     int c = file->getc();
718 #if TRACE_VERBOSE
719     if (c < 0)
720         std::cerr << "\tEOF" << "\n";
721     else
722         std::cerr << "\tBYTE 0x" << std::hex << c << std::dec << "\n";
723 #endif
724     return c;
725 }
726
727
728 inline void Parser::skip_byte(void) {
729     file->skip(1);
730 }
731
732
733 } /* namespace Trace */