1 /*------------------------------------------------------------------------- 2 * 3 * c.h 4 * Fundamental C definitions. This is included by every .c file in 5 * PostgreSQL (via either postgres.h or postgres_fe.h, as appropriate). 6 * 7 * Note that the definitions here are not intended to be exposed to clients 8 * of the frontend interface libraries --- so we don't worry much about 9 * polluting the namespace with lots of stuff... 10 * 11 * 12 * Portions Copyright (c) 1996-2021, PostgreSQL Global Development Group 13 * Portions Copyright (c) 1994, Regents of the University of California 14 * 15 * src/include/c.h 16 * 17 *------------------------------------------------------------------------- 18 */ 19 /* 20 *---------------------------------------------------------------- 21 * TABLE OF CONTENTS 22 * 23 * When adding stuff to this file, please try to put stuff 24 * into the relevant section, or add new sections as appropriate. 25 * 26 * section description 27 * ------- ------------------------------------------------ 28 * 0) pg_config.h and standard system headers 29 * 1) compiler characteristics 30 * 2) bool, true, false 31 * 3) standard system types 32 * 4) IsValid macros for system types 33 * 5) offsetof, lengthof, alignment 34 * 6) assertions 35 * 7) widely useful macros 36 * 8) random stuff 37 * 9) system-specific hacks 38 * 39 * NOTE: since this file is included by both frontend and backend modules, 40 * it's usually wrong to put an "extern" declaration here, unless it's 41 * ifdef'd so that it's seen in only one case or the other. 42 * typedefs and macros are the kind of thing that might go here. 43 * 44 *---------------------------------------------------------------- 45 */ 46 #ifndef C_H 47 #define C_H 48 49 #include "postgres_ext.h" 50 51 /* Must undef pg_config_ext.h symbols before including pg_config.h */ 52 #undef PG_INT64_TYPE 53 54 #include "pg_config.h" 55 #include "pg_config_manual.h" /* must be after pg_config.h */ 56 #include "pg_config_os.h" /* must be before any system header files */ 57 58 /* System header files that should be available everywhere in Postgres */ 59 #include <stdio.h> 60 #include <stdlib.h> 61 #include <string.h> 62 #include <stddef.h> 63 #include <stdarg.h> 64 #ifdef HAVE_STRINGS_H 65 #include <strings.h> 66 #endif 67 #include <stdint.h> 68 #include <sys/types.h> 69 #include <errno.h> 70 #if defined(WIN32) || defined(__CYGWIN__) 71 #include <fcntl.h> /* ensure O_BINARY is available */ 72 #endif 73 #include <locale.h> 74 #ifdef ENABLE_NLS 75 #include <libintl.h> 76 #endif 77 78 79 /* ---------------------------------------------------------------- 80 * Section 1: compiler characteristics 81 * 82 * type prefixes (const, signed, volatile, inline) are handled in pg_config.h. 83 * ---------------------------------------------------------------- 84 */ 85 86 /* 87 * Disable "inline" if PG_FORCE_DISABLE_INLINE is defined. 88 * This is used to work around compiler bugs and might also be useful for 89 * investigatory purposes. 90 */ 91 #ifdef PG_FORCE_DISABLE_INLINE 92 #undef inline 93 #define inline 94 #endif 95 96 /* 97 * Attribute macros 98 * 99 * GCC: https://gcc.gnu.org/onlinedocs/gcc/Function-Attributes.html 100 * GCC: https://gcc.gnu.org/onlinedocs/gcc/Type-Attributes.html 101 * Clang: https://clang.llvm.org/docs/AttributeReference.html 102 * Sunpro: https://docs.oracle.com/cd/E18659_01/html/821-1384/gjzke.html 103 * XLC: https://www.ibm.com/support/knowledgecenter/SSGH2K_13.1.2/com.ibm.xlc131.aix.doc/language_ref/function_attributes.html 104 * XLC: https://www.ibm.com/support/knowledgecenter/SSGH2K_13.1.2/com.ibm.xlc131.aix.doc/language_ref/type_attrib.html 105 */ 106 107 /* 108 * For compilers which don't support __has_attribute, we just define 109 * __has_attribute(x) to 0 so that we can define macros for various 110 * __attribute__s more easily below. 111 */ 112 #ifndef __has_attribute 113 #define __has_attribute(attribute) 0 114 #endif 115 116 /* only GCC supports the unused attribute */ 117 #ifdef __GNUC__ 118 #define pg_attribute_unused() __attribute__((unused)) 119 #else 120 #define pg_attribute_unused() 121 #endif 122 123 /* 124 * pg_nodiscard means the compiler should warn if the result of a function 125 * call is ignored. The name "nodiscard" is chosen in alignment with 126 * (possibly future) C and C++ standards. For maximum compatibility, use it 127 * as a function declaration specifier, so it goes before the return type. 128 */ 129 #ifdef __GNUC__ 130 #define pg_nodiscard __attribute__((warn_unused_result)) 131 #else 132 #define pg_nodiscard 133 #endif 134 135 /* 136 * Place this macro before functions that should be allowed to make misaligned 137 * accesses. Think twice before using it on non-x86-specific code! 138 * Testing can be done with "-fsanitize=alignment -fsanitize-trap=alignment" 139 * on clang, or "-fsanitize=alignment -fno-sanitize-recover=alignment" on gcc. 140 */ 141 #if __clang_major__ >= 7 || __GNUC__ >= 8 142 #define pg_attribute_no_sanitize_alignment() __attribute__((no_sanitize("alignment"))) 143 #else 144 #define pg_attribute_no_sanitize_alignment() 145 #endif 146 147 /* 148 * Append PG_USED_FOR_ASSERTS_ONLY to definitions of variables that are only 149 * used in assert-enabled builds, to avoid compiler warnings about unused 150 * variables in assert-disabled builds. 151 */ 152 #ifdef USE_ASSERT_CHECKING 153 #define PG_USED_FOR_ASSERTS_ONLY 154 #else 155 #define PG_USED_FOR_ASSERTS_ONLY pg_attribute_unused() 156 #endif 157 158 /* GCC and XLC support format attributes */ 159 #if defined(__GNUC__) || defined(__IBMC__) 160 #define pg_attribute_format_arg(a) __attribute__((format_arg(a))) 161 #define pg_attribute_printf(f,a) __attribute__((format(PG_PRINTF_ATTRIBUTE, f, a))) 162 #else 163 #define pg_attribute_format_arg(a) 164 #define pg_attribute_printf(f,a) 165 #endif 166 167 /* GCC, Sunpro and XLC support aligned, packed and noreturn */ 168 #if defined(__GNUC__) || defined(__SUNPRO_C) || defined(__IBMC__) 169 #define pg_attribute_aligned(a) __attribute__((aligned(a))) 170 #define pg_attribute_noreturn() __attribute__((noreturn)) 171 #define pg_attribute_packed() __attribute__((packed)) 172 #define HAVE_PG_ATTRIBUTE_NORETURN 1 173 #else 174 /* 175 * NB: aligned and packed are not given default definitions because they 176 * affect code functionality; they *must* be implemented by the compiler 177 * if they are to be used. 178 */ 179 #define pg_attribute_noreturn() 180 #endif 181 182 /* 183 * Use "pg_attribute_always_inline" in place of "inline" for functions that 184 * we wish to force inlining of, even when the compiler's heuristics would 185 * choose not to. But, if possible, don't force inlining in unoptimized 186 * debug builds. 187 */ 188 #if (defined(__GNUC__) && __GNUC__ > 3 && defined(__OPTIMIZE__)) || defined(__SUNPRO_C) || defined(__IBMC__) 189 /* GCC > 3, Sunpro and XLC support always_inline via __attribute__ */ 190 #define pg_attribute_always_inline __attribute__((always_inline)) inline 191 #elif defined(_MSC_VER) 192 /* MSVC has a special keyword for this */ 193 #define pg_attribute_always_inline __forceinline 194 #else 195 /* Otherwise, the best we can do is to say "inline" */ 196 #define pg_attribute_always_inline inline 197 #endif 198 199 /* 200 * Forcing a function not to be inlined can be useful if it's the slow path of 201 * a performance-critical function, or should be visible in profiles to allow 202 * for proper cost attribution. Note that unlike the pg_attribute_XXX macros 203 * above, this should be placed before the function's return type and name. 204 */ 205 /* GCC, Sunpro and XLC support noinline via __attribute__ */ 206 #if (defined(__GNUC__) && __GNUC__ > 2) || defined(__SUNPRO_C) || defined(__IBMC__) 207 #define pg_noinline __attribute__((noinline)) 208 /* msvc via declspec */ 209 #elif defined(_MSC_VER) 210 #define pg_noinline __declspec(noinline) 211 #else 212 #define pg_noinline 213 #endif 214 215 /* 216 * For now, just define pg_attribute_cold and pg_attribute_hot to be empty 217 * macros on minGW 8.1. There appears to be a compiler bug that results in 218 * compilation failure. At this time, we still have at least one buildfarm 219 * animal running that compiler, so this should make that green again. It's 220 * likely this compiler is not popular enough to warrant keeping this code 221 * around forever, so let's just remove it once the last buildfarm animal 222 * upgrades. 223 */ 224 #if defined(__MINGW64__) && __GNUC__ == 8 && __GNUC_MINOR__ == 1 225 226 #define pg_attribute_cold 227 #define pg_attribute_hot 228 229 #else 230 /* 231 * Marking certain functions as "hot" or "cold" can be useful to assist the 232 * compiler in arranging the assembly code in a more efficient way. 233 */ 234 #if __has_attribute (cold) 235 #define pg_attribute_cold __attribute__((cold)) 236 #else 237 #define pg_attribute_cold 238 #endif 239 240 #if __has_attribute (hot) 241 #define pg_attribute_hot __attribute__((hot)) 242 #else 243 #define pg_attribute_hot 244 #endif 245 246 #endif /* defined(__MINGW64__) && __GNUC__ == 8 && 247 * __GNUC_MINOR__ == 1 */ 248 /* 249 * Mark a point as unreachable in a portable fashion. This should preferably 250 * be something that the compiler understands, to aid code generation. 251 * In assert-enabled builds, we prefer abort() for debugging reasons. 252 */ 253 #if defined(HAVE__BUILTIN_UNREACHABLE) && !defined(USE_ASSERT_CHECKING) 254 #define pg_unreachable() __builtin_unreachable() 255 #elif defined(_MSC_VER) && !defined(USE_ASSERT_CHECKING) 256 #define pg_unreachable() __assume(0) 257 #else 258 #define pg_unreachable() abort() 259 #endif 260 261 /* 262 * Hints to the compiler about the likelihood of a branch. Both likely() and 263 * unlikely() return the boolean value of the contained expression. 264 * 265 * These should only be used sparingly, in very hot code paths. It's very easy 266 * to mis-estimate likelihoods. 267 */ 268 #if __GNUC__ >= 3 269 #define likely(x) __builtin_expect((x) != 0, 1) 270 #define unlikely(x) __builtin_expect((x) != 0, 0) 271 #else 272 #define likely(x) ((x) != 0) 273 #define unlikely(x) ((x) != 0) 274 #endif 275 276 /* 277 * CppAsString 278 * Convert the argument to a string, using the C preprocessor. 279 * CppAsString2 280 * Convert the argument to a string, after one round of macro expansion. 281 * CppConcat 282 * Concatenate two arguments together, using the C preprocessor. 283 * 284 * Note: There used to be support here for pre-ANSI C compilers that didn't 285 * support # and ##. Nowadays, these macros are just for clarity and/or 286 * backward compatibility with existing PostgreSQL code. 287 */ 288 #define CppAsString(identifier) #identifier 289 #define CppAsString2(x) CppAsString(x) 290 #define CppConcat(x, y) x##y 291 292 /* 293 * VA_ARGS_NARGS 294 * Returns the number of macro arguments it is passed. 295 * 296 * An empty argument still counts as an argument, so effectively, this is 297 * "one more than the number of commas in the argument list". 298 * 299 * This works for up to 63 arguments. Internally, VA_ARGS_NARGS_() is passed 300 * 64+N arguments, and the C99 standard only requires macros to allow up to 301 * 127 arguments, so we can't portably go higher. The implementation is 302 * pretty trivial: VA_ARGS_NARGS_() returns its 64th argument, and we set up 303 * the call so that that is the appropriate one of the list of constants. 304 * This idea is due to Laurent Deniau. 305 */ 306 #define VA_ARGS_NARGS(...) \ 307 VA_ARGS_NARGS_(__VA_ARGS__, \ 308 63,62,61,60, \ 309 59,58,57,56,55,54,53,52,51,50, \ 310 49,48,47,46,45,44,43,42,41,40, \ 311 39,38,37,36,35,34,33,32,31,30, \ 312 29,28,27,26,25,24,23,22,21,20, \ 313 19,18,17,16,15,14,13,12,11,10, \ 314 9, 8, 7, 6, 5, 4, 3, 2, 1, 0) 315 #define VA_ARGS_NARGS_( \ 316 _01,_02,_03,_04,_05,_06,_07,_08,_09,_10, \ 317 _11,_12,_13,_14,_15,_16,_17,_18,_19,_20, \ 318 _21,_22,_23,_24,_25,_26,_27,_28,_29,_30, \ 319 _31,_32,_33,_34,_35,_36,_37,_38,_39,_40, \ 320 _41,_42,_43,_44,_45,_46,_47,_48,_49,_50, \ 321 _51,_52,_53,_54,_55,_56,_57,_58,_59,_60, \ 322 _61,_62,_63, N, ...) \ 323 (N) 324 325 /* 326 * dummyret is used to set return values in macros that use ?: to make 327 * assignments. gcc wants these to be void, other compilers like char 328 */ 329 #ifdef __GNUC__ /* GNU cc */ 330 #define dummyret void 331 #else 332 #define dummyret char 333 #endif 334 335 /* 336 * Generic function pointer. This can be used in the rare cases where it's 337 * necessary to cast a function pointer to a seemingly incompatible function 338 * pointer type while avoiding gcc's -Wcast-function-type warnings. 339 */ 340 typedef void (*pg_funcptr_t) (void); 341 342 /* 343 * We require C99, hence the compiler should understand flexible array 344 * members. However, for documentation purposes we still consider it to be 345 * project style to write "field[FLEXIBLE_ARRAY_MEMBER]" not just "field[]". 346 * When computing the size of such an object, use "offsetof(struct s, f)" 347 * for portability. Don't use "offsetof(struct s, f[0])", as this doesn't 348 * work with MSVC and with C++ compilers. 349 */ 350 #define FLEXIBLE_ARRAY_MEMBER /* empty */ 351 352 /* Which __func__ symbol do we have, if any? */ 353 #ifdef HAVE_FUNCNAME__FUNC 354 #define PG_FUNCNAME_MACRO __func__ 355 #else 356 #ifdef HAVE_FUNCNAME__FUNCTION 357 #define PG_FUNCNAME_MACRO __FUNCTION__ 358 #else 359 #define PG_FUNCNAME_MACRO NULL 360 #endif 361 #endif 362 363 364 /* ---------------------------------------------------------------- 365 * Section 2: bool, true, false 366 * ---------------------------------------------------------------- 367 */ 368 369 /* 370 * bool 371 * Boolean value, either true or false. 372 * 373 * We use stdbool.h if available and its bool has size 1. That's useful for 374 * better compiler and debugger output and for compatibility with third-party 375 * libraries. But PostgreSQL currently cannot deal with bool of other sizes; 376 * there are static assertions around the code to prevent that. 377 * 378 * For C++ compilers, we assume the compiler has a compatible built-in 379 * definition of bool. 380 * 381 * See also the version of this code in src/interfaces/ecpg/include/ecpglib.h. 382 */ 383 384 #ifndef __cplusplus 385 386 #ifdef PG_USE_STDBOOL 387 #include <stdbool.h> 388 #else 389 390 #ifndef bool 391 typedef unsigned char bool; 392 #endif 393 394 #ifndef true 395 #define true ((bool) 1) 396 #endif 397 398 #ifndef false 399 #define false ((bool) 0) 400 #endif 401 402 #endif /* not PG_USE_STDBOOL */ 403 #endif /* not C++ */ 404 405 406 /* ---------------------------------------------------------------- 407 * Section 3: standard system types 408 * ---------------------------------------------------------------- 409 */ 410 411 /* 412 * Pointer 413 * Variable holding address of any memory resident object. 414 * 415 * XXX Pointer arithmetic is done with this, so it can't be void * 416 * under "true" ANSI compilers. 417 */ 418 typedef char *Pointer; 419 420 /* 421 * intN 422 * Signed integer, EXACTLY N BITS IN SIZE, 423 * used for numerical computations and the 424 * frontend/backend protocol. 425 */ 426 #ifndef HAVE_INT8 427 typedef signed char int8; /* == 8 bits */ 428 typedef signed short int16; /* == 16 bits */ 429 typedef signed int int32; /* == 32 bits */ 430 #endif /* not HAVE_INT8 */ 431 432 /* 433 * uintN 434 * Unsigned integer, EXACTLY N BITS IN SIZE, 435 * used for numerical computations and the 436 * frontend/backend protocol. 437 */ 438 #ifndef HAVE_UINT8 439 typedef unsigned char uint8; /* == 8 bits */ 440 typedef unsigned short uint16; /* == 16 bits */ 441 typedef unsigned int uint32; /* == 32 bits */ 442 #endif /* not HAVE_UINT8 */ 443 444 /* 445 * bitsN 446 * Unit of bitwise operation, AT LEAST N BITS IN SIZE. 447 */ 448 typedef uint8 bits8; /* >= 8 bits */ 449 typedef uint16 bits16; /* >= 16 bits */ 450 typedef uint32 bits32; /* >= 32 bits */ 451 452 /* 453 * 64-bit integers 454 */ 455 #ifdef HAVE_LONG_INT_64 456 /* Plain "long int" fits, use it */ 457 458 #ifndef HAVE_INT64 459 typedef long int int64; 460 #endif 461 #ifndef HAVE_UINT64 462 typedef unsigned long int uint64; 463 #endif 464 #define INT64CONST(x) (x##L) 465 #define UINT64CONST(x) (x##UL) 466 #elif defined(HAVE_LONG_LONG_INT_64) 467 /* We have working support for "long long int", use that */ 468 469 #ifndef HAVE_INT64 470 typedef long long int int64; 471 #endif 472 #ifndef HAVE_UINT64 473 typedef unsigned long long int uint64; 474 #endif 475 #define INT64CONST(x) (x##LL) 476 #define UINT64CONST(x) (x##ULL) 477 #else 478 /* neither HAVE_LONG_INT_64 nor HAVE_LONG_LONG_INT_64 */ 479 #error must have a working 64-bit integer datatype 480 #endif 481 482 /* snprintf format strings to use for 64-bit integers */ 483 #define INT64_FORMAT "%" INT64_MODIFIER "d" 484 #define UINT64_FORMAT "%" INT64_MODIFIER "u" 485 486 /* 487 * 128-bit signed and unsigned integers 488 * There currently is only limited support for such types. 489 * E.g. 128bit literals and snprintf are not supported; but math is. 490 * Also, because we exclude such types when choosing MAXIMUM_ALIGNOF, 491 * it must be possible to coerce the compiler to allocate them on no 492 * more than MAXALIGN boundaries. 493 */ 494 #if defined(PG_INT128_TYPE) 495 #if defined(pg_attribute_aligned) || ALIGNOF_PG_INT128_TYPE <= MAXIMUM_ALIGNOF 496 #define HAVE_INT128 1 497 498 typedef PG_INT128_TYPE int128 499 #if defined(pg_attribute_aligned) 500 pg_attribute_aligned(MAXIMUM_ALIGNOF) 501 #endif 502 ; 503 504 typedef unsigned PG_INT128_TYPE uint128 505 #if defined(pg_attribute_aligned) 506 pg_attribute_aligned(MAXIMUM_ALIGNOF) 507 #endif 508 ; 509 510 #endif 511 #endif 512 513 /* 514 * stdint.h limits aren't guaranteed to have compatible types with our fixed 515 * width types. So just define our own. 516 */ 517 #define PG_INT8_MIN (-0x7F-1) 518 #define PG_INT8_MAX (0x7F) 519 #define PG_UINT8_MAX (0xFF) 520 #define PG_INT16_MIN (-0x7FFF-1) 521 #define PG_INT16_MAX (0x7FFF) 522 #define PG_UINT16_MAX (0xFFFF) 523 #define PG_INT32_MIN (-0x7FFFFFFF-1) 524 #define PG_INT32_MAX (0x7FFFFFFF) 525 #define PG_UINT32_MAX (0xFFFFFFFFU) 526 #define PG_INT64_MIN (-INT64CONST(0x7FFFFFFFFFFFFFFF) - 1) 527 #define PG_INT64_MAX INT64CONST(0x7FFFFFFFFFFFFFFF) 528 #define PG_UINT64_MAX UINT64CONST(0xFFFFFFFFFFFFFFFF) 529 530 /* 531 * We now always use int64 timestamps, but keep this symbol defined for the 532 * benefit of external code that might test it. 533 */ 534 #define HAVE_INT64_TIMESTAMP 535 536 /* 537 * Size 538 * Size of any memory resident object, as returned by sizeof. 539 */ 540 typedef size_t Size; 541 542 /* 543 * Index 544 * Index into any memory resident array. 545 * 546 * Note: 547 * Indices are non negative. 548 */ 549 typedef unsigned int Index; 550 551 /* 552 * Offset 553 * Offset into any memory resident array. 554 * 555 * Note: 556 * This differs from an Index in that an Index is always 557 * non negative, whereas Offset may be negative. 558 */ 559 typedef signed int Offset; 560 561 /* 562 * Common Postgres datatype names (as used in the catalogs) 563 */ 564 typedef float float4; 565 typedef double float8; 566 567 #ifdef USE_FLOAT8_BYVAL 568 #define FLOAT8PASSBYVAL true 569 #else 570 #define FLOAT8PASSBYVAL false 571 #endif 572 573 /* 574 * Oid, RegProcedure, TransactionId, SubTransactionId, MultiXactId, 575 * CommandId 576 */ 577 578 /* typedef Oid is in postgres_ext.h */ 579 580 /* 581 * regproc is the type name used in the include/catalog headers, but 582 * RegProcedure is the preferred name in C code. 583 */ 584 typedef Oid regproc; 585 typedef regproc RegProcedure; 586 587 typedef uint32 TransactionId; 588 589 typedef uint32 LocalTransactionId; 590 591 typedef uint32 SubTransactionId; 592 593 #define InvalidSubTransactionId ((SubTransactionId) 0) 594 #define TopSubTransactionId ((SubTransactionId) 1) 595 596 /* MultiXactId must be equivalent to TransactionId, to fit in t_xmax */ 597 typedef TransactionId MultiXactId; 598 599 typedef uint32 MultiXactOffset; 600 601 typedef uint32 CommandId; 602 603 #define FirstCommandId ((CommandId) 0) 604 #define InvalidCommandId (~(CommandId)0) 605 606 607 /* ---------------- 608 * Variable-length datatypes all share the 'struct varlena' header. 609 * 610 * NOTE: for TOASTable types, this is an oversimplification, since the value 611 * may be compressed or moved out-of-line. However datatype-specific routines 612 * are mostly content to deal with de-TOASTed values only, and of course 613 * client-side routines should never see a TOASTed value. But even in a 614 * de-TOASTed value, beware of touching vl_len_ directly, as its 615 * representation is no longer convenient. It's recommended that code always 616 * use macros VARDATA_ANY, VARSIZE_ANY, VARSIZE_ANY_EXHDR, VARDATA, VARSIZE, 617 * and SET_VARSIZE instead of relying on direct mentions of the struct fields. 618 * See postgres.h for details of the TOASTed form. 619 * ---------------- 620 */ 621 struct varlena 622 { 623 char vl_len_[4]; /* Do not touch this field directly! */ 624 char vl_dat[FLEXIBLE_ARRAY_MEMBER]; /* Data content is here */ 625 }; 626 627 #define VARHDRSZ ((int32) sizeof(int32)) 628 629 /* 630 * These widely-used datatypes are just a varlena header and the data bytes. 631 * There is no terminating null or anything like that --- the data length is 632 * always VARSIZE_ANY_EXHDR(ptr). 633 */ 634 typedef struct varlena bytea; 635 typedef struct varlena text; 636 typedef struct varlena BpChar; /* blank-padded char, ie SQL char(n) */ 637 typedef struct varlena VarChar; /* var-length char, ie SQL varchar(n) */ 638 639 /* 640 * Specialized array types. These are physically laid out just the same 641 * as regular arrays (so that the regular array subscripting code works 642 * with them). They exist as distinct types mostly for historical reasons: 643 * they have nonstandard I/O behavior which we don't want to change for fear 644 * of breaking applications that look at the system catalogs. There is also 645 * an implementation issue for oidvector: it's part of the primary key for 646 * pg_proc, and we can't use the normal btree array support routines for that 647 * without circularity. 648 */ 649 typedef struct 650 { 651 int32 vl_len_; /* these fields must match ArrayType! */ 652 int ndim; /* always 1 for int2vector */ 653 int32 dataoffset; /* always 0 for int2vector */ 654 Oid elemtype; 655 int dim1; 656 int lbound1; 657 int16 values[FLEXIBLE_ARRAY_MEMBER]; 658 } int2vector; 659 660 typedef struct 661 { 662 int32 vl_len_; /* these fields must match ArrayType! */ 663 int ndim; /* always 1 for oidvector */ 664 int32 dataoffset; /* always 0 for oidvector */ 665 Oid elemtype; 666 int dim1; 667 int lbound1; 668 Oid values[FLEXIBLE_ARRAY_MEMBER]; 669 } oidvector; 670 671 /* 672 * Representation of a Name: effectively just a C string, but null-padded to 673 * exactly NAMEDATALEN bytes. The use of a struct is historical. 674 */ 675 typedef struct nameData 676 { 677 char data[NAMEDATALEN]; 678 } NameData; 679 typedef NameData *Name; 680 681 #define NameStr(name) ((name).data) 682 683 684 /* ---------------------------------------------------------------- 685 * Section 4: IsValid macros for system types 686 * ---------------------------------------------------------------- 687 */ 688 /* 689 * BoolIsValid 690 * True iff bool is valid. 691 */ 692 #define BoolIsValid(boolean) ((boolean) == false || (boolean) == true) 693 694 /* 695 * PointerIsValid 696 * True iff pointer is valid. 697 */ 698 #define PointerIsValid(pointer) ((const void*)(pointer) != NULL) 699 700 /* 701 * PointerIsAligned 702 * True iff pointer is properly aligned to point to the given type. 703 */ 704 #define PointerIsAligned(pointer, type) \ 705 (((uintptr_t)(pointer) % (sizeof (type))) == 0) 706 707 #define OffsetToPointer(base, offset) \ 708 ((void *)((char *) base + offset)) 709 710 #define OidIsValid(objectId) ((bool) ((objectId) != InvalidOid)) 711 712 #define RegProcedureIsValid(p) OidIsValid(p) 713 714 715 /* ---------------------------------------------------------------- 716 * Section 5: offsetof, lengthof, alignment 717 * ---------------------------------------------------------------- 718 */ 719 /* 720 * offsetof 721 * Offset of a structure/union field within that structure/union. 722 * 723 * XXX This is supposed to be part of stddef.h, but isn't on 724 * some systems (like SunOS 4). 725 */ 726 #ifndef offsetof 727 #define offsetof(type, field) ((long) &((type *)0)->field) 728 #endif /* offsetof */ 729 730 /* 731 * lengthof 732 * Number of elements in an array. 733 */ 734 #define lengthof(array) (sizeof (array) / sizeof ((array)[0])) 735 736 /* ---------------- 737 * Alignment macros: align a length or address appropriately for a given type. 738 * The fooALIGN() macros round up to a multiple of the required alignment, 739 * while the fooALIGN_DOWN() macros round down. The latter are more useful 740 * for problems like "how many X-sized structures will fit in a page?". 741 * 742 * NOTE: TYPEALIGN[_DOWN] will not work if ALIGNVAL is not a power of 2. 743 * That case seems extremely unlikely to be needed in practice, however. 744 * 745 * NOTE: MAXIMUM_ALIGNOF, and hence MAXALIGN(), intentionally exclude any 746 * larger-than-8-byte types the compiler might have. 747 * ---------------- 748 */ 749 750 #define TYPEALIGN(ALIGNVAL,LEN) \ 751 (((uintptr_t) (LEN) + ((ALIGNVAL) - 1)) & ~((uintptr_t) ((ALIGNVAL) - 1))) 752 753 #define SHORTALIGN(LEN) TYPEALIGN(ALIGNOF_SHORT, (LEN)) 754 #define INTALIGN(LEN) TYPEALIGN(ALIGNOF_INT, (LEN)) 755 #define LONGALIGN(LEN) TYPEALIGN(ALIGNOF_LONG, (LEN)) 756 #define DOUBLEALIGN(LEN) TYPEALIGN(ALIGNOF_DOUBLE, (LEN)) 757 #define MAXALIGN(LEN) TYPEALIGN(MAXIMUM_ALIGNOF, (LEN)) 758 /* MAXALIGN covers only built-in types, not buffers */ 759 #define BUFFERALIGN(LEN) TYPEALIGN(ALIGNOF_BUFFER, (LEN)) 760 #define CACHELINEALIGN(LEN) TYPEALIGN(PG_CACHE_LINE_SIZE, (LEN)) 761 762 #define TYPEALIGN_DOWN(ALIGNVAL,LEN) \ 763 (((uintptr_t) (LEN)) & ~((uintptr_t) ((ALIGNVAL) - 1))) 764 765 #define SHORTALIGN_DOWN(LEN) TYPEALIGN_DOWN(ALIGNOF_SHORT, (LEN)) 766 #define INTALIGN_DOWN(LEN) TYPEALIGN_DOWN(ALIGNOF_INT, (LEN)) 767 #define LONGALIGN_DOWN(LEN) TYPEALIGN_DOWN(ALIGNOF_LONG, (LEN)) 768 #define DOUBLEALIGN_DOWN(LEN) TYPEALIGN_DOWN(ALIGNOF_DOUBLE, (LEN)) 769 #define MAXALIGN_DOWN(LEN) TYPEALIGN_DOWN(MAXIMUM_ALIGNOF, (LEN)) 770 #define BUFFERALIGN_DOWN(LEN) TYPEALIGN_DOWN(ALIGNOF_BUFFER, (LEN)) 771 772 /* 773 * The above macros will not work with types wider than uintptr_t, like with 774 * uint64 on 32-bit platforms. That's not problem for the usual use where a 775 * pointer or a length is aligned, but for the odd case that you need to 776 * align something (potentially) wider, use TYPEALIGN64. 777 */ 778 #define TYPEALIGN64(ALIGNVAL,LEN) \ 779 (((uint64) (LEN) + ((ALIGNVAL) - 1)) & ~((uint64) ((ALIGNVAL) - 1))) 780 781 /* we don't currently need wider versions of the other ALIGN macros */ 782 #define MAXALIGN64(LEN) TYPEALIGN64(MAXIMUM_ALIGNOF, (LEN)) 783 784 785 /* ---------------------------------------------------------------- 786 * Section 6: assertions 787 * ---------------------------------------------------------------- 788 */ 789 790 /* 791 * USE_ASSERT_CHECKING, if defined, turns on all the assertions. 792 * - plai 9/5/90 793 * 794 * It should _NOT_ be defined in releases or in benchmark copies 795 */ 796 797 /* 798 * Assert() can be used in both frontend and backend code. In frontend code it 799 * just calls the standard assert, if it's available. If use of assertions is 800 * not configured, it does nothing. 801 */ 802 #ifndef USE_ASSERT_CHECKING 803 804 #define Assert(condition) ((void)true) 805 #define AssertMacro(condition) ((void)true) 806 #define AssertArg(condition) ((void)true) 807 #define AssertState(condition) ((void)true) 808 #define AssertPointerAlignment(ptr, bndr) ((void)true) 809 #define Trap(condition, errorType) ((void)true) 810 #define TrapMacro(condition, errorType) (true) 811 812 #elif defined(FRONTEND) 813 814 #include <assert.h> 815 #define Assert(p) assert(p) 816 #define AssertMacro(p) ((void) assert(p)) 817 #define AssertArg(condition) assert(condition) 818 #define AssertState(condition) assert(condition) 819 #define AssertPointerAlignment(ptr, bndr) ((void)true) 820 821 #else /* USE_ASSERT_CHECKING && !FRONTEND */ 822 823 /* 824 * Trap 825 * Generates an exception if the given condition is true. 826 */ 827 #define Trap(condition, errorType) \ 828 do { \ 829 if (condition) \ 830 ExceptionalCondition(#condition, (errorType), \ 831 __FILE__, __LINE__); \ 832 } while (0) 833 834 /* 835 * TrapMacro is the same as Trap but it's intended for use in macros: 836 * 837 * #define foo(x) (AssertMacro(x != 0), bar(x)) 838 * 839 * Isn't CPP fun? 840 */ 841 #define TrapMacro(condition, errorType) \ 842 ((bool) (! (condition) || \ 843 (ExceptionalCondition(#condition, (errorType), \ 844 __FILE__, __LINE__), 0))) 845 846 #define Assert(condition) \ 847 do { \ 848 if (!(condition)) \ 849 ExceptionalCondition(#condition, "FailedAssertion", \ 850 __FILE__, __LINE__); \ 851 } while (0) 852 853 #define AssertMacro(condition) \ 854 ((void) ((condition) || \ 855 (ExceptionalCondition(#condition, "FailedAssertion", \ 856 __FILE__, __LINE__), 0))) 857 858 #define AssertArg(condition) \ 859 do { \ 860 if (!(condition)) \ 861 ExceptionalCondition(#condition, "BadArgument", \ 862 __FILE__, __LINE__); \ 863 } while (0) 864 865 #define AssertState(condition) \ 866 do { \ 867 if (!(condition)) \ 868 ExceptionalCondition(#condition, "BadState", \ 869 __FILE__, __LINE__); \ 870 } while (0) 871 872 /* 873 * Check that `ptr' is `bndr' aligned. 874 */ 875 #define AssertPointerAlignment(ptr, bndr) \ 876 Trap(TYPEALIGN(bndr, (uintptr_t)(ptr)) != (uintptr_t)(ptr), \ 877 "UnalignedPointer") 878 879 #endif /* USE_ASSERT_CHECKING && !FRONTEND */ 880 881 /* 882 * ExceptionalCondition is compiled into the backend whether or not 883 * USE_ASSERT_CHECKING is defined, so as to support use of extensions 884 * that are built with that #define with a backend that isn't. Hence, 885 * we should declare it as long as !FRONTEND. 886 */ 887 #ifndef FRONTEND 888 extern void ExceptionalCondition(const char *conditionName, 889 const char *errorType, 890 const char *fileName, int lineNumber) pg_attribute_noreturn(); 891 #endif 892 893 /* 894 * Macros to support compile-time assertion checks. 895 * 896 * If the "condition" (a compile-time-constant expression) evaluates to false, 897 * throw a compile error using the "errmessage" (a string literal). 898 * 899 * gcc 4.6 and up supports _Static_assert(), but there are bizarre syntactic 900 * placement restrictions. Macros StaticAssertStmt() and StaticAssertExpr() 901 * make it safe to use as a statement or in an expression, respectively. 902 * The macro StaticAssertDecl() is suitable for use at file scope (outside of 903 * any function). 904 * 905 * Otherwise we fall back on a kluge that assumes the compiler will complain 906 * about a negative width for a struct bit-field. This will not include a 907 * helpful error message, but it beats not getting an error at all. 908 */ 909 #ifndef __cplusplus 910 #ifdef HAVE__STATIC_ASSERT 911 #define StaticAssertStmt(condition, errmessage) \ 912 do { _Static_assert(condition, errmessage); } while(0) 913 #define StaticAssertExpr(condition, errmessage) \ 914 ((void) ({ StaticAssertStmt(condition, errmessage); true; })) 915 #define StaticAssertDecl(condition, errmessage) \ 916 _Static_assert(condition, errmessage) 917 #else /* !HAVE__STATIC_ASSERT */ 918 #define StaticAssertStmt(condition, errmessage) \ 919 ((void) sizeof(struct { int static_assert_failure : (condition) ? 1 : -1; })) 920 #define StaticAssertExpr(condition, errmessage) \ 921 StaticAssertStmt(condition, errmessage) 922 #define StaticAssertDecl(condition, errmessage) \ 923 extern void static_assert_func(int static_assert_failure[(condition) ? 1 : -1]) 924 #endif /* HAVE__STATIC_ASSERT */ 925 #else /* C++ */ 926 #if defined(__cpp_static_assert) && __cpp_static_assert >= 200410 927 #define StaticAssertStmt(condition, errmessage) \ 928 static_assert(condition, errmessage) 929 #define StaticAssertExpr(condition, errmessage) \ 930 ({ static_assert(condition, errmessage); }) 931 #define StaticAssertDecl(condition, errmessage) \ 932 static_assert(condition, errmessage) 933 #else /* !__cpp_static_assert */ 934 #define StaticAssertStmt(condition, errmessage) \ 935 do { struct static_assert_struct { int static_assert_failure : (condition) ? 1 : -1; }; } while(0) 936 #define StaticAssertExpr(condition, errmessage) \ 937 ((void) ({ StaticAssertStmt(condition, errmessage); })) 938 #define StaticAssertDecl(condition, errmessage) \ 939 extern void static_assert_func(int static_assert_failure[(condition) ? 1 : -1]) 940 #endif /* __cpp_static_assert */ 941 #endif /* C++ */ 942 943 944 /* 945 * Compile-time checks that a variable (or expression) has the specified type. 946 * 947 * AssertVariableIsOfType() can be used as a statement. 948 * AssertVariableIsOfTypeMacro() is intended for use in macros, eg 949 * #define foo(x) (AssertVariableIsOfTypeMacro(x, int), bar(x)) 950 * 951 * If we don't have __builtin_types_compatible_p, we can still assert that 952 * the types have the same size. This is far from ideal (especially on 32-bit 953 * platforms) but it provides at least some coverage. 954 */ 955 #ifdef HAVE__BUILTIN_TYPES_COMPATIBLE_P 956 #define AssertVariableIsOfType(varname, typename) \ 957 StaticAssertStmt(__builtin_types_compatible_p(__typeof__(varname), typename), \ 958 CppAsString(varname) " does not have type " CppAsString(typename)) 959 #define AssertVariableIsOfTypeMacro(varname, typename) \ 960 (StaticAssertExpr(__builtin_types_compatible_p(__typeof__(varname), typename), \ 961 CppAsString(varname) " does not have type " CppAsString(typename))) 962 #else /* !HAVE__BUILTIN_TYPES_COMPATIBLE_P */ 963 #define AssertVariableIsOfType(varname, typename) \ 964 StaticAssertStmt(sizeof(varname) == sizeof(typename), \ 965 CppAsString(varname) " does not have type " CppAsString(typename)) 966 #define AssertVariableIsOfTypeMacro(varname, typename) \ 967 (StaticAssertExpr(sizeof(varname) == sizeof(typename), \ 968 CppAsString(varname) " does not have type " CppAsString(typename))) 969 #endif /* HAVE__BUILTIN_TYPES_COMPATIBLE_P */ 970 971 972 /* ---------------------------------------------------------------- 973 * Section 7: widely useful macros 974 * ---------------------------------------------------------------- 975 */ 976 /* 977 * Max 978 * Return the maximum of two numbers. 979 */ 980 #define Max(x, y) ((x) > (y) ? (x) : (y)) 981 982 /* 983 * Min 984 * Return the minimum of two numbers. 985 */ 986 #define Min(x, y) ((x) < (y) ? (x) : (y)) 987 988 /* 989 * Abs 990 * Return the absolute value of the argument. 991 */ 992 #define Abs(x) ((x) >= 0 ? (x) : -(x)) 993 994 995 /* Get a bit mask of the bits set in non-long aligned addresses */ 996 #define LONG_ALIGN_MASK (sizeof(long) - 1) 997 998 /* 999 * MemSet 1000 * Exactly the same as standard library function memset(), but considerably 1001 * faster for zeroing small word-aligned structures (such as parsetree nodes). 1002 * This has to be a macro because the main point is to avoid function-call 1003 * overhead. However, we have also found that the loop is faster than 1004 * native libc memset() on some platforms, even those with assembler 1005 * memset() functions. More research needs to be done, perhaps with 1006 * MEMSET_LOOP_LIMIT tests in configure. 1007 */ 1008 #define MemSet(start, val, len) \ 1009 do \ 1010 { \ 1011 /* must be void* because we don't know if it is integer aligned yet */ \ 1012 void *_vstart = (void *) (start); \ 1013 int _val = (val); \ 1014 Size _len = (len); \ 1015 \ 1016 if ((((uintptr_t) _vstart) & LONG_ALIGN_MASK) == 0 && \ 1017 (_len & LONG_ALIGN_MASK) == 0 && \ 1018 _val == 0 && \ 1019 _len <= MEMSET_LOOP_LIMIT && \ 1020 /* \ 1021 * If MEMSET_LOOP_LIMIT == 0, optimizer should find \ 1022 * the whole "if" false at compile time. \ 1023 */ \ 1024 MEMSET_LOOP_LIMIT != 0) \ 1025 { \ 1026 long *_start = (long *) _vstart; \ 1027 long *_stop = (long *) ((char *) _start + _len); \ 1028 while (_start < _stop) \ 1029 *_start++ = 0; \ 1030 } \ 1031 else \ 1032 memset(_vstart, _val, _len); \ 1033 } while (0) 1034 1035 /* 1036 * MemSetAligned is the same as MemSet except it omits the test to see if 1037 * "start" is word-aligned. This is okay to use if the caller knows a-priori 1038 * that the pointer is suitably aligned (typically, because he just got it 1039 * from palloc(), which always delivers a max-aligned pointer). 1040 */ 1041 #define MemSetAligned(start, val, len) \ 1042 do \ 1043 { \ 1044 long *_start = (long *) (start); \ 1045 int _val = (val); \ 1046 Size _len = (len); \ 1047 \ 1048 if ((_len & LONG_ALIGN_MASK) == 0 && \ 1049 _val == 0 && \ 1050 _len <= MEMSET_LOOP_LIMIT && \ 1051 MEMSET_LOOP_LIMIT != 0) \ 1052 { \ 1053 long *_stop = (long *) ((char *) _start + _len); \ 1054 while (_start < _stop) \ 1055 *_start++ = 0; \ 1056 } \ 1057 else \ 1058 memset(_start, _val, _len); \ 1059 } while (0) 1060 1061 1062 /* 1063 * MemSetTest/MemSetLoop are a variant version that allow all the tests in 1064 * MemSet to be done at compile time in cases where "val" and "len" are 1065 * constants *and* we know the "start" pointer must be word-aligned. 1066 * If MemSetTest succeeds, then it is okay to use MemSetLoop, otherwise use 1067 * MemSetAligned. Beware of multiple evaluations of the arguments when using 1068 * this approach. 1069 */ 1070 #define MemSetTest(val, len) \ 1071 ( ((len) & LONG_ALIGN_MASK) == 0 && \ 1072 (len) <= MEMSET_LOOP_LIMIT && \ 1073 MEMSET_LOOP_LIMIT != 0 && \ 1074 (val) == 0 ) 1075 1076 #define MemSetLoop(start, val, len) \ 1077 do \ 1078 { \ 1079 long * _start = (long *) (start); \ 1080 long * _stop = (long *) ((char *) _start + (Size) (len)); \ 1081 \ 1082 while (_start < _stop) \ 1083 *_start++ = 0; \ 1084 } while (0) 1085 1086 /* 1087 * Macros for range-checking float values before converting to integer. 1088 * We must be careful here that the boundary values are expressed exactly 1089 * in the float domain. PG_INTnn_MIN is an exact power of 2, so it will 1090 * be represented exactly; but PG_INTnn_MAX isn't, and might get rounded 1091 * off, so avoid using that. 1092 * The input must be rounded to an integer beforehand, typically with rint(), 1093 * else we might draw the wrong conclusion about close-to-the-limit values. 1094 * These macros will do the right thing for Inf, but not necessarily for NaN, 1095 * so check isnan(num) first if that's a possibility. 1096 */ 1097 #define FLOAT4_FITS_IN_INT16(num) \ 1098 ((num) >= (float4) PG_INT16_MIN && (num) < -((float4) PG_INT16_MIN)) 1099 #define FLOAT4_FITS_IN_INT32(num) \ 1100 ((num) >= (float4) PG_INT32_MIN && (num) < -((float4) PG_INT32_MIN)) 1101 #define FLOAT4_FITS_IN_INT64(num) \ 1102 ((num) >= (float4) PG_INT64_MIN && (num) < -((float4) PG_INT64_MIN)) 1103 #define FLOAT8_FITS_IN_INT16(num) \ 1104 ((num) >= (float8) PG_INT16_MIN && (num) < -((float8) PG_INT16_MIN)) 1105 #define FLOAT8_FITS_IN_INT32(num) \ 1106 ((num) >= (float8) PG_INT32_MIN && (num) < -((float8) PG_INT32_MIN)) 1107 #define FLOAT8_FITS_IN_INT64(num) \ 1108 ((num) >= (float8) PG_INT64_MIN && (num) < -((float8) PG_INT64_MIN)) 1109 1110 1111 /* ---------------------------------------------------------------- 1112 * Section 8: random stuff 1113 * ---------------------------------------------------------------- 1114 */ 1115 1116 #ifdef HAVE_STRUCT_SOCKADDR_UN 1117 #define HAVE_UNIX_SOCKETS 1 1118 #endif 1119 1120 /* 1121 * Invert the sign of a qsort-style comparison result, ie, exchange negative 1122 * and positive integer values, being careful not to get the wrong answer 1123 * for INT_MIN. The argument should be an integral variable. 1124 */ 1125 #define INVERT_COMPARE_RESULT(var) \ 1126 ((var) = ((var) < 0) ? 1 : -(var)) 1127 1128 /* 1129 * Use this, not "char buf[BLCKSZ]", to declare a field or local variable 1130 * holding a page buffer, if that page might be accessed as a page and not 1131 * just a string of bytes. Otherwise the variable might be under-aligned, 1132 * causing problems on alignment-picky hardware. (In some places, we use 1133 * this to declare buffers even though we only pass them to read() and 1134 * write(), because copying to/from aligned buffers is usually faster than 1135 * using unaligned buffers.) We include both "double" and "int64" in the 1136 * union to ensure that the compiler knows the value must be MAXALIGN'ed 1137 * (cf. configure's computation of MAXIMUM_ALIGNOF). 1138 */ 1139 typedef union PGAlignedBlock 1140 { 1141 char data[BLCKSZ]; 1142 double force_align_d; 1143 int64 force_align_i64; 1144 } PGAlignedBlock; 1145 1146 /* Same, but for an XLOG_BLCKSZ-sized buffer */ 1147 typedef union PGAlignedXLogBlock 1148 { 1149 char data[XLOG_BLCKSZ]; 1150 double force_align_d; 1151 int64 force_align_i64; 1152 } PGAlignedXLogBlock; 1153 1154 /* msb for char */ 1155 #define HIGHBIT (0x80) 1156 #define IS_HIGHBIT_SET(ch) ((unsigned char)(ch) & HIGHBIT) 1157 1158 /* 1159 * Support macros for escaping strings. escape_backslash should be true 1160 * if generating a non-standard-conforming string. Prefixing a string 1161 * with ESCAPE_STRING_SYNTAX guarantees it is non-standard-conforming. 1162 * Beware of multiple evaluation of the "ch" argument! 1163 */ 1164 #define SQL_STR_DOUBLE(ch, escape_backslash) \ 1165 ((ch) == '\'' || ((ch) == '\\' && (escape_backslash))) 1166 1167 #define ESCAPE_STRING_SYNTAX 'E' 1168 1169 1170 #define STATUS_OK (0) 1171 #define STATUS_ERROR (-1) 1172 #define STATUS_EOF (-2) 1173 1174 /* 1175 * gettext support 1176 */ 1177 1178 #ifndef ENABLE_NLS 1179 /* stuff we'd otherwise get from <libintl.h> */ 1180 #define gettext(x) (x) 1181 #define dgettext(d,x) (x) 1182 #define ngettext(s,p,n) ((n) == 1 ? (s) : (p)) 1183 #define dngettext(d,s,p,n) ((n) == 1 ? (s) : (p)) 1184 #endif 1185 1186 #define _(x) gettext(x) 1187 1188 /* 1189 * Use this to mark string constants as needing translation at some later 1190 * time, rather than immediately. This is useful for cases where you need 1191 * access to the original string and translated string, and for cases where 1192 * immediate translation is not possible, like when initializing global 1193 * variables. 1194 * 1195 * https://www.gnu.org/software/gettext/manual/html_node/Special-cases.html 1196 */ 1197 #define gettext_noop(x) (x) 1198 1199 /* 1200 * To better support parallel installations of major PostgreSQL 1201 * versions as well as parallel installations of major library soname 1202 * versions, we mangle the gettext domain name by appending those 1203 * version numbers. The coding rule ought to be that wherever the 1204 * domain name is mentioned as a literal, it must be wrapped into 1205 * PG_TEXTDOMAIN(). The macros below do not work on non-literals; but 1206 * that is somewhat intentional because it avoids having to worry 1207 * about multiple states of premangling and postmangling as the values 1208 * are being passed around. 1209 * 1210 * Make sure this matches the installation rules in nls-global.mk. 1211 */ 1212 #ifdef SO_MAJOR_VERSION 1213 #define PG_TEXTDOMAIN(domain) (domain CppAsString2(SO_MAJOR_VERSION) "-" PG_MAJORVERSION) 1214 #else 1215 #define PG_TEXTDOMAIN(domain) (domain "-" PG_MAJORVERSION) 1216 #endif 1217 1218 /* 1219 * Macro that allows to cast constness and volatile away from an expression, but doesn't 1220 * allow changing the underlying type. Enforcement of the latter 1221 * currently only works for gcc like compilers. 1222 * 1223 * Please note IT IS NOT SAFE to cast constness away if the result will ever 1224 * be modified (it would be undefined behaviour). Doing so anyway can cause 1225 * compiler misoptimizations or runtime crashes (modifying readonly memory). 1226 * It is only safe to use when the result will not be modified, but API 1227 * design or language restrictions prevent you from declaring that 1228 * (e.g. because a function returns both const and non-const variables). 1229 * 1230 * Note that this only works in function scope, not for global variables (it'd 1231 * be nice, but not trivial, to improve that). 1232 */ 1233 #if defined(HAVE__BUILTIN_TYPES_COMPATIBLE_P) 1234 #define unconstify(underlying_type, expr) \ 1235 (StaticAssertExpr(__builtin_types_compatible_p(__typeof(expr), const underlying_type), \ 1236 "wrong cast"), \ 1237 (underlying_type) (expr)) 1238 #define unvolatize(underlying_type, expr) \ 1239 (StaticAssertExpr(__builtin_types_compatible_p(__typeof(expr), volatile underlying_type), \ 1240 "wrong cast"), \ 1241 (underlying_type) (expr)) 1242 #else 1243 #define unconstify(underlying_type, expr) \ 1244 ((underlying_type) (expr)) 1245 #define unvolatize(underlying_type, expr) \ 1246 ((underlying_type) (expr)) 1247 #endif 1248 1249 /* ---------------------------------------------------------------- 1250 * Section 9: system-specific hacks 1251 * 1252 * This should be limited to things that absolutely have to be 1253 * included in every source file. The port-specific header file 1254 * is usually a better place for this sort of thing. 1255 * ---------------------------------------------------------------- 1256 */ 1257 1258 /* 1259 * NOTE: this is also used for opening text files. 1260 * WIN32 treats Control-Z as EOF in files opened in text mode. 1261 * Therefore, we open files in binary mode on Win32 so we can read 1262 * literal control-Z. The other affect is that we see CRLF, but 1263 * that is OK because we can already handle those cleanly. 1264 */ 1265 #if defined(WIN32) || defined(__CYGWIN__) 1266 #define PG_BINARY O_BINARY 1267 #define PG_BINARY_A "ab" 1268 #define PG_BINARY_R "rb" 1269 #define PG_BINARY_W "wb" 1270 #else 1271 #define PG_BINARY 0 1272 #define PG_BINARY_A "a" 1273 #define PG_BINARY_R "r" 1274 #define PG_BINARY_W "w" 1275 #endif 1276 1277 /* 1278 * Provide prototypes for routines not present in a particular machine's 1279 * standard C library. 1280 */ 1281 1282 #if defined(HAVE_FDATASYNC) && !HAVE_DECL_FDATASYNC 1283 extern int fdatasync(int fildes); 1284 #endif 1285 1286 /* Older platforms may provide strto[u]ll functionality under other names */ 1287 #if !defined(HAVE_STRTOLL) && defined(HAVE___STRTOLL) 1288 #define strtoll __strtoll 1289 #define HAVE_STRTOLL 1 1290 #endif 1291 1292 #if !defined(HAVE_STRTOLL) && defined(HAVE_STRTOQ) 1293 #define strtoll strtoq 1294 #define HAVE_STRTOLL 1 1295 #endif 1296 1297 #if !defined(HAVE_STRTOULL) && defined(HAVE___STRTOULL) 1298 #define strtoull __strtoull 1299 #define HAVE_STRTOULL 1 1300 #endif 1301 1302 #if !defined(HAVE_STRTOULL) && defined(HAVE_STRTOUQ) 1303 #define strtoull strtouq 1304 #define HAVE_STRTOULL 1 1305 #endif 1306 1307 #if defined(HAVE_STRTOLL) && !HAVE_DECL_STRTOLL 1308 extern long long strtoll(const char *str, char **endptr, int base); 1309 #endif 1310 1311 #if defined(HAVE_STRTOULL) && !HAVE_DECL_STRTOULL 1312 extern unsigned long long strtoull(const char *str, char **endptr, int base); 1313 #endif 1314 1315 /* no special DLL markers on most ports */ 1316 #ifndef PGDLLIMPORT 1317 #define PGDLLIMPORT 1318 #endif 1319 #ifndef PGDLLEXPORT 1320 #define PGDLLEXPORT 1321 #endif 1322 1323 /* 1324 * The following is used as the arg list for signal handlers. Any ports 1325 * that take something other than an int argument should override this in 1326 * their pg_config_os.h file. Note that variable names are required 1327 * because it is used in both the prototypes as well as the definitions. 1328 * Note also the long name. We expect that this won't collide with 1329 * other names causing compiler warnings. 1330 */ 1331 1332 #ifndef SIGNAL_ARGS 1333 #define SIGNAL_ARGS int postgres_signal_arg 1334 #endif 1335 1336 /* 1337 * When there is no sigsetjmp, its functionality is provided by plain 1338 * setjmp. We now support the case only on Windows. However, it seems 1339 * that MinGW-64 has some longstanding issues in its setjmp support, 1340 * so on that toolchain we cheat and use gcc's builtins. 1341 */ 1342 #ifdef WIN32 1343 #ifdef __MINGW64__ 1344 typedef intptr_t sigjmp_buf[5]; 1345 #define sigsetjmp(x,y) __builtin_setjmp(x) 1346 #define siglongjmp __builtin_longjmp 1347 #else /* !__MINGW64__ */ 1348 #define sigjmp_buf jmp_buf 1349 #define sigsetjmp(x,y) setjmp(x) 1350 #define siglongjmp longjmp 1351 #endif /* __MINGW64__ */ 1352 #endif /* WIN32 */ 1353 1354 /* EXEC_BACKEND defines */ 1355 #ifdef EXEC_BACKEND 1356 #define NON_EXEC_STATIC 1357 #else 1358 #define NON_EXEC_STATIC static 1359 #endif 1360 1361 /* /port compatibility functions */ 1362 #include "port.h" 1363 1364 #endif /* C_H */ 1365