git.cworth.org Git - apitrace/blob - common/trace_model.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 /*
  27  * Object hierarchy for describing the traces in memory.
  28  */
  29
  30 #ifndef _TRACE_MODEL_HPP_
  31 #define _TRACE_MODEL_HPP_
  32
  33
  34 #include <assert.h>
  35
  36 #include <map>
  37 #include <vector>
  38 #include <iostream>
  39
  40
  41 namespace Trace {
  42
  43
  44 typedef unsigned Id;
  45
  46
  47 struct FunctionSig {
  48     Id id;
  49     const char *name;
  50     unsigned num_args;
  51     const char **arg_names;
  52 };
  53
  54
  55 struct StructSig {
  56     Id id;
  57     const char *name;
  58     unsigned num_members;
  59     const char **member_names;
  60 };
  61
  62
  63 struct EnumSig {
  64     Id id;
  65     const char *name;
  66     signed long long value;
  67 };
  68
  69
  70 struct BitmaskFlag {
  71     const char *name;
  72     unsigned long long value;
  73 };
  74
  75
  76 struct BitmaskSig {
  77     Id id;
  78     unsigned num_flags;
  79     const BitmaskFlag *flags;
  80 };
  81
  82
  83 class Visitor;
  84
  85
  86 class Value
  87 {
  88 public:
  89     virtual ~Value() {}
  90     virtual void visit(Visitor &visitor) = 0;
  91
  92     virtual bool toBool(void) const = 0;
  93     virtual signed long long toSInt(void) const;
  94     virtual unsigned long long toUInt(void) const;
  95     virtual float toFloat(void) const;
  96     virtual double toDouble(void) const;
  97
  98     virtual void *toPointer(void) const;
  99     virtual void *toPointer(bool bind);
 100     virtual unsigned long long toUIntPtr(void) const;
 101     virtual const char *toString(void) const;
 102
 103     const Value & operator[](size_t index) const;
 104
 105     void dump(std::ostream &os, bool color=true);
 106 };
 107
 108
 109 class Null : public Value
 110 {
 111 public:
 112     bool toBool(void) const;
 113     signed long long toSInt(void) const;
 114     unsigned long long toUInt(void) const;
 115     virtual float toFloat(void) const;
 116     virtual double toDouble(void) const;
 117     void *toPointer(void) const;
 118     void *toPointer(bool bind);
 119     unsigned long long toUIntPtr(void) const;
 120     const char *toString(void) const;
 121     void visit(Visitor &visitor);
 122 };
 123
 124
 125 class Bool : public Value
 126 {
 127 public:
 128     Bool(bool _value) : value(_value) {}
 129
 130     bool toBool(void) const;
 131     signed long long toSInt(void) const;
 132     unsigned long long toUInt(void) const;
 133     virtual float toFloat(void) const;
 134     virtual double toDouble(void) const;
 135     void visit(Visitor &visitor);
 136
 137     bool value;
 138 };
 139
 140
 141 class SInt : public Value
 142 {
 143 public:
 144     SInt(signed long long _value) : value(_value) {}
 145
 146     bool toBool(void) const;
 147     signed long long toSInt(void) const;
 148     unsigned long long toUInt(void) const;
 149     virtual float toFloat(void) const;
 150     virtual double toDouble(void) const;
 151     void visit(Visitor &visitor);
 152
 153     signed long long value;
 154 };
 155
 156
 157 class UInt : public Value
 158 {
 159 public:
 160     UInt(unsigned long long _value) : value(_value) {}
 161
 162     bool toBool(void) const;
 163     signed long long toSInt(void) const;
 164     unsigned long long toUInt(void) const;
 165     virtual float toFloat(void) const;
 166     virtual double toDouble(void) const;
 167     void visit(Visitor &visitor);
 168
 169     unsigned long long value;
 170 };
 171
 172
 173 class Float : public Value
 174 {
 175 public:
 176     Float(double _value) : value(_value) {}
 177
 178     bool toBool(void) const;
 179     signed long long toSInt(void) const;
 180     unsigned long long toUInt(void) const;
 181     virtual float toFloat(void) const;
 182     virtual double toDouble(void) const;
 183     void visit(Visitor &visitor);
 184
 185     double value;
 186 };
 187
 188
 189 class String : public Value
 190 {
 191 public:
 192     String(const char * _value) : value(_value) {}
 193     ~String();
 194
 195     bool toBool(void) const;
 196     const char *toString(void) const;
 197     void visit(Visitor &visitor);
 198
 199     const char * value;
 200 };
 201
 202
 203 class Enum : public Value
 204 {
 205 public:
 206     Enum(const EnumSig *_sig) : sig(_sig) {}
 207
 208     bool toBool(void) const;
 209     signed long long toSInt(void) const;
 210     unsigned long long toUInt(void) const;
 211     virtual float toFloat(void) const;
 212     virtual double toDouble(void) const;
 213     void visit(Visitor &visitor);
 214
 215     const EnumSig *sig;
 216 };
 217
 218
 219 class Bitmask : public UInt
 220 {
 221 public:
 222     Bitmask(const BitmaskSig *_sig, unsigned long long _value) : UInt(_value), sig(_sig) {}
 223
 224     void visit(Visitor &visitor);
 225
 226     const BitmaskSig *sig;
 227 };
 228
 229
 230 class Struct : public Value
 231 {
 232 public:
 233     Struct(StructSig *_sig) : sig(_sig), members(_sig->num_members) { }
 234     ~Struct();
 235
 236     bool toBool(void) const;
 237     void visit(Visitor &visitor);
 238
 239     const StructSig *sig;
 240     std::vector<Value *> members;
 241 };
 242
 243
 244 class Array : public Value
 245 {
 246 public:
 247     Array(size_t len) : values(len) {}
 248     ~Array();
 249
 250     bool toBool(void) const;
 251     void visit(Visitor &visitor);
 252
 253     std::vector<Value *> values;
 254 };
 255
 256
 257 class Blob : public Value
 258 {
 259 public:
 260     Blob(size_t _size) {
 261         size = _size;
 262         buf = new char[_size];
 263         bound = false;
 264     }
 265
 266     ~Blob();
 267
 268     bool toBool(void) const;
 269     void *toPointer(void) const;
 270     void *toPointer(bool bind);
 271     void visit(Visitor &visitor);
 272
 273     size_t size;
 274     char *buf;
 275     bool bound;
 276 };
 277
 278
 279 class Pointer : public UInt
 280 {
 281 public:
 282     Pointer(unsigned long long value) : UInt(value) {}
 283
 284     bool toBool(void) const;
 285     void *toPointer(void) const;
 286     void *toPointer(bool bind);
 287     unsigned long long toUIntPtr(void) const;
 288     void visit(Visitor &visitor);
 289 };
 290
 291
 292 class Visitor
 293 {
 294 public:
 295     virtual void visit(Null *);
 296     virtual void visit(Bool *);
 297     virtual void visit(SInt *);
 298     virtual void visit(UInt *);
 299     virtual void visit(Float *);
 300     virtual void visit(String *);
 301     virtual void visit(Enum *);
 302     virtual void visit(Bitmask *);
 303     virtual void visit(Struct *);
 304     virtual void visit(Array *);
 305     virtual void visit(Blob *);
 306     virtual void visit(Pointer *);
 307
 308 protected:
 309     inline void _visit(Value *value) {
 310         if (value) {
 311             value->visit(*this);
 312         }
 313     }
 314 };
 315
 316
 317 inline std::ostream & operator <<(std::ostream &os, Value *value) {
 318     if (value) {
 319         value->dump(os);
 320     }
 321     return os;
 322 }
 323
 324
 325 class Call
 326 {
 327 public:
 328     unsigned no;
 329     const FunctionSig *sig;
 330     std::vector<Value *> args;
 331     Value *ret;
 332
 333     Call(FunctionSig *_sig) : sig(_sig), args(_sig->num_args), ret(0) { }
 334     ~Call();
 335
 336     inline const char * name(void) const {
 337         return sig->name;
 338     }
 339
 340     inline Value & arg(unsigned index) {
 341         assert(index < args.size());
 342         return *(args[index]);
 343     }
 344
 345     void dump(std::ostream &os, bool color=true);
 346 };
 347
 348
 349 inline std::ostream & operator <<(std::ostream &os, Call &call) {
 350     call.dump(os);
 351     return os;
 352 }
 353
 354
 355 } /* namespace Trace */
 356
 357 #endif /* _TRACE_MODEL_HPP_ */