[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

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

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

If I write this code:

struct Foo {
  int x;
};

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

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

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

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

lib/CodeGen/AsmPrinter/CodeViewDebug.cpp

1268–1269

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

[zturner]

include/llvm/DebugInfo/CodeView/CodeView.h

302

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

1479–1481

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/CodeView.h

 };
 
 /// Equivalent to CV_modifier_t.
 /// TODO: Add flag for _Atomic modifier
 enum class ModifierOptions : uint16_t {
   None = 0x0000,
   Const = 0x0001,
   Volatile = 0x0002,
-  Unaligned = 0x0004
+  Unaligned = 0x0004,
+  Restrict = 0x0008
 };
 CV_DEFINE_ENUM_CLASS_FLAGS_OPERATORS(ModifierOptions)
 
 enum class DebugSubsectionKind : uint32_t {
   None = 0,
   Symbols = 0xf1,
   Lines = 0xf2,
   StringTable = 0xf3,

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.cpp

TypeIndex CodeViewDebug::lowerType(const DIType *Ty, const DIType *ClassTy) {
   case dwarf::DW_TAG_rvalue_reference_type:
     return lowerTypePointer(cast<DIDerivedType>(Ty));
   case dwarf::DW_TAG_ptr_to_member_type:
     return lowerTypeMemberPointer(cast<DIDerivedType>(Ty));
   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_restrict_type:
+    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);
     }
case dwarf::DW_TAG_pointer_type:
     break;
   case dwarf::DW_TAG_reference_type:
     PM = PointerMode::LValueReference;
     break;
   case dwarf::DW_TAG_rvalue_reference_type:
     PM = PointerMode::RValueReference;
     break;
   }
   // FIXME: MSVC folds qualifiers into PointerOptions in the context of a method
   // 'this' pointer, but not normal contexts. Figure out what we're supposed to
   // do.
   PointerOptions PO = PointerOptions::None;
   PointerRecord PR(PointeeTI, PK, PM, PO, Ty->getSizeInBits() / 8);
   return TypeTable.writeLeafType(PR);
 }
 
 static PointerToMemberRepresentation
 translatePtrToMemberRep(unsigned SizeInBytes, bool IsPMF, unsigned Flags) {
   // SizeInBytes being zero generally implies that the member pointer type was
while (IsModifier && BaseTy) {
     // FIXME: Need to add DWARF tags for __unaligned and _Atomic
     switch (BaseTy->getTag()) {
     case dwarf::DW_TAG_const_type:
       Mods |= ModifierOptions::Const;
       break;
     case dwarf::DW_TAG_volatile_type:
       Mods |= ModifierOptions::Volatile;
       break;
+    case dwarf::DW_TAG_restrict_type:
+      Mods |= ModifierOptions::Restrict;
+      break;
     default:
       IsModifier = false;
       break;
     }
     if (IsModifier)
       BaseTy = cast<DIDerivedType>(BaseTy)->getBaseType().resolve();
   }
   TypeIndex ModifiedTI = getTypeIndex(BaseTy);

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;
   if (Mods & uint16_t(ModifierOptions::Const))
     Name.append("const ");
   if (Mods & uint16_t(ModifierOptions::Volatile))
     Name.append("volatile ");
   if (Mods & uint16_t(ModifierOptions::Unaligned))
     Name.append("__unaligned ");
   Name.append(Types.getTypeName(Mod.getModifiedType()));
+  if (Mods & uint16_t(ModifierOptions::Restrict))
+    Name.append(" __restrict");
   return Error::success();
 }
 
 Error TypeNameComputer::visitKnownRecord(CVType &CVR,
                                          VFTableShapeRecord &Shape) {
   Name = formatv("<vftable {0} methods>", Shape.getEntryCount());
   return Error::success();
 }

lib/DebugInfo/CodeView/TypeDumpVisitor.cpp

static const EnumEntry<uint16_t> PtrMemberRepNames[] = {
     ENUM_ENTRY(PointerToMemberRepresentation, MultipleInheritanceFunction),
     ENUM_ENTRY(PointerToMemberRepresentation, VirtualInheritanceFunction),
     ENUM_ENTRY(PointerToMemberRepresentation, GeneralFunction),
 };
 
 static const EnumEntry<uint16_t> TypeModifierNames[] = {
     ENUM_ENTRY(ModifierOptions, Const), ENUM_ENTRY(ModifierOptions, Volatile),
     ENUM_ENTRY(ModifierOptions, Unaligned),
+    ENUM_ENTRY(ModifierOptions, Restrict),
 };
 
 static const EnumEntry<uint8_t> CallingConventions[] = {
     ENUM_ENTRY(CallingConvention, NearC),
     ENUM_ENTRY(CallingConvention, FarC),
     ENUM_ENTRY(CallingConvention, NearPascal),
     ENUM_ENTRY(CallingConvention, FarPascal),
     ENUM_ENTRY(CallingConvention, NearFast),
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));

lib/ObjectYAML/CodeViewYAMLTypes.cpp

 }
 
 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);
+  IO.bitSetCase(Options, "Restrict", ModifierOptions::Restrict);
 }
 
 void ScalarBitSetTraits<FunctionOptions>::bitset(IO &IO,
                                                  FunctionOptions &Options) {
   IO.bitSetCase(Options, "None", FunctionOptions::None);
   IO.bitSetCase(Options, "CxxReturnUdt", FunctionOptions::CxxReturnUdt);
   IO.bitSetCase(Options, "Constructor", FunctionOptions::Constructor);
   IO.bitSetCase(Options, "ConstructorWithVirtualBases",

test/DebugInfo/COFF/modifiers.ll

+; RUN: llc < %s -filetype=obj | llvm-readobj - -codeview | FileCheck %s
+
+; C++ source to regenerate:
+; $ cat m.cpp
+; union Union {
+;   int * __restrict x;
+;   float * __restrict y;
+; };
+; int f() {
+;   Union u;
+;   const int *p;
+;   const volatile int v = 0;
+;   int* volatile __restrict m;
+;   return 1;
+; }
+; void g() {
+;   const int x = 10;
+;   const char s[] = "abc";
+; }
+; $ clang m.cpp -S -emit-llvm -g -gcodeview -o m.ll
+
+; CHECK: CodeViewTypes [
+; CHECK:   Section: .debug$T (7)
+; CHECK:   Magic: 0x4
+; CHECK:   ArgList (0x1000) {
+; CHECK:     TypeLeafKind: LF_ARGLIST (0x1201)
+; CHECK:     NumArgs: 0
+; CHECK:     Arguments [
+; CHECK:     ]
+; CHECK:   }
+; CHECK:   Procedure (0x1001) {
+; CHECK:     TypeLeafKind: LF_PROCEDURE (0x1008)
+; CHECK:     ReturnType: int (0x74)
+; CHECK:     CallingConvention: NearC (0x0)
+; CHECK:     FunctionOptions [ (0x0)
+; CHECK:     ]
+; CHECK:     NumParameters: 0
+; CHECK:     ArgListType: () (0x1000)
+; CHECK:   }
+; CHECK:   FuncId (0x1002) {
+; CHECK:     TypeLeafKind: LF_FUNC_ID (0x1601)
+; CHECK:     ParentScope: 0x0
+; CHECK:     FunctionType: int () (0x1001)
+; CHECK:     Name: f
+; CHECK:   }
+; CHECK:   Union (0x1003) {
+; 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:   Modifier (0x1004) {
+; CHECK:     TypeLeafKind: LF_MODIFIER (0x1001)
+; CHECK:     ModifiedType: int* (0x674)
+; CHECK:     Modifiers [ (0x8)
+; CHECK:       Restrict (0x8)
+; CHECK:     ]
+; CHECK:   }
+; CHECK:   Modifier (0x1005) {
+; CHECK:     TypeLeafKind: LF_MODIFIER (0x1001)
+; CHECK:     ModifiedType: float* (0x640)
+; CHECK:     Modifiers [ (0x8)
+; CHECK:       Restrict (0x8)
+; CHECK:     ]
+; CHECK:   }
+; CHECK:   FieldList (0x1006) {
+; CHECK:     TypeLeafKind: LF_FIELDLIST (0x1203)
+; CHECK:     DataMember {
+; CHECK:       TypeLeafKind: LF_MEMBER (0x150D)
+; CHECK:       AccessSpecifier: Public (0x3)
+; CHECK:       Type: int* __restrict (0x1004)
+; CHECK:       FieldOffset: 0x0
+; CHECK:       Name: x
+; CHECK:     }
+; CHECK:     DataMember {
+; CHECK:       TypeLeafKind: LF_MEMBER (0x150D)
+; CHECK:       AccessSpecifier: Public (0x3)
+; CHECK:       Type: float* __restrict (0x1005)
+; CHECK:       FieldOffset: 0x0
+; CHECK:       Name: y
+; CHECK:     }
+; CHECK:   }
+
+; CHECK:   Modifier (0x100A) {
+; CHECK:     TypeLeafKind: LF_MODIFIER (0x1001)
+; CHECK:     ModifiedType: int (0x74)
+; CHECK:     Modifiers [ (0x1)
+; CHECK:       Const (0x1)
+; CHECK:     ]
+; CHECK:   }
+; CHECK:   Pointer (0x100B) {
+; CHECK:     TypeLeafKind: LF_POINTER (0x1002)
+; CHECK:     PointeeType: const int (0x100A)
+; 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:   Modifier (0x100C) {
+; CHECK:     TypeLeafKind: LF_MODIFIER (0x1001)
+; CHECK:     ModifiedType: int (0x74)
+; CHECK:     Modifiers [ (0x3)
+; CHECK:       Const (0x1)
+; CHECK:       Volatile (0x2)
+; CHECK:     ]
+; CHECK:   }
+; CHECK:   Modifier (0x100D) {
+; CHECK:     TypeLeafKind: LF_MODIFIER (0x1001)
+; CHECK:     ModifiedType: int* (0x674)
+; CHECK:     Modifiers [ (0xA)
+; CHECK:       Restrict (0x8)
+; CHECK:       Volatile (0x2)
+; CHECK:     ]
+; CHECK:   }
+; CHECK:   Procedure (0x100E) {
+; CHECK:     TypeLeafKind: LF_PROCEDURE (0x1008)
+; CHECK:     ReturnType: void (0x3)
+; CHECK:     CallingConvention: NearC (0x0)
+; CHECK:     FunctionOptions [ (0x0)
+; CHECK:     ]
+; CHECK:     NumParameters: 0
+; CHECK:     ArgListType: () (0x1000)
+; CHECK:   }
+; CHECK:   FuncId (0x100F) {
+; CHECK:     TypeLeafKind: LF_FUNC_ID (0x1601)
+; CHECK:     ParentScope: 0x0
+; CHECK:     FunctionType: void () (0x100E)
+; CHECK:     Name: g
+; CHECK:   }
+; CHECK:   Modifier (0x1010) {
+; CHECK:     TypeLeafKind: LF_MODIFIER (0x1001)
+; CHECK:     ModifiedType: char (0x70)
+; CHECK:     Modifiers [ (0x1)
+; CHECK:       Const (0x1)
+; CHECK:     ]
+; CHECK:   }
+; CHECK:   Array (0x1011) {
+; CHECK:     TypeLeafKind: LF_ARRAY (0x1503)
+; CHECK:     ElementType: const char (0x1010)
+; 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"
+
+%union.Union = type { i32* }
+
+@"\01?s@?1??g@@YAXXZ@3QBDB" = internal constant [4 x i8] c"abc\00", align 1, !dbg !0
+
+; Function Attrs: noinline nounwind optnone uwtable
+define i32 @"\01?f@@YAHXZ"() #0 !dbg !19 {
+entry:
+  %u = alloca %union.Union, align 8
+  %p = alloca i32*, align 8
+  %v = alloca i32, align 4
+  %m = alloca i32*, align 8
+  call void @llvm.dbg.declare(metadata %union.Union* %u, metadata !23, metadata !DIExpression()), !dbg !33
+  call void @llvm.dbg.declare(metadata i32** %p, metadata !34, metadata !DIExpression()), !dbg !37
+  call void @llvm.dbg.declare(metadata i32* %v, metadata !38, metadata !DIExpression()), !dbg !41
+  store volatile i32 0, i32* %v, align 4, !dbg !41
+  call void @llvm.dbg.declare(metadata i32** %m, metadata !42, metadata !DIExpression()), !dbg !44
+  ret i32 1, !dbg !45
+}
+
+; Function Attrs: nounwind readnone speculatable
+declare void @llvm.dbg.declare(metadata, metadata, metadata) #1
+
+; Function Attrs: noinline nounwind optnone uwtable
+define void @"\01?g@@YAXXZ"() #0 !dbg !2 {
+entry:
+  %x = alloca i32, align 4
+  call void @llvm.dbg.declare(metadata i32* %x, metadata !46, metadata !DIExpression()), !dbg !47
+  store i32 10, i32* %x, align 4, !dbg !47
+  ret void, !dbg !48
+}
+
+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 }
+
+!llvm.dbg.cu = !{!6}
+!llvm.module.flags = !{!14, !15, !16, !17}
+!llvm.ident = !{!18}
+
+!0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
+!1 = distinct !DIGlobalVariable(name: "s", scope: !2, file: !3, line: 17, type: !9, isLocal: true, isDefinition: true)
+!2 = distinct !DISubprogram(name: "g", linkageName: "\01?g@@YAXXZ", scope: !3, file: !3, line: 15, type: !4, isLocal: false, isDefinition: true, scopeLine: 15, flags: DIFlagPrototyped, isOptimized: false, unit: !6, variables: !7)
+!3 = !DIFile(filename: "m.cpp", directory: "D:\5Cupstream\5Cllvm\5Ctest\5CDebugInfo\5CCOFF", checksumkind: CSK_MD5, checksum: "4b83b3746efa1ba3d647fa4b6129139f")
+!4 = !DISubroutineType(types: !5)
+!5 = !{null}
+!6 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !3, producer: "clang version 7.0.0 ", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !7, globals: !8)
+!7 = !{}
+!8 = !{!0}
+!9 = !DICompositeType(tag: DW_TAG_array_type, baseType: !10, size: 32, elements: !12)
+!10 = !DIDerivedType(tag: DW_TAG_const_type, baseType: !11)
+!11 = !DIBasicType(name: "char", size: 8, encoding: DW_ATE_signed_char)
+!12 = !{!13}
+!13 = !DISubrange(count: 4)
+!14 = !{i32 2, !"CodeView", i32 1}
+!15 = !{i32 2, !"Debug Info Version", i32 3}
+!16 = !{i32 1, !"wchar_size", i32 2}
+!17 = !{i32 7, !"PIC Level", i32 2}
+!18 = !{!"clang version 7.0.0 "}
+!19 = distinct !DISubprogram(name: "f", linkageName: "\01?f@@YAHXZ", scope: !3, file: !3, line: 8, type: !20, isLocal: false, isDefinition: true, scopeLine: 8, flags: DIFlagPrototyped, isOptimized: false, unit: !6, variables: !7)
+!20 = !DISubroutineType(types: !21)
+!21 = !{!22}
+!22 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!23 = !DILocalVariable(name: "u", scope: !19, file: !3, line: 9, type: !24)
+!24 = distinct !DICompositeType(tag: DW_TAG_union_type, name: "Union", file: !3, line: 4, size: 64, flags: DIFlagTypePassByValue, elements: !25, identifier: ".?ATUnion@@")
+!25 = !{!26, !29}
+!26 = !DIDerivedType(tag: DW_TAG_member, name: "x", scope: !24, file: !3, line: 5, baseType: !27, size: 64)
+!27 = !DIDerivedType(tag: DW_TAG_restrict_type, baseType: !28)
+!28 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !22, size: 64)
+!29 = !DIDerivedType(tag: DW_TAG_member, name: "y", scope: !24, file: !3, line: 6, baseType: !30, size: 64)
+!30 = !DIDerivedType(tag: DW_TAG_restrict_type, baseType: !31)
+!31 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !32, size: 64)
+!32 = !DIBasicType(name: "float", size: 32, encoding: DW_ATE_float)
+!33 = !DILocation(line: 9, column: 10, scope: !19)
+!34 = !DILocalVariable(name: "p", scope: !19, file: !3, line: 10, type: !35)
+!35 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !36, size: 64)
+!36 = !DIDerivedType(tag: DW_TAG_const_type, baseType: !22)
+!37 = !DILocation(line: 10, column: 15, scope: !19)
+!38 = !DILocalVariable(name: "v", scope: !19, file: !3, line: 11, type: !39)
+!39 = !DIDerivedType(tag: DW_TAG_const_type, baseType: !40)
+!40 = !DIDerivedType(tag: DW_TAG_volatile_type, baseType: !22)
+!41 = !DILocation(line: 11, column: 23, scope: !19)
+!42 = !DILocalVariable(name: "m", scope: !19, file: !3, line: 12, type: !43)
+!43 = !DIDerivedType(tag: DW_TAG_volatile_type, baseType: !27)
+!44 = !DILocation(line: 12, column: 29, scope: !19)
+!45 = !DILocation(line: 13, column: 4, scope: !19)
+!46 = !DILocalVariable(name: "x", scope: !2, file: !3, line: 16, type: !36)
+!47 = !DILocation(line: 16, column: 14, scope: !2)
+!48 = !DILocation(line: 18, column: 2, scope: !2)