1 #ifndef Py_PYPORT_H 2 #define Py_PYPORT_H 3 4 #include "pyconfig.h" /* include for defines */ 5 6 #include <inttypes.h> 7 8 9 /* Defines to build Python and its standard library: 10 * 11 * - Py_BUILD_CORE: Build Python core. Give access to Python internals, but 12 * should not be used by third-party modules. 13 * - Py_BUILD_CORE_BUILTIN: Build a Python stdlib module as a built-in module. 14 * - Py_BUILD_CORE_MODULE: Build a Python stdlib module as a dynamic library. 15 * 16 * Py_BUILD_CORE_BUILTIN and Py_BUILD_CORE_MODULE imply Py_BUILD_CORE. 17 * 18 * On Windows, Py_BUILD_CORE_MODULE exports "PyInit_xxx" symbol, whereas 19 * Py_BUILD_CORE_BUILTIN does not. 20 */ 21 #if defined(Py_BUILD_CORE_BUILTIN) && !defined(Py_BUILD_CORE) 22 # define Py_BUILD_CORE 23 #endif 24 #if defined(Py_BUILD_CORE_MODULE) && !defined(Py_BUILD_CORE) 25 # define Py_BUILD_CORE 26 #endif 27 28 29 /************************************************************************** 30 Symbols and macros to supply platform-independent interfaces to basic 31 C language & library operations whose spellings vary across platforms. 32 33 Please try to make documentation here as clear as possible: by definition, 34 the stuff here is trying to illuminate C's darkest corners. 35 36 Config #defines referenced here: 37 38 SIGNED_RIGHT_SHIFT_ZERO_FILLS 39 Meaning: To be defined iff i>>j does not extend the sign bit when i is a 40 signed integral type and i < 0. 41 Used in: Py_ARITHMETIC_RIGHT_SHIFT 42 43 Py_DEBUG 44 Meaning: Extra checks compiled in for debug mode. 45 Used in: Py_SAFE_DOWNCAST 46 47 **************************************************************************/ 48 49 /* typedefs for some C9X-defined synonyms for integral types. 50 * 51 * The names in Python are exactly the same as the C9X names, except with a 52 * Py_ prefix. Until C9X is universally implemented, this is the only way 53 * to ensure that Python gets reliable names that don't conflict with names 54 * in non-Python code that are playing their own tricks to define the C9X 55 * names. 56 * 57 * NOTE: don't go nuts here! Python has no use for *most* of the C9X 58 * integral synonyms. Only define the ones we actually need. 59 */ 60 61 /* long long is required. Ensure HAVE_LONG_LONG is defined for compatibility. */ 62 #ifndef HAVE_LONG_LONG 63 #define HAVE_LONG_LONG 1 64 #endif 65 #ifndef PY_LONG_LONG 66 #define PY_LONG_LONG long long 67 /* If LLONG_MAX is defined in limits.h, use that. */ 68 #define PY_LLONG_MIN LLONG_MIN 69 #define PY_LLONG_MAX LLONG_MAX 70 #define PY_ULLONG_MAX ULLONG_MAX 71 #endif 72 73 #define PY_UINT32_T uint32_t 74 #define PY_UINT64_T uint64_t 75 76 /* Signed variants of the above */ 77 #define PY_INT32_T int32_t 78 #define PY_INT64_T int64_t 79 80 /* If PYLONG_BITS_IN_DIGIT is not defined then we'll use 30-bit digits if all 81 the necessary integer types are available, and we're on a 64-bit platform 82 (as determined by SIZEOF_VOID_P); otherwise we use 15-bit digits. */ 83 84 #ifndef PYLONG_BITS_IN_DIGIT 85 #if SIZEOF_VOID_P >= 8 86 #define PYLONG_BITS_IN_DIGIT 30 87 #else 88 #define PYLONG_BITS_IN_DIGIT 15 89 #endif 90 #endif 91 92 /* uintptr_t is the C9X name for an unsigned integral type such that a 93 * legitimate void* can be cast to uintptr_t and then back to void* again 94 * without loss of information. Similarly for intptr_t, wrt a signed 95 * integral type. 96 */ 97 typedef uintptr_t Py_uintptr_t; 98 typedef intptr_t Py_intptr_t; 99 100 /* Py_ssize_t is a signed integral type such that sizeof(Py_ssize_t) == 101 * sizeof(size_t). C99 doesn't define such a thing directly (size_t is an 102 * unsigned integral type). See PEP 353 for details. 103 */ 104 #ifdef HAVE_PY_SSIZE_T 105 106 #elif HAVE_SSIZE_T 107 typedef ssize_t Py_ssize_t; 108 #elif SIZEOF_VOID_P == SIZEOF_SIZE_T 109 typedef Py_intptr_t Py_ssize_t; 110 #else 111 # error "Python needs a typedef for Py_ssize_t in pyport.h." 112 #endif 113 114 /* Py_hash_t is the same size as a pointer. */ 115 #define SIZEOF_PY_HASH_T SIZEOF_SIZE_T 116 typedef Py_ssize_t Py_hash_t; 117 /* Py_uhash_t is the unsigned equivalent needed to calculate numeric hash. */ 118 #define SIZEOF_PY_UHASH_T SIZEOF_SIZE_T 119 typedef size_t Py_uhash_t; 120 121 /* Only used for compatibility with code that may not be PY_SSIZE_T_CLEAN. */ 122 #ifdef PY_SSIZE_T_CLEAN 123 typedef Py_ssize_t Py_ssize_clean_t; 124 #else 125 typedef int Py_ssize_clean_t; 126 #endif 127 128 /* Largest possible value of size_t. */ 129 #define PY_SIZE_MAX SIZE_MAX 130 131 /* Largest positive value of type Py_ssize_t. */ 132 #define PY_SSIZE_T_MAX ((Py_ssize_t)(((size_t)-1)>>1)) 133 /* Smallest negative value of type Py_ssize_t. */ 134 #define PY_SSIZE_T_MIN (-PY_SSIZE_T_MAX-1) 135 136 /* Macro kept for backward compatibility: use "z" in new code. 137 * 138 * PY_FORMAT_SIZE_T is a platform-specific modifier for use in a printf 139 * format to convert an argument with the width of a size_t or Py_ssize_t. 140 * C99 introduced "z" for this purpose, but old MSVCs had not supported it. 141 * Since MSVC supports "z" since (at least) 2015, we can just use "z" 142 * for new code. 143 * 144 * These "high level" Python format functions interpret "z" correctly on 145 * all platforms (Python interprets the format string itself, and does whatever 146 * the platform C requires to convert a size_t/Py_ssize_t argument): 147 * 148 * PyBytes_FromFormat 149 * PyErr_Format 150 * PyBytes_FromFormatV 151 * PyUnicode_FromFormatV 152 * 153 * Lower-level uses require that you interpolate the correct format modifier 154 * yourself (e.g., calling printf, fprintf, sprintf, PyOS_snprintf); for 155 * example, 156 * 157 * Py_ssize_t index; 158 * fprintf(stderr, "index %" PY_FORMAT_SIZE_T "d sucks\n", index); 159 * 160 * That will expand to %zd or to something else correct for a Py_ssize_t on 161 * the platform. 162 */ 163 #ifndef PY_FORMAT_SIZE_T 164 # define PY_FORMAT_SIZE_T "z" 165 #endif 166 167 /* Py_LOCAL can be used instead of static to get the fastest possible calling 168 * convention for functions that are local to a given module. 169 * 170 * Py_LOCAL_INLINE does the same thing, and also explicitly requests inlining, 171 * for platforms that support that. 172 * 173 * If PY_LOCAL_AGGRESSIVE is defined before python.h is included, more 174 * "aggressive" inlining/optimization is enabled for the entire module. This 175 * may lead to code bloat, and may slow things down for those reasons. It may 176 * also lead to errors, if the code relies on pointer aliasing. Use with 177 * care. 178 * 179 * NOTE: You can only use this for functions that are entirely local to a 180 * module; functions that are exported via method tables, callbacks, etc, 181 * should keep using static. 182 */ 183 184 #if defined(_MSC_VER) 185 # if defined(PY_LOCAL_AGGRESSIVE) 186 /* enable more aggressive optimization for MSVC */ 187 /* active in both release and debug builds - see bpo-43271 */ 188 # pragma optimize("gt", on) 189 #endif 190 /* ignore warnings if the compiler decides not to inline a function */ 191 # pragma warning(disable: 4710) 192 /* fastest possible local call under MSVC */ 193 # define Py_LOCAL(type) static type __fastcall 194 # define Py_LOCAL_INLINE(type) static __inline type __fastcall 195 #else 196 # define Py_LOCAL(type) static type 197 # define Py_LOCAL_INLINE(type) static inline type 198 #endif 199 200 /* Py_MEMCPY is kept for backwards compatibility, 201 * see https://bugs.python.org/issue28126 */ 202 #define Py_MEMCPY memcpy 203 204 #include <stdlib.h> 205 206 #ifdef HAVE_IEEEFP_H 207 #include <ieeefp.h> /* needed for 'finite' declaration on some platforms */ 208 #endif 209 210 #include <math.h> /* Moved here from the math section, before extern "C" */ 211 212 /******************************************** 213 * WRAPPER FOR <time.h> and/or <sys/time.h> * 214 ********************************************/ 215 216 #ifdef TIME_WITH_SYS_TIME 217 #include <sys/time.h> 218 #include <time.h> 219 #else /* !TIME_WITH_SYS_TIME */ 220 #ifdef HAVE_SYS_TIME_H 221 #include <sys/time.h> 222 #else /* !HAVE_SYS_TIME_H */ 223 #include <time.h> 224 #endif /* !HAVE_SYS_TIME_H */ 225 #endif /* !TIME_WITH_SYS_TIME */ 226 227 228 /****************************** 229 * WRAPPER FOR <sys/select.h> * 230 ******************************/ 231 232 /* NB caller must include <sys/types.h> */ 233 234 #ifdef HAVE_SYS_SELECT_H 235 #include <sys/select.h> 236 #endif /* !HAVE_SYS_SELECT_H */ 237 238 /******************************* 239 * stat() and fstat() fiddling * 240 *******************************/ 241 242 #ifdef HAVE_SYS_STAT_H 243 #include <sys/stat.h> 244 #elif defined(HAVE_STAT_H) 245 #include <stat.h> 246 #endif 247 248 #ifndef S_IFMT 249 /* VisualAge C/C++ Failed to Define MountType Field in sys/stat.h */ 250 #define S_IFMT 0170000 251 #endif 252 253 #ifndef S_IFLNK 254 /* Windows doesn't define S_IFLNK but posixmodule.c maps 255 * IO_REPARSE_TAG_SYMLINK to S_IFLNK */ 256 # define S_IFLNK 0120000 257 #endif 258 259 #ifndef S_ISREG 260 #define S_ISREG(x) (((x) & S_IFMT) == S_IFREG) 261 #endif 262 263 #ifndef S_ISDIR 264 #define S_ISDIR(x) (((x) & S_IFMT) == S_IFDIR) 265 #endif 266 267 #ifndef S_ISCHR 268 #define S_ISCHR(x) (((x) & S_IFMT) == S_IFCHR) 269 #endif 270 271 #ifdef __cplusplus 272 /* Move this down here since some C++ #include's don't like to be included 273 inside an extern "C" */ 274 extern "C" { 275 #endif 276 277 278 /* Py_ARITHMETIC_RIGHT_SHIFT 279 * C doesn't define whether a right-shift of a signed integer sign-extends 280 * or zero-fills. Here a macro to force sign extension: 281 * Py_ARITHMETIC_RIGHT_SHIFT(TYPE, I, J) 282 * Return I >> J, forcing sign extension. Arithmetically, return the 283 * floor of I/2**J. 284 * Requirements: 285 * I should have signed integer type. In the terminology of C99, this can 286 * be either one of the five standard signed integer types (signed char, 287 * short, int, long, long long) or an extended signed integer type. 288 * J is an integer >= 0 and strictly less than the number of bits in the 289 * type of I (because C doesn't define what happens for J outside that 290 * range either). 291 * TYPE used to specify the type of I, but is now ignored. It's been left 292 * in for backwards compatibility with versions <= 2.6 or 3.0. 293 * Caution: 294 * I may be evaluated more than once. 295 */ 296 #ifdef SIGNED_RIGHT_SHIFT_ZERO_FILLS 297 #define Py_ARITHMETIC_RIGHT_SHIFT(TYPE, I, J) \ 298 ((I) < 0 ? -1-((-1-(I)) >> (J)) : (I) >> (J)) 299 #else 300 #define Py_ARITHMETIC_RIGHT_SHIFT(TYPE, I, J) ((I) >> (J)) 301 #endif 302 303 /* Py_FORCE_EXPANSION(X) 304 * "Simply" returns its argument. However, macro expansions within the 305 * argument are evaluated. This unfortunate trickery is needed to get 306 * token-pasting to work as desired in some cases. 307 */ 308 #define Py_FORCE_EXPANSION(X) X 309 310 /* Py_SAFE_DOWNCAST(VALUE, WIDE, NARROW) 311 * Cast VALUE to type NARROW from type WIDE. In Py_DEBUG mode, this 312 * assert-fails if any information is lost. 313 * Caution: 314 * VALUE may be evaluated more than once. 315 */ 316 #ifdef Py_DEBUG 317 #define Py_SAFE_DOWNCAST(VALUE, WIDE, NARROW) \ 318 (assert((WIDE)(NARROW)(VALUE) == (VALUE)), (NARROW)(VALUE)) 319 #else 320 #define Py_SAFE_DOWNCAST(VALUE, WIDE, NARROW) (NARROW)(VALUE) 321 #endif 322 323 /* Py_SET_ERRNO_ON_MATH_ERROR(x) 324 * If a libm function did not set errno, but it looks like the result 325 * overflowed or not-a-number, set errno to ERANGE or EDOM. Set errno 326 * to 0 before calling a libm function, and invoke this macro after, 327 * passing the function result. 328 * Caution: 329 * This isn't reliable. See Py_OVERFLOWED comments. 330 * X is evaluated more than once. 331 */ 332 #if defined(__FreeBSD__) || defined(__OpenBSD__) || (defined(__hpux) && defined(__ia64)) 333 #define _Py_SET_EDOM_FOR_NAN(X) if (isnan(X)) errno = EDOM; 334 #else 335 #define _Py_SET_EDOM_FOR_NAN(X) ; 336 #endif 337 #define Py_SET_ERRNO_ON_MATH_ERROR(X) \ 338 do { \ 339 if (errno == 0) { \ 340 if ((X) == Py_HUGE_VAL || (X) == -Py_HUGE_VAL) \ 341 errno = ERANGE; \ 342 else _Py_SET_EDOM_FOR_NAN(X) \ 343 } \ 344 } while(0) 345 346 /* Py_SET_ERANGE_IF_OVERFLOW(x) 347 * An alias of Py_SET_ERRNO_ON_MATH_ERROR for backward-compatibility. 348 */ 349 #define Py_SET_ERANGE_IF_OVERFLOW(X) Py_SET_ERRNO_ON_MATH_ERROR(X) 350 351 /* Py_ADJUST_ERANGE1(x) 352 * Py_ADJUST_ERANGE2(x, y) 353 * Set errno to 0 before calling a libm function, and invoke one of these 354 * macros after, passing the function result(s) (Py_ADJUST_ERANGE2 is useful 355 * for functions returning complex results). This makes two kinds of 356 * adjustments to errno: (A) If it looks like the platform libm set 357 * errno=ERANGE due to underflow, clear errno. (B) If it looks like the 358 * platform libm overflowed but didn't set errno, force errno to ERANGE. In 359 * effect, we're trying to force a useful implementation of C89 errno 360 * behavior. 361 * Caution: 362 * This isn't reliable. See Py_OVERFLOWED comments. 363 * X and Y may be evaluated more than once. 364 */ 365 #define Py_ADJUST_ERANGE1(X) \ 366 do { \ 367 if (errno == 0) { \ 368 if ((X) == Py_HUGE_VAL || (X) == -Py_HUGE_VAL) \ 369 errno = ERANGE; \ 370 } \ 371 else if (errno == ERANGE && (X) == 0.0) \ 372 errno = 0; \ 373 } while(0) 374 375 #define Py_ADJUST_ERANGE2(X, Y) \ 376 do { \ 377 if ((X) == Py_HUGE_VAL || (X) == -Py_HUGE_VAL || \ 378 (Y) == Py_HUGE_VAL || (Y) == -Py_HUGE_VAL) { \ 379 if (errno == 0) \ 380 errno = ERANGE; \ 381 } \ 382 else if (errno == ERANGE) \ 383 errno = 0; \ 384 } while(0) 385 386 /* The functions _Py_dg_strtod and _Py_dg_dtoa in Python/dtoa.c (which are 387 * required to support the short float repr introduced in Python 3.1) require 388 * that the floating-point unit that's being used for arithmetic operations 389 * on C doubles is set to use 53-bit precision. It also requires that the 390 * FPU rounding mode is round-half-to-even, but that's less often an issue. 391 * 392 * If your FPU isn't already set to 53-bit precision/round-half-to-even, and 393 * you want to make use of _Py_dg_strtod and _Py_dg_dtoa, then you should 394 * 395 * #define HAVE_PY_SET_53BIT_PRECISION 1 396 * 397 * and also give appropriate definitions for the following three macros: 398 * 399 * _PY_SET_53BIT_PRECISION_START : store original FPU settings, and 400 * set FPU to 53-bit precision/round-half-to-even 401 * _PY_SET_53BIT_PRECISION_END : restore original FPU settings 402 * _PY_SET_53BIT_PRECISION_HEADER : any variable declarations needed to 403 * use the two macros above. 404 * 405 * The macros are designed to be used within a single C function: see 406 * Python/pystrtod.c for an example of their use. 407 */ 408 409 /* get and set x87 control word for gcc/x86 */ 410 #ifdef HAVE_GCC_ASM_FOR_X87 411 #define HAVE_PY_SET_53BIT_PRECISION 1 412 /* _Py_get/set_387controlword functions are defined in Python/pymath.c */ 413 #define _Py_SET_53BIT_PRECISION_HEADER \ 414 unsigned short old_387controlword, new_387controlword 415 #define _Py_SET_53BIT_PRECISION_START \ 416 do { \ 417 old_387controlword = _Py_get_387controlword(); \ 418 new_387controlword = (old_387controlword & ~0x0f00) | 0x0200; \ 419 if (new_387controlword != old_387controlword) \ 420 _Py_set_387controlword(new_387controlword); \ 421 } while (0) 422 #define _Py_SET_53BIT_PRECISION_END \ 423 if (new_387controlword != old_387controlword) \ 424 _Py_set_387controlword(old_387controlword) 425 #endif 426 427 /* get and set x87 control word for VisualStudio/x86 */ 428 #if defined(_MSC_VER) && !defined(_WIN64) && !defined(_M_ARM) /* x87 not supported in 64-bit or ARM */ 429 #define HAVE_PY_SET_53BIT_PRECISION 1 430 #define _Py_SET_53BIT_PRECISION_HEADER \ 431 unsigned int old_387controlword, new_387controlword, out_387controlword 432 /* We use the __control87_2 function to set only the x87 control word. 433 The SSE control word is unaffected. */ 434 #define _Py_SET_53BIT_PRECISION_START \ 435 do { \ 436 __control87_2(0, 0, &old_387controlword, NULL); \ 437 new_387controlword = \ 438 (old_387controlword & ~(_MCW_PC | _MCW_RC)) | (_PC_53 | _RC_NEAR); \ 439 if (new_387controlword != old_387controlword) \ 440 __control87_2(new_387controlword, _MCW_PC | _MCW_RC, \ 441 &out_387controlword, NULL); \ 442 } while (0) 443 #define _Py_SET_53BIT_PRECISION_END \ 444 do { \ 445 if (new_387controlword != old_387controlword) \ 446 __control87_2(old_387controlword, _MCW_PC | _MCW_RC, \ 447 &out_387controlword, NULL); \ 448 } while (0) 449 #endif 450 451 #ifdef HAVE_GCC_ASM_FOR_MC68881 452 #define HAVE_PY_SET_53BIT_PRECISION 1 453 #define _Py_SET_53BIT_PRECISION_HEADER \ 454 unsigned int old_fpcr, new_fpcr 455 #define _Py_SET_53BIT_PRECISION_START \ 456 do { \ 457 __asm__ ("fmove.l %%fpcr,%0" : "=g" (old_fpcr)); \ 458 /* Set double precision / round to nearest. */ \ 459 new_fpcr = (old_fpcr & ~0xf0) | 0x80; \ 460 if (new_fpcr != old_fpcr) \ 461 __asm__ volatile ("fmove.l %0,%%fpcr" : : "g" (new_fpcr)); \ 462 } while (0) 463 #define _Py_SET_53BIT_PRECISION_END \ 464 do { \ 465 if (new_fpcr != old_fpcr) \ 466 __asm__ volatile ("fmove.l %0,%%fpcr" : : "g" (old_fpcr)); \ 467 } while (0) 468 #endif 469 470 /* default definitions are empty */ 471 #ifndef HAVE_PY_SET_53BIT_PRECISION 472 #define _Py_SET_53BIT_PRECISION_HEADER 473 #define _Py_SET_53BIT_PRECISION_START 474 #define _Py_SET_53BIT_PRECISION_END 475 #endif 476 477 /* If we can't guarantee 53-bit precision, don't use the code 478 in Python/dtoa.c, but fall back to standard code. This 479 means that repr of a float will be long (17 sig digits). 480 481 Realistically, there are two things that could go wrong: 482 483 (1) doubles aren't IEEE 754 doubles, or 484 (2) we're on x86 with the rounding precision set to 64-bits 485 (extended precision), and we don't know how to change 486 the rounding precision. 487 */ 488 489 #if !defined(DOUBLE_IS_LITTLE_ENDIAN_IEEE754) && \ 490 !defined(DOUBLE_IS_BIG_ENDIAN_IEEE754) && \ 491 !defined(DOUBLE_IS_ARM_MIXED_ENDIAN_IEEE754) 492 #define PY_NO_SHORT_FLOAT_REPR 493 #endif 494 495 /* double rounding is symptomatic of use of extended precision on x86. If 496 we're seeing double rounding, and we don't have any mechanism available for 497 changing the FPU rounding precision, then don't use Python/dtoa.c. */ 498 #if defined(X87_DOUBLE_ROUNDING) && !defined(HAVE_PY_SET_53BIT_PRECISION) 499 #define PY_NO_SHORT_FLOAT_REPR 500 #endif 501 502 503 /* Py_DEPRECATED(version) 504 * Declare a variable, type, or function deprecated. 505 * The macro must be placed before the declaration. 506 * Usage: 507 * Py_DEPRECATED(3.3) extern int old_var; 508 * Py_DEPRECATED(3.4) typedef int T1; 509 * Py_DEPRECATED(3.8) PyAPI_FUNC(int) Py_OldFunction(void); 510 */ 511 #if defined(__GNUC__) \ 512 && ((__GNUC__ >= 4) || (__GNUC__ == 3) && (__GNUC_MINOR__ >= 1)) 513 #define Py_DEPRECATED(VERSION_UNUSED) __attribute__((__deprecated__)) 514 #elif defined(_MSC_VER) 515 #define Py_DEPRECATED(VERSION) __declspec(deprecated( \ 516 "deprecated in " #VERSION)) 517 #else 518 #define Py_DEPRECATED(VERSION_UNUSED) 519 #endif 520 521 #if defined(__clang__) 522 #define _Py_COMP_DIAG_PUSH _Pragma("clang diagnostic push") 523 #define _Py_COMP_DIAG_IGNORE_DEPR_DECLS \ 524 _Pragma("clang diagnostic ignored \"-Wdeprecated-declarations\"") 525 #define _Py_COMP_DIAG_POP _Pragma("clang diagnostic pop") 526 #elif defined(__GNUC__) \ 527 && ((__GNUC__ >= 5) || (__GNUC__ == 4) && (__GNUC_MINOR__ >= 6)) 528 #define _Py_COMP_DIAG_PUSH _Pragma("GCC diagnostic push") 529 #define _Py_COMP_DIAG_IGNORE_DEPR_DECLS \ 530 _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"") 531 #define _Py_COMP_DIAG_POP _Pragma("GCC diagnostic pop") 532 #elif defined(_MSC_VER) 533 #define _Py_COMP_DIAG_PUSH __pragma(warning(push)) 534 #define _Py_COMP_DIAG_IGNORE_DEPR_DECLS __pragma(warning(disable: 4996)) 535 #define _Py_COMP_DIAG_POP __pragma(warning(pop)) 536 #else 537 #define _Py_COMP_DIAG_PUSH 538 #define _Py_COMP_DIAG_IGNORE_DEPR_DECLS 539 #define _Py_COMP_DIAG_POP 540 #endif 541 542 /* _Py_HOT_FUNCTION 543 * The hot attribute on a function is used to inform the compiler that the 544 * function is a hot spot of the compiled program. The function is optimized 545 * more aggressively and on many target it is placed into special subsection of 546 * the text section so all hot functions appears close together improving 547 * locality. 548 * 549 * Usage: 550 * int _Py_HOT_FUNCTION x(void) { return 3; } 551 * 552 * Issue #28618: This attribute must not be abused, otherwise it can have a 553 * negative effect on performance. Only the functions were Python spend most of 554 * its time must use it. Use a profiler when running performance benchmark 555 * suite to find these functions. 556 */ 557 #if defined(__GNUC__) \ 558 && ((__GNUC__ >= 5) || (__GNUC__ == 4) && (__GNUC_MINOR__ >= 3)) 559 #define _Py_HOT_FUNCTION __attribute__((hot)) 560 #else 561 #define _Py_HOT_FUNCTION 562 #endif 563 564 /* _Py_NO_INLINE 565 * Disable inlining on a function. For example, it helps to reduce the C stack 566 * consumption. 567 * 568 * Usage: 569 * int _Py_NO_INLINE x(void) { return 3; } 570 */ 571 #if defined(_MSC_VER) 572 # define _Py_NO_INLINE __declspec(noinline) 573 #elif defined(__GNUC__) || defined(__clang__) 574 # define _Py_NO_INLINE __attribute__ ((noinline)) 575 #else 576 # define _Py_NO_INLINE 577 #endif 578 579 /************************************************************************** 580 Prototypes that are missing from the standard include files on some systems 581 (and possibly only some versions of such systems.) 582 583 Please be conservative with adding new ones, document them and enclose them 584 in platform-specific #ifdefs. 585 **************************************************************************/ 586 587 #ifdef SOLARIS 588 /* Unchecked */ 589 extern int gethostname(char *, int); 590 #endif 591 592 #ifdef HAVE__GETPTY 593 #include <sys/types.h> /* we need to import mode_t */ 594 extern char * _getpty(int *, int, mode_t, int); 595 #endif 596 597 /* On QNX 6, struct termio must be declared by including sys/termio.h 598 if TCGETA, TCSETA, TCSETAW, or TCSETAF are used. sys/termio.h must 599 be included before termios.h or it will generate an error. */ 600 #if defined(HAVE_SYS_TERMIO_H) && !defined(__hpux) 601 #include <sys/termio.h> 602 #endif 603 604 605 /* On 4.4BSD-descendants, ctype functions serves the whole range of 606 * wchar_t character set rather than single byte code points only. 607 * This characteristic can break some operations of string object 608 * including str.upper() and str.split() on UTF-8 locales. This 609 * workaround was provided by Tim Robbins of FreeBSD project. 610 */ 611 612 #if defined(__APPLE__) 613 # define _PY_PORT_CTYPE_UTF8_ISSUE 614 #endif 615 616 #ifdef _PY_PORT_CTYPE_UTF8_ISSUE 617 #ifndef __cplusplus 618 /* The workaround below is unsafe in C++ because 619 * the <locale> defines these symbols as real functions, 620 * with a slightly different signature. 621 * See issue #10910 622 */ 623 #include <ctype.h> 624 #include <wctype.h> 625 #undef isalnum 626 #define isalnum(c) iswalnum(btowc(c)) 627 #undef isalpha 628 #define isalpha(c) iswalpha(btowc(c)) 629 #undef islower 630 #define islower(c) iswlower(btowc(c)) 631 #undef isspace 632 #define isspace(c) iswspace(btowc(c)) 633 #undef isupper 634 #define isupper(c) iswupper(btowc(c)) 635 #undef tolower 636 #define tolower(c) towlower(btowc(c)) 637 #undef toupper 638 #define toupper(c) towupper(btowc(c)) 639 #endif 640 #endif 641 642 643 /* Declarations for symbol visibility. 644 645 PyAPI_FUNC(type): Declares a public Python API function and return type 646 PyAPI_DATA(type): Declares public Python data and its type 647 PyMODINIT_FUNC: A Python module init function. If these functions are 648 inside the Python core, they are private to the core. 649 If in an extension module, it may be declared with 650 external linkage depending on the platform. 651 652 As a number of platforms support/require "__declspec(dllimport/dllexport)", 653 we support a HAVE_DECLSPEC_DLL macro to save duplication. 654 */ 655 656 /* 657 All windows ports, except cygwin, are handled in PC/pyconfig.h. 658 659 Cygwin is the only other autoconf platform requiring special 660 linkage handling and it uses __declspec(). 661 */ 662 #if defined(__CYGWIN__) 663 # define HAVE_DECLSPEC_DLL 664 #endif 665 666 #include "exports.h" 667 668 /* only get special linkage if built as shared or platform is Cygwin */ 669 #if defined(Py_ENABLE_SHARED) || defined(__CYGWIN__) 670 # if defined(HAVE_DECLSPEC_DLL) 671 # if defined(Py_BUILD_CORE) && !defined(Py_BUILD_CORE_MODULE) 672 # define PyAPI_FUNC(RTYPE) Py_EXPORTED_SYMBOL RTYPE 673 # define PyAPI_DATA(RTYPE) extern Py_EXPORTED_SYMBOL RTYPE 674 /* module init functions inside the core need no external linkage */ 675 /* except for Cygwin to handle embedding */ 676 # if defined(__CYGWIN__) 677 # define PyMODINIT_FUNC Py_EXPORTED_SYMBOL PyObject* 678 # else /* __CYGWIN__ */ 679 # define PyMODINIT_FUNC PyObject* 680 # endif /* __CYGWIN__ */ 681 # else /* Py_BUILD_CORE */ 682 /* Building an extension module, or an embedded situation */ 683 /* public Python functions and data are imported */ 684 /* Under Cygwin, auto-import functions to prevent compilation */ 685 /* failures similar to those described at the bottom of 4.1: */ 686 /* http://docs.python.org/extending/windows.html#a-cookbook-approach */ 687 # if !defined(__CYGWIN__) 688 # define PyAPI_FUNC(RTYPE) Py_IMPORTED_SYMBOL RTYPE 689 # endif /* !__CYGWIN__ */ 690 # define PyAPI_DATA(RTYPE) extern Py_IMPORTED_SYMBOL RTYPE 691 /* module init functions outside the core must be exported */ 692 # if defined(__cplusplus) 693 # define PyMODINIT_FUNC extern "C" Py_EXPORTED_SYMBOL PyObject* 694 # else /* __cplusplus */ 695 # define PyMODINIT_FUNC Py_EXPORTED_SYMBOL PyObject* 696 # endif /* __cplusplus */ 697 # endif /* Py_BUILD_CORE */ 698 # endif /* HAVE_DECLSPEC_DLL */ 699 #endif /* Py_ENABLE_SHARED */ 700 701 /* If no external linkage macros defined by now, create defaults */ 702 #ifndef PyAPI_FUNC 703 # define PyAPI_FUNC(RTYPE) Py_EXPORTED_SYMBOL RTYPE 704 #endif 705 #ifndef PyAPI_DATA 706 # define PyAPI_DATA(RTYPE) extern Py_EXPORTED_SYMBOL RTYPE 707 #endif 708 #ifndef PyMODINIT_FUNC 709 # if defined(__cplusplus) 710 # define PyMODINIT_FUNC extern "C" Py_EXPORTED_SYMBOL PyObject* 711 # else /* __cplusplus */ 712 # define PyMODINIT_FUNC Py_EXPORTED_SYMBOL PyObject* 713 # endif /* __cplusplus */ 714 #endif 715 716 /* limits.h constants that may be missing */ 717 718 #ifndef INT_MAX 719 #define INT_MAX 2147483647 720 #endif 721 722 #ifndef LONG_MAX 723 #if SIZEOF_LONG == 4 724 #define LONG_MAX 0X7FFFFFFFL 725 #elif SIZEOF_LONG == 8 726 #define LONG_MAX 0X7FFFFFFFFFFFFFFFL 727 #else 728 #error "could not set LONG_MAX in pyport.h" 729 #endif 730 #endif 731 732 #ifndef LONG_MIN 733 #define LONG_MIN (-LONG_MAX-1) 734 #endif 735 736 #ifndef LONG_BIT 737 #define LONG_BIT (8 * SIZEOF_LONG) 738 #endif 739 740 #if LONG_BIT != 8 * SIZEOF_LONG 741 /* 04-Oct-2000 LONG_BIT is apparently (mis)defined as 64 on some recent 742 * 32-bit platforms using gcc. We try to catch that here at compile-time 743 * rather than waiting for integer multiplication to trigger bogus 744 * overflows. 745 */ 746 #error "LONG_BIT definition appears wrong for platform (bad gcc/glibc config?)." 747 #endif 748 749 #ifdef __cplusplus 750 } 751 #endif 752 753 /* 754 * Hide GCC attributes from compilers that don't support them. 755 */ 756 #if (!defined(__GNUC__) || __GNUC__ < 2 || \ 757 (__GNUC__ == 2 && __GNUC_MINOR__ < 7) ) 758 #define Py_GCC_ATTRIBUTE(x) 759 #else 760 #define Py_GCC_ATTRIBUTE(x) __attribute__(x) 761 #endif 762 763 /* 764 * Specify alignment on compilers that support it. 765 */ 766 #if defined(__GNUC__) && __GNUC__ >= 3 767 #define Py_ALIGNED(x) __attribute__((aligned(x))) 768 #else 769 #define Py_ALIGNED(x) 770 #endif 771 772 /* Eliminate end-of-loop code not reached warnings from SunPro C 773 * when using do{...}while(0) macros 774 */ 775 #ifdef __SUNPRO_C 776 #pragma error_messages (off,E_END_OF_LOOP_CODE_NOT_REACHED) 777 #endif 778 779 #ifndef Py_LL 780 #define Py_LL(x) x##LL 781 #endif 782 783 #ifndef Py_ULL 784 #define Py_ULL(x) Py_LL(x##U) 785 #endif 786 787 #define Py_VA_COPY va_copy 788 789 /* 790 * Convenient macros to deal with endianness of the platform. WORDS_BIGENDIAN is 791 * detected by configure and defined in pyconfig.h. The code in pyconfig.h 792 * also takes care of Apple's universal builds. 793 */ 794 795 #ifdef WORDS_BIGENDIAN 796 # define PY_BIG_ENDIAN 1 797 # define PY_LITTLE_ENDIAN 0 798 #else 799 # define PY_BIG_ENDIAN 0 800 # define PY_LITTLE_ENDIAN 1 801 #endif 802 803 #ifdef Py_BUILD_CORE 804 /* 805 * Macros to protect CRT calls against instant termination when passed an 806 * invalid parameter (issue23524). 807 */ 808 #if defined _MSC_VER && _MSC_VER >= 1900 809 810 extern _invalid_parameter_handler _Py_silent_invalid_parameter_handler; 811 #define _Py_BEGIN_SUPPRESS_IPH { _invalid_parameter_handler _Py_old_handler = \ 812 _set_thread_local_invalid_parameter_handler(_Py_silent_invalid_parameter_handler); 813 #define _Py_END_SUPPRESS_IPH _set_thread_local_invalid_parameter_handler(_Py_old_handler); } 814 815 #else 816 817 #define _Py_BEGIN_SUPPRESS_IPH 818 #define _Py_END_SUPPRESS_IPH 819 820 #endif /* _MSC_VER >= 1900 */ 821 #endif /* Py_BUILD_CORE */ 822 823 #ifdef __ANDROID__ 824 /* The Android langinfo.h header is not used. */ 825 # undef HAVE_LANGINFO_H 826 # undef CODESET 827 #endif 828 829 /* Maximum value of the Windows DWORD type */ 830 #define PY_DWORD_MAX 4294967295U 831 832 /* This macro used to tell whether Python was built with multithreading 833 * enabled. Now multithreading is always enabled, but keep the macro 834 * for compatibility. 835 */ 836 #ifndef WITH_THREAD 837 # define WITH_THREAD 838 #endif 839 840 /* Check that ALT_SOABI is consistent with Py_TRACE_REFS: 841 ./configure --with-trace-refs should must be used to define Py_TRACE_REFS */ 842 #if defined(ALT_SOABI) && defined(Py_TRACE_REFS) 843 # error "Py_TRACE_REFS ABI is not compatible with release and debug ABI" 844 #endif 845 846 #if defined(__ANDROID__) || defined(__VXWORKS__) 847 // Use UTF-8 as the locale encoding, ignore the LC_CTYPE locale. 848 // See _Py_GetLocaleEncoding(), PyUnicode_DecodeLocale() 849 // and PyUnicode_EncodeLocale(). 850 # define _Py_FORCE_UTF8_LOCALE 851 #endif 852 853 #if defined(_Py_FORCE_UTF8_LOCALE) || defined(__APPLE__) 854 // Use UTF-8 as the filesystem encoding. 855 // See PyUnicode_DecodeFSDefaultAndSize(), PyUnicode_EncodeFSDefault(), 856 // Py_DecodeLocale() and Py_EncodeLocale(). 857 # define _Py_FORCE_UTF8_FS_ENCODING 858 #endif 859 860 /* Mark a function which cannot return. Example: 861 PyAPI_FUNC(void) _Py_NO_RETURN PyThread_exit_thread(void); 862 863 XLC support is intentionally omitted due to bpo-40244 */ 864 #ifndef _Py_NO_RETURN 865 #if defined(__clang__) || \ 866 (defined(__GNUC__) && \ 867 ((__GNUC__ >= 3) || \ 868 (__GNUC__ == 2) && (__GNUC_MINOR__ >= 5))) 869 # define _Py_NO_RETURN __attribute__((__noreturn__)) 870 #elif defined(_MSC_VER) 871 # define _Py_NO_RETURN __declspec(noreturn) 872 #else 873 # define _Py_NO_RETURN 874 #endif 875 #endif 876 877 878 // Preprocessor check for a builtin preprocessor function. Always return 0 879 // if __has_builtin() macro is not defined. 880 // 881 // __has_builtin() is available on clang and GCC 10. 882 #ifdef __has_builtin 883 # define _Py__has_builtin(x) __has_builtin(x) 884 #else 885 # define _Py__has_builtin(x) 0 886 #endif 887 888 889 #endif /* Py_PYPORT_H */ 890