[Clang][CodeGen]Fix __builtin_dump_struct missing record type field name

Thanks for @rsmith to point this. I'm sorry for introducing this bug.
See @rsmith 's comment in https://reviews.llvm.org/D122248
Eg:(By @rsmith ) https://godbolt.org/z/o7vcbWaEf
I have added a test case
struct:
```
struct U19A {
    int a;
  };
  struct U19B {
    struct U19A a;
  };

  struct U19B a = {
    .a.a = 2022
  };
```
Dump result:
```
struct U19B {
    struct U19A a = {
        int a = 2022
    }
}
```

Reviewed By: erichkeane

Differential Revision: https://reviews.llvm.org/D122920

Author: jonasyhwang

clang/lib/CodeGen/CGBuiltin.cpp

@@ -24,6 +24,7 @@
 #include "clang/AST/Attr.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/OSLog.h"
+#include "clang/AST/FormatString.h"
 #include "clang/Basic/TargetBuiltins.h"
 #include "clang/Basic/TargetInfo.h"
 #include "clang/CodeGen/CGFunctionInfo.h"
@@ -2043,47 +2044,39 @@ EmitCheckedMixedSignMultiply(CodeGenFunction &CGF, const clang::Expr *Op1,
   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();
+static std::string getPrintfSpecifier(CodeGenFunction &CGF, QualType QT) {
+  analyze_printf::PrintfSpecifier spec;
+  if (!spec.fixType(QT, CGF.getLangOpts(), CGF.getContext(), false)) {
+    // If this type is a boolean type, we should use '%d' to dump its value.
+    if (QT->isBooleanType())
+      return "%d";
+
+    // Otherwise, in order to keep the same behavior as before, use '%p' for
+    // unknown types
+    return "%p";
+  }
+  std::string str;
+  llvm::raw_string_ostream ss(str);
+  spec.toString(ss);
+  return str;
+}
+
+static llvm::Value *dumpValue(CodeGenFunction &CGF, QualType RType,
+                              LValue RecordLV, CharUnits Align,
+                              llvm::FunctionCallee Func, PrintingPolicy Policy,
+                              int Lvl) {
   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 *GString = CGF.Builder.CreateGlobalStringPtr("{\n");
   Value *Res = CGF.Builder.CreateCall(Func, {GString});
 
-  static llvm::DenseMap<QualType, const char *> 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";
-  }
-
   for (const auto *FD : RD->fields()) {
     Value *TmpRes = nullptr;
 
     std::string Format = llvm::Twine(ElementPad)
-                             .concat(FD->getType().getAsString())
+                             .concat(FD->getType().getAsString(Policy))
                              .concat(llvm::Twine(' '))
                              .concat(FD->getNameAsString())
                              .str();
@@ -2108,31 +2101,36 @@ static llvm::Value *dumpRecord(CodeGenFunction &CGF, QualType RType,
       }
     }
 
+    GString = CGF.Builder.CreateGlobalStringPtr(
+        llvm::Twine(Format).concat(" = ").str());
+    TmpRes = CGF.Builder.CreateCall(Func, {GString});
+    Res = CGF.Builder.CreateAdd(TmpRes, Res);
+
     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);
+
+      // If current field is a record type, we should not dump the type name in
+      // recursive dumpRecord call, and we only dump the things between {...}
+      TmpRes =
+          dumpValue(CGF, CanonicalType, FieldLV, Align, Func, Policy, 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];
-
-    GString = CGF.Builder.CreateGlobalStringPtr(llvm::Twine(Format)
-                                                    .concat(" = ")
-                                                    .concat(TypeFormat)
-                                                    .concat(llvm::Twine('\n'))
-                                                    .str());
+    std::string PrintFormatSpec = getPrintfSpecifier(CGF, FD->getType());
+    GString = CGF.Builder.CreateGlobalStringPtr(
+        llvm::Twine(PrintFormatSpec).concat(llvm::Twine('\n')).str());
 
     RValue RV = FD->isBitField()
                     ? CGF.EmitLoadOfBitfieldLValue(FieldLV, FD->getLocation())
                     : CGF.EmitLoadOfLValue(FieldLV, FD->getLocation());
+
+    /// FIXME: This place needs type promotion.
     TmpRes = CGF.Builder.CreateCall(Func, {GString, RV.getScalarVal()});
     Res = CGF.Builder.CreateAdd(Res, TmpRes);
   }
@@ -2143,6 +2141,20 @@ static llvm::Value *dumpRecord(CodeGenFunction &CGF, QualType RType,
   return Res;
 }
 
+static llvm::Value *dumpRecord(CodeGenFunction &CGF, QualType RType,
+                               LValue RecordLV, CharUnits Align,
+                               llvm::FunctionCallee Func) {
+  ASTContext &Context = CGF.getContext();
+  PrintingPolicy Policy(Context.getLangOpts());
+  Policy.AnonymousTagLocations = false;
+  std::string Name = llvm::Twine(RType.getAsString(Policy)).concat(" ").str();
+  Value *GString = CGF.Builder.CreateGlobalStringPtr(Name);
+  Value *Res = CGF.Builder.CreateCall(Func, {GString});
+  Value *TmpRes = dumpValue(CGF, RType, RecordLV, Align, Func, Policy, 0);
+  Res = CGF.Builder.CreateAdd(Res, TmpRes);
+  return Res;
+}
+
 static bool
 TypeRequiresBuiltinLaunderImp(const ASTContext &Ctx, QualType Ty,
                               llvm::SmallPtrSetImpl<const Decl *> &Seen) {
@@ -2683,7 +2695,7 @@ RValue CodeGenFunction::EmitBuiltinExpr(const GlobalDecl GD, unsigned BuiltinID,
     Value *RecordPtr = EmitScalarExpr(Arg0);
     LValue RecordLV = MakeAddrLValue(RecordPtr, Arg0Type, Arg0Align);
     Value *Res = dumpRecord(*this, Arg0Type, RecordLV, Arg0Align,
-                            {LLVMFuncType, Func}, 0);
+                            {LLVMFuncType, Func});
     return RValue::get(Res);
   }