Make createReferenceType take size and align

[loladiro]

Summary

Since we're passing references to dbg.value as pointers, we need to have the frontend properly declare their sizes and alignments (as it already does for regular pointers) in preparation for my upcoming patch to have the verifer check that the sizes agree.

[dblaikie]

Gut reaction: This would cause extra DWARF to be emitted which might be
erroneous/confusing... (though, as you point out, there's not much of an
argument for being inconsistent with pointers here)

What's the DWARF look like for pointers and references before and after
your patch? (& the usual "what does GCC do?")

[loladiro]

Ah, interesting we skip emitting the size of a pointer in the backend. Will add the same for reference types.

[loladiro]

Skip emitting sizes for reference types in the backend.

[loladiro]

Add a test case to make sure the backend suppression doesn't get removed without somebody noticing. Does this look ok now?

[dblaikie]

Seems good to me

llvm/trunk/include/llvm/IR/DIBuilder.h

public:
     /// \param AlignInBits Alignment. (optional)
     /// \param Class Type for which this pointer points to members of.
     DIDerivedType *createMemberPointerType(DIType *PointeeTy, DIType *Class,
                                            uint64_t SizeInBits,
                                            uint64_t AlignInBits = 0);
 
     /// Create debugging information entry for a c++
     /// style reference or rvalue reference type.
-    DIDerivedType *createReferenceType(unsigned Tag, DIType *RTy);
+    DIDerivedType *createReferenceType(unsigned Tag, DIType *RTy,
+                                       uint64_t SizeInBits = 0,
+                                       uint64_t AlignInBits = 0);
 
     /// Create debugging information entry for a typedef.
     /// \param Ty          Original type.
     /// \param Name        Typedef name.
     /// \param File        File where this type is defined.
     /// \param LineNo      Line number.
     /// \param Context     The surrounding context for the typedef.
     DIDerivedType *createTypedef(DIType *Ty, StringRef Name, DIFile *File,

llvm/trunk/lib/CodeGen/AsmPrinter/DwarfUnit.cpp

if (FromTy)
     addType(Buffer, FromTy);
 
   // Add name if not anonymous or intermediate type.
   if (!Name.empty())
     addString(Buffer, dwarf::DW_AT_name, Name);
 
   // Add size if non-zero (derived types might be zero-sized.)
   if (Size && Tag != dwarf::DW_TAG_pointer_type
-           && Tag != dwarf::DW_TAG_ptr_to_member_type)
+           && Tag != dwarf::DW_TAG_ptr_to_member_type
+           && Tag != dwarf::DW_TAG_reference_type
+           && Tag != dwarf::DW_TAG_rvalue_reference_type)
     addUInt(Buffer, dwarf::DW_AT_byte_size, None, Size);
 
   if (Tag == dwarf::DW_TAG_ptr_to_member_type)
     addDIEEntry(
         Buffer, dwarf::DW_AT_containing_type,
         *getOrCreateTypeDIE(resolve(cast<DIDerivedType>(DTy)->getClassType())));
   // Add source line info if available and TyDesc is not a forward declaration.
   if (!DTy->isForwardDecl())

llvm/trunk/lib/IR/DIBuilder.cpp

DIDerivedType *DIBuilder::createMemberPointerType(DIType *PointeeTy,
                                                   uint64_t SizeInBits,
                                                   uint64_t AlignInBits) {
   return DIDerivedType::get(VMContext, dwarf::DW_TAG_ptr_to_member_type, "",
                             nullptr, 0, nullptr, DITypeRef::get(PointeeTy),
                             SizeInBits, AlignInBits, 0, 0,
                             DITypeRef::get(Base));
 }
 
-DIDerivedType *DIBuilder::createReferenceType(unsigned Tag, DIType *RTy) {
+DIDerivedType *DIBuilder::createReferenceType(unsigned Tag, DIType *RTy,
+                                              uint64_t SizeInBits,
+                                              uint64_t AlignInBits) {
   assert(RTy && "Unable to create reference type");
   return DIDerivedType::get(VMContext, Tag, "", nullptr, 0, nullptr,
-                            DITypeRef::get(RTy), 0, 0, 0, 0);
+                            DITypeRef::get(RTy), SizeInBits, AlignInBits, 0, 0);
 }
 
 DIDerivedType *DIBuilder::createTypedef(DIType *Ty, StringRef Name,
                                         DIFile *File, unsigned LineNo,
                                         DIScope *Context) {
   return DIDerivedType::get(VMContext, dwarf::DW_TAG_typedef, Name, File,
                             LineNo,
                             DIScopeRef::get(getNonCompileUnitScope(Context)),

llvm/trunk/test/DebugInfo/Generic/ptrsize.ll

+; REQUIRES: object-emission
+
+; RUN: %llc_dwarf -O0 -filetype=obj < %s > %t
+; RUN: llvm-dwarfdump %t | FileCheck %s
+
+; Check that pointers and references get emitted without size information in
+; DWARF, even if they are so specified in the IR
+
+; CHECK: 0x[[O1:[0-9a-f]+]]:   DW_TAG_pointer_type
+; CHECK-NEXT: DW_AT_type [DW_FORM_ref4]
+; CHECK-NOT: DW_AT_byte_size
+; CHECK: 0x[[O2:[0-9a-f]+]]:   DW_TAG_
+
+; CHECK: 0x[[O3:[0-9a-f]+]]:   DW_TAG_reference_type
+; CHECK-NEXT: DW_AT_type [DW_FORM_ref4]
+; CHECK-NOT: DW_AT_byte_size
+
+define i32 @foo() !dbg !4 {
+entry:
+  ret i32 0, !dbg !13
+}
+
+define i32 @bar() !dbg !5 {
+entry:
+  ret i32 0, !dbg !13
+}
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!11, !12}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang", isOptimized: false, runtimeVersion: 0, emissionKind: 0, enums: !2, retainedTypes: !2, subprograms: !3, globals: !2, imports: !2)
+!1 = !DIFile(filename: "dwarf-test.c", directory: "test")
+!2 = !{}
+!3 = !{!4, !5}
+!4 = distinct !DISubprogram(name: "foo", scope: !0, file: !1, line: 6, type: !6, isLocal: false, isDefinition: true, scopeLine: 6, virtualIndex: 6, flags: DIFlagPrototyped, isOptimized: false, variables: !2)
+!5 = distinct !DISubprogram(name: "bar", scope: !0, file: !1, line: 6, type: !15, isLocal: false, isDefinition: true, scopeLine: 6, virtualIndex: 6, flags: DIFlagPrototyped, isOptimized: false, variables: !2)
+!6 = !DISubroutineType(types: !7)
+!7 = !{!9}
+!8 = !DIBasicType(name: "int", size: 32, align: 32, encoding: DW_ATE_signed)
+!9 = !DIDerivedType(tag: DW_TAG_pointer_type, scope: !0, baseType: !8, size: 64, align: 64)
+!10 = !DIDerivedType(tag: DW_TAG_reference_type, scope: !0, baseType: !8, size: 64, align: 64)
+!11 = !{i32 2, !"Dwarf Version", i32 3}
+!12 = !{i32 1, !"Debug Info Version", i32 3}
+!13 = !DILocation(line: 7, scope: !4)
+!14 = !{!10}
+!15 = !DISubroutineType(types: !14)