示例#1
0
void
fn0 (int n)
{
  p = __builtin_alloca_with_align (n, 6); /* { dg-error "39:must be a constant integer" } */

  r += __builtin_isfinite (0); /* { dg-error "28:non-floating-point argument in call" } */
  r += __builtin_isinf (0); /* { dg-error "25:non-floating-point argument in call" } */
  r += __builtin_isinf_sign (0); /* { dg-error "30:non-floating-point argument in call" } */
  r += __builtin_isnan (0); /* { dg-error "25:non-floating-point argument in call" } */
  r += __builtin_isnormal (0); /* { dg-error "28:non-floating-point argument in call" } */
  r += __builtin_signbit (0); /* { dg-error "27:non-floating-point argument in call" } */

  r += __builtin_isgreater (0, 0); /* { dg-error "8:non-floating-point arguments in call to function" } */
  r += __builtin_isgreaterequal (0, 0); /* { dg-error "8:non-floating-point arguments in call to function" } */
  r += __builtin_isless (0, 0); /* { dg-error "8:non-floating-point arguments in call to function" } */
  r += __builtin_islessequal (0, 0); /* { dg-error "8:non-floating-point arguments in call to function" } */
  r += __builtin_islessgreater (0, 0); /* { dg-error "8:non-floating-point arguments in call to function" } */
  r += __builtin_isunordered (0, 0); /* { dg-error "8:non-floating-point arguments in call to function" } */

  r += __builtin_fpclassify (1, 2, n, 4, 5, n); /* { dg-error "36:non-const integer argument 3 in call" } */
  r += __builtin_fpclassify (1, 2, 3, 4, 5, 6); /* { dg-error "45:non-floating-point argument in call" } */

  d = __builtin_assume_aligned (p, n, p); /* { dg-error "39:non-integer argument 3 in call" } */

  b = __builtin_add_overflow (n, *d, &r); /* { dg-error "34:argument 2 in call to function" } */
  b = __builtin_add_overflow (n, 5, d); /* { dg-error "37:argument 3 in call" } */
  b = __builtin_sub_overflow (n, *d, &r); /* { dg-error "34:argument 2 in call to function" } */
  b = __builtin_sub_overflow (n, 5, d); /* { dg-error "37:argument 3 in call" } */
  b = __builtin_mul_overflow (n, *d, &r); /* { dg-error "34:argument 2 in call to function" } */
  b = __builtin_mul_overflow (n, 5, d); /* { dg-error "37:argument 3 in call" } */
}
示例#2
0
int
f4 (float *fp, double *dp, _Complex int *cp, enum E *ep, bool *bp, long long int *llp)
{
  int x = __builtin_add_overflow (1, 2, fp);	/* { dg-error "argument 3 in call to function\[^\n\r]*does not have pointer to integer type" } */
  x += __builtin_sub_overflow (1, 2, dp);	/* { dg-error "argument 3 in call to function\[^\n\r]*does not have pointer to integer type" } */
  x += __builtin_mul_overflow (1, 2, cp);	/* { dg-error "argument 3 in call to function\[^\n\r]*does not have pointer to integer type" } */
  x += __builtin_add_overflow (1, 2, ep);	/* { dg-error "argument 3 in call to function\[^\n\r]*does not have pointer to integer type" } */
  x += __builtin_sub_overflow (1, 2, bp);	/* { dg-error "argument 3 in call to function\[^\n\r]*does not have pointer to integer type" } */
  x += __builtin_mul_overflow (1, 2, llp);
  return x;
}
示例#3
0
文件: fraction.cpp 项目: hallca/sp16
Fraction Fraction::operator *= (const Fraction& rhs)
{
    if (__builtin_mul_overflow(numerator, rhs.numerator, &numerator)) goto err;
    if (__builtin_mul_overflow(DenominatorAsInt(), rhs.DenominatorAsInt(), &denominator)) goto err;
    Reduce();
    return *this;

err:
    valid = false;
    return *this;
}
示例#4
0
int
f3 (float fa, int a, _Complex long int ca, double fb, void *pb, int b, enum E eb, bool bb, int *c)
{
  int x = __builtin_add_overflow (fa, b, c);	/* { dg-error "argument 1 in call to function\[^\n\r]*does not have integral type" } */
  x += __builtin_sub_overflow (ca, b, c);	/* { dg-error "argument 1 in call to function\[^\n\r]*does not have integral type" } */
  x += __builtin_mul_overflow (a, fb, c);	/* { dg-error "argument 2 in call to function\[^\n\r]*does not have integral type" } */
  x += __builtin_add_overflow (a, pb, c);	/* { dg-error "argument 2 in call to function\[^\n\r]*does not have integral type" } */
  x += __builtin_sub_overflow (a, eb, c);
  x += __builtin_mul_overflow (a, bb, c);
  return x;
}
示例#5
0
文件: string.c 项目: celskeggs/libca
u64 parseu64(string data, string *remain) {
	if (remain == NULL) {
		if (*data == 0) {
			panic_static("parsenum got no number");
		}
		if (*data == '-') {
			panic_static("parsenum got a negative number");
		}
		string str;
		u64 out = parseu64(data, &str);
		if (str == NULL) {
			panic_static("parsenum found a too-large number");
		} else if (*str != '\0') {
			if (str == data) {
				panic_static("parsenum did not find a number");
			} else if (*str >= '0' && *str <= '9') {
				panic_static("parsenum found a too-long number");
			} else {
				panic_static("parsenum found garbage after a number");
			}
		}
		return out;
	}
	u64 out = 0;
	while (*data >= '0' && *data <= '9') {
		if (__builtin_mul_overflow(out, 10, &out) || __builtin_add_overflow(out, *data - '0', &out)) {
			*remain = NULL;
			return out;
		}
		data++;
	}
	*remain = data;
	return out;
}
示例#6
0
int
f1 (void)
{
  int x = __builtin_add_overflow ();	/* { dg-error "not enough arguments to function" } */
  x += __builtin_sub_overflow ();	/* { dg-error "not enough arguments to function" } */
  x += __builtin_mul_overflow ();	/* { dg-error "not enough arguments to function" } */
  return x;
}
示例#7
0
int
f2 (int a, int b, int *c, int d)
{
  int x = __builtin_add_overflow (a, b, c, d);	/* { dg-error "too many arguments to function" } */
  x += __builtin_sub_overflow (a, b, c, d, d, d);	/* { dg-error "too many arguments to function" } */
  x += __builtin_mul_overflow (a, b, c, d);	/* { dg-error "too many arguments to function" } */
  return x;
}
示例#8
0
文件: pr71554.c 项目: Droufte/gcc
void
foo (unsigned int x)
{
  signed int y = ((-__INT_MAX__ - 1) / 2);
  signed int r;
  if (__builtin_mul_overflow (x, y, &r))
    bar ();
}
示例#9
0
/* MUL_OVERFLOW should be folded into unsigned multiplication,
   because it always overflows.  */
__attribute__((noinline, noclone)) signed char
fn5 (long int x, long int y, int *ovf)
{
  signed char res;
  x = (x & 63) + (__SCHAR_MAX__ / 4);
  y = (y & 3) + 5;
  *ovf = __builtin_mul_overflow (x, y, &res);
  return res;
}
示例#10
0
文件: fraction.cpp 项目: hallca/sp16
Fraction Fraction::operator += (const Fraction& rhs)
{
    const int lcm = LCM(DenominatorAsInt(), rhs.DenominatorAsInt());
    int A = 0, B = 0;
    
    if (__builtin_mul_overflow(numerator / DenominatorAsInt(), lcm, &A)) goto err;
    if (__builtin_mul_overflow(rhs.numerator / rhs.DenominatorAsInt(), lcm, &B)) goto err;
    if (__builtin_add_overflow(A, B, &numerator)) goto err;

    denominator = lcm;

    Reduce();
    return *this;

err:
    valid = false;
    return *this;
}
示例#11
0
/* MUL_OVERFLOW should be folded into unsigned multiplication,
   because it never overflows.  */
__attribute__((noinline, noclone)) long int
fn4 (long int x, long int y, int *ovf)
{
  long int res;
  x &= 65535;
  y = (y & 65535) - 32768;
  *ovf = __builtin_mul_overflow (x, y, &res);
  return res;
}
示例#12
0
/* MUL_OVERFLOW should be folded into unsigned multiplication,
   because ovf is never used.  */
__attribute__((noinline, noclone)) int
fn2 (char x, long int y)
{
  short int res;
  int ovf = __builtin_mul_overflow (x, y, &res);
  int res2 = res;
  int res3 = res2 - 2;
  (void) ovf;
  return res;
}
示例#13
0
文件: Overflow.hpp 项目: jdh8/chic
bool Overflow<Unsigned>::operator*=(Unsigned other)
{
  #ifdef __GNUC__
    return __builtin_mul_overflow(_value, other, &_value);
  #else
    Unsigned cache = _value;
    _value *= other;
    return other && _value / other != cache;
  #endif
}
示例#14
0
void *
__libc_reallocarray (void *optr, size_t nmemb, size_t elem_size)
{
  size_t bytes;
  if (__builtin_mul_overflow (nmemb, elem_size, &bytes))
    {
      __set_errno (ENOMEM);
      return 0;
    }
  return realloc (optr, bytes);
}
示例#15
0
文件: fraction.cpp 项目: hallca/sp16
Fraction Fraction::operator -= (const Fraction& rhs)
{
    const int lcm = LCM(DenominatorAsInt(), rhs.DenominatorAsInt());
    int A = 0, B = 0;

    if (__builtin_mul_overflow(numerator / DenominatorAsInt(), lcm, &A)) goto err;
    if (__builtin_mul_overflow(rhs.numerator / rhs.DenominatorAsInt(), lcm, &B)) goto err;
    if (__builtin_sub_overflow(A, B, &numerator)) goto err;

    denominator = lcm;

    Reduce();

//    std::cout << "result: " << *this << std::endl;
    return *this;

err:
    valid = false;
    return *this;
}
示例#16
0
void* debug_calloc(size_t nmemb, size_t bytes) {
  if (DebugCallsDisabled()) {
    return g_dispatch->calloc(nmemb, bytes);
  }
  ScopedDisableDebugCalls disable;

  size_t size;
  if (__builtin_mul_overflow(nmemb, bytes, &size)) {
    // Overflow
    errno = ENOMEM;
    return nullptr;
  }

  if (size == 0) {
    size = 1;
  }

  size_t real_size;
  if (__builtin_add_overflow(size, g_debug->extra_bytes(), &real_size)) {
    // Overflow.
    errno = ENOMEM;
    return nullptr;
  }

  if (g_debug->need_header()) {
    // The above check will guarantee the multiply will not overflow.
    if (size > Header::max_size()) {
      errno = ENOMEM;
      return nullptr;
    }

    // Need to guarantee the alignment of the header.
    Header* header = reinterpret_cast<Header*>(
        g_dispatch->memalign(MINIMUM_ALIGNMENT_BYTES, real_size));
    if (header == nullptr) {
      return nullptr;
    }
    memset(header, 0, g_dispatch->malloc_usable_size(header));
    return InitHeader(header, header, size);
  } else {
    return g_dispatch->calloc(1, real_size);
  }
}
示例#17
0
int main(int argc, const char **argv) {
  signed int res;

  if (__builtin_mul_overflow((signed int)0x0, (signed int)0x0, &res)) {
    return -1;
  }

  if (__builtin_mul_overflow((signed int)0x0, (signed int)0x7FFFFFFF, &res)) {
    return -1;
  }

  if (__builtin_mul_overflow((signed int)0x0, (signed int)0x80000000, &res)) {
    return -1;
  }

  if (__builtin_mul_overflow((signed int)0x1, (signed int)0x7FFFFFFF, &res)) {
    return -1;
  }

  if (__builtin_mul_overflow((signed int)0x1, (signed int)0x80000000, &res)) {
    return -1;
  }

  if (__builtin_mul_overflow((signed int)0x2, (signed int)0x3FFFFFFF, &res)) {
    return -1;
  }

  if (__builtin_mul_overflow((signed int)0x2, (signed int)0xC0000000, &res)) {
    return -1;
  }

  if (!__builtin_mul_overflow((signed int)0x2, (signed int)0x7FFFFFFF, &res)) {
    return -1;
  }

  if (!__builtin_mul_overflow((signed int)0x2, (signed int)0x80000000, &res)) {
    return -1;
  }

  if (__builtin_mul_overflow((signed int)0x0FFFFFFF, (signed int)0x8, &res)) {
    return -1;
  }

  if (!__builtin_mul_overflow((signed int)0x10000000, (signed int)0x8, &res)) {
    return -1;
  }

  if (__builtin_mul_overflow((signed int)0x7FFFFFFF, (signed int)0x0, &res)) {
    return -1;
  }

  if (__builtin_mul_overflow((signed int)0x7FFFFFFF, (signed int)0x1, &res)) {
    return -1;
  }

  if (!__builtin_mul_overflow((signed int)0x7FFFFFFF, (signed int)0x2, &res)) {
    return -1;
  }

  if (!__builtin_mul_overflow((signed int)0x7FFFFFFF, (signed int)0x7FFFFFFF, &res)) {
    return -1;
  }

  if (!__builtin_mul_overflow((signed int)0x7FFFFFFF, (signed int)0x80000000, &res)) {
    return -1;
  }

  if (__builtin_mul_overflow((signed int)0x80000000, (signed int)0x0, &res)) {
    return -1;
  }

  if (__builtin_mul_overflow((signed int)0x80000000, (signed int)0x1, &res)) {
    return -1;
  }

  if (!__builtin_mul_overflow((signed int)0x80000000, (signed int)0x2, &res)) {
    return -1;
  }

  if (!__builtin_mul_overflow((signed int)0x80000000, (signed int)0x7FFFFFFF, &res)) {
    return -1;
  }

  if (!__builtin_mul_overflow((signed int)0x80000000, (signed int)0x80000000, &res)) {
    return -1;
  }

  if (__builtin_mul_overflow((signed int)0xFFFFFFFF, (signed int)0x0, &res)) {
    return -1;
  }

  if (__builtin_mul_overflow((signed int)0xFFFFFFFF, (signed int)0x1, &res)) {
    return -1;
  }

  if (__builtin_mul_overflow((signed int)0xFFFFFFFF, (signed int)0xFFFFFFFF, &res)) {
    return -1;
  }

  return 0;
}
constexpr Result<RET> mul(LHS &&lhs, RHS &&rhs) {
  RET sum{};
  return {__builtin_mul_overflow(lhs, rhs, &sum), sum};
}
示例#19
0
文件: umult16.c 项目: gebi/libowfat
int umult16(uint16 a,uint16 b,uint16* c) { return !__builtin_mul_overflow(a,b,c); }
示例#20
0
// Determine video dimensions from the sequence parameterset.
void FindAVCDimensions(
        const sp<ABuffer> &seqParamSet,
        int32_t *width, int32_t *height,
        int32_t *sarWidth, int32_t *sarHeight) {
    ABitReader br(seqParamSet->data() + 1, seqParamSet->size() - 1);

    unsigned profile_idc = br.getBits(8);
    br.skipBits(16);
    parseUE(&br);  // seq_parameter_set_id

    unsigned chroma_format_idc = 1;  // 4:2:0 chroma format

    if (profile_idc == 100 || profile_idc == 110
            || profile_idc == 122 || profile_idc == 244
            || profile_idc == 44 || profile_idc == 83 || profile_idc == 86) {
        chroma_format_idc = parseUE(&br);
        if (chroma_format_idc == 3) {
            br.skipBits(1);  // residual_colour_transform_flag
        }
        parseUE(&br);  // bit_depth_luma_minus8
        parseUE(&br);  // bit_depth_chroma_minus8
        br.skipBits(1);  // qpprime_y_zero_transform_bypass_flag

        if (br.getBits(1)) {  // seq_scaling_matrix_present_flag
            for (size_t i = 0; i < 8; ++i) {
                if (br.getBits(1)) {  // seq_scaling_list_present_flag[i]

                    // WARNING: the code below has not ever been exercised...
                    // need a real-world example.

                    if (i < 6) {
                        // ScalingList4x4[i],16,...
                        skipScalingList(&br, 16);
                    } else {
                        // ScalingList8x8[i-6],64,...
                        skipScalingList(&br, 64);
                    }
                }
            }
        }
    }

    parseUE(&br);  // log2_max_frame_num_minus4
    unsigned pic_order_cnt_type = parseUE(&br);

    if (pic_order_cnt_type == 0) {
        parseUE(&br);  // log2_max_pic_order_cnt_lsb_minus4
    } else if (pic_order_cnt_type == 1) {
        // offset_for_non_ref_pic, offset_for_top_to_bottom_field and
        // offset_for_ref_frame are technically se(v), but since we are
        // just skipping over them the midpoint does not matter.

        br.getBits(1);  // delta_pic_order_always_zero_flag
        parseUE(&br);  // offset_for_non_ref_pic
        parseUE(&br);  // offset_for_top_to_bottom_field

        unsigned num_ref_frames_in_pic_order_cnt_cycle = parseUE(&br);
        for (unsigned i = 0; i < num_ref_frames_in_pic_order_cnt_cycle; ++i) {
            parseUE(&br);  // offset_for_ref_frame
        }
    }

    parseUE(&br);  // num_ref_frames
    br.getBits(1);  // gaps_in_frame_num_value_allowed_flag

    unsigned pic_width_in_mbs_minus1 = parseUE(&br);
    unsigned pic_height_in_map_units_minus1 = parseUE(&br);
    unsigned frame_mbs_only_flag = br.getBits(1);

    *width = pic_width_in_mbs_minus1 * 16 + 16;

    *height = (2 - frame_mbs_only_flag)
        * (pic_height_in_map_units_minus1 * 16 + 16);

    if (!frame_mbs_only_flag) {
        br.getBits(1);  // mb_adaptive_frame_field_flag
    }

    br.getBits(1);  // direct_8x8_inference_flag

    if (br.getBits(1)) {  // frame_cropping_flag
        unsigned frame_crop_left_offset = parseUE(&br);
        unsigned frame_crop_right_offset = parseUE(&br);
        unsigned frame_crop_top_offset = parseUE(&br);
        unsigned frame_crop_bottom_offset = parseUE(&br);

        unsigned cropUnitX, cropUnitY;
        if (chroma_format_idc == 0  /* monochrome */) {
            cropUnitX = 1;
            cropUnitY = 2 - frame_mbs_only_flag;
        } else {
            unsigned subWidthC = (chroma_format_idc == 3) ? 1 : 2;
            unsigned subHeightC = (chroma_format_idc == 1) ? 2 : 1;

            cropUnitX = subWidthC;
            cropUnitY = subHeightC * (2 - frame_mbs_only_flag);
        }

        ALOGV("frame_crop = (%u, %u, %u, %u), cropUnitX = %u, cropUnitY = %u",
             frame_crop_left_offset, frame_crop_right_offset,
             frame_crop_top_offset, frame_crop_bottom_offset,
             cropUnitX, cropUnitY);


        // *width -= (frame_crop_left_offset + frame_crop_right_offset) * cropUnitX;
        if(__builtin_add_overflow(frame_crop_left_offset, frame_crop_right_offset, &frame_crop_left_offset) ||
            __builtin_mul_overflow(frame_crop_left_offset, cropUnitX, &frame_crop_left_offset) ||
            __builtin_sub_overflow(*width, frame_crop_left_offset, width) ||
            *width < 0) {
            *width = 0;
        }

        //*height -= (frame_crop_top_offset + frame_crop_bottom_offset) * cropUnitY;
        if(__builtin_add_overflow(frame_crop_top_offset, frame_crop_bottom_offset, &frame_crop_top_offset) ||
            __builtin_mul_overflow(frame_crop_top_offset, cropUnitY, &frame_crop_top_offset) ||
            __builtin_sub_overflow(*height, frame_crop_top_offset, height) ||
            *height < 0) {
            *height = 0;
        }
    }

    if (sarWidth != NULL) {
        *sarWidth = 0;
    }

    if (sarHeight != NULL) {
        *sarHeight = 0;
    }

    if (br.getBits(1)) {  // vui_parameters_present_flag
        unsigned sar_width = 0, sar_height = 0;

        if (br.getBits(1)) {  // aspect_ratio_info_present_flag
            unsigned aspect_ratio_idc = br.getBits(8);

            if (aspect_ratio_idc == 255 /* extendedSAR */) {
                sar_width = br.getBits(16);
                sar_height = br.getBits(16);
            } else {
                static const struct { unsigned width, height; } kFixedSARs[] = {
                        {   0,  0 }, // Invalid
                        {   1,  1 },
                        {  12, 11 },
                        {  10, 11 },
                        {  16, 11 },
                        {  40, 33 },
                        {  24, 11 },
                        {  20, 11 },
                        {  32, 11 },
                        {  80, 33 },
                        {  18, 11 },
                        {  15, 11 },
                        {  64, 33 },
                        { 160, 99 },
                        {   4,  3 },
                        {   3,  2 },
                        {   2,  1 },
                };

                if (aspect_ratio_idc > 0 && aspect_ratio_idc < NELEM(kFixedSARs)) {
                    sar_width = kFixedSARs[aspect_ratio_idc].width;
                    sar_height = kFixedSARs[aspect_ratio_idc].height;
                }
            }
        }

        ALOGV("sample aspect ratio = %u : %u", sar_width, sar_height);

        if (sarWidth != NULL) {
            *sarWidth = sar_width;
        }

        if (sarHeight != NULL) {
            *sarHeight = sar_height;
        }
    }
}
示例#21
0
文件: imult16.c 项目: rsenn/dirlist
int
imult16(int16 a, int16 b, int16* c) {
  return !__builtin_mul_overflow(a, b, c);
}