blob: fd274af789c044c4d695258930db4bd1888bb258 (
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
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
|
// 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 Internal.TypeSystem;
using Internal.TypeSystem.Ecma;
namespace ILCompiler
{
public static class MethodExtensions
{
public static string GetRuntimeImportName(this EcmaMethod This)
{
var decoded = This.GetDecodedCustomAttribute("System.Runtime", "RuntimeImportAttribute");
if (decoded == null)
return null;
var decodedValue = decoded.Value;
if (decodedValue.FixedArguments.Length != 0)
return (string)decodedValue.FixedArguments[decodedValue.FixedArguments.Length - 1].Value;
foreach (var argument in decodedValue.NamedArguments)
{
if (argument.Name == "EntryPoint")
return (string)argument.Value;
}
return null;
}
public static string GetRuntimeImportDllName(this EcmaMethod This)
{
var decoded = This.GetDecodedCustomAttribute("System.Runtime", "RuntimeImportAttribute");
if (decoded == null)
return null;
var decodedValue = decoded.Value;
if (decodedValue.FixedArguments.Length == 2)
return (string)decodedValue.FixedArguments[0].Value;
foreach (var argument in decodedValue.NamedArguments)
{
if (argument.Name == "DllName")
return (string)argument.Value;
}
return null;
}
public static string GetRuntimeExportName(this EcmaMethod This)
{
var decoded = This.GetDecodedCustomAttribute("System.Runtime", "RuntimeExportAttribute");
if (decoded == null)
return null;
var decodedValue = decoded.Value;
if (decodedValue.FixedArguments.Length != 0)
return (string)decodedValue.FixedArguments[0].Value;
foreach (var argument in decodedValue.NamedArguments)
{
if (argument.Name == "EntryPoint")
return (string)argument.Value;
}
return null;
}
public static string GetNativeCallableExportName(this EcmaMethod This)
{
var decoded = This.GetDecodedCustomAttribute("System.Runtime.InteropServices", "NativeCallableAttribute");
if (decoded == null)
return null;
var decodedValue = decoded.Value;
foreach (var argument in decodedValue.NamedArguments)
{
if (argument.Name == "EntryPoint")
return (string)argument.Value;
}
return null;
}
/// <summary>
/// Returns true if <paramref name="method"/> is an actual native entrypoint.
/// There's a distinction between when a method reports it's a PInvoke in the metadata
/// versus how it's treated in the compiler. For many PInvoke methods the compiler will generate
/// an IL body. The methods with an IL method body shouldn't be treated as PInvoke within the compiler.
/// </summary>
public static bool IsRawPInvoke(this MethodDesc method)
{
return method.IsPInvoke && ((method is Internal.IL.Stubs.PInvokeTargetNativeMethod) || Internal.IL.McgInteropSupport.IsPregeneratedInterop(method));
}
/// <summary>
/// What is the maximum number of steps that need to be taken from this type to its most contained generic type.
/// i.e.
/// SomeGenericType<System.Int32>.Method<System.Int32> => 1
/// SomeType.Method<System.Int32> => 0
/// SomeType.Method<List<System.Int32>> => 1
/// </summary>
public static int GetGenericDepth(this MethodDesc method)
{
int genericDepth = method.OwningType.GetGenericDepth();
foreach (TypeDesc type in method.Instantiation)
{
genericDepth = Math.Max(genericDepth, type.GetGenericDepth());
}
return genericDepth;
}
/// <summary>
/// Determine if a type has a generic depth greater than a given value
/// </summary>
/// <param name="depth"></param>
/// <returns></returns>
public static bool IsGenericDepthGreaterThan(this MethodDesc method, int depth)
{
if (method.OwningType.IsGenericDepthGreaterThan(depth))
return true;
foreach (TypeDesc type in method.Instantiation)
{
if (type.IsGenericDepthGreaterThan(depth))
return true;
}
return false;
}
/// <summary>
/// Determine whether a method can go into the sealed vtable of a type. Such method must be a sealed virtual
/// method that is not overriding any method on a base type.
/// Given that such methods can never be overridden in any derived type, we can
/// save space in the vtable of a type, and all of its derived types by not emitting these methods in their vtables,
/// and storing them in a separate table on the side. This is especially beneficial for all array types,
/// since all of their collection interface methods are sealed and implemented on the System.Array and
/// System.Array<T> base types, and therefore we can minimize the vtable sizes of all derived array types.
/// </summary>
public static bool CanMethodBeInSealedVTable(this MethodDesc method)
{
return method.IsFinal && method.IsNewSlot;
}
}
}
|
