Insert itypes for parameters with typedef types (#690)

This allows a function using an otherwise unchecked typedef type to expose an
checked interface. It also lets a function use a typedef'ed parameter unsafely
without forcing the entire typedef to be unchecked.

In the following example, the typedef td is unchecked because of the unsafe use
of b. Prior to this change, test would not be rewritten, leaving it with a
fully unchecked type. The new rewriting is `void test(td a : itype(_Ptr<int>))`.

    typedef int *td;
    void test(td a) {
      td b = 1;
    }

In the other direction, the parameter can be used unsafely, but the typedef
will still be rewritten to `_Ptr<int>`, and the parameter will get an itype
`int * : itype(td)`.

    typedef int *td;
    void test(td a) {
      a = 1;
    }

Author: john-h-kastner

clang/include/clang/3C/ConstraintVariables.h

@@ -365,7 +365,7 @@ class PointerVariableConstraint : public ConstraintVariable {
   bool IsZeroWidthArray;
 
   bool IsTypedef = false;
-  TypedefNameDecl *TDT;
+  ConstraintVariable *TypedefVar;
   std::string TypedefString;
   // Does the type internally contain a typedef, and if so: at what level and
   // what is it's name?
@@ -381,7 +381,7 @@ class PointerVariableConstraint : public ConstraintVariable {
     ConstraintVariable(PointerVariable, "", Name), FV(nullptr),
     SrcHasItype(false), PartOfFuncPrototype(false), Parent(nullptr),
     SourceGenericIndex(-1), InferredGenericIndex(-1),
-    IsZeroWidthArray(false), IsTypedef(false), TDT(nullptr),
+    IsZeroWidthArray(false), IsTypedef(false),
     TypedefLevelInfo({}), IsVoidPtr(false) {}
 
 public:
@@ -392,8 +392,9 @@ class PointerVariableConstraint : public ConstraintVariable {
   // Check if any of the pointers is either a sized or unsized arr.
   bool hasSomeSizedArr() const;
 
-  bool isTypedef(void);
-  void setTypedef(TypedefNameDecl *T, std::string S);
+  bool isTypedef(void) const;
+  const ConstraintVariable *getTypedefVar() const;
+  void setTypedef(ConstraintVariable *TDVar, std::string S);
 
   // Return true if this constraint had an itype in the original source code.
   bool srcHasItype() const override { return SrcHasItype; }

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

@@ -162,8 +162,8 @@ class ProgramInfo : public ProgramVariableAdder {
   void ensureNtCorrect(const QualType &QT, const ASTContext &C,
                        PointerVariableConstraint *PV);
 
-  void unifyIfTypedef(const clang::Type *, clang::ASTContext &,
-                      clang::DeclaratorDecl *, PVConstraint *);
+  void unifyIfTypedef(const QualType &QT, clang::ASTContext &,
+                      PVConstraint *, ConsAction CA = Same_to_Same);
 
   CVarOption lookupTypedef(PersistentSourceLoc PSL);
 

clang/lib/3C/ConstraintVariables.cpp

@@ -130,7 +130,7 @@ PointerVariableConstraint::PointerVariableConstraint(
     SourceGenericIndex(Ot->SourceGenericIndex),
     InferredGenericIndex(Ot->InferredGenericIndex),
     IsZeroWidthArray(Ot->IsZeroWidthArray),
-    IsTypedef(Ot->IsTypedef), TDT(Ot->TDT), TypedefString(Ot->TypedefString),
+    IsTypedef(Ot->IsTypedef), TypedefString(Ot->TypedefString),
     TypedefLevelInfo(Ot->TypedefLevelInfo), IsVoidPtr(Ot->IsVoidPtr) {
   // These are fields of the super class Constraint Variable
   this->HasEqArgumentConstraints = Ot->HasEqArgumentConstraints;
@@ -206,8 +206,7 @@ PointerVariableConstraint::PointerVariableConstraint(
     const ASTContext &C, std::string *InFunc, int ForceGenericIndex,
     bool PotentialGeneric,
     bool VarAtomForChecked, TypeSourceInfo *TSInfo, const QualType &ITypeT)
-    : ConstraintVariable(ConstraintVariable::PointerVariable,
-                         tyToStr(QT.getTypePtr()), N),
+    : ConstraintVariable(ConstraintVariable::PointerVariable, qtyToStr(QT), N),
       FV(nullptr), SrcHasItype(false), PartOfFuncPrototype(InFunc != nullptr),
       Parent(nullptr) {
   QualType QTy = QT;
@@ -704,14 +703,20 @@ void PointerVariableConstraint::addArrayAnnotations(
   assert(ConstArrs.empty());
 }
 
-bool PointerVariableConstraint::isTypedef(void) { return IsTypedef; }
+bool PointerVariableConstraint::isTypedef(void) const { return IsTypedef; }
 
-void PointerVariableConstraint::setTypedef(TypedefNameDecl *T, std::string S) {
+void PointerVariableConstraint::setTypedef(ConstraintVariable *TDVar,
+                                           std::string S) {
   IsTypedef = true;
-  TDT = T;
+  TypedefVar = TDVar;
   TypedefString = S;
 }
 
+const ConstraintVariable *PointerVariableConstraint::getTypedefVar() const {
+  assert(isTypedef());
+  return TypedefVar;
+}
+
 // Mesh resolved constraints with the PointerVariableConstraints set of
 // variables and potentially nested function pointer declaration. Produces a
 // string that can be replaced in the source code.
@@ -736,8 +741,12 @@ PointerVariableConstraint::mkString(Constraints &CS,
     UseName = getName();
 
   if (IsTypedef && !UnmaskTypedef) {
-    return gatherQualStrings() + TypedefString +
-           (EmitName && !IsReturn ? (" " + UseName) : " ");
+    std::string QualTypedef = gatherQualStrings() + TypedefString;
+    if (!ForItype)
+      QualTypedef += " ";
+    if (EmitName && !IsReturn)
+      QualTypedef += UseName;
+    return QualTypedef;
   }
 
   std::ostringstream Ss;

clang/lib/3C/DeclRewriter.cpp

@@ -35,17 +35,33 @@ using namespace clang;
 void DeclRewriter::buildItypeDecl(PVConstraint *Defn, DeclaratorDecl *Decl,
                                   std::string &Type, std::string &IType,
                                   ProgramInfo &Info, ArrayBoundsRewriter &ABR) {
+  const EnvironmentMap &Env = Info.getConstraints().getVariables();
+  bool IsTypedefVarUnchecked =
+    Defn->isTypedef() && (ItypesForExtern ||
+                          !Defn->getTypedefVar()->isSolutionChecked(Env));
   if (Defn->getFV()) {
     // This declaration is for a function pointer. Writing itypes on function
     // pointers is a little bit harder since the original type string will not
     // work for the unchecked portion of the itype. We need to generate the
     // unchecked type from the PVConstraint. The last argument of this call
     // tells mkString to generate a string using unchecked types instead of
     // checked types.
-    Type = Defn->mkString(Info.getConstraints(),
-                          MKSTRING_OPTS(ForItypeBase = true));
+    if (Defn->isTypedef() && !IsTypedefVarUnchecked)
+      Type = Defn->mkString(Info.getConstraints(),
+                            MKSTRING_OPTS(UnmaskTypedef = true,
+                                          ForItypeBase = true));
+    else
+      Type = Defn->mkString(Info.getConstraints(),
+                            MKSTRING_OPTS(ForItypeBase = true));
   } else {
-    Type = Defn->getRewritableOriginalTy();
+    if (Defn->isTypedef() && !IsTypedefVarUnchecked)
+      Type = Defn->mkString(Info.getConstraints(),
+                            MKSTRING_OPTS(UnmaskTypedef = true,
+                                          ForItypeBase = true,
+                                          EmitName = false));
+    else
+      Type = Defn->getRewritableOriginalTy();
+
     if (isa_and_nonnull<ParmVarDecl>(Decl)) {
       if (Decl->getName().empty())
         Type += Defn->getName();
@@ -59,7 +75,8 @@ void DeclRewriter::buildItypeDecl(PVConstraint *Defn, DeclaratorDecl *Decl,
   }
 
   IType = " : itype(";
-  if (ItypesForExtern && Defn->isTypedef()) {
+
+  if (IsTypedefVarUnchecked) {
     // In -itypes-for-extern mode we do not rewrite typedefs to checked types.
     // They are given a checked itype instead. The unchecked portion of the
     // itype continues to use the original typedef, but the typedef in the

clang/lib/3C/ProgramInfo.cpp

@@ -640,22 +640,22 @@ void ProgramInfo::addVariable(clang::DeclaratorDecl *D,
     NewCV = F;
 
     auto RetTy = FD->getReturnType();
-    unifyIfTypedef(RetTy.getTypePtr(), *AstContext, FD, F->getExternalReturn());
-    unifyIfTypedef(RetTy.getTypePtr(), *AstContext, FD, F->getInternalReturn());
+    unifyIfTypedef(RetTy, *AstContext, F->getExternalReturn(), Wild_to_Safe);
+    unifyIfTypedef(RetTy, *AstContext, F->getInternalReturn(), Safe_to_Wild);
     ensureNtCorrect(RetTy, *AstContext, F->getExternalReturn());
     ensureNtCorrect(RetTy, *AstContext, F->getInternalReturn());
 
     // Add mappings from the parameters PLoc to the constraint variables for
     // the parameters.
     for (unsigned I = 0; I < FD->getNumParams(); I++) {
       ParmVarDecl *PVD = FD->getParamDecl(I);
-      const Type *Ty = PVD->getType().getTypePtr();
+      QualType ParamTy = PVD->getType();
       PVConstraint *PVInternal = F->getInternalParam(I);
       PVConstraint *PVExternal = F->getExternalParam(I);
-      unifyIfTypedef(Ty, *AstContext, PVD, PVInternal);
-      unifyIfTypedef(Ty, *AstContext, PVD, PVExternal);
-      ensureNtCorrect(PVD->getType(), *AstContext, PVInternal);
-      ensureNtCorrect(PVD->getType(), *AstContext, PVExternal);
+      unifyIfTypedef(ParamTy, *AstContext, PVExternal, Wild_to_Safe);
+      unifyIfTypedef(ParamTy, *AstContext, PVInternal, Safe_to_Wild);
+      ensureNtCorrect(ParamTy, *AstContext, PVInternal);
+      ensureNtCorrect(ParamTy, *AstContext, PVExternal);
       PVInternal->setValidDecl();
       PersistentSourceLoc PSL = PersistentSourceLoc::mkPSL(PVD, *AstContext);
       // Constraint variable is stored on the parent function, so we need to
@@ -675,13 +675,13 @@ void ProgramInfo::addVariable(clang::DeclaratorDecl *D,
 
   } else if (VarDecl *VD = dyn_cast<VarDecl>(D)) {
     assert(!isa<ParmVarDecl>(VD));
-    const Type *Ty = VD->getTypeSourceInfo()->getTypeLoc().getTypePtr();
-    if (Ty->isPointerType() || Ty->isArrayType()) {
+    QualType QT = VD->getTypeSourceInfo()->getTypeLoc().getType();
+    if (QT->isPointerType() || QT->isArrayType()) {
       PVConstraint *P = new PVConstraint(D, *this, *AstContext);
       P->setValidDecl();
       NewCV = P;
       std::string VarName(VD->getName());
-      unifyIfTypedef(Ty, *AstContext, VD, P);
+      unifyIfTypedef(QT, *AstContext, P);
       ensureNtCorrect(VD->getType(), *AstContext, P);
       if (VD->hasGlobalStorage()) {
         // If we see a definition for this global variable, indicate so in
@@ -699,10 +699,10 @@ void ProgramInfo::addVariable(clang::DeclaratorDecl *D,
     }
 
   } else if (FieldDecl *FlD = dyn_cast<FieldDecl>(D)) {
-    const Type *Ty = FlD->getTypeSourceInfo()->getTypeLoc().getTypePtr();
-    if (Ty->isPointerType() || Ty->isArrayType()) {
+    QualType QT = FlD->getTypeSourceInfo()->getTypeLoc().getType();
+    if (QT->isPointerType() || QT->isArrayType()) {
       PVConstraint *P = new PVConstraint(D, *this, *AstContext);
-      unifyIfTypedef(Ty, *AstContext, FlD, P);
+      unifyIfTypedef(QT, *AstContext, P);
       NewCV = P;
       NewCV->setValidDecl();
     }
@@ -725,16 +725,16 @@ void ProgramInfo::ensureNtCorrect(const QualType &QT, const ASTContext &C,
   }
 }
 
-void ProgramInfo::unifyIfTypedef(const Type *Ty, ASTContext &Context,
-                                 DeclaratorDecl *Decl, PVConstraint *P) {
-  if (const auto *TDT = dyn_cast<TypedefType>(Ty)) {
+void ProgramInfo::unifyIfTypedef(const QualType &QT, ASTContext &Context,
+                                 PVConstraint *P, ConsAction CA) {
+  if (const auto *TDT = dyn_cast<TypedefType>(QT.getTypePtr())) {
     auto *TDecl = TDT->getDecl();
     auto PSL = PersistentSourceLoc::mkPSL(TDecl, Context);
     auto O = lookupTypedef(PSL);
     if (O.hasValue()) {
       auto *Bounds = &O.getValue();
-      P->setTypedef(TDecl, TDecl->getNameAsString());
-      constrainConsVarGeq(P, Bounds, CS, &PSL, Same_to_Same, true, this);
+      P->setTypedef(Bounds, TDecl->getNameAsString());
+      constrainConsVarGeq(P, Bounds, CS, &PSL, CA, false, this);
     }
   }
 }

clang/test/3C/basic_checks.c

@@ -38,7 +38,7 @@ void mut_pa(PA p) {
   p->a = 0;
   p->b = 1;
 }
-//CHECK: void mut_pa(PA p) {
+//CHECK: void mut_pa(PA p : itype(_Ptr<struct _A>)) {
 
 void pa_driver(void) {
   A a = {0};

clang/test/3C/itype_typedef.c

@@ -0,0 +1,120 @@
+// RUN: rm -rf %t*
+// RUN: 3c -base-dir=%S -alltypes -addcr %s -- | FileCheck -match-full-lines -check-prefixes="CHECK_ALL","CHECK" %s
+// RUN: 3c -base-dir=%S -addcr %s -- | FileCheck -match-full-lines -check-prefixes="CHECK_NOALL","CHECK" %s
+// RUN: 3c -base-dir=%S -addcr %s -- | %clang -c -fcheckedc-extension -x c -o /dev/null -
+// RUN: 3c -base-dir=%S -alltypes -output-dir=%t.checked %s --
+// RUN: 3c -base-dir=%t.checked -alltypes %t.checked/itype_typedef.c -- | diff %t.checked/itype_typedef.c -
+
+// Itype typedef on the paramter
+
+typedef int *td0;
+void test0(td0 a) {
+//CHECK: typedef _Ptr<int> td0;
+//CHECK: void test0(int *a : itype(td0)) {
+  a = 1;
+}
+
+typedef int *td1;
+void test1(td1 a) {
+//CHECK: typedef int *td1;
+//CHECK: void test1(td1 a : itype(_Ptr<int>)) {
+  td1 b = a;
+  b = 1;
+}
+
+typedef int *td2;
+void test2(td2 a) {
+//CHECK: typedef int *td2;
+//CHECK: void test2(td2 a : itype(_Ptr<int>)) {
+  td2 b = 1;
+}
+
+// Itype typedef on the return
+
+typedef int *td3;
+td3 test3() {
+//CHECK: typedef _Ptr<int> td3;
+//CHECK: int * test3(void) : itype(td3) {
+  return (int*) 1;
+}
+
+typedef int *td4;
+td4 test4() {
+//CHECK: typedef int *td4;
+//CHECK: td4 test4(void) : itype(_Ptr<int>) {
+  td4 a = 1;
+  return a;
+}
+
+// Itype typedef with array bounds
+
+typedef int *td5;
+void test5(td5 a, int n) {
+//CHECK: typedef int *td5;
+//CHECK_ALL: void test5(td5 a : itype(_Array_ptr<int>) count(n), int n) {
+//CHECK_NOALL: void test5(td5 a : itype(_Ptr<int>), int n) {
+  for (int i = 0; i < n; i++)
+    a[i];
+  td5 b = 1;
+}
+
+typedef int *td6;
+void test6(td6 a, int n) {
+//CHECK_ALL: typedef _Array_ptr<int> td6;
+//CHECK_ALL: void test6(int *a : itype(td6) count(n), int n) {
+//CHECK_NOALL: typedef _Ptr<int> td6;
+//CHECK_NOALL: void test6(int *a : itype(td6), int n) {
+  for (int i = 0; i < n; i++)
+    a[i];
+  a = 1;
+}
+
+// Itype typedef with type qualifiers
+
+typedef int *td7;
+void test7(const td7 a) {
+//CHECK: typedef _Ptr<int> td7;
+//CHECK: void test7(int *const a : itype(const td7)) {
+  int *b = a;
+  b = 1;
+}
+
+typedef int *td8;
+void test8(const td8 a) {
+//CHECK: typedef int *td8;
+//CHECK: void test8(const td8 a : itype(const _Ptr<int>)) {
+  td8 b = a;
+  b = 1;
+}
+
+typedef const int *td9;
+void test9(td9 a) {
+//CHECK: typedef _Ptr<const int> td9;
+//CHECK: void test9(const int *a : itype(td9)) {
+  int *b = a;
+  b = 1;
+}
+
+typedef const int *td10;
+void test10(td10 a) {
+//CHECK: typedef const int *td10;
+//CHECK: void test10(td10 a : itype(_Ptr<const int>)) {
+  td10 b = a;
+  b = 1;
+}
+
+// With functions pointers
+
+typedef int (*fp_td0)(int);
+void fp_test0(fp_td0 a) {
+//CHECK: typedef _Ptr<int (int)> fp_td0;
+//CHECK: void fp_test0(int ((*a)(int)) : itype(fp_td0)) {
+  a = 1;
+}
+
+typedef int (*fp_td1)(int);
+void fp_test1(fp_td1 a) {
+//CHECK: typedef int (*fp_td1)(int);
+//CHECK: void fp_test1(fp_td1 a : itype(_Ptr<int (int)>)) {
+  fp_td1 b = 1;
+}