PostgreSQL Source Code git master
Functions
int.h File Reference
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions

static bool pg_add_s16_overflow (int16 a, int16 b, int16 *result)
 
static bool pg_sub_s16_overflow (int16 a, int16 b, int16 *result)
 
static bool pg_mul_s16_overflow (int16 a, int16 b, int16 *result)
 
static bool pg_neg_s16_overflow (int16 a, int16 *result)
 
static uint16 pg_abs_s16 (int16 a)
 
static bool pg_add_s32_overflow (int32 a, int32 b, int32 *result)
 
static bool pg_sub_s32_overflow (int32 a, int32 b, int32 *result)
 
static bool pg_mul_s32_overflow (int32 a, int32 b, int32 *result)
 
static bool pg_neg_s32_overflow (int32 a, int32 *result)
 
static uint32 pg_abs_s32 (int32 a)
 
static bool pg_add_s64_overflow (int64 a, int64 b, int64 *result)
 
static bool pg_sub_s64_overflow (int64 a, int64 b, int64 *result)
 
static bool pg_mul_s64_overflow (int64 a, int64 b, int64 *result)
 
static bool pg_neg_s64_overflow (int64 a, int64 *result)
 
static uint64 pg_abs_s64 (int64 a)
 
static bool pg_add_u16_overflow (uint16 a, uint16 b, uint16 *result)
 
static bool pg_sub_u16_overflow (uint16 a, uint16 b, uint16 *result)
 
static bool pg_mul_u16_overflow (uint16 a, uint16 b, uint16 *result)
 
static bool pg_neg_u16_overflow (uint16 a, int16 *result)
 
static bool pg_add_u32_overflow (uint32 a, uint32 b, uint32 *result)
 
static bool pg_sub_u32_overflow (uint32 a, uint32 b, uint32 *result)
 
static bool pg_mul_u32_overflow (uint32 a, uint32 b, uint32 *result)
 
static bool pg_neg_u32_overflow (uint32 a, int32 *result)
 
static bool pg_add_u64_overflow (uint64 a, uint64 b, uint64 *result)
 
static bool pg_sub_u64_overflow (uint64 a, uint64 b, uint64 *result)
 
static bool pg_mul_u64_overflow (uint64 a, uint64 b, uint64 *result)
 
static bool pg_neg_u64_overflow (uint64 a, int64 *result)
 
static int pg_cmp_s16 (int16 a, int16 b)
 
static int pg_cmp_u16 (uint16 a, uint16 b)
 
static int pg_cmp_s32 (int32 a, int32 b)
 
static int pg_cmp_u32 (uint32 a, uint32 b)
 
static int pg_cmp_s64 (int64 a, int64 b)
 
static int pg_cmp_u64 (uint64 a, uint64 b)
 
static int pg_cmp_size (size_t a, size_t b)
 

Function Documentation

◆ pg_abs_s16()

static uint16 pg_abs_s16 ( int16  a)
inlinestatic

Definition at line 137 of file int.h.

138{
139 /*
140 * This first widens the argument from int16 to int32 for use with abs().
141 * The result is then narrowed from int32 to uint16. This prevents any
142 * possibility of overflow.
143 */
144 return (uint16) abs((int32) a);
145}
int32
int32_t int32
Definition: c.h:498
uint16
uint16_t uint16
Definition: c.h:501
a
int a
Definition: isn.c:73

References a.

◆ pg_abs_s32()

static uint32 pg_abs_s32 ( int32  a)
inlinestatic

Definition at line 221 of file int.h.

222{
223 /*
224 * This first widens the argument from int32 to int64 for use with
225 * i64abs(). The result is then narrowed from int64 to uint32. This
226 * prevents any possibility of overflow.
227 */
228 return (uint32) i64abs((int64) a);
229}
int64
int64_t int64
Definition: c.h:499
uint32
uint32_t uint32
Definition: c.h:502

References a.

Referenced by jsonb_array_element(), jsonb_array_element_text(), jsonb_delete_idx(), power_var_int(), and setPathArray().

◆ pg_abs_s64()

static uint64 pg_abs_s64 ( int64  a)
inlinestatic

Definition at line 352 of file int.h.

353{
354 if (unlikely(a == PG_INT64_MIN))
355 return (uint64) PG_INT64_MAX + 1;
356 return (uint64) i64abs(a);
357}
PG_INT64_MAX
#define PG_INT64_MAX
Definition: c.h:563
PG_INT64_MIN
#define PG_INT64_MIN
Definition: c.h:562
uint64
uint64_t uint64
Definition: c.h:503
unlikely
#define unlikely(x)
Definition: c.h:347

References a, PG_INT64_MAX, PG_INT64_MIN, and unlikely.

Referenced by cash_out(), and int64_to_numericvar().

◆ pg_add_s16_overflow()

static bool pg_add_s16_overflow ( int16  a,
int16  b,
int16 *  result 
)
inlinestatic

Definition at line 67 of file int.h.

68{
69#if defined(HAVE__BUILTIN_OP_OVERFLOW)
70 return __builtin_add_overflow(a, b, result);
71#else
72 int32 res = (int32) a + (int32) b;
73
74 if (res > PG_INT16_MAX || res < PG_INT16_MIN)
75 {
76 *result = 0x5EED; /* to avoid spurious warnings */
77 return true;
78 }
79 *result = (int16) res;
80 return false;
81#endif
82}
int16
int16_t int16
Definition: c.h:497
PG_INT16_MIN
#define PG_INT16_MIN
Definition: c.h:556
PG_INT16_MAX
#define PG_INT16_MAX
Definition: c.h:557
b
int b
Definition: isn.c:74

References a, b, PG_INT16_MAX, and PG_INT16_MIN.

Referenced by AdjustNotNullInheritance(), ATExecAddColumn(), ATExecSetNotNull(), ConstraintSetParentConstraint(), int2pl(), MergeAttributesIntoExisting(), MergeCheckConstraint(), MergeConstraintsIntoExisting(), MergeInheritedAttribute(), and MergeWithExistingConstraint().

◆ pg_add_s32_overflow()

static bool pg_add_s32_overflow ( int32  a,
int32  b,
int32 *  result 
)
inlinestatic

Definition at line 151 of file int.h.

152{
153#if defined(HAVE__BUILTIN_OP_OVERFLOW)
154 return __builtin_add_overflow(a, b, result);
155#else
156 int64 res = (int64) a + (int64) b;
157
158 if (res > PG_INT32_MAX || res < PG_INT32_MIN)
159 {
160 *result = 0x5EED; /* to avoid spurious warnings */
161 return true;
162 }
163 *result = (int32) res;
164 return false;
165#endif
166}
PG_INT32_MAX
#define PG_INT32_MAX
Definition: c.h:560
PG_INT32_MIN
#define PG_INT32_MIN
Definition: c.h:559

References a, b, PG_INT32_MAX, and PG_INT32_MIN.

Referenced by AdjustDays(), AdjustFractDays(), AdjustFractYears(), AdjustMonths(), AdjustYears(), array_append(), array_set_element(), array_set_element_expanded(), array_set_slice(), ArrayCheckBoundsSafe(), bit_overlay(), bitsubstring(), bytea_overlay(), bytea_substring(), DCH_from_char(), detoast_attr_slice(), do_to_timestamp(), finite_interval_pl(), generate_series_step_int4(), in_range_int2_int4(), in_range_int4_int4(), int24pl(), int42pl(), int4inc(), int4pl(), interval_div(), interval_justify_days(), interval_justify_hours(), interval_justify_interval(), interval_mul(), lpad(), make_interval(), ReadArrayDimensions(), repeat(), rpad(), text_format_parse_digits(), text_overlay(), text_substring(), timestamp_pl_interval(), timestamptz_pl_interval_internal(), translate(), and width_bucket_float8().

◆ pg_add_s64_overflow()

static bool pg_add_s64_overflow ( int64  a,
int64  b,
int64 *  result 
)
inlinestatic

Definition at line 235 of file int.h.

236{
237#if defined(HAVE__BUILTIN_OP_OVERFLOW)
238 return __builtin_add_overflow(a, b, result);
239#elif defined(HAVE_INT128)
240 int128 res = (int128) a + (int128) b;
241
242 if (res > PG_INT64_MAX || res < PG_INT64_MIN)
243 {
244 *result = 0x5EED; /* to avoid spurious warnings */
245 return true;
246 }
247 *result = (int64) res;
248 return false;
249#else
250 if ((a > 0 && b > 0 && a > PG_INT64_MAX - b) ||
251 (a < 0 && b < 0 && a < PG_INT64_MIN - b))
252 {
253 *result = 0x5EED; /* to avoid spurious warnings */
254 return true;
255 }
256 *result = a + b;
257 return false;
258#endif
259}

References a, b, PG_INT64_MAX, and PG_INT64_MIN.

Referenced by AdjustFractMicroseconds(), AdjustIntervalForTypmod(), cash_pl_cash(), DecodeInterval(), evalStandardFunc(), finite_interval_pl(), generate_series_step_int8(), in_range_int4_int8(), in_range_int8_int8(), in_range_time_interval(), in_range_timetz_interval(), int28pl(), int48pl(), int64_multiply_add(), int82pl(), int84pl(), int8inc(), int8pl(), interval_part_common(), itm2interval(), make_interval(), make_timestamp_internal(), timestamp_bin(), timestamp_pl_interval(), timestamptz_bin(), timestamptz_pl_interval_internal(), and tm2timestamp().

◆ pg_add_u16_overflow()

static bool pg_add_u16_overflow ( uint16  a,
uint16  b,
uint16 *  result 
)
inlinestatic

Definition at line 368 of file int.h.

369{
370#if defined(HAVE__BUILTIN_OP_OVERFLOW)
371 return __builtin_add_overflow(a, b, result);
372#else
373 uint16 res = a + b;
374
375 if (res < a)
376 {
377 *result = 0x5EED; /* to avoid spurious warnings */
378 return true;
379 }
380 *result = res;
381 return false;
382#endif
383}

References a, and b.

◆ pg_add_u32_overflow()

static bool pg_add_u32_overflow ( uint32  a,
uint32  b,
uint32 *  result 
)
inlinestatic

Definition at line 441 of file int.h.

442{
443#if defined(HAVE__BUILTIN_OP_OVERFLOW)
444 return __builtin_add_overflow(a, b, result);
445#else
446 uint32 res = a + b;
447
448 if (res < a)
449 {
450 *result = 0x5EED; /* to avoid spurious warnings */
451 return true;
452 }
453 *result = res;
454 return false;
455#endif
456}

References a, and b.

◆ pg_add_u64_overflow()

static bool pg_add_u64_overflow ( uint64  a,
uint64  b,
uint64 *  result 
)
inlinestatic

Definition at line 514 of file int.h.

515{
516#if defined(HAVE__BUILTIN_OP_OVERFLOW)
517 return __builtin_add_overflow(a, b, result);
518#else
519 uint64 res = a + b;
520
521 if (res < a)
522 {
523 *result = 0x5EED; /* to avoid spurious warnings */
524 return true;
525 }
526 *result = res;
527 return false;
528#endif
529}

References a, and b.

Referenced by basic_archive_file(), and numericvar_to_uint64().

◆ pg_cmp_s16()

static int pg_cmp_s16 ( int16  a,
int16  b 
)
inlinestatic

Definition at line 634 of file int.h.

635{
636 return (int32) a - (int32) b;
637}

References a, and b.

Referenced by _bt_delitems_cmp(), _bt_splitcmp(), AttrDefaultCmp(), and cmpNodePtr().

◆ pg_cmp_s32()

static int pg_cmp_s32 ( int32  a,
int32  b 
)
inlinestatic

Definition at line 646 of file int.h.

647{
648 return (a > b) - (a < b);
649}

References a, and b.

Referenced by cmp_list_len_asc(), comp_location(), comp_ptrgm(), compare_int(), comparecost(), compareint(), compareWordEntryPos(), db_comparator(), int_cmp(), library_name_compare(), list_int_cmp(), and rankCompare().

◆ pg_cmp_s64()

static int pg_cmp_s64 ( int64  a,
int64  b 
)
inlinestatic

Definition at line 658 of file int.h.

659{
660 return (a > b) - (a < b);
661}

References a, and b.

◆ pg_cmp_size()

static int pg_cmp_size ( size_t  a,
size_t  b 
)
inlinestatic

Definition at line 670 of file int.h.

671{
672 return (a > b) - (a < b);
673}

References a, and b.

Referenced by library_name_compare().

◆ pg_cmp_u16()

static int pg_cmp_u16 ( uint16  a,
uint16  b 
)
inlinestatic

Definition at line 640 of file int.h.

641{
642 return (int32) a - (int32) b;
643}

References a, and b.

Referenced by cmpOffsetNumbers().

◆ pg_cmp_u32()

static int pg_cmp_u32 ( uint32  a,
uint32  b 
)
inlinestatic

Definition at line 652 of file int.h.

653{
654 return (a > b) - (a < b);
655}

References a, and b.

Referenced by _bt_blk_cmp(), BinaryUpgradeClassOidItemCmp(), compare_block_numbers(), enum_oid_cmp(), FileNameMapCmp(), list_oid_cmp(), oid_cmp(), oid_compare(), resource_priority_cmp(), SequenceItemCmp(), tbm_comparator(), and xidComparator().

◆ pg_cmp_u64()

static int pg_cmp_u64 ( uint64  a,
uint64  b 
)
inlinestatic

Definition at line 664 of file int.h.

665{
666 return (a > b) - (a < b);
667}

References a, and b.

Referenced by cmp_lsn(), file_sort_by_lsn(), ginCompareItemPointers(), key_cmp(), and ListComparatorForWalSummaryFiles().

◆ pg_mul_s16_overflow()

static bool pg_mul_s16_overflow ( int16  a,
int16  b,
int16 *  result 
)
inlinestatic

Definition at line 103 of file int.h.

104{
105#if defined(HAVE__BUILTIN_OP_OVERFLOW)
106 return __builtin_mul_overflow(a, b, result);
107#else
108 int32 res = (int32) a * (int32) b;
109
110 if (res > PG_INT16_MAX || res < PG_INT16_MIN)
111 {
112 *result = 0x5EED; /* to avoid spurious warnings */
113 return true;
114 }
115 *result = (int16) res;
116 return false;
117#endif
118}

References a, b, PG_INT16_MAX, and PG_INT16_MIN.

Referenced by int2mul().

◆ pg_mul_s32_overflow()

static bool pg_mul_s32_overflow ( int32  a,
int32  b,
int32 *  result 
)
inlinestatic

Definition at line 187 of file int.h.

188{
189#if defined(HAVE__BUILTIN_OP_OVERFLOW)
190 return __builtin_mul_overflow(a, b, result);
191#else
192 int64 res = (int64) a * (int64) b;
193
194 if (res > PG_INT32_MAX || res < PG_INT32_MIN)
195 {
196 *result = 0x5EED; /* to avoid spurious warnings */
197 return true;
198 }
199 *result = (int32) res;
200 return false;
201#endif
202}

References a, b, PG_INT32_MAX, and PG_INT32_MIN.

Referenced by AdjustDays(), AdjustYears(), DCH_from_char(), do_to_timestamp(), int24mul(), int42mul(), int4lcm(), int4mul(), lpad(), make_interval(), repeat(), rpad(), text_format_parse_digits(), text_substring(), and translate().

◆ pg_mul_s64_overflow()

static bool pg_mul_s64_overflow ( int64  a,
int64  b,
int64 *  result 
)
inlinestatic

Definition at line 293 of file int.h.

294{
295#if defined(HAVE__BUILTIN_OP_OVERFLOW)
296 return __builtin_mul_overflow(a, b, result);
297#elif defined(HAVE_INT128)
298 int128 res = (int128) a * (int128) b;
299
300 if (res > PG_INT64_MAX || res < PG_INT64_MIN)
301 {
302 *result = 0x5EED; /* to avoid spurious warnings */
303 return true;
304 }
305 *result = (int64) res;
306 return false;
307#else
308 /*
309 * Overflow can only happen if at least one value is outside the range
310 * sqrt(min)..sqrt(max) so check that first as the division can be quite a
311 * bit more expensive than the multiplication.
312 *
313 * Multiplying by 0 or 1 can't overflow of course and checking for 0
314 * separately avoids any risk of dividing by 0. Be careful about dividing
315 * INT_MIN by -1 also, note reversing the a and b to ensure we're always
316 * dividing it by a positive value.
317 *
318 */
319 if ((a > PG_INT32_MAX || a < PG_INT32_MIN ||
320 b > PG_INT32_MAX || b < PG_INT32_MIN) &&
321 a != 0 && a != 1 && b != 0 && b != 1 &&
322 ((a > 0 && b > 0 && a > PG_INT64_MAX / b) ||
323 (a > 0 && b < 0 && b < PG_INT64_MIN / a) ||
324 (a < 0 && b > 0 && a < PG_INT64_MIN / b) ||
325 (a < 0 && b < 0 && a < PG_INT64_MAX / b)))
326 {
327 *result = 0x5EED; /* to avoid spurious warnings */
328 return true;
329 }
330 *result = a * b;
331 return false;
332#endif
333}

References a, b, PG_INT32_MAX, PG_INT32_MIN, PG_INT64_MAX, and PG_INT64_MIN.

Referenced by cash_in(), cash_mul_int64(), DecodeInterval(), evalStandardFunc(), int28mul(), int48mul(), int64_div_fast_to_numeric(), int64_multiply_add(), int82mul(), int84mul(), int8lcm(), int8mul(), interval_part_common(), itm2interval(), make_timestamp_internal(), numericvar_to_int64(), strtoint64(), timestamp_bin(), timestamptz_bin(), and tm2timestamp().

◆ pg_mul_u16_overflow()

static bool pg_mul_u16_overflow ( uint16  a,
uint16  b,
uint16 *  result 
)
inlinestatic

Definition at line 402 of file int.h.

403{
404#if defined(HAVE__BUILTIN_OP_OVERFLOW)
405 return __builtin_mul_overflow(a, b, result);
406#else
407 uint32 res = (uint32) a * (uint32) b;
408
409 if (res > PG_UINT16_MAX)
410 {
411 *result = 0x5EED; /* to avoid spurious warnings */
412 return true;
413 }
414 *result = (uint16) res;
415 return false;
416#endif
417}
PG_UINT16_MAX
#define PG_UINT16_MAX
Definition: c.h:558

References a, b, and PG_UINT16_MAX.

◆ pg_mul_u32_overflow()

static bool pg_mul_u32_overflow ( uint32  a,
uint32  b,
uint32 *  result 
)
inlinestatic

Definition at line 475 of file int.h.

476{
477#if defined(HAVE__BUILTIN_OP_OVERFLOW)
478 return __builtin_mul_overflow(a, b, result);
479#else
480 uint64 res = (uint64) a * (uint64) b;
481
482 if (res > PG_UINT32_MAX)
483 {
484 *result = 0x5EED; /* to avoid spurious warnings */
485 return true;
486 }
487 *result = (uint32) res;
488 return false;
489#endif
490}
PG_UINT32_MAX
#define PG_UINT32_MAX
Definition: c.h:561

References a, b, and PG_UINT32_MAX.

◆ pg_mul_u64_overflow()

static bool pg_mul_u64_overflow ( uint64  a,
uint64  b,
uint64 *  result 
)
inlinestatic

Definition at line 548 of file int.h.

549{
550#if defined(HAVE__BUILTIN_OP_OVERFLOW)
551 return __builtin_mul_overflow(a, b, result);
552#elif defined(HAVE_INT128)
553 uint128 res = (uint128) a * (uint128) b;
554
555 if (res > PG_UINT64_MAX)
556 {
557 *result = 0x5EED; /* to avoid spurious warnings */
558 return true;
559 }
560 *result = (uint64) res;
561 return false;
562#else
563 uint64 res = a * b;
564
565 if (a != 0 && b != res / a)
566 {
567 *result = 0x5EED; /* to avoid spurious warnings */
568 return true;
569 }
570 *result = res;
571 return false;
572#endif
573}
PG_UINT64_MAX
#define PG_UINT64_MAX
Definition: c.h:564

References a, b, and PG_UINT64_MAX.

Referenced by basic_archive_file(), and numericvar_to_uint64().

◆ pg_neg_s16_overflow()

static bool pg_neg_s16_overflow ( int16  a,
int16 *  result 
)
inlinestatic

Definition at line 121 of file int.h.

122{
123#if defined(HAVE__BUILTIN_OP_OVERFLOW)
124 return __builtin_sub_overflow(0, a, result);
125#else
126 if (unlikely(a == PG_INT16_MIN))
127 {
128 *result = 0x5EED; /* to avoid spurious warnings */
129 return true;
130 }
131 *result = -a;
132 return false;
133#endif
134}

References a, PG_INT16_MIN, and unlikely.

◆ pg_neg_s32_overflow()

static bool pg_neg_s32_overflow ( int32  a,
int32 *  result 
)
inlinestatic

Definition at line 205 of file int.h.

206{
207#if defined(HAVE__BUILTIN_OP_OVERFLOW)
208 return __builtin_sub_overflow(0, a, result);
209#else
210 if (unlikely(a == PG_INT32_MIN))
211 {
212 *result = 0x5EED; /* to avoid spurious warnings */
213 return true;
214 }
215 *result = -a;
216 return false;
217#endif
218}

References a, PG_INT32_MIN, and unlikely.

Referenced by make_date().

◆ pg_neg_s64_overflow()

static bool pg_neg_s64_overflow ( int64  a,
int64 *  result 
)
inlinestatic

Definition at line 336 of file int.h.

337{
338#if defined(HAVE__BUILTIN_OP_OVERFLOW)
339 return __builtin_sub_overflow(0, a, result);
340#else
341 if (unlikely(a == PG_INT64_MIN))
342 {
343 *result = 0x5EED; /* to avoid spurious warnings */
344 return true;
345 }
346 *result = -a;
347 return false;
348#endif
349}

References a, PG_INT64_MIN, and unlikely.

◆ pg_neg_u16_overflow()

static bool pg_neg_u16_overflow ( uint16  a,
int16 *  result 
)
inlinestatic

Definition at line 420 of file int.h.

421{
422#if defined(HAVE__BUILTIN_OP_OVERFLOW)
423 return __builtin_sub_overflow(0, a, result);
424#else
425 int32 res = -((int32) a);
426
427 if (unlikely(res < PG_INT16_MIN))
428 {
429 *result = 0x5EED; /* to avoid spurious warnings */
430 return true;
431 }
432 *result = res;
433 return false;
434#endif
435}

References a, PG_INT16_MIN, and unlikely.

Referenced by pg_strtoint16_safe().

◆ pg_neg_u32_overflow()

static bool pg_neg_u32_overflow ( uint32  a,
int32 *  result 
)
inlinestatic

Definition at line 493 of file int.h.

494{
495#if defined(HAVE__BUILTIN_OP_OVERFLOW)
496 return __builtin_sub_overflow(0, a, result);
497#else
498 int64 res = -((int64) a);
499
500 if (unlikely(res < PG_INT32_MIN))
501 {
502 *result = 0x5EED; /* to avoid spurious warnings */
503 return true;
504 }
505 *result = res;
506 return false;
507#endif
508}

References a, PG_INT32_MIN, and unlikely.

Referenced by pg_strtoint32_safe().

◆ pg_neg_u64_overflow()

static bool pg_neg_u64_overflow ( uint64  a,
int64 *  result 
)
inlinestatic

Definition at line 576 of file int.h.

577{
578#if defined(HAVE__BUILTIN_OP_OVERFLOW)
579 return __builtin_sub_overflow(0, a, result);
580#elif defined(HAVE_INT128)
581 int128 res = -((int128) a);
582
583 if (unlikely(res < PG_INT64_MIN))
584 {
585 *result = 0x5EED; /* to avoid spurious warnings */
586 return true;
587 }
588 *result = res;
589 return false;
590#else
591 if (unlikely(a > (uint64) PG_INT64_MAX + 1))
592 {
593 *result = 0x5EED; /* to avoid spurious warnings */
594 return true;
595 }
596 if (unlikely(a == (uint64) PG_INT64_MAX + 1))
597 *result = PG_INT64_MIN;
598 else
599 *result = -((int64) a);
600 return false;
601#endif
602}

References a, PG_INT64_MAX, PG_INT64_MIN, and unlikely.

Referenced by pg_strtoint64_safe().

◆ pg_sub_s16_overflow()

static bool pg_sub_s16_overflow ( int16  a,
int16  b,
int16 *  result 
)
inlinestatic

Definition at line 85 of file int.h.

86{
87#if defined(HAVE__BUILTIN_OP_OVERFLOW)
88 return __builtin_sub_overflow(a, b, result);
89#else
90 int32 res = (int32) a - (int32) b;
91
92 if (res > PG_INT16_MAX || res < PG_INT16_MIN)
93 {
94 *result = 0x5EED; /* to avoid spurious warnings */
95 return true;
96 }
97 *result = (int16) res;
98 return false;
99#endif
100}

References a, b, PG_INT16_MAX, and PG_INT16_MIN.

Referenced by int2_dist(), and int2mi().

◆ pg_sub_s32_overflow()

static bool pg_sub_s32_overflow ( int32  a,
int32  b,
int32 *  result 
)
inlinestatic

Definition at line 169 of file int.h.

170{
171#if defined(HAVE__BUILTIN_OP_OVERFLOW)
172 return __builtin_sub_overflow(a, b, result);
173#else
174 int64 res = (int64) a - (int64) b;
175
176 if (res > PG_INT32_MAX || res < PG_INT32_MIN)
177 {
178 *result = 0x5EED; /* to avoid spurious warnings */
179 return true;
180 }
181 *result = (int32) res;
182 return false;
183#endif
184}

References a, b, PG_INT32_MAX, and PG_INT32_MIN.

Referenced by array_prepend(), array_set_element(), array_set_element_expanded(), array_set_slice(), do_to_timestamp(), finite_interval_mi(), int24mi(), int42mi(), int4_dist(), int4mi(), interval_um_internal(), and ReadArrayDimensions().

◆ pg_sub_s64_overflow()

static bool pg_sub_s64_overflow ( int64  a,
int64  b,
int64 *  result 
)
inlinestatic

Definition at line 262 of file int.h.

263{
264#if defined(HAVE__BUILTIN_OP_OVERFLOW)
265 return __builtin_sub_overflow(a, b, result);
266#elif defined(HAVE_INT128)
267 int128 res = (int128) a - (int128) b;
268
269 if (res > PG_INT64_MAX || res < PG_INT64_MIN)
270 {
271 *result = 0x5EED; /* to avoid spurious warnings */
272 return true;
273 }
274 *result = (int64) res;
275 return false;
276#else
277 /*
278 * Note: overflow is also possible when a == 0 and b < 0 (specifically,
279 * when b == PG_INT64_MIN).
280 */
281 if ((a < 0 && b > 0 && a < PG_INT64_MIN + b) ||
282 (a >= 0 && b < 0 && a > PG_INT64_MAX + b))
283 {
284 *result = 0x5EED; /* to avoid spurious warnings */
285 return true;
286 }
287 *result = a - b;
288 return false;
289#endif
290}

References a, b, PG_INT64_MAX, and PG_INT64_MIN.

Referenced by AdjustIntervalForTypmod(), cash_dist(), cash_in(), cash_mi_cash(), evalStandardFunc(), finite_interval_mi(), generate_series_timestamp_support(), int28mi(), int48mi(), int82mi(), int84mi(), int8_dist(), int8dec(), int8mi(), interval_um_internal(), numericvar_to_int64(), strtoint64(), timestamp_bin(), timestamp_mi(), TimestampDifferenceMilliseconds(), and timestamptz_bin().

◆ pg_sub_u16_overflow()

static bool pg_sub_u16_overflow ( uint16  a,
uint16  b,
uint16 *  result 
)
inlinestatic

Definition at line 386 of file int.h.

387{
388#if defined(HAVE__BUILTIN_OP_OVERFLOW)
389 return __builtin_sub_overflow(a, b, result);
390#else
391 if (b > a)
392 {
393 *result = 0x5EED; /* to avoid spurious warnings */
394 return true;
395 }
396 *result = a - b;
397 return false;
398#endif
399}

References a, and b.

◆ pg_sub_u32_overflow()

static bool pg_sub_u32_overflow ( uint32  a,
uint32  b,
uint32 *  result 
)
inlinestatic

Definition at line 459 of file int.h.

460{
461#if defined(HAVE__BUILTIN_OP_OVERFLOW)
462 return __builtin_sub_overflow(a, b, result);
463#else
464 if (b > a)
465 {
466 *result = 0x5EED; /* to avoid spurious warnings */
467 return true;
468 }
469 *result = a - b;
470 return false;
471#endif
472}

References a, and b.

◆ pg_sub_u64_overflow()

static bool pg_sub_u64_overflow ( uint64  a,
uint64  b,
uint64 *  result 
)
inlinestatic

Definition at line 532 of file int.h.

533{
534#if defined(HAVE__BUILTIN_OP_OVERFLOW)
535 return __builtin_sub_overflow(a, b, result);
536#else
537 if (b > a)
538 {
539 *result = 0x5EED; /* to avoid spurious warnings */
540 return true;
541 }
542 *result = a - b;
543 return false;
544#endif
545}

References a, and b.