blob: 9def3ed499b8be1b693ab2f6eb56e2b124cde5b2 (
plain)
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
|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System;
using Internal.TypeSystem;
using Debug = System.Diagnostics.Debug;
namespace Internal.IL
{
public sealed partial class InstantiatedMethodIL : MethodIL
{
private MethodDesc _method;
private MethodIL _methodIL;
private Instantiation _typeInstantiation;
private Instantiation _methodInstantiation;
public InstantiatedMethodIL(MethodDesc owningMethod, MethodIL methodIL)
{
Debug.Assert(methodIL.GetMethodILDefinition() == methodIL);
Debug.Assert(owningMethod.HasInstantiation || owningMethod.OwningType.HasInstantiation);
Debug.Assert(owningMethod.GetTypicalMethodDefinition() == methodIL.OwningMethod);
_methodIL = methodIL;
_method = owningMethod;
_typeInstantiation = owningMethod.OwningType.Instantiation;
_methodInstantiation = owningMethod.Instantiation;
}
public override MethodDesc OwningMethod
{
get
{
return _method;
}
}
public override byte[] GetILBytes()
{
return _methodIL.GetILBytes();
}
public override int MaxStack
{
get
{
return _methodIL.MaxStack;
}
}
public override ILExceptionRegion[] GetExceptionRegions()
{
return _methodIL.GetExceptionRegions();
}
public override bool IsInitLocals
{
get
{
return _methodIL.IsInitLocals;
}
}
public override LocalVariableDefinition[] GetLocals()
{
LocalVariableDefinition[] locals = _methodIL.GetLocals();
LocalVariableDefinition[] clone = null;
for (int i = 0; i < locals.Length; i++)
{
TypeDesc uninst = locals[i].Type;
TypeDesc inst = uninst.InstantiateSignature(_typeInstantiation, _methodInstantiation);
if (uninst != inst)
{
if (clone == null)
{
clone = new LocalVariableDefinition[locals.Length];
for (int j = 0; j < clone.Length; j++)
{
clone[j] = locals[j];
}
}
clone[i] = new LocalVariableDefinition(inst, locals[i].IsPinned);
}
}
return (clone == null) ? locals : clone;
}
public override Object GetObject(int token, NotFoundBehavior notFoundBehavior)
{
Object o = _methodIL.GetObject(token, notFoundBehavior);
if (o is MethodDesc)
{
o = ((MethodDesc)o).InstantiateSignature(_typeInstantiation, _methodInstantiation);
}
else if (o is TypeDesc)
{
o = ((TypeDesc)o).InstantiateSignature(_typeInstantiation, _methodInstantiation);
}
else if (o is FieldDesc)
{
o = ((FieldDesc)o).InstantiateSignature(_typeInstantiation, _methodInstantiation);
}
else if (o is MethodSignature)
{
MethodSignature template = (MethodSignature)o;
MethodSignatureBuilder builder = new MethodSignatureBuilder(template);
builder.ReturnType = template.ReturnType.InstantiateSignature(_typeInstantiation, _methodInstantiation);
for (int i = 0; i < template.Length; i++)
builder[i] = template[i].InstantiateSignature(_typeInstantiation, _methodInstantiation);
o = builder.ToSignature();
}
return o;
}
public override MethodIL GetMethodILDefinition()
{
return _methodIL;
}
}
}
|
