[CodeView] Lower __restrict and other pointer qualifiers correctly

[rnk]

Summary

Qualifiers on a pointer or reference type may apply to either the
pointee or the pointer itself. Consider 'const char *' and 'char *
const'. In the first example, the pointee data may not be modified
without casts, and in the second example, the pointer may not be updated
to point to new data.

In the general case, qualifiers are applied to types with LF_MODIFIER
records, which support the usual const and volatile qualifiers as well
as the __unaligned extension qualifier.

However, LF_POINTER records, which are used for pointers, references,
and member pointers, have flags for qualifiers applying to the
*pointer*. In fact, this is the only way to represent the restrict
qualifier, which can only apply to pointers, and cannot qualify regular
data types.

This patch causes LLVM to correctly fold 'const' and 'volatile' pointer
qualifiers into the pointer record, as well as adding support for
'__restrict' qualifiers in the same place.

Based on a patch from Aaron Smith

[zturner]

+rnk, in the future add him on anything MSABI specific.

[zturner]

s/msabi/codeview/

(I can review too btw, just would suggest adding him also)

[zturner]

include/llvm/DebugInfo/CodeView/CodeView.h

302 ↗

(On Diff #133360)

Can you post a code fragment that I can compile with cl.exe to see this value of 0x0008 being emitted on an LF_MODIFIER CodeView record?

We already have a PointerOptions::Restrict which is a separate enum from ModifierOptions and corresponds to an LF_POINTER record. Are you sure this value is correct?

If I write this code:

struct Foo {
  int x;
};

void foo(Foo &__restrict f) {
  printf("%d", f.x);
}

Then cl generates an LF_POINTER record with the restrict option, but it doesn't generate a corresponding LF_MODIFIER record

$ llvm-pdbutil.exe dump -types restricttest.pdb | grep 0x104C
  0x104C | LF_STRUCTURE [size = 36] `Foo`
           referent = 0x104C, mode = ref, opts = restrict, kind = ptr32

$ llvm-pdbutil.exe dump -types restricttest.pdb | grep -A 1 LF_MODIFIER | grep 0x104C
  (no results)

lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

1268–1269 ↗

(On Diff #133360)

Based on the above hypothesis, is it possible that you need to instead use lowerTypePointer here?

[zturner]

include/llvm/DebugInfo/CodeView/CodeView.h

302 ↗

(On Diff #133360)

1 additional line of grep context for clarity:

$ llvm-pdbutil.exe dump -types restricttest.pdb | grep -B 1 0x104C
           options: has ctor / dtor | contains nested class | has unique name
  0x104C | LF_STRUCTURE [size = 36] `Foo`
--
  0x104D | LF_POINTER [size = 12]
           referent = 0x104C, mode = ref, opts = restrict, kind = ptr32

[zturner]

I should probably defer to @rnk for the main content of the review here.

lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

1514–1516 ↗

(On Diff #133971)

If this is a solution, then do we still need the FIXME?

[rnk]

I patched this in to try to understand why the DenseMap changes were necessary. I don't think they are. I'll grab this and upload a new version in a bit.

[rnk]

• rewrite

[rnk]

I discovered two other bugs while working on this:
https://bugs.llvm.org/show_bug.cgi?id=36526
https://bugs.llvm.org/show_bug.cgi?id=17747

[rnk]

• Remove dead parameters
• Fix a null deref for 'const void'

[Hui]

llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

2143

I am thinking without extra information for the method getTypeIndex, two different DIType, for example, int* and int* __restrict, that having the same Ty, will be hashed with only one key in the DenseMap. So what is returned by finding DenseMap will be whatever is hashed first. This might not be correct. If this thought is right, changing DenseMap is still needed.

[rnk]

llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

2143

The DITypeRef key should encode this information already. In the first case, the key will be a single DW_TAG_pointer_type DIDerivedType node. In the second case, it will be a DW_TAG_restrict_type node wrapping a pointer node.

[Hui]

llvm/test/DebugInfo/COFF/type-quals.ll

14

Could you check the type of p in the test? Should be something like

LocalSym {

  Kind: S_LOCAL (0x113E)
  Type: const int* (0x100E)
  Flags [ (0x0)
  ]
  VarName: p
}

[rnk]

llvm/lib/DebugInfo/CodeView/RecordName.cpp

170–175

I noticed that these should be printed on the right like __restrict. That affects the type-quals.ll test. See also https://llvm.org/pr36541.

[rnk]

• Fix pointer type printing

llvm/include/llvm/DebugInfo/CodeView/TypeRecord.h

public:
   bool isVolatile() const {
     return !!(Attrs & uint32_t(PointerOptions::Volatile));
   }
 
   bool isUnaligned() const {
     return !!(Attrs & uint32_t(PointerOptions::Unaligned));
   }
 
+  bool isRestrict() const {
+    return !!(Attrs & uint32_t(PointerOptions::Restrict));
+  }
+
   TypeIndex ReferentType;
   uint32_t Attrs;
   Optional<MemberPointerInfo> MemberInfo;
 
   void setAttrs(PointerKind PK, PointerMode PM, PointerOptions PO,
                 uint8_t Size) {
     Attrs = calcAttrs(PK, PM, PO, Size);
   }

llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.h

class LLVM_LIBRARY_VISIBILITY CodeViewDebug : public DebugHandlerBase {
   codeview::TypeIndex getVBPTypeIndex();
 
   void addToUDTs(const DIType *Ty);
 
   codeview::TypeIndex lowerType(const DIType *Ty, const DIType *ClassTy);
   codeview::TypeIndex lowerTypeAlias(const DIDerivedType *Ty);
   codeview::TypeIndex lowerTypeArray(const DICompositeType *Ty);
   codeview::TypeIndex lowerTypeBasic(const DIBasicType *Ty);
-  codeview::TypeIndex lowerTypePointer(const DIDerivedType *Ty);
-  codeview::TypeIndex lowerTypeMemberPointer(const DIDerivedType *Ty);
+  codeview::TypeIndex lowerTypePointer(
+      const DIDerivedType *Ty, const DIType *ClassTy,
+      codeview::PointerOptions PO = codeview::PointerOptions::None);
+  codeview::TypeIndex lowerTypeMemberPointer(
+      const DIDerivedType *Ty, const DIType *ClassTy,
+      codeview::PointerOptions PO = codeview::PointerOptions::None);
   codeview::TypeIndex lowerTypeModifier(const DIDerivedType *Ty);
   codeview::TypeIndex lowerTypeFunction(const DISubroutineType *Ty);
   codeview::TypeIndex lowerTypeVFTableShape(const DIDerivedType *Ty);
   codeview::TypeIndex lowerTypeMemberFunction(const DISubroutineType *Ty,
                                               const DIType *ClassTy,
                                               int ThisAdjustment,
                                               bool IsStaticMethod);
   codeview::TypeIndex lowerTypeEnum(const DICompositeType *Ty);
class LLVM_LIBRARY_VISIBILITY CodeViewDebug : public DebugHandlerBase {
   /// structs, classes, and unions. Returns the field list index and the member
   /// count.
   std::tuple<codeview::TypeIndex, codeview::TypeIndex, unsigned, bool>
   lowerRecordFieldList(const DICompositeType *Ty);
 
   /// Inserts {{Node, ClassTy}, TI} into TypeIndices and checks for duplicates.
   codeview::TypeIndex recordTypeIndexForDINode(const DINode *Node,
                                                codeview::TypeIndex TI,
-                                               const DIType *ClassTy = nullptr);
+                                               const DIType *ClassTy = nullptr,
+                                               const DIType *QualTy = nullptr);
 
   unsigned getPointerSizeInBytes();
 
 protected:
   /// \brief Gather pre-function debug information.
   void beginFunctionImpl(const MachineFunction *MF) override;
 
   /// \brief Gather post-function debug information.

llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

TypeIndex CodeViewDebug::getMemberFunctionType(const DISubprogram *SP,
   const bool IsStaticMethod = (SP->getFlags() & DINode::FlagStaticMember) != 0;
   TypeIndex TI = lowerTypeMemberFunction(
       SP->getType(), Class, SP->getThisAdjustment(), IsStaticMethod);
   return recordTypeIndexForDINode(SP, TI, Class);
 }
 
 TypeIndex CodeViewDebug::recordTypeIndexForDINode(const DINode *Node,
                                                   TypeIndex TI,
-                                                  const DIType *ClassTy) {
+                                                  const DIType *ClassTy,
+                                                  const DIType *NodeQualTy) {
   auto InsertResult = TypeIndices.insert({{Node, ClassTy}, TI});
   (void)InsertResult;
   assert(InsertResult.second && "DINode was already assigned a type index");
   return TI;
 }
 
 unsigned CodeViewDebug::getPointerSizeInBytes() {
   return MMI->getModule()->getDataLayout().getPointerSizeInBits() / 8;
TypeIndex CodeViewDebug::lowerType(const DIType *Ty, const DIType *ClassTy) {
   case dwarf::DW_TAG_base_type:
     return lowerTypeBasic(cast<DIBasicType>(Ty));
   case dwarf::DW_TAG_pointer_type:
     if (cast<DIDerivedType>(Ty)->getName() == "__vtbl_ptr_type")
       return lowerTypeVFTableShape(cast<DIDerivedType>(Ty));
     LLVM_FALLTHROUGH;
   case dwarf::DW_TAG_reference_type:
   case dwarf::DW_TAG_rvalue_reference_type:
-    return lowerTypePointer(cast<DIDerivedType>(Ty));
+    return lowerTypePointer(cast<DIDerivedType>(Ty), ClassTy);
   case dwarf::DW_TAG_ptr_to_member_type:
-    return lowerTypeMemberPointer(cast<DIDerivedType>(Ty));
+    return lowerTypeMemberPointer(cast<DIDerivedType>(Ty), ClassTy);
+  case dwarf::DW_TAG_restrict_type:
   case dwarf::DW_TAG_const_type:
   case dwarf::DW_TAG_volatile_type:
   // TODO: add support for DW_TAG_atomic_type here
     return lowerTypeModifier(cast<DIDerivedType>(Ty));
   case dwarf::DW_TAG_subroutine_type:
     if (ClassTy) {
       // The member function type of a member function pointer has no
       // ThisAdjustment.
TypeIndex CodeViewDebug::lowerTypeBasic(const DIBasicType *Ty) {
   if ((STK == SimpleTypeKind::SignedCharacter ||
        STK == SimpleTypeKind::UnsignedCharacter) &&
       Ty->getName() == "char")
     STK = SimpleTypeKind::NarrowCharacter;
 
   return TypeIndex(STK);
 }
 
-TypeIndex CodeViewDebug::lowerTypePointer(const DIDerivedType *Ty) {
+TypeIndex CodeViewDebug::lowerTypePointer(const DIDerivedType *Ty,
+                                          const DIType *ClassTy,
+                                          PointerOptions PO) {
   TypeIndex PointeeTI = getTypeIndex(Ty->getBaseType());
 
-  // Pointers to simple types can use SimpleTypeMode, rather than having a
-  // dedicated pointer type record.
-  if (PointeeTI.isSimple() &&
+  // Pointers to simple types without any options can use SimpleTypeMode, rather
+  // than having a dedicated pointer type record.
+  if (PointeeTI.isSimple() && PO == PointerOptions::None &&
       PointeeTI.getSimpleMode() == SimpleTypeMode::Direct &&
       Ty->getTag() == dwarf::DW_TAG_pointer_type) {
     SimpleTypeMode Mode = Ty->getSizeInBits() == 64
                               ? SimpleTypeMode::NearPointer64
                               : SimpleTypeMode::NearPointer32;
     return TypeIndex(PointeeTI.getSimpleKind(), Mode);
   }
 
   PointerKind PK =
       Ty->getSizeInBits() == 64 ? PointerKind::Near64 : PointerKind::Near32;
   PointerMode PM = PointerMode::Pointer;
   switch (Ty->getTag()) {
   default: llvm_unreachable("not a pointer tag type");
   case dwarf::DW_TAG_pointer_type:
     PM = PointerMode::Pointer;
     break;
   case dwarf::DW_TAG_reference_type:
     PM = PointerMode::LValueReference;
     break;
   case dwarf::DW_TAG_rvalue_reference_type:
     PM = PointerMode::RValueReference;
     break;
   }
-  // FIXME: MSVC folds qualifiers into PointerOptions in the context of a method
-  // 'this' pointer, but not normal contexts. Figure out what we're supposed to
-  // do.
-  PointerOptions PO = PointerOptions::None;
+
   PointerRecord PR(PointeeTI, PK, PM, PO, Ty->getSizeInBits() / 8);
   return TypeTable.writeLeafType(PR);
 }
 
 static PointerToMemberRepresentation
 translatePtrToMemberRep(unsigned SizeInBytes, bool IsPMF, unsigned Flags) {
   // SizeInBytes being zero generally implies that the member pointer type was
   // incomplete, which can happen if it is part of a function prototype. In this
case DINode::FlagMultipleInheritance:
       return PointerToMemberRepresentation::MultipleInheritanceData;
     case DINode::FlagVirtualInheritance:
       return PointerToMemberRepresentation::VirtualInheritanceData;
     }
   }
   llvm_unreachable("invalid ptr to member representation");
 }
 
-TypeIndex CodeViewDebug::lowerTypeMemberPointer(const DIDerivedType *Ty) {
+TypeIndex CodeViewDebug::lowerTypeMemberPointer(const DIDerivedType *Ty,
+                                                const DIType *ClassTy,
+                                                PointerOptions PO) {
   assert(Ty->getTag() == dwarf::DW_TAG_ptr_to_member_type);
   TypeIndex ClassTI = getTypeIndex(Ty->getClassType());
   TypeIndex PointeeTI = getTypeIndex(Ty->getBaseType(), Ty->getClassType());
   PointerKind PK = Asm->TM.getPointerSize() == 8 ? PointerKind::Near64
                                                  : PointerKind::Near32;
   bool IsPMF = isa<DISubroutineType>(Ty->getBaseType());
   PointerMode PM = IsPMF ? PointerMode::PointerToMemberFunction
                          : PointerMode::PointerToDataMember;
-  PointerOptions PO = PointerOptions::None; // FIXME
+
   assert(Ty->getSizeInBits() / 8 <= 0xff && "pointer size too big");
   uint8_t SizeInBytes = Ty->getSizeInBits() / 8;
   MemberPointerInfo MPI(
       ClassTI, translatePtrToMemberRep(SizeInBytes, IsPMF, Ty->getFlags()));
   PointerRecord PR(PointeeTI, PK, PM, PO, SizeInBytes, MPI);
   return TypeTable.writeLeafType(PR);
 }
 
 /// Given a DWARF calling convention, get the CodeView equivalent. If we don't
 /// have a translation, use the NearC convention.
 static CallingConvention dwarfCCToCodeView(unsigned DwarfCC) {
   switch (DwarfCC) {
   case dwarf::DW_CC_normal:             return CallingConvention::NearC;
   case dwarf::DW_CC_BORLAND_msfastcall: return CallingConvention::NearFast;
   case dwarf::DW_CC_BORLAND_thiscall:   return CallingConvention::ThisCall;
   case dwarf::DW_CC_BORLAND_stdcall:    return CallingConvention::NearStdCall;
   case dwarf::DW_CC_BORLAND_pascal:     return CallingConvention::NearPascal;
   case dwarf::DW_CC_LLVM_vectorcall:    return CallingConvention::NearVector;
   }
   return CallingConvention::NearC;
 }
 
 TypeIndex CodeViewDebug::lowerTypeModifier(const DIDerivedType *Ty) {
   ModifierOptions Mods = ModifierOptions::None;
+  PointerOptions PO = PointerOptions::None;
   bool IsModifier = true;
   const DIType *BaseTy = Ty;
   while (IsModifier && BaseTy) {
     // FIXME: Need to add DWARF tags for __unaligned and _Atomic
     switch (BaseTy->getTag()) {
     case dwarf::DW_TAG_const_type:
       Mods |= ModifierOptions::Const;
+      PO |= PointerOptions::Const;
       break;
     case dwarf::DW_TAG_volatile_type:
       Mods |= ModifierOptions::Volatile;
+      PO |= PointerOptions::Volatile;
+      break;
+    case dwarf::DW_TAG_restrict_type:
+      // Only pointer types be marked with __restrict. There is no known flag
+      // for __restrict in LF_MODIFIER records.
+      PO |= PointerOptions::Restrict;
       break;
     default:
       IsModifier = false;
       break;
     }
     if (IsModifier)
       BaseTy = cast<DIDerivedType>(BaseTy)->getBaseType().resolve();
   }
+
+  // Check if the inner type will use an LF_POINTER record. If so, the
+  // qualifiers will go in the LF_POINTER record. This comes up for types like
+  // 'int *const' and 'int *__restrict', not the more common cases like 'const
+  // char *'.
+  switch (BaseTy->getTag()) {
+  case dwarf::DW_TAG_pointer_type:
+  case dwarf::DW_TAG_reference_type:
+  case dwarf::DW_TAG_rvalue_reference_type:
+    return lowerTypePointer(cast<DIDerivedType>(BaseTy), nullptr, PO);
+  case dwarf::DW_TAG_ptr_to_member_type:
+    return lowerTypeMemberPointer(cast<DIDerivedType>(BaseTy), nullptr, PO);
+  default:
+    break;
+  }
+
   TypeIndex ModifiedTI = getTypeIndex(BaseTy);
+
+  // Return the base type index if there aren't any modifiers. For example, the
+  // metadata could contain restrict wrappers around non-pointer types.
+  if (Mods == ModifierOptions::None)
+    return ModifiedTI;
+
   ModifierRecord MR(ModifiedTI, Mods);
   return TypeTable.writeLeafType(MR);
 }
 
 TypeIndex CodeViewDebug::lowerTypeFunction(const DISubroutineType *Ty) {
   SmallVector<TypeIndex, 8> ReturnAndArgTypeIndices;
   for (DITypeRef ArgTypeRef : Ty->getTypeArray())
     ReturnAndArgTypeIndices.push_back(getTypeIndex(ArgTypeRef));
TypeIndex CodeViewDebug::getTypeIndex(DITypeRef TypeRef, DITypeRef ClassTyRef) {
 
   // The null DIType is the void type. Don't try to hash it.
   if (!Ty)
     return TypeIndex::Void();
 
   // Check if we've already translated this type. Don't try to do a
   // get-or-create style insertion that caches the hash lookup across the
   // lowerType call. It will update the TypeIndices map.
   auto I = TypeIndices.find({Ty, ClassTy});
   if (I != TypeIndices.end())
     return I->second;
 
   TypeLoweringScope S(*this);
   TypeIndex TI = lowerType(Ty, ClassTy);
   return recordTypeIndexForDINode(Ty, TI, ClassTy);
 }
 

llvm/lib/DebugInfo/CodeView/RecordName.cpp

Error TypeNameComputer::visitKnownRecord(CVType &CVR, PointerRecord &Ptr) {
 
   if (Ptr.isPointerToMember()) {
     const MemberPointerInfo &MI = Ptr.getMemberInfo();
 
     StringRef Pointee = Types.getTypeName(Ptr.getReferentType());
     StringRef Class = Types.getTypeName(MI.getContainingType());
     Name = formatv("{0} {1}::*", Pointee, Class);
   } else {
     if (Ptr.isConst())
       Name.append("const ");
     if (Ptr.isVolatile())
       Name.append("volatile ");
     if (Ptr.isUnaligned())
       Name.append("__unaligned ");
 
     Name.append(Types.getTypeName(Ptr.getReferentType()));
 
     if (Ptr.getMode() == PointerMode::LValueReference)
       Name.append("&");
     else if (Ptr.getMode() == PointerMode::RValueReference)
       Name.append("&&");
     else if (Ptr.getMode() == PointerMode::Pointer)
       Name.append("*");
+
+    if (Ptr.isRestrict())
+      Name.append(" __restrict");
   }
   return Error::success();
 }
 
 Error TypeNameComputer::visitKnownRecord(CVType &CVR, ModifierRecord &Mod) {
   uint16_t Mods = static_cast<uint16_t>(Mod.getModifiers());
 
   SmallString<256> TypeName;

llvm/lib/DebugInfo/CodeView/TypeDumpVisitor.cpp

Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, PointerRecord &Ptr) {
   W->printEnum("PtrType", unsigned(Ptr.getPointerKind()),
                makeArrayRef(PtrKindNames));
   W->printEnum("PtrMode", unsigned(Ptr.getMode()), makeArrayRef(PtrModeNames));
 
   W->printNumber("IsFlat", Ptr.isFlat());
   W->printNumber("IsConst", Ptr.isConst());
   W->printNumber("IsVolatile", Ptr.isVolatile());
   W->printNumber("IsUnaligned", Ptr.isUnaligned());
+  W->printNumber("IsRestrict", Ptr.isRestrict());
   W->printNumber("SizeOf", Ptr.getSize());
 
   if (Ptr.isPointerToMember()) {
     const MemberPointerInfo &MI = Ptr.getMemberInfo();
 
     printTypeIndex("ClassType", MI.getContainingType());
     W->printEnum("Representation", uint16_t(MI.getRepresentation()),
                  makeArrayRef(PtrMemberRepNames));

llvm/test/DebugInfo/COFF/type-quals.ll

+; RUN: llc < %s -filetype=obj | llvm-readobj - -codeview | FileCheck %s
+
+; C++ source to regenerate:
+; $ cat m.cpp
+; union Union {
+;   int * __restrict x_member;
+;   float * __restrict y_member;
+;   int* volatile __restrict m_volatile;
+; };
+;
+; int f(const volatile int* __restrict arg_crv) {
+;   Union u;
+;   const int *p;
+;   const volatile int v = 0;
+;   return 1;
+; }
+;
+; void g(int& __restrict arg_ref) {
+;   const int x = 10;
+;   const char str[] = "abc";
+; }
+;
+; void h() {
+;   struct Foo {
+;     int a;
+;     int func(int x) __restrict { return 1; } 
+;   };  
+;
+;   Foo s = { 10 };
+;
+;   int* __restrict p_object = &s.a;
+;
+;   int Foo:: * __restrict p_data_member = &Foo::a;
+;
+;   int (Foo::* p_member_func)(int) __restrict = &Foo::func;
+; }
+;
+; $ clang++ m.cpp -S -emit-llvm -g -gcodeview -o m.ll
+
+
+; CHECK: CodeViewTypes [
+; CHECK:   Section: .debug$T (7)
+; CHECK:   Magic: 0x4
+; CHECK:   Modifier (0x1000) {
+; CHECK:     TypeLeafKind: LF_MODIFIER (0x1001)
+; CHECK:     ModifiedType: int (0x74)
+; CHECK:     Modifiers [ (0x3)
+; CHECK:       Const (0x1)
+; CHECK:       Volatile (0x2)
+; CHECK:     ]
+; CHECK:   }
+; CHECK:   Pointer (0x1001) {
+; CHECK:     TypeLeafKind: LF_POINTER (0x1002)
+; CHECK:     PointeeType: const volatile int (0x1000)
+; CHECK:     PointerAttributes: 0x1100C
+; CHECK:     PtrType: Near64 (0xC)
+; CHECK:     PtrMode: Pointer (0x0)
+; CHECK:     IsFlat: 0
+; CHECK:     IsConst: 0
+; CHECK:     IsVolatile: 0
+; CHECK:     IsUnaligned: 0
+; CHECK:     IsRestrict: 1
+; CHECK:     SizeOf: 8
+; CHECK:   }
+; CHECK:   ArgList (0x1002) {
+; CHECK:     TypeLeafKind: LF_ARGLIST (0x1201)
+; CHECK:     NumArgs: 1
+; CHECK:     Arguments [
+; CHECK:       ArgType: const volatile int* __restrict (0x1001)
+; CHECK:     ]
+; CHECK:   }
+; CHECK:   Procedure (0x1003) {
+; CHECK:     TypeLeafKind: LF_PROCEDURE (0x1008)
+; CHECK:     ReturnType: int (0x74)
+; CHECK:     CallingConvention: NearC (0x0)
+; CHECK:     FunctionOptions [ (0x0)
+; CHECK:     ]
+; CHECK:     NumParameters: 1
+; CHECK:     ArgListType: (const volatile int* __restrict) (0x1002)
+; CHECK:   }
+; CHECK:   FuncId (0x1004) {
+; CHECK:     TypeLeafKind: LF_FUNC_ID (0x1601)
+; CHECK:     ParentScope: 0x0
+; CHECK:     FunctionType: int (const volatile int* __restrict) (0x1003)
+; CHECK:     Name: f
+; CHECK:   }
+; CHECK:   Union (0x1005) {
+; CHECK:     TypeLeafKind: LF_UNION (0x1506)
+; CHECK:     MemberCount: 0
+; CHECK:     Properties [ (0x280)
+; CHECK:       ForwardReference (0x80)
+; CHECK:       HasUniqueName (0x200)
+; CHECK:     ]
+; CHECK:     FieldList: 0x0
+; CHECK:     SizeOf: 0
+; CHECK:     Name: Union
+; CHECK:     LinkageName: .?ATUnion@@
+; CHECK:   }
+; CHECK:   Pointer (0x1006) {
+; CHECK:     TypeLeafKind: LF_POINTER (0x1002)
+; CHECK:     PointeeType: int (0x74)
+; CHECK:     PointerAttributes: 0x1100C
+; CHECK:     PtrType: Near64 (0xC)
+; CHECK:     PtrMode: Pointer (0x0)
+; CHECK:     IsFlat: 0
+; CHECK:     IsConst: 0
+; CHECK:     IsVolatile: 0
+; CHECK:     IsUnaligned: 0
+; CHECK:     IsRestrict: 1
+; CHECK:     SizeOf: 8
+; CHECK:   }
+; CHECK:   Pointer (0x1007) {
+; CHECK:     TypeLeafKind: LF_POINTER (0x1002)
+; CHECK:     PointeeType: float (0x40)
+; CHECK:     PointerAttributes: 0x1100C
+; CHECK:     PtrType: Near64 (0xC)
+; CHECK:     PtrMode: Pointer (0x0)
+; CHECK:     IsFlat: 0
+; CHECK:     IsConst: 0
+; CHECK:     IsVolatile: 0
+; CHECK:     IsUnaligned: 0
+; CHECK:     IsRestrict: 1
+; CHECK:     SizeOf: 8
+; CHECK:   }
+; CHECK:   Pointer (0x1008) {
+; CHECK:     TypeLeafKind: LF_POINTER (0x1002)
+; CHECK:     PointeeType: int (0x74)
+; CHECK:     PointerAttributes: 0x1120C
+; CHECK:     PtrType: Near64 (0xC)
+; CHECK:     PtrMode: Pointer (0x0)
+; CHECK:     IsFlat: 0
+; CHECK:     IsConst: 0
+; CHECK:     IsVolatile: 1
+; CHECK:     IsUnaligned: 0
+; CHECK:     IsRestrict: 1
+; CHECK:     SizeOf: 8
+; CHECK:   }
+; CHECK:   FieldList (0x1009) {
+; CHECK:     TypeLeafKind: LF_FIELDLIST (0x1203)
+; CHECK:     DataMember {
+; CHECK:       TypeLeafKind: LF_MEMBER (0x150D)
+; CHECK:       AccessSpecifier: Public (0x3)
+; CHECK:       Type: int* __restrict (0x1006)
+; CHECK:       FieldOffset: 0x0
+; CHECK:       Name: x_member
+; CHECK:     }
+; CHECK:     DataMember {
+; CHECK:       TypeLeafKind: LF_MEMBER (0x150D)
+; CHECK:       AccessSpecifier: Public (0x3)
+; CHECK:       Type: float* __restrict (0x1007)
+; CHECK:       FieldOffset: 0x0
+; CHECK:       Name: y_member
+; CHECK:     }
+; CHECK:     DataMember {
+; CHECK:       TypeLeafKind: LF_MEMBER (0x150D)
+; CHECK:       AccessSpecifier: Public (0x3)
+; CHECK:       Type: volatile int* __restrict (0x1008)
+; CHECK:       FieldOffset: 0x0
+; CHECK:       Name: m_volatile
+; CHECK:     }
+; CHECK:   }
+
+; CHECK:   Modifier (0x100D) {
+; CHECK:     TypeLeafKind: LF_MODIFIER (0x1001)
+; CHECK:     ModifiedType: int (0x74)
+; CHECK:     Modifiers [ (0x1)
+; CHECK:       Const (0x1)
+; CHECK:     ]
+; CHECK:   }
+; CHECK:   Pointer (0x100E) {
+; CHECK:     TypeLeafKind: LF_POINTER (0x1002)
+; CHECK:     PointeeType: const int (0x100D)
+; CHECK:     PointerAttributes: 0x1000C
+; CHECK:     PtrType: Near64 (0xC)
+; CHECK:     PtrMode: Pointer (0x0)
+; CHECK:     IsFlat: 0
+; CHECK:     IsConst: 0
+; CHECK:     IsVolatile: 0
+; CHECK:     IsUnaligned: 0
+; CHECK:     IsRestrict: 0
+; CHECK:     SizeOf: 8
+; CHECK:   }
+; CHECK:   Pointer (0x100F) {
+; CHECK:     TypeLeafKind: LF_POINTER (0x1002)
+; CHECK:     PointeeType: int (0x74)
+; CHECK:     PointerAttributes: 0x1102C
+; CHECK:     PtrType: Near64 (0xC)
+; CHECK:     PtrMode: LValueReference (0x1)
+; CHECK:     IsFlat: 0
+; CHECK:     IsConst: 0
+; CHECK:     IsVolatile: 0
+; CHECK:     IsUnaligned: 0
+; CHECK:     IsRestrict: 1
+; CHECK:     SizeOf: 8
+; CHECK:   }
+; CHECK:   ArgList (0x1010) {
+; CHECK:     TypeLeafKind: LF_ARGLIST (0x1201)
+; CHECK:     NumArgs: 1
+; CHECK:     Arguments [
+; CHECK:       ArgType: int& __restrict (0x100F)
+; CHECK:     ]
+; CHECK:   }
+; CHECK:   Procedure (0x1011) {
+; CHECK:     TypeLeafKind: LF_PROCEDURE (0x1008)
+; CHECK:     ReturnType: void (0x3)
+; CHECK:     CallingConvention: NearC (0x0)
+; CHECK:     FunctionOptions [ (0x0)
+; CHECK:     ]
+; CHECK:     NumParameters: 1
+; CHECK:     ArgListType: (int& __restrict) (0x1010)
+; CHECK:   }
+; CHECK:   FuncId (0x1012) {
+; CHECK:     TypeLeafKind: LF_FUNC_ID (0x1601)
+; CHECK:     ParentScope: 0x0
+; CHECK:     FunctionType: void (int& __restrict) (0x1011)
+; CHECK:     Name: g
+; CHECK:   }
+; CHECK:   ArgList (0x1013) {
+; CHECK:     TypeLeafKind: LF_ARGLIST (0x1201)
+; CHECK:     NumArgs: 0
+; CHECK:     Arguments [
+; CHECK:     ]
+; CHECK:   }
+; CHECK:   Procedure (0x1014) {
+; CHECK:     TypeLeafKind: LF_PROCEDURE (0x1008)
+; CHECK:     ReturnType: void (0x3)
+; CHECK:     CallingConvention: NearC (0x0)
+; CHECK:     FunctionOptions [ (0x0)
+; CHECK:     ]
+; CHECK:     NumParameters: 0
+; CHECK:     ArgListType: () (0x1013)
+; CHECK:   }
+; CHECK:   FuncId (0x1015) {
+; CHECK:     TypeLeafKind: LF_FUNC_ID (0x1601)
+; CHECK:     ParentScope: 0x0
+; CHECK:     FunctionType: void () (0x1014)
+; CHECK:     Name: h
+; CHECK:   }
+; CHECK:   Struct (0x1016) {
+; CHECK:     TypeLeafKind: LF_STRUCTURE (0x1505)
+; CHECK:     MemberCount: 0
+; CHECK:     Properties [ (0x180)
+; CHECK:       ForwardReference (0x80)
+; CHECK:       Scoped (0x100)
+; CHECK:     ]
+; CHECK:     FieldList: 0x0
+; CHECK:     DerivedFrom: 0x0
+; CHECK:     VShape: 0x0
+; CHECK:     SizeOf: 0
+; CHECK:     Name: h::Foo
+; CHECK:   }
+; CHECK:   Pointer (0x1017) {
+; CHECK:     TypeLeafKind: LF_POINTER (0x1002)
+; CHECK:     PointeeType: h::Foo (0x1016)
+; CHECK:     PointerAttributes: 0x1000C
+; CHECK:     PtrType: Near64 (0xC)
+; CHECK:     PtrMode: Pointer (0x0)
+; CHECK:     IsFlat: 0
+; CHECK:     IsConst: 0
+; CHECK:     IsVolatile: 0
+; CHECK:     IsUnaligned: 0
+; CHECK:     IsRestrict: 0
+; CHECK:     SizeOf: 8
+; CHECK:   }
+; CHECK:   ArgList (0x1018) {
+; CHECK:     TypeLeafKind: LF_ARGLIST (0x1201)
+; CHECK:     NumArgs: 1
+; CHECK:     Arguments [
+; CHECK:       ArgType: int (0x74)
+; CHECK:     ]
+; CHECK:   }
+; CHECK:   MemberFunction (0x1019) {
+; CHECK:     TypeLeafKind: LF_MFUNCTION (0x1009)
+; CHECK:     ReturnType: int (0x74)
+; CHECK:     ClassType: h::Foo (0x1016)
+; CHECK:     ThisType: h::Foo* (0x1017)
+; CHECK:     CallingConvention: NearC (0x0)
+; CHECK:     FunctionOptions [ (0x0)
+; CHECK:     ]
+; CHECK:     NumParameters: 1
+; CHECK:     ArgListType: (int) (0x1018)
+; CHECK:     ThisAdjustment: 0
+; CHECK:   }
+; CHECK:   FieldList (0x101A) {
+; CHECK:     TypeLeafKind: LF_FIELDLIST (0x1203)
+; CHECK:     DataMember {
+; CHECK:       TypeLeafKind: LF_MEMBER (0x150D)
+; CHECK:       AccessSpecifier: Public (0x3)
+; CHECK:       Type: int (0x74)
+; CHECK:       FieldOffset: 0x0
+; CHECK:       Name: a
+; CHECK:     }
+; CHECK:     OneMethod {
+; CHECK:       TypeLeafKind: LF_ONEMETHOD (0x1511)
+; CHECK:       AccessSpecifier: Public (0x3)
+; CHECK:       Type: int h::Foo::(int) (0x1019)
+; CHECK:       Name: func
+; CHECK:     }
+; CHECK:   }
+; CHECK:   Struct (0x101B) {
+; CHECK:     TypeLeafKind: LF_STRUCTURE (0x1505)
+; CHECK:     MemberCount: 2
+; CHECK:     Properties [ (0x100)
+; CHECK:       Scoped (0x100)
+; CHECK:     ]
+; CHECK:     FieldList: <field list> (0x101A)
+; CHECK:     DerivedFrom: 0x0
+; CHECK:     VShape: 0x0
+; CHECK:     SizeOf: 4
+; CHECK:     Name: h::Foo
+; CHECK:   }
+
+; CHECK:   Pointer (0x101D) {
+; CHECK:     TypeLeafKind: LF_POINTER (0x1002)
+; CHECK:     PointeeType: int (0x74)
+; CHECK:     PointerAttributes: 0x904C
+; CHECK:     PtrType: Near64 (0xC)
+; CHECK:     PtrMode: PointerToDataMember (0x2)
+; CHECK:     IsFlat: 0
+; CHECK:     IsConst: 0
+; CHECK:     IsVolatile: 0
+; CHECK:     IsUnaligned: 0
+; CHECK:     IsRestrict: 1
+; CHECK:     SizeOf: 4
+; CHECK:     ClassType: h::Foo (0x1016)
+; CHECK:     Representation: SingleInheritanceData (0x1)
+; CHECK:   }
+; CHECK:   Pointer (0x101E) {
+; CHECK:     TypeLeafKind: LF_POINTER (0x1002)
+; CHECK:     PointeeType: int h::Foo::(int) (0x1019)
+; CHECK:     PointerAttributes: 0x1006C
+; CHECK:     PtrType: Near64 (0xC)
+; CHECK:     PtrMode: PointerToMemberFunction (0x3)
+; CHECK:     IsFlat: 0
+; CHECK:     IsConst: 0
+; CHECK:     IsVolatile: 0
+; CHECK:     IsUnaligned: 0
+; CHECK:     IsRestrict: 0
+; CHECK:     SizeOf: 8
+; CHECK:     ClassType: h::Foo (0x1016)
+; CHECK:     Representation: SingleInheritanceFunction (0x5)
+; CHECK:   }
+; CHECK:   MemberFuncId (0x101F) {
+; CHECK:     TypeLeafKind: LF_MFUNC_ID (0x1602)
+; CHECK:     ClassType: h::Foo (0x1016)
+; CHECK:     FunctionType: int h::Foo::(int) (0x1019)
+; CHECK:     Name: func
+; CHECK:   }
+; CHECK:   Modifier (0x1020) {
+; CHECK:     TypeLeafKind: LF_MODIFIER (0x1001)
+; CHECK:     ModifiedType: char (0x70)
+; CHECK:     Modifiers [ (0x1)
+; CHECK:       Const (0x1)
+; CHECK:     ]
+; CHECK:   }
+; CHECK:   Array (0x1021) {
+; CHECK:     TypeLeafKind: LF_ARRAY (0x1503)
+; CHECK:     ElementType: const char (0x1020)
+; CHECK:     IndexType: unsigned __int64 (0x23)
+; CHECK:     SizeOf: 4
+; CHECK:     Name:
+; CHECK:   }
+; CHECK: ]
+
+
+; ModuleID = 'm.cpp'
+source_filename = "m.cpp"
+target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-pc-windows-msvc19.11.25507"
+
+%struct.Foo = type { i32 }
+%union.Union = type { i32* }
+
+@"\01?str@?1??g@@YAXAEIAH@Z@3QBDB" = internal constant [4 x i8] c"abc\00", align 1, !dbg !0
+@"\01?s@?1??h@@YAXXZ@3UFoo@?1??1@YAXXZ@A" = private unnamed_addr constant %struct.Foo { i32 10 }, align 4
+
+; Function Attrs: noinline nounwind optnone uwtable
+define i32 @"\01?f@@YAHPEIDH@Z"(i32* noalias %arg_crv) #0 !dbg !22 {
+entry:
+  %arg_crv.addr = alloca i32*, align 8
+  %u = alloca %union.Union, align 8
+  %p = alloca i32*, align 8
+  %v = alloca i32, align 4
+  store i32* %arg_crv, i32** %arg_crv.addr, align 8
+  call void @llvm.dbg.declare(metadata i32** %arg_crv.addr, metadata !29, metadata !DIExpression()), !dbg !30
+  call void @llvm.dbg.declare(metadata %union.Union* %u, metadata !31, metadata !DIExpression()), !dbg !43
+  call void @llvm.dbg.declare(metadata i32** %p, metadata !44, metadata !DIExpression()), !dbg !47
+  call void @llvm.dbg.declare(metadata i32* %v, metadata !48, metadata !DIExpression()), !dbg !49
+  store volatile i32 0, i32* %v, align 4, !dbg !49
+  ret i32 1, !dbg !50
+}
+
+; Function Attrs: nounwind readnone speculatable
+declare void @llvm.dbg.declare(metadata, metadata, metadata) #1
+
+; Function Attrs: noinline nounwind optnone uwtable
+define void @"\01?g@@YAXAEIAH@Z"(i32* noalias dereferenceable(4) %arg_ref) #0 !dbg !2 {
+entry:
+  %arg_ref.addr = alloca i32*, align 8
+  %x = alloca i32, align 4
+  store i32* %arg_ref, i32** %arg_ref.addr, align 8
+  call void @llvm.dbg.declare(metadata i32** %arg_ref.addr, metadata !51, metadata !DIExpression()), !dbg !52
+  call void @llvm.dbg.declare(metadata i32* %x, metadata !53, metadata !DIExpression()), !dbg !54
+  store i32 10, i32* %x, align 4, !dbg !54
+  ret void, !dbg !55
+}
+
+; Function Attrs: noinline nounwind optnone uwtable
+define void @"\01?h@@YAXXZ"() #0 !dbg !56 {
+entry:
+  %s = alloca %struct.Foo, align 4
+  %p_object = alloca i32*, align 8
+  %p_data_member = alloca i32, align 8
+  %p_member_func = alloca i8*, align 8
+  call void @llvm.dbg.declare(metadata %struct.Foo* %s, metadata !59, metadata !DIExpression()), !dbg !68
+  %0 = bitcast %struct.Foo* %s to i8*, !dbg !68
+  call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 4 %0, i8* align 4 bitcast (%struct.Foo* @"\01?s@?1??h@@YAXXZ@3UFoo@?1??1@YAXXZ@A" to i8*), i64 4, i1 false), !dbg !68
+  call void @llvm.dbg.declare(metadata i32** %p_object, metadata !69, metadata !DIExpression()), !dbg !70
+  %a = getelementptr inbounds %struct.Foo, %struct.Foo* %s, i32 0, i32 0, !dbg !71
+  store i32* %a, i32** %p_object, align 8, !dbg !70
+  call void @llvm.dbg.declare(metadata i32* %p_data_member, metadata !72, metadata !DIExpression()), !dbg !75
+  store i32 0, i32* %p_data_member, align 8, !dbg !75
+  call void @llvm.dbg.declare(metadata i8** %p_member_func, metadata !76, metadata !DIExpression()), !dbg !78
+  store i8* bitcast (i32 (%struct.Foo*, i32)* @"\01?func@Foo@?1??h@@YAXXZ@QEIAAHH@Z" to i8*), i8** %p_member_func, align 8, !dbg !78
+  ret void, !dbg !79
+}
+
+; Function Attrs: argmemonly nounwind
+declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture writeonly, i8* nocapture readonly, i64, i1) #2
+
+; Function Attrs: noinline nounwind optnone uwtable
+define internal i32 @"\01?func@Foo@?1??h@@YAXXZ@QEIAAHH@Z"(%struct.Foo* %this, i32 %x) #0 align 2 !dbg !80 {
+entry:
+  %x.addr = alloca i32, align 4
+  %this.addr = alloca %struct.Foo*, align 8
+  store i32 %x, i32* %x.addr, align 4
+  call void @llvm.dbg.declare(metadata i32* %x.addr, metadata !81, metadata !DIExpression()), !dbg !82
+  store %struct.Foo* %this, %struct.Foo** %this.addr, align 8
+  call void @llvm.dbg.declare(metadata %struct.Foo** %this.addr, metadata !83, metadata !DIExpression()), !dbg !85
+  %this1 = load %struct.Foo*, %struct.Foo** %this.addr, align 8
+  ret i32 1, !dbg !86
+}
+
+attributes #0 = { noinline nounwind optnone uwtable "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+fxsr,+mmx,+sse,+sse2,+x87" "unsafe-fp-math"="false" "use-soft-float"="false" }
+attributes #1 = { nounwind readnone speculatable }
+attributes #2 = { argmemonly nounwind }
+
+!llvm.dbg.cu = !{!9}
+!llvm.module.flags = !{!17, !18, !19, !20}
+!llvm.ident = !{!21}
+
+!0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
+!1 = distinct !DIGlobalVariable(name: "str", scope: !2, file: !3, line: 18, type: !12, isLocal: true, isDefinition: true)
+!2 = distinct !DISubprogram(name: "g", linkageName: "\01?g@@YAXAEIAH@Z", scope: !3, file: !3, line: 16, type: !4, isLocal: false, isDefinition: true, scopeLine: 16, flags: DIFlagPrototyped, isOptimized: false, unit: !9, variables: !10)
+!3 = !DIFile(filename: "m.cpp", directory: "C:\5CUsers\5CHui\5Ctmp\5Chui", checksumkind: CSK_MD5, checksum: "a8da0f4dca948db1ef1129c8728a881c")
+!4 = !DISubroutineType(types: !5)
+!5 = !{null, !6}
+!6 = !DIDerivedType(tag: DW_TAG_restrict_type, baseType: !7)
+!7 = !DIDerivedType(tag: DW_TAG_reference_type, baseType: !8, size: 64)
+!8 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!9 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !3, producer: "clang version 7.0.0 ", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !10, globals: !11)
+!10 = !{}
+!11 = !{!0}
+!12 = !DICompositeType(tag: DW_TAG_array_type, baseType: !13, size: 32, elements: !15)
+!13 = !DIDerivedType(tag: DW_TAG_const_type, baseType: !14)
+!14 = !DIBasicType(name: "char", size: 8, encoding: DW_ATE_signed_char)
+!15 = !{!16}
+!16 = !DISubrange(count: 4)
+!17 = !{i32 2, !"CodeView", i32 1}
+!18 = !{i32 2, !"Debug Info Version", i32 3}
+!19 = !{i32 1, !"wchar_size", i32 2}
+!20 = !{i32 7, !"PIC Level", i32 2}
+!21 = !{!"clang version 7.0.0 "}
+!22 = distinct !DISubprogram(name: "f", linkageName: "\01?f@@YAHPEIDH@Z", scope: !3, file: !3, line: 9, type: !23, isLocal: false, isDefinition: true, scopeLine: 9, flags: DIFlagPrototyped, isOptimized: false, unit: !9, variables: !10)
+!23 = !DISubroutineType(types: !24)
+!24 = !{!8, !25}
+!25 = !DIDerivedType(tag: DW_TAG_restrict_type, baseType: !26)
+!26 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !27, size: 64)
+!27 = !DIDerivedType(tag: DW_TAG_const_type, baseType: !28)
+!28 = !DIDerivedType(tag: DW_TAG_volatile_type, baseType: !8)
+!29 = !DILocalVariable(name: "arg_crv", arg: 1, scope: !22, file: !3, line: 9, type: !25)
+!30 = !DILocation(line: 9, column: 39, scope: !22)
+!31 = !DILocalVariable(name: "u", scope: !22, file: !3, line: 10, type: !32)
+!32 = distinct !DICompositeType(tag: DW_TAG_union_type, name: "Union", file: !3, line: 3, size: 64, flags: DIFlagTypePassByValue, elements: !33, identifier: ".?ATUnion@@")
+!33 = !{!34, !37, !41}
+!34 = !DIDerivedType(tag: DW_TAG_member, name: "x_member", scope: !32, file: !3, line: 4, baseType: !35, size: 64)
+!35 = !DIDerivedType(tag: DW_TAG_restrict_type, baseType: !36)
+!36 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !8, size: 64)
+!37 = !DIDerivedType(tag: DW_TAG_member, name: "y_member", scope: !32, file: !3, line: 5, baseType: !38, size: 64)
+!38 = !DIDerivedType(tag: DW_TAG_restrict_type, baseType: !39)
+!39 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !40, size: 64)
+!40 = !DIBasicType(name: "float", size: 32, encoding: DW_ATE_float)
+!41 = !DIDerivedType(tag: DW_TAG_member, name: "m_volatile", scope: !32, file: !3, line: 6, baseType: !42, size: 64)
+!42 = !DIDerivedType(tag: DW_TAG_volatile_type, baseType: !35)
+!43 = !DILocation(line: 10, column: 10, scope: !22)
+!44 = !DILocalVariable(name: "p", scope: !22, file: !3, line: 11, type: !45)
+!45 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !46, size: 64)
+!46 = !DIDerivedType(tag: DW_TAG_const_type, baseType: !8)
+!47 = !DILocation(line: 11, column: 15, scope: !22)
+!48 = !DILocalVariable(name: "v", scope: !22, file: !3, line: 12, type: !27)
+!49 = !DILocation(line: 12, column: 23, scope: !22)
+!50 = !DILocation(line: 13, column: 4, scope: !22)
+!51 = !DILocalVariable(name: "arg_ref", arg: 1, scope: !2, file: !3, line: 16, type: !6)
+!52 = !DILocation(line: 16, column: 25, scope: !2)
+!53 = !DILocalVariable(name: "x", scope: !2, file: !3, line: 17, type: !46)
+!54 = !DILocation(line: 17, column: 14, scope: !2)
+!55 = !DILocation(line: 19, column: 2, scope: !2)
+!56 = distinct !DISubprogram(name: "h", linkageName: "\01?h@@YAXXZ", scope: !3, file: !3, line: 21, type: !57, isLocal: false, isDefinition: true, scopeLine: 21, flags: DIFlagPrototyped, isOptimized: false, unit: !9, variables: !10)
+!57 = !DISubroutineType(types: !58)
+!58 = !{null}
+!59 = !DILocalVariable(name: "s", scope: !56, file: !3, line: 27, type: !60)
+!60 = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "Foo", scope: !56, file: !3, line: 22, size: 32, flags: DIFlagTypePassByValue, elements: !61)
+!61 = !{!62, !63}
+!62 = !DIDerivedType(tag: DW_TAG_member, name: "a", scope: !60, file: !3, line: 23, baseType: !8, size: 32)
+!63 = !DISubprogram(name: "func", scope: !60, file: !3, line: 24, type: !64, isLocal: false, isDefinition: false, scopeLine: 24, flags: DIFlagPrototyped, isOptimized: false)
+!64 = !DISubroutineType(types: !65)
+!65 = !{!8, !66, !8}
+
+; FIXME: Clang emits wrong debug info here because of PR17747. We should
+; regenerate this IR when it is fixed.
+!66 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !67, size: 64, flags: DIFlagArtificial | DIFlagObjectPointer)
+!67 = !DIDerivedType(tag: DW_TAG_restrict_type, baseType: !60)
+
+!68 = !DILocation(line: 27, column: 8, scope: !56)
+!69 = !DILocalVariable(name: "p_object", scope: !56, file: !3, line: 29, type: !35)
+!70 = !DILocation(line: 29, column: 20, scope: !56)
+!71 = !DILocation(line: 29, column: 34, scope: !56)
+!72 = !DILocalVariable(name: "p_data_member", scope: !56, file: !3, line: 31, type: !73)
+!73 = !DIDerivedType(tag: DW_TAG_restrict_type, baseType: !74)
+!74 = !DIDerivedType(tag: DW_TAG_ptr_to_member_type, baseType: !8, size: 32, flags: DIFlagSingleInheritance, extraData: !60)
+!75 = !DILocation(line: 31, column: 27, scope: !56)
+!76 = !DILocalVariable(name: "p_member_func", scope: !56, file: !3, line: 33, type: !77)
+!77 = !DIDerivedType(tag: DW_TAG_ptr_to_member_type, baseType: !64, size: 64, flags: DIFlagSingleInheritance, extraData: !60)
+!78 = !DILocation(line: 33, column: 16, scope: !56)
+!79 = !DILocation(line: 34, column: 2, scope: !56)
+!80 = distinct !DISubprogram(name: "func", linkageName: "\01?func@Foo@?1??h@@YAXXZ@QEIAAHH@Z", scope: !60, file: !3, line: 24, type: !64, isLocal: true, isDefinition: true, scopeLine: 24, flags: DIFlagPrototyped, isOptimized: false, unit: !9, declaration: !63, variables: !10)
+!81 = !DILocalVariable(name: "x", arg: 2, scope: !80, file: !3, line: 24, type: !8)
+!82 = !DILocation(line: 24, column: 19, scope: !80)
+!83 = !DILocalVariable(name: "this", arg: 1, scope: !80, type: !84, flags: DIFlagArtificial | DIFlagObjectPointer)
+!84 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !67, size: 64)
+!85 = !DILocation(line: 0, scope: !80)
+!86 = !DILocation(line: 24, column: 35, scope: !80)