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 #include <string.h>
  31
  32 #include "trace_file.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     glGetErrorSig = NULL;
  48 }
  49
  50
  51 Parser::~Parser() {
  52     close();
  53 }
  54
  55
  56 bool Parser::open(const char *filename) {
  57     assert(!file);
  58     file = File::createForRead(filename);
  59     if (!file) {
  60         return false;
  61     }
  62
  63     version = read_uint();
  64     if (version > TRACE_VERSION) {
  65         std::cerr << "error: unsupported trace format version " << version << "\n";
  66         return false;
  67     }
  68
  69     return true;
  70 }
  71
  72 template <typename Iter>
  73 inline void
  74 deleteAll(Iter begin, Iter end)
  75 {
  76     while (begin != end) {
  77         delete *begin;
  78         ++begin;
  79     }
  80 }
  81
  82 template <typename Container>
  83 inline void
  84 deleteAll(Container &c)
  85 {
  86     deleteAll(c.begin(), c.end());
  87     c.clear();
  88 }
  89
  90 void Parser::close(void) {
  91     if (file) {
  92         file->close();
  93         delete file;
  94         file = NULL;
  95     }
  96
  97     deleteAll(calls);
  98
  99     // Delete all signature data.  Signatures are mere structures which don't
 100     // own their own memory, so we need to destroy all data we created here.
 101
 102     for (FunctionMap::iterator it = functions.begin(); it != functions.end(); ++it) {
 103         FunctionSigState *sig = *it;
 104         if (sig) {
 105             delete [] sig->name;
 106             for (unsigned arg = 0; arg < sig->num_args; ++arg) {
 107                 delete [] sig->arg_names[arg];
 108             }
 109             delete [] sig->arg_names;
 110             delete sig;
 111         }
 112     }
 113     functions.clear();
 114
 115     for (StructMap::iterator it = structs.begin(); it != structs.end(); ++it) {
 116         StructSigState *sig = *it;
 117         if (sig) {
 118             delete [] sig->name;
 119             for (unsigned member = 0; member < sig->num_members; ++member) {
 120                 delete [] sig->member_names[member];
 121             }
 122             delete [] sig->member_names;
 123             delete sig;
 124         }
 125     }
 126     structs.clear();
 127
 128     for (EnumMap::iterator it = enums.begin(); it != enums.end(); ++it) {
 129         EnumSigState *sig = *it;
 130         if (sig) {
 131             for (unsigned value = 0; value < sig->num_values; ++value) {
 132                 delete [] sig->values[value].name;
 133             }
 134             delete [] sig->values;
 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     next_call_no = 0;
 153 }
 154
 155
 156 void Parser::getBookmark(ParseBookmark &bookmark) {
 157     bookmark.offset = file->currentOffset();
 158     bookmark.next_call_no = next_call_no;
 159 }
 160
 161
 162 void Parser::setBookmark(const ParseBookmark &bookmark) {
 163     file->setCurrentOffset(bookmark.offset);
 164     next_call_no = bookmark.next_call_no;
 165
 166     // Simply ignore all pending calls
 167     deleteAll(calls);
 168 }
 169
 170
 171 Call *Parser::parse_call(Mode mode) {
 172     do {
 173         Call *call;
 174         int c = read_byte();
 175         switch (c) {
 176         case trace::EVENT_ENTER:
 177             parse_enter(mode);
 178             break;
 179         case trace::EVENT_LEAVE:
 180             call = parse_leave(mode);
 181             adjust_call_flags(call);
 182             return call;
 183         default:
 184             std::cerr << "error: unknown event " << c << "\n";
 185             exit(1);
 186         case -1:
 187             if (!calls.empty()) {
 188                 call = calls.front();
 189                 call->flags |= CALL_FLAG_INCOMPLETE;
 190                 calls.pop_front();
 191                 adjust_call_flags(call);
 192                 return call;
 193             }
 194             return NULL;
 195         }
 196     } while(true);
 197 }
 198
 199
 200 /**
 201  * Helper function to lookup an ID in a vector, resizing the vector if it doesn't fit.
 202  */
 203 template<class T>
 204 T *lookup(std::vector<T *> &map, size_t index) {
 205     if (index >= map.size()) {
 206         map.resize(index + 1);
 207         return NULL;
 208     } else {
 209         return map[index];
 210     }
 211 }
 212
 213
 214 Parser::FunctionSigFlags *
 215 Parser::parse_function_sig(void) {
 216     size_t id = read_uint();
 217
 218     FunctionSigState *sig = lookup(functions, id);
 219
 220     if (!sig) {
 221         /* parse the signature */
 222         sig = new FunctionSigState;
 223         sig->id = id;
 224         sig->name = read_string();
 225         sig->num_args = read_uint();
 226         const char **arg_names = new const char *[sig->num_args];
 227         for (unsigned i = 0; i < sig->num_args; ++i) {
 228             arg_names[i] = read_string();
 229         }
 230         sig->arg_names = arg_names;
 231         sig->flags = lookupCallFlags(sig->name);
 232         sig->offset = file->currentOffset();
 233         functions[id] = sig;
 234
 235         /**
 236          * Note down the signature of special functions for future reference.
 237          *
 238          * NOTE: If the number of comparisons increases we should move this to a
 239          * separate function and use bisection.
 240          */
 241         if (sig->num_args == 0 &&
 242             strcmp(sig->name, "glGetError") == 0) {
 243             glGetErrorSig = sig;
 244         }
 245
 246     } else if (file->currentOffset() < sig->offset) {
 247         /* skip over the signature */
 248         skip_string(); /* name */
 249         unsigned num_args = read_uint();
 250         for (unsigned i = 0; i < num_args; ++i) {
 251              skip_string(); /*arg_name*/
 252         }
 253     }
 254
 255     assert(sig);
 256     return sig;
 257 }
 258
 259
 260 StructSig *Parser::parse_struct_sig() {
 261     size_t id = read_uint();
 262
 263     StructSigState *sig = lookup(structs, id);
 264
 265     if (!sig) {
 266         /* parse the signature */
 267         sig = new StructSigState;
 268         sig->id = id;
 269         sig->name = read_string();
 270         sig->num_members = read_uint();
 271         const char **member_names = new const char *[sig->num_members];
 272         for (unsigned i = 0; i < sig->num_members; ++i) {
 273             member_names[i] = read_string();
 274         }
 275         sig->member_names = member_names;
 276         sig->offset = file->currentOffset();
 277         structs[id] = sig;
 278     } else if (file->currentOffset() < sig->offset) {
 279         /* skip over the signature */
 280         skip_string(); /* name */
 281         unsigned num_members = read_uint();
 282         for (unsigned i = 0; i < num_members; ++i) {
 283             skip_string(); /* member_name */
 284         }
 285     }
 286
 287     assert(sig);
 288     return sig;
 289 }
 290
 291
 292 /*
 293  * Old enum signatures would cover a single name/value only:
 294  *
 295  *   enum_sig = id name value
 296  *            | id
 297  */
 298 EnumSig *Parser::parse_old_enum_sig() {
 299     size_t id = read_uint();
 300
 301     EnumSigState *sig = lookup(enums, id);
 302
 303     if (!sig) {
 304         /* parse the signature */
 305         sig = new EnumSigState;
 306         sig->id = id;
 307         sig->num_values = 1;
 308         EnumValue *values = new EnumValue[sig->num_values];
 309         values->name = read_string();
 310         values->value = read_sint();
 311         sig->values = values;
 312         sig->offset = file->currentOffset();
 313         enums[id] = sig;
 314     } else if (file->currentOffset() < sig->offset) {
 315         /* skip over the signature */
 316         skip_string(); /*name*/
 317         scan_value();
 318     }
 319
 320     assert(sig);
 321     return sig;
 322 }
 323
 324
 325 EnumSig *Parser::parse_enum_sig() {
 326     size_t id = read_uint();
 327
 328     EnumSigState *sig = lookup(enums, id);
 329
 330     if (!sig) {
 331         /* parse the signature */
 332         sig = new EnumSigState;
 333         sig->id = id;
 334         sig->num_values = read_uint();
 335         EnumValue *values = new EnumValue[sig->num_values];
 336         for (EnumValue *it = values; it != values + sig->num_values; ++it) {
 337             it->name = read_string();
 338             it->value = read_sint();
 339         }
 340         sig->values = values;
 341         sig->offset = file->currentOffset();
 342         enums[id] = sig;
 343     } else if (file->currentOffset() < sig->offset) {
 344         /* skip over the signature */
 345         int num_values = read_uint();
 346         for (int i = 0; i < num_values; ++i) {
 347             skip_string(); /*name */
 348             skip_sint(); /* value */
 349         }
 350     }
 351
 352     assert(sig);
 353     return sig;
 354 }
 355
 356
 357 BitmaskSig *Parser::parse_bitmask_sig() {
 358     size_t id = read_uint();
 359
 360     BitmaskSigState *sig = lookup(bitmasks, id);
 361
 362     if (!sig) {
 363         /* parse the signature */
 364         sig = new BitmaskSigState;
 365         sig->id = id;
 366         sig->num_flags = read_uint();
 367         BitmaskFlag *flags = new BitmaskFlag[sig->num_flags];
 368         for (BitmaskFlag *it = flags; it != flags + sig->num_flags; ++it) {
 369             it->name = read_string();
 370             it->value = read_uint();
 371             if (it->value == 0 && it != flags) {
 372                 std::cerr << "warning: bitmask " << it->name << " is zero but is not first flag\n";
 373             }
 374         }
 375         sig->flags = flags;
 376         sig->offset = file->currentOffset();
 377         bitmasks[id] = sig;
 378     } else if (file->currentOffset() < sig->offset) {
 379         /* skip over the signature */
 380         int num_flags = read_uint();
 381         for (int i = 0; i < num_flags; ++i) {
 382             skip_string(); /*name */
 383             skip_uint(); /* value */
 384         }
 385     }
 386
 387     assert(sig);
 388     return sig;
 389 }
 390
 391
 392 void Parser::parse_enter(Mode mode) {
 393     unsigned thread_id;
 394
 395     if (version >= 4) {
 396         thread_id = read_uint();
 397     } else {
 398         thread_id = 0;
 399     }
 400
 401     FunctionSigFlags *sig = parse_function_sig();
 402
 403     Call *call = new Call(sig, sig->flags, thread_id);
 404
 405     call->no = next_call_no++;
 406
 407     if (parse_call_details(call, mode)) {
 408         calls.push_back(call);
 409     } else {
 410         delete call;
 411     }
 412 }
 413
 414
 415 Call *Parser::parse_leave(Mode mode) {
 416     unsigned call_no = read_uint();
 417     Call *call = NULL;
 418     for (CallList::iterator it = calls.begin(); it != calls.end(); ++it) {
 419         if ((*it)->no == call_no) {
 420             call = *it;
 421             calls.erase(it);
 422             break;
 423         }
 424     }
 425     if (!call) {
 426         return NULL;
 427     }
 428
 429     if (parse_call_details(call, mode)) {
 430         return call;
 431     } else {
 432         delete call;
 433         return NULL;
 434     }
 435 }
 436
 437
 438 bool Parser::parse_call_details(Call *call, Mode mode) {
 439     do {
 440         int c = read_byte();
 441         switch (c) {
 442         case trace::CALL_END:
 443             return true;
 444         case trace::CALL_ARG:
 445             parse_arg(call, mode);
 446             break;
 447         case trace::CALL_RET:
 448             call->ret = parse_value(mode);
 449             break;
 450         default:
 451             std::cerr << "error: ("<<call->name()<< ") unknown call detail "
 452                       << c << "\n";
 453             exit(1);
 454         case -1:
 455             return false;
 456         }
 457     } while(true);
 458 }
 459
 460
 461 /**
 462  * Make adjustments to this particular call flags.
 463  *
 464  * NOTE: This is called per-call so no string comparisons should be done here.
 465  * All name comparisons should be done when the signature is parsed instead.
 466  */
 467 void Parser::adjust_call_flags(Call *call) {
 468     // Mark glGetError() = GL_NO_ERROR as verbose
 469     if (call->sig == glGetErrorSig &&
 470         call->ret &&
 471         call->ret->toSInt() == 0) {
 472         call->flags |= CALL_FLAG_VERBOSE;
 473     }
 474 }
 475
 476 void Parser::parse_arg(Call *call, Mode mode) {
 477     unsigned index = read_uint();
 478     Value *value = parse_value(mode);
 479     if (value) {
 480         if (index >= call->args.size()) {
 481             call->args.resize(index + 1);
 482         }
 483         call->args[index] = value;
 484     }
 485 }
 486
 487
 488 Value *Parser::parse_value(void) {
 489     int c;
 490     Value *value;
 491     c = read_byte();
 492     switch (c) {
 493     case trace::TYPE_NULL:
 494         value = new Null;
 495         break;
 496     case trace::TYPE_FALSE:
 497         value = new Bool(false);
 498         break;
 499     case trace::TYPE_TRUE:
 500         value = new Bool(true);
 501         break;
 502     case trace::TYPE_SINT:
 503         value = parse_sint();
 504         break;
 505     case trace::TYPE_UINT:
 506         value = parse_uint();
 507         break;
 508     case trace::TYPE_FLOAT:
 509         value = parse_float();
 510         break;
 511     case trace::TYPE_DOUBLE:
 512         value = parse_double();
 513         break;
 514     case trace::TYPE_STRING:
 515         value = parse_string();
 516         break;
 517     case trace::TYPE_ENUM:
 518         value = parse_enum();
 519         break;
 520     case trace::TYPE_BITMASK:
 521         value = parse_bitmask();
 522         break;
 523     case trace::TYPE_ARRAY:
 524         value = parse_array();
 525         break;
 526     case trace::TYPE_STRUCT:
 527         value = parse_struct();
 528         break;
 529     case trace::TYPE_BLOB:
 530         value = parse_blob();
 531         break;
 532     case trace::TYPE_OPAQUE:
 533         value = parse_opaque();
 534         break;
 535     default:
 536         std::cerr << "error: unknown type " << c << "\n";
 537         exit(1);
 538     case -1:
 539         value = NULL;
 540         break;
 541     }
 542 #if TRACE_VERBOSE
 543     if (value) {
 544         std::cerr << "\tVALUE " << value << "\n";
 545     }
 546 #endif
 547     return value;
 548 }
 549
 550
 551 void Parser::scan_value(void) {
 552     int c = read_byte();
 553     switch (c) {
 554     case trace::TYPE_NULL:
 555     case trace::TYPE_FALSE:
 556     case trace::TYPE_TRUE:
 557         break;
 558     case trace::TYPE_SINT:
 559         scan_sint();
 560         break;
 561     case trace::TYPE_UINT:
 562         scan_uint();
 563         break;
 564     case trace::TYPE_FLOAT:
 565         scan_float();
 566         break;
 567     case trace::TYPE_DOUBLE:
 568         scan_double();
 569         break;
 570     case trace::TYPE_STRING:
 571         scan_string();
 572         break;
 573     case trace::TYPE_ENUM:
 574         scan_enum();
 575         break;
 576     case trace::TYPE_BITMASK:
 577         scan_bitmask();
 578         break;
 579     case trace::TYPE_ARRAY:
 580         scan_array();
 581         break;
 582     case trace::TYPE_STRUCT:
 583         scan_struct();
 584         break;
 585     case trace::TYPE_BLOB:
 586         scan_blob();
 587         break;
 588     case trace::TYPE_OPAQUE:
 589         scan_opaque();
 590         break;
 591     default:
 592         std::cerr << "error: unknown type " << c << "\n";
 593         exit(1);
 594     case -1:
 595         break;
 596     }
 597 }
 598
 599
 600 Value *Parser::parse_sint() {
 601     return new SInt(-(signed long long)read_uint());
 602 }
 603
 604
 605 void Parser::scan_sint() {
 606     skip_uint();
 607 }
 608
 609
 610 Value *Parser::parse_uint() {
 611     return new UInt(read_uint());
 612 }
 613
 614
 615 void Parser::scan_uint() {
 616     skip_uint();
 617 }
 618
 619
 620 Value *Parser::parse_float() {
 621     float value;
 622     file->read(&value, sizeof value);
 623     return new Float(value);
 624 }
 625
 626
 627 void Parser::scan_float() {
 628     file->skip(sizeof(float));
 629 }
 630
 631
 632 Value *Parser::parse_double() {
 633     double value;
 634     file->read(&value, sizeof value);
 635     return new Double(value);
 636 }
 637
 638
 639 void Parser::scan_double() {
 640     file->skip(sizeof(double));
 641 }
 642
 643
 644 Value *Parser::parse_string() {
 645     return new String(read_string());
 646 }
 647
 648
 649 void Parser::scan_string() {
 650     skip_string();
 651 }
 652
 653
 654 Value *Parser::parse_enum() {
 655     EnumSig *sig;
 656     signed long long value;
 657     if (version >= 3) {
 658         sig = parse_enum_sig();
 659         value = read_sint();
 660     } else {
 661         sig = parse_old_enum_sig();
 662         assert(sig->num_values == 1);
 663         value = sig->values->value;
 664     }
 665     return new Enum(sig, value);
 666 }
 667
 668
 669 void Parser::scan_enum() {
 670     if (version >= 3) {
 671         parse_enum_sig();
 672         skip_sint();
 673     } else {
 674         parse_old_enum_sig();
 675     }
 676 }
 677
 678
 679 Value *Parser::parse_bitmask() {
 680     BitmaskSig *sig = parse_bitmask_sig();
 681
 682     unsigned long long value = read_uint();
 683
 684     return new Bitmask(sig, value);
 685 }
 686
 687
 688 void Parser::scan_bitmask() {
 689     parse_bitmask_sig();
 690     skip_uint(); /* value */
 691 }
 692
 693
 694 Value *Parser::parse_array(void) {
 695     size_t len = read_uint();
 696     Array *array = new Array(len);
 697     for (size_t i = 0; i < len; ++i) {
 698         array->values[i] = parse_value();
 699     }
 700     return array;
 701 }
 702
 703
 704 void Parser::scan_array(void) {
 705     size_t len = read_uint();
 706     for (size_t i = 0; i < len; ++i) {
 707         scan_value();
 708     }
 709 }
 710
 711
 712 Value *Parser::parse_blob(void) {
 713     size_t size = read_uint();
 714     Blob *blob = new Blob(size);
 715     if (size) {
 716         file->read(blob->buf, (unsigned)size);
 717     }
 718     return blob;
 719 }
 720
 721
 722 void Parser::scan_blob(void) {
 723     size_t size = read_uint();
 724     if (size) {
 725         file->skip(size);
 726     }
 727 }
 728
 729
 730 Value *Parser::parse_struct() {
 731     StructSig *sig = parse_struct_sig();
 732     Struct *value = new Struct(sig);
 733
 734     for (size_t i = 0; i < sig->num_members; ++i) {
 735         value->members[i] = parse_value();
 736     }
 737
 738     return value;
 739 }
 740
 741
 742 void Parser::scan_struct() {
 743     StructSig *sig = parse_struct_sig();
 744     for (size_t i = 0; i < sig->num_members; ++i) {
 745         scan_value();
 746     }
 747 }
 748
 749
 750 Value *Parser::parse_opaque() {
 751     unsigned long long addr;
 752     addr = read_uint();
 753     return new Pointer(addr);
 754 }
 755
 756
 757 void Parser::scan_opaque() {
 758     skip_uint();
 759 }
 760
 761
 762 const char * Parser::read_string(void) {
 763     size_t len = read_uint();
 764     char * value = new char[len + 1];
 765     if (len) {
 766         file->read(value, (unsigned)len);
 767     }
 768     value[len] = 0;
 769 #if TRACE_VERBOSE
 770     std::cerr << "\tSTRING \"" << value << "\"\n";
 771 #endif
 772     return value;
 773 }
 774
 775
 776 void Parser::skip_string(void) {
 777     size_t len = read_uint();
 778     file->skip(len);
 779 }
 780
 781
 782 /*
 783  * For the time being, a signed int is encoded as any other value, but we here parse
 784  * it without the extra baggage of the Value class.
 785  */
 786 signed long long
 787 Parser::read_sint(void) {
 788     int c;
 789     c = read_byte();
 790     switch (c) {
 791     case trace::TYPE_SINT:
 792         return -read_uint();
 793     case trace::TYPE_UINT:
 794         return read_uint();
 795     default:
 796         std::cerr << "error: unexpected type " << c << "\n";
 797         exit(1);
 798     case -1:
 799         return 0;
 800     }
 801 }
 802
 803 void
 804 Parser::skip_sint(void) {
 805     skip_byte();
 806     skip_uint();
 807 }
 808
 809 unsigned long long Parser::read_uint(void) {
 810     unsigned long long value = 0;
 811     int c;
 812     unsigned shift = 0;
 813     do {
 814         c = file->getc();
 815         if (c == -1) {
 816             break;
 817         }
 818         value |= (unsigned long long)(c & 0x7f) << shift;
 819         shift += 7;
 820     } while(c & 0x80);
 821 #if TRACE_VERBOSE
 822     std::cerr << "\tUINT " << value << "\n";
 823 #endif
 824     return value;
 825 }
 826
 827
 828 void Parser::skip_uint(void) {
 829     int c;
 830     do {
 831         c = file->getc();
 832         if (c == -1) {
 833             break;
 834         }
 835     } while(c & 0x80);
 836 }
 837
 838
 839 inline int Parser::read_byte(void) {
 840     int c = file->getc();
 841 #if TRACE_VERBOSE
 842     if (c < 0)
 843         std::cerr << "\tEOF" << "\n";
 844     else
 845         std::cerr << "\tBYTE 0x" << std::hex << c << std::dec << "\n";
 846 #endif
 847     return c;
 848 }
 849
 850
 851 inline void Parser::skip_byte(void) {
 852     file->skip(1);
 853 }
 854
 855
 856 } /* namespace trace */