Implementation of VlA of GNU C++ extension

[• vbyakovl]

Summary

This enables GNU C++ extension "Variable length array" by default.

[DmitryPolukhin]

The patch itself looks good to me but the main question do we want to support VLA in C++ in GNU extension mode.

[aaron.ballman]

Adding a few more reviewers.

Is there a major use case driving this patch, or is this just for GCC compatibility? Personally, I would prefer to avoid adding VLA support to C++ unless there's a good motivating use case, but would like to hear what Richard or Doug think on the subject.

[rengolin]

En passant comment: I really wish we wouldn't.

The C++ standard had some very careful considerations on VLAs and decided *not* to support. It wasn't for lack of interest, it was a well informed decision.

llvm/tools/clang/test/SemaCXX/c99-variable-length-array.cpp

1 ↗

(On Diff #52779)

are we not supporting this in c99 anymore?

llvm/tools/clang/test/SemaCXX/vla.cpp

1 ↗

(On Diff #52779)

doesn't this remove the test for support for it in c99?

[DmitryPolukhin]

llvm/tools/clang/test/SemaCXX/c99-variable-length-array.cpp

1 ↗

(On Diff #52779)

No, it is C++ test due to file extension .cpp. So C99 mode shouldn't be affected as far as I understand (i.e. the test was never run in C99). Mode by default is gnu++98 where this patch enable VLA so some warnings/errors from this test are gone (-Wvla-extension).

[hfinkel]

In D18823#397071, @rengolin wrote:

En passant comment: I really wish we wouldn't.

The C++ standard had some very careful considerations on VLAs and decided *not* to support. It wasn't for lack of interest, it was a well informed decision.

The decision might have been well informed, but it was really a lack of consensus. There was (and still is) a large fraction of the committee in favor of VLAs (or ARBs as they called them). There is also a large fraction of the committee opposed to them, or willing to accept them, but only if we could also add a library type with a better interface. There is a concern, which is not completely unreasonable, that if we make a point of adding this feature to the C++ standard, without adding a library container type, it will make people more likely to use "raw" arrays and pointers instead of using higher-level containers and iterators. It turns out, however, that it is not clear how such a library container could be implemented in practice.

However, as an implementation extension, this concern is not relevant. I'm in favor of this; I have uses who use this feature in GCC. It is certainly true that most HPC users are using these on PODs, but the fact that you cannot apply them to other types creates a problem with generic programming that people have run into.

[rengolin]

In D18823#397112, @hfinkel wrote:

However, as an implementation extension, this concern is not relevant. I'm in favor of this; I have uses who use this feature in GCC. It is certainly true that most HPC users are using these on PODs, but the fact that you cannot apply them to other types creates a problem with generic programming that people have run into.

Sounds odd to argue in favour of generic programming and not in favour of using generic standard containers.

I can easily accept the legacy argument, but creating new code with contentious features seems totally backwards to me.

[hfinkel]

In D18823#397122, @rengolin wrote:

In D18823#397112, @hfinkel wrote:

However, as an implementation extension, this concern is not relevant. I'm in favor of this; I have uses who use this feature in GCC. It is certainly true that most HPC users are using these on PODs, but the fact that you cannot apply them to other types creates a problem with generic programming that people have run into.

Sounds odd to argue in favour of generic programming and not in favour of using generic standard containers.

I can easily accept the legacy argument, but creating new code with contentious features seems totally backwards to me.

It comes up in cases where you're writing templates that are normally used with PODs and the relevant types, but don't want them to completely fail when used with other types (class for extended precision floats, or those doing forward automated differentiation, etc.).

Using VLAs in C++, as a general statement, is one of the most common language extensions I see used. It is used in new code regularly, and is often critical for performance (i.e. to avoid calls to the memory allocator). Using them on on-PODs is certainly less common, but still comes up.

[rsmith]

@vbyakovl The description of this patch is very misleading. What I believe this does is to allow VLAs with non-trivially-destructed element types. Can you fix the description (and make sure the fixed version ends up in the commit message if this is approved)?
@rjmccall Do you recall why we disallow this?

[rjmccall]

It requires careful IRGen support which at one point did not exist. When I implemented VLAs of strong/weak references for ARC, I deliberately tried to make sure that the infrastructure would also work for the C++ cases, but I didn't have time to go actually test any of it. It looks like the support was nearly sufficient.

[rsmith]

llvm/tools/clang/lib/Sema/SemaType.cpp

2158–2159 ↗

(On Diff #52779)

This isn't right; this is *not* a GNU C++ extension. GCC rejects it with -pedantic-errors in GNU and non-GNU mode, and accepts it by default in GNU and non-GNU mode.

What you need to do is to delete the check for a POD element type below, since that is the new feature you're adding support for.

Then please revert all of your test changes other than the new file.

[doug.gregor]

I think it's completely reasonable to implement support for VLAs as a GNU C++ extension. We did go through a phase where we tried to avoid implementing VLAs in C++ because we considered them to be a poor feature in C++. However, their use was wide-spread enough that we changed course and enabled the implementation for POD types in C++. That got us most of the compatibility without a significant amount of effort, whereas we didn't have the infrastructure to handle non-PODs at that time. It wasn't a statement of intent---it just wasn't important enough to implement at the time. Looks like rjmccall's work on VLAs containing ARC-qualified pointers got us most of the way there, so it makes sense to generalize it to non-POD types.

[• vbyakovl]

Sema/SemaType.cpp: Vla works in C++ by default. An error is printed if a class has not default constructor.
test/SemaCXX/c99-variable-length-array.cpp: Changes is removed
test/SemaCXX/vla.cpp: changes is removed.
test/CodeGenCXX/vla-consruct.cpp is added.

[rsmith]

llvm/tools/clang/lib/Sema/SemaType.cpp

2163–2165 ↗

(On Diff #53548)

Why reject types without default constructors? That's something SemaInit should be checking for, not the responsibility of this code. If we really need to reject them here for some reason, a "non-POD" error is not the right way to diagnose it.

[• vbyakovl]

Sema/SemaType.cpp: Deleted POD type and default constructor checkings.
test/SemaCXX/c99-variable-length-array-cxx11.cpp: Edited dianocnics.

[• vbyakovl]

Richard, now my changes are good for you?

[• vbyakovl]

@rsmith ping

[rsmith]

LGTM.

cfe/trunk/lib/CodeGen/CGClass.cpp

 /// constructor for each of several members of an array.
 ///
 /// \param ctor the constructor to call for each element
 /// \param arrayType the type of the array to initialize
 /// \param arrayBegin an arrayType*
 /// \param zeroInitialize true if each element should be
 ///   zero-initialized before it is constructed
 void CodeGenFunction::EmitCXXAggrConstructorCall(
-    const CXXConstructorDecl *ctor, const ConstantArrayType *arrayType,
+    const CXXConstructorDecl *ctor, const ArrayType *arrayType,
     Address arrayBegin, const CXXConstructExpr *E, bool zeroInitialize) {
   QualType elementType;
   llvm::Value *numElements =
     emitArrayLength(arrayType, elementType, arrayBegin);
 
   EmitCXXAggrConstructorCall(ctor, numElements, arrayBegin, E, zeroInitialize);
 }
 

cfe/trunk/lib/CodeGen/CGExprCXX.cpp

if (getLangOpts().ElideConstructors && E->isElidable()) {
     assert(getContext().hasSameUnqualifiedType(E->getType(),
                                                E->getArg(0)->getType()));
     if (E->getArg(0)->isTemporaryObject(getContext(), CD->getParent())) {
       EmitAggExpr(E->getArg(0), Dest);
       return;
     }
   }
   
-  if (const ConstantArrayType *arrayType 
-        = getContext().getAsConstantArrayType(E->getType())) {
+  if (const ArrayType *arrayType
+        = getContext().getAsArrayType(E->getType())) {
     EmitCXXAggrConstructorCall(CD, arrayType, Dest.getAddress(), E);
   } else {
     CXXCtorType Type = Ctor_Complete;
     bool ForVirtualBase = false;
     bool Delegating = false;
     
     switch (E->getConstructionKind()) {
      case CXXConstructExpr::CK_Delegating:

cfe/trunk/lib/CodeGen/CodeGenFunction.h

#endif
   /// Emit assumption that vptr load == global vtable.
   void EmitVTableAssumptionLoad(const VPtr &vptr, Address This);
 
   void EmitSynthesizedCXXCopyCtorCall(const CXXConstructorDecl *D,
                                       Address This, Address Src,
                                       const CXXConstructExpr *E);
 
   void EmitCXXAggrConstructorCall(const CXXConstructorDecl *D,
-                                  const ConstantArrayType *ArrayTy,
+                                  const ArrayType *ArrayTy,
                                   Address ArrayPtr,
                                   const CXXConstructExpr *E,
                                   bool ZeroInitialization = false);
 
   void EmitCXXAggrConstructorCall(const CXXConstructorDecl *D,
                                   llvm::Value *NumElements,
                                   Address ArrayPtr,
                                   const CXXConstructExpr *E,

cfe/trunk/lib/Sema/SemaType.cpp

QualType Sema::BuildArrayType(QualType T, ArrayType::ArraySizeModifier ASM,
   // OpenCL v1.2 s6.9.d: variable length arrays are not supported.
   if (getLangOpts().OpenCL && T->isVariableArrayType()) {
     Diag(Loc, diag::err_opencl_vla);
     return QualType();
   }
   // If this is not C99, extwarn about VLA's and C99 array size modifiers.
   if (!getLangOpts().C99) {
     if (T->isVariableArrayType()) {
-      // Prohibit the use of non-POD types in VLAs.
-      QualType BaseT = Context.getBaseElementType(T);
-      if (!T->isDependentType() && isCompleteType(Loc, BaseT) &&
-          !BaseT.isPODType(Context) && !BaseT->isObjCLifetimeType()) {
-        Diag(Loc, diag::err_vla_non_pod) << BaseT;
-        return QualType();
-      }
       // Prohibit the use of VLAs during template argument deduction.
-      else if (isSFINAEContext()) {
+      if (isSFINAEContext()) {
         Diag(Loc, diag::err_vla_in_sfinae);
         return QualType();
       }
       // Just extwarn about VLAs.
       else
         Diag(Loc, diag::ext_vla);
     } else if (ASM != ArrayType::Normal || Quals != 0)
       Diag(Loc,

cfe/trunk/test/CodeGenCXX/vla-consruct.cpp

+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fcxx-exceptions -fexceptions -O0 %s -emit-llvm -o - | FileCheck %s
+
+extern "C" int printf(const char *, ...);
+
+static int N;
+struct S {
+  S()
+  __attribute__((nothrow)) { printf("%d: S()\n", ++N); }
+  ~S() __attribute__((nothrow)) { printf("%d: ~S()\n", N--); }
+  int n[17];
+};
+// CHECK: [[struct_S:%.+]] = type { [17 x i32] }
+void print(int n, int a, int b, int c, int d) {
+  printf("n=%d\n,sizeof(S)=%d\nsizeof(array_t[0][0])=%d\nsizeof(array_t[0])=%d\nsizeof(array_t)=%d\n",
+         n, a, b, c, d);
+  if (n == 2)
+    throw(n);
+}
+
+void test(int n) {
+  // CHECK: define void {{.*test.*}}(i32 [[n:%.+]]) #
+  // CHECK: [[n_addr:%.+]] = alloca
+  // CHECK-NEXT: [[saved_stack:%.+]] = alloca
+  // CHECK-NEXT: [[sizeof_S:%.+]] = alloca
+  // CHECK-NEXT: [[sizeof_array_t_0_0:%.+]] = alloca
+  // CHECK-NEXT: [[sizeof_array_t_0:%.+]] = alloca
+  // CHECK-NEXT: [[sizeof_array_t:%.+]] = alloca
+  // CHECK-NEXT: [[exn_slot:%.+]] = alloca i8*
+  // CHECK-NEXT: [[ehselector_slot:%.+]] = alloca i32
+  // CHECK-NEXT: store i32 [[n]], i32* [[n_addr]]
+  // CHECK-NEXT: [[t0:%.+]] = load i32, i32* [[n_addr]]
+  // CHECK-NEXT: [[t1:%.+]] = zext i32 [[t0]] to i64
+  // CHECK-NEXT: [[t2:%.+]] = load i32, i32* [[n_addr]]
+  // CHECK-NEXT: [[add:%.+]] = add nsw i32 [[t2]], 1
+  // CHECK-NEXT: [[t3:%.+]] = zext i32 [[add]] to i64
+  // CHECK-NEXT: [[t4:%.+]] = call i8* @llvm.stacksave()
+  // CHECK-NEXT: store i8* [[t4]], i8** [[saved_stack]]
+  // CHECK-NEXT: [[t5:%.+]] = mul nuw i64 [[t1]], [[t3]]
+  // CHECK-NEXT: [[vla:%.+]] = alloca [[struct_S]], i64 [[t5]]
+  // CHECK-NEXT: [[t6:%.+]] = mul nuw i64 [[t1]], [[t3]]
+  // CHECK-NEXT: [[isempty:%.+]] = icmp eq i64 [[t6]], 0
+  // CHECK-NEXT: br i1 [[isempty]], label %[[arrayctor_cont:.+]], label %[[new_ctorloop:.+]]
+
+  S array_t[n][n + 1];
+
+  // CHECK: [[new_ctorloop]]
+  // CHECK-NEXT: [[arrayctor_end:%.+]] = getelementptr inbounds [[struct_S]], [[struct_S]]* [[vla]], i64 [[t6]]
+  // CHECK-NEXT: br label %[[arrayctor_loop:.+]]
+
+  // CHECK: [[arrayctor_loop]]
+  // CHECK-NEXT: [[arrayctor_cur:%.+]] = phi [[struct_S]]* [ [[vla]], %[[new_ctorloop]] ], [ [[arrayctor_next:%.+]], %[[arrayctor_loop]] ]
+  // CHECK-NEXT: call void [[ctor:@.+]]([[struct_S]]* [[arrayctor_cur]])
+  // CHECK-NEXT: [[arrayctor_next]] = getelementptr inbounds [[struct_S]], [[struct_S]]* [[arrayctor_cur]], i64 1
+  // CHECK-NEXT: [[arrayctor_done:%.+]] = icmp eq [[struct_S]]* [[arrayctor_next]], [[arrayctor_end]]
+  // CHECK-NEXT: br i1 [[arrayctor_done]], label %[[arrayctor_cont]], label %[[arrayctor_loop]]
+
+  int sizeof_S = sizeof(S);
+  int sizeof_array_t_0_0 = sizeof(array_t[0][0]);
+  int sizeof_array_t_0 = sizeof(array_t[0]);
+  int sizeof_array_t = sizeof(array_t);
+  print(n, sizeof_S, sizeof_array_t_0_0, sizeof_array_t_0, sizeof_array_t);
+
+  //  CHECK: [[arrayctor_cont]]
+  //  CHECK-NEXT: store i32 68, i32* [[sizeof_S]]
+  //  CHECK-NEXT: store i32 68, i32* [[sizeof_array_t_0_0]]
+  //  CHECK: [[t8:%.+]] = mul nuw i64 68, [[t3]]
+  //  CHECK-NEXT: [[conv:%.+]] = trunc i64 [[t8]] to i32
+  //  CHECK-NEXT: store i32 [[conv]], i32* [[sizeof_array_t_0]]
+  //  CHECK-NEXT: [[t9:%.+]] = mul nuw i64 [[t1]], [[t3]]
+  //  CHECK-NEXT: [[t10:%.+]] = mul nuw i64 68, [[t9]]
+  //  CHECK-NEXT: [[conv1:%.+]] = trunc i64 [[t10]] to i32
+  //  CHECK-NEXT: store i32 [[conv1]], i32* [[sizeof_array_t]]
+  //  CHECK-NEXT: [[t11:%.+]] = load i32, i32* [[n_addr:%.+]]
+  //  CHECK-NEXT: [[t12:%.+]] = load i32, i32* [[sizeof_S]]
+  //  CHECK-NEXT: [[t13:%.+]] = load i32, i32* [[sizeof_array_t_0_0]]
+  //  CHECK-NEXT: [[t14:%.+]] = load i32, i32* [[sizeof_array_t_0]]
+  //  CHECK-NEXT: [[t15:%.+]] = load i32, i32* [[sizeof_array_t]]
+  //  CHECK-NEXT: invoke void @{{.*print.*}}(i32 [[t11]], i32 [[t12]], i32 [[t13]], i32 [[t14]], i32 [[t15]])
+  //  CHECK-NEXT: to label %[[invoke_cont:.+]] unwind label %[[lpad:.+]]
+
+  //  CHECK: [[invoke_cont]]
+  //  CHECK-NEXT: [[t16:%.+]] = mul nuw i64 [[t1]], [[t3]]
+  //  CHECK-NEXT: [[t17:%.+]] = getelementptr inbounds [[struct_S]], [[struct_S]]* [[vla]], i64 [[t16]]
+  //  CHECK-NEXT: [[arraydestroy_isempty:%.+]] = icmp eq [[struct_S]]* [[vla]], [[t17]]
+  //  CHECK-NEXT: br i1 [[arraydestroy_isempty]], label %[[arraydestroy_done2:.+]], label %[[arraydestroy_body:.+]]
+
+  //  CHECK: [[arraydestroy_body]]
+  //  CHECK-NEXT: [[arraydestroy_elementPast:%.+]] = phi [[struct_S]]* [ [[t17]], %[[invoke_cont]] ], [ [[arraydestroy_element:%.+]], %[[arraydestroy_body]] ]
+  //  CHECK-NEXT: [[arraydestroy_element]] = getelementptr inbounds [[struct_S]], [[struct_S]]* [[arraydestroy_elementPast]]
+  //  CHECK-NEXT: call void @[[dtor:.+]]([[struct_S]]* [[arraydestroy_element]])
+  //  CHECK-NEXT: [[arraydestroy_done:%.+]] = icmp eq [[struct_S]]* [[arraydestroy_element]], [[vla]]
+  //  CHECK-NEXT: br i1 [[arraydestroy_done]], label %[[arraydestroy_done2]], label %[[arraydestroy_body]]
+
+  //  CHECK: [[arraydestroy_done2]]
+  //  CHECK-NEXT: [[t17:%.+]] = load i8*, i8** [[saved_stack]]
+  //  CHECK-NEXT: call void @llvm.stackrestore(i8* [[t17]])
+  //  CHECK: ret void
+
+  //  CHECK: [[lpad]]
+  //  CHECK-NEXT: [[t19:%.+]] = landingpad { i8*, i32 }
+  //  CHECK: [[t20:%.+]] = extractvalue { i8*, i32 } [[t19]], 0
+  //  CHECK-NEXT: store i8* [[t20]], i8** [[exn_slot]]
+  //  CHECK-NEXT: [[t21:%.+]] = extractvalue { i8*, i32 } [[t19]], 1
+  //  CHECK-NEXT: store i32 [[t21]], i32* [[ehselector_slot]]
+  //  CHECK-NEXT: [[t22:%.+]] = mul nuw i64 [[t1]], [[t3]]
+  //  CHECK-NEXT: [[t23:%.+]] = getelementptr inbounds [[struct_S]], [[struct_S]]* [[vla]], i64 [[t22]]
+  //  CHECK-NEXT: [[arraydestroy_isempty3:%.+]] = icmp eq [[struct_S]]* [[vla]], [[t23]]
+  //  CHECK-NEXT: br i1 [[arraydestroy_isempty3]], label %[[arraydestroy_done8:.+]], label %[[arraydestroy_body4:.+]]
+
+  //  CHECK: [[arraydestroy_body4]]
+  //  CHECK: [[arraydestroy_elementPast5:%.+]] = phi [[struct_S]]* [ [[t23]], %[[lpad]] ], [ [[arraydestroy_element6:.+]], %[[arraydestroy_body4]] ]
+  //  CHECK-NEXT: [[arraydestroy_element6]] = getelementptr inbounds [[struct_S]], [[struct_S]]* [[arraydestroy_elementPast5]], i64 -1
+  //  CHECK-NEXT: call void @[[dtor]]([[struct_S]]* [[arraydestroy_element6]])
+  //  CHECK-NEXT: [[arraydestroy_done7:%.+]] = icmp eq [[struct_S]]* [[arraydestroy_element6]], [[vla]]
+  //  CHECK-NEXT: br i1 [[arraydestroy_done7]], label %[[arraydestroy_done8]], label %[[arraydestroy_body4]]
+
+  //  CHECK: [[arraydestroy_done8]]
+  //  CHECK-NEXT: br label %[[eh_resume:.+]]
+
+  //  CHECK: [[eh_resume]]
+  //  CHECK-NEXT: [[exn:%.+]] = load i8*, i8** [[exn_slot]]
+  //  CHECK-NEXT: [[sel:%.+]] = load i32, i32* [[ehselector_slot]]
+  //  CHECK-NEXT: [[lpad_val:%.+]] = insertvalue { i8*, i32 } undef, i8* [[exn]], 0
+  //  CHECK-NEXT: [[lpad_val9:%.+]] = insertvalue { i8*, i32 } [[lpad_val]], i32 [[sel]], 1
+  //  CHECK-NEXT: resume { i8*, i32 } [[lpad_val9]]
+}
+
+int main() {
+  try {
+    test(2);
+  } catch (int e) {
+    printf("expeption %d\n", e);
+  }
+  try {
+    test(3);
+  } catch (int e) {
+    printf("expeption %d", e);
+  }
+}

cfe/trunk/test/SemaCXX/c99-variable-length-array-cxx11.cpp

 };
 
 // We allow VLAs of POD types, only.
 void vla(int N) {
   int array1[N]; // expected-warning{{variable length arrays are a C99 feature}}
   POD array2[N]; // expected-warning{{variable length arrays are a C99 feature}}
   StillPOD array3[N]; // expected-warning{{variable length arrays are a C99 feature}}
   StillPOD2 array4[N][3]; // expected-warning{{variable length arrays are a C99 feature}}
-  NonPOD array5[N]; // expected-error{{variable length array of non-POD element type 'NonPOD'}}
+  NonPOD array5[N]; // expected-error{{no matching constructor for initialization of 'NonPOD [N]'}}
+  // expected-warning@-1{{variable length arrays are a C99 feature}}
+  // expected-note@-16{{candidate constructor not viable}}
+  // expected-note@-18{{candidate constructor (the implicit copy constructor) not viable}}
+  // expected-note@-19{{candidate constructor (the implicit move constructor) not viable}}
 }

cfe/trunk/test/SemaCXX/c99-variable-length-array.cpp

struct POD {
   int x;
   int y;
 };
 
 // We allow VLAs of POD types, only.
 void vla(int N) {
   int array1[N]; // expected-warning{{variable length arrays are a C99 feature}}
   POD array2[N]; // expected-warning{{variable length arrays are a C99 feature}}
-  NonPOD array3[N]; // expected-error{{variable length array of non-POD element type 'NonPOD'}}
-  NonPOD2 array4[N][3]; // expected-error{{variable length array of non-POD element type 'NonPOD2'}}
+  NonPOD array3[N]; // expected-warning{{variable length arrays are a C99 feature}}
+  NonPOD2 array4[N][3]; // expected-warning{{variable length arrays are a C99 feature}}
 }
 
 /// Warn about VLAs in templates.
 template<typename T>
 void vla_in_template(int N, T t) {
   int array1[N]; // expected-warning{{variable length arrays are a C99 feature}}
 }
 

cfe/trunk/test/SemaCXX/vla-consruct.cpp

+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fcxx-exceptions -fexceptions -O0 -verify %s
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fcxx-exceptions -fexceptions -pedantic-errors -DPE -O0 -verify %s
+
+# ifndef PE
+// expected-no-diagnostics
+# endif
+
+extern "C" int printf(const char*, ...);
+
+static int N;
+struct S {
+  S() __attribute__ ((nothrow))  { printf("%d: S()\n", ++N); }
+  ~S()  __attribute__ ((nothrow))  { printf("%d: ~S()\n", N--); }
+  int n[17];
+};
+
+void print(int n, int a, int b, int c, int d) {
+  printf("n=%d\n,sizeof(S)=%d\nsizeof(array_t[0][0])=%d\nsizeof(array_t[0])=%d\nsizeof(array_t)=%d\n",
+         n, a, b, c, d);
+  if (n == 2) throw(n);
+}
+
+void test(int n) {
+  S array_t[n][n+1];
+# ifdef PE
+   // expected-error@-2 {{variable length arrays are a C99 feature}}
+   // expected-error@-3 {{variable length arrays are a C99 feature}}
+# endif
+  int sizeof_S = sizeof(S);
+  int sizeof_array_t_0_0 = sizeof(array_t[0][0]);
+  int sizeof_array_t_0 = sizeof(array_t[0]);
+  int sizeof_array_t = sizeof(array_t);
+  print(n, sizeof_S, sizeof_array_t_0_0, sizeof_array_t_0, sizeof_array_t);
+}
+
+int main()
+{
+  try {
+    test(2);
+  } catch(int e) {
+    printf("expeption %d\n", e);
+  }
+  try {
+    test(3);
+  } catch(int e) {
+    printf("expeption %d", e);
+  }
+}