Fix for the issue: #3

Author: Machiry

tools/checked-c-convert/ConstraintVariables.cpp

@@ -16,15 +16,6 @@
 
 using namespace clang;
 
-// Helper method to print a Type in a way that can be represented in the source.
-static
-std::string
-tyToStr(const Type *T) {
-  QualType QT(T, 0);
-
-  return QT.getAsString();
-}
-
 PointerVariableConstraint::PointerVariableConstraint(DeclaratorDecl *D,
                                                      ConstraintKey &K, Constraints &CS, const ASTContext &C) :
         PointerVariableConstraint(D->getType(), K, D, D->getName(), CS, C) { }

tools/checked-c-convert/RewriteUtils.cpp

@@ -758,6 +758,83 @@ class DeclArrayVisitor : public clang::RecursiveASTVisitor<DeclArrayVisitor>
   ProgramInfo& Info;
 };
 
+// This class initializes all the structure variables that
+// contains at least one checked pointer?
+class StructVariableInitializer : public clang::RecursiveASTVisitor<StructVariableInitializer>
+{
+public:
+  explicit StructVariableInitializer(ASTContext *_C, ProgramInfo &_I, RSet &R)
+    : Context(_C), I(_I), RewriteThese(R)
+  {
+    RecordsWithCPointers.clear();
+  }
+
+  bool VariableNeedsInitializer(VarDecl *VD, DeclStmt *S) {
+    RecordDecl *RD = VD->getType().getTypePtr()->getAsRecordDecl();
+    if (RecordDecl *Definition = RD->getDefinition()) {
+      // see if we already know that this structure has a checked pointer.
+      if(RecordsWithCPointers.find(Definition) != RecordsWithCPointers.end()) {
+        return true;
+      }
+      for (const auto &D : Definition->fields()) {
+        if (D->getType()->isPointerType() || D->getType()->isArrayType()) {
+          std::set<ConstraintVariable *> fieldConsVars = I.getVariable(D, Context, false);
+          for (auto CV: fieldConsVars) {
+            PVConstraint *PV = dyn_cast<PVConstraint>(CV);
+            if (PV && PV->anyChanges(I.getConstraints().getVariables())) {
+              // ok this contains a pointer that is checked.
+              // store it.
+              RecordsWithCPointers.insert(Definition);
+              return true;
+            }
+          }
+        }
+      }
+    }
+    return false;
+  }
+
+  // check to see if this variable require an initialization.
+  bool VisitDeclStmt(DeclStmt *S) {
+
+    std::set<VarDecl*> allDecls;
+
+    if (S->isSingleDecl()) {
+      if (VarDecl *VD = dyn_cast<VarDecl>(S->getSingleDecl())) {
+        allDecls.insert(VD);
+      }
+    } else {
+      for (const auto &D : S->decls()) {
+        if (VarDecl *VD = dyn_cast<VarDecl>(D)) {
+          allDecls.insert(VD);
+        }
+      }
+    }
+
+    for(auto VD: allDecls) {
+      // check if this variable is a structure or union and doesn't have an initializer.
+      if(!VD->hasInit() && isStructOrUnionType(VD)) {
+        // check if the variable needs a initializer.
+        if(VariableNeedsInitializer(VD, S)) {
+          const clang::Type *Ty = VD->getType().getTypePtr();
+          std::string OriginalType = tyToStr(Ty);
+          // create replacement text with an initializer.
+          std::string toReplace = OriginalType + " " + VD->getName().str() + " = {}";
+          RewriteThese.insert(DAndReplace(VD, S, toReplace));
+        }
+      }
+    }
+
+    return true;
+  }
+private:
+  ASTContext*  Context;
+  ProgramInfo &I;
+  RSet &RewriteThese;
+  std::set<RecordDecl*> RecordsWithCPointers;
+
+};
+
 std::map<std::string, std::string> RewriteConsumer::ModifiedFuncSignatures;
 
 std::string RewriteConsumer::getModifiedFuncSignature(std::string funcName) {
@@ -799,8 +876,11 @@ void RewriteConsumer::HandleTranslationUnit(ASTContext &Context) {
   RSet skip(DComp(Context.getSourceManager()));
   MappingVisitor V(keys, Context);
   TranslationUnitDecl *TUD = Context.getTranslationUnitDecl();
-  for (const auto &D : TUD->decls())
+  StructVariableInitializer FV = StructVariableInitializer(&Context, Info, rewriteThese);
+  for (auto &D : TUD->decls()) {
     V.TraverseDecl(D);
+    FV.TraverseDecl(D);
+  }
 
   std::tie(PSLMap, VDLToStmtMap) = V.getResults();
 

tools/checked-c-convert/Utils.cpp

@@ -187,4 +187,13 @@ float getTimeSpentInSeconds(clock_t startTime) {
 
 bool isPointerType(clang::VarDecl *VD) {
   return VD->getType().getTypePtr()->isPointerType();
+}
+
+bool isStructOrUnionType(clang::VarDecl *VD) {
+  return VD->getType().getTypePtr()->isStructureType() || VD->getType().getTypePtr()->isUnionType();
+}
+
+std::string tyToStr(const Type *T) {
+  QualType QT(T, 0);
+  return QT.getAsString();
 }

tools/checked-c-convert/Utils.h

@@ -10,6 +10,7 @@
 #define _UTILS_H
 #include <set>
 #include "llvm/Support/CommandLine.h"
+#include "clang/AST/Type.h"
 
 #include "PersistentSourceLoc.h"
 
@@ -59,5 +60,12 @@ bool isFunctionAllocator(std::string funcName);
 // Is the given variable built  in type?
 bool isPointerType(clang::VarDecl *VD);
 
+// check if the variable is of a structure or union type.
+bool isStructOrUnionType(clang::VarDecl *VD);
+
+// Helper method to print a Type in a way that can be represented in the source.
+std::string tyToStr(const clang::Type *T);
+
+
 clang::SourceLocation getFunctionDeclarationEnd(clang::FunctionDecl *FD, clang::SourceManager &S);
 #endif

tools/checked-c-convert/functests/ntarr/basic_field_local.expected.c

@@ -20,7 +20,7 @@ typedef struct {
 } foo3;
 
 int main() {
-  foo obj;
+  foo obj = {};
   _Nt_array_ptr<char> bp = NULL;
   float b;
   foo2 obj2;

tools/checked-c-convert/functests/ptr/basic_field_local.expected.c

@@ -18,9 +18,9 @@ typedef struct {
   char d; 
 } foo3;
 int main() {
-  foo obj;
+  foo obj = {};
   float b;
-  foo2 obj2;
+  foo2 obj2 = {};
   obj2.b = &b;
   foo3 obj3;
   obj3.p = 0xcafebabe;