[Clang][CodeGen]Add constant array support for __builtin_dump_sturct

[yihanaa]

Summary

Add constant array support for __builtin_dump_sturct. For N-dimensional arrays, the new dumpArray function dumps the elements of the array by generating N layers of 'for' loops.
for example:
The struct:

struct Foo {
  int x;
};

struct S {
  int a[3];
  int b[2][2];
  struct Foo c[2];
};

The dump result:

struct S {
    int[3] a = [
        [0] = 1
        [1] = 2
        [2] = 3
    ]
    int[2][2] b = [
        [0] = [
            [0] = 1
            [1] = 2
        ]
        [1] = [
            [0] = 3
            [1] = 4
        ]
    ]
    struct Foo[2] c = [
        [0] = {
            int x = 1
        }
        [1] = {
            int x = 2
        }
    ]
}

[erichkeane]

clang/lib/CodeGen/CGBuiltin.cpp

2048

Instead of this initialization, can we make this a constexpr constructor/collection of some sort and instantiate it inline?

2049

I wonder if instead of this whole business, this function should just be replaced with a 'switch' on the types.

2071

When can we hit this case? Does this mean that any types we dont understand we are just treating as void ptrs?

2119

This branch doesn't seem right? We are in a ConstantArrayType, which means we DEFINITELY know the length. Additionally, Length is constructed directly from a llvm::ConstantInt::get, so we already know this answer.

2138

We already know if this is a 'zero' length array, we should probably just not emit IR at all in that case.

2204

instead of inArray you probably should have something a little more descriptive here, it seems what you really need is something like, includeTypeName, preferably as an enum to make it more clear at the caller side.

2257

Do we want to do anything for the OTHER array types?

2827

Typically we do a comment to explain what bool parms mean. Alternatively, if instead you could create an enum of some sort that would better describe the 'false', it wouldlikely be more helpful. (same on 2252).

[yihanaa]

Thanks for your suggestion @erichkeane !

clang/lib/CodeGen/CGBuiltin.cpp

2048

Instead of this initialization, can we make this a constexpr constructor/collection of some sort and instantiate it inline?

I don't have a good idea because it relies on Context to get some types like const char *

2071

The previous version treated it as a void *ptr for unsupported types, such as arrays (before this patch) and __int128. This is the case i saw in an issue. I also think that for unsupported types, we should generate a clearer message saying "This type is temporarily not supported", do you have any good ideas?

2119

I agree with you

2138

Good idea!

2204

I think that's a good idea for clarity.

2257

I understand struct fields must have a constant size, and I see" 'variable length array in structure' extension will never be supported" from clang's diagnostics

2827

I agree!

[erichkeane]

clang/lib/CodeGen/CGBuiltin.cpp

2048

We could at minimum do a in inline-initializer instead of the branch below.

2071

A diagnostic about ''TYPE' not yet supported by __bultin...' probably isn't a bad idea if we have the ability.

2257

Ah, right, good point. I think this + the diagnostic discussed above would make that alright.

There is ALSO the 'matrix' type that we could emit, but that might be worth a separate commit.

[yihanaa]

clang/lib/CodeGen/CGBuiltin.cpp

2071

I think maybe we can emit an error(or warning? in this way, it may be necessary to handle those unsupported types) diag msg, but that might be worth a separate commit. What do you think?

[erichkeane]

clang/lib/CodeGen/CGBuiltin.cpp

2071

As long as we are good about 'notes' to tell the user how we GOT to there, I'd think the warning would be useful. I'd probably just do something like, "FunnyType Foo = <unsupported>" rather than do something about it.

I'd be OK with that being a separate commit.

[yihanaa]

There is another question, which way should I print for an empty array?

#1: Same as non empty array

int[0] a = [
]

#2:

int[0] a = []

The #1's format is more uniform, and the #2 maybe looks a little clearer. What do you think? @erichkeane

[erichkeane]

In D122822#3420057, @yihanaa wrote:

There is another question, which way should I print for an empty array?

#1: Same as non empty array

int[0] a = [
]

#2:

int[0] a = []

The #1's format is more uniform, and the #2 maybe looks a little clearer. What do you think? @erichkeane

I'm not motivated one way or another, I can see the logic to each. I would do whichever doesn't require 'special' handling in any way.

[yihanaa]

clang/lib/CodeGen/CGBuiltin.cpp

2048

I still haven't come up with a good idea to do it😔

[erichkeane]

clang/lib/CodeGen/CGBuiltin.cpp

2048

Hrmph, DenseMap doesn't seem to have an init list ctor?!

Since this is a finite, known at compile time list of low 'N', I'd suggest just making it static std::array<pair<QualType, StringRef>> Types = {{Context.CharTy, "%c"},....

Then just doing a llvm::find_if. The list is small enough I suspect the DenseMap overhead is more than the use of llvm::find_if.

[yihanaa]

clang/lib/CodeGen/CGBuiltin.cpp

2048

Haha,DenseMap also has no constexpr ctor. I think the time complexity of these two is the same.

[rsmith]

I'm concerned about the direction of this patch given @rjmccall's comments on https://reviews.llvm.org/D112626 -- presumably the way we'd want to address those comments would be to convert a __builtin_dump_struct(a, f) call into a single f("...", a.x, a.y, a.z) call in Sema, and that approach doesn't seem compatible with generating code to loop over array elements.

I'm also concerned that this builtin is making a lot of design decisions on behalf of the programmer, meaning that either it does exactly what you want or it's not suitable for your use and there's not much you can do about it. A different design that let the programmer choose whether to recurse into structs and arrays and similarly let the programmer choose how to format the fields would seem preferable, but I'm not confident there's a good way to expose that in C (though in C++ there seem to be good designs to choose from). As an example of how that manifests here, the choice to print each element as a separate line for a struct member of type const char str[256]; is probably going to make the output very unreadable, but choosing to print every array of char using "%s" will be equally bad for arrays that don't contain text -- the "right" answer for a dumping facility probably involves checking whether the array contains only printable characters and trimming a trailing sequence of zeroes, but that seems like vastly more complexity than we'd want in code generated by a builtin.

[yihanaa]

clang/lib/CodeGen/CGBuiltin.cpp

2048

The Context.CharTy... etc. are not static, So we might need a static value instead of it, and compare it with QualType

[erichkeane]

clang/lib/CodeGen/CGBuiltin.cpp

2048

They don't have to be static? This should do 'magic static' initialization.

[yihanaa]

clang/lib/CodeGen/CGBuiltin.cpp

2048

I can't agree more. it might be a type identifier, such as getAsString()'s return value

[erichkeane]

clang/lib/CodeGen/CGBuiltin.cpp

2048

Actually, I don't think the collection can be static! When we re-use the same process for multiple TUs, we get a new ASTContext. SO this would result in us having types that don't necessarily 'match'. I think this collection/checks need to either be stored in ASTContext, or in an 'if-else' tree here.

[yihanaa]

In D122822#3420162, @rsmith wrote:

I'm concerned about the direction of this patch given @rjmccall's comments on https://reviews.llvm.org/D112626 -- presumably the way we'd want to address those comments would be to convert a __builtin_dump_struct(a, f) call into a single f("...", a.x, a.y, a.z) call in Sema, and that approach doesn't seem compatible with generating code to loop over array elements.

I'm also concerned that this builtin is making a lot of design decisions on behalf of the programmer, meaning that either it does exactly what you want or it's not suitable for your use and there's not much you can do about it. A different design that let the programmer choose whether to recurse into structs and arrays and similarly let the programmer choose how to format the fields would seem preferable, but I'm not confident there's a good way to expose that in C (though in C++ there seem to be good designs to choose from). As an example of how that manifests here, the choice to print each element as a separate line for a struct member of type const char str[256]; is probably going to make the output very unreadable, but choosing to print every array of char using "%s" will be equally bad for arrays that don't contain text -- the "right" answer for a dumping facility probably involves checking whether the array contains only printable characters and trimming a trailing sequence of zeroes, but that seems like vastly more complexity than we'd want in code generated by a builtin.

I'm also a newbie and only gradually integrated into the community with the help of @erichkeane , @aaron.ballman and others many times, this problem may be a bit difficult for me at the moment, but I'd be like to do a bigger overhaul of the whole builtin if that would make it more great.😉

[rjmccall]

In D122822#3420162, @rsmith wrote:

I'm concerned about the direction of this patch given @rjmccall's comments on https://reviews.llvm.org/D112626 -- presumably the way we'd want to address those comments would be to convert a __builtin_dump_struct(a, f) call into a single f("...", a.x, a.y, a.z) call in Sema, and that approach doesn't seem compatible with generating code to loop over array elements.

Well, we could generate a whole helper function that takes the struct by reference. That would also drastically improve the code-size impact of this builtin, since it's likely that the builtin will be used multiple times with the same struct.

I'm also concerned that this builtin is making a lot of design decisions on behalf of the programmer, meaning that either it does exactly what you want or it's not suitable for your use and there's not much you can do about it.

Yeah, I agree with this point, too; it's a very opinionated builtin.

[yihanaa]

clang/lib/CodeGen/CGBuiltin.cpp

2048

I also don't think it should be maintained in this place. Shouldn't this be better maintained together with the printf parameter checking part, what do you think?

[erichkeane]

clang/lib/CodeGen/CGBuiltin.cpp

2048

I'm unfamiliar with what you mean.

HOWEVER, the comments by @rsmith and @rjmccall I think are blocking on this feature/functionality anyway. So we might still wish to refactor this builtin significantly based on what they come up with.

[rsmith]

One thing we could do would be to build a descriptor for the type (as data) -- a type name string, a type "kind", plus (for a record type) a list of (field type descriptor, field name, offset) tuples -- and pass it to a user-specified function. We could provide a library implementation of a dumping function that takes that descriptor and a function with printf's signature and provides the "normal" formatting per the current __builtin_dump_struct behavior -- and indeed we could then implement __builtin_dump_struct(p, f) as a call to normal_dumping_function(__builtin_type_descriptor(T), p, f). I'm not sure how comfortable we'd be putting that library implementation in compiler-rt versus somewhere else, though it presumably wouldn't be very large.

[erichkeane]

In D122822#3420357, @rsmith wrote:

One thing we could do would be to build a descriptor for the type (as data) -- a type name string, a type "kind", plus (for a record type) a list of (field type descriptor, field name, offset) tuples -- and pass it to a user-specified function. We could provide a library implementation of a dumping function that takes that descriptor and a function with printf's signature and provides the "normal" formatting per the current __builtin_dump_struct behavior -- and indeed we could then implement __builtin_dump_struct(p, f) as a call to normal_dumping_function(__builtin_type_descriptor(T), p, f). I'm not sure how comfortable we'd be putting that library implementation in compiler-rt versus somewhere else, though it presumably wouldn't be very large.

This seems to be quickly decaying into 'implement Reflection', doesn't it? I see this __builtin_dump_struct to be a useful debugging builtin. As much as I see 'Reflection' as incredibly useful, I would think this is intended to be something much simpler, right?

[aaron.ballman]

In D122822#3420162, @rsmith wrote:

I'm also concerned that this builtin is making a lot of design decisions on behalf of the programmer, meaning that either it does exactly what you want or it's not suitable for your use and there's not much you can do about it.

FWIW, I'm not concerned by this. My understanding of this builtin is that it exists solely as a developer debugging aid (https://reviews.llvm.org/D44093) predominately for kernel folks when a debugger may not be available. As such, I view this the same as our other dump() methods -- we try to dump useful information, but ultimately, nobody should be relying on this output or building anything around it.

A different design that let the programmer choose whether to recurse into structs and arrays and similarly let the programmer choose how to format the fields would seem preferable, but I'm not confident there's a good way to expose that in C (though in C++ there seem to be good designs to choose from). As an example of how that manifests here, the choice to print each element as a separate line for a struct member of type const char str[256]; is probably going to make the output very unreadable, but choosing to print every array of char using "%s" will be equally bad for arrays that don't contain text -- the "right" answer for a dumping facility probably involves checking whether the array contains only printable characters and trimming a trailing sequence of zeroes, but that seems like vastly more complexity than we'd want in code generated by a builtin.

While this is interesting, I am not certain there's a lot of value to it as a debugging aid for times when a debugger is not available to you. It sounds like a fair amount of complexity, so I'd like to know whether there's a strong need for this much generality.

[yihanaa]

clang/lib/CodeGen/CGBuiltin.cpp

2048

Ah, I think the way I described it is not correct, my thought is, can this getDumpStructFormatSpecifier similar function be maintained in somewhere like FormatString.h😂

[yihanaa]

I also agree that this is a useful debugging builtin, and no program logic should be forced to depend on the output of this builtin. It's just used to print out some useful debugging information

[yihanaa]

clang/lib/CodeGen/CGBuiltin.cpp

2052

I think this types should have been promoted according to the integer promotions.

[erichkeane]

In D122822#3421089, @yihanaa wrote:

I also agree that this is a useful debugging builtin, and no program logic should be forced to depend on the output of this builtin. It's just used to print out some useful debugging information

FWIW, @rsmith is the clang-codeowner, so he's the one to convince (and @rjmccall is also a very senior reviewer). So I wouldn't be able to approve this patch without their consent/agreement.

[yihanaa]

In D122822#3422463, @erichkeane wrote:

In D122822#3421089, @yihanaa wrote:

I also agree that this is a useful debugging builtin, and no program logic should be forced to depend on the output of this builtin. It's just used to print out some useful debugging information

FWIW, @rsmith is the clang-codeowner, so he's the one to convince (and @rjmccall is also a very senior reviewer). So I wouldn't be able to approve this patch without their consent/agreement.

Thank you for your information, @erichkeane I really hope we can find a solution and reach a consensus😊

clang/docs/ReleaseNotes.rst

 
 Non-comprehensive list of changes in this release
 -------------------------------------------------
 - Improve __builtin_dump_struct:
   - Support bitfields in struct and union.
   - Improve the dump format, dump both bitwidth(if its a bitfield) and field value.
   - Remove anonymous tag locations.
   - Beautify dump format, add indent for nested struct and struct members.
+  - Support constant array in struct and union.
 
 New Compiler Flags
 ------------------
 
 Deprecated Compiler Flags
 -------------------------
 
 Modified Compiler Flags

clang/lib/CodeGen/CGBuiltin.cpp

EmitCheckedMixedSignMultiply(CodeGenFunction &CGF, const clang::Expr *Op1,
 
   bool isVolatile =
       ResultArg->getType()->getPointeeType().isVolatileQualified();
   CGF.Builder.CreateStore(CGF.EmitToMemory(Result, ResultQTy), ResultPtr,
                           isVolatile);
   return RValue::get(Overflow);
 }
 
-static llvm::Value *dumpRecord(CodeGenFunction &CGF, QualType RType,
-                               LValue RecordLV, CharUnits Align,
-                               llvm::FunctionCallee Func, int Lvl) {
-  ASTContext &Context = CGF.getContext();
-  RecordDecl *RD = RType->castAs<RecordType>()->getDecl()->getDefinition();
-  std::string Pad = std::string(Lvl * 4, ' ');
-  std::string ElementPad = std::string((Lvl + 1) * 4, ' ');
-
-  PrintingPolicy Policy(Context.getLangOpts());
-  Policy.AnonymousTagLocations = false;
-  Value *GString = CGF.Builder.CreateGlobalStringPtr(
-    llvm::Twine(Pad).concat(RType.getAsString(Policy)).concat(" {\n").str());
-  Value *Res = CGF.Builder.CreateCall(Func, {GString});
-
-  static llvm::DenseMap<QualType, const char *> Types;
+static StringRef getDumpStructFormatSpecifier(ASTContext &Context,
+                                              QualType Type) {
+  static llvm::DenseMap<QualType, StringRef> Types;
   if (Types.empty()) {
     Types[Context.CharTy] = "%c";
     Types[Context.BoolTy] = "%d";
     Types[Context.SignedCharTy] = "%hhd";
     Types[Context.UnsignedCharTy] = "%hhu";
     Types[Context.IntTy] = "%d";
     Types[Context.UnsignedIntTy] = "%u";
     Types[Context.LongTy] = "%ld";
     Types[Context.UnsignedLongTy] = "%lu";
     Types[Context.LongLongTy] = "%lld";
     Types[Context.UnsignedLongLongTy] = "%llu";
     Types[Context.ShortTy] = "%hd";
     Types[Context.UnsignedShortTy] = "%hu";
     Types[Context.VoidPtrTy] = "%p";
     Types[Context.FloatTy] = "%f";
     Types[Context.DoubleTy] = "%f";
     Types[Context.LongDoubleTy] = "%Lf";
     Types[Context.getPointerType(Context.CharTy)] = "%s";
     Types[Context.getPointerType(Context.getConstType(Context.CharTy))] = "%s";
   }
 
+  if (Types.find(Type) == Types.end())
+    return Types[Context.VoidPtrTy];
+  return Types[Type];
+}
+
+static llvm::Value *dumpRecord(CodeGenFunction &CGF, QualType RType,
+                               LValue RecordLV, CharUnits Align, bool inArray,
+                               llvm::FunctionCallee Func, int Lvl);
+
+static llvm::Value *dumpArray(CodeGenFunction &CGF, QualType ArrayType,
+                              LValue LV, CharUnits Align,
+                              llvm::FunctionCallee Func, int Lvl) {
+  assert(ArrayType->isConstantArrayType() && "required an array type");
+  auto &Builder = CGF.Builder;
+  ASTContext &Context = CGF.getContext();
+  std::string Pad = std::string(Lvl * 4, ' ');
+  std::string ElementPad = std::string((Lvl + 1) * 4, ' ');
+  std::string &LastElementPad = Pad;
+  std::string Name = "__builtin_dump_struct.array.";
+
+  auto GetConstInt = [&CGF](int64_t Val) -> llvm::ConstantInt * {
+    return llvm::ConstantInt::get(CGF.IntPtrTy, Val, true);
+  };
+
+  auto GetInstName = [&Name, &Lvl](StringRef Suffix) -> std::string {
+    return llvm::Twine(Name)
+        .concat(Suffix)
+        .concat(".")
+        .concat(llvm::Twine(Lvl))
+        .str();
+  };
+
+  const ConstantArrayType *CAT = Context.getAsConstantArrayType(ArrayType);
+  QualType ElementType = CAT->getElementType();
+  Address ArrayAddress = LV.getAddress(CGF);
+
+  CharUnits ElementAlign = ArrayAddress.getAlignment().alignmentOfArrayElement(
+      Context.getTypeSizeInChars(ArrayType));
+
+  const llvm::ArrayType *LLVMArrayType =
+      dyn_cast<llvm::ArrayType>(ArrayAddress.getElementType());
+
+  // The length of an array in elements, as well as the base element type and a
+  // properly-typed first element pointer.
+  llvm::Value *Length = GetConstInt(LLVMArrayType->getNumElements());
+
+  // Normally we have to check whether the array is zero-length.
+  bool CheckZeroLength = true;
+  // But if the array length is constant, we can suppress that.
+  if (llvm::ConstantInt *CL = dyn_cast<llvm::ConstantInt>(Length)) {
+    // ...and if it's constant zero, we can just skip the entire thing.
+    if (!CL->isZero())
+      CheckZeroLength = false;
+  }
+
+  llvm::Value *Begin = ArrayAddress.getPointer();
+  llvm::Value *End =
+      Builder.CreateInBoundsGEP(ArrayAddress.getElementType(), Begin, Length);
+
+  Address IndexAddr = CGF.CreateTempAlloca(CGF.IntPtrTy, CGF.getSizeAlign(),
+                                           "index", GetConstInt(1), nullptr);
+  llvm::Value *Index = Builder.CreateStore(GetConstInt(0), IndexAddr);
+
+  // The basic structure here is a do-while loop, because we don't
+  // need to check for the zero-element case.
+  llvm::BasicBlock *BodyBB = CGF.createBasicBlock(GetInstName("body"));
+  llvm::BasicBlock *DoneBB = CGF.createBasicBlock(GetInstName("done"));
+
+  if (CheckZeroLength) {
+    llvm::Value *isEmpty =
+        Builder.CreateICmpEQ(Begin, End, GetInstName("isempty"));
+    CGF.Builder.CreateCondBr(isEmpty, DoneBB, BodyBB);
+  }
+
+  llvm::Value *GString = Builder.CreateGlobalStringPtr("[\n");
+  llvm::Value *Res = Builder.CreateCall(Func, {GString});
+  llvm::Value *TmpRes = nullptr;
+
+  CGF.EmitBlock(BodyBB);
+  Index = Builder.CreateLoad(IndexAddr);
+  llvm::Value *Element = Builder.CreateInBoundsGEP(
+      ArrayAddress.getElementType(), ArrayAddress.getPointer(),
+      {CGF.CGM.getSize(CharUnits::Zero()), Index});
+  Address ElementAddr =
+      Address(Element, LLVMArrayType->getElementType(), ElementAlign);
+  LValue ElementLV = CGF.MakeAddrLValue(ElementAddr, ElementType);
+
+  GString = Builder.CreateGlobalStringPtr(
+      llvm::Twine(ElementPad).concat("[%ld] = ").str());
+  TmpRes = CGF.Builder.CreateCall(Func, {GString, Index});
+  Res = CGF.Builder.CreateAdd(Res, TmpRes);
+
+  if (ElementType->isConstantArrayType()) {
+    TmpRes =
+        dumpArray(CGF, ElementType, ElementLV, ElementAlign, Func, Lvl + 1);
+    Res = Builder.CreateAdd(Res, TmpRes);
+  } else {
+    if (ElementType->isRecordType()) {
+      TmpRes = dumpRecord(CGF, ElementType, ElementLV, ElementAlign, true, Func,
+                          Lvl + 1);
+    } else {
+      StringRef Format = getDumpStructFormatSpecifier(Context, ElementType);
+      GString =
+          Builder.CreateGlobalStringPtr(llvm::Twine(Format).concat("\n").str());
+      RValue RV = CGF.EmitLoadOfLValue(ElementLV, SourceLocation());
+      TmpRes = CGF.Builder.CreateCall(Func, {GString, RV.getScalarVal()});
+    }
+    Res = CGF.Builder.CreateAdd(Res, TmpRes);
+  }
+
+  Index = Builder.CreateAdd(Index, GetConstInt(1));
+  Builder.CreateStore(Index, IndexAddr);
+
+  llvm::Value *Done = Builder.CreateICmpEQ(Index, Length);
+  Builder.CreateCondBr(Done, DoneBB, BodyBB);
+
+  CGF.EmitBlock(DoneBB);
+  GString = Builder.CreateGlobalStringPtr(
+      llvm::Twine(LastElementPad).concat("]\n").str());
+  TmpRes = Builder.CreateCall(Func, {GString});
+  Res = Builder.CreateAdd(TmpRes, Res);
+  return Res;
+}
+
+static llvm::Value *dumpRecord(CodeGenFunction &CGF, QualType RType,
+                               LValue RecordLV, CharUnits Align, bool inArray,
+                               llvm::FunctionCallee Func, int Lvl) {
+  ASTContext &Context = CGF.getContext();
+  RecordDecl *RD = RType->castAs<RecordType>()->getDecl()->getDefinition();
+  std::string Pad = std::string(Lvl * 4, ' ');
+  std::string FieldPad = std::string((Lvl + 1) * 4, ' ');
+
+  Value *GString = nullptr;
+  if (inArray) {
+    GString = CGF.Builder.CreateGlobalStringPtr("{\n");
+  } else {
+    PrintingPolicy Policy(Context.getLangOpts());
+    Policy.AnonymousTagLocations = false;
+    GString =
+        CGF.Builder.CreateGlobalStringPtr(llvm::Twine(Pad)
+                                              .concat(RType.getAsString(Policy))
+                                              .concat(" {\n")
+                                              .str());
+  }
+  Value *Res = CGF.Builder.CreateCall(Func, {GString});
+
   for (const auto *FD : RD->fields()) {
     Value *TmpRes = nullptr;
 
-    std::string Format = llvm::Twine(ElementPad)
+    std::string Format = llvm::Twine(FieldPad)
                              .concat(FD->getType().getAsString())
                              .concat(llvm::Twine(' '))
                              .concat(FD->getNameAsString())
                              .str();
 
     if (FD->isBitField()) {
       unsigned BitfieldWidth = FD->getBitWidthValue(CGF.getContext());
 
for (const auto *FD : RD->fields()) {
     }
 
     LValue FieldLV = CGF.EmitLValueForField(RecordLV, FD);
     QualType CanonicalType =
         FD->getType().getUnqualifiedType().getCanonicalType();
 
     // We check whether we are in a recursive type
     if (CanonicalType->isRecordType()) {
-      TmpRes = dumpRecord(CGF, CanonicalType, FieldLV, Align, Func, Lvl + 1);
+      TmpRes =
+          dumpRecord(CGF, CanonicalType, FieldLV, Align, false, Func, Lvl + 1);
+      Res = CGF.Builder.CreateAdd(TmpRes, Res);
+      continue;
+    }
+
+    if (CanonicalType->isConstantArrayType()) {
+      GString = CGF.Builder.CreateGlobalStringPtr(
+          llvm::Twine(Format).concat(" = ").str());
+      TmpRes = CGF.Builder.CreateCall(Func, {GString});
+      Res = CGF.Builder.CreateAdd(Res, TmpRes);
+      TmpRes = dumpArray(CGF, CanonicalType, FieldLV, Align, Func, Lvl + 1);
       Res = CGF.Builder.CreateAdd(TmpRes, Res);
       continue;
     }
 
     // We try to determine the best format to print the current field
-    const char *TypeFormat = Types.find(CanonicalType) == Types.end()
-                                 ? Types[Context.VoidPtrTy]
-                                 : Types[CanonicalType];
+    StringRef TypeFormat = getDumpStructFormatSpecifier(Context, CanonicalType);
 
     GString = CGF.Builder.CreateGlobalStringPtr(llvm::Twine(Format)
                                                     .concat(" = ")
                                                     .concat(TypeFormat)
                                                     .concat(llvm::Twine('\n'))
                                                     .str());
 
     RValue RV = FD->isBitField()
case Builtin::BI__builtin_dump_struct: {
     Value *Func = EmitScalarExpr(E->getArg(1)->IgnoreImpCasts());
     CharUnits Arg0Align = EmitPointerWithAlignment(E->getArg(0)).getAlignment();
 
     const Expr *Arg0 = E->getArg(0)->IgnoreImpCasts();
     QualType Arg0Type = Arg0->getType()->getPointeeType();
 
     Value *RecordPtr = EmitScalarExpr(Arg0);
     LValue RecordLV = MakeAddrLValue(RecordPtr, Arg0Type, Arg0Align);
-    Value *Res = dumpRecord(*this, Arg0Type, RecordLV, Arg0Align,
+    Value *Res = dumpRecord(*this, Arg0Type, RecordLV, Arg0Align, false,
                             {LLVMFuncType, Func}, 0);
     return RValue::get(Res);
   }
 
   case Builtin::BI__builtin_preserve_access_index: {
     // Only enabled preserved access index region when debuginfo
     // is available as debuginfo is needed to preserve user-level
     // access pattern.

clang/test/CodeGen/dump-struct-builtin.c

 
 // CHECK: @__const.unit14.a = private unnamed_addr constant %struct.U14A { double 0x3FF1F9ACFFA7EB6C }, align 8
 // CHECK-NEXT: [[STRUCT_STR_U14:@[0-9]+]] = private unnamed_addr constant [15 x i8] c"struct U14A {\0A\00", align 1
 // CHECK-NEXT: [[FIELD_U14:@[0-9]+]] = private unnamed_addr constant [19 x i8] c"    double a = %f\0A\00", align 1
 // CHECK-NEXT: [[END_STRUCT_U14:@[0-9]+]] = private unnamed_addr constant [3 x i8] c"}\0A\00", align 1
 
 // CHECK: @__const.unit15.a = private unnamed_addr constant %struct.U15A { [3 x i32] [i32 1, i32 2, i32 3] }, align 4
 // CHECK-NEXT: [[STRUCT_STR_U15:@[0-9]+]] = private unnamed_addr constant [15 x i8] c"struct U15A {\0A\00", align 1
-// CHECK-NEXT: [[FIELD_U15:@[0-9]+]] = private unnamed_addr constant [19 x i8] c"    int[3] a = %p\0A\00", align 1
+// CHECK-NEXT: [[FIELD_U15:@[0-9]+]] = private unnamed_addr constant [16 x i8] c"    int[3] a = \00", align 1
+// CHECK-NEXT: [[ARRAY_L_SQUARE_U15:@[0-9]+]] = private unnamed_addr constant [3 x i8] c"[\0A\00", align 1
+// CHECK-NEXT: [[ARRAY_INDEX_U15:@[0-9]+]] = private unnamed_addr constant [17 x i8] c"        [%ld] = \00", align 1
+// CHECK-NEXT: [[ARRAY_ELEMENT_U15:@[0-9]+]] = private unnamed_addr constant [4 x i8] c"%d\0A\00", align 1
+// CHECK-NEXT: [[ARRAY_R_SQUARE_U15:@[0-9]+]] = private unnamed_addr constant [7 x i8] c"    ]\0A\00", align 1
 // CHECK-NEXT: [[END_STRUCT_U15:@[0-9]+]] = private unnamed_addr constant [3 x i8] c"}\0A\00", align 1
 
 // CHECK: @__const.unit16.a = private unnamed_addr constant %struct.U16A { i8 12 }, align 1
 // CHECK-NEXT: [[STRUCT_STR_U16:@[0-9]+]] = private unnamed_addr constant [15 x i8] c"struct U16A {\0A\00", align 1
 // CHECK-NEXT: [[FIELD_U16:@[0-9]+]] = private unnamed_addr constant [22 x i8] c"    uint8_t a = %hhu\0A\00", align 1
 // CHECK-NEXT: [[END_STRUCT_U16:@[0-9]+]] = private unnamed_addr constant [3 x i8] c"}\0A\00", align 1
 
 // CHECK: @__const.unit17.a = private unnamed_addr constant %struct.U17A { i8 12 }, align 1
 // CHECK-NEXT: [[STRUCT_STR_U17:@[0-9]+]] = private unnamed_addr constant [15 x i8] c"struct U17A {\0A\00", align 1
 // CHECK-NEXT: [[FIELD_U17:@[0-9]+]] = private unnamed_addr constant [21 x i8] c"    int8_t a = %hhd\0A\00", align 1
 // CHECK-NEXT: [[END_STRUCT_U17:@[0-9]+]] = private unnamed_addr constant [3 x i8] c"}\0A\00", align 1
 
 // CHECK: @__const.unit18.a = private unnamed_addr constant %struct.U18A { x86_fp80 0xK3FFF8FCD67FD3F5B6000 }, align 16
 // CHECK-NEXT: [[STRUCT_STR_U18:@[0-9]+]] = private unnamed_addr constant [15 x i8] c"struct U18A {\0A\00", align 1
 // CHECK-NEXT: [[FIELD_U18:@[0-9]+]] = private unnamed_addr constant [25 x i8] c"    long double a = %Lf\0A\00", align 1
 // CHECK-NEXT: [[END_STRUCT_U18:@[0-9]+]] = private unnamed_addr constant [3 x i8] c"}\0A\00", align 1
 
+// CHECK: @__const.unit19.a = private unnamed_addr constant %struct.T19A { {{.*}} }, align 4
+// CHECK-NEXT: [[STRUCT_STR_U19:@[0-9]+]] = private unnamed_addr constant [15 x i8] c"struct T19A {\0A\00", align 1
+// CHECK-NEXT: [[FIELD_U19:@[0-9]+]] = private unnamed_addr constant [19 x i8] c"    int[2][2] b = \00", align 1
+// CHECK-NEXT: [[ARRAY_L_SQUARE_U19:@[0-9]+]] = private unnamed_addr constant [3 x i8] c"[\0A\00", align 1
+// CHECK-NEXT: [[ARRAY_INDEX_U19:@[0-9]+]] = private unnamed_addr constant [17 x i8] c"        [%ld] = \00", align 1
+// CHECK-NEXT: [[ARRAY_L_SQUARE2_U19:@[0-9]+]] = private unnamed_addr constant [3 x i8] c"[\0A\00", align 1
+// CHECK-NEXT: [[ARRAY_INDEX2_U19:@[0-9]+]] = private unnamed_addr constant [21 x i8] c"            [%ld] = \00", align 1
+// CHECK-NEXT: [[ARRAY_ELEMENT_U19:@[0-9]+]] = private unnamed_addr constant [4 x i8] c"%d\0A\00", align 1
+// CHECK-NEXT: [[ARRAY_R_SQUARE2_U19:@[0-9]+]] = private unnamed_addr constant [11 x i8] c"        ]\0A\00", align 1
+// CHECK-NEXT: [[ARRAY_R_SQUARE_U19:@[0-9]+]] = private unnamed_addr constant [7 x i8] c"    ]\0A\00", align 1
+// CHECK-NEXT: [[END_STRUCT_U19:@[0-9]+]] = private unnamed_addr constant [3 x i8] c"}\0A\00", align 1
+
 int printf(const char *fmt, ...) {
     return 0;
 }
 
 void unit1(void) {
   struct U1A {
     short a;
   };
 
   struct U1A a = {
       .a = 12,
   };
   // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([14 x i8], [14 x i8]* [[STRUCT_STR_U1]], i32 0, i32 0))
-  // CHECK: [[RES1:%.*]] = getelementptr inbounds %struct.U1A, %struct.U1A* %a, i32 0, i32 0
-  // CHECK: [[LOAD1:%.*]] = load i16, i16* [[RES1]],
+  // CHECK: [[RES1:%[−a−zA−Z._0-9]+]] = getelementptr inbounds %struct.U1A, %struct.U1A* %a, i32 0, i32 0
+  // CHECK: [[LOAD1:%[0-9]+]] = load i16, i16* [[RES1]],
   // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* [[FIELD_U1]], i32 0, i32 0), i16 [[LOAD1]])
   // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* [[END_STRUCT_U1]], i32 0, i32 0))
   __builtin_dump_struct(&a, &printf);
 }
 
 void unit2(void) {
   struct U2A {
     unsigned short a;
   };
 
   struct U2A a = {
       .a = 12,
   };
 
   // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([14 x i8], [14 x i8]* [[STRUCT_STR_U2]], i32 0, i32 0))
-  // CHECK: [[RES1:%.*]] = getelementptr inbounds %struct.U2A, %struct.U2A* %a, i32 0, i32 0
-  // CHECK: [[LOAD1:%.*]] = load i16, i16* [[RES1]],
+  // CHECK: [[RES1:%[−a−zA−Z._0-9]+]] = getelementptr inbounds %struct.U2A, %struct.U2A* %a, i32 0, i32 0
+  // CHECK: [[LOAD1:%[0-9]+]] = load i16, i16* [[RES1]],
   // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([28 x i8], [28 x i8]* [[FIELD_U2]], i32 0, i32 0), i16 [[LOAD1]])
   // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* [[END_STRUCT_U2]], i32 0, i32 0))
   __builtin_dump_struct(&a, &printf);
 }
 
 void unit3(void) {
   struct U3A {
     int a;
   };
 
   struct U3A a = {
       .a = 12,
   };
 
   // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([14 x i8], [14 x i8]* [[STRUCT_STR_U3]], i32 0, i32 0))
-  // CHECK: [[RES1:%.*]] = getelementptr inbounds %struct.U3A, %struct.U3A* %a, i32 0, i32 0
-  // CHECK: [[LOAD1:%.*]] = load i32, i32* [[RES1]],
+  // CHECK: [[RES1:%[−a−zA−Z._0-9]+]] = getelementptr inbounds %struct.U3A, %struct.U3A* %a, i32 0, i32 0
+  // CHECK: [[LOAD1:%[0-9]+]] = load i32, i32* [[RES1]],
   // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([16 x i8], [16 x i8]* [[FIELD_U3]], i32 0, i32 0), i32 [[LOAD1]])
   // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* [[END_STRUCT_U3]], i32 0, i32 0)
   __builtin_dump_struct(&a, &printf);
 }
 
 void unit4(void) {
   struct U4A {
     unsigned int a;
   };
 
   struct U4A a = {
       .a = 12,
   };
 
   // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([14 x i8], [14 x i8]* [[STRUCT_STR_U4]], i32 0, i32 0))
-  // CHECK: [[RES1:%.*]] = getelementptr inbounds %struct.U4A, %struct.U4A* %a, i32 0, i32 0
-  // CHECK: [[LOAD1:%.*]] = load i32, i32* [[RES1]],
+  // CHECK: [[RES1:%[−a−zA−Z._0-9]+]] = getelementptr inbounds %struct.U4A, %struct.U4A* %a, i32 0, i32 0
+  // CHECK: [[LOAD1:%[0-9]+]] = load i32, i32* [[RES1]],
   // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([25 x i8], [25 x i8]* [[FIELD_U4]], i32 0, i32 0), i32 [[LOAD1]])
   // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* [[END_STRUCT_U4]], i32 0, i32 0)
   __builtin_dump_struct(&a, &printf);
 }
 
 void unit5(void) {
   struct U5A {
     long a;
   };
 
   struct U5A a = {
       .a = 12,
   };
 
   // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([14 x i8], [14 x i8]* [[STRUCT_STR_U5]], i32 0, i32 0))
-  // CHECK: [[RES1:%.*]] = getelementptr inbounds %struct.U5A, %struct.U5A* %a, i32 0, i32 0
-  // CHECK: [[LOAD1:%.*]] = load i64, i64* [[RES1]],
+  // CHECK: [[RES1:%[−a−zA−Z._0-9]+]] = getelementptr inbounds %struct.U5A, %struct.U5A* %a, i32 0, i32 0
+  // CHECK: [[LOAD1:%[0-9]+]] = load i64, i64* [[RES1]],
   // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* [[FIELD_U5]], i32 0, i32 0), i64 [[LOAD1]])
   // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* [[END_STRUCT_U5]], i32 0, i32 0)
   __builtin_dump_struct(&a, &printf);
 }
 
 void unit6(void) {
   struct U6A {
     unsigned long a;
   };
 
   struct U6A a = {
       .a = 12,
   };
 
   // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([14 x i8], [14 x i8]* [[STRUCT_STR_U6]], i32 0, i32 0))
-  // CHECK: [[RES1:%.*]] = getelementptr inbounds %struct.U6A, %struct.U6A* %a, i32 0, i32 0
-  // CHECK: [[LOAD1:%.*]] = load i64, i64* [[RES1]],
+  // CHECK: [[RES1:%[−a−zA−Z._0-9]+]] = getelementptr inbounds %struct.U6A, %struct.U6A* %a, i32 0, i32 0
+  // CHECK: [[LOAD1:%[0-9]+]] = load i64, i64* [[RES1]],
   // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([27 x i8], [27 x i8]* [[FIELD_U6]], i32 0, i32 0), i64 [[LOAD1]])
   // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* [[END_STRUCT_U6]], i32 0, i32 0)
   __builtin_dump_struct(&a, &printf);
 }
 
 void unit7(void) {
   struct U7A {
     long long a;
   };
 
   struct U7A a = {
       .a = 12,
   };
 
   // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([14 x i8], [14 x i8]* [[STRUCT_STR_U7]], i32 0, i32 0))
-  // CHECK: [[RES1:%.*]] = getelementptr inbounds %struct.U7A, %struct.U7A* %a, i32 0, i32 0
-  // CHECK: [[LOAD1:%.*]] = load i64, i64* [[RES1]],
+  // CHECK: [[RES1:%[−a−zA−Z._0-9]+]] = getelementptr inbounds %struct.U7A, %struct.U7A* %a, i32 0, i32 0
+  // CHECK: [[LOAD1:%[0-9]+]] = load i64, i64* [[RES1]],
   // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([24 x i8], [24 x i8]* [[FIELD_U7]], i32 0, i32 0), i64 [[LOAD1]])
   // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* [[END_STRUCT_U7]], i32 0, i32 0)
   __builtin_dump_struct(&a, &printf);
 }
 
 void unit8(void) {
   struct U8A {
     unsigned long long a;
   };
 
   struct U8A a = {
       .a = 12,
   };
 
   // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([14 x i8], [14 x i8]* [[STRUCT_STR_U8]], i32 0, i32 0))
-  // CHECK: [[RES1:%.*]] = getelementptr inbounds %struct.U8A, %struct.U8A* %a, i32 0, i32 0
-  // CHECK: [[LOAD1:%.*]] = load i64, i64* [[RES1]],
+  // CHECK: [[RES1:%[−a−zA−Z._0-9]+]] = getelementptr inbounds %struct.U8A, %struct.U8A* %a, i32 0, i32 0
+  // CHECK: [[LOAD1:%[0-9]+]] = load i64, i64* [[RES1]],
   // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([33 x i8], [33 x i8]* [[FIELD_U8]], i32 0, i32 0), i64 [[LOAD1]])
   // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* [[END_STRUCT_U8]], i32 0, i32 0)
   __builtin_dump_struct(&a, &printf);
 }
 
 void unit9(void) {
   struct U9A {
     char a;
   };
 
   struct U9A a = {
       .a = 'a',
   };
 
   // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([14 x i8], [14 x i8]* [[STRUCT_STR_U9]], i32 0, i32 0))
-  // CHECK: [[RES1:%.*]] = getelementptr inbounds %struct.U9A, %struct.U9A* %a, i32 0, i32 0
-  // CHECK: [[LOAD1:%.*]] = load i8, i8* [[RES1]],
+  // CHECK: [[RES1:%[−a−zA−Z._0-9]+]] = getelementptr inbounds %struct.U9A, %struct.U9A* %a, i32 0, i32 0
+  // CHECK: [[LOAD1:%[0-9]+]] = load i8, i8* [[RES1]],
   // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([17 x i8], [17 x i8]* [[FIELD_U9]], i32 0, i32 0), i8 [[LOAD1]])
   // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* [[END_STRUCT_U9]], i32 0, i32 0)
   __builtin_dump_struct(&a, &printf);
 }
 
 void unit10(void) {
   struct U10A {
     char *a;
   };
 
   struct U10A a = {
       .a = "LSE",
   };
 
   // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* [[STRUCT_STR_U10]], i32 0, i32 0))
-  // CHECK: [[RES1:%.*]] = getelementptr inbounds %struct.U10A, %struct.U10A* %a, i32 0, i32 0
-  // CHECK: [[LOAD1:%.*]] = load i8*, i8** [[RES1]],
+  // CHECK: [[RES1:%[−a−zA−Z._0-9]+]] = getelementptr inbounds %struct.U10A, %struct.U10A* %a, i32 0, i32 0
+  // CHECK: [[LOAD1:%[0-9]+]] = load i8*, i8** [[RES1]],
   // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* [[FIELD_U10]], i32 0, i32 0), i8* [[LOAD1]])
   // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* [[END_STRUCT_U10]], i32 0, i32 0)
   __builtin_dump_struct(&a, &printf);
 }
 
 void unit11(void) {
   struct U11A {
     void *a;
   };
 
   struct U11A a = {
       .a = (void *)0x12345678,
   };
 
   // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* [[STRUCT_STR_U11]], i32 0, i32 0))
-  // CHECK: [[RES1:%.*]] = getelementptr inbounds %struct.U11A, %struct.U11A* %a, i32 0, i32 0
-  // CHECK: [[LOAD1:%.*]] = load i8*, i8** [[RES1]],
+  // CHECK: [[RES1:%[−a−zA−Z._0-9]+]] = getelementptr inbounds %struct.U11A, %struct.U11A* %a, i32 0, i32 0
+  // CHECK: [[LOAD1:%[0-9]+]] = load i8*, i8** [[RES1]],
   // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* [[FIELD_U11]], i32 0, i32 0), i8* [[LOAD1]])
   // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* [[END_STRUCT_U11]], i32 0, i32 0)
   __builtin_dump_struct(&a, &printf);
 }
 
 void unit12(void) {
   struct U12A {
     const char *a;
void unit15(void) {
   };
 
   struct U15A a = {
       .a = {1, 2, 3},
   };
 
   // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* [[STRUCT_STR_U15]], i32 0, i32 0))
   // CHECK: [[RES1:%.*]] = getelementptr inbounds %struct.U15A, %struct.U15A* %a, i32 0, i32 0
-  // CHECK: [[LOAD1:%.*]] = load [3 x i32], [3 x i32]* [[RES1]],
-  // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* [[FIELD_U15]], i32 0, i32 0), [3 x i32] [[LOAD1]])
-  // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* [[END_STRUCT_U15]], i32 0, i32 0)
+  // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([16 x i8], [16 x i8]* [[FIELD_U15]], i32 0, i32 0))
+  // CHECK: [[ARRAY_PTR:%.*]] = getelementptr inbounds [3 x i32], [3 x i32]* [[RES1]], i64 3
+  // CHECK: [[ALLOC_INDEX:%.*]] = alloca i64, i64 1,
+  // CHECK: store i64 0, i64* [[ALLOC_INDEX]],
+  // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* [[ARRAY_L_SQUARE_U15]], i32 0, i32 0))
+  // CHECK: br label %__builtin_dump_struct.array.body.1
+
+  // CHECK: __builtin_dump_struct.array.body.1:
+  // CHECK: [[INDEX:%.*]] = load i64, i64* [[ALLOC_INDEX]]
+  // CHECK: [[RES2:%.*]] = getelementptr inbounds [3 x i32], [3 x i32]* [[RES1]], i64 0, i64 [[INDEX]]
+  // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([17 x i8], [17 x i8]* [[ARRAY_INDEX_U15]], i32 0, i32 0), i64 [[INDEX]])
+  // CHECK: [[LOAD1:%.*]] = load i32, i32* [[RES2]],
+  // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* [[ARRAY_ELEMENT_U15]], i32 0, i32 0), i32 [[LOAD1]])
+  // CHECK: [[NEXT_INDEX:%.*]] = add i64 [[INDEX]], 1
+  // CHECK: store i64 [[NEXT_INDEX]], i64* [[ALLOC_INDEX]],
+  // CHECK: [[DONE:%.*]] = icmp eq i64 [[NEXT_INDEX]], 3
+  // CHECK: br i1 [[DONE]], label %__builtin_dump_struct.array.done.1, label %__builtin_dump_struct.array.body.1
+  // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([7 x i8], [7 x i8]* [[ARRAY_R_SQUARE_U15]], i32 0, i32 0))
+  // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* [[END_STRUCT_U15]], i32 0, i32 0))
     __builtin_dump_struct(&a, &printf);
 }
 
 void unit16(void) {
   struct U16A {
     uint8_t a;
   };
 
   struct U16A a = {
void unit18(void) {
   // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* [[STRUCT_STR_U18]], i32 0, i32 0))
   // CHECK: [[RES1:%.*]] = getelementptr inbounds %struct.U18A, %struct.U18A* %a, i32 0, i32 0
   // CHECK: [[LOAD1:%.*]] = load x86_fp80, x86_fp80* [[RES1]],
   // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([25 x i8], [25 x i8]* [[FIELD_U18]], i32 0, i32 0), x86_fp80 [[LOAD1]])
   // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* [[END_STRUCT_U18]], i32 0, i32 0)
   __builtin_dump_struct(&a, &printf);
 }
 
+void unit19(void) {
+  struct T19A {
+    int b[2][2];
+  };
+  struct T19A a = {
+    .b = {{1, 2}, {3, 4}}
+  };
+
+  // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([15 x i8], [15 x i8]* [[STRUCT_STR_U19]], i32 0, i32 0))
+  // CHECK: [[RES1:%.*]] = getelementptr inbounds %struct.T19A, %struct.T19A* %a, i32 0, i32 0
+  // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* [[FIELD_U19]], i32 0, i32 0))
+  // CHECK: [[RES2:%.*]] = getelementptr inbounds [2 x [2 x i32]], [2 x [2 x i32]]* [[RES1]], i64 2
+  // CHECK: [[ALLOC_INDEX:%.*]] = alloca i64, i64 1,
+  // CHECK: store i64 0, i64* [[ALLOC_INDEX]],
+  // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* [[ARRAY_L_SQUARE_U19]], i32 0, i32 0))
+  // CHECK: br label %__builtin_dump_struct.array.body.1
+
+  // CHECK: __builtin_dump_struct.array.body.1:
+  // CHECK: [[INDEX:%.*]] = load i64, i64* [[ALLOC_INDEX]]
+  // CHECK: [[RES3:%.*]] = getelementptr inbounds [2 x [2 x i32]], [2 x [2 x i32]]* [[RES1]], i64 0, i64 [[INDEX]]
+  // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([17 x i8], [17 x i8]* [[ARRAY_INDEX_U19]], i32 0, i32 0), i64 [[INDEX]])
+  // CHECK: [[RES4:%.*]] = getelementptr inbounds [2 x i32], [2 x i32]* [[RES3]], i64 2
+  // CHECK: [[ALLOC_INDEX1:%.*]] = alloca i64, i64 1,
+  // CHECK: store i64 0, i64* [[ALLOC_INDEX1]],
+  // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* [[ARRAY_L_SQUARE2_U19]], i32 0, i32 0))
+  // CHECK: br label %__builtin_dump_struct.array.body.2
+
+  // CHECK: __builtin_dump_struct.array.body.2:
+  // CHECK: [[INDEX1:%.*]] = load i64, i64* [[ALLOC_INDEX1]],
+  // CHECK: [[RES5:%.*]] = getelementptr inbounds [2 x i32], [2 x i32]* [[RES3]], i64 0, i64 [[INDEX1]]
+  // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([21 x i8], [21 x i8]* [[ARRAY_INDEX2_U19]], i32 0, i32 0), i64 [[INDEX1]])
+  // CHECK: [[LOAD1:%.*]] = load i32, i32* [[RES5]],
+  // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* [[ARRAY_ELEMENT_U19]], i32 0, i32 0), i32 [[LOAD1]])
+  // CHECK: [[NEXT_INDEX1:%.*]] = add i64 [[INDEX1]], 1
+  // CHECK: store i64 [[NEXT_INDEX1]], i64* [[ALLOC_INDEX1]],
+  // CHECK: [[DONE1:%.*]] = icmp eq i64 [[NEXT_INDEX1]], 2
+  // CHECK: br i1 %20, label %__builtin_dump_struct.array.done.2, label %__builtin_dump_struct.array.body.2
+
+  // CHECK: __builtin_dump_struct.array.done.2:
+  // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([11 x i8], [11 x i8]* [[ARRAY_R_SQUARE2_U19]], i32 0, i32 0))
+  // CHECK: [[NEXT_INDEX:%.*]] = add i64 [[INDEX]], 1
+  // CHECK: store i64 [[NEXT_INDEX]], i64* [[ALLOC_INDEX]],
+  // CHECK: [[DONE:%.*]] = icmp eq i64 [[NEXT_INDEX]], 2
+  // CHECK: br i1 %25, label %__builtin_dump_struct.array.done.1, label %__builtin_dump_struct.array.body.1
+
+  // CHECK: __builtin_dump_struct.array.done.1:
+  // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([7 x i8], [7 x i8]* [[ARRAY_R_SQUARE_U19]], i32 0, i32 0))
+  // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* [[END_STRUCT_U19]], i32 0, i32 0))
+  __builtin_dump_struct(&a, &printf);
+}
+
 void test1(void) {
   struct T1A {
     int a;
     char *b;
   };
 
   struct T1A a = {
       .a = 12,
void test3(void) {
 
   // CHECK: call i32 (i8*, ...) @printf(
   // CHECK: [[RES1:%.*]] = getelementptr inbounds %struct.T3A, %struct.T3A* %a, i32 0, i32 0
   // CHECK: call i32 (i8*, ...) @printf(
   // CHECK: [[BC1:%.*]] = bitcast %union.anon* [[RES1]] to i32*
   // CHECK: [[LOAD1:%.*]] = load i32, i32* [[BC1]],
   // CHECK: call i32 (i8*, ...) @printf({{.*}}, i32 [[LOAD1]])
   // CHECK: [[BC2:%.*]] = bitcast %union.anon* [[RES1]] to [4 x i8]*
-  // CHECK: [[LOAD2:%.*]] = load [4 x i8], [4 x i8]* [[BC2]],
-  // CHECK: call i32 (i8*, ...) @printf({{.*}}, [4 x i8] [[LOAD2]])
+  // CHECK: call i32 (i8*, ...) @printf(
+  // CHECK: [[RES2:%.*]] = getelementptr inbounds [4 x i8], [4 x i8]* [[BC2]], i64 4
+  // CHECK: [[ALLOC_INDEX:%.*]] = alloca i64, i64 1,
+  // CHECK: store i64 0, i64* [[ALLOC_INDEX]],
+  // CHECK: call i32 (i8*, ...) @printf(
+  // CHECK: br label %__builtin_dump_struct.array.body.2
+  // CHECK: __builtin_dump_struct.array.body.2:
+  // CHECK: [[INDEX:%.*]] = load i64, i64* [[ALLOC_INDEX]],
+  // CHECK: [[RES3:%.*]] = getelementptr inbounds [4 x i8], [4 x i8]* [[BC2]], i64 0, i64 [[INDEX]]
+  // CHECK: call i32 (i8*, ...) @printf({{.*}}, i64 [[INDEX]])
+  // CHECK: [[LOAD2:%.*]] = load i8, i8* [[RES3]],
+  // CHECK: call i32 (i8*, ...) @printf({{.*}}, i8 [[LOAD2]])
+  // CHECK: [[NEXT_INDEX:%.*]] = add i64 [[INDEX]], 1
+  // CHECK: store i64 [[NEXT_INDEX]], i64* [[ALLOC_INDEX]],
+  // CHECK: [[DONE:%.*]] = icmp eq i64 [[NEXT_INDEX]], 4
+  // CHECK: br i1 %19, label %__builtin_dump_struct.array.done.2, label %__builtin_dump_struct.array.body.2
+  // CHECK: __builtin_dump_struct.array.done.2:
+  // CHECK: call i32 (i8*, ...) @printf(
   // CHECK: call i32 (i8*, ...) @printf(
   // CHECK: call i32 (i8*, ...) @printf(
   __builtin_dump_struct(&a, &printf);
 }
 
 void test4(void) {
   struct T4A {
     union {
struct T8A {
     unsigned b;
   };
 
   struct T8A a = {
     .b = 2022,
   };
 
   // CHECK: call i32 (i8*, ...) @printf(
-  // CHECK: [[BC1:%.*]] = bitcast %struct.T8A* %a to i8*
-  // CHECK: [[LOAD1:%.*]] = load i8, i8* [[BC1]],
-  // CHECK: [[CLEAR1:%.*]] = and i8 [[LOAD1]], 1
-  // CHECK: [[CAST1:%.*]] = zext i8 [[CLEAR1]] to i32
+  // CHECK: [[BC1:%[−a−zA−Z._0-9]+]] = bitcast %struct.T8A* %a to i8*
+  // CHECK: [[LOAD1:%[-a-zA-Z._0-9]+]] = load i8, i8* [[BC1]],
+  // CHECK: [[CLEAR1:%[-a-zA-Z._0-9]+]] = and i8 [[LOAD1]], 1
+  // CHECK: [[CAST1:%[-a-zA-Z._0-9]+]] = zext i8 [[CLEAR1]] to i32
   // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([29 x i8], [29 x i8]* {{.*}}, i32 0, i32 0), i32 [[CAST1]])
-  // CHECK: [[BC2:%.*]] = bitcast %struct.T8A* %a to i8*
-  // CHECK: [[LOAD2:%.*]] = load i8, i8* [[BC2]],
-  // CHECK: [[LSHR2:%.*]] = lshr i8 [[LOAD2]], 1
-  // CHECK: [[CLEAR2:%.*]] = and i8 [[LSHR2]], 7
-  // CHECK: [[CAST2:%.*]] = zext i8 [[CLEAR2]] to i32
+  // CHECK: [[BC2:%[−a−zA−Z._0-9]+]] = bitcast %struct.T8A* %a to i8*
+  // CHECK: [[LOAD2:%[-a-zA-Z._0-9]+]] = load i8, i8* [[BC2]],
+  // CHECK: [[LSHR2:%[0-9a-z.]+]] = lshr i8 [[LOAD2]], 1
+  // CHECK: [[CLEAR2:%[-a-zA-Z._0-9]+]] = and i8 [[LSHR2]], 7
+  // CHECK: [[CAST2:%[-a-zA-Z._0-9]+]] = zext i8 [[CLEAR2]] to i32
   // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([27 x i8], [27 x i8]* {{.*}}, i32 0, i32 0), i32 [[CAST2]])
   // CHECK: call i32 (i8*, ...) @printf(
-  // CHECK: [[RES3:%.*]] = getelementptr inbounds %struct.T8A, %struct.T8A* %a, i32 0, i32 1
-  // CHECK: [[LOAD3:%.*]] = load i32, i32* [[RES3]],
+  // CHECK: [[RES3:%[-a-zA-Z._0-9]+]] = getelementptr inbounds %struct.T8A, %struct.T8A* %a, i32 0, i32 1
+  // CHECK: [[LOAD3:%[-a-zA-Z._0-9]+]] = load i32, i32* [[RES3]],
   // CHECK: call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([25 x i8], [25 x i8]* {{.*}}, i32 0, i32 0), i32 [[LOAD3]])
   // CHECK: call i32 (i8*, ...) @printf(
   __builtin_dump_struct(&a, &printf);
 }