1 2 /*--------------------------------------------------------------------*/ 3 /*--- Header included by every tool C file. pub_tool_basics.h ---*/ 4 /*--------------------------------------------------------------------*/ 5 6 /* 7 This file is part of Valgrind, a dynamic binary instrumentation 8 framework. 9 10 Copyright (C) 2000-2017 Julian Seward 11 jseward (at) acm.org 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., 59 Temple Place, Suite 330, Boston, MA 26 02111-1307, USA. 27 28 The GNU General Public License is contained in the file COPYING. 29 */ 30 31 #ifndef __PUB_TOOL_BASICS_H 32 #define __PUB_TOOL_BASICS_H 33 34 //-------------------------------------------------------------------- 35 // PURPOSE: This header should be imported by every single C file in 36 // tools. It contains the basic types and other things needed everywhere. 37 // There is no corresponding C file because this isn't a module 38 // containing executable code, it's all just declarations. 39 //-------------------------------------------------------------------- 40 41 /* --------------------------------------------------------------------- 42 Other headers to include 43 ------------------------------------------------------------------ */ 44 45 // VEX defines Char, UChar, Short, UShort, Int, UInt, Long, ULong, SizeT, 46 // Addr, Addr32, Addr64, HWord, HChar, Bool, False and True. 47 #include "libvex_basictypes.h" 48 49 // For varargs types 50 #include <stdarg.h> 51 52 53 /* --------------------------------------------------------------------- 54 symbol prefixing 55 ------------------------------------------------------------------ */ 56 57 // All symbols externally visible from Valgrind are prefixed 58 // as specified here to avoid namespace conflict problems. 59 // 60 // VG_ is for symbols exported from modules. ML_ (module-local) is 61 // for symbols which are not intended to be visible outside modules, 62 // but which cannot be declared as C 'static's since they need to be 63 // visible across C files within a given module. It is a mistake for 64 // a ML_ name to appear in a pub_core_*.h or pub_tool_*.h file. 65 // Likewise it is a mistake for a VG_ name to appear in a priv_*.h 66 // file. 67 68 #define VGAPPEND(str1,str2) str1##str2 69 70 #define VG_(str) VGAPPEND(vgPlain_, str) 71 #define ML_(str) VGAPPEND(vgModuleLocal_, str) 72 73 74 /* --------------------------------------------------------------------- 75 builtin types 76 ------------------------------------------------------------------ */ 77 78 // By choosing the right types, we can get these right for 32-bit and 64-bit 79 // platforms without having to do any conditional compilation or anything. 80 // POSIX references: 81 // - http://www.opengroup.org/onlinepubs/009695399/basedefs/sys/types.h.html 82 // - http://www.opengroup.org/onlinepubs/009695399/basedefs/stddef.h.html 83 // 84 // Size in bits on: 32-bit archs 64-bit archs 85 // ------------ ------------ 86 typedef unsigned long UWord; // 32 64 87 typedef signed long Word; // 32 64 88 89 // Our equivalent of POSIX 'ssize_t': 90 // - ssize_t is "used for a count of bytes or an error indication". 91 typedef Word SSizeT; // 32 64 92 93 // Our equivalent of POSIX 'ptrdiff_t': 94 // - ptrdiff_t is a "signed integer type of the result of subtracting two 95 // pointers". 96 // We use it for memory offsets, eg. the offset into a memory block. 97 typedef Word PtrdiffT; // 32 64 98 99 // Our equivalent of POSIX 'off_t': 100 // - off_t is "used for file sizes". 101 // At one point we were using it for memory offsets, but PtrdiffT should be 102 // used in those cases. 103 // Nb: on Linux, off_t is a signed word-sized int. On Darwin it's 104 // always a signed 64-bit int. So we defined our own Off64T as well. 105 #if defined(VGO_linux) || defined(VGO_solaris) 106 typedef Word OffT; // 32 64 107 #elif defined(VGO_darwin) 108 typedef Long OffT; // 64 64 109 #else 110 # error Unknown OS 111 #endif 112 typedef Long Off64T; // 64 64 113 114 #if !defined(NULL) 115 # define NULL ((void*)0) 116 #endif 117 118 /* This is just too useful to not have around the place somewhere. */ 119 typedef struct { UWord uw1; UWord uw2; } UWordPair; 120 121 122 /* --------------------------------------------------------------------- 123 non-builtin types 124 ------------------------------------------------------------------ */ 125 126 // These probably shouldn't be here, but moving them to their logical 127 // modules results in a lot more #includes... 128 129 /* ThreadIds are simply indices into the VG_(threads)[] array. */ 130 typedef UInt ThreadId; 131 132 /* Many data structures need to allocate and release memory. 133 The allocation/release functions must be provided by the caller. 134 The Alloc_Fn_t function must allocate a chunk of memory of size szB. 135 cc is the Cost Centre for this allocated memory. This constant string 136 is used to provide Valgrind's heap profiling, activated by 137 --profile-heap=no|yes. 138 The corresponding Free_Fn_t frees the memory chunk p. */ 139 140 typedef void* (*Alloc_Fn_t) ( const HChar* cc, SizeT szB ); 141 typedef void (*Free_Fn_t) ( void* p ); 142 143 /* An abstraction of syscall return values. 144 Linux/MIPS32 and Linux/MIPS64: 145 When _isError == False, 146 _val and possible _valEx hold the return value. Whether 147 _valEx actually holds a valid value depends on which syscall 148 this SysRes holds of the result of. 149 When _isError == True, 150 _val holds the error code. 151 152 Linux/other: 153 When _isError == False, 154 _val holds the return value. 155 When _isError == True, 156 _val holds the error code. 157 158 Darwin: 159 Interpretation depends on _mode: 160 MACH, MDEP: 161 these can never 'fail' (apparently). The result of the 162 syscall is a single host word, _wLO. 163 UNIX: 164 Can record a double-word error or a double-word result: 165 When _mode is SysRes_UNIX_OK, _wHI:_wLO holds the result. 166 When _mode is SysRes_UNIX_ERR, _wHI:_wLO holds the error code. 167 Probably the high word of an error is always ignored by 168 userspace, but we have to record it, so that we can correctly 169 update both {R,E}DX and {R,E}AX (in guest state) given a SysRes, 170 if we're required to. 171 172 Solaris: 173 When _isError == False, 174 _val and _val2 hold the return value. 175 When _isError == True, 176 _val holds the error code. 177 */ 178 #if defined(VGP_mips32_linux) || defined(VGP_mips64_linux) 179 typedef 180 struct { 181 Bool _isError; 182 UWord _val; 183 UWord _valEx; 184 } 185 SysRes; 186 187 #elif defined(VGO_linux) \ 188 && !defined(VGP_mips32_linux) && !defined(VGP_mips64_linux) 189 typedef 190 struct { 191 Bool _isError; 192 UWord _val; 193 } 194 SysRes; 195 196 #elif defined(VGO_darwin) 197 typedef 198 enum { 199 SysRes_MACH=40, // MACH, result is _wLO 200 SysRes_MDEP, // MDEP, result is _wLO 201 SysRes_UNIX_OK, // UNIX, success, result is _wHI:_wLO 202 SysRes_UNIX_ERR // UNIX, error, error is _wHI:_wLO 203 } 204 SysResMode; 205 typedef 206 struct { 207 UWord _wLO; 208 UWord _wHI; 209 SysResMode _mode; 210 } 211 SysRes; 212 213 #elif defined(VGO_solaris) 214 typedef 215 struct { 216 UWord _val; 217 UWord _val2; 218 Bool _isError; 219 } 220 SysRes; 221 222 #else 223 # error "Unknown OS" 224 #endif 225 226 227 /* ---- And now some basic accessor functions for it. ---- */ 228 229 #if defined(VGP_mips32_linux) || defined(VGP_mips64_linux) 230 231 static inline Bool sr_isError ( SysRes sr ) { 232 return sr._isError; 233 } 234 static inline UWord sr_Res ( SysRes sr ) { 235 return sr._isError ? 0 : sr._val; 236 } 237 static inline UWord sr_ResEx ( SysRes sr ) { 238 return sr._isError ? 0 : sr._valEx; 239 } 240 static inline UWord sr_Err ( SysRes sr ) { 241 return sr._isError ? sr._val : 0; 242 } 243 static inline Bool sr_EQ ( UInt sysno, SysRes sr1, SysRes sr2 ) { 244 /* This uglyness of hardcoding syscall numbers is necessary to 245 avoid having this header file be dependent on 246 include/vki/vki-scnums-mips{32,64}-linux.h. It seems pretty 247 safe given that it is inconceivable that the syscall numbers 248 for such simple syscalls would ever change. To make it 249 really safe, coregrind/m_vkiscnums.c static-asserts that these 250 syscall numbers haven't changed, so that the build wil simply 251 fail if they ever do. */ 252 # if defined(VGP_mips32_linux) 253 const UInt __nr_Linux = 4000; 254 const UInt __nr_pipe = __nr_Linux + 42; 255 const UInt __nr_pipe2 = __nr_Linux + 328; 256 # else 257 const UInt __nr_Linux = 5000; 258 const UInt __nr_pipe = __nr_Linux + 21; 259 const UInt __nr_pipe2 = __nr_Linux + 287; 260 # endif 261 Bool useEx = sysno == __nr_pipe || sysno == __nr_pipe2; 262 return sr1._val == sr2._val 263 && (useEx ? (sr1._valEx == sr2._valEx) : True) 264 && sr1._isError == sr2._isError; 265 } 266 267 #elif defined(VGO_linux) \ 268 && !defined(VGP_mips32_linux) && !defined(VGP_mips64_linux) 269 270 static inline Bool sr_isError ( SysRes sr ) { 271 return sr._isError; 272 } 273 static inline UWord sr_Res ( SysRes sr ) { 274 return sr._isError ? 0 : sr._val; 275 } 276 static inline UWord sr_Err ( SysRes sr ) { 277 return sr._isError ? sr._val : 0; 278 } 279 static inline Bool sr_EQ ( UInt sysno, SysRes sr1, SysRes sr2 ) { 280 /* sysno is ignored for Linux/not-MIPS */ 281 return sr1._val == sr2._val 282 && sr1._isError == sr2._isError; 283 } 284 285 #elif defined(VGO_darwin) 286 287 static inline Bool sr_isError ( SysRes sr ) { 288 switch (sr._mode) { 289 case SysRes_UNIX_ERR: 290 return True; 291 /* should check tags properly and assert here, but we can't here */ 292 case SysRes_MACH: 293 case SysRes_MDEP: 294 case SysRes_UNIX_OK: 295 default: 296 return False; 297 } 298 } 299 300 static inline UWord sr_Res ( SysRes sr ) { 301 switch (sr._mode) { 302 case SysRes_MACH: 303 case SysRes_MDEP: 304 case SysRes_UNIX_OK: 305 return sr._wLO; 306 /* should assert, but we can't here */ 307 case SysRes_UNIX_ERR: 308 default: 309 return 0; 310 } 311 } 312 313 static inline UWord sr_ResHI ( SysRes sr ) { 314 switch (sr._mode) { 315 case SysRes_UNIX_OK: 316 return sr._wHI; 317 /* should assert, but we can't here */ 318 case SysRes_MACH: 319 case SysRes_MDEP: 320 case SysRes_UNIX_ERR: 321 default: 322 return 0; 323 } 324 } 325 326 static inline UWord sr_Err ( SysRes sr ) { 327 switch (sr._mode) { 328 case SysRes_UNIX_ERR: 329 return sr._wLO; 330 /* should assert, but we can't here */ 331 case SysRes_MACH: 332 case SysRes_MDEP: 333 case SysRes_UNIX_OK: 334 default: 335 return 0; 336 } 337 } 338 339 static inline Bool sr_EQ ( UInt sysno, SysRes sr1, SysRes sr2 ) { 340 /* sysno is ignored for Darwin */ 341 return sr1._mode == sr2._mode 342 && sr1._wLO == sr2._wLO && sr1._wHI == sr2._wHI; 343 } 344 345 #elif defined(VGO_solaris) 346 347 static inline Bool sr_isError ( SysRes sr ) { 348 return sr._isError; 349 } 350 static inline UWord sr_Res ( SysRes sr ) { 351 return sr._isError ? 0 : sr._val; 352 } 353 static inline UWord sr_ResHI ( SysRes sr ) { 354 return sr._isError ? 0 : sr._val2; 355 } 356 static inline UWord sr_Err ( SysRes sr ) { 357 return sr._isError ? sr._val : 0; 358 } 359 static inline Bool sr_EQ ( UInt sysno, SysRes sr1, SysRes sr2 ) { 360 /* sysno is ignored for Solaris */ 361 return sr1._val == sr2._val 362 && sr1._isError == sr2._isError 363 && (!sr1._isError) ? (sr1._val2 == sr2._val2) : True; 364 } 365 366 #else 367 # error "Unknown OS" 368 #endif 369 370 371 /* --------------------------------------------------------------------- 372 Miscellaneous (word size, endianness, regparmness, stringification) 373 ------------------------------------------------------------------ */ 374 375 /* Word size: this is going to be either 4 or 8. */ 376 // It should probably be in m_machine. 377 #define VG_WORDSIZE VEX_HOST_WORDSIZE 378 379 /* Endianness */ 380 #undef VG_BIGENDIAN 381 #undef VG_LITTLEENDIAN 382 383 #if defined(VGA_x86) || defined(VGA_amd64) || defined (VGA_arm) \ 384 || ((defined(VGA_mips32) || defined(VGA_mips64)) && defined (_MIPSEL)) \ 385 || defined(VGA_arm64) || defined(VGA_ppc64le) 386 # define VG_LITTLEENDIAN 1 387 #elif defined(VGA_ppc32) || defined(VGA_ppc64be) || defined(VGA_s390x) \ 388 || ((defined(VGA_mips32) || defined(VGA_mips64)) && defined (_MIPSEB)) 389 # define VG_BIGENDIAN 1 390 #else 391 # error Unknown arch 392 #endif 393 394 /* Offsetof */ 395 #if !defined(offsetof) 396 # define offsetof(type,memb) ((SizeT)(HWord)&((type*)0)->memb) 397 #endif 398 399 #if !defined(container_of) 400 # define container_of(ptr, type, member) ((type *)((char *)(ptr) - offsetof(type, member))) 401 #endif 402 403 /* Alignment */ 404 /* We use a prefix vg_ for vg_alignof as its behaviour slightly 405 differs from the standard alignof/gcc defined __alignof__ 406 407 vg_alignof returns a "safe" alignement. 408 "safe" is defined as the alignment chosen by the compiler in 409 a struct made of a char followed by this type. 410 411 Note that this is not necessarily the "preferred" alignment 412 for a platform. This preferred alignment is returned by the gcc 413 __alignof__ and by the standard (in recent standard) alignof. 414 Compared to __alignof__, vg_alignof gives on some platforms (e.g. 415 amd64, ppc32, ppc64) a bigger alignment for long double (16 bytes 416 instead of 8). 417 On some platforms (e.g. x86), vg_alignof gives a smaller alignment 418 than __alignof__ for long long and double (4 bytes instead of 8). 419 If we want to have the "preferred" alignment for the basic types, 420 then either we need to depend on gcc __alignof__, or on a (too) 421 recent standard and compiler (implementing <stdalign.h>). 422 */ 423 #define vg_alignof(_type) (sizeof(struct {char c;_type _t;})-sizeof(_type)) 424 425 /* Regparmness */ 426 #if defined(VGA_x86) 427 # define VG_REGPARM(n) __attribute__((regparm(n))) 428 #elif defined(VGA_amd64) || defined(VGA_ppc32) \ 429 || defined(VGA_ppc64be) || defined(VGA_ppc64le) \ 430 || defined(VGA_arm) || defined(VGA_s390x) \ 431 || defined(VGA_mips32) || defined(VGA_mips64) \ 432 || defined(VGA_arm64) 433 # define VG_REGPARM(n) /* */ 434 #else 435 # error Unknown arch 436 #endif 437 438 /* Macro games */ 439 #define VG_STRINGIFZ(__str) #__str 440 #define VG_STRINGIFY(__str) VG_STRINGIFZ(__str) 441 442 // Where to send bug reports to. 443 #define VG_BUGS_TO "www.valgrind.org" 444 445 /* Branch prediction hints. */ 446 #if defined(__GNUC__) 447 # define LIKELY(x) __builtin_expect(!!(x), 1) 448 # define UNLIKELY(x) __builtin_expect(!!(x), 0) 449 #else 450 # define LIKELY(x) (x) 451 # define UNLIKELY(x) (x) 452 #endif 453 454 // printf format string checking for gcc. 455 // This feature has been supported since at least gcc version 2.95. 456 // For more information about the format attribute, see 457 // http://gcc.gnu.org/onlinedocs/gcc-4.3.0/gcc/Function-Attributes.html. 458 #if defined(__GNUC__) 459 #define PRINTF_CHECK(x, y) __attribute__((format(__printf__, x, y))) 460 #else 461 #define PRINTF_CHECK(x, y) 462 #endif 463 464 // Macro to "cast" away constness (from type const T to type T) without 465 // GCC complaining about it. This macro should be used RARELY. 466 // x is expected to have type const T 467 #define CONST_CAST(T,x) \ 468 ({ \ 469 union { \ 470 const T in; \ 471 T out; \ 472 } var = { .in = x }; var.out; \ 473 }) 474 475 /* Some architectures (eg. mips, arm) do not support unaligned memory access 476 by hardware, so GCC warns about suspicious situations. This macro could 477 be used to avoid these warnings but only after careful examination. */ 478 #define ASSUME_ALIGNED(D, x) \ 479 ({ \ 480 union { \ 481 void *in; \ 482 D out; \ 483 } var; \ 484 var.in = (void *) (x); var.out; \ 485 }) 486 487 // Poor man's static assert 488 #define STATIC_ASSERT(x) extern int VG_(VG_(VG_(unused)))[(x) ? 1 : -1] \ 489 __attribute__((unused)) 490 491 #define VG_MAX(a,b) ((a) > (b) ? a : b) 492 #define VG_MIN(a,b) ((a) < (b) ? a : b) 493 494 #endif /* __PUB_TOOL_BASICS_H */ 495 496 /*--------------------------------------------------------------------*/ 497 /*--- end ---*/ 498 /*--------------------------------------------------------------------*/ 499
