git.cworth.org Git - apitrace/blob - 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 */