llvm-project/clang/test/Analysis/double-ranges-bug.c

// RUN: %clang_analyze_cc1 -verify %s -analyzer-checker=core

// expected-no-diagnostics

typedef unsigned long int A;

extern int fill(A **values, int *nvalues);

void foo(void) {
  A *values;
  int nvalues;
  fill(&values, &nvalues);

  int i = 1;
  double x, y;

  y = values[i - 1];
  x = values[i];

  if (x <= y) {
  }
}
[analyzer] Refactor range inference for symbolic expressions Summary: This change introduces a new component to unite all of the reasoning we have about operations on ranges in the analyzer's solver. In many cases, we might conclude that the range for a symbolic operation is much more narrow than the type implies. While reasoning about runtime conditions (especially in loops), we need to support more and more of those little pieces of logic. The new component mostly plays a role of an organizer for those, and allows us to focus on the actual reasoning about ranges and not dispatching manually on the types of the nested symbolic expressions. Differential Revision: https://reviews.llvm.org/D79232 2020-05-01 11:49:23 +03:00			`// RUN: %clang_analyze_cc1 -verify %s -analyzer-checker=core`

			`// expected-no-diagnostics`

			`typedef unsigned long int A;`

			`extern int fill(A *values, int nvalues);`

Use functions with prototypes when appropriate; NFC A significant number of our tests in C accidentally use functions without prototypes. This patch converts the function signatures to have a prototype for the situations where the test is not specific to K&R C declarations. e.g., void func(); becomes void func(void); This is the eighth batch of tests being updated (there are a significant number of other tests left to be updated). 2022-02-12 07:23:43 -05:00			`void foo(void) {`
[analyzer] Refactor range inference for symbolic expressions Summary: This change introduces a new component to unite all of the reasoning we have about operations on ranges in the analyzer's solver. In many cases, we might conclude that the range for a symbolic operation is much more narrow than the type implies. While reasoning about runtime conditions (especially in loops), we need to support more and more of those little pieces of logic. The new component mostly plays a role of an organizer for those, and allows us to focus on the actual reasoning about ranges and not dispatching manually on the types of the nested symbolic expressions. Differential Revision: https://reviews.llvm.org/D79232 2020-05-01 11:49:23 +03:00			`A *values;`
			`int nvalues;`
			`fill(&values, &nvalues);`

			`int i = 1;`
			`double x, y;`

			`y = values[i - 1];`
			`x = values[i];`

			`if (x <= y) {`
			`}`
			`}`