Patch implements passing arrays to functions expecting

vla. Implements pr7827.

git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@114737 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/include/clang/AST/ASTContext.h b/include/clang/AST/ASTContext.h
index b1369a47572dfe8132f84433bf9e289b27661af6..cd6bd09d32f60f95797a213894cade13eb34dab6 100644 (file)
--- a/include/clang/AST/ASTContext.h
+++ b/include/clang/AST/ASTContext.h
@@ -568,6 +568,14 @@ public:
   QualType getConstantArrayType(QualType EltTy, const llvm::APInt &ArySize,
                                 ArrayType::ArraySizeModifier ASM,
                                 unsigned EltTypeQuals);
+  
+  /// getUnknownSizeVariableArrayType - Return a variable array type with
+  /// all variable indices replaced with unknow [*] size.
+  QualType getUnknownSizeVariableArrayType(QualType Ty);
+  
+  /// getVariableArrayDecayedType - Returns a vla type where known sizes
+  /// are replaced with [*]
+  QualType getVariableArrayDecayedType(QualType Ty);
 
   /// getVectorType - Return the unique reference to a vector type of
   /// the specified element type and size. VectorType must be a built-in type.

diff --git a/include/clang/AST/Type.h b/include/clang/AST/Type.h
index 92e62a58d42ce6696b83ebb8c3b5ea0319273f3b..9b32836a1602fc0c94357d9122016861a1e15f5c 100644 (file)
--- a/include/clang/AST/Type.h
+++ b/include/clang/AST/Type.h
@@ -3281,7 +3281,17 @@ inline bool QualType::isCanonical() const {
 
 inline bool QualType::isCanonicalAsParam() const {
   if (hasLocalQualifiers()) return false;
+  
   const Type *T = getTypePtr();
+  if ((*this)->isPointerType()) {
+    QualType BaseType = (*this)->getAs<PointerType>()->getPointeeType();
+    if (isa<VariableArrayType>(BaseType)) {
+      ArrayType *AT = dyn_cast<ArrayType>(BaseType);
+      VariableArrayType *VAT = cast<VariableArrayType>(AT);
+      if (VAT->getSizeExpr())
+        T = BaseType.getTypePtr();
+    }
+  }
   return T->isCanonicalUnqualified() &&
            !isa<FunctionType>(T) && !isa<ArrayType>(T);
 }

diff --git a/include/clang/Sema/Initialization.h b/include/clang/Sema/Initialization.h
index 2ba6cdfd5646024002b39487f1a56f7ab48a44b5..e0f518bef89e3474b4207bb4a37ff4829e8293c1 100644 (file)
--- a/include/clang/Sema/Initialization.h
+++ b/include/clang/Sema/Initialization.h
@@ -152,16 +152,20 @@ public:
   }
   
   /// \brief Create the initialization entity for a parameter.
-  static InitializedEntity InitializeParameter(ParmVarDecl *Parm) {
-    return InitializedEntity(Parm);
+  static InitializedEntity InitializeParameter(ASTContext &Context,
+                                               ParmVarDecl *Parm) {
+    InitializedEntity Res(Parm);
+    Res.Type = Context.getVariableArrayDecayedType(Res.Type);
+    return Res;
   }
 
   /// \brief Create the initialization entity for a parameter that is
   /// only known by its type.
-  static InitializedEntity InitializeParameter(QualType Type) {
+  static InitializedEntity InitializeParameter(ASTContext &Context,
+                                               QualType Type) {
     InitializedEntity Entity;
     Entity.Kind = EK_Parameter;
-    Entity.Type = Type;
+    Entity.Type = Context.getVariableArrayDecayedType(Type);
     Entity.Parent = 0;
     Entity.VariableOrMember = 0;
     return Entity;

diff --git a/lib/AST/ASTContext.cpp b/lib/AST/ASTContext.cpp
index 4b4c56502b2c652d6ec812a815536ad746c5aba0..fdeac1ebf87b3cea9cefa705442979dd8694a622 100644 (file)
--- a/lib/AST/ASTContext.cpp
+++ b/lib/AST/ASTContext.cpp
@@ -1413,6 +1413,54 @@ QualType ASTContext::getConstantArrayType(QualType EltTy,
   return QualType(New, 0);
 }
 
+/// getIncompleteArrayType - Returns a unique reference to the type for a
+/// incomplete array of the specified element type.
+QualType ASTContext::getUnknownSizeVariableArrayType(QualType Ty) {
+  QualType ElemTy = getBaseElementType(Ty);
+  DeclarationName Name;
+  llvm::SmallVector<QualType, 8> ATypes;
+  QualType ATy = Ty;
+  while (const ArrayType *AT = getAsArrayType(ATy)) {
+    ATypes.push_back(ATy);
+    ATy = AT->getElementType();
+  }
+  for (int i = ATypes.size() - 1; i >= 0; i--) {
+    if (const VariableArrayType *VAT = getAsVariableArrayType(ATypes[i])) {
+      ElemTy = getVariableArrayType(ElemTy, /*ArraySize*/0, ArrayType::Star,
+                                    0, VAT->getBracketsRange());
+    }
+    else if (const ConstantArrayType *CAT = getAsConstantArrayType(ATypes[i])) {
+      llvm::APSInt ConstVal(CAT->getSize());
+      ElemTy = getConstantArrayType(ElemTy, ConstVal, ArrayType::Normal, 0);
+    }
+    else if (getAsIncompleteArrayType(ATypes[i])) {
+      ElemTy = getVariableArrayType(ElemTy, /*ArraySize*/0, ArrayType::Normal,
+                                    0, SourceRange());
+    }
+    else
+      assert(false && "DependentArrayType is seen");
+  }
+  return ElemTy;
+}
+
+/// getVariableArrayDecayedType - Returns a vla type where known sizes
+/// are replaced with [*]
+QualType ASTContext::getVariableArrayDecayedType(QualType Ty) {
+  if (Ty->isPointerType()) {
+    QualType BaseType = Ty->getAs<PointerType>()->getPointeeType();
+    if (isa<VariableArrayType>(BaseType)) {
+      ArrayType *AT = dyn_cast<ArrayType>(BaseType);
+      VariableArrayType *VAT = cast<VariableArrayType>(AT);
+      if (VAT->getSizeExpr()) {
+        Ty = getUnknownSizeVariableArrayType(BaseType);
+        Ty = getPointerType(Ty);
+      }
+    }
+  }
+  return Ty;
+}
+
+
 /// getVariableArrayType - Returns a non-unique reference to the type for a
 /// variable array of the specified element type.
 QualType ASTContext::getVariableArrayType(QualType EltTy,
@@ -2396,8 +2444,8 @@ CanQualType ASTContext::getCanonicalParamType(QualType T) {
   // Push qualifiers into arrays, and then discard any remaining
   // qualifiers.
   T = getCanonicalType(T);
+  T = getVariableArrayDecayedType(T);
   const Type *Ty = T.getTypePtr();
-
   QualType Result;
   if (isa<ArrayType>(Ty)) {
     Result = getArrayDecayedType(QualType(Ty,0));
@@ -2737,7 +2785,6 @@ const ArrayType *ASTContext::getAsArrayType(QualType T) {
                                               VAT->getBracketsRange()));
 }
 
-
 /// getArrayDecayedType - Return the properly qualified result of decaying the
 /// specified array type to a pointer.  This operation is non-trivial when
 /// handling typedefs etc.  The canonical type of "T" must be an array type,

diff --git a/lib/CodeGen/CGExprScalar.cpp b/lib/CodeGen/CGExprScalar.cpp
index 055e3f7e679429502b2304bf7ca5586a733ab5cb..73e94d1ece11ddcc723a86774631b01b284acc12 100644 (file)
--- a/lib/CodeGen/CGExprScalar.cpp
+++ b/lib/CodeGen/CGExprScalar.cpp
@@ -209,17 +209,8 @@ public:
   }
   Value *VisitCastExpr(CastExpr *E) {
     // Make sure to evaluate VLA bounds now so that we have them for later.
-    if (E->getType()->isVariablyModifiedType()) {
-      // Implicit cast of a null pointer to a vla type need not result in vla
-      // size computation which is not always possible in any case (see pr7827).
-      bool NeedSize = true;
-      if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E))
-        NeedSize = 
-          !ICE->getSubExpr()->isNullPointerConstant(CGF.getContext(),
-                                                Expr::NPC_ValueDependentIsNull);
-      if (NeedSize)
-        CGF.EmitVLASize(E->getType());
-    }
+    if (E->getType()->isVariablyModifiedType())
+      CGF.EmitVLASize(E->getType());
 
     return EmitCastExpr(E);
   }

diff --git a/lib/CodeGen/CodeGenFunction.cpp b/lib/CodeGen/CodeGenFunction.cpp
index c2016e83863e66134f4e0ad06414124172239421..5e301b5218ba8dce87c2dc4c282f149fd66cbe5a 100644 (file)
--- a/lib/CodeGen/CodeGenFunction.cpp
+++ b/lib/CodeGen/CodeGenFunction.cpp
@@ -625,6 +625,9 @@ llvm::Value *CodeGenFunction::EmitVLASize(QualType Ty) {
   EnsureInsertPoint();
 
   if (const VariableArrayType *VAT = getContext().getAsVariableArrayType(Ty)) {
+    // unknown size indication requires no size computation.
+    if (!VAT->getSizeExpr())
+      return 0;
     llvm::Value *&SizeEntry = VLASizeMap[VAT->getSizeExpr()];
 
     if (!SizeEntry) {

diff --git a/lib/CodeGen/CodeGenFunction.h b/lib/CodeGen/CodeGenFunction.h
index 740371115527c7daaef4653bf0e17fd6f3517efc..8dc8ac1e3d2c5c01de3a3923c5c3afa32b5aad0a 100644 (file)
--- a/lib/CodeGen/CodeGenFunction.h
+++ b/lib/CodeGen/CodeGenFunction.h
@@ -1714,12 +1714,26 @@ private:
            E = CallArgTypeInfo->arg_type_end(); I != E; ++I, ++Arg) {
         assert(Arg != ArgEnd && "Running over edge of argument list!");
         QualType ArgType = *I;
-
+#ifndef NDEBUG
+        QualType ActualArgType = Arg->getType();
+        if (ArgType->isPointerType() && ActualArgType->isPointerType()) {
+          QualType ActualBaseType = 
+            ActualArgType->getAs<PointerType>()->getPointeeType();
+          QualType ArgBaseType = 
+            ArgType->getAs<PointerType>()->getPointeeType();
+          if (ArgBaseType->isVariableArrayType()) {
+            if (const VariableArrayType *VAT =
+                getContext().getAsVariableArrayType(ActualBaseType)) {
+              if (!VAT->getSizeExpr())
+                ActualArgType = ArgType;
+            }
+          }
+        }
         assert(getContext().getCanonicalType(ArgType.getNonReferenceType()).
                getTypePtr() ==
-               getContext().getCanonicalType(Arg->getType()).getTypePtr() &&
+               getContext().getCanonicalType(ActualArgType).getTypePtr() &&
                "type mismatch in call argument!");
-
+#endif
         Args.push_back(std::make_pair(EmitCallArg(*Arg, ArgType),
                                       ArgType));
       }

diff --git a/lib/Sema/SemaDeclCXX.cpp b/lib/Sema/SemaDeclCXX.cpp
index 00f71a2bd46e4b075554a8abb4654712b7f59e0f..b171d85ee0ea6891666f9386221f93b64d409c9e 100644 (file)
--- a/lib/Sema/SemaDeclCXX.cpp
+++ b/lib/Sema/SemaDeclCXX.cpp
@@ -125,7 +125,8 @@ Sema::SetParamDefaultArgument(ParmVarDecl *Param, Expr *Arg,
   //   the same semantic constraints as the initializer expression in
   //   a declaration of a variable of the parameter type, using the
   //   copy-initialization semantics (8.5).
-  InitializedEntity Entity = InitializedEntity::InitializeParameter(Param);
+  InitializedEntity Entity = InitializedEntity::InitializeParameter(Context,
+                                                                    Param);
   InitializationKind Kind = InitializationKind::CreateCopy(Param->getLocation(),
                                                            EqualLoc);
   InitializationSequence InitSeq(*this, Entity, Kind, &Arg, 1);

diff --git a/lib/Sema/SemaExpr.cpp b/lib/Sema/SemaExpr.cpp
index 51ef01fce864d853c6b090fbbaf34a9f79bd9268..c22b5e5bb6333e728479d6df0d07fa5488f62a3e 100644 (file)
--- a/lib/Sema/SemaExpr.cpp
+++ b/lib/Sema/SemaExpr.cpp
@@ -3435,7 +3435,7 @@ ExprResult Sema::BuildCXXDefaultArgExpr(SourceLocation CallLoc,
 
     // Check the expression as an initializer for the parameter.
     InitializedEntity Entity
-      = InitializedEntity::InitializeParameter(Param);
+      = InitializedEntity::InitializeParameter(Context, Param);
     InitializationKind Kind
       = InitializationKind::CreateCopy(Param->getLocation(),
              /*FIXME:EqualLoc*/UninstExpr->getSourceRange().getBegin());
@@ -3564,10 +3564,9 @@ bool Sema::GatherArgumentsForCall(SourceLocation CallLoc,
       if (FDecl && i < FDecl->getNumParams())
         Param = FDecl->getParamDecl(i);
 
-
       InitializedEntity Entity =
-        Param? InitializedEntity::InitializeParameter(Param)
-             : InitializedEntity::InitializeParameter(ProtoArgType);
+        Param? InitializedEntity::InitializeParameter(Context, Param)
+             : InitializedEntity::InitializeParameter(Context, ProtoArgType);
       ExprResult ArgE = PerformCopyInitialization(Entity,
                                                         SourceLocation(),
                                                         Owned(Arg));
@@ -6232,12 +6231,12 @@ void Sema::ConvertPropertyAssignment(Expr *LHS, Expr *&RHS, QualType& LHSTy) {
                   LHSTy->isRecordType());
   if (copyInit) {
     InitializedEntity Entity = 
-    InitializedEntity::InitializeParameter(LHSTy);
+    InitializedEntity::InitializeParameter(Context, LHSTy);
     Expr *Arg = RHS;
     ExprResult ArgE = PerformCopyInitialization(Entity, SourceLocation(),
                                                 Owned(Arg));
     if (!ArgE.isInvalid())
-      RHS = ArgE.takeAs<Expr>();
+      RHS = ArgE.takeAs<Expr>(); 
   }
 }
   

diff --git a/lib/Sema/SemaExprCXX.cpp b/lib/Sema/SemaExprCXX.cpp
index 80dbe459ce97b205fe015c2b7dd7082c4565bd8e..f30fcf731288dcfa750647a121950031cd398abe 100644 (file)
--- a/lib/Sema/SemaExprCXX.cpp
+++ b/lib/Sema/SemaExprCXX.cpp
@@ -1194,6 +1194,7 @@ bool Sema::FindAllocationOverload(SourceLocation StartLoc, SourceRange Range,
     for (unsigned i = 0; (i < NumArgs && i < NumArgsInFnDecl); ++i) {
       ExprResult Result
         = PerformCopyInitialization(InitializedEntity::InitializeParameter(
+                                                       Context,
                                                        FnDecl->getParamDecl(i)),
                                     SourceLocation(),
                                     Owned(Args[i]->Retain()));

diff --git a/lib/Sema/SemaExprObjC.cpp b/lib/Sema/SemaExprObjC.cpp
index e9295ebb24454046dee51b19fcb5195baa1e3eef..a9c7a727f126b3a5e648fd9b6908d14481fac0dc 100644 (file)
--- a/lib/Sema/SemaExprObjC.cpp
+++ b/lib/Sema/SemaExprObjC.cpp
@@ -241,7 +241,8 @@ bool Sema::CheckMessageArgumentTypes(Expr **Args, unsigned NumArgs,
                               << argExpr->getSourceRange()))
       return true;
 
-    InitializedEntity Entity = InitializedEntity::InitializeParameter(Param);
+    InitializedEntity Entity = InitializedEntity::InitializeParameter(Context,
+                                                                      Param);
     ExprResult ArgE = PerformCopyInitialization(Entity,
                                                       SourceLocation(),
                                                       Owned(argExpr->Retain()));

diff --git a/lib/Sema/SemaOverload.cpp b/lib/Sema/SemaOverload.cpp
index bd971b793aefec0f6b706bd4d37e1ff89fdef6af..696e5b289c9a519a13d4dccbea8bdc1731e4e4b1 100644 (file)
--- a/lib/Sema/SemaOverload.cpp
+++ b/lib/Sema/SemaOverload.cpp
@@ -6864,6 +6864,7 @@ Sema::CreateOverloadedUnaryOp(SourceLocation OpLoc, unsigned OpcIn,
         // Convert the arguments.
         ExprResult InputInit
           = PerformCopyInitialization(InitializedEntity::InitializeParameter(
+                                                      Context,
                                                       FnDecl->getParamDecl(0)),
                                       SourceLocation(), 
                                       Input);
@@ -7045,6 +7046,7 @@ Sema::CreateOverloadedBinOp(SourceLocation OpLoc,
           ExprResult Arg1
             = PerformCopyInitialization(
                                         InitializedEntity::InitializeParameter(
+                                                        Context,
                                                         FnDecl->getParamDecl(0)),
                                         SourceLocation(),
                                         Owned(Args[1]));
@@ -7061,6 +7063,7 @@ Sema::CreateOverloadedBinOp(SourceLocation OpLoc,
           ExprResult Arg0
             = PerformCopyInitialization(
                                         InitializedEntity::InitializeParameter(
+                                                        Context,
                                                         FnDecl->getParamDecl(0)),
                                         SourceLocation(),
                                         Owned(Args[0]));
@@ -7070,6 +7073,7 @@ Sema::CreateOverloadedBinOp(SourceLocation OpLoc,
           ExprResult Arg1
             = PerformCopyInitialization(
                                         InitializedEntity::InitializeParameter(
+                                                        Context,
                                                         FnDecl->getParamDecl(1)),
                                         SourceLocation(),
                                         Owned(Args[1]));
@@ -7229,6 +7233,7 @@ Sema::CreateOverloadedArraySubscriptExpr(SourceLocation LLoc,
         // Convert the arguments.
         ExprResult InputInit
           = PerformCopyInitialization(InitializedEntity::InitializeParameter(
+                                                      Context,
                                                       FnDecl->getParamDecl(0)),
                                       SourceLocation(), 
                                       Owned(Args[1]));
@@ -7666,6 +7671,7 @@ Sema::BuildCallToObjectOfClassType(Scope *S, Expr *Object,
 
       ExprResult InputInit
         = PerformCopyInitialization(InitializedEntity::InitializeParameter(
+                                                    Context,
                                                     Method->getParamDecl(i)),
                                     SourceLocation(), Arg);
       

diff --git a/test/CodeGen/vla.c b/test/CodeGen/vla.c
index 8011497bf57d56a94aadcba0b3c72a96367d06e4..06d17b88d346e9d21acf362c13983e3b244d48b9 100644 (file)
--- a/test/CodeGen/vla.c
+++ b/test/CodeGen/vla.c
@@ -52,10 +52,24 @@ void f_8403108(unsigned x) {
 }
 
 // pr7827
-void function(short width, int data[][width]) {}
+void function(short width, int data[][width]) {} // expected-note {{passing argument to parameter 'data' here}}
 
 void test() {
+     int bork[4][13];
      // CHECK: call void @function(i16 signext 1, i32* null)
      function(1, 0);
+     // CHECK: call void @function(i16 signext 1, i32* inttoptr
+     function(1, 0xbadbeef); // expected-warning {{incompatible integer to pointer conversion passing}}
+     // CHECK: call void @function(i16 signext 1, i32* {{.*}})
+     function(1, bork);
+}
+
+void function1(short width, int data[][width][width]) {}
+void test1() {
+     int bork[4][13][15];
+     // CHECK: call void @function1(i16 signext 1, i32* {{.*}})
+     function1(1, bork);
+     // CHECK: call void @function(i16 signext 1, i32* {{.*}}) 
+     function(1, bork[2]);
 }