]> git.cworth.org Git - apitrace/blob - retrace_stdc.cpp
egl: Add eglimports.hpp
[apitrace] / retrace_stdc.cpp
1 /**************************************************************************
2  *
3  * Copyright 2011 Jose Fonseca
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 <assert.h>
28
29 #include <string.h>
30
31 #include "glproc.hpp"
32
33
34
35 #include "trace_parser.hpp"
36 #include "retrace.hpp"
37
38
39 namespace retrace {
40
41 struct Region
42 {
43     void *buffer;
44     unsigned long long size;
45 };
46
47 typedef std::map<unsigned long long, Region> RegionMap;
48 static RegionMap regionMap;
49
50 // Iterator to the first region that contains the address
51 static RegionMap::iterator
52 lowerBound(unsigned long long address) {
53     RegionMap::iterator it = regionMap.lower_bound(address);
54
55     while (it != regionMap.begin() &&
56            it != regionMap.end() &&
57            it->first + it->second. size > address) {
58         --it;
59     }
60
61     return it;
62 }
63
64 // Iterator to the first region that not contains the address
65 static RegionMap::iterator
66 upperBound(unsigned long long address) {
67     RegionMap::iterator it = regionMap.upper_bound(address);
68
69     while (it != regionMap.end() &&
70            it->first + it->second.size > address) {
71         ++it;
72     }
73
74     return it;
75 }
76
77 void
78 addRegion(unsigned long long address, void *buffer, unsigned long long size)
79 {
80     // Forget all regions that intersect this new one.
81     if (0) {
82         RegionMap::iterator start = lowerBound(address);
83         if (start != regionMap.end()) {
84             RegionMap::iterator stop = upperBound(address + size);
85             regionMap.erase(start, stop);
86         }
87     }
88
89     assert(buffer);
90
91     Region region;
92     region.buffer = buffer;
93     region.size = size;
94
95     regionMap[address] = region;
96 }
97
98 static RegionMap::iterator
99 lookupRegion(unsigned long long address) {
100     RegionMap::iterator it = regionMap.lower_bound(address);
101
102     if (it == regionMap.end() ||
103         it->first > address) {
104         if (it == regionMap.begin()) {
105             return regionMap.end();
106         } else {
107             --it;
108         }
109     }
110
111     assert(it->first <= address);
112     assert(it->first + it->second.size >= address);
113     return it;
114 }
115
116 void
117 delRegion(unsigned long long address) {
118     RegionMap::iterator it = lookupRegion(address);
119     if (it != regionMap.end()) {
120         regionMap.erase(it);
121     } else {
122         assert(0);
123     }
124 }
125
126
127 void
128 delRegionByPointer(void *ptr) {
129     RegionMap::iterator it = regionMap.begin();
130     while (it != regionMap.end()) {
131         if (it->second.buffer == ptr) {
132             regionMap.erase(it);
133             return;
134         }
135     }
136     assert(0);
137 }
138
139 void *
140 lookupAddress(unsigned long long address) {
141     RegionMap::iterator it = lookupRegion(address);
142     if (it != regionMap.end()) {
143         unsigned long long offset = address - it->first;
144         assert(offset < it->second.size);
145         return (char *)it->second.buffer + offset;
146     }
147
148     if (address >= 0x00400000) {
149         std::cerr << "warning: could not translate address 0x" << std::hex << address << std::dec << "\n";
150     }
151
152     return (void *)(uintptr_t)address;
153 }
154
155
156 class Translator : protected trace::Visitor
157 {
158 protected:
159     bool bind;
160
161     void *result;
162
163     void visit(trace::Null *) {
164         result = NULL;
165     }
166
167     void visit(trace::Blob *blob) {
168         result = blob->toPointer(bind);
169     }
170
171     void visit(trace::Pointer *p) {
172         result = lookupAddress(p->value);
173     }
174
175 public:
176     Translator(bool _bind) :
177         bind(_bind),
178         result(NULL)
179     {}
180
181     void * operator() (trace::Value *node) {
182         _visit(node);
183         return result;
184     }
185 };
186
187
188 void *
189 toPointer(trace::Value &value, bool bind) {
190     return Translator(bind) (&value);
191 }
192
193
194 static void retrace_malloc(trace::Call &call) {
195     size_t size = call.arg(0).toUInt();
196     unsigned long long address = call.ret->toUIntPtr();
197
198     if (!address) {
199         return;
200     }
201
202     void *buffer = malloc(size);
203     if (!buffer) {
204         std::cerr << "error: failed to allocated " << size << " bytes.";
205         return;
206     }
207
208     addRegion(address, buffer, size);
209 }
210
211
212 static void retrace_memcpy(trace::Call &call) {
213     void * dest = toPointer(call.arg(0));
214     void * src  = toPointer(call.arg(1));
215     size_t n    = call.arg(2).toUInt();
216
217     if (!dest || !src || !n) {
218         return;
219     }
220
221     memcpy(dest, src, n);
222 }
223
224
225 const retrace::Entry stdc_callbacks[] = {
226     {"malloc", &retrace_malloc},
227     {"memcpy", &retrace_memcpy},
228     {NULL, NULL}
229 };
230
231
232 } /* retrace */