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     FunctionSigFlags *sig = parse_function_sig();
 394
 395     Call *call = new Call(sig, sig->flags);
 396
 397     call->no = next_call_no++;
 398
 399     if (parse_call_details(call, mode)) {
 400         calls.push_back(call);
 401     } else {
 402         delete call;
 403     }
 404 }
 405
 406
 407 Call *Parser::parse_leave(Mode mode) {
 408     unsigned call_no = read_uint();
 409     Call *call = NULL;
 410     for (CallList::iterator it = calls.begin(); it != calls.end(); ++it) {
 411         if ((*it)->no == call_no) {
 412             call = *it;
 413             calls.erase(it);
 414             break;
 415         }
 416     }
 417     if (!call) {
 418         return NULL;
 419     }
 420
 421     if (parse_call_details(call, mode)) {
 422         return call;
 423     } else {
 424         delete call;
 425         return NULL;
 426     }
 427 }
 428
 429
 430 bool Parser::parse_call_details(Call *call, Mode mode) {
 431     do {
 432         int c = read_byte();
 433         switch (c) {
 434         case trace::CALL_END:
 435             return true;
 436         case trace::CALL_ARG:
 437             parse_arg(call, mode);
 438             break;
 439         case trace::CALL_RET:
 440             call->ret = parse_value(mode);
 441             break;
 442         default:
 443             std::cerr << "error: ("<<call->name()<< ") unknown call detail "
 444                       << c << "\n";
 445             exit(1);
 446         case -1:
 447             return false;
 448         }
 449     } while(true);
 450 }
 451
 452
 453 /**
 454  * Make adjustments to this particular call flags.
 455  *
 456  * NOTE: This is called per-call so no string comparisons should be done here.
 457  * All name comparisons should be done when the signature is parsed instead.
 458  */
 459 void Parser::adjust_call_flags(Call *call) {
 460     // Mark glGetError() = GL_NO_ERROR as verbose
 461     if (call->sig == glGetErrorSig &&
 462         call->ret &&
 463         call->ret->toSInt() == 0) {
 464         call->flags |= CALL_FLAG_VERBOSE;
 465     }
 466 }
 467
 468 void Parser::parse_arg(Call *call, Mode mode) {
 469     unsigned index = read_uint();
 470     Value *value = parse_value(mode);
 471     if (value) {
 472         if (index >= call->args.size()) {
 473             call->args.resize(index + 1);
 474         }
 475         call->args[index] = value;
 476     }
 477 }
 478
 479
 480 Value *Parser::parse_value(void) {
 481     int c;
 482     Value *value;
 483     c = read_byte();
 484     switch (c) {
 485     case trace::TYPE_NULL:
 486         value = new Null;
 487         break;
 488     case trace::TYPE_FALSE:
 489         value = new Bool(false);
 490         break;
 491     case trace::TYPE_TRUE:
 492         value = new Bool(true);
 493         break;
 494     case trace::TYPE_SINT:
 495         value = parse_sint();
 496         break;
 497     case trace::TYPE_UINT:
 498         value = parse_uint();
 499         break;
 500     case trace::TYPE_FLOAT:
 501         value = parse_float();
 502         break;
 503     case trace::TYPE_DOUBLE:
 504         value = parse_double();
 505         break;
 506     case trace::TYPE_STRING:
 507         value = parse_string();
 508         break;
 509     case trace::TYPE_ENUM:
 510         value = parse_enum();
 511         break;
 512     case trace::TYPE_BITMASK:
 513         value = parse_bitmask();
 514         break;
 515     case trace::TYPE_ARRAY:
 516         value = parse_array();
 517         break;
 518     case trace::TYPE_STRUCT:
 519         value = parse_struct();
 520         break;
 521     case trace::TYPE_BLOB:
 522         value = parse_blob();
 523         break;
 524     case trace::TYPE_OPAQUE:
 525         value = parse_opaque();
 526         break;
 527     default:
 528         std::cerr << "error: unknown type " << c << "\n";
 529         exit(1);
 530     case -1:
 531         value = NULL;
 532         break;
 533     }
 534 #if TRACE_VERBOSE
 535     if (value) {
 536         std::cerr << "\tVALUE " << value << "\n";
 537     }
 538 #endif
 539     return value;
 540 }
 541
 542
 543 void Parser::scan_value(void) {
 544     int c = read_byte();
 545     switch (c) {
 546     case trace::TYPE_NULL:
 547     case trace::TYPE_FALSE:
 548     case trace::TYPE_TRUE:
 549         break;
 550     case trace::TYPE_SINT:
 551         scan_sint();
 552         break;
 553     case trace::TYPE_UINT:
 554         scan_uint();
 555         break;
 556     case trace::TYPE_FLOAT:
 557         scan_float();
 558         break;
 559     case trace::TYPE_DOUBLE:
 560         scan_double();
 561         break;
 562     case trace::TYPE_STRING:
 563         scan_string();
 564         break;
 565     case trace::TYPE_ENUM:
 566         scan_enum();
 567         break;
 568     case trace::TYPE_BITMASK:
 569         scan_bitmask();
 570         break;
 571     case trace::TYPE_ARRAY:
 572         scan_array();
 573         break;
 574     case trace::TYPE_STRUCT:
 575         scan_struct();
 576         break;
 577     case trace::TYPE_BLOB:
 578         scan_blob();
 579         break;
 580     case trace::TYPE_OPAQUE:
 581         scan_opaque();
 582         break;
 583     default:
 584         std::cerr << "error: unknown type " << c << "\n";
 585         exit(1);
 586     case -1:
 587         break;
 588     }
 589 }
 590
 591
 592 Value *Parser::parse_sint() {
 593     return new SInt(-(signed long long)read_uint());
 594 }
 595
 596
 597 void Parser::scan_sint() {
 598     skip_uint();
 599 }
 600
 601
 602 Value *Parser::parse_uint() {
 603     return new UInt(read_uint());
 604 }
 605
 606
 607 void Parser::scan_uint() {
 608     skip_uint();
 609 }
 610
 611
 612 Value *Parser::parse_float() {
 613     float value;
 614     file->read(&value, sizeof value);
 615     return new Float(value);
 616 }
 617
 618
 619 void Parser::scan_float() {
 620     file->skip(sizeof(float));
 621 }
 622
 623
 624 Value *Parser::parse_double() {
 625     double value;
 626     file->read(&value, sizeof value);
 627     return new Double(value);
 628 }
 629
 630
 631 void Parser::scan_double() {
 632     file->skip(sizeof(double));
 633 }
 634
 635
 636 Value *Parser::parse_string() {
 637     return new String(read_string());
 638 }
 639
 640
 641 void Parser::scan_string() {
 642     skip_string();
 643 }
 644
 645
 646 Value *Parser::parse_enum() {
 647     EnumSig *sig;
 648     signed long long value;
 649     if (version >= 3) {
 650         sig = parse_enum_sig();
 651         value = read_sint();
 652     } else {
 653         sig = parse_old_enum_sig();
 654         assert(sig->num_values == 1);
 655         value = sig->values->value;
 656     }
 657     return new Enum(sig, value);
 658 }
 659
 660
 661 void Parser::scan_enum() {
 662     if (version >= 3) {
 663         parse_enum_sig();
 664         skip_sint();
 665     } else {
 666         parse_old_enum_sig();
 667     }
 668 }
 669
 670
 671 Value *Parser::parse_bitmask() {
 672     BitmaskSig *sig = parse_bitmask_sig();
 673
 674     unsigned long long value = read_uint();
 675
 676     return new Bitmask(sig, value);
 677 }
 678
 679
 680 void Parser::scan_bitmask() {
 681     parse_bitmask_sig();
 682     skip_uint(); /* value */
 683 }
 684
 685
 686 Value *Parser::parse_array(void) {
 687     size_t len = read_uint();
 688     Array *array = new Array(len);
 689     for (size_t i = 0; i < len; ++i) {
 690         array->values[i] = parse_value();
 691     }
 692     return array;
 693 }
 694
 695
 696 void Parser::scan_array(void) {
 697     size_t len = read_uint();
 698     for (size_t i = 0; i < len; ++i) {
 699         scan_value();
 700     }
 701 }
 702
 703
 704 Value *Parser::parse_blob(void) {
 705     size_t size = read_uint();
 706     Blob *blob = new Blob(size);
 707     if (size) {
 708         file->read(blob->buf, (unsigned)size);
 709     }
 710     return blob;
 711 }
 712
 713
 714 void Parser::scan_blob(void) {
 715     size_t size = read_uint();
 716     if (size) {
 717         file->skip(size);
 718     }
 719 }
 720
 721
 722 Value *Parser::parse_struct() {
 723     StructSig *sig = parse_struct_sig();
 724     Struct *value = new Struct(sig);
 725
 726     for (size_t i = 0; i < sig->num_members; ++i) {
 727         value->members[i] = parse_value();
 728     }
 729
 730     return value;
 731 }
 732
 733
 734 void Parser::scan_struct() {
 735     StructSig *sig = parse_struct_sig();
 736     for (size_t i = 0; i < sig->num_members; ++i) {
 737         scan_value();
 738     }
 739 }
 740
 741
 742 Value *Parser::parse_opaque() {
 743     unsigned long long addr;
 744     addr = read_uint();
 745     return new Pointer(addr);
 746 }
 747
 748
 749 void Parser::scan_opaque() {
 750     skip_uint();
 751 }
 752
 753
 754 const char * Parser::read_string(void) {
 755     size_t len = read_uint();
 756     char * value = new char[len + 1];
 757     if (len) {
 758         file->read(value, (unsigned)len);
 759     }
 760     value[len] = 0;
 761 #if TRACE_VERBOSE
 762     std::cerr << "\tSTRING \"" << value << "\"\n";
 763 #endif
 764     return value;
 765 }
 766
 767
 768 void Parser::skip_string(void) {
 769     size_t len = read_uint();
 770     file->skip(len);
 771 }
 772
 773
 774 /*
 775  * For the time being, a signed int is encoded as any other value, but we here parse
 776  * it without the extra baggage of the Value class.
 777  */
 778 signed long long
 779 Parser::read_sint(void) {
 780     int c;
 781     c = read_byte();
 782     switch (c) {
 783     case trace::TYPE_SINT:
 784         return -read_uint();
 785     case trace::TYPE_UINT:
 786         return read_uint();
 787     default:
 788         std::cerr << "error: unexpected type " << c << "\n";
 789         exit(1);
 790     case -1:
 791         return 0;
 792     }
 793 }
 794
 795 void
 796 Parser::skip_sint(void) {
 797     skip_byte();
 798     skip_uint();
 799 }
 800
 801 unsigned long long Parser::read_uint(void) {
 802     unsigned long long value = 0;
 803     int c;
 804     unsigned shift = 0;
 805     do {
 806         c = file->getc();
 807         if (c == -1) {
 808             break;
 809         }
 810         value |= (unsigned long long)(c & 0x7f) << shift;
 811         shift += 7;
 812     } while(c & 0x80);
 813 #if TRACE_VERBOSE
 814     std::cerr << "\tUINT " << value << "\n";
 815 #endif
 816     return value;
 817 }
 818
 819
 820 void Parser::skip_uint(void) {
 821     int c;
 822     do {
 823         c = file->getc();
 824         if (c == -1) {
 825             break;
 826         }
 827     } while(c & 0x80);
 828 }
 829
 830
 831 inline int Parser::read_byte(void) {
 832     int c = file->getc();
 833 #if TRACE_VERBOSE
 834     if (c < 0)
 835         std::cerr << "\tEOF" << "\n";
 836     else
 837         std::cerr << "\tBYTE 0x" << std::hex << c << std::dec << "\n";
 838 #endif
 839     return c;
 840 }
 841
 842
 843 inline void Parser::skip_byte(void) {
 844     file->skip(1);
 845 }
 846
 847
 848 } /* namespace trace */