infer_clone/infer/tests/codetoanalyze/c/bufferoverrun/prune_constant.c

/*
 * Copyright (c) 2017-present, Facebook, Inc.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 */
void prune_constant_true_Ok() {
  int a[1];

  if (1) {
    a[0] = 0;
  } else {
    a[1] = 0;
  }
}

void prune_constant_false_Ok() {
  int a[1];

  if (0) {
    a[1] = 0;
  } else {
    a[0] = 0;
  }
}

void prune_constant_value_Ok(int x) {
  int a[1];
  if (-1 < x && x < 1) {
    if (x) {
      a[1] = 0;
    } else {
      a[0] = 0;
    }
  }
}

void prune_constant_not_Bad() {
  int x = 0;
  int a[1];
  if (!x) {
    a[x + 1] = 0;
  }
}

int fromHex(char c) {
  if (c < '0' || (c > '9' && (c < 'a' || c > 'f'))) {
    return -1; // invalid not 0-9a-f hex char
  }
  if (c <= '9') {
    return c - '0';
  }
  return c - 'a' + 10;
}

void call_fromHex_sym_Good(char c) {
  char arr[16];
  int idx = fromHex(c);
  if (idx >= 0) {
    arr[idx] = 'H';
  }
}

void call_fromHex_200_Good() {
  char arr[16];
  int idx = fromHex(200);
  if (idx >= 0) {
    arr[idx] = 'H';
  }
}

void call_fromHex2_sym_Good_FP(char c) {
  char arr[17];
  int idx = fromHex(c);
  arr[idx + 1] = 'H';
}

void call_fromHex2_200_Good_FP() {
  char arr[17];
  int idx = fromHex(200);
  arr[idx + 1] = 'H';
}

void prune_add1(unsigned int x) {
  int a[10];
  if (x + 1 < 11) {
    a[x] = 0;
  }
}

void call_prune_add1_1_Good() { prune_add1(5); }

void call_prune_add1_2_Good() { prune_add1(10); }

void prune_add2(unsigned int x) {
  int a[10];
  if (x + 1 < 12) {
    a[x] = 0;
  }
}

void call_prune_add2_1_Good() { prune_add2(5); }

void call_prune_add2_2_Bad() { prune_add2(10); }

void call_prune_add2_3_Good() { prune_add2(100); }

void prune_sub1(unsigned int x) {
  int a[10];
  if (9 > x - 1) {
    a[x] = 0;
  }
}

void call_prune_sub1_1_Good() { prune_sub1(5); }

void call_prune_sub1_2_Good() { prune_sub1(10); }

void prune_sub2(unsigned int x) {
  int a[10];
  if (10 > x - 1) {
    a[x] = 0;
  }
}

void call_prune_sub2_1_Good() { prune_sub2(5); }

void call_prune_sub2_2_Bad() { prune_sub2(10); }

void call_prune_sub2_3_Good() { prune_sub2(100); }

void null_pruning1_Good(int* p) {
  if (p == 0) {
    if (p != 0) {
      int a[5];
      a[10] = 1;
    }
  }
}

void null_pruning1_Bad(int* p) {
  if (p == 0) {
    if (p == 0) {
      int a[5];
      a[10] = 1;
    }
  }
}

void null_pruning2_Good_FP(int* p) {
  if (p != 0) {
    if (p == 0) {
      int a[5];
      a[10] = 1;
    }
  }
}

void null_pruning2_Bad(int* p) {
  if (p != 0) {
    if (p != 0) {
      int a[5];
      a[10] = 1;
    }
  }
}

int greater_than(unsigned int x, unsigned int y) { return (x > y); }

void call_greater_than_Good_FP() {
  unsigned int idx = 0;
  if (greater_than(idx, 0)) {
    idx = idx - 1;
  }
}

void null_pruning_symbols(unsigned int a, unsigned int b) {
  unsigned int c = a + b;
  if (c > 0) {
    char result[c];
    result[c - 1] = 0;
  }
}

void call_null_pruning_symbols_Good_FP() { null_pruning_symbols(10, 20); }