1 /*
2  * TargetValue.cpp -- Access to target values using OMPD callbacks
3  */
4 
5 //===----------------------------------------------------------------------===//
6 //
7 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
8 // See https://llvm.org/LICENSE.txt for license information.
9 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #include "TargetValue.h"
14 #include "Debug.h"
15 #include <cstring>
16 #include <fstream>
17 #include <iostream>
18 #include <sstream>
19 
20 const ompd_callbacks_t *TValue::callbacks = NULL;
21 ompd_device_type_sizes_t TValue::type_sizes;
22 
23 inline int ompd_sizeof(ompd_target_prim_types_t t) {
24   assert(t != ompd_type_max && "ompd_type_max should not be used anywhere");
25   assert(t != ompd_type_invalid && "request size of invalid type");
26 
27   return (((char *)&TValue::type_sizes)[(int)t]);
28 }
29 
30 TType &TTypeFactory::getType(ompd_address_space_context_t *context,
31                              const char *typeName, ompd_addr_t segment) {
32   TType empty(true);
33 
34   if (ttypes.find(context) == ttypes.end()) {
35     std::map<const char *, TType> empty;
36     ttypes[context] = empty;
37   }
38 
39   auto t = ttypes.find(context);
40   auto i = t->second.find(typeName);
41   if (i == t->second.end())
42     i = t->second.insert(
43         i, std::make_pair(typeName, TType(context, typeName, segment)));
44   else
45     i->second.context = context;
46 
47   return i->second;
48 }
49 
50 TType::TType(ompd_address_space_context_t *_context, const char *_typeName,
51              ompd_addr_t _segment)
52     : typeSize(0), fieldOffsets(), descSegment(_segment), typeName(_typeName),
53       context(_context), isvoid(false) {}
54 
55 ompd_rc_t TType::getSize(ompd_size_t *size) {
56   ompd_rc_t ret = ompd_rc_ok;
57   if (typeSize == 0) {
58     ompd_address_t symbolAddr;
59     ompd_size_t tmpSize;
60     std::stringstream ss;
61     ss << "ompd_sizeof__" << typeName;
62 
63     ret = TValue::callbacks->symbol_addr_lookup(context, NULL, ss.str().c_str(),
64                                                 &symbolAddr, NULL);
65     if (ret != ompd_rc_ok) {
66       dout << "missing symbol " << ss.str()
67            << " add this to ompd-specific.h:\nOMPD_SIZEOF(" << typeName
68            << ") \\" << std::endl;
69       return ret;
70     }
71 
72     symbolAddr.segment = descSegment;
73 
74     ret = TValue::callbacks->read_memory(
75         context, NULL, &symbolAddr, 1 * TValue::type_sizes.sizeof_long_long,
76         &(tmpSize));
77     if (ret != ompd_rc_ok)
78       return ret;
79     ret = TValue::callbacks->device_to_host(
80         context, &tmpSize, TValue::type_sizes.sizeof_long_long, 1, &(typeSize));
81   }
82   *size = typeSize;
83   return ret;
84 }
85 
86 ompd_rc_t TType::getBitfieldMask(const char *fieldName,
87                                  uint64_t *bitfieldmask) {
88   ompd_rc_t ret = ompd_rc_ok;
89   auto i = bitfieldMasks.find(fieldName);
90   if (i == bitfieldMasks.end()) {
91     uint64_t tmpMask, bitfieldMask;
92     ompd_address_t symbolAddr;
93     std::stringstream ss;
94     ss << "ompd_bitfield__" << typeName << "__" << fieldName;
95     ret = TValue::callbacks->symbol_addr_lookup(context, NULL, ss.str().c_str(),
96                                                 &symbolAddr, NULL);
97     if (ret != ompd_rc_ok) {
98       dout << "missing symbol " << ss.str()
99            << " add this to ompd-specific.h:\nOMPD_BITFIELD(" << typeName << ","
100            << fieldName << ") \\" << std::endl;
101       return ret;
102     }
103     symbolAddr.segment = descSegment;
104 
105     ret = TValue::callbacks->read_memory(
106         context, NULL, &symbolAddr, 1 * TValue::type_sizes.sizeof_long_long,
107         &(tmpMask));
108     if (ret != ompd_rc_ok)
109       return ret;
110     ret = TValue::callbacks->device_to_host(context, &(tmpMask),
111                                             TValue::type_sizes.sizeof_long_long,
112                                             1, &(bitfieldMask));
113     if (ret != ompd_rc_ok) {
114       return ret;
115     }
116     i = bitfieldMasks.insert(i, std::make_pair(fieldName, bitfieldMask));
117   }
118   *bitfieldmask = i->second;
119   return ret;
120 }
121 
122 ompd_rc_t TType::getElementOffset(const char *fieldName, ompd_size_t *offset) {
123   ompd_rc_t ret = ompd_rc_ok;
124   auto i = fieldOffsets.find(fieldName);
125   if (i == fieldOffsets.end()) {
126     ompd_size_t tmpOffset, fieldOffset;
127     ompd_address_t symbolAddr;
128     std::stringstream ss;
129     ss << "ompd_access__" << typeName << "__" << fieldName;
130 
131     ret = TValue::callbacks->symbol_addr_lookup(context, NULL, ss.str().c_str(),
132                                                 &symbolAddr, NULL);
133     if (ret != ompd_rc_ok) {
134       dout << "missing symbol " << ss.str()
135            << " add this to ompd-specific.h:\nOMPD_ACCESS(" << typeName << ","
136            << fieldName << ") \\" << std::endl;
137       return ret;
138     }
139     symbolAddr.segment = descSegment;
140 
141     ret = TValue::callbacks->read_memory(
142         context, NULL, &symbolAddr, 1 * TValue::type_sizes.sizeof_long_long,
143         &(tmpOffset));
144     if (ret != ompd_rc_ok)
145       return ret;
146     ret = TValue::callbacks->device_to_host(context, &(tmpOffset),
147                                             TValue::type_sizes.sizeof_long_long,
148                                             1, &fieldOffset);
149     if (ret != ompd_rc_ok) {
150       return ret;
151     }
152     i = fieldOffsets.insert(i, std::make_pair(fieldName, fieldOffset));
153   }
154   *offset = i->second;
155   return ret;
156 }
157 
158 ompd_rc_t TType::getElementSize(const char *fieldName, ompd_size_t *size) {
159   ompd_rc_t ret = ompd_rc_ok;
160   auto i = fieldSizes.find(fieldName);
161   if (i == fieldSizes.end()) {
162     ompd_size_t tmpOffset, fieldSize;
163     ompd_address_t symbolAddr;
164     std::stringstream ss;
165     ss << "ompd_sizeof__" << typeName << "__" << fieldName;
166 
167     ret = TValue::callbacks->symbol_addr_lookup(context, NULL, ss.str().c_str(),
168                                                 &symbolAddr, NULL);
169     if (ret != ompd_rc_ok) {
170       dout << "missing symbol " << ss.str()
171            << " add this to ompd-specific.h:\nOMPD_ACCESS(" << typeName << ","
172            << fieldName << ") \\" << std::endl;
173       return ret;
174     }
175     symbolAddr.segment = descSegment;
176 
177     ret = TValue::callbacks->read_memory(
178         context, NULL, &symbolAddr, 1 * TValue::type_sizes.sizeof_long_long,
179         &(tmpOffset));
180     if (ret != ompd_rc_ok)
181       return ret;
182     ret = TValue::callbacks->device_to_host(context, &tmpOffset,
183                                             TValue::type_sizes.sizeof_long_long,
184                                             1, &fieldSize);
185     if (ret != ompd_rc_ok) {
186       return ret;
187     }
188     i = fieldSizes.insert(i, std::make_pair(fieldName, fieldSize));
189   }
190   *size = i->second;
191   return ret;
192 }
193 
194 TValue::TValue(ompd_address_space_context_t *_context,
195                ompd_thread_context_t *_tcontext, const char *_valueName,
196                ompd_addr_t segment)
197     : errorState(ompd_rc_ok), type(&nullType), pointerLevel(0),
198       context(_context), tcontext(_tcontext), fieldSize(0) {
199   errorState.errorCode = callbacks->symbol_addr_lookup(
200       context, tcontext, _valueName, &symbolAddr, NULL);
201   symbolAddr.segment = segment;
202 }
203 
204 TValue::TValue(ompd_address_space_context_t *_context,
205                ompd_thread_context_t *_tcontext, ompd_address_t addr)
206     : errorState(ompd_rc_ok), type(&nullType), pointerLevel(0),
207       context(_context), tcontext(_tcontext), symbolAddr(addr), fieldSize(0) {
208   if (addr.address == 0)
209     errorState.errorCode = ompd_rc_bad_input;
210 }
211 
212 TValue &TValue::cast(const char *typeName) {
213   if (gotError())
214     return *this;
215   type = &tf.getType(context, typeName, symbolAddr.segment);
216   pointerLevel = 0;
217   assert(!type->isVoid() && "cast to invalid type failed");
218   return *this;
219 }
220 
221 TValue &TValue::cast(const char *typeName, int _pointerLevel,
222                      ompd_addr_t segment) {
223   if (gotError())
224     return *this;
225   type = &tf.getType(context, typeName, symbolAddr.segment);
226   pointerLevel = _pointerLevel;
227   symbolAddr.segment = segment;
228   assert(!type->isVoid() && "cast to invalid type failed");
229   return *this;
230 }
231 
232 TValue TValue::dereference() const {
233   if (gotError())
234     return *this;
235   ompd_address_t tmpAddr;
236   assert(!type->isVoid() && "cannot work with void");
237   assert(pointerLevel > 0 && "cannot dereference non-pointer");
238   TValue ret = *this;
239   ret.pointerLevel--;
240   ret.errorState.errorCode = callbacks->read_memory(
241       context, tcontext, &symbolAddr, 1 * TValue::type_sizes.sizeof_pointer,
242       &(tmpAddr.address));
243   if (ret.errorState.errorCode != ompd_rc_ok)
244     return ret;
245 
246   ret.errorState.errorCode = callbacks->device_to_host(
247       context, &(tmpAddr.address), TValue::type_sizes.sizeof_pointer, 1,
248       &(ret.symbolAddr.address));
249   if (ret.errorState.errorCode != ompd_rc_ok) {
250     return ret;
251   }
252   if (ret.symbolAddr.address == 0)
253     ret.errorState.errorCode = ompd_rc_unsupported;
254   return ret;
255 }
256 
257 ompd_rc_t TValue::getAddress(ompd_address_t *addr) const {
258   *addr = symbolAddr;
259   if (symbolAddr.address == 0)
260     return ompd_rc_unsupported;
261   return errorState.errorCode;
262 }
263 
264 ompd_rc_t TValue::getRawValue(void *buf, int count) {
265   if (errorState.errorCode != ompd_rc_ok)
266     return errorState.errorCode;
267   ompd_size_t size;
268   errorState.errorCode = type->getSize(&size);
269   if (errorState.errorCode != ompd_rc_ok)
270     return errorState.errorCode;
271 
272   errorState.errorCode =
273       callbacks->read_memory(context, tcontext, &symbolAddr, size, buf);
274   return errorState.errorCode;
275 }
276 
277 ompd_rc_t TValue::getString(const char **buf) {
278   *buf = 0;
279   if (gotError())
280     return getError();
281 
282   TValue strValue = dereference();
283   if (strValue.gotError()) {
284     return strValue.getError();
285   }
286 
287   if (!callbacks) {
288     return ompd_rc_error;
289   }
290   ompd_rc_t ret;
291 #define BUF_LEN 512
292   char *string_buffer;
293 
294   // Allocate an extra byte, but pass only BUF_LEN to the tool
295   // so that we can detect truncation later.
296   ret = callbacks->alloc_memory(BUF_LEN + 1, (void **)&string_buffer);
297   if (ret != ompd_rc_ok) {
298     return ret;
299   }
300   string_buffer[BUF_LEN] = '\0';
301 
302   // TODO: if we have not read in the complete string, we need to realloc
303   // 'string_buffer' and attempt reading again repeatedly till the entire string
304   // is read in.
305   ret = callbacks->read_string(context, tcontext, &strValue.symbolAddr, BUF_LEN,
306                                (void *)string_buffer);
307   *buf = string_buffer;
308   // Check for truncation. The standard specifies that if a null byte is not
309   // among the first 'nbytes' bytes, the string placed in the buffer is not
310   // null-terminated. 'nbytes' is BUF_LEN in this case.
311   if (ret == ompd_rc_ok && strlen(string_buffer) == BUF_LEN) {
312     return ompd_rc_error;
313   }
314   return ret;
315 }
316 
317 TBaseValue TValue::castBase(const char *varName) {
318   ompd_size_t size;
319   errorState.errorCode =
320       tf.getType(context, varName, symbolAddr.segment).getSize(&size);
321   return TBaseValue(*this, size);
322 }
323 
324 TBaseValue TValue::castBase() const {
325   if (pointerLevel > 0)
326     return TBaseValue(*this, type_sizes.sizeof_pointer);
327   return TBaseValue(*this, fieldSize);
328 }
329 
330 TBaseValue TValue::castBase(ompd_target_prim_types_t baseType) const {
331   return TBaseValue(*this, baseType);
332 }
333 
334 TValue TValue::access(const char *fieldName) const {
335   if (gotError())
336     return *this;
337   TValue ret = *this;
338   assert(pointerLevel < 2 && "access to field element of pointer array failed");
339   if (pointerLevel == 1) // -> operator
340     ret = ret.dereference();
341   // we use *this for . operator
342   ompd_size_t offset;
343   ret.errorState.errorCode = type->getElementOffset(fieldName, &offset);
344   ret.errorState.errorCode = type->getElementSize(fieldName, &(ret.fieldSize));
345   ret.symbolAddr.address += offset;
346 
347   return ret;
348 }
349 
350 ompd_rc_t TValue::check(const char *bitfieldName, ompd_word_t *isSet) const {
351   if (gotError())
352     return getError();
353   int bitfield;
354   uint64_t bitfieldmask;
355   ompd_rc_t ret = this->castBase(ompd_type_int).getValue(&bitfield, 1);
356   if (ret != ompd_rc_ok)
357     return ret;
358   ret = type->getBitfieldMask(bitfieldName, &bitfieldmask);
359   *isSet = ((bitfield & bitfieldmask) != 0);
360   return ret;
361 }
362 
363 TValue TValue::getArrayElement(int elemNumber) const {
364   if (gotError())
365     return *this;
366   TValue ret;
367   if (pointerLevel > 0) {
368     ret = dereference();
369   } else {
370     ret = *this;
371   }
372   if (ret.pointerLevel == 0) {
373     ompd_size_t size;
374     ret.errorState.errorCode = type->getSize(&size);
375     ret.symbolAddr.address += elemNumber * size;
376   } else {
377     ret.symbolAddr.address += elemNumber * type_sizes.sizeof_pointer;
378   }
379   return ret;
380 }
381 
382 TValue TValue::getPtrArrayElement(int elemNumber) const {
383   if (gotError()) {
384     return *this;
385   }
386   assert(pointerLevel > 0 && "This only works on arrays of pointers");
387   TValue ret = *this;
388   ret.symbolAddr.address += elemNumber * type_sizes.sizeof_pointer;
389   return ret;
390 }
391 
392 TBaseValue::TBaseValue(const TValue &_tvalue,
393                        ompd_target_prim_types_t _baseType)
394     : TValue(_tvalue), baseTypeSize(ompd_sizeof(_baseType)) {}
395 TBaseValue::TBaseValue(const TValue &_tvalue, ompd_size_t _baseTypeSize)
396     : TValue(_tvalue), baseTypeSize(_baseTypeSize) {}
397 
398 ompd_rc_t TBaseValue::getValue(void *buf, int count) {
399   if (errorState.errorCode != ompd_rc_ok)
400     return errorState.errorCode;
401   errorState.errorCode = callbacks->read_memory(context, tcontext, &symbolAddr,
402                                                 count * baseTypeSize, buf);
403   if (errorState.errorCode != ompd_rc_ok)
404     return errorState.errorCode;
405   errorState.errorCode =
406       callbacks->device_to_host(context, buf, baseTypeSize, count, buf);
407   return errorState.errorCode;
408 }
409