[Clang][Sema] Warn when function argument is less aligned than parameter

[tmatheson]

Summary

See https://bugs.llvm.org/show_bug.cgi?id=42154.

GCC's attribute((align)) can reduce the alignment of a type when applied to
a typedef. However, functions which take a pointer or reference to the
original type are compiled assuming the original alignment. Therefore when any
such function is passed an object of the new, less-aligned type, an alignment
fault can occur. In particular, this applies to the constructor, which is
defined for the original type and called for the less-aligned object.

This change adds a warning whenever an pointer or reference to an object is
passed to a function that was defined for a more-aligned type.

The calls to ASTContext::getTypeAlignInChars seem change the order in which
record layouts are evaluated, which caused changes to the output of
-fdump-record-layouts. As such some tests needed to be updated:

• Use CHECK-LABEL rather than counting the number of "Dumping AST Record Layout" headers.
• Check for end of line in labels, so that struct B1 doesn't match struct B etc.
• Add --strict-whitespace, since the whitespace shows meaningful structure.
• The order in which record layouts are printed has changed in some cases.
• clang-format for regions changed

[tmatheson]

Ping

[dnsampaio]

LGTM . Just a few coding style nits to fix. But please wait a couple of days to see if someone else has anything else to say.

clang/lib/Sema/SemaChecking.cpp

4495

empty line after return.

4566

Follow clang-tidy.

[tmatheson]

• Add blank line after retun

• Apply clang-tidy recommendations

[tmatheson]

Attempt to fix error on windows: change unsigned long -> int in operator new

[tmatheson]

int -> unsigned long long

[tmatheson]

...use SIZE_TYPE

[probinson]

Looks like this caused PR49534 (https://bugs.llvm.org/show_bug.cgi?id=49534)

[tmatheson]

I believe PR49534 was fixed by D98548 above

clang/include/clang/Basic/DiagnosticSemaKinds.td

def note_indirection_through_null : Note<
   "consider using __builtin_trap() or qualifying pointer with 'volatile'">;
 def warn_pointer_indirection_from_incompatible_type : Warning<
   "dereference of type %1 that was reinterpret_cast from type %0 has undefined "
   "behavior">,
   InGroup<UndefinedReinterpretCast>, DefaultIgnore;
 def warn_taking_address_of_packed_member : Warning<
   "taking address of packed member %0 of class or structure %q1 may result in an unaligned pointer value">,
   InGroup<DiagGroup<"address-of-packed-member">>;
+def warn_param_mismatched_alignment : Warning<
+  "passing %0-byte aligned argument to %1-byte aligned parameter %2 of %3 may result in an unaligned pointer access">,
+  InGroup<DiagGroup<"align-mismatch">>;
 
 def err_objc_object_assignment : Error<
   "cannot assign to class object (%0 invalid)">;
 def err_typecheck_invalid_operands : Error<
   "invalid operands to binary expression (%0 and %1)">;
 def note_typecheck_invalid_operands_converted : Note<
   "%select{first|second}0 operand was implicitly converted to type %1">;
 def err_typecheck_logical_vector_expr_gnu_cpp_restrict : Error<

clang/include/clang/Sema/Sema.h

public:
   /// it simply returns the passed in expression.
   ExprResult MaybeBindToTemporary(Expr *E);
 
   /// Wrap the expression in a ConstantExpr if it is a potential immediate
   /// invocation.
   ExprResult CheckForImmediateInvocation(ExprResult E, FunctionDecl *Decl);
 
   bool CompleteConstructorCall(CXXConstructorDecl *Constructor,
-                               MultiExprArg ArgsPtr,
+                               QualType DeclInitType, MultiExprArg ArgsPtr,
                                SourceLocation Loc,
-                               SmallVectorImpl<Expr*> &ConvertedArgs,
+                               SmallVectorImpl<Expr *> &ConvertedArgs,
                                bool AllowExplicit = false,
                                bool IsListInitialization = false);
 
   ParsedType getInheritingConstructorName(CXXScopeSpec &SS,
                                           SourceLocation NameLoc,
                                           IdentifierInfo &Name);
 
   ParsedType getConstructorName(IdentifierInfo &II, SourceLocation NameLoc,
static bool getFormatStringInfo(const FormatAttr *Format, bool IsCXXMember,
                                   FormatStringInfo *FSI);
   bool CheckFunctionCall(FunctionDecl *FDecl, CallExpr *TheCall,
                          const FunctionProtoType *Proto);
   bool CheckObjCMethodCall(ObjCMethodDecl *Method, SourceLocation loc,
                            ArrayRef<const Expr *> Args);
   bool CheckPointerCall(NamedDecl *NDecl, CallExpr *TheCall,
                         const FunctionProtoType *Proto);
   bool CheckOtherCall(CallExpr *TheCall, const FunctionProtoType *Proto);
-  void CheckConstructorCall(FunctionDecl *FDecl,
+  void CheckConstructorCall(FunctionDecl *FDecl, QualType ThisType,
                             ArrayRef<const Expr *> Args,
-                            const FunctionProtoType *Proto,
-                            SourceLocation Loc);
+                            const FunctionProtoType *Proto, SourceLocation Loc);
+
+  void CheckArgAlignment(SourceLocation Loc, NamedDecl *FDecl,
+                         StringRef ParamName, QualType ArgTy, QualType ParamTy);
 
   void checkCall(NamedDecl *FDecl, const FunctionProtoType *Proto,
                  const Expr *ThisArg, ArrayRef<const Expr *> Args,
                  bool IsMemberFunction, SourceLocation Loc, SourceRange Range,
                  VariadicCallType CallType);
 
   bool CheckObjCString(Expr *Arg);
   ExprResult CheckOSLogFormatStringArg(Expr *Arg);

clang/lib/Sema/SemaChecking.cpp

static void CheckNonNullArguments(Sema &S,
   // Check for non-null arguments.
   for (unsigned ArgIndex = 0, ArgIndexEnd = NonNullArgs.size();
        ArgIndex != ArgIndexEnd; ++ArgIndex) {
     if (NonNullArgs[ArgIndex])
       CheckNonNullArgument(S, Args[ArgIndex], CallSiteLoc);
   }
 }
 
+/// Warn if a pointer or reference argument passed to a function points to an
+/// object that is less aligned than the parameter. This can happen when
+/// creating a typedef with a lower alignment than the original type and then
+/// calling functions defined in terms of the original type.
+void Sema::CheckArgAlignment(SourceLocation Loc, NamedDecl *FDecl,
+                             StringRef ParamName, QualType ArgTy,
+                             QualType ParamTy) {
+
+  // If a function accepts a pointer or reference type
+  if (!ParamTy->isPointerType() && !ParamTy->isReferenceType())
+    return;
+
+  // If the parameter is a pointer type, get the pointee type for the
+  // argument too. If the parameter is a reference type, don't try to get
+  // the pointee type for the argument.
+  if (ParamTy->isPointerType())
+    ArgTy = ArgTy->getPointeeType();
+
+  // Remove reference or pointer
+  ParamTy = ParamTy->getPointeeType();
+
+  // Find expected alignment, and the actual alignment of the passed object.
+  // getTypeAlignInChars requires complete types
+  if (ParamTy->isIncompleteType() || ArgTy->isIncompleteType())
+    return;
+
+  CharUnits ParamAlign = Context.getTypeAlignInChars(ParamTy);
+  CharUnits ArgAlign = Context.getTypeAlignInChars(ArgTy);
+
+  // If the argument is less aligned than the parameter, there is a
+  // potential alignment issue.
+  if (ArgAlign < ParamAlign)
+    Diag(Loc, diag::warn_param_mismatched_alignment)
+        << (int)ArgAlign.getQuantity() << (int)ParamAlign.getQuantity()
+        << ParamName << FDecl;
+};
+
 /// Handles the checks for format strings, non-POD arguments to vararg
 /// functions, NULL arguments passed to non-NULL parameters, and diagnose_if
 /// attributes.
 void Sema::checkCall(NamedDecl *FDecl, const FunctionProtoType *Proto,
                      const Expr *ThisArg, ArrayRef<const Expr *> Args,
                      bool IsMemberFunction, SourceLocation Loc,
                      SourceRange Range, VariadicCallType CallType) {
   // FIXME: We should check as much as we can in the template definition.
if (FDecl || Proto) {
 
     // Type safety checking.
     if (FDecl) {
       for (const auto *I : FDecl->specific_attrs<ArgumentWithTypeTagAttr>())
         CheckArgumentWithTypeTag(I, Args, Loc);
     }
   }
 
+  // Check that passed arguments match the alignment of original arguments.
+  // Try to get the missing prototype from the declaration.
+  if (!Proto && FDecl) {
+    const auto *FT = FDecl->getFunctionType();
+    if (isa_and_nonnull<FunctionProtoType>(FT))
+      Proto = cast<FunctionProtoType>(FDecl->getFunctionType());
+  }
+  if (Proto) {
+    // For variadic functions, we may have more args than parameters.
+    // For some K&R functions, we may have less args than parameters.
+    const auto N = std::min<unsigned>(Proto->getNumParams(), Args.size());
+    for (unsigned ArgIdx = 0; ArgIdx < N; ++ArgIdx) {
+      // Args[ArgIdx] can be null in malformed code.
+      if (const Expr *Arg = Args[ArgIdx]) {
+        QualType ParamTy = Proto->getParamType(ArgIdx);
+        QualType ArgTy = Arg->getType();
+        CheckArgAlignment(Arg->getExprLoc(), FDecl, std::to_string(ArgIdx + 1),
+                          ArgTy, ParamTy);
+      }
+    }
+  }
+
   if (FDecl && FDecl->hasAttr<AllocAlignAttr>()) {
     auto *AA = FDecl->getAttr<AllocAlignAttr>();
     const Expr *Arg = Args[AA->getParamIndex().getASTIndex()];
     if (!Arg->isValueDependent()) {
       Expr::EvalResult Align;
       if (Arg->EvaluateAsInt(Align, Context)) {
         const llvm::APSInt &I = Align.Val.getInt();
         if (!I.isPowerOf2())
           Diag(Arg->getExprLoc(), diag::warn_alignment_not_power_of_two)
               << Arg->getSourceRange();
 
         if (I > Sema::MaximumAlignment)
           Diag(Arg->getExprLoc(), diag::warn_assume_aligned_too_great)
               << Arg->getSourceRange() << Sema::MaximumAlignment;
       }
     }
   }
 
   if (FD)
     diagnoseArgDependentDiagnoseIfAttrs(FD, ThisArg, Args, Loc);
 }
 
 /// CheckConstructorCall - Check a constructor call for correctness and safety
 /// properties not enforced by the C type system.
-void Sema::CheckConstructorCall(FunctionDecl *FDecl,
+void Sema::CheckConstructorCall(FunctionDecl *FDecl, QualType ThisType,
                                 ArrayRef<const Expr *> Args,
                                 const FunctionProtoType *Proto,
                                 SourceLocation Loc) {
   VariadicCallType CallType =
       Proto->isVariadic() ? VariadicConstructor : VariadicDoesNotApply;
+
+  auto *Ctor = cast<CXXConstructorDecl>(FDecl);
+  CheckArgAlignment(Loc, FDecl, "'this'", Context.getPointerType(ThisType),
+                    Context.getPointerType(Ctor->getThisObjectType()));
+
   checkCall(FDecl, Proto, /*ThisArg=*/nullptr, Args, /*IsMemberFunction=*/true,
             Loc, SourceRange(), CallType);
 }
 
 /// CheckFunctionCall - Check a direct function call for various correctness
 /// and safety properties not strictly enforced by the C type system.
 bool Sema::CheckFunctionCall(FunctionDecl *FDecl, CallExpr *TheCall,
                              const FunctionProtoType *Proto) {
if (IsMemberOperatorCall) {
     // FIXME: Our choice of AST representation here is less than ideal.
     ImplicitThis = Args[0];
     ++Args;
     --NumArgs;
   } else if (IsMemberFunction)
     ImplicitThis =
         cast<CXXMemberCallExpr>(TheCall)->getImplicitObjectArgument();
 
+  if (ImplicitThis) {
+    // ImplicitThis may or may not be a pointer, depending on whether . or -> is
+    // used.
+    QualType ThisType = ImplicitThis->getType();
+    if (!ThisType->isPointerType()) {
+      assert(!ThisType->isReferenceType());
+      ThisType = Context.getPointerType(ThisType);
+    }
+
+    QualType ThisTypeFromDecl =
+        Context.getPointerType(cast<CXXMethodDecl>(FDecl)->getThisObjectType());
+
+    CheckArgAlignment(TheCall->getRParenLoc(), FDecl, "'this'", ThisType,
+                      ThisTypeFromDecl);
+  }
+
   checkCall(FDecl, Proto, ImplicitThis, llvm::makeArrayRef(Args, NumArgs),
             IsMemberFunction, TheCall->getRParenLoc(),
             TheCall->getCallee()->getSourceRange(), CallType);
 
   IdentifierInfo *FnInfo = FDecl->getIdentifier();
   // None of the checks below are needed for functions that don't have
   // simple names (e.g., C++ conversion functions).
   if (!FnInfo)

clang/lib/Sema/SemaDeclCXX.cpp

if (!VD->isStaticLocal())
     Diag(VD->getLocation(), diag::warn_global_destructor);
 }
 
 /// Given a constructor and the set of arguments provided for the
 /// constructor, convert the arguments and add any required default arguments
 /// to form a proper call to this constructor.
 ///
 /// \returns true if an error occurred, false otherwise.
-bool
-Sema::CompleteConstructorCall(CXXConstructorDecl *Constructor,
-                              MultiExprArg ArgsPtr,
+bool Sema::CompleteConstructorCall(CXXConstructorDecl *Constructor,
+                                   QualType DeclInitType, MultiExprArg ArgsPtr,
                                    SourceLocation Loc,
-                              SmallVectorImpl<Expr*> &ConvertedArgs,
+                                   SmallVectorImpl<Expr *> &ConvertedArgs,
                                    bool AllowExplicit,
                                    bool IsListInitialization) {
   // FIXME: This duplicates a lot of code from Sema::ConvertArgumentsForCall.
   unsigned NumArgs = ArgsPtr.size();
   Expr **Args = ArgsPtr.data();
 
   const auto *Proto = Constructor->getType()->castAs<FunctionProtoType>();
   unsigned NumParams = Proto->getNumParams();
 
   // If too few arguments are available, we'll fill in the rest with defaults.
bool Invalid = GatherArgumentsForCall(Loc, Constructor,
                                         llvm::makeArrayRef(Args, NumArgs),
                                         AllArgs,
                                         CallType, AllowExplicit,
                                         IsListInitialization);
   ConvertedArgs.append(AllArgs.begin(), AllArgs.end());
 
   DiagnoseSentinelCalls(Constructor, Loc, AllArgs);
 
-  CheckConstructorCall(Constructor,
+  CheckConstructorCall(Constructor, DeclInitType,
                        llvm::makeArrayRef(AllArgs.data(), AllArgs.size()),
                        Proto, Loc);
 
   return Invalid;
 }
 
 static inline bool
 CheckOperatorNewDeleteDeclarationScope(Sema &SemaRef,

clang/lib/Sema/SemaExprCXX.cpp

static ExprResult BuildCXXCastArgument(Sema &S,
   case CK_ConstructorConversion: {
     CXXConstructorDecl *Constructor = cast<CXXConstructorDecl>(Method);
     SmallVector<Expr*, 8> ConstructorArgs;
 
     if (S.RequireNonAbstractType(CastLoc, Ty,
                                  diag::err_allocation_of_abstract_type))
       return ExprError();
 
-    if (S.CompleteConstructorCall(Constructor, From, CastLoc, ConstructorArgs))
+    if (S.CompleteConstructorCall(Constructor, Ty, From, CastLoc,
+                                  ConstructorArgs))
       return ExprError();
 
     S.CheckConstructorAccess(CastLoc, Constructor, FoundDecl,
                              InitializedEntity::InitializeTemporary(Ty));
     if (S.DiagnoseUseOfDecl(Method, CastLoc))
       return ExprError();
 
     ExprResult Result = S.BuildCXXConstructExpr(
Sema::PerformImplicitConversion(Expr *From, QualType ToType,
   // so that we don't need to recompute anything here.
   QualType FromType = From->getType();
 
   if (SCS.CopyConstructor) {
     // FIXME: When can ToType be a reference type?
     assert(!ToType->isReferenceType());
     if (SCS.Second == ICK_Derived_To_Base) {
       SmallVector<Expr*, 8> ConstructorArgs;
-      if (CompleteConstructorCall(cast<CXXConstructorDecl>(SCS.CopyConstructor),
-                                  From, /*FIXME:ConstructLoc*/SourceLocation(),
-                                  ConstructorArgs))
+      if (CompleteConstructorCall(
+              cast<CXXConstructorDecl>(SCS.CopyConstructor), ToType, From,
+              /*FIXME:ConstructLoc*/ SourceLocation(), ConstructorArgs))
         return ExprError();
       return BuildCXXConstructExpr(
           /*FIXME:ConstructLoc*/ SourceLocation(), ToType,
           SCS.FoundCopyConstructor, SCS.CopyConstructor,
           ConstructorArgs, /*HadMultipleCandidates*/ false,
           /*ListInit*/ false, /*StdInitListInit*/ false, /*ZeroInit*/ false,
           CXXConstructExpr::CK_Complete, SourceRange());
     }

clang/lib/Sema/SemaInit.cpp

if (IsExtraneousCopy) {
     }
 
     return CurInitExpr;
   }
 
   // Determine the arguments required to actually perform the
   // constructor call (we might have derived-to-base conversions, or
   // the copy constructor may have default arguments).
-  if (S.CompleteConstructorCall(Constructor, CurInitExpr, Loc, ConstructorArgs))
+  if (S.CompleteConstructorCall(Constructor, T, CurInitExpr, Loc,
+                                ConstructorArgs))
     return ExprError();
 
   // C++0x [class.copy]p32:
   //   When certain criteria are met, an implementation is allowed to
   //   omit the copy/move construction of a class object, even if the
   //   copy/move constructor and/or destructor for the object have
   //   side effects. [...]
   //     - when a temporary class object that has not been bound to a
PerformConstructorInitialization(Sema &S,
   //     are also considered.
   bool AllowExplicitConv =
       Kind.AllowExplicit() && !Kind.isCopyInit() && Args.size() == 1 &&
       hasCopyOrMoveCtorParam(S.Context,
                              getConstructorInfo(Step.Function.FoundDecl));
 
   // Determine the arguments required to actually perform the constructor
   // call.
-  if (S.CompleteConstructorCall(Constructor, Args,
-                                Loc, ConstructorArgs,
-                                AllowExplicitConv,
+  if (S.CompleteConstructorCall(Constructor, Step.Type, Args, Loc,
+                                ConstructorArgs, AllowExplicitConv,
                                 IsListInitialization))
     return ExprError();
 
-
   if (isExplicitTemporary(Entity, Kind, NumArgs)) {
     // An explicitly-constructed temporary, e.g., X(1, 2).
     if (S.DiagnoseUseOfDecl(Constructor, Loc))
       return ExprError();
 
     TypeSourceInfo *TSInfo = Entity.getTypeSourceInfo();
     if (!TSInfo)
       TSInfo = S.Context.getTrivialTypeSourceInfo(Entity.getType(), Loc);
case SK_UserConversion: {
       if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(Fn)) {
         // Build a call to the selected constructor.
         SmallVector<Expr*, 8> ConstructorArgs;
         SourceLocation Loc = CurInit.get()->getBeginLoc();
 
         // Determine the arguments required to actually perform the constructor
         // call.
         Expr *Arg = CurInit.get();
-        if (S.CompleteConstructorCall(Constructor,
-                                      MultiExprArg(&Arg, 1),
-                                      Loc, ConstructorArgs))
+        if (S.CompleteConstructorCall(Constructor, Step->Type,
+                                      MultiExprArg(&Arg, 1), Loc,
+                                      ConstructorArgs))
           return ExprError();
 
         // Build an expression that constructs a temporary.
         CurInit = S.BuildCXXConstructExpr(Loc, Step->Type,
                                           FoundFn, Constructor,
                                           ConstructorArgs,
                                           HadMultipleCandidates,
                                           /*ListInit*/ false,

clang/lib/Sema/SemaOverload.cpp

case OR_Success: {
           ImplicitThis = ArgsArray[0];
           ArgsArray = ArgsArray.slice(1);
         }
 
         // Check for a self move.
         if (Op == OO_Equal)
           DiagnoseSelfMove(Args[0], Args[1], OpLoc);
 
+        if (ImplicitThis) {
+          QualType ThisType = Context.getPointerType(ImplicitThis->getType());
+          QualType ThisTypeFromDecl = Context.getPointerType(
+              cast<CXXMethodDecl>(FnDecl)->getThisObjectType());
+
+          CheckArgAlignment(OpLoc, FnDecl, "'this'", ThisType,
+                            ThisTypeFromDecl);
+        }
+
         checkCall(FnDecl, nullptr, ImplicitThis, ArgsArray,
                   isa<CXXMethodDecl>(FnDecl), OpLoc, TheCall->getSourceRange(),
                   VariadicDoesNotApply);
 
         ExprResult R = MaybeBindToTemporary(TheCall);
         if (R.isInvalid())
           return ExprError();
 

clang/lib/Sema/TreeTransform.h

ExprResult RebuildCXXConstructExpr(QualType T,
                              CXXConstructExpr::ConstructionKind ConstructKind,
                                      SourceRange ParenRange) {
     // Reconstruct the constructor we originally found, which might be
     // different if this is a call to an inherited constructor.
     CXXConstructorDecl *FoundCtor = Constructor;
     if (Constructor->isInheritingConstructor())
       FoundCtor = Constructor->getInheritedConstructor().getConstructor();
 
-    SmallVector<Expr*, 8> ConvertedArgs;
-    if (getSema().CompleteConstructorCall(FoundCtor, Args, Loc, ConvertedArgs))
+    SmallVector<Expr *, 8> ConvertedArgs;
+    if (getSema().CompleteConstructorCall(FoundCtor, T, Args, Loc,
+                                          ConvertedArgs))
       return ExprError();
 
     return getSema().BuildCXXConstructExpr(Loc, T, Constructor,
                                            IsElidable,
                                            ConvertedArgs,
                                            HadMultipleCandidates,
                                            ListInitialization,
                                            StdInitListInitialization,

clang/test/CodeGen/typedef_alignment_mismatch_warning.cpp

+// RUN: %clang_cc1 %s -fsyntax-only -verify -fdata-sections -fcolor-diagnostics
+
+// Warn for any function that
+//   * takes a pointer or a reference to an object (including "this" pointer),
+//   * that was defined for aligned object,
+//   * but is called with a pointer or reference to a less aligned object.
+// Attributes on using declarations are ignored.
+
+typedef __attribute__((aligned(2))) int Aligned2Int;
+typedef __attribute__((aligned(8))) int Aligned8Int;
+
+typedef __SIZE_TYPE__ size_t;
+
+// Normal function calls
+void f_takes_val(int i) {}
+void f_takes_ptr(int *p) {}
+void f_takes_ref(int &p) {}
+
+void test0() {
+  Aligned2Int xwarn;
+  Aligned8Int xok;
+  f_takes_val(xwarn);
+  f_takes_ptr(&xwarn); // expected-warning {{passing 2-byte aligned argument to 4-byte aligned parameter 1 of 'f_takes_ptr' may result in an unaligned pointer access}}
+  f_takes_ref(xwarn);  // expected-warning {{passing 2-byte aligned argument to 4-byte aligned parameter 1 of 'f_takes_ref' may result in an unaligned pointer access}}
+  f_takes_val(xok);
+  f_takes_ptr(&xok);
+  f_takes_ref(xok);
+}
+
+// Constructor expects to work on an 8 byte aligned type, but is called on a (potentially) 4 byte aligned object.
+void test1() {
+  struct StructAligned8 {
+    Aligned8Int Aligned8Member;
+    StructAligned8(int whatever) : Aligned8Member(whatever) {}
+  };
+  typedef __attribute__((aligned(4))) StructAligned8 TypedefAligned4;
+  using UsingAligned4 = __attribute__((aligned(4))) StructAligned8;
+
+  StructAligned8 SA8(11);
+  TypedefAligned4 TA4(11); // expected-warning {{passing 4-byte aligned argument to 8-byte aligned parameter 'this' of 'StructAligned8' may result in an unaligned pointer access}}
+  UsingAligned4 UA4(11);
+}
+
+// Same as above, should still trigger since passing by value is irrelevant
+void test1_byvalue() {
+  struct StructAligned8 {
+    int __attribute__((aligned(8))) Aligned8Member;
+    int Irrelevant;
+    StructAligned8(Aligned8Int arg) : Aligned8Member(arg) {}
+  };
+  typedef __attribute__((aligned(4))) StructAligned8 TypedefAligned4;
+  using UsingAligned4 = __attribute__((aligned(4))) StructAligned8;
+
+  Aligned8Int o{0};
+  StructAligned8 SA8(o);
+  TypedefAligned4 TA4(o); // expected-warning {{passing 4-byte aligned argument to 8-byte aligned parameter 'this' of 'StructAligned8' may result in an unaligned pointer access}}
+  UsingAligned4 UA4(o);
+}
+
+// This example uses a function call trigger
+void test2() {
+  struct StructAligned8 {
+    int __attribute__((aligned(8))) Aligned8Member;
+    int Irrelevant;
+  };
+  auto assignment_function = [](StructAligned8 &S, Aligned8Int arg) {
+    S.Aligned8Member = arg;
+  };
+  typedef __attribute__((aligned(4))) StructAligned8 TypedefAligned4;
+  using UsingAligned4 = __attribute__((aligned(4))) StructAligned8;
+
+  StructAligned8 SA8;
+  TypedefAligned4 TA4;          // expected-warning {{passing 4-byte aligned argument to 8-byte aligned parameter 'this' of 'StructAligned8' may result in an unaligned pointer access}}
+  assignment_function(TA4, 11); // expected-warning {{passing 4-byte aligned argument to 8-byte aligned parameter 1 of 'operator()' may result in an unaligned pointer access}}
+  UsingAligned4 UA4;
+  assignment_function(UA4, 11);
+}
+
+// Same as above, but should not trigger as passed by value
+void test2_byvalue() {
+  struct StructAligned8 {
+    int __attribute__((aligned(8))) Aligned8Member;
+    int Irrelevant;
+  };
+  auto assignment_function = [](StructAligned8 S, Aligned8Int arg) {
+    S.Aligned8Member = arg;
+  };
+  typedef __attribute__((aligned(4))) StructAligned8 TypedefAligned4;
+  using UsingAligned4 = __attribute__((aligned(4))) StructAligned8;
+
+  Aligned8Int o{0};
+  StructAligned8 SA8;
+  TypedefAligned4 TA4; // expected-warning {{passing 4-byte aligned argument to 8-byte aligned parameter 'this' of 'StructAligned8' may result in an unaligned pointer access}}
+  assignment_function(TA4, o);
+  UsingAligned4 UA4;
+  assignment_function(UA4, o);
+}
+
+void test4() {
+  struct StructWithPackedMember {
+    int PackedMember __attribute__((packed));
+  } SWPM;
+
+  // Explicitly taking the address of an unaligned member causes a warning
+  (void)&SWPM.PackedMember; // expected-warning {{taking address of packed member 'PackedMember' of class or structure 'StructWithPackedMember' may result in an unaligned pointer value}}
+}
+
+// Aligned attribute on struct itself
+void test5() {
+  struct __attribute__((aligned(8))) StructAligned8 {
+    int Aligned8Member;
+    int Irrelevant;
+    StructAligned8(int i) : Aligned8Member(i) {}
+  };
+  typedef __attribute__((aligned(4))) StructAligned8 TypedefAligned4;
+  using UsingAligned4 = __attribute__((aligned(4))) StructAligned8;
+
+  StructAligned8 SA8(11);
+  TypedefAligned4 TA4(11); // expected-warning {{passing 4-byte aligned argument to 8-byte aligned parameter 'this' of 'StructAligned8' may result in an unaligned pointer access}}
+  UsingAligned4 UA4(11);
+}
+
+// Via function pointer
+void test6() {
+  struct __attribute__((aligned(8))) StructAligned8 {
+    int Aligned8Member;
+    StructAligned8(int i) : Aligned8Member(i) {}
+  };
+
+  auto assignment_function_ref = [](StructAligned8 &S) {
+    S.Aligned8Member = 42;
+  };
+  auto assignment_function_ptr = [](StructAligned8 *S) {
+    S->Aligned8Member = 42;
+  };
+
+  void (*RefFnPtr)(StructAligned8 &) = assignment_function_ref;
+  void (*PtrFnPtr)(StructAligned8 *) = assignment_function_ptr;
+
+  typedef __attribute__((aligned(4))) StructAligned8 TypedefAligned4;
+  using UsingAligned4 = __attribute__((aligned(4))) StructAligned8;
+
+  StructAligned8 SA8(11);
+  RefFnPtr(SA8);
+  PtrFnPtr(&SA8);
+  TypedefAligned4 TA4(11); // expected-warning {{passing 4-byte aligned argument to 8-byte aligned parameter 'this' of 'StructAligned8' may result in an unaligned pointer access}}
+  RefFnPtr(TA4);           // expected-warning {{passing 4-byte aligned argument to 8-byte aligned parameter 1 of 'RefFnPtr' may result in an unaligned pointer access}}
+  PtrFnPtr(&TA4);          // expected-warning {{passing 4-byte aligned argument to 8-byte aligned parameter 1 of 'PtrFnPtr' may result in an unaligned pointer access}}
+  UsingAligned4 UA4(11);
+  RefFnPtr(UA4);
+  PtrFnPtr(&UA4);
+}
+
+// Member function
+void test7() {
+  struct __attribute__((aligned(8))) StructAligned8 {
+    int Aligned8Member;
+    StructAligned8(int i) : Aligned8Member(i) {}
+    void memberFnAssignment() {
+      Aligned8Member = 42;
+    }
+  };
+
+  typedef __attribute__((aligned(4))) StructAligned8 TypedefAligned4;
+  using UsingAligned4 = __attribute__((aligned(4))) StructAligned8;
+
+  StructAligned8 SA8(11);
+  SA8.memberFnAssignment();
+  TypedefAligned4 TA4(11);  // expected-warning {{passing 4-byte aligned argument to 8-byte aligned parameter 'this' of 'StructAligned8' may result in an unaligned pointer access}}
+  TA4.memberFnAssignment(); // expected-warning {{passing 4-byte aligned argument to 8-byte aligned parameter 'this' of 'memberFnAssignment' may result in an unaligned pointer access}}
+  UsingAligned4 UA4(11);
+  UA4.memberFnAssignment();
+
+  // Check access through pointer
+  StructAligned8 *SA8ptr;
+  SA8ptr->memberFnAssignment();
+  TypedefAligned4 *TA4ptr;
+  TA4ptr->memberFnAssignment(); // expected-warning {{passing 4-byte aligned argument to 8-byte aligned parameter 'this' of 'memberFnAssignment' may result in an unaligned pointer access}}
+  UsingAligned4 *UA4ptr;
+  UA4ptr->memberFnAssignment();
+}
+
+// Member binary and unary operator
+void test8() {
+  struct __attribute__((aligned(8))) StructAligned8 {
+    int Aligned8Member;
+    StructAligned8(int i) : Aligned8Member(i) {}
+    StructAligned8 operator+(StructAligned8 &other) {
+      return {other.Aligned8Member + Aligned8Member};
+    }
+    StructAligned8 operator-(StructAligned8 *other) {
+      return {other->Aligned8Member + Aligned8Member};
+    }
+    StructAligned8 &operator++() {
+      Aligned8Member++;
+      return *this;
+    }
+    StructAligned8 &operator--() {
+      Aligned8Member--;
+      return *this;
+    }
+  };
+
+  typedef __attribute__((aligned(4))) StructAligned8 TypedefAligned4;
+  using UsingAligned4 = __attribute__((aligned(4))) StructAligned8;
+
+  StructAligned8 SA8a(11);
+  StructAligned8 SA8b(11);
+  auto SA8c = SA8a + SA8b;
+  auto SA8d = SA8a - &SA8b;
+  ++SA8c;
+  --SA8d;
+  TypedefAligned4 TA8a(11);            // expected-warning {{passing 4-byte aligned argument to 8-byte aligned parameter 'this' of 'StructAligned8' may result in an unaligned pointer access}}
+  TypedefAligned4 TA8b(11);            // expected-warning {{passing 4-byte aligned argument to 8-byte aligned parameter 'this' of 'StructAligned8' may result in an unaligned pointer access}}
+  TypedefAligned4 TA8c = TA8a + TA8b;  // expected-warning {{passing 4-byte aligned argument to 8-byte aligned parameter 'this' of 'operator+' may result in an unaligned pointer access}}
+                                       // expected-warning@-1 {{passing 4-byte aligned argument to 8-byte aligned parameter 1 of 'operator+' may result in an unaligned pointer access}}
+                                       // expected-warning@-2 {{passing 4-byte aligned argument to 8-byte aligned parameter 'this' of 'StructAligned8' may result in an unaligned pointer access}}
+  TypedefAligned4 TA8d = TA8a - &TA8b; // expected-warning {{passing 4-byte aligned argument to 8-byte aligned parameter 'this' of 'operator-' may result in an unaligned pointer access}}
+                                       // expected-warning@-1 {{passing 4-byte aligned argument to 8-byte aligned parameter 1 of 'operator-' may result in an unaligned pointer access}}
+                                       // expected-warning@-2 {{passing 4-byte aligned argument to 8-byte aligned parameter 'this' of 'StructAligned8' may result in an unaligned pointer access}}
+  ++TA8d;                              // expected-warning {{passing 4-byte aligned argument to 8-byte aligned parameter 'this' of 'operator++' may result in an unaligned pointer access}}
+  --TA8c;                              // expected-warning {{passing 4-byte aligned argument to 8-byte aligned parameter 'this' of 'operator--' may result in an unaligned pointer access}}
+  UsingAligned4 UA8a(11);
+  UsingAligned4 UA8b(11);
+  auto UA8c = UA8a + UA8b;
+  auto UA8d = UA8a - &UA8b;
+  ++UA8c;
+  --UA8d;
+
+  // Bonus
+  auto bonus1 = TA8a + SA8b;  // expected-warning {{passing 4-byte aligned argument to 8-byte aligned parameter 'this' of 'operator+' may result in an unaligned pointer access}}
+  auto bonus2 = SA8a + TA8b;  // expected-warning {{passing 4-byte aligned argument to 8-byte aligned parameter 1 of 'operator+' may result in an unaligned pointer access}}
+  auto bonus3 = TA8a - &SA8b; // expected-warning {{passing 4-byte aligned argument to 8-byte aligned parameter 'this' of 'operator-' may result in an unaligned pointer access}}
+  auto bonus4 = SA8a - &TA8b; // expected-warning {{passing 4-byte aligned argument to 8-byte aligned parameter 1 of 'operator-' may result in an unaligned pointer access}}
+}
+
+// Static binary operator
+struct __attribute__((aligned(8))) test9Struct {
+  int Aligned8Member;
+  test9Struct(int i) : Aligned8Member(i) {}
+};
+test9Struct operator+(test9Struct &a, test9Struct &b) {
+  return {a.Aligned8Member + b.Aligned8Member};
+}
+void test9() {
+
+  typedef __attribute__((aligned(4))) test9Struct TypedefAligned4;
+  using UsingAligned4 = __attribute__((aligned(4))) test9Struct;
+
+  test9Struct SA8a(11);
+  test9Struct SA8b(11);
+  auto SA8c = SA8a + SA8b;
+  TypedefAligned4 TA8a(11); // expected-warning {{passing 4-byte aligned argument to 8-byte aligned parameter 'this' of 'test9Struct' may result in an unaligned pointer access}}
+  TypedefAligned4 TA8b(11); // expected-warning {{passing 4-byte aligned argument to 8-byte aligned parameter 'this' of 'test9Struct' may result in an unaligned pointer access}}
+  auto TA8c = TA8a + TA8b;  // expected-warning {{passing 4-byte aligned argument to 8-byte aligned parameter 1 of 'operator+' may result in an unaligned pointer access}}
+                            // expected-warning@-1 {{passing 4-byte aligned argument to 8-byte aligned parameter 2 of 'operator+' may result in an unaligned pointer access}}
+  UsingAligned4 UA8a(11);
+  UsingAligned4 UA8b(11);
+  auto UA8c = UA8a + UA8b;
+
+  // Bonus
+  auto bonus1 = TA8a + SA8b; // expected-warning {{passing 4-byte aligned argument to 8-byte aligned parameter 1 of 'operator+' may result in an unaligned pointer access}}
+  auto bonus2 = SA8a + TA8b; // expected-warning {{passing 4-byte aligned argument to 8-byte aligned parameter 2 of 'operator+' may result in an unaligned pointer access}}
+}
+
+// Operator new and placement new
+void test10() {
+  struct __attribute__((aligned(8))) StructAligned8 {
+    int Aligned8Member;
+    StructAligned8(int i) : Aligned8Member(i) {}
+    void *operator new(size_t count) { return (void *)0x123456; }
+    void *operator new(size_t count, void *p) { return p; }
+  };
+
+  typedef __attribute__((aligned(4))) StructAligned8 TypedefAligned4;
+  using UsingAligned4 = __attribute__((aligned(4))) StructAligned8;
+
+  auto *SA8ptr = new StructAligned8(11);
+  new (SA8ptr) StructAligned8(12);
+  auto *TA4ptr = new TypedefAligned4(11); // expected-warning {{passing 4-byte aligned argument to 8-byte aligned parameter 'this' of 'StructAligned8' may result in an unaligned pointer access}}
+  new (TA4ptr) TypedefAligned4(12);       // expected-warning {{passing 4-byte aligned argument to 8-byte aligned parameter 'this' of 'StructAligned8' may result in an unaligned pointer access}}
+  auto *UA4ptr = new UsingAligned4(11);
+  new (UA4ptr) UsingAligned4(12);
+}

clang/test/Layout/ms-x86-alias-avoidance-padding.cpp

 // RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fms-extensions -fdump-record-layouts -fsyntax-only %s 2>/dev/null \
-// RUN:            | FileCheck %s
+// RUN:            | FileCheck %s --strict-whitespace
 // RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fms-extensions -fdump-record-layouts -fsyntax-only %s 2>/dev/null \
-// RUN:            | FileCheck %s -check-prefix CHECK-X64
+// RUN:            | FileCheck %s -check-prefix CHECK-X64 --strict-whitespace
 
 extern "C" int printf(const char *fmt, ...);
 __declspec(align(4096)) char buffer[4096];
 
 struct AT {};
 
 struct V : AT {
   char c;

 };
 
 struct AT3 : AT2, AT1 {
   AT3() {
     printf("AT3 - this: %d\n", (int)((char*)this - buffer));
   }
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct AT3
+// CHECK-LABEL:   0 | struct AT3{{$}}
 // CHECK-NEXT:    0 |   struct AT2 (base)
 // CHECK-NEXT:    0 |     struct AT0 t
 // CHECK-NEXT:    0 |       union AT0::(unnamed at {{.*}} x
 // CHECK-NEXT:    0 |         struct AT0::(unnamed at {{.*}} y
 // CHECK-NEXT:    0 |           int a
 // CHECK-NEXT:    4 |           struct AT t (empty)
 // CHECK:         0 |         int b
 // CHECK:         8 |       char c
 // CHECK:        12 |     char AT2FieldName0
 // CHECK-NEXT:   20 |   struct AT1 (base)
 // CHECK-NEXT:   20 |     struct V (base)
 // CHECK-NEXT:   20 |       struct AT (base) (empty)
 // CHECK-NEXT:   20 |       char c
 // CHECK-NEXT:   24 |     int a
 // CHECK-NEXT:      | [sizeof=28, align=4
 // CHECK-NEXT:      |  nvsize=28, nvalign=4]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct AT3
+// CHECK-X64-LABEL:   0 | struct AT3{{$}}
 // CHECK-X64-NEXT:    0 |   struct AT2 (base)
 // CHECK-X64-NEXT:    0 |     struct AT0 t
 // CHECK-X64-NEXT:    0 |       union AT0::(unnamed at {{.*}} x
 // CHECK-X64-NEXT:    0 |         struct AT0::(unnamed at {{.*}} y
 // CHECK-X64-NEXT:    0 |           int a
 // CHECK-X64-NEXT:    4 |           struct AT t (empty)
 // CHECK-X64:         0 |         int b
 // CHECK-X64:         8 |       char c

 };
 
 struct BT3 : BT0, BT2 {
   BT3() {
     printf("BT3 - this: %d\n", (int)((char*)this - buffer));
   }
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct BT3
+// CHECK-LABEL:   0 | struct BT3{{$}}
 // CHECK-NEXT:    0 |   struct BT0 (base) (empty)
 // CHECK-NEXT:    1 |   struct BT2 (base)
 // CHECK-NEXT:    1 |     struct BT0 (base) (empty)
 // CHECK-NEXT:    1 |     char BT2FieldName0
 // CHECK-NEXT:      | [sizeof=2, align=1
 // CHECK-NEXT:      |  nvsize=2, nvalign=1]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct BT3
+// CHECK-X64-LABEL:   0 | struct BT3{{$}}
 // CHECK-X64-NEXT:    0 |   struct BT0 (base) (empty)
 // CHECK-X64-NEXT:    1 |   struct BT2 (base)
 // CHECK-X64-NEXT:    1 |     struct BT0 (base) (empty)
 // CHECK-X64-NEXT:    1 |     char BT2FieldName0
 // CHECK-X64-NEXT:      | [sizeof=2, align=1
 // CHECK-X64-NEXT:      |  nvsize=2, nvalign=1]
 
 struct T0 : AT {

 };
 
 struct __declspec(align(1)) T3 : virtual T1, virtual T2 {
   T3() {
     printf("T3 (this) : %d\n", (int)((char*)this - buffer));
   }
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct T3
+// CHECK-LABEL:   0 | struct T3{{$}}
 // CHECK-NEXT:    0 |   (T3 vbtable pointer)
 // CHECK-NEXT:    4 |   struct T1 (virtual base)
 // CHECK-NEXT:    4 |     struct T0 (base) (empty)
 // CHECK-NEXT:    4 |       struct AT (base) (empty)
 // CHECK-NEXT:    4 |     char a
 // CHECK-NEXT:   12 |   struct T2 (virtual base)
 // CHECK-NEXT:   12 |     struct AT (base) (empty)
 // CHECK-NEXT:   12 |     char a
 // CHECK-NEXT:      | [sizeof=16, align=4
 // CHECK-NEXT:      |  nvsize=4, nvalign=4]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct T3
+// CHECK-X64-LABEL:   0 | struct T3{{$}}
 // CHECK-X64-NEXT:    0 |   (T3 vbtable pointer)
 // CHECK-X64-NEXT:    8 |   struct T1 (virtual base)
 // CHECK-X64-NEXT:    8 |     struct T0 (base) (empty)
 // CHECK-X64-NEXT:    8 |       struct AT (base) (empty)
 // CHECK-X64-NEXT:    8 |     char a
 // CHECK-X64-NEXT:   16 |   struct T2 (virtual base)
 // CHECK-X64-NEXT:   16 |     struct AT (base) (empty)
 // CHECK-X64-NEXT:   16 |     char a
 // CHECK-X64-NEXT:      | [sizeof=24, align=8
 // CHECK-X64-NEXT:      |  nvsize=8, nvalign=8]
 
 struct B {};
 struct C { int a; };
 struct D : B, virtual C { B b; };
 struct E : D, B {};
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct E
+// CHECK-LABEL:   0 | struct E{{$}}
 // CHECK-NEXT:    0 |   struct D (base)
 // CHECK-NEXT:    4 |     struct B (base) (empty)
 // CHECK-NEXT:    0 |     (D vbtable pointer)
 // CHECK-NEXT:    4 |     struct B b (empty)
 // CHECK:         8 |   struct B (base) (empty)
 // CHECK-NEXT:    8 |   struct C (virtual base)
 // CHECK-NEXT:    8 |     int a
 // CHECK-NEXT:      | [sizeof=12, align=4
 // CHECK-NEXT:      |  nvsize=8, nvalign=4]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:   0 | struct E
+// CHECK-X64-LABEL:  0 | struct E{{$}}
 // CHECK-X64-NEXT:   0 |   struct D (base)
 // CHECK-X64-NEXT:   8 |     struct B (base) (empty)
 // CHECK-X64-NEXT:   0 |     (D vbtable pointer)
 // CHECK-X64-NEXT:   8 |     struct B b (empty)
 // CHECK-X64:       16 |   struct B (base) (empty)
 // CHECK-X64-NEXT:  16 |   struct C (virtual base)
 // CHECK-X64-NEXT:  16 |     int a
 // CHECK-X64-NEXT:     | [sizeof=24, align=8
 // CHECK-X64-NEXT:     |  nvsize=16, nvalign=8]
 
 struct F : virtual D, virtual B {};
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct F
+// CHECK-LABEL:   0 | struct F{{$}}
 // CHECK-NEXT:    0 |   (F vbtable pointer)
 // CHECK-NEXT:    4 |   struct C (virtual base)
 // CHECK-NEXT:    4 |     int a
 // CHECK-NEXT:    8 |   struct D (virtual base)
 // CHECK-NEXT:   12 |     struct B (base) (empty)
 // CHECK-NEXT:    8 |     (D vbtable pointer)
 // CHECK-NEXT:   12 |     struct B b (empty)
 // CHECK:        16 |   struct B (virtual base) (empty)
 // CHECK-NEXT:      | [sizeof=16, align=4
 // CHECK-NEXT:      |  nvsize=4, nvalign=4]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct F
+// CHECK-X64-LABEL:   0 | struct F{{$}}
 // CHECK-X64-NEXT:    0 |   (F vbtable pointer)
 // CHECK-X64-NEXT:    8 |   struct C (virtual base)
 // CHECK-X64-NEXT:    8 |     int a
 // CHECK-X64-NEXT:   16 |   struct D (virtual base)
 // CHECK-X64-NEXT:   24 |     struct B (base) (empty)
 // CHECK-X64-NEXT:   16 |     (D vbtable pointer)
 // CHECK-X64-NEXT:   24 |     struct B b (empty)
 // CHECK-X64:        32 |   struct B (virtual base) (empty)

 };
 struct JC2 : JC1 {
   JC2() { printf("JC2 : %d\n", (int)((char*)this - buffer)); }
 };
 struct JC4 : JC1, JC2 {
   JC4() { printf("JC4 : %d\n", (int)((char*)this - buffer)); }
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct JC4
+// CHECK-LABEL:   0 | struct JC4{{$}}
 // CHECK-NEXT:    0 |   struct JC1 (primary base)
 // CHECK-NEXT:    0 |     (JC1 vftable pointer)
 // CHECK-NEXT:    4 |     struct JC0 (base) (empty)
 // CHECK-NEXT:    8 |   struct JC2 (base)
 // CHECK-NEXT:    8 |     struct JC1 (primary base)
 // CHECK-NEXT:    8 |       (JC1 vftable pointer)
 // CHECK-NEXT:   12 |       struct JC0 (base) (empty)
 // CHECK-NEXT:      | [sizeof=12, align=4
 // CHECK-NEXT:      |  nvsize=12, nvalign=4]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct JC4
+// CHECK-X64-LABEL:   0 | struct JC4{{$}}
 // CHECK-X64-NEXT:    0 |   struct JC1 (primary base)
 // CHECK-X64-NEXT:    0 |     (JC1 vftable pointer)
 // CHECK-X64-NEXT:    8 |     struct JC0 (base) (empty)
 // CHECK-X64-NEXT:   16 |   struct JC2 (base)
 // CHECK-X64-NEXT:   16 |     struct JC1 (primary base)
 // CHECK-X64-NEXT:   16 |       (JC1 vftable pointer)
 // CHECK-X64-NEXT:   24 |       struct JC0 (base) (empty)
 // CHECK-X64-NEXT:      | [sizeof=24, align=8

 struct RX3 : RA { RB a; };
 struct RX4 { RA a; char b; };
 struct RX5 { RA a; RB b; };
 struct RX6 : virtual RV { RB a; };
 struct RX7 : virtual RW { RA a; };
 struct RX8 : RA, virtual RW {};
 
 struct RZ0 : RX0, RY {};
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct RZ0
+// CHECK-LABEL:   0 | struct RZ0{{$}}
 // CHECK-NEXT:    0 |   struct RX0 (base)
 // CHECK-NEXT:    0 |     struct RB (base)
 // CHECK-NEXT:    0 |       char c
 // CHECK-NEXT:    1 |     struct RA (base) (empty)
 // CHECK-NEXT:    2 |   struct RY (base) (empty)
 // CHECK-NEXT:      | [sizeof=2, align=1
 // CHECK-NEXT:      |  nvsize=2, nvalign=1]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct RZ0
+// CHECK-X64-LABEL:   0 | struct RZ0{{$}}
 // CHECK-X64-NEXT:    0 |   struct RX0 (base)
 // CHECK-X64-NEXT:    0 |     struct RB (base)
 // CHECK-X64-NEXT:    0 |       char c
 // CHECK-X64-NEXT:    1 |     struct RA (base) (empty)
 // CHECK-X64-NEXT:    2 |   struct RY (base) (empty)
 // CHECK-X64-NEXT:      | [sizeof=2, align=1
 // CHECK-X64-NEXT:      |  nvsize=2, nvalign=1]
 
 struct RZ1 : RX1, RY {};
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct RZ1
+// CHECK-LABEL:   0 | struct RZ1{{$}}
 // CHECK-NEXT:    0 |   struct RX1 (base)
 // CHECK-NEXT:    0 |     struct RA (base) (empty)
 // CHECK-NEXT:    0 |     struct RB (base)
 // CHECK-NEXT:    0 |       char c
 // CHECK-NEXT:    1 |   struct RY (base) (empty)
 // CHECK-NEXT:      | [sizeof=1, align=1
 // CHECK-NEXT:      |  nvsize=1, nvalign=1]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct RZ1
+// CHECK-X64-LABEL:   0 | struct RZ1{{$}}
 // CHECK-X64-NEXT:    0 |   struct RX1 (base)
 // CHECK-X64-NEXT:    0 |     struct RA (base) (empty)
 // CHECK-X64-NEXT:    0 |     struct RB (base)
 // CHECK-X64-NEXT:    0 |       char c
 // CHECK-X64-NEXT:    1 |   struct RY (base) (empty)
 // CHECK-X64-NEXT:      | [sizeof=1, align=1
 // CHECK-X64-NEXT:      |  nvsize=1, nvalign=1]
 
 struct RZ2 : RX2, RY {};
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct RZ2
+// CHECK-LABEL:   0 | struct RZ2{{$}}
 // CHECK-NEXT:    0 |   struct RX2 (base)
 // CHECK-NEXT:    0 |     struct RA (base) (empty)
 // CHECK-NEXT:    0 |     char a
 // CHECK-NEXT:    2 |   struct RY (base) (empty)
 // CHECK-NEXT:      | [sizeof=2, align=1
 // CHECK-NEXT:      |  nvsize=2, nvalign=1]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct RZ2
+// CHECK-X64-LABEL:   0 | struct RZ2{{$}}
 // CHECK-X64-NEXT:    0 |   struct RX2 (base)
 // CHECK-X64-NEXT:    0 |     struct RA (base) (empty)
 // CHECK-X64-NEXT:    0 |     char a
 // CHECK-X64-NEXT:    2 |   struct RY (base) (empty)
 // CHECK-X64-NEXT:      | [sizeof=2, align=1
 // CHECK-X64-NEXT:      |  nvsize=2, nvalign=1]
 
 struct RZ3 : RX3, RY {};
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct RZ3
+// CHECK-LABEL:   0 | struct RZ3{{$}}
 // CHECK-NEXT:    0 |   struct RX3 (base)
 // CHECK-NEXT:    0 |     struct RA (base) (empty)
 // CHECK-NEXT:    0 |     struct RB a
 // CHECK-NEXT:    0 |       char c
 // CHECK-NEXT:    1 |   struct RY (base) (empty)
 // CHECK-NEXT:      | [sizeof=1, align=1
 // CHECK-NEXT:      |  nvsize=1, nvalign=1]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct RZ3
+// CHECK-X64-LABEL:   0 | struct RZ3{{$}}
 // CHECK-X64-NEXT:    0 |   struct RX3 (base)
 // CHECK-X64-NEXT:    0 |     struct RA (base) (empty)
 // CHECK-X64-NEXT:    0 |     struct RB a
 // CHECK-X64-NEXT:    0 |       char c
 // CHECK-X64-NEXT:    1 |   struct RY (base) (empty)
 // CHECK-X64-NEXT:      | [sizeof=1, align=1
 // CHECK-X64-NEXT:      |  nvsize=1, nvalign=1]
 
 struct RZ4 : RX4, RY {};
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct RZ4
+// CHECK-LABEL:   0 | struct RZ4{{$}}
 // CHECK-NEXT:    0 |   struct RX4 (base)
 // CHECK-NEXT:    0 |     struct RA a (empty)
 // CHECK-NEXT:    1 |     char b
 // CHECK-NEXT:    3 |   struct RY (base) (empty)
 // CHECK-NEXT:      | [sizeof=3, align=1
 // CHECK-NEXT:      |  nvsize=3, nvalign=1]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct RZ4
+// CHECK-X64-LABEL:   0 | struct RZ4{{$}}
 // CHECK-X64-NEXT:    0 |   struct RX4 (base)
 // CHECK-X64-NEXT:    0 |     struct RA a (empty)
 // CHECK-X64-NEXT:    1 |     char b
 // CHECK-X64-NEXT:    3 |   struct RY (base) (empty)
 // CHECK-X64-NEXT:      | [sizeof=3, align=1
 // CHECK-X64-NEXT:      |  nvsize=3, nvalign=1]
 
 struct RZ5 : RX5, RY {};
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct RZ5
+// CHECK-LABEL:   0 | struct RZ5{{$}}
 // CHECK-NEXT:    0 |   struct RX5 (base)
 // CHECK-NEXT:    0 |     struct RA a (empty)
 // CHECK-NEXT:    1 |     struct RB b
 // CHECK-NEXT:    1 |       char c
 // CHECK-NEXT:    2 |   struct RY (base) (empty)
 // CHECK-NEXT:      | [sizeof=2, align=1
 // CHECK-NEXT:      |  nvsize=2, nvalign=1]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct RZ5
+// CHECK-X64-LABEL:   0 | struct RZ5{{$}}
 // CHECK-X64-NEXT:    0 |   struct RX5 (base)
 // CHECK-X64-NEXT:    0 |     struct RA a (empty)
 // CHECK-X64-NEXT:    1 |     struct RB b
 // CHECK-X64-NEXT:    1 |       char c
 // CHECK-X64-NEXT:    2 |   struct RY (base) (empty)
 // CHECK-X64-NEXT:      | [sizeof=2, align=1
 // CHECK-X64-NEXT:      |  nvsize=2, nvalign=1]
 
 struct RZ6 : RX6, RY {};
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct RZ6
+// CHECK-LABEL:   0 | struct RZ6{{$}}
 // CHECK-NEXT:    0 |   struct RX6 (base)
 // CHECK-NEXT:    0 |     (RX6 vbtable pointer)
 // CHECK-NEXT:    4 |     struct RB a
 // CHECK-NEXT:    4 |       char c
 // CHECK-NEXT:    9 |   struct RY (base) (empty)
 // CHECK-NEXT:   12 |   struct RV (virtual base) (empty)
 // CHECK-NEXT:      | [sizeof=12, align=4
 // CHECK-NEXT:      |  nvsize=12, nvalign=4]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct RZ6
+// CHECK-X64-LABEL:   0 | struct RZ6{{$}}
 // CHECK-X64-NEXT:    0 |   struct RX6 (base)
 // CHECK-X64-NEXT:    0 |     (RX6 vbtable pointer)
 // CHECK-X64-NEXT:    8 |     struct RB a
 // CHECK-X64-NEXT:    8 |       char c
 // CHECK-X64-NEXT:   17 |   struct RY (base) (empty)
 // CHECK-X64-NEXT:   24 |   struct RV (virtual base) (empty)
 // CHECK-X64-NEXT:      | [sizeof=24, align=8
 // CHECK-X64-NEXT:      |  nvsize=24, nvalign=8]
 
 struct RZ7 : RX7, RY {};
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct RZ7
+// CHECK-LABEL:   0 | struct RZ7{{$}}
 // CHECK-NEXT:    0 |   struct RX7 (base)
 // CHECK-NEXT:    0 |     (RX7 vbtable pointer)
 // CHECK-NEXT:    4 |     struct RA a (empty)
 // CHECK-NEXT:    8 |   struct RY (base) (empty)
 // CHECK-NEXT:    8 |   struct RW (virtual base)
 // CHECK-NEXT:    8 |     char c
 // CHECK-NEXT:      | [sizeof=9, align=4
 // CHECK-NEXT:      |  nvsize=8, nvalign=4]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct RZ7
+// CHECK-X64-LABEL:   0 | struct RZ7{{$}}
 // CHECK-X64-NEXT:    0 |   struct RX7 (base)
 // CHECK-X64-NEXT:    0 |     (RX7 vbtable pointer)
 // CHECK-X64-NEXT:    8 |     struct RA a (empty)
 // CHECK-X64-NEXT:   16 |   struct RY (base) (empty)
 // CHECK-X64-NEXT:   16 |   struct RW (virtual base)
 // CHECK-X64-NEXT:   16 |     char c
 // CHECK-X64-NEXT:      | [sizeof=24, align=8
 // CHECK-X64-NEXT:      |  nvsize=16, nvalign=8]
 
 struct RZ8 : RX8, RY {};
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct RZ8
+// CHECK-LABEL:   0 | struct RZ8{{$}}
 // CHECK-NEXT:    0 |   struct RX8 (base)
 // CHECK-NEXT:    4 |     struct RA (base) (empty)
 // CHECK-NEXT:    0 |     (RX8 vbtable pointer)
 // CHECK-NEXT:    4 |   struct RY (base) (empty)
 // CHECK-NEXT:    4 |   struct RW (virtual base)
 // CHECK-NEXT:    4 |     char c
 // CHECK-NEXT:      | [sizeof=5, align=4
 // CHECK-NEXT:      |  nvsize=4, nvalign=4]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct RZ8
+// CHECK-X64-LABEL:   0 | struct RZ8{{$}}
 // CHECK-X64-NEXT:    0 |   struct RX8 (base)
 // CHECK-X64-NEXT:    8 |     struct RA (base) (empty)
 // CHECK-X64-NEXT:    0 |     (RX8 vbtable pointer)
 // CHECK-X64-NEXT:    8 |   struct RY (base) (empty)
 // CHECK-X64-NEXT:    8 |   struct RW (virtual base)
 // CHECK-X64-NEXT:    8 |     char c
 // CHECK-X64-NEXT:      | [sizeof=16, align=8
 // CHECK-X64-NEXT:      |  nvsize=8, nvalign=8]
 
 struct JA {};
 struct JB {};
 struct JC : JA { virtual void f() {} };
 struct JD : virtual JB, virtual JC { virtual void f() {} JD() {} };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct JD
+// CHECK-LABEL:   0 | struct JD{{$}}
 // CHECK-NEXT:    0 |   (JD vbtable pointer)
 // CHECK-NEXT:    4 |   struct JB (virtual base) (empty)
 // CHECK-NEXT:    4 |   (vtordisp for vbase JC)
 // CHECK-NEXT:    8 |   struct JC (virtual base)
 // CHECK-NEXT:    8 |     (JC vftable pointer)
 // CHECK-NEXT:   12 |     struct JA (base) (empty)
 // CHECK-NEXT:      | [sizeof=12, align=4
 // CHECK-NEXT:      |  nvsize=4, nvalign=4]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct JD
+// CHECK-X64-LABEL:   0 | struct JD{{$}}
 // CHECK-X64-NEXT:    0 |   (JD vbtable pointer)
 // CHECK-X64-NEXT:    8 |   struct JB (virtual base) (empty)
 // CHECK-X64-NEXT:   12 |   (vtordisp for vbase JC)
 // CHECK-X64-NEXT:   16 |   struct JC (virtual base)
 // CHECK-X64-NEXT:   16 |     (JC vftable pointer)
 // CHECK-X64-NEXT:   24 |     struct JA (base) (empty)
 // CHECK-X64-NEXT:      | [sizeof=24, align=8
 // CHECK-X64-NEXT:      |  nvsize=8, nvalign=8]

clang/test/Layout/ms-x86-aligned-tail-padding.cpp

 // RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fms-extensions -fdump-record-layouts -fsyntax-only %s 2>/dev/null \
-// RUN:            | FileCheck %s
+// RUN:            | FileCheck %s --strict-whitespace
 // RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fms-extensions -fdump-record-layouts -fsyntax-only %s 2>/dev/null \
-// RUN:            | FileCheck %s -check-prefix CHECK-X64
+// RUN:            | FileCheck %s -check-prefix CHECK-X64 --strict-whitespace
 
 extern "C" int printf(const char *fmt, ...);
 
 struct B0 {
   int a;
   B0() : a(0xf00000B0) {}
 };
 struct __declspec(align(16)) B1 {
struct B6X {
   B6X() : a(0xf00000B6) {}
 };
 
 struct A : B1, B0, B2, virtual V {
   int a;
   A() : a(0xf000000A) {}
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct A
+// CHECK-LABEL:   0 | struct A{{$}}
 // CHECK-NEXT:    0 |   struct B1 (base)
 // CHECK-NEXT:    0 |     int a
 // CHECK-NEXT:    4 |   struct B0 (base)
 // CHECK-NEXT:    4 |     int a
 // CHECK-NEXT:   16 |   struct B2 (base)
 // CHECK-NEXT:   16 |     int a
 // CHECK-NEXT:   32 |   (A vbtable pointer)
 // CHECK-NEXT:   48 |   int a
 // CHECK-NEXT:   64 |   struct V (virtual base)
 // CHECK-NEXT:   64 |     char a
 // CHECK-NEXT:      | [sizeof=80, align=16
 // CHECK-NEXT:      |  nvsize=64, nvalign=16]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct A
+// CHECK-X64-LABEL:   0 | struct A{{$}}
 // CHECK-X64-NEXT:    0 |   struct B1 (base)
 // CHECK-X64-NEXT:    0 |     int a
 // CHECK-X64-NEXT:    4 |   struct B0 (base)
 // CHECK-X64-NEXT:    4 |     int a
 // CHECK-X64-NEXT:   16 |   struct B2 (base)
 // CHECK-X64-NEXT:   16 |     int a
 // CHECK-X64-NEXT:   32 |   (A vbtable pointer)
 // CHECK-X64-NEXT:   48 |   int a
 // CHECK-X64-NEXT:   64 |   struct V (virtual base)
 // CHECK-X64-NEXT:   64 |     char a
 // CHECK-X64-NEXT:      | [sizeof=80, align=16
 // CHECK-X64-NEXT:      |  nvsize=64, nvalign=16]
 
 struct B : B2, B0, B1, virtual V {
   int a;
   B() : a(0xf000000B) {}
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct B
+// CHECK-LABEL:   0 | struct B{{$}}
 // CHECK-NEXT:    0 |   struct B2 (base)
 // CHECK-NEXT:    0 |     int a
 // CHECK-NEXT:   16 |   struct B0 (base)
 // CHECK-NEXT:   16 |     int a
 // CHECK-NEXT:   32 |   struct B1 (base)
 // CHECK-NEXT:   32 |     int a
 // CHECK-NEXT:   36 |   (B vbtable pointer)
 // CHECK-NEXT:   52 |   int a
 // CHECK-NEXT:   64 |   struct V (virtual base)
 // CHECK-NEXT:   64 |     char a
 // CHECK-NEXT:      | [sizeof=80, align=16
 // CHECK-NEXT:      |  nvsize=64, nvalign=16]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct B
+// CHECK-X64-LABEL:   0 | struct B{{$}}
 // CHECK-X64-NEXT:    0 |   struct B2 (base)
 // CHECK-X64-NEXT:    0 |     int a
 // CHECK-X64-NEXT:   16 |   struct B0 (base)
 // CHECK-X64-NEXT:   16 |     int a
 // CHECK-X64-NEXT:   32 |   struct B1 (base)
 // CHECK-X64-NEXT:   32 |     int a
 // CHECK-X64-NEXT:   40 |   (B vbtable pointer)
 // CHECK-X64-NEXT:   52 |   int a
 // CHECK-X64-NEXT:   64 |   struct V (virtual base)
 // CHECK-X64-NEXT:   64 |     char a
 // CHECK-X64-NEXT:      | [sizeof=80, align=16
 // CHECK-X64-NEXT:      |  nvsize=64, nvalign=16]
 
 struct C : B1, B0, virtual V {
   int a;
   long long a1;
   C() : a(0xf000000C), a1(0xf000000Cf000000Cll) {}
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct C
+// CHECK-LABEL:   0 | struct C{{$}}
 // CHECK-NEXT:    0 |   struct B1 (base)
 // CHECK-NEXT:    0 |     int a
 // CHECK-NEXT:    4 |   struct B0 (base)
 // CHECK-NEXT:    4 |     int a
 // CHECK-NEXT:    8 |   (C vbtable pointer)
 // CHECK-NEXT:   24 |   int a
 // CHECK-NEXT:   32 |   long long a1
 // CHECK-NEXT:   48 |   struct V (virtual base)
 // CHECK-NEXT:   48 |     char a
 // CHECK-NEXT:      | [sizeof=64, align=16
 // CHECK-NEXT:      |  nvsize=48, nvalign=16]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct C
+// CHECK-X64-LABEL:   0 | struct C{{$}}
 // CHECK-X64-NEXT:    0 |   struct B1 (base)
 // CHECK-X64-NEXT:    0 |     int a
 // CHECK-X64-NEXT:    4 |   struct B0 (base)
 // CHECK-X64-NEXT:    4 |     int a
 // CHECK-X64-NEXT:    8 |   (C vbtable pointer)
 // CHECK-X64-NEXT:   24 |   int a
 // CHECK-X64-NEXT:   32 |   long long a1
 // CHECK-X64-NEXT:   48 |   struct V (virtual base)
 // CHECK-X64-NEXT:   48 |     char a
 // CHECK-X64-NEXT:      | [sizeof=64, align=16
 // CHECK-X64-NEXT:      |  nvsize=48, nvalign=16]
 
 struct D : B2, B0, virtual V {
   int a;
   D() : a(0xf000000D) {}
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct D
+// CHECK-LABEL:   0 | struct D{{$}}
 // CHECK-NEXT:    0 |   struct B2 (base)
 // CHECK-NEXT:    0 |     int a
 // CHECK-NEXT:   16 |   struct B0 (base)
 // CHECK-NEXT:   16 |     int a
 // CHECK-NEXT:   20 |   (D vbtable pointer)
 // CHECK-NEXT:   36 |   int a
 // CHECK-NEXT:   48 |   struct V (virtual base)
 // CHECK-NEXT:   48 |     char a
 // CHECK-NEXT:      | [sizeof=64, align=16
 // CHECK-NEXT:      |  nvsize=48, nvalign=16]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct D
+// CHECK-X64-LABEL:   0 | struct D{{$}}
 // CHECK-X64-NEXT:    0 |   struct B2 (base)
 // CHECK-X64-NEXT:    0 |     int a
 // CHECK-X64-NEXT:   16 |   struct B0 (base)
 // CHECK-X64-NEXT:   16 |     int a
 // CHECK-X64-NEXT:   24 |   (D vbtable pointer)
 // CHECK-X64-NEXT:   36 |   int a
 // CHECK-X64-NEXT:   48 |   struct V (virtual base)
 // CHECK-X64-NEXT:   48 |     char a
 // CHECK-X64-NEXT:      | [sizeof=64, align=16
 // CHECK-X64-NEXT:      |  nvsize=48, nvalign=16]
 
 struct E : B3, B0, virtual V {
   int a;
   E() : a(0xf000000E) {}
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct E
+// CHECK-LABEL:   0 | struct E{{$}}
 // CHECK-NEXT:    0 |   struct B3 (base)
 // CHECK-NEXT:    0 |     long long a1
 // CHECK-NEXT:    8 |     int a
 // CHECK-NEXT:   16 |   struct B0 (base)
 // CHECK-NEXT:   16 |     int a
 // CHECK-NEXT:   20 |   (E vbtable pointer)
 // CHECK-NEXT:   36 |   int a
 // CHECK-NEXT:   48 |   struct V (virtual base)
 // CHECK-NEXT:   48 |     char a
 // CHECK-NEXT:      | [sizeof=64, align=16
 // CHECK-NEXT:      |  nvsize=48, nvalign=16]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct E
+// CHECK-X64-LABEL:   0 | struct E{{$}}
 // CHECK-X64-NEXT:    0 |   struct B3 (base)
 // CHECK-X64-NEXT:    0 |     long long a1
 // CHECK-X64-NEXT:    8 |     int a
 // CHECK-X64-NEXT:   16 |   struct B0 (base)
 // CHECK-X64-NEXT:   16 |     int a
 // CHECK-X64-NEXT:   24 |   (E vbtable pointer)
 // CHECK-X64-NEXT:   36 |   int a
 // CHECK-X64-NEXT:   48 |   struct V (virtual base)
 // CHECK-X64-NEXT:   48 |     char a
 // CHECK-X64-NEXT:      | [sizeof=64, align=16
 // CHECK-X64-NEXT:      |  nvsize=48, nvalign=16]
 
 struct F : B0, virtual V1 {
   __declspec(align(16)) int a;
   F() : a(0xf000000F) {}
   virtual void f() {}
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct F
+// CHECK-LABEL:   0 | struct F{{$}}
 // CHECK-NEXT:    0 |   struct B0 (base)
 // CHECK-NEXT:    0 |     int a
 // CHECK-NEXT:    4 |   (F vbtable pointer)
 // CHECK-NEXT:   32 |   int a
 // CHECK-NEXT:   92 |   (vtordisp for vbase V1)
 // CHECK-NEXT:   96 |   struct V1 (virtual base)
 // CHECK-NEXT:   96 |     (V1 vftable pointer)
 // CHECK-NEXT:  128 |     struct A16 (base) (empty)
 // CHECK-NEXT:      | [sizeof=128, align=32
 // CHECK-NEXT:      |  nvsize=48, nvalign=32]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct F
+// CHECK-X64-LABEL:   0 | struct F{{$}}
 // CHECK-X64-NEXT:    0 |   struct B0 (base)
 // CHECK-X64-NEXT:    0 |     int a
 // CHECK-X64-NEXT:    8 |   (F vbtable pointer)
 // CHECK-X64-NEXT:   32 |   int a
 // CHECK-X64-NEXT:   92 |   (vtordisp for vbase V1)
 // CHECK-X64-NEXT:   96 |   struct V1 (virtual base)
 // CHECK-X64-NEXT:   96 |     (V1 vftable pointer)
 // CHECK-X64-NEXT:  128 |     struct A16 (base) (empty)
 // CHECK-X64-NEXT:      | [sizeof=128, align=32
 // CHECK-X64-NEXT:      |  nvsize=48, nvalign=32]
 
 struct G : virtual V2, virtual V3 {
   int a;
   G() : a(0xf0000001) {}
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct G
+// CHECK-LABEL:   0 | struct G{{$}}
 // CHECK-NEXT:    0 |   (G vbtable pointer)
 // CHECK-NEXT:    4 |   int a
 // CHECK-NEXT:    8 |   struct V2 (virtual base)
 // CHECK-NEXT:    8 |     long long a
 // CHECK-NEXT:   16 |     int a1
 // CHECK-NEXT:   24 |   struct V3 (virtual base)
 // CHECK-NEXT:   24 |     int a
 // CHECK-NEXT:      | [sizeof=28, align=8
 // CHECK-NEXT:      |  nvsize=8, nvalign=8]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct G
+// CHECK-X64-LABEL:   0 | struct G{{$}}
 // CHECK-X64-NEXT:    0 |   (G vbtable pointer)
 // CHECK-X64-NEXT:    8 |   int a
 // CHECK-X64-NEXT:   16 |   struct V2 (virtual base)
 // CHECK-X64-NEXT:   16 |     long long a
 // CHECK-X64-NEXT:   24 |     int a1
 // CHECK-X64-NEXT:   32 |   struct V3 (virtual base)
 // CHECK-X64-NEXT:   32 |     int a
 // CHECK-X64-NEXT:      | [sizeof=40, align=8
 // CHECK-X64-NEXT:      |  nvsize=16, nvalign=8]
 
 struct H {
   __declspec(align(16)) int a;
   int b;
   H() : a(0xf0000010), b(0xf0000010) {}
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct H
+// CHECK-LABEL:   0 | struct H{{$}}
 // CHECK-NEXT:    0 |   int a
 // CHECK-NEXT:    4 |   int b
 // CHECK-NEXT:      | [sizeof=16, align=16
 // CHECK-NEXT:      |  nvsize=16, nvalign=16]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct H
+// CHECK-X64-LABEL:   0 | struct H{{$}}
 // CHECK-X64-NEXT:    0 |   int a
 // CHECK-X64-NEXT:    4 |   int b
 // CHECK-X64-NEXT:      | [sizeof=16, align=16
 // CHECK-X64-NEXT:      |  nvsize=16, nvalign=16]
 
 struct I {
   B2 a;
   int b;
   I() : b(0xf0000010) {}
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct I
+// CHECK-LABEL:   0 | struct I{{$}}
 // CHECK-NEXT:    0 |   struct B2 a
 // CHECK-NEXT:    0 |     int a
 // CHECK:        16 |   int b
 // CHECK-NEXT:      | [sizeof=32, align=16
 // CHECK-NEXT:      |  nvsize=32, nvalign=16]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct I
+// CHECK-X64-LABEL:   0 | struct I{{$}}
 // CHECK-X64-NEXT:    0 |   struct B2 a
 // CHECK-X64-NEXT:    0 |     int a
 // CHECK-X64:        16 |   int b
 // CHECK-X64-NEXT:      | [sizeof=32, align=16
 // CHECK-X64-NEXT:      |  nvsize=32, nvalign=16]
 
 struct AX : B0X, virtual B2X, virtual B6X, virtual B3X {
   int a;
   AX() : a(0xf000000A) {}
   virtual void f() {}
   virtual void g() {}
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct AX
+// CHECK-LABEL:   0 | struct AX{{$}}
 // CHECK-NEXT:    0 |   (AX vftable pointer)
 // CHECK-NEXT:   16 |   struct B0X (base)
 // CHECK-NEXT:   16 |     int a
 // CHECK-NEXT:   20 |     int a1
 // CHECK-NEXT:   24 |   (AX vbtable pointer)
 // CHECK-NEXT:   40 |   int a
 // CHECK-NEXT:   48 |   struct B2X (virtual base)
 // CHECK-NEXT:   48 |     int a
 // CHECK-NEXT:   52 |   struct B6X (virtual base)
 // CHECK-NEXT:   52 |     int a
 // CHECK-NEXT:   76 |   (vtordisp for vbase B3X)
 // CHECK-NEXT:   80 |   struct B3X (virtual base)
 // CHECK-NEXT:   80 |     (B3X vftable pointer)
 // CHECK-NEXT:   84 |     int a
 // CHECK-NEXT:      | [sizeof=96, align=16
 // CHECK-NEXT:      |  nvsize=48, nvalign=16]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct AX
+// CHECK-X64-LABEL:   0 | struct AX{{$}}
 // CHECK-X64-NEXT:    0 |   (AX vftable pointer)
 // CHECK-X64-NEXT:   16 |   struct B0X (base)
 // CHECK-X64-NEXT:   16 |     int a
 // CHECK-X64-NEXT:   20 |     int a1
 // CHECK-X64-NEXT:   24 |   (AX vbtable pointer)
 // CHECK-X64-NEXT:   40 |   int a
 // CHECK-X64-NEXT:   48 |   struct B2X (virtual base)
 // CHECK-X64-NEXT:   48 |     int a
 // CHECK-X64-NEXT:   52 |   struct B6X (virtual base)
 // CHECK-X64-NEXT:   52 |     int a
 // CHECK-X64-NEXT:   76 |   (vtordisp for vbase B3X)
 // CHECK-X64-NEXT:   80 |   struct B3X (virtual base)
 // CHECK-X64-NEXT:   80 |     (B3X vftable pointer)
 // CHECK-X64-NEXT:   88 |     int a
 // CHECK-X64-NEXT:      | [sizeof=96, align=16
 // CHECK-X64-NEXT:      |  nvsize=48, nvalign=16]
 
 struct BX : B4X, virtual B2X, virtual B6X, virtual B3X {
   int a;
   BX() : a(0xf000000B) {}
   virtual void f() {}
   virtual void g() {}
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct BX
+// CHECK-LABEL:   0 | struct BX{{$}}
 // CHECK-NEXT:    0 |   (BX vftable pointer)
 // CHECK-NEXT:   16 |   struct B4X (base)
 // CHECK-NEXT:   16 |     struct A16X (base) (empty)
 // CHECK-NEXT:   16 |     int a
 // CHECK-NEXT:   20 |     int a1
 // CHECK-NEXT:   32 |   (BX vbtable pointer)
 // CHECK-NEXT:   48 |   int a
 // CHECK-NEXT:   64 |   struct B2X (virtual base)
 // CHECK-NEXT:   64 |     int a
 // CHECK-NEXT:   68 |   struct B6X (virtual base)
 // CHECK-NEXT:   68 |     int a
 // CHECK-NEXT:   92 |   (vtordisp for vbase B3X)
 // CHECK-NEXT:   96 |   struct B3X (virtual base)
 // CHECK-NEXT:   96 |     (B3X vftable pointer)
 // CHECK-NEXT:  100 |     int a
 // CHECK-NEXT:      | [sizeof=112, align=16
 // CHECK-NEXT:      |  nvsize=64, nvalign=16]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct BX
+// CHECK-X64-LABEL:   0 | struct BX{{$}}
 // CHECK-X64-NEXT:    0 |   (BX vftable pointer)
 // CHECK-X64-NEXT:   16 |   struct B4X (base)
 // CHECK-X64-NEXT:   16 |     struct A16X (base) (empty)
 // CHECK-X64-NEXT:   16 |     int a
 // CHECK-X64-NEXT:   20 |     int a1
 // CHECK-X64-NEXT:   32 |   (BX vbtable pointer)
 // CHECK-X64-NEXT:   48 |   int a
 // CHECK-X64-NEXT:   64 |   struct B2X (virtual base)

 
 struct CX : B5X, virtual B2X, virtual B6X, virtual B3X {
   int a;
   CX() : a(0xf000000C) {}
   virtual void f() {}
   virtual void g() {}
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct CX
+// CHECK-LABEL:   0 | struct CX{{$}}
 // CHECK-NEXT:    0 |   (CX vftable pointer)
 // CHECK-NEXT:   16 |   struct B5X (base)
 // CHECK-NEXT:   16 |     (B5X vbtable pointer)
 // CHECK-NEXT:   20 |     int a
 // CHECK-NEXT:   24 |     int a1
 // CHECK-NEXT:   28 |   int a
 // CHECK-NEXT:   32 |   struct A16X (virtual base) (empty)
 // CHECK-NEXT:   32 |   struct B2X (virtual base)
 // CHECK-NEXT:   32 |     int a
 // CHECK-NEXT:   36 |   struct B6X (virtual base)
 // CHECK-NEXT:   36 |     int a
 // CHECK-NEXT:   60 |   (vtordisp for vbase B3X)
 // CHECK-NEXT:   64 |   struct B3X (virtual base)
 // CHECK-NEXT:   64 |     (B3X vftable pointer)
 // CHECK-NEXT:   68 |     int a
 // CHECK-NEXT:      | [sizeof=80, align=16
 // CHECK-NEXT:      |  nvsize=32, nvalign=16]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct CX
+// CHECK-X64-LABEL:   0 | struct CX{{$}}
 // CHECK-X64-NEXT:    0 |   (CX vftable pointer)
 // CHECK-X64-NEXT:   16 |   struct B5X (base)
 // CHECK-X64-NEXT:   16 |     (B5X vbtable pointer)
 // CHECK-X64-NEXT:   24 |     int a
 // CHECK-X64-NEXT:   28 |     int a1
 // CHECK-X64-NEXT:   32 |   int a
 // CHECK-X64-NEXT:   48 |   struct A16X (virtual base) (empty)
 // CHECK-X64-NEXT:   48 |   struct B2X (virtual base)
 // CHECK-X64-NEXT:   48 |     int a
 // CHECK-X64-NEXT:   52 |   struct B6X (virtual base)
 // CHECK-X64-NEXT:   52 |     int a
 // CHECK-X64-NEXT:   76 |   (vtordisp for vbase B3X)
 // CHECK-X64-NEXT:   80 |   struct B3X (virtual base)
 // CHECK-X64-NEXT:   80 |     (B3X vftable pointer)
 // CHECK-X64-NEXT:   88 |     int a
 // CHECK-X64-NEXT:      | [sizeof=96, align=16
 // CHECK-X64-NEXT:      |  nvsize=48, nvalign=16]
 
 struct __declspec(align(16)) DX {
   int a;
   DX() : a(0xf000000D) {}
   virtual void f() {}
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct DX
+// CHECK-LABEL:   0 | struct DX{{$}}
 // CHECK-NEXT:    0 |   (DX vftable pointer)
 // CHECK-NEXT:    4 |   int a
 // CHECK-NEXT:      | [sizeof=16, align=16
 // CHECK-NEXT:      |  nvsize=8, nvalign=16]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct DX
+// CHECK-X64-LABEL:   0 | struct DX{{$}}
 // CHECK-X64-NEXT:    0 |   (DX vftable pointer)
 // CHECK-X64-NEXT:    8 |   int a
 // CHECK-X64-NEXT:      | [sizeof=16, align=16
 // CHECK-X64-NEXT:      |  nvsize=16, nvalign=16]
 
 int a[
 sizeof(A)+
 sizeof(B)+

clang/test/Layout/ms-x86-basic-layout.cpp

 // RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fms-extensions -fdump-record-layouts -fsyntax-only %s 2>/dev/null \
-// RUN:            | FileCheck %s
+// RUN:            | FileCheck %s --strict-whitespace
 // RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fms-extensions -fdump-record-layouts -fsyntax-only %s 2>/dev/null \
-// RUN:            | FileCheck %s -check-prefix CHECK-X64
+// RUN:            | FileCheck %s -check-prefix CHECK-X64 --strict-whitespace
 
 extern "C" int printf(const char *fmt, ...);
 
 struct A4 {
   int a;
   A4() : a(0xf00000a4) {}
 };
 

 };
 
 struct C16 {
   __declspec(align(16)) int a;
   C16() : a(0xf0000c16) {}
   virtual void f() {printf("C16");}
 };
 
+struct TestF3 : A4, virtual C16 {
+  int a;
+  TestF3() : a(0xf00000f3) {}
+};
+
+// CHECK-LABEL:   0 | struct TestF3{{$}}
+// CHECK-NEXT:    0 |   struct A4 (base)
+// CHECK-NEXT:    0 |     int a
+// CHECK-NEXT:    4 |   (TestF3 vbtable pointer)
+// CHECK-NEXT:    8 |   int a
+// CHECK-NEXT:   16 |   struct C16 (virtual base)
+// CHECK-NEXT:   16 |     (C16 vftable pointer)
+// CHECK-NEXT:   32 |     int a
+// CHECK-NEXT:      | [sizeof=48, align=16
+// CHECK-NEXT:      |  nvsize=12, nvalign=16]
+// CHECK-X64-LABEL:   0 | struct TestF3{{$}}
+// CHECK-X64-NEXT:    0 |   struct A4 (base)
+// CHECK-X64-NEXT:    0 |     int a
+// CHECK-X64-NEXT:    8 |   (TestF3 vbtable pointer)
+// CHECK-X64-NEXT:   16 |   int a
+// CHECK-X64-NEXT:   32 |   struct C16 (virtual base)
+// CHECK-X64-NEXT:   32 |     (C16 vftable pointer)
+// CHECK-X64-NEXT:   48 |     int a
+// CHECK-X64-NEXT:      | [sizeof=64, align=16
+// CHECK-X64-NEXT:      |  nvsize=24, nvalign=16]
+
+struct TestF7 : A4, virtual C16 {
+  int a;
+  TestF7() : a(0xf00000f7) {}
+  virtual void f() { printf("F7"); }
+};
+
+// CHECK-LABEL:   0 | struct TestF7{{$}}
+// CHECK-NEXT:    0 |   struct A4 (base)
+// CHECK-NEXT:    0 |     int a
+// CHECK-NEXT:    4 |   (TestF7 vbtable pointer)
+// CHECK-NEXT:    8 |   int a
+// CHECK-NEXT:   28 |   (vtordisp for vbase C16)
+// CHECK-NEXT:   32 |   struct C16 (virtual base)
+// CHECK-NEXT:   32 |     (C16 vftable pointer)
+// CHECK-NEXT:   48 |     int a
+// CHECK-NEXT:      | [sizeof=64, align=16
+// CHECK-NEXT:      |  nvsize=12, nvalign=16]
+// CHECK-X64-LABEL:   0 | struct TestF7{{$}}
+// CHECK-X64-NEXT:    0 |   struct A4 (base)
+// CHECK-X64-NEXT:    0 |     int a
+// CHECK-X64-NEXT:    8 |   (TestF7 vbtable pointer)
+// CHECK-X64-NEXT:   16 |   int a
+// CHECK-X64-NEXT:   44 |   (vtordisp for vbase C16)
+// CHECK-X64-NEXT:   48 |   struct C16 (virtual base)
+// CHECK-X64-NEXT:   48 |     (C16 vftable pointer)
+// CHECK-X64-NEXT:   64 |     int a
+// CHECK-X64-NEXT:      | [sizeof=80, align=16
+// CHECK-X64-NEXT:      |  nvsize=24, nvalign=16]
+
+struct TestF9 : A4, virtual C16 {
+  int a;
+  TestF9() : a(0xf00000f9) {}
+  virtual void g() { printf("F9"); }
+};
+
+// CHECK-LABEL:   0 | struct TestF9{{$}}
+// CHECK-NEXT:    0 |   (TestF9 vftable pointer)
+// CHECK-NEXT:    4 |   struct A4 (base)
+// CHECK-NEXT:    4 |     int a
+// CHECK-NEXT:    8 |   (TestF9 vbtable pointer)
+// CHECK-NEXT:   12 |   int a
+// CHECK-NEXT:   16 |   struct C16 (virtual base)
+// CHECK-NEXT:   16 |     (C16 vftable pointer)
+// CHECK-NEXT:   32 |     int a
+// CHECK-NEXT:      | [sizeof=48, align=16
+// CHECK-NEXT:      |  nvsize=16, nvalign=16]
+// CHECK-X64-LABEL:   0 | struct TestF9{{$}}
+// CHECK-X64-NEXT:    0 |   (TestF9 vftable pointer)
+// CHECK-X64-NEXT:    8 |   struct A4 (base)
+// CHECK-X64-NEXT:    8 |     int a
+// CHECK-X64-NEXT:   16 |   (TestF9 vbtable pointer)
+// CHECK-X64-NEXT:   24 |   int a
+// CHECK-X64-NEXT:   32 |   struct C16 (virtual base)
+// CHECK-X64-NEXT:   32 |     (C16 vftable pointer)
+// CHECK-X64-NEXT:   48 |     int a
+// CHECK-X64-NEXT:      | [sizeof=64, align=16
+// CHECK-X64-NEXT:      |  nvsize=32, nvalign=16]
+
+struct TestFB : A16, virtual C16 {
+  int a;
+  TestFB() : a(0xf00000fb) {}
+  virtual void g() { printf("Fb"); }
+};
+
+// CHECK-LABEL:   0 | struct TestFB{{$}}
+// CHECK-NEXT:    0 |   (TestFB vftable pointer)
+// CHECK-NEXT:   16 |   struct A16 (base)
+// CHECK-NEXT:   16 |     int a
+// CHECK-NEXT:   32 |   (TestFB vbtable pointer)
+// CHECK-NEXT:   48 |   int a
+// CHECK-NEXT:   64 |   struct C16 (virtual base)
+// CHECK-NEXT:   64 |     (C16 vftable pointer)
+// CHECK-NEXT:   80 |     int a
+// CHECK-NEXT:      | [sizeof=96, align=16
+// CHECK-NEXT:      |  nvsize=64, nvalign=16]
+// CHECK-X64-LABEL:   0 | struct TestFB{{$}}
+// CHECK-X64-NEXT:    0 |   (TestFB vftable pointer)
+// CHECK-X64-NEXT:   16 |   struct A16 (base)
+// CHECK-X64-NEXT:   16 |     int a
+// CHECK-X64-NEXT:   32 |   (TestFB vbtable pointer)
+// CHECK-X64-NEXT:   48 |   int a
+// CHECK-X64-NEXT:   64 |   struct C16 (virtual base)
+// CHECK-X64-NEXT:   64 |     (C16 vftable pointer)
+// CHECK-X64-NEXT:   80 |     int a
+// CHECK-X64-NEXT:      | [sizeof=96, align=16
+// CHECK-X64-NEXT:      |  nvsize=64, nvalign=16]
+
 struct TestF0 : A4, virtual B4 {
   int a;
   TestF0() : a(0xf00000F0) {}
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct TestF0
+// CHECK-LABEL:   0 | struct TestF0{{$}}
 // CHECK-NEXT:    0 |   struct A4 (base)
 // CHECK-NEXT:    0 |     int a
 // CHECK-NEXT:    4 |   (TestF0 vbtable pointer)
 // CHECK-NEXT:    8 |   int a
 // CHECK-NEXT:   12 |   struct B4 (virtual base)
 // CHECK-NEXT:   12 |     int a
 // CHECK-NEXT:      | [sizeof=16, align=4
 // CHECK-NEXT:      |  nvsize=12, nvalign=4]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct TestF0
+// CHECK-X64-LABEL:   0 | struct TestF0{{$}}
 // CHECK-X64-NEXT:    0 |   struct A4 (base)
 // CHECK-X64-NEXT:    0 |     int a
 // CHECK-X64-NEXT:    8 |   (TestF0 vbtable pointer)
 // CHECK-X64-NEXT:   16 |   int a
 // CHECK-X64-NEXT:   24 |   struct B4 (virtual base)
 // CHECK-X64-NEXT:   24 |     int a
 // CHECK-X64-NEXT:      | [sizeof=32, align=8
 // CHECK-X64-NEXT:      |  nvsize=24, nvalign=8]
 
 struct TestF1 : A4, virtual A16 {
   int a;
   TestF1() : a(0xf00000f1) {}
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct TestF1
+// CHECK-LABEL:   0 | struct TestF1{{$}}
 // CHECK-NEXT:    0 |   struct A4 (base)
 // CHECK-NEXT:    0 |     int a
 // CHECK-NEXT:    4 |   (TestF1 vbtable pointer)
 // CHECK-NEXT:    8 |   int a
 // CHECK-NEXT:   16 |   struct A16 (virtual base)
 // CHECK-NEXT:   16 |     int a
 // CHECK-NEXT:      | [sizeof=32, align=16
 // CHECK-NEXT:      |  nvsize=12, nvalign=16]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct TestF1
+// CHECK-X64-LABEL:   0 | struct TestF1{{$}}
 // CHECK-X64-NEXT:    0 |   struct A4 (base)
 // CHECK-X64-NEXT:    0 |     int a
 // CHECK-X64-NEXT:    8 |   (TestF1 vbtable pointer)
 // CHECK-X64-NEXT:   16 |   int a
 // CHECK-X64-NEXT:   32 |   struct A16 (virtual base)
 // CHECK-X64-NEXT:   32 |     int a
 // CHECK-X64-NEXT:      | [sizeof=48, align=16
 // CHECK-X64-NEXT:      |  nvsize=24, nvalign=16]
 
 struct TestF2 : A4, virtual C4 {
   int a;
   TestF2() : a(0xf00000f2) {}
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct TestF2
+// CHECK-LABEL:   0 | struct TestF2{{$}}
 // CHECK-NEXT:    0 |   struct A4 (base)
 // CHECK-NEXT:    0 |     int a
 // CHECK-NEXT:    4 |   (TestF2 vbtable pointer)
 // CHECK-NEXT:    8 |   int a
 // CHECK-NEXT:   12 |   struct C4 (virtual base)
 // CHECK-NEXT:   12 |     (C4 vftable pointer)
 // CHECK-NEXT:   16 |     int a
 // CHECK-NEXT:      | [sizeof=20, align=4
 // CHECK-NEXT:      |  nvsize=12, nvalign=4]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct TestF2
+// CHECK-X64-LABEL:   0 | struct TestF2{{$}}
 // CHECK-X64-NEXT:    0 |   struct A4 (base)
 // CHECK-X64-NEXT:    0 |     int a
 // CHECK-X64-NEXT:    8 |   (TestF2 vbtable pointer)
 // CHECK-X64-NEXT:   16 |   int a
 // CHECK-X64-NEXT:   24 |   struct C4 (virtual base)
 // CHECK-X64-NEXT:   24 |     (C4 vftable pointer)
 // CHECK-X64-NEXT:   32 |     int a
 // CHECK-X64-NEXT:      | [sizeof=40, align=8
 // CHECK-X64-NEXT:      |  nvsize=24, nvalign=8]
 
-struct TestF3 : A4, virtual C16 {
-  int a;
-  TestF3() : a(0xf00000f3) {}
-};
-
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct TestF3
-// CHECK-NEXT:    0 |   struct A4 (base)
-// CHECK-NEXT:    0 |     int a
-// CHECK-NEXT:    4 |   (TestF3 vbtable pointer)
-// CHECK-NEXT:    8 |   int a
-// CHECK-NEXT:   16 |   struct C16 (virtual base)
-// CHECK-NEXT:   16 |     (C16 vftable pointer)
-// CHECK-NEXT:   32 |     int a
-// CHECK-NEXT:      | [sizeof=48, align=16
-// CHECK-NEXT:      |  nvsize=12, nvalign=16]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct TestF3
-// CHECK-X64-NEXT:    0 |   struct A4 (base)
-// CHECK-X64-NEXT:    0 |     int a
-// CHECK-X64-NEXT:    8 |   (TestF3 vbtable pointer)
-// CHECK-X64-NEXT:   16 |   int a
-// CHECK-X64-NEXT:   32 |   struct C16 (virtual base)
-// CHECK-X64-NEXT:   32 |     (C16 vftable pointer)
-// CHECK-X64-NEXT:   48 |     int a
-// CHECK-X64-NEXT:      | [sizeof=64, align=16
-// CHECK-X64-NEXT:      |  nvsize=24, nvalign=16]
-
 struct TestF4 : TestF3, A4 {
   int a;
   TestF4() : a(0xf00000f4) {}
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct TestF4
+// CHECK-LABEL:   0 | struct TestF4{{$}}
 // CHECK-NEXT:    0 |   struct TestF3 (base)
 // CHECK-NEXT:    0 |     struct A4 (base)
 // CHECK-NEXT:    0 |       int a
 // CHECK-NEXT:    4 |     (TestF3 vbtable pointer)
 // CHECK-NEXT:    8 |     int a
 // CHECK-NEXT:   12 |   struct A4 (base)
 // CHECK-NEXT:   12 |     int a
 // CHECK-NEXT:   16 |   int a
 // CHECK-NEXT:   32 |   struct C16 (virtual base)
 // CHECK-NEXT:   32 |     (C16 vftable pointer)
 // CHECK-NEXT:   48 |     int a
 // CHECK-NEXT:      | [sizeof=64, align=16
 // CHECK-NEXT:      |  nvsize=32, nvalign=16]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct TestF4
+// CHECK-X64-LABEL:   0 | struct TestF4{{$}}
 // CHECK-X64-NEXT:    0 |   struct TestF3 (base)
 // CHECK-X64-NEXT:    0 |     struct A4 (base)
 // CHECK-X64-NEXT:    0 |       int a
 // CHECK-X64-NEXT:    8 |     (TestF3 vbtable pointer)
 // CHECK-X64-NEXT:   16 |     int a
 // CHECK-X64-NEXT:   24 |   struct A4 (base)
 // CHECK-X64-NEXT:   24 |     int a
 // CHECK-X64-NEXT:   28 |   int a
 // CHECK-X64-NEXT:   32 |   struct C16 (virtual base)
 // CHECK-X64-NEXT:   32 |     (C16 vftable pointer)
 // CHECK-X64-NEXT:   48 |     int a
 // CHECK-X64-NEXT:      | [sizeof=64, align=16
 // CHECK-X64-NEXT:      |  nvsize=32, nvalign=16]
 
 struct TestF5 : TestF3, A4 {
   int a;
   TestF5() : a(0xf00000f5) {}
   virtual void g() {printf("F5");}
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct TestF5
+// CHECK-LABEL:   0 | struct TestF5{{$}}
 // CHECK-NEXT:    0 |   (TestF5 vftable pointer)
 // CHECK-NEXT:   16 |   struct TestF3 (base)
 // CHECK-NEXT:   16 |     struct A4 (base)
 // CHECK-NEXT:   16 |       int a
 // CHECK-NEXT:   20 |     (TestF3 vbtable pointer)
 // CHECK-NEXT:   24 |     int a
 // CHECK-NEXT:   28 |   struct A4 (base)
 // CHECK-NEXT:   28 |     int a
 // CHECK-NEXT:   32 |   int a
 // CHECK-NEXT:   48 |   struct C16 (virtual base)
 // CHECK-NEXT:   48 |     (C16 vftable pointer)
 // CHECK-NEXT:   64 |     int a
 // CHECK-NEXT:      | [sizeof=80, align=16
 // CHECK-NEXT:      |  nvsize=48, nvalign=16]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct TestF5
+// CHECK-X64-LABEL:   0 | struct TestF5{{$}}
 // CHECK-X64-NEXT:    0 |   (TestF5 vftable pointer)
 // CHECK-X64-NEXT:   16 |   struct TestF3 (base)
 // CHECK-X64-NEXT:   16 |     struct A4 (base)
 // CHECK-X64-NEXT:   16 |       int a
 // CHECK-X64-NEXT:   24 |     (TestF3 vbtable pointer)
 // CHECK-X64-NEXT:   32 |     int a
 // CHECK-X64-NEXT:   40 |   struct A4 (base)
 // CHECK-X64-NEXT:   40 |     int a
 // CHECK-X64-NEXT:   44 |   int a
 // CHECK-X64-NEXT:   48 |   struct C16 (virtual base)
 // CHECK-X64-NEXT:   48 |     (C16 vftable pointer)
 // CHECK-X64-NEXT:   64 |     int a
 // CHECK-X64-NEXT:      | [sizeof=80, align=16
 // CHECK-X64-NEXT:      |  nvsize=48, nvalign=16]
 
 struct TestF6 : TestF3, A4 {
   int a;
   TestF6() : a(0xf00000f6) {}
   virtual void f() {printf("F6");}
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct TestF6
+// CHECK-LABEL:   0 | struct TestF6{{$}}
 // CHECK-NEXT:    0 |   struct TestF3 (base)
 // CHECK-NEXT:    0 |     struct A4 (base)
 // CHECK-NEXT:    0 |       int a
 // CHECK-NEXT:    4 |     (TestF3 vbtable pointer)
 // CHECK-NEXT:    8 |     int a
 // CHECK-NEXT:   12 |   struct A4 (base)
 // CHECK-NEXT:   12 |     int a
 // CHECK-NEXT:   16 |   int a
 // CHECK-NEXT:   44 |   (vtordisp for vbase C16)
 // CHECK-NEXT:   48 |   struct C16 (virtual base)
 // CHECK-NEXT:   48 |     (C16 vftable pointer)
 // CHECK-NEXT:   64 |     int a
 // CHECK-NEXT:      | [sizeof=80, align=16
 // CHECK-NEXT:      |  nvsize=32, nvalign=16]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct TestF6
+// CHECK-X64-LABEL:   0 | struct TestF6{{$}}
 // CHECK-X64-NEXT:    0 |   struct TestF3 (base)
 // CHECK-X64-NEXT:    0 |     struct A4 (base)
 // CHECK-X64-NEXT:    0 |       int a
 // CHECK-X64-NEXT:    8 |     (TestF3 vbtable pointer)
 // CHECK-X64-NEXT:   16 |     int a
 // CHECK-X64-NEXT:   24 |   struct A4 (base)
 // CHECK-X64-NEXT:   24 |     int a
 // CHECK-X64-NEXT:   28 |   int a
 // CHECK-X64-NEXT:   44 |   (vtordisp for vbase C16)
 // CHECK-X64-NEXT:   48 |   struct C16 (virtual base)
 // CHECK-X64-NEXT:   48 |     (C16 vftable pointer)
 // CHECK-X64-NEXT:   64 |     int a
 // CHECK-X64-NEXT:      | [sizeof=80, align=16
 // CHECK-X64-NEXT:      |  nvsize=32, nvalign=16]
 
-struct TestF7 : A4, virtual C16 {
-  int a;
-  TestF7() : a(0xf00000f7) {}
-  virtual void f() {printf("F7");}
-};
-
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct TestF7
-// CHECK-NEXT:    0 |   struct A4 (base)
-// CHECK-NEXT:    0 |     int a
-// CHECK-NEXT:    4 |   (TestF7 vbtable pointer)
-// CHECK-NEXT:    8 |   int a
-// CHECK-NEXT:   28 |   (vtordisp for vbase C16)
-// CHECK-NEXT:   32 |   struct C16 (virtual base)
-// CHECK-NEXT:   32 |     (C16 vftable pointer)
-// CHECK-NEXT:   48 |     int a
-// CHECK-NEXT:      | [sizeof=64, align=16
-// CHECK-NEXT:      |  nvsize=12, nvalign=16]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct TestF7
-// CHECK-X64-NEXT:    0 |   struct A4 (base)
-// CHECK-X64-NEXT:    0 |     int a
-// CHECK-X64-NEXT:    8 |   (TestF7 vbtable pointer)
-// CHECK-X64-NEXT:   16 |   int a
-// CHECK-X64-NEXT:   44 |   (vtordisp for vbase C16)
-// CHECK-X64-NEXT:   48 |   struct C16 (virtual base)
-// CHECK-X64-NEXT:   48 |     (C16 vftable pointer)
-// CHECK-X64-NEXT:   64 |     int a
-// CHECK-X64-NEXT:      | [sizeof=80, align=16
-// CHECK-X64-NEXT:      |  nvsize=24, nvalign=16]
-
 struct TestF8 : TestF7, A4 {
   int a;
   TestF8() : a(0xf00000f8) {}
   virtual void f() {printf("F8");}
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct TestF8
+// CHECK-LABEL:   0 | struct TestF8{{$}}
 // CHECK-NEXT:    0 |   struct TestF7 (base)
 // CHECK-NEXT:    0 |     struct A4 (base)
 // CHECK-NEXT:    0 |       int a
 // CHECK-NEXT:    4 |     (TestF7 vbtable pointer)
 // CHECK-NEXT:    8 |     int a
 // CHECK-NEXT:   12 |   struct A4 (base)
 // CHECK-NEXT:   12 |     int a
 // CHECK-NEXT:   16 |   int a
 // CHECK-NEXT:   44 |   (vtordisp for vbase C16)
 // CHECK-NEXT:   48 |   struct C16 (virtual base)
 // CHECK-NEXT:   48 |     (C16 vftable pointer)
 // CHECK-NEXT:   64 |     int a
 // CHECK-NEXT:      | [sizeof=80, align=16
 // CHECK-NEXT:      |  nvsize=32, nvalign=16]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct TestF8
+// CHECK-X64-LABEL:   0 | struct TestF8{{$}}
 // CHECK-X64-NEXT:    0 |   struct TestF7 (base)
 // CHECK-X64-NEXT:    0 |     struct A4 (base)
 // CHECK-X64-NEXT:    0 |       int a
 // CHECK-X64-NEXT:    8 |     (TestF7 vbtable pointer)
 // CHECK-X64-NEXT:   16 |     int a
 // CHECK-X64-NEXT:   24 |   struct A4 (base)
 // CHECK-X64-NEXT:   24 |     int a
 // CHECK-X64-NEXT:   28 |   int a
 // CHECK-X64-NEXT:   44 |   (vtordisp for vbase C16)
 // CHECK-X64-NEXT:   48 |   struct C16 (virtual base)
 // CHECK-X64-NEXT:   48 |     (C16 vftable pointer)
 // CHECK-X64-NEXT:   64 |     int a
 // CHECK-X64-NEXT:      | [sizeof=80, align=16
 // CHECK-X64-NEXT:      |  nvsize=32, nvalign=16]
 
-struct TestF9 : A4, virtual C16 {
-  int a;
-  TestF9() : a(0xf00000f9) {}
-  virtual void g() {printf("F9");}
-};
-
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct TestF9
-// CHECK-NEXT:    0 |   (TestF9 vftable pointer)
-// CHECK-NEXT:    4 |   struct A4 (base)
-// CHECK-NEXT:    4 |     int a
-// CHECK-NEXT:    8 |   (TestF9 vbtable pointer)
-// CHECK-NEXT:   12 |   int a
-// CHECK-NEXT:   16 |   struct C16 (virtual base)
-// CHECK-NEXT:   16 |     (C16 vftable pointer)
-// CHECK-NEXT:   32 |     int a
-// CHECK-NEXT:      | [sizeof=48, align=16
-// CHECK-NEXT:      |  nvsize=16, nvalign=16]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct TestF9
-// CHECK-X64-NEXT:    0 |   (TestF9 vftable pointer)
-// CHECK-X64-NEXT:    8 |   struct A4 (base)
-// CHECK-X64-NEXT:    8 |     int a
-// CHECK-X64-NEXT:   16 |   (TestF9 vbtable pointer)
-// CHECK-X64-NEXT:   24 |   int a
-// CHECK-X64-NEXT:   32 |   struct C16 (virtual base)
-// CHECK-X64-NEXT:   32 |     (C16 vftable pointer)
-// CHECK-X64-NEXT:   48 |     int a
-// CHECK-X64-NEXT:      | [sizeof=64, align=16
-// CHECK-X64-NEXT:      |  nvsize=32, nvalign=16]
-
 struct TestFA : TestF9, A4 {
   int a;
   TestFA() : a(0xf00000fa) {}
   virtual void g() {printf("FA");}
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct TestFA
+// CHECK-LABEL:   0 | struct TestFA{{$}}
 // CHECK-NEXT:    0 |   struct TestF9 (primary base)
 // CHECK-NEXT:    0 |     (TestF9 vftable pointer)
 // CHECK-NEXT:    4 |     struct A4 (base)
 // CHECK-NEXT:    4 |       int a
 // CHECK-NEXT:    8 |     (TestF9 vbtable pointer)
 // CHECK-NEXT:   12 |     int a
 // CHECK-NEXT:   16 |   struct A4 (base)
 // CHECK-NEXT:   16 |     int a
 // CHECK-NEXT:   20 |   int a
 // CHECK-NEXT:   32 |   struct C16 (virtual base)
 // CHECK-NEXT:   32 |     (C16 vftable pointer)
 // CHECK-NEXT:   48 |     int a
 // CHECK-NEXT:      | [sizeof=64, align=16
 // CHECK-NEXT:      |  nvsize=32, nvalign=16]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct TestFA
+// CHECK-X64-LABEL:   0 | struct TestFA{{$}}
 // CHECK-X64-NEXT:    0 |   struct TestF9 (primary base)
 // CHECK-X64-NEXT:    0 |     (TestF9 vftable pointer)
 // CHECK-X64-NEXT:    8 |     struct A4 (base)
 // CHECK-X64-NEXT:    8 |       int a
 // CHECK-X64-NEXT:   16 |     (TestF9 vbtable pointer)
 // CHECK-X64-NEXT:   24 |     int a
 // CHECK-X64-NEXT:   32 |   struct A4 (base)
 // CHECK-X64-NEXT:   32 |     int a
 // CHECK-X64-NEXT:   36 |   int a
 // CHECK-X64-NEXT:   48 |   struct C16 (virtual base)
 // CHECK-X64-NEXT:   48 |     (C16 vftable pointer)
 // CHECK-X64-NEXT:   64 |     int a
 // CHECK-X64-NEXT:      | [sizeof=80, align=16
 // CHECK-X64-NEXT:      |  nvsize=48, nvalign=16]
 
-struct TestFB : A16, virtual C16 {
-  int a;
-  TestFB() : a(0xf00000fb) {}
-  virtual void g() {printf("Fb");}
-};
-
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct TestFB
-// CHECK-NEXT:    0 |   (TestFB vftable pointer)
-// CHECK-NEXT:   16 |   struct A16 (base)
-// CHECK-NEXT:   16 |     int a
-// CHECK-NEXT:   32 |   (TestFB vbtable pointer)
-// CHECK-NEXT:   48 |   int a
-// CHECK-NEXT:   64 |   struct C16 (virtual base)
-// CHECK-NEXT:   64 |     (C16 vftable pointer)
-// CHECK-NEXT:   80 |     int a
-// CHECK-NEXT:      | [sizeof=96, align=16
-// CHECK-NEXT:      |  nvsize=64, nvalign=16]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct TestFB
-// CHECK-X64-NEXT:    0 |   (TestFB vftable pointer)
-// CHECK-X64-NEXT:   16 |   struct A16 (base)
-// CHECK-X64-NEXT:   16 |     int a
-// CHECK-X64-NEXT:   32 |   (TestFB vbtable pointer)
-// CHECK-X64-NEXT:   48 |   int a
-// CHECK-X64-NEXT:   64 |   struct C16 (virtual base)
-// CHECK-X64-NEXT:   64 |     (C16 vftable pointer)
-// CHECK-X64-NEXT:   80 |     int a
-// CHECK-X64-NEXT:      | [sizeof=96, align=16
-// CHECK-X64-NEXT:      |  nvsize=64, nvalign=16]
-
 struct TestFC : TestFB, A4 {
   int a;
   TestFC() : a(0xf00000fc) {}
   virtual void g() {printf("FC");}
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct TestFC
+// CHECK-LABEL:   0 | struct TestFC{{$}}
 // CHECK-NEXT:    0 |   struct TestFB (primary base)
 // CHECK-NEXT:    0 |     (TestFB vftable pointer)
 // CHECK-NEXT:   16 |     struct A16 (base)
 // CHECK-NEXT:   16 |       int a
 // CHECK-NEXT:   32 |     (TestFB vbtable pointer)
 // CHECK-NEXT:   48 |     int a
 // CHECK-NEXT:   64 |   struct A4 (base)
 // CHECK-NEXT:   64 |     int a
 // CHECK-NEXT:   68 |   int a
 // CHECK-NEXT:   80 |   struct C16 (virtual base)
 // CHECK-NEXT:   80 |     (C16 vftable pointer)
 // CHECK-NEXT:   96 |     int a
 // CHECK-NEXT:      | [sizeof=112, align=16
 // CHECK-NEXT:      |  nvsize=80, nvalign=16]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct TestFC
+// CHECK-X64-LABEL:   0 | struct TestFC{{$}}
 // CHECK-X64-NEXT:    0 |   struct TestFB (primary base)
 // CHECK-X64-NEXT:    0 |     (TestFB vftable pointer)
 // CHECK-X64-NEXT:   16 |     struct A16 (base)
 // CHECK-X64-NEXT:   16 |       int a
 // CHECK-X64-NEXT:   32 |     (TestFB vbtable pointer)
 // CHECK-X64-NEXT:   48 |     int a
 // CHECK-X64-NEXT:   64 |   struct A4 (base)
 // CHECK-X64-NEXT:   64 |     int a
 // CHECK-X64-NEXT:   68 |   int a
 // CHECK-X64-NEXT:   80 |   struct C16 (virtual base)
 // CHECK-X64-NEXT:   80 |     (C16 vftable pointer)
 // CHECK-X64-NEXT:   96 |     int a
 // CHECK-X64-NEXT:      | [sizeof=112, align=16
 // CHECK-X64-NEXT:      |  nvsize=80, nvalign=16]
 
-
 struct A16f {
   __declspec(align(16)) int a;
   A16f() : a(0xf0000a16) {}
   virtual void f() {printf("A16f");}
 };
 
 struct Y { char y; Y() : y(0xaa) {} };
 struct X : virtual A16f {};
 
 struct B : A4, Y, X {
   int a;
   B() : a(0xf000000b) {}
 };
 
 struct F0 : A4, B {
   int a;
   F0() : a(0xf00000f0) {}
   virtual void g() {printf("F0");}
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct F0
+// CHECK-LABEL:   0 | struct F0{{$}}
 // CHECK-NEXT:    0 |   (F0 vftable pointer)
 // CHECK-NEXT:   16 |   struct A4 (base)
 // CHECK-NEXT:   16 |     int a
 // CHECK-NEXT:   32 |   struct B (base)
 // CHECK-NEXT:   32 |     struct A4 (base)
 // CHECK-NEXT:   32 |       int a
 // CHECK-NEXT:   36 |     struct Y (base)
 // CHECK-NEXT:   36 |       char y
 // CHECK-NEXT:   48 |     struct X (base)
 // CHECK-NEXT:   48 |       (X vbtable pointer)
 // CHECK-NEXT:   52 |     int a
 // CHECK-NEXT:   64 |   int a
 // CHECK-NEXT:   80 |   struct A16f (virtual base)
 // CHECK-NEXT:   80 |     (A16f vftable pointer)
 // CHECK-NEXT:   96 |     int a
 // CHECK-NEXT:      | [sizeof=112, align=16
 // CHECK-NEXT:      |  nvsize=80, nvalign=16]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct F0
+// CHECK-X64-LABEL:   0 | struct F0{{$}}
 // CHECK-X64-NEXT:    0 |   (F0 vftable pointer)
 // CHECK-X64-NEXT:   16 |   struct A4 (base)
 // CHECK-X64-NEXT:   16 |     int a
 // CHECK-X64-NEXT:   32 |   struct B (base)
 // CHECK-X64-NEXT:   32 |     struct A4 (base)
 // CHECK-X64-NEXT:   32 |       int a
 // CHECK-X64-NEXT:   36 |     struct Y (base)
 // CHECK-X64-NEXT:   36 |       char y
 // CHECK-X64-NEXT:   48 |     struct X (base)
 // CHECK-X64-NEXT:   48 |       (X vbtable pointer)
 // CHECK-X64-NEXT:   56 |     int a
 // CHECK-X64-NEXT:   64 |   int a
 // CHECK-X64-NEXT:   80 |   struct A16f (virtual base)
 // CHECK-X64-NEXT:   80 |     (A16f vftable pointer)
 // CHECK-X64-NEXT:   96 |     int a
 // CHECK-X64-NEXT:      | [sizeof=112, align=16
 // CHECK-X64-NEXT:      |  nvsize=80, nvalign=16]
 
 struct F1 : B, A4 {
   int a;
   F1() : a(0xf00000f1) {}
   virtual void g() {printf("F1");}
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct F1
+// CHECK-LABEL:   0 | struct F1{{$}}
 // CHECK-NEXT:    0 |   (F1 vftable pointer)
 // CHECK-NEXT:   16 |   struct B (base)
 // CHECK-NEXT:   16 |     struct A4 (base)
 // CHECK-NEXT:   16 |       int a
 // CHECK-NEXT:   20 |     struct Y (base)
 // CHECK-NEXT:   20 |       char y
 // CHECK-NEXT:   32 |     struct X (base)
 // CHECK-NEXT:   32 |       (X vbtable pointer)
 // CHECK-NEXT:   36 |     int a
 // CHECK-NEXT:   48 |   struct A4 (base)
 // CHECK-NEXT:   48 |     int a
 // CHECK-NEXT:   52 |   int a
 // CHECK-NEXT:   64 |   struct A16f (virtual base)
 // CHECK-NEXT:   64 |     (A16f vftable pointer)
 // CHECK-NEXT:   80 |     int a
 // CHECK-NEXT:      | [sizeof=96, align=16
 // CHECK-NEXT:      |  nvsize=64, nvalign=16]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct F1
+// CHECK-X64-LABEL:   0 | struct F1{{$}}
 // CHECK-X64-NEXT:    0 |   (F1 vftable pointer)
 // CHECK-X64-NEXT:   16 |   struct B (base)
 // CHECK-X64-NEXT:   16 |     struct A4 (base)
 // CHECK-X64-NEXT:   16 |       int a
 // CHECK-X64-NEXT:   20 |     struct Y (base)
 // CHECK-X64-NEXT:   20 |       char y
 // CHECK-X64-NEXT:   32 |     struct X (base)
 // CHECK-X64-NEXT:   32 |       (X vbtable pointer)
 // CHECK-X64-NEXT:   40 |     int a
 // CHECK-X64-NEXT:   48 |   struct A4 (base)
 // CHECK-X64-NEXT:   48 |     int a
 // CHECK-X64-NEXT:   52 |   int a
 // CHECK-X64-NEXT:   64 |   struct A16f (virtual base)
 // CHECK-X64-NEXT:   64 |     (A16f vftable pointer)
 // CHECK-X64-NEXT:   80 |     int a
 // CHECK-X64-NEXT:      | [sizeof=96, align=16
 // CHECK-X64-NEXT:      |  nvsize=64, nvalign=16]
 
 struct F2 : A4, virtual A16f {
   int a;
   F2() : a(0xf00000f2) {}
   virtual void g() {printf("F2");}
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct F2
+// CHECK-LABEL:   0 | struct F2{{$}}
 // CHECK-NEXT:    0 |   (F2 vftable pointer)
 // CHECK-NEXT:    4 |   struct A4 (base)
 // CHECK-NEXT:    4 |     int a
 // CHECK-NEXT:    8 |   (F2 vbtable pointer)
 // CHECK-NEXT:   12 |   int a
 // CHECK-NEXT:   16 |   struct A16f (virtual base)
 // CHECK-NEXT:   16 |     (A16f vftable pointer)
 // CHECK-NEXT:   32 |     int a
 // CHECK-NEXT:      | [sizeof=48, align=16
 // CHECK-NEXT:      |  nvsize=16, nvalign=16]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct F2
+// CHECK-X64-LABEL:   0 | struct F2{{$}}
 // CHECK-X64-NEXT:    0 |   (F2 vftable pointer)
 // CHECK-X64-NEXT:    8 |   struct A4 (base)
 // CHECK-X64-NEXT:    8 |     int a
 // CHECK-X64-NEXT:   16 |   (F2 vbtable pointer)
 // CHECK-X64-NEXT:   24 |   int a
 // CHECK-X64-NEXT:   32 |   struct A16f (virtual base)
 // CHECK-X64-NEXT:   32 |     (A16f vftable pointer)
 // CHECK-X64-NEXT:   48 |     int a
 // CHECK-X64-NEXT:      | [sizeof=64, align=16
 // CHECK-X64-NEXT:      |  nvsize=32, nvalign=16]
 
 struct F3 : A4, virtual A16f {
   __declspec(align(16)) int a;
   F3() : a(0xf00000f3) {}
   virtual void g() {printf("F3");}
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct F3
+// CHECK-LABEL:   0 | struct F3{{$}}
 // CHECK-NEXT:    0 |   (F3 vftable pointer)
 // CHECK-NEXT:   16 |   struct A4 (base)
 // CHECK-NEXT:   16 |     int a
 // CHECK-NEXT:   20 |   (F3 vbtable pointer)
 // CHECK-NEXT:   48 |   int a
 // CHECK-NEXT:   64 |   struct A16f (virtual base)
 // CHECK-NEXT:   64 |     (A16f vftable pointer)
 // CHECK-NEXT:   80 |     int a
 // CHECK-NEXT:      | [sizeof=96, align=16
 // CHECK-NEXT:      |  nvsize=64, nvalign=16]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct F3
+// CHECK-X64-LABEL:   0 | struct F3{{$}}
 // CHECK-X64-NEXT:    0 |   (F3 vftable pointer)
 // CHECK-X64-NEXT:   16 |   struct A4 (base)
 // CHECK-X64-NEXT:   16 |     int a
 // CHECK-X64-NEXT:   24 |   (F3 vbtable pointer)
 // CHECK-X64-NEXT:   48 |   int a
 // CHECK-X64-NEXT:   64 |   struct A16f (virtual base)
 // CHECK-X64-NEXT:   64 |     (A16f vftable pointer)
 // CHECK-X64-NEXT:   80 |     int a
 // CHECK-X64-NEXT:      | [sizeof=96, align=16
 // CHECK-X64-NEXT:      |  nvsize=64, nvalign=16]
 
 struct F4 : A4, B {
   __declspec(align(16)) int a;
   F4() : a(0xf00000f4) {}
   virtual void g() {printf("F4");}
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct F4
+// CHECK-LABEL:   0 | struct F4{{$}}
 // CHECK-NEXT:    0 |   (F4 vftable pointer)
 // CHECK-NEXT:   16 |   struct A4 (base)
 // CHECK-NEXT:   16 |     int a
 // CHECK-NEXT:   32 |   struct B (base)
 // CHECK-NEXT:   32 |     struct A4 (base)
 // CHECK-NEXT:   32 |       int a
 // CHECK-NEXT:   36 |     struct Y (base)
 // CHECK-NEXT:   36 |       char y
 // CHECK-NEXT:   48 |     struct X (base)
 // CHECK-NEXT:   48 |       (X vbtable pointer)
 // CHECK-NEXT:   52 |     int a
 // CHECK-NEXT:   64 |   int a
 // CHECK-NEXT:   80 |   struct A16f (virtual base)
 // CHECK-NEXT:   80 |     (A16f vftable pointer)
 // CHECK-NEXT:   96 |     int a
 // CHECK-NEXT:      | [sizeof=112, align=16
 // CHECK-NEXT:      |  nvsize=80, nvalign=16]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct F4
+// CHECK-X64-LABEL:   0 | struct F4{{$}}
 // CHECK-X64-NEXT:    0 |   (F4 vftable pointer)
 // CHECK-X64-NEXT:   16 |   struct A4 (base)
 // CHECK-X64-NEXT:   16 |     int a
 // CHECK-X64-NEXT:   32 |   struct B (base)
 // CHECK-X64-NEXT:   32 |     struct A4 (base)
 // CHECK-X64-NEXT:   32 |       int a
 // CHECK-X64-NEXT:   36 |     struct Y (base)
 // CHECK-X64-NEXT:   36 |       char y
 // CHECK-X64-NEXT:   48 |     struct X (base)
 // CHECK-X64-NEXT:   48 |       (X vbtable pointer)
 // CHECK-X64-NEXT:   56 |     int a
 // CHECK-X64-NEXT:   64 |   int a
 // CHECK-X64-NEXT:   80 |   struct A16f (virtual base)
 // CHECK-X64-NEXT:   80 |     (A16f vftable pointer)
 // CHECK-X64-NEXT:   96 |     int a
 // CHECK-X64-NEXT:      | [sizeof=112, align=16
 // CHECK-X64-NEXT:      |  nvsize=80, nvalign=16]
 
 struct F5 : A16f, virtual A4 {
   int a;
   F5() : a(0xf00000f5) {}
   virtual void g() {printf("F5");}
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct F5
+// CHECK-LABEL:   0 | struct F5{{$}}
 // CHECK-NEXT:    0 |   struct A16f (primary base)
 // CHECK-NEXT:    0 |     (A16f vftable pointer)
 // CHECK-NEXT:   16 |     int a
 // CHECK-NEXT:   32 |   (F5 vbtable pointer)
 // CHECK-NEXT:   48 |   int a
 // CHECK-NEXT:   64 |   struct A4 (virtual base)
 // CHECK-NEXT:   64 |     int a
 // CHECK-NEXT:      | [sizeof=80, align=16
 // CHECK-NEXT:      |  nvsize=64, nvalign=16]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct F5
+// CHECK-X64-LABEL:   0 | struct F5{{$}}
 // CHECK-X64-NEXT:    0 |   struct A16f (primary base)
 // CHECK-X64-NEXT:    0 |     (A16f vftable pointer)
 // CHECK-X64-NEXT:   16 |     int a
 // CHECK-X64-NEXT:   32 |   (F5 vbtable pointer)
 // CHECK-X64-NEXT:   48 |   int a
 // CHECK-X64-NEXT:   64 |   struct A4 (virtual base)
 // CHECK-X64-NEXT:   64 |     int a
 // CHECK-X64-NEXT:      | [sizeof=80, align=16
 // CHECK-X64-NEXT:      |  nvsize=64, nvalign=16]
 
 struct F6 : virtual A16f, A4, virtual B {
   int a;
   F6() : a(0xf00000f6) {}
   virtual void g() {printf("F6");}
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct F6
+// CHECK-LABEL:   0 | struct F6{{$}}
 // CHECK-NEXT:    0 |   (F6 vftable pointer)
 // CHECK-NEXT:    4 |   struct A4 (base)
 // CHECK-NEXT:    4 |     int a
 // CHECK-NEXT:    8 |   (F6 vbtable pointer)
 // CHECK-NEXT:   12 |   int a
 // CHECK-NEXT:   16 |   struct A16f (virtual base)
 // CHECK-NEXT:   16 |     (A16f vftable pointer)
 // CHECK-NEXT:   32 |     int a
 // CHECK-NEXT:   48 |   struct B (virtual base)
 // CHECK-NEXT:   48 |     struct A4 (base)
 // CHECK-NEXT:   48 |       int a
 // CHECK-NEXT:   52 |     struct Y (base)
 // CHECK-NEXT:   52 |       char y
 // CHECK-NEXT:   64 |     struct X (base)
 // CHECK-NEXT:   64 |       (X vbtable pointer)
 // CHECK-NEXT:   68 |     int a
 // CHECK-NEXT:      | [sizeof=80, align=16
 // CHECK-NEXT:      |  nvsize=16, nvalign=16]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct F6
+// CHECK-X64-LABEL:   0 | struct F6{{$}}
 // CHECK-X64-NEXT:    0 |   (F6 vftable pointer)
 // CHECK-X64-NEXT:    8 |   struct A4 (base)
 // CHECK-X64-NEXT:    8 |     int a
 // CHECK-X64-NEXT:   16 |   (F6 vbtable pointer)
 // CHECK-X64-NEXT:   24 |   int a
 // CHECK-X64-NEXT:   32 |   struct A16f (virtual base)
 // CHECK-X64-NEXT:   32 |     (A16f vftable pointer)
 // CHECK-X64-NEXT:   48 |     int a
 // CHECK-X64-NEXT:   64 |   struct B (virtual base)
 // CHECK-X64-NEXT:   64 |     struct A4 (base)
 // CHECK-X64-NEXT:   64 |       int a
 // CHECK-X64-NEXT:   68 |     struct Y (base)
 // CHECK-X64-NEXT:   68 |       char y
 // CHECK-X64-NEXT:   80 |     struct X (base)
 // CHECK-X64-NEXT:   80 |       (X vbtable pointer)
 // CHECK-X64-NEXT:   88 |     int a
 // CHECK-X64-NEXT:      | [sizeof=96, align=16
 // CHECK-X64-NEXT:      |  nvsize=32, nvalign=16]
 
 struct ArrayFieldOfRecords {
   A4 InlineElts[2];
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct ArrayFieldOfRecords
+// CHECK-LABEL:   0 | struct ArrayFieldOfRecords{{$}}
 // CHECK-NEXT:    0 |   struct A4 [2] InlineElts
 // CHECK-NEXT:      | [sizeof=8, align=4
 // CHECK-NEXT:      |  nvsize=8, nvalign=4]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct ArrayFieldOfRecords
+// CHECK-X64-LABEL:   0 | struct ArrayFieldOfRecords{{$}}
 // CHECK-X64-NEXT:    0 |   struct A4 [2] InlineElts
 // CHECK-X64-NEXT:      | [sizeof=8, align=4
 // CHECK-X64-NEXT:      |  nvsize=8, nvalign=4]
 
 struct ArrayOfArrayFieldOfRecords {
   A4 InlineElts[2][2];
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct ArrayOfArrayFieldOfRecords
+// CHECK-LABEL:   0 | struct ArrayOfArrayFieldOfRecords{{$}}
 // CHECK-NEXT:    0 |   struct A4 [2][2] InlineElts
 // CHECK-NEXT:      | [sizeof=16, align=4
 // CHECK-NEXT:      |  nvsize=16, nvalign=4]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct ArrayOfArrayFieldOfRecords
+// CHECK-X64-LABEL:   0 | struct ArrayOfArrayFieldOfRecords{{$}}
 // CHECK-X64-NEXT:    0 |   struct A4 [2][2] InlineElts
 // CHECK-X64-NEXT:      | [sizeof=16, align=4
 // CHECK-X64-NEXT:      |  nvsize=16, nvalign=4]
 
 struct RecordArrayTypedef {
   typedef A4 ArrayTy[2];
   ArrayTy InlineElts[2];
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct RecordArrayTypedef
+// CHECK-LABEL:   0 | struct RecordArrayTypedef{{$}}
 // CHECK-NEXT:    0 |   RecordArrayTypedef::ArrayTy [2] InlineElts
 // CHECK-NEXT:      | [sizeof=16, align=4
 // CHECK-NEXT:      |  nvsize=16, nvalign=4]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct RecordArrayTypedef
+// CHECK-X64-LABEL:   0 | struct RecordArrayTypedef{{$}}
 // CHECK-X64-NEXT:    0 |   RecordArrayTypedef::ArrayTy [2] InlineElts
 // CHECK-X64-NEXT:      | [sizeof=16, align=4
 // CHECK-X64-NEXT:      |  nvsize=16, nvalign=4]
 
 struct EmptyIntMemb {
   int FlexArrayMemb[0];
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct EmptyIntMemb
+// CHECK-LABEL:   0 | struct EmptyIntMemb{{$}}
 // CHECK-NEXT:    0 |   int [0] FlexArrayMemb
 // CHECK-NEXT:      | [sizeof=1, align=4
 // CHECK-NEXT:      |  nvsize=0, nvalign=4]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct EmptyIntMemb
+// CHECK-X64-LABEL:   0 | struct EmptyIntMemb{{$}}
 // CHECK-X64-NEXT:    0 |   int [0] FlexArrayMemb
 // CHECK-X64-NEXT:      | [sizeof=4, align=4
 // CHECK-X64-NEXT:      |  nvsize=0, nvalign=4]
 
 struct EmptyLongLongMemb {
   long long FlexArrayMemb[0];
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct EmptyLongLongMemb
+// CHECK-LABEL:   0 | struct EmptyLongLongMemb{{$}}
 // CHECK-NEXT:    0 |   long long [0] FlexArrayMemb
 // CHECK-NEXT:      | [sizeof=1, align=8
 // CHECK-NEXT:      |  nvsize=0, nvalign=8]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct EmptyLongLongMemb
+// CHECK-X64-LABEL:   0 | struct EmptyLongLongMemb{{$}}
 // CHECK-X64-NEXT:    0 |   long long [0] FlexArrayMemb
 // CHECK-X64-NEXT:      | [sizeof=8, align=8
 // CHECK-X64-NEXT:      |  nvsize=0, nvalign=8]
 
 int a[
 sizeof(TestF0)+
 sizeof(TestF1)+
 sizeof(TestF2)+

clang/test/Layout/ms-x86-empty-nonvirtual-bases.cpp

 // RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fms-extensions -fdump-record-layouts -fsyntax-only %s 2>/dev/null \
-// RUN:            | FileCheck %s
+// RUN:            | FileCheck %s --strict-whitespace
 // RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fms-extensions -fdump-record-layouts -fsyntax-only %s 2>/dev/null \
-// RUN:            | FileCheck %s
+// RUN:            | FileCheck %s --strict-whitespace
 
 extern "C" int printf(const char *fmt, ...);
 
 struct __declspec(align(8)) B0 { B0() {printf("B0 : %p\n", this);} };
 struct __declspec(align(8)) B1 { B1() {printf("B1 : %p\n", this);} };
 struct __declspec(align(8)) B2 { B2() {printf("B2 : %p\n", this);} };
 struct __declspec(align(8)) B3 { B3() {printf("B3 : %p\n", this);} };
 struct __declspec(align(8)) B4 { B4() {printf("B4 : %p\n", this);} };
 
 struct C0 { int a; C0() : a(0xf00000C0) {printf("C0 : %p\n", this);} };
 struct C1 { int a; C1() : a(0xf00000C1) {printf("C1 : %p\n", this);} };
 struct C2 { int a; C2() : a(0xf00000C2) {printf("C2 : %p\n", this);} };
 struct C3 { int a; C3() : a(0xf00000C3) {printf("C3 : %p\n", this);} };
 struct C4 { int a; C4() : a(0xf00000C4) {printf("C4 : %p\n", this);} };
 
 struct A : B0 {
   int a;
   A() : a(0xf000000A) {printf("X : %p\n", this);}
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct A
+// CHECK-LABEL:   0 | struct A{{$}}
 // CHECK-NEXT:    0 |   struct B0 (base) (empty)
 // CHECK-NEXT:    0 |   int a
 // CHECK-NEXT:      | [sizeof=8, align=8
 // CHECK-NEXT:      |  nvsize=8, nvalign=8]
 
 struct B : B0 {
   B0 b0;
   int a;
   B() : a(0xf000000B) {printf("X : %p\n", this);}
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct B
+// CHECK-LABEL:   0 | struct B{{$}}
 // CHECK-NEXT:    0 |   struct B0 (base) (empty)
 // CHECK-NEXT:    0 |   struct B0 b0 (empty)
 // CHECK:         8 |   int a
 // CHECK-NEXT:      | [sizeof=16, align=8
 // CHECK-NEXT:      |  nvsize=16, nvalign=8]
 
 struct C : B0, B1, B2, B3, B4 {
   int a;
   C() : a(0xf000000C) {printf("X : %p\n", this);}
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct C
+// CHECK-LABEL:   0 | struct C{{$}}
 // CHECK-NEXT:    0 |   struct B0 (base) (empty)
 // CHECK-NEXT:    8 |   struct B1 (base) (empty)
 // CHECK-NEXT:   16 |   struct B2 (base) (empty)
 // CHECK-NEXT:   24 |   struct B3 (base) (empty)
 // CHECK-NEXT:   32 |   struct B4 (base) (empty)
 // CHECK-NEXT:   32 |   int a
 // CHECK-NEXT:      | [sizeof=40, align=8
 // CHECK-NEXT:      |  nvsize=40, nvalign=8]
 
 struct D {
   B0 b0;
   C0 c0;
   C1 c1;
   C2 c2;
   B1 b1;
   int a;
   D() : a(0xf000000D) {printf("X : %p\n", this);}
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct D
+// CHECK-LABEL:   0 | struct D{{$}}
 // CHECK-NEXT:    0 |   struct B0 b0 (empty)
 // CHECK:         8 |   struct C0 c0
 // CHECK-NEXT:    8 |     int a
 // CHECK:        12 |   struct C1 c1
 // CHECK-NEXT:   12 |     int a
 // CHECK:        16 |   struct C2 c2
 // CHECK-NEXT:   16 |     int a
 // CHECK:        24 |   struct B1 b1 (empty)
 // CHECK:        32 |   int a
 // CHECK-NEXT:      | [sizeof=40, align=8
 // CHECK-NEXT:      |  nvsize=40, nvalign=8]
 
 struct E : B0, C0, C1, C2, B1 {
   int a;
   E() : a(0xf000000E) {printf("X : %p\n", this);}
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct E
+// CHECK-LABEL:   0 | struct E{{$}}
 // CHECK-NEXT:    0 |   struct B0 (base) (empty)
 // CHECK-NEXT:    0 |   struct C0 (base)
 // CHECK-NEXT:    0 |     int a
 // CHECK-NEXT:    4 |   struct C1 (base)
 // CHECK-NEXT:    4 |     int a
 // CHECK-NEXT:    8 |   struct C2 (base)
 // CHECK-NEXT:    8 |     int a
 // CHECK-NEXT:   16 |   struct B1 (base) (empty)
 // CHECK-NEXT:   16 |   int a
 // CHECK-NEXT:      | [sizeof=24, align=8
 // CHECK-NEXT:      |  nvsize=24, nvalign=8]
 
 struct F : C0, B0, B1, C1 {
   int a;
   F() : a(0xf000000F) {printf("X : %p\n", this);}
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct F
+// CHECK-LABEL:   0 | struct F{{$}}
 // CHECK-NEXT:    0 |   struct C0 (base)
 // CHECK-NEXT:    0 |     int a
 // CHECK-NEXT:    8 |   struct B0 (base) (empty)
 // CHECK-NEXT:   16 |   struct B1 (base) (empty)
 // CHECK-NEXT:   16 |   struct C1 (base)
 // CHECK-NEXT:   16 |     int a
 // CHECK-NEXT:   20 |   int a
 // CHECK-NEXT:      | [sizeof=24, align=8
 // CHECK-NEXT:      |  nvsize=24, nvalign=8]
 
 struct G : B0, B1, B2, B3, B4 {
   __declspec(align(32)) int a;
   G() : a(0xf0000011) {printf("X : %p\n", this);}
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct G
+// CHECK-LABEL:   0 | struct G{{$}}
 // CHECK-NEXT:    0 |   struct B0 (base) (empty)
 // CHECK-NEXT:    8 |   struct B1 (base) (empty)
 // CHECK-NEXT:   16 |   struct B2 (base) (empty)
 // CHECK-NEXT:   24 |   struct B3 (base) (empty)
 // CHECK-NEXT:   32 |   struct B4 (base) (empty)
 // CHECK-NEXT:   32 |   int a
 // CHECK-NEXT:      | [sizeof=64, align=32
 // CHECK-NEXT:      |  nvsize=64, nvalign=32]
 
 struct __declspec(align(32)) H : B0, B1, B2, B3, B4 {
   int a;
   H() : a(0xf0000011) {printf("X : %p\n", this);}
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct H
+// CHECK-LABEL:   0 | struct H{{$}}
 // CHECK-NEXT:    0 |   struct B0 (base) (empty)
 // CHECK-NEXT:    8 |   struct B1 (base) (empty)
 // CHECK-NEXT:   16 |   struct B2 (base) (empty)
 // CHECK-NEXT:   24 |   struct B3 (base) (empty)
 // CHECK-NEXT:   32 |   struct B4 (base) (empty)
 // CHECK-NEXT:   32 |   int a
 // CHECK-NEXT:      | [sizeof=64, align=32
 // CHECK-NEXT:      |  nvsize=40, nvalign=32]
 
 struct I {
   int i0[0];
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct I
+// CHECK-LABEL:   0 | struct I{{$}}
 // CHECK-NEXT:    0 |   int [0] i0
 // CHECK-NEXT:      | [sizeof={{1|4}}, align=4,
 // CHECK-NEXT:      |  nvsize=0, nvalign=4]
 
 struct J : I {
   int j;
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:   0 | struct J
+// CHECK-LABEL:  0 | struct J{{$}}
 // CHECK-NEXT:   0 |   struct I (base)
 // CHECK-NEXT:   0 |     int [0] i0
 // CHECK-NEXT:   0 |   int j
 // CHECK-NEXT:     | [sizeof=4, align=4,
 // CHECK-NEXT:     |  nvsize=4, nvalign=4]
 
 int a[
 sizeof(A)+

clang/test/Layout/ms-x86-empty-virtual-base.cpp

 // RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fms-extensions -fdump-record-layouts -fsyntax-only %s 2>/dev/null \
-// RUN:            | FileCheck %s
+// RUN:            | FileCheck %s --strict-whitespace
 // RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fms-extensions -fdump-record-layouts -fsyntax-only %s 2>/dev/null \
-// RUN:            | FileCheck %s -check-prefix CHECK-X64
+// RUN:            | FileCheck %s -check-prefix CHECK-X64 --strict-whitespace
 
 extern "C" int printf(const char *fmt, ...);
 
 struct __declspec(align(8)) B0 { B0() {printf("B0 : %3d\n", ((int)(__SIZE_TYPE__)this)&0xfff);} };
 struct __declspec(align(8)) B1 { B1() {printf("B1 : %3d\n", ((int)(__SIZE_TYPE__)this)&0xfff);} };
 struct __declspec(align(8)) B2 { B2() {printf("B2 : %3d\n", ((int)(__SIZE_TYPE__)this)&0xfff);} };
 struct __declspec(align(8)) B3 { B3() {printf("B3 : %3d\n", ((int)(__SIZE_TYPE__)this)&0xfff);} };
 struct __declspec(align(8)) B4 { B4() {printf("B4 : %3d\n", ((int)(__SIZE_TYPE__)this)&0xfff);} };
 
 struct C0 { int a; C0() : a(0xf00000C0) {printf("C0 : %3d\n", ((int)(__SIZE_TYPE__)this)&0xfff);} };
 struct C1 { int a; C1() : a(0xf00000C1) {printf("C1 : %3d\n", ((int)(__SIZE_TYPE__)this)&0xfff);} };
 struct C2 { int a; C2() : a(0xf00000C2) {printf("C2 : %3d\n", ((int)(__SIZE_TYPE__)this)&0xfff);} };
 struct C3 { int a; C3() : a(0xf00000C3) {printf("C3 : %3d\n", ((int)(__SIZE_TYPE__)this)&0xfff);} };
 struct C4 { int a; C4() : a(0xf00000C4) {printf("C4 : %3d\n", ((int)(__SIZE_TYPE__)this)&0xfff);} };
 
 struct __declspec(align(16)) D0 { D0() {printf("D0 : %3d\n", ((int)(__SIZE_TYPE__)this)&0xfff);} virtual void f() {} };
 struct D1 { D1() {printf("D1 : %3d\n", ((int)(__SIZE_TYPE__)this)&0xfff);} };
 struct D2 { int a[8]; D2() {printf("D2 : %3d\n", ((int)(__SIZE_TYPE__)this)&0xfff);} };
 
 struct A : virtual B0 {
   int a;
   A() : a(0xf000000A) {printf("X : %3d\n", ((int)(__SIZE_TYPE__)this)&0xfff);}
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct A
+// CHECK-LABEL:   0 | struct A{{$}}
 // CHECK-NEXT:    0 |   (A vbtable pointer)
 // CHECK-NEXT:    4 |   int a
 // CHECK-NEXT:    8 |   struct B0 (virtual base) (empty)
 // CHECK-NEXT:      | [sizeof=8, align=8
 // CHECK-NEXT:      |  nvsize=8, nvalign=8]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct A
+// CHECK-X64-LABEL:   0 | struct A{{$}}
 // CHECK-X64-NEXT:    0 |   (A vbtable pointer)
 // CHECK-X64-NEXT:    8 |   int a
 // CHECK-X64-NEXT:   16 |   struct B0 (virtual base) (empty)
 // CHECK-X64-NEXT:      | [sizeof=16, align=8
 // CHECK-X64-NEXT:      |  nvsize=16, nvalign=8]
 
 struct B : virtual B0 {
   B0 b0;
   int a;
   B() : a(0xf000000B) {printf("X : %3d\n", ((int)(__SIZE_TYPE__)this)&0xfff);}
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct B
+// CHECK-LABEL:   0 | struct B{{$}}
 // CHECK-NEXT:    0 |   (B vbtable pointer)
 // CHECK-NEXT:    8 |   struct B0 b0 (empty)
 // CHECK:        16 |   int a
 // CHECK-NEXT:   24 |   struct B0 (virtual base) (empty)
 // CHECK-NEXT:      | [sizeof=24, align=8
 // CHECK-NEXT:      |  nvsize=24, nvalign=8]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct B
+// CHECK-X64-LABEL:   0 | struct B{{$}}
 // CHECK-X64-NEXT:    0 |   (B vbtable pointer)
 // CHECK-X64-NEXT:    8 |   struct B0 b0 (empty)
 // CHECK-X64:        16 |   int a
 // CHECK-X64-NEXT:   24 |   struct B0 (virtual base) (empty)
 // CHECK-X64-NEXT:      | [sizeof=24, align=8
 // CHECK-X64-NEXT:      |  nvsize=24, nvalign=8]
 
 struct C : virtual B0, virtual B1, virtual B2, virtual B3, virtual B4 {
   int a;
   C() : a(0xf000000C) {printf("X : %3d\n", ((int)(__SIZE_TYPE__)this)&0xfff);}
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct C
+// CHECK-LABEL:   0 | struct C{{$}}
 // CHECK-NEXT:    0 |   (C vbtable pointer)
 // CHECK-NEXT:    4 |   int a
 // CHECK-NEXT:    8 |   struct B0 (virtual base) (empty)
 // CHECK-NEXT:   16 |   struct B1 (virtual base) (empty)
 // CHECK-NEXT:   24 |   struct B2 (virtual base) (empty)
 // CHECK-NEXT:   32 |   struct B3 (virtual base) (empty)
 // CHECK-NEXT:   40 |   struct B4 (virtual base) (empty)
 // CHECK-NEXT:      | [sizeof=40, align=8
 // CHECK-NEXT:      |  nvsize=8, nvalign=8]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct C
+// CHECK-X64-LABEL:   0 | struct C{{$}}
 // CHECK-X64-NEXT:    0 |   (C vbtable pointer)
 // CHECK-X64-NEXT:    8 |   int a
 // CHECK-X64-NEXT:   16 |   struct B0 (virtual base) (empty)
 // CHECK-X64-NEXT:   24 |   struct B1 (virtual base) (empty)
 // CHECK-X64-NEXT:   32 |   struct B2 (virtual base) (empty)
 // CHECK-X64-NEXT:   40 |   struct B3 (virtual base) (empty)
 // CHECK-X64-NEXT:   48 |   struct B4 (virtual base) (empty)
 // CHECK-X64-NEXT:      | [sizeof=48, align=8
 // CHECK-X64-NEXT:      |  nvsize=16, nvalign=8]
 
 struct D {
   B0 b0;
   C0 c0;
   C1 c1;
   C2 c2;
   B1 b1;
   int a;
   D() : a(0xf000000D) {printf("X : %3d\n", ((int)(__SIZE_TYPE__)this)&0xfff);}
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct D
+// CHECK-LABEL:   0 | struct D{{$}}
 // CHECK-NEXT:    0 |   struct B0 b0 (empty)
 // CHECK:         8 |   struct C0 c0
 // CHECK-NEXT:    8 |     int a
 // CHECK:        12 |   struct C1 c1
 // CHECK-NEXT:   12 |     int a
 // CHECK:        16 |   struct C2 c2
 // CHECK-NEXT:   16 |     int a
 // CHECK:        24 |   struct B1 b1 (empty)
 // CHECK:        32 |   int a
 // CHECK-NEXT:      | [sizeof=40, align=8
 // CHECK-NEXT:      |  nvsize=40, nvalign=8]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct D
+// CHECK-X64-LABEL:   0 | struct D{{$}}
 // CHECK-X64-NEXT:    0 |   struct B0 b0 (empty)
 // CHECK-X64:         8 |   struct C0 c0
 // CHECK-X64-NEXT:    8 |     int a
 // CHECK-X64:        12 |   struct C1 c1
 // CHECK-X64-NEXT:   12 |     int a
 // CHECK-X64:        16 |   struct C2 c2
 // CHECK-X64-NEXT:   16 |     int a
 // CHECK-X64:        24 |   struct B1 b1 (empty)
 // CHECK-X64:        32 |   int a
 // CHECK-X64-NEXT:      | [sizeof=40, align=8
 // CHECK-X64-NEXT:      |  nvsize=40, nvalign=8]
 
 struct E : virtual B0, virtual C0, virtual C1, virtual C2, virtual B1 {
   int a;
   E() : a(0xf000000E) {printf("X : %3d\n", ((int)(__SIZE_TYPE__)this)&0xfff);}
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct E
+// CHECK-LABEL:   0 | struct E{{$}}
 // CHECK-NEXT:    0 |   (E vbtable pointer)
 // CHECK-NEXT:    4 |   int a
 // CHECK-NEXT:    8 |   struct B0 (virtual base) (empty)
 // CHECK-NEXT:    8 |   struct C0 (virtual base)
 // CHECK-NEXT:    8 |     int a
 // CHECK-NEXT:   12 |   struct C1 (virtual base)
 // CHECK-NEXT:   12 |     int a
 // CHECK-NEXT:   16 |   struct C2 (virtual base)
 // CHECK-NEXT:   16 |     int a
 // CHECK-NEXT:   24 |   struct B1 (virtual base) (empty)
 // CHECK-NEXT:      | [sizeof=24, align=8
 // CHECK-NEXT:      |  nvsize=8, nvalign=8]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct E
+// CHECK-X64-LABEL:   0 | struct E{{$}}
 // CHECK-X64-NEXT:    0 |   (E vbtable pointer)
 // CHECK-X64-NEXT:    8 |   int a
 // CHECK-X64-NEXT:   16 |   struct B0 (virtual base) (empty)
 // CHECK-X64-NEXT:   16 |   struct C0 (virtual base)
 // CHECK-X64-NEXT:   16 |     int a
 // CHECK-X64-NEXT:   20 |   struct C1 (virtual base)
 // CHECK-X64-NEXT:   20 |     int a
 // CHECK-X64-NEXT:   24 |   struct C2 (virtual base)
 // CHECK-X64-NEXT:   24 |     int a
 // CHECK-X64-NEXT:   32 |   struct B1 (virtual base) (empty)
 // CHECK-X64-NEXT:      | [sizeof=32, align=8
 // CHECK-X64-NEXT:      |  nvsize=16, nvalign=8]
 
 struct F : virtual C0, virtual B0, virtual B1, virtual C1 {
   int a;
   F() : a(0xf000000F) {printf("X : %3d\n", ((int)(__SIZE_TYPE__)this)&0xfff);}
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct F
+// CHECK-LABEL:   0 | struct F{{$}}
 // CHECK-NEXT:    0 |   (F vbtable pointer)
 // CHECK-NEXT:    4 |   int a
 // CHECK-NEXT:    8 |   struct C0 (virtual base)
 // CHECK-NEXT:    8 |     int a
 // CHECK-NEXT:   16 |   struct B0 (virtual base) (empty)
 // CHECK-NEXT:   24 |   struct B1 (virtual base) (empty)
 // CHECK-NEXT:   24 |   struct C1 (virtual base)
 // CHECK-NEXT:   24 |     int a
 // CHECK-NEXT:      | [sizeof=32, align=8
 // CHECK-NEXT:      |  nvsize=8, nvalign=8]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct F
+// CHECK-X64-LABEL:   0 | struct F{{$}}
 // CHECK-X64-NEXT:    0 |   (F vbtable pointer)
 // CHECK-X64-NEXT:    8 |   int a
 // CHECK-X64-NEXT:   16 |   struct C0 (virtual base)
 // CHECK-X64-NEXT:   16 |     int a
 // CHECK-X64-NEXT:   24 |   struct B0 (virtual base) (empty)
 // CHECK-X64-NEXT:   32 |   struct B1 (virtual base) (empty)
 // CHECK-X64-NEXT:   32 |   struct C1 (virtual base)
 // CHECK-X64-NEXT:   32 |     int a
 // CHECK-X64-NEXT:      | [sizeof=40, align=8
 // CHECK-X64-NEXT:      |  nvsize=16, nvalign=8]
 
 struct G : virtual C0, virtual B0, virtual B1, D0, virtual C1 {
   int a;
   G() : a(0xf0000010) {printf("X : %3d\n", ((int)(__SIZE_TYPE__)this)&0xfff);}
   virtual void f() {}
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct G
+// CHECK-LABEL:   0 | struct G{{$}}
 // CHECK-NEXT:    0 |   struct D0 (primary base)
 // CHECK-NEXT:    0 |     (D0 vftable pointer)
 // CHECK-NEXT:    4 |   (G vbtable pointer)
 // CHECK-NEXT:   20 |   int a
 // CHECK-NEXT:   32 |   struct C0 (virtual base)
 // CHECK-NEXT:   32 |     int a
 // CHECK-NEXT:   40 |   struct B0 (virtual base) (empty)
 // CHECK-NEXT:   56 |   struct B1 (virtual base) (empty)
 // CHECK-NEXT:   56 |   struct C1 (virtual base)
 // CHECK-NEXT:   56 |     int a
 // CHECK-NEXT:      | [sizeof=64, align=16
 // CHECK-NEXT:      |  nvsize=32, nvalign=16]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct G
+// CHECK-X64-LABEL:   0 | struct G{{$}}
 // CHECK-X64-NEXT:    0 |   struct D0 (primary base)
 // CHECK-X64-NEXT:    0 |     (D0 vftable pointer)
 // CHECK-X64-NEXT:    8 |   (G vbtable pointer)
 // CHECK-X64-NEXT:   24 |   int a
 // CHECK-X64-NEXT:   32 |   struct C0 (virtual base)
 // CHECK-X64-NEXT:   32 |     int a
 // CHECK-X64-NEXT:   40 |   struct B0 (virtual base) (empty)
 // CHECK-X64-NEXT:   56 |   struct B1 (virtual base) (empty)
 // CHECK-X64-NEXT:   56 |   struct C1 (virtual base)
 // CHECK-X64-NEXT:   56 |     int a
 // CHECK-X64-NEXT:      | [sizeof=64, align=16
 // CHECK-X64-NEXT:      |  nvsize=32, nvalign=16]
 
 struct H : virtual C0, virtual B0, virtual B1, virtual D0, virtual C1 {
   int a;
   H() : a(0xf0000011) {printf("X : %3d\n", ((int)(__SIZE_TYPE__)this)&0xfff);}
   virtual void f() {}
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct H
+// CHECK-LABEL:   0 | struct H{{$}}
 // CHECK-NEXT:    0 |   (H vbtable pointer)
 // CHECK-NEXT:    4 |   int a
 // CHECK-NEXT:    8 |   struct C0 (virtual base)
 // CHECK-NEXT:    8 |     int a
 // CHECK-NEXT:   16 |   struct B0 (virtual base) (empty)
 // CHECK-NEXT:   24 |   struct B1 (virtual base) (empty)
 // CHECK-NEXT:   44 |   (vtordisp for vbase D0)
 // CHECK-NEXT:   48 |   struct D0 (virtual base)
 // CHECK-NEXT:   48 |     (D0 vftable pointer)
 // CHECK-NEXT:   52 |   struct C1 (virtual base)
 // CHECK-NEXT:   52 |     int a
 // CHECK-NEXT:      | [sizeof=64, align=16
 // CHECK-NEXT:      |  nvsize=8, nvalign=16]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct H
+// CHECK-X64-LABEL:   0 | struct H{{$}}
 // CHECK-X64-NEXT:    0 |   (H vbtable pointer)
 // CHECK-X64-NEXT:    8 |   int a
 // CHECK-X64-NEXT:   16 |   struct C0 (virtual base)
 // CHECK-X64-NEXT:   16 |     int a
 // CHECK-X64-NEXT:   24 |   struct B0 (virtual base) (empty)
 // CHECK-X64-NEXT:   40 |   struct B1 (virtual base) (empty)
 // CHECK-X64-NEXT:   60 |   (vtordisp for vbase D0)
 // CHECK-X64-NEXT:   64 |   struct D0 (virtual base)
 // CHECK-X64-NEXT:   64 |     (D0 vftable pointer)
 // CHECK-X64-NEXT:   72 |   struct C1 (virtual base)
 // CHECK-X64-NEXT:   72 |     int a
 // CHECK-X64-NEXT:      | [sizeof=80, align=16
 // CHECK-X64-NEXT:      |  nvsize=16, nvalign=16]
 
 struct I : virtual B0, virtual B1, virtual B2, virtual B3, virtual B4 {
   __declspec(align(32)) int a;
   I() : a(0xf0000012) {printf("X : %3d\n", ((int)(__SIZE_TYPE__)this)&0xfff);}
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct I
+// CHECK-LABEL:   0 | struct I{{$}}
 // CHECK-NEXT:    0 |   (I vbtable pointer)
 // CHECK-NEXT:   32 |   int a
 // CHECK-NEXT:   64 |   struct B0 (virtual base) (empty)
 // CHECK-NEXT:   72 |   struct B1 (virtual base) (empty)
 // CHECK-NEXT:  104 |   struct B2 (virtual base) (empty)
 // CHECK-NEXT:  136 |   struct B3 (virtual base) (empty)
 // CHECK-NEXT:  168 |   struct B4 (virtual base) (empty)
 // CHECK-NEXT:      | [sizeof=192, align=32
 // CHECK-NEXT:      |  nvsize=64, nvalign=32]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct I
+// CHECK-X64-LABEL:   0 | struct I{{$}}
 // CHECK-X64-NEXT:    0 |   (I vbtable pointer)
 // CHECK-X64-NEXT:   32 |   int a
 // CHECK-X64-NEXT:   64 |   struct B0 (virtual base) (empty)
 // CHECK-X64-NEXT:   72 |   struct B1 (virtual base) (empty)
 // CHECK-X64-NEXT:  104 |   struct B2 (virtual base) (empty)
 // CHECK-X64-NEXT:  136 |   struct B3 (virtual base) (empty)
 // CHECK-X64-NEXT:  168 |   struct B4 (virtual base) (empty)
 // CHECK-X64-NEXT:      | [sizeof=192, align=32
 // CHECK-X64-NEXT:      |  nvsize=64, nvalign=32]
 
 struct __declspec(align(32)) J : virtual B0, virtual B1, virtual B2, virtual B3, virtual B4 {
   int a;
   J() : a(0xf0000012) {printf("X : %3d\n", ((int)(__SIZE_TYPE__)this)&0xfff);}
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct J
+// CHECK-LABEL:   0 | struct J{{$}}
 // CHECK-NEXT:    0 |   (J vbtable pointer)
 // CHECK-NEXT:    4 |   int a
 // CHECK-NEXT:    8 |   struct B0 (virtual base) (empty)
 // CHECK-NEXT:   40 |   struct B1 (virtual base) (empty)
 // CHECK-NEXT:   72 |   struct B2 (virtual base) (empty)
 // CHECK-NEXT:  104 |   struct B3 (virtual base) (empty)
 // CHECK-NEXT:  136 |   struct B4 (virtual base) (empty)
 // CHECK-NEXT:      | [sizeof=160, align=32
 // CHECK-NEXT:      |  nvsize=8, nvalign=32]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct J
+// CHECK-X64-LABEL:   0 | struct J{{$}}
 // CHECK-X64-NEXT:    0 |   (J vbtable pointer)
 // CHECK-X64-NEXT:    8 |   int a
 // CHECK-X64-NEXT:   16 |   struct B0 (virtual base) (empty)
 // CHECK-X64-NEXT:   40 |   struct B1 (virtual base) (empty)
 // CHECK-X64-NEXT:   72 |   struct B2 (virtual base) (empty)
 // CHECK-X64-NEXT:  104 |   struct B3 (virtual base) (empty)
 // CHECK-X64-NEXT:  136 |   struct B4 (virtual base) (empty)
 // CHECK-X64-NEXT:      | [sizeof=160, align=32
 // CHECK-X64-NEXT:      |  nvsize=16, nvalign=32]
 
 struct K : virtual D1, virtual B1, virtual B2, virtual B3, virtual B4 {
   __declspec(align(32)) int a;
   K() : a(0xf0000013) {printf("X : %3d\n", ((int)(__SIZE_TYPE__)this)&0xfff);}
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct K
+// CHECK-LABEL:   0 | struct K{{$}}
 // CHECK-NEXT:    0 |   (K vbtable pointer)
 // CHECK-NEXT:   32 |   int a
 // CHECK-NEXT:   64 |   struct D1 (virtual base) (empty)
 // CHECK-NEXT:   72 |   struct B1 (virtual base) (empty)
 // CHECK-NEXT:  104 |   struct B2 (virtual base) (empty)
 // CHECK-NEXT:  136 |   struct B3 (virtual base) (empty)
 // CHECK-NEXT:  168 |   struct B4 (virtual base) (empty)
 // CHECK-NEXT:      | [sizeof=192, align=32
 // CHECK-NEXT:      |  nvsize=64, nvalign=32]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct K
+// CHECK-X64-LABEL:   0 | struct K{{$}}
 // CHECK-X64-NEXT:    0 |   (K vbtable pointer)
 // CHECK-X64-NEXT:   32 |   int a
 // CHECK-X64-NEXT:   64 |   struct D1 (virtual base) (empty)
 // CHECK-X64-NEXT:   72 |   struct B1 (virtual base) (empty)
 // CHECK-X64-NEXT:  104 |   struct B2 (virtual base) (empty)
 // CHECK-X64-NEXT:  136 |   struct B3 (virtual base) (empty)
 // CHECK-X64-NEXT:  168 |   struct B4 (virtual base) (empty)
 // CHECK-X64-NEXT:      | [sizeof=192, align=32
 // CHECK-X64-NEXT:      |  nvsize=64, nvalign=32]
 
 struct L : virtual B1, virtual D1, virtual B2, virtual B3, virtual B4 {
   __declspec(align(32)) int a;
   L() : a(0xf0000014) {printf("X : %3d\n", ((int)(__SIZE_TYPE__)this)&0xfff);}
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct L
+// CHECK-LABEL:   0 | struct L{{$}}
 // CHECK-NEXT:    0 |   (L vbtable pointer)
 // CHECK-NEXT:   32 |   int a
 // CHECK-NEXT:   64 |   struct B1 (virtual base) (empty)
 // CHECK-NEXT:   68 |   struct D1 (virtual base) (empty)
 // CHECK-NEXT:  104 |   struct B2 (virtual base) (empty)
 // CHECK-NEXT:  136 |   struct B3 (virtual base) (empty)
 // CHECK-NEXT:  168 |   struct B4 (virtual base) (empty)
 // CHECK-NEXT:      | [sizeof=192, align=32
 // CHECK-NEXT:      |  nvsize=64, nvalign=32]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct L
+// CHECK-X64-LABEL:   0 | struct L{{$}}
 // CHECK-X64-NEXT:    0 |   (L vbtable pointer)
 // CHECK-X64-NEXT:   32 |   int a
 // CHECK-X64-NEXT:   64 |   struct B1 (virtual base) (empty)
 // CHECK-X64-NEXT:   68 |   struct D1 (virtual base) (empty)
 // CHECK-X64-NEXT:  104 |   struct B2 (virtual base) (empty)
 // CHECK-X64-NEXT:  136 |   struct B3 (virtual base) (empty)
 // CHECK-X64-NEXT:  168 |   struct B4 (virtual base) (empty)
 // CHECK-X64-NEXT:      | [sizeof=192, align=32
 // CHECK-X64-NEXT:      |  nvsize=64, nvalign=32]
 
 struct M : virtual B1, virtual B2, virtual D1, virtual B3, virtual B4 {
   __declspec(align(32)) int a;
   M() : a(0xf0000015) {printf("X : %3d\n", ((int)(__SIZE_TYPE__)this)&0xfff);}
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct M
+// CHECK-LABEL:   0 | struct M{{$}}
 // CHECK-NEXT:    0 |   (M vbtable pointer)
 // CHECK-NEXT:   32 |   int a
 // CHECK-NEXT:   64 |   struct B1 (virtual base) (empty)
 // CHECK-NEXT:   72 |   struct B2 (virtual base) (empty)
 // CHECK-NEXT:  100 |   struct D1 (virtual base) (empty)
 // CHECK-NEXT:  136 |   struct B3 (virtual base) (empty)
 // CHECK-NEXT:  168 |   struct B4 (virtual base) (empty)
 // CHECK-NEXT:      | [sizeof=192, align=32
 // CHECK-NEXT:      |  nvsize=64, nvalign=32]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct M
+// CHECK-X64-LABEL:   0 | struct M{{$}}
 // CHECK-X64-NEXT:    0 |   (M vbtable pointer)
 // CHECK-X64-NEXT:   32 |   int a
 // CHECK-X64-NEXT:   64 |   struct B1 (virtual base) (empty)
 // CHECK-X64-NEXT:   72 |   struct B2 (virtual base) (empty)
 // CHECK-X64-NEXT:  100 |   struct D1 (virtual base) (empty)
 // CHECK-X64-NEXT:  136 |   struct B3 (virtual base) (empty)
 // CHECK-X64-NEXT:  168 |   struct B4 (virtual base) (empty)
 // CHECK-X64-NEXT:      | [sizeof=192, align=32
 // CHECK-X64-NEXT:      |  nvsize=64, nvalign=32]
 
 struct N : virtual C0, virtual B1, virtual D1, virtual B2, virtual B3, virtual B4 {
   __declspec(align(32)) int a;
   N() : a(0xf0000016) {printf("X : %3d\n", ((int)(__SIZE_TYPE__)this)&0xfff);}
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct N
+// CHECK-LABEL:   0 | struct N{{$}}
 // CHECK-NEXT:    0 |   (N vbtable pointer)
 // CHECK-NEXT:   32 |   int a
 // CHECK-NEXT:   64 |   struct C0 (virtual base)
 // CHECK-NEXT:   64 |     int a
 // CHECK-NEXT:   72 |   struct B1 (virtual base) (empty)
 // CHECK-NEXT:  100 |   struct D1 (virtual base) (empty)
 // CHECK-NEXT:  136 |   struct B2 (virtual base) (empty)
 // CHECK-NEXT:  168 |   struct B3 (virtual base) (empty)
 // CHECK-NEXT:  200 |   struct B4 (virtual base) (empty)
 // CHECK-NEXT:      | [sizeof=224, align=32
 // CHECK-NEXT:      |  nvsize=64, nvalign=32]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct N
+// CHECK-X64-LABEL:   0 | struct N{{$}}
 // CHECK-X64-NEXT:    0 |   (N vbtable pointer)
 // CHECK-X64-NEXT:   32 |   int a
 // CHECK-X64-NEXT:   64 |   struct C0 (virtual base)
 // CHECK-X64-NEXT:   64 |     int a
 // CHECK-X64-NEXT:   72 |   struct B1 (virtual base) (empty)
 // CHECK-X64-NEXT:  100 |   struct D1 (virtual base) (empty)
 // CHECK-X64-NEXT:  136 |   struct B2 (virtual base) (empty)
 // CHECK-X64-NEXT:  168 |   struct B3 (virtual base) (empty)
 // CHECK-X64-NEXT:  200 |   struct B4 (virtual base) (empty)
 // CHECK-X64-NEXT:      | [sizeof=224, align=32
 // CHECK-X64-NEXT:      |  nvsize=64, nvalign=32]
 
 struct O : virtual C0, virtual B1, virtual B2, virtual D1, virtual B3, virtual B4 {
   __declspec(align(32)) int a;
   O() : a(0xf0000017) {printf("X : %3d\n", ((int)(__SIZE_TYPE__)this)&0xfff);}
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct O
+// CHECK-LABEL:   0 | struct O{{$}}
 // CHECK-NEXT:    0 |   (O vbtable pointer)
 // CHECK-NEXT:   32 |   int a
 // CHECK-NEXT:   64 |   struct C0 (virtual base)
 // CHECK-NEXT:   64 |     int a
 // CHECK-NEXT:   72 |   struct B1 (virtual base) (empty)
 // CHECK-NEXT:  104 |   struct B2 (virtual base) (empty)
 // CHECK-NEXT:  132 |   struct D1 (virtual base) (empty)
 // CHECK-NEXT:  168 |   struct B3 (virtual base) (empty)
 // CHECK-NEXT:  200 |   struct B4 (virtual base) (empty)
 // CHECK-NEXT:      | [sizeof=224, align=32
 // CHECK-NEXT:      |  nvsize=64, nvalign=32]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct O
+// CHECK-X64-LABEL:   0 | struct O{{$}}
 // CHECK-X64-NEXT:    0 |   (O vbtable pointer)
 // CHECK-X64-NEXT:   32 |   int a
 // CHECK-X64-NEXT:   64 |   struct C0 (virtual base)
 // CHECK-X64-NEXT:   64 |     int a
 // CHECK-X64-NEXT:   72 |   struct B1 (virtual base) (empty)
 // CHECK-X64-NEXT:  104 |   struct B2 (virtual base) (empty)
 // CHECK-X64-NEXT:  132 |   struct D1 (virtual base) (empty)
 // CHECK-X64-NEXT:  168 |   struct B3 (virtual base) (empty)
 // CHECK-X64-NEXT:  200 |   struct B4 (virtual base) (empty)
 // CHECK-X64-NEXT:      | [sizeof=224, align=32
 // CHECK-X64-NEXT:      |  nvsize=64, nvalign=32]
 
 struct P : virtual B1, virtual C0, virtual D1, virtual B2, virtual B3, virtual B4 {
   __declspec(align(32)) int a;
   P() : a(0xf0000018) {printf("X : %3d\n", ((int)(__SIZE_TYPE__)this)&0xfff);}
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct P
+// CHECK-LABEL:   0 | struct P{{$}}
 // CHECK-NEXT:    0 |   (P vbtable pointer)
 // CHECK-NEXT:   32 |   int a
 // CHECK-NEXT:   64 |   struct B1 (virtual base) (empty)
 // CHECK-NEXT:   64 |   struct C0 (virtual base)
 // CHECK-NEXT:   64 |     int a
 // CHECK-NEXT:   68 |   struct D1 (virtual base) (empty)
 // CHECK-NEXT:  104 |   struct B2 (virtual base) (empty)
 // CHECK-NEXT:  136 |   struct B3 (virtual base) (empty)
 // CHECK-NEXT:  168 |   struct B4 (virtual base) (empty)
 // CHECK-NEXT:      | [sizeof=192, align=32
 // CHECK-NEXT:      |  nvsize=64, nvalign=32]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct P
+// CHECK-X64-LABEL:   0 | struct P{{$}}
 // CHECK-X64-NEXT:    0 |   (P vbtable pointer)
 // CHECK-X64-NEXT:   32 |   int a
 // CHECK-X64-NEXT:   64 |   struct B1 (virtual base) (empty)
 // CHECK-X64-NEXT:   64 |   struct C0 (virtual base)
 // CHECK-X64-NEXT:   64 |     int a
 // CHECK-X64-NEXT:   68 |   struct D1 (virtual base) (empty)
 // CHECK-X64-NEXT:  104 |   struct B2 (virtual base) (empty)
 // CHECK-X64-NEXT:  136 |   struct B3 (virtual base) (empty)
 // CHECK-X64-NEXT:  168 |   struct B4 (virtual base) (empty)
 // CHECK-X64-NEXT:      | [sizeof=192, align=32
 // CHECK-X64-NEXT:      |  nvsize=64, nvalign=32]
 
 struct Q : virtual B1, virtual C0, virtual B2, virtual D1, virtual B3, virtual B4 {
   __declspec(align(32)) int a;
   Q() : a(0xf0000019) {printf("X : %3d\n", ((int)(__SIZE_TYPE__)this)&0xfff);}
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct Q
+// CHECK-LABEL:   0 | struct Q{{$}}
 // CHECK-NEXT:    0 |   (Q vbtable pointer)
 // CHECK-NEXT:   32 |   int a
 // CHECK-NEXT:   64 |   struct B1 (virtual base) (empty)
 // CHECK-NEXT:   64 |   struct C0 (virtual base)
 // CHECK-NEXT:   64 |     int a
 // CHECK-NEXT:   72 |   struct B2 (virtual base) (empty)
 // CHECK-NEXT:  100 |   struct D1 (virtual base) (empty)
 // CHECK-NEXT:  136 |   struct B3 (virtual base) (empty)
 // CHECK-NEXT:  168 |   struct B4 (virtual base) (empty)
 // CHECK-NEXT:      | [sizeof=192, align=32
 // CHECK-NEXT:      |  nvsize=64, nvalign=32]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct Q
+// CHECK-X64-LABEL:   0 | struct Q{{$}}
 // CHECK-X64-NEXT:    0 |   (Q vbtable pointer)
 // CHECK-X64-NEXT:   32 |   int a
 // CHECK-X64-NEXT:   64 |   struct B1 (virtual base) (empty)
 // CHECK-X64-NEXT:   64 |   struct C0 (virtual base)
 // CHECK-X64-NEXT:   64 |     int a
 // CHECK-X64-NEXT:   72 |   struct B2 (virtual base) (empty)
 // CHECK-X64-NEXT:  100 |   struct D1 (virtual base) (empty)
 // CHECK-X64-NEXT:  136 |   struct B3 (virtual base) (empty)
 // CHECK-X64-NEXT:  168 |   struct B4 (virtual base) (empty)
 // CHECK-X64-NEXT:      | [sizeof=192, align=32
 // CHECK-X64-NEXT:      |  nvsize=64, nvalign=32]
 
 struct R : virtual B0, virtual B1, virtual B2, virtual C0, virtual B3, virtual B4 {
   __declspec(align(32)) int a;
   R() : a(0xf0000020) {printf("X : %3d\n", ((int)(__SIZE_TYPE__)this)&0xfff);}
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct R
+// CHECK-LABEL:   0 | struct R{{$}}
 // CHECK-NEXT:    0 |   (R vbtable pointer)
 // CHECK-NEXT:   32 |   int a
 // CHECK-NEXT:   64 |   struct B0 (virtual base) (empty)
 // CHECK-NEXT:   72 |   struct B1 (virtual base) (empty)
 // CHECK-NEXT:  104 |   struct B2 (virtual base) (empty)
 // CHECK-NEXT:  104 |   struct C0 (virtual base)
 // CHECK-NEXT:  104 |     int a
 // CHECK-NEXT:  112 |   struct B3 (virtual base) (empty)
 // CHECK-NEXT:  136 |   struct B4 (virtual base) (empty)
 // CHECK-NEXT:      | [sizeof=160, align=32
 // CHECK-NEXT:      |  nvsize=64, nvalign=32]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct R
+// CHECK-X64-LABEL:   0 | struct R{{$}}
 // CHECK-X64-NEXT:    0 |   (R vbtable pointer)
 // CHECK-X64-NEXT:   32 |   int a
 // CHECK-X64-NEXT:   64 |   struct B0 (virtual base) (empty)
 // CHECK-X64-NEXT:   72 |   struct B1 (virtual base) (empty)
 // CHECK-X64-NEXT:  104 |   struct B2 (virtual base) (empty)
 // CHECK-X64-NEXT:  104 |   struct C0 (virtual base)
 // CHECK-X64-NEXT:  104 |     int a
 // CHECK-X64-NEXT:  112 |   struct B3 (virtual base) (empty)
 // CHECK-X64-NEXT:  136 |   struct B4 (virtual base) (empty)
 // CHECK-X64-NEXT:      | [sizeof=160, align=32
 // CHECK-X64-NEXT:      |  nvsize=64, nvalign=32]
 
 struct S : virtual B0, virtual B1, virtual C0, virtual B2, virtual B3, virtual B4 {
   __declspec(align(32)) int a;
   S() : a(0xf0000021) {printf("X : %3d\n", ((int)(__SIZE_TYPE__)this)&0xfff);}
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct S
+// CHECK-LABEL:   0 | struct S{{$}}
 // CHECK-NEXT:    0 |   (S vbtable pointer)
 // CHECK-NEXT:   32 |   int a
 // CHECK-NEXT:   64 |   struct B0 (virtual base) (empty)
 // CHECK-NEXT:   72 |   struct B1 (virtual base) (empty)
 // CHECK-NEXT:   72 |   struct C0 (virtual base)
 // CHECK-NEXT:   72 |     int a
 // CHECK-NEXT:   80 |   struct B2 (virtual base) (empty)
 // CHECK-NEXT:  104 |   struct B3 (virtual base) (empty)
 // CHECK-NEXT:  136 |   struct B4 (virtual base) (empty)
 // CHECK-NEXT:      | [sizeof=160, align=32
 // CHECK-NEXT:      |  nvsize=64, nvalign=32]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct S
+// CHECK-X64-LABEL:   0 | struct S{{$}}
 // CHECK-X64-NEXT:    0 |   (S vbtable pointer)
 // CHECK-X64-NEXT:   32 |   int a
 // CHECK-X64-NEXT:   64 |   struct B0 (virtual base) (empty)
 // CHECK-X64-NEXT:   72 |   struct B1 (virtual base) (empty)
 // CHECK-X64-NEXT:   72 |   struct C0 (virtual base)
 // CHECK-X64-NEXT:   72 |     int a
 // CHECK-X64-NEXT:   80 |   struct B2 (virtual base) (empty)
 // CHECK-X64-NEXT:  104 |   struct B3 (virtual base) (empty)
 // CHECK-X64-NEXT:  136 |   struct B4 (virtual base) (empty)
 // CHECK-X64-NEXT:      | [sizeof=160, align=32
 // CHECK-X64-NEXT:      |  nvsize=64, nvalign=32]
 
 struct T : virtual B0, virtual B1, virtual C0, virtual D2, virtual B2, virtual B3, virtual B4 {
   __declspec(align(16)) int a;
   T() : a(0xf0000022) {printf("X : %3d\n", ((int)(__SIZE_TYPE__)this)&0xfff);}
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct T
+// CHECK-LABEL:   0 | struct T{{$}}
 // CHECK-NEXT:    0 |   (T vbtable pointer)
 // CHECK-NEXT:   16 |   int a
 // CHECK-NEXT:   32 |   struct B0 (virtual base) (empty)
 // CHECK-NEXT:   40 |   struct B1 (virtual base) (empty)
 // CHECK-NEXT:   40 |   struct C0 (virtual base)
 // CHECK-NEXT:   40 |     int a
 // CHECK-NEXT:   44 |   struct D2 (virtual base)
 // CHECK-NEXT:   44 |     int [8] a
 // CHECK-NEXT:   80 |   struct B2 (virtual base) (empty)
 // CHECK-NEXT:   88 |   struct B3 (virtual base) (empty)
 // CHECK-NEXT:  104 |   struct B4 (virtual base) (empty)
 // CHECK-NEXT:      | [sizeof=112, align=16
 // CHECK-NEXT:      |  nvsize=32, nvalign=16]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct T
+// CHECK-X64-LABEL:   0 | struct T{{$}}
 // CHECK-X64-NEXT:    0 |   (T vbtable pointer)
 // CHECK-X64-NEXT:   16 |   int a
 // CHECK-X64-NEXT:   32 |   struct B0 (virtual base) (empty)
 // CHECK-X64-NEXT:   40 |   struct B1 (virtual base) (empty)
 // CHECK-X64-NEXT:   40 |   struct C0 (virtual base)
 // CHECK-X64-NEXT:   40 |     int a
 // CHECK-X64-NEXT:   44 |   struct D2 (virtual base)
 // CHECK-X64-NEXT:   44 |     int [8] a
 // CHECK-X64-NEXT:   80 |   struct B2 (virtual base) (empty)
 // CHECK-X64-NEXT:   88 |   struct B3 (virtual base) (empty)
 // CHECK-X64-NEXT:  104 |   struct B4 (virtual base) (empty)
 // CHECK-X64-NEXT:      | [sizeof=112, align=16
 // CHECK-X64-NEXT:      |  nvsize=32, nvalign=16]
 
 struct __declspec(align(32)) U : virtual B0, virtual B1 {
   int a;
   U() : a(0xf0000023) {printf("X : %3d\n", ((int)(__SIZE_TYPE__)this)&0xfff);}
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct U
+// CHECK-LABEL:   0 | struct U{{$}}
 // CHECK-NEXT:    0 |   (U vbtable pointer)
 // CHECK-NEXT:    4 |   int a
 // CHECK-NEXT:    8 |   struct B0 (virtual base) (empty)
 // CHECK-NEXT:   40 |   struct B1 (virtual base) (empty)
 // CHECK-NEXT:      | [sizeof=64, align=32
 // CHECK-NEXT:      |  nvsize=8, nvalign=32]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct U
+// CHECK-X64-LABEL:   0 | struct U{{$}}
 // CHECK-X64-NEXT:    0 |   (U vbtable pointer)
 // CHECK-X64-NEXT:    8 |   int a
 // CHECK-X64-NEXT:   16 |   struct B0 (virtual base) (empty)
 // CHECK-X64-NEXT:   40 |   struct B1 (virtual base) (empty)
 // CHECK-X64-NEXT:      | [sizeof=64, align=32
 // CHECK-X64-NEXT:      |  nvsize=16, nvalign=32]
 
 struct __declspec(align(32)) V : virtual D1 {
   int a;
   V() : a(0xf0000024) {printf("X : %3d\n", ((int)(__SIZE_TYPE__)this)&0xfff);}
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct V
+// CHECK-LABEL:   0 | struct V{{$}}
 // CHECK-NEXT:    0 |   (V vbtable pointer)
 // CHECK-NEXT:    4 |   int a
 // CHECK-NEXT:    8 |   struct D1 (virtual base) (empty)
 // CHECK-NEXT:      | [sizeof=32, align=32
 // CHECK-NEXT:      |  nvsize=8, nvalign=32]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct V
+// CHECK-X64-LABEL:   0 | struct V{{$}}
 // CHECK-X64-NEXT:    0 |   (V vbtable pointer)
 // CHECK-X64-NEXT:    8 |   int a
 // CHECK-X64-NEXT:   16 |   struct D1 (virtual base) (empty)
 // CHECK-X64-NEXT:      | [sizeof=32, align=32
 // CHECK-X64-NEXT:      |  nvsize=16, nvalign=32]
 
 struct T0 {};
 struct T1 : T0 { char a; };
 struct T3 : virtual T1, virtual T0 { long long a; };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct T3
+// CHECK-LABEL:   0 | struct T3{{$}}
 // CHECK-NEXT:    0 |   (T3 vbtable pointer)
 // CHECK-NEXT:    8 |   long long a
 // CHECK-NEXT:   16 |   struct T1 (virtual base)
 // CHECK-NEXT:   16 |     struct T0 (base) (empty)
 // CHECK-NEXT:   16 |     char a
 // CHECK-NEXT:   24 |   struct T0 (virtual base) (empty)
 // CHECK-NEXT:      | [sizeof=24, align=8
 // CHECK-NEXT:      |  nvsize=16, nvalign=8]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct T3
+// CHECK-X64-LABEL:   0 | struct T3{{$}}
 // CHECK-X64-NEXT:    0 |   (T3 vbtable pointer)
 // CHECK-X64-NEXT:    8 |   long long a
 // CHECK-X64-NEXT:   16 |   struct T1 (virtual base)
 // CHECK-X64-NEXT:   16 |     struct T0 (base) (empty)
 // CHECK-X64-NEXT:   16 |     char a
 // CHECK-X64-NEXT:   24 |   struct T0 (virtual base) (empty)
 // CHECK-X64-NEXT:      | [sizeof=24, align=8
 // CHECK-X64-NEXT:      |  nvsize=16, nvalign=8]
 
 struct Q0A {};
 struct Q0B { char Q0BField; };
 struct Q0C : virtual Q0A, virtual Q0B { char Q0CField; };
 struct Q0D : Q0C, Q0A {};
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct Q0D
+// CHECK-LABEL:   0 | struct Q0D{{$}}
 // CHECK-NEXT:    0 |   struct Q0C (base)
 // CHECK-NEXT:    0 |     (Q0C vbtable pointer)
 // CHECK-NEXT:    4 |     char Q0CField
 // CHECK-NEXT:    8 |   struct Q0A (base) (empty)
 // CHECK-NEXT:    8 |   struct Q0A (virtual base) (empty)
 // CHECK-NEXT:    8 |   struct Q0B (virtual base)
 // CHECK-NEXT:    8 |     char Q0BField
 // CHECK-NEXT:      | [sizeof=9, align=4
 // CHECK-NEXT:      |  nvsize=8, nvalign=4]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct Q0D
+// CHECK-X64-LABEL:   0 | struct Q0D{{$}}
 // CHECK-X64-NEXT:    0 |   struct Q0C (base)
 // CHECK-X64-NEXT:    0 |     (Q0C vbtable pointer)
 // CHECK-X64-NEXT:    8 |     char Q0CField
 // CHECK-X64-NEXT:   16 |   struct Q0A (base) (empty)
 // CHECK-X64-NEXT:   16 |   struct Q0A (virtual base) (empty)
 // CHECK-X64-NEXT:   16 |   struct Q0B (virtual base)
 // CHECK-X64-NEXT:   16 |     char Q0BField
 // CHECK-X64-NEXT:      | [sizeof=24, align=8

clang/test/Layout/ms-x86-lazy-empty-nonvirtual-base.cpp

 // RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fms-extensions -fdump-record-layouts -fsyntax-only %s 2>/dev/null \
-// RUN:            | FileCheck %s
+// RUN:            | FileCheck %s --strict-whitespace
 // RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fms-extensions -fdump-record-layouts -fsyntax-only %s 2>/dev/null \
-// RUN:            | FileCheck %s -check-prefix CHECK-X64
+// RUN:            | FileCheck %s -check-prefix CHECK-X64 --strict-whitespace
 
 extern "C" int printf(const char *fmt, ...);
 
 struct B0 { B0() { printf("B0 = %p\n", this); } };
 struct B1 { B1() { printf("B1 = %p\n", this); } };
 struct B2 { B2() { printf("B2 = %p\n", this); } };
 struct B3 { B3() { printf("B3 = %p\n", this); } };
 struct B4 { B4() { printf("B4 = %p\n", this); } };

 struct B6X { B6X() { printf("B6 = %p\n", this); } };
 struct B8X { short a; B8X() : a(0x000000B8) { printf("B8 = %p\n", this); } };
 
 struct AA : B8, B1, virtual B0 {
   int a;
   AA() : a(0x000000AA) { printf("AA = %p\n", this); }
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct AA
+// CHECK-LABEL:   0 | struct AA{{$}}
 // CHECK-NEXT:    0 |   struct B8 (base)
 // CHECK-NEXT:    0 |     char [5] c
 // CHECK-NEXT:   13 |   struct B1 (base) (empty)
 // CHECK-NEXT:    8 |   (AA vbtable pointer)
 // CHECK-NEXT:   16 |   int a
 // CHECK-NEXT:   20 |   struct B0 (virtual base) (empty)
 // CHECK-NEXT:      | [sizeof=20, align=4
 // CHECK-NEXT:      |  nvsize=20, nvalign=4]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct AA
+// CHECK-X64-LABEL:   0 | struct AA{{$}}
 // CHECK-X64-NEXT:    0 |   struct B8 (base)
 // CHECK-X64-NEXT:    0 |     char [5] c
 // CHECK-X64-NEXT:   17 |   struct B1 (base) (empty)
 // CHECK-X64-NEXT:    8 |   (AA vbtable pointer)
 // CHECK-X64-NEXT:   20 |   int a
 // CHECK-X64-NEXT:   24 |   struct B0 (virtual base) (empty)
 // CHECK-X64-NEXT:      | [sizeof=24, align=8
 // CHECK-X64-NEXT:      |  nvsize=24, nvalign=8]
 
 struct AB : B8, B1, virtual B0 {
   short a;
   AB() : a(0x000000AB) { printf("AB = %p\n", this); }
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct AB
+// CHECK-LABEL:   0 | struct AB{{$}}
 // CHECK-NEXT:    0 |   struct B8 (base)
 // CHECK-NEXT:    0 |     char [5] c
 // CHECK-NEXT:   13 |   struct B1 (base) (empty)
 // CHECK-NEXT:    8 |   (AB vbtable pointer)
 // CHECK-NEXT:   14 |   short a
 // CHECK-NEXT:   16 |   struct B0 (virtual base) (empty)
 // CHECK-NEXT:      | [sizeof=16, align=4
 // CHECK-NEXT:      |  nvsize=16, nvalign=4]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct AB
+// CHECK-X64-LABEL:   0 | struct AB{{$}}
 // CHECK-X64-NEXT:    0 |   struct B8 (base)
 // CHECK-X64-NEXT:    0 |     char [5] c
 // CHECK-X64-NEXT:   17 |   struct B1 (base) (empty)
 // CHECK-X64-NEXT:    8 |   (AB vbtable pointer)
 // CHECK-X64-NEXT:   18 |   short a
 // CHECK-X64-NEXT:   24 |   struct B0 (virtual base) (empty)
 // CHECK-X64-NEXT:      | [sizeof=24, align=8
 // CHECK-X64-NEXT:      |  nvsize=24, nvalign=8]
 
 struct AC : B8, B1, virtual B0 {
   char a;
   AC() : a(0x000000AC) { printf("AC = %p\n", this); }
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct AC
+// CHECK-LABEL:   0 | struct AC{{$}}
 // CHECK-NEXT:    0 |   struct B8 (base)
 // CHECK-NEXT:    0 |     char [5] c
 // CHECK-NEXT:   12 |   struct B1 (base) (empty)
 // CHECK-NEXT:    8 |   (AC vbtable pointer)
 // CHECK-NEXT:   12 |   char a
 // CHECK-NEXT:   16 |   struct B0 (virtual base) (empty)
 // CHECK-NEXT:      | [sizeof=16, align=4
 // CHECK-NEXT:      |  nvsize=16, nvalign=4]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct AC
+// CHECK-X64-LABEL:   0 | struct AC{{$}}
 // CHECK-X64-NEXT:    0 |   struct B8 (base)
 // CHECK-X64-NEXT:    0 |     char [5] c
 // CHECK-X64-NEXT:   16 |   struct B1 (base) (empty)
 // CHECK-X64-NEXT:    8 |   (AC vbtable pointer)
 // CHECK-X64-NEXT:   16 |   char a
 // CHECK-X64-NEXT:   24 |   struct B0 (virtual base) (empty)
 // CHECK-X64-NEXT:      | [sizeof=24, align=8
 // CHECK-X64-NEXT:      |  nvsize=24, nvalign=8]
 
 struct AD : B8, B1, virtual B0 {
   AD() { printf("AD = %p\n", this); }
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct AD
+// CHECK-LABEL:   0 | struct AD{{$}}
 // CHECK-NEXT:    0 |   struct B8 (base)
 // CHECK-NEXT:    0 |     char [5] c
 // CHECK-NEXT:   12 |   struct B1 (base) (empty)
 // CHECK-NEXT:    8 |   (AD vbtable pointer)
 // CHECK-NEXT:   12 |   struct B0 (virtual base) (empty)
 // CHECK-NEXT:      | [sizeof=12, align=4
 // CHECK-NEXT:      |  nvsize=12, nvalign=4]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct AD
+// CHECK-X64-LABEL:   0 | struct AD{{$}}
 // CHECK-X64-NEXT:    0 |   struct B8 (base)
 // CHECK-X64-NEXT:    0 |     char [5] c
 // CHECK-X64-NEXT:   16 |   struct B1 (base) (empty)
 // CHECK-X64-NEXT:    8 |   (AD vbtable pointer)
 // CHECK-X64-NEXT:   16 |   struct B0 (virtual base) (empty)
 // CHECK-X64-NEXT:      | [sizeof=16, align=8
 // CHECK-X64-NEXT:      |  nvsize=16, nvalign=8]
 
 struct AA1 : B9, B1, virtual B0 {
   int a;
   AA1() : a(0x00000AA1) { printf("AA1 = %p\n", this); }
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct AA1
+// CHECK-LABEL:   0 | struct AA1{{$}}
 // CHECK-NEXT:    0 |   struct B9 (base)
 // CHECK-NEXT:    0 |     char [6] c
 // CHECK-NEXT:   14 |   struct B1 (base) (empty)
 // CHECK-NEXT:    8 |   (AA1 vbtable pointer)
 // CHECK-NEXT:   16 |   int a
 // CHECK-NEXT:   20 |   struct B0 (virtual base) (empty)
 // CHECK-NEXT:      | [sizeof=20, align=4
 // CHECK-NEXT:      |  nvsize=20, nvalign=4]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct AA1
+// CHECK-X64-LABEL:   0 | struct AA1{{$}}
 // CHECK-X64-NEXT:    0 |   struct B9 (base)
 // CHECK-X64-NEXT:    0 |     char [6] c
 // CHECK-X64-NEXT:   18 |   struct B1 (base) (empty)
 // CHECK-X64-NEXT:    8 |   (AA1 vbtable pointer)
 // CHECK-X64-NEXT:   20 |   int a
 // CHECK-X64-NEXT:   24 |   struct B0 (virtual base) (empty)
 // CHECK-X64-NEXT:      | [sizeof=24, align=8
 // CHECK-X64-NEXT:      |  nvsize=24, nvalign=8]
 
 struct AB1 : B9, B1, virtual B0 {
   short a;
   AB1() : a(0x00000AB1) { printf("AB1 = %p\n", this); }
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct AB1
+// CHECK-LABEL:   0 | struct AB1{{$}}
 // CHECK-NEXT:    0 |   struct B9 (base)
 // CHECK-NEXT:    0 |     char [6] c
 // CHECK-NEXT:   12 |   struct B1 (base) (empty)
 // CHECK-NEXT:    8 |   (AB1 vbtable pointer)
 // CHECK-NEXT:   12 |   short a
 // CHECK-NEXT:   16 |   struct B0 (virtual base) (empty)
 // CHECK-NEXT:      | [sizeof=16, align=4
 // CHECK-NEXT:      |  nvsize=16, nvalign=4]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct AB1
+// CHECK-X64-LABEL:   0 | struct AB1{{$}}
 // CHECK-X64-NEXT:    0 |   struct B9 (base)
 // CHECK-X64-NEXT:    0 |     char [6] c
 // CHECK-X64-NEXT:   16 |   struct B1 (base) (empty)
 // CHECK-X64-NEXT:    8 |   (AB1 vbtable pointer)
 // CHECK-X64-NEXT:   16 |   short a
 // CHECK-X64-NEXT:   24 |   struct B0 (virtual base) (empty)
 // CHECK-X64-NEXT:      | [sizeof=24, align=8
 // CHECK-X64-NEXT:      |  nvsize=24, nvalign=8]
 
 struct AC1 : B9, B1, virtual B0 {
   char a;
   AC1() : a(0x000000C1) { printf("AC1 = %p\n", this); }
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct AC1
+// CHECK-LABEL:   0 | struct AC1{{$}}
 // CHECK-NEXT:    0 |   struct B9 (base)
 // CHECK-NEXT:    0 |     char [6] c
 // CHECK-NEXT:   12 |   struct B1 (base) (empty)
 // CHECK-NEXT:    8 |   (AC1 vbtable pointer)
 // CHECK-NEXT:   12 |   char a
 // CHECK-NEXT:   16 |   struct B0 (virtual base) (empty)
 // CHECK-NEXT:      | [sizeof=16, align=4
 // CHECK-NEXT:      |  nvsize=16, nvalign=4]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct AC1
+// CHECK-X64-LABEL:   0 | struct AC1{{$}}
 // CHECK-X64-NEXT:    0 |   struct B9 (base)
 // CHECK-X64-NEXT:    0 |     char [6] c
 // CHECK-X64-NEXT:   16 |   struct B1 (base) (empty)
 // CHECK-X64-NEXT:    8 |   (AC1 vbtable pointer)
 // CHECK-X64-NEXT:   16 |   char a
 // CHECK-X64-NEXT:   24 |   struct B0 (virtual base) (empty)
 // CHECK-X64-NEXT:      | [sizeof=24, align=8
 // CHECK-X64-NEXT:      |  nvsize=24, nvalign=8]
 
 struct AD1 : B9, B1, virtual B0 {
   AD1() { printf("AD1 = %p\n", this); }
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct AD1
+// CHECK-LABEL:   0 | struct AD1{{$}}
 // CHECK-NEXT:    0 |   struct B9 (base)
 // CHECK-NEXT:    0 |     char [6] c
 // CHECK-NEXT:   12 |   struct B1 (base) (empty)
 // CHECK-NEXT:    8 |   (AD1 vbtable pointer)
 // CHECK-NEXT:   12 |   struct B0 (virtual base) (empty)
 // CHECK-NEXT:      | [sizeof=12, align=4
 // CHECK-NEXT:      |  nvsize=12, nvalign=4]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct AD1
+// CHECK-X64-LABEL:   0 | struct AD1{{$}}
 // CHECK-X64-NEXT:    0 |   struct B9 (base)
 // CHECK-X64-NEXT:    0 |     char [6] c
 // CHECK-X64-NEXT:   16 |   struct B1 (base) (empty)
 // CHECK-X64-NEXT:    8 |   (AD1 vbtable pointer)
 // CHECK-X64-NEXT:   16 |   struct B0 (virtual base) (empty)
 // CHECK-X64-NEXT:      | [sizeof=16, align=8
 // CHECK-X64-NEXT:      |  nvsize=16, nvalign=8]
 
 struct AA2 : B10, B1, virtual B0 {
   int a;
   AA2() : a(0x00000AA2) { printf("AA2 = %p\n", this); }
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct AA2
+// CHECK-LABEL:   0 | struct AA2{{$}}
 // CHECK-NEXT:    0 |   struct B10 (base)
 // CHECK-NEXT:    0 |     char [7] c
 // CHECK-NEXT:   15 |   struct B1 (base) (empty)
 // CHECK-NEXT:    8 |   (AA2 vbtable pointer)
 // CHECK-NEXT:   16 |   int a
 // CHECK-NEXT:   20 |   struct B0 (virtual base) (empty)
 // CHECK-NEXT:      | [sizeof=20, align=4
 // CHECK-NEXT:      |  nvsize=20, nvalign=4]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct AA2
+// CHECK-X64-LABEL:   0 | struct AA2{{$}}
 // CHECK-X64-NEXT:    0 |   struct B10 (base)
 // CHECK-X64-NEXT:    0 |     char [7] c
 // CHECK-X64-NEXT:   19 |   struct B1 (base) (empty)
 // CHECK-X64-NEXT:    8 |   (AA2 vbtable pointer)
 // CHECK-X64-NEXT:   20 |   int a
 // CHECK-X64-NEXT:   24 |   struct B0 (virtual base) (empty)
 // CHECK-X64-NEXT:      | [sizeof=24, align=8
 // CHECK-X64-NEXT:      |  nvsize=24, nvalign=8]
 
 struct AB2 : B10, B1, virtual B0 {
   short a;
   AB2() : a(0x00000AB2) { printf("AB2 = %p\n", this); }
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct AB2
+// CHECK-LABEL:   0 | struct AB2{{$}}
 // CHECK-NEXT:    0 |   struct B10 (base)
 // CHECK-NEXT:    0 |     char [7] c
 // CHECK-NEXT:   13 |   struct B1 (base) (empty)
 // CHECK-NEXT:    8 |   (AB2 vbtable pointer)
 // CHECK-NEXT:   14 |   short a
 // CHECK-NEXT:   16 |   struct B0 (virtual base) (empty)
 // CHECK-NEXT:      | [sizeof=16, align=4
 // CHECK-NEXT:      |  nvsize=16, nvalign=4]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct AB2
+// CHECK-X64-LABEL:   0 | struct AB2{{$}}
 // CHECK-X64-NEXT:    0 |   struct B10 (base)
 // CHECK-X64-NEXT:    0 |     char [7] c
 // CHECK-X64-NEXT:   17 |   struct B1 (base) (empty)
 // CHECK-X64-NEXT:    8 |   (AB2 vbtable pointer)
 // CHECK-X64-NEXT:   18 |   short a
 // CHECK-X64-NEXT:   24 |   struct B0 (virtual base) (empty)
 // CHECK-X64-NEXT:      | [sizeof=24, align=8
 // CHECK-X64-NEXT:      |  nvsize=24, nvalign=8]
 
 struct AC2 : B10, B1, virtual B0 {
   char a;
   AC2() : a(0x000000C2) { printf("AC2 = %p\n", this); }
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct AC2
+// CHECK-LABEL:   0 | struct AC2{{$}}
 // CHECK-NEXT:    0 |   struct B10 (base)
 // CHECK-NEXT:    0 |     char [7] c
 // CHECK-NEXT:   12 |   struct B1 (base) (empty)
 // CHECK-NEXT:    8 |   (AC2 vbtable pointer)
 // CHECK-NEXT:   12 |   char a
 // CHECK-NEXT:   16 |   struct B0 (virtual base) (empty)
 // CHECK-NEXT:      | [sizeof=16, align=4
 // CHECK-NEXT:      |  nvsize=16, nvalign=4]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct AC2
+// CHECK-X64-LABEL:   0 | struct AC2{{$}}
 // CHECK-X64-NEXT:    0 |   struct B10 (base)
 // CHECK-X64-NEXT:    0 |     char [7] c
 // CHECK-X64-NEXT:   16 |   struct B1 (base) (empty)
 // CHECK-X64-NEXT:    8 |   (AC2 vbtable pointer)
 // CHECK-X64-NEXT:   16 |   char a
 // CHECK-X64-NEXT:   24 |   struct B0 (virtual base) (empty)
 // CHECK-X64-NEXT:      | [sizeof=24, align=8
 // CHECK-X64-NEXT:      |  nvsize=24, nvalign=8]
 
 struct AD2 : B10, B1, virtual B0 {
   AD2() { printf("AD2 = %p\n", this); }
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct AD2
+// CHECK-LABEL:   0 | struct AD2{{$}}
 // CHECK-NEXT:    0 |   struct B10 (base)
 // CHECK-NEXT:    0 |     char [7] c
 // CHECK-NEXT:   12 |   struct B1 (base) (empty)
 // CHECK-NEXT:    8 |   (AD2 vbtable pointer)
 // CHECK-NEXT:   12 |   struct B0 (virtual base) (empty)
 // CHECK-NEXT:      | [sizeof=12, align=4
 // CHECK-NEXT:      |  nvsize=12, nvalign=4]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct AD2
+// CHECK-X64-LABEL:   0 | struct AD2{{$}}
 // CHECK-X64-NEXT:    0 |   struct B10 (base)
 // CHECK-X64-NEXT:    0 |     char [7] c
 // CHECK-X64-NEXT:   16 |   struct B1 (base) (empty)
 // CHECK-X64-NEXT:    8 |   (AD2 vbtable pointer)
 // CHECK-X64-NEXT:   16 |   struct B0 (virtual base) (empty)
 // CHECK-X64-NEXT:      | [sizeof=16, align=8
 // CHECK-X64-NEXT:      |  nvsize=16, nvalign=8]
 
 struct AA3 : B11, B1, virtual B0 {
   int a;
   AA3() : a(0x00000AA3) { printf("AA3 = %p\n", this); }
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct AA3
+// CHECK-LABEL:   0 | struct AA3{{$}}
 // CHECK-NEXT:    0 |   struct B11 (base)
 // CHECK-NEXT:    0 |     char [8] c
 // CHECK-NEXT:   12 |   struct B1 (base) (empty)
 // CHECK-NEXT:    8 |   (AA3 vbtable pointer)
 // CHECK-NEXT:   12 |   int a
 // CHECK-NEXT:   16 |   struct B0 (virtual base) (empty)
 // CHECK-NEXT:      | [sizeof=16, align=4
 // CHECK-NEXT:      |  nvsize=16, nvalign=4]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct AA3
+// CHECK-X64-LABEL:   0 | struct AA3{{$}}
 // CHECK-X64-NEXT:    0 |   struct B11 (base)
 // CHECK-X64-NEXT:    0 |     char [8] c
 // CHECK-X64-NEXT:   16 |   struct B1 (base) (empty)
 // CHECK-X64-NEXT:    8 |   (AA3 vbtable pointer)
 // CHECK-X64-NEXT:   16 |   int a
 // CHECK-X64-NEXT:   24 |   struct B0 (virtual base) (empty)
 // CHECK-X64-NEXT:      | [sizeof=24, align=8
 // CHECK-X64-NEXT:      |  nvsize=24, nvalign=8]
 
 struct AB3 : B11, B1, virtual B0 {
   short a;
   AB3() : a(0x00000AB3) { printf("AB3 = %p\n", this); }
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct AB3
+// CHECK-LABEL:   0 | struct AB3{{$}}
 // CHECK-NEXT:    0 |   struct B11 (base)
 // CHECK-NEXT:    0 |     char [8] c
 // CHECK-NEXT:   12 |   struct B1 (base) (empty)
 // CHECK-NEXT:    8 |   (AB3 vbtable pointer)
 // CHECK-NEXT:   12 |   short a
 // CHECK-NEXT:   16 |   struct B0 (virtual base) (empty)
 // CHECK-NEXT:      | [sizeof=16, align=4
 // CHECK-NEXT:      |  nvsize=16, nvalign=4]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct AB3
+// CHECK-X64-LABEL:   0 | struct AB3{{$}}
 // CHECK-X64-NEXT:    0 |   struct B11 (base)
 // CHECK-X64-NEXT:    0 |     char [8] c
 // CHECK-X64-NEXT:   16 |   struct B1 (base) (empty)
 // CHECK-X64-NEXT:    8 |   (AB3 vbtable pointer)
 // CHECK-X64-NEXT:   16 |   short a
 // CHECK-X64-NEXT:   24 |   struct B0 (virtual base) (empty)
 // CHECK-X64-NEXT:      | [sizeof=24, align=8
 // CHECK-X64-NEXT:      |  nvsize=24, nvalign=8]
 
 struct AC3 : B11, B1, virtual B0 {
   char a;
   AC3() : a(0x000000C3) { printf("AC3 = %p\n", this); }
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct AC3
+// CHECK-LABEL:   0 | struct AC3{{$}}
 // CHECK-NEXT:    0 |   struct B11 (base)
 // CHECK-NEXT:    0 |     char [8] c
 // CHECK-NEXT:   12 |   struct B1 (base) (empty)
 // CHECK-NEXT:    8 |   (AC3 vbtable pointer)
 // CHECK-NEXT:   12 |   char a
 // CHECK-NEXT:   16 |   struct B0 (virtual base) (empty)
 // CHECK-NEXT:      | [sizeof=16, align=4
 // CHECK-NEXT:      |  nvsize=16, nvalign=4]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct AC3
+// CHECK-X64-LABEL:   0 | struct AC3{{$}}
 // CHECK-X64-NEXT:    0 |   struct B11 (base)
 // CHECK-X64-NEXT:    0 |     char [8] c
 // CHECK-X64-NEXT:   16 |   struct B1 (base) (empty)
 // CHECK-X64-NEXT:    8 |   (AC3 vbtable pointer)
 // CHECK-X64-NEXT:   16 |   char a
 // CHECK-X64-NEXT:   24 |   struct B0 (virtual base) (empty)
 // CHECK-X64-NEXT:      | [sizeof=24, align=8
 // CHECK-X64-NEXT:      |  nvsize=24, nvalign=8]
 
 struct AD3 : B11, B1, virtual B0 {
   AD3() { printf("AD3 = %p\n", this); }
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct AD3
+// CHECK-LABEL:   0 | struct AD3{{$}}
 // CHECK-NEXT:    0 |   struct B11 (base)
 // CHECK-NEXT:    0 |     char [8] c
 // CHECK-NEXT:   12 |   struct B1 (base) (empty)
 // CHECK-NEXT:    8 |   (AD3 vbtable pointer)
 // CHECK-NEXT:   12 |   struct B0 (virtual base) (empty)
 // CHECK-NEXT:      | [sizeof=12, align=4
 // CHECK-NEXT:      |  nvsize=12, nvalign=4]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct AD3
+// CHECK-X64-LABEL:   0 | struct AD3{{$}}
 // CHECK-X64-NEXT:    0 |   struct B11 (base)
 // CHECK-X64-NEXT:    0 |     char [8] c
 // CHECK-X64-NEXT:   16 |   struct B1 (base) (empty)
 // CHECK-X64-NEXT:    8 |   (AD3 vbtable pointer)
 // CHECK-X64-NEXT:   16 |   struct B0 (virtual base) (empty)
 // CHECK-X64-NEXT:      | [sizeof=16, align=8
 // CHECK-X64-NEXT:      |  nvsize=16, nvalign=8]
 
 struct B : B1, B2, virtual B0 {
   B() { printf("B = %p\n", this); }
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct B
+// CHECK-LABEL:   0 | struct B{{$}}
 // CHECK-NEXT:    0 |   struct B1 (base) (empty)
 // CHECK-NEXT:    8 |   struct B2 (base) (empty)
 // CHECK-NEXT:    4 |   (B vbtable pointer)
 // CHECK-NEXT:    8 |   struct B0 (virtual base) (empty)
 // CHECK-NEXT:      | [sizeof=8, align=4
 // CHECK-NEXT:      |  nvsize=8, nvalign=4]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct B
+// CHECK-X64-LABEL:   0 | struct B{{$}}
 // CHECK-X64-NEXT:    0 |   struct B1 (base) (empty)
 // CHECK-X64-NEXT:   16 |   struct B2 (base) (empty)
 // CHECK-X64-NEXT:    8 |   (B vbtable pointer)
 // CHECK-X64-NEXT:   16 |   struct B0 (virtual base) (empty)
 // CHECK-X64-NEXT:      | [sizeof=16, align=8
 // CHECK-X64-NEXT:      |  nvsize=16, nvalign=8]
 
 struct C : B1, B2, B3, virtual B0 {
   char a;
   C() : a(0x0000000C) { printf("C = %p\n", this); }
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct C
+// CHECK-LABEL:   0 | struct C{{$}}
 // CHECK-NEXT:    0 |   struct B1 (base) (empty)
 // CHECK-NEXT:    1 |   struct B2 (base) (empty)
 // CHECK-NEXT:    8 |   struct B3 (base) (empty)
 // CHECK-NEXT:    4 |   (C vbtable pointer)
 // CHECK-NEXT:    8 |   char a
 // CHECK-NEXT:   12 |   struct B0 (virtual base) (empty)
 // CHECK-NEXT:      | [sizeof=12, align=4
 // CHECK-NEXT:      |  nvsize=12, nvalign=4]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct C
+// CHECK-X64-LABEL:   0 | struct C{{$}}
 // CHECK-X64-NEXT:    0 |   struct B1 (base) (empty)
 // CHECK-X64-NEXT:    1 |   struct B2 (base) (empty)
 // CHECK-X64-NEXT:   16 |   struct B3 (base) (empty)
 // CHECK-X64-NEXT:    8 |   (C vbtable pointer)
 // CHECK-X64-NEXT:   16 |   char a
 // CHECK-X64-NEXT:   24 |   struct B0 (virtual base) (empty)
 // CHECK-X64-NEXT:      | [sizeof=24, align=8
 // CHECK-X64-NEXT:      |  nvsize=24, nvalign=8]
 
 struct D : B1, B2, B3, B4, B5, virtual B0 {
   int a;
   D() : a(0x0000000D) { printf("D = %p\n", this); }
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct D
+// CHECK-LABEL:   0 | struct D{{$}}
 // CHECK-NEXT:    0 |   struct B1 (base) (empty)
 // CHECK-NEXT:    1 |   struct B2 (base) (empty)
 // CHECK-NEXT:    2 |   struct B3 (base) (empty)
 // CHECK-NEXT:    3 |   struct B4 (base) (empty)
 // CHECK-NEXT:    8 |   struct B5 (base) (empty)
 // CHECK-NEXT:    4 |   (D vbtable pointer)
 // CHECK-NEXT:    8 |   int a
 // CHECK-NEXT:   12 |   struct B0 (virtual base) (empty)
 // CHECK-NEXT:      | [sizeof=12, align=4
 // CHECK-NEXT:      |  nvsize=12, nvalign=4]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct D
+// CHECK-X64-LABEL:   0 | struct D{{$}}
 // CHECK-X64-NEXT:    0 |   struct B1 (base) (empty)
 // CHECK-X64-NEXT:    1 |   struct B2 (base) (empty)
 // CHECK-X64-NEXT:    2 |   struct B3 (base) (empty)
 // CHECK-X64-NEXT:    3 |   struct B4 (base) (empty)
 // CHECK-X64-NEXT:   16 |   struct B5 (base) (empty)
 // CHECK-X64-NEXT:    8 |   (D vbtable pointer)
 // CHECK-X64-NEXT:   16 |   int a
 // CHECK-X64-NEXT:   24 |   struct B0 (virtual base) (empty)
 // CHECK-X64-NEXT:      | [sizeof=24, align=8
 // CHECK-X64-NEXT:      |  nvsize=24, nvalign=8]
 
 struct E : B1, B6, B3, B4, B5, virtual B0 {
   int a;
   E() : a(0x0000000E) { printf("E = %p\n", this); }
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct E
+// CHECK-LABEL:   0 | struct E{{$}}
 // CHECK-NEXT:    0 |   struct B1 (base) (empty)
 // CHECK-NEXT:    2 |   struct B6 (base) (empty)
 // CHECK-NEXT:    3 |   struct B3 (base) (empty)
 // CHECK-NEXT:    4 |   struct B4 (base) (empty)
 // CHECK-NEXT:   13 |   struct B5 (base) (empty)
 // CHECK-NEXT:    8 |   (E vbtable pointer)
 // CHECK-NEXT:   16 |   int a
 // CHECK-NEXT:   20 |   struct B0 (virtual base) (empty)
 // CHECK-NEXT:      | [sizeof=20, align=4
 // CHECK-NEXT:      |  nvsize=20, nvalign=4]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct E
+// CHECK-X64-LABEL:   0 | struct E{{$}}
 // CHECK-X64-NEXT:    0 |   struct B1 (base) (empty)
 // CHECK-X64-NEXT:    2 |   struct B6 (base) (empty)
 // CHECK-X64-NEXT:    3 |   struct B3 (base) (empty)
 // CHECK-X64-NEXT:    4 |   struct B4 (base) (empty)
 // CHECK-X64-NEXT:   17 |   struct B5 (base) (empty)
 // CHECK-X64-NEXT:    8 |   (E vbtable pointer)
 // CHECK-X64-NEXT:   20 |   int a
 // CHECK-X64-NEXT:   24 |   struct B0 (virtual base) (empty)
 // CHECK-X64-NEXT:      | [sizeof=24, align=8
 // CHECK-X64-NEXT:      |  nvsize=24, nvalign=8]
 
 struct F : B1, B6, B4, B8, B5, virtual B0 {
   int a;
   F() : a(0x0000000F) { printf("&a = %p\n", &a); printf("F = %p\n", this); }
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct F
+// CHECK-LABEL:   0 | struct F{{$}}
 // CHECK-NEXT:    0 |   struct B1 (base) (empty)
 // CHECK-NEXT:    2 |   struct B6 (base) (empty)
 // CHECK-NEXT:    3 |   struct B4 (base) (empty)
 // CHECK-NEXT:    3 |   struct B8 (base)
 // CHECK-NEXT:    3 |     char [5] c
 // CHECK-NEXT:   12 |   struct B5 (base) (empty)
 // CHECK-NEXT:    8 |   (F vbtable pointer)
 // CHECK-NEXT:   12 |   int a
 // CHECK-NEXT:   16 |   struct B0 (virtual base) (empty)
 // CHECK-NEXT:      | [sizeof=16, align=4
 // CHECK-NEXT:      |  nvsize=16, nvalign=4]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct F
+// CHECK-X64-LABEL:   0 | struct F{{$}}
 // CHECK-X64-NEXT:    0 |   struct B1 (base) (empty)
 // CHECK-X64-NEXT:    2 |   struct B6 (base) (empty)
 // CHECK-X64-NEXT:    3 |   struct B4 (base) (empty)
 // CHECK-X64-NEXT:    3 |   struct B8 (base)
 // CHECK-X64-NEXT:    3 |     char [5] c
 // CHECK-X64-NEXT:   16 |   struct B5 (base) (empty)
 // CHECK-X64-NEXT:    8 |   (F vbtable pointer)
 // CHECK-X64-NEXT:   16 |   int a
 // CHECK-X64-NEXT:   24 |   struct B0 (virtual base) (empty)
 // CHECK-X64-NEXT:      | [sizeof=24, align=8
 // CHECK-X64-NEXT:      |  nvsize=24, nvalign=8]
 
 struct G : B8, B1, virtual B0 {
   int a;
   __declspec(align(16)) int a1;
   G() : a(0x00000010), a1(0xf0000010) { printf("G = %p\n", this); }
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct G
+// CHECK-LABEL:   0 | struct G{{$}}
 // CHECK-NEXT:    0 |   struct B8 (base)
 // CHECK-NEXT:    0 |     char [5] c
 // CHECK-NEXT:   21 |   struct B1 (base) (empty)
 // CHECK-NEXT:    8 |   (G vbtable pointer)
 // CHECK-NEXT:   24 |   int a
 // CHECK-NEXT:   32 |   int a1
 // CHECK-NEXT:   48 |   struct B0 (virtual base) (empty)
 // CHECK-NEXT:      | [sizeof=48, align=16
 // CHECK-NEXT:      |  nvsize=48, nvalign=16]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct G
+// CHECK-X64-LABEL:   0 | struct G{{$}}
 // CHECK-X64-NEXT:    0 |   struct B8 (base)
 // CHECK-X64-NEXT:    0 |     char [5] c
 // CHECK-X64-NEXT:   21 |   struct B1 (base) (empty)
 // CHECK-X64-NEXT:    8 |   (G vbtable pointer)
 // CHECK-X64-NEXT:   24 |   int a
 // CHECK-X64-NEXT:   32 |   int a1
 // CHECK-X64-NEXT:   48 |   struct B0 (virtual base) (empty)
 // CHECK-X64-NEXT:      | [sizeof=48, align=16
 // CHECK-X64-NEXT:      |  nvsize=48, nvalign=16]
 
 struct AX : B1X, B2X, B3X, B4X, virtual B0X {
   int a;
   AX() : a(0x0000000A) { printf(" A = %p\n", this); }
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct AX
+// CHECK-LABEL:   0 | struct AX{{$}}
 // CHECK-NEXT:    0 |   struct B1X (base) (empty)
 // CHECK-NEXT:   16 |   struct B2X (base) (empty)
 // CHECK-NEXT:   18 |   struct B3X (base) (empty)
 // CHECK-NEXT:   35 |   struct B4X (base) (empty)
 // CHECK-NEXT:   20 |   (AX vbtable pointer)
 // CHECK-NEXT:   36 |   int a
 // CHECK-NEXT:   48 |   struct B0X (virtual base) (empty)
 // CHECK-NEXT:      | [sizeof=48, align=16
 // CHECK-NEXT:      |  nvsize=48, nvalign=16]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct AX
+// CHECK-X64-LABEL:   0 | struct AX{{$}}
 // CHECK-X64-NEXT:    0 |   struct B1X (base) (empty)
 // CHECK-X64-NEXT:   16 |   struct B2X (base) (empty)
 // CHECK-X64-NEXT:   18 |   struct B3X (base) (empty)
 // CHECK-X64-NEXT:   35 |   struct B4X (base) (empty)
 // CHECK-X64-NEXT:   24 |   (AX vbtable pointer)
 // CHECK-X64-NEXT:   36 |   int a
 // CHECK-X64-NEXT:   48 |   struct B0X (virtual base) (empty)
 // CHECK-X64-NEXT:      | [sizeof=48, align=16
 // CHECK-X64-NEXT:      |  nvsize=48, nvalign=16]
 
 struct BX : B2X, B1X, B3X, B4X, virtual B0X {
   int a;
   BX() : a(0x0000000B) { printf(" B = %p\n", this); }
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct BX
+// CHECK-LABEL:   0 | struct BX{{$}}
 // CHECK-NEXT:    0 |   struct B2X (base) (empty)
 // CHECK-NEXT:    1 |   struct B1X (base) (empty)
 // CHECK-NEXT:    2 |   struct B3X (base) (empty)
 // CHECK-NEXT:   19 |   struct B4X (base) (empty)
 // CHECK-NEXT:    4 |   (BX vbtable pointer)
 // CHECK-NEXT:   20 |   int a
 // CHECK-NEXT:   32 |   struct B0X (virtual base) (empty)
 // CHECK-NEXT:      | [sizeof=32, align=16
 // CHECK-NEXT:      |  nvsize=32, nvalign=16]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct BX
+// CHECK-X64-LABEL:   0 | struct BX{{$}}
 // CHECK-X64-NEXT:    0 |   struct B2X (base) (empty)
 // CHECK-X64-NEXT:    1 |   struct B1X (base) (empty)
 // CHECK-X64-NEXT:    2 |   struct B3X (base) (empty)
 // CHECK-X64-NEXT:   19 |   struct B4X (base) (empty)
 // CHECK-X64-NEXT:    8 |   (BX vbtable pointer)
 // CHECK-X64-NEXT:   20 |   int a
 // CHECK-X64-NEXT:   32 |   struct B0X (virtual base) (empty)
 // CHECK-X64-NEXT:      | [sizeof=32, align=16
 // CHECK-X64-NEXT:      |  nvsize=32, nvalign=16]
 
 struct CX : B1X, B3X, B2X, virtual B0X {
   int a;
   CX() : a(0x0000000C) { printf(" C = %p\n", this); }
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct CX
+// CHECK-LABEL:   0 | struct CX{{$}}
 // CHECK-NEXT:    0 |   struct B1X (base) (empty)
 // CHECK-NEXT:    2 |   struct B3X (base) (empty)
 // CHECK-NEXT:   32 |   struct B2X (base) (empty)
 // CHECK-NEXT:   16 |   (CX vbtable pointer)
 // CHECK-NEXT:   32 |   int a
 // CHECK-NEXT:   48 |   struct B0X (virtual base) (empty)
 // CHECK-NEXT:      | [sizeof=48, align=16
 // CHECK-NEXT:      |  nvsize=48, nvalign=16]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct CX
+// CHECK-X64-LABEL:   0 | struct CX{{$}}
 // CHECK-X64-NEXT:    0 |   struct B1X (base) (empty)
 // CHECK-X64-NEXT:    2 |   struct B3X (base) (empty)
 // CHECK-X64-NEXT:   32 |   struct B2X (base) (empty)
 // CHECK-X64-NEXT:   16 |   (CX vbtable pointer)
 // CHECK-X64-NEXT:   32 |   int a
 // CHECK-X64-NEXT:   48 |   struct B0X (virtual base) (empty)
 // CHECK-X64-NEXT:      | [sizeof=48, align=16
 // CHECK-X64-NEXT:      |  nvsize=48, nvalign=16]
 
 struct DX : B8X, B1X, virtual B0X {
   int a;
   DX() : a(0x0000000D) { printf(" D = %p\n", this); }
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct DX
+// CHECK-LABEL:   0 | struct DX{{$}}
 // CHECK-NEXT:    0 |   struct B8X (base)
 // CHECK-NEXT:    0 |     short a
 // CHECK-NEXT:   10 |   struct B1X (base) (empty)
 // CHECK-NEXT:    4 |   (DX vbtable pointer)
 // CHECK-NEXT:   12 |   int a
 // CHECK-NEXT:   16 |   struct B0X (virtual base) (empty)
 // CHECK-NEXT:      | [sizeof=16, align=4
 // CHECK-NEXT:      |  nvsize=16, nvalign=4]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct DX
+// CHECK-X64-LABEL:   0 | struct DX{{$}}
 // CHECK-X64-NEXT:    0 |   struct B8X (base)
 // CHECK-X64-NEXT:    0 |     short a
 // CHECK-X64-NEXT:   18 |   struct B1X (base) (empty)
 // CHECK-X64-NEXT:    8 |   (DX vbtable pointer)
 // CHECK-X64-NEXT:   20 |   int a
 // CHECK-X64-NEXT:   24 |   struct B0X (virtual base) (empty)
 // CHECK-X64-NEXT:      | [sizeof=24, align=8
 // CHECK-X64-NEXT:      |  nvsize=24, nvalign=8]
 
-
 struct C0 {};
 struct C1 : public C0 { int C1F0; };
 struct C2 : public C1, public C0 {};
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct C2
+// CHECK-LABEL:   0 | struct C2{{$}}
 // CHECK-NEXT:    0 |   struct C1 (base)
 // CHECK-NEXT:    0 |     struct C0 (base) (empty)
 // CHECK-NEXT:    0 |     int C1F0
 // CHECK-NEXT:    5 |   struct C0 (base) (empty)
 // CHECK-NEXT:      | [sizeof=8, align=4
 // CHECK-NEXT:      |  nvsize=8, nvalign=4]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct C2
+// CHECK-X64-LABEL:   0 | struct C2{{$}}
 // CHECK-X64-NEXT:    0 |   struct C1 (base)
 // CHECK-X64-NEXT:    0 |     struct C0 (base) (empty)
 // CHECK-X64-NEXT:    0 |     int C1F0
 // CHECK-X64-NEXT:    5 |   struct C0 (base) (empty)
 // CHECK-X64-NEXT:      | [sizeof=8, align=4
 // CHECK-X64-NEXT:      |  nvsize=8, nvalign=4]
 
 struct JA { char a; };
 struct JB {
   char a;
   virtual void f() {}
 };
 struct JC { char a; };
 struct JD : JA, JB, virtual JC {};
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct JD
+// CHECK-LABEL:   0 | struct JD{{$}}
 // CHECK-NEXT:    0 |   struct JB (primary base)
 // CHECK-NEXT:    0 |     (JB vftable pointer)
 // CHECK-NEXT:    4 |     char a
 // CHECK-NEXT:   12 |   struct JA (base)
 // CHECK-NEXT:   12 |     char a
 // CHECK-NEXT:    8 |   (JD vbtable pointer)
 // CHECK-NEXT:   16 |   struct JC (virtual base)
 // CHECK-NEXT:   16 |     char a
 // CHECK-NEXT:      | [sizeof=17, align=4
 // CHECK-NEXT:      |  nvsize=16, nvalign=4]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct JD
+// CHECK-X64-LABEL:   0 | struct JD{{$}}
 // CHECK-X64-NEXT:    0 |   struct JB (primary base)
 // CHECK-X64-NEXT:    0 |     (JB vftable pointer)
 // CHECK-X64-NEXT:    8 |     char a
 // CHECK-X64-NEXT:   24 |   struct JA (base)
 // CHECK-X64-NEXT:   24 |     char a
 // CHECK-X64-NEXT:   16 |   (JD vbtable pointer)
 // CHECK-X64-NEXT:   32 |   struct JC (virtual base)
 // CHECK-X64-NEXT:   32 |     char a

clang/test/Layout/ms-x86-pack-and-align.cpp

 // RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fms-extensions -fdump-record-layouts -fsyntax-only -Wno-inaccessible-base %s 2>&1 \
-// RUN:            | FileCheck %s
+// RUN:            | FileCheck %s --strict-whitespace
 // RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fms-extensions -fdump-record-layouts -fsyntax-only -Wno-inaccessible-base %s 2>/dev/null \
-// RUN:            | FileCheck %s -check-prefix CHECK-X64
+// RUN:            | FileCheck %s -check-prefix CHECK-X64 --strict-whitespace
 
 extern "C" int printf(const char *fmt, ...);
 char buffer[419430400];
 
 struct A {
   char a;
   A() {
     printf("A   = %d\n", (int)((char*)this - buffer));
struct X {
   X() {
     printf("X   = %d\n", (int)((char*)this - buffer));
     printf("X.a = %d\n", (int)((char*)&a - buffer));
     printf("X.b = %d\n", (int)((char*)&b - buffer));
     printf("X.c = %d\n", (int)((char*)&c - buffer));
   }
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct X
+// CHECK-LABEL:   0 | struct X{{$}}
 // CHECK-NEXT:    0 |   struct B a
 // CHECK-NEXT:    0 |     long long a
 // CHECK-NEXT:    8 |   char b
 // CHECK-NEXT:   10 |   int c
 // CHECK-NEXT:      | [sizeof=16, align=4
 // CHECK-NEXT:      |  nvsize=14, nvalign=4]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct X
+// CHECK-X64-LABEL:   0 | struct X{{$}}
 // CHECK-X64-NEXT:    0 |   struct B a
 // CHECK-X64-NEXT:    0 |     long long a
 // CHECK-X64-NEXT:    8 |   char b
 // CHECK-X64-NEXT:   10 |   int c
 // CHECK-X64-NEXT:      | [sizeof=16, align=4
 // CHECK-X64-NEXT:      |  nvsize=14, nvalign=4]
 
 struct Y : A, B {
   char a;
   int b;
   Y() {
     printf("Y   = %d\n", (int)((char*)this - buffer));
     printf("Y.a = %d\n", (int)((char*)&a - buffer));
     printf("Y.b = %d\n", (int)((char*)&b - buffer));
   }
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct Y
+// CHECK-LABEL:   0 | struct Y{{$}}
 // CHECK-NEXT:    0 |   struct A (base)
 // CHECK-NEXT:    0 |     char a
 // CHECK-NEXT:    4 |   struct B (base)
 // CHECK-NEXT:    4 |     long long a
 // CHECK-NEXT:   12 |   char a
 // CHECK-NEXT:   14 |   int b
 // CHECK-NEXT:      | [sizeof=20, align=4
 // CHECK-NEXT:      |  nvsize=18, nvalign=4]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct Y
+// CHECK-X64-LABEL:   0 | struct Y{{$}}
 // CHECK-X64-NEXT:    0 |   struct A (base)
 // CHECK-X64-NEXT:    0 |     char a
 // CHECK-X64-NEXT:    4 |   struct B (base)
 // CHECK-X64-NEXT:    4 |     long long a
 // CHECK-X64-NEXT:   12 |   char a
 // CHECK-X64-NEXT:   14 |   int b
 // CHECK-X64-NEXT:      | [sizeof=20, align=4
 // CHECK-X64-NEXT:      |  nvsize=18, nvalign=4]
 
 struct Z : virtual B {
   char a;
   int b;
   Z() {
     printf("Z   = %d\n", (int)((char*)this - buffer));
     printf("Z.a = %d\n", (int)((char*)&a - buffer));
     printf("Z.b = %d\n", (int)((char*)&b - buffer));
   }
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct Z
+// CHECK-LABEL:   0 | struct Z{{$}}
 // CHECK-NEXT:    0 |   (Z vbtable pointer)
 // CHECK-NEXT:    4 |   char a
 // CHECK-NEXT:    6 |   int b
 // CHECK-NEXT:   12 |   struct B (virtual base)
 // CHECK-NEXT:   12 |     long long a
 // CHECK-NEXT:      | [sizeof=20, align=4
 // CHECK-NEXT:      |  nvsize=10, nvalign=4]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct Z
+// CHECK-X64-LABEL:   0 | struct Z{{$}}
 // CHECK-X64-NEXT:    0 |   (Z vbtable pointer)
 // CHECK-X64-NEXT:    8 |   char a
 // CHECK-X64-NEXT:   10 |   int b
 // CHECK-X64-NEXT:   16 |   struct B (virtual base)
 // CHECK-X64-NEXT:   16 |     long long a
 // CHECK-X64-NEXT:      | [sizeof=24, align=4
 // CHECK-X64-NEXT:      |  nvsize=14, nvalign=4]
 
 #pragma pack(pop)
 
 struct A1 { long long a; };
 #pragma pack(push, 1)
 struct B1 : virtual A1 { char a; };
 #pragma pack(pop)
 struct C1 : B1 {};
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct C1
+// CHECK-LABEL:   0 | struct C1{{$}}
 // CHECK-NEXT:    0 |   struct B1 (base)
 // CHECK-NEXT:    0 |     (B1 vbtable pointer)
 // CHECK-NEXT:    4 |     char a
 // CHECK-NEXT:    8 |   struct A1 (virtual base)
 // CHECK-NEXT:    8 |     long long a
 // CHECK-NEXT:      | [sizeof=16, align=8
 // CHECK-NEXT:      |  nvsize=5, nvalign=8]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct C1
+// CHECK-X64-LABEL:   0 | struct C1{{$}}
 // CHECK-X64-NEXT:    0 |   struct B1 (base)
 // CHECK-X64-NEXT:    0 |     (B1 vbtable pointer)
 // CHECK-X64-NEXT:    8 |     char a
 // CHECK-X64-NEXT:   16 |   struct A1 (virtual base)
 // CHECK-X64-NEXT:   16 |     long long a
 // CHECK-X64-NEXT:      | [sizeof=24, align=8
 // CHECK-X64-NEXT:      |  nvsize=9, nvalign=8]
 
 struct CA0 {
   CA0() {}
 };
 struct CA1 : virtual CA0 {
   CA1() {}
 };
 #pragma pack(push, 1)
 struct CA2 : public CA1, public CA0 {
   virtual void CA2Method() {}
   CA2() {}
 };
 #pragma pack(pop)
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct CA2
+// CHECK-LABEL:   0 | struct CA2{{$}}
 // CHECK-NEXT:    0 |   (CA2 vftable pointer)
 // CHECK-NEXT:    4 |   struct CA1 (base)
 // CHECK-NEXT:    4 |     (CA1 vbtable pointer)
 // CHECK-NEXT:    9 |   struct CA0 (base) (empty)
 // CHECK-NEXT:    9 |   struct CA0 (virtual base) (empty)
 // CHECK-NEXT:      | [sizeof=9, align=1
 // CHECK-NEXT:      |  nvsize=9, nvalign=1]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct CA2
+// CHECK-X64-LABEL:   0 | struct CA2{{$}}
 // CHECK-X64-NEXT:    0 |   (CA2 vftable pointer)
 // CHECK-X64-NEXT:    8 |   struct CA1 (base)
 // CHECK-X64-NEXT:    8 |     (CA1 vbtable pointer)
 // CHECK-X64-NEXT:   17 |   struct CA0 (base) (empty)
 // CHECK-X64-NEXT:   17 |   struct CA0 (virtual base) (empty)
 // CHECK-X64-NEXT:      | [sizeof=17, align=1
 // CHECK-X64-NEXT:      |  nvsize=17, nvalign=1]
 
 #pragma pack(16)
 struct YA {
   __declspec(align(32)) char : 1;
 };
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct YA
+// CHECK-LABEL:   0 | struct YA{{$}}
 // CHECK-NEXT:0:0-0 |   char
 // CHECK-NEXT:      | [sizeof=32, align=32
 // CHECK-NEXT:      |  nvsize=32, nvalign=32]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct YA
+// CHECK-X64-LABEL:   0 | struct YA{{$}}
 // CHECK-X64-NEXT:0:0-0 |   char
 // CHECK-X64-NEXT:      | [sizeof=32, align=32
 // CHECK-X64-NEXT:      |  nvsize=32, nvalign=32]
 
 #pragma pack(1)
 struct YB {
   char a;
   YA b;
 };
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct YB
+// CHECK-LABEL:   0 | struct YB{{$}}
 // CHECK-NEXT:    0 |   char a
 // CHECK-NEXT:    1 |   struct YA b
 // CHECK-NEXT:1:0-0 |     char
 // CHECK-NEXT:      | [sizeof=33, align=1
 // CHECK-NEXT:      |  nvsize=33, nvalign=1]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct YB
+// CHECK-X64-LABEL:   0 | struct YB{{$}}
 // CHECK-X64-NEXT:    0 |   char a
 // CHECK-X64-NEXT:    1 |   struct YA b
 // CHECK-X64-NEXT:1:0-0 |     char
 // CHECK-X64-NEXT:      | [sizeof=33, align=1
 // CHECK-X64-NEXT:      |  nvsize=33, nvalign=1]
 
 #pragma pack(8)
 struct YC {
   __declspec(align(32)) char : 1;
 };
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct YC
+// CHECK-LABEL:   0 | struct YC{{$}}
 // CHECK-NEXT:0:0-0 |   char
 // CHECK-NEXT:      | [sizeof=32, align=32
 // CHECK-NEXT:      |  nvsize=32, nvalign=32]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct YC
+// CHECK-X64-LABEL:   0 | struct YC{{$}}
 // CHECK-X64-NEXT:    0:0-0 |   char
 // CHECK-X64-NEXT:      | [sizeof=8, align=32
 // CHECK-X64-NEXT:      |  nvsize=8, nvalign=32]
 
 #pragma pack(1)
 struct YD {
   char a;
   YC b;
 };
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct YD
+// CHECK-LABEL:   0 | struct YD{{$}}
 // CHECK-NEXT:    0 |   char a
 // CHECK-NEXT:    1 |   struct YC b
 // CHECK-NEXT:1:0-0 |     char
 // CHECK-NEXT:      | [sizeof=33, align=1
 // CHECK-NEXT:      |  nvsize=33, nvalign=1]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct YD
+// CHECK-X64-LABEL:   0 | struct YD{{$}}
 // CHECK-X64-NEXT:    0 |   char a
 // CHECK-X64-NEXT:    1 |   struct YC b
 // CHECK-X64-NEXT:1:0-0 |     char
 // CHECK-X64-NEXT:      | [sizeof=9, align=1
 // CHECK-X64-NEXT:      |  nvsize=9, nvalign=1]
 
 #pragma pack(4)
 struct YE {
   __declspec(align(32)) char : 1;
 };
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct YE
+// CHECK-LABEL:   0 | struct YE{{$}}
 // CHECK-NEXT:    0:0-0 |   char
 // CHECK-NEXT:      | [sizeof=4, align=32
 // CHECK-NEXT:      |  nvsize=4, nvalign=32]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct YE
+// CHECK-X64-LABEL:   0 | struct YE{{$}}
 // CHECK-X64-NEXT:    0:0-0 |   char
 // CHECK-X64-NEXT:      | [sizeof=4, align=32
 // CHECK-X64-NEXT:      |  nvsize=4, nvalign=32]
 
 #pragma pack(1)
 struct YF {
   char a;
   YE b;
 };
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct YF
+// CHECK-LABEL:   0 | struct YF{{$}}
 // CHECK-NEXT:    0 |   char a
 // CHECK-NEXT:    1 |   struct YE b
 // CHECK-NEXT:1:0-0 |     char
 // CHECK-NEXT:      | [sizeof=5, align=1
 // CHECK-NEXT:      |  nvsize=5, nvalign=1]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct YF
+// CHECK-X64-LABEL:   0 | struct YF{{$}}
 // CHECK-X64-NEXT:    0 |   char a
 // CHECK-X64-NEXT:    1 |   struct YE b
 // CHECK-X64-NEXT:1:0-0 |     char
 // CHECK-X64-NEXT:      | [sizeof=5, align=1
 // CHECK-X64-NEXT:      |  nvsize=5, nvalign=1]
 
 #pragma pack(16)
 struct __declspec(align(16)) D0 { char a; };
 #pragma pack(1)
 struct D1 : public D0 { char a; };
 #pragma pack(16)
 struct D2 : D1 { char a; };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct D2
+// CHECK-LABEL:   0 | struct D2{{$}}
 // CHECK-NEXT:    0 |   struct D1 (base)
 // CHECK-NEXT:    0 |     struct D0 (base)
 // CHECK-NEXT:    0 |       char a
 // CHECK-NEXT:    1 |     char a
 // CHECK-NEXT:    2 |   char a
 // CHECK-NEXT:      | [sizeof=16, align=16
 // CHECK-NEXT:      |  nvsize=16, nvalign=16]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct D2
+// CHECK-X64-LABEL:   0 | struct D2{{$}}
 // CHECK-X64-NEXT:    0 |   struct D1 (base)
 // CHECK-X64-NEXT:    0 |     struct D0 (base)
 // CHECK-X64-NEXT:    0 |       char a
 // CHECK-X64-NEXT:    1 |     char a
 // CHECK-X64-NEXT:    2 |   char a
 // CHECK-X64-NEXT:      | [sizeof=16, align=16
 // CHECK-X64-NEXT:      |  nvsize=16, nvalign=16]
 
 #pragma pack()
 struct JA { char a; };
 #pragma pack(1)
 struct JB { __declspec(align(4)) char a; };
 #pragma pack()
 struct JC : JB, JA { };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct JC
+// CHECK-LABEL:   0 | struct JC{{$}}
 // CHECK-NEXT:    0 |   struct JB (base)
 // CHECK-NEXT:    0 |     char a
 // CHECK-NEXT:    1 |   struct JA (base)
 // CHECK-NEXT:    1 |     char a
 // CHECK-NEXT:      | [sizeof=4, align=4
 // CHECK-NEXT:      |  nvsize=4, nvalign=4]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct JC
+// CHECK-X64-LABEL:   0 | struct JC{{$}}
 // CHECK-X64-NEXT:    0 |   struct JB (base)
 // CHECK-X64-NEXT:    0 |     char a
 // CHECK-X64-NEXT:    1 |   struct JA (base)
 // CHECK-X64-NEXT:    1 |     char a
 // CHECK-X64-NEXT:      | [sizeof=4, align=4
 // CHECK-X64-NEXT:      |  nvsize=4, nvalign=4]
 
 #pragma pack()
 struct KA { char a; };
 #pragma pack(1)
 struct KB : KA { __declspec(align(2)) char a; };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct KB
+// CHECK-LABEL:   0 | struct KB{{$}}
 // CHECK-NEXT:    0 |   struct KA (base)
 // CHECK-NEXT:    0 |     char a
 // CHECK-NEXT:    2 |   char a
 // CHECK-NEXT:      | [sizeof=4, align=2
 // CHECK-NEXT:      |  nvsize=3, nvalign=2]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct KB
+// CHECK-X64-LABEL:   0 | struct KB{{$}}
 // CHECK-X64-NEXT:    0 |   struct KA (base)
 // CHECK-X64-NEXT:    0 |     char a
 // CHECK-X64-NEXT:    2 |   char a
 // CHECK-X64-NEXT:      | [sizeof=4, align=2
 // CHECK-X64-NEXT:      |  nvsize=3, nvalign=2]
 
 #pragma pack(1)
 struct L {
   virtual void fun() {}
   __declspec(align(256)) int Field;
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct L
+// CHECK-LABEL:   0 | struct L{{$}}
 // CHECK-NEXT:    0 |   (L vftable pointer)
 // CHECK-NEXT:  256 |   int Field
 // CHECK-NEXT:      | [sizeof=512, align=256
 // CHECK-NEXT:      |  nvsize=260, nvalign=256]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct L
+// CHECK-X64-LABEL:   0 | struct L{{$}}
 // CHECK-X64-NEXT:    0 |   (L vftable pointer)
 // CHECK-X64-NEXT:  256 |   int Field
 // CHECK-X64-NEXT:      | [sizeof=512, align=256
 // CHECK-X64-NEXT:      |  nvsize=260, nvalign=256]
 
 #pragma pack()
 struct MA {};
 #pragma pack(1)
 struct MB : virtual MA {
   __declspec(align(256)) int Field;
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct MB
+// CHECK-LABEL:   0 | struct MB{{$}}
 // CHECK-NEXT:    0 |   (MB vbtable pointer)
 // CHECK-NEXT:  256 |   int Field
 // CHECK-NEXT:  260 |   struct MA (virtual base) (empty)
 // CHECK-NEXT:      | [sizeof=512, align=256
 // CHECK-NEXT:      |  nvsize=260, nvalign=256]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct MB
+// CHECK-X64-LABEL:   0 | struct MB{{$}}
 // CHECK-X64-NEXT:    0 |   (MB vbtable pointer)
 // CHECK-X64-NEXT:  256 |   int Field
 // CHECK-X64-NEXT:  260 |   struct MA (virtual base) (empty)
 // CHECK-X64-NEXT:      | [sizeof=512, align=256
 // CHECK-X64-NEXT:      |  nvsize=260, nvalign=256]
 
 struct RA {};
 #pragma pack(1)
struct RC {
   __declspec(align(1024)) int c : 3;
 };
 struct RE {
   char _;
   RC c;
 };
 #pragma pack()
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct RB0
+// CHECK-LABEL:   0 | struct RB0{{$}}
 // CHECK-NEXT:0:0-2 |   int b
 // CHECK-NEXT:      | [sizeof=8, align=1024
 // CHECK-NEXT:      |  nvsize=4, nvalign=1024]
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct RB1
+// CHECK-LABEL:   0 | struct RB1{{$}}
 // CHECK-NEXT:    0 |   (RB1 vftable pointer)
 // CHECK-NEXT: 1024:0-2 |   int b
 // CHECK-NEXT:      | [sizeof=1032, align=1024
 // CHECK-NEXT:      |  nvsize=1028, nvalign=1024]
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct RB2
+// CHECK-LABEL:   0 | struct RB2{{$}}
 // CHECK-NEXT:    0 |   (RB2 vbtable pointer)
 // CHECK-NEXT: 1024:0-2 |   int b
 // CHECK-NEXT: 1028 |   struct RA (virtual base) (empty)
 // CHECK-NEXT:      | [sizeof=1032, align=1024
 // CHECK-NEXT:      |  nvsize=1028, nvalign=1024]
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct RB3
+// CHECK-LABEL:   0 | struct RB3{{$}}
 // CHECK-NEXT:    0 |   (RB3 vftable pointer)
 // CHECK-NEXT: 1024 |   (RB3 vbtable pointer)
 // CHECK-NEXT: 2048:0-2 |   int b
 // CHECK-NEXT: 2052 |   struct RA (virtual base) (empty)
 // CHECK-NEXT:      | [sizeof=2056, align=1024
 // CHECK-NEXT:      |  nvsize=2052, nvalign=1024]
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct RC
+// CHECK-LABEL:   0 | struct RC{{$}}
 // CHECK-NEXT:    0 |   char _
 // CHECK-NEXT: 1024:0-2 |   int c
 // CHECK-NEXT:      | [sizeof=1028, align=1024
 // CHECK-NEXT:      |  nvsize=1028, nvalign=1024]
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct RE
+// CHECK-LABEL:   0 | struct RE{{$}}
 // CHECK-NEXT:    0 |   char _
 // CHECK-NEXT:    1 |   struct RC c
 // CHECK-NEXT:    1 |     char _
 // CHECK-NEXT: 1025:0-2 |     int c
 // CHECK-NEXT:      | [sizeof=1029, align=1
 // CHECK-NEXT:      |  nvsize=1029, nvalign=1]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct RB0
+// CHECK-X64-LABEL:   0 | struct RB0{{$}}
 // CHECK-X64-NEXT:    0:0-2 |   int b
 // CHECK-X64-NEXT:      | [sizeof=8, align=1024
 // CHECK-X64-NEXT:      |  nvsize=4, nvalign=1024]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct RB1
+// CHECK-X64-LABEL:   0 | struct RB1{{$}}
 // CHECK-X64-NEXT:    0 |   (RB1 vftable pointer)
 // CHECK-X64-NEXT: 1024:0-2 |   int b
 // CHECK-X64-NEXT:      | [sizeof=1032, align=1024
 // CHECK-X64-NEXT:      |  nvsize=1028, nvalign=1024]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct RB2
+// CHECK-X64-LABEL:   0 | struct RB2{{$}}
 // CHECK-X64-NEXT:    0 |   (RB2 vbtable pointer)
 // CHECK-X64-NEXT: 1024:0-2 |   int b
 // CHECK-X64-NEXT: 1028 |   struct RA (virtual base) (empty)
 // CHECK-X64-NEXT:      | [sizeof=1032, align=1024
 // CHECK-X64-NEXT:      |  nvsize=1028, nvalign=1024]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct RB3
+// CHECK-X64-LABEL:   0 | struct RB3{{$}}
 // CHECK-X64-NEXT:    0 |   (RB3 vftable pointer)
 // CHECK-X64-NEXT: 1024 |   (RB3 vbtable pointer)
 // CHECK-X64-NEXT: 2048:0-2 |   int b
 // CHECK-X64-NEXT: 2052 |   struct RA (virtual base) (empty)
 // CHECK-X64-NEXT:      | [sizeof=2056, align=1024
 // CHECK-X64-NEXT:      |  nvsize=2052, nvalign=1024]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct RC
+// CHECK-X64-LABEL:   0 | struct RC{{$}}
 // CHECK-X64-NEXT:    0 |   char _
 // CHECK-X64-NEXT: 1024:0-2 |   int c
 // CHECK-X64-NEXT:      | [sizeof=1028, align=1024
 // CHECK-X64-NEXT:      |  nvsize=1028, nvalign=1024]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct RE
+// CHECK-X64-LABEL:   0 | struct RE{{$}}
 // CHECK-X64-NEXT:    0 |   char _
 // CHECK-X64-NEXT:    1 |   struct RC c
 // CHECK-X64-NEXT:    1 |     char _
 // CHECK-X64-NEXT: 1025:0-2 |     int c
 // CHECK-X64-NEXT:      | [sizeof=1029, align=1
 // CHECK-X64-NEXT:      |  nvsize=1029, nvalign=1]
 
 struct NA {};
 struct NB {};
 #pragma pack(push, 1)
 struct NC : virtual NA, virtual NB {};
 #pragma pack(pop)
 struct ND : NC {};
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct NA (empty)
+// CHECK-LABEL:   0 | struct NA (empty){{$}}
 // CHECK-NEXT:      | [sizeof=1, align=1
 // CHECK-NEXT:      |  nvsize=0, nvalign=1]
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct NB (empty)
+// CHECK-LABEL:   0 | struct NB (empty){{$}}
 // CHECK-NEXT:      | [sizeof=1, align=1
 // CHECK-NEXT:      |  nvsize=0, nvalign=1]
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct NC
+// CHECK-LABEL:   0 | struct NC{{$}}
 // CHECK-NEXT:    0 |   (NC vbtable pointer)
 // CHECK-NEXT:    4 |   struct NA (virtual base) (empty)
 // CHECK-NEXT:    8 |   struct NB (virtual base) (empty)
 // CHECK-NEXT:      | [sizeof=8, align=1
 // CHECK-NEXT:      |  nvsize=4, nvalign=1]
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct ND
+// CHECK-LABEL:   0 | struct ND{{$}}
 // CHECK-NEXT:    0 |   struct NC (base)
 // CHECK-NEXT:    0 |     (NC vbtable pointer)
 // CHECK-NEXT:    4 |   struct NA (virtual base) (empty)
 // CHECK-NEXT:    8 |   struct NB (virtual base) (empty)
 // CHECK-NEXT:      | [sizeof=8, align=4
 // CHECK-NEXT:      |  nvsize=4, nvalign=4]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct NA (empty)
+// CHECK-X64-LABEL:   0 | struct NA (empty){{$}}
 // CHECK-X64-NEXT:      | [sizeof=1, align=1
 // CHECK-X64-NEXT:      |  nvsize=0, nvalign=1]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct NB (empty)
+// CHECK-X64-LABEL:   0 | struct NB (empty){{$}}
 // CHECK-X64-NEXT:      | [sizeof=1, align=1
 // CHECK-X64-NEXT:      |  nvsize=0, nvalign=1]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct NC
+// CHECK-X64-LABEL:   0 | struct NC{{$}}
 // CHECK-X64-NEXT:    0 |   (NC vbtable pointer)
 // CHECK-X64-NEXT:    8 |   struct NA (virtual base) (empty)
 // CHECK-X64-NEXT:   12 |   struct NB (virtual base) (empty)
 // CHECK-X64-NEXT:      | [sizeof=12, align=1
 // CHECK-X64-NEXT:      |  nvsize=8, nvalign=1]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct ND
+// CHECK-X64-LABEL:   0 | struct ND{{$}}
 // CHECK-X64-NEXT:    0 |   struct NC (base)
 // CHECK-X64-NEXT:    0 |     (NC vbtable pointer)
 // CHECK-X64-NEXT:    8 |   struct NA (virtual base) (empty)
 // CHECK-X64-NEXT:   12 |   struct NB (virtual base) (empty)
 // CHECK-X64-NEXT:      | [sizeof=12, align=4
 // CHECK-X64-NEXT:      |  nvsize=8, nvalign=4]
 
 struct OA {};
 struct OB {};
 struct OC : virtual OA, virtual OB {};
 #pragma pack(push, 1)
 struct OD : OC {};
 #pragma pack(pop)
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct OA (empty)
+// CHECK-LABEL:   0 | struct OA (empty){{$}}
 // CHECK-NEXT:      | [sizeof=1, align=1
 // CHECK-NEXT:      |  nvsize=0, nvalign=1]
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct OB (empty)
+// CHECK-LABEL:   0 | struct OB (empty){{$}}
 // CHECK-NEXT:      | [sizeof=1, align=1
 // CHECK-NEXT:      |  nvsize=0, nvalign=1]
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct OC
+// CHECK-LABEL:   0 | struct OC{{$}}
 // CHECK-NEXT:    0 |   (OC vbtable pointer)
 // CHECK-NEXT:    4 |   struct OA (virtual base) (empty)
 // CHECK-NEXT:    8 |   struct OB (virtual base) (empty)
 // CHECK-NEXT:      | [sizeof=8, align=4
 // CHECK-NEXT:      |  nvsize=4, nvalign=4]
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct OD
+// CHECK-LABEL:   0 | struct OD{{$}}
 // CHECK-NEXT:    0 |   struct OC (base)
 // CHECK-NEXT:    0 |     (OC vbtable pointer)
 // CHECK-NEXT:    4 |   struct OA (virtual base) (empty)
 // CHECK-NEXT:    8 |   struct OB (virtual base) (empty)
 // CHECK-NEXT:      | [sizeof=8, align=1
 // CHECK-NEXT:      |  nvsize=4, nvalign=1]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct OA (empty)
+// CHECK-X64-LABEL:   0 | struct OA (empty){{$}}
 // CHECK-X64-NEXT:      | [sizeof=1, align=1
 // CHECK-X64-NEXT:      |  nvsize=0, nvalign=1]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct OB (empty)
+// CHECK-X64-LABEL:   0 | struct OB (empty){{$}}
 // CHECK-X64-NEXT:      | [sizeof=1, align=1
 // CHECK-X64-NEXT:      |  nvsize=0, nvalign=1]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct OC
+// CHECK-X64-LABEL:   0 | struct OC{{$}}
 // CHECK-X64-NEXT:    0 |   (OC vbtable pointer)
 // CHECK-X64-NEXT:    8 |   struct OA (virtual base) (empty)
 // CHECK-X64-NEXT:   12 |   struct OB (virtual base) (empty)
 // CHECK-X64-NEXT:      | [sizeof=16, align=8
 // CHECK-X64-NEXT:      |  nvsize=8, nvalign=8]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct OD
+// CHECK-X64-LABEL:   0 | struct OD{{$}}
 // CHECK-X64-NEXT:    0 |   struct OC (base)
 // CHECK-X64-NEXT:    0 |     (OC vbtable pointer)
 // CHECK-X64-NEXT:    8 |   struct OA (virtual base) (empty)
 // CHECK-X64-NEXT:   12 |   struct OB (virtual base) (empty)
 // CHECK-X64-NEXT:      | [sizeof=12, align=1
 // CHECK-X64-NEXT:      |  nvsize=8, nvalign=1]
 
 struct __declspec(align(4)) PA {
   int c;
 };
 
 typedef __declspec(align(8)) PA PB;
 
 #pragma pack(push, 1)
 struct PC {
   char a;
   PB x;
 };
 #pragma pack(pop)
 
-// CHECK: *** Dumping AST Record Layout
 // CHECK:         0 | struct PC
 // CHECK-NEXT:    0 |   char a
 // CHECK-NEXT:    8 |   struct PA x
 // CHECK-NEXT:    8 |     int c
 // CHECK-NEXT:      | [sizeof=16, align=8
 // CHECK-NEXT:      |  nvsize=12, nvalign=8]
-// CHECK-X64: *** Dumping AST Record Layout
 // CHECK-X64:         0 | struct PC
 // CHECK-X64-NEXT:    0 |   char a
 // CHECK-X64-NEXT:    8 |   struct PA x
 // CHECK-X64-NEXT:    8 |     int c
 // CHECK-X64-NEXT:      | [sizeof=16, align=8
 // CHECK-X64-NEXT:      |  nvsize=12, nvalign=8]
 
 typedef PB PD;
 
 #pragma pack(push, 1)
 struct PE {
   char a;
   PD x;
 };
 #pragma pack(pop)
 
-// CHECK: *** Dumping AST Record Layout
 // CHECK:         0 | struct PE
 // CHECK-NEXT:    0 |   char a
 // CHECK-NEXT:    8 |   struct PA x
 // CHECK-NEXT:    8 |     int c
 // CHECK-NEXT:      | [sizeof=16, align=8
 // CHECK-NEXT:      |  nvsize=12, nvalign=8]
-// CHECK-X64: *** Dumping AST Record Layout
 // CHECK-X64:         0 | struct PE
 // CHECK-X64-NEXT:    0 |   char a
 // CHECK-X64-NEXT:    8 |   struct PA x
 // CHECK-X64-NEXT:    8 |     int c
 // CHECK-X64-NEXT:      | [sizeof=16, align=8
 // CHECK-X64-NEXT:      |  nvsize=12, nvalign=8]
 
 typedef int __declspec(align(2)) QA;
 #pragma pack(push, 1)
 struct QB {
   char a;
   QA b;
 };
 #pragma pack(pop)
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct QB
+// CHECK-LABEL:   0 | struct QB{{$}}
 // CHECK-NEXT:    0 |   char a
 // CHECK-NEXT:    2 |   QA b
 // CHECK-NEXT:      | [sizeof=6, align=2
 // CHECK-NEXT:      |  nvsize=6, nvalign=2]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct QB
+// CHECK-X64-LABEL:   0 | struct QB{{$}}
 // CHECK-X64-NEXT:    0 |   char a
 // CHECK-X64-NEXT:    2 |   QA b
 // CHECK-X64-NEXT:      | [sizeof=6, align=2
 // CHECK-X64-NEXT:      |  nvsize=6, nvalign=2]
 
 struct QC {
   char a;
   QA b;
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct QC
+// CHECK-LABEL:   0 | struct QC{{$}}
 // CHECK-NEXT:    0 |   char a
 // CHECK-NEXT:    4 |   QA b
 // CHECK-NEXT:      | [sizeof=8, align=4
 // CHECK-NEXT:      |  nvsize=8, nvalign=4]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct QC
+// CHECK-X64-LABEL:   0 | struct QC{{$}}
 // CHECK-X64-NEXT:    0 |   char a
 // CHECK-X64-NEXT:    4 |   QA b
 // CHECK-X64-NEXT:      | [sizeof=8, align=4
 // CHECK-X64-NEXT:      |  nvsize=8, nvalign=4]
 
 struct QD {
   char a;
   QA b : 3;
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct QD
+// CHECK-LABEL:   0 | struct QD{{$}}
 // CHECK-NEXT:    0 |   char a
 // CHECK-NEXT:4:0-2 |   QA b
 // CHECK-NEXT:      | [sizeof=8, align=4
 // CHECK-NEXT:      |  nvsize=8, nvalign=4]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct QD
+// CHECK-X64-LABEL:   0 | struct QD{{$}}
 // CHECK-X64-NEXT:    0 |   char a
 // CHECK-X64-NEXT:4:0-2 |   QA b
 // CHECK-X64-NEXT:      | [sizeof=8, align=4
 // CHECK-X64-NEXT:      |  nvsize=8, nvalign=4]
 
 struct __declspec(align(4)) EmptyAlignedLongLongMemb {
   long long FlexArrayMemb[0];
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct EmptyAlignedLongLongMemb
+// CHECK-LABEL:   0 | struct EmptyAlignedLongLongMemb{{$}}
 // CHECK-NEXT:    0 |   long long [0] FlexArrayMemb
 // CHECK-NEXT:      | [sizeof=8, align=8
 // CHECK-NEXT:      |  nvsize=0, nvalign=8]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct EmptyAlignedLongLongMemb
+// CHECK-X64-LABEL:   0 | struct EmptyAlignedLongLongMemb{{$}}
 // CHECK-X64-NEXT:    0 |   long long [0] FlexArrayMemb
 // CHECK-X64-NEXT:      | [sizeof=8, align=8
 // CHECK-X64-NEXT:      |  nvsize=0, nvalign=8]
 
 #pragma pack(1)
 struct __declspec(align(4)) EmptyPackedAlignedLongLongMemb {
   long long FlexArrayMemb[0];
 };
 #pragma pack()
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct EmptyPackedAlignedLongLongMemb
+// CHECK-LABEL:   0 | struct EmptyPackedAlignedLongLongMemb{{$}}
 // CHECK-NEXT:    0 |   long long [0] FlexArrayMemb
 // CHECK-NEXT:      | [sizeof=4, align=4
 // CHECK-NEXT:      |  nvsize=0, nvalign=4]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct EmptyPackedAlignedLongLongMemb
+// CHECK-X64-LABEL:   0 | struct EmptyPackedAlignedLongLongMemb{{$}}
 // CHECK-X64-NEXT:    0 |   long long [0] FlexArrayMemb
 // CHECK-X64-NEXT:      | [sizeof=4, align=4
 // CHECK-X64-NEXT:      |  nvsize=0, nvalign=4]
 
 int a[
 sizeof(X)+
 sizeof(Y)+
 sizeof(Z)+

clang/test/Layout/ms-x86-primary-bases.cpp

 // RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts -fsyntax-only %s 2>/dev/null \
-// RUN:            | FileCheck %s
+// RUN:            | FileCheck %s --strict-whitespace
 // RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fdump-record-layouts -fsyntax-only %s 2>/dev/null \
-// RUN:            | FileCheck %s -check-prefix CHECK-X64
+// RUN:            | FileCheck %s -check-prefix CHECK-X64 --strict-whitespace
 
 extern "C" int printf(const char *fmt, ...);
 
 struct B0 { int a; B0() : a(0xf00000B0) { printf("B0 = %p\n", this); } virtual void f() { printf("B0"); } };
 struct B1 { int a; B1() : a(0xf00000B1) { printf("B1 = %p\n", this); } virtual void g() { printf("B1"); } };
 struct B2 { int a; B2() : a(0xf00000B2) { printf("B1 = %p\n", this); } };
 struct B0X { int a; B0X() : a(0xf00000B0) {} };
 struct B1X { int a; B1X() : a(0xf00000B1) {} virtual void f() { printf("B0"); } };
 struct B2X : virtual B1X { int a; B2X() : a(0xf00000B2) {} };
 
 struct A : virtual B0 {
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct A
+// CHECK-LABEL:   0 | struct A
 // CHECK-NEXT:    0 |   (A vbtable pointer)
 // CHECK-NEXT:    4 |   struct B0 (virtual base)
 // CHECK-NEXT:    4 |     (B0 vftable pointer)
 // CHECK-NEXT:    8 |     int a
 // CHECK-NEXT:      | [sizeof=12, align=4
 // CHECK-NEXT:      |  nvsize=4, nvalign=4]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct A
+// CHECK-X64-LABEL:   0 | struct A
 // CHECK-X64-NEXT:    0 |   (A vbtable pointer)
 // CHECK-X64-NEXT:    8 |   struct B0 (virtual base)
 // CHECK-X64-NEXT:    8 |     (B0 vftable pointer)
 // CHECK-X64-NEXT:   16 |     int a
 // CHECK-X64-NEXT:      | [sizeof=24, align=8
 // CHECK-X64-NEXT:      |  nvsize=8, nvalign=8]
 
 struct B : virtual B0 {
   virtual void f() { printf("B"); }
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct B
+// CHECK-LABEL:   0 | struct B
 // CHECK-NEXT:    0 |   (B vbtable pointer)
 // CHECK-NEXT:    4 |   struct B0 (virtual base)
 // CHECK-NEXT:    4 |     (B0 vftable pointer)
 // CHECK-NEXT:    8 |     int a
 // CHECK-NEXT:      | [sizeof=12, align=4
 // CHECK-NEXT:      |  nvsize=4, nvalign=4]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct B
+// CHECK-X64-LABEL:   0 | struct B
 // CHECK-X64-NEXT:    0 |   (B vbtable pointer)
 // CHECK-X64-NEXT:    8 |   struct B0 (virtual base)
 // CHECK-X64-NEXT:    8 |     (B0 vftable pointer)
 // CHECK-X64-NEXT:   16 |     int a
 // CHECK-X64-NEXT:      | [sizeof=24, align=8
 // CHECK-X64-NEXT:      |  nvsize=8, nvalign=8]
 
 struct C : virtual B0 {
   virtual void g() { printf("A"); }
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct C
+// CHECK-LABEL:   0 | struct C
 // CHECK-NEXT:    0 |   (C vftable pointer)
 // CHECK-NEXT:    4 |   (C vbtable pointer)
 // CHECK-NEXT:    8 |   struct B0 (virtual base)
 // CHECK-NEXT:    8 |     (B0 vftable pointer)
 // CHECK-NEXT:   12 |     int a
 // CHECK-NEXT:      | [sizeof=16, align=4
 // CHECK-NEXT:      |  nvsize=8, nvalign=4]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct C
+// CHECK-X64-LABEL:   0 | struct C
 // CHECK-X64-NEXT:    0 |   (C vftable pointer)
 // CHECK-X64-NEXT:    8 |   (C vbtable pointer)
 // CHECK-X64-NEXT:   16 |   struct B0 (virtual base)
 // CHECK-X64-NEXT:   16 |     (B0 vftable pointer)
 // CHECK-X64-NEXT:   24 |     int a
 // CHECK-X64-NEXT:      | [sizeof=32, align=8
 // CHECK-X64-NEXT:      |  nvsize=16, nvalign=8]
 
 struct D : virtual B2, virtual B0 {
   virtual void f() { printf("D"); }
   virtual void g() { printf("D"); }
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct D
+// CHECK-LABEL:   0 | struct D
 // CHECK-NEXT:    0 |   (D vftable pointer)
 // CHECK-NEXT:    4 |   (D vbtable pointer)
 // CHECK-NEXT:    8 |   struct B2 (virtual base)
 // CHECK-NEXT:    8 |     int a
 // CHECK-NEXT:   12 |   struct B0 (virtual base)
 // CHECK-NEXT:   12 |     (B0 vftable pointer)
 // CHECK-NEXT:   16 |     int a
 // CHECK-NEXT:      | [sizeof=20, align=4
 // CHECK-NEXT:      |  nvsize=8, nvalign=4]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct D
+// CHECK-X64-LABEL:   0 | struct D
 // CHECK-X64-NEXT:    0 |   (D vftable pointer)
 // CHECK-X64-NEXT:    8 |   (D vbtable pointer)
 // CHECK-X64-NEXT:   16 |   struct B2 (virtual base)
 // CHECK-X64-NEXT:   16 |     int a
 // CHECK-X64-NEXT:   24 |   struct B0 (virtual base)
 // CHECK-X64-NEXT:   24 |     (B0 vftable pointer)
 // CHECK-X64-NEXT:   32 |     int a
 // CHECK-X64-NEXT:      | [sizeof=40, align=8
 // CHECK-X64-NEXT:      |  nvsize=16, nvalign=8]
 
 struct E : B0, virtual B1 {
   virtual void f() { printf("E"); }
   virtual void g() { printf("E"); }
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct E
+// CHECK-LABEL:   0 | struct E
 // CHECK-NEXT:    0 |   struct B0 (primary base)
 // CHECK-NEXT:    0 |     (B0 vftable pointer)
 // CHECK-NEXT:    4 |     int a
 // CHECK-NEXT:    8 |   (E vbtable pointer)
 // CHECK-NEXT:   12 |   struct B1 (virtual base)
 // CHECK-NEXT:   12 |     (B1 vftable pointer)
 // CHECK-NEXT:   16 |     int a
 // CHECK-NEXT:      | [sizeof=20, align=4
 // CHECK-NEXT:      |  nvsize=12, nvalign=4]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct E
+// CHECK-X64-LABEL:   0 | struct E
 // CHECK-X64-NEXT:    0 |   struct B0 (primary base)
 // CHECK-X64-NEXT:    0 |     (B0 vftable pointer)
 // CHECK-X64-NEXT:    8 |     int a
 // CHECK-X64-NEXT:   16 |   (E vbtable pointer)
 // CHECK-X64-NEXT:   24 |   struct B1 (virtual base)
 // CHECK-X64-NEXT:   24 |     (B1 vftable pointer)
 // CHECK-X64-NEXT:   32 |     int a
 // CHECK-X64-NEXT:      | [sizeof=40, align=8
 // CHECK-X64-NEXT:      |  nvsize=24, nvalign=8]
 
 struct F : virtual B0, virtual B1 {
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct F
+// CHECK-LABEL:   0 | struct F
 // CHECK-NEXT:    0 |   (F vbtable pointer)
 // CHECK-NEXT:    4 |   struct B0 (virtual base)
 // CHECK-NEXT:    4 |     (B0 vftable pointer)
 // CHECK-NEXT:    8 |     int a
 // CHECK-NEXT:   12 |   struct B1 (virtual base)
 // CHECK-NEXT:   12 |     (B1 vftable pointer)
 // CHECK-NEXT:   16 |     int a
 // CHECK-NEXT:      | [sizeof=20, align=4
 // CHECK-NEXT:      |  nvsize=4, nvalign=4]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct F
+// CHECK-X64-LABEL:   0 | struct F
 // CHECK-X64-NEXT:    0 |   (F vbtable pointer)
 // CHECK-X64-NEXT:    8 |   struct B0 (virtual base)
 // CHECK-X64-NEXT:    8 |     (B0 vftable pointer)
 // CHECK-X64-NEXT:   16 |     int a
 // CHECK-X64-NEXT:   24 |   struct B1 (virtual base)
 // CHECK-X64-NEXT:   24 |     (B1 vftable pointer)
 // CHECK-X64-NEXT:   32 |     int a
 // CHECK-X64-NEXT:      | [sizeof=40, align=8
 // CHECK-X64-NEXT:      |  nvsize=8, nvalign=8]
 
 struct AX : B0X, B1X { int a; AX() : a(0xf000000A) {} virtual void f() { printf("A"); } };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct AX
+// CHECK-LABEL:   0 | struct AX
 // CHECK-NEXT:    0 |   struct B1X (primary base)
 // CHECK-NEXT:    0 |     (B1X vftable pointer)
 // CHECK-NEXT:    4 |     int a
 // CHECK-NEXT:    8 |   struct B0X (base)
 // CHECK-NEXT:    8 |     int a
 // CHECK-NEXT:   12 |   int a
 // CHECK-NEXT:      | [sizeof=16, align=4
 // CHECK-NEXT:      |  nvsize=16, nvalign=4]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct AX
+// CHECK-X64-LABEL:   0 | struct AX
 // CHECK-X64-NEXT:    0 |   struct B1X (primary base)
 // CHECK-X64-NEXT:    0 |     (B1X vftable pointer)
 // CHECK-X64-NEXT:    8 |     int a
 // CHECK-X64-NEXT:   16 |   struct B0X (base)
 // CHECK-X64-NEXT:   16 |     int a
 // CHECK-X64-NEXT:   20 |   int a
 // CHECK-X64-NEXT:      | [sizeof=24, align=8
 // CHECK-X64-NEXT:      |  nvsize=24, nvalign=8]
 
 struct BX : B0X, B1X { int a; BX() : a(0xf000000B) {} virtual void g() { printf("B"); } };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct BX
+// CHECK-LABEL:   0 | struct BX
 // CHECK-NEXT:    0 |   struct B1X (primary base)
 // CHECK-NEXT:    0 |     (B1X vftable pointer)
 // CHECK-NEXT:    4 |     int a
 // CHECK-NEXT:    8 |   struct B0X (base)
 // CHECK-NEXT:    8 |     int a
 // CHECK-NEXT:   12 |   int a
 // CHECK-NEXT:      | [sizeof=16, align=4
 // CHECK-NEXT:      |  nvsize=16, nvalign=4]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct BX
+// CHECK-X64-LABEL:   0 | struct BX
 // CHECK-X64-NEXT:    0 |   struct B1X (primary base)
 // CHECK-X64-NEXT:    0 |     (B1X vftable pointer)
 // CHECK-X64-NEXT:    8 |     int a
 // CHECK-X64-NEXT:   16 |   struct B0X (base)
 // CHECK-X64-NEXT:   16 |     int a
 // CHECK-X64-NEXT:   20 |   int a
 // CHECK-X64-NEXT:      | [sizeof=24, align=8
 // CHECK-X64-NEXT:      |  nvsize=24, nvalign=8]
 
 struct CX : B0X, B2X { int a; CX() : a(0xf000000C) {} virtual void g() { printf("C"); } };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct CX
+// CHECK-LABEL:   0 | struct CX
 // CHECK-NEXT:    0 |   (CX vftable pointer)
 // CHECK-NEXT:    4 |   struct B0X (base)
 // CHECK-NEXT:    4 |     int a
 // CHECK-NEXT:    8 |   struct B2X (base)
 // CHECK-NEXT:    8 |     (B2X vbtable pointer)
 // CHECK-NEXT:   12 |     int a
 // CHECK-NEXT:   16 |   int a
 // CHECK-NEXT:   20 |   struct B1X (virtual base)
 // CHECK-NEXT:   20 |     (B1X vftable pointer)
 // CHECK-NEXT:   24 |     int a
 // CHECK-NEXT:      | [sizeof=28, align=4
 // CHECK-NEXT:      |  nvsize=20, nvalign=4]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct CX
+// CHECK-X64-LABEL:   0 | struct CX
 // CHECK-X64-NEXT:    0 |   (CX vftable pointer)
 // CHECK-X64-NEXT:    8 |   struct B0X (base)
 // CHECK-X64-NEXT:    8 |     int a
 // CHECK-X64-NEXT:   16 |   struct B2X (base)
 // CHECK-X64-NEXT:   16 |     (B2X vbtable pointer)
 // CHECK-X64-NEXT:   24 |     int a
 // CHECK-X64-NEXT:   32 |   int a
 // CHECK-X64-NEXT:   40 |   struct B1X (virtual base)
 // CHECK-X64-NEXT:   40 |     (B1X vftable pointer)
 // CHECK-X64-NEXT:   48 |     int a
 // CHECK-X64-NEXT:      | [sizeof=56, align=8
 // CHECK-X64-NEXT:      |  nvsize=40, nvalign=8]
 
 struct DX : virtual B1X { int a; DX() : a(0xf000000D) {} virtual void f() { printf("D"); } };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct DX
+// CHECK-LABEL:   0 | struct DX
 // CHECK-NEXT:    0 |   (DX vbtable pointer)
 // CHECK-NEXT:    4 |   int a
 // CHECK-NEXT:    8 |   (vtordisp for vbase B1X)
 // CHECK-NEXT:   12 |   struct B1X (virtual base)
 // CHECK-NEXT:   12 |     (B1X vftable pointer)
 // CHECK-NEXT:   16 |     int a
 // CHECK-NEXT:      | [sizeof=20, align=4
 // CHECK-NEXT:      |  nvsize=8, nvalign=4]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct DX
+// CHECK-X64-LABEL:   0 | struct DX
 // CHECK-X64-NEXT:    0 |   (DX vbtable pointer)
 // CHECK-X64-NEXT:    8 |   int a
 // CHECK-X64-NEXT:   20 |   (vtordisp for vbase B1X)
 // CHECK-X64-NEXT:   24 |   struct B1X (virtual base)
 // CHECK-X64-NEXT:   24 |     (B1X vftable pointer)
 // CHECK-X64-NEXT:   32 |     int a
 // CHECK-X64-NEXT:      | [sizeof=40, align=8
 // CHECK-X64-NEXT:      |  nvsize=16, nvalign=8]
 
 struct EX : virtual B1X { int a; EX() : a(0xf000000E) {} virtual void g() { printf("E"); } };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct EX
+// CHECK-LABEL:   0 | struct EX
 // CHECK-NEXT:    0 |   (EX vftable pointer)
 // CHECK-NEXT:    4 |   (EX vbtable pointer)
 // CHECK-NEXT:    8 |   int a
 // CHECK-NEXT:   12 |   struct B1X (virtual base)
 // CHECK-NEXT:   12 |     (B1X vftable pointer)
 // CHECK-NEXT:   16 |     int a
 // CHECK-NEXT:      | [sizeof=20, align=4
 // CHECK-NEXT:      |  nvsize=12, nvalign=4]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct EX
+// CHECK-X64-LABEL:   0 | struct EX
 // CHECK-X64-NEXT:    0 |   (EX vftable pointer)
 // CHECK-X64-NEXT:    8 |   (EX vbtable pointer)
 // CHECK-X64-NEXT:   16 |   int a
 // CHECK-X64-NEXT:   24 |   struct B1X (virtual base)
 // CHECK-X64-NEXT:   24 |     (B1X vftable pointer)
 // CHECK-X64-NEXT:   32 |     int a
 // CHECK-X64-NEXT:      | [sizeof=40, align=8
 // CHECK-X64-NEXT:      |  nvsize=24, nvalign=8]
 
 struct FX : virtual B1X { int a; FX() : a(0xf000000F) {} };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct FX
+// CHECK-LABEL:   0 | struct FX
 // CHECK-NEXT:    0 |   (FX vbtable pointer)
 // CHECK-NEXT:    4 |   int a
 // CHECK-NEXT:    8 |   struct B1X (virtual base)
 // CHECK-NEXT:    8 |     (B1X vftable pointer)
 // CHECK-NEXT:   12 |     int a
 // CHECK-NEXT:      | [sizeof=16, align=4
 // CHECK-NEXT:      |  nvsize=8, nvalign=4]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct FX
+// CHECK-X64-LABEL:   0 | struct FX
 // CHECK-X64-NEXT:    0 |   (FX vbtable pointer)
 // CHECK-X64-NEXT:    8 |   int a
 // CHECK-X64-NEXT:   16 |   struct B1X (virtual base)
 // CHECK-X64-NEXT:   16 |     (B1X vftable pointer)
 // CHECK-X64-NEXT:   24 |     int a
 // CHECK-X64-NEXT:      | [sizeof=32, align=8
 // CHECK-X64-NEXT:      |  nvsize=16, nvalign=8]
 

clang/test/Layout/ms-x86-vfvb-alignment.cpp

 // RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fms-extensions -fdump-record-layouts -fsyntax-only %s 2>&1 \
-// RUN:            | FileCheck %s
+// RUN:            | FileCheck %s --strict-whitespace
 // RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fms-extensions -fdump-record-layouts -fsyntax-only %s 2>/dev/null \
-// RUN:            | FileCheck %s -check-prefix CHECK-X64
+// RUN:            | FileCheck %s -check-prefix CHECK-X64 --strict-whitespace
 
 extern "C" int printf(const char *fmt, ...);
 
 struct B0 { int a; B0() : a(0xf00000B0) {} };
 struct B1 { char a; B1() : a(0xB1) {} };
 struct B2 : virtual B1 { int a; B2() : a(0xf00000B2) {} };
 struct B3 { __declspec(align(16)) int a; B3() : a(0xf00000B3) {} };
 struct B4 : virtual B3 { int a; B4() : a(0xf00000B4) {} };
 struct B5 { __declspec(align(32)) int a; B5() : a(0xf00000B5) {} };
 struct B6 { int a; B6() : a(0xf00000B6) {} virtual void f() { printf("B6"); } };
 
 struct A : B0, virtual B1 { __declspec(align(16)) int a; A() : a(0xf000000A) {} virtual void f() { printf("A"); } };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct A
+// CHECK-LABEL:   0 | struct A
 // CHECK-NEXT:    0 |   (A vftable pointer)
 // CHECK-NEXT:   16 |   struct B0 (base)
 // CHECK-NEXT:   16 |     int a
 // CHECK-NEXT:   20 |   (A vbtable pointer)
 // CHECK-NEXT:   48 |   int a
 // CHECK-NEXT:   64 |   struct B1 (virtual base)
 // CHECK-NEXT:   64 |     char a
 // CHECK-NEXT:      | [sizeof=80, align=16
 // CHECK-NEXT:      |  nvsize=64, nvalign=16]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct A
+// CHECK-X64-LABEL:   0 | struct A
 // CHECK-X64-NEXT:    0 |   (A vftable pointer)
 // CHECK-X64-NEXT:   16 |   struct B0 (base)
 // CHECK-X64-NEXT:   16 |     int a
 // CHECK-X64-NEXT:   24 |   (A vbtable pointer)
 // CHECK-X64-NEXT:   48 |   int a
 // CHECK-X64-NEXT:   64 |   struct B1 (virtual base)
 // CHECK-X64-NEXT:   64 |     char a
 // CHECK-X64-NEXT:      | [sizeof=80, align=16
 // CHECK-X64-NEXT:      |  nvsize=64, nvalign=16]
 
+struct C : B4 {
+  int a;
+  C() : a(0xf000000C) {}
+  virtual void f() { printf("C"); }
+};
+
+// CHECK-LABEL:   0 | struct C
+// CHECK-NEXT:    0 |   (C vftable pointer)
+// CHECK-NEXT:   16 |   struct B4 (base)
+// CHECK-NEXT:   16 |     (B4 vbtable pointer)
+// CHECK-NEXT:   20 |     int a
+// CHECK-NEXT:   24 |   int a
+// CHECK-NEXT:   32 |   struct B3 (virtual base)
+// CHECK-NEXT:   32 |     int a
+// CHECK-NEXT:      | [sizeof=48, align=16
+// CHECK-NEXT:      |  nvsize=32, nvalign=16]
+// CHECK-X64-LABEL:   0 | struct C
+// CHECK-X64-NEXT:    0 |   (C vftable pointer)
+// CHECK-X64-NEXT:   16 |   struct B4 (base)
+// CHECK-X64-NEXT:   16 |     (B4 vbtable pointer)
+// CHECK-X64-NEXT:   24 |     int a
+// CHECK-X64-NEXT:   32 |   int a
+// CHECK-X64-NEXT:   48 |   struct B3 (virtual base)
+// CHECK-X64-NEXT:   48 |     int a
+// CHECK-X64-NEXT:      | [sizeof=64, align=16
+// CHECK-X64-NEXT:      |  nvsize=48, nvalign=16]
+
+struct K {
+  int a;
+  K() : a(0xf0000013) {}
+  virtual void f() { printf("K"); }
+};
+
+// CHECK-LABEL:   0 | struct K
+// CHECK-NEXT:    0 |   (K vftable pointer)
+// CHECK-NEXT:    4 |   int a
+// CHECK-NEXT:      | [sizeof=8, align=4
+// CHECK-NEXT:      |  nvsize=8, nvalign=4]
+// CHECK-X64-LABEL:   0 | struct K
+// CHECK-X64-NEXT:    0 |   (K vftable pointer)
+// CHECK-X64-NEXT:    8 |   int a
+// CHECK-X64-NEXT:      | [sizeof=16, align=8
+// CHECK-X64-NEXT:      |  nvsize=16, nvalign=8]
+
 struct B : A, B2 { int a; B() : a(0xf000000B) {} virtual void f() { printf("B"); } };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct B
+// CHECK-LABEL:   0 | struct B{{$}}
 // CHECK-NEXT:    0 |   struct A (primary base)
 // CHECK-NEXT:    0 |     (A vftable pointer)
 // CHECK-NEXT:   16 |     struct B0 (base)
 // CHECK-NEXT:   16 |       int a
 // CHECK-NEXT:   20 |     (A vbtable pointer)
 // CHECK-NEXT:   48 |     int a
 // CHECK-NEXT:   64 |   struct B2 (base)
 // CHECK-NEXT:   64 |     (B2 vbtable pointer)
 // CHECK-NEXT:   68 |     int a
 // CHECK-NEXT:   72 |   int a
 // CHECK-NEXT:   80 |   struct B1 (virtual base)
 // CHECK-NEXT:   80 |     char a
 // CHECK-NEXT:      | [sizeof=96, align=16
 // CHECK-NEXT:      |  nvsize=80, nvalign=16]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct B
+// CHECK-X64-LABEL:   0 | struct B{{$}}
 // CHECK-X64-NEXT:    0 |   struct A (primary base)
 // CHECK-X64-NEXT:    0 |     (A vftable pointer)
 // CHECK-X64-NEXT:   16 |     struct B0 (base)
 // CHECK-X64-NEXT:   16 |       int a
 // CHECK-X64-NEXT:   24 |     (A vbtable pointer)
 // CHECK-X64-NEXT:   48 |     int a
 // CHECK-X64-NEXT:   64 |   struct B2 (base)
 // CHECK-X64-NEXT:   64 |     (B2 vbtable pointer)
 // CHECK-X64-NEXT:   72 |     int a
 // CHECK-X64-NEXT:   80 |   int a
 // CHECK-X64-NEXT:   96 |   struct B1 (virtual base)
 // CHECK-X64-NEXT:   96 |     char a
 // CHECK-X64-NEXT:      | [sizeof=112, align=16
 // CHECK-X64-NEXT:      |  nvsize=96, nvalign=16]
 
-struct C : B4 { int a; C() : a(0xf000000C) {} virtual void f() { printf("C"); } };
-
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct C
-// CHECK-NEXT:    0 |   (C vftable pointer)
-// CHECK-NEXT:   16 |   struct B4 (base)
-// CHECK-NEXT:   16 |     (B4 vbtable pointer)
-// CHECK-NEXT:   20 |     int a
-// CHECK-NEXT:   24 |   int a
-// CHECK-NEXT:   32 |   struct B3 (virtual base)
-// CHECK-NEXT:   32 |     int a
-// CHECK-NEXT:      | [sizeof=48, align=16
-// CHECK-NEXT:      |  nvsize=32, nvalign=16]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct C
-// CHECK-X64-NEXT:    0 |   (C vftable pointer)
-// CHECK-X64-NEXT:   16 |   struct B4 (base)
-// CHECK-X64-NEXT:   16 |     (B4 vbtable pointer)
-// CHECK-X64-NEXT:   24 |     int a
-// CHECK-X64-NEXT:   32 |   int a
-// CHECK-X64-NEXT:   48 |   struct B3 (virtual base)
-// CHECK-X64-NEXT:   48 |     int a
-// CHECK-X64-NEXT:      | [sizeof=64, align=16
-// CHECK-X64-NEXT:      |  nvsize=48, nvalign=16]
-
 struct D : C { int a; D() : a(0xf000000D) {} virtual void f() { printf("D"); } };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct D
+// CHECK-LABEL:   0 | struct D
 // CHECK-NEXT:    0 |   struct C (primary base)
 // CHECK-NEXT:    0 |     (C vftable pointer)
 // CHECK-NEXT:   16 |     struct B4 (base)
 // CHECK-NEXT:   16 |       (B4 vbtable pointer)
 // CHECK-NEXT:   20 |       int a
 // CHECK-NEXT:   24 |     int a
 // CHECK-NEXT:   32 |   int a
 // CHECK-NEXT:   48 |   struct B3 (virtual base)
 // CHECK-NEXT:   48 |     int a
 // CHECK-NEXT:      | [sizeof=64, align=16
 // CHECK-NEXT:      |  nvsize=48, nvalign=16]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct D
+// CHECK-X64-LABEL:   0 | struct D
 // CHECK-X64-NEXT:    0 |   struct C (primary base)
 // CHECK-X64-NEXT:    0 |     (C vftable pointer)
 // CHECK-X64-NEXT:   16 |     struct B4 (base)
 // CHECK-X64-NEXT:   16 |       (B4 vbtable pointer)
 // CHECK-X64-NEXT:   24 |       int a
 // CHECK-X64-NEXT:   32 |     int a
 // CHECK-X64-NEXT:   48 |   int a
 // CHECK-X64-NEXT:   64 |   struct B3 (virtual base)
 // CHECK-X64-NEXT:   64 |     int a
 // CHECK-X64-NEXT:      | [sizeof=80, align=16
 // CHECK-X64-NEXT:      |  nvsize=64, nvalign=16]
 
 struct E : virtual C { int a; E() : a(0xf000000E) {} virtual void f() { printf("E"); } };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct E
+// CHECK-LABEL:   0 | struct E
 // CHECK-NEXT:    0 |   (E vbtable pointer)
 // CHECK-NEXT:    4 |   int a
 // CHECK-NEXT:   16 |   struct B3 (virtual base)
 // CHECK-NEXT:   16 |     int a
 // CHECK-NEXT:   44 |   (vtordisp for vbase C)
 // CHECK-NEXT:   48 |   struct C (virtual base)
 // CHECK-NEXT:   48 |     (C vftable pointer)
 // CHECK-NEXT:   64 |     struct B4 (base)
 // CHECK-NEXT:   64 |       (B4 vbtable pointer)
 // CHECK-NEXT:   68 |       int a
 // CHECK-NEXT:   72 |     int a
 // CHECK-NEXT:      | [sizeof=80, align=16
 // CHECK-NEXT:      |  nvsize=8, nvalign=16]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct E
+// CHECK-X64-LABEL:   0 | struct E
 // CHECK-X64-NEXT:    0 |   (E vbtable pointer)
 // CHECK-X64-NEXT:    8 |   int a
 // CHECK-X64-NEXT:   16 |   struct B3 (virtual base)
 // CHECK-X64-NEXT:   16 |     int a
 // CHECK-X64-NEXT:   44 |   (vtordisp for vbase C)
 // CHECK-X64-NEXT:   48 |   struct C (virtual base)
 // CHECK-X64-NEXT:   48 |     (C vftable pointer)
 // CHECK-X64-NEXT:   64 |     struct B4 (base)
 // CHECK-X64-NEXT:   64 |       (B4 vbtable pointer)
 // CHECK-X64-NEXT:   72 |       int a
 // CHECK-X64-NEXT:   80 |     int a
 // CHECK-X64-NEXT:      | [sizeof=96, align=16
 // CHECK-X64-NEXT:      |  nvsize=16, nvalign=16]
 
 struct F : B3, virtual B0 { int a; F() : a(0xf000000F) {} virtual void f() { printf("F"); } };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct F
+// CHECK-LABEL:   0 | struct F
 // CHECK-NEXT:    0 |   (F vftable pointer)
 // CHECK-NEXT:   16 |   struct B3 (base)
 // CHECK-NEXT:   16 |     int a
 // CHECK-NEXT:   32 |   (F vbtable pointer)
 // CHECK-NEXT:   48 |   int a
 // CHECK-NEXT:   64 |   struct B0 (virtual base)
 // CHECK-NEXT:   64 |     int a
 // CHECK-NEXT:      | [sizeof=80, align=16
 // CHECK-NEXT:      |  nvsize=64, nvalign=16]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct F
+// CHECK-X64-LABEL:   0 | struct F
 // CHECK-X64-NEXT:    0 |   (F vftable pointer)
 // CHECK-X64-NEXT:   16 |   struct B3 (base)
 // CHECK-X64-NEXT:   16 |     int a
 // CHECK-X64-NEXT:   32 |   (F vbtable pointer)
 // CHECK-X64-NEXT:   48 |   int a
 // CHECK-X64-NEXT:   64 |   struct B0 (virtual base)
 // CHECK-X64-NEXT:   64 |     int a
 // CHECK-X64-NEXT:      | [sizeof=80, align=16
 // CHECK-X64-NEXT:      |  nvsize=64, nvalign=16]
 
 struct G : B2, B6, virtual B1 { int a; G() : a(0xf0000010) {} };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct G
+// CHECK-LABEL:   0 | struct G
 // CHECK-NEXT:    0 |   struct B6 (primary base)
 // CHECK-NEXT:    0 |     (B6 vftable pointer)
 // CHECK-NEXT:    4 |     int a
 // CHECK-NEXT:    8 |   struct B2 (base)
 // CHECK-NEXT:    8 |     (B2 vbtable pointer)
 // CHECK-NEXT:   12 |     int a
 // CHECK-NEXT:   16 |   int a
 // CHECK-NEXT:   20 |   struct B1 (virtual base)
 // CHECK-NEXT:   20 |     char a
 // CHECK-NEXT:      | [sizeof=21, align=4
 // CHECK-NEXT:      |  nvsize=20, nvalign=4]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct G
+// CHECK-X64-LABEL:   0 | struct G
 // CHECK-X64-NEXT:    0 |   struct B6 (primary base)
 // CHECK-X64-NEXT:    0 |     (B6 vftable pointer)
 // CHECK-X64-NEXT:    8 |     int a
 // CHECK-X64-NEXT:   16 |   struct B2 (base)
 // CHECK-X64-NEXT:   16 |     (B2 vbtable pointer)
 // CHECK-X64-NEXT:   24 |     int a
 // CHECK-X64-NEXT:   32 |   int a
 // CHECK-X64-NEXT:   40 |   struct B1 (virtual base)
 // CHECK-X64-NEXT:   40 |     char a
 // CHECK-X64-NEXT:      | [sizeof=48, align=8
 // CHECK-X64-NEXT:      |  nvsize=40, nvalign=8]
 
 struct H : B6, B2, virtual B1 { int a; H() : a(0xf0000011) {} };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct H
+// CHECK-LABEL:   0 | struct H
 // CHECK-NEXT:    0 |   struct B6 (primary base)
 // CHECK-NEXT:    0 |     (B6 vftable pointer)
 // CHECK-NEXT:    4 |     int a
 // CHECK-NEXT:    8 |   struct B2 (base)
 // CHECK-NEXT:    8 |     (B2 vbtable pointer)
 // CHECK-NEXT:   12 |     int a
 // CHECK-NEXT:   16 |   int a
 // CHECK-NEXT:   20 |   struct B1 (virtual base)
 // CHECK-NEXT:   20 |     char a
 // CHECK-NEXT:      | [sizeof=21, align=4
 // CHECK-NEXT:      |  nvsize=20, nvalign=4]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct H
+// CHECK-X64-LABEL:   0 | struct H
 // CHECK-X64-NEXT:    0 |   struct B6 (primary base)
 // CHECK-X64-NEXT:    0 |     (B6 vftable pointer)
 // CHECK-X64-NEXT:    8 |     int a
 // CHECK-X64-NEXT:   16 |   struct B2 (base)
 // CHECK-X64-NEXT:   16 |     (B2 vbtable pointer)
 // CHECK-X64-NEXT:   24 |     int a
 // CHECK-X64-NEXT:   32 |   int a
 // CHECK-X64-NEXT:   40 |   struct B1 (virtual base)
 // CHECK-X64-NEXT:   40 |     char a
 // CHECK-X64-NEXT:      | [sizeof=48, align=8
 // CHECK-X64-NEXT:      |  nvsize=40, nvalign=8]
 
 struct I : B0, virtual B1 { int a; int a1; __declspec(align(16)) int a2; I() : a(0xf0000011), a1(0xf0000011), a2(0xf0000011) {} };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct I
+// CHECK-LABEL:   0 | struct I
 // CHECK-NEXT:    0 |   struct B0 (base)
 // CHECK-NEXT:    0 |     int a
 // CHECK-NEXT:    4 |   (I vbtable pointer)
 // CHECK-NEXT:   20 |   int a
 // CHECK-NEXT:   24 |   int a1
 // CHECK-NEXT:   32 |   int a2
 // CHECK-NEXT:   48 |   struct B1 (virtual base)
 // CHECK-NEXT:   48 |     char a
 // CHECK-NEXT:      | [sizeof=64, align=16
 // CHECK-NEXT:      |  nvsize=48, nvalign=16]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct I
+// CHECK-X64-LABEL:   0 | struct I
 // CHECK-X64-NEXT:    0 |   struct B0 (base)
 // CHECK-X64-NEXT:    0 |     int a
 // CHECK-X64-NEXT:    8 |   (I vbtable pointer)
 // CHECK-X64-NEXT:   20 |   int a
 // CHECK-X64-NEXT:   24 |   int a1
 // CHECK-X64-NEXT:   32 |   int a2
 // CHECK-X64-NEXT:   48 |   struct B1 (virtual base)
 // CHECK-X64-NEXT:   48 |     char a
 // CHECK-X64-NEXT:      | [sizeof=64, align=16
 // CHECK-X64-NEXT:      |  nvsize=48, nvalign=16]
 
 struct J : B0, B3, virtual B1 { int a; int a1; J() : a(0xf0000012), a1(0xf0000012) {} };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct J
+// CHECK-LABEL:   0 | struct J
 // CHECK-NEXT:    0 |   struct B0 (base)
 // CHECK-NEXT:    0 |     int a
 // CHECK-NEXT:   16 |   struct B3 (base)
 // CHECK-NEXT:   16 |     int a
 // CHECK-NEXT:   32 |   (J vbtable pointer)
 // CHECK-NEXT:   48 |   int a
 // CHECK-NEXT:   52 |   int a1
 // CHECK-NEXT:   64 |   struct B1 (virtual base)
 // CHECK-NEXT:   64 |     char a
 // CHECK-NEXT:      | [sizeof=80, align=16
 // CHECK-NEXT:      |  nvsize=64, nvalign=16]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct J
+// CHECK-X64-LABEL:   0 | struct J
 // CHECK-X64-NEXT:    0 |   struct B0 (base)
 // CHECK-X64-NEXT:    0 |     int a
 // CHECK-X64-NEXT:   16 |   struct B3 (base)
 // CHECK-X64-NEXT:   16 |     int a
 // CHECK-X64-NEXT:   32 |   (J vbtable pointer)
 // CHECK-X64-NEXT:   48 |   int a
 // CHECK-X64-NEXT:   52 |   int a1
 // CHECK-X64-NEXT:   64 |   struct B1 (virtual base)
 // CHECK-X64-NEXT:   64 |     char a
 // CHECK-X64-NEXT:      | [sizeof=80, align=16
 // CHECK-X64-NEXT:      |  nvsize=64, nvalign=16]
 
-struct K { int a; K() : a(0xf0000013) {} virtual void f() { printf("K"); } };
-
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct K
-// CHECK-NEXT:    0 |   (K vftable pointer)
-// CHECK-NEXT:    4 |   int a
-// CHECK-NEXT:      | [sizeof=8, align=4
-// CHECK-NEXT:      |  nvsize=8, nvalign=4]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct K
-// CHECK-X64-NEXT:    0 |   (K vftable pointer)
-// CHECK-X64-NEXT:    8 |   int a
-// CHECK-X64-NEXT:      | [sizeof=16, align=8
-// CHECK-X64-NEXT:      |  nvsize=16, nvalign=8]
-
 struct L : virtual K { int a; L() : a(0xf0000014) {} virtual void g() { printf("L"); } };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct L
+// CHECK-LABEL:   0 | struct L
 // CHECK-NEXT:    0 |   (L vftable pointer)
 // CHECK-NEXT:    4 |   (L vbtable pointer)
 // CHECK-NEXT:    8 |   int a
 // CHECK-NEXT:   12 |   struct K (virtual base)
 // CHECK-NEXT:   12 |     (K vftable pointer)
 // CHECK-NEXT:   16 |     int a
 // CHECK-NEXT:      | [sizeof=20, align=4
 // CHECK-NEXT:      |  nvsize=12, nvalign=4]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct L
+// CHECK-X64-LABEL:   0 | struct L
 // CHECK-X64-NEXT:    0 |   (L vftable pointer)
 // CHECK-X64-NEXT:    8 |   (L vbtable pointer)
 // CHECK-X64-NEXT:   16 |   int a
 // CHECK-X64-NEXT:   24 |   struct K (virtual base)
 // CHECK-X64-NEXT:   24 |     (K vftable pointer)
 // CHECK-X64-NEXT:   32 |     int a
 // CHECK-X64-NEXT:      | [sizeof=40, align=8
 // CHECK-X64-NEXT:      |  nvsize=24, nvalign=8]
 
 struct M : virtual K { int a; M() : a(0xf0000015) {} virtual void f() { printf("M"); } };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct M
+// CHECK-LABEL:   0 | struct M
 // CHECK-NEXT:    0 |   (M vbtable pointer)
 // CHECK-NEXT:    4 |   int a
 // CHECK-NEXT:    8 |   (vtordisp for vbase K)
 // CHECK-NEXT:   12 |   struct K (virtual base)
 // CHECK-NEXT:   12 |     (K vftable pointer)
 // CHECK-NEXT:   16 |     int a
 // CHECK-NEXT:      | [sizeof=20, align=4
 // CHECK-NEXT:      |  nvsize=8, nvalign=4]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct M
+// CHECK-X64-LABEL:   0 | struct M
 // CHECK-X64-NEXT:    0 |   (M vbtable pointer)
 // CHECK-X64-NEXT:    8 |   int a
 // CHECK-X64-NEXT:   20 |   (vtordisp for vbase K)
 // CHECK-X64-NEXT:   24 |   struct K (virtual base)
 // CHECK-X64-NEXT:   24 |     (K vftable pointer)
 // CHECK-X64-NEXT:   32 |     int a
 // CHECK-X64-NEXT:      | [sizeof=40, align=8
 // CHECK-X64-NEXT:      |  nvsize=16, nvalign=8]

clang/test/Layout/ms-x86-vfvb-sharing.cpp

 // RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple i686-pc-win32 -fms-extensions -fdump-record-layouts -fsyntax-only %s 2>&1 \
-// RUN:            | FileCheck %s
+// RUN:            | FileCheck %s --strict-whitespace
 // RUN: %clang_cc1 -fno-rtti -emit-llvm-only -triple x86_64-pc-win32 -fms-extensions -fdump-record-layouts -fsyntax-only %s 2>/dev/null \
-// RUN:            | FileCheck %s -check-prefix CHECK-X64
+// RUN:            | FileCheck %s -check-prefix CHECK-X64 --strict-whitespace
 
 extern "C" int printf(const char *fmt, ...);
 
 struct B0 { int a; B0() : a(0xf00000B0) { printf("B0 = %p\n", this); } };
 struct B1 { int a; B1() : a(0xf00000B1) { printf("B1 = %p\n", this); } };
 struct B2 { B2() { printf("B2 = %p\n", this); } virtual void g() { printf("B2"); } };
 struct B3 : virtual B1 { B3() { printf("B3 = %p\n", this); } };
 struct B4 : virtual B1 { B4() { printf("B4 = %p\n", this); } virtual void g() { printf("B4"); } };
 
 struct A : B0, virtual B1 {
   __declspec(align(16)) int a;
   A() : a(0xf000000A) { printf(" A = %p\n\n", this); }
   virtual void f() { printf("A"); }
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct A
+// CHECK-LABEL:   0 | struct A
 // CHECK-NEXT:    0 |   (A vftable pointer)
 // CHECK-NEXT:   16 |   struct B0 (base)
 // CHECK-NEXT:   16 |     int a
 // CHECK-NEXT:   20 |   (A vbtable pointer)
 // CHECK-NEXT:   48 |   int a
 // CHECK-NEXT:   64 |   struct B1 (virtual base)
 // CHECK-NEXT:   64 |     int a
 // CHECK-NEXT:      | [sizeof=80, align=16
 // CHECK-NEXT:      |  nvsize=64, nvalign=16]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct A
+// CHECK-X64-LABEL:   0 | struct A
 // CHECK-X64-NEXT:    0 |   (A vftable pointer)
 // CHECK-X64-NEXT:   16 |   struct B0 (base)
 // CHECK-X64-NEXT:   16 |     int a
 // CHECK-X64-NEXT:   24 |   (A vbtable pointer)
 // CHECK-X64-NEXT:   48 |   int a
 // CHECK-X64-NEXT:   64 |   struct B1 (virtual base)
 // CHECK-X64-NEXT:   64 |     int a
 // CHECK-X64-NEXT:      | [sizeof=80, align=16
 // CHECK-X64-NEXT:      |  nvsize=64, nvalign=16]
 
 struct B : B2, B0, virtual B1 {
   __declspec(align(16)) int a;
   B() : a(0xf000000B) { printf(" B = %p\n\n", this); }
   virtual void f() { printf("B"); }
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct B
+// CHECK-LABEL:   0 | struct B{{$}}
 // CHECK-NEXT:    0 |   struct B2 (primary base)
 // CHECK-NEXT:    0 |     (B2 vftable pointer)
 // CHECK-NEXT:    4 |   struct B0 (base)
 // CHECK-NEXT:    4 |     int a
 // CHECK-NEXT:    8 |   (B vbtable pointer)
 // CHECK-NEXT:   32 |   int a
 // CHECK-NEXT:   48 |   struct B1 (virtual base)
 // CHECK-NEXT:   48 |     int a
 // CHECK-NEXT:      | [sizeof=64, align=16
 // CHECK-NEXT:      |  nvsize=48, nvalign=16]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct B
+// CHECK-X64-LABEL:   0 | struct B{{$}}
 // CHECK-X64-NEXT:    0 |   struct B2 (primary base)
 // CHECK-X64-NEXT:    0 |     (B2 vftable pointer)
 // CHECK-X64-NEXT:    8 |   struct B0 (base)
 // CHECK-X64-NEXT:    8 |     int a
 // CHECK-X64-NEXT:   16 |   (B vbtable pointer)
 // CHECK-X64-NEXT:   32 |   int a
 // CHECK-X64-NEXT:   48 |   struct B1 (virtual base)
 // CHECK-X64-NEXT:   48 |     int a
 // CHECK-X64-NEXT:      | [sizeof=64, align=16
 // CHECK-X64-NEXT:      |  nvsize=48, nvalign=16]
 
 struct C : B3, B0, virtual B1 {
   __declspec(align(16)) int a;
   C() : a(0xf000000C) { printf(" C = %p\n\n", this); }
   virtual void f() { printf("C"); }
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct C
+// CHECK-LABEL:   0 | struct C
 // CHECK-NEXT:    0 |   (C vftable pointer)
 // CHECK-NEXT:   16 |   struct B3 (base)
 // CHECK-NEXT:   16 |     (B3 vbtable pointer)
 // CHECK-NEXT:   20 |   struct B0 (base)
 // CHECK-NEXT:   20 |     int a
 // CHECK-NEXT:   32 |   int a
 // CHECK-NEXT:   48 |   struct B1 (virtual base)
 // CHECK-NEXT:   48 |     int a
 // CHECK-NEXT:      | [sizeof=64, align=16
 // CHECK-NEXT:      |  nvsize=48, nvalign=16]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct C
+// CHECK-X64-LABEL:   0 | struct C
 // CHECK-X64-NEXT:    0 |   (C vftable pointer)
 // CHECK-X64-NEXT:   16 |   struct B3 (base)
 // CHECK-X64-NEXT:   16 |     (B3 vbtable pointer)
 // CHECK-X64-NEXT:   24 |   struct B0 (base)
 // CHECK-X64-NEXT:   24 |     int a
 // CHECK-X64-NEXT:   32 |   int a
 // CHECK-X64-NEXT:   48 |   struct B1 (virtual base)
 // CHECK-X64-NEXT:   48 |     int a
 // CHECK-X64-NEXT:      | [sizeof=64, align=16
 // CHECK-X64-NEXT:      |  nvsize=48, nvalign=16]
 
 struct D : B4, B0, virtual B1 {
   __declspec(align(16)) int a;
   D() : a(0xf000000D) { printf(" D = %p\n\n", this); }
   virtual void f() { printf("D"); }
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct D
+// CHECK-LABEL:   0 | struct D
 // CHECK-NEXT:    0 |   struct B4 (primary base)
 // CHECK-NEXT:    0 |     (B4 vftable pointer)
 // CHECK-NEXT:    4 |     (B4 vbtable pointer)
 // CHECK-NEXT:    8 |   struct B0 (base)
 // CHECK-NEXT:    8 |     int a
 // CHECK-NEXT:   16 |   int a
 // CHECK-NEXT:   32 |   struct B1 (virtual base)
 // CHECK-NEXT:   32 |     int a
 // CHECK-NEXT:      | [sizeof=48, align=16
 // CHECK-NEXT:      |  nvsize=32, nvalign=16]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct D
+// CHECK-X64-LABEL:   0 | struct D
 // CHECK-X64-NEXT:    0 |   struct B4 (primary base)
 // CHECK-X64-NEXT:    0 |     (B4 vftable pointer)
 // CHECK-X64-NEXT:    8 |     (B4 vbtable pointer)
 // CHECK-X64-NEXT:   16 |   struct B0 (base)
 // CHECK-X64-NEXT:   16 |     int a
 // CHECK-X64-NEXT:   32 |   int a
 // CHECK-X64-NEXT:   48 |   struct B1 (virtual base)
 // CHECK-X64-NEXT:   48 |     int a
 // CHECK-X64-NEXT:      | [sizeof=64, align=16
 // CHECK-X64-NEXT:      |  nvsize=48, nvalign=16]
 
 int a[
 sizeof(A)+
 sizeof(B)+
 sizeof(C)+
 sizeof(D)];

clang/test/Layout/ms-x86-vtordisp.cpp

 
 struct A : virtual B0, virtual B1 {
   int a;
   A() : a(0xf000000A) {}
   virtual void f() { printf("A"); }
   virtual void g() { printf("A"); }
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct A
+// CHECK-LABEL:   0 | struct A{{$}}
 // CHECK-NEXT:    0 |   (A vftable pointer)
 // CHECK-NEXT:    4 |   (A vbtable pointer)
 // CHECK-NEXT:    8 |   int a
 // CHECK-NEXT:   16 |   (vtordisp for vbase B0)
 // CHECK-NEXT:   20 |   struct B0 (virtual base)
 // CHECK-NEXT:   20 |     (B0 vftable pointer)
 // CHECK-NEXT:   24 |     int a
 // CHECK-NEXT:   44 |   (vtordisp for vbase B1)
 // CHECK-NEXT:   48 |   struct B1 (virtual base)
 // CHECK-NEXT:   48 |     (B1 vftable pointer)
 // CHECK-NEXT:   52 |     int a
 // CHECK-NEXT:      | [sizeof=64, align=16
 // CHECK-NEXT:      |  nvsize=12, nvalign=16]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct A
+// CHECK-X64-LABEL:   0 | struct A{{$}}
 // CHECK-X64-NEXT:    0 |   (A vftable pointer)
 // CHECK-X64-NEXT:    8 |   (A vbtable pointer)
 // CHECK-X64-NEXT:   16 |   int a
 // CHECK-X64-NEXT:   36 |   (vtordisp for vbase B0)
 // CHECK-X64-NEXT:   40 |   struct B0 (virtual base)
 // CHECK-X64-NEXT:   40 |     (B0 vftable pointer)
 // CHECK-X64-NEXT:   48 |     int a
 // CHECK-X64-NEXT:   76 |   (vtordisp for vbase B1)
 // CHECK-X64-NEXT:   80 |   struct B1 (virtual base)
 // CHECK-X64-NEXT:   80 |     (B1 vftable pointer)
 // CHECK-X64-NEXT:   88 |     int a
 // CHECK-X64-NEXT:      | [sizeof=96, align=16
 // CHECK-X64-NEXT:      |  nvsize=24, nvalign=16]
 
 struct C : virtual B0, virtual B1, VAlign32 {
   int a;
   C() : a(0xf000000C) {}
   virtual void f() { printf("C"); }
   virtual void g() { printf("C"); }
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct C
+// CHECK-LABEL:   0 | struct C{{$}}
 // CHECK-NEXT:    0 |   (C vftable pointer)
 // CHECK-NEXT:   32 |   struct VAlign32 (base)
 // CHECK-NEXT:   32 |     (VAlign32 vbtable pointer)
 // CHECK-NEXT:   36 |   int a
 // CHECK-NEXT:   64 |   (vtordisp for vbase B0)
 // CHECK-NEXT:   68 |   struct B0 (virtual base)
 // CHECK-NEXT:   68 |     (B0 vftable pointer)
 // CHECK-NEXT:   72 |     int a
 // CHECK-NEXT:  108 |   (vtordisp for vbase B1)
 // CHECK-NEXT:  112 |   struct B1 (virtual base)
 // CHECK-NEXT:  112 |     (B1 vftable pointer)
 // CHECK-NEXT:  116 |     int a
 // CHECK-NEXT:  128 |   struct Align32 (virtual base) (empty)
 // CHECK-NEXT:      | [sizeof=128, align=32
 // CHECK-NEXT:      |  nvsize=64, nvalign=32]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct C
+// CHECK-X64-LABEL:   0 | struct C{{$}}
 // CHECK-X64-NEXT:    0 |   (C vftable pointer)
 // CHECK-X64-NEXT:   32 |   struct VAlign32 (base)
 // CHECK-X64-NEXT:   32 |     (VAlign32 vbtable pointer)
 // CHECK-X64-NEXT:   40 |   int a
 // CHECK-X64-NEXT:   68 |   (vtordisp for vbase B0)
 // CHECK-X64-NEXT:   72 |   struct B0 (virtual base)
 // CHECK-X64-NEXT:   72 |     (B0 vftable pointer)
 // CHECK-X64-NEXT:   80 |     int a
 // CHECK-X64-NEXT:  108 |   (vtordisp for vbase B1)
 // CHECK-X64-NEXT:  112 |   struct B1 (virtual base)
 // CHECK-X64-NEXT:  112 |     (B1 vftable pointer)
 // CHECK-X64-NEXT:  120 |     int a
 // CHECK-X64-NEXT:  128 |   struct Align32 (virtual base) (empty)
 // CHECK-X64-NEXT:      | [sizeof=128, align=32
 // CHECK-X64-NEXT:      |  nvsize=64, nvalign=32]
 
 struct __declspec(align(32)) D : virtual B0, virtual B1  {
   int a;
   D() : a(0xf000000D) {}
   virtual void f() { printf("D"); }
   virtual void g() { printf("D"); }
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct D
+// CHECK-LABEL:   0 | struct D{{$}}
 // CHECK-NEXT:    0 |   (D vftable pointer)
 // CHECK-NEXT:    4 |   (D vbtable pointer)
 // CHECK-NEXT:    8 |   int a
 // CHECK-NEXT:   32 |   (vtordisp for vbase B0)
 // CHECK-NEXT:   36 |   struct B0 (virtual base)
 // CHECK-NEXT:   36 |     (B0 vftable pointer)
 // CHECK-NEXT:   40 |     int a
 // CHECK-NEXT:   76 |   (vtordisp for vbase B1)
 // CHECK-NEXT:   80 |   struct B1 (virtual base)
 // CHECK-NEXT:   80 |     (B1 vftable pointer)
 // CHECK-NEXT:   84 |     int a
 // CHECK-NEXT:      | [sizeof=96, align=32
 // CHECK-NEXT:      |  nvsize=12, nvalign=32]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct D
+// CHECK-X64-LABEL:   0 | struct D{{$}}
 // CHECK-X64-NEXT:    0 |   (D vftable pointer)
 // CHECK-X64-NEXT:    8 |   (D vbtable pointer)
 // CHECK-X64-NEXT:   16 |   int a
 // CHECK-X64-NEXT:   36 |   (vtordisp for vbase B0)
 // CHECK-X64-NEXT:   40 |   struct B0 (virtual base)
 // CHECK-X64-NEXT:   40 |     (B0 vftable pointer)
 // CHECK-X64-NEXT:   48 |     int a
 // CHECK-X64-NEXT:   76 |   (vtordisp for vbase B1)
 // CHECK-X64-NEXT:   80 |   struct B1 (virtual base)
 // CHECK-X64-NEXT:   80 |     (B1 vftable pointer)
 // CHECK-X64-NEXT:   88 |     int a
 // CHECK-X64-NEXT:      | [sizeof=96, align=32
 // CHECK-X64-NEXT:      |  nvsize=24, nvalign=32]
 
 struct AT {
   virtual ~AT(){}
 };
 struct CT : virtual AT {
   virtual ~CT();
 };
 CT::~CT(){}
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct CT
+// CHECK-LABEL:   0 | struct CT{{$}}
 // CHECK-NEXT:    0 |   (CT vbtable pointer)
 // CHECK-NEXT:    4 |   struct AT (virtual base)
 // CHECK-NEXT:    4 |     (AT vftable pointer)
 // CHECK-NEXT:      | [sizeof=8, align=4
 // CHECK-NEXT:      |  nvsize=4, nvalign=4]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct CT
+// CHECK-X64-LABEL:   0 | struct CT{{$}}
 // CHECK-X64-NEXT:    0 |   (CT vbtable pointer)
 // CHECK-X64-NEXT:    8 |   struct AT (virtual base)
 // CHECK-X64-NEXT:    8 |     (AT vftable pointer)
 // CHECK-X64-NEXT:      | [sizeof=16, align=8
 // CHECK-X64-NEXT:      |  nvsize=8, nvalign=8]
 
 struct XA {
   XA() { printf("XA"); }
   long long ll;
 };
 struct XB : XA {
   XB() { printf("XB"); }
   virtual void foo() {}
   int b;
 };
 struct XC : virtual XB {
   XC() { printf("XC"); }
   virtual void foo() {}
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct XC
+// CHECK-LABEL:   0 | struct XC{{$}}
 // CHECK-NEXT:    0 |   (XC vbtable pointer)
 // CHECK-NEXT:    4 |   (vtordisp for vbase XB)
 // CHECK-NEXT:    8 |   struct XB (virtual base)
 // CHECK-NEXT:    8 |     (XB vftable pointer)
 // CHECK-NEXT:   16 |     struct XA (base)
 // CHECK-NEXT:   16 |       long long ll
 // CHECK-NEXT:   24 |     int b
 // CHECK-NEXT:      | [sizeof=32, align=8
 // CHECK-NEXT:      |  nvsize=4, nvalign=8]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct XC
+// CHECK-X64-LABEL:   0 | struct XC{{$}}
 // CHECK-X64-NEXT:    0 |   (XC vbtable pointer)
 // CHECK-X64-NEXT:   12 |   (vtordisp for vbase XB)
 // CHECK-X64-NEXT:   16 |   struct XB (virtual base)
 // CHECK-X64-NEXT:   16 |     (XB vftable pointer)
 // CHECK-X64-NEXT:   24 |     struct XA (base)
 // CHECK-X64-NEXT:   24 |       long long ll
 // CHECK-X64-NEXT:   32 |     int b
 // CHECK-X64-NEXT:      | [sizeof=40, align=8
 // CHECK-X64-NEXT:      |  nvsize=8, nvalign=8]
 
 namespace pragma_test1 {
 // No overrides means no vtordisps by default.
 struct A { virtual ~A(); virtual void foo(); int a; };
 struct B : virtual A { virtual ~B(); virtual void bar(); int b; };
 struct C : virtual B { int c; };
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct pragma_test1::C
+// CHECK-LABEL:   0 | struct pragma_test1::C{{$}}
 // CHECK-NEXT:    0 |   (C vbtable pointer)
 // CHECK-NEXT:    4 |   int c
 // CHECK-NEXT:    8 |   struct pragma_test1::A (virtual base)
 // CHECK-NEXT:    8 |     (A vftable pointer)
 // CHECK-NEXT:   12 |     int a
 // CHECK-NEXT:   16 |   struct pragma_test1::B (virtual base)
 // CHECK-NEXT:   16 |     (B vftable pointer)
 // CHECK-NEXT:   20 |     (B vbtable pointer)
 // CHECK-NEXT:   24 |     int b
 // CHECK-NEXT:      | [sizeof=28, align=4
 // CHECK-NEXT:      |  nvsize=8, nvalign=4]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
 }
 
 namespace pragma_test2 {
 struct A { virtual ~A(); virtual void foo(); int a; };
 #pragma vtordisp(push,2)
 struct B : virtual A { virtual ~B(); virtual void bar(); int b; };
 struct C : virtual B { int c; };
 #pragma vtordisp(pop)
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct pragma_test2::C
+// CHECK-LABEL:   0 | struct pragma_test2::C{{$}}
 // CHECK-NEXT:    0 |   (C vbtable pointer)
 // CHECK-NEXT:    4 |   int c
 // CHECK-NEXT:    8 |   (vtordisp for vbase A)
 // CHECK-NEXT:   12 |   struct pragma_test2::A (virtual base)
 // CHECK-NEXT:   12 |     (A vftable pointer)
 // CHECK-NEXT:   16 |     int a
 //   By adding a virtual method and vftable to B, now we need a vtordisp.
 // CHECK-NEXT:   20 |   (vtordisp for vbase B)
 // CHECK-NEXT:   24 |   struct pragma_test2::B (virtual base)
 // CHECK-NEXT:   24 |     (B vftable pointer)
 // CHECK-NEXT:   28 |     (B vbtable pointer)
 // CHECK-NEXT:   32 |     int b
 // CHECK-NEXT:      | [sizeof=36, align=4
 // CHECK-NEXT:      |  nvsize=8, nvalign=4]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
 }
 
 namespace pragma_test3 {
 struct A { virtual ~A(); virtual void foo(); int a; };
 #pragma vtordisp(push,2)
 struct B : virtual A { virtual ~B(); virtual void foo(); int b; };
 struct C : virtual B { int c; };
 #pragma vtordisp(pop)
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct pragma_test3::C
+// CHECK-LABEL:   0 | struct pragma_test3::C{{$}}
 // CHECK-NEXT:    0 |   (C vbtable pointer)
 // CHECK-NEXT:    4 |   int c
 // CHECK-NEXT:    8 |   (vtordisp for vbase A)
 // CHECK-NEXT:   12 |   struct pragma_test3::A (virtual base)
 // CHECK-NEXT:   12 |     (A vftable pointer)
 // CHECK-NEXT:   16 |     int a
 //   No vtordisp before B!  It doesn't have its own vftable.
 // CHECK-NEXT:   20 |   struct pragma_test3::B (virtual base)
 // CHECK-NEXT:   20 |     (B vbtable pointer)
 // CHECK-NEXT:   24 |     int b
 // CHECK-NEXT:      | [sizeof=28, align=4
 // CHECK-NEXT:      |  nvsize=8, nvalign=4]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
 }
 
 namespace pragma_test4 {
 struct A {
   A();
   virtual void foo();
   int a;
 };
 
 // Make sure the pragma applies to class template decls before they've been
 // instantiated.
 #pragma vtordisp(push,2)
 template <typename T>
 struct B : virtual A {
   B();
   virtual ~B();
   virtual void bar();
   T b;
 };
 #pragma vtordisp(pop)
 
 struct C : virtual B<int> { int c; };
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct pragma_test4::C
+// CHECK-LABEL:   0 | struct pragma_test4::C{{$}}
 // CHECK-NEXT:    0 |   (C vbtable pointer)
 // CHECK-NEXT:    4 |   int c
 //   Pragma applies to B, which has vbase A.
 // CHECK-NEXT:    8 |   (vtordisp for vbase A)
 // CHECK-NEXT:   12 |   struct pragma_test4::A (virtual base)
 // CHECK-NEXT:   12 |     (A vftable pointer)
 // CHECK-NEXT:   16 |     int a
 //   Pragma does not apply to C, and B doesn't usually need a vtordisp in C.
 // CHECK-NEXT:   20 |   struct pragma_test4::B<int> (virtual base)
 // CHECK-NEXT:   20 |     (B vftable pointer)
 // CHECK-NEXT:   24 |     (B vbtable pointer)
 // CHECK-NEXT:   28 |     int b
 // CHECK-NEXT:      | [sizeof=32, align=4
 // CHECK-NEXT:      |  nvsize=8, nvalign=4]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
 }
 
 struct GA {
   virtual void fun() {}
 };
 struct GB: public GA {};
 struct GC: public virtual GA {
   virtual void fun() {}
   GC() {}
 };
 struct GD: public virtual GC, public virtual GB {};
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct GD
+// CHECK-LABEL:   0 | struct GD{{$}}
 // CHECK-NEXT:    0 |   (GD vbtable pointer)
 // CHECK-NEXT:    4 |   (vtordisp for vbase GA)
 // CHECK-NEXT:    8 |   struct GA (virtual base)
 // CHECK-NEXT:    8 |     (GA vftable pointer)
 // CHECK-NEXT:   12 |   struct GC (virtual base)
 // CHECK-NEXT:   12 |     (GC vbtable pointer)
 // CHECK-NEXT:   16 |   struct GB (virtual base)
 // CHECK-NEXT:   16 |     struct GA (primary base)
 // CHECK-NEXT:   16 |       (GA vftable pointer)
 // CHECK-NEXT:      | [sizeof=20, align=4
 // CHECK-NEXT:      |  nvsize=4, nvalign=4]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct GD
+// CHECK-X64-LABEL:   0 | struct GD{{$}}
 // CHECK-X64-NEXT:    0 |   (GD vbtable pointer)
 // CHECK-X64-NEXT:   12 |   (vtordisp for vbase GA)
 // CHECK-X64-NEXT:   16 |   struct GA (virtual base)
 // CHECK-X64-NEXT:   16 |     (GA vftable pointer)
 // CHECK-X64-NEXT:   24 |   struct GC (virtual base)
 // CHECK-X64-NEXT:   24 |     (GC vbtable pointer)
 // CHECK-X64-NEXT:   32 |   struct GB (virtual base)
 // CHECK-X64-NEXT:   32 |     struct GA (primary base)
 // CHECK-X64-NEXT:   32 |       (GA vftable pointer)
 // CHECK-X64-NEXT:      | [sizeof=40, align=8
 // CHECK-X64-NEXT:      |  nvsize=8, nvalign=8]
 
 struct HA {
   virtual void fun() {}
 };
 #pragma vtordisp(push, 2)
 struct HB : virtual HA {};
 #pragma vtordisp(pop)
 #pragma vtordisp(push, 0)
 struct HC : virtual HB {};
 #pragma vtordisp(pop)
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct HC
+// CHECK-LABEL:   0 | struct HC{{$}}
 // CHECK-NEXT:    0 |   (HC vbtable pointer)
 // CHECK-NEXT:    4 |   (vtordisp for vbase HA)
 // CHECK-NEXT:    8 |   struct HA (virtual base)
 // CHECK-NEXT:    8 |     (HA vftable pointer)
 // CHECK-NEXT:   12 |   struct HB (virtual base)
 // CHECK-NEXT:   12 |     (HB vbtable pointer)
 // CHECK-NEXT:      | [sizeof=16, align=4
 // CHECK-NEXT:      |  nvsize=4, nvalign=4]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct HC
+// CHECK-X64-LABEL:   0 | struct HC{{$}}
 // CHECK-X64-NEXT:    0 |   (HC vbtable pointer)
 // CHECK-X64-NEXT:   12 |   (vtordisp for vbase HA)
 // CHECK-X64-NEXT:   16 |   struct HA (virtual base)
 // CHECK-X64-NEXT:   16 |     (HA vftable pointer)
 // CHECK-X64-NEXT:   24 |   struct HB (virtual base)
 // CHECK-X64-NEXT:   24 |     (HB vbtable pointer)
 // CHECK-X64-NEXT:      | [sizeof=32, align=8
 // CHECK-X64-NEXT:      |  nvsize=8, nvalign=8]
 
 struct IA {
   virtual void f();
 };
 struct __declspec(dllexport) IB : virtual IA {
   virtual void f() = 0;
   IB() {}
 };
 
-// CHECK: *** Dumping AST Record Layout
-// CHECK: *** Dumping AST Record Layout
-// CHECK-NEXT:    0 | struct IB
+// CHECK-LABEL:   0 | struct IB{{$}}
 // CHECK-NEXT:    0 |   (IB vbtable pointer)
 // CHECK-NEXT:    4 |   struct IA (virtual base)
 // CHECK-NEXT:    4 |     (IA vftable pointer)
 // CHECK-NEXT:      | [sizeof=8, align=4
 // CHECK-NEXT:      |  nvsize=4, nvalign=4]
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64: *** Dumping AST Record Layout
-// CHECK-X64-NEXT:    0 | struct IB
+// CHECK-X64-LABEL:   0 | struct IB{{$}}
 // CHECK-X64-NEXT:    0 |   (IB vbtable pointer)
 // CHECK-X64-NEXT:    8 |   struct IA (virtual base)
 // CHECK-X64-NEXT:    8 |     (IA vftable pointer)
 // CHECK-X64-NEXT:      | [sizeof=16, align=8
 // CHECK-X64-NEXT:      |  nvsize=8, nvalign=8]
 
 int a[
 sizeof(A)+

clang/test/Sema/ms_class_layout.cpp

 // RUN: %clang_cc1 -emit-llvm-only -triple i686-pc-win32 -fdump-record-layouts %s 2>/dev/null \
-// RUN:            | FileCheck %s
+// RUN:            | FileCheck %s --strict-whitespace
 
 #pragma pack(push, 8)
 
 class B {
 public:
   virtual void b(){}
   int b_field;
 protected:
int main() {
   O* o;
   P* p;
   R* r;
   sd *h;
   EV *j;
   return 0;
 }
 
-// CHECK:       0 | class D
-// CHECK-NEXT:  0 |   (D vftable pointer)
-// CHECK-NEXT:  8 |   double a
-
-// CHECK-NEXT: sizeof=16, align=8
-// CHECK-NEXT: nvsize=16, nvalign=8
-
-// CHECK: %class.D = type { i32 (...)**, double }
-
-// CHECK:       0 | class B
+// CHECK-LABEL: 0 | class B{{$}}
 // CHECK-NEXT:  0 |   (B vftable pointer)
 // CHECK-NEXT:  4 |   int b_field
 
 // CHECK-NEXT: sizeof=8, align=4
 // CHECK-NEXT: nvsize=8, nvalign=4
 
-// CHECK: %class.B = type { i32 (...)**, i32 }
-
-// CHECK:       0 | class A
+// CHECK-LABEL: 0 | class A{{$}}
 // CHECK-NEXT:  0 |   class B (primary base)
 // CHECK-NEXT:  0 |     (B vftable pointer)
 // CHECK-NEXT:  4 |     int b_field
 // CHECK-NEXT:  8 |   int a_field
 // CHECK-NEXT: 12 |   char one
 
 // CHECK-NEXT: sizeof=16, align=4
 // CHECK-NEXT: nvsize=16, nvalign=4
 
-// CHECK:       0 | class C
+// CHECK-LABEL: 0 | class D{{$}}
+// CHECK-NEXT:  0 |   (D vftable pointer)
+// CHECK-NEXT:  8 |   double a
+
+// CHECK-NEXT: sizeof=16, align=8
+// CHECK-NEXT: nvsize=16, nvalign=8
+
+// CHECK-LABEL: 0 | class C{{$}}
 // CHECK-NEXT:  0 |   class D (primary base)
 // CHECK-NEXT:  0 |     (D vftable pointer)
 // CHECK-NEXT:  8 |     double a
 // CHECK-NEXT: 16 |   class B (base)
 // CHECK-NEXT: 16 |     (B vftable pointer)
 // CHECK-NEXT: 20 |     int b_field
 // CHECK-NEXT: 24 |   (C vbtable pointer)
 // CHECK-NEXT: 32 |   double c1_field
 // CHECK-NEXT: 40 |   int c2_field
 // CHECK-NEXT: 48 |   double c3_field
 // CHECK-NEXT: 56 |   int c4_field
 // CHECK-NEXT: 64 |   class A (virtual base)
 // CHECK-NEXT: 64 |     class B (primary base)
 // CHECK-NEXT: 64 |       (B vftable pointer)
 // CHECK-NEXT: 68 |       int b_field
 // CHECK-NEXT: 72 |     int a_field
 // CHECK-NEXT: 76 |     char one
 
 // CHECK-NEXT: sizeof=80, align=8
 // CHECK-NEXT: nvsize=64, nvalign=8
 
+// CHECK: %class.D = type { i32 (...)**, double }
+
+// CHECK: %class.B = type { i32 (...)**, i32 }
+
 // CHECK: %class.A = type { %class.B, i32, i8 }
 
 // CHECK: %class.C = type { %class.D, %class.B, i32*, double, i32, double, i32, [4 x i8], %class.A }
 // CHECK: %class.C.base = type { %class.D, %class.B, i32*, double, i32, double, i32 }
 
-// CHECK:       0 | struct BaseStruct
+// CHECK-LABEL: 0 | struct BaseStruct{{$}}
 // CHECK-NEXT:  0 |   double v0
 // CHECK-NEXT:  8 |   float v1
 // CHECK-NEXT: 16 |   class C fg
 // CHECK-NEXT: 16 |     class D (primary base)
 // CHECK-NEXT: 16 |       (D vftable pointer)
 // CHECK-NEXT: 24 |       double a
 // CHECK-NEXT: 32 |     class B (base)
 // CHECK-NEXT: 32 |       (B vftable pointer)

 // CHECK-NEXT: 84 |         int b_field
 // CHECK-NEXT: 88 |       int a_field
 // CHECK-NEXT: 92 |       char one
 // CHECK-NEXT: sizeof=96, align=8
 // CHECK-NEXT: nvsize=96, nvalign=8
 
 // CHECK: %struct.BaseStruct = type { double, float, %class.C }
 
-// CHECK:       0 | struct DerivedStruct
+// CHECK-LABEL: 0 | struct DerivedStruct{{$}}
 // CHECK-NEXT:  0 |   struct BaseStruct (base)
 // CHECK-NEXT:  0 |     double v0
 // CHECK-NEXT:  8 |     float v1
 // CHECK-NEXT: 16 |     class C fg
 // CHECK-NEXT: 16 |       class D (primary base)
 // CHECK-NEXT: 16 |         (D vftable pointer)
 // CHECK-NEXT: 24 |         double a
 // CHECK-NEXT: 32 |       class B (base)

 // CHECK-NEXT: 88 |         int a_field
 // CHECK-NEXT: 92 |         char one
 // CHECK-NEXT: 96 |   int x
 // CHECK-NEXT: sizeof=104, align=8
 // CHECK-NEXT: nvsize=104, nvalign=8
 
 // CHECK: %struct.DerivedStruct = type { %struct.BaseStruct, i32 }
 
-// CHECK:      0 | struct G
+// CHECK-LABEL:0 | struct G
 // CHECK-NEXT: 0 |   int g_field
 // CHECK-NEXT: sizeof=4, align=4
 // CHECK-NEXT: nvsize=4, nvalign=4
 
-// CHECK:       0 | struct H
+// CHECK-LABEL: 0 | struct H{{$}}
 // CHECK-NEXT:  0 |   struct G (base)
 // CHECK-NEXT:  0 |     int g_field
 // CHECK-NEXT:  4 |   (H vbtable pointer)
 // CHECK-NEXT:  8 |   class D (virtual base)
 // CHECK-NEXT:  8 |     (D vftable pointer)
 // CHECK-NEXT: 16 |     double a
 // CHECK-NEXT: sizeof=24, align=8
 // CHECK-NEXT: nvsize=8, nvalign=8
 
 // CHECK: %struct.H = type { %struct.G, i32*, %class.D }
 
-// CHECK:       0 | struct I
+// CHECK-LABEL: 0 | struct I{{$}}
 // CHECK-NEXT:  0 |   (I vftable pointer)
 // CHECK-NEXT:  8 |   (I vbtable pointer)
 // CHECK-NEXT: 16 |   double q
 // CHECK-NEXT: 24 |   class D (virtual base)
 // CHECK-NEXT: 24 |     (D vftable pointer)
 // CHECK-NEXT: 32 |     double a
 // CHECK-NEXT: sizeof=40, align=8
 // CHECK-NEXT: nvsize=24, nvalign=8
 
 // CHECK: %struct.I = type { i32 (...)**, [4 x i8], i32*, double, %class.D }
 // CHECK: %struct.I.base = type { i32 (...)**, [4 x i8], i32*, double }
 
-// CHECK:       0 | struct L
+// CHECK-LABEL: 0 | struct L{{$}}
 // CHECK-NEXT:  0 |   int l
 // CHECK-NEXT: sizeof=4, align=4
 // CHECK-NEXT: nvsize=4, nvalign=4
 
-// CHECK:       0 | struct K
+// CHECK-LABEL: 0 | struct K{{$}}
 // CHECK-NEXT:  0 |   int k
 // CHECK-NEXT: sizeof=4, align=4
 // CHECK-NEXT: nvsize=4, nvalign=4
 
-// CHECK:       0 | struct M
+// CHECK-LABEL: 0 | struct M{{$}}
 // CHECK-NEXT:  0 |   (M vbtable pointer)
 // CHECK-NEXT:  4 |   int m
 // CHECK-NEXT:  8 |   struct K (virtual base)
 // CHECK-NEXT:  8 |     int k
 // CHECK-NEXT: sizeof=12, align=4
 
 //CHECK: %struct.M = type { i32*, i32, %struct.K }
 //CHECK: %struct.M.base = type { i32*, i32 }
 
-// CHECK:       0 | struct N
+// CHECK-LABEL: 0 | struct N{{$}}
 // CHECK-NEXT:  0 |   (N vftable pointer)
 // CHECK-NEXT:  4 |   struct L (base)
 // CHECK-NEXT:  4 |     int l
 // CHECK-NEXT:  8 |   struct M (base)
 // CHECK-NEXT:  8 |     (M vbtable pointer)
 // CHECK-NEXT: 12 |     int m
 // CHECK-NEXT: 16 |   struct K (virtual base)
 // CHECK-NEXT: 16 |     int k
 // CHECK-NEXT: sizeof=20, align=4
 // CHECK-NEXT: nvsize=16, nvalign=4
 
 //CHECK: %struct.N = type { i32 (...)**, %struct.L, %struct.M.base, %struct.K }
 
-// CHECK:       0 | struct O
+// CHECK-LABEL: 0 | struct O{{$}}
 // CHECK-NEXT:  0 |   (O vftable pointer)
 // CHECK-NEXT:  8 |   struct H (base)
 // CHECK-NEXT:  8 |     struct G (base)
 // CHECK-NEXT:  8 |       int g_field
 // CHECK-NEXT: 12 |     (H vbtable pointer)
 // CHECK-NEXT: 16 |   struct G (base)
 // CHECK-NEXT: 16 |     int g_field
 // CHECK-NEXT: 24 |   class D (virtual base)
 // CHECK-NEXT: 24 |     (D vftable pointer)
 // CHECK-NEXT: 32 |     double a
 // CHECK-NEXT:    | [sizeof=40, align=8
 // CHECK-NEXT:    |  nvsize=24, nvalign=8]
 
 // CHECK: struct.O = type { i32 (...)**, [4 x i8], %struct.H.base, %struct.G, %class.D }
 // CHECK: struct.O.base = type { i32 (...)**, [4 x i8], %struct.H.base, %struct.G, [4 x i8] }
 
-
-// CHECK:       0 | struct P
+// CHECK-LABEL: 0 | struct P{{$}}
 // CHECK-NEXT:  0 |   struct M (base)
 // CHECK-NEXT:  0 |     (M vbtable pointer)
 // CHECK-NEXT:  4 |     int m
 // CHECK-NEXT:  8 |   int p
 // CHECK-NEXT: 12 |   struct K (virtual base)
 // CHECK-NEXT: 12 |     int k
 // CHECK-NEXT: 16 |   struct L (virtual base)
 // CHECK-NEXT: 16 |     int l
 // CHECK-NEXT: sizeof=20, align=4
 // CHECK-NEXT: nvsize=12, nvalign=4
 
 //CHECK: %struct.P = type { %struct.M.base, i32, %struct.K, %struct.L }
 
-// CHECK:       0 | struct R (empty)
+// CHECK-LABEL: 0 | struct R (empty){{$}}
 // CHECK-NEXT:  sizeof=1, align=1
 // CHECK-NEXT:  nvsize=0, nvalign=1
 
 //CHECK: %struct.R = type { i8 }
 
-// CHECK:       0 | struct f
+// CHECK-LABEL: 0 | struct f{{$}}
 // CHECK-NEXT:  0 |   (f vftable pointer)
 // CHECK-NEXT: sizeof=4, align=4
 // CHECK-NEXT: nvsize=4, nvalign=4
 
-// CHECK:       0 | struct s
+// CHECK-LABEL: 0 | struct s{{$}}
 // CHECK-NEXT:  0 |   (s vftable pointer)
 // CHECK-NEXT:  4 |   (s vbtable pointer)
 // CHECK-NEXT:  8 |   int r
 // CHECK-NEXT: 12 |   (vtordisp for vbase f)
 // CHECK-NEXT: 16 |   struct f (virtual base)
 // CHECK-NEXT: 16 |     (f vftable pointer)
 // CHECK-NEXT: sizeof=20, align=4
 // CHECK-NEXT: nvsize=12, nvalign=4
 
-// CHECK:       0 | class IA
+// CHECK-LABEL: 0 | class IA{{$}}
 // CHECK-NEXT:  0 |   (IA vftable pointer)
 // CHECK-NEXT:  sizeof=4, align=4
 // CHECK-NEXT:  nvsize=4, nvalign=4
-  
-// CHECK:       0 | class ICh
+// CHECK-LABEL: 0 | class ICh{{$}}
 // CHECK-NEXT:  0 |   (ICh vftable pointer)
 // CHECK-NEXT:  4 |   (ICh vbtable pointer)
 // CHECK-NEXT:  8 |   (vtordisp for vbase IA)
 // CHECK-NEXT: 12 |   class IA (virtual base)
 // CHECK-NEXT: 12 |     (IA vftable pointer)
 // CHECK-NEXT: sizeof=16, align=4
 // CHECK-NEXT: nvsize=8, nvalign=4
 
-// CHECK:       0 | struct sd
+// CHECK-LABEL: 0 | struct sd{{$}}
 // CHECK-NEXT:  0 |   (sd vbtable pointer)
 // CHECK-NEXT:  4 |   int q
 // CHECK-NEXT:  8 |   char y
 // CHECK-NEXT: 12 |   (vtordisp for vbase f)
 // CHECK-NEXT: 16 |   struct f (virtual base)
 // CHECK-NEXT: 16 |     (f vftable pointer)
 // CHECK-NEXT: 20 |   struct s (virtual base)
 // CHECK-NEXT: 20 |     (s vftable pointer)

 // CHECK-NEXT: nvsize=12, nvalign=4
 
 // CHECK: %struct.f = type { i32 (...)** }
 // CHECK: %struct.s = type { i32 (...)**, i32*, i32, i32, %struct.f }
 // CHECK: %class.IA = type { i32 (...)** }
 // CHECK: %class.ICh = type { i32 (...)**, i32*, i32, %class.IA }
 // CHECK: %struct.sd = type { i32*, i32, i8, i32, %struct.f, %struct.s.base, i32, %class.IA, %class.ICh.base }
 
-// CHECK:       0 | struct AV
+// CHECK-LABEL: 0 | struct AV{{$}}
 // CHECK-NEXT:  0 |   (AV vftable pointer)
 // CHECK-NEXT: sizeof=4, align=4
 // CHECK-NEXT: nvsize=4, nvalign=4
 
-
-// CHECK:       0 | struct BV
+// CHECK-LABEL: 0 | struct BV{{$}}
 // CHECK-NEXT:  0 |   struct AV (primary base)
 // CHECK-NEXT:  0 |     (AV vftable pointer)
 // CHECK-NEXT: sizeof=4, align=4
 // CHECK-NEXT: nvsize=4, nvalign=4
 
-
-// CHECK:       0 | struct CV
+// CHECK-LABEL: 0 | struct CV{{$}}
 // CHECK-NEXT:  0 |   (CV vbtable pointer)
 // CHECK-NEXT:  4 |   (vtordisp for vbase BV)
 // CHECK-NEXT:  8 |   struct BV (virtual base)
 // CHECK-NEXT:  8 |     struct AV (primary base)
 // CHECK-NEXT:  8 |       (AV vftable pointer)
 // CHECK-NEXT: sizeof=12, align=4
 // CHECK-NEXT: nvsize=4, nvalign=4
 
 // CHECK: %struct.AV = type { i32 (...)** }
 // CHECK: %struct.BV = type { %struct.AV }
 // CHECK: %struct.CV = type { i32*, i32, %struct.BV }
 // CHECK: %struct.CV.base = type { i32* }
 
-// CHECK:       0 | struct DV
+// CHECK-LABEL: 0 | struct DV{{$}}
 // CHECK-NEXT:  0 |   struct BV (primary base)
 // CHECK-NEXT:  0 |     struct AV (primary base)
 // CHECK-NEXT:  0 |       (AV vftable pointer)
 // CHECK-NEXT: sizeof=4, align=4
 // CHECK-NEXT: nvsize=4, nvalign=4
 
 // CHECK: %struct.DV = type { %struct.BV }
 
-// CHECK:       0 | struct EV
+// CHECK-LABEL: 0 | struct EV{{$}}
 // CHECK-NEXT:  0 |   struct DV (primary base)
 // CHECK-NEXT:  0 |     struct BV (primary base)
 // CHECK-NEXT:  0 |       struct AV (primary base)
 // CHECK-NEXT:  0 |         (AV vftable pointer)
 // CHECK-NEXT:  4 |   struct CV (base)
 // CHECK-NEXT:  4 |     (CV vbtable pointer)
 // CHECK-NEXT:  8 |   (vtordisp for vbase BV)
 // CHECK-NEXT: 12 |   struct BV (virtual base)
 // CHECK-NEXT: 12 |     struct AV (primary base)
 // CHECK-NEXT: 12 |       (AV vftable pointer)
 // CHECK-NEXT: sizeof=16, align=4
 // CHECK-NEXT: nvsize=8, nvalign=4
 
 // CHECK: %struct.EV = type { %struct.DV, %struct.CV.base, i32, %struct.BV }
 // CHECK: %struct.EV.base = type { %struct.DV, %struct.CV.base }
 
 // Overriding a method means that all the vbases containing that
 // method need a vtordisp.  Note: this code will cause an error in cl.exe.
 namespace test1 {
   struct A { virtual void foo(); };
   struct B : A {};
   struct C : virtual A, virtual B { C(); virtual void foo(); };
   void test() { C *c; }
 
-// CHECK:        0 | struct test1::C
+  // CHECK-LABEL:  0 | struct test1::C{{$}}
   // CHECK-NEXT:   0 |   (C vbtable pointer)
   // CHECK-NEXT:   4 |   (vtordisp for vbase A)
   // CHECK-NEXT:   8 |   struct test1::A (virtual base)
   // CHECK-NEXT:   8 |     (A vftable pointer)
   // CHECK-NEXT:  12 |   (vtordisp for vbase B)
   // CHECK-NEXT:  16 |   struct test1::B (virtual base)
   // CHECK-NEXT:  16 |     struct test1::A (primary base)
   // CHECK-NEXT:  16 |       (A vftable pointer)
   // CHECK-NEXT:  sizeof=20, align=4
   // CHECK-NEXT:  nvsize=4, nvalign=4
 }