[DebugInfo] Try to make class memory layout more efficient

[davide]

Summary

I started this effort after noticing that DI shows up as a considerable portion of memory usage during an LTO build (of clang, and others).
This is roughly the data I got (peak usage):
DISubprogram: 228MB
DILocalVariable: 164MB
The proposed patch packs field slightly more efficiently reducing the size of DISubprogram from 48bytes to 40bytes and of DILocalVariable from 40 bytes to 32 bytes.
The saving overall in memory is ~70MB.
This is still to be considered WIP as this breaks 4 tests in the LLVM suite (which I'm currently investigating), but I wanted to have some eyes on it as DebugInfo seems to be of interest of many these days.

[dblaikie]

Certainly seems like a thing we might want to try - though it'd help to
have a reminder/description of why shrinking these fields to these specific
bit sizes is valid (are the already restricted to those sizes in other
places/ways, for example - point to where/how they're already so restricted)

[probinson]

include/llvm/IR/DebugInfoMetadata.h

1237

MSVC starts a new container field every time you change the base type, so this won't pack the way you want on Windows. Use unsigned as the base type in all of these.

[davide]

include/llvm/IR/DebugInfoMetadata.h

1237

Oh, sigh. I'll make sure to test with MSVC.

[davide]

Addressed reviewers comments. I decided to split the DILocalVariable changes and I'll post another patch soon.
Thanks for your feedback!

[aprantl]

include/llvm/IR/DebugInfoMetadata.h

1257

Should we also have a static assert that log2(DW_VIRTUALITY_max) < 4 here?

[davide]

Addressed Adrian's comment.

[aprantl]

include/llvm/IR/DebugInfoMetadata.h

1257

Sorry, but it looks like my suggestion was incorrect: It's either log2(DW_VIRTUALITY_max) <= 2 or DW_VIRTUALITY_max < 4.

[davide]

Done. Any other comments?

[aprantl]

LGTM with Duncan's comment about Flags addressed.

include/llvm/IR/DebugInfoMetadata.h

 /// TODO: Remove DisplayName.  It's always equal to Name.
 /// TODO: Split up flags.
 class DISubprogram : public DILocalScope {
   friend class LLVMContextImpl;
   friend class MDNode;
 
   unsigned Line;
   unsigned ScopeLine;
-  unsigned Virtuality;
   unsigned VirtualIndex;
-  unsigned Flags;
-  bool IsLocalToUnit;
-  bool IsDefinition;
-  bool IsOptimized;
+
+  // Virtuality can only assume three values, so we can pack
+  // in 2 bits (none/pure/pure_virtual).
+  unsigned Virtuality:2;
+
+  unsigned Flags:27;
+
+  // These are boolean flags so one bit is enough.
+  // MSVC starts a new container field every time the base
+  // type changes so we can't use 'bool' to ensure these bits
+  // are packed.
+  unsigned IsLocalToUnit:1;
+  unsigned IsDefinition:1;
+  unsigned IsOptimized:1;
 
   DISubprogram(LLVMContext &C, StorageType Storage, unsigned Line,
                unsigned ScopeLine, unsigned Virtuality, unsigned VirtualIndex,
                unsigned Flags, bool IsLocalToUnit, bool IsDefinition,
                bool IsOptimized, ArrayRef<Metadata *> Ops)
       : DILocalScope(C, DISubprogramKind, Storage, dwarf::DW_TAG_subprogram,
                      Ops),
-        Line(Line), ScopeLine(ScopeLine), Virtuality(Virtuality),
-        VirtualIndex(VirtualIndex), Flags(Flags), IsLocalToUnit(IsLocalToUnit),
-        IsDefinition(IsDefinition), IsOptimized(IsOptimized) {}
+        Line(Line), ScopeLine(ScopeLine), VirtualIndex(VirtualIndex),
+        Virtuality(Virtuality), Flags(Flags), IsLocalToUnit(IsLocalToUnit),
+        IsDefinition(IsDefinition), IsOptimized(IsOptimized) {
+    static_assert(dwarf::DW_VIRTUALITY_max < 4, "Virtuality out of range");
+    assert(Virtuality < 4 && "Virtuality out of range");
+  }
   ~DISubprogram() = default;
 
   static DISubprogram *
   getImpl(LLVMContext &Context, DIScopeRef Scope, StringRef Name,
           StringRef LinkageName, DIFile *File, unsigned Line,
           DISubroutineType *Type, bool IsLocalToUnit, bool IsDefinition,
           unsigned ScopeLine, DITypeRef ContainingType, unsigned Virtuality,
           unsigned VirtualIndex, unsigned Flags, bool IsOptimized,

unittests/IR/MetadataTest.cpp

   StringRef LinkageName = "linkage";
   DIFile *File = getFile();
   unsigned Line = 2;
   DISubroutineType *Type = getSubroutineType();
   bool IsLocalToUnit = false;
   bool IsDefinition = true;
   unsigned ScopeLine = 3;
   DITypeRef ContainingType = getCompositeType();
-  unsigned Virtuality = 4;
+  unsigned Virtuality = 2;
   unsigned VirtualIndex = 5;
   unsigned Flags = 6;
   bool IsOptimized = false;
   MDTuple *TemplateParams = getTuple();
   DISubprogram *Declaration = getSubprogram();
   MDTuple *Variables = getTuple();
 
   auto *N = DISubprogram::get(