git.cworth.org Git - apitrace/blob - common/trace_model.cpp

   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 #include "trace_model.hpp"
  28
  29
  30 namespace trace {
  31
  32
  33 Call::~Call() {
  34     for (unsigned i = 0; i < args.size(); ++i) {
  35         delete args[i].value;
  36     }
  37
  38     if (ret) {
  39         delete ret;
  40     }
  41 }
  42
  43
  44 String::~String() {
  45     delete [] value;
  46 }
  47
  48
  49 Struct::~Struct() {
  50     for (std::vector<Value *>::iterator it = members.begin(); it != members.end(); ++it) {
  51         delete *it;
  52     }
  53 }
  54
  55
  56 Array::~Array() {
  57     for (std::vector<Value *>::iterator it = values.begin(); it != values.end(); ++it) {
  58         delete *it;
  59     }
  60 }
  61
  62 Blob::~Blob() {
  63     // Blobs are often bound and referred during many calls, so we can't delete
  64     // them here in that case.
  65     //
  66     // Once bound there is no way to know when they were unbound, which
  67     // effectively means we have to leak them.  A better solution would be to
  68     // keep a list of bound pointers, and defer the destruction to when the
  69     // trace in question has been fully processed.
  70     if (!bound) {
  71         delete [] buf;
  72     }
  73 }
  74
  75 StackFrame::~StackFrame() {
  76     if (module != NULL) {
  77         delete module;
  78     }
  79     if (function != NULL) {
  80         delete function;
  81     }
  82     if (filename != NULL) {
  83         delete filename;
  84     }
  85     if (linenumber != NULL) {
  86         delete linenumber;
  87     }
  88     if (offset != NULL) {
  89         delete offset;
  90     }
  91 }
  92
  93 Backtrace::~Backtrace() {
  94     for (int i = 0; i < frames.size(); i++) {
  95         delete frames[i];
  96     }
  97 }
  98
  99 // bool cast
 100 bool Null   ::toBool(void) const { return false; }
 101 bool Bool   ::toBool(void) const { return value; }
 102 bool SInt   ::toBool(void) const { return value != 0; }
 103 bool UInt   ::toBool(void) const { return value != 0; }
 104 bool Float  ::toBool(void) const { return value != 0; }
 105 bool Double ::toBool(void) const { return value != 0; }
 106 bool String ::toBool(void) const { return true; }
 107 bool Struct ::toBool(void) const { return true; }
 108 bool Array  ::toBool(void) const { return true; }
 109 bool Blob   ::toBool(void) const { return true; }
 110 bool Pointer::toBool(void) const { return value != 0; }
 111 bool Repr   ::toBool(void) const { return static_cast<bool>(machineValue); }
 112
 113
 114 // signed integer cast
 115 signed long long Value  ::toSInt(void) const { assert(0); return 0; }
 116 signed long long Null   ::toSInt(void) const { return 0; }
 117 signed long long Bool   ::toSInt(void) const { return static_cast<signed long long>(value); }
 118 signed long long SInt   ::toSInt(void) const { return value; }
 119 signed long long UInt   ::toSInt(void) const { assert(static_cast<signed long long>(value) >= 0); return static_cast<signed long long>(value); }
 120 signed long long Float  ::toSInt(void) const { return static_cast<signed long long>(value); }
 121 signed long long Double ::toSInt(void) const { return static_cast<signed long long>(value); }
 122 signed long long Repr   ::toSInt(void) const { return machineValue->toSInt(); }
 123
 124
 125 // unsigned integer cast
 126 unsigned long long Value  ::toUInt(void) const { assert(0); return 0; }
 127 unsigned long long Null   ::toUInt(void) const { return 0; }
 128 unsigned long long Bool   ::toUInt(void) const { return static_cast<unsigned long long>(value); }
 129 unsigned long long SInt   ::toUInt(void) const { assert(value >= 0); return static_cast<signed long long>(value); }
 130 unsigned long long UInt   ::toUInt(void) const { return value; }
 131 unsigned long long Float  ::toUInt(void) const { return static_cast<unsigned long long>(value); }
 132 unsigned long long Double ::toUInt(void) const { return static_cast<unsigned long long>(value); }
 133 unsigned long long Repr   ::toUInt(void) const { return machineValue->toUInt(); }
 134
 135
 136 // floating point cast
 137 float Value  ::toFloat(void) const { assert(0); return 0; }
 138 float Null   ::toFloat(void) const { return 0; }
 139 float Bool   ::toFloat(void) const { return static_cast<float>(value); }
 140 float SInt   ::toFloat(void) const { return static_cast<float>(value); }
 141 float UInt   ::toFloat(void) const { return static_cast<float>(value); }
 142 float Float  ::toFloat(void) const { return value; }
 143 float Double ::toFloat(void) const { return value; }
 144 float Repr   ::toFloat(void) const { return machineValue->toFloat(); }
 145
 146
 147 // floating point cast
 148 double Value  ::toDouble(void) const { assert(0); return 0; }
 149 double Null   ::toDouble(void) const { return 0; }
 150 double Bool   ::toDouble(void) const { return static_cast<double>(value); }
 151 double SInt   ::toDouble(void) const { return static_cast<double>(value); }
 152 double UInt   ::toDouble(void) const { return static_cast<double>(value); }
 153 double Float  ::toDouble(void) const { return value; }
 154 double Double ::toDouble(void) const { return value; }
 155 double Repr   ::toDouble(void) const { return machineValue->toDouble(); }
 156
 157
 158 // pointer cast
 159 void * Value  ::toPointer(void) const { assert(0); return NULL; }
 160 void * Null   ::toPointer(void) const { return NULL; }
 161 void * Blob   ::toPointer(void) const { return buf; }
 162 void * Pointer::toPointer(void) const { return (void *)value; }
 163 void * Repr   ::toPointer(void) const { return machineValue->toPointer(); }
 164
 165 void * Value  ::toPointer(bool bind) { assert(0); return NULL; }
 166 void * Null   ::toPointer(bool bind) { return NULL; }
 167 void * Blob   ::toPointer(bool bind) { if (bind) bound = true; return buf; }
 168 void * Pointer::toPointer(bool bind) { return (void *)value; }
 169 void * Repr   ::toPointer(bool bind) { return machineValue->toPointer(bind); }
 170
 171
 172 // unsigned int pointer cast
 173 unsigned long long Value  ::toUIntPtr(void) const { assert(0); return 0; }
 174 unsigned long long Null   ::toUIntPtr(void) const { return 0; }
 175 unsigned long long Pointer::toUIntPtr(void) const { return value; }
 176 unsigned long long Repr   ::toUIntPtr(void) const { return machineValue->toUIntPtr(); }
 177
 178
 179 // string cast
 180 const char * Value ::toString(void) const { assert(0); return NULL; }
 181 const char * Null  ::toString(void) const { return NULL; }
 182 const char * String::toString(void) const { return value; }
 183 const char * Repr  ::toString(void) const { return machineValue->toString(); }
 184
 185
 186 // virtual Value::visit()
 187 void Null   ::visit(Visitor &visitor) { visitor.visit(this); }
 188 void Bool   ::visit(Visitor &visitor) { visitor.visit(this); }
 189 void SInt   ::visit(Visitor &visitor) { visitor.visit(this); }
 190 void UInt   ::visit(Visitor &visitor) { visitor.visit(this); }
 191 void Float  ::visit(Visitor &visitor) { visitor.visit(this); }
 192 void Double ::visit(Visitor &visitor) { visitor.visit(this); }
 193 void String ::visit(Visitor &visitor) { visitor.visit(this); }
 194 void Enum   ::visit(Visitor &visitor) { visitor.visit(this); }
 195 void Bitmask::visit(Visitor &visitor) { visitor.visit(this); }
 196 void Struct ::visit(Visitor &visitor) { visitor.visit(this); }
 197 void Array  ::visit(Visitor &visitor) { visitor.visit(this); }
 198 void Blob   ::visit(Visitor &visitor) { visitor.visit(this); }
 199 void Pointer::visit(Visitor &visitor) { visitor.visit(this); }
 200 void Repr   ::visit(Visitor &visitor) { visitor.visit(this); }
 201
 202 void Backtrace::addFrame(StackFrame* frame) {
 203     frames.push_back(frame);
 204 }
 205
 206 void Visitor::visit(Null *) { assert(0); }
 207 void Visitor::visit(Bool *) { assert(0); }
 208 void Visitor::visit(SInt *) { assert(0); }
 209 void Visitor::visit(UInt *) { assert(0); }
 210 void Visitor::visit(Float *) { assert(0); }
 211 void Visitor::visit(Double *) { assert(0); }
 212 void Visitor::visit(String *) { assert(0); }
 213 void Visitor::visit(Enum *node) { assert(0); }
 214 void Visitor::visit(Bitmask *node) { visit(static_cast<UInt *>(node)); }
 215 void Visitor::visit(Struct *) { assert(0); }
 216 void Visitor::visit(Array *) { assert(0); }
 217 void Visitor::visit(Blob *) { assert(0); }
 218 void Visitor::visit(Pointer *) { assert(0); }
 219 void Visitor::visit(Repr *node) { node->machineValue->visit(*this); }
 220 void Visitor::visit(Backtrace *) { assert(0); }
 221 void Visitor::visit(StackFrame *) { assert(0); }
 222
 223
 224 static Null null;
 225
 226 const Value & Value::operator[](size_t index) const {
 227     const Array *array = dynamic_cast<const Array *>(this);
 228     if (array) {
 229         if (index < array->values.size()) {
 230             return *array->values[index];
 231         }
 232     }
 233     return null;
 234 }
 235
 236 } /* namespace trace */