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
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
using System;
using System.Collections.Generic;
using Internal.TypeSystem;
using Debug = System.Diagnostics.Debug;
namespace ILCompiler.DependencyAnalysis
{
/// <summary>
/// Represents a section of the executable where interface dispatch cells and their slot information
/// is stored.
/// </summary>
public class InterfaceDispatchCellSectionNode : ArrayOfEmbeddedDataNode<InterfaceDispatchCellNode>
{
public InterfaceDispatchCellSectionNode(NodeFactory factory)
: base("__InterfaceDispatchCellSection_Start", "__InterfaceDispatchCellSection_End", new DispatchCellComparer(factory))
{
}
protected override void GetElementDataForNodes(ref ObjectDataBuilder builder, NodeFactory factory, bool relocsOnly)
{
if (relocsOnly)
return;
// The interface dispatch cell has an alignment requirement of 2 * [Pointer size] as part of the
// synchronization mechanism of the two values in the runtime.
builder.RequireInitialAlignment(factory.Target.PointerSize * 2);
// This number chosen to be high enough that the cost of recording slot numbers is cheap.
const int InterfaceDispatchCellRunLength = 32;
const int NoSlot = -1;
//
// We emit the individual dispatch cells in groups. The purpose of the grouping is to save
// us the number of slots we need to emit. The grouping looks like this:
//
// DispatchCell1
// DispatchCell2
// ...
// DispatchCellN
// Null
// Slot of the above dispatch cells
//
int runLength = 0;
int currentSlot = NoSlot;
foreach (InterfaceDispatchCellNode node in NodesList)
{
MethodDesc targetMethod = node.TargetMethod;
int targetSlot = VirtualMethodSlotHelper.GetVirtualMethodSlot(factory, targetMethod, targetMethod.OwningType);
if (currentSlot == NoSlot)
{
// This is the first dispatch cell we're emitting
currentSlot = targetSlot;
}
else if (currentSlot != targetSlot || runLength == InterfaceDispatchCellRunLength)
{
// Make sure we are sorted
Debug.Assert(targetSlot >= currentSlot);
// End the run of dispatch cells
builder.EmitZeroPointer();
builder.EmitNaturalInt(currentSlot);
currentSlot = targetSlot;
runLength = 0;
}
node.InitializeOffsetFromBeginningOfArray(builder.CountBytes);
node.EncodeData(ref builder, factory, relocsOnly);
builder.AddSymbol(node);
runLength++;
}
if (runLength > 0)
{
// End the run of dispatch cells
builder.EmitZeroPointer();
builder.EmitNaturalInt(currentSlot);
}
}
public override int ClassCode => -1389343;
/// <summary>
/// Comparer that groups interface dispatch cells by their slot number.
/// </summary>
private class DispatchCellComparer : IComparer<InterfaceDispatchCellNode>
{
private readonly NodeFactory _factory;
private readonly TypeSystemComparer _comparer = new TypeSystemComparer();
public DispatchCellComparer(NodeFactory factory)
{
_factory = factory;
}
public int Compare(InterfaceDispatchCellNode x, InterfaceDispatchCellNode y)
{
MethodDesc methodX = x.TargetMethod;
MethodDesc methodY = y.TargetMethod;
// The primary purpose of this comparer is to sort everything by slot
int slotX = VirtualMethodSlotHelper.GetVirtualMethodSlot(_factory, methodX, methodX.OwningType);
int slotY = VirtualMethodSlotHelper.GetVirtualMethodSlot(_factory, methodY, methodY.OwningType);
int result = slotX - slotY;
if (result != 0)
return result;
// If slots are the same, compare the method and callsite identifier to get
// a deterministic order within the group.
result = _comparer.Compare(methodX, methodY);
if (result != 0)
return result;
result = StringComparer.Ordinal.Compare(x.CallSiteIdentifier, y.CallSiteIdentifier);
if (result != 0)
return result;
Debug.Assert(x == y);
return 0;
}
}
}
}
|
