forked from OSchip/llvm-project
121 lines
3.0 KiB
C++
121 lines
3.0 KiB
C++
// RUN: %clang_analyze_cc1 -analyzer-checker=core -verify %s
|
|
|
|
// This tests false-positive issues related to PR48534.
|
|
//
|
|
// Essentially, having a default member initializer for a constant member does
|
|
// not necessarily imply the member will have the given default value.
|
|
|
|
struct WithConstructor {
|
|
int *const ptr = nullptr;
|
|
WithConstructor(int *x) : ptr(x) {}
|
|
|
|
static auto compliant() {
|
|
WithConstructor c(new int);
|
|
return *(c.ptr); // no warning
|
|
}
|
|
|
|
static auto compliantWithParam(WithConstructor c) {
|
|
return *(c.ptr); // no warning
|
|
}
|
|
|
|
static auto issue() {
|
|
WithConstructor c(nullptr);
|
|
return *(c.ptr); // expected-warning{{Dereference of null pointer (loaded from field 'ptr')}}
|
|
}
|
|
};
|
|
|
|
struct RegularAggregate {
|
|
int *const ptr = nullptr;
|
|
|
|
static int compliant() {
|
|
RegularAggregate c{new int};
|
|
return *(c.ptr); // no warning
|
|
}
|
|
|
|
static int issue() {
|
|
RegularAggregate c;
|
|
return *(c.ptr); // expected-warning{{Dereference of null pointer (loaded from field 'ptr')}}
|
|
}
|
|
};
|
|
|
|
struct WithConstructorAndArithmetic {
|
|
int const i = 0;
|
|
WithConstructorAndArithmetic(int x) : i(x + 1) {}
|
|
|
|
static int compliant(int y) {
|
|
WithConstructorAndArithmetic c(0);
|
|
return y / c.i; // no warning
|
|
}
|
|
|
|
static int issue(int y) {
|
|
WithConstructorAndArithmetic c(-1);
|
|
return y / c.i; // expected-warning{{Division by zero}}
|
|
}
|
|
};
|
|
|
|
struct WithConstructorDeclarationOnly {
|
|
int const i = 0;
|
|
WithConstructorDeclarationOnly(int x); // definition not visible.
|
|
|
|
static int compliant1(int y) {
|
|
WithConstructorDeclarationOnly c(0);
|
|
return y / c.i; // no warning
|
|
}
|
|
|
|
static int compliant2(int y) {
|
|
WithConstructorDeclarationOnly c(-1);
|
|
return y / c.i; // no warning
|
|
}
|
|
};
|
|
|
|
// NonAggregateFP is not an aggregate (j is a private non-static field) and has no custom constructor.
|
|
// So we know i and j will always be 0 and 42, respectively.
|
|
// That being said, this is not implemented because it is deemed too rare to be worth the complexity.
|
|
struct NonAggregateFP {
|
|
public:
|
|
int const i = 0;
|
|
|
|
private:
|
|
int const j = 42;
|
|
|
|
public:
|
|
static int falsePositive1(NonAggregateFP c) {
|
|
return 10 / c.i; // FIXME: Currently, no warning.
|
|
}
|
|
|
|
static int falsePositive2(NonAggregateFP c) {
|
|
return 10 / (c.j - 42); // FIXME: Currently, no warning.
|
|
}
|
|
};
|
|
|
|
struct NonAggregate {
|
|
public:
|
|
int const i = 0;
|
|
|
|
private:
|
|
int const j = 42;
|
|
|
|
NonAggregate(NonAggregate const &); // not provided, could set i and j to arbitrary values.
|
|
|
|
public:
|
|
static int compliant1(NonAggregate c) {
|
|
return 10 / c.i; // no warning
|
|
}
|
|
|
|
static int compliant2(NonAggregate c) {
|
|
return 10 / (c.j - 42); // no warning
|
|
}
|
|
};
|
|
|
|
struct WithStaticMember {
|
|
static int const i = 0;
|
|
|
|
static int issue1(WithStaticMember c) {
|
|
return 10 / c.i; // expected-warning{{division by zero is undefined}} expected-warning{{Division by zero}}
|
|
}
|
|
|
|
static int issue2() {
|
|
return 10 / WithStaticMember::i; // expected-warning{{division by zero is undefined}} expected-warning{{Division by zero}}
|
|
}
|
|
};
|