1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
|
//===--- SILVTable.cpp - Defines the SILVTable class ----------------------===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
//
//===----------------------------------------------------------------------===//
//
// This file defines the SILVTable class, which is used to map dynamically
// dispatchable class methods and properties to their concrete implementations
// for a dynamic type. This information (FIXME) will be used by IRGen to lay
// out class vtables, and can be used by devirtualization passes to lower
// class_method instructions to static function_refs.
//
//===----------------------------------------------------------------------===//
#include "swift/SIL/SILVTable.h"
#include "swift/SIL/SILModule.h"
using namespace swift;
void SILVTableEntry::setImplementation(SILFunction *f) {
getImplementation()->decrementRefCount();
ImplAndKind.setPointer(f);
f->incrementRefCount();
}
SILVTable *SILVTable::create(SILModule &M, ClassDecl *Class,
SerializedKind_t Serialized,
ArrayRef<Entry> Entries) {
return create(M, Class, SILType(), Serialized, Entries);
}
SILVTable *SILVTable::create(SILModule &M, ClassDecl *Class, SILType classType,
SerializedKind_t Serialized,
ArrayRef<Entry> Entries) {
auto size = totalSizeToAlloc<Entry>(Entries.size());
auto buf = M.allocate(size, alignof(SILVTable));
SILVTable *vt = ::new (buf) SILVTable(Class, classType, Serialized, Entries);
M.vtables.push_back(vt);
if (vt->isSpecialized())
M.SpecializedVTableMap[classType] = vt;
else
M.VTableMap[Class] = vt;
// Update the Module's cache with new vtable + vtable entries:
for (const Entry &entry : Entries) {
M.VTableEntryCache.insert({{vt, entry.getMethod()}, entry});
}
return vt;
}
std::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 std::nullopt;
}
void SILVTable::removeFromVTableCache(Entry &entry) {
SILModule &M = entry.getImplementation()->getModule();
M.VTableEntryCache.erase({this, entry.getMethod()});
}
void SILVTable::updateVTableCache(const Entry &entry) {
SILModule &M = entry.getImplementation()->getModule();
M.VTableEntryCache[{this, entry.getMethod()}] = entry;
}
void SILVTable::replaceEntries(ArrayRef<Entry> newEntries) {
auto entries = getMutableEntries();
ASSERT(newEntries.size() <= entries.size());
for (unsigned i = 0; i < entries.size(); ++i) {
entries[i].getImplementation()->decrementRefCount();
if (i < newEntries.size()) {
entries[i] = newEntries[i];
entries[i].getImplementation()->incrementRefCount();
updateVTableCache(entries[i]);
} else {
removeFromVTableCache(entries[i]);
}
}
NumEntries = newEntries.size();
}
SILVTable::SILVTable(ClassDecl *c, SILType classType,
SerializedKind_t serialized, ArrayRef<Entry> entries)
: Class(c), classType(classType), SerializedKind(serialized),
NumEntries(entries.size()) {
std::uninitialized_copy(entries.begin(), entries.end(),
getTrailingObjects<Entry>());
// Bump the reference count of functions referenced by this table.
for (const Entry &entry : getEntries()) {
entry.getImplementation()->incrementRefCount();
}
}
SILVTable::~SILVTable() {
// Drop the reference count of functions referenced by this table.
for (const Entry &entry : getEntries()) {
entry.getImplementation()->decrementRefCount();
}
}
|
