1 // Copyright 2010 Google LLC
2 //
3 // Redistribution and use in source and binary forms, with or without
4 // modification, are permitted provided that the following conditions are
5 // met:
6 //
7 // * Redistributions of source code must retain the above copyright
8 // notice, this list of conditions and the following disclaimer.
9 // * Redistributions in binary form must reproduce the above
10 // copyright notice, this list of conditions and the following disclaimer
11 // in the documentation and/or other materials provided with the
12 // distribution.
13 // * Neither the name of Google LLC nor the names of its
14 // contributors may be used to endorse or promote products derived from
15 // this software without specific prior written permission.
16 //
17 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
18 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
19 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
20 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
21 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
22 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
23 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
27 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 //
29 // map_serializers_inl.h: implementation for serializing std::map and its
30 // wrapper classes.
31 //
32 // See map_serializers.h for documentation.
33 //
34 // Author: Siyang Xie ([email protected])
35
36 #ifndef PROCESSOR_MAP_SERIALIZERS_INL_H__
37 #define PROCESSOR_MAP_SERIALIZERS_INL_H__
38
39 #include <map>
40 #include <string>
41
42 #include "processor/map_serializers.h"
43 #include "processor/simple_serializer.h"
44
45 #include "processor/address_map-inl.h"
46 #include "processor/range_map-inl.h"
47 #include "processor/contained_range_map-inl.h"
48
49 #include "processor/logging.h"
50
51 namespace google_breakpad {
52
53 template<typename Key, typename Value>
SizeOf(const std::map<Key,Value> & m)54 size_t StdMapSerializer<Key, Value>::SizeOf(
55 const std::map<Key, Value>& m) const {
56 size_t size = 0;
57 size_t header_size = (1 + m.size()) * sizeof(uint32_t);
58 size += header_size;
59
60 typename std::map<Key, Value>::const_iterator iter;
61 for (iter = m.begin(); iter != m.end(); ++iter) {
62 size += key_serializer_.SizeOf(iter->first);
63 size += value_serializer_.SizeOf(iter->second);
64 }
65 return size;
66 }
67
68 template<typename Key, typename Value>
Write(const std::map<Key,Value> & m,char * dest)69 char* StdMapSerializer<Key, Value>::Write(const std::map<Key, Value>& m,
70 char* dest) const {
71 if (!dest) {
72 BPLOG(ERROR) << "StdMapSerializer failed: write to NULL address.";
73 return NULL;
74 }
75 char* start_address = dest;
76
77 // Write header:
78 // Number of nodes.
79 dest = SimpleSerializer<uint32_t>::Write(m.size(), dest);
80 // Nodes offsets.
81 uint32_t* offsets = reinterpret_cast<uint32_t*>(dest);
82 dest += sizeof(uint32_t) * m.size();
83
84 char* key_address = dest;
85 dest += sizeof(Key) * m.size();
86
87 // Traverse map.
88 typename std::map<Key, Value>::const_iterator iter;
89 int index = 0;
90 for (iter = m.begin(); iter != m.end(); ++iter, ++index) {
91 offsets[index] = static_cast<uint32_t>(dest - start_address);
92 key_address = key_serializer_.Write(iter->first, key_address);
93 dest = value_serializer_.Write(iter->second, dest);
94 }
95 return dest;
96 }
97
98 template<typename Key, typename Value>
Serialize(const std::map<Key,Value> & m,unsigned int * size)99 char* StdMapSerializer<Key, Value>::Serialize(
100 const std::map<Key, Value>& m, unsigned int* size) const {
101 // Compute size of memory to be allocated.
102 unsigned int size_to_alloc = SizeOf(m);
103 // Allocate memory.
104 char* serialized_data = new char[size_to_alloc];
105 if (!serialized_data) {
106 BPLOG(INFO) << "StdMapSerializer memory allocation failed.";
107 if (size) *size = 0;
108 return NULL;
109 }
110 // Write serialized data into memory.
111 Write(m, serialized_data);
112
113 if (size) *size = size_to_alloc;
114 return serialized_data;
115 }
116
117 template<typename Address, typename Entry>
SizeOf(const RangeMap<Address,Entry> & m)118 size_t RangeMapSerializer<Address, Entry>::SizeOf(
119 const RangeMap<Address, Entry>& m) const {
120 size_t size = 0;
121 size_t header_size = (1 + m.map_.size()) * sizeof(uint32_t);
122 size += header_size;
123
124 typename std::map<Address, Range>::const_iterator iter;
125 for (iter = m.map_.begin(); iter != m.map_.end(); ++iter) {
126 // Size of key (high address).
127 size += address_serializer_.SizeOf(iter->first);
128 // Size of base (low address).
129 size += address_serializer_.SizeOf(iter->second.base());
130 // Size of entry.
131 size += entry_serializer_.SizeOf(iter->second.entry());
132 }
133 return size;
134 }
135
136 template<typename Address, typename Entry>
Write(const RangeMap<Address,Entry> & m,char * dest)137 char* RangeMapSerializer<Address, Entry>::Write(
138 const RangeMap<Address, Entry>& m, char* dest) const {
139 if (!dest) {
140 BPLOG(ERROR) << "RangeMapSerializer failed: write to NULL address.";
141 return NULL;
142 }
143 char* start_address = dest;
144
145 // Write header:
146 // Number of nodes.
147 dest = SimpleSerializer<uint32_t>::Write(m.map_.size(), dest);
148 // Nodes offsets.
149 uint32_t* offsets = reinterpret_cast<uint32_t*>(dest);
150 dest += sizeof(uint32_t) * m.map_.size();
151
152 char* key_address = dest;
153 dest += sizeof(Address) * m.map_.size();
154
155 // Traverse map.
156 typename std::map<Address, Range>::const_iterator iter;
157 int index = 0;
158 for (iter = m.map_.begin(); iter != m.map_.end(); ++iter, ++index) {
159 offsets[index] = static_cast<uint32_t>(dest - start_address);
160 key_address = address_serializer_.Write(iter->first, key_address);
161 dest = address_serializer_.Write(iter->second.base(), dest);
162 dest = entry_serializer_.Write(iter->second.entry(), dest);
163 }
164 return dest;
165 }
166
167 template<typename Address, typename Entry>
Serialize(const RangeMap<Address,Entry> & m,unsigned int * size)168 char* RangeMapSerializer<Address, Entry>::Serialize(
169 const RangeMap<Address, Entry>& m, unsigned int* size) const {
170 // Compute size of memory to be allocated.
171 unsigned int size_to_alloc = SizeOf(m);
172 // Allocate memory.
173 char* serialized_data = new char[size_to_alloc];
174 if (!serialized_data) {
175 BPLOG(INFO) << "RangeMapSerializer memory allocation failed.";
176 if (size) *size = 0;
177 return NULL;
178 }
179
180 // Write serialized data into memory.
181 Write(m, serialized_data);
182
183 if (size) *size = size_to_alloc;
184 return serialized_data;
185 }
186
187
188 template<class AddrType, class EntryType>
SizeOf(const ContainedRangeMap<AddrType,EntryType> * m)189 size_t ContainedRangeMapSerializer<AddrType, EntryType>::SizeOf(
190 const ContainedRangeMap<AddrType, EntryType>* m) const {
191 size_t size = 0;
192 size_t header_size = addr_serializer_.SizeOf(m->base_)
193 + entry_serializer_.SizeOf(m->entry_)
194 + sizeof(uint32_t);
195 size += header_size;
196 // In case m.map_ == NULL, we treat it as an empty map:
197 size += sizeof(uint32_t);
198 if (m->map_) {
199 size += m->map_->size() * sizeof(uint32_t);
200 typename Map::const_iterator iter;
201 for (iter = m->map_->begin(); iter != m->map_->end(); ++iter) {
202 size += addr_serializer_.SizeOf(iter->first);
203 // Recursive calculation of size:
204 size += SizeOf(iter->second);
205 }
206 }
207 return size;
208 }
209
210 template<class AddrType, class EntryType>
Write(const ContainedRangeMap<AddrType,EntryType> * m,char * dest)211 char* ContainedRangeMapSerializer<AddrType, EntryType>::Write(
212 const ContainedRangeMap<AddrType, EntryType>* m, char* dest) const {
213 if (!dest) {
214 BPLOG(ERROR) << "StdMapSerializer failed: write to NULL address.";
215 return NULL;
216 }
217 dest = addr_serializer_.Write(m->base_, dest);
218 dest = SimpleSerializer<uint32_t>::Write(entry_serializer_.SizeOf(m->entry_),
219 dest);
220 dest = entry_serializer_.Write(m->entry_, dest);
221
222 // Write map<<AddrType, ContainedRangeMap*>:
223 char* map_address = dest;
224 if (m->map_ == NULL) {
225 dest = SimpleSerializer<uint32_t>::Write(0, dest);
226 } else {
227 dest = SimpleSerializer<uint32_t>::Write(m->map_->size(), dest);
228 uint32_t* offsets = reinterpret_cast<uint32_t*>(dest);
229 dest += sizeof(uint32_t) * m->map_->size();
230
231 char* key_address = dest;
232 dest += sizeof(AddrType) * m->map_->size();
233
234 // Traverse map.
235 typename Map::const_iterator iter;
236 int index = 0;
237 for (iter = m->map_->begin(); iter != m->map_->end(); ++iter, ++index) {
238 offsets[index] = static_cast<uint32_t>(dest - map_address);
239 key_address = addr_serializer_.Write(iter->first, key_address);
240 // Recursively write.
241 dest = Write(iter->second, dest);
242 }
243 }
244 return dest;
245 }
246
247 template<class AddrType, class EntryType>
Serialize(const ContainedRangeMap<AddrType,EntryType> * m,unsigned int * size)248 char* ContainedRangeMapSerializer<AddrType, EntryType>::Serialize(
249 const ContainedRangeMap<AddrType, EntryType>* m, unsigned int* size) const {
250 unsigned int size_to_alloc = SizeOf(m);
251 // Allocating memory.
252 char* serialized_data = new char[size_to_alloc];
253 if (!serialized_data) {
254 BPLOG(INFO) << "ContainedRangeMapSerializer memory allocation failed.";
255 if (size) *size = 0;
256 return NULL;
257 }
258 Write(m, serialized_data);
259 if (size) *size = size_to_alloc;
260 return serialized_data;
261 }
262
263 } // namespace google_breakpad
264
265 #endif // PROCESSOR_MAP_SERIALIZERS_INL_H__
266