SIL: Refactor SILVTable::getImplementation() into getEntry()

This will allow IRGen to recover the entry kind when emitting
class metadata.

Author: slavapestov

include/swift/SIL/SILModule.h

@@ -150,7 +150,7 @@ class SILModule {
   VTableListType vtables;
 
   /// This is a cache of vtable entries for quick look-up
-  llvm::DenseMap<std::pair<const SILVTable *, SILDeclRef>, SILFunction *>
+  llvm::DenseMap<std::pair<const SILVTable *, SILDeclRef>, SILVTable::Entry>
       VTableEntryCache;
 
   /// Lookup table for SIL witness tables from conformances.

include/swift/SIL/SILVTable.h

@@ -26,6 +26,7 @@
 #include "swift/SIL/SILFunction.h"
 #include "llvm/ADT/ilist_node.h"
 #include "llvm/ADT/ilist.h"
+#include "llvm/ADT/Optional.h"
 #include <algorithm>
 
 namespace swift {
@@ -117,7 +118,7 @@ class SILVTable : public llvm::ilist_node<SILVTable>,
   ArrayRef<Entry> getEntries() const { return {Entries, NumEntries}; }
 
   /// Look up the implementation function for the given method.
-  SILFunction *getImplementation(SILModule &M, SILDeclRef method) const;
+  Optional<Entry> getEntry(SILModule &M, SILDeclRef method) const;
 
   /// Removes entries from the vtable.
   /// \p predicate Returns true if the passed entry should be removed.

lib/IRGen/GenMeta.cpp

@@ -3195,9 +3195,8 @@ namespace {
     void addMethod(SILDeclRef fn) {
       // Find the vtable entry.
       assert(VTable && "no vtable?!");
-      if (SILFunction *func =
-            VTable->getImplementation(IGM.getSILModule(), fn)) {
-        B.add(IGM.getAddrOfSILFunction(func, NotForDefinition));
+      if (auto entry = VTable->getEntry(IGM.getSILModule(), fn)) {
+        B.add(IGM.getAddrOfSILFunction(entry->Implementation, NotForDefinition));
       } else {
         // The method is removed by dead method elimination.
         // It should be never called. We add a pointer to an error function.

lib/SIL/SILModule.cpp

@@ -711,8 +711,8 @@ lookUpFunctionInVTable(ClassDecl *Class, SILDeclRef Member) {
 
     // Ok, we have a VTable. Try to lookup the SILFunction implementation from
     // the VTable.
-    if (SILFunction *F = Vtbl->getImplementation(*this, Member))
-      return F;
+    if (auto E = Vtbl->getEntry(*this, Member))
+      return E->Implementation;
 
     // If we fail to lookup the SILFunction, again skip Class and attempt to
     // resolve the method in the VTable of the super class of Class if such a

lib/SIL/SILVTable.cpp

@@ -35,21 +35,21 @@ SILVTable *SILVTable::create(SILModule &M, ClassDecl *Class,
   M.VTableMap[Class] = vt;
   // Update the Module's cache with new vtable + vtable entries:
   for (const Entry &entry : Entries) {
-    M.VTableEntryCache.insert({{vt, entry.Method}, entry.Implementation});
+    M.VTableEntryCache.insert({{vt, entry.Method}, entry});
   }
   return vt;
 }
 
-SILFunction *
-SILVTable::getImplementation(SILModule &M, SILDeclRef method) const {
+Optional<SILVTable::Entry>
+SILVTable::getEntry(SILModule &M, SILDeclRef method) const {
   SILDeclRef m = method;
   do {
     auto entryIter = M.VTableEntryCache.find({this, m});
     if (entryIter != M.VTableEntryCache.end()) {
       return (*entryIter).second;
     }
   } while ((m = m.getOverridden()));
-  return nullptr;
+  return None;
 }
 
 void SILVTable::removeFromVTableCache(Entry &entry) {