1
2 /*---------------------------------------------------------------*/
3 /*--- begin libvex_basictypes.h ---*/
4 /*---------------------------------------------------------------*/
5
6 /*
7 This file is part of Valgrind, a dynamic binary instrumentation
8 framework.
9
10 Copyright (C) 2004-2017 OpenWorks LLP
11 info@open-works.net
12
13 This program is free software; you can redistribute it and/or
14 modify it under the terms of the GNU General Public License as
15 published by the Free Software Foundation; either version 2 of the
16 License, or (at your option) any later version.
17
18 This program is distributed in the hope that it will be useful, but
19 WITHOUT ANY WARRANTY; without even the implied warranty of
20 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
21 General Public License for more details.
22
23 You should have received a copy of the GNU General Public License
24 along with this program; if not, write to the Free Software
25 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
26 02110-1301, USA.
27
28 The GNU General Public License is contained in the file COPYING.
29
30 Neither the names of the U.S. Department of Energy nor the
31 University of California nor the names of its contributors may be
32 used to endorse or promote products derived from this software
33 without prior written permission.
34 */
35
36 #ifndef __LIBVEX_BASICTYPES_H
37 #define __LIBVEX_BASICTYPES_H
38
39 /* It is important that the sizes of the following data types (on the
40 host) are as stated. LibVEX_Init therefore checks these at
41 startup. */
42
43 /* Always 8 bits. */
44 typedef unsigned char UChar;
45 typedef signed char Char;
46 typedef char HChar; /* signfulness depends on host */
47 /* Only to be used for printf etc
48 format strings */
49
50 /* Always 16 bits. */
51 typedef unsigned short UShort;
52 typedef signed short Short;
53
54 /* Always 32 bits. */
55 typedef unsigned int UInt;
56 typedef signed int Int;
57
58 /* Always 64 bits. */
59 typedef unsigned long long int ULong;
60 typedef signed long long int Long;
61
62 /* Equivalent of C's size_t type. The type is unsigned and has this
63 storage requirement:
64 32 bits on a 32-bit architecture
65 64 bits on a 64-bit architecture. */
66 typedef unsigned long SizeT;
67
68 /* Always 128 bits. */
69 typedef UInt U128[4];
70
71 /* Always 256 bits. */
72 typedef UInt U256[8];
73
74 /* A union for doing 128-bit vector primitives conveniently. */
75 typedef
76 union {
77 UChar w8[16];
78 UShort w16[8];
79 UInt w32[4];
80 ULong w64[2];
81 }
82 V128;
83
84 /* A union for doing 256-bit vector primitives conveniently. */
85 typedef
86 union {
87 UChar w8[32];
88 UShort w16[16];
89 UInt w32[8];
90 ULong w64[4];
91 }
92 V256;
93
94 /* Floating point. */
95 typedef float Float; /* IEEE754 single-precision (32-bit) value */
96 typedef double Double; /* IEEE754 double-precision (64-bit) value */
97
98 /* Bool is always 8 bits. */
99 typedef unsigned char Bool;
100 #define True ((Bool)1)
101 #define False ((Bool)0)
102
103 /* Use this to coerce the result of a C comparison to a Bool. This is
104 useful when compiling with Intel icc with ultra-paranoid
105 compilation flags (-Wall). */
toBool(Int x)106 static inline Bool toBool ( Int x ) {
107 Int r = (x == 0) ? False : True;
108 return (Bool)r;
109 }
toUChar(Int x)110 static inline UChar toUChar ( Int x ) {
111 x &= 0xFF;
112 return (UChar)x;
113 }
toHChar(Int x)114 static inline HChar toHChar ( Int x ) {
115 x &= 0xFF;
116 return (HChar)x;
117 }
toUShort(Int x)118 static inline UShort toUShort ( Int x ) {
119 x &= 0xFFFF;
120 return (UShort)x;
121 }
toShort(Int x)122 static inline Short toShort ( Int x ) {
123 x &= 0xFFFF;
124 return (Short)x;
125 }
toUInt(Long x)126 static inline UInt toUInt ( Long x ) {
127 x &= 0xFFFFFFFFLL;
128 return (UInt)x;
129 }
130
131 /* 32/64 bit addresses. */
132 typedef UInt Addr32;
133 typedef ULong Addr64;
134
135 /* An address: 32-bit or 64-bit wide depending on host architecture */
136 typedef unsigned long Addr;
137
138
139 /* Something which has the same size as void* on the host. That is,
140 it is 32 bits on a 32-bit host and 64 bits on a 64-bit host, and so
141 it can safely be coerced to and from a pointer type on the host
142 machine. */
143 typedef unsigned long HWord;
144
145 /* Set up VEX_HOST_WORDSIZE and VEX_REGPARM. */
146 #undef VEX_HOST_WORDSIZE
147 #undef VEX_REGPARM
148
149 /* The following 4 work OK for Linux. */
150 #if defined(__x86_64__)
151 # define VEX_HOST_WORDSIZE 8
152 # define VEX_REGPARM(_n) /* */
153
154 #elif defined(__i386__)
155 # define VEX_HOST_WORDSIZE 4
156 # define VEX_REGPARM(_n) __attribute__((regparm(_n)))
157
158 #elif defined(__powerpc__) && defined(__powerpc64__)
159 # define VEX_HOST_WORDSIZE 8
160 # define VEX_REGPARM(_n) /* */
161
162 #elif defined(__powerpc__) && !defined(__powerpc64__)
163 # define VEX_HOST_WORDSIZE 4
164 # define VEX_REGPARM(_n) /* */
165
166 #elif defined(__arm__) && !defined(__aarch64__)
167 # define VEX_HOST_WORDSIZE 4
168 # define VEX_REGPARM(_n) /* */
169
170 #elif defined(__aarch64__) && !defined(__arm__)
171 # define VEX_HOST_WORDSIZE 8
172 # define VEX_REGPARM(_n) /* */
173
174 #elif defined(__s390x__)
175 # define VEX_HOST_WORDSIZE 8
176 # define VEX_REGPARM(_n) /* */
177
178 #elif defined(__mips__) && (__mips == 64)
179 # define VEX_HOST_WORDSIZE 8
180 # define VEX_REGPARM(_n) /* */
181
182 #elif defined(__mips__) && (__mips != 64)
183 # define VEX_HOST_WORDSIZE 4
184 # define VEX_REGPARM(_n) /* */
185
186 #else
187 # error "Vex: Fatal: Can't establish the host architecture"
188 #endif
189
190
191 #endif /* ndef __LIBVEX_BASICTYPES_H */
192
193 /*---------------------------------------------------------------*/
194 /*--- libvex_basictypes.h ---*/
195 /*---------------------------------------------------------------*/
196
197