// RUN: %clang_analyze_cc1 -analyzer-checker=core -analyzer-config suppress-inlined-defensive-checks=true -verify %s

// Perform inline defensive checks.
void idc(void *p) {
	if (p)
		;
}

int test01(int *p) {
  if (p)
    ;
  return *p; // expected-warning {{Dereference of null pointer}}
}

int test02(int *p, int *x) {
  if (p)
    ;
  idc(p);
	if (x)
		;
  return *p; // expected-warning {{Dereference of null pointer}}
}

int test03(int *p, int *x) {
	idc(p);
	if (p)
		;
	return *p; // False negative
}

int deref04(int *p) {
  return *p; // expected-warning {{Dereference of null pointer}}
}

int test04(int *p) {
  if (p)
    ;
  idc(p);
  return deref04(p);
}

int test11(int *q, int *x) {
	int *p = q;
	if (q)
		;
	if (x)
		;
	return *p; // expected-warning{{Dereference of null pointer}}
}

int test12(int *q) {
	int *p = q;
	idc(q);
	return *p;
}

int test13(int *q) {
	int *p = q;
	idc(p);
	return *p;
}

int test21(int *q, int *x) {
	if (q)
		;
	if (x)
		;
	int *p = q;
	return *p; // expected-warning{{Dereference of null pointer}}
}

int test22(int *q, int *x) {
  idc(q);
	if (x)
		;
	int *p = q;
	return *p;
}

int test23(int *q, int *x) {
  idc(q);
	if (x)
		;
	int *p = q;
  if (!p)
    ;
	return *p; // False negative
}

void use(char *p) {
  if (!p)
    return;
  p[0] = 'a';
}

void test24(char *buffer) {
  use(buffer);
  buffer[1] = 'b';
}

// Ensure idc works on pointers with constant offset.
void idcchar(const char *s2) {
  if(s2)
    ;
}
void testConstantOffset(char *value) {
  char *cursor = value + 5;
  idcchar(cursor);
  if (*cursor) {
    cursor++;
  }
}

// Ensure idc works for integer zero values (ex: suppressed div by zero).
void idcZero(int assume) {
  if (assume)
    ;
}

int idcTriggerZeroValue(int m) {
  idcZero(m);
  return 5/m; // no-warning
}

int idcTriggerZeroValueThroughCall(int i) {
  return 5/i; // no-warning
}
void idcTrackZeroValueThroughCall(int x) {
  idcZero(x);
  idcTriggerZeroValueThroughCall(x);
}

int idcTriggerZeroThroughDoubleAssignemnt(int i) {
  return 5/i; // no-warning
}
void idcTrackZeroThroughDoubleAssignemnt(int x) {
  idcZero(x);
  int y = x;
  int z = y;
  idcTriggerZeroValueThroughCall(z);
}

struct S {
  int f1;
  int f2;
};

void idcTrackZeroValueThroughUnaryPointerOperators(struct S *s) {
  idc(s);
  *(&(s->f1)) = 7; // no-warning
}

void idcTrackZeroValueThroughUnaryPointerOperatorsWithOffset1(struct S *s) {
  idc(s);
  int *x = &(s->f2);
  *x = 7; // no-warning
}

void idcTrackZeroValueThroughUnaryPointerOperatorsWithOffset2(struct S *s) {
  idc(s);
  int *x = &(s->f2) - 1;
  *x = 7; // no-warning
}

void idcTrackZeroValueThroughUnaryPointerOperatorsWithAssignment(struct S *s) {
  idc(s);
  int *x = &(s->f1);
  *x = 7; // no-warning
}

void idcTrackZeroValueThroughManyUnaryPointerOperatorsWithAssignment(struct S *s) {
  idc(s);
  int *x = &*&(s->f1);
  *x = 7; // no-warning
}

void idcTrackZeroValueThroughManyUnaryPointerOperatorsWithAssignmentAndUnaryIncrement(struct S *s) {
  idc(s);
  int *x = &*&((++s)->f1);
  *x = 7; // no-warning
}


struct S2 {
  int a[1];
};

void idcTrackZeroValueThroughUnaryPointerOperatorsWithArrayField(struct S2 *s) {
  idc(s);
  *(&(s->a[0])) = 7; // no-warning
}

void idcTrackConstraintThroughSymbolicRegion(int **x) {
  idc(*x);
  // FIXME: Should not warn.
  **x = 7; // expected-warning{{Dereference of null pointer}}
}

void idcTrackConstraintThroughSymbolicRegionAndParens(int **x) {
  idc(*x);
  // FIXME: Should not warn.
  *(*x) = 7; // expected-warning{{Dereference of null pointer}}
}

int *idcPlainNull(int coin) {
  if (coin)
    return 0;
  static int X;
  return &X;
}

void idcTrackZeroValueThroughSymbolicRegion(int coin, int **x) {
  *x = idcPlainNull(coin);
  **x = 7; // no-warning
}

void idcTrackZeroValueThroughSymbolicRegionAndParens(int coin, int **x) {
  *x = idcPlainNull(coin);
  *(*x) = 7; // no-warning
}

struct WithInt {
  int i;
};

struct WithArray {
  struct WithInt arr[1];
};

struct WithArray *idcPlainNullWithArray(int coin) {
  if (coin)
    return 0;
  static struct WithArray S;
  return &S;
}

void idcTrackZeroValueThroughSymbolicRegionWithArray(int coin, struct WithArray **s) {
  *s = idcPlainNullWithArray(coin);
  (*s)->arr[0].i = 1; // no-warning
  // Same thing.
  (*s)->arr->i = 1; // no-warning
}
