Fix for http://llvm.org/PR21915: Assertion Failed on multidimensional VLA in function arguments.

[ABataev]

Summary

Fixed assertion on type checking for arguments and parameters on function call if arguments are pointers to VLA

[rjmccall]

lib/CodeGen/CodeGenFunction.h

2752

Pointers aren't the only variably-modified type; you need to be able to look through functions types as well. Something like::

size_t test(int n, int (*(*fn)(void))[n])

And you're not looking through references, either.

But why not just have an exception for any variably-modified type?

2756

If you do keep this code, use castAs<> for casts that you know will succeed.

[ABataev]

John, fixed your comments

[rjmccall]

Okay, but now that you have an exception for variably-modified types, why you do need to look through pointer types at all? Shouldn't the argument type always match exactly unless it's variably-modified?

[ABataev]

Yep, you're right, we don't need to dig through all these pointers. I'll
fix it.

Best regards,

Alexey Bataev

Software Engineer
Intel Compiler Team

16.12.2014 21:16, John McCall пишет:

Okay, but now that you have an exception for variably-modified types, why you do need to look through pointer types at all? Shouldn't the argument type always match exactly unless it's variably-modified?

http://reviews.llvm.org/D6655

EMAIL PREFERENCES

http://reviews.llvm.org/settings/panel/emailpreferences/

[ABataev]

Update after review

[rjmccall]

Looks great, thanks!

lib/CodeGen/CodeGenFunction.h

if (CallArgTypeInfo) {
       // First, use the argument types that the type info knows about
       for (auto I = CallArgTypeInfo->param_type_begin() + ParamsToSkip,
                 E = CallArgTypeInfo->param_type_end();
            I != E; ++I, ++Arg) {
         assert(Arg != ArgEnd && "Running over edge of argument list!");
 #ifndef NDEBUG
         QualType ArgType = *I;
         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;
-            }
+        QualType ArgBaseType = ArgType.getNonReferenceType();
+        QualType ActualBaseType = ActualArgType;
+        while (ArgBaseType->isPointerType() &&
+               ActualBaseType->isPointerType()) {
+          ActualBaseType =
+              ActualBaseType->castAs<PointerType>()->getPointeeType();
+          ArgBaseType = ArgBaseType->castAs<PointerType>()->getPointeeType();
+          if (ArgBaseType->isVariablyModifiedType()) {
+            break;
           }
         }
         assert(getContext()
                        .getCanonicalType(ArgType.getNonReferenceType())
                        .getTypePtr() ==
                    getContext().getCanonicalType(ActualArgType).getTypePtr() &&
                "type mismatch in call argument!");
 #endif

test/CodeGen/vlt_to_pointer.c

+// RUN: %clang_cc1 %s -emit-llvm -o - | FileCheck %s
+
+int c[1][3*2];
+// CHECK: @{{.+}} = {{.*}} global [1 x [6 x {{i[0-9]+}}]] zeroinitializer
+
+// CHECK-LABEL: @f
+int f(int * const m, int (**v)[*m * 2])
+{
+    return &(c[0][*m]) == &((*v)[0][*m]);
+    // CHECK: icmp
+    // CHECK: ret i{{[0-9]+}}
+}
+
+// CHECK-LABEL: @test
+int test(int n, int (*(*fn)(void))[n]) {
+  return (*fn())[0];
+}
+
+// CHECK-LABEL: @main
+int main()
+{
+    int m = 3;
+    int (*d)[3*2] = c;
+    int (*fn[m])(void);
+    return f(&m, &d) + test(m, &fn);
+
+    // CHECK: call {{.+}} @f(
+    // CHECK: ret i{{[0-9]+}}
+}
+

test/CodeGenCXX/vlt_to_reference.cpp

+// RUN: %clang_cc1 %s -emit-llvm -o - | FileCheck %s
+
+// CHECK-LABEL: @main
+
+struct dyn_array { 
+    int size;
+    int data[];
+};
+
+int foo(dyn_array **&d) {
+  return (*d)->data[1];
+}
+
+int main()
+{
+    dyn_array **d;
+    return foo(d);
+
+    // CHECK: call {{.+}} @{{.+}}foo{{.+}}(
+    // CHECK: ret i{{[0-9]+}}
+}
+