Unify debug scope and location handling in SILInstruction and SILBuilder.

The drivers for this change are providing a simpler API to SIL pass
authors, having a more efficient of the in-memory representation,
and ruling out an entire class of common bugs that usually result
in hard-to-debug backend crashes.

Summary
-------

SILInstruction

Old                   New
+---------------+     +------------------+    +-----------------+
|SILInstruction |     |SILInstruction    |    |SILDebugLocation |
+---------------+     +------------------+    +-----------------+
| ...           |     | ...              |    | ...             |
|SILLocation    |     |SILDebugLocation *| -> |SILLocation      |
|SILDebugScope *|     +------------------+    |SILDebugScope *  |
+---------------+                             +-----------------+

We’re introducing a new class SILDebugLocation which represents the
combination of a SILLocation and a SILDebugScope.
Instead of storing an inline SILLocation and a SILDebugScope pointer,
SILInstruction now only has one SILDebugLocation pointer. The APIs of
SILBuilder and SILDebugLocation guarantees that every SILInstruction
has a nonempty SILDebugScope.

Developer-visible changes include:

SILBuilder
----------

In the old design SILBuilder populated the InsertedInstrs list to
allow setting the debug scopes of all built instructions in bulk
at the very end (as the responsibility of the user). In the new design,
SILBuilder now carries a "current debug scope" state and immediately
sets the debug scope when an instruction is inserted.
This fixes a use-after-free issue with with SIL passes that delete
instructions before destroying the SILBuilder that created them.

Because of this, SILBuilderWithScopes no longer needs to be a template,
which simplifies its call sites.

SILInstruction
--------------

It is neither possible or necessary to manually call setDebugScope()
on a SILInstruction any more. The function still exists as a private
method, but is only used when splicing instructions from one function
to another.

Efficiency
----------

In addition to dropping 20 bytes from each SILInstruction,
SILDebugLocations are now allocated in the SILModule's bump pointer
allocator and are uniqued by SILBuilder. Unfortunately repeat compiles
of the standard library already vary by about 5% so I couldn’t yet
produce reliable numbers for how much this saves overall.

rdar://problem/22017421

Author: adrian-prantl

include/swift/Basic/SourceLoc.h

@@ -59,6 +59,8 @@ class SourceLoc {
     return SourceLoc();
   }
 
+  const void *getOpaquePointerValue() const { return Value.getPointer(); }
+
   /// Print out the SourceLoc.  If this location is in the same buffer
   /// as specified by \c LastBufferID, then we don't print the filename.  If
   /// not, we do print the filename, and then update \c LastBufferID with the

include/swift/SIL/SILBuilder.h

@@ -24,48 +24,45 @@
 
 namespace swift {
 
-class SILFunction;
+class SILDebugLocation;
+class SILDebugScope;
 
 /// SILDebugScope - This class stores a lexical scope as it is
 /// represented in the debug info.
 class SILDebugScope : public SILAllocated<SILDebugScope> {
 public:
   SILLocation Loc;
   /// Always points to the parent lexical scope.
-  SILDebugScope *Parent;
+  const SILDebugScope *Parent;
   /// If this scope is inlined, this points to a special "scope" that
   /// holds only the location of the call site. The parent scope will be
   /// the scope of the inlined call site.
-  SILDebugScope *InlinedCallSite;
+  const SILDebugScope *InlinedCallSite;
   /// The SILFunction that the scope belongs to. Inlined functions may
   /// be elided, so keep track of their type here.
   /// FIXME: Storing this for every scope is wasteful.  We only need
   /// this once per function.
   SILFunction *SILFn;
 
-  SILDebugScope(SILLocation Loc,
-                SILFunction &SILFn,
-                SILDebugScope *Parent = nullptr)
-    : Loc(Loc), Parent(Parent), InlinedCallSite(nullptr),
-      SILFn(&SILFn)
-    { }
+  SILDebugScope(SILLocation Loc, SILFunction &SILFn,
+                const SILDebugScope *Parent = nullptr,
+                const SILDebugScope *InlinedCallSite = nullptr)
+      : Loc(Loc), Parent(Parent), InlinedCallSite(InlinedCallSite),
+        SILFn(&SILFn) {}
 
   /// Create a scope for an artificial function.
   SILDebugScope(SILLocation Loc)
-    : Loc(Loc), Parent(nullptr), InlinedCallSite(nullptr), SILFn(nullptr)
-    { }
+      : Loc(Loc), Parent(nullptr), InlinedCallSite(nullptr), SILFn(nullptr) {}
 
   /// Create an inlined version of CalleeScope.
-  SILDebugScope(SILDebugScope *CallSiteScope, SILDebugScope *CalleeScope,
-                SILFunction *InlinedFn)
-    : Loc(CalleeScope->Loc), Parent(CalleeScope->Parent),
-      InlinedCallSite(CallSiteScope), SILFn(InlinedFn) {
+  SILDebugScope(const SILDebugScope *CallSiteScope,
+                const SILDebugScope *CalleeScope, SILFunction *InlinedFn)
+      : Loc(CalleeScope->Loc), Parent(CalleeScope->Parent),
+        InlinedCallSite(CallSiteScope), SILFn(InlinedFn) {
     assert(CallSiteScope && CalleeScope);
     assert(InlinedFn->isInlined() &&
            "function of inlined debug scope is not inlined");
   }
-
-  void setParent(SILDebugScope *P) { Parent = P; }
 };
 
 #ifndef NDEBUG
@@ -75,36 +72,72 @@ bool maybeScopeless(SILInstruction &I);
 
 /// Knows how to make a deep copy of a debug scope.
 class ScopeCloner {
-  llvm::SmallDenseMap<SILDebugScope *, SILDebugScope *> ClonedScopeCache;
+  llvm::SmallDenseMap<const SILDebugScope *,
+                      const SILDebugScope *> ClonedScopeCache;
   SILFunction &NewFn;
 public:
-  ScopeCloner(SILFunction &Fn) : NewFn(Fn) {
-    auto *OrigScope = Fn.getDebugScope();
-    Fn.setDebugScope(getOrCreateClonedScope(OrigScope));
-    OrigScope->SILFn->setInlined();
+  /// ScopeCloner expects NewFn to be a clone of the original
+  /// function, with all debug scopes and locations still pointing to
+  /// the original function.
+  ScopeCloner(SILFunction &NewFn) : NewFn(NewFn) {
+    // Some clients of SILCloner copy over the original function's
+    // debug scope. Create a new one here.
+    // FIXME: Audit all call sites and make them create the function
+    // debug scope.
+    if (NewFn.getDebugScope()->SILFn != &NewFn) {
+      NewFn.getDebugScope()->SILFn->setInlined();
+      NewFn.setDebugScope(getOrCreateClonedScope(NewFn.getDebugScope()));
+    }
   }
-  SILDebugScope *getOrCreateClonedScope(SILDebugScope *OrigScope) {
+
+  /// Return a (cached) deep copy of a scope.
+  const SILDebugScope *getOrCreateClonedScope(const SILDebugScope *OrigScope) {
     if (!OrigScope)
       return nullptr;
 
     auto it = ClonedScopeCache.find(OrigScope);
     if (it != ClonedScopeCache.end())
       return it->second;
 
-    auto CloneScope = new (NewFn.getModule()) SILDebugScope(*OrigScope);
+    auto ClonedScope = new (NewFn.getModule()) SILDebugScope(*OrigScope);
     if (OrigScope->InlinedCallSite) {
       // For inlined functions, we need to rewrite the inlined call site.
-      CloneScope->InlinedCallSite =
-        getOrCreateClonedScope(OrigScope->InlinedCallSite);
+      ClonedScope->InlinedCallSite =
+          getOrCreateClonedScope(OrigScope->InlinedCallSite);
     } else {
-      CloneScope->SILFn = &NewFn;
-      CloneScope->Parent = getOrCreateClonedScope(OrigScope->Parent);
-    }    // Create an inline scope for the cloned instruction.
-    ClonedScopeCache.insert({OrigScope, CloneScope});
-    return CloneScope;
+      ClonedScope->SILFn = &NewFn;
+      ClonedScope->Parent = getOrCreateClonedScope(OrigScope->Parent);
+    }
+    // Create an inline scope for the cloned instruction.
+    assert(ClonedScopeCache.find(OrigScope) == ClonedScopeCache.end());
+    ClonedScopeCache.insert({OrigScope, ClonedScope});
+    return ClonedScope;
+  }
+};
+
+/// A SILLocation together with a SILDebugScope.
+class SILDebugLocation : public SILAllocated<SILDebugLocation> {
+  SILLocation Location;
+  const SILDebugScope *Scope = nullptr;
+
+public:
+  SILDebugLocation(SILLocation Loc, const SILDebugScope *DS)
+      : Location(Loc), Scope(DS) {}
+  SILLocation getLocation() const { return Location; }
+  const SILDebugScope *getScope() const { return Scope; }
+  bool operator==(const SILDebugLocation &other) const {
+    return Location == other.getLocation() && Scope == other.getScope();
   }
 };
 
+/// For use in a DenseMap.
+typedef std::pair<std::pair<const void *, unsigned>, const void *> DebugLocKey;
+struct SILDebugLocationID : public DebugLocKey {
+  SILDebugLocationID(const SILDebugLocation &L)
+      : DebugLocKey({L.getLocation().getOpaquePointerValue(),
+                     L.getLocation().getOpaqueKind()},
+                    L.getScope()) {}
+};
 }
 
 #endif

include/swift/SIL/SILCloner.h

@@ -86,7 +86,7 @@ class SILFunction
   DeclContext *DeclCtx;
 
   /// The source location and scope of the function.
-  SILDebugScope *DebugScope;
+  const SILDebugScope *DebugScope;
 
   /// The function's bare attribute. Bare means that the function is SIL-only
   /// and does not require debug info.
@@ -162,7 +162,7 @@ class SILFunction
               ClassVisibility_t classVisibility,
               Inline_t inlineStrategy, EffectsKind E,
               SILFunction *insertBefore,
-              SILDebugScope *debugScope,
+              const SILDebugScope *debugScope,
               DeclContext *DC);
 
 public:
@@ -178,7 +178,7 @@ class SILFunction
                              Inline_t inlineStrategy = InlineDefault,
                              EffectsKind EK = EffectsKind::Unspecified,
                              SILFunction *InsertBefore = nullptr,
-                             SILDebugScope *DebugScope = nullptr,
+                             const SILDebugScope *DebugScope = nullptr,
                              DeclContext *DC = nullptr);
   ~SILFunction();
 
@@ -380,10 +380,10 @@ class SILFunction
   }
 
   /// Initialize the debug scope of the function.
-  void setDebugScope(SILDebugScope *DS) { DebugScope = DS; }
+  void setDebugScope(const SILDebugScope *DS) { DebugScope = DS; }
 
   /// Get the source location of the function.
-  SILDebugScope *getDebugScope() const { return DebugScope; }
+  const SILDebugScope *getDebugScope() const { return DebugScope; }
 
   /// Get this function's bare attribute.
   IsBare_t isBare() const { return IsBare_t(Bare); }