blob: 82edd8aaf59ce4a78440ffb44f7d4a99649b7321 (
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
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
|
// 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.
#include "common.h"
#include "CommonTypes.h"
#include "CommonMacros.h"
#include "daccess.h"
#include "rhassert.h"
#include "rhbinder.h"
#include "eetype.h"
#include "PalRedhawkCommon.h"
#include "PalRedhawk.h"
#include "CommonMacros.inl"
#pragma warning(disable:4127) // C4127: conditional expression is constant
// Validate an EEType extracted from an object.
bool EEType::Validate(bool assertOnFail /* default: true */)
{
#define REPORT_FAILURE() do { if (assertOnFail) { ASSERT_UNCONDITIONALLY("EEType::Validate check failed"); } return false; } while (false)
// Deal with the most common case of a bad pointer without an exception.
if (this == NULL)
REPORT_FAILURE();
// EEType structures should be at least pointer aligned.
if (dac_cast<TADDR>(this) & (sizeof(TADDR)-1))
REPORT_FAILURE();
// Verify object size is bigger than min_obj_size
size_t minObjSize = get_BaseSize();
if (get_ComponentSize() != 0)
{
// If it is an array, we will align the size to the nearest pointer alignment, even if there are
// zero elements. Our strings take advantage of this.
minObjSize = (size_t)ALIGN_UP(minObjSize, sizeof(TADDR));
}
if (minObjSize < (3 * sizeof(TADDR)))
REPORT_FAILURE();
switch (get_Kind())
{
case CanonicalEEType:
{
// If the parent type is NULL this had better look like Object.
if (!IsInterface() && (m_RelatedType.m_pBaseType == NULL))
{
if (IsRelatedTypeViaIAT() ||
get_IsValueType() ||
HasFinalizer() ||
HasReferenceFields() ||
HasGenericVariance())
{
REPORT_FAILURE();
}
}
break;
}
case ClonedEEType:
{
// Cloned types must have a related type.
if (m_RelatedType.m_ppCanonicalTypeViaIAT == NULL)
REPORT_FAILURE();
// Either we're dealing with a clone of String or a generic type. We can tell the difference based
// on the component size.
switch (get_ComponentSize())
{
case 0:
{
// Cloned generic type.
if (!IsRelatedTypeViaIAT())
{
REPORT_FAILURE();
}
break;
}
case 2:
{
// Cloned string.
if (get_IsValueType() ||
HasFinalizer() ||
HasReferenceFields() ||
HasGenericVariance())
{
REPORT_FAILURE();
}
break;
}
default:
// Apart from cloned strings we don't expected cloned types to have a component size.
REPORT_FAILURE();
}
break;
}
case ParameterizedEEType:
{
// The only parameter EETypes that can exist on the heap are arrays
// Array types must have a related type.
if (m_RelatedType.m_pRelatedParameterType == NULL)
REPORT_FAILURE();
// Component size cannot be zero in this case.
if (get_ComponentSize() == 0)
REPORT_FAILURE();
if (get_IsValueType() ||
HasFinalizer() ||
HasGenericVariance())
{
REPORT_FAILURE();
}
break;
}
case GenericTypeDefEEType:
{
// We should never see uninstantiated generic type definitions here
// since we should never construct an object instance around them.
REPORT_FAILURE();
}
default:
// Should be unreachable.
REPORT_FAILURE();
}
#undef REPORT_FAILURE
return true;
}
//-----------------------------------------------------------------------------------------------------------
EEType::Kinds EEType::get_Kind()
{
return (Kinds)(m_usFlags & (UInt16)EETypeKindMask);
}
//-----------------------------------------------------------------------------------------------------------
EEType * EEType::get_CanonicalEEType()
{
// cloned EETypes must always refer to types in other modules
ASSERT(IsCloned());
if (IsRelatedTypeViaIAT())
return *PTR_PTR_EEType(reinterpret_cast<TADDR>(m_RelatedType.m_ppCanonicalTypeViaIAT));
else
return PTR_EEType(reinterpret_cast<TADDR>(m_RelatedType.m_pCanonicalType)); // in the R2R case, the link is direct rather than indirect via the IAT
}
//-----------------------------------------------------------------------------------------------------------
EEType * EEType::get_RelatedParameterType()
{
ASSERT(IsParameterizedType());
if (IsRelatedTypeViaIAT())
return *PTR_PTR_EEType(reinterpret_cast<TADDR>(m_RelatedType.m_ppRelatedParameterTypeViaIAT));
else
return PTR_EEType(reinterpret_cast<TADDR>(m_RelatedType.m_pRelatedParameterType));
}
|
