[CodeView] Emit proper debug info for ref-qualified member functions

[zturner]

Summary

When you have a member function with a ref-qualifier, for example:

struct Foo {
  void Func() &;
  void Func2() &&;
};

clang-cl was not emitting this information. Doing so is a bit awkward, because it's not a property of the LF_MFUNCTION type, which is what you'd expect. Instead, it's a property of the this pointer which is actually an LF_POINTER. This record has an attributes bitmask on it, and our handling of this bitmask was all wrong. We had some parts of the bitmask defined incorrectly, but importantly for this bug, we didn't know about these extra 2 bits that represent the ref qualifier at all. We can see this in the reference implementation here:

https://github.com/Microsoft/microsoft-pdb/blob/master/include/cvinfo.h#L1524-L1525

And we can also observe that clang-cl and cl emit different records by compiling a simple program and using llvm-pdbutil to dump the results of each one.

// cat foo.cpp
struct A {
  int NoRefQual();

  int RefQual() &;
  int RefQual() &&;

  int LValueRef() &;

  int RValueRef() &&;
};

int main(int argc, char **argv) {
  A *GenericPtr = nullptr;
  A a;
  return 0;
}

With clang:

$ clang-cl.exe /Z7 /GS- /GR- foo.cpp /o foo-clang.exe

$ llvm-pdbutil.exe dump -types -type-index=0x1009 -dependents -type-data foo-clang.pdb


                     Types (TPI Stream)
============================================================
  Showing 1 records and their dependents (7 records total)
   0x1003 | LF_STRUCTURE [size = 32] `A`
            unique name: `.?AUA@@`
            vtable: <no type>, base list: <no type>, field list: <no type>
            options: forward ref (-> 0x1009) | has unique name, sizeof 0
           Bytes (
             0000: 1E000515 00008002 00000000 00000000 00000000 00004100 2E3F4155 41404000  |......................A..?AUA@@.|
           )
   0x1004 | LF_POINTER [size = 12]
            referent = 0x1003, mode = pointer, opts = None, kind = ptr64
           Bytes (
             0000: 0A000210 03100000 0C000100                                               |............|
           )
   0x1005 | LF_ARGLIST [size = 8]
           Bytes (
             0000: 06000112 00000000                                                        |........|
           )
   0x1006 | LF_MFUNCTION [size = 28]
            return type = 0x0074 (int), # args = 0, param list = 0x1005
            class type = 0x1003, this type = 0x1004, this adjust = 0
            calling conv = cdecl, options = None
           Bytes (
             0000: 1A000910 74000000 03100000 04100000 00000000 05100000 00000000           |....t.......................|
           )
   0x1007 | LF_METHODLIST [size = 20]
            - Method [type = 0x1006, vftable offset = -1, attrs = public]
            - Method [type = 0x1006, vftable offset = -1, attrs = public]
           Bytes (
             0000: 12000612 03000000 06100000 03000000 06100000                             |....................|
           )
   0x1008 | LF_FIELDLIST [size = 80]
            - LF_ONEMETHOD [name = `NoRefQual`]
              type = 0x1006, vftable offset = -1, attrs = public
              Bytes (
                0000: 03000610 00004E6F 52656651 75616C00                                      |......NoRefQual.|
              )
            - LF_METHOD [name = `RefQual`, # overloads = 2, overload list = 0x1007]
              Bytes (
                0000: 02000710 00005265 66517561 6C00                                          |......RefQual.|
              )
            - LF_ONEMETHOD [name = `LValueRef`]
              type = 0x1006, vftable offset = -1, attrs = public
              Bytes (
                0000: 03000610 00004C56 616C7565 52656600                                      |......LValueRef.|
              )
            - LF_ONEMETHOD [name = `RValueRef`]
              type = 0x1006, vftable offset = -1, attrs = public
              Bytes (
                0000: 03000610 00005256 616C7565 52656600                                      |......RValueRef.|
              )
           Bytes (
             0000: 4E000312 11150300 06100000 4E6F5265 66517561 6C00F2F1 0F150200 07100000  |N...........NoRefQual...........|
             0020: 52656651 75616C00 11150300 06100000 4C56616C 75655265 6600F2F1 11150300  |RefQual.........LValueRef.......|
             0040: 06100000 5256616C 75655265 6600F2F1                                      |....RValueRef...|
           )
   0x1009 | LF_STRUCTURE [size = 32] `A`
            unique name: `.?AUA@@`
            vtable: <no type>, base list: <no type>, field list: 0x1008
            options: has unique name, sizeof 1
           Bytes (
             0000: 1E000515 05000002 08100000 00000000 00000000 01004100 2E3F4155 41404000  |......................A..?AUA@@.|
           )

If we follow the type indices here, we can see that RValueRef, LValueRef, both overloads of RefQual and also NoRefQual all have the same LF_MFUNCTION type, which is 0x1006. Since they have the same LF_MFUNCTION, they also have the same LF_POINTER for the this pointer since it is part of that record. For the sake of comparison later, the dump of this pointer record is:

referent = 0x1003, mode = pointer, opts = None, kind = ptr64  0000: 0A000210 03100000 0C000100

With MSVC

$ cl.exe /Z7 /GS- /GR- foo.cpp /o foo-cl.exe

$ llvm-pdbutil.exe dump -types -type-index=0x100E -dependents -type-data foo-cl.pdb


                     Types (TPI Stream)
============================================================
  Showing 1 records and their dependents (11 records total)
   0x1003 | LF_STRUCTURE [size = 32] `A`
            unique name: `.?AUA@@`
            vtable: <no type>, base list: <no type>, field list: <no type>
            options: forward ref (-> 0x100E) | has unique name, sizeof 0
           Bytes (
             0000: 1E000515 00008002 00000000 00000000 00000000 00004100 2E3F4155 41404000  |......................A..?AUA@@.|
           )
   0x1005 | LF_POINTER [size = 12]
            referent = 0x1003, mode = pointer, opts = const, kind = ptr64
           Bytes (
             0000: 0A000210 03100000 0C040100                                               |............|
           )
   0x1006 | LF_ARGLIST [size = 8]
           Bytes (
             0000: 06000112 00000000                                                        |........|
           )
   0x1007 | LF_MFUNCTION [size = 28]
            return type = 0x0074 (int), # args = 0, param list = 0x1006
            class type = 0x1003, this type = 0x1005, this adjust = 0
            calling conv = cdecl, options = None
           Bytes (
             0000: 1A000910 74000000 03100000 05100000 00000000 06100000 00000000           |....t.......................|
           )
   0x1008 | LF_POINTER [size = 12]
            referent = 0x1003, mode = pointer, opts = const, kind = ptr64
           Bytes (
             0000: 0A000210 03100000 0C042100                                               |..........!.|
           )
   0x1009 | LF_MFUNCTION [size = 28]
            return type = 0x0074 (int), # args = 0, param list = 0x1006
            class type = 0x1003, this type = 0x1008, this adjust = 0
            calling conv = cdecl, options = None
           Bytes (
             0000: 1A000910 74000000 03100000 08100000 00000000 06100000 00000000           |....t.......................|
           )
   0x100A | LF_POINTER [size = 12]
            referent = 0x1003, mode = pointer, opts = const, kind = ptr64
           Bytes (
             0000: 0A000210 03100000 0C041100                                               |............|
           )
   0x100B | LF_MFUNCTION [size = 28]
            return type = 0x0074 (int), # args = 0, param list = 0x1006
            class type = 0x1003, this type = 0x100A, this adjust = 0
            calling conv = cdecl, options = None
           Bytes (
             0000: 1A000910 74000000 03100000 0A100000 00000000 06100000 00000000           |....t.......................|
           )
   0x100C | LF_METHODLIST [size = 20]
            - Method [type = 0x1009, vftable offset = -1, attrs = public]
            - Method [type = 0x100B, vftable offset = -1, attrs = public]
           Bytes (
             0000: 12000612 03000000 09100000 03000000 0B100000                             |....................|
           )
   0x100D | LF_FIELDLIST [size = 80]
            - LF_ONEMETHOD [name = `NoRefQual`]
              type = 0x1007, vftable offset = -1, attrs = public
              Bytes (
                0000: 03000710 00004E6F 52656651 75616C00                                      |......NoRefQual.|
              )
            - LF_METHOD [name = `RefQual`, # overloads = 2, overload list = 0x100C]
              Bytes (
                0000: 02000C10 00005265 66517561 6C00                                          |......RefQual.|
              )
            - LF_ONEMETHOD [name = `LValueRef`]
              type = 0x100B, vftable offset = -1, attrs = public
              Bytes (
                0000: 03000B10 00004C56 616C7565 52656600                                      |......LValueRef.|
              )
            - LF_ONEMETHOD [name = `RValueRef`]
              type = 0x1009, vftable offset = -1, attrs = public
              Bytes (
                0000: 03000910 00005256 616C7565 52656600                                      |......RValueRef.|
              )
           Bytes (
             0000: 4E000312 11150300 07100000 4E6F5265 66517561 6C00F2F1 0F150200 0C100000  |N...........NoRefQual...........|
             0020: 52656651 75616C00 11150300 0B100000 4C56616C 75655265 6600F2F1 11150300  |RefQual.........LValueRef.......|
             0040: 09100000 5256616C 75655265 6600F2F1                                      |....RValueRef...|
           )
   0x100E | LF_STRUCTURE [size = 32] `A`
            unique name: `.?AUA@@`
            vtable: <no type>, base list: <no type>, field list: 0x100D
            options: has unique name, sizeof 1
           Bytes (
             0000: 1E000515 05000002 0D100000 00000000 00000000 01004100 2E3F4155 41404000  |......................A..?AUA@@.|
           )

Here we see several different LF_MFUNCTION records in use.

0x1009: Used by Foo::RValueRef and one overload of Foo::RefQual
0x100B: Used by Foo::LValueRef and one overload of Foo::RefQual
0x1007: Used by Foo::NoRefQual

And the only difference between any of them is the "this type" field. So for this pointer types, we have:

0x1008: Used by Foo::RValueRef and one overload of Foo::RefQual
0x100A: Used by Foo::LValueRef and one overload of Foo::RefQual
0x1005: Used by Foo::NoRefQual

And if we then go look at the record data of each one, we have:

0x1008: referent = 0x1003, mode = pointer, opts = const, kind = ptr64  0000: 0A000210 03100000 0C042100
0x100A: referent = 0x1003, mode = pointer, opts = const, kind = ptr64  0000: 0A000210 03100000 0C041100
0x1005: referent = 0x1003, mode = pointer, opts = const, kind = ptr64  0000: 0A000210 03100000 0C040100

The data that llvm-pdbutil looks identical for each one, but if we look closer at the record bytes we can see that there is 1 bit difference in each of them.

After this patch, clang-cl emits compatible debug info for this case.

0x1009: referent = 0x1003, mode = pointer, opts = None, kind = ptr64  0000: 0A000210 03100000 0C002100
0x1007: referent = 0x1003, mode = pointer, opts = None, kind = ptr64  0000: 0A000210 03100000 0C001100
0x1004: referent = 0x1003, mode = pointer, opts = None, kind = ptr64  0000: 0A000210 03100000 0C000100

[zturner]

In my original output, you could still see one bit different on our this pointer records and MSVC's. Specifically, they mark them as const. I went ahead and did the same thing in this update.

[zturner]

Uploaded the wrong patch last time. This time I actually have the change for marking the pointers const.

[rnk]

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

362–364

Why should we separate these? I don't think the WinRT smart pointer bit really relates to ref qualifier overloading, does it? Since these are just more flags, grouping them together reduces the number of parameters we need to make pointer records.

llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

1717

This constructor is getting pretty big at this point, for example.

llvm/lib/DebugInfo/CodeView/TypeDumpVisitor.cpp

364

Most of the diff is updating tests to cope with this. You should be able to commit this one line change separately and fix up all the tests by deleting lines in test containing PointerAttributes.

[zturner]

I moved the patch for marking them const and removing the PointerAttributes field from the dump output to separate patches, so this is now much smaller.

[rnk]

lgtm, thanks!

llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

1901

Nice.

2465–2467

Every time we have to add a new method that routes around getTypeIndex and has to do its own TypeIndices.find check, I shed a tear. So far as I can tell, though, it's necessary.

[zturner]

llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

2465–2467

Yes, I was sad about this. One way we could have avoided it is if the DI Flags were on the pointer as well as (or instead of) being on the subroutine. Then we could have handled it inside of lowerTypePointer the same way I did for the constness.

[andrewrk]

I think this patch broke Zig's tests:

zig: /store/dev/llvm-project/llvm/include/llvm/Support/Casting.h:255: typename llvm::cast_retty<X, Y*>::ret_type llvm::cast(Y*) [with X = llvm::DIDerivedType; Y = const llvm::DIType; typename llvm::cast_retty<X, Y*>::ret_type = const llvm::DIDerivedType*]: Assertion `isa<X>(Val) && "cast<Ty>() argument of incompatible type!"' failed.
#0  0x00007ffff65d3264 in raise () from /nix/store/2kcrj1ksd2a14bm5sky182fv2xwfhfap-glibc-2.26-131/lib/libc.so.6
#1  0x00007ffff65d4665 in abort () from /nix/store/2kcrj1ksd2a14bm5sky182fv2xwfhfap-glibc-2.26-131/lib/libc.so.6
#2  0x00007ffff65cbce7 in __assert_fail_base () from /nix/store/2kcrj1ksd2a14bm5sky182fv2xwfhfap-glibc-2.26-131/lib/libc.so.6
#3  0x00007ffff65cbd92 in __assert_fail () from /nix/store/2kcrj1ksd2a14bm5sky182fv2xwfhfap-glibc-2.26-131/lib/libc.so.6
#4  0x0000000003ad313e in llvm::cast<llvm::DIDerivedType, llvm::DIType const> (Val=0xa9f98a8)
    at /store/dev/llvm-project/llvm/include/llvm/Support/Casting.h:255
#5  0x00000000049c498a in llvm::CodeViewDebug::getTypeIndexForThisPtr (this=0x1c865190, TypeRef=..., SubroutineTy=0xb640010)
    at /store/dev/llvm-project/llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp:2419
#6  0x00000000049c1f58 in llvm::CodeViewDebug::lowerTypeMemberFunction (this=0x1c865190, Ty=0xb640010, ClassTy=0x176a1b38, ThisAdjustment=0, 
    IsStaticMethod=false, FO=llvm::codeview::FunctionOptions::None) at /store/dev/llvm-project/llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp:1843
#7  0x00000000049ba3a8 in llvm::CodeViewDebug::getMemberFunctionType (this=0x1c865190, SP=0x1cc572c0, Class=0x176a1b38)
    at /store/dev/llvm-project/llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp:419
#8  0x00000000049b9e70 in llvm::CodeViewDebug::getFuncIdForSubprogram (this=0x1c865190, SP=0x1cc572c0)
    at /store/dev/llvm-project/llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp:355
#9  0x00000000049bddc1 in llvm::CodeViewDebug::emitDebugInfoForFunction (this=0x1c865190, GV=0x1c95d228, FI=...)
    at /store/dev/llvm-project/llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp:1011
#10 0x00000000049bac5f in llvm::CodeViewDebug::endModule (this=0x1c865190)
    at /store/dev/llvm-project/llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp:542
#11 0x0000000004922eb5 in llvm::AsmPrinter::doFinalization (this=0x16056300, M=...)
    at /store/dev/llvm-project/llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp:1450
#12 0x0000000005edd4cb in llvm::FPPassManager::doFinalization (this=0x18ed1ac0, M=...)
    at /store/dev/llvm-project/llvm/lib/IR/LegacyPassManager.cpp:1697
#13 0x0000000005edd9fd in (anonymous namespace)::MPPassManager::runOnModule (this=0x162b8150, M=...)
    at /store/dev/llvm-project/llvm/lib/IR/LegacyPassManager.cpp:1773
#14 0x0000000005eddf34 in llvm::legacy::PassManagerImpl::run (this=0x1a07c230, M=...)
    at /store/dev/llvm-project/llvm/lib/IR/LegacyPassManager.cpp:1857
#15 0x0000000005ede163 in llvm::legacy::PassManager::run (this=0x7fffffffaf60, M=...)
    at /store/dev/llvm-project/llvm/lib/IR/LegacyPassManager.cpp:1888
#16 0x0000000001d9b889 in ZigLLVMTargetMachineEmitToFile (targ_machine_ref=0xa9f1fe0, module_ref=0xa9f0180,

#5  0x00000000049c498a in llvm::CodeViewDebug::getTypeIndexForThisPtr (this=0x1c865190, TypeRef=..., SubroutineTy=0xb640010)
    at /store/dev/llvm-project/llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp:2419
2419      TypeIndex TI = lowerTypePointer(cast<DIDerivedType>(Ty), Options);
(gdb) p Ty->dump()
<0xa9f98a8> = !DIBasicType(name: "i32", size: 32, encoding: DW_ATE_signed)
$3 = void

#8  0x00000000049b9e70 in llvm::CodeViewDebug::getFuncIdForSubprogram (this=0x1c865190, SP=0x1cc572c0)
    at /store/dev/llvm-project/llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp:355
355                                    DisplayName);
(gdb) p DisplayName
$4 = {static npos = 18446744073709551615, Data = 0x1c985700 "StructWithNoFields_add", Length = 22}

#9  0x00000000049bddc1 in llvm::CodeViewDebug::emitDebugInfoForFunction (this=0x1c865190, GV=0x1c95d228, FI=...)
    at /store/dev/llvm-project/llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp:1011
1011        OS.EmitIntValue(getFuncIdForSubprogram(GV->getSubprogram()).getIndex(), 4);
(gdb) p GV->getSubprogram()
$5 = (llvm::DISubprogram *) 0x1cc572c0
(gdb) p GV->getSubprogram()->dump()
<0x1cc572c0> = distinct !DISubprogram(name: "StructWithNoFields_add", scope: <0x176a1b38>, file: <0xb1bf220>, line: 7, type: <0xb640010>, scopeLine: 7, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: <0xa9b7098>, retainedNodes: <0x1c87f3b0>)
$6 = void

Relevant excerpt from the module IR:

; Function Attrs: nobuiltin nounwind uwtable
define internal fastcc i32 @StructWithNoFields_add(i32, i32) unnamed_addr #0 !dbg !12316 {
Entry:
  %a = alloca i32, align 4
  %b = alloca i32, align 4
  store i32 %0, i32* %a, align 4
  call void @llvm.dbg.declare(metadata i32* %a, metadata !12319, metadata !DIExpression()), !dbg !12322
  store i32 %1, i32* %b, align 4
  call void @llvm.dbg.declare(metadata i32* %b, metadata !12320, metadata !DIExpression()), !dbg !12323
  %2 = load i32, i32* %a, align 4, !dbg !12324
  %3 = load i32, i32* %b, align 4, !dbg !12327
  %4 = call { i32, i1 } @llvm.sadd.with.overflow.i32(i32 %2, i32 %3), !dbg !12328
  %5 = extractvalue { i32, i1 } %4, 0, !dbg !12328
  %6 = extractvalue { i32, i1 } %4, 1, !dbg !12328
  br i1 %6, label %OverflowFail, label %OverflowOk, !dbg !12328

OverflowFail:                                     ; preds = %Entry
  tail call fastcc void @panic(%"[]u8"* @1141, %StackTrace* null), !dbg !12328
  unreachable, !dbg !12328

OverflowOk:                                       ; preds = %Entry
  ret i32 %5, !dbg !12329
}

attributes #0 = { nobuiltin nounwind uwtable "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" }


!1089 = !DIBasicType(name: "i32", size: 32, encoding: DW_ATE_signed)
!12316 = distinct !DISubprogram(name: "StructWithNoFields_add", scope: !12317, file: !621, line: 7, type: !4560, scopeLine: 7, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition, unit: !1, retainedNodes: !12318)
!12317 = !DICompositeType(tag: DW_TAG_structure_type, name: "StructWithNoFields", scope: !621, file: !621, line: 6, elements: !1259)
!12318 = !{!12319, !12320}
!12319 = !DILocalVariable(name: "a", arg: 1, scope: !12316, file: !621, line: 7, type: !1089)
!12320 = !DILocalVariable(name: "b", arg: 2, scope: !12321, file: !621, line: 7, type: !1089)

The same debug info, when using DWARF instead of CodeView, builds successfully.

Any clues as to something I'm doing wrong, or is this a regression in LLVM?

[rnk]

We can change the code to avoid the crash, but what debug info did you want clang to emit? It seems like the best way to describe StructWithNoFields_add is as a static method of the class StructWithNoFields, since it doesn't appear to have a 'this' parameter.

[rnk]

This shouldn't crash anymore after rL350073.

[andrewrk]

In D54667#1340985, @rnk wrote:

We can change the code to avoid the crash, but what debug info did you want clang to emit? It seems like the best way to describe StructWithNoFields_add is as a static method of the class StructWithNoFields, since it doesn't appear to have a 'this' parameter.

Thanks for the fix!

I think that is a good way to emit debug info. Here's the code from the frontend:

const StructWithNoFields = struct {
    fn add(a: i32, b: i32) i32 {
        return a + b;
    }
};

test "call struct static method" {
    const result = StructWithNoFields.add(3, 4);
    assert(result == 7);
}

In Zig, a struct acts as a namespace full of static functions, so what you said works perfectly.

I'm also open for suggestions if there was a better way to represent this in LLVM's debug info.

[rnk]

In D54667#1341110, @andrewrk wrote:

In Zig, a struct acts as a namespace full of static functions, so what you said works perfectly.

I'm also open for suggestions if there was a better way to represent this in LLVM's debug info.

In that case, you might want to add the DINode::FlagStaticMember flag to all your methods. If a DISubprogram lists a DICompositeType as its scope or is used as an element of the composite type, it gets treated as a C++-style method where the first argument is assumed to be 'this'. That's a very C++-centric way to do things, so it might be nicer if we explicitly marked C++ instance methods, but that's the way things are today and changing it would require thinking about backwards compatibility. >_>

The benefit of explicitly marking everything as a "static" method for zig is that if the first argument happens to be a pointer type it won't end up looking like an instance method.

[andrewrk]

In D54667#1341372, @rnk wrote:

In that case, you might want to add the DINode::FlagStaticMember flag to all your methods. If a DISubprogram lists a DICompositeType as its scope or is used as an element of the composite type, it gets treated as a C++-style method where the first argument is assumed to be 'this'. That's a very C++-centric way to do things, so it might be nicer if we explicitly marked C++ instance methods, but that's the way things are today and changing it would require thinking about backwards compatibility. >_>

The benefit of explicitly marking everything as a "static" method for zig is that if the first argument happens to be a pointer type it won't end up looking like an instance method.

Thank you for the advice! We made this change downstream.

lldb/lit/SymbolFile/NativePDB/member-function-types.cpp

 // clang-format off
 // REQUIRES: lld
 
 // RUN: clang-cl -m32 /Z7 /GS- /GR- /c -Xclang -fkeep-static-consts /Fo%t.obj -- %s
 // RUN: lld-link /DEBUG /nodefaultlib /entry:main /OUT:%t.exe /PDB:%t.pdb -- %t.obj
 // RUN: env LLDB_USE_NATIVE_PDB_READER=1 lldb -f %t.exe -s \
 // RUN:     %p/Inputs/member-function-types.lldbinit | FileCheck %s
 
 struct Foo {
   static void StaticFn() {}
   void MemberFn() { }
   void ConstFn() const {}
   void ConstVolFn() const volatile {}
-  void RefFn() && {}
+
+  void Overloaded(int x) {}
+  void Overloaded(int x) const {}
+  void Overloaded(double x) {}
+
+  void RefOverload(double x) & {}
+  void RefOverload(double x) && {}
+
+  int DataMember = 0;
 };
 
 auto sfn = &Foo::StaticFn;
 
 auto mfn = &Foo::MemberFn;
 
 auto cfn = &Foo::ConstFn;
 
 auto cvfn = &Foo::ConstVolFn;
 
-auto rfn = &Foo::RefFn;
+auto dm = &Foo::DataMember;
 
 int main(int argc, char **argv) {
   return 0;
 }

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

enum class PointerMode : uint8_t {
   LValueReference = 0x01,         // "old" reference
   PointerToDataMember = 0x02,     // pointer to data member
   PointerToMemberFunction = 0x03, // pointer to member function
   RValueReference = 0x04          // r-value reference
 };
 
 /// Equivalent to misc lfPointerAttr bitfields.
 enum class PointerOptions : uint32_t {
-  None = 0x00000000,
-  Flat32 = 0x00000100,
-  Volatile = 0x00000200,
-  Const = 0x00000400,
-  Unaligned = 0x00000800,
-  Restrict = 0x00001000,
-  WinRTSmartPointer = 0x00080000
+  None = 0x00,
+  Flat32 = 0x01,
+  Volatile = 0x02,
+  Const = 0x04,
+  Unaligned = 0x08,
+  Restrict = 0x10,
 };
 CV_DEFINE_ENUM_CLASS_FLAGS_OPERATORS(PointerOptions)
 
+enum class PointerQualifier : uint32_t {
+  None = 0x0,
+  WinRTSmartPointer = 0x01,
+  ThisPtrLValueRef = 0x02,
+  ThisPtrRValueRef = 0x04
+};
+CV_DEFINE_ENUM_CLASS_FLAGS_OPERATORS(PointerQualifier)
+
 /// Equivalent to CV_pmtype_e.
 enum class PointerToMemberRepresentation : uint16_t {
   Unknown = 0x00,                     // not specified (pre VC8)
   SingleInheritanceData = 0x01,       // member data, single inheritance
   MultipleInheritanceData = 0x02,     // member data, multiple inheritance
   VirtualInheritanceData = 0x03,      // member data, virtual inheritance
   GeneralData = 0x04,                 // member data, most general
   SingleInheritanceFunction = 0x05,   // member function, single inheritance

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

public:
   ArrayRef<TypeIndex> getIndices() const { return StringIndices; }
 
   std::vector<TypeIndex> StringIndices;
 };
 
 // LF_POINTER
 class PointerRecord : public TypeRecord {
 public:
+  // See the lfPointer::lfPointerAttr enumeration in cvinfo.h
+  // ---------------------------XXXXX
   static const uint32_t PointerKindShift = 0;
   static const uint32_t PointerKindMask = 0x1F;
 
+  // ------------------------XXX-----
   static const uint32_t PointerModeShift = 5;
   static const uint32_t PointerModeMask = 0x07;
 
-  static const uint32_t PointerOptionMask = 0xFF;
+  // -------------------XXXXX--------
+  static const uint32_t PointerOptionShift = 8;
+  static const uint32_t PointerOptionMask = 0x1F;
 
+  // -------------XXXXXX-------------
   static const uint32_t PointerSizeShift = 13;
-  static const uint32_t PointerSizeMask = 0xFF;
+  static const uint32_t PointerSizeMask = 0x3F;
+
+  // ----------XXX-------------------
+  static const uint32_t PointerQualifierShift = 19;
+  static const uint32_t PointerQualifierMask = 0x07;
 
   PointerRecord() = default;
   explicit PointerRecord(TypeRecordKind Kind) : TypeRecord(Kind) {}
 
   PointerRecord(TypeIndex ReferentType, uint32_t Attrs)
       : TypeRecord(TypeRecordKind::Pointer), ReferentType(ReferentType),
         Attrs(Attrs) {}
 
   PointerRecord(TypeIndex ReferentType, PointerKind PK, PointerMode PM,
-                PointerOptions PO, uint8_t Size)
+                PointerOptions PO, PointerQualifier PQ, uint8_t Size)
       : TypeRecord(TypeRecordKind::Pointer), ReferentType(ReferentType),
-        Attrs(calcAttrs(PK, PM, PO, Size)) {}
+        Attrs(calcAttrs(PK, PM, PO, PQ, Size)) {}
 
   PointerRecord(TypeIndex ReferentType, PointerKind PK, PointerMode PM,
-                PointerOptions PO, uint8_t Size, const MemberPointerInfo &MPI)
+                PointerOptions PO, PointerQualifier PQ, uint8_t Size,
+                const MemberPointerInfo &MPI)
       : TypeRecord(TypeRecordKind::Pointer), ReferentType(ReferentType),
-        Attrs(calcAttrs(PK, PM, PO, Size)), MemberInfo(MPI) {}
+        Attrs(calcAttrs(PK, PM, PO, PQ, Size)), MemberInfo(MPI) {}
 
   TypeIndex getReferentType() const { return ReferentType; }
 
   PointerKind getPointerKind() const {
     return static_cast<PointerKind>((Attrs >> PointerKindShift) &
                                     PointerKindMask);
   }
 
   PointerMode getMode() const {
     return static_cast<PointerMode>((Attrs >> PointerModeShift) &
                                     PointerModeMask);
   }
 
   PointerOptions getOptions() const {
-    return static_cast<PointerOptions>(Attrs);
+    return static_cast<PointerOptions>((Attrs >> PointerOptionShift) &
+                                       PointerOptionMask);
+  }
+
+  PointerQualifier getQualifier() const {
+    return static_cast<PointerQualifier>((Attrs >> PointerQualifierShift) &
+                                         PointerQualifierMask);
   }
 
   uint8_t getSize() const {
     return (Attrs >> PointerSizeShift) & PointerSizeMask;
   }
 
   MemberPointerInfo getMemberInfo() const { return *MemberInfo; }
 
   bool isPointerToMember() const {
     return getMode() == PointerMode::PointerToDataMember ||
            getMode() == PointerMode::PointerToMemberFunction;
   }
 
-  bool isFlat() const { return !!(Attrs & uint32_t(PointerOptions::Flat32)); }
-  bool isConst() const { return !!(Attrs & uint32_t(PointerOptions::Const)); }
+  bool isFlat() const {
+    return (getOptions() & PointerOptions::Flat32) != PointerOptions::None;
+  }
+  bool isConst() const {
+    return (getOptions() & PointerOptions::Const) != PointerOptions::None;
+  }
 
   bool isVolatile() const {
-    return !!(Attrs & uint32_t(PointerOptions::Volatile));
+    return (getOptions() & PointerOptions::Volatile) != PointerOptions::None;
   }
 
   bool isUnaligned() const {
-    return !!(Attrs & uint32_t(PointerOptions::Unaligned));
+    return (getOptions() & PointerOptions::Unaligned) != PointerOptions::None;
   }
 
   bool isRestrict() const {
-    return !!(Attrs & uint32_t(PointerOptions::Restrict));
+    return (getOptions() & PointerOptions::Restrict) != PointerOptions::None;
+  }
+
+  bool isThisPtrLValueRefQual() const {
+    return (getQualifier() & PointerQualifier::ThisPtrLValueRef) !=
+           PointerQualifier::None;
+  }
+
+  bool isThisPtrRValueRefQual() const {
+    return (getQualifier() & PointerQualifier::ThisPtrRValueRef) !=
+           PointerQualifier::None;
   }
 
   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);
+                PointerQualifier PQ, uint8_t Size) {
+    Attrs = calcAttrs(PK, PM, PO, PQ, Size);
   }
 
 private:
   static uint32_t calcAttrs(PointerKind PK, PointerMode PM, PointerOptions PO,
-                            uint8_t Size) {
+                            PointerQualifier PQ, uint8_t Size) {
     uint32_t A = 0;
     A |= static_cast<uint32_t>(PK);
-    A |= static_cast<uint32_t>(PO);
+    A |= (static_cast<uint32_t>(PO) << PointerOptionShift);
     A |= (static_cast<uint32_t>(PM) << PointerModeShift);
     A |= (static_cast<uint32_t>(Size) << PointerSizeShift);
+    A |= (static_cast<uint32_t>(PQ) << PointerQualifierShift);
     return A;
   }
 };
 
 // LF_NESTTYPE
 class NestedTypeRecord : public TypeRecord {
 public:
   NestedTypeRecord() = default;

llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.h

class LLVM_LIBRARY_VISIBILITY CodeViewDebug : public DebugHandlerBase {
 
   /// Translates the DIType to codeview if necessary and returns a type index
   /// for it.
   codeview::TypeIndex getTypeIndex(DITypeRef TypeRef,
                                    DITypeRef ClassTyRef = DITypeRef());
 
   codeview::TypeIndex getTypeIndexForReferenceTo(DITypeRef TypeRef);
 
+  codeview::TypeIndex
+  getTypeIndexForThisPtr(DITypeRef TypeRef,
+                         const DISubroutineType *SubroutineTy);
+
   codeview::TypeIndex getMemberFunctionType(const DISubprogram *SP,
                                             const DICompositeType *Class);
 
   codeview::TypeIndex getScopeIndex(const DIScope *Scope);
 
   codeview::TypeIndex getVBPTypeIndex();
 
   void addToUDTs(const DIType *Ty);
 
   void addUDTSrcLine(const DIType *Ty, codeview::TypeIndex TI);
 
   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::PointerOptions PO = codeview::PointerOptions::None);
+      codeview::PointerOptions PO = codeview::PointerOptions::None,
+      codeview::PointerQualifier PQ = codeview::PointerQualifier::None);
   codeview::TypeIndex lowerTypeMemberPointer(
       const DIDerivedType *Ty,
       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,

llvm/lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

if ((STK == SimpleTypeKind::SignedCharacter ||
        STK == SimpleTypeKind::UnsignedCharacter) &&
       Ty->getName() == "char")
     STK = SimpleTypeKind::NarrowCharacter;
 
   return TypeIndex(STK);
 }
 
 TypeIndex CodeViewDebug::lowerTypePointer(const DIDerivedType *Ty,
-                                          PointerOptions PO) {
+                                          PointerOptions PO,
+                                          PointerQualifier PQ) {
   TypeIndex PointeeTI = getTypeIndex(Ty->getBaseType());
 
   // 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
TypeIndex CodeViewDebug::lowerTypePointer(const DIDerivedType *Ty,
   case dwarf::DW_TAG_reference_type:
     PM = PointerMode::LValueReference;
     break;
   case dwarf::DW_TAG_rvalue_reference_type:
     PM = PointerMode::RValueReference;
     break;
   }
 
-  PointerRecord PR(PointeeTI, PK, PM, PO, Ty->getSizeInBits() / 8);
+  PointerRecord PR(PointeeTI, PK, PM, PO, PQ, 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, use the unknown model instead of the general model.
TypeIndex CodeViewDebug::lowerTypeMemberPointer(const DIDerivedType *Ty,
   bool IsPMF = isa<DISubroutineType>(Ty->getBaseType());
   PointerMode PM = IsPMF ? PointerMode::PointerToMemberFunction
                          : PointerMode::PointerToDataMember;
 
   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);
+  PointerRecord PR(PointeeTI, PK, PM, PO, PointerQualifier::None, 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;

 TypeIndex CodeViewDebug::lowerTypeMemberFunction(const DISubroutineType *Ty,
                                                  const DIType *ClassTy,
                                                  int ThisAdjustment,
                                                  bool IsStaticMethod,
                                                  FunctionOptions FO) {
   // Lower the containing class type.
   TypeIndex ClassType = getTypeIndex(ClassTy);
 
-  SmallVector<TypeIndex, 8> ReturnAndArgTypeIndices;
-  for (DITypeRef ArgTypeRef : Ty->getTypeArray())
-    ReturnAndArgTypeIndices.push_back(getTypeIndex(ArgTypeRef));
+  DITypeRefArray ReturnAndArgs = Ty->getTypeArray();
 
-  // MSVC uses type none for variadic argument.
-  if (ReturnAndArgTypeIndices.size() > 1 &&
-      ReturnAndArgTypeIndices.back() == TypeIndex::Void()) {
-    ReturnAndArgTypeIndices.back() = TypeIndex::None();
-  }
-  TypeIndex ReturnTypeIndex = TypeIndex::Void();
-  ArrayRef<TypeIndex> ArgTypeIndices = None;
-  if (!ReturnAndArgTypeIndices.empty()) {
-    auto ReturnAndArgTypesRef = makeArrayRef(ReturnAndArgTypeIndices);
-    ReturnTypeIndex = ReturnAndArgTypesRef.front();
-    ArgTypeIndices = ReturnAndArgTypesRef.drop_front();
-  }
+  unsigned Index = 0;
+  SmallVector<TypeIndex, 8> ArgTypeIndices;
+  TypeIndex ReturnTypeIndex = getTypeIndex(ReturnAndArgs[Index++]);
   TypeIndex ThisTypeIndex;
-  if (!IsStaticMethod && !ArgTypeIndices.empty()) {
-    ThisTypeIndex = ArgTypeIndices.front();
-    ArgTypeIndices = ArgTypeIndices.drop_front();
+  if (!IsStaticMethod && ReturnAndArgs.size() > 1)
+    ThisTypeIndex = getTypeIndexForThisPtr(ReturnAndArgs[Index++], Ty);
+
+  while (Index < ReturnAndArgs.size())
+    ArgTypeIndices.push_back(getTypeIndex(ReturnAndArgs[Index++]));
+
+  // MSVC uses type none for variadic argument.
+  if (!ArgTypeIndices.empty() && ArgTypeIndices.back() == TypeIndex::Void()) {
+    ArgTypeIndices.back() = TypeIndex::None();
   }
 
   ArgListRecord ArgListRec(TypeRecordKind::ArgList, ArgTypeIndices);
   TypeIndex ArgListIndex = TypeTable.writeLeafType(ArgListRec);
 
   CallingConvention CC = dwarfCCToCodeView(Ty->getCC());
 
   MemberFunctionRecord MFR(ReturnTypeIndex, ClassType, ThisTypeIndex, CC, FO,
                            ArgTypeIndices.size(), ArgListIndex, ThisAdjustment);
   return TypeTable.writeLeafType(MFR);
 }
 
 TypeIndex CodeViewDebug::lowerTypeVFTableShape(const DIDerivedType *Ty) {
if (!VBPType.getIndex()) {
     // Make a 'const int *' type.
     ModifierRecord MR(TypeIndex::Int32(), ModifierOptions::Const);
     TypeIndex ModifiedTI = TypeTable.writeLeafType(MR);
 
     PointerKind PK = getPointerSizeInBytes() == 8 ? PointerKind::Near64
                                                   : PointerKind::Near32;
     PointerMode PM = PointerMode::Pointer;
     PointerOptions PO = PointerOptions::None;
-    PointerRecord PR(ModifiedTI, PK, PM, PO, getPointerSizeInBytes());
+    PointerRecord PR(ModifiedTI, PK, PM, PO, PointerQualifier::None,
+                     getPointerSizeInBytes());
     VBPType = TypeTable.writeLeafType(PR);
   }
 
   return VBPType;
 }
 
 TypeIndex CodeViewDebug::getTypeIndex(DITypeRef TypeRef, DITypeRef ClassTyRef) {
   const DIType *Ty = TypeRef.resolve();
TypeIndex CodeViewDebug::getTypeIndex(DITypeRef TypeRef, DITypeRef ClassTyRef) {
   if (I != TypeIndices.end())
     return I->second;
 
   TypeLoweringScope S(*this);
   TypeIndex TI = lowerType(Ty, ClassTy);
   return recordTypeIndexForDINode(Ty, TI, ClassTy);
 }
 
+TypeIndex
+CodeViewDebug::getTypeIndexForThisPtr(DITypeRef TypeRef,
+                                      const DISubroutineType *SubroutineTy) {
+  const DIType *Ty = TypeRef.resolve();
+
+  PointerQualifier PQ = PointerQualifier::None;
+  if (SubroutineTy->getFlags() & DINode::DIFlags::FlagLValueReference)
+    PQ = PointerQualifier::ThisPtrLValueRef;
+  else if (SubroutineTy->getFlags() & DINode::DIFlags::FlagRValueReference)
+    PQ = PointerQualifier::ThisPtrRValueRef;
+
+  // Check if we've already translated this type.  If there is no ref qualifier
+  // on the function then we look up this pointer type with no associated class
+  // so that the TypeIndex for the this pointer can be shared with the type
+  // index for other pointers to this class type.  If there is a ref qualifier
+  // then we lookup the pointer using the subroutine as the parent type.
+  const DIType *ParentTy = nullptr;
+  if (PQ != PointerQualifier::None)
+    ParentTy = SubroutineTy;
+
+  auto I = TypeIndices.find({Ty, ParentTy});
+  if (I != TypeIndices.end())
+    return I->second;
+
+  assert(Ty->getTag() == dwarf::DW_TAG_pointer_type);
+
+  TypeLoweringScope S(*this);
+  TypeIndex TI =
+      lowerTypePointer(cast<DIDerivedType>(Ty), PointerOptions::Const, PQ);
+  return recordTypeIndexForDINode(Ty, TI, ParentTy);
+}
+
 TypeIndex CodeViewDebug::getTypeIndexForReferenceTo(DITypeRef TypeRef) {
   DIType *Ty = TypeRef.resolve();
   PointerRecord PR(getTypeIndex(Ty),
                    getPointerSizeInBytes() == 8 ? PointerKind::Near64
                                                 : PointerKind::Near32,
                    PointerMode::LValueReference, PointerOptions::None,
-                   Ty->getSizeInBits() / 8);
+                   PointerQualifier::None, Ty->getSizeInBits() / 8);
   return TypeTable.writeLeafType(PR);
 }
 
 TypeIndex CodeViewDebug::getCompleteTypeIndex(DITypeRef TypeRef) {
   const DIType *Ty = TypeRef.resolve();
 
   // The null DIType is the void type. Don't try to hash it.
   if (!Ty)

llvm/lib/DebugInfo/CodeView/TypeDumpVisitor.cpp

Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, TypeServer2Record &TS) {
   W->printString("Guid", formatv("{0}", TS.getGuid()).str());
   W->printNumber("Age", TS.getAge());
   W->printString("Name", TS.getName());
   return Error::success();
 }
 
 Error TypeDumpVisitor::visitKnownRecord(CVType &CVR, PointerRecord &Ptr) {
   printTypeIndex("PointeeType", Ptr.getReferentType());
-  W->printHex("PointerAttributes", uint32_t(Ptr.getOptions()));
   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("IsThisPtr&", Ptr.isThisPtrLValueRefQual());
+  W->printNumber("IsThisPtr&&", Ptr.isThisPtrRValueRefQual());
   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/lib/ObjectYAML/CodeViewYAMLTypes.cpp

 void ScalarBitSetTraits<PointerOptions>::bitset(IO &IO,
                                                 PointerOptions &Options) {
   IO.bitSetCase(Options, "None", PointerOptions::None);
   IO.bitSetCase(Options, "Flat32", PointerOptions::Flat32);
   IO.bitSetCase(Options, "Volatile", PointerOptions::Volatile);
   IO.bitSetCase(Options, "Const", PointerOptions::Const);
   IO.bitSetCase(Options, "Unaligned", PointerOptions::Unaligned);
   IO.bitSetCase(Options, "Restrict", PointerOptions::Restrict);
-  IO.bitSetCase(Options, "WinRTSmartPointer",
-                PointerOptions::WinRTSmartPointer);
 }
 
 void ScalarBitSetTraits<ModifierOptions>::bitset(IO &IO,
                                                  ModifierOptions &Options) {
   IO.bitSetCase(Options, "None", ModifierOptions::None);
   IO.bitSetCase(Options, "Const", ModifierOptions::Const);
   IO.bitSetCase(Options, "Volatile", ModifierOptions::Volatile);
   IO.bitSetCase(Options, "Unaligned", ModifierOptions::Unaligned);

llvm/test/DebugInfo/COFF/defer-complete-type.ll

 ; CHECK:     VShape: 0x0
 ; CHECK:     SizeOf: 0
 ; CHECK:     Name: A
 ; CHECK:     LinkageName: .?AUA@@
 ; CHECK:   }
 ; CHECK:   Pointer (0x1001) {
 ; CHECK:     TypeLeafKind: LF_POINTER (0x1002)
 ; CHECK:     PointeeType: A (0x1000)
-; CHECK:     PointerAttributes: 0x1000C
 ; CHECK:     PtrType: Near64 (0xC)
 ; CHECK:     PtrMode: Pointer (0x0)
 ; CHECK:     IsFlat: 0
 ; CHECK:     IsConst: 0
 ; CHECK:     IsVolatile: 0
 ; CHECK:     IsUnaligned: 0
 ; CHECK:     SizeOf: 8
 ; CHECK:   }

 ; CHECK:     VShape: 0x0
 ; CHECK:     SizeOf: 0
 ; CHECK:     Name: B
 ; CHECK:     LinkageName: .?AUB@@
 ; CHECK:   }
 ; CHECK:   Pointer (0x1005) {
 ; CHECK:     TypeLeafKind: LF_POINTER (0x1002)
 ; CHECK:     PointeeType: B (0x1004)
-; CHECK:     PointerAttributes: 0x1000C
 ; CHECK:     PtrType: Near64 (0xC)
 ; CHECK:     PtrMode: Pointer (0x0)
 ; CHECK:     IsFlat: 0
 ; CHECK:     IsConst: 0
 ; CHECK:     IsVolatile: 0
 ; CHECK:     IsUnaligned: 0
 ; CHECK:     SizeOf: 8
 ; CHECK:   }

llvm/test/DebugInfo/COFF/function-options.ll

 ; CHECK:     ]
 ; CHECK:     NumParameters: 1
 ; CHECK:     ArgListType: (BClass&) ({{.*}})
 ; CHECK:   }
 ; CHECK:   MemberFunction ([[MF1:.*]]) {
 ; CHECK:     TypeLeafKind: LF_MFUNCTION (0x1009)
 ; CHECK:     ReturnType: void (0x3)
 ; CHECK:     ClassType: BClass ({{.*}})
-; CHECK:     ThisType: BClass* ({{.*}})
+; CHECK:     ThisType: BClass* const ({{.*}})
 ; CHECK:     CallingConvention: NearC (0x0)
 ; CHECK:     FunctionOptions [ (0x2)
 ; CHECK:       Constructor (0x2)
 ; CHECK:     ]
 ; CHECK:     NumParameters: 0
 ; CHECK:     ArgListType: () ({{.*}})
 ; CHECK:     ThisAdjustment: 0
 ; CHECK:   }

 ; CHECK:     ]
 ; CHECK:     NumParameters: 1
 ; CHECK:     ArgListType: (C1Class&) ({{.*}})
 ; CHECK:   }
 ; CHECK:   MemberFunction ([[MF2:.*]]) {
 ; CHECK:     TypeLeafKind: LF_MFUNCTION (0x1009)
 ; CHECK:     ReturnType: void (0x3)
 ; CHECK:     ClassType: C1Class ({{.*}})
-; CHECK:     ThisType: C1Class* ({{.*}})
+; CHECK:     ThisType: C1Class* const ({{.*}})
 ; CHECK:     CallingConvention: NearC (0x0)
 ; CHECK:     FunctionOptions [ (0x0)
 ; CHECK:     ]
 ; CHECK:     NumParameters: 0
 ; CHECK:     ArgListType: () ({{.*}})
 ; CHECK:     ThisAdjustment: 0
 ; CHECK:   }
 ; CHECK:   FieldList ({{.*}}) {

 ; CHECK:     ]
 ; CHECK:     NumParameters: 1
 ; CHECK:     ArgListType: (C2Class&) ({{.*}})
 ; CHECK:   }
 ; CHECK:   MemberFunction ([[MF3:.*]]) {
 ; CHECK:     TypeLeafKind: LF_MFUNCTION (0x1009)
 ; CHECK:     ReturnType: void (0x3)
 ; CHECK:     ClassType: C2Class ({{.*}})
-; CHECK:     ThisType: C2Class* ({{.*}})
+; CHECK:     ThisType: C2Class* const ({{.*}})
 ; CHECK:     CallingConvention: NearC (0x0)
 ; CHECK:     FunctionOptions [ (0x0)
 ; CHECK:     ]
 ; CHECK:     NumParameters: 0
 ; CHECK:     ArgListType: () ({{.*}})
 ; CHECK:     ThisAdjustment: 0
 ; CHECK:   }
 ; CHECK:   FieldList ({{.*}}) {

 ; CHECK:     ]
 ; CHECK:     NumParameters: 1
 ; CHECK:     ArgListType: (BStruct&) ({{.*}})
 ; CHECK:   }
 ; CHECK:   MemberFunction ([[MF4:.*]]) {
 ; CHECK:     TypeLeafKind: LF_MFUNCTION (0x1009)
 ; CHECK:     ReturnType: void (0x3)
 ; CHECK:     ClassType: BStruct ({{.*}})
-; CHECK:     ThisType: BStruct* ({{.*}})
+; CHECK:     ThisType: BStruct* const ({{.*}})
 ; CHECK:     CallingConvention: NearC (0x0)
 ; CHECK:     FunctionOptions [ (0x2)
 ; CHECK:       Constructor (0x2)
 ; CHECK:     ]
 ; CHECK:     NumParameters: 0
 ; CHECK:     ArgListType: () ({{.*}})
 ; CHECK:     ThisAdjustment: 0
 ; CHECK:   }

 ; CHECK:     ]
 ; CHECK:     NumParameters: 1
 ; CHECK:     ArgListType: (BUnion&) ({{.*}})
 ; CHECK:   }
 ; CHECK:   MemberFunction ([[MF5:.*]]) {
 ; CHECK:     TypeLeafKind: LF_MFUNCTION (0x1009)
 ; CHECK:     ReturnType: void (0x3)
 ; CHECK:     ClassType: BUnion ({{.*}})
-; CHECK:     ThisType: BUnion* ({{.*}})
+; CHECK:     ThisType: BUnion* const ({{.*}})
 ; CHECK:     CallingConvention: NearC (0x0)
 ; CHECK:     FunctionOptions [ (0x0)
 ; CHECK:     ]
 ; CHECK:     NumParameters: 0
 ; CHECK:     ArgListType: () ({{.*}})
 ; CHECK:     ThisAdjustment: 0
 ; CHECK:   }
 ; CHECK:   FieldList ({{.*}}) {

llvm/test/DebugInfo/COFF/global-type-hashes.ll

 ; YAML:           Name:            Foo
 ; YAML:           UniqueName:      '.?AUFoo@@'
 ; YAML:           DerivationList:  0
 ; YAML:           VTableShape:     0
 ; YAML:           Size:            0
 ; YAML:       - Kind:            LF_POINTER
 ; YAML:         Pointer:
 ; YAML:           ReferentType:    4100
-; YAML:           Attrs:           32778
+; YAML:           Attrs:           33802
 ; YAML:       - Kind:            LF_ARGLIST
 ; YAML:         ArgList:
 ; YAML:           ArgIndices:      [ 116, 116 ]
 ; YAML:       - Kind:            LF_MFUNCTION
 ; YAML:         MemberFunction:
 ; YAML:           ReturnType:      3
 ; YAML:           ClassType:       4100
 ; YAML:           ThisType:        4101

 ; YAML:           UDT:             4107
 ; YAML:           SourceFile:      4108
 ; YAML:           LineNumber:      1
 ; YAML:       - Kind:            LF_MFUNC_ID
 ; YAML:         MemberFuncId:
 ; YAML:           ClassType:       4100
 ; YAML:           FunctionType:    4103
 ; YAML:           Name:            Foo
+; YAML:       - Kind:            LF_POINTER
+; YAML:         Pointer:         
+; YAML:           ReferentType:    4100
+; YAML:           Attrs:           32778
 ; YAML:       - Kind:            LF_MFUNC_ID
 ; YAML:         MemberFuncId:
 ; YAML:           ClassType:       4100
 ; YAML:           FunctionType:    4105
 ; YAML:           Name:            method
 ; YAML:   - Name:            '.debug$H'
 ; YAML:     Characteristics: [ IMAGE_SCN_CNT_INITIALIZED_DATA, IMAGE_SCN_MEM_DISCARDABLE, IMAGE_SCN_MEM_READ ]
 ; YAML:     Alignment:       4
 ; YAML:     GlobalHashes:
 ; YAML:       Version:         0
 ; YAML:       HashAlgorithm:   1
 ; YAML:       HashValues:
 ; YAML:         - 800309EE1ED8BB5B
 ; YAML:         - 5397319F1CC14E2C
 ; YAML:         - DF04AA3125BBC50E
 ; YAML:         - 95CEBA304A2C4493
 ; YAML:         - C324F82D24D22283
-; YAML:         - 74698BE366891D3D
+; YAML:         - BB039258F2425BCF
 ; YAML:         - DDE23757322DB7C3
-; YAML:         - 1692305447C3D360
+; YAML:         - C935E8E1F016CC27
 ; YAML:         - D341E2F9BE57A1C7
-; YAML:         - 243F76AED6D8FB79
-; YAML:         - C75E2FD5D79D363D
-; YAML:         - 30FB9353B361B4B8
+; YAML:         - DD327744BE6783A4
+; YAML:         - 479521BB013A4AEC
+; YAML:         - 7820AAA31FC8CC67
 ; YAML:         - 0634944401BCC520
-; YAML:         - DF0B7BE0B5AD5B4F
-; YAML:         - 0916E74F3860DA92
-; YAML:         - 17D3CDC3384402DD
+; YAML:         - F380373F5DE8E9A3
+; YAML:         - 2ADB463E9E726E20
+; YAML:         - 74698BE366891D3D
+; YAML:         - 4470750F2E319329
+; YAML:         - 0FB556FD1FAB66D7
+; YAML:         - 5970EFB4874D0F3F
+; YAML:         - EDB1D74C120CF44A
 ; ...
 
 
 ; ASM:      .section        .debug$H,"dr"
 ; ASM-NEXT: .p2align        2
 ; ASM-NEXT: .long   20171205                # Magic
 ; ASM-NEXT: .short  0                       # Section Version
 ; ASM-NEXT: .short  1                       # Hash Algorithm
 ; ASM-NEXT: .byte   0x80, 0x03, 0x09, 0xee  # 0x1000 [800309EE1ED8BB5B]
 ; ASM-NEXT: .byte   0x1e, 0xd8, 0xbb, 0x5b
 ; ASM-NEXT: .byte   0x53, 0x97, 0x31, 0x9f  # 0x1001 [5397319F1CC14E2C]
 ; ASM-NEXT: .byte   0x1c, 0xc1, 0x4e, 0x2c
 ; ASM-NEXT: .byte   0xdf, 0x04, 0xaa, 0x31  # 0x1002 [DF04AA3125BBC50E]

llvm/test/DebugInfo/COFF/globals.ll

 ; OBJ:     ModifiedType: int (0x74)
 ; OBJ:     Modifiers [ (0x1)
 ; OBJ:       Const (0x1)
 ; OBJ:     ]
 ; OBJ:   }
 ; OBJ:   Pointer (0x1001) {
 ; OBJ:     TypeLeafKind: LF_POINTER (0x1002)
 ; OBJ:     PointeeType: const int (0x1000)
-; OBJ:     PointerAttributes: 0x1000C
 ; OBJ:     PtrType: Near64 (0xC)
 ; OBJ:     PtrMode: Pointer (0x0)
 ; OBJ:     IsFlat: 0
 ; OBJ:     IsConst: 0
 ; OBJ:     IsVolatile: 0
 ; OBJ:     IsUnaligned: 0
 ; OBJ:   }
 ; OBJ: ]

llvm/test/DebugInfo/COFF/static-methods.ll

 ; CHECK-NEXT:    NumParameters: 0
 ; CHECK-NEXT:    ArgListType: () ({{.*}})
 ; CHECK-NEXT:    ThisAdjustment: 0
 ; CHECK-NEXT:  }
 ; CHECK:       MemberFunction ([[INSTANCE_VOID:0x.*]]) {
 ; CHECK-NEXT:    TypeLeafKind: LF_MFUNCTION (0x1009)
 ; CHECK-NEXT:    ReturnType: void (0x3)
 ; CHECK-NEXT:    ClassType: A ({{.*}})
-; CHECK-NEXT:    ThisType: A* ({{.*}})
+; CHECK-NEXT:    ThisType: A* const ({{.*}})
 ; CHECK-NEXT:    CallingConvention: ThisCall (0xB)
 ; CHECK-NEXT:    FunctionOptions [ (0x0)
 ; CHECK-NEXT:    ]
 ; CHECK-NEXT:    NumParameters: 0
 ; CHECK-NEXT:    ArgListType: () ({{.*}})
 ; CHECK-NEXT:    ThisAdjustment: 0
 ; CHECK-NEXT:  }
 ; CHECK:       MemberFunction ([[STATIC_TWO:0x.*]]) {

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

 ; 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:     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:     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:     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:     IsConst: 1
 ; 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:     ThisType: h::Foo* const (0x1017)
 ; CHECK:     CallingConvention: NearC (0x0)
 ; CHECK:     FunctionOptions [ (0x0)
 ; CHECK:     ]
 ; CHECK:     NumParameters: 1
 ; CHECK:     ArgListType: (int) (0x1018)
 ; CHECK:     ThisAdjustment: 0
 ; CHECK:   }
 ; CHECK:   FieldList (0x101A) {

 ; 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:   Pointer (0x1020) {
+; CHECK:     TypeLeafKind: LF_POINTER (0x1002)
+; CHECK:     PointeeType: h::Foo (0x1016)
+; CHECK:     PtrType: Near64 (0xC)
+; CHECK:     PtrMode: Pointer (0x0)
+; CHECK:     IsFlat: 0
+; CHECK:     IsConst: 0
+; CHECK:     IsVolatile: 0
+; CHECK:     IsUnaligned: 0
+; CHECK:     SizeOf: 8
+; CHECK:   }
+; CHECK:   Modifier (0x1021) {
 ; CHECK:     TypeLeafKind: LF_MODIFIER (0x1001)
 ; CHECK:     ModifiedType: char (0x70)
 ; CHECK:     Modifiers [ (0x1)
 ; CHECK:       Const (0x1)
 ; CHECK:     ]
 ; CHECK:   }
-; CHECK:   Array (0x1021) {
+; CHECK:   Array (0x1022) {
 ; CHECK:     TypeLeafKind: LF_ARRAY (0x1503)
-; CHECK:     ElementType: const char (0x1020)
+; CHECK:     ElementType: const char (0x1021)
 ; CHECK:     IndexType: unsigned __int64 (0x23)
 ; CHECK:     SizeOf: 4
 ; CHECK:     Name:
 ; CHECK:   }
 ; CHECK: ]
 
 ; CHECK-LABEL: CodeViewDebugInfo [
 ; CHECK-NEXT:   Section: .debug$S (6)

llvm/test/DebugInfo/COFF/types-array-advanced.ll

 ; CHECK:     ElementType: int (0x74)
 ; CHECK:     IndexType: unsigned long (0x22)
 ; CHECK:     SizeOf: 0
 ; CHECK:     Name: 
 ; CHECK:   }
 ; CHECK:   Pointer (0x1004) {
 ; CHECK:     TypeLeafKind: LF_POINTER (0x1002)
 ; CHECK:     PointeeType: 0x1003
-; CHECK:     PointerAttributes: 0x2A
 ; CHECK:     PtrType: Near32 (0xA)
 ; CHECK:     PtrMode: LValueReference (0x1)
 ; CHECK:     IsFlat: 0
 ; CHECK:     IsConst: 0
 ; CHECK:     IsVolatile: 0
 ; CHECK:     IsUnaligned: 0
 ; CHECK:     SizeOf: 0
 ; CHECK:   }

 ; CHECK:     ElementType: incomplete_struct (0x1008)
 ; CHECK:     IndexType: unsigned long (0x22)
 ; CHECK:     SizeOf: 12
 ; CHECK:     Name: 
 ; CHECK:   }
 ; CHECK:   Pointer (0x100A) {
 ; CHECK:     TypeLeafKind: LF_POINTER (0x1002)
 ; CHECK:     PointeeType: 0x1009
-; CHECK:     PointerAttributes: 0x800A
 ; CHECK:     PtrType: Near32 (0xA)
 ; CHECK:     PtrMode: Pointer (0x0)
 ; CHECK:     IsFlat: 0
 ; CHECK:     IsConst: 0
 ; CHECK:     IsVolatile: 0
 ; CHECK:     IsUnaligned: 0
 ; CHECK:     SizeOf: 4
 ; CHECK:   }

llvm/test/DebugInfo/COFF/types-basic.ll

 ; CHECK:     ModifiedType: int (0x74)
 ; CHECK:     Modifiers [ (0x1)
 ; CHECK:       Const (0x1)
 ; CHECK:     ]
 ; CHECK:   }
 ; CHECK:   Pointer (0x1004) {
 ; CHECK:     TypeLeafKind: LF_POINTER (0x1002)
 ; CHECK:     PointeeType: const int (0x1003)
-; CHECK:     PointerAttributes: 0x1000C
 ; CHECK:     PtrType: Near64 (0xC)
 ; CHECK:     PtrMode: Pointer (0x0)
 ; CHECK:     IsFlat: 0
 ; CHECK:     IsConst: 0
 ; CHECK:     IsVolatile: 0
 ; CHECK:     IsUnaligned: 0
 ; CHECK:   }
 ; CHECK:   Struct (0x1005) {
 ; CHECK:     TypeLeafKind: LF_STRUCTURE (0x1505)
 ; CHECK:     MemberCount: 0
 ; CHECK:     Properties [ (0x80)
 ; CHECK:       ForwardReference (0x80)
 ; CHECK:     ]
 ; CHECK:     FieldList: 0x0
 ; CHECK:     DerivedFrom: 0x0
 ; CHECK:     VShape: 0x0
 ; CHECK:     SizeOf: 0
 ; CHECK:     Name: A
 ; CHECK:   }
 ; CHECK:   Pointer (0x1006) {
 ; CHECK:     TypeLeafKind: LF_POINTER (0x1002)
 ; CHECK:     PointeeType: int (0x74)
-; CHECK:     PointerAttributes: 0x804C
 ; CHECK:     PtrType: Near64 (0xC)
 ; CHECK:     PtrMode: PointerToDataMember (0x2)
 ; CHECK:     IsFlat: 0
 ; CHECK:     IsConst: 0
 ; CHECK:     IsVolatile: 0
 ; CHECK:     IsUnaligned: 0
 ; CHECK:     ClassType: A (0x1005)
 ; CHECK:     Representation: GeneralData (0x4)
 ; CHECK:   }
 ; CHECK:   Pointer (0x1007) {
 ; CHECK:     TypeLeafKind: LF_POINTER (0x1002)
 ; CHECK:     PointeeType: A (0x1005)
-; CHECK:     PointerAttributes: 0x1000C
 ; CHECK:     PtrType: Near64 (0xC)
 ; CHECK:     PtrMode: Pointer (0x0)
 ; CHECK:     IsFlat: 0
-; CHECK:     IsConst: 0
+; CHECK:     IsConst: 1
 ; CHECK:     IsVolatile: 0
 ; CHECK:     IsUnaligned: 0
 ; CHECK:   }
 ; CHECK:   ArgList (0x1008) {
 ; CHECK:     TypeLeafKind: LF_ARGLIST (0x1201)
 ; CHECK:     NumArgs: 0
 ; CHECK:     Arguments [
 ; CHECK:     ]
 ; CHECK:   }
 ; CHECK:   MemberFunction (0x1009) {
 ; CHECK:     TypeLeafKind: LF_MFUNCTION (0x1009)
 ; CHECK:     ReturnType: void (0x3)
 ; CHECK:     ClassType: A (0x1005)
-; CHECK:     ThisType: A* (0x1007)
+; CHECK:     ThisType: A* const (0x1007)
 ; CHECK:     CallingConvention: NearC (0x0)
 ; CHECK:     FunctionOptions [ (0x0)
 ; CHECK:     ]
 ; CHECK:     NumParameters: 0
 ; CHECK:     ArgListType: () (0x1008)
 ; CHECK:     ThisAdjustment: 0
 ; CHECK:   }
 ; CHECK:   FieldList (0x100A) {

 ; CHECK:     TypeLeafKind: LF_UDT_SRC_LINE (0x1606)
 ; CHECK:     UDT: A (0x100B)
 ; CHECK:     SourceFile: D:\src\llvm\build\t.cpp (0x100C)
 ; CHECK:     LineNumber: 1
 ; CHECK:   }
 ; CHECK:   Pointer (0x100E) {
 ; CHECK:     TypeLeafKind: LF_POINTER (0x1002)
 ; CHECK:     PointeeType: void A::() (0x1009)
-; CHECK:     PointerAttributes: 0x1006C
 ; CHECK:     PtrType: Near64 (0xC)
 ; CHECK:     PtrMode: PointerToMemberFunction (0x3)
 ; CHECK:     IsFlat: 0
 ; CHECK:     IsConst: 0
 ; CHECK:     IsVolatile: 0
 ; CHECK:     IsUnaligned: 0
 ; CHECK:     ClassType: A (0x1005)
 ; CHECK:     Representation: GeneralFunction (0x8)
 ; CHECK:   }
 ; CHECK:   Modifier (0x100F) {
 ; CHECK:     TypeLeafKind: LF_MODIFIER (0x1001)
 ; CHECK:     ModifiedType: void (0x3)
 ; CHECK:     Modifiers [ (0x1)
 ; CHECK:       Const (0x1)
 ; CHECK:     ]
 ; CHECK:   }
 ; CHECK:   Pointer (0x1010) {
 ; CHECK:     TypeLeafKind: LF_POINTER (0x1002)
 ; CHECK:     PointeeType: const void (0x100F)
-; CHECK:     PointerAttributes: 0x1000C
 ; CHECK:     PtrType: Near64 (0xC)
 ; CHECK:     PtrMode: Pointer (0x0)
 ; CHECK:     IsFlat: 0
 ; CHECK:     IsConst: 0
 ; CHECK:     IsVolatile: 0
 ; CHECK:     IsUnaligned: 0
 ; CHECK:   }
 ; CHECK:   Procedure (0x1011) {

llvm/test/DebugInfo/COFF/types-calling-conv.ll

 ; CHECK:     DerivedFrom: 0x0
 ; CHECK:     VShape: 0x0
 ; CHECK:     SizeOf: 0
 ; CHECK:     Name: A
 ; CHECK:   }
 ; CHECK:   Pointer (0x1001) {
 ; CHECK:     TypeLeafKind: LF_POINTER (0x1002)
 ; CHECK:     PointeeType: A (0x1000)
-; CHECK:     PointerAttributes: 0x800A
 ; CHECK:     PtrType: Near32 (0xA)
 ; CHECK:     PtrMode: Pointer (0x0)
 ; CHECK:     IsFlat: 0
-; CHECK:     IsConst: 0
+; CHECK:     IsConst: 1
 ; CHECK:     IsVolatile: 0
 ; CHECK:     IsUnaligned: 0
 ; CHECK:     SizeOf: 4
 ; CHECK:   }
 ; CHECK:   ArgList (0x1002) {
 ; CHECK:     TypeLeafKind: LF_ARGLIST (0x1201)
 ; CHECK:     NumArgs: 0
 ; CHECK:     Arguments [
 ; CHECK:     ]
 ; CHECK:   }
 ; CHECK:   MemberFunction (0x1003) {
 ; CHECK:     TypeLeafKind: LF_MFUNCTION (0x1009)
 ; CHECK:     ReturnType: void (0x3)
 ; CHECK:     ClassType: A (0x1000)
-; CHECK:     ThisType: A* (0x1001)
+; CHECK:     ThisType: A* const (0x1001)
 ; CHECK:     CallingConvention: ThisCall (0xB)
 ; CHECK:     FunctionOptions [ (0x0)
 ; CHECK:     ]
 ; CHECK:     NumParameters: 0
 ; CHECK:     ArgListType: () (0x1002)
 ; CHECK:     ThisAdjustment: 0
 ; CHECK:   }
 ; CHECK:   FieldList (0x1004) {

 ; CHECK:     LineNumber: 1
 ; CHECK:   }
 ; CHECK:   MemberFuncId (0x1008) {
 ; CHECK:     TypeLeafKind: LF_MFUNC_ID (0x1602)
 ; CHECK:     ClassType: A (0x1000)
 ; CHECK:     FunctionType: void A::() (0x1003)
 ; CHECK:     Name: A::thiscallcc
 ; CHECK:   }
-; CHECK:   Procedure (0x1009) {
+; CHECK:   Pointer (0x1009) {
+; CHECK:     TypeLeafKind: LF_POINTER (0x1002)
+; CHECK:     PointeeType: A (0x1000)
+; CHECK:     PtrType: Near32 (0xA)
+; CHECK:     PtrMode: Pointer (0x0)
+; CHECK:     IsFlat: 0
+; CHECK:     IsConst: 0
+; CHECK:     IsVolatile: 0
+; CHECK:     IsUnaligned: 0
+; CHECK:     SizeOf: 4
+; CHECK:   }
+; CHECK:   Procedure (0x100A) {
 ; CHECK:     TypeLeafKind: LF_PROCEDURE (0x1008)
 ; CHECK:     ReturnType: void (0x3)
 ; CHECK:     CallingConvention: NearC (0x0)
 ; CHECK:     FunctionOptions [ (0x0)
 ; CHECK:     ]
 ; CHECK:     NumParameters: 0
 ; CHECK:     ArgListType: () (0x1002)
 ; CHECK:   }
-; CHECK:   FuncId (0x100A) {
+; CHECK:   FuncId (0x100B) {
 ; CHECK:     TypeLeafKind: LF_FUNC_ID (0x1601)
 ; CHECK:     ParentScope: 0x0
-; CHECK:     FunctionType: void () (0x1009)
+; CHECK:     FunctionType: void () (0x100A)
 ; CHECK:     Name: cdeclcc
 ; CHECK:   }
-; CHECK:   Procedure (0x100B) {
+; CHECK:   Procedure (0x100C) {
 ; CHECK:     TypeLeafKind: LF_PROCEDURE (0x1008)
 ; CHECK:     ReturnType: void (0x3)
 ; CHECK:     CallingConvention: NearFast (0x4)
 ; CHECK:     FunctionOptions [ (0x0)
 ; CHECK:     ]
 ; CHECK:     NumParameters: 0
 ; CHECK:     ArgListType: () (0x1002)
 ; CHECK:   }
-; CHECK:   FuncId (0x100C) {
+; CHECK:   FuncId (0x100D) {
 ; CHECK:     TypeLeafKind: LF_FUNC_ID (0x1601)
 ; CHECK:     ParentScope: 0x0
-; CHECK:     FunctionType: void () (0x100B)
+; CHECK:     FunctionType: void () (0x100C)
 ; CHECK:     Name: fastcallcc
 ; CHECK:   }
-; CHECK:   Procedure (0x100D) {
+; CHECK:   Procedure (0x100E) {
 ; CHECK:     TypeLeafKind: LF_PROCEDURE (0x1008)
 ; CHECK:     ReturnType: void (0x3)
 ; CHECK:     CallingConvention: NearStdCall (0x7)
 ; CHECK:     FunctionOptions [ (0x0)
 ; CHECK:     ]
 ; CHECK:     NumParameters: 0
 ; CHECK:     ArgListType: () (0x1002)
 ; CHECK:   }
-; CHECK:   FuncId (0x100E) {
+; CHECK:   FuncId (0x100F) {
 ; CHECK:     TypeLeafKind: LF_FUNC_ID (0x1601)
 ; CHECK:     ParentScope: 0x0
-; CHECK:     FunctionType: void () (0x100D)
+; CHECK:     FunctionType: void () (0x100E)
 ; CHECK:     Name: stdcallcc
 ; CHECK:   }
-; CHECK:   Procedure (0x100F) {
+; CHECK:   Procedure (0x1010) {
 ; CHECK:     TypeLeafKind: LF_PROCEDURE (0x1008)
 ; CHECK:     ReturnType: void (0x3)
 ; CHECK:     CallingConvention: NearVector (0x18)
 ; CHECK:     FunctionOptions [ (0x0)
 ; CHECK:     ]
 ; CHECK:     NumParameters: 0
 ; CHECK:     ArgListType: () (0x1002)
 ; CHECK:   }
-; CHECK:   FuncId (0x1010) {
+; CHECK:   FuncId (0x1011) {
 ; CHECK:     TypeLeafKind: LF_FUNC_ID (0x1601)
 ; CHECK:     ParentScope: 0x0
-; CHECK:     FunctionType: void () (0x100F)
+; CHECK:     FunctionType: void () (0x1010)
 ; CHECK:     Name: vectorcallcc
 ; CHECK:   }
 ; CHECK: ]
 
 ; ModuleID = 't.cpp'
 source_filename = "t.cpp"
 target datalayout = "e-m:x-p:32:32-i64:64-f80:32-n8:16:32-a:0:32-S32"
 target triple = "i386-pc-windows-msvc19.0.23918"

llvm/test/DebugInfo/COFF/types-cvarargs.ll

 ; CHECK:    SubSectionSize: 0x2A
 ; CHECK:    UDTSym {
 ; CHECK:      Kind: S_UDT (0x1108)
 ; CHECK:      Type: MemberTest::A (0x1008)
 ; CHECK:      UDTName: MemberTest::A
 ; CHECK:    }
 ; CHECK:    UDTSym {
 ; CHECK:      Kind: S_UDT (0x1108)
-; CHECK:      Type: void (int, float, <no type>)* (0x100E)
+; CHECK:      Type: void (int, float, <no type>)* (0x100F)
 ; CHECK:      UDTName: FuncTypedef
 ; CHECK:    }
 ; CHECK:  ]
 
 ; ModuleID = 't.cpp'
 source_filename = "t.cpp"
 target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-pc-windows-msvc19.11.25507"

llvm/test/DebugInfo/COFF/types-data-members.ll

 ; CHECK:     VShape: 0x0
 ; CHECK:     SizeOf: 0
 ; CHECK:     Name: DerivedClass
 ; CHECK:     LinkageName: .?AUDerivedClass@@
 ; CHECK:   }
 ; CHECK:   Pointer (0x1012) {
 ; CHECK:     TypeLeafKind: LF_POINTER (0x1002)
 ; CHECK:     PointeeType: const int (0x1004)
-; CHECK:     PointerAttributes: 0x1000C
 ; CHECK:     PtrType: Near64 (0xC)
 ; CHECK:     PtrMode: Pointer (0x0)
 ; CHECK:     IsFlat: 0
 ; CHECK:     IsConst: 0
 ; CHECK:     IsVolatile: 0
 ; CHECK:     IsUnaligned: 0
 ; CHECK:     SizeOf: 8
 ; CHECK:   }
 ; CHECK:   VFTableShape (0x1013) {
 ; CHECK:     TypeLeafKind: LF_VTSHAPE (0xA)
 ; CHECK:     VFEntryCount: 1
 ; CHECK:   }
 ; CHECK:   Pointer (0x1014) {
 ; CHECK:     TypeLeafKind: LF_POINTER (0x1002)
 ; CHECK:     PointeeType: <vftable 1 methods> (0x1013)
-; CHECK:     PointerAttributes: 0x1000C
 ; CHECK:     PtrType: Near64 (0xC)
 ; CHECK:     PtrMode: Pointer (0x0)
 ; CHECK:     IsFlat: 0
 ; CHECK:     IsConst: 0
 ; CHECK:     IsVolatile: 0
 ; CHECK:     IsUnaligned: 0
 ; CHECK:     SizeOf: 8
 ; CHECK:   }

 ; CHECK:     TypeLeafKind: LF_UDT_SRC_LINE (0x1606)
 ; CHECK:     UDT: Class::Nested (0x101A)
 ; CHECK:     SourceFile: D:\src\llvm\build\t.cpp (0x1007)
 ; CHECK:     LineNumber: 23
 ; CHECK:   }
 ; CHECK:   Pointer (0x101C) {
 ; CHECK:     TypeLeafKind: LF_POINTER (0x1002)
 ; CHECK:     PointeeType: DerivedClass (0x1011)
-; CHECK:     PointerAttributes: 0x1000C
 ; CHECK:     PtrType: Near64 (0xC)
 ; CHECK:     PtrMode: Pointer (0x0)
 ; CHECK:     IsFlat: 0
-; CHECK:     IsConst: 0
+; CHECK:     IsConst: 1
 ; CHECK:     IsVolatile: 0
 ; CHECK:     IsUnaligned: 0
 ; CHECK:     SizeOf: 8
 ; CHECK:   }
 ; CHECK:   MemberFunction (0x101D) {
 ; CHECK:     TypeLeafKind: LF_MFUNCTION (0x1009)
 ; CHECK:     ReturnType: void (0x3)
 ; CHECK:     ClassType: DerivedClass (0x1011)
-; CHECK:     ThisType: DerivedClass* (0x101C)
+; CHECK:     ThisType: DerivedClass* const (0x101C)
 ; CHECK:     CallingConvention: NearC (0x0)
 ; CHECK:     FunctionOptions [ (0x0)
 ; CHECK:     ]
 ; CHECK:     NumParameters: 0
 ; CHECK:     ArgListType: () (0x1000)
 ; CHECK:     ThisAdjustment: 0
 ; CHECK:   }
 ; CHECK:   MemberFuncId (0x101E) {

llvm/test/DebugInfo/COFF/types-method-ref-qualifiers.ll

+; RUN: llc < %s -filetype=obj | llvm-readobj - -codeview | FileCheck %s
+
+; C++ source to regenerate:
+; struct A {
+;   int NoRefQual();
+;   
+;   int RefQual() &;
+;   int RefQual() &&;
+;   
+;   int LValueRef() &;
+;   
+;   int RValueRef() &&;
+; };
+;
+; void foo() {
+;   A *GenericPtr = nullptr;
+;   A a;
+; }
+
+
+; ModuleID = 'foo.cpp'
+source_filename = "foo.cpp"
+target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-pc-windows-msvc19.15.26732"
+
+%struct.A = type { i8 }
+
+; Function Attrs: noinline nounwind optnone uwtable
+define dso_local void @"?foo@@YAXXZ"() #0 !dbg !10 {
+entry:
+  %GenericPtr = alloca %struct.A*, align 8
+  %a = alloca %struct.A, align 1
+  call void @llvm.dbg.declare(metadata %struct.A** %GenericPtr, metadata !13, metadata !DIExpression()), !dbg !28
+  store %struct.A* null, %struct.A** %GenericPtr, align 8, !dbg !28
+  call void @llvm.dbg.declare(metadata %struct.A* %a, metadata !29, metadata !DIExpression()), !dbg !30
+  ret void, !dbg !31
+}
+
+; Function Attrs: nounwind readnone speculatable
+declare void @llvm.dbg.declare(metadata, metadata, metadata) #1
+
+attributes #0 = { noinline nounwind optnone uwtable "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "less-precise-fpmad"="false" "min-legal-vector-width"="0" "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 }
+
+!llvm.dbg.cu = !{!0}
+!llvm.linker.options = !{!3, !4}
+!llvm.module.flags = !{!5, !6, !7, !8}
+!llvm.ident = !{!9}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !1, producer: "clang version 8.0.0 ", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, nameTableKind: None)
+!1 = !DIFile(filename: "foo.cpp", directory: "D:\5C\5Csrc\5C\5Cllvmbuild\5C\5Cninja-x64", checksumkind: CSK_MD5, checksum: "d1b6ae9dc9ab85ca0a41c8b8c79a0b6a")
+!2 = !{}
+!3 = !{!"/DEFAULTLIB:libcmt.lib"}
+!4 = !{!"/DEFAULTLIB:oldnames.lib"}
+!5 = !{i32 2, !"CodeView", i32 1}
+!6 = !{i32 2, !"Debug Info Version", i32 3}
+!7 = !{i32 1, !"wchar_size", i32 2}
+!8 = !{i32 7, !"PIC Level", i32 2}
+!9 = !{!"clang version 8.0.0 "}
+!10 = distinct !DISubprogram(name: "foo", linkageName: "?foo@@YAXXZ", scope: !1, file: !1, line: 12, type: !11, isLocal: false, isDefinition: true, scopeLine: 12, flags: DIFlagPrototyped, isOptimized: false, unit: !0, retainedNodes: !2)
+!11 = !DISubroutineType(types: !12)
+!12 = !{null}
+!13 = !DILocalVariable(name: "GenericPtr", scope: !10, file: !1, line: 13, type: !14)
+!14 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !15, size: 64)
+!15 = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "A", file: !1, line: 1, size: 8, flags: DIFlagTypePassByValue | DIFlagTrivial, elements: !16, identifier: ".?AUA@@")
+!16 = !{!17, !22, !24, !26, !27}
+!17 = !DISubprogram(name: "NoRefQual", linkageName: "?NoRefQual@A@@QEAAHXZ", scope: !15, file: !1, line: 2, type: !18, isLocal: false, isDefinition: false, scopeLine: 2, flags: DIFlagPrototyped, isOptimized: false)
+!18 = !DISubroutineType(types: !19)
+!19 = !{!20, !21}
+!20 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!21 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !15, size: 64, flags: DIFlagArtificial | DIFlagObjectPointer)
+!22 = !DISubprogram(name: "RefQual", linkageName: "?RefQual@A@@QEGAAHXZ", scope: !15, file: !1, line: 4, type: !23, isLocal: false, isDefinition: false, scopeLine: 4, flags: DIFlagPrototyped | DIFlagLValueReference, isOptimized: false)
+!23 = !DISubroutineType(flags: DIFlagLValueReference, types: !19)
+!24 = !DISubprogram(name: "RefQual", linkageName: "?RefQual@A@@QEHAAHXZ", scope: !15, file: !1, line: 5, type: !25, isLocal: false, isDefinition: false, scopeLine: 5, flags: DIFlagPrototyped | DIFlagRValueReference, isOptimized: false)
+!25 = !DISubroutineType(flags: DIFlagRValueReference, types: !19)
+!26 = !DISubprogram(name: "LValueRef", linkageName: "?LValueRef@A@@QEGAAHXZ", scope: !15, file: !1, line: 7, type: !23, isLocal: false, isDefinition: false, scopeLine: 7, flags: DIFlagPrototyped | DIFlagLValueReference, isOptimized: false)
+!27 = !DISubprogram(name: "RValueRef", linkageName: "?RValueRef@A@@QEHAAHXZ", scope: !15, file: !1, line: 9, type: !25, isLocal: false, isDefinition: false, scopeLine: 9, flags: DIFlagPrototyped | DIFlagRValueReference, isOptimized: false)
+!28 = !DILocation(line: 13, scope: !10)
+!29 = !DILocalVariable(name: "a", scope: !10, file: !1, line: 14, type: !15)
+!30 = !DILocation(line: 14, scope: !10)
+!31 = !DILocation(line: 15, scope: !10)
+
+
+
+
+; CHECK: CodeViewTypes [
+; CHECK:   Section: .debug$T (7)
+; CHECK:   Magic: 0x4
+; CHECK: ]

llvm/test/DebugInfo/COFF/types-non-virtual-methods.ll

 ; CHECK:     DerivedFrom: 0x0
 ; CHECK:     VShape: 0x0
 ; CHECK:     SizeOf: 0
 ; CHECK:     Name: A
 ; CHECK:   }
 ; CHECK:   Pointer (0x1004) {
 ; CHECK:     TypeLeafKind: LF_POINTER (0x1002)
 ; CHECK:     PointeeType: A (0x1003)
-; CHECK:     PointerAttributes: 0x800A
 ; CHECK:     PtrType: Near32 (0xA)
 ; CHECK:     PtrMode: Pointer (0x0)
 ; CHECK:     IsFlat: 0
-; CHECK:     IsConst: 0
+; CHECK:     IsConst: 1
 ; CHECK:     IsVolatile: 0
 ; CHECK:     IsUnaligned: 0
 ; CHECK:   }
 ; CHECK:   MemberFunction (0x1005) {
 ; CHECK:     TypeLeafKind: LF_MFUNCTION (0x1009)
 ; CHECK:     ReturnType: void (0x3)
 ; CHECK:     ClassType: A (0x1003)
-; CHECK:     ThisType: A* (0x1004)
+; CHECK:     ThisType: A* const (0x1004)
 ; CHECK:     CallingConvention: ThisCall (0xB)
 ; CHECK:     FunctionOptions [ (0x0)
 ; CHECK:     ]
 ; CHECK:     NumParameters: 0
 ; CHECK:     ArgListType: () (0x1000)
 ; CHECK:     ThisAdjustment: 0
 ; CHECK:   }
 ; CHECK:   FieldList (0x1006) {

 ; CHECK:     DerivedFrom: 0x0
 ; CHECK:     VShape: 0x0
 ; CHECK:     SizeOf: 0
 ; CHECK:     Name: B
 ; CHECK:   }
 ; CHECK:   Pointer (0x100B) {
 ; CHECK:     TypeLeafKind: LF_POINTER (0x1002)
 ; CHECK:     PointeeType: B (0x100A)
-; CHECK:     PointerAttributes: 0x800A
 ; CHECK:     PtrType: Near32 (0xA)
 ; CHECK:     PtrMode: Pointer (0x0)
 ; CHECK:     IsFlat: 0
-; CHECK:     IsConst: 0
+; CHECK:     IsConst: 1
 ; CHECK:     IsVolatile: 0
 ; CHECK:     IsUnaligned: 0
 ; CHECK:     SizeOf: 4
 ; CHECK:   }
 ; CHECK:   MemberFunction (0x100C) {
 ; CHECK:     TypeLeafKind: LF_MFUNCTION (0x1009)
 ; CHECK:     ReturnType: void (0x3)
 ; CHECK:     ClassType: B (0x100A)
-; CHECK:     ThisType: B* (0x100B)
+; CHECK:     ThisType: B* const (0x100B)
 ; CHECK:     CallingConvention: ThisCall (0xB)
 ; CHECK:     FunctionOptions [ (0x0)
 ; CHECK:     ]
 ; CHECK:     NumParameters: 0
 ; CHECK:     ArgListType: () (0x1000)
 ; CHECK:     ThisAdjustment: 0
 ; CHECK:   }
 ; CHECK:   ArgList (0x100D) {
 ; CHECK:     TypeLeafKind: LF_ARGLIST (0x1201)
 ; CHECK:     NumArgs: 1
 ; CHECK:     Arguments [
 ; CHECK:       ArgType: float (0x40)
 ; CHECK:     ]
 ; CHECK:   }
 ; CHECK:   MemberFunction (0x100E) {
 ; CHECK:     TypeLeafKind: LF_MFUNCTION (0x1009)
 ; CHECK:     ReturnType: void (0x3)
 ; CHECK:     ClassType: B (0x100A)
-; CHECK:     ThisType: B* (0x100B)
+; CHECK:     ThisType: B* const (0x100B)
 ; CHECK:     CallingConvention: ThisCall (0xB)
 ; CHECK:     FunctionOptions [ (0x0)
 ; CHECK:     ]
 ; CHECK:     NumParameters: 1
 ; CHECK:     ArgListType: (float) (0x100D)
 ; CHECK:     ThisAdjustment: 0
 ; CHECK:   }
 ; CHECK:   ArgList (0x100F) {
 ; CHECK:     TypeLeafKind: LF_ARGLIST (0x1201)
 ; CHECK:     NumArgs: 1
 ; CHECK:     Arguments [
 ; CHECK:       ArgType: int (0x74)
 ; CHECK:     ]
 ; CHECK:   }
 ; CHECK:   MemberFunction (0x1010) {
 ; CHECK:     TypeLeafKind: LF_MFUNCTION (0x1009)
 ; CHECK:     ReturnType: void (0x3)
 ; CHECK:     ClassType: B (0x100A)
-; CHECK:     ThisType: B* (0x100B)
+; CHECK:     ThisType: B* const (0x100B)
 ; CHECK:     CallingConvention: ThisCall (0xB)
 ; CHECK:     FunctionOptions [ (0x0)
 ; CHECK:     ]
 ; CHECK:     NumParameters: 1
 ; CHECK:     ArgListType: (int) (0x100F)
 ; CHECK:     ThisAdjustment: 0
 ; CHECK:   }
 ; CHECK:   MethodOverloadList (0x1011) {

llvm/test/DebugInfo/COFF/types-ptr-to-member.ll

 
 ; CHECK: CodeViewTypes [
 
 ; Pointer to data member
 
 ; CHECK:   Pointer ({{.*}}) {
 ; CHECK:     TypeLeafKind: LF_POINTER (0x1002)
 ; CHECK:     PointeeType: int (0x74)
-; CHECK:     PointerAttributes: 0x804C
 ; CHECK:     PtrType: Near64 (0xC)
 ; CHECK:     PtrMode: PointerToDataMember (0x2)
 ; CHECK:     IsFlat: 0
 ; CHECK:     IsConst: 0
 ; CHECK:     IsVolatile: 0
 ; CHECK:     IsUnaligned: 0
 ; CHECK:     SizeOf: 4
 ; CHECK:     ClassType: A
 ; CHECK:     Representation: SingleInheritanceData (0x1)
 ; CHECK:   }
 ; CHECK:   Pointer ({{.*}}) {
 ; CHECK:     TypeLeafKind: LF_POINTER (0x1002)
 ; CHECK:     PointeeType: int (0x74)
-; CHECK:     PointerAttributes: 0x804C
 ; CHECK:     PtrType: Near64 (0xC)
 ; CHECK:     PtrMode: PointerToDataMember (0x2)
 ; CHECK:     IsFlat: 0
 ; CHECK:     IsConst: 0
 ; CHECK:     IsVolatile: 0
 ; CHECK:     IsUnaligned: 0
 ; CHECK:     SizeOf: 4
 ; CHECK:     ClassType: C
 ; CHECK:     Representation: MultipleInheritanceData (0x2)
 ; CHECK:   }
 ; CHECK:   Pointer ({{.*}}) {
 ; CHECK:     TypeLeafKind: LF_POINTER (0x1002)
 ; CHECK:     PointeeType: int (0x74)
-; CHECK:     PointerAttributes: 0x1004C
 ; CHECK:     PtrType: Near64 (0xC)
 ; CHECK:     PtrMode: PointerToDataMember (0x2)
 ; CHECK:     IsFlat: 0
 ; CHECK:     IsConst: 0
 ; CHECK:     IsVolatile: 0
 ; CHECK:     IsUnaligned: 0
 ; CHECK:     SizeOf: 8
 ; CHECK:     ClassType: D
 ; CHECK:     Representation: VirtualInheritanceData (0x3)
 ; CHECK:   }
 ; CHECK:   Pointer ({{.*}}) {
 ; CHECK:     TypeLeafKind: LF_POINTER (0x1002)
 ; CHECK:     PointeeType: int (0x74)
-; CHECK:     PointerAttributes: 0x1804C
 ; CHECK:     PtrType: Near64 (0xC)
 ; CHECK:     PtrMode: PointerToDataMember (0x2)
 ; CHECK:     IsFlat: 0
 ; CHECK:     IsConst: 0
 ; CHECK:     IsVolatile: 0
 ; CHECK:     IsUnaligned: 0
 ; CHECK:     SizeOf: 12
 ; CHECK:     ClassType: E
 ; CHECK:     Representation: GeneralData (0x4)
 ; CHECK:   }
 
 ; Pointer to member function
 
 ; CHECK:   Pointer ({{.*}}) {
 ; CHECK:     TypeLeafKind: LF_POINTER (0x1002)
 ; CHECK:     PointeeType: void A::()
-; CHECK:     PointerAttributes: 0x1006C
 ; CHECK:     PtrType: Near64 (0xC)
 ; CHECK:     PtrMode: PointerToMemberFunction (0x3)
 ; CHECK:     IsFlat: 0
 ; CHECK:     IsConst: 0
 ; CHECK:     IsVolatile: 0
 ; CHECK:     IsUnaligned: 0
 ; CHECK:     SizeOf: 8
 ; CHECK:     ClassType: A
 ; CHECK:     Representation: SingleInheritanceFunction (0x5)
 ; CHECK:   }
 ; CHECK:   Pointer ({{.*}}) {
 ; CHECK:     TypeLeafKind: LF_POINTER (0x1002)
 ; CHECK:     PointeeType: void C::()
-; CHECK:     PointerAttributes: 0x2006C
 ; CHECK:     PtrType: Near64 (0xC)
 ; CHECK:     PtrMode: PointerToMemberFunction (0x3)
 ; CHECK:     IsFlat: 0
 ; CHECK:     IsConst: 0
 ; CHECK:     IsVolatile: 0
 ; CHECK:     IsUnaligned: 0
 ; CHECK:     SizeOf: 16
 ; CHECK:     ClassType: C
 ; CHECK:     Representation: MultipleInheritanceFunction (0x6)
 ; CHECK:   }
 ; CHECK:   Pointer ({{.*}}) {
 ; CHECK:     TypeLeafKind: LF_POINTER (0x1002)
 ; CHECK:     PointeeType: void D::()
-; CHECK:     PointerAttributes: 0x2006C
 ; CHECK:     PtrType: Near64 (0xC)
 ; CHECK:     PtrMode: PointerToMemberFunction (0x3)
 ; CHECK:     IsFlat: 0
 ; CHECK:     IsConst: 0
 ; CHECK:     IsVolatile: 0
 ; CHECK:     IsUnaligned: 0
 ; CHECK:     SizeOf: 16
 ; CHECK:     ClassType: D
 ; CHECK:     Representation: VirtualInheritanceFunction (0x7)
 ; CHECK:   }
 ; CHECK:   Pointer ({{.*}}) {
 ; CHECK:     TypeLeafKind: LF_POINTER (0x1002)
 ; CHECK:     PointeeType: void E::()
-; CHECK:     PointerAttributes: 0x3006C
 ; CHECK:     PtrType: Near64 (0xC)
 ; CHECK:     PtrMode: PointerToMemberFunction (0x3)
 ; CHECK:     IsFlat: 0
 ; CHECK:     IsConst: 0
 ; CHECK:     IsVolatile: 0
 ; CHECK:     IsUnaligned: 0
 ; CHECK:     SizeOf: 24
 ; CHECK:     ClassType: E
 ; CHECK:     Representation: GeneralFunction (0x8)
 ; CHECK:   }
 
 ; Unknown inheritance model MPT
 ; CHECK:   Pointer ({{.*}}) {
 ; CHECK:     TypeLeafKind: LF_POINTER (0x1002)
 ; CHECK:     PointeeType: int
-; CHECK:     PointerAttributes: 0x4C
 ; CHECK:     PtrType: Near64 (0xC)
 ; CHECK:     PtrMode: PointerToDataMember (0x2)
 ; CHECK:     IsFlat: 0
 ; CHECK:     IsConst: 0
 ; CHECK:     IsVolatile: 0
 ; CHECK:     IsUnaligned: 0
 ; CHECK:     SizeOf: 0
 ; CHECK:     ClassType: Incomplete
 ; CHECK:     Representation: Unknown (0x0)
 ; CHECK:   }
 ; CHECK:   Pointer ({{.*}}) {
 ; CHECK:     TypeLeafKind: LF_POINTER (0x1002)
 ; CHECK:   Pointer ({{.*}}) {
 ; CHECK:     TypeLeafKind: LF_POINTER (0x1002)
 ; CHECK:     PointeeType: void Incomplete::()
-; CHECK:     PointerAttributes: 0x6C
 ; CHECK:     PtrType: Near64 (0xC)
 ; CHECK:     PtrMode: PointerToMemberFunction (0x3)
 ; CHECK:     IsFlat: 0
 ; CHECK:     IsConst: 0
 ; CHECK:     IsVolatile: 0
 ; CHECK:     IsUnaligned: 0
 ; CHECK:     SizeOf: 0
 ; CHECK:     ClassType: Incomplete

llvm/test/DebugInfo/COFF/types-recursive-struct.ll

 ; CHECK:     DerivedFrom: 0x0
 ; CHECK:     VShape: 0x0
 ; CHECK:     SizeOf: 0
 ; CHECK:     Name: B
 ; CHECK:   }
 ; CHECK:   Pointer (0x1005) {
 ; CHECK:     TypeLeafKind: LF_POINTER (0x1002)
 ; CHECK:     PointeeType: B (0x1004)
-; CHECK:     PointerAttributes: 0x1000C
 ; CHECK:     PtrType: Near64 (0xC)
 ; CHECK:     PtrMode: Pointer (0x0)
 ; CHECK:     IsFlat: 0
 ; CHECK:     IsConst: 0
 ; CHECK:     IsVolatile: 0
 ; CHECK:     IsUnaligned: 0
 ; CHECK:   }
 ; CHECK:   FieldList (0x1006) {

llvm/test/DebugInfo/COFF/virtual-methods.ll

 ; int D::g() { return d; }
 ; $ clang t.cpp -S -emit-llvm -fstandalone-debug -g -gcodeview -o t.ll
 
 ; A::f
 ; CHECK:      MemberFunction ({{.*}}) {
 ; CHECK-NEXT:   TypeLeafKind: LF_MFUNCTION (0x1009)
 ; CHECK-NEXT:   ReturnType: int (0x74)
 ; CHECK-NEXT:   ClassType: A ({{.*}})
-; CHECK-NEXT:   ThisType: A* ({{.*}})
+; CHECK-NEXT:   ThisType: A* const ({{.*}})
 ; CHECK-NEXT:   CallingConvention: NearC (0x0)
 ; CHECK-NEXT:   FunctionOptions [ (0x0)
 ; CHECK-NEXT:   ]
 ; CHECK-NEXT:   NumParameters: 0
 ; CHECK-NEXT:   ArgListType: () ({{.*}})
 ; CHECK-NEXT:   ThisAdjustment: 0
 ; CHECK-NEXT: }
 
 ; A::g
 ; CHECK:      MemberFunction ({{.*}}) {
 ; CHECK-NEXT:   TypeLeafKind: LF_MFUNCTION (0x1009)
 ; CHECK-NEXT:   ReturnType: int (0x74)
 ; CHECK-NEXT:   ClassType: B ({{.*}})
-; CHECK-NEXT:   ThisType: B* ({{.*}})
+; CHECK-NEXT:   ThisType: B* const ({{.*}})
 ; CHECK-NEXT:   CallingConvention: NearC (0x0)
 ; CHECK-NEXT:   FunctionOptions [ (0x0)
 ; CHECK-NEXT:   ]
 ; CHECK-NEXT:   NumParameters: 0
 ; CHECK-NEXT:   ArgListType: () ({{.*}})
 ; CHECK-NEXT:   ThisAdjustment: 0
 ; CHECK-NEXT: }
 
 ; C::g
 ; CHECK:      MemberFunction ([[C_g:.*]]) {
 ; CHECK-NEXT:   TypeLeafKind: LF_MFUNCTION (0x1009)
 ; CHECK-NEXT:   ReturnType: int (0x74)
 ; CHECK-NEXT:   ClassType: C ({{.*}})
-; CHECK-NEXT:   ThisType: C* ({{.*}})
+; CHECK-NEXT:   ThisType: C* const ({{.*}})
 ; CHECK-NEXT:   CallingConvention: NearC (0x0)
 ; CHECK-NEXT:   FunctionOptions [ (0x0)
 ; CHECK-NEXT:   ]
 ; CHECK-NEXT:   NumParameters: 0
 ; CHECK-NEXT:   ArgListType: () ({{.*}})
 ; CHECK-NEXT:   ThisAdjustment: 8
 ; CHECK-NEXT: }
 
 ; CHECK:      FieldList ({{.*}}) {
 ; CHECK:        OneMethod {
 ; CHECK-NEXT:     TypeLeafKind: LF_ONEMETHOD (0x1511)
 ; CHECK-NEXT:     AccessSpecifier: Public (0x3)
 ; CHECK-NEXT:     MethodKind: Virtual (0x1)
 ; CHECK-NEXT:     Type: int C::() ([[C_g]])
 ; CHECK-NEXT:     Name: g
 ; CHECK-NEXT:   }
 ; CHECK-NEXT: }
 
 ; D::g
 ; CHECK:      MemberFunction ([[D_g:.*]]) {
 ; CHECK-NEXT:   TypeLeafKind: LF_MFUNCTION (0x1009)
 ; CHECK-NEXT:   ReturnType: int (0x74)
 ; CHECK-NEXT:   ClassType: D ({{.*}})
-; CHECK-NEXT:   ThisType: D* ({{.*}})
+; CHECK-NEXT:   ThisType: D* const ({{.*}})
 ; CHECK-NEXT:   CallingConvention: NearC (0x0)
 ; CHECK-NEXT:   FunctionOptions [ (0x0)
 ; CHECK-NEXT:   ]
 ; CHECK-NEXT:   NumParameters: 0
 ; CHECK-NEXT:   ArgListType: () ({{.*}})
 ; CHECK-NEXT:   ThisAdjustment: 16
 ; CHECK-NEXT: }
 

llvm/tools/llvm-pdbutil/MinimalTypeDumper.cpp

 
 static std::string pointerOptions(PointerOptions Options) {
   std::vector<std::string> Opts;
   PUSH_FLAG(PointerOptions, Flat32, Options, "flat32");
   PUSH_FLAG(PointerOptions, Volatile, Options, "volatile");
   PUSH_FLAG(PointerOptions, Const, Options, "const");
   PUSH_FLAG(PointerOptions, Unaligned, Options, "unaligned");
   PUSH_FLAG(PointerOptions, Restrict, Options, "restrict");
-  PUSH_FLAG(PointerOptions, WinRTSmartPointer, Options, "winrt");
+  if (Opts.empty())
+    return "None";
+  return join(Opts, " | ");
+}
+
+static std::string pointerQualifier(PointerQualifier Qualifier) {
+  std::vector<std::string> Opts;
+  PUSH_FLAG(PointerQualifier, WinRTSmartPointer, Qualifier, "winrt");
+  PUSH_FLAG(PointerQualifier, ThisPtrLValueRef, Qualifier, "&");
+  PUSH_FLAG(PointerQualifier, ThisPtrRValueRef, Qualifier, "&&");
   if (Opts.empty())
     return "None";
   return join(Opts, " | ");
 }
 
 static std::string modifierOptions(ModifierOptions Options) {
   std::vector<std::string> Opts;
   PUSH_FLAG(ModifierOptions, Const, Options, "const");
static std::string memberAttributes(const MemberAttributes &Attrs) {
   PUSH_FLAG(MethodOptions, Sealed, Flags, "sealed");
   return join(Opts, " ");
 }
 
 static std::string formatPointerAttrs(const PointerRecord &Record) {
   PointerMode Mode = Record.getMode();
   PointerOptions Opts = Record.getOptions();
   PointerKind Kind = Record.getPointerKind();
-  return formatv("mode = {0}, opts = {1}, kind = {2}", formatPointerMode(Mode),
-                 pointerOptions(Opts), pointerKind(Kind));
+  PointerQualifier Qual = Record.getQualifier();
+  return formatv("mode = {0}, opts = {1}, kind = {2}, qualifier = {3}",
+                 formatPointerMode(Mode), pointerOptions(Opts),
+                 pointerKind(Kind), pointerQualifier(Qual));
 }
 
 static std::string formatFunctionOptions(FunctionOptions Options) {
   std::vector<std::string> Opts;
 
   PUSH_FLAG(FunctionOptions, CxxReturnUdt, Options, "returns cxx udt");
   PUSH_FLAG(FunctionOptions, ConstructorWithVirtualBases, Options,
             "constructor with virtual bases");