Remove hard-coded checked declarations from 3C regression tests. (#576)

Author: mattmccutchen-cci

clang/test/3C/3d-allocation.c

@@ -8,9 +8,6 @@
 #include <stdio.h>
 #include <stdlib.h>
 
-extern _Itype_for_any(T) void *malloc(size_t size)
-    : itype(_Array_ptr<T>) byte_count(size);
-
 int ***malloc3d(int y, int x, int z) {
   //CHECK_NOALL: int ***malloc3d(int y, int x, int z) : itype(_Ptr<int **>) {
   //CHECK_ALL: _Array_ptr<_Array_ptr<_Array_ptr<int>>> malloc3d(int y, int x, int z) : count(y) {

clang/test/3C/add_bounds.c

@@ -35,8 +35,7 @@ void biz(){
   //CHECK_ALL: _Array_ptr<int> b : count(10) = a;
 }
 
-#include<stddef.h>
-_Itype_for_any(T) void *malloc(size_t size) : itype(_Array_ptr<T>) byte_count(size);
+#include <stdlib.h>
 _Array_ptr<int> faz(void) {
 //CHECK_ALL: _Array_ptr<int> faz(void) : count(100) {
   int *c = malloc(100 * sizeof(int));

clang/test/3C/alloc_type_param.c

@@ -5,15 +5,7 @@
 // RUN: 3c -base-dir=%S -output-dir=%t.checked -alltypes %s --
 // RUN: 3c -base-dir=%t.checked -alltypes %t.checked/alloc_type_param.c -- | diff %t.checked/alloc_type_param.c -
 
-#include <stddef.h>
-extern _Itype_for_any(T) void *calloc(size_t nmemb, size_t size)
-    : itype(_Array_ptr<T>) byte_count(nmemb * size);
-extern _Itype_for_any(T) void *malloc(size_t size)
-    : itype(_Array_ptr<T>) byte_count(size);
-extern _Itype_for_any(T) void *realloc(void *pointer
-                                       : itype(_Array_ptr<T>) byte_count(1),
-                                         size_t size)
-    : itype(_Array_ptr<T>) byte_count(size);
+#include <stdlib.h>
 
 /* Check basic behavior with the three alloc functions */
 void foo() {

clang/test/3C/allocator.c

@@ -9,10 +9,7 @@
 // RUN: 3c -base-dir=%t.checked %t.checked/allocator.c -- | diff %t.checked/allocator.c -
 // expected-no-diagnostics
 //
-#include <stddef.h>
-_Itype_for_any(T) void *malloc(size_t size)
-    : itype(_Array_ptr<T>) byte_count(size);
-_Itype_for_any(T) void free(void *pointer : itype(_Array_ptr<T>) byte_count(0));
+#include <stdlib.h>
 
 void dosomething(void) {
   int a = 0;

clang/test/3C/arrboundsbasic.c

@@ -6,18 +6,7 @@
 Basic array bounds tests (without any data-flow analysis).
 */
 
-#include <stddef.h>
-
-extern _Itype_for_any(T) void *calloc(size_t nmemb, size_t size)
-    : itype(_Array_ptr<T>) byte_count(nmemb * size);
-extern _Itype_for_any(T) void free(void *pointer
-                                   : itype(_Array_ptr<T>) byte_count(0));
-extern _Itype_for_any(T) void *malloc(size_t size)
-    : itype(_Array_ptr<T>) byte_count(size);
-extern _Itype_for_any(T) void *realloc(void *pointer
-                                       : itype(_Array_ptr<T>) byte_count(1),
-                                         size_t size)
-    : itype(_Array_ptr<T>) byte_count(size);
+#include <stdlib.h>
 
 struct bar {
   char *a;

clang/test/3C/arrboundsbasicinfer.c

@@ -6,10 +6,7 @@
 Basic array bounds tests (without any data-flow analysis).
 */
 
-#include <stddef.h>
-
-extern _Itype_for_any(T) void *malloc(size_t size)
-    : itype(_Array_ptr<T>) byte_count(size);
+#include <stdlib.h>
 
 struct bar {
   char *a;

clang/test/3C/arrboundsbyte.c

@@ -6,14 +6,14 @@
 Array bounds (byte_bound) tests with data-flow analysis.
 */
 
-#include <stddef.h>
-_Itype_for_any(T) void *malloc(size_t size)
-    : itype(_Array_ptr<T>) byte_count(size);
-int *memcpy(int *restrict dest
-            : itype(restrict _Array_ptr<int>) byte_count(n),
-              const int *restrict src
-            : itype(restrict _Array_ptr<const int>) byte_count(n), size_t n)
+#include <stdlib.h>
+// This test needs a custom version of memcpy where src and dest are `int *`.
+int *memcpy_int(int *restrict dest
+                : itype(restrict _Array_ptr<int>) byte_count(n),
+                  const int *restrict src
+                : itype(restrict _Array_ptr<const int>) byte_count(n), size_t n)
     : itype(_Array_ptr<int>) byte_count(n);
+
 struct foo {
   int *y;
   int l;
@@ -22,7 +22,7 @@ struct foo {
 void bar(int *x, int c) {
   struct foo f = {x, c};
   int *q = malloc(sizeof(int) * c);
-  memcpy(q, f.y, c);
+  memcpy_int(q, f.y, c);
 }
 //CHECK: void bar(_Array_ptr<int> x : byte_count(c), int c) {
 //CHECK: _Array_ptr<int> q : count(c) = malloc<int>(sizeof(int) * c);

clang/test/3C/arrboundsheuristics.c

@@ -10,9 +10,7 @@
 
 int *glob;
 int lenplusone;
-#include <stddef.h>
-extern _Itype_for_any(T) void *malloc(size_t size)
-    : itype(_Array_ptr<T>) byte_count(size);
+#include <stdlib.h>
 //CHECK_ALL: _Array_ptr<int> glob = ((void *)0);
 //CHECK_NOALL: int *glob;
 

clang/test/3C/arrboundsinfer2.c

@@ -6,10 +6,8 @@
 Basic array bounds tests (without any data-flow analysis).
 */
 
-#include <stddef.h>
+#include <stdlib.h>
 
-extern _Itype_for_any(T) void *malloc(size_t size)
-    : itype(_Array_ptr<T>) byte_count(size);
 extern void ext_func(_Array_ptr<int> arr : count(len), unsigned len);
 
 struct bar {

clang/test/3C/arrctxsenbounds.c

@@ -5,9 +5,7 @@
 /*
 Context-sensitive array-bounds inference.
 */
-typedef long size_t;
-extern _Itype_for_any(T) void *malloc(size_t size)
-    : itype(_Array_ptr<T>) byte_count(size);
+#include <stdlib.h>
 struct foo {
   int *x;
   unsigned olol;