Refactor to include generic types info in VCs (#372)

kyleheadley · web-flow · commit 7162656e5ca9 · 2021-01-12T16:26:45.000-05:00
* upgrade IsGeneric to GenericIndex

* don't deref null

* refactor to use cached indexes

* allow get constraint from decl

* add generic indexes to constructed PVCs

* force generic indexes earlier

* merge GenericIndex

* set typeparam count in fvcs
diff --git a/clang/include/clang/3C/ConstraintVariables.h b/clang/include/clang/3C/ConstraintVariables.h
@@ -268,11 +268,11 @@ class PointerVariableConstraint : public ConstraintVariable {
   // String representing declared bounds expression.
   std::string BoundsAnnotationStr;
 
-  // Does this variable represent a generic type?
+  // Does this variable represent a generic type? Which one (or -1 for none)?
   // Generic types can be used with fewer restrictions, so this field is used
-  // stop assignments wth generic variables from forcing constraint variables
+  // stop assignments with generic variables from forcing constraint variables
   // to be wild.
-  bool IsGeneric;
+  int GenericIndex;
 
   // Empty array pointers are represented the same as standard pointers. This
   // lets pointers be passed to functions expecting a zero width array. This
@@ -296,11 +296,11 @@ class PointerVariableConstraint : public ConstraintVariable {
   // Constructor for when we know a CVars and a type string.
   PointerVariableConstraint(CAtoms V, std::string T, std::string Name,
                             FunctionVariableConstraint *F, bool IsArr,
-                            bool IsItype, std::string Is, bool Generic = false)
+                            bool IsItype, std::string Is, int Generic = -1)
       : ConstraintVariable(PointerVariable, "" /*not used*/, Name), BaseType(T),
         Vars(V), FV(F), ArrPresent(IsArr), ItypeStr(Is),
         PartOfFuncPrototype(false), Parent(nullptr), BoundsAnnotationStr(""),
-        IsGeneric(Generic), IsZeroWidthArray(false) {}
+        GenericIndex(Generic), IsZeroWidthArray(false) {}
 
   std::string getTy() const { return BaseType; }
   bool getArrPresent() const { return ArrPresent; }
@@ -321,7 +321,8 @@ class PointerVariableConstraint : public ConstraintVariable {
   // Get bounds annotation.
   std::string getBoundsStr() const { return BoundsAnnotationStr; }
 
-  bool getIsGeneric() const { return IsGeneric; }
+  bool getIsGeneric() const { return GenericIndex >= 0; }
+  int getGenericIndex() const { return GenericIndex; }
 
   bool getIsOriginallyChecked() const override {
     return llvm::any_of(Vars, [](Atom *A) { return isa<ConstAtom>(A); });
@@ -348,14 +349,14 @@ class PointerVariableConstraint : public ConstraintVariable {
   //          that all constructor calls will take the same global objects here.
   // inFunc: If this variable is part of a function prototype, this string is
   //         the name of the function. nullptr otherwise.
-  // IsGeneric: CheckedC supports generic types (_Itype_for_any) which need less
-  //            restrictive constraints. Set to true to indicate that this
-  //            variable is generic.
+  // ForceGenericIndex: CheckedC supports generic types (_Itype_for_any) which
+  //                    need less restrictive constraints. Set >= 0 to indicate
+  //                    that this variable should be considered generic.
   PointerVariableConstraint(const clang::QualType &QT, clang::DeclaratorDecl *D,
                             std::string N, ProgramInfo &I,
                             const clang::ASTContext &C,
                             std::string *InFunc = nullptr,
-                            bool IsGeneric = false);
+                            int ForceGenericIndex = -1);
 
   const CAtoms &getCvars() const { return Vars; }
 
@@ -437,6 +438,9 @@ class FunctionVariableConstraint : public ConstraintVariable {
   // Flag to indicate whether this is a function pointer or not.
   bool IsFunctionPtr;
 
+  // Count of type parameters from `_Itype_for_any(...)`
+  int TypeParams;
+
   void equateFVConstraintVars(ConstraintVariable *CV, ProgramInfo &Info) const;
 
 public:
@@ -479,6 +483,9 @@ class FunctionVariableConstraint : public ConstraintVariable {
   }
 
   bool hasItype() const override;
+
+  int getGenericIndex() const { return ReturnVar->getGenericIndex(); }
+
   bool solutionEqualTo(Constraints &CS,
                        const ConstraintVariable *CV) const override;
 
diff --git a/clang/include/clang/3C/TypeVariableAnalysis.h b/clang/include/clang/3C/TypeVariableAnalysis.h
@@ -93,7 +93,6 @@ class TypeVarVisitor : public RecursiveASTVisitor<TypeVarVisitor>,
   ConstraintResolver CR;
   TypeVariableMapT TVMap;
 
-  void insertBinding(CallExpr *CE, const TypeVariableType *TyV, QualType Ty,
-                     CVarSet &CVs);
+  void insertBinding(CallExpr *CE, const int TyIdx, QualType Ty, CVarSet &CVs);
 };
 #endif
diff --git a/clang/include/clang/3C/Utils.h b/clang/include/clang/3C/Utils.h
@@ -164,8 +164,6 @@ std::string getSourceText(const clang::SourceRange &SR,
 unsigned longestCommonSubsequence(const char *Str1, const char *Str2,
                                   unsigned long Str1Len, unsigned long Str2Len);
 
-const clang::TypeVariableType *getTypeVariableType(clang::DeclaratorDecl *Decl);
-
 bool isTypeAnonymous(const clang::Type *T);
 
 // Find the index of parameter PV in the parameter list of function FD.
diff --git a/clang/lib/3C/CastPlacement.cpp b/clang/lib/3C/CastPlacement.cpp
@@ -35,15 +35,14 @@ bool CastPlacementVisitor::VisitCallExpr(CallExpr *CE) {
         TypeVars = Info.getTypeParamBindings(CE, Context);
       unsigned PIdx = 0;
       for (const auto &A : CE->arguments()) {
-        if (PIdx < FD->getNumParams()) {
+        if (PIdx < FV->numParams()) {
           // Avoid adding incorrect casts to generic function arguments by
           // removing implicit casts when on arguments with a consistently
           // used generic type.
           Expr *ArgExpr = A;
-          const TypeVariableType *TyVar =
-              getTypeVariableType(FD->getParamDecl(PIdx));
-          if (TyVar && TypeVars.find(TyVar->GetIndex()) != TypeVars.end() &&
-              TypeVars[TyVar->GetIndex()] != nullptr)
+          const int TyVarIdx = FV->getParamVar(PIdx)->getGenericIndex();
+          if (TypeVars.find(TyVarIdx) != TypeVars.end() &&
+              TypeVars[TyVarIdx] != nullptr)
             ArgExpr = ArgExpr->IgnoreImpCasts();
 
           CVarSet ArgumentConstraints = CR.getExprConstraintVars(ArgExpr);
diff --git a/clang/lib/3C/ConstraintBuilder.cpp b/clang/lib/3C/ConstraintBuilder.cpp
@@ -266,12 +266,11 @@ class FunctionVisitor : public RecursiveASTVisitor<FunctionVisitor> {
           std::vector<CVarSet> Deferred;
           for (const auto &A : E->arguments()) {
             CVarSet ArgumentConstraints;
-            if (TFD != nullptr && I < TFD->getNumParams()) {
+            if (I < TargetFV->numParams()) {
               // Remove casts to void* on polymorphic types that are used
               // consistently.
-              const auto *Ty = getTypeVariableType(TFD->getParamDecl(I));
-              if (Ty != nullptr && ConsistentTypeParams.find(Ty->GetIndex()) !=
-                                       ConsistentTypeParams.end())
+              const int TyIdx = TargetFV->getParamVar(I)->getGenericIndex();
+              if (ConsistentTypeParams.find(TyIdx) != ConsistentTypeParams.end())
                 ArgumentConstraints =
                     CB.getExprConstraintVars(A->IgnoreImpCasts());
               else
diff --git a/clang/lib/3C/ConstraintResolver.cpp b/clang/lib/3C/ConstraintResolver.cpp
@@ -448,7 +448,7 @@ CVarSet ConstraintResolver::getExprConstraintVars(Expr *E) {
               N = "&" + N;
               ExprType = Context->getPointerType(ArgTy);
               PVConstraint *PVC = new PVConstraint(ExprType, nullptr, N, Info,
-                                                   *Context, nullptr, true);
+                                                   *Context, nullptr, 0);
               PVC->constrainOuterTo(CS, A, true);
               ReturnCVs.insert(PVC);
               DidInsert = true;
@@ -504,9 +504,10 @@ CVarSet ConstraintResolver::getExprConstraintVars(Expr *E) {
             // had a checked type in the input program because the constraint
             // variables contain constant atoms that are reused by the copy
             // constructor.
-            NewCV =
+            auto *NewPCV =
                 new PVConstraint(CE->getType(), nullptr, PCV->getName(), Info,
-                                 *Context, nullptr, PCV->getIsGeneric());
+                                 *Context, nullptr, PCV->getGenericIndex());
+            NewCV = NewPCV;
             if (PCV->hasBoundsKey())
               NewCV->setBoundsKey(PCV->getBoundsKey());
           } else {
diff --git a/clang/lib/3C/ConstraintVariables.cpp b/clang/lib/3C/ConstraintVariables.cpp
@@ -107,7 +107,7 @@ PointerVariableConstraint::PointerVariableConstraint(
     this->FV = dyn_cast<FVConstraint>(Ot->FV->getCopy(CS));
   }
   this->Parent = Ot;
-  this->IsGeneric = Ot->IsGeneric;
+  this->GenericIndex = Ot->GenericIndex;
   this->IsZeroWidthArray = Ot->IsZeroWidthArray;
   // We need not initialize other members.
 }
@@ -169,11 +169,10 @@ class TypedefLevelFinder : public RecursiveASTVisitor<TypedefLevelFinder> {
 
 PointerVariableConstraint::PointerVariableConstraint(
     const QualType &QT, DeclaratorDecl *D, std::string N, ProgramInfo &I,
-    const ASTContext &C, std::string *InFunc, bool Generic)
+    const ASTContext &C, std::string *InFunc, int ForceGenericIndex)
     : ConstraintVariable(ConstraintVariable::PointerVariable,
                          tyToStr(QT.getTypePtr()), N),
-      FV(nullptr), PartOfFuncPrototype(InFunc != nullptr), Parent(nullptr),
-      IsGeneric(Generic) {
+      FV(nullptr), PartOfFuncPrototype(InFunc != nullptr), Parent(nullptr) {
   QualType QTy = QT;
   const Type *Ty = QTy.getTypePtr();
   auto &CS = I.getConstraints();
@@ -252,11 +251,28 @@ PointerVariableConstraint::PointerVariableConstraint(
     }
   }
 
-  // At this point `QTy` holds the computed type (and `QT` still holds the
+  // At this point `QTy`/`Ty` hold the computed type (and `QT` still holds the
   // input type). It will be consumed to create atoms, so any code that needs
   // to be coordinated with the atoms should access it here first.
+
   typedeflevelinfo = TypedefLevelFinder::find(QTy);
 
+  if (ForceGenericIndex >= 0) {
+    GenericIndex = ForceGenericIndex;
+  } else {
+    GenericIndex = -1;
+    // This makes a lot of assumptions about how the AST will look, and limits
+    // it to one level.
+    // TODO: Enhance TypedefLevelFinder to get this info
+    if (Ty->isPointerType()) {
+      auto *PtrTy = Ty->getPointeeType().getTypePtr();
+      if (auto *TypdefTy = dyn_cast_or_null<TypedefType>(PtrTy)) {
+        const auto *Tv = dyn_cast<TypeVariableType>(TypdefTy->desugar());
+        if (Tv) GenericIndex = Tv->GetIndex();
+      }
+    }
+  }
+
   bool VarCreated = false;
   bool IsArr = false;
   bool IsIncompleteArr = false;
@@ -407,7 +423,7 @@ PointerVariableConstraint::PointerVariableConstraint(
   // Get a string representing the type without pointer and array indirection.
   BaseType = extractBaseType(D, QT, Ty, C);
 
-  bool IsWild = !IsGeneric && (isVarArgType(BaseType) || isTypeHasVoid(QT));
+  bool IsWild = !getIsGeneric() && (isVarArgType(BaseType) || isTypeHasVoid(QT));
   if (IsWild) {
     std::string Rsn =
         isTypeHasVoid(QT) ? "Default void* type" : "Default Var arg list type";
@@ -879,6 +895,7 @@ FunctionVariableConstraint::FunctionVariableConstraint(const Type *Ty,
   FileName = "";
   HasEqArgumentConstraints = false;
   IsFunctionPtr = true;
+  TypeParams = 0;
 
   // Metadata about function
   FunctionDecl *FD = nullptr;
@@ -925,10 +942,11 @@ FunctionVariableConstraint::FunctionVariableConstraint(const Type *Ty,
           PName = PVD->getName();
         }
       }
-      bool IsGeneric =
-          ParmVD != nullptr && getTypeVariableType(ParmVD) != nullptr;
-      ParamVars.push_back(
-          new PVConstraint(QT, ParmVD, PName, I, Ctx, &N, IsGeneric));
+      auto *ParamVar = new PVConstraint(QT, ParmVD, PName, I, Ctx, &N);
+      int GenericIdx = ParamVar->getGenericIndex();
+      if (GenericIdx >= 0)
+        TypeParams = std::max(TypeParams, GenericIdx + 1);
+      ParamVars.push_back(ParamVar);
     }
 
     Hasproto = true;
@@ -941,8 +959,11 @@ FunctionVariableConstraint::FunctionVariableConstraint(const Type *Ty,
   }
 
   // ConstraintVariable for the return
-  bool IsGeneric = FD != nullptr && getTypeVariableType(FD) != nullptr;
-  ReturnVar = new PVConstraint(RT, D, RETVAR, I, Ctx, &N, IsGeneric);
+  auto *ReturnVC = new PVConstraint(RT, D, RETVAR, I, Ctx, &N);
+  int GenericIdx = ReturnVC->getGenericIndex();
+  if (GenericIdx >= 0)
+    TypeParams = std::max(TypeParams, GenericIdx + 1);
+  ReturnVar = ReturnVC;
 }
 
 void FunctionVariableConstraint::constrainToWild(Constraints &CS,
@@ -1214,7 +1235,7 @@ bool PointerVariableConstraint::solutionEqualTo(
   if (CV != nullptr) {
     if (const auto *PV = dyn_cast<PVConstraint>(CV)) {
       auto &OthCVars = PV->Vars;
-      if (IsGeneric || PV->IsGeneric || Vars.size() == OthCVars.size()) {
+      if (getIsGeneric() || PV->getIsGeneric() || Vars.size() == OthCVars.size()) {
         Ret = true;
 
         auto I = Vars.begin();
@@ -1683,6 +1704,8 @@ void PointerVariableConstraint::mergeDeclaration(ConstraintVariable *FromCV,
   Vars = NewVatoms;
   if (!From->ItypeStr.empty())
     ItypeStr = From->ItypeStr;
+  if (From->GenericIndex >= 0)
+    GenericIndex = From->GenericIndex;
   if (FV) {
     assert(From->FV);
     FV->mergeDeclaration(From->FV, Info, ReasonFailed);
@@ -1694,7 +1717,7 @@ Atom *PointerVariableConstraint::getAtom(unsigned AtomIdx, Constraints &CS) {
     // If index is in bounds, just return the atom.
     return Vars[AtomIdx];
   }
-  if (IsGeneric && AtomIdx == Vars.size()) {
+  if (getIsGeneric() && AtomIdx == Vars.size()) {
     // Polymorphic types don't know how "deep" their pointers are beforehand so,
     // we need to create new atoms for new pointer levels on the fly.
     std::string Stars(Vars.size(), '*');
diff --git a/clang/lib/3C/ProgramInfo.cpp b/clang/lib/3C/ProgramInfo.cpp
@@ -496,21 +496,25 @@ bool ProgramInfo::insertNewFVConstraint(FunctionDecl *FD, FVConstraint *FVCon,
 void ProgramInfo::specialCaseVarIntros(ValueDecl *D, ASTContext *Context) {
   // Special-case for va_list, constrain to wild.
   bool IsGeneric = false;
-  if (auto *PVD = dyn_cast<ParmVarDecl>(D))
-    IsGeneric = getTypeVariableType(PVD) != nullptr;
+  PVConstraint *PVC = nullptr;
+
+  CVarOption CVOpt = getVariable(D, Context);
+  if (CVOpt.hasValue()) {
+    ConstraintVariable &CV = CVOpt.getValue();
+    PVC = dyn_cast<PVConstraint>(&CV);
+  }
+
+  if (isa<ParmVarDecl>(D))
+    IsGeneric = PVC && PVC->getIsGeneric();
   if (isVarArgType(D->getType().getAsString()) ||
       (hasVoidType(D) && !IsGeneric)) {
     // set the reason for making this variable WILD.
     std::string Rsn = "Variable type void.";
     PersistentSourceLoc PL = PersistentSourceLoc::mkPSL(D, *Context);
     if (!D->getType()->isVoidType())
       Rsn = "Variable type is va_list.";
-    CVarOption CVOpt = getVariable(D, Context);
-    if (CVOpt.hasValue()) {
-      ConstraintVariable &CV = CVOpt.getValue();
-      if (PVConstraint *PVC = dyn_cast<PVConstraint>(&CV))
-        PVC->constrainToWild(CS, Rsn, &PL);
-    }
+    if (PVC != nullptr)
+      PVC->constrainToWild(CS, Rsn, &PL);
   }
 }
 
diff --git a/clang/lib/3C/TypeVariableAnalysis.cpp b/clang/lib/3C/TypeVariableAnalysis.cpp
diff --git a/clang/lib/3C/Utils.cpp b/clang/lib/3C/Utils.cpp
