Merge pull request #336 from kyleheadley/bugfix#264

Bugfix#264

Author: kyleheadley

clang/include/clang/3C/ProgramInfo.h

@@ -81,9 +81,6 @@ class ProgramInfo : public ProgramVariableAdder {
   FVConstraint *getStaticFuncConstraint(std::string FuncName,
                                         std::string FileName) const;
 
-  // Check if the given function is an extern function.
-  bool isAnExternFunction(const std::string &FName);
-
   // Called when we are done adding constraints and visiting ASTs.
   // Links information about global symbols together and adds
   // constraints where appropriate.
@@ -128,10 +125,9 @@ class ProgramInfo : public ProgramVariableAdder {
   // Is the ProgramInfo persisted? Only tested in asserts. Starts at true.
   bool Persisted;
 
-  // Map of global decls for which we don't have a body, the keys are
-  // names of external functions/vars, the value is whether the body/def
+  // Map of global decls for which we don't have a definition, the keys are
+  // names of external vars, the value is whether the def
   // has been seen before.
-  std::map<std::string, bool> ExternFunctions;
   std::map<std::string, bool> ExternGVars;
 
   // Maps for global/static functions, global variables

clang/lib/3C/ProgramInfo.cpp

@@ -323,17 +323,16 @@ bool ProgramInfo::link() {
     }
   }
 
-  // For every global function that is an unresolved external, constrain
-  // its parameter types to be wild. Unless it has a bounds-safe annotation.
-  for (const auto &U : ExternFunctions) {
+  // For every global function that is an unresolved external, constrain 
+  // its parameter types to be wild. Unless it has a bounds-safe annotation. 
+  for (const auto &U : ExternalFunctionFVCons) {
+    std::string FuncName = U.first;
+    FVConstraint *G = U.second;
     // If we've seen this symbol, but never seen a body for it, constrain
     // everything about it.
-    std::string FuncName = U.first;
-    if (!U.second && !isExternOkay(FuncName)) {
-      // Some global symbols we don't need to constrain to wild, like
-      // malloc and free. Check those here and skip if we find them.
-      FVConstraint *G = getExtFuncDefnConstraint(FuncName);
-      assert("Function constraints could not be found!" && G != nullptr);
+    // Some global symbols we don't need to constrain to wild, like
+    // malloc and free. Check those here and skip if we find them.
+    if (!G->hasBody() && !isExternOkay(FuncName)) {
 
       // If there was a checked type on a variable in the input program, it
       // should stay that way. Otherwise, we shouldn't be adding a checked type
@@ -348,14 +347,35 @@ bool ProgramInfo::link() {
           G->getParamVar(I)->constrainToWild(CS, Rsn);
     }
   }
+  // repeat for static functions
+  //
+  // Static functions that don't have a body will always cause a linking
+  // error during compilation. They may still be useful as code is developed,
+  // so we treat them as if they are external, and constrain parameters
+  // to wild as appropriate.
+  for (const auto &U :StaticFunctionFVCons) {
+    for (const auto &V :U.second) {
+
+      std::string FileName = U.first;
+      std::string FuncName = V.first;
+      FVConstraint *G = V.second;
+      if (!G->hasBody()) {
+
+        std::string Rsn =
+            "Unchecked pointer in parameter or return of static function " +
+            FuncName + " in " + FileName;
+        if (!G->getReturnVar()->getIsGeneric())
+          G->getReturnVar()->constrainToWild(CS, Rsn);
+        for (unsigned I = 0; I < G->numParams(); I++)
+          if (!G->getParamVar(I)->getIsGeneric())
+            G->getParamVar(I)->constrainToWild(CS, Rsn);
+      }
+    }
+  }
 
   return true;
 }
 
-bool ProgramInfo::isAnExternFunction(const std::string &FName) {
-  return !ExternFunctions[FName];
-}
-
 // Populate Variables, VarDeclToStatement, RVariables, and DepthMap with
 // AST data structures that correspond do the data stored in PDMap and
 // ReversePDMap.
@@ -463,13 +483,6 @@ bool ProgramInfo::insertNewFVConstraint(FunctionDecl *FD, FVConstraint *FVCon,
     // external method.
     Ret = insertIntoExternalFunctionMap(ExternalFunctionFVCons, FuncName, FVCon,
                                         FD, C);
-    bool IsDef = FVCon->hasBody();
-    if (IsDef) {
-      ExternFunctions[FuncName] = true;
-    } else {
-      if (!ExternFunctions[FuncName])
-        ExternFunctions[FuncName] = false;
-    }
   } else {
     // static method
     auto Psl = PersistentSourceLoc::mkPSL(FD, *C);

clang/test/3C/bodiless.c

@@ -0,0 +1,60 @@
+// RUN: 3c %s > %S/temp_bodiless.c
+// RUN: %clang -c %S/temp_bodiless.c
+// RUN: FileCheck -match-full-lines --input-file %S/temp_bodiless.c %s
+// RUN: rm %S/temp_bodiless.c
+
+/***********************************************/
+/* Tests that functions without bodies         */
+/* are marked wild when there is no interface  */
+/***********************************************/
+
+static int *foo1(void) { return (void *)0; }
+void test1() {
+  int *a = foo1();
+}
+//CHECK _Ptr<int> a = foo1();
+
+static int *foo2(void);
+void test2() {
+  int *a = foo2();
+}
+//CHECK int *a = foo2();
+
+int *foo3(void) { return (void *)0; }
+void test3() {
+  int *a = foo3();
+}
+//CHECK: _Ptr<int> a = foo3();
+
+int *foo4(void);
+void test4() {
+  int *a = foo4();
+}
+//CHECK: int *a = foo4();
+
+int *foo5(void) : itype(_Ptr<int>);
+void test5() {
+  int *a = foo5();
+}
+//CHECK: _Ptr<int> a = foo5();
+
+extern int *foo6(void);
+void test6() {
+  int *a = foo6();
+}
+//CHECK: int *a = foo6();
+
+extern int *foo7(void) : itype(_Ptr<int>);
+void test7() {
+  int *a = foo7();
+}
+//CHECK: _Ptr<int> a = foo7();
+
+
+// parameters are not defined and therefore unchecked
+extern int *foo8() : itype(_Ptr<int>);
+void test8() {
+  int *a = foo8();
+}
+//CHECK: int *a = foo8();
+