git.cworth.org Git - apitrace/blob - trace_parser.hpp

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