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
|
/*
Copyright (C) 2011-2015 de4dot@gmail.com
This file is part of de4dot.
de4dot is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
de4dot is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with de4dot. If not, see <http://www.gnu.org/licenses/>.
*/
using System;
using System.Collections.Generic;
using System.Reflection;
using dnlib.DotNet;
using de4dot.blocks;
namespace AssemblyData.methodsrewriter {
static class ResolverUtils {
public static bool CompareTypes(Type a, IType b) {
return new SigComparer().Equals(a, b);
}
public static bool CompareFields(FieldInfo a, IField b) {
return new SigComparer().Equals(a, b);
}
public static bool HasThis(MethodBase method) {
return (method.CallingConvention & CallingConventions.HasThis) != 0;
}
public static bool ExplicitThis(MethodBase method) {
return (method.CallingConvention & CallingConventions.ExplicitThis) != 0;
}
public static bool CompareMethods(MethodBase a, IMethod b) {
return new SigComparer().Equals(a, b);
}
public static Type GetReturnType(MethodBase methodBase) {
var methodInfo = methodBase as MethodInfo;
if (methodInfo != null)
return methodInfo.ReturnType;
var ctorInfo = methodBase as ConstructorInfo;
if (ctorInfo != null)
return typeof(void);
throw new ApplicationException(string.Format("Could not figure out return type: {0} ({1:X8})", methodBase, methodBase.MetadataToken));
}
public static Type[] GetGenericArguments(MethodBase methodBase) {
try {
return methodBase.GetGenericArguments();
}
catch (NotSupportedException) {
return new Type[0];
}
}
public static IEnumerable<MethodBase> GetMethodBases(Type type, BindingFlags flags) {
if (type.TypeInitializer != null)
yield return type.TypeInitializer;
foreach (var ctor in type.GetConstructors(flags))
yield return ctor;
foreach (var m in type.GetMethods(flags))
yield return m;
}
class CachedMemberInfo {
Type type;
Type memberType;
public CachedMemberInfo(Type type, Type memberType) {
this.type = type;
this.memberType = memberType;
}
public override int GetHashCode() {
return type.GetHashCode() ^ memberType.GetHashCode();
}
public override bool Equals(object obj) {
var other = obj as CachedMemberInfo;
if (other == null)
return false;
return type == other.type && memberType == other.memberType;
}
}
static Dictionary<CachedMemberInfo, FieldInfo> cachedFieldInfos = new Dictionary<CachedMemberInfo, FieldInfo>();
public static FieldInfo GetField(Type type, Type fieldType, BindingFlags flags) {
var key = new CachedMemberInfo(type, fieldType);
FieldInfo fieldInfo;
if (cachedFieldInfos.TryGetValue(key, out fieldInfo))
return fieldInfo;
foreach (var field in type.GetFields(flags)) {
if (field.FieldType == fieldType) {
cachedFieldInfos[key] = field;
return field;
}
}
return null;
}
public static FieldInfo GetFieldThrow(Type type, Type fieldType, BindingFlags flags, string msg) {
var info = GetField(type, fieldType, flags);
if (info != null)
return info;
throw new ApplicationException(msg);
}
public static List<FieldInfo> GetFields(Type type, Type fieldType, BindingFlags flags) {
var list = new List<FieldInfo>();
foreach (var field in type.GetFields(flags)) {
if (field.FieldType == fieldType)
list.Add(field);
}
return list;
}
public static Type MakeInstanceType(Type type, ITypeDefOrRef typeRef) {
var ts = typeRef as TypeSpec;
if (ts == null)
return type;
var git = ts.TypeSig as GenericInstSig;
if (git == null)
return type;
var types = new Type[git.GenericArguments.Count];
bool isTypeDef = true;
for (int i = 0; i < git.GenericArguments.Count; i++) {
var arg = git.GenericArguments[i];
if (!(arg is GenericSig))
isTypeDef = false;
types[i] = Resolver.GetRtType(arg);
}
if (isTypeDef)
return type;
return type.MakeGenericType(types);
}
}
}
|
