1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
|
#ifndef EMUGL_PROTOCOL_UTILS_H
#define EMUGL_PROTOCOL_UTILS_H
#include <stddef.h>
#include <stdint.h>
namespace emugl {
// Helper macro
#define COMPILE_ASSERT(cond) static char kAssert##__LINE__[1 - 2 * !(cond)] __attribute__((unused)) = { 0 }
// Helper template: is_pointer.
// is_pointer<T>::value is true iff |T| is a pointer type.
template <typename T> struct is_pointer {
static const bool value = false;
};
template <typename T> struct is_pointer<T*> {
static const bool value = true;
};
// A helper template to extract values form the wire protocol stream
// and convert them to appropriate host values.
//
// The wire protocol uses 32-bit exclusively when transferring
// GLintptr or GLsizei values, as well as opaque handles like GLeglImage,
// from the guest (even when the guest is 64-bit).
//
// The corresponding host definitions depend on the host bitness. For
// example, GLintptr is 64-bit on linux-x86_64. The following is a set
// of templates that can simplify the conversion of protocol values
// into host ones.
//
// The most important one is:
//
// unpack<HOST_TYPE,SIZE_TYPE>(const void* ptr)
//
// Which reads bytes from |ptr|, using |SIZE_TYPE| as the underlying
// sized-integer specifier (e.g. 'uint32_t'), and converting the result
// into a |HOST_TYPE| value. For example:
//
// unpack<EGLImage,uint32_t>(ptr + 12);
//
// will read a 4-byte value from |ptr + 12| and convert it into
// an EGLImage, which is a host void*. The template detects host
// pointer types to perform proper type casting.
//
// TODO(digit): Add custom unpackers to handle generic opaque void* values.
// and map them to unique 32-bit values.
template <typename T, typename S, bool IS_POINTER>
struct UnpackerT {};
template <typename T, typename S>
struct UnpackerT<T,S,false> {
static inline T unpack(const void* ptr) {
COMPILE_ASSERT(sizeof(T) == sizeof(S));
return (T)(*(S*)(ptr));
}
};
template <typename T, typename S>
struct UnpackerT<T,S,true> {
static inline T unpack(const void* ptr) {
return (T)(uintptr_t)(*(S*)(ptr));
}
};
template <>
struct UnpackerT<float,uint32_t,false> {
static inline float unpack(const void* ptr) {
union {
float f;
uint32_t u;
} v;
v.u = *(uint32_t*)(ptr);
return v.f;
}
};
template <>
struct UnpackerT<double,uint64_t,false> {
static inline double unpack(const void* ptr) {
union {
double d;
uint32_t u;
} v;
v.u = *(uint64_t*)(ptr);
return v.d;
}
};
template <>
struct UnpackerT<ssize_t,uint32_t,false> {
static inline ssize_t unpack(const void* ptr) {
return (ssize_t)*(int32_t*)(ptr);
}
};
template <typename T, typename S>
inline T Unpack(const void* ptr) {
return UnpackerT<T, S, is_pointer<T>::value>::unpack(ptr);
}
} // namespace emugl
#endif // EMUGL_PROTOCOL_UTILS_H
|
