[codeview] Improved array type support (multi dimension array)

[aaboud]

Summary

Added support for multi dimension array.

Also worked around some issues with:

1. array of incomplete structure type.
2. dynamic size array.

[majnemer]

lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

859–862 ↗

(On Diff #61282)

If a type is incomplete, how can we emit a size for it?

[rnk]

Thanks, seems like the right approach.

lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

858–862 ↗

(On Diff #61282)

This shouldn't be a FIXME. There is nothing we can do in the frontend when the type definition is unavailable, as in the example you used in your test case. MSVC gives the array size zero, which is what your code does. You should reword the comment to document that this is intended behavior.

876 ↗

(On Diff #61282)

Why not just assert(Subrange->getLowerBound() == 0 && "codeview doesn't support subranges with lower bounds");? As is, your code will probably trigger unused variable warnings in NDEBUG builds.

881 ↗

(On Diff #61282)

This comment needs work. It's worth mentioning that a count of -1 means that this is a VLA, and that it is not currently representable in CodeView. Actually, why not just let it go through as ~0U?

894 ↗

(On Diff #61282)

I think without adding (void)UndefinedSubrange outside the assert, you will get -Wunused-but-set warnings in an NDEBUG build.

[majnemer]

lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

881 ↗

(On Diff #61282)

Can't we use LF_DIMVARLU for VLAs?

[aaboud]

Thanks for the comments.
Answer inline.

lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

858–862 ↗

(On Diff #61282)

Actually, it is a bug. However, my example was not correct.
I fixed the example to show the issue.

It is true that incomplete structure has no size.
However if we:

1. Declare an incomplete structure.
2. Define the structure later.
3. Declare an array of that defined structure.

Then the array will have no size, though it will be pointing to the defined complete structure.

This leads the assertion to be hit. (for incomplete structure without definition we do not hit assertion)

881 ↗

(On Diff #61282)

This comment needs work. It's worth mentioning that a count of -1 means that this is a VLA, and that it is not currently representable in CodeView. Actually, why not just let it go through as ~0U?

I will fix the comment.
output ~0U will sign to the debugger that you have a large array what might cause accessing out-of-scope memory.
Better assign the minimum size of '1' till we fix the LLVM Ir and use LF_DIMVARLU as David suggested.

Can't we use LF_DIMVARLU for VLAs?

We should do that once front-end supports sub-ranges of variable values.
To do this we need to introduce a new debug intrinsic, as we cannot point to an instruction from external metadata.

[aaboud]

Applied changes according to comments from Reid and David.

[rnk]

lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

858–862 ↗

(On Diff #61446)

Nice find! However, let's file that bug in http://llvm.org/bugs, and once we fix it, this code doesn't need to change, so I don't see why we need a comment here about it. It's correct as written, assuming the frontend does the right thing.

881 ↗

(On Diff #61446)

VLA stands for "variable length array", not "very large array". :)

Why do we need to change the frontend? Don't we already know that Count == -1 implies a VLA? This will be a backend change, not a frontend change.

[aaboud]

Thanks Reid for the comments.
Please see answers below.

lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

858–862 ↗

(On Diff #61446)

OK, will report a bug in LLVM.
I can remove the comment, however, if we fix this bug we will not need the check below, that is why I added the comment in the first place.
If you think that we should not assert that arrays with total size zero, does not sum into non-zero size, then we can let this check here exist. Otherwise, this check is a temporary one and should be removed once the above bug is fixed.

What is your preference?

881 ↗

(On Diff #61446)

VLA stands for "variable length array", not "very large array". :)

Indeed, I thought I wrote it right :) will fix it.

Why do we need to change the frontend? Don't we already know that Count == -1 implies a VLA? This will be a backend change, not a frontend change.

Because we should emit something like this:

; void foo(int x) {
;   int dyn_size_arr[x];
;   dyn_size_arr[0] = 0;
; }

REFSYM (0x1003) {
  TypeLeafKind: LF_REFSYM (0x20c)
  Constant {
    Type: long (0x112)
    Value: 0
  }
}

REFSYM (0x1004) {
  TypeLeafKind: LF_REFSYM (0x20c)
  RegRelativeSym {
    Offset: 0x40
    Type: int (0x74)
    Register: 0x14E
    VarName: x
  }
}

DIMVARLU (0x1005) {
  TypeLeafKind: LF_DIMVARLU (0x120a)
  Rank: 1
  IndexType: int (0x74)
  Bounds: (0x1003:0x1004)
}

Array (0x1006) {
  TypeLeafKind: LF_DIMARRAY (0x1508)
  ElementType: int (0x74)
  DimensionInfo: 0x1005
  Name:
}

We need to track dynamic array range, which will be an LLVM IR value.
Can we do this without adding a new dbg intrinsic?

[rnk]

lgtm with a better comment about arrays of incomplete type.

lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

858–862 ↗

(On Diff #61446)

OK, now I understand. I thought we needed this check to pass the assertion in the simple incomplete type case. I think the comment needs to elaborate that this is only a problem when the code builds an array of incomplete struct type, and then later completes the struct type. In fact, just putting the test case in the comments helps:

struct A (*p)[3];
struct A { int f; } a[3];

881 ↗

(On Diff #61446)

Thanks for the explanation, makes sense.

[aaboud]

Patch was reverted at revision (273815) due to PR28311.

[aaboud]

Fixed PR28311.
Now we take care of base element of the array, which is derived from other type (e.g. typedef).
These derived types might have no Size field, that is why we hit the assertion:
assert(UndefinedSubrange || ElementSize == (Ty->getSizeInBits() / 8));

[rnk]

lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

918 ↗

(On Diff #62084)

use clang-format to align Tag.

933 ↗

(On Diff #62084)

use clang-format here

Can you give an example of when this would be needed? It would make a good test.

test/DebugInfo/COFF/types-array-advanced.ll

17 ↗

(On Diff #62084)

Maybe make it 'typedef const volatile int T_INT' to cover a few more codepaths?

[aaboud]

lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

933 ↗

(On Diff #62084)

I am not sure there is an example where a base type of an array is a reference or rvalue reference.
I took this code from DwarfUnit.cpp, where it was used to determine base size of member types.

I would remove this code for now, unless you have other opinion.

[aaboud]

Improved LIT test according to Reid comment.
Applied clang-format.
Update revision to top of trunk.

[rnk]

Looks good after sharing common code

lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

1005 ↗

(On Diff #62743)

Oh, then let's move it to the common base class for both, DebugHandlerBase.

[aaboud]

Applied Reid comment and moved getBaseTypeSize to DebugHandlerBase as it used by DwarfDebug and CodeViewDebug.

Added David Blaikie to review the change in DwarfDebug.

[aaboud]

Updated getBaseTypeSize to match more the top of trunk version moved from DwarfUnit.cpp.

llvm/trunk/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

TypeIndex CodeViewDebug::getMemberFunctionType(const DISubprogram *SP,
   // function type, as the complete class type is likely to reference this
   // member function type.
   TypeLoweringScope S(*this);
   TypeIndex TI =
       lowerTypeMemberFunction(SP->getType(), Class, SP->getThisAdjustment());
   return recordTypeIndexForDINode(SP, TI, Class);
 }
 
-TypeIndex CodeViewDebug::recordTypeIndexForDINode(const DINode *Node, TypeIndex TI,
+TypeIndex CodeViewDebug::recordTypeIndexForDINode(const DINode *Node,
+                                                  TypeIndex TI,
                                                   const DIType *ClassTy) {
   auto InsertResult = TypeIndices.insert({{Node, ClassTy}, TI});
   (void)InsertResult;
   assert(InsertResult.second && "DINode was already assigned a type index");
   return TI;
 }
 
 unsigned CodeViewDebug::getPointerSizeInBytes() {
   return MMI->getModule()->getDataLayout().getPointerSizeInBits() / 8;

 
 TypeIndex CodeViewDebug::lowerTypeArray(const DICompositeType *Ty) {
   DITypeRef ElementTypeRef = Ty->getBaseType();
   TypeIndex ElementTypeIndex = getTypeIndex(ElementTypeRef);
   // IndexType is size_t, which depends on the bitness of the target.
   TypeIndex IndexType = Asm->MAI->getPointerSize() == 8
                             ? TypeIndex(SimpleTypeKind::UInt64Quad)
                             : TypeIndex(SimpleTypeKind::UInt32Long);
-  uint64_t Size = Ty->getSizeInBits() / 8;
-  ArrayRecord Record(ElementTypeIndex, IndexType, Size, Ty->getName());
-  return TypeTable.writeArray(Record);
+
+  uint64_t ElementSize = getBaseTypeSize(ElementTypeRef) / 8;
+
+  bool UndefinedSubrange = false;
+
+  // FIXME:
+  // There is a bug in the front-end where an array of a structure, which was
+  // declared as incomplete structure first, ends up not getting a size assigned
+  // to it. (PR28303)
+  // Example:
+  //   struct A(*p)[3];
+  //   struct A { int f; } a[3];
+  //
+  // This needs to be fixed in the front-end, but in the meantime we don't want
+  // to trigger an assertion because of this.
+  if (Ty->getSizeInBits() == 0) {
+    UndefinedSubrange = true;
+  }
+
+  // Add subranges to array type.
+  DINodeArray Elements = Ty->getElements();
+  for (int i = Elements.size() - 1; i >= 0; --i) {
+    const DINode *Element = Elements[i];
+    assert(Element->getTag() == dwarf::DW_TAG_subrange_type);
+
+    const DISubrange *Subrange = cast<DISubrange>(Element);
+    assert(Subrange->getLowerBound() == 0 &&
+           "codeview doesn't support subranges with lower bounds");
+    int64_t Count = Subrange->getCount();
+
+    // Variable Length Array (VLA) has Count equal to '-1'.
+    // Replace with Count '1', assume it is the minimum VLA length.
+    // FIXME: Make front-end support VLA subrange and emit LF_DIMVARLU.
+    if (Count == -1) {
+      Count = 1;
+      UndefinedSubrange = true;
+    }
+
+    StringRef Name = (i == 0) ? Ty->getName() : "";
+    // Update the element size and element type index for subsequent subranges.
+    ElementSize *= Count;
+    ElementTypeIndex = TypeTable.writeArray(
+        ArrayRecord(ElementTypeIndex, IndexType, ElementSize, Name));
+  }
+
+  (void)UndefinedSubrange;
+  assert(UndefinedSubrange || ElementSize == (Ty->getSizeInBits() / 8));
+
+  return ElementTypeIndex;
 }
 
 TypeIndex CodeViewDebug::lowerTypeBasic(const DIBasicType *Ty) {
   TypeIndex Index;
   dwarf::TypeKind Kind;
   uint32_t ByteSize;
 
   Kind = static_cast<dwarf::TypeKind>(Ty->getEncoding());
default:
     llvm_unreachable("not a record");
   }
 
   InsertResult.first->second = TI;
   return TI;
 }
 
 /// Emit all the deferred complete record types. Try to do this in FIFO order,
-/// and do this until fixpoint, as each complete record type typically references
+/// and do this until fixpoint, as each complete record type typically
+/// references
 /// many other record types.
 void CodeViewDebug::emitDeferredCompleteTypes() {
   SmallVector<const DICompositeType *, 4> TypesToEmit;
   while (!DeferredCompleteTypes.empty()) {
     std::swap(DeferredCompleteTypes, TypesToEmit);
     for (const DICompositeType *RecordTy : TypesToEmit)
       getCompleteTypeIndex(RecordTy);
     TypesToEmit.clear();

llvm/trunk/lib/CodeGen/AsmPrinter/DebugHandlerBase.h

public:
 
   /// Determine the relative position of the pieces described by P1 and P2.
   /// Returns  -1 if P1 is entirely before P2, 0 if P1 and P2 overlap,
   /// 1 if P1 is entirely after P2.
   static int pieceCmp(const DIExpression *P1, const DIExpression *P2);
 
   /// Determine whether two variable pieces overlap.
   static bool piecesOverlap(const DIExpression *P1, const DIExpression *P2);
+
+  /// If this type is derived from a base type then return base type size.
+  static uint64_t getBaseTypeSize(const DITypeRef TyRef);
 };
 
 }
 
 #endif

llvm/trunk/lib/CodeGen/AsmPrinter/DebugHandlerBase.cpp

 
 /// Determine whether two variable pieces overlap.
 bool DebugHandlerBase::piecesOverlap(const DIExpression *P1, const DIExpression *P2) {
   if (!P1->isBitPiece() || !P2->isBitPiece())
     return true;
   return pieceCmp(P1, P2) == 0;
 }
 
+/// If this type is derived from a base type then return base type size.
+uint64_t DebugHandlerBase::getBaseTypeSize(const DITypeRef TyRef) {
+  DIType *Ty = TyRef.resolve();
+  assert(Ty);
+  DIDerivedType *DDTy = dyn_cast<DIDerivedType>(Ty);
+  if (!DDTy)
+    return Ty->getSizeInBits();
+
+  unsigned Tag = DDTy->getTag();
+
+  if (Tag != dwarf::DW_TAG_member && Tag != dwarf::DW_TAG_typedef &&
+      Tag != dwarf::DW_TAG_const_type && Tag != dwarf::DW_TAG_volatile_type &&
+      Tag != dwarf::DW_TAG_restrict_type)
+    return DDTy->getSizeInBits();
+
+  DIType *BaseType = DDTy->getBaseType().resolve();
+
+  assert(BaseType && "Unexpected invalid base type");
+
+  // If this is a derived type, go ahead and get the base type, unless it's a
+  // reference then it's just the size of the field. Pointer types have no need
+  // of this since they're a different type of qualification on the type.
+  if (BaseType->getTag() == dwarf::DW_TAG_reference_type ||
+      BaseType->getTag() == dwarf::DW_TAG_rvalue_reference_type)
+    return Ty->getSizeInBits();
+
+  return getBaseTypeSize(BaseType);
+}
+
 void DebugHandlerBase::beginFunction(const MachineFunction *MF) {
   // Grab the lexical scopes for the function, if we don't have any of those
   // then we're not going to be able to do anything.
   LScopes.initialize(*MF);
   if (LScopes.empty())
     return;
 
   // Make sure that each lexical scope will have a begin/end label.

llvm/trunk/lib/CodeGen/AsmPrinter/DwarfUnit.cpp

assert((Encoding == dwarf::DW_ATE_unsigned ||
            Ty->getName() == "decltype(nullptr)")) &&
          "Unsupported encoding");
   return Encoding == dwarf::DW_ATE_unsigned ||
          Encoding == dwarf::DW_ATE_unsigned_char ||
          Encoding == dwarf::DW_ATE_UTF || Encoding == dwarf::DW_ATE_boolean ||
          Ty->getTag() == dwarf::DW_TAG_unspecified_type;
 }
 
-/// If this type is derived from a base type then return base type size.
-static uint64_t getBaseTypeSize(DwarfDebug *DD, const DIDerivedType *Ty) {
-  unsigned Tag = Ty->getTag();
-
-  if (Tag != dwarf::DW_TAG_member && Tag != dwarf::DW_TAG_typedef &&
-      Tag != dwarf::DW_TAG_const_type && Tag != dwarf::DW_TAG_volatile_type &&
-      Tag != dwarf::DW_TAG_restrict_type)
-    return Ty->getSizeInBits();
-
-  auto *BaseType = DD->resolve(Ty->getBaseType());
-
-  assert(BaseType && "Unexpected invalid base type");
-
-  // If this is a derived type, go ahead and get the base type, unless it's a
-  // reference then it's just the size of the field. Pointer types have no need
-  // of this since they're a different type of qualification on the type.
-  if (BaseType->getTag() == dwarf::DW_TAG_reference_type ||
-      BaseType->getTag() == dwarf::DW_TAG_rvalue_reference_type)
-    return Ty->getSizeInBits();
-
-  if (auto *DT = dyn_cast<DIDerivedType>(BaseType))
-    return getBaseTypeSize(DD, DT);
-
-  return BaseType->getSizeInBits();
-}
-
 void DwarfUnit::addConstantFPValue(DIE &Die, const MachineOperand &MO) {
   assert(MO.isFPImm() && "Invalid machine operand!");
   DIEBlock *Block = new (DIEValueAllocator) DIEBlock;
   APFloat FPImm = MO.getFPImm()->getValueAPF();
 
   // Get the raw data form of the floating point.
   const APInt FltVal = FPImm.bitcastToAPInt();
   const char *FltPtr = (const char *)FltVal.getRawData();
if (DT->getTag() == dwarf::DW_TAG_inheritance && DT->isVirtual()) {
     addUInt(*VBaseLocationDie, dwarf::DW_FORM_udata, DT->getOffsetInBits());
     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_minus);
     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_deref);
     addUInt(*VBaseLocationDie, dwarf::DW_FORM_data1, dwarf::DW_OP_plus);
 
     addBlock(MemberDie, dwarf::DW_AT_data_member_location, VBaseLocationDie);
   } else {
     uint64_t Size = DT->getSizeInBits();
-    uint64_t FieldSize = getBaseTypeSize(DD, DT);
+    uint64_t FieldSize = DD->getBaseTypeSize(DT);
     uint64_t OffsetInBytes;
 
     bool IsBitfield = FieldSize && Size != FieldSize;
     if (IsBitfield) {
       // Handle bitfield, assume bytes are 8 bits.
       if (DD->useDWARF2Bitfields())
         addUInt(MemberDie, dwarf::DW_AT_byte_size, None, FieldSize/8);
       addUInt(MemberDie, dwarf::DW_AT_bit_size, None, Size);

llvm/trunk/test/DebugInfo/COFF/types-array-advanced.ll

+; RUN: llc < %s -filetype=obj | llvm-readobj - -codeview | FileCheck %s
+
+; C++ source to regenerate:
+; $ cat t.cpp
+; char multi_dim_arr[2][5][7];
+;
+; struct incomplete_struct(*p_incomplete_struct_arr)[3];
+; struct incomplete_struct {
+;   int s1;
+; } incomplete_struct_arr[3];
+;
+; void foo(int x) {
+;   int dyn_size_arr[x];
+;   dyn_size_arr[0] = 0;
+; }
+;
+; typedef const volatile int T_INT;
+; T_INT typedef_arr[4] = {0};
+; $ clang t.cpp -S -emit-llvm -g -gcodeview -o t.ll
+
+; CHECK: CodeViewTypes [
+; CHECK:   Section: .debug$T (6)
+; CHECK:   Magic: 0x4
+; CHECK:   ArgList (0x1000) {
+; CHECK:     TypeLeafKind: LF_ARGLIST (0x1201)
+; CHECK:     NumArgs: 1
+; CHECK:     Arguments [
+; CHECK:       ArgType: int (0x74)
+; CHECK:     ]
+; CHECK:   }
+; CHECK:   Procedure (0x1001) {
+; CHECK:     TypeLeafKind: LF_PROCEDURE (0x1008)
+; CHECK:     ReturnType: void (0x3)
+; CHECK:     CallingConvention: NearC (0x0)
+; CHECK:     FunctionOptions [ (0x0)
+; CHECK:     ]
+; CHECK:     NumParameters: 1
+; CHECK:     ArgListType: (int) (0x1000)
+; CHECK:   }
+; CHECK:   FuncId (0x1002) {
+; CHECK:     TypeLeafKind: LF_FUNC_ID (0x1601)
+; CHECK:     ParentScope: 0x0
+; CHECK:     FunctionType: void (int) (0x1001)
+; CHECK:     Name: foo
+; CHECK:   }
+; CHECK:   Array (0x1003) {
+; CHECK:     TypeLeafKind: LF_ARRAY (0x1503)
+; CHECK:     ElementType: int (0x74)
+; CHECK:     IndexType: unsigned long (0x22)
+; CHECK:     SizeOf: 4
+; CHECK:     Name: 
+; CHECK:   }
+; CHECK:   Array (0x1004) {
+; CHECK:     TypeLeafKind: LF_ARRAY (0x1503)
+; CHECK:     ElementType: char (0x70)
+; CHECK:     IndexType: unsigned long (0x22)
+; CHECK:     SizeOf: 7
+; CHECK:     Name: 
+; CHECK:   }
+; CHECK:   Array (0x1005) {
+; CHECK:     TypeLeafKind: LF_ARRAY (0x1503)
+; CHECK:     ElementType: 0x1004
+; CHECK:     IndexType: unsigned long (0x22)
+; CHECK:     SizeOf: 35
+; CHECK:     Name: 
+; CHECK:   }
+; CHECK:   Array (0x1006) {
+; CHECK:     TypeLeafKind: LF_ARRAY (0x1503)
+; CHECK:     ElementType: 0x1005
+; CHECK:     IndexType: unsigned long (0x22)
+; CHECK:     SizeOf: 70
+; CHECK:     Name: 
+; CHECK:   }
+; CHECK:   Struct (0x1007) {
+; CHECK:     TypeLeafKind: LF_STRUCTURE (0x1505)
+; CHECK:     MemberCount: 0
+; CHECK:     Properties [ (0x280)
+; CHECK:       ForwardReference (0x80)
+; CHECK:       HasUniqueName (0x200)
+; CHECK:     ]
+; CHECK:     FieldList: 0x0
+; CHECK:     DerivedFrom: 0x0
+; CHECK:     VShape: 0x0
+; CHECK:     SizeOf: 0
+; CHECK:     Name: incomplete_struct
+; CHECK:     LinkageName: .?AUincomplete_struct@@
+; CHECK:   }
+; CHECK:   Array (0x1008) {
+; CHECK:     TypeLeafKind: LF_ARRAY (0x1503)
+; CHECK:     ElementType: incomplete_struct (0x1007)
+; CHECK:     IndexType: unsigned long (0x22)
+; CHECK:     SizeOf: 12
+; CHECK:     Name: 
+; CHECK:   }
+; CHECK:   Pointer (0x1009) {
+; CHECK:     TypeLeafKind: LF_POINTER (0x1002)
+; CHECK:     PointeeType: 0x1008
+; CHECK:     PointerAttributes: 0x800A
+; CHECK:     PtrType: Near32 (0xA)
+; CHECK:     PtrMode: Pointer (0x0)
+; CHECK:     IsFlat: 0
+; CHECK:     IsConst: 0
+; CHECK:     IsVolatile: 0
+; CHECK:     IsUnaligned: 0
+; CHECK:     SizeOf: 4
+; CHECK:   }
+;
+; CHECK:   Modifier (0x100E) {
+; CHECK:     TypeLeafKind: LF_MODIFIER (0x1001)
+; CHECK:     ModifiedType: int (0x74)
+; CHECK:     Modifiers [ (0x3)
+; CHECK:       Const (0x1)
+; CHECK:       Volatile (0x2)
+; CHECK:     ]
+; CHECK:   }
+; CHECK:   Array (0x100F) {
+; CHECK:     TypeLeafKind: LF_ARRAY (0x1503)
+; CHECK:     ElementType: const volatile int (0x100E)
+; CHECK:     IndexType: unsigned long (0x22)
+; CHECK:     SizeOf: 16
+; CHECK:     Name:
+; CHECK:   }
+; CHECK: ]
+
+target datalayout = "e-m:x-p:32:32-i64:64-f80:32-n8:16:32-a:0:32-S32"
+target triple = "i686-pc-windows-msvc18.0.31101"
+
+%struct.incomplete_struct = type { i32 }
+
+@"\01?multi_dim_arr@@3PAY146DA" = global [2 x [5 x [7 x i8]]] zeroinitializer, align 1
+@"\01?p_incomplete_struct_arr@@3PAY02Uincomplete_struct@@A" = global [3 x i8]* null, align 4
+@"\01?incomplete_struct_arr@@3PAUincomplete_struct@@A" = global [3 x %struct.incomplete_struct] zeroinitializer, align 4
+@"\01?typedef_arr@@3SDHD" = constant [4 x i32] zeroinitializer, align 4
+
+; Function Attrs: nounwind
+define void @"\01?foo@@YAXH@Z"(i32 %x) #0 !dbg !31 {
+entry:
+  %x.addr = alloca i32, align 4
+  %saved_stack = alloca i8*, align 4
+  store i32 %x, i32* %x.addr, align 4
+  call void @llvm.dbg.declare(metadata i32* %x.addr, metadata !34, metadata !35), !dbg !36
+  %0 = load i32, i32* %x.addr, align 4, !dbg !37
+  %1 = call i8* @llvm.stacksave(), !dbg !38
+  store i8* %1, i8** %saved_stack, align 4, !dbg !38
+  %vla = alloca i32, i32 %0, align 4, !dbg !38
+  call void @llvm.dbg.declare(metadata i32* %vla, metadata !39, metadata !43), !dbg !44
+  %arrayidx = getelementptr inbounds i32, i32* %vla, i32 0, !dbg !45
+  store i32 0, i32* %arrayidx, align 4, !dbg !46
+  %2 = load i8*, i8** %saved_stack, align 4, !dbg !47
+  call void @llvm.stackrestore(i8* %2), !dbg !47
+  ret void, !dbg !47
+}
+
+; Function Attrs: nounwind readnone
+declare void @llvm.dbg.declare(metadata, metadata, metadata) #1
+
+; Function Attrs: nounwind
+declare i8* @llvm.stacksave() #2
+
+; Function Attrs: nounwind
+declare void @llvm.stackrestore(i8*) #2
+
+attributes #0 = { nounwind }
+attributes #1 = { nounwind readnone }
+attributes #2 = { nounwind }
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!28, !29}
+!llvm.ident = !{!30}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !1, producer: "clang version 3.9.0 (trunk 273874)", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, globals: !3)
+!1 = !DIFile(filename: "t.cpp", directory: "/")
+!2 = !{}
+!3 = !{!4, !11, !20, !21}
+!4 = distinct !DIGlobalVariable(name: "multi_dim_arr", linkageName: "\01?multi_dim_arr@@3PAY146DA", scope: !0, file: !1, line: 1, type: !5, isLocal: false, isDefinition: true, variable: [2 x [5 x [7 x i8]]]* @"\01?multi_dim_arr@@3PAY146DA")
+!5 = !DICompositeType(tag: DW_TAG_array_type, baseType: !6, size: 560, align: 8, elements: !7)
+!6 = !DIBasicType(name: "char", size: 8, align: 8, encoding: DW_ATE_signed_char)
+!7 = !{!8, !9, !10}
+!8 = !DISubrange(count: 2)
+!9 = !DISubrange(count: 5)
+!10 = !DISubrange(count: 7)
+!11 = distinct !DIGlobalVariable(name: "p_incomplete_struct_arr", linkageName: "\01?p_incomplete_struct_arr@@3PAY02Uincomplete_struct@@A", scope: !0, file: !1, line: 3, type: !12, isLocal: false, isDefinition: true, variable: [3 x i8]** @"\01?p_incomplete_struct_arr@@3PAY02Uincomplete_struct@@A")
+!12 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !13, size: 32, align: 32)
+!13 = !DICompositeType(tag: DW_TAG_array_type, baseType: !14, elements: !18)
+!14 = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "incomplete_struct", file: !1, line: 4, size: 32, align: 32, elements: !15, identifier: ".?AUincomplete_struct@@")
+!15 = !{!16}
+!16 = !DIDerivedType(tag: DW_TAG_member, name: "s1", scope: !14, file: !1, line: 5, baseType: !17, size: 32, align: 32)
+!17 = !DIBasicType(name: "int", size: 32, align: 32, encoding: DW_ATE_signed)
+!18 = !{!19}
+!19 = !DISubrange(count: 3)
+!20 = distinct !DIGlobalVariable(name: "incomplete_struct_arr", linkageName: "\01?incomplete_struct_arr@@3PAUincomplete_struct@@A", scope: !0, file: !1, line: 6, type: !13, isLocal: false, isDefinition: true, variable: [3 x %struct.incomplete_struct]* @"\01?incomplete_struct_arr@@3PAUincomplete_struct@@A")
+!21 = distinct !DIGlobalVariable(name: "typedef_arr", linkageName: "\01?typedef_arr@@3SDHD", scope: !0, file: !1, line: 14, type: !22, isLocal: false, isDefinition: true, variable: [4 x i32]* @"\01?typedef_arr@@3SDHD")
+!22 = !DICompositeType(tag: DW_TAG_array_type, baseType: !23, size: 128, align: 32, elements: !26)
+!23 = !DIDerivedType(tag: DW_TAG_typedef, name: "T_INT", file: !1, line: 13, baseType: !24)
+!24 = !DIDerivedType(tag: DW_TAG_const_type, baseType: !25)
+!25 = !DIDerivedType(tag: DW_TAG_volatile_type, baseType: !17)
+!26 = !{!27}
+!27 = !DISubrange(count: 4)
+!28 = !{i32 2, !"CodeView", i32 1}
+!29 = !{i32 2, !"Debug Info Version", i32 3}
+!30 = !{!"clang version 3.9.0 (trunk 273874)"}
+!31 = distinct !DISubprogram(name: "foo", linkageName: "\01?foo@@YAXH@Z", scope: !1, file: !1, line: 8, type: !32, isLocal: false, isDefinition: true, scopeLine: 8, flags: DIFlagPrototyped, isOptimized: false, unit: !0, variables: !2)
+!32 = !DISubroutineType(types: !33)
+!33 = !{null, !17}
+!34 = !DILocalVariable(name: "x", arg: 1, scope: !31, file: !1, line: 8, type: !17)
+!35 = !DIExpression()
+!36 = !DILocation(line: 8, column: 14, scope: !31)
+!37 = !DILocation(line: 9, column: 21, scope: !31)
+!38 = !DILocation(line: 9, column: 4, scope: !31)
+!39 = !DILocalVariable(name: "dyn_size_arr", scope: !31, file: !1, line: 9, type: !40)
+!40 = !DICompositeType(tag: DW_TAG_array_type, baseType: !17, align: 32, elements: !41)
+!41 = !{!42}
+!42 = !DISubrange(count: -1)
+!43 = !DIExpression(DW_OP_deref)
+!44 = !DILocation(line: 9, column: 8, scope: !31)
+!45 = !DILocation(line: 10, column: 4, scope: !31)
+!46 = !DILocation(line: 10, column: 20, scope: !31)
+!47 = !DILocation(line: 11, column: 1, scope: !31)