[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

1275–1276

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

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

2142 ↗

(On Diff #135974)

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

2142 ↗

(On Diff #135974)

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

13 ↗

(On Diff #135974)

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 ↗

(On Diff #135974)

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

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);
   }

lib/CodeGen/AsmPrinter/CodeViewDebug.h

class LLVM_LIBRARY_VISIBILITY CodeViewDebug : public DebugHandlerBase {
 
   /// Map from full file path to .cv_file id. Full paths are built from DIFiles
   /// and are stored in FileToFilepathMap;
   DenseMap<StringRef, unsigned> FileIdMap;
 
   /// All inlined subprograms in the order they should be emitted.
   SmallSetVector<const DISubprogram *, 4> InlinedSubprograms;
 
-  /// Map from a pair of DI metadata nodes and its DI type (or scope) that can
-  /// be nullptr, to CodeView type indices. Primarily indexed by
-  /// {DIType*, DIType*} and {DISubprogram*, DIType*}.
+  typedef std::pair<const DIType *, const DIType *> DITypePair;
+
+  /// Map from a pair of DI metadata nodes and DITypePair type to CodeView type
+  /// indices. Primarily indexed by
+  /// {DIType*, {DIType*, DIType*}} and {DISubprogram*, {DIType*, DIType*}}
+  ///
+  /// DITypePair is a pair of DI metadata node's DI type (or scope) and the
+  /// node's certain qualifier type (restrict) that can be both nullptr.
   ///
-  /// The second entry in the key is needed for methods as DISubroutineType
+  /// The first entry in DITypePair is needed for methods as DISubroutineType
   /// representing static method type are shared with non-method function type.
-  DenseMap<std::pair<const DINode *, const DIType *>, codeview::TypeIndex>
+  ///
+  /// The second entry in DITypePair is needed when handling DI metadata node
+  /// modified with certain qualifier (restrict) but there is no such qualifier
+  /// information in the context of the metadata node.
+  ///
+  /// For example, for a restricted pointer, MSVC would create a LF_POINTER node
+  /// by folding the qualifier (restrict) into PointerOptions rather than
+  /// create a LF_MODIFIER node. There is no qualifier information in DI metadata
+  /// representing the restricted pointer, so we will utilize this entry to
+  /// determine the node's qualifiers.
+
+  DenseMap<std::pair<const DINode *, DITypePair>, codeview::TypeIndex>
       TypeIndices;
 
+#define CV_TYPE_KEY(Node, ClassTy, NodeQualTy) \
+  {Node, {ClassTy, NodeQualTy}}
+
   /// Map from DICompositeType* to complete type index. Non-record types are
   /// always looked up in the normal TypeIndices map.
   DenseMap<const DICompositeType *, codeview::TypeIndex> CompleteTypeIndices;
 
   /// Complete record types to emit after all active type lowerings are
   /// finished.
   SmallVector<const DICompositeType *, 4> DeferredCompleteTypes;
 
#define CV_TYPE_KEY(Node, ClassTy, NodeQualTy) \
   void emitLocalVariableList(ArrayRef<LocalVariable> Locals);
 
   /// Emits an S_LOCAL record and its associated defined ranges.
   void emitLocalVariable(const LocalVariable &Var);
 
   /// Translates the DIType to codeview if necessary and returns a type index
   /// for it.
   codeview::TypeIndex getTypeIndex(DITypeRef TypeRef,
-                                   DITypeRef ClassTyRef = DITypeRef());
+                                   DITypeRef ClassTyRef = DITypeRef(),
+                                   DITypeRef NodeQualTyRef = DITypeRef());
 
   codeview::TypeIndex getTypeIndexForReferenceTo(DITypeRef TypeRef);
 
   codeview::TypeIndex getMemberFunctionType(const DISubprogram *SP,
                                             const DICompositeType *Class);
 
   codeview::TypeIndex getScopeIndex(const DIScope *Scope);
 
   codeview::TypeIndex getVBPTypeIndex();
 
   void addToUDTs(const DIType *Ty);
 
-  codeview::TypeIndex lowerType(const DIType *Ty, const DIType *ClassTy);
+  codeview::TypeIndex lowerType(const DIType *Ty, const DIType *ClassTy,
+                                const DIType *NodeQualTy);
   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 lowerTypeRestrict(const DIDerivedType *Ty,
+                                        const DIType *ClassTy,
+                                        const DIType *NodeQualTy);
+  codeview::TypeIndex lowerTypePointer(const DIDerivedType *Ty,
+                                       const DIType *ClassTy,
+                                       const DIType *NodeQualTy);
+  codeview::TypeIndex lowerTypeMemberPointer(const DIDerivedType *Ty,
+                                             const DIType *ClassTy,
+                                             const DIType *NodeQualTy);
   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);
#define CV_TYPE_KEY(Node, ClassTy, NodeQualTy) \
   /// 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.

lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

 TypeIndex CodeViewDebug::getScopeIndex(const DIScope *Scope) {
   // No scope means global scope and that uses the zero index.
   if (!Scope || isa<DIFile>(Scope))
     return TypeIndex();
 
   assert(!isa<DIType>(Scope) && "shouldn't make a namespace scope for a type");
 
   // Check if we've already translated this scope.
-  auto I = TypeIndices.find({Scope, nullptr});
+  auto I = TypeIndices.find(CV_TYPE_KEY(Scope, nullptr, nullptr));
   if (I != TypeIndices.end())
     return I->second;
 
   // Build the fully qualified name of the scope.
   std::string ScopeName = getFullyQualifiedName(Scope);
   StringIdRecord SID(TypeIndex(), ScopeName);
   auto TI = TypeTable.writeLeafType(SID);
   return recordTypeIndexForDINode(Scope, TI);
 }
 
 TypeIndex CodeViewDebug::getFuncIdForSubprogram(const DISubprogram *SP) {
   assert(SP);
 
   // Check if we've already translated this subprogram.
-  auto I = TypeIndices.find({SP, nullptr});
+  auto I = TypeIndices.find(CV_TYPE_KEY(SP, nullptr, nullptr));
   if (I != TypeIndices.end())
     return I->second;
 
   // The display name includes function template arguments. Drop them to match
   // MSVC.
   StringRef DisplayName = SP->getName().split('<').first;
 
   const DIScope *Scope = SP->getScope().resolve();
TypeIndex CodeViewDebug::getMemberFunctionType(const DISubprogram *SP,
   // Always use the method declaration as the key for the function type. The
   // method declaration contains the this adjustment.
   if (SP->getDeclaration())
     SP = SP->getDeclaration();
   assert(!SP->getDeclaration() && "should use declaration as key");
 
   // Key the MemberFunctionRecord into the map as {SP, Class}. It won't collide
   // with the MemberFuncIdRecord, which is keyed in as {SP, nullptr}.
-  auto I = TypeIndices.find({SP, Class});
+  auto I = TypeIndices.find(CV_TYPE_KEY(SP, Class, nullptr));
   if (I != TypeIndices.end())
     return I->second;
 
   // Make sure complete type info for the class is emitted *after* the member
   // function type, as the complete class type is likely to reference this
   // member function type.
   TypeLoweringScope S(*this);
   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) {
-  auto InsertResult = TypeIndices.insert({{Node, ClassTy}, TI});
+                                                  const DIType *ClassTy,
+                                                  const DIType *NodeQualTy) {
+  auto InsertResult =
+      TypeIndices.insert({CV_TYPE_KEY(Node, ClassTy, NodeQualTy), TI});
   (void)InsertResult;
   assert(InsertResult.second && "DINode was already assigned a type index");
   return TI;
 }
 
 unsigned CodeViewDebug::getPointerSizeInBytes() {
   return MMI->getModule()->getDataLayout().getPointerSizeInBits() / 8;
 }
void CodeViewDebug::emitInlineeLinesSubsection() {
   // We emit the checksum info for files.  This is used by debuggers to
   // determine if a pdb matches the source before loading it.  Visual Studio,
   // for instance, will display a warning that the breakpoints are not valid if
   // the pdb does not match the source.
   OS.AddComment("Inlinee lines signature");
   OS.EmitIntValue(unsigned(InlineeLinesSignature::Normal), 4);
 
   for (const DISubprogram *SP : InlinedSubprograms) {
-    assert(TypeIndices.count({SP, nullptr}));
-    TypeIndex InlineeIdx = TypeIndices[{SP, nullptr}];
+    assert(TypeIndices.count(CV_TYPE_KEY(SP, nullptr, nullptr)));
+    TypeIndex InlineeIdx = TypeIndices[CV_TYPE_KEY(SP, nullptr, nullptr)];
 
     OS.AddBlankLine();
     unsigned FileId = maybeRecordFile(SP->getFile());
     OS.AddComment("Inlined function " + SP->getName() + " starts at " +
                   SP->getFilename() + Twine(':') + Twine(SP->getLine()));
     OS.AddBlankLine();
     OS.AddComment("Type index of inlined function");
     OS.EmitIntValue(InlineeIdx.getIndex(), 4);
     OS.AddComment("Offset into filechecksum table");
     OS.EmitCVFileChecksumOffsetDirective(FileId);
     OS.AddComment("Starting line number");
     OS.EmitIntValue(SP->getLine(), 4);
   }
 
   endCVSubsection(InlineEnd);
 }
 
 void CodeViewDebug::emitInlinedCallSite(const FunctionInfo &FI,
                                         const DILocation *InlinedAt,
                                         const InlineSite &Site) {
   MCSymbol *InlineBegin = MMI->getContext().createTempSymbol(),
            *InlineEnd = MMI->getContext().createTempSymbol();
 
-  assert(TypeIndices.count({Site.Inlinee, nullptr}));
-  TypeIndex InlineeIdx = TypeIndices[{Site.Inlinee, nullptr}];
+  assert(TypeIndices.count(CV_TYPE_KEY(Site.Inlinee, nullptr, nullptr)));
+  TypeIndex InlineeIdx =
+      TypeIndices[CV_TYPE_KEY(Site.Inlinee, nullptr, nullptr)];
 
   // SymbolRecord
   OS.AddComment("Record length");
   OS.emitAbsoluteSymbolDiff(InlineEnd, InlineBegin, 2);   // RecordLength
   OS.EmitLabel(InlineBegin);
   OS.AddComment("Record kind: S_INLINESITE");
   OS.EmitIntValue(SymbolKind::S_INLINESITE, 2); // RecordKind
 
void CodeViewDebug::addToUDTs(const DIType *Ty) {
   // TODO: What if the ClosestSubprogram is neither null or the current
   // subprogram?  Currently, the UDT just gets dropped on the floor.
   //
   // The current behavior is not desirable.  To get maximal fidelity, we would
   // need to perform all type translation before beginning emission of .debug$S
   // and then make LocalUDTs a member of FunctionInfo
 }
 
-TypeIndex CodeViewDebug::lowerType(const DIType *Ty, const DIType *ClassTy) {
+TypeIndex CodeViewDebug::lowerType(const DIType *Ty, const DIType *ClassTy,
+                                   const DIType *NodeQualTy) {
   // Generic dispatch for lowering an unknown type.
   switch (Ty->getTag()) {
   case dwarf::DW_TAG_array_type:
     return lowerTypeArray(cast<DICompositeType>(Ty));
   case dwarf::DW_TAG_typedef:
     return lowerTypeAlias(cast<DIDerivedType>(Ty));
   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, NodeQualTy);
+  case dwarf::DW_TAG_restrict_type:
+    return lowerTypeRestrict(cast<DIDerivedType>(Ty), ClassTy, NodeQualTy);
   case dwarf::DW_TAG_ptr_to_member_type:
-    return lowerTypeMemberPointer(cast<DIDerivedType>(Ty));
+    return lowerTypeMemberPointer(cast<DIDerivedType>(Ty), ClassTy,
+                                  NodeQualTy);
   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.
       return lowerTypeMemberFunction(cast<DISubroutineType>(Ty), ClassTy,
                                      /*ThisAdjustment=*/0,
                                      /*IsStaticMethod=*/false);
     }
     return lowerTypeFunction(cast<DISubroutineType>(Ty));
   case dwarf::DW_TAG_enumeration_type:
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::lowerTypeRestrict(const DIDerivedType *Ty,
+                                           const DIType *ClassTy,
+                                           const DIType *NodeQualTy) {
+  if (Ty->getTag() == dwarf::DW_TAG_restrict_type) {
+    if (OS.getContext().getDwarfVersion() <= 2)
+      return getTypeIndex(Ty->getBaseType());
+  }
+
+  auto BaseTy = Ty->getBaseType().resolve();
+  if (!BaseTy)
+    return getTypeIndex(Ty->getBaseType());
+
+  switch (BaseTy->getTag()) {
+  case dwarf::DW_TAG_pointer_type:
+  case dwarf::DW_TAG_ptr_to_member_type:
+  case dwarf::DW_TAG_reference_type:
+  case dwarf::DW_TAG_rvalue_reference_type:
+    break;
+  default:
+    // FIXME: there is case that DICompositeType is restricted.
+    return getTypeIndex(Ty->getBaseType());
+  }
+
+  // This would pass qualifier rather than create a new node.
+  return getTypeIndex(Ty->getBaseType(), ClassTy, Ty);
+}
+
+TypeIndex CodeViewDebug::lowerTypePointer(const DIDerivedType *Ty,
+                                          const DIType *ClassTy,
+                                          const DIType *NodeQualTy) {
   TypeIndex PointeeTI = getTypeIndex(Ty->getBaseType());
 
   // Pointers to simple types can use SimpleTypeMode, rather than having a
-  // dedicated pointer type record.
-  if (PointeeTI.isSimple() &&
+  // dedicated pointer type record. Except pointers modified by certain
+  // qualifier.
+  if (!NodeQualTy && PointeeTI.isSimple() &&
       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.
+  // do. Using NodeQualTy is a solution.
   PointerOptions PO = PointerOptions::None;
+  if (NodeQualTy && NodeQualTy->getTag() == dwarf::DW_TAG_restrict_type)
+    PO |= PointerOptions::Restrict;
+
   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,
+                                                const DIType *NodeQualTy) {
   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
+  PointerOptions PO = PointerOptions::None;
+  if (NodeQualTy && NodeQualTy->getTag() == dwarf::DW_TAG_restrict_type)
+    PO |= PointerOptions::Restrict;
+
   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);
 }
 
if (!VBPType.getIndex()) {
     PointerOptions PO = PointerOptions::None;
     PointerRecord PR(ModifiedTI, PK, PM, PO, getPointerSizeInBytes());
     VBPType = TypeTable.writeLeafType(PR);
   }
 
   return VBPType;
 }
 
-TypeIndex CodeViewDebug::getTypeIndex(DITypeRef TypeRef, DITypeRef ClassTyRef) {
+TypeIndex CodeViewDebug::getTypeIndex(DITypeRef TypeRef, DITypeRef ClassTyRef,
+                                      DITypeRef NodeQualTyRef) {
   const DIType *Ty = TypeRef.resolve();
   const DIType *ClassTy = ClassTyRef.resolve();
+  const DIType *NodeQualTy = NodeQualTyRef.resolve();
 
   // 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});
+  auto I = TypeIndices.find(CV_TYPE_KEY(Ty, ClassTy, NodeQualTy));
   if (I != TypeIndices.end())
     return I->second;
 
   TypeLoweringScope S(*this);
-  TypeIndex TI = lowerType(Ty, ClassTy);
-  return recordTypeIndexForDINode(Ty, TI, ClassTy);
+  TypeIndex TI = lowerType(Ty, ClassTy, NodeQualTy);
+  return recordTypeIndexForDINode(Ty, TI, ClassTy, NodeQualTy);
 }
 
 TypeIndex CodeViewDebug::getTypeIndexForReferenceTo(DITypeRef TypeRef) {
   DIType *Ty = TypeRef.resolve();
   PointerRecord PR(getTypeIndex(Ty),
                    getPointerSizeInBytes() == 8 ? PointerKind::Near64
                                                 : PointerKind::Near32,
                    PointerMode::LValueReference, PointerOptions::None,

lib/DebugInfo/CodeView/RecordName.cpp

if (Ptr.isPointerToMember()) {
     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;

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));

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:   Modifier (0x1008) {
+; CHECK:     TypeLeafKind: LF_MODIFIER (0x1001)
+; CHECK:     ModifiedType: int* __restrict (0x1006)
+; CHECK:     Modifiers [ (0x2)
+; CHECK:       Volatile (0x2)
+; CHECK:     ]
+; 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}
+!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)