SIL: efficiently store SILLocation in SILInstruction

Store the 1-byte kindAndFlags of SILLocation in the instruction's SILNode bitfield and only store SILLocation::storage in SILInstruction directly.
This reduces the space for the location from 2 to 1 word in SILInstruction.

Author: eeckstein

include/swift/SIL/SILInstruction.h

@@ -323,13 +323,17 @@ class SILInstruction : public llvm::ilist_node<SILInstruction> {
 
   /// A backreference to the containing basic block.  This is maintained by
   /// ilist_traits<SILInstruction>.
-  SILBasicBlock *ParentBB;
+  SILBasicBlock *ParentBB = nullptr;
 
-  /// This instruction's containing lexical scope and source location
-  /// used for debug info and diagnostics.
-  SILDebugLocation Location;
+  /// This instruction's containing lexical scope for debug info.
+  const SILDebugScope *debugScope = nullptr;
+
+  /// This instructions source location for diagnostics and debug info.
+  ///
+  /// To reduce space, this is only the storage of the SILLocation. The
+  /// location's kindAndFlags is stored in the SILNode inline bitfields.
+  SILLocation::Storage locationStorage;
 
-  SILInstruction() = delete;
   void operator=(const SILInstruction &) = delete;
   void operator delete(void *Ptr, size_t) = delete;
 
@@ -360,8 +364,7 @@ class SILInstruction : public llvm::ilist_node<SILInstruction> {
   SILInstructionResultArray getResultsImpl() const;
 
 protected:
-  SILInstruction(SILDebugLocation DebugLoc) :
-        ParentBB(nullptr), Location(DebugLoc) {
+  SILInstruction() {
     NumCreatedInstructions++;
   }
 
@@ -423,14 +426,25 @@ class SILInstruction : public llvm::ilist_node<SILInstruction> {
   SILModule &getModule() const;
 
   /// This instruction's source location (AST node).
-  SILLocation getLoc() const;
-  const SILDebugScope *getDebugScope() const;
-  SILDebugLocation getDebugLocation() const { return Location; }
+  SILLocation getLoc() const {
+    return SILLocation(locationStorage,
+                       asSILNode()->Bits.SILInstruction.LocationKindAndFlags);
+  }
+  const SILDebugScope *getDebugScope() const { return debugScope; }
+  SILDebugLocation getDebugLocation() const {
+    return SILDebugLocation(getLoc(), debugScope);
+  }
 
   /// Sets the debug location.
   /// Note: Usually it should not be needed to use this function as the location
   /// is already set in when creating an instruction.
-  void setDebugLocation(SILDebugLocation Loc) { Location = Loc; }
+  void setDebugLocation(SILDebugLocation debugLoc) {
+    debugScope = debugLoc.getScope();
+    SILLocation loc = debugLoc.getLocation();
+    asSILNode()->Bits.SILInstruction.LocationKindAndFlags =
+      loc.kindAndFlags.packedKindAndFlags;
+    locationStorage = loc.storage;
+  }
 
   /// This method unlinks 'self' from the containing basic block and deletes it.
   void eraseFromParent();
@@ -758,7 +772,9 @@ class NonSingleValueInstruction : public SILInstruction, public SILNode {
   friend struct SILNodeOffsetChecker;
 public:
   NonSingleValueInstruction(SILInstructionKind kind, SILDebugLocation loc)
-    : SILInstruction(loc), SILNode((SILNodeKind)kind) {}
+      : SILInstruction(), SILNode((SILNodeKind)kind) {
+    setDebugLocation(loc);
+  }
 
   using SILInstruction::operator new;
   using SILInstruction::dumpInContext;
@@ -929,8 +945,9 @@ class SingleValueInstruction : public SILInstruction, public ValueBase {
 public:
   SingleValueInstruction(SILInstructionKind kind, SILDebugLocation loc,
                          SILType type)
-      : SILInstruction(loc),
-        ValueBase(ValueKind(kind), type) {}
+        : SILInstruction(), ValueBase(ValueKind(kind), type) {
+    setDebugLocation(loc);
+  }
 
   using SILInstruction::operator new;
   using SILInstruction::dumpInContext;

include/swift/SIL/SILLocation.h

@@ -119,6 +119,8 @@ class SILLocation {
   };
 
 private:
+  friend class SILInstruction;
+
   /// Each kind corresponds to a union member in `Storage`.
   enum StorageKind : uint8_t {
     /// For usages see the struct `FilenameAndLocation`.
@@ -164,6 +166,7 @@ class SILLocation {
   /// Contains the LocationKind, StorageKind and some extra flags.
   /// This fits nicely in a single byte. If for some reason we need more flags
   /// it's possible to extend this to e.g. a uint16_t.
+  /// But SILNode::Bits.LocationKindAndFlags must be updated accordingly.
   union KindAndFlags {
     KindAndFlags() : packedKindAndFlags(0) {}
     KindAndFlags(LocationKind kind, StorageKind storageKind)
@@ -266,6 +269,10 @@ class SILLocation {
   SILLocation(SourceLoc L, LocationKind K)
       : storage(L), kindAndFlags(K, SourceLocKind) {}
 
+  // Used by SILInstruction.
+  SILLocation(Storage storage, uint8_t packedKindAndFlags) :
+    storage(storage), kindAndFlags(packedKindAndFlags) {}
+
 public:
   // When an ASTNode gets implicitly converted into a SILLocation we
   // construct a RegularLocation. Since RegularLocations represent the majority

include/swift/SIL/SILNode.h

@@ -124,6 +124,8 @@ class alignas(8) SILNode {
   enum { NumSILAccessEnforcementBits = 2 };
 
 protected:
+  friend class SILInstruction;
+
   union { uint64_t OpaqueBits;
 
   SWIFT_INLINE_BITFIELD_BASE(SILNode, bitmax(NumSILNodeKindBits,8),
@@ -145,7 +147,9 @@ class alignas(8) SILNode {
       Index : 32
   );
 
-  SWIFT_INLINE_BITFIELD_EMPTY(SILInstruction, SILNode);
+  SWIFT_INLINE_BITFIELD(SILInstruction, SILNode, 8,
+    LocationKindAndFlags : 8
+  );
 
   // Special handling for UnaryInstructionWithTypeDependentOperandsBase
   SWIFT_INLINE_BITFIELD(IBWTO, SILNode, 64-NumSILNodeBits,
@@ -227,7 +231,7 @@ class alignas(8) SILNode {
     OnStack : 1,
     NumTailTypes : 32-1-1-NumAllocationInstBits
   );
-  static_assert(32-1-1-NumAllocationInstBits >= 16, "Reconsider bitfield use?");
+  static_assert(32-1-1-NumAllocationInstBits >= 14, "Reconsider bitfield use?");
 
   UIWTDOB_BITFIELD_EMPTY(AllocValueBufferInst, AllocationInst);
 

lib/SIL/IR/SILInstruction.cpp

@@ -36,20 +36,14 @@ using namespace Lowering;
 // Instruction-specific properties on SILValue
 //===----------------------------------------------------------------------===//
 
-SILLocation SILInstruction::getLoc() const { return Location.getLocation(); }
-
-const SILDebugScope *SILInstruction::getDebugScope() const {
-  return Location.getScope();
-}
-
 void SILInstruction::setDebugScope(const SILDebugScope *DS) {
   if (getDebugScope() && getDebugScope()->InlinedCallSite)
     assert(DS->InlinedCallSite && "throwing away inlined scope info");
 
   assert(DS->getParentFunction() == getFunction() &&
          "scope belongs to different function");
 
-  Location = SILDebugLocation(getLoc(), DS);
+  debugScope = DS;
 }
 
 //===----------------------------------------------------------------------===//